fable-editor 1.0.0

package/dist/angular/esm2022/core/editor.mjs

@@ -0,0 +1,2700 @@
+import { getStrings } from './i18n';
+import { FONTS, SIZES, BLOCKS, COLORS, QUICK_COLORS, CHARS, MIN_FONT_PX, MAX_FONT_PX, LINE_HEIGHTS, WORD_SPACINGS, DEFAULT_TOOLBAR, DEFAULT_MENUBAR } from './config';
+import { IC } from './icons';
+import { cleanPastedHTML, normalizeTextPaste } from './paste-engine';
+import { importDocxToHtml } from './docx-import';
+const IMG_CORNERS = ['nw', 'ne', 'sw', 'se'];
+export class FableEditor {
+    static instanceCounter = 0;
+    options;
+    lang = 'en';
+    contentClass = 'fable-content-' + FableEditor.instanceCounter++;
+    contentStyleEl = null;
+    shell;
+    menubar;
+    toolbar;
+    ed;
+    statusbar;
+    sbHelp;
+    sbWords;
+    imgInput;
+    savedRange = null;
+    foreColor = '#000000';
+    backColor = '#FACC15';
+    openPop = null;
+    openSubEl = null;
+    popAnchor = null;
+    dlgOvl = null;
+    tblActive = null;
+    tblCorner = null;
+    tblColBars = [];
+    tblCtx = null;
+    tblCellMark = null;
+    tblOpMark = null;
+    tblOpMarkKind = null;
+    imgActive = null;
+    imgHandles = [];
+    imgCtx = null;
+    imgHideTimer = null;
+    phActive = null;
+    phCtx = null;
+    phUploadTarget = null;
+    imageUploadHandler;
+    onImageUploadError;
+    contentStyle;
+    selCtx = null;
+    docInput;
+    revisions = [];
+    revTimer = null;
+    draftTimer = null;
+    draftStorageKey = '';
+    listeners = [];
+    isDestroyed = false;
+    constructor(options) {
+        this.options = {
+            target: options.target,
+            language: options.language || 'en',
+            height: options.height ?? 302,
+            initialContent: options.initialContent ?? '<p><br></p>',
+            onChange: options.onChange || (() => { }),
+            onReady: options.onReady || (() => { }),
+            menubar: options.menubar ?? true,
+            toolbar: options.toolbar ?? true,
+            statusbar: options.statusbar ?? true,
+            readonly: options.readonly ?? false,
+            draftKey: options.draftKey ?? (typeof location !== 'undefined' ? location.pathname : 'default'),
+            fontFamilyFormats: options.fontFamilyFormats ?? FONTS,
+            imageFileTypes: options.imageFileTypes ?? ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/bmp', 'image/webp']
+        };
+        this.imageUploadHandler = options.imageUploadHandler;
+        this.onImageUploadError = options.onImageUploadError;
+        this.contentStyle = options.contentStyle;
+        this.lang = this.options.language;
+        this.draftStorageKey = 'tmclone-draft:' + this.options.draftKey;
+        this.initDOM();
+        this.bindEvents();
+        this.initUI();
+        this.recordRevision();
+        this.options.onReady(this);
+    }
+    t(key) {
+        const s = getStrings(this.lang)[key];
+        return typeof s === 'string' ? s : s.join(',');
+    }
+    tArr(key) {
+        return getStrings(this.lang)[key];
+    }
+    dir() {
+        return getStrings(this.lang).dir;
+    }
+    /* ---------------------------------------------------------- DOM setup */
+    initDOM() {
+        const target = this.options.target;
+        target.innerHTML = '';
+        target.classList.add('tox-root');
+        this.shell = document.createElement('div');
+        this.shell.className = 'tox';
+        this.menubar = document.createElement('div');
+        this.menubar.className = 'mnb';
+        this.toolbar = document.createElement('div');
+        this.toolbar.className = 'tbr';
+        this.ed = document.createElement('div');
+        this.ed.className = 'earea ' + this.contentClass;
+        this.ed.setAttribute('contenteditable', (!this.options.readonly).toString());
+        this.ed.spellcheck = true;
+        this.ed.innerHTML = this.options.initialContent;
+        this.ed.style.height = this.options.height + 'px';
+        this.statusbar = document.createElement('div');
+        this.statusbar.className = 'sbar';
+        this.statusbar.innerHTML = `
+      <span class="mid"></span>
+      <span class="words"></span>
+      <span class="grip">
+        <svg viewBox="0 0 12 12"><path d="M11 1 1 11M11 6 6 11M11 11h0"/></svg>
+      </span>
+    `;
+        this.sbHelp = this.statusbar.querySelector('.mid');
+        this.sbWords = this.statusbar.querySelector('.words');
+        const grip = this.statusbar.querySelector('.grip');
+        this.bindGrip(grip);
+        this.shell.appendChild(this.menubar);
+        this.shell.appendChild(this.toolbar);
+        this.shell.appendChild(this.ed);
+        this.shell.appendChild(this.statusbar);
+        if (this.contentStyle) {
+            this.contentStyleEl = document.createElement('style');
+            this.contentStyleEl.textContent = this.scopeContentStyle(this.contentStyle);
+            this.shell.appendChild(this.contentStyleEl);
+        }
+        target.appendChild(this.shell);
+        if (!this.options.statusbar)
+            this.statusbar.style.display = 'none';
+        this.imgInput = document.createElement('input');
+        this.imgInput.type = 'file';
+        this.imgInput.accept = this.options.imageFileTypes.join(',');
+        this.imgInput.style.display = 'none';
+        target.appendChild(this.imgInput);
+        this.docInput = document.createElement('input');
+        this.docInput.type = 'file';
+        this.docInput.accept = '.docx,application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+        this.docInput.style.display = 'none';
+        target.appendChild(this.docInput);
+    }
+    /** Rewrites the literal word `body` in a user-supplied `contentStyle` string to a
+     *  selector scoped to this instance's content div. Everything else passes through
+     *  verbatim, since `.ed` is a plain div in the host page (not an iframe) and an
+     *  unscoped `body { ... }` rule would otherwise leak onto the host page's body. */
+    scopeContentStyle(css) {
+        return css.replace(/\bbody\b/g, '.' + this.contentClass);
+    }
+    bindGrip(grip) {
+        let startY = 0;
+        let startH = 0;
+        const md = (e) => {
+            startY = e.clientY;
+            startH = this.ed.offsetHeight;
+            e.preventDefault();
+            const mv = (ev) => {
+                this.ed.style.height = Math.max(120, startH + ev.clientY - startY) + 'px';
+            };
+            const up = () => {
+                window.removeEventListener('mousemove', mv);
+                window.removeEventListener('mouseup', up);
+            };
+            window.addEventListener('mousemove', mv);
+            window.addEventListener('mouseup', up);
+        };
+        grip.addEventListener('mousedown', md);
+        this.listeners.push(() => grip.removeEventListener('mousedown', md));
+    }
+    /* ---------------------------------------------------------- event binding */
+    bindEvents() {
+        this.onDoc('mousedown', (e) => {
+            if (this.openPop &&
+                !this.openPop.contains(e.target) &&
+                !this.popAnchor.contains(e.target) &&
+                !(this.openSubEl && this.openSubEl.contains(e.target))) {
+                this.closePop();
+            }
+        });
+        this.onDoc('keydown', (e) => {
+            if (e.key === 'Escape') {
+                this.closePop();
+                this.closeDlg();
+            }
+        });
+        this.onDoc('selectionchange', () => {
+            const sel = window.getSelection();
+            if (sel && this.ed.contains(sel.anchorNode)) {
+                this.saveSel();
+                this.refreshState();
+                this.updateSelToolbar(sel);
+                this.positionCellMarker();
+            }
+            else {
+                this.clearSelToolbar();
+            }
+        });
+        this.on(this.ed, 'input', () => {
+            this.refreshState();
+            this.onChange();
+            this.positionTableHandles();
+            this.positionImageHandles();
+            this.positionImgPhCtx();
+        });
+        this.on(this.ed, 'keydown', (e) => {
+            if (e.altKey && e.key === '0') {
+                e.preventDefault();
+                this.helpDlg();
+            }
+        });
+        this.on(this.ed, 'paste', (e) => this.handlePaste(e));
+        this.on(this.ed, 'drop', (e) => {
+            /* content drops stay blocked (powerpaste_block_drop) — only an
+               image file dropped onto an upload placeholder is consumed */
+            e.preventDefault();
+            const ph = e.target.closest?.('.img-ph');
+            if (!ph || !this.ed.contains(ph) || this.options.readonly)
+                return;
+            const file = Array.from(e.dataTransfer?.files || []).find((f) => f.type.startsWith('image/'));
+            if (file)
+                this.readImageFileInto(file, ph);
+        });
+        this.on(this.ed, 'dragover', (e) => e.preventDefault());
+        this.on(this.ed, 'mousedown', (e) => {
+            const target = e.target;
+            const table = target.closest?.('table');
+            if (table && this.ed.contains(table))
+                this.selectTableForResize(table);
+            else
+                this.clearTableHandles();
+            const ph = target.closest?.('.img-ph');
+            if (ph && this.ed.contains(ph) && !this.options.readonly) {
+                e.preventDefault();
+                this.selectImgPlaceholder(ph);
+            }
+            else {
+                this.clearImgPlaceholderSel();
+            }
+            const img = target.closest?.('img');
+            if (img && this.ed.contains(img) && !this.options.readonly) {
+                e.preventDefault();
+                this.selectImage(img);
+            }
+            else {
+                this.clearImageHandles();
+            }
+        });
+        this.on(this.ed, 'mouseover', (e) => {
+            if (this.options.readonly)
+                return;
+            const img = e.target.closest?.('img');
+            if (img && this.ed.contains(img)) {
+                this.cancelImgHide();
+                this.selectImage(img);
+            }
+        });
+        this.on(this.ed, 'mouseout', (e) => {
+            const img = e.target.closest?.('img');
+            if (!img)
+                return;
+            const to = e.relatedTarget;
+            if (to &&
+                (this.imgCtx?.contains(to) ||
+                    this.imgHandles.some((h) => h.contains(to)) ||
+                    to.closest?.('img') === img))
+                return;
+            this.scheduleImgHide();
+        });
+        this.on(this.ed, 'scroll', () => {
+            this.positionTableHandles();
+            this.positionImageHandles();
+            this.positionImgPhCtx();
+        });
+        this.onWin('scroll', () => {
+            this.positionTableHandles();
+            this.positionImageHandles();
+            this.positionImgPhCtx();
+            this.repositionSelToolbar();
+        }, true);
+        this.onWin('resize', () => {
+            this.positionTableHandles();
+            this.positionImageHandles();
+            this.positionImgPhCtx();
+            this.repositionSelToolbar();
+        });
+        this.on(this.imgInput, 'change', () => {
+            const file = this.imgInput.files?.[0];
+            if (!file)
+                return;
+            const ph = this.phUploadTarget;
+            this.phUploadTarget = null;
+            if (ph && this.ed.contains(ph)) {
+                this.readImageFileInto(file, ph);
+                return;
+            }
+            const fr = new FileReader();
+            fr.onload = () => {
+                this.restoreSel();
+                document.execCommand('insertHTML', false, `<img src="${fr.result}" title="${file.name.replace(/"/g, '')}" alt="">`);
+                this.onChange();
+            };
+            fr.readAsDataURL(file);
+        });
+        this.on(this.docInput, 'change', () => {
+            const file = this.docInput.files?.[0];
+            if (!file)
+                return;
+            this.importWordFile(file).catch(() => alert(this.t('importfail')));
+        });
+        this.onDoc('mousedown', (e) => {
+            if (this.ed.contains(e.target) ||
+                e.target === this.tblCorner ||
+                this.tblColBars.includes(e.target) ||
+                (this.tblCtx && this.tblCtx.contains(e.target)) ||
+                this.imgHandles.includes(e.target) ||
+                (this.imgCtx && this.imgCtx.contains(e.target)) ||
+                (this.phCtx && this.phCtx.contains(e.target)) ||
+                (this.selCtx && this.selCtx.contains(e.target)) ||
+                (this.openPop && this.openPop.contains(e.target)) ||
+                (this.openSubEl && this.openSubEl.contains(e.target)))
+                return;
+            this.clearTableHandles();
+            this.clearImageHandles();
+            this.clearImgPlaceholderSel();
+            this.clearSelToolbar();
+        });
+    }
+    on(target, event, handler) {
+        target.addEventListener(event, handler);
+        this.listeners.push(() => target.removeEventListener(event, handler));
+    }
+    onDoc(event, handler) {
+        document.addEventListener(event, handler);
+        this.listeners.push(() => document.removeEventListener(event, handler));
+    }
+    onWin(event, handler, capture) {
+        window.addEventListener(event, handler, capture);
+        this.listeners.push(() => window.removeEventListener(event, handler, capture));
+    }
+    /* ---------------------------------------------------------- public API */
+    getContent() {
+        return this.ed.innerHTML;
+    }
+    setContent(html) {
+        this.ed.innerHTML = html || '<p><br></p>';
+        this.refreshState();
+        this.clearTableHandles();
+        this.clearImageHandles();
+        this.clearImgPlaceholderSel();
+        this.clearSelToolbar();
+        this.onChange();
+    }
+    insertContent(html) {
+        this.restoreSel();
+        document.execCommand('insertHTML', false, html);
+        this.saveSel();
+        this.refreshState();
+        this.onChange();
+    }
+    setLanguage(lang) {
+        this.lang = lang;
+        this.initUI();
+    }
+    focus() {
+        this.ed.focus();
+    }
+    async importWordFile(file) {
+        const html = await importDocxToHtml(file);
+        this.recordRevision();
+        this.setContent(html);
+        this.recordRevision();
+    }
+    restoreDraft() {
+        let raw = null;
+        try {
+            raw = localStorage.getItem(this.draftStorageKey);
+        }
+        catch {
+            /* storage unavailable */
+        }
+        if (!raw)
+            return false;
+        try {
+            const draft = JSON.parse(raw);
+            if (!draft.html)
+                return false;
+            this.recordRevision();
+            this.setContent(draft.html);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getRevisions() {
+        return this.revisions.slice();
+    }
+    destroy() {
+        if (this.isDestroyed)
+            return;
+        this.isDestroyed = true;
+        if (this.revTimer != null)
+            window.clearTimeout(this.revTimer);
+        if (this.draftTimer != null)
+            window.clearTimeout(this.draftTimer);
+        this.closePop();
+        this.closeDlg();
+        this.clearTableHandles();
+        this.clearImageHandles();
+        this.clearImgPlaceholderSel();
+        this.clearSelToolbar();
+        this.listeners.forEach((fn) => fn());
+        this.listeners = [];
+        if (this.shell && this.shell.parentNode)
+            this.shell.parentNode.removeChild(this.shell);
+        if (this.imgInput && this.imgInput.parentNode)
+            this.imgInput.parentNode.removeChild(this.imgInput);
+        if (this.docInput && this.docInput.parentNode)
+            this.docInput.parentNode.removeChild(this.docInput);
+        this.contentStyleEl = null;
+    }
+    /* ---------------------------------------------------------- selection */
+    saveSel() {
+        const s = window.getSelection();
+        if (s && s.rangeCount && this.ed.contains(s.anchorNode))
+            this.savedRange = s.getRangeAt(0).cloneRange();
+    }
+    restoreSel() {
+        if (!this.savedRange) {
+            this.ed.focus();
+            return;
+        }
+        this.ed.focus();
+        const s = window.getSelection();
+        if (!s)
+            return;
+        s.removeAllRanges();
+        s.addRange(this.savedRange);
+    }
+    exec(cmd, val) {
+        this.restoreSel();
+        document.execCommand('styleWithCSS', false, cmd !== 'fontSize' ? 'true' : 'false');
+        document.execCommand(cmd, false, val ?? undefined);
+        this.saveSel();
+        this.refreshState();
+        this.onChange();
+    }
+    closestBlock(node) {
+        while (node && node !== this.ed) {
+            if (node.nodeType === 1 && /^(P|DIV|H[1-6]|LI|PRE|BLOCKQUOTE|TD|TH)$/i.test(node.tagName)) {
+                return node;
+            }
+            node = node.parentNode;
+        }
+        return null;
+    }
+    selectedBlocks() {
+        const s = window.getSelection();
+        if (!s || !s.rangeCount || !this.ed.contains(s.anchorNode))
+            return [];
+        const r = s.getRangeAt(0);
+        const blocks = Array.from(this.ed.querySelectorAll('p,h1,h2,h3,h4,h5,h6,li,pre,blockquote,td,th')).filter((b) => r.intersectsNode(b));
+        if (!blocks.length) {
+            const b = this.closestBlock(s.anchorNode);
+            if (b)
+                return [b];
+        }
+        return blocks;
+    }
+    onChange() {
+        this.options.onChange(this.ed.innerHTML);
+        this.scheduleRevision();
+        this.scheduleDraftSave();
+    }
+    /* ---------------------------------------------------------- revisions / drafts */
+    recordRevision() {
+        const html = this.ed.innerHTML;
+        const last = this.revisions[this.revisions.length - 1];
+        if (last && last.html === html)
+            return;
+        this.revisions.push({ time: Date.now(), html });
+        if (this.revisions.length > 30)
+            this.revisions.shift();
+    }
+    scheduleRevision() {
+        if (this.revTimer != null)
+            window.clearTimeout(this.revTimer);
+        this.revTimer = window.setTimeout(() => {
+            this.revTimer = null;
+            this.recordRevision();
+        }, 1500);
+    }
+    scheduleDraftSave() {
+        if (this.draftTimer != null)
+            window.clearTimeout(this.draftTimer);
+        this.draftTimer = window.setTimeout(() => {
+            this.draftTimer = null;
+            try {
+                localStorage.setItem(this.draftStorageKey, JSON.stringify({ time: Date.now(), html: this.ed.innerHTML }));
+            }
+            catch {
+                /* storage unavailable or full */
+            }
+        }, 800);
+    }
+    revisionDlg() {
+        this.recordRevision();
+        this.dialog(this.t('revhistory'), (body) => {
+            if (!this.revisions.length) {
+                body.innerHTML = `<p style="color:#556">${this.t('revempty')}</p>`;
+                return;
+            }
+            const wrap = document.createElement('div');
+            wrap.className = 'revwrap';
+            const list = document.createElement('div');
+            list.className = 'revlist';
+            const prev = document.createElement('div');
+            prev.className = 'revprev';
+            const restoreBtn = document.createElement('button');
+            restoreBtn.type = 'button';
+            restoreBtn.className = 'revrestore';
+            restoreBtn.textContent = this.t('restore');
+            let selected = this.revisions.length - 1;
+            const fmt = new Intl.DateTimeFormat(this.lang === 'ar' ? 'ar-AE' : 'en-GB', {
+                year: 'numeric',
+                month: 'short',
+                day: 'numeric',
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit'
+            });
+            const items = {};
+            const show = (i) => {
+                selected = i;
+                this.revisions.forEach((_, j) => items[j]?.classList.toggle('on', j === i));
+                prev.innerHTML = this.revisions[i].html;
+                restoreBtn.disabled = i === this.revisions.length - 1;
+            };
+            for (let i = this.revisions.length - 1; i >= 0; i--) {
+                const rev = this.revisions[i];
+                const b = document.createElement('button');
+                b.type = 'button';
+                const words = (new DOMParser().parseFromString(rev.html, 'text/html').body.textContent || '').trim();
+                const wc = words ? words.split(/\s+/).length : 0;
+                const isCurrent = i === this.revisions.length - 1;
+                b.innerHTML = `<span>${isCurrent ? this.t('currentver') : fmt.format(new Date(rev.time))}</span><span class="wc">${wc} ${this.t('words')}</span>`;
+                b.addEventListener('click', () => show(i));
+                items[i] = b;
+                list.appendChild(b);
+            }
+            list.append(restoreBtn);
+            restoreBtn.addEventListener('click', () => {
+                const rev = this.revisions[selected];
+                if (!rev)
+                    return;
+                this.recordRevision();
+                this.setContent(rev.html);
+                this.recordRevision();
+                this.closeDlg();
+            });
+            wrap.append(list, prev);
+            body.appendChild(wrap);
+            show(selected);
+        });
+    }
+    /* ---------------------------------------------------------- popups / menus */
+    closeSub() {
+        this.openSubEl?.remove();
+        this.openSubEl = null;
+    }
+    closePop() {
+        this.closeSub();
+        if (this.openPop) {
+            this.openPop.remove();
+            this.openPop = null;
+            this.popAnchor?.classList.remove('open');
+            this.popAnchor = null;
+            /* a menu item's mouseleave never fires once the menu is removed,
+               so drop any row/column highlight it left behind */
+            this.setOpTarget(null);
+        }
+    }
+    openSubFor(item, anchor) {
+        this.closeSub();
+        const sub = document.createElement('div');
+        sub.className = 'pop sub';
+        sub.dir = this.dir();
+        if (item.subBuild)
+            item.subBuild(sub);
+        else if (item.sub)
+            this.menuItems(sub, item.sub);
+        sub.addEventListener('mousedown', (e) => {
+            if (e.target.tagName !== 'INPUT')
+                e.preventDefault();
+        });
+        document.body.appendChild(sub);
+        const r = anchor.getBoundingClientRect();
+        const isRtl = this.dir() === 'rtl';
+        // overlap the parent item slightly so the pointer can travel into the flyout
+        let x = isRtl ? r.left - sub.offsetWidth + 2 : r.right - 2;
+        x = Math.max(8, Math.min(x + scrollX, scrollX + innerWidth - sub.offsetWidth - 8));
+        let y = r.top + scrollY - 6;
+        y = Math.max(8 + scrollY, Math.min(y, scrollY + innerHeight - sub.offsetHeight - 8));
+        sub.style.left = x + 'px';
+        sub.style.top = y + 'px';
+        this.openSubEl = sub;
+    }
+    popup(anchor, build) {
+        if (this.openPop && this.popAnchor === anchor) {
+            this.closePop();
+            return;
+        }
+        this.closePop();
+        const el = document.createElement('div');
+        el.className = 'pop';
+        el.dir = this.dir();
+        build(el);
+        document.body.appendChild(el);
+        const r = anchor.getBoundingClientRect();
+        // align the menu with its control: at least as wide as the anchor
+        el.style.minWidth = Math.max(160, Math.round(r.width)) + 'px';
+        el.style.top = r.bottom + scrollY + 2 + 'px';
+        const isRtl = this.dir() === 'rtl';
+        let x = isRtl ? r.right - el.offsetWidth : r.left;
+        x = Math.max(8, Math.min(x + scrollX, scrollX + innerWidth - el.offsetWidth - 8));
+        el.style.left = x + 'px';
+        el.addEventListener('mousedown', (e) => {
+            if (e.target.tagName !== 'INPUT')
+                e.preventDefault();
+        });
+        this.openPop = el;
+        this.popAnchor = anchor;
+        anchor.classList.add('open');
+    }
+    menuItems(el, items) {
+        items.forEach((it) => {
+            if (it === '|') {
+                el.insertAdjacentHTML('beforeend', '<div class="sep"></div>');
+                return;
+            }
+            const hasSub = !!(it.sub || it.subBuild);
+            const b = document.createElement('button');
+            b.className = 'mi' + (it.on ? ' on' : '');
+            b.innerHTML = `<span class="ic">${it.icon || ''}</span><span class="prev" ${it.previewStyle ? `style="${it.previewStyle}"` : ''}>${it.label}</span>${it.shortcut ? `<span class="sc">${it.shortcut}</span>` : ''}${hasSub ? `<span class="subarrow">${IC.chev}</span>` : ''}`;
+            b.addEventListener('click', () => {
+                if (!it.action)
+                    return;
+                this.closePop();
+                it.action();
+            });
+            b.addEventListener('mouseenter', () => {
+                if (hasSub)
+                    this.openSubFor(it, b);
+                else if (this.openSubEl && el !== this.openSubEl)
+                    this.closeSub();
+                it.hover?.(true);
+            });
+            b.addEventListener('mouseleave', () => it.hover?.(false));
+            el.appendChild(b);
+        });
+    }
+    /* ---------------------------------------------------------- toolbar builders */
+    tbtn(icon, tip, fn, id) {
+        const b = document.createElement('button');
+        b.className = 'tbtn';
+        b.type = 'button';
+        b.title = tip;
+        b.innerHTML = icon;
+        if (id)
+            b.dataset.id = id;
+        b.addEventListener('mousedown', (e) => e.preventDefault());
+        b.addEventListener('click', fn);
+        return b;
+    }
+    /** Font-size increase / decrease step button. */
+    stepBtn(delta) {
+        const sign = delta > 0 ? '+' : '−';
+        const icon = delta > 0 ? IC.fontsizeup : IC.fontsizedown;
+        const b = this.tbtn(icon, this.t('fontsize') + ' ' + sign, () => this.stepFontSize(delta));
+        b.addEventListener('mousedown', () => this.saveSel());
+        return b;
+    }
+    /** Toolbar icon button that opens a popup menu anchored to itself. */
+    menuTbtn(icon, tip, menuFn, id) {
+        const b = this.tbtn(icon, tip, () => menuFn(b), id);
+        b.classList.add('hasmenu');
+        b.insertAdjacentHTML('beforeend', IC.chev);
+        b.addEventListener('mousedown', () => this.saveSel());
+        return b;
+    }
+    /** Quick text-color chips plus a "more" chip that opens the full palette. */
+    colorChips() {
+        const chip = (title) => {
+            const b = document.createElement('button');
+            b.type = 'button';
+            b.className = 'cchip';
+            b.title = title;
+            b.addEventListener('mousedown', (e) => {
+                e.preventDefault();
+                this.saveSel();
+            });
+            return b;
+        };
+        const chips = QUICK_COLORS.map((c) => {
+            const b = chip(this.t('forecolor'));
+            b.style.background = c;
+            b.addEventListener('click', () => this.applyColor('fore', c));
+            return b;
+        });
+        const more = chip(this.t('forecolor'));
+        more.classList.add('more');
+        more.dataset.cb = 'fore';
+        more.innerHTML = IC.chev;
+        more.addEventListener('click', () => this.colorMenu(more, 'fore'));
+        return [...chips, more];
+    }
+    group(...els) {
+        const g = document.createElement('div');
+        g.className = 'tgrp';
+        els.forEach((e) => {
+            e.classList.add('gbtn');
+            g.appendChild(e);
+        });
+        return g;
+    }
+    tsel(cls, id, defLabel, menuFn) {
+        const b = document.createElement('button');
+        b.className = 'tsel ' + cls;
+        b.type = 'button';
+        b.dataset.id = id;
+        b.innerHTML = `<span class="lbl empty">${defLabel || ''}</span>${IC.chev}`;
+        b.addEventListener('mousedown', (e) => {
+            e.preventDefault();
+            this.saveSel();
+        });
+        b.addEventListener('click', () => menuFn(b));
+        return b;
+    }
+    setListStyle(kind, style) {
+        this.restoreSel();
+        const s = window.getSelection();
+        if (!s)
+            return;
+        let list = this.closestBlock(s.anchorNode)?.closest(kind);
+        if (!list) {
+            this.exec(kind === 'ol' ? 'insertOrderedList' : 'insertUnorderedList');
+            list = this.closestBlock(s.anchorNode)?.closest(kind);
+        }
+        if (list)
+            list.style.listStyleType = style;
+        this.saveSel();
+        this.onChange();
+    }
+    listMenu(anchor, kind) {
+        const cmd = kind === 'ol' ? 'insertOrderedList' : 'insertUnorderedList';
+        // the toggle item creates the default style, so it is not repeated below
+        const styles = kind === 'ol'
+            ? [
+                ['lower-alpha', IC.ol_alpha],
+                ['lower-roman', IC.ol_roman],
+                ['upper-alpha', IC.ol_alphau],
+                ['upper-roman', IC.ol_romanu]
+            ]
+            : [
+                ['circle', IC.ul_circle],
+                ['square', IC.ul_square]
+            ];
+        const labels = this.tArr(kind === 'ol' ? 'liststyles_ol' : 'liststyles_ul').slice(1);
+        const sel = window.getSelection();
+        const listEl = sel ? this.closestBlock(sel.anchorNode)?.closest(kind) : null;
+        const curStyle = listEl ? listEl.style.listStyleType : '';
+        this.popup(anchor, (el) => {
+            this.menuItems(el, [
+                {
+                    label: this.t(kind === 'ol' ? 'numlist' : 'bullist'),
+                    icon: kind === 'ol' ? IC.numlist : IC.bullist,
+                    on: document.queryCommandState(cmd),
+                    action: () => this.exec(cmd)
+                }
+            ]);
+            el.insertAdjacentHTML('beforeend', '<div class="sep"></div>');
+            const grid = document.createElement('div');
+            grid.className = 'mi-grid';
+            styles.forEach(([s, icon], i) => {
+                const b = document.createElement('button');
+                b.className = 'mi' + (curStyle === s ? ' on' : '');
+                b.innerHTML = `<span class="ic">${icon}</span><span class="prev">${labels[i]}</span>`;
+                b.addEventListener('click', () => {
+                    this.closePop();
+                    this.setListStyle(kind, s);
+                });
+                grid.appendChild(b);
+            });
+            el.appendChild(grid);
+        });
+    }
+    colorMenu(anchor, kind) {
+        this.popup(anchor, (el) => {
+            const grid = document.createElement('div');
+            grid.className = 'cpal';
+            COLORS.forEach((c) => {
+                const b = document.createElement('button');
+                b.style.background = c;
+                b.title = c;
+                b.addEventListener('click', () => {
+                    this.closePop();
+                    this.applyColor(kind, c);
+                });
+                grid.appendChild(b);
+            });
+            el.appendChild(grid);
+            el.insertAdjacentHTML('beforeend', '<div class="sep"></div>');
+            const foot = document.createElement('div');
+            foot.className = 'cfoot';
+            const cur = document.createElement('div');
+            cur.className = 'cswatch cur';
+            cur.title = this.t('currentcolor');
+            const curColor = kind === 'fore' ? this.foreColor : this.backColor;
+            cur.style.background = /^#[0-9a-f]{6}$/i.test(curColor) ? curColor : '#000000';
+            cur.innerHTML = IC.check;
+            const nocolor = document.createElement('button');
+            nocolor.type = 'button';
+            nocolor.className = 'cswatch nocolor';
+            nocolor.title = this.t('removecolor');
+            nocolor.addEventListener('click', () => {
+                this.closePop();
+                this.applyColor(kind, null);
+            });
+            const wheel = document.createElement('label');
+            wheel.className = 'cswatch cwheel';
+            wheel.title = this.t('customcolor');
+            wheel.innerHTML = IC.palette;
+            const picker = document.createElement('input');
+            picker.type = 'color';
+            picker.value = /^#[0-9a-f]{6}$/i.test(curColor) ? curColor : '#000000';
+            picker.addEventListener('change', () => {
+                this.closePop();
+                this.applyColor(kind, picker.value);
+            });
+            wheel.appendChild(picker);
+            foot.append(cur, nocolor, wheel);
+            el.appendChild(foot);
+        });
+    }
+    applyColor(kind, c) {
+        if (kind === 'fore') {
+            this.foreColor = c || '#000000';
+            this.exec('foreColor', c || '#000000');
+        }
+        else {
+            this.backColor = c || 'transparent';
+            this.exec('hiliteColor', c || 'transparent');
+        }
+        this.syncColorSwatches(this.toolbar);
+        if (this.selCtx)
+            this.syncColorSwatches(this.selCtx);
+    }
+    syncColorSwatches(container) {
+        container.querySelectorAll(`[data-cb=fore]`).forEach((el) => (el.style.background = this.foreColor));
+        container.querySelectorAll(`[data-cb=back]`).forEach((el) => (el.style.background = this.backColor));
+    }
+    fontMenu(anchor) {
+        this.popup(anchor, (el) => {
+            this.menuItems(el, this.options.fontFamilyFormats.map(([name, val]) => ({
+                label: name,
+                previewStyle: `font-family:${val}`,
+                on: this.currentFont() === name,
+                action: () => this.exec('fontName', val)
+            })));
+        });
+    }
+    sizeMenu(anchor) {
+        this.popup(anchor, (el) => {
+            this.menuItems(el, SIZES.map((s) => ({
+                label: s,
+                on: this.currentSize() === s,
+                action: () => this.applyFontSize(s)
+            })));
+        });
+    }
+    /** Font sizing needs a non-collapsed range. With a bare caret, grow the
+        selection to the word under it; in an empty spot, select a zero-width
+        space so the new size applies to what gets typed next. */
+    ensureSizeTarget() {
+        const s = window.getSelection();
+        if (!s)
+            return;
+        if (!s.rangeCount) {
+            const r = document.createRange();
+            r.selectNodeContents(this.ed);
+            r.collapse(true);
+            s.addRange(r);
+        }
+        if (!s.isCollapsed)
+            return;
+        const r = s.getRangeAt(0);
+        const node = r.startContainer;
+        if (node.nodeType === 3) {
+            const text = node.data;
+            let a = r.startOffset;
+            let b = r.startOffset;
+            while (a > 0 && /\S/.test(text[a - 1]))
+                a--;
+            while (b < text.length && /\S/.test(text[b]))
+                b++;
+            if (b > a) {
+                const nr = document.createRange();
+                nr.setStart(node, a);
+                nr.setEnd(node, b);
+                s.removeAllRanges();
+                s.addRange(nr);
+                this.savedRange = nr.cloneRange();
+                return;
+            }
+        }
+        const zw = document.createTextNode(String.fromCharCode(0x200b));
+        r.insertNode(zw);
+        const nr = document.createRange();
+        nr.setStart(zw, 0);
+        nr.setEnd(zw, 1);
+        s.removeAllRanges();
+        s.addRange(nr);
+        this.savedRange = nr.cloneRange();
+    }
+    applyFontSize(px) {
+        this.restoreSel();
+        this.ensureSizeTarget();
+        document.execCommand('styleWithCSS', false, 'false');
+        document.execCommand('fontSize', false, '7');
+        const spans = [];
+        this.ed.querySelectorAll('font[size="7"]').forEach((f) => {
+            const span = document.createElement('span');
+            span.style.fontSize = px;
+            while (f.firstChild)
+                span.appendChild(f.firstChild);
+            f.replaceWith(span);
+            spans.push(span);
+        });
+        if (spans.length) {
+            // keep the selection anchored inside the new spans so the current
+            // size reads back correctly (e.g. for repeated +/- stepping)
+            const r = document.createRange();
+            r.setStart(spans[0], 0);
+            r.setEnd(spans[spans.length - 1], spans[spans.length - 1].childNodes.length);
+            const s = window.getSelection();
+            if (s) {
+                s.removeAllRanges();
+                s.addRange(r);
+            }
+        }
+        this.saveSel();
+        this.refreshState();
+        this.onChange();
+    }
+    stepFontSize(delta) {
+        const cur = parseInt(this.currentSize(), 10) || 14;
+        const next = Math.min(MAX_FONT_PX, Math.max(MIN_FONT_PX, cur + delta));
+        if (next === cur)
+            return;
+        this.applyFontSize(next + 'px');
+    }
+    /* ------------------------------------------------ case / spacing / link */
+    transformCase(kind) {
+        this.restoreSel();
+        const s = window.getSelection();
+        if (!s || !s.rangeCount || s.isCollapsed)
+            return;
+        const range = s.getRangeAt(0);
+        const walker = document.createTreeWalker(this.ed, NodeFilter.SHOW_TEXT);
+        const nodes = [];
+        let n;
+        while ((n = walker.nextNode()))
+            if (range.intersectsNode(n))
+                nodes.push(n);
+        nodes.forEach((t) => {
+            const start = t === range.startContainer ? range.startOffset : 0;
+            const end = t === range.endContainer ? range.endOffset : t.data.length;
+            if (end <= start)
+                return;
+            const mid = t.data.slice(start, end);
+            let out = mid;
+            if (kind === 'lower')
+                out = mid.toLowerCase();
+            else if (kind === 'upper')
+                out = mid.toUpperCase();
+            else
+                out = mid.replace(/(^|\s)(\S)/g, (m, sp, ch) => sp + ch.toUpperCase());
+            t.replaceData(start, end - start, out);
+        });
+        this.saveSel();
+        this.refreshState();
+        this.onChange();
+    }
+    caseMenu(anchor) {
+        this.popup(anchor, (el) => {
+            this.menuItems(el, [
+                { label: this.t('lowercase'), icon: IC.lowercaseic, action: () => this.transformCase('lower') },
+                { label: this.t('uppercase'), icon: IC.uppercaseic, action: () => this.transformCase('upper') },
+                { label: this.t('capitalize'), icon: IC.capitalizeic, action: () => this.transformCase('capitalize') }
+            ]);
+        });
+    }
+    applyBlockStyle(prop, value) {
+        this.restoreSel();
+        const blocks = this.selectedBlocks();
+        blocks.forEach((b) => {
+            if (value)
+                b.style[prop] = value;
+            else
+                b.style.removeProperty(prop === 'lineHeight' ? 'line-height' : 'word-spacing');
+        });
+        this.saveSel();
+        this.onChange();
+    }
+    currentBlockStyle(prop) {
+        const s = window.getSelection();
+        const b = s ? this.closestBlock(s.anchorNode) : null;
+        return b ? b.style[prop] || '' : '';
+    }
+    lineHeightMenu(anchor) {
+        const cur = this.currentBlockStyle('lineHeight');
+        this.popup(anchor, (el) => {
+            this.menuItems(el, [
+                { label: this.t('normal'), on: !cur, action: () => this.applyBlockStyle('lineHeight', '') },
+                ...LINE_HEIGHTS.map((v) => ({
+                    label: v,
+                    on: cur === v,
+                    action: () => this.applyBlockStyle('lineHeight', v)
+                }))
+            ]);
+        });
+    }
+    wordSpacingMenu(anchor) {
+        const cur = this.currentBlockStyle('wordSpacing');
+        this.popup(anchor, (el) => {
+            this.menuItems(el, [
+                { label: this.t('normal'), on: !cur, action: () => this.applyBlockStyle('wordSpacing', '') },
+                ...WORD_SPACINGS.map((v) => ({
+                    label: v,
+                    on: cur === v,
+                    action: () => this.applyBlockStyle('wordSpacing', v)
+                }))
+            ]);
+        });
+    }
+    closestAnchor() {
+        const s = window.getSelection();
+        let node = s && this.ed.contains(s.anchorNode) ? s.anchorNode : null;
+        while (node && node !== this.ed) {
+            if (node.nodeType === 1 && node.tagName === 'A')
+                return node;
+            node = node.parentNode;
+        }
+        return null;
+    }
+    linkDlg() {
+        this.saveSel();
+        const anchorEl = this.closestAnchor();
+        let urlIn;
+        const buttons = [];
+        if (anchorEl) {
+            buttons.push({
+                label: this.t('unlink'),
+                action: () => {
+                    const r = document.createRange();
+                    r.selectNodeContents(anchorEl);
+                    const s = window.getSelection();
+                    if (s) {
+                        s.removeAllRanges();
+                        s.addRange(r);
+                    }
+                    document.execCommand('unlink');
+                    this.closeDlg();
+                    this.onChange();
+                }
+            });
+        }
+        buttons.push({ label: this.t('cancel'), action: () => this.closeDlg() }, {
+            label: this.t('save'),
+            primary: true,
+            action: () => {
+                const url = urlIn.value.trim();
+                this.closeDlg();
+                if (!url)
+                    return;
+                if (anchorEl) {
+                    anchorEl.setAttribute('href', url);
+                    this.onChange();
+                    return;
+                }
+                this.restoreSel();
+                const s = window.getSelection();
+                if (!s || s.isCollapsed) {
+                    document.execCommand('insertHTML', false, `<a href="${url.replace(/"/g, '&quot;')}">${url
+                        .replace(/&/g, '&amp;')
+                        .replace(/</g, '&lt;')}</a>`);
+                }
+                else {
+                    document.execCommand('styleWithCSS', false, 'false');
+                    document.execCommand('createLink', false, url);
+                }
+                this.saveSel();
+                this.onChange();
+            }
+        });
+        this.dialog(this.t('linkttl'), (body) => {
+            const row = document.createElement('div');
+            row.style.cssText = 'display:flex;align-items:center;gap:10px;margin:10px 0;min-width:360px';
+            const lbl = document.createElement('span');
+            lbl.style.cssText = 'width:60px;color:#556;flex:none';
+            lbl.textContent = this.t('linkurl');
+            urlIn = document.createElement('input');
+            urlIn.type = 'url';
+            urlIn.placeholder = 'https://';
+            urlIn.style.cssText = 'flex:1;border:1px solid #cfd6df;border-radius:6px;padding:7px 9px;font:14px inherit';
+            urlIn.value = anchorEl?.getAttribute('href') || '';
+            row.append(lbl, urlIn);
+            body.appendChild(row);
+            setTimeout(() => urlIn.focus(), 0);
+        }, buttons);
+    }
+    blocksMenu(anchor) {
+        this.popup(anchor, (el) => {
+            this.menuItems(el, BLOCKS.map(([tag, key]) => ({
+                label: this.blockLabel(tag),
+                previewStyle: tag.startsWith('h')
+                    ? `font-weight:700;font-size:${22 - 2 * (+tag[1])}px`
+                    : tag === 'pre'
+                        ? 'font-family:monospace'
+                        : '',
+                on: this.currentBlock() === tag,
+                action: () => this.exec('formatBlock', '<' + tag + '>')
+            })));
+        });
+    }
+    blockLabel(tag) {
+        if (tag === 'p')
+            return this.t('para');
+        if (tag === 'pre')
+            return this.t('pre');
+        return this.t('heading') + ' ' + tag[1];
+    }
+    tableGrid(anchor, after) {
+        this.popup(anchor, (el) => this.buildTableGridInto(el, after));
+    }
+    buildTableGridInto(el, after) {
+        {
+            const wrap = document.createElement('div');
+            wrap.className = 'tgridwrap';
+            const grid = document.createElement('div');
+            grid.className = 'tgrid';
+            const lbl = document.createElement('div');
+            lbl.className = 'tgridlbl';
+            lbl.textContent = '1 × 1';
+            const cells = [];
+            for (let r = 0; r < 8; r++)
+                for (let c = 0; c < 10; c++) {
+                    const sp = document.createElement('span');
+                    sp.dataset.r = String(r);
+                    sp.dataset.c = String(c);
+                    sp.addEventListener('mouseenter', () => {
+                        cells.forEach((x) => x.classList.toggle('hot', +x.dataset.r <= r && +x.dataset.c <= c));
+                        lbl.textContent = c + 1 + ' × ' + (r + 1);
+                    });
+                    sp.addEventListener('click', () => {
+                        this.closePop();
+                        this.insertTable(r + 1, c + 1);
+                        after?.();
+                    });
+                    cells.push(sp);
+                    grid.appendChild(sp);
+                }
+            wrap.append(grid, lbl);
+            el.appendChild(wrap);
+        }
+    }
+    insertTable(rows, cols) {
+        this.restoreSel();
+        /* table-layout:fixed keeps the columns evenly sized while typing —
+           text wraps at the column edge instead of widening the column */
+        let html = '<table style="border-collapse:collapse;width:100%;table-layout:fixed"><tbody>';
+        for (let r = 0; r < rows; r++) {
+            html += '<tr>';
+            for (let c = 0; c < cols; c++)
+                html += '<td style="border:1px solid #b9c2cc"><br></td>';
+            html += '</tr>';
+        }
+        html += '</tbody></table><p><br></p>';
+        document.execCommand('insertHTML', false, html);
+        this.saveSel();
+        this.onChange();
+    }
+    setDir(dir) {
+        this.restoreSel();
+        const blocks = this.selectedBlocks();
+        if (blocks.length)
+            blocks.forEach((b) => b.setAttribute('dir', dir));
+        else
+            this.ed.setAttribute('dir', dir);
+        this.saveSel();
+        this.refreshState();
+        this.onChange();
+    }
+    /** Splits a toolbar layout string into groups of item names: `|` separates visual
+     *  groups, whitespace separates items within a group. Empty groups/tokens (e.g. from
+     *  leading/trailing/doubled separators) are dropped. Pure function. */
+    parseToolbarString(spec) {
+        return spec
+            .split('|')
+            .map((group) => group.trim().split(/\s+/).filter(Boolean))
+            .filter((group) => group.length > 0);
+    }
+    /** Maps every supported toolbar item name to a builder for that one control. Each
+     *  entry is a direct lift of what used to be an inline call in `buildToolbar()` — no
+     *  behavior changes, just named lookup. Only `forecolor` yields multiple elements
+     *  (the quick color chips); everything else yields one. */
+    buildToolbarRegistry() {
+        const tableBtn = this.tbtn(IC.tableic, this.t('quicktable'), () => this.tableGrid(tableBtn));
+        return {
+            undo: () => this.tbtn(IC.undo, this.t('undo'), () => this.exec('undo')),
+            redo: () => this.tbtn(IC.redo, this.t('redo'), () => this.exec('redo')),
+            preview: () => this.tbtn(IC.prevw, this.t('preview'), () => this.previewDlg()),
+            print: () => this.tbtn(IC.printic, this.t('print'), () => this.printDoc()),
+            importword: () => this.tbtn(IC.wordic, this.t('importword'), () => this.pickWordDoc()),
+            revhistory: () => this.tbtn(IC.historyic, this.t('revhistory'), () => this.revisionDlg()),
+            fontfamily: () => this.tsel('w-font', 'fontsel', '', (b) => this.fontMenu(b)),
+            fontsize: () => this.tsel('w-size', 'sizesel', '', (b) => this.sizeMenu(b)),
+            fontsizeincrease: () => this.stepBtn(1),
+            fontsizedecrease: () => this.stepBtn(-1),
+            bold: () => this.tbtn(IC.bold, this.t('bold'), () => this.exec('bold'), 'bold'),
+            italic: () => this.tbtn(IC.italic, this.t('italic'), () => this.exec('italic'), 'italic'),
+            underline: () => this.tbtn(IC.underline, this.t('underline'), () => this.exec('underline'), 'underline'),
+            strikethrough: () => this.tbtn(IC.strikethrough, this.t('strikethrough'), () => this.exec('strikeThrough'), 'strikeThrough'),
+            forecolor: () => this.colorChips(),
+            backcolor: () => this.menuTbtn(IC.backcolor + '<span class="colorbar" data-cb="back"></span>', this.t('backcolor'), (b) => this.colorMenu(b, 'back')),
+            alignleft: () => this.tbtn(IC.alignleft, this.t('alignleft'), () => this.exec('justifyLeft'), 'justifyLeft'),
+            aligncenter: () => this.tbtn(IC.aligncenter, this.t('aligncenter'), () => this.exec('justifyCenter'), 'justifyCenter'),
+            alignright: () => this.tbtn(IC.alignright, this.t('alignright'), () => this.exec('justifyRight'), 'justifyRight'),
+            alignjustify: () => this.tbtn(IC.alignjustify, this.t('alignjustify'), () => this.exec('justifyFull'), 'justifyFull'),
+            bullist: () => this.menuTbtn(IC.bullist, this.t('bullist'), (b) => this.listMenu(b, 'ul'), 'insertUnorderedList'),
+            numlist: () => this.menuTbtn(IC.numlist, this.t('numlist'), (b) => this.listMenu(b, 'ol'), 'insertOrderedList'),
+            outdent: () => this.tbtn(IC.outdent, this.t('outdent'), () => this.exec('outdent')),
+            indent: () => this.tbtn(IC.indent, this.t('indent'), () => this.exec('indent')),
+            link: () => this.tbtn(IC.link, this.t('linkttl'), () => this.linkDlg()),
+            blockquote: () => this.tbtn(IC.quote, this.t('quote'), () => this.toggleBlock('blockquote'), 'blockquote'),
+            changecase: () => this.menuTbtn(IC.caseic, this.t('changecase'), (b) => this.caseMenu(b)),
+            lineheight: () => this.menuTbtn(IC.lineheight, this.t('lineheight'), (b) => this.lineHeightMenu(b)),
+            wordspacing: () => this.menuTbtn(IC.wordspacing, this.t('wordspacing'), (b) => this.wordSpacingMenu(b)),
+            removeformat: () => this.tbtn(IC.clearformatic, this.t('removeformat'), () => this.exec('removeFormat')),
+            blocks: () => this.tsel('w-block', 'blocksel', this.t('para'), (b) => this.blocksMenu(b)),
+            ltr: () => this.tbtn(IC.ltr, this.t('ltr'), () => this.setDir('ltr'), 'ltr'),
+            rtl: () => this.tbtn(IC.rtl, this.t('rtl'), () => this.setDir('rtl'), 'rtl'),
+            quickimage: () => this.tbtn(IC.image, this.t('quickimage'), () => this.insertImagePlaceholder()),
+            quicktable: () => tableBtn,
+            charmap: () => this.tbtn(IC.charic, this.t('charmap'), () => this.charMap()),
+            fullscreen: () => this.tbtn(IC.fullscreen, this.t('fullscreen'), () => this.toggleFullscreen(), 'fullscreen'),
+            sourcecode: () => this.tbtn(IC.srcic, this.t('sourcecode'), () => this.sourceDlg())
+        };
+    }
+    buildToolbar() {
+        this.toolbar.innerHTML = '';
+        const spec = this.options.toolbar === true ? DEFAULT_TOOLBAR : this.options.toolbar;
+        const registry = this.buildToolbarRegistry();
+        this.parseToolbarString(spec).forEach((tokens) => {
+            const elements = [];
+            tokens.forEach((token) => {
+                const builder = registry[token];
+                if (!builder) {
+                    console.warn(`FableEditor: unknown toolbar item "${token}"`);
+                    return;
+                }
+                const result = builder();
+                if (Array.isArray(result))
+                    elements.push(...result);
+                else
+                    elements.push(result);
+            });
+            if (elements.length)
+                this.toolbar.appendChild(this.group(...elements));
+        });
+        this.syncColorSwatches(this.toolbar);
+    }
+    /* ---------------------------------------------------------- menubar */
+    mItem(label, icon, action, shortcut) {
+        return { label: this.t(label), icon, action, shortcut };
+    }
+    buildMenubar() {
+        this.menubar.innerHTML = '';
+        const menus = {
+            file: [
+                this.mItem('newdoc', IC.newic, () => {
+                    this.recordRevision();
+                    this.ed.innerHTML = '<p><br></p>';
+                    this.onChange();
+                }),
+                '|',
+                this.mItem('importword', IC.wordic, () => this.pickWordDoc()),
+                this.mItem('restoredraft', IC.draftic, () => {
+                    if (!this.restoreDraft())
+                        alert(this.t('draftempty'));
+                }),
+                this.mItem('revhistory', IC.historyic, () => this.revisionDlg()),
+                '|',
+                this.mItem('preview', IC.prevw, () => this.previewDlg()),
+                this.mItem('print', IC.printic, () => this.printDoc(), 'Ctrl+P')
+            ],
+            edit: [
+                this.mItem('undo', IC.undo, () => this.exec('undo'), 'Ctrl+Z'),
+                this.mItem('redo', IC.redo, () => this.exec('redo'), 'Ctrl+Y'),
+                '|',
+                this.mItem('cut', IC.cutic, () => this.exec('cut'), 'Ctrl+X'),
+                this.mItem('copy', IC.copyic, () => this.exec('copy'), 'Ctrl+C'),
+                this.mItem('paste', IC.pasteic, () => alert(this.t('pastehint')), 'Ctrl+V'),
+                '|',
+                this.mItem('selectall', IC.selall, () => this.exec('selectAll'), 'Ctrl+A')
+            ],
+            view: [
+                this.mItem('fullscreen', IC.fullscreen, () => this.toggleFullscreen()),
+                this.mItem('preview', IC.prevw, () => this.previewDlg()),
+                this.mItem('sourcecode', IC.srcic, () => this.sourceDlg())
+            ],
+            insert: [
+                this.mItem('link', IC.link, () => this.linkDlg()),
+                this.mItem('image', IC.image, () => this.insertImagePlaceholder()),
+                { label: this.t('inserttable'), icon: IC.tableic, action: () => this.tableGrid(this.menubar.querySelector('[data-menu-key="table"]') || this.menubar) },
+                this.mItem('hr', IC.hric, () => this.exec('insertHorizontalRule')),
+                '|',
+                this.mItem('charmap', IC.charic, () => this.charMap()),
+                this.mItem('datetime', IC.dateic, () => this.exec('insertText', new Date().toLocaleString(this.lang === 'ar' ? 'ar-AE' : 'en-GB'))),
+                '|',
+                {
+                    label: this.t('pagebreak'),
+                    icon: IC.pbic,
+                    action: () => {
+                        this.restoreSel();
+                        document.execCommand('insertHTML', false, '<hr class="pagebreak"><p><br></p>');
+                        this.onChange();
+                    }
+                },
+                this.mItem('nbsp', IC.nbspic, () => this.exec('insertText', '\u00A0'))
+            ],
+            format: [
+                this.mItem('bold', IC.bold, () => this.exec('bold'), 'Ctrl+B'),
+                this.mItem('italic', IC.italic, () => this.exec('italic'), 'Ctrl+I'),
+                this.mItem('underline', IC.underline, () => this.exec('underline'), 'Ctrl+U'),
+                this.mItem('strikethrough', IC.strikethrough, () => this.exec('strikeThrough')),
+                this.mItem('superscript', IC.superscriptic, () => this.exec('superscript')),
+                this.mItem('subscript', IC.subscriptic, () => this.exec('subscript')),
+                '|',
+                this.mItem('lowercase', IC.lowercaseic, () => this.transformCase('lower')),
+                this.mItem('uppercase', IC.uppercaseic, () => this.transformCase('upper')),
+                this.mItem('capitalize', IC.capitalizeic, () => this.transformCase('capitalize')),
+                '|',
+                this.mItem('clearformat', IC.clearformatic, () => this.exec('removeFormat'))
+            ],
+            tools: [this.mItem('sourcecode', IC.srcic, () => this.sourceDlg()), this.mItem('wordcount', IC.wcic, () => this.wordCountDlg())],
+            table: [
+                { label: this.t('inserttable'), icon: IC.tableic, subBuild: (el) => this.buildTableGridInto(el) },
+                '|',
+                {
+                    label: this.t('cell'),
+                    sub: [{ label: this.t('cellprops'), icon: IC.tableic, action: () => this.cellPropsDlg() }]
+                },
+                {
+                    label: this.t('row'),
+                    sub: [
+                        { label: this.t('rowabove'), icon: IC.rowbefore, action: () => this.tableOp('rowabove'), hover: (on) => this.setOpTarget(on ? 'row' : null) },
+                        { label: this.t('rowbelow'), icon: IC.rowafter, action: () => this.tableOp('rowbelow'), hover: (on) => this.setOpTarget(on ? 'row' : null) },
+                        { label: this.t('delrow'), icon: IC.rowdelete, action: () => this.tableOp('delrow'), hover: (on) => this.setOpTarget(on ? 'row' : null) },
+                        '|',
+                        { label: this.t('rowprops'), icon: IC.tableic, action: () => this.rowPropsDlg(), hover: (on) => this.setOpTarget(on ? 'row' : null) }
+                    ]
+                },
+                {
+                    label: this.t('column'),
+                    sub: [
+                        { label: this.t('colbefore'), icon: IC.colbefore, action: () => this.tableOp('colbefore'), hover: (on) => this.setOpTarget(on ? 'col' : null) },
+                        { label: this.t('colafter'), icon: IC.colafter, action: () => this.tableOp('colafter'), hover: (on) => this.setOpTarget(on ? 'col' : null) },
+                        { label: this.t('delcol'), icon: IC.coldelete, action: () => this.tableOp('delcol'), hover: (on) => this.setOpTarget(on ? 'col' : null) },
+                        '|',
+                        { label: this.t('colprops'), icon: IC.tableic, action: () => this.colPropsDlg(), hover: (on) => this.setOpTarget(on ? 'col' : null) }
+                    ]
+                },
+                '|',
+                {
+                    label: this.t('tablepropsttl'),
+                    icon: IC.tableic,
+                    action: () => {
+                        const cell = this.currentCell();
+                        if (!cell) {
+                            alert(this.t('nocell'));
+                            return;
+                        }
+                        this.tblActive = cell.closest('table');
+                        this.tablePropsDlg();
+                    }
+                },
+                { label: this.t('deltable'), icon: IC.tabledelete, action: () => this.tableOp('deltable') }
+            ],
+            help: [this.mItem('helpttl', IC.helpic, () => this.helpDlg(), 'Alt+0')]
+        };
+        const spec = this.options.menubar === true ? DEFAULT_MENUBAR : this.options.menubar;
+        const seen = new Set();
+        spec
+            .split(/\s+/)
+            .filter(Boolean)
+            .forEach((key) => {
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            if (!menus[key]) {
+                console.warn(`FableEditor: unknown menubar item "${key}"`);
+                return;
+            }
+            const b = document.createElement('button');
+            b.type = 'button';
+            b.textContent = this.t(key);
+            b.dataset.menuKey = key;
+            b.addEventListener('mousedown', (e) => {
+                e.preventDefault();
+                this.saveSel();
+            });
+            b.addEventListener('click', () => this.popup(b, (el) => this.menuItems(el, menus[key])));
+            this.menubar.appendChild(b);
+        });
+    }
+    /* ---------------------------------------------------------- table ops */
+    tableOp(op) {
+        this.restoreSel();
+        const s = window.getSelection();
+        if (!s)
+            return;
+        const cell = this.closestBlock(s.anchorNode)?.closest('td,th') ||
+            (s.anchorNode && s.anchorNode.nodeType === 1 ? s.anchorNode.closest?.('td,th') : null);
+        if (!cell)
+            return;
+        const row = cell.parentElement;
+        const table = cell.closest('table');
+        const idx = Array.from(row.children).indexOf(cell);
+        const newRow = () => {
+            const r = row.cloneNode(false);
+            Array.from(row.children).forEach((src) => {
+                const td = document.createElement('td');
+                /* carry the source cell's inline style so borders / padding /
+                   column widths survive on inserted rows */
+                const st = src.getAttribute('style');
+                if (st)
+                    td.setAttribute('style', st);
+                td.style.removeProperty('background-color');
+                td.innerHTML = '<br>';
+                r.appendChild(td);
+            });
+            return r;
+        };
+        if (op === 'rowabove')
+            row.before(newRow());
+        if (op === 'rowbelow')
+            row.after(newRow());
+        if (op === 'delrow') {
+            const body = row.parentElement;
+            row.remove();
+            if (!body.querySelector('tr'))
+                table.remove();
+        }
+        if (op === 'colbefore' || op === 'colafter') {
+            table.querySelectorAll('tr').forEach((tr) => {
+                const ref = tr.children[Math.min(idx, tr.children.length - 1)];
+                const td = document.createElement('td');
+                /* carry the reference cell's inline style so borders / padding
+                   survive on inserted columns; width is dropped so the new
+                   column shares the table space instead of doubling it */
+                const st = ref.getAttribute('style');
+                if (st)
+                    td.setAttribute('style', st);
+                td.style.removeProperty('width');
+                td.style.removeProperty('background-color');
+                td.innerHTML = '<br>';
+                op === 'colbefore' ? ref.before(td) : ref.after(td);
+            });
+        }
+        if (op === 'delcol') {
+            table.querySelectorAll('tr').forEach((tr) => tr.children[idx]?.remove());
+            if (!table.querySelector('td,th'))
+                table.remove();
+        }
+        if (op === 'deltable')
+            table.remove();
+        this.onChange();
+        this.positionTableHandles();
+    }
+    applyTableProps(table, vals) {
+        if (vals.width)
+            table.style.width = /^\d+$/.test(vals.width) ? vals.width + 'px' : vals.width;
+        else
+            table.style.removeProperty('width');
+        const cells = Array.from(table.querySelectorAll('td,th'));
+        if (vals.cellpadding !== '')
+            cells.forEach((c) => (c.style.padding = vals.cellpadding + 'px'));
+        else
+            cells.forEach((c) => c.style.removeProperty('padding'));
+        if (vals.cellspacing !== '') {
+            table.style.borderCollapse = 'separate';
+            table.style.borderSpacing = vals.cellspacing + 'px';
+        }
+        else {
+            table.style.borderCollapse = 'collapse';
+            table.style.removeProperty('border-spacing');
+        }
+        if (vals.border !== '' && +vals.border > 0) {
+            table.style.border = vals.border + 'px solid #b9c2cc';
+            cells.forEach((c) => (c.style.border = vals.border + 'px solid #b9c2cc'));
+        }
+        else {
+            table.style.removeProperty('border');
+            cells.forEach((c) => c.style.removeProperty('border'));
+        }
+        table.style.removeProperty('margin-left');
+        table.style.removeProperty('margin-right');
+        if (vals.align === 'center') {
+            table.style.marginLeft = 'auto';
+            table.style.marginRight = 'auto';
+        }
+        else if (vals.align === 'right') {
+            table.style.marginLeft = 'auto';
+            table.style.marginRight = '0';
+        }
+        else if (vals.align === 'left') {
+            table.style.marginLeft = '0';
+            table.style.marginRight = 'auto';
+        }
+    }
+    tablePropsDlg() {
+        const table = this.tblActive;
+        if (!table)
+            return;
+        let wIn;
+        let padIn;
+        let spIn;
+        let bIn;
+        let alignSel;
+        const rowStyle = 'display:flex;align-items:center;gap:10px;margin:10px 0';
+        const lblStyle = 'width:120px;color:#556;flex:none';
+        const inputStyle = 'flex:1;border:1px solid #cfd6df;border-radius:6px;padding:7px 9px;font:14px inherit';
+        const firstCell = table.querySelector('td,th');
+        const curWidth = table.style.width || '';
+        const curPad = firstCell && firstCell.style.padding ? parseFloat(firstCell.style.padding) : '';
+        const curSp = table.style.borderSpacing ? parseFloat(table.style.borderSpacing) : '';
+        const curBorder = table.style.borderWidth ? parseFloat(table.style.borderWidth) : '';
+        const ml = table.style.marginLeft;
+        const mr = table.style.marginRight;
+        const curAlign = ml === 'auto' && mr === 'auto' ? 'center' : ml === 'auto' ? 'right' : mr === 'auto' && ml === '0' ? 'left' : '';
+        this.dialog(this.t('tablepropsttl'), (body) => {
+            const mk = (labelKey, el) => {
+                const row = document.createElement('div');
+                row.style.cssText = rowStyle;
+                const lbl = document.createElement('span');
+                lbl.style.cssText = lblStyle;
+                lbl.textContent = this.t(labelKey);
+                row.append(lbl, el);
+                body.appendChild(row);
+            };
+            wIn = document.createElement('input');
+            wIn.type = 'text';
+            wIn.style.cssText = inputStyle;
+            wIn.placeholder = 'e.g. 600px or 100%';
+            wIn.value = curWidth;
+            mk('tblwidth', wIn);
+            padIn = document.createElement('input');
+            padIn.type = 'number';
+            padIn.min = '0';
+            padIn.style.cssText = inputStyle;
+            padIn.value = String(curPad);
+            mk('tblcellpadding', padIn);
+            spIn = document.createElement('input');
+            spIn.type = 'number';
+            spIn.min = '0';
+            spIn.style.cssText = inputStyle;
+            spIn.value = String(curSp);
+            mk('tblcellspacing', spIn);
+            bIn = document.createElement('input');
+            bIn.type = 'number';
+            bIn.min = '0';
+            bIn.style.cssText = inputStyle;
+            bIn.value = String(curBorder);
+            mk('tblborder', bIn);
+            alignSel = document.createElement('select');
+            alignSel.style.cssText = inputStyle;
+            [
+                ['', 'alignnone'],
+                ['left', 'alignleft'],
+                ['center', 'aligncenter'],
+                ['right', 'alignright']
+            ].forEach(([v, k]) => {
+                const o = document.createElement('option');
+                o.value = v;
+                o.textContent = this.t(k);
+                if (v === curAlign)
+                    o.selected = true;
+                alignSel.appendChild(o);
+            });
+            mk('tblalign', alignSel);
+        }, [
+            { label: this.t('cancel'), action: () => this.closeDlg() },
+            {
+                label: this.t('save'),
+                primary: true,
+                action: () => {
+                    this.applyTableProps(table, {
+                        width: wIn.value.trim(),
+                        cellpadding: padIn.value.trim(),
+                        cellspacing: spIn.value.trim(),
+                        border: bIn.value.trim(),
+                        align: alignSel.value
+                    });
+                    this.closeDlg();
+                    this.onChange();
+                    this.positionTableHandles();
+                }
+            }
+        ]);
+    }
+    /* ------------------------------------------- cell / row / column props */
+    currentCell() {
+        let node = this.savedRange ? this.savedRange.startContainer : null;
+        if (!node || !this.ed.contains(node)) {
+            const s = window.getSelection();
+            node = s && this.ed.contains(s.anchorNode) ? s.anchorNode : null;
+        }
+        while (node && node !== this.ed) {
+            if (node.nodeType === 1 && /^(TD|TH)$/.test(node.tagName)) {
+                return node;
+            }
+            node = node.parentNode;
+        }
+        return null;
+    }
+    toHexColor(c) {
+        if (/^#[0-9a-fA-F]{6}$/.test(c))
+            return c;
+        const m = /rgba?\((\d+)[,\s]+(\d+)[,\s]+(\d+)/.exec(c);
+        if (!m)
+            return '';
+        return '#' + [m[1], m[2], m[3]].map((n) => (+n).toString(16).padStart(2, '0')).join('');
+    }
+    formRow(body, label, el) {
+        const row = document.createElement('div');
+        row.style.cssText = 'display:flex;align-items:center;gap:10px;margin:10px 0;min-width:360px';
+        const lbl = document.createElement('span');
+        lbl.style.cssText = 'width:120px;color:#556;flex:none';
+        lbl.textContent = label;
+        row.append(lbl, el);
+        body.appendChild(row);
+    }
+    formInput(value, placeholder = '') {
+        const i = document.createElement('input');
+        i.type = 'text';
+        i.style.cssText = 'flex:1;border:1px solid #cfd6df;border-radius:6px;padding:7px 9px;font:14px inherit;min-width:0';
+        i.value = value;
+        i.placeholder = placeholder;
+        return i;
+    }
+    formSelect(options, cur) {
+        const sel = document.createElement('select');
+        sel.style.cssText = 'flex:1;border:1px solid #cfd6df;border-radius:6px;padding:7px 9px;font:14px inherit;background:#fff';
+        options.forEach(([v, label]) => {
+            const o = document.createElement('option');
+            o.value = v;
+            o.textContent = label;
+            if (v === cur)
+                o.selected = true;
+            sel.appendChild(o);
+        });
+        return sel;
+    }
+    formBg(cur) {
+        const wrap = document.createElement('div');
+        wrap.style.cssText = 'flex:1;display:flex;align-items:center;gap:8px';
+        const hex = this.toHexColor(cur);
+        const color = document.createElement('input');
+        color.type = 'color';
+        color.value = hex || '#ffffff';
+        color.style.cssText = 'width:36px;height:29px;border:1px solid #cfd6df;border-radius:4px;padding:1px;background:none;cursor:pointer';
+        const lbl = document.createElement('label');
+        lbl.style.cssText = 'display:flex;align-items:center;gap:6px;cursor:pointer;color:#556';
+        const fill = document.createElement('input');
+        fill.type = 'checkbox';
+        fill.checked = !!hex;
+        lbl.append(fill, document.createTextNode(this.t('fill')));
+        color.addEventListener('input', () => (fill.checked = true));
+        wrap.append(color, lbl);
+        return { wrap, color, fill };
+    }
+    setOrClear(el, prop, val) {
+        if (val)
+            el.style.setProperty(prop, /^(width|height)$/.test(prop) && /^\d+$/.test(val) ? val + 'px' : val);
+        else
+            el.style.removeProperty(prop);
+    }
+    cellPropsDlg() {
+        const cell = this.currentCell();
+        if (!cell) {
+            alert(this.t('nocell'));
+            return;
+        }
+        let wIn;
+        let hIn;
+        let alignSel;
+        let vSel;
+        let bg;
+        this.dialog(this.t('cellprops').replace('…', ''), (body) => {
+            wIn = this.formInput(cell.style.width, 'e.g. 120px / 25%');
+            this.formRow(body, this.t('tblwidth'), wIn);
+            hIn = this.formInput(cell.style.height, 'e.g. 40px');
+            this.formRow(body, this.t('tblheight'), hIn);
+            alignSel = this.formSelect([
+                ['', this.t('alignnone')],
+                ['left', this.t('alignleft')],
+                ['center', this.t('aligncenter')],
+                ['right', this.t('alignright')]
+            ], cell.style.textAlign || '');
+            this.formRow(body, this.t('tblalign'), alignSel);
+            vSel = this.formSelect([
+                ['', this.t('alignnone')],
+                ['top', this.t('valigntop')],
+                ['middle', this.t('valignmiddle')],
+                ['bottom', this.t('valignbottom')]
+            ], cell.style.verticalAlign || '');
+            this.formRow(body, this.t('valign'), vSel);
+            bg = this.formBg(cell.style.backgroundColor || '');
+            this.formRow(body, this.t('backcolor'), bg.wrap);
+        }, [
+            { label: this.t('cancel'), action: () => this.closeDlg() },
+            {
+                label: this.t('save'),
+                primary: true,
+                action: () => {
+                    this.setOrClear(cell, 'width', wIn.value.trim());
+                    this.setOrClear(cell, 'height', hIn.value.trim());
+                    this.setOrClear(cell, 'text-align', alignSel.value);
+                    this.setOrClear(cell, 'vertical-align', vSel.value);
+                    this.setOrClear(cell, 'background-color', bg.fill.checked ? bg.color.value : '');
+                    this.closeDlg();
+                    this.onChange();
+                    this.positionTableHandles();
+                }
+            }
+        ]);
+    }
+    rowPropsDlg() {
+        const cell = this.currentCell();
+        if (!cell) {
+            alert(this.t('nocell'));
+            return;
+        }
+        const row = cell.parentElement;
+        let hIn;
+        let bg;
+        this.dialog(this.t('rowprops').replace('…', ''), (body) => {
+            hIn = this.formInput(row.style.height, 'e.g. 40px');
+            this.formRow(body, this.t('tblheight'), hIn);
+            bg = this.formBg(row.style.backgroundColor || '');
+            this.formRow(body, this.t('backcolor'), bg.wrap);
+        }, [
+            { label: this.t('cancel'), action: () => this.closeDlg() },
+            {
+                label: this.t('save'),
+                primary: true,
+                action: () => {
+                    this.setOrClear(row, 'height', hIn.value.trim());
+                    this.setOrClear(row, 'background-color', bg.fill.checked ? bg.color.value : '');
+                    this.closeDlg();
+                    this.onChange();
+                    this.positionTableHandles();
+                }
+            }
+        ]);
+    }
+    colPropsDlg() {
+        const cell = this.currentCell();
+        if (!cell) {
+            alert(this.t('nocell'));
+            return;
+        }
+        const row = cell.parentElement;
+        const table = cell.closest('table');
+        const idx = Array.from(row.children).indexOf(cell);
+        const colCells = Array.from(table.rows)
+            .map((r) => r.cells[idx])
+            .filter(Boolean);
+        let wIn;
+        let bg;
+        this.dialog(this.t('colprops').replace('…', ''), (body) => {
+            wIn = this.formInput(cell.style.width, 'e.g. 120px / 25%');
+            this.formRow(body, this.t('tblwidth'), wIn);
+            bg = this.formBg(cell.style.backgroundColor || '');
+            this.formRow(body, this.t('backcolor'), bg.wrap);
+        }, [
+            { label: this.t('cancel'), action: () => this.closeDlg() },
+            {
+                label: this.t('save'),
+                primary: true,
+                action: () => {
+                    colCells.forEach((c) => {
+                        this.setOrClear(c, 'width', wIn.value.trim());
+                        this.setOrClear(c, 'background-color', bg.fill.checked ? bg.color.value : '');
+                    });
+                    this.closeDlg();
+                    this.onChange();
+                    this.positionTableHandles();
+                }
+            }
+        ]);
+    }
+    /* ---------------------------------------------------------- dialogs */
+    closeDlg() {
+        if (this.dlgOvl) {
+            this.dlgOvl.remove();
+            this.dlgOvl = null;
+        }
+    }
+    dialog(title, bodyBuild, buttons) {
+        this.closeDlg();
+        this.closePop();
+        this.dlgOvl = document.createElement('div');
+        this.dlgOvl.className = 'ovl';
+        const d = document.createElement('div');
+        d.className = 'dlg';
+        d.dir = this.dir();
+        d.innerHTML = `<header><span>${title}</span><button type="button">×</button></header>
+                   <div class="body"></div><footer></footer>`;
+        d.querySelector('header button').onclick = () => this.closeDlg();
+        bodyBuild(d.querySelector('.body'));
+        (buttons || [{ label: this.t('close'), primary: true, action: () => this.closeDlg() }]).forEach((b) => {
+            const btn = document.createElement('button');
+            btn.type = 'button';
+            btn.textContent = b.label;
+            if (b.primary)
+                btn.className = 'pri';
+            btn.onclick = b.action;
+            d.querySelector('footer').appendChild(btn);
+        });
+        this.dlgOvl.appendChild(d);
+        this.dlgOvl.addEventListener('mousedown', (e) => {
+            if (e.target === this.dlgOvl)
+                this.closeDlg();
+        });
+        document.body.appendChild(this.dlgOvl);
+    }
+    sourceDlg() {
+        let ta;
+        this.dialog(this.t('srcttl'), (body) => {
+            ta = document.createElement('textarea');
+            ta.value = this.ed.innerHTML.replace(/></g, '>\n<');
+            body.appendChild(ta);
+        }, [
+            { label: this.t('cancel'), action: () => this.closeDlg() },
+            {
+                label: this.t('save'),
+                primary: true,
+                action: () => {
+                    this.ed.innerHTML = ta.value;
+                    this.closeDlg();
+                    this.onChange();
+                }
+            }
+        ]);
+    }
+    helpDlg() {
+        this.dialog(this.t('helpttl'), (body) => {
+            const rows = [
+                ['Ctrl+B', this.t('bold')],
+                ['Ctrl+I', this.t('italic')],
+                ['Ctrl+U', this.t('underline')],
+                ['Ctrl+Z', this.t('undo')],
+                ['Ctrl+Y', this.t('redo')],
+                ['Ctrl+A', this.t('selectall')],
+                ['Alt+0', this.t('helpttl')]
+            ];
+            body.innerHTML = `<p style="color:#556">${this.t('shortcuts')}</p>
+        <table class="kbd">${rows.map((r) => `<tr><td>${r[1]}</td><td><kbd>${r[0]}</kbd></td></tr>`).join('')}</table>`;
+        });
+    }
+    wordCountDlg() {
+        this.dialog(this.t('wcttl'), (body) => {
+            body.innerHTML = `<table class="kbd">
+        <tr><td>${this.t('wcwords')}</td><td>${this.countWords()}</td></tr>
+        <tr><td>${this.t('wcchars')}</td><td>${this.ed.textContent?.replace(/\s/g, '').length ?? 0}</td></tr></table>`;
+        });
+    }
+    previewDlg() {
+        this.dialog(this.t('previewttl'), (body) => {
+            const box = document.createElement('div');
+            box.style.cssText =
+                'width:640px;max-width:78vw;max-height:52vh;overflow:auto;border:1px solid #e3e3e3;border-radius:6px;padding:14px;font-family:Helvetica,Arial,sans-serif;font-size:14px';
+            box.innerHTML = this.ed.innerHTML;
+            body.appendChild(box);
+        });
+    }
+    charMap() {
+        this.dialog(this.t('charmap').replace('…', ''), (body) => {
+            const g = document.createElement('div');
+            g.className = 'chgrid';
+            CHARS.forEach((ch) => {
+                const b = document.createElement('button');
+                b.textContent = ch;
+                b.onclick = () => {
+                    this.closeDlg();
+                    this.exec('insertText', ch);
+                };
+                g.appendChild(b);
+            });
+            body.appendChild(g);
+        });
+    }
+    printDoc() {
+        const w = window.open('', '_blank');
+        if (!w)
+            return;
+        w.document.write(`<html dir="${this.dir()}"><body style="font-family:Helvetica,Arial,sans-serif;font-size:14px">${this.ed.innerHTML}</body></html>`);
+        w.document.close();
+        w.focus();
+        w.print();
+    }
+    pickImage() {
+        this.imgInput.value = '';
+        this.imgInput.click();
+    }
+    /* ---------------------------------------------- image upload placeholder */
+    insertImagePlaceholder() {
+        this.restoreSel();
+        const id = 'img-ph-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+        document.execCommand('insertHTML', false, `<div class="img-ph" id="${id}" contenteditable="false">${IC.image}<span>${this.t('dropimage')}</span></div>`);
+        const ph = this.ed.querySelector('#' + id);
+        if (ph) {
+            ph.removeAttribute('id');
+            this.selectImgPlaceholder(ph);
+        }
+        this.onChange();
+    }
+    clearImgPlaceholderSel() {
+        this.phCtx?.remove();
+        this.phCtx = null;
+        this.phActive?.classList.remove('active');
+        this.phActive = null;
+    }
+    selectImgPlaceholder(ph) {
+        if (this.phActive === ph)
+            return;
+        this.clearImgPlaceholderSel();
+        this.phActive = ph;
+        ph.classList.add('active');
+        this.phCtx = document.createElement('div');
+        this.phCtx.className = 'imgctx img-ph-ctx';
+        this.phCtx.dir = this.dir();
+        document.body.appendChild(this.phCtx);
+        this.renderPhCtxButtons();
+    }
+    renderPhCtxButtons() {
+        const el = this.phCtx;
+        if (!el)
+            return;
+        el.innerHTML = '';
+        el.append(this.ctxBtn(IC.uploadic, this.t('uploadimg'), () => {
+            this.phUploadTarget = this.phActive;
+            this.pickImage();
+        }), this.ctxBtn(IC.link, this.t('imagelink'), () => this.renderPhCtxUrlInput()));
+        this.positionImgPhCtx();
+    }
+    renderPhCtxUrlInput() {
+        const el = this.phCtx;
+        if (!el)
+            return;
+        el.innerHTML = '';
+        const inp = document.createElement('input');
+        inp.type = 'url';
+        inp.className = 'urlinp';
+        inp.placeholder = this.t('imageurlph');
+        const ok = document.createElement('button');
+        ok.type = 'button';
+        ok.className = 'txtbtn';
+        ok.textContent = this.t('insertimg');
+        const submit = () => {
+            const url = inp.value.trim();
+            const ph = this.phActive;
+            if (!ph)
+                return;
+            if (!/^(https?:|data:image\/|blob:)/i.test(url)) {
+                inp.classList.add('err');
+                inp.focus();
+                return;
+            }
+            ok.disabled = true;
+            inp.disabled = true;
+            /* only place the image once the URL actually loads, so the user
+               gets a working preview instead of a broken-image icon */
+            const probe = new Image();
+            probe.onload = () => this.replacePlaceholderWithImage(ph, url, '');
+            probe.onerror = () => {
+                ok.disabled = false;
+                inp.disabled = false;
+                inp.classList.add('err');
+                inp.focus();
+            };
+            probe.src = url;
+        };
+        ok.addEventListener('click', submit);
+        inp.addEventListener('input', () => inp.classList.remove('err'));
+        inp.addEventListener('keydown', (e) => {
+            if (e.key === 'Enter') {
+                e.preventDefault();
+                submit();
+            }
+            else if (e.key === 'Escape') {
+                e.stopPropagation();
+                this.renderPhCtxButtons();
+            }
+        });
+        el.append(inp, ok);
+        this.positionImgPhCtx();
+        inp.focus();
+    }
+    readImageFileInto(file, ph) {
+        if (ph.classList.contains('uploading'))
+            return;
+        if (this.imageUploadHandler) {
+            this.uploadImageFile(file, ph);
+            return;
+        }
+        const fr = new FileReader();
+        fr.onload = () => {
+            if (this.ed.contains(ph))
+                this.replacePlaceholderWithImage(ph, fr.result, file.name.replace(/"/g, ''));
+        };
+        fr.readAsDataURL(file);
+    }
+    /** Runs the host-supplied imageUploadHandler instead of inlining base64,
+     *  so apps can route the file to S3 / Azure Blob / their own server. */
+    uploadImageFile(file, ph) {
+        const title = file.name.replace(/"/g, '');
+        ph.classList.remove('upload-error');
+        ph.classList.add('uploading');
+        const span = ph.querySelector('span');
+        if (span)
+            span.textContent = this.t('uploading');
+        this.imageUploadHandler(file)
+            .then((url) => {
+            if (!this.ed.contains(ph))
+                return;
+            this.replacePlaceholderWithImage(ph, url, title);
+        })
+            .catch((err) => {
+            if (!this.ed.contains(ph))
+                return;
+            ph.classList.remove('uploading');
+            ph.classList.add('upload-error');
+            if (span)
+                span.textContent = this.t('uploadfailed');
+            this.onImageUploadError?.(err, file);
+        });
+    }
+    replacePlaceholderWithImage(ph, src, title) {
+        const img = document.createElement('img');
+        img.src = src;
+        img.alt = '';
+        if (title)
+            img.title = title;
+        ph.replaceWith(img);
+        if (this.phActive === ph)
+            this.clearImgPlaceholderSel();
+        this.refreshState();
+        this.onChange();
+    }
+    positionImgPhCtx() {
+        if (this.phActive && !document.body.contains(this.phActive)) {
+            this.clearImgPlaceholderSel();
+            return;
+        }
+        if (!this.phActive || !this.phCtx)
+            return;
+        const r = this.phActive.getBoundingClientRect();
+        const cw = this.phCtx.offsetWidth;
+        const ch = this.phCtx.offsetHeight;
+        let cx = r.left + scrollX + (r.width - cw) / 2;
+        cx = Math.max(8 + scrollX, Math.min(cx, scrollX + innerWidth - cw - 8));
+        let cy = r.bottom + scrollY + 8;
+        if (r.bottom + 8 + ch > innerHeight - 4)
+            cy = Math.max(this.ctxMinTop(), r.top + scrollY - ch - 8);
+        this.phCtx.style.left = cx + 'px';
+        this.phCtx.style.top = cy + 'px';
+    }
+    pickWordDoc() {
+        this.docInput.value = '';
+        this.docInput.click();
+    }
+    /* ---------------------------------------------------------- fullscreen */
+    toggleFullscreen() {
+        this.shell.classList.toggle('fullscreen');
+        const b = this.toolbar.querySelector('[data-id=fullscreen]');
+        b?.classList.toggle('on', this.shell.classList.contains('fullscreen'));
+        this.positionTableHandles();
+    }
+    /* ---------------------------------------------------------- table resize */
+    clearTableHandles() {
+        this.tblCorner?.remove();
+        this.tblCorner = null;
+        this.tblColBars.forEach((b) => b.remove());
+        this.tblColBars = [];
+        this.tblCtx?.remove();
+        this.tblCtx = null;
+        this.tblCellMark?.remove();
+        this.tblCellMark = null;
+        this.tblOpMark?.remove();
+        this.tblOpMark = null;
+        this.tblOpMarkKind = null;
+        this.tblActive?.classList.remove('tbl-selected');
+        this.tblActive = null;
+    }
+    /** Blue outline around the cell that holds the caret, so it is clear
+        which cell / row / column the table operations will target. */
+    positionCellMarker() {
+        if (!this.tblCellMark)
+            return;
+        const cell = this.currentCell();
+        if (!cell || !this.tblActive || cell.closest('table') !== this.tblActive) {
+            this.tblCellMark.style.display = 'none';
+            return;
+        }
+        const r = cell.getBoundingClientRect();
+        this.tblCellMark.style.display = 'block';
+        this.tblCellMark.style.left = r.left + scrollX + 'px';
+        this.tblCellMark.style.top = r.top + scrollY + 'px';
+        this.tblCellMark.style.width = r.width + 'px';
+        this.tblCellMark.style.height = r.height + 'px';
+    }
+    /** Dashed highlight over the whole row / column an operation targets,
+        shown while its button or menu item is hovered. */
+    setOpTarget(kind) {
+        this.tblOpMarkKind = kind;
+        this.positionOpMark();
+    }
+    positionOpMark() {
+        const kind = this.tblOpMarkKind;
+        const cell = kind ? this.currentCell() : null;
+        if (!kind || !cell || !this.tblActive || cell.closest('table') !== this.tblActive) {
+            this.tblOpMark?.remove();
+            this.tblOpMark = null;
+            return;
+        }
+        if (!this.tblOpMark) {
+            this.tblOpMark = document.createElement('div');
+            this.tblOpMark.className = 'tbl-opmark';
+            document.body.appendChild(this.tblOpMark);
+        }
+        const tr = this.tblActive.getBoundingClientRect();
+        const cr = cell.getBoundingClientRect();
+        const rr = cell.parentElement.getBoundingClientRect();
+        const left = kind === 'row' ? rr.left : cr.left;
+        const top = kind === 'row' ? rr.top : tr.top;
+        const width = kind === 'row' ? rr.width : cr.width;
+        const height = kind === 'row' ? rr.height : tr.height;
+        this.tblOpMark.style.left = left + scrollX + 'px';
+        this.tblOpMark.style.top = top + scrollY + 'px';
+        this.tblOpMark.style.width = width + 'px';
+        this.tblOpMark.style.height = height + 'px';
+    }
+    /** Lowest allowed top for floating context toolbars — keeps them from
+        covering the editor menubar/toolbar when the target sits on the first line. */
+    ctxMinTop() {
+        return Math.max(scrollY + 4, this.ed.getBoundingClientRect().top + scrollY - 2);
+    }
+    ctxBtn(icon, tip, fn, id) {
+        const b = document.createElement('button');
+        b.type = 'button';
+        b.title = tip;
+        b.innerHTML = icon;
+        if (id)
+            b.dataset.id = id;
+        b.addEventListener('mousedown', (e) => e.preventDefault());
+        b.addEventListener('click', fn);
+        return b;
+    }
+    ctxSep() {
+        const s = document.createElement('div');
+        s.className = 'sep';
+        return s;
+    }
+    buildTableCtxToolbar() {
+        const el = document.createElement('div');
+        el.className = 'tblctx';
+        el.dir = this.dir();
+        /* hovering a row/column button highlights the row/column it targets */
+        const hl = (b, kind) => {
+            b.addEventListener('mouseenter', () => this.setOpTarget(kind));
+            b.addEventListener('mouseleave', () => this.setOpTarget(null));
+            return b;
+        };
+        el.append(hl(this.ctxBtn(IC.rowbefore, this.t('rowabove'), () => this.tableOp('rowabove')), 'row'), hl(this.ctxBtn(IC.rowafter, this.t('rowbelow'), () => this.tableOp('rowbelow')), 'row'), hl(this.ctxBtn(IC.rowdelete, this.t('delrow'), () => this.tableOp('delrow')), 'row'), this.ctxSep(), hl(this.ctxBtn(IC.colbefore, this.t('colbefore'), () => this.tableOp('colbefore')), 'col'), hl(this.ctxBtn(IC.colafter, this.t('colafter'), () => this.tableOp('colafter')), 'col'), hl(this.ctxBtn(IC.coldelete, this.t('delcol'), () => this.tableOp('delcol')), 'col'), this.ctxSep(), this.ctxBtn(IC.tabledelete, this.t('deltable'), () => this.tableOp('deltable')), this.ctxBtn(IC.tableic, this.t('tablepropsttl'), () => this.tablePropsDlg()));
+        document.body.appendChild(el);
+        return el;
+    }
+    positionTableHandles() {
+        if (!this.tblActive || !document.body.contains(this.tblActive)) {
+            this.clearTableHandles();
+            return;
+        }
+        const rtl = this.ed.getAttribute('dir') === 'rtl';
+        const r = this.tblActive.getBoundingClientRect();
+        const top = r.top + scrollY;
+        const left = r.left + scrollX;
+        const right = r.right + scrollX;
+        const bottom = r.bottom + scrollY;
+        if (this.tblCorner) {
+            this.tblCorner.style.top = bottom - 5 + 'px';
+            this.tblCorner.style.left = (rtl ? left - 5 : right - 5) + 'px';
+            this.tblCorner.style.cursor = rtl ? 'nesw-resize' : 'nwse-resize';
+        }
+        if (this.tblCtx) {
+            const cw = this.tblCtx.offsetWidth;
+            const ch = this.tblCtx.offsetHeight;
+            let cx = left + (right - left) / 2 - cw / 2;
+            cx = Math.max(8 + scrollX, Math.min(cx, scrollX + innerWidth - cw - 8));
+            let cy = top - ch - 8;
+            if (cy < this.ctxMinTop())
+                cy = bottom + 8;
+            this.tblCtx.style.left = cx + 'px';
+            this.tblCtx.style.top = cy + 'px';
+        }
+        this.tblColBars.forEach((b) => b.remove());
+        this.tblColBars = [];
+        const row = this.tblActive.rows[0];
+        if (row) {
+            for (let i = 0; i < row.cells.length - 1; i++) {
+                const rA = row.cells[i].getBoundingClientRect();
+                const boundaryX = (rtl ? rA.left : rA.right) + scrollX;
+                const bar = document.createElement('div');
+                bar.className = 'tbl-colbar';
+                bar.style.top = top + 'px';
+                bar.style.left = boundaryX + 'px';
+                bar.style.height = bottom - top + 'px';
+                document.body.appendChild(bar);
+                bar.addEventListener('mousedown', (e) => this.startColBarDrag(e, i));
+                this.tblColBars.push(bar);
+            }
+        }
+        this.positionCellMarker();
+        this.positionOpMark();
+    }
+    selectTableForResize(table) {
+        if (this.tblActive === table)
+            return;
+        this.clearTableHandles();
+        this.tblActive = table;
+        table.classList.add('tbl-selected');
+        this.tblCorner = document.createElement('div');
+        this.tblCorner.className = 'tbl-handle';
+        document.body.appendChild(this.tblCorner);
+        this.tblCorner.addEventListener('mousedown', (e) => this.startTableCornerDrag(e));
+        this.tblCellMark = document.createElement('div');
+        this.tblCellMark.className = 'tbl-cellmark';
+        this.tblCellMark.style.display = 'none';
+        document.body.appendChild(this.tblCellMark);
+        this.tblCtx = this.buildTableCtxToolbar();
+        this.positionTableHandles();
+    }
+    withNoTextSelect(fn) {
+        const prev = document.body.style.userSelect;
+        document.body.style.userSelect = 'none';
+        fn(() => {
+            document.body.style.userSelect = prev;
+        });
+    }
+    startTableCornerDrag(e) {
+        e.preventDefault();
+        const table = this.tblActive;
+        if (!table)
+            return;
+        const rtl = this.ed.getAttribute('dir') === 'rtl';
+        const startX = e.clientX;
+        const startW = table.getBoundingClientRect().width;
+        table.style.tableLayout = table.style.tableLayout || 'fixed';
+        this.withNoTextSelect((restore) => {
+            const mv = (ev) => {
+                const dx = rtl ? -(ev.clientX - startX) : ev.clientX - startX;
+                table.style.width = Math.max(60, Math.round(startW + dx)) + 'px';
+                this.positionTableHandles();
+            };
+            const up = () => {
+                window.removeEventListener('mousemove', mv);
+                window.removeEventListener('mouseup', up);
+                restore();
+                this.onChange();
+            };
+            window.addEventListener('mousemove', mv);
+            window.addEventListener('mouseup', up);
+        });
+    }
+    startColBarDrag(e, i) {
+        e.preventDefault();
+        e.stopPropagation();
+        const table = this.tblActive;
+        if (!table)
+            return;
+        const rtl = this.ed.getAttribute('dir') === 'rtl';
+        const rows = Array.from(table.rows);
+        const colA = rows.map((r) => r.cells[i]).filter(Boolean);
+        const colB = rows.map((r) => r.cells[i + 1]).filter(Boolean);
+        if (!colA.length || !colB.length)
+            return;
+        const startX = e.clientX;
+        const wA = colA[0].getBoundingClientRect().width;
+        const wB = colB[0].getBoundingClientRect().width;
+        table.style.tableLayout = 'fixed';
+        this.withNoTextSelect((restore) => {
+            const mv = (ev) => {
+                const dx = (rtl ? -1 : 1) * (ev.clientX - startX);
+                colA.forEach((c) => (c.style.width = Math.max(24, Math.round(wA + dx)) + 'px'));
+                colB.forEach((c) => (c.style.width = Math.max(24, Math.round(wB - dx)) + 'px'));
+                this.positionTableHandles();
+            };
+            const up = () => {
+                window.removeEventListener('mousemove', mv);
+                window.removeEventListener('mouseup', up);
+                restore();
+                this.onChange();
+            };
+            window.addEventListener('mousemove', mv);
+            window.addEventListener('mouseup', up);
+        });
+    }
+    /* ---------------------------------------------------------- image toolbar / resize */
+    cancelImgHide() {
+        if (this.imgHideTimer != null) {
+            window.clearTimeout(this.imgHideTimer);
+            this.imgHideTimer = null;
+        }
+    }
+    scheduleImgHide() {
+        this.cancelImgHide();
+        this.imgHideTimer = window.setTimeout(() => this.clearImageHandles(), 250);
+    }
+    clearImageHandles() {
+        this.cancelImgHide();
+        this.imgHandles.forEach((h) => h.remove());
+        this.imgHandles = [];
+        this.imgCtx?.remove();
+        this.imgCtx = null;
+        this.imgActive?.classList.remove('img-selected');
+        this.imgActive = null;
+    }
+    selectImage(img) {
+        if (this.imgActive === img)
+            return;
+        this.clearImageHandles();
+        this.imgActive = img;
+        img.classList.add('img-selected');
+        this.imgHandles = IMG_CORNERS.map((corner) => {
+            const h = document.createElement('div');
+            h.className = 'img-handle img-handle-' + corner;
+            h.dataset.corner = corner;
+            h.addEventListener('mousedown', (e) => this.startImageResizeDrag(e, corner));
+            h.addEventListener('mouseenter', () => this.cancelImgHide());
+            h.addEventListener('mouseleave', () => this.scheduleImgHide());
+            document.body.appendChild(h);
+            return h;
+        });
+        this.imgCtx = this.buildImageCtxToolbar(img);
+        this.positionImageHandles();
+    }
+    buildImageCtxToolbar(img) {
+        const el = document.createElement('div');
+        el.className = 'imgctx';
+        el.dir = this.dir();
+        const rebuild = () => {
+            const rebuilt = this.buildImageCtxToolbar(img);
+            this.imgCtx?.replaceWith(rebuilt);
+            this.imgCtx = rebuilt;
+            this.positionImageHandles();
+        };
+        const align = (a) => {
+            this.setImageAlign(img, a);
+            rebuild();
+        };
+        const isLeft = img.style.float === 'left';
+        const isRight = img.style.float === 'right';
+        const isCenter = !isLeft && !isRight && img.style.marginLeft === 'auto' && img.style.marginRight === 'auto';
+        const mkBtn = (icon, tip, on, fn) => {
+            const b = this.ctxBtn(icon, tip, fn);
+            b.classList.toggle('on', on);
+            return b;
+        };
+        el.append(mkBtn(IC.alignleft, this.t('alignleft'), isLeft, () => align('left')), mkBtn(IC.aligncenter, this.t('aligncenter'), isCenter, () => align('center')), mkBtn(IC.alignright, this.t('alignright'), isRight, () => align('right')), this.ctxSep(), mkBtn(IC.rotateleft, this.t('rotateleft'), false, () => {
+            this.rotateImage(img, -90);
+            rebuild();
+        }), mkBtn(IC.rotateright, this.t('rotateright'), false, () => {
+            this.rotateImage(img, 90);
+            rebuild();
+        }), this.ctxSep(), mkBtn(IC.fliphorizontal, this.t('fliphorizontal'), img.dataset.flipx === '1', () => {
+            this.flipImage(img, 'x');
+            rebuild();
+        }), mkBtn(IC.flipvertical, this.t('flipvertical'), img.dataset.flipy === '1', () => {
+            this.flipImage(img, 'y');
+            rebuild();
+        }), this.ctxSep(), mkBtn(IC.trash, this.t('deleteimg'), false, () => {
+            img.remove();
+            this.clearImageHandles();
+            this.onChange();
+        }));
+        el.addEventListener('mousedown', (e) => e.preventDefault());
+        el.addEventListener('mouseenter', () => this.cancelImgHide());
+        el.addEventListener('mouseleave', () => this.scheduleImgHide());
+        document.body.appendChild(el);
+        return el;
+    }
+    setImageAlign(img, align) {
+        img.style.float = '';
+        img.style.display = '';
+        img.style.marginLeft = '';
+        img.style.marginRight = '';
+        img.style.marginBottom = '';
+        if (align === 'left') {
+            img.style.float = 'left';
+            img.style.marginInlineEnd = '1em';
+            img.style.marginBottom = '0.5em';
+        }
+        else if (align === 'right') {
+            img.style.float = 'right';
+            img.style.marginInlineStart = '1em';
+            img.style.marginBottom = '0.5em';
+        }
+        else {
+            img.style.display = 'block';
+            img.style.marginLeft = 'auto';
+            img.style.marginRight = 'auto';
+        }
+        this.onChange();
+    }
+    applyImgTransform(img) {
+        const rot = parseInt(img.dataset.rotate || '0', 10);
+        const fx = img.dataset.flipx === '1' ? -1 : 1;
+        const fy = img.dataset.flipy === '1' ? -1 : 1;
+        img.style.transform = rot || fx < 0 || fy < 0 ? `rotate(${rot}deg) scale(${fx}, ${fy})` : '';
+    }
+    rotateImage(img, delta) {
+        const rot = (((parseInt(img.dataset.rotate || '0', 10) + delta) % 360) + 360) % 360;
+        img.dataset.rotate = String(rot);
+        this.applyImgTransform(img);
+        this.positionImageHandles();
+        this.onChange();
+    }
+    flipImage(img, axis) {
+        const key = axis === 'x' ? 'flipx' : 'flipy';
+        img.dataset[key] = img.dataset[key] === '1' ? '' : '1';
+        this.applyImgTransform(img);
+        this.positionImageHandles();
+        this.onChange();
+    }
+    positionImageHandles() {
+        if (!this.imgActive || !document.body.contains(this.imgActive)) {
+            this.clearImageHandles();
+            return;
+        }
+        const r = this.imgActive.getBoundingClientRect();
+        const top = r.top + scrollY;
+        const left = r.left + scrollX;
+        const right = r.right + scrollX;
+        const bottom = r.bottom + scrollY;
+        const cornerPos = {
+            nw: [left, top],
+            ne: [right, top],
+            sw: [left, bottom],
+            se: [right, bottom]
+        };
+        this.imgHandles.forEach((h) => {
+            const [x, y] = cornerPos[h.dataset.corner];
+            h.style.left = x - 5 + 'px';
+            h.style.top = y - 5 + 'px';
+        });
+        if (this.imgCtx) {
+            const cw = this.imgCtx.offsetWidth;
+            const ch = this.imgCtx.offsetHeight;
+            let cx = left + (right - left) / 2 - cw / 2;
+            cx = Math.max(8 + scrollX, Math.min(cx, scrollX + innerWidth - cw - 8));
+            let cy = top - ch - 8;
+            if (cy < this.ctxMinTop())
+                cy = bottom + 8;
+            this.imgCtx.style.left = cx + 'px';
+            this.imgCtx.style.top = cy + 'px';
+        }
+    }
+    startImageResizeDrag(e, corner) {
+        e.preventDefault();
+        const img = this.imgActive;
+        if (!img)
+            return;
+        this.cancelImgHide();
+        const startX = e.clientX;
+        const startW = img.getBoundingClientRect().width;
+        const sign = corner === 'nw' || corner === 'sw' ? -1 : 1;
+        this.withNoTextSelect((restore) => {
+            const mv = (ev) => {
+                img.style.width = Math.max(24, Math.round(startW + sign * (ev.clientX - startX))) + 'px';
+                img.style.height = 'auto';
+                this.positionImageHandles();
+            };
+            const up = () => {
+                window.removeEventListener('mousemove', mv);
+                window.removeEventListener('mouseup', up);
+                restore();
+                this.onChange();
+            };
+            window.addEventListener('mousemove', mv);
+            window.addEventListener('mouseup', up);
+        });
+    }
+    /* ---------------------------------------------------------- selection bubble toolbar */
+    toggleBlock(tag) {
+        this.exec('formatBlock', this.currentBlock() === tag ? '<p>' : '<' + tag + '>');
+    }
+    clearSelToolbar() {
+        this.selCtx?.remove();
+        this.selCtx = null;
+    }
+    updateSelToolbar(sel) {
+        if (this.options.readonly || sel.isCollapsed || !sel.rangeCount) {
+            this.clearSelToolbar();
+            return;
+        }
+        const range = sel.getRangeAt(0);
+        const r = range.getBoundingClientRect();
+        if (!r.width && !r.height) {
+            this.clearSelToolbar();
+            return;
+        }
+        if (!this.selCtx)
+            this.selCtx = this.buildSelToolbar();
+        this.positionSelToolbar(range);
+    }
+    buildSelToolbar() {
+        const el = document.createElement('div');
+        el.className = 'selctx';
+        el.dir = this.dir();
+        const foreBtn = this.ctxBtn('<b style="font:600 15px/1 Georgia,serif">A</b><span class="colorbar" data-cb="fore"></span>', this.t('forecolor'), () => this.colorMenu(foreBtn, 'fore'));
+        const backBtn = this.ctxBtn(IC.backcolor, this.t('backcolor'), () => this.colorMenu(backBtn, 'back'));
+        backBtn.querySelector('svg')?.insertAdjacentHTML('afterend', '<span class="colorbar" data-cb="back"></span>');
+        const caseBtn = this.ctxBtn(IC.caseic, this.t('changecase'), () => this.caseMenu(caseBtn));
+        const lhBtn = this.ctxBtn(IC.lineheight, this.t('lineheight'), () => this.lineHeightMenu(lhBtn));
+        const wsBtn = this.ctxBtn(IC.wordspacing, this.t('wordspacing'), () => this.wordSpacingMenu(wsBtn));
+        el.append(this.ctxBtn(IC.bold, this.t('bold'), () => this.exec('bold'), 'bold'), this.ctxBtn(IC.italic, this.t('italic'), () => this.exec('italic'), 'italic'), foreBtn, backBtn, this.ctxSep(), this.ctxBtn(IC.quote, this.t('quote'), () => this.toggleBlock('blockquote'), 'blockquote'), this.ctxBtn('<b style="font:700 12px/1 Arial,sans-serif">H2</b>', this.blockLabel('h2'), () => this.toggleBlock('h2'), 'h2'), this.ctxBtn('<b style="font:700 12px/1 Arial,sans-serif">H3</b>', this.blockLabel('h3'), () => this.toggleBlock('h3'), 'h3'), this.ctxSep(), this.ctxBtn(IC.link, this.t('linkttl'), () => this.linkDlg()), caseBtn, lhBtn, wsBtn);
+        el.addEventListener('mousedown', (e) => e.preventDefault());
+        document.body.appendChild(el);
+        this.syncColorSwatches(el);
+        return el;
+    }
+    positionSelToolbar(range) {
+        if (!this.selCtx)
+            return;
+        const r = range.getBoundingClientRect();
+        const top = r.top + scrollY;
+        const left = r.left + scrollX;
+        const right = r.right + scrollX;
+        const bottom = r.bottom + scrollY;
+        const cw = this.selCtx.offsetWidth;
+        const ch = this.selCtx.offsetHeight;
+        let cx = left + (right - left) / 2 - cw / 2;
+        cx = Math.max(8 + scrollX, Math.min(cx, scrollX + innerWidth - cw - 8));
+        let cy = top - ch - 8;
+        if (cy < this.ctxMinTop())
+            cy = bottom + 8;
+        this.selCtx.style.left = cx + 'px';
+        this.selCtx.style.top = cy + 'px';
+    }
+    repositionSelToolbar() {
+        if (!this.selCtx)
+            return;
+        const s = window.getSelection();
+        if (s && s.rangeCount && !s.isCollapsed && this.ed.contains(s.anchorNode))
+            this.positionSelToolbar(s.getRangeAt(0));
+    }
+    /* ---------------------------------------------------------- state sync */
+    currentBlock() {
+        const s = window.getSelection();
+        if (!s || !s.anchorNode || !this.ed.contains(s.anchorNode))
+            return 'p';
+        const b = this.closestBlock(s.anchorNode);
+        return b ? b.tagName.toLowerCase().replace('div', 'p') : 'p';
+    }
+    /** Element whose computed font reflects the current caret, falling back to the editor root before any selection lands inside it. */
+    fontRefEl() {
+        const s = window.getSelection();
+        if (s && s.anchorNode && this.ed.contains(s.anchorNode)) {
+            return s.anchorNode.nodeType === 1 ? s.anchorNode : s.anchorNode.parentElement;
+        }
+        return this.ed;
+    }
+    currentFont() {
+        const fam = getComputedStyle(this.fontRefEl()).fontFamily.toLowerCase();
+        const hit = this.options.fontFamilyFormats.find(([n, v]) => fam.includes(v.split(',')[0].toLowerCase()));
+        return hit ? hit[0] : '';
+    }
+    currentSize() {
+        const px = Math.round(parseFloat(getComputedStyle(this.fontRefEl()).fontSize));
+        return px > 0 ? px + 'px' : '';
+    }
+    refreshState() {
+        const s = window.getSelection();
+        const inEd = s ? this.ed.contains(s.anchorNode) : false;
+        const blkTag = this.currentBlock();
+        const containers = [this.toolbar, this.selCtx].filter(Boolean);
+        containers.forEach((container) => {
+            [
+                'bold',
+                'italic',
+                'underline',
+                'strikeThrough',
+                'justifyLeft',
+                'justifyCenter',
+                'justifyRight',
+                'justifyFull',
+                'insertOrderedList',
+                'insertUnorderedList'
+            ].forEach((c) => {
+                const b = container.querySelector(`[data-id=${c}]`);
+                if (b)
+                    b.classList.toggle('on', inEd && document.queryCommandState(c));
+            });
+            ['h2', 'h3', 'blockquote'].forEach((tag) => {
+                const b = container.querySelector(`[data-id=${tag}]`);
+                if (b)
+                    b.classList.toggle('on', inEd && blkTag === tag);
+            });
+        });
+        const blk = s ? this.closestBlock(s.anchorNode) : null;
+        const dir = blk?.closest('[dir]')?.getAttribute('dir') || this.ed.getAttribute('dir') || this.dir();
+        this.toolbar.querySelector('[data-id=ltr]')?.classList.toggle('on', inEd && dir === 'ltr');
+        this.toolbar.querySelector('[data-id=rtl]')?.classList.toggle('on', inEd && dir === 'rtl');
+        const setLbl = (id, val, def) => {
+            const l = this.toolbar.querySelector(`[data-id=${id}] .lbl`);
+            if (!l)
+                return;
+            l.textContent = val || def || '';
+            l.classList.toggle('empty', !val);
+        };
+        setLbl('fontsel', this.currentFont());
+        setLbl('sizesel', this.currentSize().replace('px', ''));
+        if (inEd) {
+            setLbl('blocksel', BLOCKS.some((b) => b[0] === blkTag) ? this.blockLabel(blkTag) : this.t('para'));
+        }
+        this.sbWords.textContent = this.countWords() + ' ' + this.t('words');
+    }
+    countWords() {
+        const txt = (this.ed.textContent || '').trim();
+        return txt ? txt.split(/\s+/).length : 0;
+    }
+    /* ---------------------------------------------------------- paste */
+    handlePaste(e) {
+        const cd = e.clipboardData;
+        if (!cd)
+            return;
+        e.preventDefault();
+        const html = cd.getData('text/html');
+        const imgItem = Array.from(cd.items).find((i) => i.type.startsWith('image/'));
+        if (imgItem && !html) {
+            const fr = new FileReader();
+            fr.onload = () => {
+                document.execCommand('insertHTML', false, `<img src="${fr.result}" alt="">`);
+                this.onChange();
+            };
+            fr.readAsDataURL(imgItem.getAsFile());
+            return;
+        }
+        if (html) {
+            document.execCommand('insertHTML', false, cleanPastedHTML(html, this.dir()));
+        }
+        else {
+            document.execCommand('insertHTML', false, normalizeTextPaste(cd.getData('text/plain')));
+        }
+        this.onChange();
+    }
+    /* ---------------------------------------------------------- init */
+    initUI() {
+        this.closePop();
+        this.closeDlg();
+        this.clearTableHandles();
+        this.clearImgPlaceholderSel();
+        this.shell.dir = this.dir();
+        this.ed.dir = this.dir();
+        if (this.options.menubar)
+            this.buildMenubar();
+        else
+            this.menubar.style.display = 'none';
+        if (this.options.toolbar)
+            this.buildToolbar();
+        else
+            this.toolbar.style.display = 'none';
+        this.sbHelp.textContent = this.t('statushelp');
+        this.refreshState();
+    }
+}
+export default FableEditor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.js","sourceRoot":"","sources":["../../../../src/core/editor.ts"],"names":[],"mappings":"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","sourcesContent":["import { EditorInitOptions, EditorLanguage, FableEditorApi, MenuItemDef, DialogButton } from './types';\nimport { getStrings, I18nStrings } from './i18n';\nimport { FONTS, SIZES, BLOCKS, COLORS, QUICK_COLORS, CHARS, MIN_FONT_PX, MAX_FONT_PX, LINE_HEIGHTS, WORD_SPACINGS, DEFAULT_TOOLBAR, DEFAULT_MENUBAR } from './config';\nimport { IC } from './icons';\nimport { cleanPastedHTML, normalizeTextPaste } from './paste-engine';\nimport { importDocxToHtml } from './docx-import';\n\ntype ImgCorner = 'nw' | 'ne' | 'sw' | 'se';\nconst IMG_CORNERS: ImgCorner[] = ['nw', 'ne', 'sw', 'se'];\n\nexport class FableEditor implements FableEditorApi {\n    private static instanceCounter = 0;\n\n    private options: Required<Omit<EditorInitOptions, 'imageUploadHandler' | 'onImageUploadError' | 'contentStyle'>>;\n    private lang: EditorLanguage = 'en';\n    private contentClass = 'fable-content-' + FableEditor.instanceCounter++;\n    private contentStyleEl: HTMLStyleElement | null = null;\n\n    private shell!: HTMLElement;\n    private menubar!: HTMLElement;\n    private toolbar!: HTMLElement;\n    private ed!: HTMLElement;\n    private statusbar!: HTMLElement;\n    private sbHelp!: HTMLElement;\n    private sbWords!: HTMLElement;\n    private imgInput!: HTMLInputElement;\n\n    private savedRange: Range | null = null;\n    private foreColor = '#000000';\n    private backColor = '#FACC15';\n\n    private openPop: HTMLElement | null = null;\n    private openSubEl: HTMLElement | null = null;\n    private popAnchor: HTMLElement | null = null;\n    private dlgOvl: HTMLElement | null = null;\n\n    private tblActive: HTMLTableElement | null = null;\n    private tblCorner: HTMLElement | null = null;\n    private tblColBars: HTMLElement[] = [];\n    private tblCtx: HTMLElement | null = null;\n    private tblCellMark: HTMLElement | null = null;\n    private tblOpMark: HTMLElement | null = null;\n    private tblOpMarkKind: 'row' | 'col' | null = null;\n\n    private imgActive: HTMLImageElement | null = null;\n    private imgHandles: HTMLElement[] = [];\n    private imgCtx: HTMLElement | null = null;\n    private imgHideTimer: number | null = null;\n\n    private phActive: HTMLElement | null = null;\n    private phCtx: HTMLElement | null = null;\n    private phUploadTarget: HTMLElement | null = null;\n    private imageUploadHandler?: (file: File) => Promise<string>;\n    private onImageUploadError?: (error: unknown, file: File) => void;\n    private contentStyle?: string;\n\n    private selCtx: HTMLElement | null = null;\n\n    private docInput!: HTMLInputElement;\n    private revisions: Array<{ time: number; html: string }> = [];\n    private revTimer: number | null = null;\n    private draftTimer: number | null = null;\n    private draftStorageKey = '';\n\n    private listeners: Array<() => void> = [];\n    private isDestroyed = false;\n\n    constructor(options: EditorInitOptions) {\n        this.options = {\n            target: options.target,\n            language: options.language || 'en',\n            height: options.height ?? 302,\n            initialContent: options.initialContent ?? '<p><br></p>',\n            onChange: options.onChange || (() => { }),\n            onReady: options.onReady || (() => { }),\n            menubar: options.menubar ?? true,\n            toolbar: options.toolbar ?? true,\n            statusbar: options.statusbar ?? true,\n            readonly: options.readonly ?? false,\n            draftKey: options.draftKey ?? (typeof location !== 'undefined' ? location.pathname : 'default'),\n            fontFamilyFormats: options.fontFamilyFormats ?? FONTS,\n            imageFileTypes: options.imageFileTypes ?? ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/bmp', 'image/webp']\n        };\n        this.imageUploadHandler = options.imageUploadHandler;\n        this.onImageUploadError = options.onImageUploadError;\n        this.contentStyle = options.contentStyle;\n        this.lang = this.options.language;\n        this.draftStorageKey = 'tmclone-draft:' + this.options.draftKey;\n        this.initDOM();\n        this.bindEvents();\n        this.initUI();\n        this.recordRevision();\n        this.options.onReady(this);\n    }\n\n    private t(key: keyof I18nStrings): string {\n        const s = getStrings(this.lang)[key];\n        return typeof s === 'string' ? s : (s as string[]).join(',');\n    }\n\n    private tArr(key: keyof I18nStrings): string[] {\n        return getStrings(this.lang)[key] as string[];\n    }\n\n    private dir(): 'ltr' | 'rtl' {\n        return getStrings(this.lang).dir;\n    }\n\n    /* ---------------------------------------------------------- DOM setup */\n    private initDOM(): void {\n        const target = this.options.target;\n        target.innerHTML = '';\n        target.classList.add('tox-root');\n\n        this.shell = document.createElement('div');\n        this.shell.className = 'tox';\n\n        this.menubar = document.createElement('div');\n        this.menubar.className = 'mnb';\n\n        this.toolbar = document.createElement('div');\n        this.toolbar.className = 'tbr';\n\n        this.ed = document.createElement('div');\n        this.ed.className = 'earea ' + this.contentClass;\n        this.ed.setAttribute('contenteditable', (!this.options.readonly).toString());\n        this.ed.spellcheck = true;\n        this.ed.innerHTML = this.options.initialContent;\n        this.ed.style.height = this.options.height + 'px';\n\n        this.statusbar = document.createElement('div');\n        this.statusbar.className = 'sbar';\n        this.statusbar.innerHTML = `\n      <span class=\"mid\"></span>\n      <span class=\"words\"></span>\n      <span class=\"grip\">\n        <svg viewBox=\"0 0 12 12\"><path d=\"M11 1 1 11M11 6 6 11M11 11h0\"/></svg>\n      </span>\n    `;\n        this.sbHelp = this.statusbar.querySelector('.mid') as HTMLElement;\n        this.sbWords = this.statusbar.querySelector('.words') as HTMLElement;\n        const grip = this.statusbar.querySelector('.grip') as HTMLElement;\n        this.bindGrip(grip);\n\n        this.shell.appendChild(this.menubar);\n        this.shell.appendChild(this.toolbar);\n        this.shell.appendChild(this.ed);\n        this.shell.appendChild(this.statusbar);\n        if (this.contentStyle) {\n            this.contentStyleEl = document.createElement('style');\n            this.contentStyleEl.textContent = this.scopeContentStyle(this.contentStyle);\n            this.shell.appendChild(this.contentStyleEl);\n        }\n        target.appendChild(this.shell);\n\n        if (!this.options.statusbar) this.statusbar.style.display = 'none';\n\n        this.imgInput = document.createElement('input');\n        this.imgInput.type = 'file';\n        this.imgInput.accept = this.options.imageFileTypes.join(',');\n        this.imgInput.style.display = 'none';\n        target.appendChild(this.imgInput);\n\n        this.docInput = document.createElement('input');\n        this.docInput.type = 'file';\n        this.docInput.accept = '.docx,application/vnd.openxmlformats-officedocument.wordprocessingml.document';\n        this.docInput.style.display = 'none';\n        target.appendChild(this.docInput);\n    }\n\n    /** Rewrites the literal word `body` in a user-supplied `contentStyle` string to a\n     *  selector scoped to this instance's content div. Everything else passes through\n     *  verbatim, since `.ed` is a plain div in the host page (not an iframe) and an\n     *  unscoped `body { ... }` rule would otherwise leak onto the host page's body. */\n    private scopeContentStyle(css: string): string {\n        return css.replace(/\\bbody\\b/g, '.' + this.contentClass);\n    }\n\n    private bindGrip(grip: HTMLElement): void {\n        let startY = 0;\n        let startH = 0;\n        const md = (e: MouseEvent) => {\n            startY = e.clientY;\n            startH = this.ed.offsetHeight;\n            e.preventDefault();\n            const mv = (ev: MouseEvent) => {\n                this.ed.style.height = Math.max(120, startH + ev.clientY - startY) + 'px';\n            };\n            const up = () => {\n                window.removeEventListener('mousemove', mv);\n                window.removeEventListener('mouseup', up);\n            };\n            window.addEventListener('mousemove', mv);\n            window.addEventListener('mouseup', up);\n        };\n        grip.addEventListener('mousedown', md);\n        this.listeners.push(() => grip.removeEventListener('mousedown', md));\n    }\n\n    /* ---------------------------------------------------------- event binding */\n    private bindEvents(): void {\n        this.onDoc('mousedown', (e) => {\n            if (\n                this.openPop &&\n                !this.openPop.contains(e.target as Node) &&\n                !this.popAnchor!.contains(e.target as Node) &&\n                !(this.openSubEl && this.openSubEl.contains(e.target as Node))\n            ) {\n                this.closePop();\n            }\n        });\n        this.onDoc('keydown', (e) => {\n            if (e.key === 'Escape') {\n                this.closePop();\n                this.closeDlg();\n            }\n        });\n        this.onDoc('selectionchange', () => {\n            const sel = window.getSelection();\n            if (sel && this.ed.contains(sel.anchorNode)) {\n                this.saveSel();\n                this.refreshState();\n                this.updateSelToolbar(sel);\n                this.positionCellMarker();\n            } else {\n                this.clearSelToolbar();\n            }\n        });\n\n        this.on(this.ed, 'input', () => {\n            this.refreshState();\n            this.onChange();\n            this.positionTableHandles();\n            this.positionImageHandles();\n            this.positionImgPhCtx();\n        });\n        this.on(this.ed, 'keydown', (e: KeyboardEvent) => {\n            if (e.altKey && e.key === '0') {\n                e.preventDefault();\n                this.helpDlg();\n            }\n        });\n        this.on(this.ed, 'paste', (e: ClipboardEvent) => this.handlePaste(e));\n        this.on(this.ed, 'drop', (e: DragEvent) => {\n            /* content drops stay blocked (powerpaste_block_drop) — only an\n               image file dropped onto an upload placeholder is consumed */\n            e.preventDefault();\n            const ph = (e.target as HTMLElement).closest?.('.img-ph') as HTMLElement | null;\n            if (!ph || !this.ed.contains(ph) || this.options.readonly) return;\n            const file = Array.from(e.dataTransfer?.files || []).find((f) => f.type.startsWith('image/'));\n            if (file) this.readImageFileInto(file, ph);\n        });\n        this.on(this.ed, 'dragover', (e: DragEvent) => e.preventDefault());\n        this.on(this.ed, 'mousedown', (e: MouseEvent) => {\n            const target = e.target as HTMLElement;\n            const table = target.closest?.('table');\n            if (table && this.ed.contains(table)) this.selectTableForResize(table as HTMLTableElement);\n            else this.clearTableHandles();\n            const ph = target.closest?.('.img-ph') as HTMLElement | null;\n            if (ph && this.ed.contains(ph) && !this.options.readonly) {\n                e.preventDefault();\n                this.selectImgPlaceholder(ph);\n            } else {\n                this.clearImgPlaceholderSel();\n            }\n            const img = target.closest?.('img') as HTMLImageElement | null;\n            if (img && this.ed.contains(img) && !this.options.readonly) {\n                e.preventDefault();\n                this.selectImage(img);\n            } else {\n                this.clearImageHandles();\n            }\n        });\n        this.on(this.ed, 'mouseover', (e: MouseEvent) => {\n            if (this.options.readonly) return;\n            const img = (e.target as HTMLElement).closest?.('img') as HTMLImageElement | null;\n            if (img && this.ed.contains(img)) {\n                this.cancelImgHide();\n                this.selectImage(img);\n            }\n        });\n        this.on(this.ed, 'mouseout', (e: MouseEvent) => {\n            const img = (e.target as HTMLElement).closest?.('img');\n            if (!img) return;\n            const to = e.relatedTarget as Node | null;\n            if (\n                to &&\n                (this.imgCtx?.contains(to) ||\n                    this.imgHandles.some((h) => h.contains(to)) ||\n                    (to as HTMLElement).closest?.('img') === img)\n            )\n                return;\n            this.scheduleImgHide();\n        });\n        this.on(this.ed, 'scroll', () => {\n            this.positionTableHandles();\n            this.positionImageHandles();\n            this.positionImgPhCtx();\n        });\n        this.onWin(\n            'scroll',\n            () => {\n                this.positionTableHandles();\n                this.positionImageHandles();\n                this.positionImgPhCtx();\n                this.repositionSelToolbar();\n            },\n            true\n        );\n        this.onWin('resize', () => {\n            this.positionTableHandles();\n            this.positionImageHandles();\n            this.positionImgPhCtx();\n            this.repositionSelToolbar();\n        });\n\n        this.on(this.imgInput, 'change', () => {\n            const file = this.imgInput.files?.[0];\n            if (!file) return;\n            const ph = this.phUploadTarget;\n            this.phUploadTarget = null;\n            if (ph && this.ed.contains(ph)) {\n                this.readImageFileInto(file, ph);\n                return;\n            }\n            const fr = new FileReader();\n            fr.onload = () => {\n                this.restoreSel();\n                document.execCommand(\n                    'insertHTML',\n                    false,\n                    `<img src=\"${fr.result}\" title=\"${file.name.replace(/\"/g, '')}\" alt=\"\">`\n                );\n                this.onChange();\n            };\n            fr.readAsDataURL(file);\n        });\n\n        this.on(this.docInput, 'change', () => {\n            const file = this.docInput.files?.[0];\n            if (!file) return;\n            this.importWordFile(file).catch(() => alert(this.t('importfail')));\n        });\n\n        this.onDoc('mousedown', (e) => {\n            if (\n                this.ed.contains(e.target as Node) ||\n                e.target === this.tblCorner ||\n                this.tblColBars.includes(e.target as HTMLElement) ||\n                (this.tblCtx && this.tblCtx.contains(e.target as Node)) ||\n                this.imgHandles.includes(e.target as HTMLElement) ||\n                (this.imgCtx && this.imgCtx.contains(e.target as Node)) ||\n                (this.phCtx && this.phCtx.contains(e.target as Node)) ||\n                (this.selCtx && this.selCtx.contains(e.target as Node)) ||\n                (this.openPop && this.openPop.contains(e.target as Node)) ||\n                (this.openSubEl && this.openSubEl.contains(e.target as Node))\n            )\n                return;\n            this.clearTableHandles();\n            this.clearImageHandles();\n            this.clearImgPlaceholderSel();\n            this.clearSelToolbar();\n        });\n    }\n\n    private on<K extends keyof HTMLElementEventMap>(\n        target: EventTarget,\n        event: K,\n        handler: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any\n    ): void {\n        target.addEventListener(event, handler as EventListener);\n        this.listeners.push(() => target.removeEventListener(event, handler as EventListener));\n    }\n\n    private onDoc<K extends keyof DocumentEventMap>(event: K, handler: (this: Document, ev: DocumentEventMap[K]) => any): void {\n        document.addEventListener(event, handler as EventListener);\n        this.listeners.push(() => document.removeEventListener(event, handler as EventListener));\n    }\n\n    private onWin<K extends keyof WindowEventMap>(\n        event: K,\n        handler: (this: Window, ev: WindowEventMap[K]) => any,\n        capture?: boolean\n    ): void {\n        window.addEventListener(event, handler as EventListener, capture);\n        this.listeners.push(() => window.removeEventListener(event, handler as EventListener, capture));\n    }\n\n    /* ---------------------------------------------------------- public API */\n    getContent(): string {\n        return this.ed.innerHTML;\n    }\n\n    setContent(html: string): void {\n        this.ed.innerHTML = html || '<p><br></p>';\n        this.refreshState();\n        this.clearTableHandles();\n        this.clearImageHandles();\n        this.clearImgPlaceholderSel();\n        this.clearSelToolbar();\n        this.onChange();\n    }\n\n    insertContent(html: string): void {\n        this.restoreSel();\n        document.execCommand('insertHTML', false, html);\n        this.saveSel();\n        this.refreshState();\n        this.onChange();\n    }\n\n    setLanguage(lang: EditorLanguage): void {\n        this.lang = lang;\n        this.initUI();\n    }\n\n    focus(): void {\n        this.ed.focus();\n    }\n\n    async importWordFile(file: File | Blob): Promise<void> {\n        const html = await importDocxToHtml(file);\n        this.recordRevision();\n        this.setContent(html);\n        this.recordRevision();\n    }\n\n    restoreDraft(): boolean {\n        let raw: string | null = null;\n        try {\n            raw = localStorage.getItem(this.draftStorageKey);\n        } catch {\n            /* storage unavailable */\n        }\n        if (!raw) return false;\n        try {\n            const draft = JSON.parse(raw) as { time: number; html: string };\n            if (!draft.html) return false;\n            this.recordRevision();\n            this.setContent(draft.html);\n            return true;\n        } catch {\n            return false;\n        }\n    }\n\n    getRevisions(): Array<{ time: number; html: string }> {\n        return this.revisions.slice();\n    }\n\n    destroy(): void {\n        if (this.isDestroyed) return;\n        this.isDestroyed = true;\n        if (this.revTimer != null) window.clearTimeout(this.revTimer);\n        if (this.draftTimer != null) window.clearTimeout(this.draftTimer);\n        this.closePop();\n        this.closeDlg();\n        this.clearTableHandles();\n        this.clearImageHandles();\n        this.clearImgPlaceholderSel();\n        this.clearSelToolbar();\n        this.listeners.forEach((fn) => fn());\n        this.listeners = [];\n        if (this.shell && this.shell.parentNode) this.shell.parentNode.removeChild(this.shell);\n        if (this.imgInput && this.imgInput.parentNode) this.imgInput.parentNode.removeChild(this.imgInput);\n        if (this.docInput && this.docInput.parentNode) this.docInput.parentNode.removeChild(this.docInput);\n        this.contentStyleEl = null;\n    }\n\n    /* ---------------------------------------------------------- selection */\n    private saveSel(): void {\n        const s = window.getSelection();\n        if (s && s.rangeCount && this.ed.contains(s.anchorNode)) this.savedRange = s.getRangeAt(0).cloneRange();\n    }\n\n    private restoreSel(): void {\n        if (!this.savedRange) {\n            this.ed.focus();\n            return;\n        }\n        this.ed.focus();\n        const s = window.getSelection();\n        if (!s) return;\n        s.removeAllRanges();\n        s.addRange(this.savedRange);\n    }\n\n    private exec(cmd: string, val?: string): void {\n        this.restoreSel();\n        document.execCommand('styleWithCSS', false, cmd !== 'fontSize' ? 'true' : 'false');\n        document.execCommand(cmd, false, val ?? (undefined as any));\n        this.saveSel();\n        this.refreshState();\n        this.onChange();\n    }\n\n    private closestBlock(node: Node | null): HTMLElement | null {\n        while (node && node !== this.ed) {\n            if ((node as HTMLElement).nodeType === 1 && /^(P|DIV|H[1-6]|LI|PRE|BLOCKQUOTE|TD|TH)$/i.test((node as HTMLElement).tagName)) {\n                return node as HTMLElement;\n            }\n            node = (node as ChildNode).parentNode;\n        }\n        return null;\n    }\n\n    private selectedBlocks(): HTMLElement[] {\n        const s = window.getSelection();\n        if (!s || !s.rangeCount || !this.ed.contains(s.anchorNode)) return [];\n        const r = s.getRangeAt(0);\n        const blocks = Array.from(this.ed.querySelectorAll('p,h1,h2,h3,h4,h5,h6,li,pre,blockquote,td,th')).filter((b) =>\n            r.intersectsNode(b)\n        );\n        if (!blocks.length) {\n            const b = this.closestBlock(s.anchorNode);\n            if (b) return [b];\n        }\n        return blocks as HTMLElement[];\n    }\n\n    private onChange(): void {\n        this.options.onChange(this.ed.innerHTML);\n        this.scheduleRevision();\n        this.scheduleDraftSave();\n    }\n\n    /* ---------------------------------------------------------- revisions / drafts */\n    private recordRevision(): void {\n        const html = this.ed.innerHTML;\n        const last = this.revisions[this.revisions.length - 1];\n        if (last && last.html === html) return;\n        this.revisions.push({ time: Date.now(), html });\n        if (this.revisions.length > 30) this.revisions.shift();\n    }\n\n    private scheduleRevision(): void {\n        if (this.revTimer != null) window.clearTimeout(this.revTimer);\n        this.revTimer = window.setTimeout(() => {\n            this.revTimer = null;\n            this.recordRevision();\n        }, 1500);\n    }\n\n    private scheduleDraftSave(): void {\n        if (this.draftTimer != null) window.clearTimeout(this.draftTimer);\n        this.draftTimer = window.setTimeout(() => {\n            this.draftTimer = null;\n            try {\n                localStorage.setItem(this.draftStorageKey, JSON.stringify({ time: Date.now(), html: this.ed.innerHTML }));\n            } catch {\n                /* storage unavailable or full */\n            }\n        }, 800);\n    }\n\n    private revisionDlg(): void {\n        this.recordRevision();\n        this.dialog(this.t('revhistory'), (body) => {\n            if (!this.revisions.length) {\n                body.innerHTML = `<p style=\"color:#556\">${this.t('revempty')}</p>`;\n                return;\n            }\n            const wrap = document.createElement('div');\n            wrap.className = 'revwrap';\n            const list = document.createElement('div');\n            list.className = 'revlist';\n            const prev = document.createElement('div');\n            prev.className = 'revprev';\n            const restoreBtn = document.createElement('button');\n            restoreBtn.type = 'button';\n            restoreBtn.className = 'revrestore';\n            restoreBtn.textContent = this.t('restore');\n            let selected = this.revisions.length - 1;\n            const fmt = new Intl.DateTimeFormat(this.lang === 'ar' ? 'ar-AE' : 'en-GB', {\n                year: 'numeric',\n                month: 'short',\n                day: 'numeric',\n                hour: '2-digit',\n                minute: '2-digit',\n                second: '2-digit'\n            });\n            const items: Record<number, HTMLButtonElement> = {};\n            const show = (i: number) => {\n                selected = i;\n                this.revisions.forEach((_, j) => items[j]?.classList.toggle('on', j === i));\n                prev.innerHTML = this.revisions[i].html;\n                restoreBtn.disabled = i === this.revisions.length - 1;\n            };\n            for (let i = this.revisions.length - 1; i >= 0; i--) {\n                const rev = this.revisions[i];\n                const b = document.createElement('button');\n                b.type = 'button';\n                const words = (new DOMParser().parseFromString(rev.html, 'text/html').body.textContent || '').trim();\n                const wc = words ? words.split(/\\s+/).length : 0;\n                const isCurrent = i === this.revisions.length - 1;\n                b.innerHTML = `<span>${isCurrent ? this.t('currentver') : fmt.format(new Date(rev.time))}</span><span class=\"wc\">${wc} ${this.t('words')}</span>`;\n                b.addEventListener('click', () => show(i));\n                items[i] = b;\n                list.appendChild(b);\n            }\n            list.append(restoreBtn);\n            restoreBtn.addEventListener('click', () => {\n                const rev = this.revisions[selected];\n                if (!rev) return;\n                this.recordRevision();\n                this.setContent(rev.html);\n                this.recordRevision();\n                this.closeDlg();\n            });\n            wrap.append(list, prev);\n            body.appendChild(wrap);\n            show(selected);\n        });\n    }\n\n    /* ---------------------------------------------------------- popups / menus */\n    private closeSub(): void {\n        this.openSubEl?.remove();\n        this.openSubEl = null;\n    }\n\n    private closePop(): void {\n        this.closeSub();\n        if (this.openPop) {\n            this.openPop.remove();\n            this.openPop = null;\n            this.popAnchor?.classList.remove('open');\n            this.popAnchor = null;\n            /* a menu item's mouseleave never fires once the menu is removed,\n               so drop any row/column highlight it left behind */\n            this.setOpTarget(null);\n        }\n    }\n\n    private openSubFor(item: MenuItemDef, anchor: HTMLElement): void {\n        this.closeSub();\n        const sub = document.createElement('div');\n        sub.className = 'pop sub';\n        sub.dir = this.dir();\n        if (item.subBuild) item.subBuild(sub);\n        else if (item.sub) this.menuItems(sub, item.sub);\n        sub.addEventListener('mousedown', (e) => {\n            if ((e.target as HTMLElement).tagName !== 'INPUT') e.preventDefault();\n        });\n        document.body.appendChild(sub);\n        const r = anchor.getBoundingClientRect();\n        const isRtl = this.dir() === 'rtl';\n        // overlap the parent item slightly so the pointer can travel into the flyout\n        let x = isRtl ? r.left - sub.offsetWidth + 2 : r.right - 2;\n        x = Math.max(8, Math.min(x + scrollX, scrollX + innerWidth - sub.offsetWidth - 8));\n        let y = r.top + scrollY - 6;\n        y = Math.max(8 + scrollY, Math.min(y, scrollY + innerHeight - sub.offsetHeight - 8));\n        sub.style.left = x + 'px';\n        sub.style.top = y + 'px';\n        this.openSubEl = sub;\n    }\n\n    private popup(anchor: HTMLElement, build: (el: HTMLElement) => void): void {\n        if (this.openPop && this.popAnchor === anchor) {\n            this.closePop();\n            return;\n        }\n        this.closePop();\n        const el = document.createElement('div');\n        el.className = 'pop';\n        el.dir = this.dir();\n        build(el);\n        document.body.appendChild(el);\n        const r = anchor.getBoundingClientRect();\n        // align the menu with its control: at least as wide as the anchor\n        el.style.minWidth = Math.max(160, Math.round(r.width)) + 'px';\n        el.style.top = r.bottom + scrollY + 2 + 'px';\n        const isRtl = this.dir() === 'rtl';\n        let x = isRtl ? r.right - el.offsetWidth : r.left;\n        x = Math.max(8, Math.min(x + scrollX, scrollX + innerWidth - el.offsetWidth - 8));\n        el.style.left = x + 'px';\n        el.addEventListener('mousedown', (e) => {\n            if ((e.target as HTMLElement).tagName !== 'INPUT') e.preventDefault();\n        });\n        this.openPop = el;\n        this.popAnchor = anchor;\n        anchor.classList.add('open');\n    }\n\n    private menuItems(el: HTMLElement, items: (MenuItemDef | '|')[]): void {\n        items.forEach((it) => {\n            if (it === '|') {\n                el.insertAdjacentHTML('beforeend', '<div class=\"sep\"></div>');\n                return;\n            }\n            const hasSub = !!(it.sub || it.subBuild);\n            const b = document.createElement('button');\n            b.className = 'mi' + (it.on ? ' on' : '');\n            b.innerHTML = `<span class=\"ic\">${it.icon || ''}</span><span class=\"prev\" ${it.previewStyle ? `style=\"${it.previewStyle}\"` : ''\n                }>${it.label}</span>${it.shortcut ? `<span class=\"sc\">${it.shortcut}</span>` : ''}${hasSub ? `<span class=\"subarrow\">${IC.chev}</span>` : ''\n                }`;\n            b.addEventListener('click', () => {\n                if (!it.action) return;\n                this.closePop();\n                it.action();\n            });\n            b.addEventListener('mouseenter', () => {\n                if (hasSub) this.openSubFor(it, b);\n                else if (this.openSubEl && el !== this.openSubEl) this.closeSub();\n                it.hover?.(true);\n            });\n            b.addEventListener('mouseleave', () => it.hover?.(false));\n            el.appendChild(b);\n        });\n    }\n\n    /* ---------------------------------------------------------- toolbar builders */\n    private tbtn(icon: string, tip: string, fn: (e?: Event) => void, id?: string): HTMLButtonElement {\n        const b = document.createElement('button');\n        b.className = 'tbtn';\n        b.type = 'button';\n        b.title = tip;\n        b.innerHTML = icon;\n        if (id) b.dataset.id = id;\n        b.addEventListener('mousedown', (e) => e.preventDefault());\n        b.addEventListener('click', fn as EventListener);\n        return b;\n    }\n\n    /** Font-size increase / decrease step button. */\n    private stepBtn(delta: number): HTMLButtonElement {\n        const sign = delta > 0 ? '+' : '−';\n        const icon = delta > 0 ? IC.fontsizeup : IC.fontsizedown;\n        const b = this.tbtn(icon, this.t('fontsize') + ' ' + sign, () => this.stepFontSize(delta));\n        b.addEventListener('mousedown', () => this.saveSel());\n        return b;\n    }\n\n    /** Toolbar icon button that opens a popup menu anchored to itself. */\n    private menuTbtn(icon: string, tip: string, menuFn: (b: HTMLButtonElement) => void, id?: string): HTMLButtonElement {\n        const b = this.tbtn(icon, tip, () => menuFn(b), id);\n        b.classList.add('hasmenu');\n        b.insertAdjacentHTML('beforeend', IC.chev);\n        b.addEventListener('mousedown', () => this.saveSel());\n        return b;\n    }\n\n    /** Quick text-color chips plus a \"more\" chip that opens the full palette. */\n    private colorChips(): HTMLElement[] {\n        const chip = (title: string): HTMLButtonElement => {\n            const b = document.createElement('button');\n            b.type = 'button';\n            b.className = 'cchip';\n            b.title = title;\n            b.addEventListener('mousedown', (e) => {\n                e.preventDefault();\n                this.saveSel();\n            });\n            return b;\n        };\n        const chips = QUICK_COLORS.map((c) => {\n            const b = chip(this.t('forecolor'));\n            b.style.background = c;\n            b.addEventListener('click', () => this.applyColor('fore', c));\n            return b;\n        });\n        const more = chip(this.t('forecolor'));\n        more.classList.add('more');\n        more.dataset.cb = 'fore';\n        more.innerHTML = IC.chev;\n        more.addEventListener('click', () => this.colorMenu(more, 'fore'));\n        return [...chips, more];\n    }\n\n    private group(...els: HTMLElement[]): HTMLElement {\n        const g = document.createElement('div');\n        g.className = 'tgrp';\n        els.forEach((e) => {\n            e.classList.add('gbtn');\n            g.appendChild(e);\n        });\n        return g;\n    }\n\n    private tsel(cls: string, id: string, defLabel: string, menuFn: (b: HTMLButtonElement) => void): HTMLButtonElement {\n        const b = document.createElement('button');\n        b.className = 'tsel ' + cls;\n        b.type = 'button';\n        b.dataset.id = id;\n        b.innerHTML = `<span class=\"lbl empty\">${defLabel || ''}</span>${IC.chev}`;\n        b.addEventListener('mousedown', (e) => {\n            e.preventDefault();\n            this.saveSel();\n        });\n        b.addEventListener('click', () => menuFn(b));\n        return b;\n    }\n\n    private setListStyle(kind: 'ol' | 'ul', style: string): void {\n        this.restoreSel();\n        const s = window.getSelection();\n        if (!s) return;\n        let list = this.closestBlock(s.anchorNode)?.closest(kind);\n        if (!list) {\n            this.exec(kind === 'ol' ? 'insertOrderedList' : 'insertUnorderedList');\n            list = this.closestBlock(s.anchorNode)?.closest(kind);\n        }\n        if (list) (list as HTMLElement).style.listStyleType = style;\n        this.saveSel();\n        this.onChange();\n    }\n\n    private listMenu(anchor: HTMLButtonElement, kind: 'ul' | 'ol'): void {\n        const cmd = kind === 'ol' ? 'insertOrderedList' : 'insertUnorderedList';\n        // the toggle item creates the default style, so it is not repeated below\n        const styles: [string, string][] =\n            kind === 'ol'\n                ? [\n                    ['lower-alpha', IC.ol_alpha],\n                    ['lower-roman', IC.ol_roman],\n                    ['upper-alpha', IC.ol_alphau],\n                    ['upper-roman', IC.ol_romanu]\n                ]\n                : [\n                    ['circle', IC.ul_circle],\n                    ['square', IC.ul_square]\n                ];\n        const labels = this.tArr(kind === 'ol' ? 'liststyles_ol' : 'liststyles_ul').slice(1);\n        const sel = window.getSelection();\n        const listEl = sel ? (this.closestBlock(sel.anchorNode)?.closest(kind) as HTMLElement | null) : null;\n        const curStyle = listEl ? listEl.style.listStyleType : '';\n        this.popup(anchor, (el) => {\n            this.menuItems(el, [\n                {\n                    label: this.t(kind === 'ol' ? 'numlist' : 'bullist'),\n                    icon: kind === 'ol' ? IC.numlist : IC.bullist,\n                    on: document.queryCommandState(cmd),\n                    action: () => this.exec(cmd)\n                }\n            ]);\n            el.insertAdjacentHTML('beforeend', '<div class=\"sep\"></div>');\n            const grid = document.createElement('div');\n            grid.className = 'mi-grid';\n            styles.forEach(([s, icon], i) => {\n                const b = document.createElement('button');\n                b.className = 'mi' + (curStyle === s ? ' on' : '');\n                b.innerHTML = `<span class=\"ic\">${icon}</span><span class=\"prev\">${labels[i]}</span>`;\n                b.addEventListener('click', () => {\n                    this.closePop();\n                    this.setListStyle(kind, s);\n                });\n                grid.appendChild(b);\n            });\n            el.appendChild(grid);\n        });\n    }\n\n    private colorMenu(anchor: HTMLButtonElement, kind: 'fore' | 'back'): void {\n        this.popup(anchor, (el) => {\n            const grid = document.createElement('div');\n            grid.className = 'cpal';\n            COLORS.forEach((c) => {\n                const b = document.createElement('button');\n                b.style.background = c;\n                b.title = c;\n                b.addEventListener('click', () => {\n                    this.closePop();\n                    this.applyColor(kind, c);\n                });\n                grid.appendChild(b);\n            });\n            el.appendChild(grid);\n            el.insertAdjacentHTML('beforeend', '<div class=\"sep\"></div>');\n            const foot = document.createElement('div');\n            foot.className = 'cfoot';\n            const cur = document.createElement('div');\n            cur.className = 'cswatch cur';\n            cur.title = this.t('currentcolor');\n            const curColor = kind === 'fore' ? this.foreColor : this.backColor;\n            cur.style.background = /^#[0-9a-f]{6}$/i.test(curColor) ? curColor : '#000000';\n            cur.innerHTML = IC.check;\n            const nocolor = document.createElement('button');\n            nocolor.type = 'button';\n            nocolor.className = 'cswatch nocolor';\n            nocolor.title = this.t('removecolor');\n            nocolor.addEventListener('click', () => {\n                this.closePop();\n                this.applyColor(kind, null);\n            });\n            const wheel = document.createElement('label');\n            wheel.className = 'cswatch cwheel';\n            wheel.title = this.t('customcolor');\n            wheel.innerHTML = IC.palette;\n            const picker = document.createElement('input');\n            picker.type = 'color';\n            picker.value = /^#[0-9a-f]{6}$/i.test(curColor) ? curColor : '#000000';\n            picker.addEventListener('change', () => {\n                this.closePop();\n                this.applyColor(kind, picker.value);\n            });\n            wheel.appendChild(picker);\n            foot.append(cur, nocolor, wheel);\n            el.appendChild(foot);\n        });\n    }\n\n    private applyColor(kind: 'fore' | 'back', c: string | null): void {\n        if (kind === 'fore') {\n            this.foreColor = c || '#000000';\n            this.exec('foreColor', c || '#000000');\n        } else {\n            this.backColor = c || 'transparent';\n            this.exec('hiliteColor', c || 'transparent');\n        }\n        this.syncColorSwatches(this.toolbar);\n        if (this.selCtx) this.syncColorSwatches(this.selCtx);\n    }\n\n    private syncColorSwatches(container: HTMLElement): void {\n        container.querySelectorAll(`[data-cb=fore]`).forEach((el) => ((el as HTMLElement).style.background = this.foreColor));\n        container.querySelectorAll(`[data-cb=back]`).forEach((el) => ((el as HTMLElement).style.background = this.backColor));\n    }\n\n    private fontMenu(anchor: HTMLButtonElement): void {\n        this.popup(anchor, (el) => {\n            this.menuItems(\n                el,\n                this.options.fontFamilyFormats.map(([name, val]) => ({\n                    label: name,\n                    previewStyle: `font-family:${val}`,\n                    on: this.currentFont() === name,\n                    action: () => this.exec('fontName', val)\n                }))\n            );\n        });\n    }\n\n    private sizeMenu(anchor: HTMLButtonElement): void {\n        this.popup(anchor, (el) => {\n            this.menuItems(\n                el,\n                SIZES.map((s) => ({\n                    label: s,\n                    on: this.currentSize() === s,\n                    action: () => this.applyFontSize(s)\n                }))\n            );\n        });\n    }\n\n    /** Font sizing needs a non-collapsed range. With a bare caret, grow the\n        selection to the word under it; in an empty spot, select a zero-width\n        space so the new size applies to what gets typed next. */\n    private ensureSizeTarget(): void {\n        const s = window.getSelection();\n        if (!s) return;\n        if (!s.rangeCount) {\n            const r = document.createRange();\n            r.selectNodeContents(this.ed);\n            r.collapse(true);\n            s.addRange(r);\n        }\n        if (!s.isCollapsed) return;\n        const r = s.getRangeAt(0);\n        const node = r.startContainer;\n        if (node.nodeType === 3) {\n            const text = (node as Text).data;\n            let a = r.startOffset;\n            let b = r.startOffset;\n            while (a > 0 && /\\S/.test(text[a - 1])) a--;\n            while (b < text.length && /\\S/.test(text[b])) b++;\n            if (b > a) {\n                const nr = document.createRange();\n                nr.setStart(node, a);\n                nr.setEnd(node, b);\n                s.removeAllRanges();\n                s.addRange(nr);\n                this.savedRange = nr.cloneRange();\n                return;\n            }\n        }\n        const zw = document.createTextNode(String.fromCharCode(0x200b));\n        r.insertNode(zw);\n        const nr = document.createRange();\n        nr.setStart(zw, 0);\n        nr.setEnd(zw, 1);\n        s.removeAllRanges();\n        s.addRange(nr);\n        this.savedRange = nr.cloneRange();\n    }\n\n    private applyFontSize(px: string): void {\n        this.restoreSel();\n        this.ensureSizeTarget();\n        document.execCommand('styleWithCSS', false, 'false');\n        document.execCommand('fontSize', false, '7');\n        const spans: HTMLSpanElement[] = [];\n        this.ed.querySelectorAll('font[size=\"7\"]').forEach((f) => {\n            const span = document.createElement('span');\n            span.style.fontSize = px;\n            while (f.firstChild) span.appendChild(f.firstChild);\n            f.replaceWith(span);\n            spans.push(span);\n        });\n        if (spans.length) {\n            // keep the selection anchored inside the new spans so the current\n            // size reads back correctly (e.g. for repeated +/- stepping)\n            const r = document.createRange();\n            r.setStart(spans[0], 0);\n            r.setEnd(spans[spans.length - 1], spans[spans.length - 1].childNodes.length);\n            const s = window.getSelection();\n            if (s) {\n                s.removeAllRanges();\n                s.addRange(r);\n            }\n        }\n        this.saveSel();\n        this.refreshState();\n        this.onChange();\n    }\n\n    private stepFontSize(delta: number): void {\n        const cur = parseInt(this.currentSize(), 10) || 14;\n        const next = Math.min(MAX_FONT_PX, Math.max(MIN_FONT_PX, cur + delta));\n        if (next === cur) return;\n        this.applyFontSize(next + 'px');\n    }\n\n    /* ------------------------------------------------ case / spacing / link */\n    private transformCase(kind: 'lower' | 'upper' | 'capitalize'): void {\n        this.restoreSel();\n        const s = window.getSelection();\n        if (!s || !s.rangeCount || s.isCollapsed) return;\n        const range = s.getRangeAt(0);\n        const walker = document.createTreeWalker(this.ed, NodeFilter.SHOW_TEXT);\n        const nodes: Text[] = [];\n        let n: Node | null;\n        while ((n = walker.nextNode())) if (range.intersectsNode(n)) nodes.push(n as Text);\n        nodes.forEach((t) => {\n            const start = t === range.startContainer ? range.startOffset : 0;\n            const end = t === range.endContainer ? range.endOffset : t.data.length;\n            if (end <= start) return;\n            const mid = t.data.slice(start, end);\n            let out = mid;\n            if (kind === 'lower') out = mid.toLowerCase();\n            else if (kind === 'upper') out = mid.toUpperCase();\n            else out = mid.replace(/(^|\\s)(\\S)/g, (m, sp, ch) => sp + ch.toUpperCase());\n            t.replaceData(start, end - start, out);\n        });\n        this.saveSel();\n        this.refreshState();\n        this.onChange();\n    }\n\n    private caseMenu(anchor: HTMLButtonElement): void {\n        this.popup(anchor, (el) => {\n            this.menuItems(el, [\n                { label: this.t('lowercase'), icon: IC.lowercaseic, action: () => this.transformCase('lower') },\n                { label: this.t('uppercase'), icon: IC.uppercaseic, action: () => this.transformCase('upper') },\n                { label: this.t('capitalize'), icon: IC.capitalizeic, action: () => this.transformCase('capitalize') }\n            ]);\n        });\n    }\n\n    private applyBlockStyle(prop: 'lineHeight' | 'wordSpacing', value: string): void {\n        this.restoreSel();\n        const blocks = this.selectedBlocks();\n        blocks.forEach((b) => {\n            if (value) b.style[prop] = value;\n            else b.style.removeProperty(prop === 'lineHeight' ? 'line-height' : 'word-spacing');\n        });\n        this.saveSel();\n        this.onChange();\n    }\n\n    private currentBlockStyle(prop: 'lineHeight' | 'wordSpacing'): string {\n        const s = window.getSelection();\n        const b = s ? this.closestBlock(s.anchorNode) : null;\n        return b ? b.style[prop] || '' : '';\n    }\n\n    private lineHeightMenu(anchor: HTMLButtonElement): void {\n        const cur = this.currentBlockStyle('lineHeight');\n        this.popup(anchor, (el) => {\n            this.menuItems(el, [\n                { label: this.t('normal'), on: !cur, action: () => this.applyBlockStyle('lineHeight', '') },\n                ...LINE_HEIGHTS.map((v) => ({\n                    label: v,\n                    on: cur === v,\n                    action: () => this.applyBlockStyle('lineHeight', v)\n                }))\n            ]);\n        });\n    }\n\n    private wordSpacingMenu(anchor: HTMLButtonElement): void {\n        const cur = this.currentBlockStyle('wordSpacing');\n        this.popup(anchor, (el) => {\n            this.menuItems(el, [\n                { label: this.t('normal'), on: !cur, action: () => this.applyBlockStyle('wordSpacing', '') },\n                ...WORD_SPACINGS.map((v) => ({\n                    label: v,\n                    on: cur === v,\n                    action: () => this.applyBlockStyle('wordSpacing', v)\n                }))\n            ]);\n        });\n    }\n\n    private closestAnchor(): HTMLAnchorElement | null {\n        const s = window.getSelection();\n        let node: Node | null = s && this.ed.contains(s.anchorNode) ? s.anchorNode : null;\n        while (node && node !== this.ed) {\n            if ((node as HTMLElement).nodeType === 1 && (node as HTMLElement).tagName === 'A') return node as HTMLAnchorElement;\n            node = node.parentNode;\n        }\n        return null;\n    }\n\n    private linkDlg(): void {\n        this.saveSel();\n        const anchorEl = this.closestAnchor();\n        let urlIn: HTMLInputElement;\n        const buttons: DialogButton[] = [];\n        if (anchorEl) {\n            buttons.push({\n                label: this.t('unlink'),\n                action: () => {\n                    const r = document.createRange();\n                    r.selectNodeContents(anchorEl);\n                    const s = window.getSelection();\n                    if (s) {\n                        s.removeAllRanges();\n                        s.addRange(r);\n                    }\n                    document.execCommand('unlink');\n                    this.closeDlg();\n                    this.onChange();\n                }\n            });\n        }\n        buttons.push(\n            { label: this.t('cancel'), action: () => this.closeDlg() },\n            {\n                label: this.t('save'),\n                primary: true,\n                action: () => {\n                    const url = urlIn.value.trim();\n                    this.closeDlg();\n                    if (!url) return;\n                    if (anchorEl) {\n                        anchorEl.setAttribute('href', url);\n                        this.onChange();\n                        return;\n                    }\n                    this.restoreSel();\n                    const s = window.getSelection();\n                    if (!s || s.isCollapsed) {\n                        document.execCommand('insertHTML', false, `<a href=\"${url.replace(/\"/g, '&quot;')}\">${url\n                            .replace(/&/g, '&amp;')\n                            .replace(/</g, '&lt;')}</a>`);\n                    } else {\n                        document.execCommand('styleWithCSS', false, 'false');\n                        document.execCommand('createLink', false, url);\n                    }\n                    this.saveSel();\n                    this.onChange();\n                }\n            }\n        );\n        this.dialog(\n            this.t('linkttl'),\n            (body) => {\n                const row = document.createElement('div');\n                row.style.cssText = 'display:flex;align-items:center;gap:10px;margin:10px 0;min-width:360px';\n                const lbl = document.createElement('span');\n                lbl.style.cssText = 'width:60px;color:#556;flex:none';\n                lbl.textContent = this.t('linkurl');\n                urlIn = document.createElement('input');\n                urlIn.type = 'url';\n                urlIn.placeholder = 'https://';\n                urlIn.style.cssText = 'flex:1;border:1px solid #cfd6df;border-radius:6px;padding:7px 9px;font:14px inherit';\n                urlIn.value = anchorEl?.getAttribute('href') || '';\n                row.append(lbl, urlIn);\n                body.appendChild(row);\n                setTimeout(() => urlIn.focus(), 0);\n            },\n            buttons\n        );\n    }\n\n    private blocksMenu(anchor: HTMLButtonElement): void {\n        this.popup(anchor, (el) => {\n            this.menuItems(\n                el,\n                BLOCKS.map(([tag, key]) => ({\n                    label: this.blockLabel(tag),\n                    previewStyle: tag.startsWith('h')\n                        ? `font-weight:700;font-size:${22 - 2 * (+tag[1])}px`\n                        : tag === 'pre'\n                            ? 'font-family:monospace'\n                            : '',\n                    on: this.currentBlock() === tag,\n                    action: () => this.exec('formatBlock', '<' + tag + '>')\n                }))\n            );\n        });\n    }\n\n    private blockLabel(tag: string): string {\n        if (tag === 'p') return this.t('para');\n        if (tag === 'pre') return this.t('pre');\n        return this.t('heading') + ' ' + tag[1];\n    }\n\n    private tableGrid(anchor: HTMLElement, after?: () => void): void {\n        this.popup(anchor, (el) => this.buildTableGridInto(el, after));\n    }\n\n    private buildTableGridInto(el: HTMLElement, after?: () => void): void {\n        {\n            const wrap = document.createElement('div');\n            wrap.className = 'tgridwrap';\n            const grid = document.createElement('div');\n            grid.className = 'tgrid';\n            const lbl = document.createElement('div');\n            lbl.className = 'tgridlbl';\n            lbl.textContent = '1 × 1';\n            const cells: HTMLSpanElement[] = [];\n            for (let r = 0; r < 8; r++)\n                for (let c = 0; c < 10; c++) {\n                    const sp = document.createElement('span');\n                    sp.dataset.r = String(r);\n                    sp.dataset.c = String(c);\n                    sp.addEventListener('mouseenter', () => {\n                        cells.forEach((x) => x.classList.toggle('hot', +x.dataset.r! <= r && +x.dataset.c! <= c));\n                        lbl.textContent = c + 1 + ' × ' + (r + 1);\n                    });\n                    sp.addEventListener('click', () => {\n                        this.closePop();\n                        this.insertTable(r + 1, c + 1);\n                        after?.();\n                    });\n                    cells.push(sp);\n                    grid.appendChild(sp);\n                }\n            wrap.append(grid, lbl);\n            el.appendChild(wrap);\n        }\n    }\n\n    private insertTable(rows: number, cols: number): void {\n        this.restoreSel();\n        /* table-layout:fixed keeps the columns evenly sized while typing —\n           text wraps at the column edge instead of widening the column */\n        let html = '<table style=\"border-collapse:collapse;width:100%;table-layout:fixed\"><tbody>';\n        for (let r = 0; r < rows; r++) {\n            html += '<tr>';\n            for (let c = 0; c < cols; c++) html += '<td style=\"border:1px solid #b9c2cc\"><br></td>';\n            html += '</tr>';\n        }\n        html += '</tbody></table><p><br></p>';\n        document.execCommand('insertHTML', false, html);\n        this.saveSel();\n        this.onChange();\n    }\n\n    private setDir(dir: 'ltr' | 'rtl'): void {\n        this.restoreSel();\n        const blocks = this.selectedBlocks();\n        if (blocks.length) blocks.forEach((b) => b.setAttribute('dir', dir));\n        else this.ed.setAttribute('dir', dir);\n        this.saveSel();\n        this.refreshState();\n        this.onChange();\n    }\n\n    /** Splits a toolbar layout string into groups of item names: `|` separates visual\n     *  groups, whitespace separates items within a group. Empty groups/tokens (e.g. from\n     *  leading/trailing/doubled separators) are dropped. Pure function. */\n    private parseToolbarString(spec: string): string[][] {\n        return spec\n            .split('|')\n            .map((group) => group.trim().split(/\\s+/).filter(Boolean))\n            .filter((group) => group.length > 0);\n    }\n\n    /** Maps every supported toolbar item name to a builder for that one control. Each\n     *  entry is a direct lift of what used to be an inline call in `buildToolbar()` — no\n     *  behavior changes, just named lookup. Only `forecolor` yields multiple elements\n     *  (the quick color chips); everything else yields one. */\n    private buildToolbarRegistry(): Record<string, () => HTMLElement | HTMLElement[]> {\n        const tableBtn = this.tbtn(IC.tableic, this.t('quicktable'), () => this.tableGrid(tableBtn));\n        return {\n            undo: () => this.tbtn(IC.undo, this.t('undo'), () => this.exec('undo')),\n            redo: () => this.tbtn(IC.redo, this.t('redo'), () => this.exec('redo')),\n            preview: () => this.tbtn(IC.prevw, this.t('preview'), () => this.previewDlg()),\n            print: () => this.tbtn(IC.printic, this.t('print'), () => this.printDoc()),\n            importword: () => this.tbtn(IC.wordic, this.t('importword'), () => this.pickWordDoc()),\n            revhistory: () => this.tbtn(IC.historyic, this.t('revhistory'), () => this.revisionDlg()),\n            fontfamily: () => this.tsel('w-font', 'fontsel', '', (b) => this.fontMenu(b)),\n            fontsize: () => this.tsel('w-size', 'sizesel', '', (b) => this.sizeMenu(b)),\n            fontsizeincrease: () => this.stepBtn(1),\n            fontsizedecrease: () => this.stepBtn(-1),\n            bold: () => this.tbtn(IC.bold, this.t('bold'), () => this.exec('bold'), 'bold'),\n            italic: () => this.tbtn(IC.italic, this.t('italic'), () => this.exec('italic'), 'italic'),\n            underline: () => this.tbtn(IC.underline, this.t('underline'), () => this.exec('underline'), 'underline'),\n            strikethrough: () => this.tbtn(IC.strikethrough, this.t('strikethrough'), () => this.exec('strikeThrough'), 'strikeThrough'),\n            forecolor: () => this.colorChips(),\n            backcolor: () =>\n                this.menuTbtn(\n                    IC.backcolor + '<span class=\"colorbar\" data-cb=\"back\"></span>',\n                    this.t('backcolor'),\n                    (b) => this.colorMenu(b, 'back')\n                ),\n            alignleft: () => this.tbtn(IC.alignleft, this.t('alignleft'), () => this.exec('justifyLeft'), 'justifyLeft'),\n            aligncenter: () => this.tbtn(IC.aligncenter, this.t('aligncenter'), () => this.exec('justifyCenter'), 'justifyCenter'),\n            alignright: () => this.tbtn(IC.alignright, this.t('alignright'), () => this.exec('justifyRight'), 'justifyRight'),\n            alignjustify: () => this.tbtn(IC.alignjustify, this.t('alignjustify'), () => this.exec('justifyFull'), 'justifyFull'),\n            bullist: () => this.menuTbtn(IC.bullist, this.t('bullist'), (b) => this.listMenu(b, 'ul'), 'insertUnorderedList'),\n            numlist: () => this.menuTbtn(IC.numlist, this.t('numlist'), (b) => this.listMenu(b, 'ol'), 'insertOrderedList'),\n            outdent: () => this.tbtn(IC.outdent, this.t('outdent'), () => this.exec('outdent')),\n            indent: () => this.tbtn(IC.indent, this.t('indent'), () => this.exec('indent')),\n            link: () => this.tbtn(IC.link, this.t('linkttl'), () => this.linkDlg()),\n            blockquote: () => this.tbtn(IC.quote, this.t('quote'), () => this.toggleBlock('blockquote'), 'blockquote'),\n            changecase: () => this.menuTbtn(IC.caseic, this.t('changecase'), (b) => this.caseMenu(b)),\n            lineheight: () => this.menuTbtn(IC.lineheight, this.t('lineheight'), (b) => this.lineHeightMenu(b)),\n            wordspacing: () => this.menuTbtn(IC.wordspacing, this.t('wordspacing'), (b) => this.wordSpacingMenu(b)),\n            removeformat: () => this.tbtn(IC.clearformatic, this.t('removeformat'), () => this.exec('removeFormat')),\n            blocks: () => this.tsel('w-block', 'blocksel', this.t('para'), (b) => this.blocksMenu(b)),\n            ltr: () => this.tbtn(IC.ltr, this.t('ltr'), () => this.setDir('ltr'), 'ltr'),\n            rtl: () => this.tbtn(IC.rtl, this.t('rtl'), () => this.setDir('rtl'), 'rtl'),\n            quickimage: () => this.tbtn(IC.image, this.t('quickimage'), () => this.insertImagePlaceholder()),\n            quicktable: () => tableBtn,\n            charmap: () => this.tbtn(IC.charic, this.t('charmap'), () => this.charMap()),\n            fullscreen: () => this.tbtn(IC.fullscreen, this.t('fullscreen'), () => this.toggleFullscreen(), 'fullscreen'),\n            sourcecode: () => this.tbtn(IC.srcic, this.t('sourcecode'), () => this.sourceDlg())\n        };\n    }\n\n    private buildToolbar(): void {\n        this.toolbar.innerHTML = '';\n        const spec = this.options.toolbar === true ? DEFAULT_TOOLBAR : (this.options.toolbar as string);\n        const registry = this.buildToolbarRegistry();\n        this.parseToolbarString(spec).forEach((tokens) => {\n            const elements: HTMLElement[] = [];\n            tokens.forEach((token) => {\n                const builder = registry[token];\n                if (!builder) {\n                    console.warn(`FableEditor: unknown toolbar item \"${token}\"`);\n                    return;\n                }\n                const result = builder();\n                if (Array.isArray(result)) elements.push(...result);\n                else elements.push(result);\n            });\n            if (elements.length) this.toolbar.appendChild(this.group(...elements));\n        });\n        this.syncColorSwatches(this.toolbar);\n    }\n\n    /* ---------------------------------------------------------- menubar */\n    private mItem(label: keyof I18nStrings, icon: string | undefined, action: () => void, shortcut?: string): MenuItemDef {\n        return { label: this.t(label), icon, action, shortcut };\n    }\n\n    private buildMenubar(): void {\n        this.menubar.innerHTML = '';\n        const menus: Record<string, (MenuItemDef | '|')[]> = {\n            file: [\n                this.mItem('newdoc', IC.newic, () => {\n                    this.recordRevision();\n                    this.ed.innerHTML = '<p><br></p>';\n                    this.onChange();\n                }),\n                '|',\n                this.mItem('importword', IC.wordic, () => this.pickWordDoc()),\n                this.mItem('restoredraft', IC.draftic, () => {\n                    if (!this.restoreDraft()) alert(this.t('draftempty'));\n                }),\n                this.mItem('revhistory', IC.historyic, () => this.revisionDlg()),\n                '|',\n                this.mItem('preview', IC.prevw, () => this.previewDlg()),\n                this.mItem('print', IC.printic, () => this.printDoc(), 'Ctrl+P')\n            ],\n            edit: [\n                this.mItem('undo', IC.undo, () => this.exec('undo'), 'Ctrl+Z'),\n                this.mItem('redo', IC.redo, () => this.exec('redo'), 'Ctrl+Y'),\n                '|',\n                this.mItem('cut', IC.cutic, () => this.exec('cut'), 'Ctrl+X'),\n                this.mItem('copy', IC.copyic, () => this.exec('copy'), 'Ctrl+C'),\n                this.mItem('paste', IC.pasteic, () => alert(this.t('pastehint')), 'Ctrl+V'),\n                '|',\n                this.mItem('selectall', IC.selall, () => this.exec('selectAll'), 'Ctrl+A')\n            ],\n            view: [\n                this.mItem('fullscreen', IC.fullscreen, () => this.toggleFullscreen()),\n                this.mItem('preview', IC.prevw, () => this.previewDlg()),\n                this.mItem('sourcecode', IC.srcic, () => this.sourceDlg())\n            ],\n            insert: [\n                this.mItem('link', IC.link, () => this.linkDlg()),\n                this.mItem('image', IC.image, () => this.insertImagePlaceholder()),\n                { label: this.t('inserttable'), icon: IC.tableic, action: () => this.tableGrid((this.menubar.querySelector('[data-menu-key=\"table\"]') as HTMLElement) || this.menubar) },\n                this.mItem('hr', IC.hric, () => this.exec('insertHorizontalRule')),\n                '|',\n                this.mItem('charmap', IC.charic, () => this.charMap()),\n                this.mItem('datetime', IC.dateic, () =>\n                    this.exec('insertText', new Date().toLocaleString(this.lang === 'ar' ? 'ar-AE' : 'en-GB'))\n                ),\n                '|',\n                {\n                    label: this.t('pagebreak'),\n                    icon: IC.pbic,\n                    action: () => {\n                        this.restoreSel();\n                        document.execCommand('insertHTML', false, '<hr class=\"pagebreak\"><p><br></p>');\n                        this.onChange();\n                    }\n                },\n                this.mItem('nbsp', IC.nbspic, () => this.exec('insertText', '\\u00A0'))\n            ],\n            format: [\n                this.mItem('bold', IC.bold, () => this.exec('bold'), 'Ctrl+B'),\n                this.mItem('italic', IC.italic, () => this.exec('italic'), 'Ctrl+I'),\n                this.mItem('underline', IC.underline, () => this.exec('underline'), 'Ctrl+U'),\n                this.mItem('strikethrough', IC.strikethrough, () => this.exec('strikeThrough')),\n                this.mItem('superscript', IC.superscriptic, () => this.exec('superscript')),\n                this.mItem('subscript', IC.subscriptic, () => this.exec('subscript')),\n                '|',\n                this.mItem('lowercase', IC.lowercaseic, () => this.transformCase('lower')),\n                this.mItem('uppercase', IC.uppercaseic, () => this.transformCase('upper')),\n                this.mItem('capitalize', IC.capitalizeic, () => this.transformCase('capitalize')),\n                '|',\n                this.mItem('clearformat', IC.clearformatic, () => this.exec('removeFormat'))\n            ],\n            tools: [this.mItem('sourcecode', IC.srcic, () => this.sourceDlg()), this.mItem('wordcount', IC.wcic, () => this.wordCountDlg())],\n            table: [\n                { label: this.t('inserttable'), icon: IC.tableic, subBuild: (el) => this.buildTableGridInto(el) },\n                '|',\n                {\n                    label: this.t('cell'),\n                    sub: [{ label: this.t('cellprops'), icon: IC.tableic, action: () => this.cellPropsDlg() }]\n                },\n                {\n                    label: this.t('row'),\n                    sub: [\n                        { label: this.t('rowabove'), icon: IC.rowbefore, action: () => this.tableOp('rowabove'), hover: (on) => this.setOpTarget(on ? 'row' : null) },\n                        { label: this.t('rowbelow'), icon: IC.rowafter, action: () => this.tableOp('rowbelow'), hover: (on) => this.setOpTarget(on ? 'row' : null) },\n                        { label: this.t('delrow'), icon: IC.rowdelete, action: () => this.tableOp('delrow'), hover: (on) => this.setOpTarget(on ? 'row' : null) },\n                        '|',\n                        { label: this.t('rowprops'), icon: IC.tableic, action: () => this.rowPropsDlg(), hover: (on) => this.setOpTarget(on ? 'row' : null) }\n                    ]\n                },\n                {\n                    label: this.t('column'),\n                    sub: [\n                        { label: this.t('colbefore'), icon: IC.colbefore, action: () => this.tableOp('colbefore'), hover: (on) => this.setOpTarget(on ? 'col' : null) },\n                        { label: this.t('colafter'), icon: IC.colafter, action: () => this.tableOp('colafter'), hover: (on) => this.setOpTarget(on ? 'col' : null) },\n                        { label: this.t('delcol'), icon: IC.coldelete, action: () => this.tableOp('delcol'), hover: (on) => this.setOpTarget(on ? 'col' : null) },\n                        '|',\n                        { label: this.t('colprops'), icon: IC.tableic, action: () => this.colPropsDlg(), hover: (on) => this.setOpTarget(on ? 'col' : null) }\n                    ]\n                },\n                '|',\n                {\n                    label: this.t('tablepropsttl'),\n                    icon: IC.tableic,\n                    action: () => {\n                        const cell = this.currentCell();\n                        if (!cell) {\n                            alert(this.t('nocell'));\n                            return;\n                        }\n                        this.tblActive = cell.closest('table');\n                        this.tablePropsDlg();\n                    }\n                },\n                { label: this.t('deltable'), icon: IC.tabledelete, action: () => this.tableOp('deltable') }\n            ],\n            help: [this.mItem('helpttl', IC.helpic, () => this.helpDlg(), 'Alt+0')]\n        };\n        const spec = this.options.menubar === true ? DEFAULT_MENUBAR : (this.options.menubar as string);\n        const seen = new Set<string>();\n        spec\n            .split(/\\s+/)\n            .filter(Boolean)\n            .forEach((key) => {\n                if (seen.has(key)) return;\n                seen.add(key);\n                if (!menus[key]) {\n                    console.warn(`FableEditor: unknown menubar item \"${key}\"`);\n                    return;\n                }\n                const b = document.createElement('button');\n                b.type = 'button';\n                b.textContent = this.t(key as keyof I18nStrings);\n                b.dataset.menuKey = key;\n                b.addEventListener('mousedown', (e) => {\n                    e.preventDefault();\n                    this.saveSel();\n                });\n                b.addEventListener('click', () => this.popup(b, (el) => this.menuItems(el, menus[key])));\n                this.menubar.appendChild(b);\n            });\n    }\n\n    /* ---------------------------------------------------------- table ops */\n    private tableOp(op: string): void {\n        this.restoreSel();\n        const s = window.getSelection();\n        if (!s) return;\n        const cell =\n            this.closestBlock(s.anchorNode)?.closest('td,th') ||\n            (s.anchorNode && (s.anchorNode as Element).nodeType === 1 ? (s.anchorNode as Element).closest?.('td,th') : null);\n        if (!cell) return;\n        const row = cell.parentElement as HTMLTableRowElement;\n        const table = cell.closest('table') as HTMLTableElement;\n        const idx = Array.from(row.children).indexOf(cell as HTMLTableCellElement);\n        const newRow = () => {\n            const r = row.cloneNode(false) as HTMLTableRowElement;\n            Array.from(row.children).forEach((src) => {\n                const td = document.createElement('td');\n                /* carry the source cell's inline style so borders / padding /\n                   column widths survive on inserted rows */\n                const st = (src as HTMLElement).getAttribute('style');\n                if (st) td.setAttribute('style', st);\n                td.style.removeProperty('background-color');\n                td.innerHTML = '<br>';\n                r.appendChild(td);\n            });\n            return r;\n        };\n        if (op === 'rowabove') row.before(newRow());\n        if (op === 'rowbelow') row.after(newRow());\n        if (op === 'delrow') {\n            const body = row.parentElement!;\n            row.remove();\n            if (!body.querySelector('tr')) table.remove();\n        }\n        if (op === 'colbefore' || op === 'colafter') {\n            table.querySelectorAll('tr').forEach((tr) => {\n                const ref = tr.children[Math.min(idx, tr.children.length - 1)] as HTMLElement;\n                const td = document.createElement('td');\n                /* carry the reference cell's inline style so borders / padding\n                   survive on inserted columns; width is dropped so the new\n                   column shares the table space instead of doubling it */\n                const st = ref.getAttribute('style');\n                if (st) td.setAttribute('style', st);\n                td.style.removeProperty('width');\n                td.style.removeProperty('background-color');\n                td.innerHTML = '<br>';\n                op === 'colbefore' ? ref.before(td) : ref.after(td);\n            });\n        }\n        if (op === 'delcol') {\n            table.querySelectorAll('tr').forEach((tr) => tr.children[idx]?.remove());\n            if (!table.querySelector('td,th')) table.remove();\n        }\n        if (op === 'deltable') table.remove();\n        this.onChange();\n        this.positionTableHandles();\n    }\n\n    private applyTableProps(table: HTMLTableElement, vals: Record<string, string>): void {\n        if (vals.width) table.style.width = /^\\d+$/.test(vals.width) ? vals.width + 'px' : vals.width;\n        else table.style.removeProperty('width');\n\n        const cells = Array.from(table.querySelectorAll('td,th')) as HTMLElement[];\n        if (vals.cellpadding !== '') cells.forEach((c) => (c.style.padding = vals.cellpadding + 'px'));\n        else cells.forEach((c) => c.style.removeProperty('padding'));\n\n        if (vals.cellspacing !== '') {\n            table.style.borderCollapse = 'separate';\n            table.style.borderSpacing = vals.cellspacing + 'px';\n        } else {\n            table.style.borderCollapse = 'collapse';\n            table.style.removeProperty('border-spacing');\n        }\n\n        if (vals.border !== '' && +vals.border > 0) {\n            table.style.border = vals.border + 'px solid #b9c2cc';\n            cells.forEach((c) => (c.style.border = vals.border + 'px solid #b9c2cc'));\n        } else {\n            table.style.removeProperty('border');\n            cells.forEach((c) => c.style.removeProperty('border'));\n        }\n\n        table.style.removeProperty('margin-left');\n        table.style.removeProperty('margin-right');\n        if (vals.align === 'center') {\n            table.style.marginLeft = 'auto';\n            table.style.marginRight = 'auto';\n        } else if (vals.align === 'right') {\n            table.style.marginLeft = 'auto';\n            table.style.marginRight = '0';\n        } else if (vals.align === 'left') {\n            table.style.marginLeft = '0';\n            table.style.marginRight = 'auto';\n        }\n    }\n\n    private tablePropsDlg(): void {\n        const table = this.tblActive;\n        if (!table) return;\n        let wIn: HTMLInputElement;\n        let padIn: HTMLInputElement;\n        let spIn: HTMLInputElement;\n        let bIn: HTMLInputElement;\n        let alignSel: HTMLSelectElement;\n        const rowStyle = 'display:flex;align-items:center;gap:10px;margin:10px 0';\n        const lblStyle = 'width:120px;color:#556;flex:none';\n        const inputStyle = 'flex:1;border:1px solid #cfd6df;border-radius:6px;padding:7px 9px;font:14px inherit';\n        const firstCell = table.querySelector('td,th') as HTMLElement | null;\n        const curWidth = table.style.width || '';\n        const curPad = firstCell && firstCell.style.padding ? parseFloat(firstCell.style.padding) : '';\n        const curSp = table.style.borderSpacing ? parseFloat(table.style.borderSpacing) : '';\n        const curBorder = table.style.borderWidth ? parseFloat(table.style.borderWidth) : '';\n        const ml = table.style.marginLeft;\n        const mr = table.style.marginRight;\n        const curAlign = ml === 'auto' && mr === 'auto' ? 'center' : ml === 'auto' ? 'right' : mr === 'auto' && ml === '0' ? 'left' : '';\n\n        this.dialog(\n            this.t('tablepropsttl'),\n            (body) => {\n                const mk = (labelKey: keyof I18nStrings, el: HTMLElement) => {\n                    const row = document.createElement('div');\n                    row.style.cssText = rowStyle;\n                    const lbl = document.createElement('span');\n                    lbl.style.cssText = lblStyle;\n                    lbl.textContent = this.t(labelKey);\n                    row.append(lbl, el);\n                    body.appendChild(row);\n                };\n                wIn = document.createElement('input');\n                wIn.type = 'text';\n                wIn.style.cssText = inputStyle;\n                wIn.placeholder = 'e.g. 600px or 100%';\n                wIn.value = curWidth as string;\n                mk('tblwidth', wIn);\n                padIn = document.createElement('input');\n                padIn.type = 'number';\n                padIn.min = '0';\n                padIn.style.cssText = inputStyle;\n                padIn.value = String(curPad);\n                mk('tblcellpadding', padIn);\n                spIn = document.createElement('input');\n                spIn.type = 'number';\n                spIn.min = '0';\n                spIn.style.cssText = inputStyle;\n                spIn.value = String(curSp);\n                mk('tblcellspacing', spIn);\n                bIn = document.createElement('input');\n                bIn.type = 'number';\n                bIn.min = '0';\n                bIn.style.cssText = inputStyle;\n                bIn.value = String(curBorder);\n                mk('tblborder', bIn);\n                alignSel = document.createElement('select');\n                alignSel.style.cssText = inputStyle;\n                (\n                    [\n                        ['', 'alignnone'],\n                        ['left', 'alignleft'],\n                        ['center', 'aligncenter'],\n                        ['right', 'alignright']\n                    ] as [string, keyof I18nStrings][]\n                ).forEach(([v, k]) => {\n                    const o = document.createElement('option');\n                    o.value = v;\n                    o.textContent = this.t(k);\n                    if (v === curAlign) o.selected = true;\n                    alignSel.appendChild(o);\n                });\n                mk('tblalign', alignSel);\n            },\n            [\n                { label: this.t('cancel'), action: () => this.closeDlg() },\n                {\n                    label: this.t('save'),\n                    primary: true,\n                    action: () => {\n                        this.applyTableProps(table, {\n                            width: wIn.value.trim(),\n                            cellpadding: padIn.value.trim(),\n                            cellspacing: spIn.value.trim(),\n                            border: bIn.value.trim(),\n                            align: alignSel.value\n                        });\n                        this.closeDlg();\n                        this.onChange();\n                        this.positionTableHandles();\n                    }\n                }\n            ]\n        );\n    }\n\n    /* ------------------------------------------- cell / row / column props */\n    private currentCell(): HTMLTableCellElement | null {\n        let node: Node | null = this.savedRange ? this.savedRange.startContainer : null;\n        if (!node || !this.ed.contains(node)) {\n            const s = window.getSelection();\n            node = s && this.ed.contains(s.anchorNode) ? s.anchorNode : null;\n        }\n        while (node && node !== this.ed) {\n            if ((node as HTMLElement).nodeType === 1 && /^(TD|TH)$/.test((node as HTMLElement).tagName)) {\n                return node as HTMLTableCellElement;\n            }\n            node = node.parentNode;\n        }\n        return null;\n    }\n\n    private toHexColor(c: string): string {\n        if (/^#[0-9a-fA-F]{6}$/.test(c)) return c;\n        const m = /rgba?\\((\\d+)[,\\s]+(\\d+)[,\\s]+(\\d+)/.exec(c);\n        if (!m) return '';\n        return '#' + [m[1], m[2], m[3]].map((n) => (+n).toString(16).padStart(2, '0')).join('');\n    }\n\n    private formRow(body: HTMLElement, label: string, el: HTMLElement): void {\n        const row = document.createElement('div');\n        row.style.cssText = 'display:flex;align-items:center;gap:10px;margin:10px 0;min-width:360px';\n        const lbl = document.createElement('span');\n        lbl.style.cssText = 'width:120px;color:#556;flex:none';\n        lbl.textContent = label;\n        row.append(lbl, el);\n        body.appendChild(row);\n    }\n\n    private formInput(value: string, placeholder = ''): HTMLInputElement {\n        const i = document.createElement('input');\n        i.type = 'text';\n        i.style.cssText = 'flex:1;border:1px solid #cfd6df;border-radius:6px;padding:7px 9px;font:14px inherit;min-width:0';\n        i.value = value;\n        i.placeholder = placeholder;\n        return i;\n    }\n\n    private formSelect(options: [string, string][], cur: string): HTMLSelectElement {\n        const sel = document.createElement('select');\n        sel.style.cssText = 'flex:1;border:1px solid #cfd6df;border-radius:6px;padding:7px 9px;font:14px inherit;background:#fff';\n        options.forEach(([v, label]) => {\n            const o = document.createElement('option');\n            o.value = v;\n            o.textContent = label;\n            if (v === cur) o.selected = true;\n            sel.appendChild(o);\n        });\n        return sel;\n    }\n\n    private formBg(cur: string): { wrap: HTMLElement; color: HTMLInputElement; fill: HTMLInputElement } {\n        const wrap = document.createElement('div');\n        wrap.style.cssText = 'flex:1;display:flex;align-items:center;gap:8px';\n        const hex = this.toHexColor(cur);\n        const color = document.createElement('input');\n        color.type = 'color';\n        color.value = hex || '#ffffff';\n        color.style.cssText = 'width:36px;height:29px;border:1px solid #cfd6df;border-radius:4px;padding:1px;background:none;cursor:pointer';\n        const lbl = document.createElement('label');\n        lbl.style.cssText = 'display:flex;align-items:center;gap:6px;cursor:pointer;color:#556';\n        const fill = document.createElement('input');\n        fill.type = 'checkbox';\n        fill.checked = !!hex;\n        lbl.append(fill, document.createTextNode(this.t('fill')));\n        color.addEventListener('input', () => (fill.checked = true));\n        wrap.append(color, lbl);\n        return { wrap, color, fill };\n    }\n\n    private setOrClear(el: HTMLElement, prop: string, val: string): void {\n        if (val) el.style.setProperty(prop, /^(width|height)$/.test(prop) && /^\\d+$/.test(val) ? val + 'px' : val);\n        else el.style.removeProperty(prop);\n    }\n\n    private cellPropsDlg(): void {\n        const cell = this.currentCell();\n        if (!cell) {\n            alert(this.t('nocell'));\n            return;\n        }\n        let wIn: HTMLInputElement;\n        let hIn: HTMLInputElement;\n        let alignSel: HTMLSelectElement;\n        let vSel: HTMLSelectElement;\n        let bg: { wrap: HTMLElement; color: HTMLInputElement; fill: HTMLInputElement };\n        this.dialog(\n            this.t('cellprops').replace('…', ''),\n            (body) => {\n                wIn = this.formInput(cell.style.width, 'e.g. 120px / 25%');\n                this.formRow(body, this.t('tblwidth'), wIn);\n                hIn = this.formInput(cell.style.height, 'e.g. 40px');\n                this.formRow(body, this.t('tblheight'), hIn);\n                alignSel = this.formSelect(\n                    [\n                        ['', this.t('alignnone')],\n                        ['left', this.t('alignleft')],\n                        ['center', this.t('aligncenter')],\n                        ['right', this.t('alignright')]\n                    ],\n                    cell.style.textAlign || ''\n                );\n                this.formRow(body, this.t('tblalign'), alignSel);\n                vSel = this.formSelect(\n                    [\n                        ['', this.t('alignnone')],\n                        ['top', this.t('valigntop')],\n                        ['middle', this.t('valignmiddle')],\n                        ['bottom', this.t('valignbottom')]\n                    ],\n                    cell.style.verticalAlign || ''\n                );\n                this.formRow(body, this.t('valign'), vSel);\n                bg = this.formBg(cell.style.backgroundColor || '');\n                this.formRow(body, this.t('backcolor'), bg.wrap);\n            },\n            [\n                { label: this.t('cancel'), action: () => this.closeDlg() },\n                {\n                    label: this.t('save'),\n                    primary: true,\n                    action: () => {\n                        this.setOrClear(cell, 'width', wIn.value.trim());\n                        this.setOrClear(cell, 'height', hIn.value.trim());\n                        this.setOrClear(cell, 'text-align', alignSel.value);\n                        this.setOrClear(cell, 'vertical-align', vSel.value);\n                        this.setOrClear(cell, 'background-color', bg.fill.checked ? bg.color.value : '');\n                        this.closeDlg();\n                        this.onChange();\n                        this.positionTableHandles();\n                    }\n                }\n            ]\n        );\n    }\n\n    private rowPropsDlg(): void {\n        const cell = this.currentCell();\n        if (!cell) {\n            alert(this.t('nocell'));\n            return;\n        }\n        const row = cell.parentElement as HTMLTableRowElement;\n        let hIn: HTMLInputElement;\n        let bg: { wrap: HTMLElement; color: HTMLInputElement; fill: HTMLInputElement };\n        this.dialog(\n            this.t('rowprops').replace('…', ''),\n            (body) => {\n                hIn = this.formInput(row.style.height, 'e.g. 40px');\n                this.formRow(body, this.t('tblheight'), hIn);\n                bg = this.formBg(row.style.backgroundColor || '');\n                this.formRow(body, this.t('backcolor'), bg.wrap);\n            },\n            [\n                { label: this.t('cancel'), action: () => this.closeDlg() },\n                {\n                    label: this.t('save'),\n                    primary: true,\n                    action: () => {\n                        this.setOrClear(row, 'height', hIn.value.trim());\n                        this.setOrClear(row, 'background-color', bg.fill.checked ? bg.color.value : '');\n                        this.closeDlg();\n                        this.onChange();\n                        this.positionTableHandles();\n                    }\n                }\n            ]\n        );\n    }\n\n    private colPropsDlg(): void {\n        const cell = this.currentCell();\n        if (!cell) {\n            alert(this.t('nocell'));\n            return;\n        }\n        const row = cell.parentElement as HTMLTableRowElement;\n        const table = cell.closest('table') as HTMLTableElement;\n        const idx = Array.from(row.children).indexOf(cell);\n        const colCells = Array.from(table.rows)\n            .map((r) => r.cells[idx])\n            .filter(Boolean) as HTMLTableCellElement[];\n        let wIn: HTMLInputElement;\n        let bg: { wrap: HTMLElement; color: HTMLInputElement; fill: HTMLInputElement };\n        this.dialog(\n            this.t('colprops').replace('…', ''),\n            (body) => {\n                wIn = this.formInput(cell.style.width, 'e.g. 120px / 25%');\n                this.formRow(body, this.t('tblwidth'), wIn);\n                bg = this.formBg(cell.style.backgroundColor || '');\n                this.formRow(body, this.t('backcolor'), bg.wrap);\n            },\n            [\n                { label: this.t('cancel'), action: () => this.closeDlg() },\n                {\n                    label: this.t('save'),\n                    primary: true,\n                    action: () => {\n                        colCells.forEach((c) => {\n                            this.setOrClear(c, 'width', wIn.value.trim());\n                            this.setOrClear(c, 'background-color', bg.fill.checked ? bg.color.value : '');\n                        });\n                        this.closeDlg();\n                        this.onChange();\n                        this.positionTableHandles();\n                    }\n                }\n            ]\n        );\n    }\n\n    /* ---------------------------------------------------------- dialogs */\n    private closeDlg(): void {\n        if (this.dlgOvl) {\n            this.dlgOvl.remove();\n            this.dlgOvl = null;\n        }\n    }\n\n    private dialog(title: string, bodyBuild: (body: HTMLElement) => void, buttons?: DialogButton[]): void {\n        this.closeDlg();\n        this.closePop();\n        this.dlgOvl = document.createElement('div');\n        this.dlgOvl.className = 'ovl';\n        const d = document.createElement('div');\n        d.className = 'dlg';\n        d.dir = this.dir();\n        d.innerHTML = `<header><span>${title}</span><button type=\"button\">×</button></header>\n                   <div class=\"body\"></div><footer></footer>`;\n        (d.querySelector('header button') as HTMLButtonElement).onclick = () => this.closeDlg();\n        bodyBuild(d.querySelector('.body') as HTMLElement);\n        (buttons || [{ label: this.t('close'), primary: true, action: () => this.closeDlg() }]).forEach((b) => {\n            const btn = document.createElement('button');\n            btn.type = 'button';\n            btn.textContent = b.label;\n            if (b.primary) btn.className = 'pri';\n            btn.onclick = b.action;\n            d.querySelector('footer')!.appendChild(btn);\n        });\n        this.dlgOvl.appendChild(d);\n        this.dlgOvl.addEventListener('mousedown', (e) => {\n            if (e.target === this.dlgOvl) this.closeDlg();\n        });\n        document.body.appendChild(this.dlgOvl);\n    }\n\n    private sourceDlg(): void {\n        let ta: HTMLTextAreaElement;\n        this.dialog(\n            this.t('srcttl'),\n            (body) => {\n                ta = document.createElement('textarea');\n                ta.value = this.ed.innerHTML.replace(/></g, '>\\n<');\n                body.appendChild(ta);\n            },\n            [\n                { label: this.t('cancel'), action: () => this.closeDlg() },\n                {\n                    label: this.t('save'),\n                    primary: true,\n                    action: () => {\n                        this.ed.innerHTML = ta.value;\n                        this.closeDlg();\n                        this.onChange();\n                    }\n                }\n            ]\n        );\n    }\n\n    private helpDlg(): void {\n        this.dialog(this.t('helpttl'), (body) => {\n            const rows = [\n                ['Ctrl+B', this.t('bold')],\n                ['Ctrl+I', this.t('italic')],\n                ['Ctrl+U', this.t('underline')],\n                ['Ctrl+Z', this.t('undo')],\n                ['Ctrl+Y', this.t('redo')],\n                ['Ctrl+A', this.t('selectall')],\n                ['Alt+0', this.t('helpttl')]\n            ];\n            body.innerHTML = `<p style=\"color:#556\">${this.t('shortcuts')}</p>\n        <table class=\"kbd\">${rows.map((r) => `<tr><td>${r[1]}</td><td><kbd>${r[0]}</kbd></td></tr>`).join('')}</table>`;\n        });\n    }\n\n    private wordCountDlg(): void {\n        this.dialog(this.t('wcttl'), (body) => {\n            body.innerHTML = `<table class=\"kbd\">\n        <tr><td>${this.t('wcwords')}</td><td>${this.countWords()}</td></tr>\n        <tr><td>${this.t('wcchars')}</td><td>${this.ed.textContent?.replace(/\\s/g, '').length ?? 0}</td></tr></table>`;\n        });\n    }\n\n    private previewDlg(): void {\n        this.dialog(this.t('previewttl'), (body) => {\n            const box = document.createElement('div');\n            box.style.cssText =\n                'width:640px;max-width:78vw;max-height:52vh;overflow:auto;border:1px solid #e3e3e3;border-radius:6px;padding:14px;font-family:Helvetica,Arial,sans-serif;font-size:14px';\n            box.innerHTML = this.ed.innerHTML;\n            body.appendChild(box);\n        });\n    }\n\n    private charMap(): void {\n        this.dialog(\n            this.t('charmap').replace('…', ''),\n            (body) => {\n                const g = document.createElement('div');\n                g.className = 'chgrid';\n                CHARS.forEach((ch) => {\n                    const b = document.createElement('button');\n                    b.textContent = ch;\n                    b.onclick = () => {\n                        this.closeDlg();\n                        this.exec('insertText', ch);\n                    };\n                    g.appendChild(b);\n                });\n                body.appendChild(g);\n            }\n        );\n    }\n\n    private printDoc(): void {\n        const w = window.open('', '_blank');\n        if (!w) return;\n        w.document.write(\n            `<html dir=\"${this.dir()}\"><body style=\"font-family:Helvetica,Arial,sans-serif;font-size:14px\">${this.ed.innerHTML}</body></html>`\n        );\n        w.document.close();\n        w.focus();\n        w.print();\n    }\n\n    private pickImage(): void {\n        this.imgInput.value = '';\n        this.imgInput.click();\n    }\n\n    /* ---------------------------------------------- image upload placeholder */\n    private insertImagePlaceholder(): void {\n        this.restoreSel();\n        const id = 'img-ph-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);\n        document.execCommand(\n            'insertHTML',\n            false,\n            `<div class=\"img-ph\" id=\"${id}\" contenteditable=\"false\">${IC.image}<span>${this.t('dropimage')}</span></div>`\n        );\n        const ph = this.ed.querySelector('#' + id) as HTMLElement | null;\n        if (ph) {\n            ph.removeAttribute('id');\n            this.selectImgPlaceholder(ph);\n        }\n        this.onChange();\n    }\n\n    private clearImgPlaceholderSel(): void {\n        this.phCtx?.remove();\n        this.phCtx = null;\n        this.phActive?.classList.remove('active');\n        this.phActive = null;\n    }\n\n    private selectImgPlaceholder(ph: HTMLElement): void {\n        if (this.phActive === ph) return;\n        this.clearImgPlaceholderSel();\n        this.phActive = ph;\n        ph.classList.add('active');\n        this.phCtx = document.createElement('div');\n        this.phCtx.className = 'imgctx img-ph-ctx';\n        this.phCtx.dir = this.dir();\n        document.body.appendChild(this.phCtx);\n        this.renderPhCtxButtons();\n    }\n\n    private renderPhCtxButtons(): void {\n        const el = this.phCtx;\n        if (!el) return;\n        el.innerHTML = '';\n        el.append(\n            this.ctxBtn(IC.uploadic, this.t('uploadimg'), () => {\n                this.phUploadTarget = this.phActive;\n                this.pickImage();\n            }),\n            this.ctxBtn(IC.link, this.t('imagelink'), () => this.renderPhCtxUrlInput())\n        );\n        this.positionImgPhCtx();\n    }\n\n    private renderPhCtxUrlInput(): void {\n        const el = this.phCtx;\n        if (!el) return;\n        el.innerHTML = '';\n        const inp = document.createElement('input');\n        inp.type = 'url';\n        inp.className = 'urlinp';\n        inp.placeholder = this.t('imageurlph');\n        const ok = document.createElement('button');\n        ok.type = 'button';\n        ok.className = 'txtbtn';\n        ok.textContent = this.t('insertimg');\n        const submit = () => {\n            const url = inp.value.trim();\n            const ph = this.phActive;\n            if (!ph) return;\n            if (!/^(https?:|data:image\\/|blob:)/i.test(url)) {\n                inp.classList.add('err');\n                inp.focus();\n                return;\n            }\n            ok.disabled = true;\n            inp.disabled = true;\n            /* only place the image once the URL actually loads, so the user\n               gets a working preview instead of a broken-image icon */\n            const probe = new Image();\n            probe.onload = () => this.replacePlaceholderWithImage(ph, url, '');\n            probe.onerror = () => {\n                ok.disabled = false;\n                inp.disabled = false;\n                inp.classList.add('err');\n                inp.focus();\n            };\n            probe.src = url;\n        };\n        ok.addEventListener('click', submit);\n        inp.addEventListener('input', () => inp.classList.remove('err'));\n        inp.addEventListener('keydown', (e) => {\n            if (e.key === 'Enter') {\n                e.preventDefault();\n                submit();\n            } else if (e.key === 'Escape') {\n                e.stopPropagation();\n                this.renderPhCtxButtons();\n            }\n        });\n        el.append(inp, ok);\n        this.positionImgPhCtx();\n        inp.focus();\n    }\n\n    private readImageFileInto(file: File, ph: HTMLElement): void {\n        if (ph.classList.contains('uploading')) return;\n        if (this.imageUploadHandler) {\n            this.uploadImageFile(file, ph);\n            return;\n        }\n        const fr = new FileReader();\n        fr.onload = () => {\n            if (this.ed.contains(ph)) this.replacePlaceholderWithImage(ph, fr.result as string, file.name.replace(/\"/g, ''));\n        };\n        fr.readAsDataURL(file);\n    }\n\n    /** Runs the host-supplied imageUploadHandler instead of inlining base64,\n     *  so apps can route the file to S3 / Azure Blob / their own server. */\n    private uploadImageFile(file: File, ph: HTMLElement): void {\n        const title = file.name.replace(/\"/g, '');\n        ph.classList.remove('upload-error');\n        ph.classList.add('uploading');\n        const span = ph.querySelector('span');\n        if (span) span.textContent = this.t('uploading');\n        this.imageUploadHandler!(file)\n            .then((url) => {\n                if (!this.ed.contains(ph)) return;\n                this.replacePlaceholderWithImage(ph, url, title);\n            })\n            .catch((err) => {\n                if (!this.ed.contains(ph)) return;\n                ph.classList.remove('uploading');\n                ph.classList.add('upload-error');\n                if (span) span.textContent = this.t('uploadfailed');\n                this.onImageUploadError?.(err, file);\n            });\n    }\n\n    private replacePlaceholderWithImage(ph: HTMLElement, src: string, title: string): void {\n        const img = document.createElement('img');\n        img.src = src;\n        img.alt = '';\n        if (title) img.title = title;\n        ph.replaceWith(img);\n        if (this.phActive === ph) this.clearImgPlaceholderSel();\n        this.refreshState();\n        this.onChange();\n    }\n\n    private positionImgPhCtx(): void {\n        if (this.phActive && !document.body.contains(this.phActive)) {\n            this.clearImgPlaceholderSel();\n            return;\n        }\n        if (!this.phActive || !this.phCtx) return;\n        const r = this.phActive.getBoundingClientRect();\n        const cw = this.phCtx.offsetWidth;\n        const ch = this.phCtx.offsetHeight;\n        let cx = r.left + scrollX + (r.width - cw) / 2;\n        cx = Math.max(8 + scrollX, Math.min(cx, scrollX + innerWidth - cw - 8));\n        let cy = r.bottom + scrollY + 8;\n        if (r.bottom + 8 + ch > innerHeight - 4) cy = Math.max(this.ctxMinTop(), r.top + scrollY - ch - 8);\n        this.phCtx.style.left = cx + 'px';\n        this.phCtx.style.top = cy + 'px';\n    }\n\n    private pickWordDoc(): void {\n        this.docInput.value = '';\n        this.docInput.click();\n    }\n\n    /* ---------------------------------------------------------- fullscreen */\n    private toggleFullscreen(): void {\n        this.shell.classList.toggle('fullscreen');\n        const b = this.toolbar.querySelector('[data-id=fullscreen]') as HTMLElement | null;\n        b?.classList.toggle('on', this.shell.classList.contains('fullscreen'));\n        this.positionTableHandles();\n    }\n\n    /* ---------------------------------------------------------- table resize */\n    private clearTableHandles(): void {\n        this.tblCorner?.remove();\n        this.tblCorner = null;\n        this.tblColBars.forEach((b) => b.remove());\n        this.tblColBars = [];\n        this.tblCtx?.remove();\n        this.tblCtx = null;\n        this.tblCellMark?.remove();\n        this.tblCellMark = null;\n        this.tblOpMark?.remove();\n        this.tblOpMark = null;\n        this.tblOpMarkKind = null;\n        this.tblActive?.classList.remove('tbl-selected');\n        this.tblActive = null;\n    }\n\n    /** Blue outline around the cell that holds the caret, so it is clear\n        which cell / row / column the table operations will target. */\n    private positionCellMarker(): void {\n        if (!this.tblCellMark) return;\n        const cell = this.currentCell();\n        if (!cell || !this.tblActive || cell.closest('table') !== this.tblActive) {\n            this.tblCellMark.style.display = 'none';\n            return;\n        }\n        const r = cell.getBoundingClientRect();\n        this.tblCellMark.style.display = 'block';\n        this.tblCellMark.style.left = r.left + scrollX + 'px';\n        this.tblCellMark.style.top = r.top + scrollY + 'px';\n        this.tblCellMark.style.width = r.width + 'px';\n        this.tblCellMark.style.height = r.height + 'px';\n    }\n\n    /** Dashed highlight over the whole row / column an operation targets,\n        shown while its button or menu item is hovered. */\n    private setOpTarget(kind: 'row' | 'col' | null): void {\n        this.tblOpMarkKind = kind;\n        this.positionOpMark();\n    }\n\n    private positionOpMark(): void {\n        const kind = this.tblOpMarkKind;\n        const cell = kind ? this.currentCell() : null;\n        if (!kind || !cell || !this.tblActive || cell.closest('table') !== this.tblActive) {\n            this.tblOpMark?.remove();\n            this.tblOpMark = null;\n            return;\n        }\n        if (!this.tblOpMark) {\n            this.tblOpMark = document.createElement('div');\n            this.tblOpMark.className = 'tbl-opmark';\n            document.body.appendChild(this.tblOpMark);\n        }\n        const tr = this.tblActive.getBoundingClientRect();\n        const cr = cell.getBoundingClientRect();\n        const rr = (cell.parentElement as HTMLElement).getBoundingClientRect();\n        const left = kind === 'row' ? rr.left : cr.left;\n        const top = kind === 'row' ? rr.top : tr.top;\n        const width = kind === 'row' ? rr.width : cr.width;\n        const height = kind === 'row' ? rr.height : tr.height;\n        this.tblOpMark.style.left = left + scrollX + 'px';\n        this.tblOpMark.style.top = top + scrollY + 'px';\n        this.tblOpMark.style.width = width + 'px';\n        this.tblOpMark.style.height = height + 'px';\n    }\n\n    /** Lowest allowed top for floating context toolbars — keeps them from\n        covering the editor menubar/toolbar when the target sits on the first line. */\n    private ctxMinTop(): number {\n        return Math.max(scrollY + 4, this.ed.getBoundingClientRect().top + scrollY - 2);\n    }\n\n    private ctxBtn(icon: string, tip: string, fn: () => void, id?: string): HTMLButtonElement {\n        const b = document.createElement('button');\n        b.type = 'button';\n        b.title = tip;\n        b.innerHTML = icon;\n        if (id) b.dataset.id = id;\n        b.addEventListener('mousedown', (e) => e.preventDefault());\n        b.addEventListener('click', fn);\n        return b;\n    }\n\n    private ctxSep(): HTMLElement {\n        const s = document.createElement('div');\n        s.className = 'sep';\n        return s;\n    }\n\n    private buildTableCtxToolbar(): HTMLElement {\n        const el = document.createElement('div');\n        el.className = 'tblctx';\n        el.dir = this.dir();\n        /* hovering a row/column button highlights the row/column it targets */\n        const hl = (b: HTMLButtonElement, kind: 'row' | 'col'): HTMLButtonElement => {\n            b.addEventListener('mouseenter', () => this.setOpTarget(kind));\n            b.addEventListener('mouseleave', () => this.setOpTarget(null));\n            return b;\n        };\n        el.append(\n            hl(this.ctxBtn(IC.rowbefore, this.t('rowabove'), () => this.tableOp('rowabove')), 'row'),\n            hl(this.ctxBtn(IC.rowafter, this.t('rowbelow'), () => this.tableOp('rowbelow')), 'row'),\n            hl(this.ctxBtn(IC.rowdelete, this.t('delrow'), () => this.tableOp('delrow')), 'row'),\n            this.ctxSep(),\n            hl(this.ctxBtn(IC.colbefore, this.t('colbefore'), () => this.tableOp('colbefore')), 'col'),\n            hl(this.ctxBtn(IC.colafter, this.t('colafter'), () => this.tableOp('colafter')), 'col'),\n            hl(this.ctxBtn(IC.coldelete, this.t('delcol'), () => this.tableOp('delcol')), 'col'),\n            this.ctxSep(),\n            this.ctxBtn(IC.tabledelete, this.t('deltable'), () => this.tableOp('deltable')),\n            this.ctxBtn(IC.tableic, this.t('tablepropsttl'), () => this.tablePropsDlg())\n        );\n        document.body.appendChild(el);\n        return el;\n    }\n\n    private positionTableHandles(): void {\n        if (!this.tblActive || !document.body.contains(this.tblActive)) {\n            this.clearTableHandles();\n            return;\n        }\n        const rtl = this.ed.getAttribute('dir') === 'rtl';\n        const r = this.tblActive.getBoundingClientRect();\n        const top = r.top + scrollY;\n        const left = r.left + scrollX;\n        const right = r.right + scrollX;\n        const bottom = r.bottom + scrollY;\n        if (this.tblCorner) {\n            this.tblCorner.style.top = bottom - 5 + 'px';\n            this.tblCorner.style.left = (rtl ? left - 5 : right - 5) + 'px';\n            this.tblCorner.style.cursor = rtl ? 'nesw-resize' : 'nwse-resize';\n        }\n        if (this.tblCtx) {\n            const cw = this.tblCtx.offsetWidth;\n            const ch = this.tblCtx.offsetHeight;\n            let cx = left + (right - left) / 2 - cw / 2;\n            cx = Math.max(8 + scrollX, Math.min(cx, scrollX + innerWidth - cw - 8));\n            let cy = top - ch - 8;\n            if (cy < this.ctxMinTop()) cy = bottom + 8;\n            this.tblCtx.style.left = cx + 'px';\n            this.tblCtx.style.top = cy + 'px';\n        }\n        this.tblColBars.forEach((b) => b.remove());\n        this.tblColBars = [];\n        const row = this.tblActive.rows[0];\n        if (row) {\n            for (let i = 0; i < row.cells.length - 1; i++) {\n                const rA = row.cells[i].getBoundingClientRect();\n                const boundaryX = (rtl ? rA.left : rA.right) + scrollX;\n                const bar = document.createElement('div');\n                bar.className = 'tbl-colbar';\n                bar.style.top = top + 'px';\n                bar.style.left = boundaryX + 'px';\n                bar.style.height = bottom - top + 'px';\n                document.body.appendChild(bar);\n                bar.addEventListener('mousedown', (e) => this.startColBarDrag(e, i));\n                this.tblColBars.push(bar);\n            }\n        }\n        this.positionCellMarker();\n        this.positionOpMark();\n    }\n\n    private selectTableForResize(table: HTMLTableElement): void {\n        if (this.tblActive === table) return;\n        this.clearTableHandles();\n        this.tblActive = table;\n        table.classList.add('tbl-selected');\n        this.tblCorner = document.createElement('div');\n        this.tblCorner.className = 'tbl-handle';\n        document.body.appendChild(this.tblCorner);\n        this.tblCorner.addEventListener('mousedown', (e) => this.startTableCornerDrag(e));\n        this.tblCellMark = document.createElement('div');\n        this.tblCellMark.className = 'tbl-cellmark';\n        this.tblCellMark.style.display = 'none';\n        document.body.appendChild(this.tblCellMark);\n        this.tblCtx = this.buildTableCtxToolbar();\n        this.positionTableHandles();\n    }\n\n    private withNoTextSelect(fn: (restore: () => void) => void): void {\n        const prev = document.body.style.userSelect;\n        document.body.style.userSelect = 'none';\n        fn(() => {\n            document.body.style.userSelect = prev;\n        });\n    }\n\n    private startTableCornerDrag(e: MouseEvent): void {\n        e.preventDefault();\n        const table = this.tblActive;\n        if (!table) return;\n        const rtl = this.ed.getAttribute('dir') === 'rtl';\n        const startX = e.clientX;\n        const startW = table.getBoundingClientRect().width;\n        table.style.tableLayout = table.style.tableLayout || 'fixed';\n        this.withNoTextSelect((restore) => {\n            const mv = (ev: MouseEvent) => {\n                const dx = rtl ? -(ev.clientX - startX) : ev.clientX - startX;\n                table.style.width = Math.max(60, Math.round(startW + dx)) + 'px';\n                this.positionTableHandles();\n            };\n            const up = () => {\n                window.removeEventListener('mousemove', mv);\n                window.removeEventListener('mouseup', up);\n                restore();\n                this.onChange();\n            };\n            window.addEventListener('mousemove', mv);\n            window.addEventListener('mouseup', up);\n        });\n    }\n\n    private startColBarDrag(e: MouseEvent, i: number): void {\n        e.preventDefault();\n        e.stopPropagation();\n        const table = this.tblActive;\n        if (!table) return;\n        const rtl = this.ed.getAttribute('dir') === 'rtl';\n        const rows = Array.from(table.rows);\n        const colA = rows.map((r) => r.cells[i]).filter(Boolean) as HTMLTableCellElement[];\n        const colB = rows.map((r) => r.cells[i + 1]).filter(Boolean) as HTMLTableCellElement[];\n        if (!colA.length || !colB.length) return;\n        const startX = e.clientX;\n        const wA = colA[0].getBoundingClientRect().width;\n        const wB = colB[0].getBoundingClientRect().width;\n        table.style.tableLayout = 'fixed';\n        this.withNoTextSelect((restore) => {\n            const mv = (ev: MouseEvent) => {\n                const dx = (rtl ? -1 : 1) * (ev.clientX - startX);\n                colA.forEach((c) => (c.style.width = Math.max(24, Math.round(wA + dx)) + 'px'));\n                colB.forEach((c) => (c.style.width = Math.max(24, Math.round(wB - dx)) + 'px'));\n                this.positionTableHandles();\n            };\n            const up = () => {\n                window.removeEventListener('mousemove', mv);\n                window.removeEventListener('mouseup', up);\n                restore();\n                this.onChange();\n            };\n            window.addEventListener('mousemove', mv);\n            window.addEventListener('mouseup', up);\n        });\n    }\n\n    /* ---------------------------------------------------------- image toolbar / resize */\n    private cancelImgHide(): void {\n        if (this.imgHideTimer != null) {\n            window.clearTimeout(this.imgHideTimer);\n            this.imgHideTimer = null;\n        }\n    }\n\n    private scheduleImgHide(): void {\n        this.cancelImgHide();\n        this.imgHideTimer = window.setTimeout(() => this.clearImageHandles(), 250);\n    }\n\n    private clearImageHandles(): void {\n        this.cancelImgHide();\n        this.imgHandles.forEach((h) => h.remove());\n        this.imgHandles = [];\n        this.imgCtx?.remove();\n        this.imgCtx = null;\n        this.imgActive?.classList.remove('img-selected');\n        this.imgActive = null;\n    }\n\n    private selectImage(img: HTMLImageElement): void {\n        if (this.imgActive === img) return;\n        this.clearImageHandles();\n        this.imgActive = img;\n        img.classList.add('img-selected');\n        this.imgHandles = IMG_CORNERS.map((corner) => {\n            const h = document.createElement('div');\n            h.className = 'img-handle img-handle-' + corner;\n            h.dataset.corner = corner;\n            h.addEventListener('mousedown', (e) => this.startImageResizeDrag(e, corner));\n            h.addEventListener('mouseenter', () => this.cancelImgHide());\n            h.addEventListener('mouseleave', () => this.scheduleImgHide());\n            document.body.appendChild(h);\n            return h;\n        });\n        this.imgCtx = this.buildImageCtxToolbar(img);\n        this.positionImageHandles();\n    }\n\n    private buildImageCtxToolbar(img: HTMLImageElement): HTMLElement {\n        const el = document.createElement('div');\n        el.className = 'imgctx';\n        el.dir = this.dir();\n        const rebuild = () => {\n            const rebuilt = this.buildImageCtxToolbar(img);\n            this.imgCtx?.replaceWith(rebuilt);\n            this.imgCtx = rebuilt;\n            this.positionImageHandles();\n        };\n        const align = (a: 'left' | 'center' | 'right') => {\n            this.setImageAlign(img, a);\n            rebuild();\n        };\n        const isLeft = img.style.float === 'left';\n        const isRight = img.style.float === 'right';\n        const isCenter = !isLeft && !isRight && img.style.marginLeft === 'auto' && img.style.marginRight === 'auto';\n        const mkBtn = (icon: string, tip: string, on: boolean, fn: () => void) => {\n            const b = this.ctxBtn(icon, tip, fn);\n            b.classList.toggle('on', on);\n            return b;\n        };\n        el.append(\n            mkBtn(IC.alignleft, this.t('alignleft'), isLeft, () => align('left')),\n            mkBtn(IC.aligncenter, this.t('aligncenter'), isCenter, () => align('center')),\n            mkBtn(IC.alignright, this.t('alignright'), isRight, () => align('right')),\n            this.ctxSep(),\n            mkBtn(IC.rotateleft, this.t('rotateleft'), false, () => {\n                this.rotateImage(img, -90);\n                rebuild();\n            }),\n            mkBtn(IC.rotateright, this.t('rotateright'), false, () => {\n                this.rotateImage(img, 90);\n                rebuild();\n            }),\n            this.ctxSep(),\n            mkBtn(IC.fliphorizontal, this.t('fliphorizontal'), img.dataset.flipx === '1', () => {\n                this.flipImage(img, 'x');\n                rebuild();\n            }),\n            mkBtn(IC.flipvertical, this.t('flipvertical'), img.dataset.flipy === '1', () => {\n                this.flipImage(img, 'y');\n                rebuild();\n            }),\n            this.ctxSep(),\n            mkBtn(IC.trash, this.t('deleteimg'), false, () => {\n                img.remove();\n                this.clearImageHandles();\n                this.onChange();\n            })\n        );\n        el.addEventListener('mousedown', (e) => e.preventDefault());\n        el.addEventListener('mouseenter', () => this.cancelImgHide());\n        el.addEventListener('mouseleave', () => this.scheduleImgHide());\n        document.body.appendChild(el);\n        return el;\n    }\n\n    private setImageAlign(img: HTMLImageElement, align: 'left' | 'center' | 'right'): void {\n        img.style.float = '';\n        img.style.display = '';\n        img.style.marginLeft = '';\n        img.style.marginRight = '';\n        img.style.marginBottom = '';\n        if (align === 'left') {\n            img.style.float = 'left';\n            img.style.marginInlineEnd = '1em';\n            img.style.marginBottom = '0.5em';\n        } else if (align === 'right') {\n            img.style.float = 'right';\n            img.style.marginInlineStart = '1em';\n            img.style.marginBottom = '0.5em';\n        } else {\n            img.style.display = 'block';\n            img.style.marginLeft = 'auto';\n            img.style.marginRight = 'auto';\n        }\n        this.onChange();\n    }\n\n    private applyImgTransform(img: HTMLImageElement): void {\n        const rot = parseInt(img.dataset.rotate || '0', 10);\n        const fx = img.dataset.flipx === '1' ? -1 : 1;\n        const fy = img.dataset.flipy === '1' ? -1 : 1;\n        img.style.transform = rot || fx < 0 || fy < 0 ? `rotate(${rot}deg) scale(${fx}, ${fy})` : '';\n    }\n\n    private rotateImage(img: HTMLImageElement, delta: number): void {\n        const rot = (((parseInt(img.dataset.rotate || '0', 10) + delta) % 360) + 360) % 360;\n        img.dataset.rotate = String(rot);\n        this.applyImgTransform(img);\n        this.positionImageHandles();\n        this.onChange();\n    }\n\n    private flipImage(img: HTMLImageElement, axis: 'x' | 'y'): void {\n        const key = axis === 'x' ? 'flipx' : 'flipy';\n        img.dataset[key] = img.dataset[key] === '1' ? '' : '1';\n        this.applyImgTransform(img);\n        this.positionImageHandles();\n        this.onChange();\n    }\n\n    private positionImageHandles(): void {\n        if (!this.imgActive || !document.body.contains(this.imgActive)) {\n            this.clearImageHandles();\n            return;\n        }\n        const r = this.imgActive.getBoundingClientRect();\n        const top = r.top + scrollY;\n        const left = r.left + scrollX;\n        const right = r.right + scrollX;\n        const bottom = r.bottom + scrollY;\n        const cornerPos: Record<ImgCorner, [number, number]> = {\n            nw: [left, top],\n            ne: [right, top],\n            sw: [left, bottom],\n            se: [right, bottom]\n        };\n        this.imgHandles.forEach((h) => {\n            const [x, y] = cornerPos[h.dataset.corner as ImgCorner];\n            h.style.left = x - 5 + 'px';\n            h.style.top = y - 5 + 'px';\n        });\n        if (this.imgCtx) {\n            const cw = this.imgCtx.offsetWidth;\n            const ch = this.imgCtx.offsetHeight;\n            let cx = left + (right - left) / 2 - cw / 2;\n            cx = Math.max(8 + scrollX, Math.min(cx, scrollX + innerWidth - cw - 8));\n            let cy = top - ch - 8;\n            if (cy < this.ctxMinTop()) cy = bottom + 8;\n            this.imgCtx.style.left = cx + 'px';\n            this.imgCtx.style.top = cy + 'px';\n        }\n    }\n\n    private startImageResizeDrag(e: MouseEvent, corner: ImgCorner): void {\n        e.preventDefault();\n        const img = this.imgActive;\n        if (!img) return;\n        this.cancelImgHide();\n        const startX = e.clientX;\n        const startW = img.getBoundingClientRect().width;\n        const sign = corner === 'nw' || corner === 'sw' ? -1 : 1;\n        this.withNoTextSelect((restore) => {\n            const mv = (ev: MouseEvent) => {\n                img.style.width = Math.max(24, Math.round(startW + sign * (ev.clientX - startX))) + 'px';\n                img.style.height = 'auto';\n                this.positionImageHandles();\n            };\n            const up = () => {\n                window.removeEventListener('mousemove', mv);\n                window.removeEventListener('mouseup', up);\n                restore();\n                this.onChange();\n            };\n            window.addEventListener('mousemove', mv);\n            window.addEventListener('mouseup', up);\n        });\n    }\n\n    /* ---------------------------------------------------------- selection bubble toolbar */\n    private toggleBlock(tag: string): void {\n        this.exec('formatBlock', this.currentBlock() === tag ? '<p>' : '<' + tag + '>');\n    }\n\n    private clearSelToolbar(): void {\n        this.selCtx?.remove();\n        this.selCtx = null;\n    }\n\n    private updateSelToolbar(sel: Selection): void {\n        if (this.options.readonly || sel.isCollapsed || !sel.rangeCount) {\n            this.clearSelToolbar();\n            return;\n        }\n        const range = sel.getRangeAt(0);\n        const r = range.getBoundingClientRect();\n        if (!r.width && !r.height) {\n            this.clearSelToolbar();\n            return;\n        }\n        if (!this.selCtx) this.selCtx = this.buildSelToolbar();\n        this.positionSelToolbar(range);\n    }\n\n    private buildSelToolbar(): HTMLElement {\n        const el = document.createElement('div');\n        el.className = 'selctx';\n        el.dir = this.dir();\n        const foreBtn = this.ctxBtn(\n            '<b style=\"font:600 15px/1 Georgia,serif\">A</b><span class=\"colorbar\" data-cb=\"fore\"></span>',\n            this.t('forecolor'),\n            () => this.colorMenu(foreBtn, 'fore')\n        );\n        const backBtn = this.ctxBtn(IC.backcolor, this.t('backcolor'), () => this.colorMenu(backBtn, 'back'));\n        backBtn.querySelector('svg')?.insertAdjacentHTML('afterend', '<span class=\"colorbar\" data-cb=\"back\"></span>');\n        const caseBtn = this.ctxBtn(IC.caseic, this.t('changecase'), () => this.caseMenu(caseBtn));\n        const lhBtn = this.ctxBtn(IC.lineheight, this.t('lineheight'), () => this.lineHeightMenu(lhBtn));\n        const wsBtn = this.ctxBtn(IC.wordspacing, this.t('wordspacing'), () => this.wordSpacingMenu(wsBtn));\n        el.append(\n            this.ctxBtn(IC.bold, this.t('bold'), () => this.exec('bold'), 'bold'),\n            this.ctxBtn(IC.italic, this.t('italic'), () => this.exec('italic'), 'italic'),\n            foreBtn,\n            backBtn,\n            this.ctxSep(),\n            this.ctxBtn(IC.quote, this.t('quote'), () => this.toggleBlock('blockquote'), 'blockquote'),\n            this.ctxBtn('<b style=\"font:700 12px/1 Arial,sans-serif\">H2</b>', this.blockLabel('h2'), () => this.toggleBlock('h2'), 'h2'),\n            this.ctxBtn('<b style=\"font:700 12px/1 Arial,sans-serif\">H3</b>', this.blockLabel('h3'), () => this.toggleBlock('h3'), 'h3'),\n            this.ctxSep(),\n            this.ctxBtn(IC.link, this.t('linkttl'), () => this.linkDlg()),\n            caseBtn,\n            lhBtn,\n            wsBtn\n        );\n        el.addEventListener('mousedown', (e) => e.preventDefault());\n        document.body.appendChild(el);\n        this.syncColorSwatches(el);\n        return el;\n    }\n\n    private positionSelToolbar(range: Range): void {\n        if (!this.selCtx) return;\n        const r = range.getBoundingClientRect();\n        const top = r.top + scrollY;\n        const left = r.left + scrollX;\n        const right = r.right + scrollX;\n        const bottom = r.bottom + scrollY;\n        const cw = this.selCtx.offsetWidth;\n        const ch = this.selCtx.offsetHeight;\n        let cx = left + (right - left) / 2 - cw / 2;\n        cx = Math.max(8 + scrollX, Math.min(cx, scrollX + innerWidth - cw - 8));\n        let cy = top - ch - 8;\n        if (cy < this.ctxMinTop()) cy = bottom + 8;\n        this.selCtx.style.left = cx + 'px';\n        this.selCtx.style.top = cy + 'px';\n    }\n\n    private repositionSelToolbar(): void {\n        if (!this.selCtx) return;\n        const s = window.getSelection();\n        if (s && s.rangeCount && !s.isCollapsed && this.ed.contains(s.anchorNode)) this.positionSelToolbar(s.getRangeAt(0));\n    }\n\n    /* ---------------------------------------------------------- state sync */\n    private currentBlock(): string {\n        const s = window.getSelection();\n        if (!s || !s.anchorNode || !this.ed.contains(s.anchorNode)) return 'p';\n        const b = this.closestBlock(s.anchorNode);\n        return b ? b.tagName.toLowerCase().replace('div', 'p') : 'p';\n    }\n\n    /** Element whose computed font reflects the current caret, falling back to the editor root before any selection lands inside it. */\n    private fontRefEl(): Element {\n        const s = window.getSelection();\n        if (s && s.anchorNode && this.ed.contains(s.anchorNode)) {\n            return s.anchorNode.nodeType === 1 ? (s.anchorNode as Element) : (s.anchorNode.parentElement as Element);\n        }\n        return this.ed;\n    }\n\n    private currentFont(): string {\n        const fam = getComputedStyle(this.fontRefEl()).fontFamily.toLowerCase();\n        const hit = this.options.fontFamilyFormats.find(([n, v]) => fam.includes(v.split(',')[0].toLowerCase()));\n        return hit ? hit[0] : '';\n    }\n\n    private currentSize(): string {\n        const px = Math.round(parseFloat(getComputedStyle(this.fontRefEl()).fontSize));\n        return px > 0 ? px + 'px' : '';\n    }\n\n    private refreshState(): void {\n        const s = window.getSelection();\n        const inEd = s ? this.ed.contains(s.anchorNode) : false;\n        const blkTag = this.currentBlock();\n        const containers = [this.toolbar, this.selCtx].filter(Boolean) as HTMLElement[];\n        containers.forEach((container) => {\n            (\n                [\n                    'bold',\n                    'italic',\n                    'underline',\n                    'strikeThrough',\n                    'justifyLeft',\n                    'justifyCenter',\n                    'justifyRight',\n                    'justifyFull',\n                    'insertOrderedList',\n                    'insertUnorderedList'\n                ] as const\n            ).forEach((c) => {\n                const b = container.querySelector(`[data-id=${c}]`) as HTMLElement | null;\n                if (b) b.classList.toggle('on', inEd && document.queryCommandState(c));\n            });\n            (['h2', 'h3', 'blockquote'] as const).forEach((tag) => {\n                const b = container.querySelector(`[data-id=${tag}]`) as HTMLElement | null;\n                if (b) b.classList.toggle('on', inEd && blkTag === tag);\n            });\n        });\n        const blk = s ? this.closestBlock(s.anchorNode) : null;\n        const dir = blk?.closest('[dir]')?.getAttribute('dir') || this.ed.getAttribute('dir') || this.dir();\n        this.toolbar.querySelector('[data-id=ltr]')?.classList.toggle('on', inEd && dir === 'ltr');\n        this.toolbar.querySelector('[data-id=rtl]')?.classList.toggle('on', inEd && dir === 'rtl');\n        const setLbl = (id: string, val: string, def?: string) => {\n            const l = this.toolbar.querySelector(`[data-id=${id}] .lbl`) as HTMLElement | null;\n            if (!l) return;\n            l.textContent = val || def || '';\n            l.classList.toggle('empty', !val);\n        };\n        setLbl('fontsel', this.currentFont());\n        setLbl('sizesel', this.currentSize().replace('px', ''));\n        if (inEd) {\n            setLbl('blocksel', BLOCKS.some((b) => b[0] === blkTag) ? this.blockLabel(blkTag) : this.t('para'));\n        }\n        this.sbWords.textContent = this.countWords() + ' ' + this.t('words');\n    }\n\n    private countWords(): number {\n        const txt = (this.ed.textContent || '').trim();\n        return txt ? txt.split(/\\s+/).length : 0;\n    }\n\n    /* ---------------------------------------------------------- paste */\n    private handlePaste(e: ClipboardEvent): void {\n        const cd = e.clipboardData;\n        if (!cd) return;\n        e.preventDefault();\n        const html = cd.getData('text/html');\n        const imgItem = Array.from(cd.items).find((i) => i.type.startsWith('image/'));\n        if (imgItem && !html) {\n            const fr = new FileReader();\n            fr.onload = () => {\n                document.execCommand('insertHTML', false, `<img src=\"${fr.result}\" alt=\"\">`);\n                this.onChange();\n            };\n            fr.readAsDataURL(imgItem.getAsFile() as Blob);\n            return;\n        }\n        if (html) {\n            document.execCommand('insertHTML', false, cleanPastedHTML(html, this.dir()));\n        } else {\n            document.execCommand('insertHTML', false, normalizeTextPaste(cd.getData('text/plain')));\n        }\n        this.onChange();\n    }\n\n    /* ---------------------------------------------------------- init */\n    private initUI(): void {\n        this.closePop();\n        this.closeDlg();\n        this.clearTableHandles();\n        this.clearImgPlaceholderSel();\n        this.shell.dir = this.dir();\n        this.ed.dir = this.dir();\n        if (this.options.menubar) this.buildMenubar();\n        else this.menubar.style.display = 'none';\n        if (this.options.toolbar) this.buildToolbar();\n        else this.toolbar.style.display = 'none';\n        this.sbHelp.textContent = this.t('statushelp');\n        this.refreshState();\n    }\n}\n\nexport default FableEditor;\n"]}