@richscripts/richtexteditor 2.5.3 → 2.6.0

package/richtexteditor/all_plugins.js

@@ -499,7 +499,13 @@ function RTE_Plugin_AccessibilityChecker() {
                 if (headingText) previousHeadingLevel = level;
             }
 
-            var images = node.querySelectorAll ? node.querySelectorAll("img") : [];
+            // querySelectorAll only returns DESCENDANTS, so an image that is
+            // itself a top-level block — which is exactly where a pasted or
+            // dropped image lands in an empty editor — was never checked, and
+            // missing alt text went unreported. The table rule below already
+            // guards this case; the image rule did not. Measured 2026-08-27:
+            // bare top-level img => 0 issues, the same img inside a <p> => 1.
+            var images = tag === "img" ? [node] : (node.querySelectorAll ? node.querySelectorAll("img") : []);
             for (var imageIndex = 0; imageIndex < images.length; imageIndex++) {
                 var image = images[imageIndex];
                 if (!String(image.getAttribute("alt") || "").replace(/^\s+|\s+$/g, "")) {
@@ -516,11 +522,33 @@ function RTE_Plugin_AccessibilityChecker() {
             var tables = tag === "table" ? [node] : (node.querySelectorAll ? node.querySelectorAll("table") : []);
             for (var tableIndex = 0; tableIndex < tables.length; tableIndex++) {
                 var table = tables[tableIndex];
-                if (!table.querySelector("th")) {
+                var tableRole = String(table.getAttribute("role") || "").toLowerCase();
+                var isLayoutTable = (tableRole === "presentation" || tableRole === "none");
+
+                // 2026-08-30 A layout table MUST NOT have headers, so demanding
+                // them here produced an error the author could never clear —
+                // which is how a checker teaches people to ignore it. Presentation
+                // tables are held to the opposite rule instead: they must not
+                // carry data-table semantics, because <th>/scope/<caption> make a
+                // screen reader announce relationships that do not exist
+                // (WCAG 1.3.1). See layouttable.js.
+                if (isLayoutTable) {
+                    var semantic = table.querySelector("th, [scope], caption") || table.getAttribute("summary");
+                    if (semantic) {
+                        issues.push({
+                            code: "layout-table-semantics",
+                            severity: "error",
+                            message: "Layout table still carries data-table markup (header cells, scope or a caption). A screen reader will announce relationships this table does not have.",
+                            path: path + ".table[" + tableIndex + "]",
+                            _target: table
+                        });
+                    }
+                }
+                else if (!table.querySelector("th")) {
                     issues.push({
                         code: "table-missing-header",
                         severity: "warning",
-                        message: "Table has no header cells. Promote the first row to headers when it describes the columns.",
+                        message: "Table has no header cells. Promote the first row to headers, or mark it as a layout table when it only positions content.",
                         path: path + ".table[" + tableIndex + "]",
                         _target: table
                     });
@@ -551,7 +579,13 @@ function RTE_Plugin_AccessibilityChecker() {
             target.parentNode.replaceChild(replacement, target);
         }
         else if (issue.code === "table-missing-header") {
-            promoteFirstTableRow(target);
+            // Two valid outcomes, and only the author knows which: the table
+            // describes data (give it headers) or only positions it (say so).
+            if (options && options.markLayout) markTableAsLayout(target);
+            else promoteFirstTableRow(target);
+        }
+        else if (issue.code === "layout-table-semantics") {
+            markTableAsLayout(target);
         }
         else if (issue.code === "language-of-parts") {
             markLanguageRuns(target, options && options.lang ? options.lang : issue._lang, issue._script);
@@ -636,6 +670,35 @@ function RTE_Plugin_AccessibilityChecker() {
         }
     }
 
+    // Delegates to layouttable.js when it is loaded so there is ONE definition of
+    // what "layout table" means; the fallback keeps the repair working in builds
+    // where that plugin was left out of the bundle.
+    function markTableAsLayout(table) {
+        if (!table) return;
+        if (editor && typeof editor.setTableLayoutMode === "function") {
+            try { editor.setTableLayoutMode("layout", table); return; } catch (e) {}
+        }
+        table.setAttribute("role", "presentation");
+        table.removeAttribute("summary");
+        var caption = table.querySelector("caption");
+        if (caption && caption.parentNode === table) caption.parentNode.removeChild(caption);
+        var cells = table.querySelectorAll("th,[scope]");
+        for (var i = 0; i < cells.length; i++) {
+            var cell = cells[i];
+            // Tables nest — do not strip the headers of a data table that
+            // happens to sit inside a cell of this one.
+            if (cell.closest && cell.closest("table") !== table) continue;
+            cell.removeAttribute("scope");
+            cell.removeAttribute("headers");
+            if (String(cell.nodeName || "").toLowerCase() !== "th") continue;
+            var td = table.ownerDocument.createElement("td");
+            while (cell.firstChild) td.appendChild(cell.firstChild);
+            copyAttributes(cell, td);
+            td.removeAttribute("scope");
+            cell.parentNode.replaceChild(td, cell);
+        }
+    }
+
     function copyAttributes(source, target) {
         if (!source || !target || !source.attributes) return;
         for (var index = 0; index < source.attributes.length; index++) {
@@ -869,7 +932,9 @@ if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
     var existing = document.querySelectorAll("link[rel=stylesheet]");
     for (var i = 0; i < existing.length; i++) {
         var href = existing[i].getAttribute("href") || "";
-        if (/(?:^|\/)aitoolkit\.css(?:\?.*)?$/i.test(href)) return;
+        // Matches the minified variant too - a host page that links either one
+        // must not get a second copy injected.
+        if (/(?:^|\/)aitoolkit(?:\.min)?\.css(?:\?.*)?$/i.test(href)) return;
     }
     // Locate our own script tag (aitoolkit.js or all_plugins.js) so we
     // can resolve aitoolkit.css next to it. Matches a custom mount path.
@@ -883,14 +948,30 @@ if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
         }
     }
     var srcAttr = ourScript ? ourScript.getAttribute("src") : "";
-    var cssHref = srcAttr
-        ? srcAttr.replace(/[^/]+$/, "aitoolkit.css")
-        : (((window.RTE_DefaultConfig && window.RTE_DefaultConfig.url_base) || "/richtexteditor") + "/plugins/aitoolkit.css");
-    if (cssHref.indexOf("?") < 0) cssHref += "?v=20260703a";
+    // Prefer the minified stylesheet. aitoolkit.css is 537 KB unminified - larger
+    // than the obfuscated rte.js - and every page that loads the AI toolkit was
+    // paying for it. The readable .css is still shipped and still the one to edit
+    // or override; this only changes what gets fetched by default.
+    function resolve(name) {
+        return srcAttr
+            ? srcAttr.replace(/[^/]+$/, name)
+            : (((window.RTE_DefaultConfig && window.RTE_DefaultConfig.url_base) || "/richtexteditor") + "/plugins/" + name);
+    }
+    function bust(href) { return href.indexOf("?") < 0 ? href + "?v=20260830a" : href; }
+
     var link = document.createElement("link");
     link.rel = "stylesheet";
-    link.href = cssHref;
+    link.href = bust(resolve("aitoolkit.min.css"));
     link.setAttribute("data-rte-auto-injected", "aitoolkit");
+    // .min.css is newer than .css. An install that predates it - an unpacked older
+    // zip, a tier the mirror missed - would otherwise lose ALL AI toolkit styling
+    // silently, which is a far worse failure than shipping the larger file. Fall
+    // back to the readable stylesheet if the minified one is not there.
+    link.onerror = function () {
+        if (link.getAttribute("data-rte-css-fallback")) return;
+        link.setAttribute("data-rte-css-fallback", "1");
+        link.href = bust(resolve("aitoolkit.css"));
+    };
     (document.head || document.documentElement).appendChild(link);
 })();
 
@@ -30895,346 +30976,758 @@ function RTE_Plugin_InsertTemplate() {
     };
 }
 
+if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
+
+// 2026-08-02 Keyboard and state accessibility for the editor CHROME.
+//
+// a11yenhance.js names the editing region and dialoga11y.js names the dialogs.
+// This closes what an audit of the running editor found still open — four
+// findings, three of them WCAG Level A:
+//
+//   1. KEYBOARD TRAP (2.1.2, Level A). Tab inside the editing area is
+//      preventDefault-ed and inserts spaces, so a keyboard-only or screen
+//      reader user who enters the editor can never leave it. Reloading the page
+//      is the only way out. This is the most serious kind of accessibility
+//      defect: it does not degrade the experience, it ends it.
+//
+//   2. TOGGLE STATE NOT EXPOSED (4.1.2, Level A). Bold, italic, underline and
+//      the alignment buttons carry their state in a CSS class
+//      (rte-command-active / rte-command-deactive) and nowhere else. Sighted
+//      users see a highlighted button; assistive technology is told nothing.
+//      Measured: 0 of 6 toggle buttons exposed aria-pressed.
+//
+//   3. POPUP STATE NOT EXPOSED (4.1.2, Level A). Buttons carry
+//      aria-haspopup but never aria-expanded, so there is no way to know
+//      whether a menu is open. Measured: 0 of 7.
+//
+//   4. EVERY TOOLBAR BUTTON IS A TAB STOP (2.4.3, and plain usability).
+//      Measured 53. The ARIA Authoring Practices toolbar pattern is a single
+//      tab stop per toolbar with arrow keys moving between buttons. 53 presses
+//      of Tab to reach the text you came to write is not operable in any
+//      meaningful sense.
+//
+// All four are fixed here rather than in the core, so they ship without a
+// re-obfuscation cycle.
+//
+// Config:
+//   config.keyboardA11y = false            // opt out entirely
+//   config.a11yEscapeHint = "..."          // wording appended to the editing area's name
+//   config.a11yEditorLabel = "..."        // accessible NAME of the editing area (default "Rich text editor")
+//   config.a11yRovingToolbar = false       // keep every button as a tab stop
+RTE_DefaultConfig.plugin_keyboarda11y = RTE_Plugin_KeyboardA11y;
+if (typeof RTE_DefaultConfig.keyboardA11y === "undefined") RTE_DefaultConfig.keyboardA11y = true;
+
+function RTE_Plugin_KeyboardA11y() {
+    var obj = this;
+    var config, editor;
+    var observers = [];
+    var popupOwner = null;          // last activated [aria-haspopup]
+    var openPanels = [];            // [{ panel, owner }]
+
+    obj.PluginName = "KeyboardA11y";
+
+    obj.InitConfig = function (argconfig) { config = argconfig; };
+
+    obj.InitEditor = function (argeditor) {
+        editor = argeditor;
+        if (config.keyboardA11y === false) return;
+
+        editor.focusToolbar = function () { return focusFirstToolbarButton(); };
+
+        setup();
+        try { editor.attachEvent("ready", setup); } catch (e) {}
+        // The toolbar is built asynchronously; a deferred pass catches the case
+        // where InitEditor runs before it exists.
+        setTimeout(setup, 0);
+        setTimeout(setup, 400);
+    };
+
+    function shell() {
+        try {
+            var ed = editor.getEditable();
+            if (!ed) return null;
+            var win = ed.ownerDocument.defaultView;
+            var node = (win && win.frameElement) ? win.frameElement : ed;
+            while (node && node.classList && !node.classList.contains("richtexteditor")) node = node.parentNode;
+            return (node && node.classList) ? node : null;
+        } catch (e) { return null; }
+    }
+
+    function setup() {
+        var root = shell();
+        if (!root) return;
+        bindEscapeHatch();
+        applyRovingTabindex(root);
+        syncToggleStates(root);
+        trackPopups(root);
+        watch(root);
+    }
+
+    // ---------------------------------------------------- 1. keyboard trap
+    //
+    // Tab keeps its editing meaning (indent, next table cell) because that is
+    // what writers expect and what every other editor does. The escape is a
+    // separate, documented key: Escape leaves the editing area and puts focus
+    // on the toolbar, from which Tab continues through the page normally.
+    //
+    // Escape is only intercepted when nothing is open — a dialog or dropdown
+    // must still get its own Escape first, or closing a colour picker would
+    // throw the user out of the editor.
+    // Bound on the DOCUMENT rather than on the body element. Escape bubbles, so
+    // one listener at document level covers the editing area no matter how the
+    // surface is re-created, and it does not depend on a marker flag pinned to a
+    // particular element surviving. Defensive only: no shipped operation is known
+    // to replace the editing body — setHTML, htmlview, fullscreen, readingmode,
+    // preview and toggleborder all preserve its identity (measured 2026-08-27).
+    // Keeping the binding here costs nothing and removes an assumption, but it
+    // fixes no known live defect; do not describe it as a bug fix.
+    function bindEscapeHatch() {
+        var ed, doc;
+        try { ed = editor.getEditable(); doc = ed && ed.ownerDocument; } catch (e) { return; }
+        if (!ed || !doc) return;
+
+        if (!doc.__rteEscapeHatch) {
+            doc.__rteEscapeHatch = true;
+            doc.addEventListener("keydown", function (e) {
+                if (e.key !== "Escape" && e.keyCode !== 27) return;
+                if (anythingOpen()) return;           // let the panel close itself
+                e.preventDefault();
+                e.stopPropagation();
+                if (!focusFirstToolbarButton()) focusAfterEditor();
+            }, false);
+
+            // Deliberately not re-asserting the body's aria-label here. An
+            // earlier version did, on the theory that the editing body could be
+            // replaced underneath us; that mechanism was retracted 2026-08-27
+            // after it turned out to be an instrumentation artefact, and
+            // editor.getEditable() is verified to return the live, connected
+            // body on every shipped path. announceEscape() at the end of this
+            // function is sufficient.
+        }
+
+        announceEscape(ed);
+    }
+
+    function anythingOpen() {
+        try {
+            var panels = document.querySelectorAll("rte-dropdown-panel, rte-dialog-float, rte-floatpanel");
+            for (var i = 0; i < panels.length; i++) {
+                var s = getComputedStyle(panels[i]);
+                if (s.display !== "none" && s.visibility !== "hidden") return true;
+            }
+        } catch (e) {}
+        return false;
+    }
+
+    // The way out has to be discoverable, or it may as well not exist. The
+    // editing region's accessible name is the one thing a screen reader always
+    // announces on entry, so the hint goes there rather than into the content.
+    //
+    // But an instruction is not a NAME. When the host page had not labelled the
+    // editing area, appending the hint to an empty label left the region's
+    // accessible name as nothing but "Press Escape to leave the editing area." —
+    // a screen reader then told the user how to LEAVE a field without ever
+    // saying what it was, and two editors on one page were indistinguishable.
+    // So: a host-supplied label still wins as the name; otherwise we supply a
+    // real one and the hint follows it.
+    function announceEscape(ed) {
+        var hint = config.a11yEscapeHint ||
+            "Press Escape to leave the editing area.";
+        var label = ed.getAttribute("aria-label") || "";
+        if (label.indexOf(hint) >= 0) return;
+        var name = label || config.a11yEditorLabel || "Rich text editor";
+        ed.setAttribute("aria-label", name.replace(/\s*$/, "") + " " + hint);
+    }
+
+    function focusAfterEditor() {
+        var root = shell();
+        if (!root) return false;
+        var all = [].slice.call(document.querySelectorAll(
+            'a[href],button,input,select,textarea,[tabindex]:not([tabindex="-1"])'
+        )).filter(function (el) {
+            return !root.contains(el) && el.offsetParent !== null;
+        });
+        // The first focusable that follows the editor in document order.
+        for (var i = 0; i < all.length; i++) {
+            if (root.compareDocumentPosition(all[i]) & Node.DOCUMENT_POSITION_FOLLOWING) {
+                all[i].focus();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // ------------------------------------------------- 4. roving tabindex
+    function toolbarsIn(root) {
+        return [].slice.call(root.querySelectorAll('[role="toolbar"]'));
+    }
+    // Toolbars nest — an overflow or ribbon toolbar sits inside the main one.
+    // A plain descendant query therefore makes the outer toolbar claim the
+    // inner one's buttons, and the two passes fight: the first run measured two
+    // tab stops in one toolbar and NONE in the other two, which left those
+    // buttons unreachable by keyboard altogether. Each button belongs to its
+    // NEAREST toolbar and to no other.
+    function buttonsIn(bar) {
+        return [].slice.call(bar.querySelectorAll('[role="button"]')).filter(function (b) {
+            if (b.getAttribute("aria-disabled") === "true") return false;
+            if (b.offsetParent === null) return false;                 // hidden: not reachable anyway
+            return (b.closest && b.closest('[role="toolbar"]')) === bar;
+        });
+    }
+
+    function applyRovingTabindex(root) {
+        if (config.a11yRovingToolbar === false) return;
+        var bars = toolbarsIn(root);
+        for (var i = 0; i < bars.length; i++) {
+            (function (bar) {
+                var btns = buttonsIn(bar);
+                if (!btns.length) return;
+                // Exactly one tab stop per toolbar, which is the ARIA pattern.
+                var current = btns.filter(function (b) { return b.getAttribute("tabindex") === "0"; })[0] || btns[0];
+                for (var j = 0; j < btns.length; j++) btns[j].setAttribute("tabindex", btns[j] === current ? "0" : "-1");
+
+                if (bar.__rteRoving) return;
+                bar.__rteRoving = true;
+                bar.addEventListener("keydown", function (e) {
+                    var list = buttonsIn(bar);
+                    var at = list.indexOf(document.activeElement);
+                    if (at < 0) return;
+                    var rtl = (bar.closest && bar.closest('[dir="rtl"]')) ? true : false;
+                    var next = null;
+                    if (e.key === "ArrowRight") next = list[(at + (rtl ? -1 : 1) + list.length) % list.length];
+                    else if (e.key === "ArrowLeft") next = list[(at + (rtl ? 1 : -1) + list.length) % list.length];
+                    else if (e.key === "Home") next = list[0];
+                    else if (e.key === "End") next = list[list.length - 1];
+                    else return;
+                    e.preventDefault();
+                    for (var k = 0; k < list.length; k++) list[k].setAttribute("tabindex", list[k] === next ? "0" : "-1");
+                    next.focus();
+                }, false);
+                // Clicking a button makes it the new tab stop, so returning by
+                // Tab lands where the user last was.
+                bar.addEventListener("focusin", function (e) {
+                    var list = buttonsIn(bar);
+                    if (list.indexOf(e.target) < 0) return;
+                    for (var k = 0; k < list.length; k++) list[k].setAttribute("tabindex", list[k] === e.target ? "0" : "-1");
+                }, false);
+            })(bars[i]);
+        }
+    }
+
+    function focusFirstToolbarButton() {
+        var root = shell();
+        if (!root) return false;
+        var bars = toolbarsIn(root);
+        for (var i = 0; i < bars.length; i++) {
+            var btns = buttonsIn(bars[i]);
+            if (!btns.length) continue;
+            var target = btns.filter(function (b) { return b.getAttribute("tabindex") === "0"; })[0] || btns[0];
+            target.focus();
+            return true;
+        }
+        return false;
+    }
+
+    // ------------------------------------------------- 2. aria-pressed
+    //
+    // The editor already tracks active state — it just keeps it in a class.
+    // Mirroring rather than recomputing means the announced state can never
+    // disagree with the highlighted button.
+    // Command names here must match the TOOLBAR command exactly — the regex is
+    // anchored, so a near-miss is a silent no-op that looks like coverage.
+    // "blockquote" is one: the command is `insertblockquote`, so the entry
+    // written specifically for it never matched and that button ships with no
+    // aria-pressed. Found by checking every genuine toggle on the full toolbar
+    // rather than the three the published verify page samples.
+    //
+    // This mirror only copies the editor's own active state, so a command may
+    // only be listed here once core actually tracks it. Emitting the attribute
+    // for an untracked command yields a permanent aria-pressed="false" —
+    // confidently announcing "not pressed" while the formatting IS applied,
+    // which makes announced state DISAGREE with the highlight. That is the exact
+    // failure this mirror exists to prevent, so silence beats a wrong answer.
+    //   - `toggleborder` was already tracked (core checks the editable's
+    //     rte-toggleborder class); it reads inactive simply when borders are off.
+    //   - `insertblockquote` was NOT tracked and now is, via a core case added
+    //     alongside `indent`, which resolves the same way.
+    // Both verified on the running editor rather than inferred.
+    //
+    // `inlinecode`, `pagination`, `typewriter` and `focusmode` match nothing in
+    // this build, and now the reason is known rather than assumed: pagination.js
+    // and typewriter.js are API-only (togglePageView / toggleTypewriterMode …)
+    // and register no toolbar command, and insertcode.js registers `insertcode`,
+    // which inserts a block rather than toggling the selection. They are kept —
+    // harmless, and correct the moment a toolbar button is added — but they
+    // cover nothing today, so do not read this list as evidence of coverage.
+    var TOGGLE_CMD = /^(bold|italic|underline|strikethrough|subscript|superscript|justifyleft|justifycenter|justifyright|justifyfull|insertorderedlist|insertunorderedlist|outdent|indent|insertblockquote|toggleborder|inlinecode|trackchanges|typewriter|focusmode|pagination|formattingmarks|linenumbers|permanentpen|rtlui)$/;
+
+    function syncToggleStates(root) {
+        var btns = [].slice.call(root.querySelectorAll('[role="button"][rte-cmd-name]'));
+        for (var i = 0; i < btns.length; i++) {
+            var cmd = (btns[i].getAttribute("rte-cmd-name") || "").toLowerCase();
+            if (!TOGGLE_CMD.test(cmd)) continue;
+            var active = btns[i].classList.contains("rte-command-active");
+            var pressed = active ? "true" : "false";
+            if (btns[i].getAttribute("aria-pressed") !== pressed) btns[i].setAttribute("aria-pressed", pressed);
+        }
+    }
+
+    // ------------------------------------------------- 3. aria-expanded
+    //
+    // Opening a menu inserts an <rte-dropdown-panel> elsewhere in the document
+    // and leaves the button untouched, so the button and its panel have to be
+    // correlated: remember which popup button was activated, then pair it with
+    // the panel that appears.
+    function trackPopups(root) {
+        var pops = [].slice.call(root.querySelectorAll("[aria-haspopup]"));
+        for (var i = 0; i < pops.length; i++) {
+            if (!pops[i].hasAttribute("aria-expanded")) pops[i].setAttribute("aria-expanded", "false");
+            if (pops[i].__rtePopupBound) continue;
+            pops[i].__rtePopupBound = true;
+            (function (el) {
+                function remember() { popupOwner = el; }
+                el.addEventListener("mousedown", remember, true);
+                el.addEventListener("keydown", function (e) {
+                    if (e.key === "Enter" || e.key === " " || e.key === "ArrowDown") remember();
+                }, true);
+            })(pops[i]);
+        }
+
+        if (trackPopups.bound) return;
+        trackPopups.bound = true;
+        var mo = new MutationObserver(function (records) {
+            for (var r = 0; r < records.length; r++) {
+                var rec = records[r];
+                for (var a = 0; a < rec.addedNodes.length; a++) {
+                    var n = rec.addedNodes[a];
+                    if (n.nodeType !== 1 || !isPanel(n)) continue;
+                    if (popupOwner) {
+                        popupOwner.setAttribute("aria-expanded", "true");
+                        openPanels.push({ panel: n, owner: popupOwner });
+                        popupOwner = null;
+                    }
+                }
+                for (var d = 0; d < rec.removedNodes.length; d++) {
+                    var m = rec.removedNodes[d];
+                    if (m.nodeType !== 1 || !isPanel(m)) continue;
+                    for (var k = openPanels.length - 1; k >= 0; k--) {
+                        if (openPanels[k].panel === m) {
+                            openPanels[k].owner.setAttribute("aria-expanded", "false");
+                            openPanels.splice(k, 1);
+                        }
+                    }
+                }
+            }
+        });
+        mo.observe(document.body, { childList: true, subtree: true });
+        observers.push(mo);
+    }
+    function isPanel(el) {
+        var t = (el.tagName || "").toLowerCase();
+        return t === "rte-dropdown-panel" || t === "rte-floatpanel" || t === "rte-dialog-float";
+    }
+
+    // Toolbar buttons are rebuilt and re-classed as the selection moves, so the
+    // mirrored state has to follow rather than be set once.
+    function watch(root) {
+        if (root.__rteA11yWatch) return;
+        root.__rteA11yWatch = true;
+        var pending = null;
+        var mo = new MutationObserver(function () {
+            if (pending) return;
+            pending = setTimeout(function () {
+                pending = null;
+                syncToggleStates(root);
+                applyRovingTabindex(root);
+                trackPopups(root);
+            }, 60);
+        });
+        mo.observe(root, { subtree: true, childList: true, attributes: true, attributeFilter: ["class", "aria-disabled"] });
+        observers.push(mo);
+    }
+}
+
 if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
 
-// 2026-08-02 Keyboard and state accessibility for the editor CHROME.
-//
-// a11yenhance.js names the editing region and dialoga11y.js names the dialogs.
-// This closes what an audit of the running editor found still open — four
-// findings, three of them WCAG Level A:
+// 2026-08-30 Layout tables — say whether a table carries data or only geometry.
 //
-//   1. KEYBOARD TRAP (2.1.2, Level A). Tab inside the editing area is
-//      preventDefault-ed and inserts spaces, so a keyboard-only or screen
-//      reader user who enters the editor can never leave it. Reloading the page
-//      is the only way out. This is the most serious kind of accessibility
-//      defect: it does not degrade the experience, it ends it.
+// Found by re-sweeping CKEditor 5's feature pages (they ship `layout-tables`);
+// TinyMCE has no equivalent. Every other editor treats <table> as one thing.
+// It is two:
 //
-//   2. TOGGLE STATE NOT EXPOSED (4.1.2, Level A). Bold, italic, underline and
-//      the alignment buttons carry their state in a CSS class
-//      (rte-command-active / rte-command-deactive) and nowhere else. Sighted
-//      users see a highlighted button; assistive technology is told nothing.
-//      Measured: 0 of 6 toggle buttons exposed aria-pressed.
+//   * a DATA table states relationships — this cell is described by that header —
+//     and a screen reader announces them on every cell;
+//   * a LAYOUT table states nothing. Newsletters, signatures and pre-CSS page
+//     furniture use it purely for geometry, and the correct markup is
+//     role="presentation", which tells assistive technology to read the cells as
+//     plain flow content instead of narrating a fake grid.
 //
-//   3. POPUP STATE NOT EXPOSED (4.1.2, Level A). Buttons carry
-//      aria-haspopup but never aria-expanded, so there is no way to know
-//      whether a menu is open. Measured: 0 of 7.
+// Using one where the other is meant is a real WCAG 1.3.1 failure, not a style
+// preference: a layout table with <th>/scope/<caption> makes a screen reader
+// announce column headers that describe nothing.
 //
-//   4. EVERY TOOLBAR BUTTON IS A TAB STOP (2.4.3, and plain usability).
-//      Measured 53. The ARIA Authoring Practices toolbar pattern is a single
-//      tab stop per toolbar with arrow keys moving between buttons. 53 presses
-//      of Tab to reach the text you came to write is not operable in any
-//      meaningful sense.
+// It also fixes a false alarm we were shipping. `accessibilitychecker.js` raised
+// `table-missing-header` on EVERY table without a <th>, so an email layout — which
+// must not have one — produced a permanent error the author could never clear. A
+// checker that cannot be satisfied teaches people to ignore it, so the rule now
+// skips presentation tables and instead flags the genuine fault: a layout table
+// that still carries data-table semantics.
 //
-// All four are fixed here rather than in the core, so they ship without a
-// re-obfuscation cycle.
-//
-// Config:
-//   config.keyboardA11y = false            // opt out entirely
-//   config.a11yEscapeHint = "..."          // wording appended to the editing area's name
-//   config.a11yRovingToolbar = false       // keep every button as a tab stop
-RTE_DefaultConfig.plugin_keyboarda11y = RTE_Plugin_KeyboardA11y;
-if (typeof RTE_DefaultConfig.keyboardA11y === "undefined") RTE_DefaultConfig.keyboardA11y = true;
-
-function RTE_Plugin_KeyboardA11y() {
+// Design notes:
+//   - role="presentation" is the whole marker. No vendor class is added, so the
+//     exported HTML gains nothing this editor has to own; `role=none` is the ARIA
+//     synonym and is accepted on read, though we always write "presentation"
+//     because Outlook-era mail clients are more likely to have heard of it.
+//   - The dashed outline is injected into the EDITING document only (a <style> in
+//     the iframe head, like formattingmarks.js), never into the content. A layout
+//     table is invisible by design; without an affordance the author cannot see
+//     the thing they are editing.
+//   - Tables nest. Marking the outer table layout must not strip the headers of a
+//     data table sitting inside one of its cells, so every walk is restricted to
+//     cells whose nearest ancestor table is this one.
+//   - Converting <th> to <td> loses information. Which cells were headers is
+//     remembered per table in a WeakMap so an accidental toggle is reversible in
+//     the session, and that memory is deliberately NOT written into the markup —
+//     restoring it is a convenience, not a document property. Reloaded documents
+//     therefore restore nothing; `promoteFirstRow` is offered for that case.
+RTE_DefaultConfig.plugin_layouttable = RTE_Plugin_LayoutTable;
+
+// Show a dashed outline around layout tables while editing.
+if (typeof RTE_DefaultConfig.layoutTableOutline === "undefined") RTE_DefaultConfig.layoutTableOutline = true;
+
+function RTE_Plugin_LayoutTable() {
     var obj = this;
     var config, editor;
-    var observers = [];
-    var popupOwner = null;          // last activated [aria-haspopup]
-    var openPanels = [];            // [{ panel, owner }]
+    var headerMemory = (typeof WeakMap === "function") ? new WeakMap() : null;
 
-    obj.PluginName = "KeyboardA11y";
+    obj.PluginName = "LayoutTable";
 
     obj.InitConfig = function (argconfig) { config = argconfig; };
 
     obj.InitEditor = function (argeditor) {
         editor = argeditor;
-        if (config.keyboardA11y === false) return;
 
-        editor.focusToolbar = function () { return focusFirstToolbarButton(); };
+        editor.attachEvent("exec_command_tablelayoutmode", function (state) {
+            state.returnValue = true;
+            obj.SetMode(tableAtCaret(), "layout");
+        });
+        editor.attachEvent("exec_command_tabledatamode", function (state) {
+            state.returnValue = true;
+            obj.SetMode(tableAtCaret(), "data");
+        });
+        editor.attachEvent("exec_command_toggletablelayout", function (state) {
+            state.returnValue = true;
+            obj.Toggle();
+        });
+        editor.attachEvent("exec_command_insertlayouttable", function (state) {
+            state.returnValue = true;
+            obj.InsertLayoutTable();
+        });
 
-        setup();
-        try { editor.attachEvent("ready", setup); } catch (e) {}
-        // The toolbar is built asynchronously; a deferred pass catches the case
-        // where InitEditor runs before it exists.
-        setTimeout(setup, 0);
-        setTimeout(setup, 400);
-    };
+        // Public API.
+        editor.setTableLayoutMode = function (mode, table, options) {
+            return obj.SetMode(table || tableAtCaret(), mode, options);
+        };
+        editor.getTableLayoutMode = function (table) {
+            var t = table || tableAtCaret();
+            return t ? (isLayout(t) ? "layout" : "data") : null;
+        };
+        editor.isLayoutTable = function (table) { return isLayout(table || tableAtCaret()); };
+        editor.toggleTableLayoutMode = function () { return obj.Toggle(); };
+        editor.insertLayoutTable = function (rows, cols, options) {
+            return obj.InsertLayoutTable(rows, cols, options);
+        };
+        editor.listLayoutTables = function () {
+            var ed = getEditable();
+            if (!ed) return [];
+            var out = [], all = ed.getElementsByTagName("table");
+            for (var i = 0; i < all.length; i++) if (isLayout(all[i])) out.push(all[i]);
+            return out;
+        };
+        editor.showLayoutTableOutlines = function (on) {
+            outlineOn = (on !== false);
+            injectStyles(editableDoc());
+            return outlineOn;
+        };
 
-    function shell() {
         try {
-            var ed = editor.getEditable();
-            if (!ed) return null;
-            var win = ed.ownerDocument.defaultView;
-            var node = (win && win.frameElement) ? win.frameElement : ed;
-            while (node && node.classList && !node.classList.contains("richtexteditor")) node = node.parentNode;
-            return (node && node.classList) ? node : null;
-        } catch (e) { return null; }
+            if (config && typeof config.layoutTableOutline !== "undefined") outlineOn = !!config.layoutTableOutline;
+        } catch (e) {}
+        injectStyles(editableDoc());
+        try {
+            editor.attachEvent("editor_ready", function () { injectStyles(editableDoc()); });
+            editor.attachEvent("update_design", function () { injectStyles(editableDoc()); });
+        } catch (e) {}
+    };
+
+    var outlineOn = true;
+
+    // ---------------------------------------------------------------- commands
+
+    obj.SetMode = function (table, mode, options) {
+        if (!table) return null;
+        if (String(mode).toLowerCase() === "layout") return toLayout(table);
+        return toData(table, options);
+    };
+
+    obj.Toggle = function () {
+        var t = tableAtCaret();
+        if (!t) return null;
+        return isLayout(t) ? toData(t) : toLayout(t);
+    };
+
+    obj.InsertLayoutTable = function (rows, cols, options) {
+        var doc = editableDoc();
+        if (!doc) return null;
+        rows = Math.max(1, parseInt(rows, 10) || 2);
+        cols = Math.max(1, parseInt(cols, 10) || 2);
+        options = options || {};
+
+        var table = doc.createElement("table");
+        table.setAttribute("role", "presentation");
+        // The three attributes every email layout table needs; without
+        // border-collapse the cells show a 2px gap in Outlook.
+        table.setAttribute("cellpadding", "0");
+        table.setAttribute("cellspacing", "0");
+        table.style.width = options.width || "100%";
+        table.style.borderCollapse = "collapse";
+
+        var tbody = doc.createElement("tbody");
+        for (var r = 0; r < rows; r++) {
+            var tr = doc.createElement("tr");
+            for (var c = 0; c < cols; c++) {
+                var td = doc.createElement("td");
+                td.style.verticalAlign = "top";
+                td.appendChild(doc.createElement("br"));
+                tr.appendChild(td);
+            }
+            tbody.appendChild(tr);
+        }
+        table.appendChild(tbody);
+
+        insertAtCaret(table, doc);
+        injectStyles(doc);
+        fireChange();
+        return table;
+    };
+
+    // ------------------------------------------------------------- conversions
+
+    function toLayout(table) {
+        table.setAttribute("role", "presentation");
+
+        // A caption is announced as the table's name; a layout table has no name
+        // to announce. Keep the text — it is content the author typed — by moving
+        // it out into a paragraph before the table rather than deleting it.
+        var caption = firstOwnChild(table, "caption");
+        if (caption) {
+            var text = String(caption.textContent || "").replace(/^\s+|\s+$/g, "");
+            if (text) {
+                var p = table.ownerDocument.createElement("p");
+                while (caption.firstChild) p.appendChild(caption.firstChild);
+                if (table.parentNode) table.parentNode.insertBefore(p, table);
+            }
+            caption.parentNode.removeChild(caption);
+        }
+
+        table.removeAttribute("summary");
+
+        var cells = ownCells(table), converted = [];
+        for (var i = 0; i < cells.length; i++) {
+            var cell = cells[i];
+            cell.removeAttribute("scope");
+            cell.removeAttribute("headers");
+            cell.removeAttribute("abbr");
+            if (cell.nodeName === "TH") {
+                var td = rename(cell, "td");
+                converted.push(td);
+            }
+        }
+        if (headerMemory && converted.length) headerMemory.set(table, converted);
+
+        // <thead> on a layout table is harmless to AT once role=presentation is
+        // set, but it makes the markup lie to the next human who reads it.
+        var thead = firstOwnChild(table, "thead");
+        if (thead) unwrapSection(table, thead);
+
+        fireChange();
+        return table;
     }
 
-    function setup() {
-        var root = shell();
-        if (!root) return;
-        bindEscapeHatch();
-        applyRovingTabindex(root);
-        syncToggleStates(root);
-        trackPopups(root);
-        watch(root);
+    function toData(table, options) {
+        table.removeAttribute("role");
+
+        var restored = headerMemory ? headerMemory.get(table) : null;
+        var promoted = false;
+        if (restored && restored.length) {
+            for (var i = 0; i < restored.length; i++) {
+                var cell = restored[i];
+                // The cell may have been deleted, or the whole table replaced,
+                // since it was remembered.
+                if (cell && cell.parentNode && contains(table, cell)) {
+                    rename(cell, "th");
+                    promoted = true;
+                }
+            }
+            headerMemory["delete"](table);
+        }
+        if (!promoted && options && options.promoteFirstRow) promoteFirstRow(table);
+
+        fireChange();
+        return table;
     }
 
-    // ---------------------------------------------------- 1. keyboard trap
-    //
-    // Tab keeps its editing meaning (indent, next table cell) because that is
-    // what writers expect and what every other editor does. The escape is a
-    // separate, documented key: Escape leaves the editing area and puts focus
-    // on the toolbar, from which Tab continues through the page normally.
-    //
-    // Escape is only intercepted when nothing is open — a dialog or dropdown
-    // must still get its own Escape first, or closing a colour picker would
-    // throw the user out of the editor.
-    function bindEscapeHatch() {
-        var ed;
-        try { ed = editor.getEditable(); } catch (e) { return; }
-        if (!ed || ed.__rteEscapeHatch) return;
-        ed.__rteEscapeHatch = true;
+    function promoteFirstRow(table) {
+        var rows = ownRows(table);
+        if (!rows.length) return;
+        var cells = rowCells(rows[0]);
+        for (var i = 0; i < cells.length; i++) {
+            var th = rename(cells[i], "th");
+            th.setAttribute("scope", "col");
+        }
+    }
 
-        ed.addEventListener("keydown", function (e) {
-            if (e.key !== "Escape" && e.keyCode !== 27) return;
-            if (anythingOpen()) return;           // let the panel close itself
-            e.preventDefault();
-            e.stopPropagation();
-            if (!focusFirstToolbarButton()) focusAfterEditor();
-        }, false);
+    // ------------------------------------------------------------------ helpers
 
-        announceEscape(ed);
+    function isLayout(table) {
+        if (!table || table.nodeName !== "TABLE") return false;
+        var role = String(table.getAttribute("role") || "").toLowerCase();
+        return role === "presentation" || role === "none";
     }
 
-    function anythingOpen() {
-        try {
-            var panels = document.querySelectorAll("rte-dropdown-panel, rte-dialog-float, rte-floatpanel");
-            for (var i = 0; i < panels.length; i++) {
-                var s = getComputedStyle(panels[i]);
-                if (s.display !== "none" && s.visibility !== "hidden") return true;
-            }
-        } catch (e) {}
-        return false;
+    // Tables nest: only touch nodes whose nearest ancestor table is this one.
+    function ownsNode(table, node) {
+        var n = node.parentNode;
+        while (n && n !== table) {
+            if (n.nodeName === "TABLE") return false;
+            n = n.parentNode;
+        }
+        return n === table;
     }
 
-    // The way out has to be discoverable, or it may as well not exist. The
-    // editing region's accessible name is the one thing a screen reader always
-    // announces on entry, so the hint goes there rather than into the content.
-    function announceEscape(ed) {
-        var hint = config.a11yEscapeHint ||
-            "Press Escape to leave the editing area.";
-        var label = ed.getAttribute("aria-label") || "";
-        if (label.indexOf(hint) >= 0) return;
-        ed.setAttribute("aria-label", (label ? label.replace(/\s*$/, " ") : "") + hint);
-    }
-
-    function focusAfterEditor() {
-        var root = shell();
-        if (!root) return false;
-        var all = [].slice.call(document.querySelectorAll(
-            'a[href],button,input,select,textarea,[tabindex]:not([tabindex="-1"])'
-        )).filter(function (el) {
-            return !root.contains(el) && el.offsetParent !== null;
-        });
-        // The first focusable that follows the editor in document order.
-        for (var i = 0; i < all.length; i++) {
-            if (root.compareDocumentPosition(all[i]) & Node.DOCUMENT_POSITION_FOLLOWING) {
-                all[i].focus();
-                return true;
-            }
+    function ownCells(table) {
+        var out = [], all = table.querySelectorAll ? table.querySelectorAll("th,td") : [];
+        for (var i = 0; i < all.length; i++) if (ownsNode(table, all[i])) out.push(all[i]);
+        return out;
+    }
+
+    function ownRows(table) {
+        var out = [], all = table.querySelectorAll ? table.querySelectorAll("tr") : [];
+        for (var i = 0; i < all.length; i++) if (ownsNode(table, all[i])) out.push(all[i]);
+        return out;
+    }
+
+    function rowCells(row) {
+        var out = [];
+        for (var n = row.firstChild; n; n = n.nextSibling) {
+            if (n.nodeName === "TH" || n.nodeName === "TD") out.push(n);
         }
+        return out;
+    }
+
+    function firstOwnChild(table, name) {
+        name = name.toUpperCase();
+        for (var n = table.firstChild; n; n = n.nextSibling) if (n.nodeName === name) return n;
+        return null;
+    }
+
+    function contains(root, node) {
+        var n = node;
+        while (n) { if (n === root) return true; n = n.parentNode; }
         return false;
     }
 
-    // ------------------------------------------------- 4. roving tabindex
-    function toolbarsIn(root) {
-        return [].slice.call(root.querySelectorAll('[role="toolbar"]'));
-    }
-    // Toolbars nest — an overflow or ribbon toolbar sits inside the main one.
-    // A plain descendant query therefore makes the outer toolbar claim the
-    // inner one's buttons, and the two passes fight: the first run measured two
-    // tab stops in one toolbar and NONE in the other two, which left those
-    // buttons unreachable by keyboard altogether. Each button belongs to its
-    // NEAREST toolbar and to no other.
-    function buttonsIn(bar) {
-        return [].slice.call(bar.querySelectorAll('[role="button"]')).filter(function (b) {
-            if (b.getAttribute("aria-disabled") === "true") return false;
-            if (b.offsetParent === null) return false;                 // hidden: not reachable anyway
-            return (b.closest && b.closest('[role="toolbar"]')) === bar;
-        });
+    // Move a <thead>'s rows into the table body and drop the section.
+    function unwrapSection(table, section) {
+        var body = firstOwnChild(table, "tbody");
+        if (!body) {
+            body = table.ownerDocument.createElement("tbody");
+            table.insertBefore(body, section.nextSibling);
+        }
+        while (section.firstChild) body.insertBefore(section.firstChild, body.firstChild);
+        section.parentNode.removeChild(section);
     }
 
-    function applyRovingTabindex(root) {
-        if (config.a11yRovingToolbar === false) return;
-        var bars = toolbarsIn(root);
-        for (var i = 0; i < bars.length; i++) {
-            (function (bar) {
-                var btns = buttonsIn(bar);
-                if (!btns.length) return;
-                // Exactly one tab stop per toolbar, which is the ARIA pattern.
-                var current = btns.filter(function (b) { return b.getAttribute("tabindex") === "0"; })[0] || btns[0];
-                for (var j = 0; j < btns.length; j++) btns[j].setAttribute("tabindex", btns[j] === current ? "0" : "-1");
-
-                if (bar.__rteRoving) return;
-                bar.__rteRoving = true;
-                bar.addEventListener("keydown", function (e) {
-                    var list = buttonsIn(bar);
-                    var at = list.indexOf(document.activeElement);
-                    if (at < 0) return;
-                    var rtl = (bar.closest && bar.closest('[dir="rtl"]')) ? true : false;
-                    var next = null;
-                    if (e.key === "ArrowRight") next = list[(at + (rtl ? -1 : 1) + list.length) % list.length];
-                    else if (e.key === "ArrowLeft") next = list[(at + (rtl ? 1 : -1) + list.length) % list.length];
-                    else if (e.key === "Home") next = list[0];
-                    else if (e.key === "End") next = list[list.length - 1];
-                    else return;
-                    e.preventDefault();
-                    for (var k = 0; k < list.length; k++) list[k].setAttribute("tabindex", list[k] === next ? "0" : "-1");
-                    next.focus();
-                }, false);
-                // Clicking a button makes it the new tab stop, so returning by
-                // Tab lands where the user last was.
-                bar.addEventListener("focusin", function (e) {
-                    var list = buttonsIn(bar);
-                    if (list.indexOf(e.target) < 0) return;
-                    for (var k = 0; k < list.length; k++) list[k].setAttribute("tabindex", list[k] === e.target ? "0" : "-1");
-                }, false);
-            })(bars[i]);
-        }
-    }
-
-    function focusFirstToolbarButton() {
-        var root = shell();
-        if (!root) return false;
-        var bars = toolbarsIn(root);
-        for (var i = 0; i < bars.length; i++) {
-            var btns = buttonsIn(bars[i]);
-            if (!btns.length) continue;
-            var target = btns.filter(function (b) { return b.getAttribute("tabindex") === "0"; })[0] || btns[0];
-            target.focus();
-            return true;
+    // Replace an element with the same content and attributes under a new tag.
+    // The caret may be inside it, so the range is restored afterwards.
+    function rename(el, tagName) {
+        var doc = el.ownerDocument;
+        var replacement = doc.createElement(tagName);
+        for (var i = 0; i < el.attributes.length; i++) {
+            var a = el.attributes[i];
+            try { replacement.setAttribute(a.name, a.value); } catch (e) {}
         }
-        return false;
+        while (el.firstChild) replacement.appendChild(el.firstChild);
+        el.parentNode.replaceChild(replacement, el);
+        return replacement;
     }
 
-    // ------------------------------------------------- 2. aria-pressed
-    //
-    // The editor already tracks active state — it just keeps it in a class.
-    // Mirroring rather than recomputing means the announced state can never
-    // disagree with the highlighted button.
-    // Command names here must match the TOOLBAR command exactly — the regex is
-    // anchored, so a near-miss is a silent no-op that looks like coverage.
-    // "blockquote" is one: the command is `insertblockquote`, so the entry
-    // written specifically for it never matched and that button ships with no
-    // aria-pressed. Found by checking every genuine toggle on the full toolbar
-    // rather than the three the published verify page samples.
-    //
-    // This mirror only copies the editor's own active state, so a command may
-    // only be listed here once core actually tracks it. Emitting the attribute
-    // for an untracked command yields a permanent aria-pressed="false" —
-    // confidently announcing "not pressed" while the formatting IS applied,
-    // which makes announced state DISAGREE with the highlight. That is the exact
-    // failure this mirror exists to prevent, so silence beats a wrong answer.
-    //   - `toggleborder` was already tracked (core checks the editable's
-    //     rte-toggleborder class); it reads inactive simply when borders are off.
-    //   - `insertblockquote` was NOT tracked and now is, via a core case added
-    //     alongside `indent`, which resolves the same way.
-    // Both verified on the running editor rather than inferred.
-    //
-    // `inlinecode`, `pagination`, `typewriter` and `focusmode` match nothing in
-    // this build, and now the reason is known rather than assumed: pagination.js
-    // and typewriter.js are API-only (togglePageView / toggleTypewriterMode …)
-    // and register no toolbar command, and insertcode.js registers `insertcode`,
-    // which inserts a block rather than toggling the selection. They are kept —
-    // harmless, and correct the moment a toolbar button is added — but they
-    // cover nothing today, so do not read this list as evidence of coverage.
-    var TOGGLE_CMD = /^(bold|italic|underline|strikethrough|subscript|superscript|justifyleft|justifycenter|justifyright|justifyfull|insertorderedlist|insertunorderedlist|outdent|indent|insertblockquote|toggleborder|inlinecode|trackchanges|typewriter|focusmode|pagination|formattingmarks|linenumbers|permanentpen|rtlui)$/;
-
-    function syncToggleStates(root) {
-        var btns = [].slice.call(root.querySelectorAll('[role="button"][rte-cmd-name]'));
-        for (var i = 0; i < btns.length; i++) {
-            var cmd = (btns[i].getAttribute("rte-cmd-name") || "").toLowerCase();
-            if (!TOGGLE_CMD.test(cmd)) continue;
-            var active = btns[i].classList.contains("rte-command-active");
-            var pressed = active ? "true" : "false";
-            if (btns[i].getAttribute("aria-pressed") !== pressed) btns[i].setAttribute("aria-pressed", pressed);
-        }
-    }
-
-    // ------------------------------------------------- 3. aria-expanded
-    //
-    // Opening a menu inserts an <rte-dropdown-panel> elsewhere in the document
-    // and leaves the button untouched, so the button and its panel have to be
-    // correlated: remember which popup button was activated, then pair it with
-    // the panel that appears.
-    function trackPopups(root) {
-        var pops = [].slice.call(root.querySelectorAll("[aria-haspopup]"));
-        for (var i = 0; i < pops.length; i++) {
-            if (!pops[i].hasAttribute("aria-expanded")) pops[i].setAttribute("aria-expanded", "false");
-            if (pops[i].__rtePopupBound) continue;
-            pops[i].__rtePopupBound = true;
-            (function (el) {
-                function remember() { popupOwner = el; }
-                el.addEventListener("mousedown", remember, true);
-                el.addEventListener("keydown", function (e) {
-                    if (e.key === "Enter" || e.key === " " || e.key === "ArrowDown") remember();
-                }, true);
-            })(pops[i]);
-        }
-
-        if (trackPopups.bound) return;
-        trackPopups.bound = true;
-        var mo = new MutationObserver(function (records) {
-            for (var r = 0; r < records.length; r++) {
-                var rec = records[r];
-                for (var a = 0; a < rec.addedNodes.length; a++) {
-                    var n = rec.addedNodes[a];
-                    if (n.nodeType !== 1 || !isPanel(n)) continue;
-                    if (popupOwner) {
-                        popupOwner.setAttribute("aria-expanded", "true");
-                        openPanels.push({ panel: n, owner: popupOwner });
-                        popupOwner = null;
-                    }
-                }
-                for (var d = 0; d < rec.removedNodes.length; d++) {
-                    var m = rec.removedNodes[d];
-                    if (m.nodeType !== 1 || !isPanel(m)) continue;
-                    for (var k = openPanels.length - 1; k >= 0; k--) {
-                        if (openPanels[k].panel === m) {
-                            openPanels[k].owner.setAttribute("aria-expanded", "false");
-                            openPanels.splice(k, 1);
-                        }
-                    }
-                }
+    function tableAtCaret() {
+        var ed = getEditable();
+        if (!ed) return null;
+        var node = null;
+        try {
+            var sel = editor.getSelection();
+            if (sel && sel.rangeCount) node = sel.getRangeAt(0).startContainer;
+        } catch (e) {}
+        if (!node) return null;
+        if (node.nodeType === 3) node = node.parentNode;
+        while (node && node !== ed) {
+            if (node.nodeName === "TABLE") return node;
+            node = node.parentNode;
+        }
+        return null;
+    }
+
+    function insertAtCaret(node, doc) {
+        var inserted = false;
+        try {
+            var sel = editor.getSelection();
+            if (sel && sel.rangeCount) {
+                var range = sel.getRangeAt(0);
+                range.deleteContents();
+                range.insertNode(node);
+                inserted = true;
             }
-        });
-        mo.observe(document.body, { childList: true, subtree: true });
-        observers.push(mo);
+        } catch (e) {}
+        if (!inserted) {
+            var ed = getEditable();
+            if (ed) { ed.appendChild(node); inserted = true; }
+        }
+        // A table at the very end of the document is a caret trap; gapcursor.js
+        // handles escaping it, so nothing is appended here.
+        return inserted;
     }
-    function isPanel(el) {
-        var t = (el.tagName || "").toLowerCase();
-        return t === "rte-dropdown-panel" || t === "rte-floatpanel" || t === "rte-dialog-float";
-    }
-
-    // Toolbar buttons are rebuilt and re-classed as the selection moves, so the
-    // mirrored state has to follow rather than be set once.
-    function watch(root) {
-        if (root.__rteA11yWatch) return;
-        root.__rteA11yWatch = true;
-        var pending = null;
-        var mo = new MutationObserver(function () {
-            if (pending) return;
-            pending = setTimeout(function () {
-                pending = null;
-                syncToggleStates(root);
-                applyRovingTabindex(root);
-                trackPopups(root);
-            }, 60);
-        });
-        mo.observe(root, { subtree: true, childList: true, attributes: true, attributeFilter: ["class", "aria-disabled"] });
-        observers.push(mo);
+
+    function getEditable() { try { return editor.getEditable(); } catch (e) { return null; } }
+
+    function editableDoc() {
+        var ed = getEditable();
+        return ed ? ed.ownerDocument : null;
+    }
+
+    function injectStyles(doc) {
+        if (!doc) return;
+        var text = outlineOn
+            ? "table[role=presentation]{outline:1px dashed rgba(120,120,140,.55);outline-offset:1px;}" +
+              "table[role=presentation] td{outline:1px dashed rgba(120,120,140,.28);}"
+            : "";
+        var existing = doc.getElementById("rte-layout-table-styles");
+        if (existing) {
+            if (existing.getAttribute("data-css") === text) return;
+            existing.parentNode && existing.parentNode.removeChild(existing);
+        }
+        if (!text) return;
+        var st = doc.createElement("style");
+        st.id = "rte-layout-table-styles";
+        st.setAttribute("data-css", text);
+        st.appendChild(doc.createTextNode(text));
+        (doc.head || doc.getElementsByTagName("head")[0] || doc.documentElement).appendChild(st);
+    }
+
+    function fireChange() {
+        try { if (typeof editor.updateDesign === "function") editor.updateDesign(); } catch (e) {}
+        try { if (typeof editor.fireChange === "function") editor.fireChange(); } catch (e) {}
     }
 }
 
@@ -37846,6 +38339,259 @@ function RTE_Plugin_Sanitizer() {
 
 if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
 
+// 2026-08-30 Shadow DOM support — make the editor usable inside a shadow root.
+//
+// TinyMCE documents shadow-DOM support as a supported integration; we had none
+// under any name. Design systems, micro-frontends and anything built as a custom
+// element put their markup inside a shadow root, and that is where this editor
+// was quietly broken.
+//
+// Measured before writing a line of it, on a real instance in Chromium:
+//
+//   | mounted in            | toolbar height | font              |
+//   |-----------------------|----------------|-------------------|
+//   | the page (light DOM)  | 82 px          | system-ui         |
+//   | a shadow root         | 45,468 px      | Times New Roman   |
+//
+// So it is not "mostly fine". The editor CONSTRUCTS, the iframe appears, and
+// setHTMLCode/getHTMLCode round-trip correctly — which is exactly why this was
+// never noticed — but a style boundary is a wall: `<link rel=stylesheet>` in the
+// document head does not cross into a shadow root, so every rule in
+// rte_theme_default.css misses, and the toolbar renders as a 45,000-pixel column
+// of unstyled buttons.
+//
+// The fix is to put the editor's own stylesheets on the inside of the wall too.
+//
+// Design notes:
+//   - <link> clones, not fetch + CSSStyleSheet. Constructing a stylesheet means
+//     fetching the CSS with JS, which needs CORS on a CDN-hosted theme and fails
+//     closed — a cloned <link> hits the HTTP cache, needs no CORS, and works on
+//     every browser that has shadow DOM at all. adoptedStyleSheets is used only
+//     for sheets already adopted by the document, which have no URL to clone.
+//   - Only the EDITOR's stylesheets are copied. Cloning the whole head into a
+//     shadow root would undo the encapsulation the integrator chose it for. A
+//     sheet counts as ours by origin — served from the folder rte.js was loaded
+//     from — plus an `rte-`/`__rte` element id, the same origin-based test that
+//     importstyles.js had to arrive at after prefix matching failed.
+//   - A MutationObserver keeps watching the head. Plugins inject their styles
+//     lazily, when their panel first opens — the accessibility checker and the AI
+//     toolkit both do — so a one-shot copy at init produces a styled toolbar and
+//     an unstyled dialog half an hour later, which is a worse bug to diagnose
+//     than a wholly unstyled editor.
+//   - Nothing is copied when the editor is NOT in a shadow root, and the
+//     observer is not even created. This plugin must cost nothing for the 99%.
+RTE_DefaultConfig.plugin_shadowdom = RTE_Plugin_ShadowDom;
+
+// Copy the editor's stylesheets into the shadow root that contains it.
+if (typeof RTE_DefaultConfig.shadowStyleAdoption === "undefined") RTE_DefaultConfig.shadowStyleAdoption = true;
+// Extra stylesheet URLs to copy in as well (an integrator's own skin overrides).
+if (typeof RTE_DefaultConfig.shadowStyleSources === "undefined") RTE_DefaultConfig.shadowStyleSources = null;
+
+function RTE_Plugin_ShadowDom() {
+    var obj = this;
+    var config, editor;
+    var root = null;
+    var observer = null;
+    var copied = null;
+
+    obj.PluginName = "ShadowDom";
+
+    obj.InitConfig = function (argconfig) { config = argconfig; };
+
+    obj.InitEditor = function (argeditor) {
+        editor = argeditor;
+
+        // Public API — useful even outside a shadow root, for a host page that
+        // wants to style a second root (a dialog portal, a preview pane).
+        editor.getShadowRoot = function () { return findRoot(); };
+        editor.isInShadowDom = function () { return !!findRoot(); };
+        editor.adoptEditorStyles = function (target) { return adopt(target || findRoot(), true); };
+        editor.getAdoptedStyleCount = function () { return copied ? copied.size : 0; };
+
+        if (config && config.shadowStyleAdoption === false) return;
+
+        // The chrome is built asynchronously; the container may not exist yet.
+        whenReady(function () {
+            root = findRoot();
+            if (!root) return;
+            copied = new (window.Set || Array)();
+            adopt(root, false);
+            watchHead(root);
+        });
+    };
+
+    obj.Destroy = function () {
+        if (observer) { try { observer.disconnect(); } catch (e) {} observer = null; }
+    };
+
+    // ------------------------------------------------------------------ lookup
+
+    // The editor's container is the element the integrator passed in; from the
+    // editing iframe it is the nearest ancestor carrying the editor's own class.
+    function container() {
+        try {
+            var editable = editor.getEditable();
+            var frame = editable && editable.ownerDocument && editable.ownerDocument.defaultView
+                ? editable.ownerDocument.defaultView.frameElement : null;
+            if (!frame) return null;
+            var node = frame;
+            while (node) {
+                if (node.classList && node.classList.contains("richtexteditor")) return node;
+                node = node.parentNode || node.host;
+            }
+            return frame;
+        }
+        catch (e) { return null; }
+    }
+
+    function findRoot() {
+        var el = container();
+        if (!el || typeof el.getRootNode !== "function") return null;
+        var r = el.getRootNode();
+        // A DocumentFragment with a `host` is a shadow root; a plain document is not.
+        return (r && r.host && r !== document) ? r : null;
+    }
+
+    function whenReady(callback) {
+        if (container()) { callback(); return; }
+        var tries = 0;
+        var timer = window.setInterval(function () {
+            if (container() || ++tries > 100) { window.clearInterval(timer); callback(); }
+        }, 50);
+    }
+
+    // ------------------------------------------------------------------ adopt
+
+    // Where rte.js itself was served from. Everything under that folder is ours.
+    function assetBase() {
+        try {
+            var scripts = document.getElementsByTagName("script");
+            for (var i = 0; i < scripts.length; i++) {
+                var src = scripts[i].src || "";
+                if (/(^|\/)rte(\.min)?\.js(\?|$)/.test(src)) return src.replace(/[^\/]*$/, "");
+            }
+        }
+        catch (e) {}
+        return null;
+    }
+
+    function isOurs(node) {
+        var id = String(node.id || "");
+        if (/^rte[-_]|^__rte/.test(id)) return true;
+        var href = node.href || "";
+        if (!href) return false;
+        var base = assetBase();
+        if (base && href.indexOf(base) === 0) return true;
+        // Fall back to the file names this product actually ships, so an
+        // integrator who renamed or re-hosted the folder still gets styled
+        // chrome rather than a silent 45,000-pixel toolbar.
+        return /rte_theme|rte_mobile|richtexteditor_content|richtexteditor_preview|aitoolkit/.test(href);
+    }
+
+    function extraSources() {
+        var list = (config && config.shadowStyleSources) || null;
+        if (!list) return [];
+        return typeof list === "string" ? [list] : list;
+    }
+
+    function key(node) {
+        return (node.href || "") + "|" + (node.id || "") + "|" + (node.textContent || "").length;
+    }
+
+    function has(k) {
+        return copied && (copied.has ? copied.has(k) : copied.indexOf(k) >= 0);
+    }
+
+    function remember(k) {
+        if (!copied) return;
+        if (copied.add) copied.add(k); else copied.push(k);
+    }
+
+    function adopt(target, force) {
+        if (!target) return 0;
+        if (!copied) copied = new (window.Set || Array)();
+        var added = 0;
+        var nodes = document.querySelectorAll("link[rel~=stylesheet],style");
+
+        for (var i = 0; i < nodes.length; i++) {
+            var node = nodes[i];
+            if (!isOurs(node)) continue;
+            var k = key(node);
+            if (!force && has(k)) continue;
+            if (has(k)) continue;
+            target.appendChild(cloneSheet(node, target));
+            remember(k);
+            added++;
+        }
+
+        var extras = extraSources();
+        for (var e = 0; e < extras.length; e++) {
+            var ek = "extra|" + extras[e];
+            if (has(ek)) continue;
+            var link = document.createElement("link");
+            link.rel = "stylesheet";
+            link.href = extras[e];
+            link.setAttribute("data-rte-adopted", "1");
+            target.appendChild(link);
+            remember(ek);
+            added++;
+        }
+
+        // Sheets the page adopted programmatically have no URL to clone, so they
+        // are re-adopted by reference where the browser supports it.
+        try {
+            if (target.adoptedStyleSheets && document.adoptedStyleSheets && document.adoptedStyleSheets.length) {
+                var merged = target.adoptedStyleSheets.slice();
+                for (var a = 0; a < document.adoptedStyleSheets.length; a++) {
+                    if (merged.indexOf(document.adoptedStyleSheets[a]) < 0) merged.push(document.adoptedStyleSheets[a]);
+                }
+                target.adoptedStyleSheets = merged;
+            }
+        }
+        catch (e2) {}
+
+        return added;
+    }
+
+    function cloneSheet(node, target) {
+        if (node.tagName === "LINK") {
+            var link = document.createElement("link");
+            link.rel = "stylesheet";
+            // Resolved (absolute) href — a relative one would resolve against the
+            // document anyway, but being explicit survives a <base> element.
+            link.href = node.href;
+            if (node.media) link.media = node.media;
+            link.setAttribute("data-rte-adopted", "1");
+            return link;
+        }
+        var style = document.createElement("style");
+        style.textContent = node.textContent;
+        if (node.id) style.setAttribute("data-rte-source-id", node.id);
+        style.setAttribute("data-rte-adopted", "1");
+        return style;
+    }
+
+    // A plugin's <style> arrives when its panel first opens, long after init.
+    function watchHead(target) {
+        if (!window.MutationObserver) return;
+        observer = new MutationObserver(function (records) {
+            var interesting = false;
+            for (var i = 0; i < records.length && !interesting; i++) {
+                var added = records[i].addedNodes || [];
+                for (var j = 0; j < added.length; j++) {
+                    var n = added[j];
+                    if (n.nodeType !== 1) continue;
+                    if ((n.tagName === "STYLE" || n.tagName === "LINK") && isOurs(n)) { interesting = true; break; }
+                }
+            }
+            if (interesting) adopt(target, false);
+        });
+        observer.observe(document.head || document.documentElement, { childList: true, subtree: true });
+    }
+}
+
+if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
+
 RTE_DefaultConfig.plugin_slashcommand = RTE_Plugin_SlashCommand;
 
 function RTE_Plugin_SlashCommand() {
@@ -38091,6 +38837,14 @@ function RTE_Plugin_SlashCommand() {
             push("Tools", "tablerownumbers", "Number table rows", "Add or remove an automatic row-numbering column", ["number", "rows", "table", "count", "index"], iconSort(),
                 function () { editor.execCommand("tablerownumbers"); });
         }
+        if (typeof editor.setTableLayoutMode === "function") {
+            push("Insert", "layouttable", "Layout table", "Insert a borderless table for positioning content (role=presentation)", ["layout", "table", "grid", "email", "columns", "presentation"], iconTable(),
+                function () { editor.insertLayoutTable(2, 2); });
+            push("Tools", "tablelayoutmode", "Mark table as layout", "This table only positions content — stop screen readers announcing it as data", ["layout", "table", "presentation", "accessibility", "screen reader"], iconTable(),
+                function () { editor.setTableLayoutMode("layout"); });
+            push("Tools", "tabledatamode", "Mark table as data", "This table states relationships — restore its header cells", ["data", "table", "header", "accessibility"], iconTable(),
+                function () { editor.setTableLayoutMode("data", null, { promoteFirstRow: true }); });
+        }
         if (typeof editor.moveBlockUp === "function") {
             push("Tools", "moveblockup", "Move block up", "Move this paragraph or block above the previous one (Alt+Shift+Up)", ["move", "block", "up", "reorder", "drag"], iconMoveBlock(),
                 function () { editor.moveBlockUp(); });