<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: plugin-20250822035051.js</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>/**
 * plugin.js
 *
 * Released under LGPL License.
 * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
 *
 * License: http://www.tinymce.com/license
 * Contributing: http://www.tinymce.com/contributing
 */

/*global tinymce:true, console:true */
/*eslint no-console:0, new-cap:0 */

/**
 * This plugin adds missing events form the 4.x API back. Not every event is
 * properly supported but most things should work.
 *
 * Unsupported things:
 *  - No editor.onEvent
 *  - Can't cancel execCommands with beforeExecCommand
 */
(function (tinymce) {
  var reported;

  function noop() {
  }

  function log(apiCall) {
    if (!reported &amp;&amp; window &amp;&amp; window.console) {
      reported = true;
      console.log(&quot;Deprecated TinyMCE API call: &quot; + apiCall);
    }
  }

  function Dispatcher(target, newEventName, argsMap, defaultScope) {
    target = target || this;
    var cbs = [];

    if (!newEventName) {
      this.add = this.addToTop = this.remove = this.dispatch = noop;
      return;
    }

    this.add = function (callback, scope, prepend) {
      log('&lt;target&gt;.on' + newEventName + &quot;.add(..)&quot;);

      // Convert callback({arg1:x, arg2:x}) -&gt; callback(arg1, arg2)
      function patchedEventCallback(e) {
        var callbackArgs = [];

        if (typeof argsMap == &quot;string&quot;) {
          argsMap = argsMap.split(&quot; &quot;);
        }

        if (argsMap &amp;&amp; typeof argsMap !== &quot;function&quot;) {
          for (var i = 0; i &lt; argsMap.length; i++) {
            callbackArgs.push(e[argsMap[i]]);
          }
        }

        if (typeof argsMap == &quot;function&quot;) {
          callbackArgs = argsMap(newEventName, e, target);
          if (!callbackArgs) {
            return;
          }
        }

        if (!argsMap) {
          callbackArgs = [e];
        }

        callbackArgs.unshift(defaultScope || target);

        if (callback.apply(scope || defaultScope || target, callbackArgs) === false) {
          e.stopImmediatePropagation();
        }
      }

      target.on(newEventName, patchedEventCallback, prepend);

      var handlers = {
        original: callback,
        patched: patchedEventCallback
      };

      cbs.push(handlers);
      return patchedEventCallback;
    };

    this.addToTop = function (callback, scope) {
      this.add(callback, scope, true);
    };

    this.remove = function (callback) {
      cbs.forEach(function (item, i) {
        if (item.original === callback) {
          cbs.splice(i, 1);
          return target.off(newEventName, item.patched);
        }
      });

      return target.off(newEventName, callback);
    };

    this.dispatch = function () {
      target.fire(newEventName);
      return true;
    };
  }

  tinymce.util.Dispatcher = Dispatcher;
  tinymce.onBeforeUnload = new Dispatcher(tinymce, &quot;BeforeUnload&quot;);
  tinymce.onAddEditor = new Dispatcher(tinymce, &quot;AddEditor&quot;, &quot;editor&quot;);
  tinymce.onRemoveEditor = new Dispatcher(tinymce, &quot;RemoveEditor&quot;, &quot;editor&quot;);

  tinymce.util.Cookie = {
    get: noop, getHash: noop, remove: noop, set: noop, setHash: noop
  };

  function patchEditor(editor) {

    function translate(str) {
      var prefix = editor.settings.language || &quot;en&quot;;
      var prefixedStr = [prefix, str].join('.');
      var translatedStr = tinymce.i18n.translate(prefixedStr);

      return prefixedStr !== translatedStr ? translatedStr : tinymce.i18n.translate(str);
    }

    function patchEditorEvents(oldEventNames, argsMap) {
      tinymce.each(oldEventNames.split(&quot; &quot;), function (oldName) {
        editor[&quot;on&quot; + oldName] = new Dispatcher(editor, oldName, argsMap);
      });
    }

    function convertUndoEventArgs(type, event, target) {
      return [
        event.level,
        target
      ];
    }

    function filterSelectionEvents(needsSelection) {
      return function (type, e) {
        if ((!e.selection &amp;&amp; !needsSelection) || e.selection == needsSelection) {
          return [e];
        }
      };
    }

    if (editor.controlManager) {
      return;
    }

    function cmNoop() {
      var obj = {}, methods = 'add addMenu addSeparator collapse createMenu destroy displayColor expand focus ' +
        'getLength hasMenus hideMenu isActive isCollapsed isDisabled isRendered isSelected mark ' +
        'postRender remove removeAll renderHTML renderMenu renderNode renderTo select selectByIndex ' +
        'setActive setAriaProperty setColor setDisabled setSelected setState showMenu update';

      log('editor.controlManager.*');

      function _noop() {
        return cmNoop();
      }

      tinymce.each(methods.split(' '), function (method) {
        obj[method] = _noop;
      });

      return obj;
    }

    editor.controlManager = {
      buttons: {},

      setDisabled: function (name, state) {
        log(&quot;controlManager.setDisabled(..)&quot;);

        if (this.buttons[name]) {
          this.buttons[name].disabled(state);
        }
      },

      setActive: function (name, state) {
        log(&quot;controlManager.setActive(..)&quot;);

        if (this.buttons[name]) {
          this.buttons[name].active(state);
        }
      },

      onAdd: new Dispatcher(),
      onPostRender: new Dispatcher(),

      add: function (obj) {
        return obj;
      },
      createButton: cmNoop,
      createColorSplitButton: cmNoop,
      createControl: cmNoop,
      createDropMenu: cmNoop,
      createListBox: cmNoop,
      createMenuButton: cmNoop,
      createSeparator: cmNoop,
      createSplitButton: cmNoop,
      createToolbar: cmNoop,
      createToolbarGroup: cmNoop,
      destroy: noop,
      get: noop,
      setControlType: cmNoop
    };

    patchEditorEvents(&quot;PreInit BeforeRenderUI PostRender Load Init Remove Activate Deactivate&quot;, &quot;editor&quot;);
    patchEditorEvents(&quot;Click MouseUp MouseDown DblClick KeyDown KeyUp KeyPress ContextMenu Paste Submit Reset&quot;);
    patchEditorEvents(&quot;BeforeExecCommand ExecCommand&quot;, &quot;command ui value args&quot;); // args.terminate not supported
    patchEditorEvents(&quot;PreProcess PostProcess LoadContent SaveContent Change&quot;);
    patchEditorEvents(&quot;BeforeSetContent BeforeGetContent SetContent GetContent&quot;, filterSelectionEvents(false));
    patchEditorEvents(&quot;SetProgressState&quot;, &quot;state time&quot;);
    patchEditorEvents(&quot;VisualAid&quot;, &quot;element hasVisual&quot;);
    patchEditorEvents(&quot;Undo Redo&quot;, convertUndoEventArgs);

    patchEditorEvents(&quot;NodeChange&quot;, function (type, e) {
      return [
        editor.controlManager,
        e.element,
        editor.selection.isCollapsed(),
        e
      ];
    });

    var originalAddButton = editor.addButton;
    editor.addButton = function (name, settings) {
      var originalOnPostRender;

      function patchedPostRender() {
        editor.controlManager.buttons[name] = this;

        if (originalOnPostRender) {
          return originalOnPostRender.apply(this, arguments);
        }
      }

      for (var key in settings) {
        if (key.toLowerCase() === &quot;onpostrender&quot;) {
          originalOnPostRender = settings[key];
          settings.onPostRender = patchedPostRender;
        }
      }

      if (!originalOnPostRender) {
        settings.onPostRender = patchedPostRender;
      }

      if (settings.title) {
        settings.title = translate(settings.title);
      }

      return originalAddButton.call(this, name, settings);
    };

    editor.on('init', function () {
      var undoManager = editor.undoManager, selection = editor.selection;

      undoManager.onUndo = new Dispatcher(editor, &quot;Undo&quot;, convertUndoEventArgs, null, undoManager);
      undoManager.onRedo = new Dispatcher(editor, &quot;Redo&quot;, convertUndoEventArgs, null, undoManager);
      undoManager.onBeforeAdd = new Dispatcher(editor, &quot;BeforeAddUndo&quot;, null, undoManager);
      undoManager.onAdd = new Dispatcher(editor, &quot;AddUndo&quot;, null, undoManager);

      selection.onBeforeGetContent = new Dispatcher(editor, &quot;BeforeGetContent&quot;, filterSelectionEvents(true), selection);
      selection.onGetContent = new Dispatcher(editor, &quot;GetContent&quot;, filterSelectionEvents(true), selection);
      selection.onBeforeSetContent = new Dispatcher(editor, &quot;BeforeSetContent&quot;, filterSelectionEvents(true), selection);
      selection.onSetContent = new Dispatcher(editor, &quot;SetContent&quot;, filterSelectionEvents(true), selection);
    });

    editor.on('BeforeRenderUI', function () {
      var windowManager = editor.windowManager;

      windowManager.onOpen = new Dispatcher();
      windowManager.onClose = new Dispatcher();
      windowManager.createInstance = function (className, a, b, c, d, e) {
        log(&quot;windowManager.createInstance(..)&quot;);

        var constr = tinymce.resolve(className);
        return new constr(a, b, c, d, e);
      };
    });
  }

  tinymce.on('SetupEditor', function (e) {
    patchEditor(e.editor);
  });

  tinymce.PluginManager.add(&quot;compat3x&quot;, patchEditor);

  tinymce.addI18n = function (prefix, o) {
    var I18n = tinymce.util.I18n, each = tinymce.each;

    if (typeof prefix == &quot;string&quot; &amp;&amp; prefix.indexOf('.') === -1) {
      I18n.add(prefix, o);
      return;
    }

    if (!tinymce.is(prefix, 'string')) {
      each(prefix, function (o, lc) {
        each(o, function (o, g) {
          each(o, function (o, k) {
            if (g === 'common') {
              I18n.data[lc + '.' + k] = o;
            } else {
              I18n.data[lc + '.' + g + '.' + k] = o;
            }
          });
        });
      });
    } else {
      each(o, function (o, k) {
        I18n.data[prefix + '.' + k] = o;
      });
    }
  };
})(tinymce);
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-admin-20250805060641%2Fnetwork'>🔙 Back</a>