@richscripts/richtexteditor 2.5.4 → 2.6.0

package/richtexteditor/all_plugins.js

@@ -522,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
                     });
@@ -557,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);
@@ -642,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++) {
@@ -875,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.
@@ -889,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);
 })();
 
@@ -31274,6 +31349,390 @@ function RTE_Plugin_KeyboardA11y() {
 
 if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
 
+// 2026-08-30 Layout tables — say whether a table carries data or only geometry.
+//
+// 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:
+//
+//   * 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.
+//
+// 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.
+//
+// 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.
+//
+// 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 headerMemory = (typeof WeakMap === "function") ? new WeakMap() : null;
+
+    obj.PluginName = "LayoutTable";
+
+    obj.InitConfig = function (argconfig) { config = argconfig; };
+
+    obj.InitEditor = function (argeditor) {
+        editor = argeditor;
+
+        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();
+        });
+
+        // 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;
+        };
+
+        try {
+            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 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;
+    }
+
+    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");
+        }
+    }
+
+    // ------------------------------------------------------------------ helpers
+
+    function isLayout(table) {
+        if (!table || table.nodeName !== "TABLE") return false;
+        var role = String(table.getAttribute("role") || "").toLowerCase();
+        return role === "presentation" || role === "none";
+    }
+
+    // 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;
+    }
+
+    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;
+    }
+
+    // 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);
+    }
+
+    // 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) {}
+        }
+        while (el.firstChild) replacement.appendChild(el.firstChild);
+        el.parentNode.replaceChild(replacement, el);
+        return replacement;
+    }
+
+    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;
+            }
+        } 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 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) {}
+    }
+}
+
+if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
+
 // 2026-07-27 Margin line numbers. Numbers every visual line in the left gutter,
 // the way a word processor does for pleadings, statutes, transcripts and any
 // document people cite by line ("page 4, lines 12-15").
@@ -37880,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() {
@@ -38125,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(); });