tinymce-rails 8.8.1 → 8.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a62c7a288ed5696f584343feec82754519985ae2f5b114d512cad2dfbdeee0ad
-  data.tar.gz: afa1237efdcf85f4b879e2d857ebaf5c6a76a27b11861aae0cf853337da4ac48
+  metadata.gz: ac0f6b7996563391a41c7a79784540a1a7e4d6e4c3df8172f45886f909320b38
+  data.tar.gz: '018e0b48877e87639b2312a6ba0b673d275e9dfb905c3986e6d93ab8d1d14eec'
 SHA512:
-  metadata.gz: 1f34f17bd042bb908ff1551f4db673326eae1b476555866c15c58f837f0141431c3c596d302088763879b3ac34f1d3af77f136189cf8d4dd55a36c012b07c9ec
-  data.tar.gz: 96a89c0c643a51a2b904de5c4dd4f45c20abb0e3572f3613f44edf54dddc2aa44816b29c900500e9c39ec9b2a30309e2a9364f5265303362feb428b2db5f4c0f
+  metadata.gz: 9fa2ae87f866744fb26965a51de6193bf53fef8afbce8baebf7ab2b8d2a19e63923c89b8044e3fe843cdbeb05d580352ca831fc47fec780d51d0e165f19326c0
+  data.tar.gz: 66d4cbe492f6247fbc37d64f050863766162ae84403845e953bd3573302c4357378e701fd2153d67fad8bb8810d76159e4633e8e0d080002d50d42a36ad66104

data/app/assets/source/tinymce/tinymce.js

@@ -1,5 +1,5 @@
 /**
- * TinyMCE version 8.8.1 (2026-07-22)
+ * TinyMCE version 8.9.0 (2026-08-27)
  */
 
 (function () {
@@ -12153,6 +12153,13 @@
         const selector = isEmpty$5(formatNoneditableSelector) ? baseDataSelector : `${baseDataSelector},${formatNoneditableSelector}`;
         return is$2(SugarElement.fromDom(node), selector);
     };
+    const hasEditableDescendants = (dom, node) => dom.select('[contenteditable="true"]', node).length > 0;
+    const getEditableDescendants = (dom, parent) => foldl(from(parent.childNodes), (editableDescendants, child) => [
+        ...editableDescendants,
+        ...(isElement$7(child) && dom.getContentEditable(child) === 'true'
+            ? [child]
+            : getEditableDescendants(dom, child))
+    ], []);
     // A noneditable element is wrappable if it:
     // - is valid target (has data-mce-cef-wrappable attribute or matches selector from option)
     // - has no editable descendants - removing formats in the editable region can result in the wrapped noneditable being split which is undesirable
@@ -12161,7 +12168,7 @@
         return (isElementNode$1(node) &&
             dom.getContentEditable(node) === 'false' &&
             isWrapNoneditableTarget(editor, node) &&
-            dom.select('[contenteditable="true"]', node).length === 0);
+            !hasEditableDescendants(dom, node));
     };
     /**
      * Replaces variables in the value. The variable format is %var.
@@ -13399,7 +13406,11 @@
             editor.selection.normalize();
         }, (caretPos) => editor.selection.setRng(caretPos.toRange()));
     };
-    const focusBody = (body) => {
+    const focusBody = (body, preventScroll = false) => {
+        if (preventScroll) {
+            body.focus({ preventScroll: true });
+            return;
+        }
         if (body.setActive) {
             // IE 11 sometimes throws "Invalid function" then fallback to focus
             // setActive is better since it doesn't scroll to the element being focused
@@ -13430,7 +13441,7 @@
     };
     const hasFocus = (editor) => editor.inline ? hasInlineFocus(editor) : hasIframeFocus(editor);
     const hasEditorOrUiFocus = (editor) => hasFocus(editor) || hasUiFocus(editor);
-    const focusEditor = (editor) => {
+    const focusEditor = (editor, preventScroll) => {
         const selection = editor.selection;
         const body = editor.getBody();
         let rng = selection.getRng();
@@ -13448,9 +13459,9 @@
         const contentEditableHost = getContentEditableHost(editor, selection.getNode());
         if (contentEditableHost && editor.dom.isChildOf(contentEditableHost, body)) {
             if (!hasContentEditableFalseParent$1(editor, contentEditableHost)) {
-                focusBody(body);
+                focusBody(body, preventScroll);
             }
-            focusBody(contentEditableHost);
+            focusBody(contentEditableHost, preventScroll);
             if (!editor.hasEditableRoot()) {
                 restoreBookmark(editor);
             }
@@ -13461,30 +13472,40 @@
         // Focus the window iframe
         if (!editor.inline) {
             // WebKit needs this call to fire focusin event properly see #5948
-            // But Opera pre Blink engine will produce an empty selection so skip Opera
-            if (!Env.browser.isOpera()) {
-                focusBody(body);
+            focusBody(body, preventScroll);
+            if (preventScroll) {
+                if (isNonNullable(editor.iframeElement)) {
+                    editor.iframeElement.focus({ preventScroll: true });
+                }
+            }
+            else {
+                editor.getWin().focus();
             }
-            editor.getWin().focus();
         }
         // Focus the body as well since it's contentEditable
         if (Env.browser.isFirefox() || editor.inline) {
-            focusBody(body);
+            focusBody(body, preventScroll);
             normalizeSelection(editor, rng);
         }
         activateEditor(editor);
     };
     const activateEditor = (editor) => editor.editorManager.setActive(editor);
-    const focus = (editor, skipFocus) => {
+    const normalizeFocusOptions = (args) => {
+        if (isNonNullable(args) && !isBoolean(args)) {
+            return args;
+        }
+        return { scrollToSelection: true };
+    };
+    const focus = (editor, args) => {
         if (editor.removed) {
             return;
         }
-        if (skipFocus) {
+        if (args === true) {
             activateEditor(editor);
+            return;
         }
-        else {
-            focusEditor(editor);
-        }
+        const options = normalizeFocusOptions(args);
+        focusEditor(editor, options.scrollToSelection === false);
     };
 
     /**
@@ -16769,14 +16790,23 @@
         }
         return undefined;
     };
+    const containsFormatDeep = (editor, root, name, vars, similar) => isNonNullable(matchNode$1(editor, root, name, vars, similar)) ||
+        exists(from(root.childNodes), (child) => containsFormatDeep(editor, child, name, vars, similar));
+    const matchEditableDescendants = (editor, node, name, vars, similar) => {
+        const dom = editor.dom;
+        if (!isElement$7(node) || dom.getContentEditable(node) !== 'false' || isWrappableNoneditable(editor, node)) {
+            return false;
+        }
+        return exists(getEditableDescendants(dom, node), (descendant) => containsFormatDeep(editor, descendant, name, vars, similar));
+    };
     const match$2 = (editor, name, vars, node, similar) => {
         // Check specified node
         if (node) {
-            return matchParents(editor, node, name, vars, similar);
+            return matchParents(editor, node, name, vars, similar) || matchEditableDescendants(editor, node, name, vars, similar);
         }
         // Check selected node
         node = editor.selection.getNode();
-        if (matchParents(editor, node, name, vars, similar)) {
+        if (matchParents(editor, node, name, vars, similar) || matchEditableDescendants(editor, node, name, vars, similar)) {
             return true;
         }
         // Check start node if it's different
@@ -18647,7 +18677,7 @@
         }
     };
 
-    /*! @license DOMPurify 3.4.11 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.11/LICENSE */
+    /*! @license DOMPurify 3.4.12 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.12/LICENSE */
 
     function _arrayLikeToArray(r, a) {
       (null == a || a > r.length) && (a = r.length);
@@ -18960,7 +18990,7 @@
     const text = freeze(['#text']);
 
     const html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'command', 'commandfor', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'exportparts', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inert', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'part', 'pattern', 'placeholder', 'playsinline', 'popover', 'popovertarget', 'popovertargetaction', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'slot', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'wrap', 'xmlns']);
-    const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'mask-type', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
+    const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dominant-baseline', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'mask-type', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-orientation', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
     const mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnalign', 'columnlines', 'columnspacing', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lquote', 'lspace', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
     const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
 
@@ -19073,7 +19103,7 @@
     function createDOMPurify() {
       let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
       const DOMPurify = root => createDOMPurify(root);
-      DOMPurify.version = '3.4.11';
+      DOMPurify.version = '3.4.12';
       DOMPurify.removed = [];
       if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
         // Not running in a browser, provide a factory function
@@ -19755,6 +19785,13 @@
        * @param root the in-place root to empty
        */
       const _neutralizeRoot = function _neutralizeRoot(root) {
+        /* Strip every disallowed attribute (on* handlers included) off the whole
+           subtree BEFORE detaching anything. Detaching first would hand back
+           handler-bearing originals (e.g. an already-loading `<img onerror>`)
+           whose queued resource event still fires in page scope after we throw.
+           Clobber-safe reads; a doomed clobbered node's own attributes are
+           irrelevant while its non-clobbered descendants are reached and scrubbed. */
+        _neutralizeSubtree(root);
         const childNodes = getChildNodes(root);
         if (childNodes) {
           const snapshot = [];
@@ -19882,6 +19919,82 @@
           }
         }
       };
+      /**
+       * _neutralizePatchLinkage
+       *
+       * IN_PLACE entry pre-pass (declarative-partial-updates / streaming
+       * hardening, https://github.com/WICG/declarative-partial-updates).
+       *
+       * The main walk strips patch linkage (`for`/`patchsrc`) and removes range
+       * markers (PIs / markup comments) node-by-node, in document order, AS it
+       * reaches each node. On a live in-place root that leaves a window: from the
+       * moment the root is connected until the walk arrives at a given node, that
+       * node's linkage is live. A patch applied on connection/stream can fire as
+       * a microtask during the walk and inject or teleport an unsanitized DOM
+       * range into a region the iterator has already passed and will not revisit,
+       * so the post-return "tree is sanitized" contract is violated. Sweep the
+       * whole tree once up front and sever every linkage before the walk begins,
+       * closing that window.
+       *
+       * This CANNOT undo a patch that already fired before sanitize ran — that is
+       * the irreducible "do not IN_PLACE a live-connected attacker tree" caveat —
+       * but it closes everything from sanitize-start onward. Gated on SAFE_FOR_XML
+       * to group with the rest of the declarative-partial-updates handling and
+       * stay overridable, consistent with the codebase.
+       *
+       * Clobber-safe traversal (cached childNodes getter); per-node try/catch so a
+       * clobbered root cannot defeat the sweep of its non-clobbered descendants.
+       *
+       * NOTE (pending real-Chrome confirmation, see test/declarative-patch-probe
+       * .html Q1): this mirrors the existing policy of keeping `for` on
+       * <label>/<output>. If the shipping feature can drive a patch through a
+       * surviving `for`-on-label/output + `id` pair, this pre-pass and the
+       * attribute check at _isBasicCustomElement's caller must additionally drop
+       * that pair on the IN_PLACE path. Left as-is until the taxonomy is verified.
+       *
+       * @param root the in-place root to sweep
+       */
+      const _neutralizePatchLinkage = function _neutralizePatchLinkage(root) {
+        if (!SAFE_FOR_XML) {
+          return;
+        }
+        const stack = [root];
+        while (stack.length > 0) {
+          const node = stack.pop();
+          const nodeType = getNodeType ? getNodeType(node) : node.nodeType;
+          /* Remove range markers (the target side of a patch linkage): every
+             processing instruction, and any markup-bearing comment. */
+          if (nodeType === NODE_TYPE.processingInstruction || nodeType === NODE_TYPE.comment && regExpTest(COMMENT_MARKUP_PROBE, node.data)) {
+            try {
+              remove(node);
+            } catch (_) {
+              /* Best-effort */
+            }
+            continue;
+          }
+          /* Strip patch-source attributes (the source side) off elements. */
+          if (nodeType === NODE_TYPE.element) {
+            const element = node;
+            const lcTag = transformCaseFunc(getNodeName ? getNodeName(node) : node.nodeName);
+            try {
+              if (element.hasAttribute && element.hasAttribute('patchsrc')) {
+                element.removeAttribute('patchsrc');
+              }
+              if (element.hasAttribute && element.hasAttribute('for') && lcTag !== 'label' && lcTag !== 'output') {
+                element.removeAttribute('for');
+              }
+            } catch (_) {
+              /* Clobbered removeAttribute/hasAttribute on a doomed node — ignore */
+            }
+          }
+          const childNodes = getChildNodes(node);
+          if (childNodes) {
+            for (let i = childNodes.length - 1; i >= 0; --i) {
+              stack.push(childNodes[i]);
+            }
+          }
+        }
+      };
       /**
        * _initDocument
        *
@@ -20132,9 +20245,15 @@
       /**
        * Handle a node whose tag is forbidden or not allowlisted: keep
        * allowed custom elements (false return exits _sanitizeElements
-       * early - namespace/fallback checks and the afterSanitizeElements
-       * hook are intentionally skipped for kept custom elements), else
-       * hoist content per KEEP_CONTENT and remove.
+       * early - the namespace and fallback-tag removal checks are
+       * intentionally skipped for kept custom elements), else hoist
+       * content per KEEP_CONTENT and remove.
+       *
+       * A kept custom element is the ONLY case in which this function
+       * returns false, so the caller uses that return value to run the
+       * afterSanitizeElements hook on the kept element and keep the
+       * element-hook lifecycle consistent with normal allowlisted
+       * elements (GHSA-c2j3-45gr-mqc4).
        *
        * @param currentNode the disallowed node
        * @param tagName the node's transformCaseFunc'd tag name
@@ -20200,9 +20319,15 @@
        * @param currentNode to check for permission to exist
        * @return true if node was killed, false if left alive
        */
-      const _sanitizeElements = function _sanitizeElements(currentNode) {
+      // eslint-disable-next-line complexity
+      const _sanitizeElements = function _sanitizeElements(currentNode, root) {
         /* Execute a hook if present */
         _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+        /* A hook may have detached the node — treat it as removed (see the
+           detached-node comment after the uponSanitizeElement hook below). */
+        if (currentNode !== root && getParentNode(currentNode) === null) {
+          return true;
+        }
         /* Check if element is clobbered or can clobber */
         if (_isClobbered(currentNode)) {
           _forceRemove(currentNode);
@@ -20215,6 +20340,24 @@
           tagName,
           allowedTags: ALLOWED_TAGS
         });
+        /* A hook may have detached the node from the tree — a long-standing
+           user pattern (issue #469; draw.io-style foreignObject filtering).
+           Per the cached, unclobberable parentNode getter the node is
+           genuinely out of the tree, so it can reach neither the serialized
+           output nor an IN_PLACE live tree; treat it as removed and stop
+           processing it. Without this guard, the unsafe-node / namespace
+           checks below would call _forceRemove on a parentless node and hit
+           the REPORT-3 fail-closed throw — which exists for nodes DOMPurify
+           wants gone but *cannot* detach (clobbered / parentless roots), the
+           opposite of a node that is already safely gone. The walk root is
+           exempt: a detached IN_PLACE root is legitimate input and must still
+           be fully sanitized, and a kill-decision on it must keep hitting the
+           REPORT-3 throw. Nodes detached by hooks are the hook's
+           responsibility: they are not recorded in DOMPurify.removed and are
+           not neutralized by the post-walk IN_PLACE pass. */
+        if (currentNode !== root && getParentNode(currentNode) === null) {
+          return true;
+        }
         /* Remove mXSS vectors, processing instructions and risky comments */
         if (_isUnsafeNode(currentNode, tagName)) {
           _forceRemove(currentNode);
@@ -20222,7 +20365,22 @@
         }
         /* Remove element if anything forbids its presence */
         if (FORBID_TAGS[tagName] || !(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && !ALLOWED_TAGS[tagName]) {
-          return _sanitizeDisallowedNode(currentNode, tagName);
+          const removed = _sanitizeDisallowedNode(currentNode, tagName);
+          /* A false return means the node is a custom element kept via
+             CUSTOM_ELEMENT_HANDLING - the only keep path through
+             _sanitizeDisallowedNode. Run afterSanitizeElements on it so the
+             element-hook lifecycle matches normal allowlisted elements: a
+             security policy applied in this hook (e.g. stripping an attribute
+             from every surviving element) must not silently skip kept custom
+             elements (GHSA-c2j3-45gr-mqc4). This mirrors the normal-element
+             tail below - the hook runs, then the walker's subsequent
+             _sanitizeAttributes pass sanitizes the element's attributes. The
+             deliberately skipped namespace and fallback-tag removal checks stay
+             skipped; they are removal decisions, not the hook contract. */
+          if (removed === false) {
+            _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+          }
+          return removed;
         }
         /* Check whether element has a valid namespace.
            Realm-safe check (GHSA-hpcv-96wg-7vj8): use the cached Node.prototype
@@ -20269,6 +20427,33 @@
         if (FORBID_ATTR[lcName]) {
           return false;
         }
+        /* Reject declarative-partial-updates patch-linkage attributes
+           (https://github.com/WICG/declarative-partial-updates).
+                Empirical note (Chrome 150, verified — see
+           test/declarative-patch-probe-v3.html): expansion is NOT applied after
+           sanitization. For the string path it fires during sanitize()'s own
+           parse, so the walk sees and sanitizes the fully materialized expanded
+           tree — teleports into MathML/SVG integration points included; a
+           weaponized `<template for>`->`<img onerror>` comes back with the handler
+           stripped. For the IN_PLACE path it fires on connection, before the walk.
+           Either way DOMPurify is NOT blind to the patch.
+                This removal is therefore defense-in-depth rather than the sole barrier:
+           it prevents live linkage from surviving into the OUTPUT and re-expanding
+           in the caller's context, and keeps behaviour deterministic if a future
+           engine defers expansion. `for` is legitimate only on <label>/<output>;
+           anywhere else (notably <template for>) it links the element to a patch
+           target and teleports or removes an arbitrary DOM range by id/marker name.
+           `patchsrc` fetches remote markup and is treated as a script-loading
+           mechanism (CSP). Gated on SAFE_FOR_XML so the removal groups with the
+           other structural-threat checks and stays overridable, consistent with
+           the rest of the codebase. PI range markers are already removed by
+           _isUnsafeNode. */
+        if (SAFE_FOR_XML && lcName === 'patchsrc') {
+          return false;
+        }
+        if (SAFE_FOR_XML && lcName === 'for' && lcTag !== 'label' && lcTag !== 'output') {
+          return false;
+        }
         /* Make sure attribute cannot clobber */
         if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
           return false;
@@ -20478,7 +20663,7 @@
           /* Execute a hook if present */
           _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
           /* Sanitize tags and elements */
-          _sanitizeElements(shadowNode);
+          _sanitizeElements(shadowNode, fragment);
           /* Check attributes next */
           _sanitizeAttributes(shadowNode);
           /* Deep shadow DOM detected.
@@ -20669,6 +20854,11 @@
            keep using and whose return value they ignore — unsanitized. REPORT-2. */
         const inPlace = IN_PLACE && typeof dirty !== 'string' && _isNode(dirty);
         if (inPlace) {
+          /* Declarative-partial-updates / streaming pre-pass: sever every patch
+             linkage across the live tree BEFORE the walk, so no patch can fire
+             mid-walk and inject into an already-processed region. Runs first, so
+             it also covers the forbidden/clobbered roots that throw below. */
+          _neutralizePatchLinkage(dirty);
           /* Do some early pre-sanitization to avoid unsafe root nodes.
              Read nodeName through the cached prototype getter — a clobbering
              child named "nodeName" on the form root would otherwise shadow
@@ -20678,6 +20868,9 @@
           if (typeof nn === 'string') {
             const tagName = transformCaseFunc(nn);
             if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+              /* Fail closed on a live root: neutralize handlers/children before
+                 throwing, exactly as the mid-walk abort path does. */
+              _neutralizeRoot(dirty);
               throw typeErrorCreate('root node is forbidden and cannot be sanitized in-place');
             }
           }
@@ -20692,6 +20885,10 @@
              the application unsanitized. Refuse to sanitize such a root
              the same way we refuse a forbidden tag. GHSA-r47g-fvhr-h676. */
           if (_isClobbered(dirty)) {
+            /* Fail closed on a live clobbered root before throwing.
+               _neutralizeRoot's reads are clobber-safe (cached getters); the
+               form's non-clobbered descendants, e.g. an armed <img>, are scrubbed. */
+            _neutralizeRoot(dirty);
             throw typeErrorCreate('root node is clobbered and cannot be sanitized in-place');
           }
           /* Sanitize attached shadow roots before the main iterator runs.
@@ -20744,7 +20941,8 @@
           _forceRemove(body.firstChild);
         }
         /* Get node iterator */
-        const nodeIterator = _createNodeIterator(inPlace ? dirty : body);
+        const walkRoot = inPlace ? dirty : body;
+        const nodeIterator = _createNodeIterator(walkRoot);
         /* Now start iterating over the created document.
            The walk runs inside an exception barrier (campaign-3 F2): a re-entrant
            engine/custom-element mutation can detach a node mid-walk so
@@ -20757,7 +20955,7 @@
         try {
           while (currentNode = nodeIterator.nextNode()) {
             /* Sanitize tags and elements */
-            _sanitizeElements(currentNode);
+            _sanitizeElements(currentNode, walkRoot);
             /* Check attributes next */
             _sanitizeAttributes(currentNode);
             /* Shadow DOM detected, sanitize it.
@@ -20771,6 +20969,14 @@
         } catch (error) {
           if (inPlace) {
             _neutralizeRoot(dirty);
+            /* Nodes _forceRemove'd earlier in the aborted walk are already
+               detached from the root, so _neutralizeRoot's subtree pass does not
+               reach them. Defuse them too, mirroring the success-path loop below. */
+            arrayForEach(DOMPurify.removed, entry => {
+              if (entry.element) {
+                _neutralizeSubtree(entry.element);
+              }
+            });
           }
           throw error;
         }
@@ -21368,44 +21574,22 @@
         const bogus = get$a(element, 'data-mce-bogus');
         if (!isInternalElement && isString(bogus)) {
             if (bogus === 'all') {
-                // Empty before removing so a detached raw-text element (e.g. script/style) can't carry
-                // markup-like content into DOMPurify's unsafe-node check, which would then throw trying
-                // to _forceRemove the now-parentless node.
-                empty(element);
                 remove$8(element);
             }
             else {
                 unwrap(element);
             }
-            // We detach the element above; DOMPurify throws if it then tries to _forceRemove the
-            // now-parentless node, so mark the tag allowed to stop that second removal.
-            if (isNonNullable(evt)) {
-                evt.allowedTags[lcTagName] = true;
-            }
             return;
         }
         // Determine if the schema allows the element and either add it or remove it
         const rule = schema.getElementRule(lcTagName);
         if (validate && !rule) {
-            // Don't detach invalid special / non-HTML-namespace elements: DOMPurify throws if it later
-            // _forceRemoves a parentless node (its unsafe-content and namespace checks do this regardless
-            // of allowedTags). Empty and leave attached instead, so DOMPurify removes it without hoisting content.
-            if (settings.sanitize && (has$2(specialElements, lcTagName) || scope !== 'html')) {
-                empty(element);
+            // If a special element is invalid, then remove the entire element instead of unwrapping
+            if (has$2(specialElements, lcTagName)) {
+                remove$8(element);
             }
             else {
-                // No DOMPurify to remove it (sanitize disabled), or a plain invalid HTML element: detach it ourselves.
-                if (has$2(specialElements, lcTagName)) {
-                    remove$8(element);
-                }
-                else {
-                    unwrap(element);
-                }
-                // The element is now detached; mark the tag allowed so DOMPurify won't _forceRemove the
-                // parentless node and throw. Safe here: it's empty and HTML-namespaced, so no earlier check fires.
-                if (isNonNullable(evt)) {
-                    evt.allowedTags[lcTagName] = true;
-                }
+                unwrap(element);
             }
             return;
         }
@@ -21588,9 +21772,7 @@
                 evt.allowedTags[lcTagName] = keepElement;
                 if (!keepElement && settings.sanitize) {
                     if (isElement$7(node)) {
-                        // Empty the node and leave it attached so DOMPurify removes it (allowedTags is false).
-                        // Detaching it would make DOMPurify throw when it _forceRemoves the parentless node.
-                        empty(SugarElement.fromDom(node));
+                        node.remove();
                     }
                 }
             });
@@ -23212,14 +23394,21 @@
                 }
             });
         };
-        // TODO: TINY-9142: Remove this to make nested noneditable formatting work
         const targetNode = isNode(node) ? node : selection.getNode();
         if (dom.getContentEditable(targetNode) === 'false' && !isWrappableNoneditable(ed, targetNode)) {
             // node variable is used by other functions above in the same scope so need to set it here
             node = targetNode;
             applyNodeStyle(formatList, node);
-            if (isBlockFormat(format) && !dom.isBlock(targetNode)) {
-                const parentBlock = dom.getParent(targetNode, dom.isBlock);
+            if (hasEditableDescendants(dom, node)) {
+                each$e(getEditableDescendants(dom, node), (island) => {
+                    const rng = dom.createRng();
+                    rng.selectNodeContents(island);
+                    applyRngStyle(dom, rng, true);
+                });
+                return;
+            }
+            if (isBlockFormat(format) && !dom.isBlock(node)) {
+                const parentBlock = dom.getParent(node, dom.isBlock);
                 if (dom.isEditable(parentBlock)) {
                     const wrapperElementName = format.block;
                     if (parentBlock.nodeName.toLowerCase() === wrapperElementName.toLowerCase()) {
@@ -23231,6 +23420,12 @@
                     }
                 }
             }
+            else {
+                const selectorFormats = filter$5(formatList, isSelectorFormat);
+                Optional.from(dom.getParent(node, (candidate) => exists(selectorFormats, (fmt) => dom.is(candidate, fmt.selector))))
+                    .filter(dom.isEditable)
+                    .each((parent) => applyNodeStyle(formatList, parent));
+            }
             fireFormatApply(ed, name, node, vars);
             return;
         }
@@ -38309,9 +38504,11 @@
     const initTooltipClosing = (editor) => {
         const closeTooltipsListener = (event) => {
             if (event.keyCode === VK.ESC && !event.defaultPrevented) {
-                if (fireCloseTooltips(editor).isDefaultPrevented()) {
-                    event.preventDefault();
-                }
+                each$e(editor.editorManager.get(), (ed) => {
+                    if (fireCloseTooltips(ed).isDefaultPrevented()) {
+                        event.preventDefault();
+                    }
+                });
             }
         };
         document.addEventListener('keyup', closeTooltipsListener);
@@ -39479,7 +39676,7 @@
                 editor.getWin().print();
             },
             mceFocus: (_command, _ui, value) => {
-                focus(editor, value === true);
+                focus(editor, value);
             },
             mceToggleVisualAid: () => {
                 editor.hasVisual = !editor.hasVisual;
@@ -41205,7 +41402,12 @@
          * it will also place DOM focus inside the editor.
          *
          * @method focus
-         * @param {Boolean} skipFocus Skip DOM focus. Just set is as the active editor.
+         * @param {Boolean/Object} skipFocus If true, skip DOM focus and only set this editor as the active editor. If an object, focus the editor and optionally control scrolling.
+         * @param {Boolean} skipFocus.scrollToSelection If false, focuses the editor without scrolling the selection into view. Defaults to true.
+         * @example
+         * tinymce.activeEditor.focus();
+         * tinymce.activeEditor.focus(true);
+         * tinymce.activeEditor.focus({ scrollToSelection: false });
          */
         focus(skipFocus) {
             this.execCommand('mceFocus', false, skipFocus);
@@ -41901,14 +42103,14 @@
          * @property minorVersion
          * @type String
          */
-        minorVersion: '8.1',
+        minorVersion: '9.0',
         /**
          * Release date of TinyMCE build.
          *
          * @property releaseDate
          * @type String
          */
-        releaseDate: '2026-07-22',
+        releaseDate: '2026-08-27',
         /**
          * Collection of language pack data.
          *

data/lib/tinymce/rails/version.rb

@@ -1,6 +1,6 @@
 module TinyMCE
   module Rails
-    VERSION = "8.8.1"
-    TINYMCE_VERSION = "8.8.1"
+    VERSION = "8.9.0"
+    TINYMCE_VERSION = "8.9.0"
   end
 end