@richscripts/richtexteditor 2.4.0 → 2.4.1

package/richtexteditor/plugins/tabletools.js

@@ -0,0 +1,342 @@
+if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
+
+// 2026-07-27 Table sorting and row numbering.
+//
+// TinyMCE sells both as the premium "Enhanced Tables" plugin: "This plugin is
+// only available for paid TinyMCE subscriptions". It adds sorting by column and
+// an automatic row-numbering column on top of the standard table plugin.
+//
+// Design notes:
+//   - Column type is DETECTED, not assumed. A column of prices sorts numerically
+//     even when the cells read "$1,240.00" or "(500)"; a column of dates sorts
+//     chronologically rather than as strings. Text sorting a numeric column is
+//     the classic wrong answer that puts 10 before 9.
+//   - The sort REFUSES on a table with merged body cells rather than doing it
+//     badly. A rowspan crossing rows has no meaning once the rows move; silently
+//     shredding a table the user spent an hour on is far worse than declining.
+//   - <thead> and <tfoot> never move. If a table has no <thead>, a first row
+//     that looks like a header (all <th>) is pinned anyway.
+//   - The sort is STABLE, so re-sorting by a second column preserves the order
+//     of the first — which is how people expect to sort by two things.
+RTE_DefaultConfig.plugin_tabletools = RTE_Plugin_TableTools;
+
+// "numeric" | "upper-alpha" | "lower-alpha" | "upper-roman" | "lower-roman"
+if (typeof RTE_DefaultConfig.tableNumberSeries === "undefined") RTE_DefaultConfig.tableNumberSeries = "numeric";
+// Heading placed above the numbering column.
+if (typeof RTE_DefaultConfig.tableNumberHeader === "undefined") RTE_DefaultConfig.tableNumberHeader = "#";
+
+function RTE_Plugin_TableTools() {
+    var obj = this;
+    var config, editor;
+
+    obj.PluginName = "TableTools";
+
+    obj.InitConfig = function (argconfig) { config = argconfig; };
+
+    obj.InitEditor = function (argeditor) {
+        editor = argeditor;
+
+        editor.attachEvent("exec_command_sorttable", function (state) {
+            state.returnValue = true;
+            obj.SortAtCaret(state && state.value === "desc" ? "desc" : "asc");
+        });
+        editor.attachEvent("exec_command_tablerownumbers", function (state) {
+            state.returnValue = true;
+            obj.ToggleRowNumbers();
+        });
+
+        // Public API.
+        editor.sortTableByColumn = function (index, dir) { return obj.Sort(tableAtCaret(), index, dir); };
+        editor.sortTableAtCaret = function (dir) { return obj.SortAtCaret(dir); };
+        editor.canSortTable = function () { return canSort(tableAtCaret()); };
+        editor.addTableRowNumbers = function (opts) { return obj.AddRowNumbers(opts); };
+        editor.removeTableRowNumbers = function () { return obj.RemoveRowNumbers(); };
+        editor.hasTableRowNumbers = function () {
+            var t = tableAtCaret();
+            return !!(t && t.querySelector("[data-rte-rownum]"));
+        };
+    };
+
+    function getEditable() { try { return editor.getEditable(); } catch (e) { return null; } }
+
+    // ---- locating ---------------------------------------------------------
+
+    function tableAtCaret() {
+        try {
+            var sel = editor.getSelection();
+            if (!sel || sel.rangeCount === 0) return null;
+            var n = sel.getRangeAt(0).startContainer;
+            if (n && n.nodeType === 3) n = n.parentNode;
+            var editable = getEditable();
+            while (n && n !== editable) {
+                if (n.nodeName === "TABLE") return n;
+                n = n.parentNode;
+            }
+            return null;
+        } catch (e) { return null; }
+    }
+
+    function cellAtCaret() {
+        try {
+            var sel = editor.getSelection();
+            if (!sel || sel.rangeCount === 0) return null;
+            var n = sel.getRangeAt(0).startContainer;
+            if (n && n.nodeType === 3) n = n.parentNode;
+            var editable = getEditable();
+            while (n && n !== editable) {
+                if (n.nodeName === "TD" || n.nodeName === "TH") return n;
+                n = n.parentNode;
+            }
+            return null;
+        } catch (e) { return null; }
+    }
+
+    // Rows that are allowed to move: everything except thead/tfoot and a
+    // header-looking first row.
+    function bodyRows(table) {
+        if (!table) return [];
+        var all = Array.prototype.slice.call(table.rows || []);
+        var out = [];
+        for (var i = 0; i < all.length; i++) {
+            var r = all[i];
+            var section = r.parentNode ? r.parentNode.nodeName : "";
+            if (section === "THEAD" || section === "TFOOT") continue;
+            // No <thead>: treat an all-<th> first row as the header anyway.
+            if (out.length === 0 && i === 0 && r.cells.length && allHeaderCells(r)) continue;
+            out.push(r);
+        }
+        return out;
+    }
+
+    function allHeaderCells(row) {
+        for (var i = 0; i < row.cells.length; i++) if (row.cells[i].nodeName !== "TH") return false;
+        return true;
+    }
+
+    // ---- safety -----------------------------------------------------------
+
+    function canSort(table) {
+        if (!table) return { ok: false, reason: "The caret is not inside a table." };
+        var rows = bodyRows(table);
+        if (rows.length < 2) return { ok: false, reason: "The table has fewer than two sortable rows." };
+        for (var i = 0; i < rows.length; i++) {
+            for (var c = 0; c < rows[i].cells.length; c++) {
+                var cell = rows[i].cells[c];
+                if ((cell.rowSpan || 1) > 1 || (cell.colSpan || 1) > 1) {
+                    return {
+                        ok: false,
+                        reason: "This table has merged cells. Sorting would move rows out from under a rowspan and break the table, so it has been left alone."
+                    };
+                }
+            }
+        }
+        return { ok: true, reason: "" };
+    }
+
+    // ---- value typing -----------------------------------------------------
+
+    // Detect what a cell actually holds so the comparison matches the data.
+    function cellValue(text) {
+        var t = String(text == null ? "" : text).trim();
+        if (!t) return { type: "empty", v: "" };
+        if (/\d/.test(t)) {
+            // Strip currency, spaces, thousands separators; (500) is accounting
+            // notation for negative.
+            var num = t.replace(/[\s ,]/g, "").replace(/^\(([^)]*)\)$/, "-$1").replace(/[^0-9.eE+-]/g, "");
+            if (num && /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(num)) {
+                return { type: "number", v: parseFloat(num) };
+            }
+            var d = Date.parse(t);
+            if (!isNaN(d)) return { type: "date", v: d };
+        }
+        return { type: "text", v: t.toLowerCase() };
+    }
+
+    // The column's type is whatever most of its non-empty cells are.
+    function columnType(rows, index) {
+        var counts = { number: 0, date: 0, text: 0 };
+        for (var i = 0; i < rows.length; i++) {
+            var cell = rows[i].cells[index];
+            if (!cell) continue;
+            var val = cellValue(cell.textContent);
+            if (val.type === "empty") continue;
+            counts[val.type]++;
+        }
+        if (counts.number >= counts.date && counts.number >= counts.text && counts.number > 0) return "number";
+        if (counts.date >= counts.text && counts.date > 0) return "date";
+        return "text";
+    }
+
+    // ---- sort -------------------------------------------------------------
+
+    obj.SortAtCaret = function (dir) {
+        var table = tableAtCaret();
+        var cell = cellAtCaret();
+        if (!table || !cell) return false;
+        return obj.Sort(table, cell.cellIndex, dir);
+    };
+
+    obj.Sort = function (table, index, dir) {
+        var check = canSort(table);
+        if (!check.ok) return check;
+        var descending = String(dir).toLowerCase() === "desc";
+        var rows = bodyRows(table);
+        var type = columnType(rows, index);
+
+        // Decorate with the original position so the sort is stable — the
+        // Array.prototype.sort in older engines is not guaranteed to be.
+        var decorated = [];
+        for (var i = 0; i < rows.length; i++) {
+            var cell = rows[i].cells[index];
+            decorated.push({ row: rows[i], order: i, val: cellValue(cell ? cell.textContent : "") });
+        }
+
+        decorated.sort(function (a, b) {
+            // Empty cells sink to the bottom in both directions: a blank is
+            // "no value", not "the smallest value".
+            if (a.val.type === "empty" && b.val.type === "empty") return a.order - b.order;
+            if (a.val.type === "empty") return 1;
+            if (b.val.type === "empty") return -1;
+
+            var cmp;
+            if (type === "number" || type === "date") {
+                var av = a.val.type === type ? a.val.v : Number.POSITIVE_INFINITY;
+                var bv = b.val.type === type ? b.val.v : Number.POSITIVE_INFINITY;
+                cmp = av < bv ? -1 : (av > bv ? 1 : 0);
+            } else {
+                var as = String(a.val.v), bs = String(b.val.v);
+                cmp = as.localeCompare ? as.localeCompare(bs, undefined, { numeric: true, sensitivity: "base" })
+                                       : (as < bs ? -1 : (as > bs ? 1 : 0));
+            }
+            if (cmp === 0) return a.order - b.order;      // stable
+            return descending ? -cmp : cmp;
+        });
+
+        // Re-append in the new order. Appending a row already in the table moves
+        // it, so this reorders in place without cloning (which would drop any
+        // event handlers or editor state attached to the cells).
+        var parent = decorated.length ? decorated[0].row.parentNode : null;
+        if (!parent) return { ok: false, reason: "The table has no sortable rows." };
+
+        // Moving a row that contains the caret collapses the selection, so a
+        // second sort would find no cell and silently do nothing. Remember the
+        // cell and put the caret back into it afterwards.
+        var caretCell = cellAtCaret();
+        for (var j = 0; j < decorated.length; j++) parent.appendChild(decorated[j].row);
+        restoreCaret(caretCell);
+
+        renumber(table);      // numbering is positional, so it follows the sort
+        fireChange();
+        return { ok: true, reason: "", sortedBy: index, direction: descending ? "desc" : "asc", detectedType: type };
+    };
+
+    // ---- row numbering ----------------------------------------------------
+
+    function seriesLabel(n, series) {
+        switch (String(series)) {
+            case "upper-alpha": return alpha(n).toUpperCase();
+            case "lower-alpha": return alpha(n);
+            case "upper-roman": return roman(n);
+            case "lower-roman": return roman(n).toLowerCase();
+            default: return String(n);
+        }
+    }
+
+    function alpha(n) {
+        var s = "";
+        while (n > 0) { var m = (n - 1) % 26; s = String.fromCharCode(97 + m) + s; n = Math.floor((n - 1) / 26); }
+        return s || "a";
+    }
+
+    function roman(n) {
+        var map = [[1000,"M"],[900,"CM"],[500,"D"],[400,"CD"],[100,"C"],[90,"XC"],
+                   [50,"L"],[40,"XL"],[10,"X"],[9,"IX"],[5,"V"],[4,"IV"],[1,"I"]];
+        var out = "";
+        for (var i = 0; i < map.length; i++) while (n >= map[i][0]) { out += map[i][1]; n -= map[i][0]; }
+        return out || "I";
+    }
+
+    obj.AddRowNumbers = function (opts) {
+        var table = tableAtCaret();
+        if (!table) return false;
+        if (table.querySelector("[data-rte-rownum]")) { renumber(table); return true; }
+        opts = opts || {};
+        var series = opts.series || config.tableNumberSeries;
+        var doc = table.ownerDocument;
+
+        // Header cell in every header row so the columns stay aligned.
+        var all = Array.prototype.slice.call(table.rows || []);
+        var body = bodyRows(table);
+        var bodySet = {};
+        for (var b = 0; b < body.length; b++) bodySet[rowKey(body[b])] = true;
+
+        for (var i = 0; i < all.length; i++) {
+            var row = all[i];
+            var isBody = bodySet[rowKey(row)];
+            var cell = doc.createElement(isBody ? "td" : "th");
+            cell.setAttribute("data-rte-rownum", isBody ? "value" : "header");
+            if (!isBody) cell.textContent = String(config.tableNumberHeader == null ? "#" : config.tableNumberHeader);
+            row.insertBefore(cell, row.firstChild);
+        }
+        table.setAttribute("data-rte-rownum-series", series);
+        renumber(table);
+        fireChange();
+        return true;
+    };
+
+    // rows have no stable identity across arrays, so key on position
+    var keySeq = 0;
+    function rowKey(row) {
+        if (!row.__rteKey) row.__rteKey = "r" + (keySeq++);
+        return row.__rteKey;
+    }
+
+    obj.RemoveRowNumbers = function () {
+        var table = tableAtCaret();
+        if (!table) return false;
+        var cells = table.querySelectorAll("[data-rte-rownum]");
+        if (!cells.length) return false;
+        for (var i = 0; i < cells.length; i++) if (cells[i].parentNode) cells[i].parentNode.removeChild(cells[i]);
+        table.removeAttribute("data-rte-rownum-series");
+        fireChange();
+        return true;
+    };
+
+    obj.ToggleRowNumbers = function () {
+        var table = tableAtCaret();
+        if (!table) return false;
+        return table.querySelector("[data-rte-rownum]") ? obj.RemoveRowNumbers() : obj.AddRowNumbers();
+    };
+
+    // Numbering is positional: after a sort, row 1 is whatever is now on top.
+    function renumber(table) {
+        if (!table) return;
+        var series = table.getAttribute("data-rte-rownum-series") || config.tableNumberSeries;
+        var rows = bodyRows(table);
+        var n = 1;
+        for (var i = 0; i < rows.length; i++) {
+            var cell = rows[i].querySelector("[data-rte-rownum='value']");
+            if (!cell) continue;
+            cell.textContent = seriesLabel(n++, series);
+        }
+    }
+
+    // Put a collapsed caret back into a cell that has just been moved.
+    function restoreCaret(cell) {
+        if (!cell || !cell.parentNode) return;
+        try {
+            var doc = cell.ownerDocument;
+            var r = doc.createRange();
+            r.selectNodeContents(cell);
+            r.collapse(true);
+            var sel = editor.getSelection();
+            sel.removeAllRanges();
+            sel.addRange(r);
+        } catch (e) {}
+    }
+
+    function fireChange() {
+        try { if (typeof editor.updateDesign === "function") editor.updateDesign(); } catch (e) {}
+        try { if (typeof editor.fireChange === "function") editor.fireChange(); } catch (e) {}
+    }
+}

package/richtexteditor/plugins/textdirection.js

@@ -0,0 +1,313 @@
+if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
+
+// 2026-07-28 Text direction / bidirectional text. Arabic, Hebrew, Persian and
+// Urdu are written right-to-left, and until now this editor had no way to say so
+// — no direction command, no toolbar item, not even a language string. Seventy-two
+// translation files do not help if the text still runs the wrong way.
+//
+// Design notes:
+//   - `dir` is CONTENT, not presentation. It must persist in getHTMLCode(), and
+//     it is deliberately NOT stripped around serialize the way the page-view
+//     overlay or the watermark are. A document whose direction disappeared on
+//     save would be unreadable.
+//   - Flipping direction SWAPS an explicit physical alignment. `dir` alone only
+//     changes the DEFAULT alignment, so a paragraph explicitly set to
+//     text-align:left stays hard-left in RTL and looks broken. Word swaps it;
+//     so do we.
+//   - Detection uses the first-strong algorithm, the same rule the HTML spec
+//     defines for dir="auto": the paragraph's direction is that of its first
+//     strongly-directional character, ignoring digits and punctuation.
+//   - Mixed content is isolated, not just marked. Dropping an LTR URL into an
+//     RTL sentence without isolation lets the bidi algorithm reorder the
+//     surrounding punctuation, which is how "(https://example.com)" ends up
+//     rendering with its brackets swapped.
+//
+// Not covered here: mirroring the editor's own toolbar/chrome for RTL locales.
+// That is theme work in rte_theme_default.css, not document direction.
+RTE_DefaultConfig.plugin_textdirection = RTE_Plugin_TextDirection;
+
+// "rtl" | "ltr" | null (leave the document alone)
+if (typeof RTE_DefaultConfig.defaultTextDirection === "undefined") RTE_DefaultConfig.defaultTextDirection = null;
+// Detect direction from content when HTML is loaded or pasted.
+if (typeof RTE_DefaultConfig.textDirectionAutoDetect === "undefined") RTE_DefaultConfig.textDirectionAutoDetect = false;
+// Swap an explicit left/right alignment when direction flips.
+if (typeof RTE_DefaultConfig.textDirectionSwapAlign === "undefined") RTE_DefaultConfig.textDirectionSwapAlign = true;
+
+function RTE_Plugin_TextDirection() {
+    var obj = this;
+    var config, editor;
+    var boundDoc = null;
+
+    var BLOCKS = { P: 1, DIV: 1, LI: 1, H1: 1, H2: 1, H3: 1, H4: 1, H5: 1, H6: 1,
+                   BLOCKQUOTE: 1, TD: 1, TH: 1, PRE: 1, UL: 1, OL: 1, TABLE: 1, SECTION: 1, ARTICLE: 1 };
+
+    // Strongly right-to-left ranges: Hebrew, Arabic (+ supplement, extended),
+    // Syriac, Thaana, NKo, Samaritan, Mandaic, and the Arabic presentation forms.
+    var RTL_RE = /[֐-׿؀-ۿ܀-ݏݐ-ݿހ-޿߀-߿ࠀ-࠿ࡀ-࡟ࢠ-ࣿיִ-﷿ﹰ-]/;
+    // Strongly left-to-right: Latin, Greek, Cyrillic, Armenian, and CJK/Kana
+    // (which are LTR for bidi purposes).
+    var LTR_RE = /[A-Za-zÀ-ʯͰ-֏ऀ-႟Ḁ-῿Ⰰ-ⷿ⺀-꓏가-힯]/;
+
+    obj.PluginName = "TextDirection";
+
+    obj.InitConfig = function (argconfig) { config = argconfig; };
+
+    obj.InitEditor = function (argeditor) {
+        editor = argeditor;
+
+        editor.attachEvent("exec_command_textdirection", function (state) {
+            state.returnValue = true;
+            var v = state && state.value;
+            if (v === "rtl" || v === "ltr") obj.Apply(v);
+            else obj.Toggle();
+        });
+
+        setup();
+        try { editor.attachEvent("ready", setup); } catch (e) {}
+        try { editor.attachEvent("aftersethtml", function () { setup(); afterLoad(); }); } catch (e) {}
+        setTimeout(function () { setup(); afterLoad(); }, 0);
+
+        // Public API.
+        editor.setTextDirection = function (dir) { return obj.Apply(dir); };
+        editor.toggleTextDirection = function () { return obj.Toggle(); };
+        editor.getTextDirection = function () { return obj.Current(); };
+        editor.setBaseDirection = function (dir) { return obj.Base(dir); };
+        editor.getBaseDirection = function () {
+            var ed = getEditable();
+            return ed ? (ed.getAttribute("dir") || "ltr") : "ltr";
+        };
+        editor.detectTextDirection = function (text) { return firstStrong(String(text == null ? "" : text)); };
+        editor.autoDetectTextDirection = function () { return obj.AutoDetect(); };
+        editor.isolateBidi = function (html, dir) { return obj.Isolate(html, dir); };
+        editor.insertIsolated = function (html, dir) { return obj.InsertIsolated(html, dir); };
+        editor.getTextDirectionCss = function () { return css(); };
+    };
+
+    function setup() {
+        var doc = getDoc();
+        if (!doc || doc === boundDoc) return;
+        boundDoc = doc;
+        injectStyles(doc);
+    }
+
+    function afterLoad() {
+        var ed = getEditable();
+        if (!ed) return;
+        if (config.defaultTextDirection === "rtl" || config.defaultTextDirection === "ltr") {
+            if (!ed.getAttribute("dir")) obj.Base(config.defaultTextDirection);
+        }
+        if (config.textDirectionAutoDetect) obj.AutoDetect();
+    }
+
+    function getDoc() { try { return editor.getDocument(); } catch (e) { return null; } }
+    function getEditable() { try { return editor.getEditable(); } catch (e) { return null; } }
+
+    // ---- detection -------------------------------------------------------
+
+    // First-strong: the direction of the first strongly-directional character.
+    // Digits, punctuation and whitespace are neutral and skipped, which is why
+    // "123 שלום" is RTL and "123 hello" is LTR.
+    function firstStrong(text) {
+        for (var i = 0; i < text.length; i++) {
+            var ch = text.charAt(i);
+            if (RTL_RE.test(ch)) return "rtl";
+            if (LTR_RE.test(ch)) return "ltr";
+        }
+        return "neutral";
+    }
+
+    // ---- selection -------------------------------------------------------
+
+    function blocksInSelection() {
+        var ed = getEditable();
+        var out = [];
+        try {
+            var sel = editor.getSelection();
+            if (!sel || sel.rangeCount === 0) return out;
+            var range = sel.getRangeAt(0);
+            var start = blockOf(range.startContainer);
+            var end = blockOf(range.endContainer);
+            if (!start) return out;
+            if (start === end || range.collapsed) return [start];
+
+            // Walk top-level blocks between the two endpoints.
+            var all = ed.querySelectorAll("*");
+            var collecting = false;
+            for (var i = 0; i < all.length; i++) {
+                var el = all[i];
+                if (!BLOCKS[el.nodeName]) continue;
+                if (el === start) collecting = true;
+                if (collecting && !containsBlockChild(el)) out.push(el);
+                if (el === end) break;
+            }
+            if (!out.length) out.push(start);
+        } catch (e) {}
+        return out;
+    }
+
+    // Only leaf-ish blocks get dir, so setting it on a <li> does not also stamp
+    // the parent <ul> and double-apply.
+    function containsBlockChild(el) {
+        for (var i = 0; i < el.children.length; i++) {
+            if (BLOCKS[el.children[i].nodeName]) return true;
+        }
+        return false;
+    }
+
+    function blockOf(node) {
+        var ed = getEditable();
+        var n = node && node.nodeType === 3 ? node.parentNode : node;
+        while (n && n !== ed) {
+            if (n.nodeType === 1 && BLOCKS[n.nodeName]) return n;
+            n = n.parentNode;
+        }
+        return ed && ed.firstElementChild ? ed.firstElementChild : null;
+    }
+
+    // ---- apply -----------------------------------------------------------
+
+    obj.Current = function () {
+        var b = blocksInSelection()[0];
+        if (!b) return editor.getBaseDirection ? editor.getBaseDirection() : "ltr";
+        var d = b.getAttribute("dir");
+        if (d) return d;
+        try {
+            var doc = getDoc();
+            var win = doc && (doc.defaultView || doc.parentWindow);
+            if (win) return win.getComputedStyle(b).direction || "ltr";
+        } catch (e) {}
+        return "ltr";
+    };
+
+    obj.Apply = function (dir) {
+        dir = (dir === "rtl") ? "rtl" : (dir === "auto" ? "auto" : "ltr");
+        var blocks = blocksInSelection();
+        if (!blocks.length) return false;
+        for (var i = 0; i < blocks.length; i++) {
+            var b = blocks[i];
+            var was = b.getAttribute("dir") || "ltr";
+            b.setAttribute("dir", dir);
+            if (config.textDirectionSwapAlign !== false && dir !== "auto" && was !== dir) swapAlign(b, dir);
+        }
+        fireChange();
+        return dir;
+    };
+
+    obj.Toggle = function () {
+        return obj.Apply(obj.Current() === "rtl" ? "ltr" : "rtl");
+    };
+
+    // `dir` only changes the DEFAULT alignment. An explicit text-align:left
+    // survives the flip and pins the text to the wrong edge, so swap the
+    // physical value to the mirror side.
+    function swapAlign(el, dir) {
+        var cur = (el.style && el.style.textAlign) || el.getAttribute("align") || "";
+        if (!cur) return;
+        var next = null;
+        if (cur === "left") next = "right";
+        else if (cur === "right") next = "left";
+        if (!next) return;
+        // Landing on the new direction's natural side means the explicit value
+        // is now redundant; drop it so the block follows `dir` from here on.
+        var natural = (dir === "rtl") ? "right" : "left";
+        if (el.style) el.style.textAlign = (next === natural) ? "" : next;
+        if (el.getAttribute("align")) el.removeAttribute("align");
+    }
+
+    obj.Base = function (dir) {
+        var ed = getEditable();
+        if (!ed) return false;
+        dir = (dir === "rtl") ? "rtl" : (dir === "auto" ? "auto" : "ltr");
+        ed.setAttribute("dir", dir);
+        fireChange();
+        return dir;
+    };
+
+    // Stamp each block with the direction its own text implies.
+    obj.AutoDetect = function () {
+        var ed = getEditable();
+        if (!ed) return [];
+        var out = [];
+        var all = ed.querySelectorAll("*");
+        for (var i = 0; i < all.length; i++) {
+            var el = all[i];
+            if (!BLOCKS[el.nodeName] || containsBlockChild(el)) continue;
+            var d = firstStrong(el.textContent || "");
+            if (d === "neutral") continue;          // nothing to go on: leave it
+            if (el.getAttribute("dir") === d) continue;
+            el.setAttribute("dir", d);
+            out.push({ tag: el.nodeName, dir: d });
+        }
+        if (out.length) fireChange();
+        return out;
+    };
+
+    // ---- bidi isolation --------------------------------------------------
+
+    // <bdi> isolates a run so the surrounding text's direction cannot reorder
+    // it. Without this, an LTR URL inside an RTL sentence drags the adjacent
+    // punctuation to the wrong side.
+    obj.Isolate = function (html, dir) {
+        var d = (dir === "rtl" || dir === "ltr") ? dir : "auto";
+        return '<bdi dir="' + d + '">' + String(html == null ? "" : html) + "</bdi>";
+    };
+
+    obj.InsertIsolated = function (html, dir) {
+        var doc = getDoc();
+        if (!doc) return false;
+        var span = doc.createElement("bdi");
+        span.setAttribute("dir", (dir === "rtl" || dir === "ltr") ? dir : "auto");
+        span.innerHTML = String(html == null ? "" : html);
+        try {
+            if (typeof editor.insertElement === "function") { editor.insertElement(span); fireChange(); return true; }
+        } catch (e) {}
+        try {
+            var sel = editor.getSelection();
+            if (sel && sel.rangeCount) {
+                var r = sel.getRangeAt(0);
+                r.collapse(false);
+                r.insertNode(span);
+                r.setStartAfter(span); r.collapse(true);
+                sel.removeAllRanges(); sel.addRange(r);
+                fireChange();
+                return true;
+            }
+        } catch (e) {}
+        return false;
+    };
+
+    function fireChange() {
+        try { if (typeof editor.updateDesign === "function") editor.updateDesign(); } catch (e) {}
+        try { if (typeof editor.fireChange === "function") editor.fireChange(); } catch (e) {}
+    }
+
+    // ---- styles ----------------------------------------------------------
+
+    function css() {
+        return (
+            // Lists and quotes carry their decoration on the physical side, so
+            // they need flipping too or bullets sit on the wrong edge.
+            "[dir='rtl'] ul,[dir='rtl'] ol{padding-right:1.6em;padding-left:0;}" +
+            "[dir='rtl'] blockquote{border-right:3px solid #ddd;border-left:0;" +
+            "padding-right:.9em;padding-left:0;margin-right:0;}" +
+            "[dir='rtl'] table{direction:rtl;}" +
+            // Isolation should be visually invisible.
+            "bdi{unicode-bidi:isolate;}"
+        );
+    }
+
+    function injectStyles(doc) {
+        if (!doc) return;
+        var existing = doc.getElementById("rte-textdirection-styles");
+        var text = css();
+        if (existing) {
+            if (existing.getAttribute("data-css") === text) return;
+            existing.parentNode && existing.parentNode.removeChild(existing);
+        }
+        var st = doc.createElement("style");
+        st.id = "rte-textdirection-styles";
+        st.setAttribute("data-css", text);
+        st.appendChild(doc.createTextNode(text));
+        (doc.head || doc.getElementsByTagName("head")[0] || doc.documentElement).appendChild(st);
+    }
+}