smartrte-react 0.2.8 → 0.3.0

package/dist/components/ClassicEditor.js

@@ -1,9 +1,16 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from "react";
 import { MediaManager } from "./MediaManager.js";
+import { LinkEditorPopover } from "./LinkEditorPopover.js";
 import * as pdfjsLib from 'pdfjs-dist';
 import mammoth from 'mammoth';
 import JSZip from 'jszip';
+import { applyLink, applyTextColor as coreApplyTextColor, markdownToCompatibilityHtml, removeLink, sanitizeLinkHref, toggleBold, toggleItalic, toggleSubscript, toggleSuperscript, toggleUnderline } from 'smartrte-core';
+import { restoreSelectionToDom, selectionFromDom } from '../adapters/domSelectionBridge.js';
+import { serializeSmartDocument, smartDocumentFromEditorRoot } from '../adapters/domSmartDocument.js';
+import { isShadowModeEnabled, runShadowCommand } from '../adapters/shadowMode.js';
+import { getCoreInlineMarkResult, isCoreInlineMarkEnabled } from '../adapters/inlineMarkCoreExecution.js';
+import { closestFromTarget, isNode } from '../adapters/domTargets.js';
 import { ensureStyleSheet } from '../theme.js';
 // Initialize PDF.js worker
 if (typeof window !== 'undefined') {
@@ -50,18 +57,23 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
     const selectionRef = useRef(null);
     const selectingRef = useRef(null);
     const [imageMenu, setImageMenu] = useState(null);
+    const [linkMenu, setLinkMenu] = useState(null);
     const [showMediaManager, setShowMediaManager] = useState(false);
     const [showColorPicker, setShowColorPicker] = useState(false);
     const [showSpecialChars, setShowSpecialChars] = useState(false);
     const [colorPickerType, setColorPickerType] = useState('text');
     const savedRangeRef = useRef(null);
+    const pendingFontSizeRef = useRef(null);
+    const inlineScriptCaretOverrideRef = useRef(null);
     const historyRef = useRef({
         undo: [],
         redo: [],
     });
+    const inputHistoryGroupRef = useRef(null);
     const [currentFontSize, setCurrentFontSize] = useState("");
     const [currentFont, setCurrentFont] = useState("");
     const [currentBlockType, setCurrentBlockType] = useState("p");
+    const [currentAlignment, setCurrentAlignment] = useState("left");
     const [activeState, setActiveState] = useState({
         bold: false,
         italic: false,
@@ -69,10 +81,12 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         strikeThrough: false,
         subscript: false,
         superscript: false,
+        checklist: false,
         unorderedList: false,
         orderedList: false,
         blockquote: false,
         codeBlock: false,
+        link: false,
     });
     useEffect(() => {
         const el = editableRef.current;
@@ -82,9 +96,17 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         if (typeof value === "string" && value !== el.innerHTML) {
             el.innerHTML = value || "";
             fixNegativeMargins(el);
+            normalizeInvalidQuoteNesting(el);
+            normalizeInvalidCodeBlockNesting(el);
+            normalizeInvalidTableNesting(el);
             ensureTableWrappers(el);
+            ensureCaretBoundaryParagraphs(el);
             addTableResizeHandles();
         }
+        normalizeInvalidQuoteNesting(el);
+        normalizeInvalidCodeBlockNesting(el);
+        normalizeInvalidTableNesting(el);
+        ensureCaretBoundaryParagraphs(el);
         // Suppress native context menu inside table cells at capture phase
         const onCtx = (evt) => {
             const target = evt.target;
@@ -98,6 +120,83 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
             el.removeEventListener("contextmenu", onCtx, { capture: true });
         };
     }, [value]);
+    const parseFontSizePx = (value) => {
+        const match = /^([\d.]+)(px|pt)?$/i.exec(value.trim());
+        if (!match)
+            return null;
+        const numeric = Number(match[1]);
+        if (!Number.isFinite(numeric) || numeric <= 0)
+            return null;
+        return match[2]?.toLowerCase() === "pt" ? numeric * 4 / 3 : numeric;
+    };
+    const explicitFontSizeAt = (node) => {
+        let element = node instanceof HTMLElement ? node : node.parentElement;
+        while (element && element !== editableRef.current) {
+            const parsed = parseFontSizePx(element.style.fontSize);
+            if (parsed)
+                return parsed;
+            element = element.parentElement;
+        }
+        return null;
+    };
+    const normalizeFontSizeSpans = (root) => {
+        Array.from(root.querySelectorAll('span[style*="font-size"]')).reverse().forEach((span) => {
+            const parent = span.parentElement;
+            if (parent?.tagName === "SPAN" &&
+                parseFontSizePx(parent.style.fontSize) === parseFontSizePx(span.style.fontSize) &&
+                span.attributes.length === 1) {
+                while (span.firstChild)
+                    parent.insertBefore(span.firstChild, span);
+                span.remove();
+            }
+        });
+        Array.from(root.querySelectorAll('span[style*="font-size"]')).forEach((span) => {
+            let next = span.nextElementSibling;
+            while (next?.tagName === "SPAN" &&
+                next.getAttribute("style") === span.getAttribute("style") &&
+                next.attributes.length === span.attributes.length) {
+                while (next.firstChild)
+                    span.appendChild(next.firstChild);
+                const following = next.nextElementSibling;
+                next.remove();
+                next = following;
+            }
+        });
+    };
+    const resolveFontSizeForRange = (range) => {
+        const pending = pendingFontSizeRef.current;
+        if (range.collapsed && pending &&
+            range.startContainer === pending.container &&
+            range.startOffset === pending.offset)
+            return String(Math.round(pending.valuePx));
+        if (range.collapsed) {
+            const explicit = explicitFontSizeAt(range.startContainer);
+            return explicit ? String(Math.round(explicit)) : "";
+        }
+        const editor = editableRef.current;
+        if (!editor)
+            return "";
+        const sizes = new Set();
+        const walker = document.createTreeWalker(editor, NodeFilter.SHOW_TEXT);
+        let node = walker.nextNode();
+        while (node) {
+            try {
+                if (range.intersectsNode(node) && node.textContent) {
+                    const size = explicitFontSizeAt(node);
+                    if (size)
+                        sizes.add(Math.round(size));
+                    else
+                        sizes.add(0);
+                }
+            }
+            catch { }
+            if (sizes.size > 1)
+                return "";
+            node = walker.nextNode();
+        }
+        const only = Array.from(sizes)[0];
+        return only ? String(only) : "";
+    };
     const updateActiveState = () => {
         const editor = editableRef.current;
         if (!editor)
@@ -114,18 +213,59 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
             const element = node instanceof HTMLElement ? node : null;
             const block = element?.closest("p,h1,h2,h3,h4,h5,h6,li,blockquote,pre,div");
             const tag = block?.tagName.toLowerCase();
-            setCurrentBlockType(tag === "h1" || tag === "h2" || tag === "h3" ? tag : "p");
+            const queryState = (command) => typeof document.queryCommandState === "function" && document.queryCommandState(command);
+            const scriptOverride = inlineScriptCaretOverrideRef.current;
+            const overrideApplies = Boolean(scriptOverride &&
+                range.collapsed &&
+                range.startContainer === scriptOverride.container &&
+                range.startOffset === scriptOverride.offset);
+            if (scriptOverride && !overrideApplies) {
+                inlineScriptCaretOverrideRef.current = null;
+            }
+            const subscriptActive = queryState("subscript") || Boolean(element?.closest("sub"));
+            const superscriptActive = queryState("superscript") || Boolean(element?.closest("sup"));
+            if (!range.collapsed) {
+                const formattingBlocks = getSelectedBlocks(range);
+                [range.startContainer, range.endContainer].forEach((endpoint) => {
+                    const endpointElement = endpoint instanceof HTMLElement ? endpoint : endpoint.parentElement;
+                    const endpointBlock = endpointElement?.closest("p,h1,h2,h3,h4,h5,h6,li");
+                    if (endpointBlock && editor.contains(endpointBlock) && !formattingBlocks.includes(endpointBlock)) {
+                        formattingBlocks.push(endpointBlock);
+                    }
+                });
+                const types = new Set(formattingBlocks.map((selectedBlock) => {
+                    const contentBlock = selectedBlock.tagName === "LI"
+                        ? selectedBlock.querySelector(":scope > p,:scope > h1,:scope > h2,:scope > h3,:scope > h4,:scope > h5,:scope > h6")
+                        : selectedBlock;
+                    const selectedTag = contentBlock?.tagName.toLowerCase() || "p";
+                    return /^h[1-6]$/.test(selectedTag) ? selectedTag : "p";
+                }));
+                setCurrentBlockType(types.size > 1 ? "mixed" : (Array.from(types)[0] || "p"));
+            }
+            else {
+                setCurrentBlockType(/^h[1-6]$/.test(tag || "") ? tag : "p");
+            }
+            setCurrentFontSize(resolveFontSizeForRange(range));
+            const alignmentTargets = getAlignmentTargets(range);
+            const alignments = new Set(alignmentTargets.map(readTextAlignment));
+            setCurrentAlignment(alignments.size > 1 ? "mixed" : Array.from(alignments)[0] || "left");
             setActiveState({
-                bold: document.queryCommandState("bold"),
-                italic: document.queryCommandState("italic"),
-                underline: document.queryCommandState("underline"),
-                strikeThrough: document.queryCommandState("strikeThrough"),
-                subscript: document.queryCommandState("subscript"),
-                superscript: document.queryCommandState("superscript"),
-                unorderedList: Boolean(element?.closest("ul")),
+                bold: queryState("bold"),
+                italic: queryState("italic"),
+                underline: queryState("underline"),
+                strikeThrough: queryState("strikeThrough"),
+                subscript: overrideApplies && scriptOverride?.command === "subscript"
+                    ? false
+                    : subscriptActive,
+                superscript: overrideApplies && scriptOverride?.command === "superscript"
+                    ? false
+                    : superscriptActive,
+                checklist: Boolean(element?.closest('[data-srte-checklist="true"]')),
+                unorderedList: Boolean(element?.closest("ul:not([data-srte-checklist=\"true\"])")),
                 orderedList: Boolean(element?.closest("ol")),
                 blockquote: Boolean(element?.closest("blockquote")),
                 codeBlock: Boolean(element?.closest("pre")),
+                link: Boolean(element?.closest("a")),
             });
         }
         catch { }
@@ -138,6 +278,10 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                 const range = sel.getRangeAt(0);
                 const editor = editableRef.current;
                 if (editor && editor.contains(range.commonAncestorContainer)) {
+                    const pending = pendingFontSizeRef.current;
+                    if (pending &&
+                        (!range.collapsed || range.startContainer !== pending.container || range.startOffset !== pending.offset))
+                        pendingFontSizeRef.current = null;
                     savedRangeRef.current = range.cloneRange();
                     updateActiveState();
                 }
@@ -165,6 +309,53 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                 toggleList("ol");
                 return;
             }
+            pushEditorHistory();
+            const editor = editableRef.current;
+            const coreMark = { bold: "bold", italic: "italic", underline: "underline", superscript: "superscript", subscript: "subscript" }[command];
+            if (coreMark && editor && isCoreInlineMarkEnabled(coreMark)) {
+                try {
+                    const result = getCoreInlineMarkResult(editor, coreMark);
+                    if (result) {
+                        editor.innerHTML = result.html;
+                        ensureTableWrappers(editor);
+                        addTableResizeHandles();
+                        if (!restoreSelectionToDom(editor, result.selectionAfter)) {
+                            const fallback = document.createRange();
+                            fallback.selectNodeContents(editor);
+                            fallback.collapse(false);
+                            safeSelectRange(fallback);
+                            if (isShadowModeEnabled())
+                                console.warn(`[Smart RTE] Core ${coreMark} could not restore its exact selection.`);
+                        }
+                        handleInput();
+                        return;
+                    }
+                }
+                catch (error) {
+                    if (isShadowModeEnabled())
+                        console.warn(`[Smart RTE] Core ${coreMark} fell back to legacy execution.`, error);
+                }
+            }
+            const shadowCommand = {
+                bold: toggleBold,
+                italic: toggleItalic,
+                underline: toggleUnderline,
+                superscript: toggleSuperscript,
+                subscript: toggleSubscript,
+                foreColor: coreApplyTextColor,
+                createLink: applyLink,
+                unlink: removeLink,
+            }[command];
+            const shadowInput = command === "createLink" ? { href: valueArg || "" } : valueArg;
+            const shadowState = shadowCommand && editor && isShadowModeEnabled()
+                ? (() => {
+                    const selection = selectionFromDom(editor, window.getSelection());
+                    if (!selection)
+                        return null;
+                    const { document: coreDocument } = smartDocumentFromEditorRoot(editor);
+                    return { document: coreDocument, selection };
+                })()
+                : null;
             const beforeHtml = editableRef.current?.innerHTML || "";
             const ok = document.execCommand(command, false, valueArg);
             const afterHtml = editableRef.current?.innerHTML || "";
@@ -174,25 +365,103 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                 if (command === "formatBlock" && valueArg)
                     applyFormatBlockFallback(valueArg);
             }
+            if (shadowCommand && shadowState) {
+                runShadowCommand({
+                    command: shadowCommand,
+                    context: { document: shadowState.document, selection: shadowState.selection },
+                    input: shadowInput,
+                    state: shadowState,
+                    legacyHtml: afterHtml,
+                    serialize: (state) => serializeSmartDocument(state.document),
+                });
+            }
             handleInput();
         }
         catch { }
     };
+    const getScriptAncestor = (node, tagName) => {
+        const editor = editableRef.current;
+        let element = node instanceof HTMLElement ? node : node?.parentElement || null;
+        while (element && element !== editor) {
+            if (element.tagName.toLowerCase() === tagName)
+                return element;
+            element = element.parentElement;
+        }
+        return null;
+    };
+    const toggleInlineScript = (command) => {
+        try {
+            if (!restoreSavedSelection()) {
+                safeSelectRange(getSelectionRangeInEditor());
+            }
+            const editor = editableRef.current;
+            const range = getSelectionRangeInEditor();
+            if (!editor || !range)
+                return;
+            const tagName = command === "subscript" ? "sub" : "sup";
+            const script = range.collapsed
+                ? getScriptAncestor(range.startContainer, tagName)
+                : null;
+            if (range.collapsed && document.queryCommandState(command)) {
+                document.execCommand(command, false);
+                const currentRange = getSelectionRangeInEditor();
+                savedRangeRef.current = currentRange?.cloneRange() || null;
+                inlineScriptCaretOverrideRef.current = currentRange?.collapsed
+                    ? {
+                        command,
+                        container: currentRange.startContainer,
+                        offset: currentRange.startOffset,
+                    }
+                    : null;
+                setActiveState((current) => ({
+                    ...current,
+                    subscript: command === "subscript" ? false : current.subscript,
+                    superscript: command === "superscript" ? false : current.superscript,
+                }));
+                handleInput();
+                requestAnimationFrame(updateActiveState);
+                return;
+            }
+            if (script) {
+                const nextRange = document.createRange();
+                nextRange.setStartAfter(script);
+                nextRange.collapse(true);
+                safeSelectRange(nextRange);
+                savedRangeRef.current = nextRange.cloneRange();
+                inlineScriptCaretOverrideRef.current = {
+                    command,
+                    container: nextRange.startContainer,
+                    offset: nextRange.startOffset,
+                };
+                setActiveState((current) => ({
+                    ...current,
+                    subscript: command === "subscript" ? false : current.subscript,
+                    superscript: command === "superscript" ? false : current.superscript,
+                }));
+                requestAnimationFrame(updateActiveState);
+                return;
+            }
+            inlineScriptCaretOverrideRef.current = null;
+            exec(command);
+            requestAnimationFrame(updateActiveState);
+        }
+        catch { }
+    };
     const applyFormatBlock = (blockName) => {
         try {
             if (!restoreSavedSelection()) {
                 safeSelectRange(getSelectionRangeInEditor());
             }
+            pushEditorHistory();
             if (applyFormatBlockFallback(blockName)) {
                 const tag = normalizeBlockTag(blockName);
-                if (tag === "p" || tag === "h1" || tag === "h2" || tag === "h3") {
+                if (tag === "p" || /^h[1-6]$/.test(tag || "")) {
                     setCurrentBlockType(tag);
                 }
                 handleInput();
                 requestAnimationFrame(updateActiveState);
                 return;
             }
-            exec("formatBlock", blockName);
         }
         catch { }
     };
@@ -206,10 +475,12 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
             onChange(html);
         }
     };
-    const pushEditorHistory = () => {
+    const pushEditorHistory = (preserveInputGroup = false) => {
         const editor = editableRef.current;
         if (!editor)
             return;
+        if (!preserveInputGroup)
+            inputHistoryGroupRef.current = null;
         const selectionCells = selectionRef.current
             ? getCellsInGridRect(selectionRef.current.tbody, selectionRef.current.sr, selectionRef.current.sc, selectionRef.current.er, selectionRef.current.ec)
             : [];
@@ -247,22 +518,49 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         const history = historyRef.current;
         const from = dir === "undo" ? history.undo : history.redo;
         const to = dir === "undo" ? history.redo : history.undo;
-        const html = from.pop();
+        const currentHtml = editor.innerHTML;
+        let html;
+        while (from.length > 0) {
+            const candidate = from.pop();
+            if (candidate !== currentHtml) {
+                html = candidate;
+                break;
+            }
+        }
         if (html == null)
             return false;
-        to.push(editor.innerHTML);
+        if (to[to.length - 1] !== currentHtml)
+            to.push(currentHtml);
         editor.innerHTML = html;
         fixNegativeMargins(editor);
+        normalizeInvalidCodeBlockNesting(editor);
         ensureTableWrappers(editor);
+        ensureCaretBoundaryParagraphs(editor);
         addTableResizeHandles();
         clearSelectionDecor();
         setTableMenu(null);
+        inputHistoryGroupRef.current = null;
+        focusElementEnd(editor);
+        requestAnimationFrame(updateActiveState);
         if (html !== lastEmittedRef.current) {
             lastEmittedRef.current = html;
             onChange?.(html);
         }
         return true;
     };
+    const captureInputHistory = (inputType) => {
+        const now = Date.now();
+        const previous = inputHistoryGroupRef.current;
+        const groupable = inputType === "insertText" ||
+            inputType === "deleteContentBackward" ||
+            inputType === "deleteContentForward";
+        const continuesGroup = groupable &&
+            previous?.inputType === inputType &&
+            now - previous.timestamp < 1000;
+        if (!continuesGroup)
+            pushEditorHistory(true);
+        inputHistoryGroupRef.current = { inputType, timestamp: now };
+    };
     const restoreSavedSelection = () => {
         const editor = editableRef.current;
         if (!editor)
@@ -286,11 +584,119 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
             savedRangeRef.current = range.cloneRange();
         }
     };
-    const insertLink = () => {
-        const url = window.prompt("Enter URL", "https://");
-        if (!url)
+    const escapeAttribute = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    const getSelectedAnchor = () => {
+        const editor = editableRef.current;
+        const range = getSelectionRangeInEditor();
+        if (!editor || !range)
+            return null;
+        const node = range.startContainer.nodeType === Node.TEXT_NODE ? range.startContainer.parentElement : range.startContainer;
+        const anchor = node?.closest?.("a");
+        return anchor && editor.contains(anchor) ? anchor : null;
+    };
+    const selectAnchorContents = (anchor) => {
+        const range = document.createRange();
+        range.selectNodeContents(anchor);
+        safeSelectRange(range);
+        savedRangeRef.current = range.cloneRange();
+    };
+    const getRangeRect = (range) => {
+        if (!range || typeof range.getBoundingClientRect !== "function")
+            return null;
+        const rect = range.getBoundingClientRect();
+        return rect.width || rect.height ? rect : null;
+    };
+    const openLinkEditor = (existingAnchor) => {
+        const editor = editableRef.current;
+        if (!editor)
             return;
-        exec("createLink", url);
+        const anchor = existingAnchor || getSelectedAnchor();
+        const range = anchor
+            ? (() => {
+                const anchorRange = document.createRange();
+                anchorRange.selectNodeContents(anchor);
+                return anchorRange;
+            })()
+            : getSelectionRangeInEditor();
+        const rect = anchor?.getBoundingClientRect() || getRangeRect(range) || editor.getBoundingClientRect();
+        setLinkMenu({
+            x: Math.max(8, Math.min(rect.left, window.innerWidth - 320)),
+            y: Math.max(8, Math.min(rect.bottom + 8, window.innerHeight - 180)),
+            anchor: anchor || undefined,
+            range: range ? range.cloneRange() : null,
+            initialHref: anchor?.getAttribute("href") || "",
+            initialText: anchor?.textContent || (range && !range.collapsed ? range.toString() : ""),
+            showTextInput: Boolean(anchor || !range || range.collapsed),
+        });
+    };
+    const applyLinkEditorValue = (value) => {
+        const state = linkMenu;
+        if (!state)
+            return;
+        setLinkMenu(null);
+        if (state.anchor) {
+            pushEditorHistory();
+            state.anchor.setAttribute("href", value.href);
+            updateAnchorTarget(state.anchor, value.openInNewTab);
+            if (value.text != null && value.text !== state.anchor.textContent) {
+                state.anchor.textContent = value.text;
+            }
+            selectAnchorContents(state.anchor);
+            handleInput();
+            return;
+        }
+        if (state.range)
+            safeSelectRange(state.range.cloneRange());
+        if (state.range && !state.range.collapsed) {
+            exec("createLink", value.href);
+            const createdAnchor = getSelectedAnchor();
+            if (createdAnchor) {
+                updateAnchorTarget(createdAnchor, value.openInNewTab);
+                handleInput();
+            }
+            return;
+        }
+        if (!value.text)
+            return;
+        pushEditorHistory();
+        const targetAttributes = value.openInNewTab ? ' target="_blank" rel="noopener noreferrer"' : "";
+        document.execCommand("insertHTML", false, `<a href="${escapeAttribute(value.href)}"${targetAttributes}>${escapeAttribute(value.text)}</a>`);
+        handleInput();
+    };
+    const updateAnchorTarget = (anchor, openInNewTab) => {
+        const otherRelValues = (anchor.getAttribute("rel") || "")
+            .split(/\s+/)
+            .filter((value) => value && value !== "noopener" && value !== "noreferrer");
+        if (openInNewTab) {
+            anchor.target = "_blank";
+            anchor.rel = [...otherRelValues, "noopener", "noreferrer"].join(" ");
+            return;
+        }
+        anchor.removeAttribute("target");
+        if (otherRelValues.length)
+            anchor.rel = otherRelValues.join(" ");
+        else
+            anchor.removeAttribute("rel");
+    };
+    const removeAnchorLink = (anchor) => {
+        selectAnchorContents(anchor);
+        exec("unlink");
+        setLinkMenu(null);
+    };
+    const openEditorLink = (anchor) => {
+        const safeHref = sanitizeLinkHref(anchor.getAttribute("href"));
+        if (!safeHref)
+            return;
+        try {
+            const url = new URL(safeHref, window.location.href);
+            if (!["http:", "https:", "mailto:", "tel:"].includes(url.protocol))
+                return;
+            const target = anchor.getAttribute("target") || "_blank";
+            const opened = window.open(url.href, target, target === "_blank" ? "noopener,noreferrer" : undefined);
+            if (opened && target === "_blank")
+                opened.opener = null;
+        }
+        catch { }
     };
     const getSelectionRangeInEditor = () => {
         const editor = editableRef.current;
@@ -315,12 +721,22 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         const range = getSelectionRangeInEditor();
         if (!editor || !range)
             return null;
-        let node = range.commonAncestorContainer;
+        let node = range.startContainer;
         if (node.nodeType === Node.TEXT_NODE)
             node = node.parentNode;
         const element = node instanceof HTMLElement ? node : null;
+        const cell = element?.closest("td,th");
+        if (cell && editor.contains(cell)) {
+            const cellBlock = element?.closest("p,h1,h2,h3,h4,h5,h6,blockquote,pre");
+            if (cellBlock && cell.contains(cellBlock))
+                return cellBlock;
+            const directBlock = Array.from(cell.children).find((child) => child.matches("p,h1,h2,h3,h4,h5,h6,blockquote,pre"));
+            if (directBlock instanceof HTMLElement)
+                return directBlock;
+            return cell;
+        }
         const block = element?.closest("p,h1,h2,h3,h4,h5,h6,li,blockquote,pre,div");
-        if (!block || block === editor || !editor.contains(block))
+        if (!block || block === editor || block.getAttribute("data-table-wrapper") === "true" || !editor.contains(block))
             return null;
         return block;
     };
@@ -329,22 +745,43 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         const editor = editableRef.current;
         if (!editor)
             return [];
-        const blocks = Array.from(editor.querySelectorAll(blockSelector))
-            .filter((block) => {
-            if (block === editor)
+        if (range.collapsed) {
+            const current = getCurrentBlock();
+            return current ? [current] : [];
+        }
+        const startElement = range.startContainer.nodeType === Node.TEXT_NODE ? range.startContainer.parentElement : range.startContainer;
+        const endElement = range.endContainer.nodeType === Node.TEXT_NODE ? range.endContainer.parentElement : range.endContainer;
+        const startCell = startElement?.closest?.("td,th");
+        const endCell = endElement?.closest?.("td,th");
+        const scope = startCell && startCell === endCell && editor.contains(startCell) ? startCell : editor;
+        const blocks = Array.from(scope.querySelectorAll(blockSelector)).filter((block) => {
+            if (block === editor || block.getAttribute("data-table-wrapper") === "true")
                 return false;
             const parentBlock = block.parentElement?.closest(blockSelector);
-            if (parentBlock && parentBlock !== editor && editor.contains(parentBlock))
+            if (parentBlock && scope.contains(parentBlock) && parentBlock !== scope)
                 return false;
             try {
-                return range.intersectsNode(block);
+                if (!range.intersectsNode(block))
+                    return false;
+                const parent = block.parentNode;
+                if (parent === range.endContainer) {
+                    const index = Array.prototype.indexOf.call(parent.childNodes, block);
+                    if (range.endOffset <= index)
+                        return false;
+                }
+                if (parent === range.startContainer) {
+                    const index = Array.prototype.indexOf.call(parent.childNodes, block);
+                    if (range.startOffset > index)
+                        return false;
+                }
+                return true;
             }
             catch {
                 return false;
             }
         });
         if (blocks.length > 0)
-            return blocks;
+            return sortInDocumentOrder(blocks);
         const current = getCurrentBlock();
         return current ? [current] : [];
     };
@@ -362,6 +799,67 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         });
         return items;
     };
+    const getAlignmentTarget = (block) => {
+        const item = block.tagName === "LI" ? block : block.closest("li");
+        return item instanceof HTMLElement ? item : block;
+    };
+    const getAlignmentTargets = (range) => {
+        const editor = editableRef.current;
+        if (!editor)
+            return [];
+        const tableSelection = selectionRef.current;
+        const rangeElement = range.startContainer instanceof HTMLElement ? range.startContainer : range.startContainer.parentElement;
+        const rangeCell = rangeElement?.closest("td,th");
+        const selectedCells = tableSelection && rangeCell && isCellInsideSelection(rangeCell)
+            ? getCellsInGridRect(tableSelection.tbody, tableSelection.sr, tableSelection.sc, tableSelection.er, tableSelection.ec)
+            : [];
+        const candidates = selectedCells.length > 0
+            ? selectedCells.flatMap((cell) => {
+                const blocks = Array.from(cell.children).filter((child) => child instanceof HTMLElement && child.matches("p,h1,h2,h3,h4,h5,h6,blockquote,pre"));
+                return blocks.length > 0 ? blocks : [cell];
+            })
+            : getSelectedBlocks(range).map(getAlignmentTarget);
+        const seen = new Set();
+        return candidates.filter((target) => {
+            if (!editor.contains(target) || seen.has(target))
+                return false;
+            seen.add(target);
+            return true;
+        });
+    };
+    const readTextAlignment = (target) => {
+        const explicit = target.style.textAlign;
+        if (explicit === "center" || explicit === "right" || explicit === "justify")
+            return explicit;
+        const inherited = target.closest("blockquote[style*='text-align']");
+        const inheritedValue = inherited?.style.textAlign;
+        return inheritedValue === "center" || inheritedValue === "right" || inheritedValue === "justify"
+            ? inheritedValue
+            : "left";
+    };
+    const applyTextAlignment = (alignment) => {
+        try {
+            if (!restoreSavedSelection())
+                safeSelectRange(getSelectionRangeInEditor());
+            const range = getSelectionRangeInEditor();
+            if (!range)
+                return;
+            const targets = getAlignmentTargets(range);
+            if (targets.length === 0)
+                return;
+            pushEditorHistory();
+            targets.forEach((target) => {
+                target.style.textAlign = alignment === "left" ? "" : alignment;
+                if (!target.getAttribute("style"))
+                    target.removeAttribute("style");
+            });
+            safeSelectRange(range);
+            savedRangeRef.current = range.cloneRange();
+            handleInput();
+            requestAnimationFrame(updateActiveState);
+        }
+        catch { }
+    };
     const copyCellOrBlockStyles = (from, to) => {
         to.innerHTML = from.innerHTML || "<br>";
         const style = from.getAttribute("style");
@@ -428,6 +926,39 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         block.parentElement?.replaceChild(replacement, block);
         return replacement;
     };
+    const clearExplicitFontSizes = (block) => {
+        Array.from(block.querySelectorAll('[style*="font-size"]')).forEach((element) => {
+            element.style.fontSize = "";
+            if (!element.style.cssText)
+                element.removeAttribute("style");
+            if (element.tagName === "SPAN" && !element.getAttribute("style") && element.attributes.length === 0) {
+                const parent = element.parentNode;
+                if (!parent)
+                    return;
+                while (element.firstChild)
+                    parent.insertBefore(element.firstChild, element);
+                element.remove();
+            }
+        });
+    };
+    const replaceListItemContentTag = (item, tag) => {
+        const directBlock = Array.from(item.children).find((child) => child.matches("p,h1,h2,h3,h4,h5,h6"));
+        if (directBlock)
+            return replaceBlockTag(directBlock, tag);
+        const block = document.createElement(tag);
+        const boundary = Array.from(item.children).find((child) => child.matches("ul,ol,blockquote,pre")) || null;
+        Array.from(item.childNodes).forEach((node) => {
+            if (node === boundary)
+                return;
+            if (node instanceof HTMLElement && node.dataset.srteCheck === "true")
+                return;
+            block.appendChild(node);
+        });
+        if (!block.childNodes.length)
+            block.innerHTML = "<br>";
+        item.insertBefore(block, boundary);
+        return block;
+    };
     const applyFormatBlockFallback = (blockName) => {
         const editor = editableRef.current;
         const range = getSelectionRangeInEditor();
@@ -443,23 +974,36 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         }
         if (range.collapsed) {
             const block = getCurrentBlock();
-            if (!block || block === editor || block.closest("ul,ol") || !block.parentElement)
+            if (!block || block === editor || !block.parentElement)
                 return false;
-            const replacement = replaceBlockTag(block, tag);
+            const item = block.closest("li");
+            const replacement = item ? replaceListItemContentTag(item, tag) : replaceBlockTag(block, tag);
+            if (/^h[1-6]$/.test(tag))
+                clearExplicitFontSizes(replacement);
             focusElementEnd(replacement);
             return true;
         }
         const selectedBlocks = sortInDocumentOrder(getSelectedBlocks(range)).filter((block) => {
             if (!editor.contains(block) || block === editor)
                 return false;
-            if (block.closest("ul,ol"))
-                return false;
             return Boolean(block.parentElement);
         });
         if (selectedBlocks.length > 0) {
             let lastReplacement = null;
+            const handledItems = new Set();
             selectedBlocks.forEach((block) => {
-                lastReplacement = replaceBlockTag(block, tag);
+                const item = block.closest("li");
+                if (item) {
+                    if (handledItems.has(item))
+                        return;
+                    handledItems.add(item);
+                    lastReplacement = replaceListItemContentTag(item, tag);
+                }
+                else {
+                    lastReplacement = replaceBlockTag(block, tag);
+                }
+                if (lastReplacement && /^h[1-6]$/.test(tag))
+                    clearExplicitFontSizes(lastReplacement);
             });
             if (lastReplacement)
                 focusElementEnd(lastReplacement);
@@ -479,6 +1023,64 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         Array.from(list.attributes).forEach((attr) => clone.setAttribute(attr.name, attr.value));
         return clone;
     };
+    const mergeAdjacentCompatibleLists = (list) => {
+        const isCompatible = (candidate) => candidate instanceof HTMLElement &&
+            candidate.tagName === list.tagName &&
+            candidate.style.listStyleType === list.style.listStyleType &&
+            candidate.dataset.srteChecklist === list.dataset.srteChecklist &&
+            candidate.dataset.srteChecklistStrike === list.dataset.srteChecklistStrike;
+        let merged = list;
+        const previous = merged.previousElementSibling;
+        if (isCompatible(previous)) {
+            while (merged.firstChild)
+                previous.appendChild(merged.firstChild);
+            merged.remove();
+            merged = previous;
+        }
+        const next = merged.nextElementSibling;
+        if (isCompatible(next)) {
+            while (next.firstChild)
+                merged.appendChild(next.firstChild);
+            next.remove();
+        }
+        return merged;
+    };
+    const clearChecklist = (list) => {
+        delete list.dataset.srteChecklist;
+        delete list.dataset.srteChecklistStrike;
+        list.querySelectorAll(':scope > li > [data-srte-check]').forEach((control) => control.remove());
+        Array.from(list.children).forEach((item) => {
+            if (item instanceof HTMLElement) {
+                delete item.dataset.checked;
+                item.style.textDecoration = "";
+            }
+        });
+    };
+    const decorateChecklist = (list, strikeCompleted) => {
+        list.dataset.srteChecklist = "true";
+        list.dataset.srteChecklistStrike = strikeCompleted ? "true" : "false";
+        list.style.listStyleType = "none";
+        list.style.paddingInlineStart = "1.5em";
+        Array.from(list.children).forEach((item) => {
+            if (!(item instanceof HTMLElement) || item.tagName !== "LI")
+                return;
+            const legacyCheckbox = item.querySelector(':scope > input[data-srte-check]');
+            const checked = item.dataset.checked === "true" || Boolean(legacyCheckbox?.checked);
+            item.querySelectorAll(':scope > [data-srte-check]').forEach((control) => control.remove());
+            item.dataset.checked = checked ? "true" : "false";
+            const control = document.createElement("button");
+            control.type = "button";
+            control.dataset.srteCheck = "true";
+            control.contentEditable = "false";
+            control.tabIndex = -1;
+            control.setAttribute("aria-label", checked ? "Mark incomplete" : "Mark complete");
+            control.textContent = checked ? "☑" : "☐";
+            control.style.cssText = "margin-inline:-1.45em .45em;border:0;padding:0;background:transparent;color:inherit;font:inherit;cursor:pointer";
+            item.prepend(control);
+            item.style.textDecoration = strikeCompleted && checked ? "line-through" : "";
+        });
+        return mergeAdjacentCompatibleLists(list);
+    };
     const focusElementEnd = (element) => {
         const range = document.createRange();
         range.selectNodeContents(element);
@@ -505,6 +1107,7 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
             return;
         const paragraph = document.createElement("p");
         paragraph.innerHTML = li.innerHTML || "<br>";
+        paragraph.style.textAlign = li.style.textAlign;
         const beforeList = cloneListShell(list);
         const afterList = cloneListShell(list);
         while (list.firstChild && list.firstChild !== li) {
@@ -568,7 +1171,227 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         }
         return changed;
     };
-    const convertSelectedBlocksToList = (blocks, listTag) => {
+    const nestListSelection = () => {
+        const editor = editableRef.current;
+        if (!editor)
+            return;
+        if (!restoreSavedSelection())
+            safeSelectRange(getSelectionRangeInEditor());
+        const range = getSelectionRangeInEditor();
+        if (!range || range.collapsed)
+            return;
+        const items = sortInDocumentOrder(getSelectedListItems(getSelectedBlocks(range)));
+        const firstList = items[0]?.parentElement;
+        if (items.length === 0 ||
+            !firstList ||
+            !["ul", "ol"].includes(firstList.tagName.toLowerCase())) {
+            return;
+        }
+        const listTag = firstList.tagName.toLowerCase();
+        const directItems = items.filter((item) => item.parentElement === firstList);
+        if (directItems.length === 0 || !directItems[0].previousElementSibling)
+            return;
+        pushEditorHistory();
+        if (nestSelectedListItems(directItems, listTag)) {
+            handleInput();
+            requestAnimationFrame(updateActiveState);
+        }
+    };
+    const restyleSelectedListItems = (items, listTag, styleType) => {
+        const editor = editableRef.current;
+        if (!editor || items.length === 0)
+            return null;
+        const selected = new Set(items);
+        const sourceLists = Array.from(new Set(items.map((item) => item.parentElement)));
+        let lastSelected = null;
+        sourceLists.forEach((source) => {
+            const parent = source.parentElement;
+            if (!parent || !editor.contains(source))
+                return;
+            const outputs = [];
+            let pending = null;
+            let pendingSelected = null;
+            Array.from(source.children).forEach((child) => {
+                if (!(child instanceof HTMLElement) || child.tagName !== "LI")
+                    return;
+                const isSelected = selected.has(child);
+                if (!pending || pendingSelected !== isSelected) {
+                    pending = isSelected ? document.createElement(listTag) : cloneListShell(source);
+                    if (isSelected)
+                        pending.style.listStyleType = styleType;
+                    outputs.push(pending);
+                    pendingSelected = isSelected;
+                }
+                if (isSelected) {
+                    child.querySelectorAll(':scope > [data-srte-check]').forEach((control) => control.remove());
+                    delete child.dataset.checked;
+                    child.style.textDecoration = "";
+                    lastSelected = child;
+                }
+                pending.appendChild(child);
+            });
+            outputs.forEach((output) => parent.insertBefore(output, source));
+            source.remove();
+            outputs.forEach((output) => {
+                if (output.tagName.toLowerCase() === listTag && output.style.listStyleType === styleType) {
+                    clearChecklist(output);
+                }
+                mergeAdjacentCompatibleLists(output);
+            });
+        });
+        return lastSelected;
+    };
+    const applyListStyle = (value) => {
+        const listTag = value.startsWith("ordered:") ? "ol" : "ul";
+        const styleType = value.replace(/^(ordered|bullet):/, "");
+        if (!restoreSavedSelection())
+            safeSelectRange(getSelectionRangeInEditor());
+        const range = getSelectionRangeInEditor();
+        if (!range)
+            return;
+        const selectedBlocks = getSelectedBlocks(range);
+        const selectedItems = getSelectedListItems(selectedBlocks);
+        const selectedPlainBlocks = selectedBlocks.filter((block) => !block.closest("ul,ol"));
+        if (selectedItems.length > 0) {
+            pushEditorHistory();
+            const lastItem = restyleSelectedListItems(selectedItems, listTag, styleType);
+            const convertedPlainBlocks = convertSelectedBlocksToList(selectedPlainBlocks, listTag, styleType);
+            if (!convertedPlainBlocks && lastItem)
+                focusElementEnd(lastItem);
+            handleInput();
+            requestAnimationFrame(updateActiveState);
+            return;
+        }
+        const lists = new Set();
+        getSelectedListItems(getSelectedBlocks(range)).forEach((item) => {
+            const list = item.parentElement;
+            if (list &&
+                ["ul", "ol"].includes(list.tagName.toLowerCase())) {
+                lists.add(list);
+            }
+        });
+        [range.startContainer, range.endContainer].forEach((node) => {
+            const element = node instanceof HTMLElement ? node : node.parentElement;
+            const list = element?.closest("ul,ol");
+            if (list && editableRef.current?.contains(list))
+                lists.add(list);
+        });
+        if (lists.size === 0) {
+            const blocks = range.collapsed
+                ? [getCurrentBlock()].filter((block) => Boolean(block))
+                : getSelectedBlocks(range);
+            const convertibleBlocks = blocks.filter((block) => editableRef.current?.contains(block) &&
+                !block.closest("ul,ol") &&
+                Boolean(block.parentElement));
+            if (convertibleBlocks.length > 0) {
+                pushEditorHistory();
+                if (convertSelectedBlocksToList(convertibleBlocks, listTag)) {
+                    const createdList = getCurrentBlock()?.closest("ul,ol");
+                    if (createdList) {
+                        createdList.style.listStyleType = styleType;
+                        const mergedList = mergeAdjacentCompatibleLists(createdList);
+                        const lastItem = mergedList.lastElementChild;
+                        if (lastItem)
+                            focusElementEnd(lastItem);
+                    }
+                }
+                handleInput();
+                requestAnimationFrame(updateActiveState);
+                return;
+            }
+            if (!range.collapsed && blocks.length === 0) {
+                toggleList(listTag);
+                const createdList = getCurrentBlock()?.closest("ul,ol");
+                if (createdList) {
+                    createdList.style.listStyleType = styleType;
+                    handleInput();
+                }
+                return;
+            }
+            const block = getCurrentBlock();
+            if (!block?.closest("ul,ol"))
+                return;
+            const currentList = block.closest("ul,ol");
+            if (currentList)
+                lists.add(currentList);
+        }
+        if (lists.size === 0)
+            return;
+        pushEditorHistory();
+        let lastList = null;
+        const styledLists = [];
+        lists.forEach((list) => {
+            const target = list.tagName.toLowerCase() === listTag
+                ? list
+                : cloneListShell(list, listTag);
+            if (target !== list) {
+                target.innerHTML = list.innerHTML;
+                list.parentElement?.replaceChild(target, list);
+            }
+            clearChecklist(target);
+            target.style.listStyleType = styleType;
+            lastList = target;
+            styledLists.push(target);
+        });
+        styledLists.forEach((list) => {
+            if (editableRef.current?.contains(list)) {
+                lastList = mergeAdjacentCompatibleLists(list);
+            }
+        });
+        const lastItem = lastList?.lastElementChild;
+        if (lastItem)
+            focusElementEnd(lastItem);
+        handleInput();
+        requestAnimationFrame(updateActiveState);
+    };
+    const applyChecklist = (strikeCompleted = false, toggleOff = false) => {
+        if (!restoreSavedSelection())
+            safeSelectRange(getSelectionRangeInEditor());
+        const range = getSelectionRangeInEditor();
+        if (!range)
+            return;
+        const selectedItems = getSelectedListItems(getSelectedBlocks(range));
+        const selectedChecklists = selectedItems.filter((item) => item.parentElement?.dataset.srteChecklist === "true");
+        if (toggleOff && selectedItems.length > 0 && selectedChecklists.length === selectedItems.length) {
+            pushEditorHistory();
+            selectedItems.forEach((item) => {
+                item.querySelectorAll(':scope > [data-srte-check]').forEach((control) => control.remove());
+                delete item.dataset.checked;
+                item.style.textDecoration = "";
+            });
+            if (transformSelectedListItems(selectedItems, "ul")) {
+                handleInput();
+                requestAnimationFrame(updateActiveState);
+            }
+            return;
+        }
+        if (selectedItems.length > 0) {
+            pushEditorHistory();
+            const lastItem = restyleSelectedListItems(selectedItems, "ul", "none");
+            const lists = new Set();
+            selectedItems.forEach((item) => {
+                if (item.parentElement)
+                    lists.add(item.parentElement);
+            });
+            lists.forEach((list) => decorateChecklist(list, strikeCompleted));
+            if (lastItem)
+                focusElementEnd(lastItem);
+            handleInput();
+            requestAnimationFrame(updateActiveState);
+            return;
+        }
+        applyListStyle("bullet:none");
+        const createdList = getCurrentBlock()?.closest("ul");
+        if (!createdList)
+            return;
+        const merged = decorateChecklist(createdList, strikeCompleted);
+        const lastItem = merged.lastElementChild;
+        if (lastItem)
+            focusElementEnd(lastItem);
+        handleInput();
+        requestAnimationFrame(updateActiveState);
+    };
+    const convertSelectedBlocksToList = (blocks, listTag, styleType) => {
         const editor = editableRef.current;
         if (!editor || blocks.length === 0)
             return false;
@@ -599,64 +1422,279 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                 return position & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
             });
             const list = document.createElement(listTag);
+            if (styleType)
+                list.style.listStyleType = styleType;
             parent.insertBefore(list, group[0]);
             group.forEach((block) => {
                 const li = document.createElement("li");
                 li.innerHTML = block.innerHTML || "<br>";
+                li.style.textAlign = block.style.textAlign;
                 list.appendChild(li);
                 block.remove();
                 lastLi = li;
             });
+            mergeAdjacentCompatibleLists(list);
         });
         if (lastLi)
             focusElementEnd(lastLi);
         return true;
     };
+    const convertTableCellSelectionToList = (range, listTag) => {
+        if (range.collapsed)
+            return false;
+        const startCell = getClosestCell(range.startContainer);
+        const endCell = getClosestCell(range.endContainer);
+        if (!startCell || startCell !== endCell)
+            return false;
+        const fragment = range.extractContents();
+        const parts = [document.createDocumentFragment()];
+        Array.from(fragment.childNodes).forEach((node) => {
+            if (node instanceof HTMLBRElement) {
+                parts.push(document.createDocumentFragment());
+            }
+            else {
+                parts[parts.length - 1].appendChild(node);
+            }
+        });
+        const nonEmptyParts = parts.filter((part) => part.textContent?.trim() || part.childNodes.length > 0);
+        if (nonEmptyParts.length === 0) {
+            range.insertNode(fragment);
+            return false;
+        }
+        const list = document.createElement(listTag);
+        nonEmptyParts.forEach((part) => {
+            const item = document.createElement("li");
+            item.appendChild(part);
+            if (!item.innerHTML.trim())
+                item.innerHTML = "<br>";
+            list.appendChild(item);
+        });
+        range.insertNode(list);
+        const lastItem = list.lastElementChild;
+        if (lastItem)
+            focusElementEnd(lastItem);
+        return true;
+    };
+    const convertRootLineSelectionToList = (range, listTag) => {
+        const editor = editableRef.current;
+        if (!editor || range.collapsed)
+            return false;
+        const closestBlock = (node) => {
+            const element = node instanceof HTMLElement ? node : node.parentElement;
+            const block = element?.closest(blockSelector);
+            return block === editor ? null : block;
+        };
+        if (closestBlock(range.startContainer) || closestBlock(range.endContainer))
+            return false;
+        const lineRange = range.cloneRange();
+        const breaks = Array.from(editor.querySelectorAll("br"));
+        let previousBreak = null;
+        let nextBreak = null;
+        breaks.forEach((lineBreak) => {
+            const parent = lineBreak.parentNode;
+            if (!parent)
+                return;
+            const index = Array.prototype.indexOf.call(parent.childNodes, lineBreak);
+            const beforeRelation = range.comparePoint(parent, index);
+            const afterRelation = range.comparePoint(parent, index + 1);
+            if (afterRelation === -1) {
+                previousBreak = lineBreak;
+            }
+            else if (!nextBreak &&
+                (beforeRelation === 1 || (beforeRelation === 0 && !range.intersectsNode(lineBreak)))) {
+                nextBreak = lineBreak;
+            }
+        });
+        if (previousBreak)
+            lineRange.setStartAfter(previousBreak);
+        else
+            lineRange.setStart(editor, 0);
+        if (nextBreak)
+            lineRange.setEndBefore(nextBreak);
+        else
+            lineRange.setEnd(editor, editor.childNodes.length);
+        const fragment = lineRange.extractContents();
+        const parts = [document.createDocumentFragment()];
+        Array.from(fragment.childNodes).forEach((node) => {
+            if (node instanceof HTMLBRElement)
+                parts.push(document.createDocumentFragment());
+            else if (node instanceof HTMLElement && node.matches(blockSelector)) {
+                if (parts[parts.length - 1].childNodes.length > 0)
+                    parts.push(document.createDocumentFragment());
+                while (node.firstChild)
+                    parts[parts.length - 1].appendChild(node.firstChild);
+                parts.push(document.createDocumentFragment());
+            }
+            else
+                parts[parts.length - 1].appendChild(node);
+        });
+        const nonEmptyParts = parts.filter((part) => part.textContent?.length || part.childNodes.length > 0);
+        if (nonEmptyParts.length === 0) {
+            lineRange.insertNode(fragment);
+            return false;
+        }
+        const list = document.createElement(listTag);
+        nonEmptyParts.forEach((part) => {
+            const item = document.createElement("li");
+            item.appendChild(part);
+            list.appendChild(item);
+        });
+        lineRange.insertNode(list);
+        const mergedList = mergeAdjacentCompatibleLists(list);
+        const lastItem = mergedList.lastElementChild;
+        if (lastItem)
+            focusElementEnd(lastItem);
+        return true;
+    };
+    const transformSelectedListItems = (items, listTag) => {
+        const editor = editableRef.current;
+        if (!editor || items.length === 0)
+            return false;
+        const selected = new Set(items.filter((item) => {
+            const parentItem = item.parentElement?.closest("li");
+            return !parentItem || !items.includes(parentItem);
+        }));
+        const lists = new Set();
+        selected.forEach((item) => {
+            const list = item.parentElement;
+            if (list &&
+                (list.tagName.toLowerCase() === "ul" || list.tagName.toLowerCase() === "ol")) {
+                lists.add(list);
+            }
+        });
+        let changed = false;
+        let lastTarget = null;
+        lists.forEach((list) => {
+            const parent = list.parentElement;
+            if (!parent || !editor.contains(list))
+                return;
+            const toggleOff = list.tagName.toLowerCase() === listTag;
+            let pendingList = null;
+            const flushPendingList = () => {
+                if (!pendingList?.childNodes.length)
+                    return;
+                parent.insertBefore(pendingList, list);
+                pendingList = null;
+            };
+            Array.from(list.children).forEach((child) => {
+                if (!(child instanceof HTMLElement) || child.tagName.toLowerCase() !== "li")
+                    return;
+                const isSelected = selected.has(child);
+                if (isSelected && toggleOff) {
+                    flushPendingList();
+                    const paragraph = document.createElement("p");
+                    paragraph.innerHTML = child.innerHTML || "<br>";
+                    paragraph.style.textAlign = child.style.textAlign;
+                    parent.insertBefore(paragraph, list);
+                    lastTarget = paragraph;
+                    child.remove();
+                    changed = true;
+                    return;
+                }
+                const outputTag = isSelected ? listTag : list.tagName.toLowerCase();
+                if (!pendingList || pendingList.tagName.toLowerCase() !== outputTag) {
+                    flushPendingList();
+                    pendingList = cloneListShell(list, outputTag);
+                }
+                pendingList.appendChild(child);
+                if (isSelected) {
+                    lastTarget = child;
+                    changed = true;
+                }
+            });
+            flushPendingList();
+            list.remove();
+        });
+        if (changed && lastTarget)
+            focusElementEnd(lastTarget);
+        return changed;
+    };
     const toggleList = (listTag) => {
         const editor = editableRef.current;
         if (!editor)
             return;
         if (!restoreSavedSelection())
             safeSelectRange(getSelectionRangeInEditor());
+        const setListActiveState = (active) => {
+            setActiveState((current) => ({
+                ...current,
+                unorderedList: listTag === "ul" ? active : false,
+                orderedList: listTag === "ol" ? active : false,
+            }));
+        };
         const range = getSelectionRangeInEditor();
         if (range && !range.collapsed) {
             const blocks = getSelectedBlocks(range);
             const selectedListItems = getSelectedListItems(blocks);
+            if (selectedListItems.length > 0) {
+                pushEditorHistory();
+                if (transformSelectedListItems(selectedListItems, listTag)) {
+                    const active = Boolean(getCurrentBlock()?.closest(listTag));
+                    setListActiveState(active);
+                    handleInput();
+                    requestAnimationFrame(updateActiveState);
+                    return;
+                }
+            }
+            pushEditorHistory();
             const convertedBlocks = convertSelectedBlocksToList(blocks, listTag);
-            const nestedItems = nestSelectedListItems(selectedListItems, listTag);
-            if (convertedBlocks || nestedItems) {
+            if (convertedBlocks) {
+                setListActiveState(true);
                 handleInput();
                 requestAnimationFrame(updateActiveState);
                 return;
             }
+            if (blocks.length === 0) {
+                pushEditorHistory();
+                if (convertRootLineSelectionToList(range, listTag)) {
+                    setListActiveState(true);
+                    handleInput();
+                    requestAnimationFrame(updateActiveState);
+                    return;
+                }
+                if (convertTableCellSelectionToList(range, listTag)) {
+                    setListActiveState(true);
+                    handleInput();
+                    requestAnimationFrame(updateActiveState);
+                    return;
+                }
+            }
         }
         const block = getCurrentBlock();
         if (!block) {
+            pushEditorHistory();
             insertEmptyListAtSelection(listTag);
+            setListActiveState(true);
             handleInput();
             requestAnimationFrame(updateActiveState);
             return;
         }
         const currentList = block.closest("ul,ol");
         if (currentList && editor.contains(currentList)) {
+            pushEditorHistory();
             if (currentList.tagName.toLowerCase() === listTag) {
                 const li = block.closest("li");
-                if (li)
+                if (li) {
                     unwrapListItem(li, currentList);
+                    setListActiveState(false);
+                }
             }
             else {
                 convertListTag(currentList, listTag);
+                setListActiveState(true);
             }
             handleInput();
             requestAnimationFrame(updateActiveState);
             return;
         }
+        pushEditorHistory();
         const list = document.createElement(listTag);
         const li = document.createElement("li");
         li.innerHTML = block.innerHTML || "<br>";
         list.appendChild(li);
         block.parentElement?.replaceChild(list, block);
         focusElementEnd(li);
+        setListActiveState(true);
         handleInput();
         requestAnimationFrame(updateActiveState);
     };
@@ -708,19 +1746,69 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                 const selected = sortInDocumentOrder(blocks).filter((block) => {
                     if (!editor.contains(block) || block === editor)
                         return false;
-                    if (block.closest("ul,ol"))
-                        return false;
                     if (block.tagName.toLowerCase() === "blockquote")
                         return false;
                     return Boolean(block.parentElement);
                 });
                 if (selected.length === 0)
                     return false;
+                const mergeQuote = (quote) => {
+                    let merged = quote;
+                    const previous = merged.previousElementSibling;
+                    if (previous?.tagName === "BLOCKQUOTE") {
+                        while (merged.firstChild)
+                            previous.appendChild(merged.firstChild);
+                        merged.remove();
+                        merged = previous;
+                    }
+                    const next = merged.nextElementSibling;
+                    if (next?.tagName === "BLOCKQUOTE") {
+                        while (next.firstChild)
+                            merged.appendChild(next.firstChild);
+                        next.remove();
+                    }
+                    return merged;
+                };
+                const selectedItems = new Set(getSelectedListItems(selected));
+                const sourceLists = Array.from(new Set(Array.from(selectedItems, (item) => item.parentElement)));
                 let lastWrapped = null;
-                selected.forEach((block) => {
+                sourceLists.forEach((source) => {
+                    const parent = source.parentElement;
+                    if (!parent)
+                        return;
+                    let pending = null;
+                    let pendingSelected = null;
+                    const outputs = [];
+                    Array.from(source.children).forEach((child) => {
+                        if (!(child instanceof HTMLElement) || child.tagName !== "LI")
+                            return;
+                        const isSelected = selectedItems.has(child);
+                        if (!pending || pendingSelected !== isSelected) {
+                            pending = cloneListShell(source);
+                            pendingSelected = isSelected;
+                            outputs.push({ list: pending, selected: isSelected });
+                        }
+                        pending.appendChild(child);
+                    });
+                    outputs.forEach((output) => {
+                        if (output.selected) {
+                            const quote = document.createElement("blockquote");
+                            quote.appendChild(output.list);
+                            parent.insertBefore(quote, source);
+                            mergeQuote(quote);
+                            lastWrapped = output.list.lastElementChild;
+                        }
+                        else {
+                            parent.insertBefore(output.list, source);
+                        }
+                    });
+                    source.remove();
+                });
+                selected.filter((block) => !block.closest("ul,ol")).forEach((block) => {
                     const quote = document.createElement("blockquote");
                     block.parentElement?.insertBefore(quote, block);
                     quote.appendChild(block);
+                    mergeQuote(quote);
                     lastWrapped = block;
                 });
                 if (lastWrapped)
@@ -746,6 +1834,16 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                 const block = getCurrentBlock();
                 if (block) {
                     pushEditorHistory();
+                    const currentList = block.closest("ul,ol");
+                    if (currentList && editor.contains(currentList)) {
+                        const quote = document.createElement("blockquote");
+                        currentList.parentElement?.insertBefore(quote, currentList);
+                        quote.appendChild(currentList);
+                        focusElementEnd(block);
+                        handleInput();
+                        requestAnimationFrame(updateActiveState);
+                        return;
+                    }
                     if (!wrapBlocks([block]))
                         return;
                     handleInput();
@@ -769,70 +1867,210 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         }
         catch { }
     };
+    const toggleCodeBlock = () => {
+        try {
+            if (!restoreSavedSelection())
+                safeSelectRange(getSelectionRangeInEditor());
+            const editor = editableRef.current;
+            const range = getSelectionRangeInEditor();
+            if (!editor || !range)
+                return;
+            const blocks = (range.collapsed
+                ? [getCurrentBlock()].filter((block) => Boolean(block))
+                : getSelectedBlocks(range)).filter((block) => editor.contains(block));
+            if (blocks.length === 0)
+                return;
+            const listItems = getSelectedListItems(blocks);
+            const plainBlocks = blocks.filter((block) => !block.closest("ul,ol") && !block.closest("table"));
+            const getItemCode = (item) => item.querySelector(":scope > pre[data-srte-list-code]");
+            const allTargetsActive = listItems.every((item) => Boolean(getItemCode(item))) &&
+                plainBlocks.every((block) => block.tagName === "PRE") &&
+                listItems.length + plainBlocks.length > 0;
+            pushEditorHistory();
+            let lastTarget = null;
+            listItems.forEach((item) => {
+                const existing = getItemCode(item);
+                if (allTargetsActive && existing) {
+                    const code = existing.querySelector(":scope > code");
+                    const source = code || existing;
+                    while (source.firstChild)
+                        item.insertBefore(source.firstChild, existing);
+                    existing.remove();
+                    lastTarget = item;
+                    return;
+                }
+                if (existing) {
+                    lastTarget = existing;
+                    return;
+                }
+                const pre = document.createElement("pre");
+                pre.dataset.srteListCode = "true";
+                pre.style.textAlign = "left";
+                const code = document.createElement("code");
+                const nestedList = Array.from(item.children).find((child) => child.matches("ul,ol")) || null;
+                Array.from(item.childNodes).forEach((node) => {
+                    if (node === nestedList)
+                        return;
+                    if (node instanceof HTMLElement && node.dataset.srteCheck === "true")
+                        return;
+                    code.appendChild(node);
+                });
+                if (!code.childNodes.length)
+                    code.innerHTML = "<br>";
+                pre.appendChild(code);
+                item.insertBefore(pre, nestedList);
+                lastTarget = pre;
+            });
+            sortInDocumentOrder(plainBlocks).forEach((block) => {
+                if (allTargetsActive && block.tagName === "PRE") {
+                    const paragraph = document.createElement("p");
+                    const code = block.querySelector(":scope > code");
+                    paragraph.innerHTML = code?.innerHTML || block.innerHTML || "<br>";
+                    block.parentElement?.replaceChild(paragraph, block);
+                    lastTarget = paragraph;
+                }
+                else if (block.tagName !== "PRE") {
+                    const pre = replaceBlockTag(block, "pre");
+                    pre.style.textAlign = "left";
+                    if (!pre.querySelector(":scope > code")) {
+                        const code = document.createElement("code");
+                        while (pre.firstChild)
+                            code.appendChild(pre.firstChild);
+                        pre.appendChild(code);
+                    }
+                    lastTarget = pre;
+                }
+            });
+            if (lastTarget)
+                focusElementEnd(lastTarget);
+            handleInput();
+            requestAnimationFrame(updateActiveState);
+        }
+        catch { }
+    };
     const applyFontSize = (size) => {
         try {
-            // Update current font size state
-            setCurrentFontSize(size);
             const editor = editableRef.current;
             if (!editor)
                 return;
-            editor.focus();
-            // Try to get current selection, or use saved range
-            let range = null;
-            const sel = window.getSelection();
-            if (sel && sel.rangeCount > 0) {
-                const currentRange = sel.getRangeAt(0);
-                // Use current range if it's within our editor
-                if (editor.contains(currentRange.commonAncestorContainer)) {
-                    range = currentRange;
-                }
-            }
-            // Fallback to saved range if current range is not available
-            if (!range && savedRangeRef.current) {
-                range = savedRangeRef.current.cloneRange();
-            }
-            // If no range at all, just update state for future typing
+            const valuePx = Number(size);
+            if (!Number.isFinite(valuePx) || valuePx <= 0)
+                return;
+            if (!restoreSavedSelection())
+                safeSelectRange(getSelectionRangeInEditor());
+            const range = getSelectionRangeInEditor();
             if (!range)
                 return;
-            // If range is collapsed (cursor position, no selection), insert an invisible span
+            setCurrentFontSize(String(Math.round(valuePx)));
             if (range.collapsed) {
-                // Create a span with zero-width space that will capture future typing
-                const span = document.createElement('span');
-                span.style.fontSize = size + 'pt';
-                span.textContent = '\u200B'; // Zero-width space
-                range.insertNode(span);
-                // Position cursor inside the span
-                const newRange = document.createRange();
-                newRange.setStart(span.firstChild, 1);
-                newRange.collapse(true);
-                if (sel) {
-                    sel.removeAllRanges();
-                    sel.addRange(newRange);
-                }
-                handleInput();
+                pendingFontSizeRef.current = {
+                    valuePx,
+                    container: range.startContainer,
+                    offset: range.startOffset,
+                };
+                savedRangeRef.current = range.cloneRange();
                 return;
             }
-            // If there's selected text, wrap it
-            const span = document.createElement('span');
-            span.style.fontSize = size + 'pt';
-            // Extract the selected content and wrap it in the span
-            const fragment = range.extractContents();
-            span.appendChild(fragment);
-            // Insert the span at the current position
-            range.insertNode(span);
-            // Update selection to show what was changed
-            if (sel) {
-                range.selectNodeContents(span);
-                sel.removeAllRanges();
-                sel.addRange(range);
+            pushEditorHistory();
+            pendingFontSizeRef.current = null;
+            const textNodes = [];
+            const walker = document.createTreeWalker(editor, NodeFilter.SHOW_TEXT);
+            let candidate = walker.nextNode();
+            while (candidate) {
+                const text = candidate;
+                const owner = text.parentElement;
+                try {
+                    if (text.data.length > 0 && range.intersectsNode(text) &&
+                        !owner?.closest('[contenteditable="false"],button,[data-srte-editor-only="true"]'))
+                        textNodes.push(text);
+                }
+                catch { }
+                candidate = walker.nextNode();
+            }
+            const selectedTexts = [];
+            [...textNodes].reverse().forEach((text) => {
+                const start = text === range.startContainer ? range.startOffset : 0;
+                const end = text === range.endContainer ? range.endOffset : text.data.length;
+                if (end <= start)
+                    return;
+                if (end < text.data.length)
+                    text.splitText(end);
+                const selected = start > 0 ? text.splitText(start) : text;
+                const parent = selected.parentElement;
+                if (parent?.tagName === "SPAN" &&
+                    parent.childNodes.length === 1 &&
+                    parent.textContent === selected.data) {
+                    parent.style.fontSize = `${valuePx}px`;
+                }
+                else {
+                    const span = document.createElement("span");
+                    span.style.fontSize = `${valuePx}px`;
+                    selected.parentNode?.insertBefore(span, selected);
+                    span.appendChild(selected);
+                }
+                selectedTexts.unshift(selected);
+            });
+            if (selectedTexts.length > 0) {
+                normalizeFontSizeSpans(editor);
+                const nextRange = document.createRange();
+                nextRange.setStart(selectedTexts[0], 0);
+                const last = selectedTexts[selectedTexts.length - 1];
+                nextRange.setEnd(last, last.data.length);
+                safeSelectRange(nextRange);
+                savedRangeRef.current = nextRange.cloneRange();
             }
-            // Trigger change event
             handleInput();
+            requestAnimationFrame(updateActiveState);
         }
         catch (error) {
             console.error('Error applying font size:', error);
         }
     };
+    useEffect(() => {
+        const editor = editableRef.current;
+        if (!editor)
+            return;
+        const applyPendingFontSize = (event) => {
+            const pending = pendingFontSizeRef.current;
+            if (!pending || event.inputType !== "insertText" || !event.data)
+                return;
+            const range = getSelectionRangeInEditor();
+            if (!range?.collapsed ||
+                range.startContainer !== pending.container ||
+                range.startOffset !== pending.offset)
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            pushEditorHistory();
+            const text = document.createTextNode(event.data);
+            const sizedAncestor = range.startContainer instanceof HTMLElement
+                ? range.startContainer.closest("span")
+                : range.startContainer.parentElement?.closest("span");
+            if (sizedAncestor instanceof HTMLElement &&
+                parseFontSizePx(sizedAncestor.style.fontSize) === pending.valuePx) {
+                range.insertNode(text);
+            }
+            else {
+                const span = document.createElement("span");
+                span.style.fontSize = `${pending.valuePx}px`;
+                span.appendChild(text);
+                range.insertNode(span);
+            }
+            const nextRange = document.createRange();
+            nextRange.setStartAfter(text);
+            nextRange.collapse(true);
+            safeSelectRange(nextRange);
+            pendingFontSizeRef.current = {
+                valuePx: pending.valuePx,
+                container: nextRange.startContainer,
+                offset: nextRange.startOffset,
+            };
+            savedRangeRef.current = nextRange.cloneRange();
+            handleInput();
+        };
+        editor.addEventListener("beforeinput", applyPendingFontSize);
+        return () => editor.removeEventListener("beforeinput", applyPendingFontSize);
+    }, []);
     const applyFontFamily = (font) => {
         try {
             setCurrentFont(font);
@@ -1920,164 +3158,6 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         .replace(/&/g, "&amp;")
         .replace(/</g, "&lt;")
         .replace(/>/g, "&gt;");
-    const escapeHtmlAttribute = (value) => escapeHtml(value).replace(/"/g, "&quot;");
-    const markdownToHtml = (markdown) => {
-        const lines = markdown.replace(/\r\n/g, "\n").split("\n");
-        let html = "";
-        let listType = null;
-        let paragraph = [];
-        let codeFence = null;
-        const closeList = () => {
-            if (listType) {
-                html += `</${listType}>`;
-                listType = null;
-            }
-        };
-        const inline = (text) => {
-            const codeTokens = [];
-            let value = text.replace(/`([^`]+)`/g, (_match, code) => {
-                const token = `@@SRTE_CODE_${codeTokens.length}@@`;
-                codeTokens.push(`<code>${escapeHtml(code)}</code>`);
-                return token;
-            });
-            value = escapeHtml(value)
-                .replace(/!\[([^\]]*)\]\(([^)\s]+)(?:\s+"([^"]+)")?\)/g, (_match, alt, src, title) => {
-                const titleAttr = title ? ` title="${escapeHtmlAttribute(title)}"` : "";
-                return `<img src="${escapeHtmlAttribute(src)}" alt="${escapeHtmlAttribute(alt)}"${titleAttr}>`;
-            })
-                .replace(/\[([^\]]+)\]\(([^)\s]+)(?:\s+"([^"]+)")?\)/g, (_match, label, href, title) => {
-                const titleAttr = title ? ` title="${escapeHtmlAttribute(title)}"` : "";
-                return `<a href="${escapeHtmlAttribute(href)}"${titleAttr}>${label}</a>`;
-            })
-                .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
-                .replace(/__([^_]+)__/g, "<strong>$1</strong>")
-                .replace(/~~([^~]+)~~/g, "<s>$1</s>")
-                .replace(/(^|[^*])\*([^*\n]+)\*/g, "$1<em>$2</em>")
-                .replace(/(^|[^_])_([^_\n]+)_/g, "$1<em>$2</em>");
-            codeTokens.forEach((replacement, index) => {
-                value = value.replace(`@@SRTE_CODE_${index}@@`, replacement);
-            });
-            return value;
-        };
-        const closeParagraph = () => {
-            if (!paragraph.length)
-                return;
-            html += `<p>${inline(paragraph.join(" "))}</p>`;
-            paragraph = [];
-        };
-        const isTableSeparator = (line) => /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(line);
-        const parseTableRow = (line) => {
-            let value = line.trim();
-            if (value.startsWith("|"))
-                value = value.slice(1);
-            if (value.endsWith("|"))
-                value = value.slice(0, -1);
-            return value.split("|").map((cell) => cell.trim());
-        };
-        const renderTable = (startIndex) => {
-            const header = parseTableRow(lines[startIndex]);
-            let index = startIndex + 2;
-            const rows = [];
-            while (index < lines.length && lines[index].includes("|") && lines[index].trim()) {
-                rows.push(parseTableRow(lines[index]));
-                index += 1;
-            }
-            const headHtml = `<thead><tr>${header.map((cell) => `<th>${inline(cell)}</th>`).join("")}</tr></thead>`;
-            const bodyHtml = rows.length
-                ? `<tbody>${rows.map((row) => `<tr>${header.map((_cell, cellIndex) => `<td>${inline(row[cellIndex] || "")}</td>`).join("")}</tr>`).join("")}</tbody>`
-                : "";
-            html += `<table style="border-collapse: collapse; width: 100%; margin: 12px 0;">${headHtml}${bodyHtml}</table>`;
-            return index;
-        };
-        for (let i = 0; i < lines.length; i += 1) {
-            const line = lines[i];
-            const trimmed = line.trim();
-            const fence = /^```([A-Za-z0-9_-]+)?\s*$/.exec(trimmed);
-            if (fence) {
-                closeParagraph();
-                closeList();
-                if (codeFence) {
-                    const langClass = codeFence.lang ? ` class="language-${escapeHtmlAttribute(codeFence.lang)}"` : "";
-                    html += `<pre><code${langClass}>${escapeHtml(codeFence.lines.join("\n"))}</code></pre>`;
-                    codeFence = null;
-                }
-                else {
-                    codeFence = { lang: fence[1] || "", lines: [] };
-                }
-                continue;
-            }
-            if (codeFence) {
-                codeFence.lines.push(line);
-                continue;
-            }
-            if (!trimmed) {
-                closeParagraph();
-                closeList();
-                continue;
-            }
-            if (/^(-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
-                closeParagraph();
-                closeList();
-                html += "<hr>";
-                continue;
-            }
-            if (i + 1 < lines.length && trimmed.includes("|") && isTableSeparator(lines[i + 1])) {
-                closeParagraph();
-                closeList();
-                i = renderTable(i) - 1;
-                continue;
-            }
-            const heading = /^(#{1,6})\s+(.+)$/.exec(trimmed);
-            if (heading) {
-                closeParagraph();
-                closeList();
-                const level = heading[1].length;
-                html += `<h${level}>${inline(heading[2])}</h${level}>`;
-                continue;
-            }
-            const bullet = /^[-*+]\s+(.+)$/.exec(trimmed);
-            if (bullet) {
-                closeParagraph();
-                if (listType !== "ul") {
-                    closeList();
-                    html += "<ul>";
-                    listType = "ul";
-                }
-                html += `<li>${inline(bullet[1])}</li>`;
-                continue;
-            }
-            const numbered = /^\d+[.)]\s+(.+)$/.exec(trimmed);
-            if (numbered) {
-                closeParagraph();
-                if (listType !== "ol") {
-                    closeList();
-                    html += "<ol>";
-                    listType = "ol";
-                }
-                html += `<li>${inline(numbered[1])}</li>`;
-                continue;
-            }
-            const quote = /^>\s?(.*)$/.exec(trimmed);
-            if (quote) {
-                closeParagraph();
-                closeList();
-                html += `<blockquote>${inline(quote[1]) || "<br>"}</blockquote>`;
-                continue;
-            }
-            closeList();
-            paragraph.push(trimmed);
-        }
-        if (codeFence) {
-            const langClass = codeFence.lang ? ` class="language-${escapeHtmlAttribute(codeFence.lang)}"` : "";
-            html += `<pre><code${langClass}>${escapeHtml(codeFence.lines.join("\n"))}</code></pre>`;
-        }
-        closeParagraph();
-        closeList();
-        const root = document.createElement("div");
-        root.innerHTML = html;
-        enhanceImportedTables(root);
-        return root.innerHTML;
-    };
     const htmlToMarkdown = (html) => {
         const root = document.createElement("div");
         root.innerHTML = html;
@@ -2121,7 +3201,7 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
             return;
         const file = files[0];
         const text = await file.text();
-        const html = type === "html" ? text : markdownToHtml(text);
+        const html = type === "html" ? text : markdownToCompatibilityHtml(text);
         const el = editableRef.current;
         const hasContent = el && el.textContent && el.textContent.trim().length > 0;
         insertImportedHtml(html, hasContent ? "append" : "replace", {
@@ -2587,11 +3667,73 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
             console.error("Error wrapping tables", e);
         }
     };
+    const normalizeInvalidTableNesting = (root) => {
+        const getOuterList = (item) => {
+            let list = item.parentElement;
+            while (list?.parentElement?.tagName === "LI") {
+                const parentList = list.parentElement.parentElement;
+                if (!parentList || !["UL", "OL"].includes(parentList.tagName))
+                    break;
+                list = parentList;
+            }
+            return list;
+        };
+        root.querySelectorAll("table").forEach((table) => {
+            const tableBlock = (table.closest('[data-table-wrapper="true"]') || table);
+            const codeBlock = tableBlock.closest("pre");
+            if (codeBlock?.parentElement) {
+                codeBlock.parentElement.insertBefore(tableBlock, codeBlock.nextSibling);
+                return;
+            }
+            const listItem = tableBlock.closest("li");
+            if (!listItem)
+                return;
+            const outerList = getOuterList(listItem);
+            if (outerList?.parentElement) {
+                outerList.parentElement.insertBefore(tableBlock, outerList.nextSibling);
+            }
+        });
+    };
+    const normalizeInvalidQuoteNesting = (root) => {
+        root.querySelectorAll("blockquote blockquote").forEach((quote) => {
+            const outerQuote = quote.parentElement?.closest("blockquote");
+            if (outerQuote?.parentElement) {
+                outerQuote.parentElement.insertBefore(quote, outerQuote.nextSibling);
+            }
+        });
+        root.querySelectorAll("p,h1,h2,h3,h4,h5,h6,pre").forEach((container) => {
+            const nestedQuotes = Array.from(container.children).filter((child) => child.tagName === "BLOCKQUOTE");
+            nestedQuotes.forEach((quote) => {
+                container.parentElement?.insertBefore(quote, container.nextSibling);
+            });
+            if (nestedQuotes.length > 0 &&
+                container.tagName === "P" &&
+                !container.textContent?.trim() &&
+                Array.from(container.children).every((child) => child.tagName === "BR")) {
+                container.remove();
+            }
+        });
+    };
+    const normalizeInvalidCodeBlockNesting = (root) => {
+        root.querySelectorAll("pre pre").forEach((codeBlock) => {
+            const outerCodeBlock = codeBlock.parentElement?.closest("pre");
+            if (outerCodeBlock?.parentElement) {
+                outerCodeBlock.parentElement.insertBefore(codeBlock, outerCodeBlock.nextSibling);
+            }
+        });
+        root.querySelectorAll("p,h1,h2,h3,h4,h5,h6,blockquote").forEach((container) => {
+            const nestedCodeBlocks = Array.from(container.children).filter((child) => child.tagName === "PRE");
+            nestedCodeBlocks.forEach((codeBlock) => {
+                container.parentElement?.insertBefore(codeBlock, container.nextSibling);
+            });
+        });
+    };
     const isCaretBoundaryBlock = (node) => {
         if (!(node instanceof HTMLElement))
             return false;
         const tag = node.tagName.toLowerCase();
         return (tag === "blockquote" ||
+            tag === "pre" ||
             tag === "table" ||
             node.getAttribute("data-table-wrapper") === "true");
     };
@@ -2624,6 +3766,12 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
             return;
         // Auto-fix negative margins that might cause visibility issues
         fixNegativeMargins(el);
+        // Quotes are document blocks and cannot be nested by drag and drop.
+        normalizeInvalidQuoteNesting(el);
+        // Code blocks are document blocks and cannot be nested by drag and drop.
+        normalizeInvalidCodeBlockNesting(el);
+        // Tables are document-level blocks and must not remain inside code or list items.
+        normalizeInvalidTableNesting(el);
         // Ensure tables are wrapped for horizontal scrolling
         ensureTableWrappers(el);
         // Keep a reachable typing position around isolating blocks at document edges
@@ -3211,13 +4359,19 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         if (image && editor.contains(image)) {
             return (image.parentElement?.tagName === "A" ? image.parentElement : image);
         }
+        const listElement = element.closest("ul,ol");
+        if (listElement && editor.contains(listElement))
+            return listElement;
         const tableElement = element.closest("table");
         if (tableElement && editor.contains(tableElement)) {
             return (tableElement.closest('[data-table-wrapper="true"]') || tableElement);
         }
-        const listElement = element.closest("ul,ol");
-        if (listElement && editor.contains(listElement))
-            return listElement;
+        const quoteElement = element.closest("blockquote");
+        if (quoteElement && editor.contains(quoteElement))
+            return quoteElement;
+        const codeBlock = element.closest("pre");
+        if (codeBlock && editor.contains(codeBlock))
+            return codeBlock;
         const block = element.closest('[data-table-wrapper="true"],blockquote,pre,p,h1,h2,h3,h4,h5,h6,div');
         if (!block || block === editor || !editor.contains(block))
             return null;
@@ -3237,8 +4391,13 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         }
         const targetRect = target.getBoundingClientRect();
         const scrollRect = scroller.getBoundingClientRect();
+        const isTableTarget = target.matches("table,[data-table-wrapper='true']") ||
+            Boolean(target.querySelector("table"));
+        const isListInsideCell = target.matches("ul,ol") &&
+            Boolean(target.closest("td,th"));
         const next = {
-            left: Math.max(4, targetRect.left - scrollRect.left + scroller.scrollLeft - 30),
+            // Table handles sit on the table's left border so nested tables remain reachable.
+            left: Math.max(4, targetRect.left - scrollRect.left + scroller.scrollLeft - (isTableTarget || isListInsideCell ? 12 : 30)),
             top: targetRect.top - scrollRect.top + scroller.scrollTop,
             height: Math.max(24, targetRect.height),
             target,
@@ -3261,7 +4420,7 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
             dragHandleHideTimerRef.current = null;
             if (!draggedBlockRef.current)
                 setDragHandle(null);
-        }, 120);
+        }, 350);
     };
     const getImageFromMovableBlock = (block) => {
         if (block.tagName === "IMG")
@@ -3273,6 +4432,50 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         if (!editor || !editor.contains(block))
             return false;
         const under = document.elementFromPoint(x, y);
+        const draggedQuote = block.tagName === "BLOCKQUOTE";
+        const draggedCodeBlock = block.tagName === "PRE";
+        if (draggedQuote) {
+            const underElement = under instanceof HTMLElement ? under : under?.parentElement;
+            const quoteTarget = underElement?.closest("blockquote");
+            if (quoteTarget && quoteTarget !== block) {
+                let rootQuote = quoteTarget;
+                while (rootQuote.parentElement?.closest("blockquote")) {
+                    rootQuote = rootQuote.parentElement.closest("blockquote");
+                }
+                const parent = rootQuote.parentElement;
+                if (!parent)
+                    return false;
+                const rect = rootQuote.getBoundingClientRect();
+                if (rootQuote.contains(block) || y >= rect.top + rect.height / 2) {
+                    parent.insertBefore(block, rootQuote.nextSibling);
+                }
+                else {
+                    parent.insertBefore(block, rootQuote);
+                }
+                return true;
+            }
+        }
+        if (draggedCodeBlock) {
+            const underElement = under instanceof HTMLElement ? under : under?.parentElement;
+            const codeTarget = underElement?.closest("pre");
+            if (codeTarget && codeTarget !== block) {
+                let rootCodeBlock = codeTarget;
+                while (rootCodeBlock.parentElement?.closest("pre")) {
+                    rootCodeBlock = rootCodeBlock.parentElement.closest("pre");
+                }
+                const parent = rootCodeBlock.parentElement;
+                if (!parent)
+                    return false;
+                const rect = rootCodeBlock.getBoundingClientRect();
+                if (rootCodeBlock.contains(block) || y >= rect.top + rect.height / 2) {
+                    parent.insertBefore(block, rootCodeBlock.nextSibling);
+                }
+                else {
+                    parent.insertBefore(block, rootCodeBlock);
+                }
+                return true;
+            }
+        }
         const draggedImage = getImageFromMovableBlock(block);
         const targetCell = draggedImage ? getClosestCell(under) : null;
         if (draggedImage && targetCell && !block.contains(targetCell)) {
@@ -3303,6 +4506,78 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
         if (range && editor.contains(range.commonAncestorContainer)) {
             if (block.contains(range.commonAncestorContainer))
                 return false;
+            if (draggedQuote) {
+                const element = range.commonAncestorContainer instanceof HTMLElement
+                    ? range.commonAncestorContainer
+                    : range.commonAncestorContainer.parentElement;
+                const container = element?.closest("p,h1,h2,h3,h4,h5,h6,pre");
+                if (container?.parentElement) {
+                    const isEmpty = !container.textContent?.trim() &&
+                        Array.from(container.children).every((child) => child.tagName === "BR");
+                    if (isEmpty) {
+                        container.parentElement.insertBefore(block, container);
+                        container.remove();
+                    }
+                    else {
+                        const rect = container.getBoundingClientRect();
+                        container.parentElement.insertBefore(block, y < rect.top + rect.height / 2 ? container : container.nextSibling);
+                    }
+                    return true;
+                }
+            }
+            if (draggedCodeBlock) {
+                const element = range.commonAncestorContainer instanceof HTMLElement
+                    ? range.commonAncestorContainer
+                    : range.commonAncestorContainer.parentElement;
+                const codeTarget = element?.closest("pre");
+                if (codeTarget?.parentElement) {
+                    let rootCodeBlock = codeTarget;
+                    while (rootCodeBlock.parentElement?.closest("pre")) {
+                        rootCodeBlock = rootCodeBlock.parentElement.closest("pre");
+                    }
+                    rootCodeBlock.parentElement.insertBefore(block, rootCodeBlock.nextSibling);
+                    return true;
+                }
+                const container = element?.closest("p,h1,h2,h3,h4,h5,h6,blockquote");
+                if (container?.parentElement) {
+                    const isEmpty = !container.textContent?.trim() &&
+                        Array.from(container.children).every((child) => child.tagName === "BR");
+                    if (isEmpty) {
+                        container.parentElement.insertBefore(block, container);
+                        container.remove();
+                    }
+                    else {
+                        const rect = container.getBoundingClientRect();
+                        container.parentElement.insertBefore(block, y < rect.top + rect.height / 2 ? container : container.nextSibling);
+                    }
+                    return true;
+                }
+            }
+            const isTableBlock = block.matches("table,[data-table-wrapper='true']") || Boolean(block.querySelector("table"));
+            if (isTableBlock) {
+                const element = range.commonAncestorContainer instanceof HTMLElement
+                    ? range.commonAncestorContainer
+                    : range.commonAncestorContainer.parentElement;
+                const codeBlock = element?.closest("pre");
+                if (codeBlock?.parentElement) {
+                    codeBlock.parentElement.insertBefore(block, codeBlock.nextSibling);
+                    return true;
+                }
+                const listItem = element?.closest("li");
+                if (listItem) {
+                    let outerList = listItem.parentElement;
+                    while (outerList?.parentElement?.tagName === "LI") {
+                        const parentList = outerList.parentElement.parentElement;
+                        if (!parentList || !["UL", "OL"].includes(parentList.tagName))
+                            break;
+                        outerList = parentList;
+                    }
+                    if (outerList?.parentElement) {
+                        outerList.parentElement.insertBefore(block, outerList.nextSibling);
+                        return true;
+                    }
+                }
+            }
             range.insertNode(block);
             return true;
         }
@@ -3327,20 +4602,145 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
             return null;
         return getMovableElementFromNode(element);
     };
+    const getMoveTarget = () => {
+        const editor = editableRef.current;
+        if (!editor)
+            return null;
+        const imageTarget = selectedImage?.parentElement?.tagName === "A"
+            ? selectedImage.parentElement
+            : selectedImage;
+        if (imageTarget && editor.contains(imageTarget))
+            return imageTarget;
+        const range = getSelectionRangeInEditor();
+        let node = range?.commonAncestorContainer || null;
+        if (node?.nodeType === Node.TEXT_NODE)
+            node = node.parentNode;
+        const element = node instanceof HTMLElement ? node : null;
+        if (!element)
+            return null;
+        const listItem = element.closest("li");
+        if (listItem && editor.contains(listItem))
+            return listItem;
+        const cell = getClosestCell(element);
+        if (cell) {
+            const block = element.closest("p,h1,h2,h3,h4,h5,h6,blockquote,pre,div");
+            if (block && block !== cell && cell.contains(block))
+                return block;
+            return cell;
+        }
+        return getTopLevelMovableElement();
+    };
+    const outdentListItem = (item) => {
+        const list = item.parentElement;
+        const parentItem = list?.parentElement;
+        const outerList = parentItem?.parentElement;
+        if (!list ||
+            !parentItem ||
+            parentItem.tagName.toLowerCase() !== "li" ||
+            !outerList ||
+            !["ul", "ol"].includes(outerList.tagName.toLowerCase())) {
+            return false;
+        }
+        outerList.insertBefore(item, parentItem.nextSibling);
+        if (!list.querySelector("li"))
+            list.remove();
+        return true;
+    };
     const elementSibling = (element, direction) => {
         let sibling = direction === "previous" ? element.previousSibling : element.nextSibling;
-        while (sibling && sibling.nodeType === Node.TEXT_NODE && !sibling.textContent?.trim()) {
+        while (sibling &&
+            ((sibling.nodeType === Node.TEXT_NODE && !sibling.textContent?.trim()) ||
+                (sibling instanceof HTMLElement && sibling.getAttribute("data-srte-caret-boundary") === "true"))) {
             sibling = direction === "previous" ? sibling.previousSibling : sibling.nextSibling;
         }
         return sibling;
     };
+    const moveSelectedBlocks = (direction) => {
+        const editor = editableRef.current;
+        const range = getSelectionRangeInEditor();
+        if (!editor || !range || range.collapsed)
+            return false;
+        const blocks = sortInDocumentOrder(getSelectedBlocks(range)).filter((block) => {
+            if (!editor.contains(block) || !block.parentElement)
+                return false;
+            const parentBlock = block.parentElement.closest(blockSelector);
+            return !parentBlock || parentBlock === editor;
+        });
+        if (blocks.length === 0)
+            return false;
+        const parent = blocks[0].parentElement;
+        if (!parent || blocks.some((block) => block.parentElement !== parent))
+            return false;
+        pushEditorHistory();
+        if (direction === "up") {
+            const previous = elementSibling(blocks[0], "previous");
+            if (previous && !blocks.includes(previous)) {
+                blocks.forEach((block) => parent.insertBefore(block, previous));
+            }
+        }
+        else if (direction === "down") {
+            const next = elementSibling(blocks[blocks.length - 1], "next");
+            if (next && !blocks.includes(next)) {
+                const afterNext = next.nextSibling;
+                blocks.forEach((block) => parent.insertBefore(block, afterNext));
+            }
+        }
+        else {
+            blocks.forEach((block) => {
+                const current = parseInt(block.style.marginLeft || "0", 10) || 0;
+                const nextMargin = direction === "right"
+                    ? Math.min(current + 24, 240)
+                    : Math.max(current - 24, 0);
+                block.style.marginLeft = nextMargin ? `${nextMargin}px` : "";
+            });
+        }
+        const movedRange = document.createRange();
+        movedRange.setStartBefore(blocks[0]);
+        movedRange.setEndAfter(blocks[blocks.length - 1]);
+        safeSelectRange(movedRange);
+        savedRangeRef.current = movedRange.cloneRange();
+        handleInput();
+        requestAnimationFrame(updateActiveState);
+        return true;
+    };
     const moveCurrentElement = (direction) => {
         const editor = editableRef.current;
-        const target = getTopLevelMovableElement();
+        if (moveSelectedBlocks(direction))
+            return;
+        let target = getMoveTarget();
         if (!editor || !target)
             return;
         pushEditorHistory();
-        if (direction === "up") {
+        if (target.tagName === "TD" || target.tagName === "TH") {
+            const cell = target;
+            const paragraph = document.createElement("p");
+            while (cell.firstChild)
+                paragraph.appendChild(cell.firstChild);
+            cell.appendChild(paragraph);
+            target = paragraph;
+        }
+        if (target.tagName.toLowerCase() === "li") {
+            const list = target.parentElement;
+            if (!list)
+                return;
+            if (direction === "up") {
+                const previous = elementSibling(target, "previous");
+                if (previous?.nodeName === "LI")
+                    list.insertBefore(target, previous);
+            }
+            else if (direction === "down") {
+                const next = elementSibling(target, "next");
+                if (next?.nodeName === "LI")
+                    list.insertBefore(next, target);
+            }
+            else if (direction === "right") {
+                nestSelectedListItems([target], list.tagName.toLowerCase());
+            }
+            else {
+                outdentListItem(target);
+            }
+        }
+        else if (direction === "up") {
             const previous = elementSibling(target, "previous");
             if (previous)
                 target.parentElement?.insertBefore(target, previous);
@@ -3488,7 +4888,7 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                         } }), _jsx("input", { ref: mdInputRef, type: "file", accept: ".md,.markdown,text/markdown,text/plain", style: { display: "none" }, onChange: (e) => {
                             importTextFile(e.currentTarget.files, "md");
                             e.currentTarget.value = "";
-                        } }), _jsxs("select", { value: currentBlockType, onMouseDown: preserveEditorSelection, onChange: (e) => {
+                        } }), _jsxs("select", { value: currentBlockType, onPointerDown: preserveEditorSelection, onMouseDown: preserveEditorSelection, onChange: (e) => {
                             const val = e.target.value;
                             if (val === "p")
                                 applyFormatBlock("<p>");
@@ -3498,6 +4898,12 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                                 applyFormatBlock("<h2>");
                             else if (val === "h3")
                                 applyFormatBlock("<h3>");
+                            else if (val === "h4")
+                                applyFormatBlock("<h4>");
+                            else if (val === "h5")
+                                applyFormatBlock("<h5>");
+                            else if (val === "h6")
+                                applyFormatBlock("<h6>");
                         }, title: "Paragraph/Heading", style: {
                             height: 32,
                             padding: "0 8px",
@@ -3505,24 +4911,23 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                             borderRadius: 6,
                             background: "var(--srte-input-bg)",
                             color: "var(--srte-input-text)",
-                        }, children: [_jsx("option", { value: "p", children: "Paragraph" }), _jsx("option", { value: "h1", children: "Heading 1" }), _jsx("option", { value: "h2", children: "Heading 2" }), _jsx("option", { value: "h3", children: "Heading 3" })] }), _jsx("button", { title: "Bold", onClick: () => exec("bold"), "aria-pressed": activeState.bold, style: activeButtonStyle(activeState.bold), children: _jsx("span", { style: { fontWeight: 700 }, children: "B" }) }), _jsx("button", { title: "Italic", onClick: () => exec("italic"), "aria-pressed": activeState.italic, style: activeButtonStyle(activeState.italic, { fontStyle: "italic" }), children: "I" }), _jsx("button", { title: "Underline", onClick: () => exec("underline"), "aria-pressed": activeState.underline, style: activeButtonStyle(activeState.underline, { textDecoration: "underline" }), children: "U" }), _jsx("button", { title: "Strikethrough", onClick: () => exec("strikeThrough"), "aria-pressed": activeState.strikeThrough, style: activeButtonStyle(activeState.strikeThrough, { textDecoration: "line-through" }), children: "S" }), showFontSize && (_jsxs("select", { value: currentFontSize, onMouseDown: () => {
-                            // Save selection before dropdown interaction
-                            const sel = window.getSelection();
-                            if (sel && sel.rangeCount > 0) {
-                                const range = sel.getRangeAt(0);
-                                const editor = editableRef.current;
-                                if (editor && editor.contains(range.commonAncestorContainer) && !range.collapsed) {
-                                    savedRangeRef.current = range.cloneRange();
-                                }
-                            }
-                        }, onChange: (e) => applyFontSize(e.target.value), title: "Font Size", style: {
+                        }, children: [_jsx("option", { value: "mixed", disabled: true, children: "Mixed" }), _jsx("option", { value: "p", children: "Paragraph" }), _jsx("option", { value: "h1", children: "Heading 1" }), _jsx("option", { value: "h2", children: "Heading 2" }), _jsx("option", { value: "h3", children: "Heading 3" }), _jsx("option", { value: "h4", children: "Heading 4" }), _jsx("option", { value: "h5", children: "Heading 5" }), _jsx("option", { value: "h6", children: "Heading 6" })] }), [
+                        ["left", "Left", "Align left"],
+                        ["center", "Center", "Align center"],
+                        ["right", "Right", "Align right"],
+                        ["justify", "Justify", "Justify"],
+                    ].map(([alignment, label, title]) => (_jsx("button", { type: "button", title: title, "aria-label": title, "aria-pressed": currentAlignment === alignment, onPointerDown: preserveEditorSelection, onMouseDown: preserveEditorSelection, onClick: () => applyTextAlignment(alignment), style: activeButtonStyle(currentAlignment === alignment, {
+                            minWidth: 32,
+                            padding: "0 6px",
+                            fontSize: 10,
+                        }), children: label }, alignment))), _jsx("button", { title: "Bold", onClick: () => exec("bold"), "aria-pressed": activeState.bold, style: activeButtonStyle(activeState.bold), children: _jsx("span", { style: { fontWeight: 700 }, children: "B" }) }), _jsx("button", { title: "Italic", onClick: () => exec("italic"), "aria-pressed": activeState.italic, style: activeButtonStyle(activeState.italic, { fontStyle: "italic" }), children: "I" }), _jsx("button", { title: "Underline", onClick: () => exec("underline"), "aria-pressed": activeState.underline, style: activeButtonStyle(activeState.underline, { textDecoration: "underline" }), children: "U" }), _jsx("button", { title: "Strikethrough", onClick: () => exec("strikeThrough"), "aria-pressed": activeState.strikeThrough, style: activeButtonStyle(activeState.strikeThrough, { textDecoration: "line-through" }), children: "S" }), showFontSize && (_jsxs("select", { value: currentFontSize, onPointerDown: preserveEditorSelection, onMouseDown: preserveEditorSelection, onChange: (e) => applyFontSize(e.target.value), title: "Font Size", style: {
                             height: 32,
                             padding: "0 8px",
                             border: "1px solid var(--srte-input-border)",
                             borderRadius: 6,
                             background: "var(--srte-input-bg)",
                             color: "var(--srte-input-text)",
-                        }, children: [_jsx("option", { value: "", disabled: true, children: "Size" }), _jsx("option", { value: "8", children: "8" }), _jsx("option", { value: "9", children: "9" }), _jsx("option", { value: "10", children: "10" }), _jsx("option", { value: "11", children: "11" }), _jsx("option", { value: "12", children: "12" }), _jsx("option", { value: "14", children: "14" }), _jsx("option", { value: "18", children: "18" }), _jsx("option", { value: "24", children: "24" }), _jsx("option", { value: "30", children: "30" }), _jsx("option", { value: "36", children: "36" }), _jsx("option", { value: "48", children: "48" }), _jsx("option", { value: "60", children: "60" }), _jsx("option", { value: "72", children: "72" }), _jsx("option", { value: "96", children: "96" })] })), preserveFontFamily && (_jsxs("select", { value: currentFont, onMouseDown: () => {
+                        }, children: [_jsx("option", { value: "", disabled: true, children: "Size" }), currentFontSize && !["8", "9", "10", "11", "12", "14", "16", "18", "24", "30", "36", "48", "60", "72", "96"].includes(currentFontSize) && (_jsx("option", { value: currentFontSize, children: currentFontSize })), _jsx("option", { value: "8", children: "8" }), _jsx("option", { value: "9", children: "9" }), _jsx("option", { value: "10", children: "10" }), _jsx("option", { value: "11", children: "11" }), _jsx("option", { value: "12", children: "12" }), _jsx("option", { value: "14", children: "14" }), _jsx("option", { value: "16", children: "16" }), _jsx("option", { value: "18", children: "18" }), _jsx("option", { value: "24", children: "24" }), _jsx("option", { value: "30", children: "30" }), _jsx("option", { value: "36", children: "36" }), _jsx("option", { value: "48", children: "48" }), _jsx("option", { value: "60", children: "60" }), _jsx("option", { value: "72", children: "72" }), _jsx("option", { value: "96", children: "96" })] })), preserveFontFamily && (_jsxs("select", { value: currentFont, onMouseDown: () => {
                             const sel = window.getSelection();
                             if (sel && sel.rangeCount > 0) {
                                 const range = sel.getRangeAt(0);
@@ -3562,7 +4967,50 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                             borderRadius: 6,
                             background: "var(--srte-input-bg)",
                             color: "var(--srte-input-text)",
-                        }, children: _jsx("span", { style: { fontWeight: 700, padding: "1px 4px", background: "var(--srte-accent-bg)", borderRadius: 3 }, children: "A" }) }), _jsxs("button", { title: "Subscript", onClick: () => exec("subscript"), "aria-pressed": activeState.subscript, style: activeButtonStyle(activeState.subscript), children: ["X", _jsx("sub", { children: "2" })] }), _jsxs("button", { title: "Superscript", onClick: () => exec("superscript"), "aria-pressed": activeState.superscript, style: activeButtonStyle(activeState.superscript), children: ["X", _jsx("sup", { children: "2" })] }), _jsx("button", { title: "Bulleted list", onClick: () => exec("insertUnorderedList"), "aria-pressed": activeState.unorderedList, style: activeButtonStyle(activeState.unorderedList, { padding: "0 10px" }), children: "\u2022 List" }), _jsx("button", { title: "Numbered list", onClick: () => exec("insertOrderedList"), "aria-pressed": activeState.orderedList, style: activeButtonStyle(activeState.orderedList, { padding: "0 10px" }), children: "1. List" }), _jsx("button", { title: "Blockquote", onClick: toggleBlockquote, "aria-pressed": activeState.blockquote, style: activeButtonStyle(activeState.blockquote), children: "\u275D" }), _jsx("button", { title: "Special characters", onClick: () => setShowSpecialChars(true), style: {
+                        }, children: _jsx("span", { style: { fontWeight: 700, padding: "1px 4px", background: "var(--srte-accent-bg)", borderRadius: 3 }, children: "A" }) }), _jsxs("button", { title: "Subscript", onClick: () => toggleInlineScript("subscript"), "aria-pressed": activeState.subscript, style: activeButtonStyle(activeState.subscript), children: ["X", _jsx("sub", { children: "2" })] }), _jsxs("button", { title: "Superscript", onClick: () => toggleInlineScript("superscript"), "aria-pressed": activeState.superscript, style: activeButtonStyle(activeState.superscript), children: ["X", _jsx("sup", { children: "2" })] }), [
+                        {
+                            key: "check",
+                            label: "☐",
+                            title: "Checklist",
+                            active: activeState.checklist,
+                            action: () => applyChecklist(false, true),
+                            options: [["check:plain", "☐ Checklist"], ["check:strike", "☑ Checked + strike"]],
+                        },
+                        {
+                            key: "bullet",
+                            label: "•≡",
+                            title: "Bulleted list",
+                            active: activeState.unorderedList,
+                            action: () => applyListStyle("bullet:disc"),
+                            options: [["bullet:disc", "• Disc"], ["bullet:circle", "○ Circle"], ["bullet:square", "▪ Square"]],
+                        },
+                        {
+                            key: "ordered",
+                            label: "1≡",
+                            title: "Numbered list",
+                            active: activeState.orderedList,
+                            action: () => applyListStyle("ordered:decimal"),
+                            options: [["ordered:decimal", "1. 2. 3."], ["ordered:lower-alpha", "a. b. c."], ["ordered:upper-alpha", "A. B. C."], ["ordered:lower-roman", "i. ii. iii."], ["ordered:upper-roman", "I. II. III."]],
+                        },
+                    ].map((control) => (_jsxs("span", { style: { display: "inline-flex", height: 32 }, children: [_jsx("button", { type: "button", title: control.title, onPointerDown: preserveEditorSelection, onClick: control.action, "aria-pressed": control.active, style: activeButtonStyle(control.active, { padding: "0 9px", borderRadius: "6px 0 0 6px" }), children: control.label }), _jsxs("select", { defaultValue: "", "aria-label": `${control.title} styles`, title: `${control.title} styles`, onPointerDown: preserveEditorSelection, onMouseDown: preserveEditorSelection, onChange: (event) => {
+                                    const selected = event.currentTarget.value;
+                                    if (selected === "check:plain")
+                                        applyChecklist(false);
+                                    else if (selected === "check:strike")
+                                        applyChecklist(true);
+                                    else if (selected)
+                                        applyListStyle(selected);
+                                    event.currentTarget.value = "";
+                                }, style: {
+                                    width: 28,
+                                    height: 32,
+                                    padding: 0,
+                                    border: "1px solid var(--srte-input-border)",
+                                    borderLeft: 0,
+                                    borderRadius: "0 6px 6px 0",
+                                    background: "var(--srte-input-bg)",
+                                    color: "var(--srte-input-text)",
+                                }, children: [_jsx("option", { value: "", disabled: true, children: "Style" }), control.options.map(([value, label]) => _jsx("option", { value: value, children: label }, value))] })] }, control.key))), _jsx("button", { type: "button", title: "Blockquote", onPointerDown: preserveEditorSelection, onClick: toggleBlockquote, "aria-pressed": activeState.blockquote, style: activeButtonStyle(activeState.blockquote), children: "\u275D" }), _jsx("button", { title: "Special characters", onClick: () => setShowSpecialChars(true), style: {
                             height: 32,
                             minWidth: 32,
                             padding: "0 8px",
@@ -3570,7 +5018,7 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                             borderRadius: 6,
                             background: "var(--srte-input-bg)",
                             color: "var(--srte-input-text)",
-                        }, children: "\u03A9" }), _jsx("button", { title: "Code block", onClick: () => exec("formatBlock", "<pre>"), "aria-pressed": activeState.codeBlock, style: activeButtonStyle(activeState.codeBlock, {
+                        }, children: "\u03A9" }), _jsx("button", { type: "button", title: "Code block", onPointerDown: preserveEditorSelection, onClick: toggleCodeBlock, "aria-pressed": activeState.codeBlock, style: activeButtonStyle(activeState.codeBlock, {
                             minWidth: 36,
                             fontFamily: "ui-monospace, SFMono-Regular, Menlo",
                         }), children: "< />" }), formula && (_jsx("button", { title: "Insert formula", onClick: () => setShowFormulaDialog(true), style: {
@@ -3581,21 +5029,18 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                             borderRadius: 6,
                             background: "var(--srte-input-bg)",
                             color: "var(--srte-input-text)",
-                        }, children: "\u2211" })), _jsx("button", { title: "Insert link", onClick: insertLink, style: {
-                            height: 32,
-                            padding: "0 10px",
-                            border: "1px solid var(--srte-input-border)",
-                            borderRadius: 6,
-                            background: "var(--srte-input-bg)",
-                            color: "var(--srte-input-text)",
-                        }, children: "Link" }), _jsx("button", { title: "Remove link", onClick: () => exec("unlink"), style: {
+                        }, children: "\u2211" })), _jsx("button", { type: "button", title: "Insert link", "aria-label": "Insert or edit link", "aria-pressed": activeState.link, onPointerDown: preserveEditorSelection, onClick: () => openLinkEditor(), style: activeButtonStyle(activeState.link, { minWidth: 34, fontSize: 17 }), children: _jsx("span", { "aria-hidden": "true", children: "\u2197" }) }), _jsx("button", { type: "button", title: "Remove link", "aria-label": "Remove link", disabled: !activeState.link, onPointerDown: preserveEditorSelection, onClick: () => exec("unlink"), style: {
                             height: 32,
-                            padding: "0 10px",
+                            minWidth: 34,
+                            padding: "0 8px",
                             border: "1px solid var(--srte-input-border)",
                             borderRadius: 6,
                             background: "var(--srte-input-bg)",
                             color: "var(--srte-input-text)",
-                        }, children: "Unlink" }), media && (_jsxs(_Fragment, { children: [_jsx("button", { title: "Insert image", onClick: insertImage, style: {
+                            cursor: activeState.link ? "pointer" : "not-allowed",
+                            opacity: activeState.link ? 1 : 0.45,
+                            fontSize: 16,
+                        }, children: _jsx("span", { "aria-hidden": "true", children: "\u2197\u0338" }) }), media && (_jsxs(_Fragment, { children: [_jsx("button", { title: "Insert image", onClick: insertImage, style: {
                                     height: 32,
                                     padding: "0 10px",
                                     border: "1px solid var(--srte-input-border)",
@@ -4084,14 +5529,29 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                     boxSizing: "border-box",
                     position: "relative",
                     scrollPaddingBottom: 24,
-                }, children: [_jsx("div", { ref: editableRef, contentEditable: !readOnly, suppressContentEditableWarning: true, onInput: handleInput, onKeyUp: updateActiveState, onMouseUp: updateActiveState, onCompositionStart: () => (isComposingRef.current = true), onCompositionEnd: () => {
+                }, children: [_jsx("div", { ref: editableRef, contentEditable: !readOnly, suppressContentEditableWarning: true, onBeforeInput: (e) => {
+                            const inputType = e.nativeEvent.inputType || "input";
+                            if (inputType === "historyUndo" || inputType === "historyRedo") {
+                                if (restoreEditorHistory(inputType === "historyUndo" ? "undo" : "redo")) {
+                                    e.preventDefault();
+                                }
+                                return;
+                            }
+                            captureInputHistory(inputType);
+                        }, onInput: handleInput, onKeyUp: updateActiveState, onMouseUp: updateActiveState, onCompositionStart: () => (isComposingRef.current = true), onCompositionEnd: () => {
                             isComposingRef.current = false;
                             handleInput();
                         }, onMouseMove: (e) => {
                             if (draggedBlockRef.current)
                                 return;
-                            updateDragHandleForTarget(getMovableElementFromNode(e.target));
-                        }, onMouseLeave: () => {
+                            updateDragHandleForTarget(isNode(e.target) ? getMovableElementFromNode(e.target) : null);
+                        }, onMouseOver: (e) => {
+                            if (draggedBlockRef.current)
+                                return;
+                            updateDragHandleForTarget(isNode(e.target) ? getMovableElementFromNode(e.target) : null);
+                        }, onMouseLeave: (e) => {
+                            if (closestFromTarget(e.relatedTarget, "[data-srte-drag-handle]"))
+                                return;
                             if (!draggedBlockRef.current)
                                 scheduleDragHandleHide();
                         }, onPaste: (e) => {
@@ -4104,6 +5564,7 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                                     return;
                                 }
                             }
+                            pushEditorHistory();
                             const html = e.clipboardData?.getData("text/html");
                             if (html) {
                                 e.preventDefault();
@@ -4186,6 +5647,31 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                             }
                         }, onClick: (e) => {
                             const t = e.target;
+                            if (t.dataset.srteCheck === "true") {
+                                const item = t.closest("li");
+                                const list = item?.closest('[data-srte-checklist="true"]');
+                                if (item && list) {
+                                    pushEditorHistory();
+                                    const checked = item.dataset.checked !== "true";
+                                    item.dataset.checked = checked ? "true" : "false";
+                                    t.textContent = checked ? "☑" : "☐";
+                                    t.setAttribute("aria-label", checked ? "Mark incomplete" : "Mark complete");
+                                    item.style.textDecoration =
+                                        list.dataset.srteChecklistStrike === "true" && checked ? "line-through" : "";
+                                    handleInput();
+                                    return;
+                                }
+                            }
+                            const anchor = t?.closest("a");
+                            if (anchor && editableRef.current?.contains(anchor)) {
+                                e.preventDefault();
+                                e.stopPropagation();
+                                openLinkEditor(anchor);
+                                setTableMenu(null);
+                                setImageMenu(null);
+                                return;
+                            }
+                            setLinkMenu(null);
                             if (t && t.tagName === "IMG") {
                                 setSelectedImage(t);
                                 scheduleImageOverlay();
@@ -4237,6 +5723,11 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                             }
                             updateActiveState();
                         }, onKeyDown: (e) => {
+                            if ((e.metaKey || e.ctrlKey) && String(e.key).toLowerCase() === "k") {
+                                e.preventDefault();
+                                openLinkEditor();
+                                return;
+                            }
                             if ((e.metaKey || e.ctrlKey) && String(e.key).toLowerCase() === "z") {
                                 const restored = restoreEditorHistory(e.shiftKey ? "redo" : "undo");
                                 if (restored) {
@@ -4261,13 +5752,29 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                             // Keep Tab for indentation in lists; otherwise insert 2 spaces
                             if (e.key === "Tab") {
                                 e.preventDefault();
-                                if (document.queryCommandState("insertUnorderedList") ||
-                                    document.queryCommandState("insertOrderedList")) {
+                                const selection = getSelectionRangeInEditor();
+                                const selectedListItems = selection && !selection.collapsed
+                                    ? getSelectedListItems(getSelectedBlocks(selection))
+                                    : [];
+                                if (selectedListItems.length > 0) {
+                                    if (!e.shiftKey) {
+                                        nestListSelection();
+                                        return;
+                                    }
+                                    pushEditorHistory();
+                                    exec("outdent");
+                                    return;
+                                }
+                                const currentBlock = getCurrentBlock();
+                                if (currentBlock?.closest("li")) {
+                                    pushEditorHistory();
                                     exec(e.shiftKey ? "outdent" : "indent");
                                 }
                                 else {
+                                    captureInputHistory("insertText");
                                     document.execCommand("insertText", false, "  ");
                                 }
+                                return;
                             }
                             // Table navigation with arrows inside cells
                             if (["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(e.key)) {
@@ -4372,7 +5879,7 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                                 setTableMenu(null);
                                 setImageMenu(null);
                             }
-                        } }), dragHandle && !readOnly && (_jsx("button", { type: "button", draggable: true, title: "Drag block", "aria-label": "Drag block", onMouseEnter: () => {
+                        } }), dragHandle && !readOnly && (_jsx("button", { type: "button", draggable: true, "data-srte-drag-handle": "true", title: "Drag block", "aria-label": "Drag block", onMouseEnter: () => {
                             if (dragHandleHideTimerRef.current != null) {
                                 window.clearTimeout(dragHandleHideTimerRef.current);
                                 dragHandleHideTimerRef.current = null;
@@ -4509,7 +6016,10 @@ export function ClassicEditor({ value, onChange, placeholder = "Type here…", m
                                     borderRadius: 2,
                                     cursor: "ew-resize",
                                     pointerEvents: "auto",
-                                } })] }))] }), tableMenu && (_jsx("div", { style: {
+                                } })] }))] }), linkMenu && (_jsx(LinkEditorPopover, { x: linkMenu.x, y: linkMenu.y, initialHref: linkMenu.initialHref, initialText: linkMenu.initialText, initialOpenInNewTab: linkMenu.anchor?.target === "_blank", showTextInput: linkMenu.showTextInput, showOpen: Boolean(linkMenu.anchor), showRemove: Boolean(linkMenu.anchor), onApply: applyLinkEditorValue, onOpen: linkMenu.anchor ? () => {
+                    openEditorLink(linkMenu.anchor);
+                    setLinkMenu(null);
+                } : undefined, onRemove: linkMenu.anchor ? () => removeAnchorLink(linkMenu.anchor) : undefined, onCancel: () => setLinkMenu(null) })), tableMenu && (_jsx("div", { style: {
                     position: "fixed",
                     inset: 0,
                     zIndex: 60,