tinymce-rails 7.5.1 → 7.6.0

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

@@ -1,5 +1,5 @@
 /**
- * TinyMCE version 7.5.1 (TBD)
+ * TinyMCE version 7.6.0 (2024-12-11)
  */
 
 (function () {
@@ -1178,7 +1178,7 @@
         throw new Error('Attribute value was not simple');
       }
     };
-    const set$3 = (element, key, value) => {
+    const set$4 = (element, key, value) => {
       rawSet(element.dom, key, value);
     };
     const setAll$1 = (element, attrs) => {
@@ -1215,13 +1215,13 @@
     const add$4 = (element, attr, id) => {
       const old = read$4(element, attr);
       const nu = old.concat([id]);
-      set$3(element, attr, nu.join(' '));
+      set$4(element, attr, nu.join(' '));
       return true;
     };
     const remove$8 = (element, attr, id) => {
       const nu = filter$5(read$4(element, attr), v => v !== id);
       if (nu.length > 0) {
-        set$3(element, attr, nu.join(' '));
+        set$4(element, attr, nu.join(' '));
       } else {
         remove$9(element, attr);
       }
@@ -1508,6 +1508,9 @@
       }
     };
     const getRaw$1 = element => element.dom.contentEditable;
+    const set$3 = (element, editable) => {
+      element.dom.contentEditable = editable ? 'true' : 'false';
+    };
 
     const isSupported = dom => dom.style !== undefined && isFunction(dom.style.getPropertyValue);
 
@@ -2426,16 +2429,16 @@
           id: state.id
         });
         if (settings.contentCssCors) {
-          set$3(linkElem, 'crossOrigin', 'anonymous');
+          set$4(linkElem, 'crossOrigin', 'anonymous');
         }
         if (settings.referrerPolicy) {
-          set$3(linkElem, 'referrerpolicy', settings.referrerPolicy);
+          set$4(linkElem, 'referrerpolicy', settings.referrerPolicy);
         }
         link = linkElem.dom;
         link.onload = passed;
         link.onerror = failed;
         addStyle(linkElem);
-        set$3(linkElem, 'href', urlWithSuffix);
+        set$4(linkElem, 'href', urlWithSuffix);
       });
       const loadRawCss = (key, css) => {
         const state = getOrCreateState(key);
@@ -2443,9 +2446,10 @@
         state.count++;
         const styleElem = SugarElement.fromTag('style', doc.dom);
         setAll$1(styleElem, {
-          rel: 'stylesheet',
-          type: 'text/css',
-          id: state.id
+          'rel': 'stylesheet',
+          'type': 'text/css',
+          'id': state.id,
+          'data-mce-key': key
         });
         styleElem.dom.innerHTML = css;
         addStyle(styleElem);
@@ -4148,7 +4152,7 @@
       if (isNullable(value) || value === '') {
         remove$9(elm, name);
       } else {
-        set$3(elm, name, value);
+        set$4(elm, name, value);
       }
     };
     const camelCaseToHyphens = name => name.replace(/[A-Z]/g, v => '-' + v.toLowerCase());
@@ -5356,7 +5360,7 @@
       const toggleActiveAttr = (uid, state) => {
         each$e(findMarkers(editor, uid), elem => {
           if (state) {
-            set$3(elem, dataAnnotationActive(), 'true');
+            set$4(elem, dataAnnotationActive(), 'true');
           } else {
             remove$9(elem, dataAnnotationActive());
           }
@@ -5655,7 +5659,7 @@
     };
     const createPaddingBr = () => {
       const br = SugarElement.fromTag('br');
-      set$3(br, 'data-mce-bogus', '1');
+      set$4(br, 'data-mce-bogus', '1');
       return br;
     };
     const fillWithPaddingBr = elm => {
@@ -6826,6 +6830,90 @@
       };
     };
 
+    const firePreProcess = (editor, args) => editor.dispatch('PreProcess', args);
+    const firePostProcess = (editor, args) => editor.dispatch('PostProcess', args);
+    const fireRemove = editor => {
+      editor.dispatch('remove');
+    };
+    const fireDetach = editor => {
+      editor.dispatch('detach');
+    };
+    const fireSwitchMode = (editor, mode) => {
+      editor.dispatch('SwitchMode', { mode });
+    };
+    const fireObjectResizeStart = (editor, target, width, height, origin) => {
+      editor.dispatch('ObjectResizeStart', {
+        target,
+        width,
+        height,
+        origin
+      });
+    };
+    const fireObjectResized = (editor, target, width, height, origin) => {
+      editor.dispatch('ObjectResized', {
+        target,
+        width,
+        height,
+        origin
+      });
+    };
+    const firePreInit = editor => {
+      editor.dispatch('PreInit');
+    };
+    const firePostRender = editor => {
+      editor.dispatch('PostRender');
+    };
+    const fireInit = editor => {
+      editor.dispatch('Init');
+    };
+    const firePlaceholderToggle = (editor, state) => {
+      editor.dispatch('PlaceholderToggle', { state });
+    };
+    const fireError = (editor, errorType, error) => {
+      editor.dispatch(errorType, error);
+    };
+    const fireFormatApply = (editor, format, node, vars) => {
+      editor.dispatch('FormatApply', {
+        format,
+        node,
+        vars
+      });
+    };
+    const fireFormatRemove = (editor, format, node, vars) => {
+      editor.dispatch('FormatRemove', {
+        format,
+        node,
+        vars
+      });
+    };
+    const fireBeforeSetContent = (editor, args) => editor.dispatch('BeforeSetContent', args);
+    const fireSetContent = (editor, args) => editor.dispatch('SetContent', args);
+    const fireBeforeGetContent = (editor, args) => editor.dispatch('BeforeGetContent', args);
+    const fireGetContent = (editor, args) => editor.dispatch('GetContent', args);
+    const fireAutocompleterStart = (editor, args) => {
+      editor.dispatch('AutocompleterStart', args);
+    };
+    const fireAutocompleterUpdate = (editor, args) => {
+      editor.dispatch('AutocompleterUpdate', args);
+    };
+    const fireAutocompleterUpdateActiveRange = (editor, args) => {
+      editor.dispatch('AutocompleterUpdateActiveRange', args);
+    };
+    const fireAutocompleterEnd = editor => {
+      editor.dispatch('AutocompleterEnd');
+    };
+    const firePastePreProcess = (editor, html, internal) => editor.dispatch('PastePreProcess', {
+      content: html,
+      internal
+    });
+    const firePastePostProcess = (editor, node, internal) => editor.dispatch('PastePostProcess', {
+      node,
+      internal
+    });
+    const firePastePlainTextToggle = (editor, state) => editor.dispatch('PastePlainTextToggle', { state });
+    const fireEditableRootStateChange = (editor, state) => editor.dispatch('EditableRootStateChange', { state });
+    const fireDisabledStateChange = (editor, state) => editor.dispatch('DisabledStateChange', { state });
+
     const deviceDetection$1 = detect$1().deviceType;
     const isTouch = deviceDetection$1.isTouch();
     const DOM$a = DOMUtils.DOM;
@@ -7219,6 +7307,26 @@
         processor: 'boolean',
         default: false
       });
+      registerOption('disabled', {
+        processor: value => {
+          if (isBoolean(value)) {
+            if (editor.initialized && isDisabled$1(editor) !== value) {
+              Promise.resolve().then(() => {
+                fireDisabledStateChange(editor, value);
+              });
+            }
+            return {
+              valid: true,
+              value
+            };
+          }
+          return {
+            valid: false,
+            message: 'The value must be a boolean.'
+          };
+        },
+        default: false
+      });
       registerOption('readonly', {
         processor: 'boolean',
         default: false
@@ -7738,6 +7846,7 @@
     const shouldConvertUnsafeEmbeds = option('convert_unsafe_embeds');
     const getLicenseKey = option('license_key');
     const getApiKey = option('api_key');
+    const isDisabled$1 = option('disabled');
 
     const isElement$3 = isElement$6;
     const isText$5 = isText$b;
@@ -9303,18 +9412,18 @@
     const applyAnnotation = (elem, masterUId, data, annotationName, decorate, directAnnotation) => {
       const {uid = masterUId, ...otherData} = data;
       add$2(elem, annotation());
-      set$3(elem, `${ dataAnnotationId() }`, uid);
-      set$3(elem, `${ dataAnnotation() }`, annotationName);
+      set$4(elem, `${ dataAnnotationId() }`, uid);
+      set$4(elem, `${ dataAnnotation() }`, annotationName);
       const {attributes = {}, classes = []} = decorate(uid, otherData);
       setAll$1(elem, attributes);
       add(elem, classes);
       if (directAnnotation) {
         if (classes.length > 0) {
-          set$3(elem, `${ dataAnnotationClasses() }`, classes.join(','));
+          set$4(elem, `${ dataAnnotationClasses() }`, classes.join(','));
         }
         const attributeNames = keys(attributes);
         if (attributeNames.length > 0) {
-          set$3(elem, `${ dataAnnotationAttributes() }`, attributeNames.join(','));
+          set$4(elem, `${ dataAnnotationAttributes() }`, attributeNames.join(','));
         }
       }
     };
@@ -9470,1563 +9579,1480 @@
       }
     };
 
-    const firePreProcess = (editor, args) => editor.dispatch('PreProcess', args);
-    const firePostProcess = (editor, args) => editor.dispatch('PostProcess', args);
-    const fireRemove = editor => {
-      editor.dispatch('remove');
-    };
-    const fireDetach = editor => {
-      editor.dispatch('detach');
+    const getDocument = () => SugarElement.fromDom(document);
+
+    const focus$1 = (element, preventScroll = false) => element.dom.focus({ preventScroll });
+    const hasFocus$1 = element => {
+      const root = getRootNode(element).dom;
+      return element.dom === root.activeElement;
     };
-    const fireSwitchMode = (editor, mode) => {
-      editor.dispatch('SwitchMode', { mode });
+    const active$1 = (root = getDocument()) => Optional.from(root.dom.activeElement).map(SugarElement.fromDom);
+    const search = element => active$1(getRootNode(element)).filter(e => element.dom.contains(e.dom));
+
+    const create$9 = (start, soffset, finish, foffset) => ({
+      start,
+      soffset,
+      finish,
+      foffset
+    });
+    const SimRange = { create: create$9 };
+
+    const adt$3 = Adt.generate([
+      { before: ['element'] },
+      {
+        on: [
+          'element',
+          'offset'
+        ]
+      },
+      { after: ['element'] }
+    ]);
+    const cata = (subject, onBefore, onOn, onAfter) => subject.fold(onBefore, onOn, onAfter);
+    const getStart$2 = situ => situ.fold(identity, identity, identity);
+    const before$1 = adt$3.before;
+    const on = adt$3.on;
+    const after$1 = adt$3.after;
+    const Situ = {
+      before: before$1,
+      on,
+      after: after$1,
+      cata,
+      getStart: getStart$2
     };
-    const fireObjectResizeStart = (editor, target, width, height, origin) => {
-      editor.dispatch('ObjectResizeStart', {
-        target,
-        width,
-        height,
-        origin
-      });
+
+    const adt$2 = Adt.generate([
+      { domRange: ['rng'] },
+      {
+        relative: [
+          'startSitu',
+          'finishSitu'
+        ]
+      },
+      {
+        exact: [
+          'start',
+          'soffset',
+          'finish',
+          'foffset'
+        ]
+      }
+    ]);
+    const exactFromRange = simRange => adt$2.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset);
+    const getStart$1 = selection => selection.match({
+      domRange: rng => SugarElement.fromDom(rng.startContainer),
+      relative: (startSitu, _finishSitu) => Situ.getStart(startSitu),
+      exact: (start, _soffset, _finish, _foffset) => start
+    });
+    const domRange = adt$2.domRange;
+    const relative = adt$2.relative;
+    const exact = adt$2.exact;
+    const getWin = selection => {
+      const start = getStart$1(selection);
+      return defaultView(start);
     };
-    const fireObjectResized = (editor, target, width, height, origin) => {
-      editor.dispatch('ObjectResized', {
-        target,
-        width,
-        height,
-        origin
-      });
+    const range = SimRange.create;
+    const SimSelection = {
+      domRange,
+      relative,
+      exact,
+      exactFromRange,
+      getWin,
+      range
     };
-    const firePreInit = editor => {
-      editor.dispatch('PreInit');
+
+    const clamp$1 = (offset, element) => {
+      const max = isText$c(element) ? get$3(element).length : children$1(element).length + 1;
+      if (offset > max) {
+        return max;
+      } else if (offset < 0) {
+        return 0;
+      }
+      return offset;
     };
-    const firePostRender = editor => {
-      editor.dispatch('PostRender');
+    const normalizeRng = rng => SimSelection.range(rng.start, clamp$1(rng.soffset, rng.start), rng.finish, clamp$1(rng.foffset, rng.finish));
+    const isOrContains = (root, elm) => !isRestrictedNode(elm.dom) && (contains(root, elm) || eq(root, elm));
+    const isRngInRoot = root => rng => isOrContains(root, rng.start) && isOrContains(root, rng.finish);
+    const shouldStore = editor => editor.inline || Env.browser.isFirefox();
+    const nativeRangeToSelectionRange = r => SimSelection.range(SugarElement.fromDom(r.startContainer), r.startOffset, SugarElement.fromDom(r.endContainer), r.endOffset);
+    const readRange = win => {
+      const selection = win.getSelection();
+      const rng = !selection || selection.rangeCount === 0 ? Optional.none() : Optional.from(selection.getRangeAt(0));
+      return rng.map(nativeRangeToSelectionRange);
     };
-    const fireInit = editor => {
-      editor.dispatch('Init');
+    const getBookmark$1 = root => {
+      const win = defaultView(root);
+      return readRange(win.dom).filter(isRngInRoot(root));
     };
-    const firePlaceholderToggle = (editor, state) => {
-      editor.dispatch('PlaceholderToggle', { state });
+    const validate = (root, bookmark) => Optional.from(bookmark).filter(isRngInRoot(root)).map(normalizeRng);
+    const bookmarkToNativeRng = bookmark => {
+      const rng = document.createRange();
+      try {
+        rng.setStart(bookmark.start.dom, bookmark.soffset);
+        rng.setEnd(bookmark.finish.dom, bookmark.foffset);
+        return Optional.some(rng);
+      } catch (_) {
+        return Optional.none();
+      }
     };
-    const fireError = (editor, errorType, error) => {
-      editor.dispatch(errorType, error);
+    const store = editor => {
+      const newBookmark = shouldStore(editor) ? getBookmark$1(SugarElement.fromDom(editor.getBody())) : Optional.none();
+      editor.bookmark = newBookmark.isSome() ? newBookmark : editor.bookmark;
     };
-    const fireFormatApply = (editor, format, node, vars) => {
-      editor.dispatch('FormatApply', {
-        format,
-        node,
-        vars
-      });
+    const getRng = editor => {
+      const bookmark = editor.bookmark ? editor.bookmark : Optional.none();
+      return bookmark.bind(x => validate(SugarElement.fromDom(editor.getBody()), x)).bind(bookmarkToNativeRng);
     };
-    const fireFormatRemove = (editor, format, node, vars) => {
-      editor.dispatch('FormatRemove', {
-        format,
-        node,
-        vars
-      });
+    const restore = editor => {
+      getRng(editor).each(rng => editor.selection.setRng(rng));
     };
-    const fireBeforeSetContent = (editor, args) => editor.dispatch('BeforeSetContent', args);
-    const fireSetContent = (editor, args) => editor.dispatch('SetContent', args);
-    const fireBeforeGetContent = (editor, args) => editor.dispatch('BeforeGetContent', args);
-    const fireGetContent = (editor, args) => editor.dispatch('GetContent', args);
-    const fireAutocompleterStart = (editor, args) => {
-      editor.dispatch('AutocompleterStart', args);
-    };
-    const fireAutocompleterUpdate = (editor, args) => {
-      editor.dispatch('AutocompleterUpdate', args);
+
+    const isEditorUIElement$1 = elm => {
+      const className = elm.className.toString();
+      return className.indexOf('tox-') !== -1 || className.indexOf('mce-') !== -1;
     };
-    const fireAutocompleterUpdateActiveRange = (editor, args) => {
-      editor.dispatch('AutocompleterUpdateActiveRange', args);
+    const FocusManager = { isEditorUIElement: isEditorUIElement$1 };
+
+    const wrappedSetTimeout = (callback, time) => {
+      if (!isNumber(time)) {
+        time = 0;
+      }
+      return setTimeout(callback, time);
     };
-    const fireAutocompleterEnd = editor => {
-      editor.dispatch('AutocompleterEnd');
+    const wrappedSetInterval = (callback, time) => {
+      if (!isNumber(time)) {
+        time = 0;
+      }
+      return setInterval(callback, time);
     };
-    const firePastePreProcess = (editor, html, internal) => editor.dispatch('PastePreProcess', {
-      content: html,
-      internal
-    });
-    const firePastePostProcess = (editor, node, internal) => editor.dispatch('PastePostProcess', {
-      node,
-      internal
-    });
-    const firePastePlainTextToggle = (editor, state) => editor.dispatch('PastePlainTextToggle', { state });
-    const fireEditableRootStateChange = (editor, state) => editor.dispatch('EditableRootStateChange', { state });
-
-    const VK = {
-      BACKSPACE: 8,
-      DELETE: 46,
-      DOWN: 40,
-      ENTER: 13,
-      ESC: 27,
-      LEFT: 37,
-      RIGHT: 39,
-      SPACEBAR: 32,
-      TAB: 9,
-      UP: 38,
-      PAGE_UP: 33,
-      PAGE_DOWN: 34,
-      END: 35,
-      HOME: 36,
-      modifierPressed: e => {
-        return e.shiftKey || e.ctrlKey || e.altKey || VK.metaKeyPressed(e);
+    const Delay = {
+      setEditorTimeout: (editor, callback, time) => {
+        return wrappedSetTimeout(() => {
+          if (!editor.removed) {
+            callback();
+          }
+        }, time);
       },
-      metaKeyPressed: e => {
-        return Env.os.isMacOS() || Env.os.isiOS() ? e.metaKey : e.ctrlKey && !e.altKey;
+      setEditorInterval: (editor, callback, time) => {
+        const timer = wrappedSetInterval(() => {
+          if (!editor.removed) {
+            callback();
+          } else {
+            clearInterval(timer);
+          }
+        }, time);
+        return timer;
       }
     };
 
-    const elementSelectionAttr = 'data-mce-selected';
-    const controlElmSelector = 'table,img,figure.image,hr,video,span.mce-preview-object,details';
-    const abs = Math.abs;
-    const round$1 = Math.round;
-    const resizeHandles = {
-      nw: [
-        0,
-        0,
-        -1,
-        -1
-      ],
-      ne: [
-        1,
-        0,
-        1,
-        -1
-      ],
-      se: [
-        1,
-        1,
-        1,
-        1
-      ],
-      sw: [
-        0,
-        1,
-        -1,
-        1
-      ]
+    const isManualNodeChange = e => {
+      return e.type === 'nodechange' && e.selectionChange;
     };
-    const isTouchEvent = evt => evt.type === 'longpress' || evt.type.indexOf('touch') === 0;
-    const ControlSelection = (selection, editor) => {
-      const dom = editor.dom;
-      const editableDoc = editor.getDoc();
-      const rootDocument = document;
-      const rootElement = editor.getBody();
-      let selectedElm, selectedElmGhost, resizeHelper, selectedHandle, resizeBackdrop;
-      let startX, startY, selectedElmX, selectedElmY, startW, startH, ratio, resizeStarted;
-      let width;
-      let height;
-      let startScrollWidth;
-      let startScrollHeight;
-      const isImage = elm => isNonNullable(elm) && (isImg(elm) || dom.is(elm, 'figure.image'));
-      const isMedia = elm => isMedia$2(elm) || dom.hasClass(elm, 'mce-preview-object');
-      const isEventOnImageOutsideRange = (evt, range) => {
-        if (isTouchEvent(evt)) {
-          const touch = evt.touches[0];
-          return isImage(evt.target) && !isXYWithinRange(touch.clientX, touch.clientY, range);
-        } else {
-          return isImage(evt.target) && !isXYWithinRange(evt.clientX, evt.clientY, range);
-        }
-      };
-      const contextMenuSelectImage = evt => {
-        const target = evt.target;
-        if (isEventOnImageOutsideRange(evt, editor.selection.getRng()) && !evt.isDefaultPrevented()) {
-          editor.selection.select(target);
-        }
-      };
-      const getResizeTargets = elm => {
-        if (dom.hasClass(elm, 'mce-preview-object') && isNonNullable(elm.firstElementChild)) {
-          return [
-            elm,
-            elm.firstElementChild
-          ];
-        } else if (dom.is(elm, 'figure.image')) {
-          return [elm.querySelector('img')];
-        } else {
-          return [elm];
-        }
+    const registerPageMouseUp = (editor, throttledStore) => {
+      const mouseUpPage = () => {
+        throttledStore.throttle();
       };
-      const isResizable = elm => {
-        const selector = getObjectResizing(editor);
-        if (!selector || editor.mode.isReadOnly()) {
-          return false;
-        }
-        if (elm.getAttribute('data-mce-resize') === 'false') {
-          return false;
+      DOMUtils.DOM.bind(document, 'mouseup', mouseUpPage);
+      editor.on('remove', () => {
+        DOMUtils.DOM.unbind(document, 'mouseup', mouseUpPage);
+      });
+    };
+    const registerMouseUp = (editor, throttledStore) => {
+      editor.on('mouseup touchend', _e => {
+        throttledStore.throttle();
+      });
+    };
+    const registerEditorEvents = (editor, throttledStore) => {
+      registerMouseUp(editor, throttledStore);
+      editor.on('keyup NodeChange AfterSetSelectionRange', e => {
+        if (!isManualNodeChange(e)) {
+          store(editor);
         }
-        if (elm === editor.getBody()) {
-          return false;
+      });
+    };
+    const register$6 = editor => {
+      const throttledStore = first$1(() => {
+        store(editor);
+      }, 0);
+      editor.on('init', () => {
+        if (editor.inline) {
+          registerPageMouseUp(editor, throttledStore);
         }
-        if (dom.hasClass(elm, 'mce-preview-object') && isNonNullable(elm.firstElementChild)) {
-          return is$1(SugarElement.fromDom(elm.firstElementChild), selector);
-        } else {
-          return is$1(SugarElement.fromDom(elm), selector);
+        registerEditorEvents(editor, throttledStore);
+      });
+      editor.on('remove', () => {
+        throttledStore.cancel();
+      });
+    };
+
+    let documentFocusInHandler;
+    const DOM$9 = DOMUtils.DOM;
+    const isEditorUIElement = elm => {
+      return isElement$6(elm) && FocusManager.isEditorUIElement(elm);
+    };
+    const isEditorContentAreaElement = elm => {
+      const classList = elm.classList;
+      if (classList !== undefined) {
+        return classList.contains('tox-edit-area') || classList.contains('tox-edit-area__iframe') || classList.contains('mce-content-body');
+      } else {
+        return false;
+      }
+    };
+    const isUIElement = (editor, elm) => {
+      const customSelector = getCustomUiSelector(editor);
+      const parent = DOM$9.getParent(elm, elm => {
+        return isEditorUIElement(elm) || (customSelector ? editor.dom.is(elm, customSelector) : false);
+      });
+      return parent !== null;
+    };
+    const getActiveElement = editor => {
+      try {
+        const root = getRootNode(SugarElement.fromDom(editor.getElement()));
+        return active$1(root).fold(() => document.body, x => x.dom);
+      } catch (ex) {
+        return document.body;
+      }
+    };
+    const registerEvents$1 = (editorManager, e) => {
+      const editor = e.editor;
+      register$6(editor);
+      const toggleContentAreaOnFocus = (editor, fn) => {
+        if (shouldHighlightOnFocus(editor) && editor.inline !== true) {
+          const contentArea = SugarElement.fromDom(editor.getContainer());
+          fn(contentArea, 'tox-edit-focus');
         }
       };
-      const createGhostElement = (dom, elm) => {
-        if (isMedia(elm)) {
-          return dom.create('img', { src: Env.transparentSrc });
-        } else if (isTable$2(elm)) {
-          const isNorth = startsWith(selectedHandle.name, 'n');
-          const rowSelect = isNorth ? head : last$2;
-          const tableElm = elm.cloneNode(true);
-          rowSelect(dom.select('tr', tableElm)).each(tr => {
-            const cells = dom.select('td,th', tr);
-            dom.setStyle(tr, 'height', null);
-            each$e(cells, cell => dom.setStyle(cell, 'height', null));
-          });
-          return tableElm;
-        } else {
-          return elm.cloneNode(true);
+      editor.on('focusin', () => {
+        const focusedEditor = editorManager.focusedEditor;
+        if (isEditorContentAreaElement(getActiveElement(editor))) {
+          toggleContentAreaOnFocus(editor, add$2);
         }
-      };
-      const setSizeProp = (element, name, value) => {
-        if (isNonNullable(value)) {
-          const targets = getResizeTargets(element);
-          each$e(targets, target => {
-            if (target.style[name] || !editor.schema.isValid(target.nodeName.toLowerCase(), name)) {
-              dom.setStyle(target, name, value);
-            } else {
-              dom.setAttrib(target, name, '' + value);
-            }
-          });
-        }
-      };
-      const setGhostElmSize = (ghostElm, width, height) => {
-        setSizeProp(ghostElm, 'width', width);
-        setSizeProp(ghostElm, 'height', height);
-      };
-      const resizeGhostElement = e => {
-        let deltaX, deltaY, proportional;
-        let resizeHelperX, resizeHelperY;
-        deltaX = e.screenX - startX;
-        deltaY = e.screenY - startY;
-        width = deltaX * selectedHandle[2] + startW;
-        height = deltaY * selectedHandle[3] + startH;
-        width = width < 5 ? 5 : width;
-        height = height < 5 ? 5 : height;
-        if ((isImage(selectedElm) || isMedia(selectedElm)) && getResizeImgProportional(editor) !== false) {
-          proportional = !VK.modifierPressed(e);
-        } else {
-          proportional = VK.modifierPressed(e);
-        }
-        if (proportional) {
-          if (abs(deltaX) > abs(deltaY)) {
-            height = round$1(width * ratio);
-            width = round$1(height / ratio);
-          } else {
-            width = round$1(height / ratio);
-            height = round$1(width * ratio);
-          }
-        }
-        setGhostElmSize(selectedElmGhost, width, height);
-        resizeHelperX = selectedHandle.startPos.x + deltaX;
-        resizeHelperY = selectedHandle.startPos.y + deltaY;
-        resizeHelperX = resizeHelperX > 0 ? resizeHelperX : 0;
-        resizeHelperY = resizeHelperY > 0 ? resizeHelperY : 0;
-        dom.setStyles(resizeHelper, {
-          left: resizeHelperX,
-          top: resizeHelperY,
-          display: 'block'
-        });
-        resizeHelper.innerHTML = width + ' &times; ' + height;
-        if (selectedHandle[2] < 0 && selectedElmGhost.clientWidth <= width) {
-          dom.setStyle(selectedElmGhost, 'left', selectedElmX + (startW - width));
-        }
-        if (selectedHandle[3] < 0 && selectedElmGhost.clientHeight <= height) {
-          dom.setStyle(selectedElmGhost, 'top', selectedElmY + (startH - height));
-        }
-        deltaX = rootElement.scrollWidth - startScrollWidth;
-        deltaY = rootElement.scrollHeight - startScrollHeight;
-        if (deltaX + deltaY !== 0) {
-          dom.setStyles(resizeHelper, {
-            left: resizeHelperX - deltaX,
-            top: resizeHelperY - deltaY
-          });
-        }
-        if (!resizeStarted) {
-          fireObjectResizeStart(editor, selectedElm, startW, startH, 'corner-' + selectedHandle.name);
-          resizeStarted = true;
-        }
-      };
-      const endGhostResize = () => {
-        const wasResizeStarted = resizeStarted;
-        resizeStarted = false;
-        if (wasResizeStarted) {
-          setSizeProp(selectedElm, 'width', width);
-          setSizeProp(selectedElm, 'height', height);
-        }
-        dom.unbind(editableDoc, 'mousemove', resizeGhostElement);
-        dom.unbind(editableDoc, 'mouseup', endGhostResize);
-        if (rootDocument !== editableDoc) {
-          dom.unbind(rootDocument, 'mousemove', resizeGhostElement);
-          dom.unbind(rootDocument, 'mouseup', endGhostResize);
-        }
-        dom.remove(selectedElmGhost);
-        dom.remove(resizeHelper);
-        dom.remove(resizeBackdrop);
-        showResizeRect(selectedElm);
-        if (wasResizeStarted) {
-          fireObjectResized(editor, selectedElm, width, height, 'corner-' + selectedHandle.name);
-          dom.setAttrib(selectedElm, 'style', dom.getAttrib(selectedElm, 'style'));
-        }
-        editor.nodeChanged();
-      };
-      const showResizeRect = targetElm => {
-        unbindResizeHandleEvents();
-        const position = dom.getPos(targetElm, rootElement);
-        const selectedElmX = position.x;
-        const selectedElmY = position.y;
-        const rect = targetElm.getBoundingClientRect();
-        const targetWidth = rect.width || rect.right - rect.left;
-        const targetHeight = rect.height || rect.bottom - rect.top;
-        if (selectedElm !== targetElm) {
-          hideResizeRect();
-          selectedElm = targetElm;
-          width = height = 0;
-        }
-        const e = editor.dispatch('ObjectSelected', { target: targetElm });
-        if (isResizable(targetElm) && !e.isDefaultPrevented()) {
-          each$d(resizeHandles, (handle, name) => {
-            const startDrag = e => {
-              const target = getResizeTargets(selectedElm)[0];
-              startX = e.screenX;
-              startY = e.screenY;
-              startW = target.clientWidth;
-              startH = target.clientHeight;
-              ratio = startH / startW;
-              selectedHandle = handle;
-              selectedHandle.name = name;
-              selectedHandle.startPos = {
-                x: targetWidth * handle[0] + selectedElmX,
-                y: targetHeight * handle[1] + selectedElmY
-              };
-              startScrollWidth = rootElement.scrollWidth;
-              startScrollHeight = rootElement.scrollHeight;
-              resizeBackdrop = dom.add(rootElement, 'div', {
-                'class': 'mce-resize-backdrop',
-                'data-mce-bogus': 'all'
-              });
-              dom.setStyles(resizeBackdrop, {
-                position: 'fixed',
-                left: '0',
-                top: '0',
-                width: '100%',
-                height: '100%'
-              });
-              selectedElmGhost = createGhostElement(dom, selectedElm);
-              dom.addClass(selectedElmGhost, 'mce-clonedresizable');
-              dom.setAttrib(selectedElmGhost, 'data-mce-bogus', 'all');
-              selectedElmGhost.contentEditable = 'false';
-              dom.setStyles(selectedElmGhost, {
-                left: selectedElmX,
-                top: selectedElmY,
-                margin: 0
-              });
-              setGhostElmSize(selectedElmGhost, targetWidth, targetHeight);
-              selectedElmGhost.removeAttribute(elementSelectionAttr);
-              rootElement.appendChild(selectedElmGhost);
-              dom.bind(editableDoc, 'mousemove', resizeGhostElement);
-              dom.bind(editableDoc, 'mouseup', endGhostResize);
-              if (rootDocument !== editableDoc) {
-                dom.bind(rootDocument, 'mousemove', resizeGhostElement);
-                dom.bind(rootDocument, 'mouseup', endGhostResize);
-              }
-              resizeHelper = dom.add(rootElement, 'div', {
-                'class': 'mce-resize-helper',
-                'data-mce-bogus': 'all'
-              }, startW + ' &times; ' + startH);
-            };
-            let handleElm = dom.get('mceResizeHandle' + name);
-            if (handleElm) {
-              dom.remove(handleElm);
-            }
-            handleElm = dom.add(rootElement, 'div', {
-              'id': 'mceResizeHandle' + name,
-              'data-mce-bogus': 'all',
-              'class': 'mce-resizehandle',
-              'unselectable': true,
-              'style': 'cursor:' + name + '-resize; margin:0; padding:0'
-            });
-            dom.bind(handleElm, 'mousedown', e => {
-              e.stopImmediatePropagation();
-              e.preventDefault();
-              startDrag(e);
-            });
-            handle.elm = handleElm;
-            dom.setStyles(handleElm, {
-              left: targetWidth * handle[0] + selectedElmX - handleElm.offsetWidth / 2,
-              top: targetHeight * handle[1] + selectedElmY - handleElm.offsetHeight / 2
-            });
-          });
-        } else {
-          hideResizeRect(false);
-        }
-      };
-      const throttledShowResizeRect = first$1(showResizeRect, 0);
-      const hideResizeRect = (removeSelected = true) => {
-        throttledShowResizeRect.cancel();
-        unbindResizeHandleEvents();
-        if (selectedElm && removeSelected) {
-          selectedElm.removeAttribute(elementSelectionAttr);
-        }
-        each$d(resizeHandles, (value, name) => {
-          const handleElm = dom.get('mceResizeHandle' + name);
-          if (handleElm) {
-            dom.unbind(handleElm);
-            dom.remove(handleElm);
-          }
-        });
-      };
-      const isChildOrEqual = (node, parent) => dom.isChildOf(node, parent);
-      const updateResizeRect = e => {
-        if (resizeStarted || editor.removed || editor.composing) {
-          return;
-        }
-        const targetElm = e.type === 'mousedown' ? e.target : selection.getNode();
-        const controlElm = closest$3(SugarElement.fromDom(targetElm), controlElmSelector).map(e => e.dom).filter(e => dom.isEditable(e.parentElement) || e.nodeName === 'IMG' && dom.isEditable(e)).getOrUndefined();
-        const selectedValue = isNonNullable(controlElm) ? dom.getAttrib(controlElm, elementSelectionAttr, '1') : '1';
-        each$e(dom.select(`img[${ elementSelectionAttr }],hr[${ elementSelectionAttr }]`), img => {
-          img.removeAttribute(elementSelectionAttr);
-        });
-        if (isNonNullable(controlElm) && isChildOrEqual(controlElm, rootElement) && editor.hasFocus()) {
-          disableGeckoResize();
-          const startElm = selection.getStart(true);
-          if (isChildOrEqual(startElm, controlElm) && isChildOrEqual(selection.getEnd(true), controlElm)) {
-            dom.setAttrib(controlElm, elementSelectionAttr, selectedValue);
-            throttledShowResizeRect.throttle(controlElm);
-            return;
-          }
-        }
-        hideResizeRect();
-      };
-      const unbindResizeHandleEvents = () => {
-        each$d(resizeHandles, handle => {
-          if (handle.elm) {
-            dom.unbind(handle.elm);
-            delete handle.elm;
-          }
-        });
-      };
-      const disableGeckoResize = () => {
-        try {
-          editor.getDoc().execCommand('enableObjectResizing', false, 'false');
-        } catch (ex) {
-        }
-      };
-      editor.on('init', () => {
-        disableGeckoResize();
-        editor.on('NodeChange ResizeEditor ResizeWindow ResizeContent drop', updateResizeRect);
-        editor.on('keyup compositionend', e => {
-          if (selectedElm && selectedElm.nodeName === 'TABLE') {
-            updateResizeRect(e);
-          }
-        });
-        editor.on('hide blur', hideResizeRect);
-        editor.on('contextmenu longpress', contextMenuSelectImage, true);
-      });
-      editor.on('remove', unbindResizeHandleEvents);
-      const destroy = () => {
-        throttledShowResizeRect.cancel();
-        selectedElm = selectedElmGhost = resizeBackdrop = null;
-      };
-      return {
-        isResizable,
-        showResizeRect,
-        hideResizeRect,
-        updateResizeRect,
-        destroy
-      };
-    };
-
-    const setStart = (rng, situ) => {
-      situ.fold(e => {
-        rng.setStartBefore(e.dom);
-      }, (e, o) => {
-        rng.setStart(e.dom, o);
-      }, e => {
-        rng.setStartAfter(e.dom);
-      });
-    };
-    const setFinish = (rng, situ) => {
-      situ.fold(e => {
-        rng.setEndBefore(e.dom);
-      }, (e, o) => {
-        rng.setEnd(e.dom, o);
-      }, e => {
-        rng.setEndAfter(e.dom);
-      });
-    };
-    const relativeToNative = (win, startSitu, finishSitu) => {
-      const range = win.document.createRange();
-      setStart(range, startSitu);
-      setFinish(range, finishSitu);
-      return range;
-    };
-    const exactToNative = (win, start, soffset, finish, foffset) => {
-      const rng = win.document.createRange();
-      rng.setStart(start.dom, soffset);
-      rng.setEnd(finish.dom, foffset);
-      return rng;
-    };
-
-    const adt$3 = Adt.generate([
-      {
-        ltr: [
-          'start',
-          'soffset',
-          'finish',
-          'foffset'
-        ]
-      },
-      {
-        rtl: [
-          'start',
-          'soffset',
-          'finish',
-          'foffset'
-        ]
-      }
-    ]);
-    const fromRange = (win, type, range) => type(SugarElement.fromDom(range.startContainer), range.startOffset, SugarElement.fromDom(range.endContainer), range.endOffset);
-    const getRanges = (win, selection) => selection.match({
-      domRange: rng => {
-        return {
-          ltr: constant(rng),
-          rtl: Optional.none
-        };
-      },
-      relative: (startSitu, finishSitu) => {
-        return {
-          ltr: cached(() => relativeToNative(win, startSitu, finishSitu)),
-          rtl: cached(() => Optional.some(relativeToNative(win, finishSitu, startSitu)))
-        };
-      },
-      exact: (start, soffset, finish, foffset) => {
-        return {
-          ltr: cached(() => exactToNative(win, start, soffset, finish, foffset)),
-          rtl: cached(() => Optional.some(exactToNative(win, finish, foffset, start, soffset)))
-        };
-      }
-    });
-    const doDiagnose = (win, ranges) => {
-      const rng = ranges.ltr();
-      if (rng.collapsed) {
-        const reversed = ranges.rtl().filter(rev => rev.collapsed === false);
-        return reversed.map(rev => adt$3.rtl(SugarElement.fromDom(rev.endContainer), rev.endOffset, SugarElement.fromDom(rev.startContainer), rev.startOffset)).getOrThunk(() => fromRange(win, adt$3.ltr, rng));
-      } else {
-        return fromRange(win, adt$3.ltr, rng);
-      }
-    };
-    const diagnose = (win, selection) => {
-      const ranges = getRanges(win, selection);
-      return doDiagnose(win, ranges);
-    };
-    adt$3.ltr;
-    adt$3.rtl;
-
-    const create$9 = (start, soffset, finish, foffset) => ({
-      start,
-      soffset,
-      finish,
-      foffset
-    });
-    const SimRange = { create: create$9 };
-
-    const caretPositionFromPoint = (doc, x, y) => {
-      var _a;
-      return Optional.from((_a = doc.caretPositionFromPoint) === null || _a === void 0 ? void 0 : _a.call(doc, x, y)).bind(pos => {
-        if (pos.offsetNode === null) {
-          return Optional.none();
+        if (focusedEditor !== editor) {
+          if (focusedEditor) {
+            focusedEditor.dispatch('blur', { focusedEditor: editor });
+          }
+          editorManager.setActive(editor);
+          editorManager.focusedEditor = editor;
+          editor.dispatch('focus', { blurredEditor: focusedEditor });
+          editor.focus(true);
         }
-        const r = doc.createRange();
-        r.setStart(pos.offsetNode, pos.offset);
-        r.collapse();
-        return Optional.some(r);
       });
-    };
-    const caretRangeFromPoint = (doc, x, y) => {
-      var _a;
-      return Optional.from((_a = doc.caretRangeFromPoint) === null || _a === void 0 ? void 0 : _a.call(doc, x, y));
-    };
-    const availableSearch = (doc, x, y) => {
-      if (doc.caretPositionFromPoint) {
-        return caretPositionFromPoint(doc, x, y);
-      } else if (doc.caretRangeFromPoint) {
-        return caretRangeFromPoint(doc, x, y);
-      } else {
-        return Optional.none();
+      editor.on('focusout', () => {
+        Delay.setEditorTimeout(editor, () => {
+          const focusedEditor = editorManager.focusedEditor;
+          if (!isEditorContentAreaElement(getActiveElement(editor)) || focusedEditor !== editor) {
+            toggleContentAreaOnFocus(editor, remove$6);
+          }
+          if (!isUIElement(editor, getActiveElement(editor)) && focusedEditor === editor) {
+            editor.dispatch('blur', { focusedEditor: null });
+            editorManager.focusedEditor = null;
+          }
+        });
+      });
+      if (!documentFocusInHandler) {
+        documentFocusInHandler = e => {
+          const activeEditor = editorManager.activeEditor;
+          if (activeEditor) {
+            getOriginalEventTarget(e).each(target => {
+              const elem = target;
+              if (elem.ownerDocument === document) {
+                if (elem !== document.body && !isUIElement(activeEditor, elem) && editorManager.focusedEditor === activeEditor) {
+                  activeEditor.dispatch('blur', { focusedEditor: null });
+                  editorManager.focusedEditor = null;
+                }
+              }
+            });
+          }
+        };
+        DOM$9.bind(document, 'focusin', documentFocusInHandler);
       }
     };
-    const fromPoint$1 = (win, x, y) => {
-      const doc = win.document;
-      return availableSearch(doc, x, y).map(rng => SimRange.create(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset));
-    };
-
-    const adt$2 = Adt.generate([
-      { before: ['element'] },
-      {
-        on: [
-          'element',
-          'offset'
-        ]
-      },
-      { after: ['element'] }
-    ]);
-    const cata = (subject, onBefore, onOn, onAfter) => subject.fold(onBefore, onOn, onAfter);
-    const getStart$2 = situ => situ.fold(identity, identity, identity);
-    const before$1 = adt$2.before;
-    const on = adt$2.on;
-    const after$1 = adt$2.after;
-    const Situ = {
-      before: before$1,
-      on,
-      after: after$1,
-      cata,
-      getStart: getStart$2
-    };
-
-    const adt$1 = Adt.generate([
-      { domRange: ['rng'] },
-      {
-        relative: [
-          'startSitu',
-          'finishSitu'
-        ]
-      },
-      {
-        exact: [
-          'start',
-          'soffset',
-          'finish',
-          'foffset'
-        ]
+    const unregisterDocumentEvents = (editorManager, e) => {
+      if (editorManager.focusedEditor === e.editor) {
+        editorManager.focusedEditor = null;
+      }
+      if (!editorManager.activeEditor && documentFocusInHandler) {
+        DOM$9.unbind(document, 'focusin', documentFocusInHandler);
+        documentFocusInHandler = null;
       }
-    ]);
-    const exactFromRange = simRange => adt$1.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset);
-    const getStart$1 = selection => selection.match({
-      domRange: rng => SugarElement.fromDom(rng.startContainer),
-      relative: (startSitu, _finishSitu) => Situ.getStart(startSitu),
-      exact: (start, _soffset, _finish, _foffset) => start
-    });
-    const domRange = adt$1.domRange;
-    const relative = adt$1.relative;
-    const exact = adt$1.exact;
-    const getWin = selection => {
-      const start = getStart$1(selection);
-      return defaultView(start);
     };
-    const range = SimRange.create;
-    const SimSelection = {
-      domRange,
-      relative,
-      exact,
-      exactFromRange,
-      getWin,
-      range
+    const setup$w = editorManager => {
+      editorManager.on('AddEditor', curry(registerEvents$1, editorManager));
+      editorManager.on('RemoveEditor', curry(unregisterDocumentEvents, editorManager));
     };
 
-    const beforeSpecial = (element, offset) => {
-      const name$1 = name(element);
-      if ('input' === name$1) {
-        return Situ.after(element);
-      } else if (!contains$2([
-          'br',
-          'img'
-        ], name$1)) {
-        return Situ.on(element, offset);
+    const getContentEditableHost = (editor, node) => editor.dom.getParent(node, node => editor.dom.getContentEditable(node) === 'true');
+    const hasContentEditableFalseParent$1 = (editor, node) => editor.dom.getParent(node, node => editor.dom.getContentEditable(node) === 'false') !== null;
+    const getCollapsedNode = rng => rng.collapsed ? Optional.from(getNode$1(rng.startContainer, rng.startOffset)).map(SugarElement.fromDom) : Optional.none();
+    const getFocusInElement = (root, rng) => getCollapsedNode(rng).bind(node => {
+      if (isTableSection(node)) {
+        return Optional.some(node);
+      } else if (!contains(root, node)) {
+        return Optional.some(root);
       } else {
-        return offset === 0 ? Situ.before(element) : Situ.after(element);
+        return Optional.none();
       }
-    };
-    const preprocessRelative = (startSitu, finishSitu) => {
-      const start = startSitu.fold(Situ.before, beforeSpecial, Situ.after);
-      const finish = finishSitu.fold(Situ.before, beforeSpecial, Situ.after);
-      return SimSelection.relative(start, finish);
-    };
-    const preprocessExact = (start, soffset, finish, foffset) => {
-      const startSitu = beforeSpecial(start, soffset);
-      const finishSitu = beforeSpecial(finish, foffset);
-      return SimSelection.relative(startSitu, finishSitu);
-    };
-    const preprocess = selection => selection.match({
-      domRange: rng => {
-        const start = SugarElement.fromDom(rng.startContainer);
-        const finish = SugarElement.fromDom(rng.endContainer);
-        return preprocessExact(start, rng.startOffset, finish, rng.endOffset);
-      },
-      relative: preprocessRelative,
-      exact: preprocessExact
     });
-
-    const fromElements = (elements, scope) => {
-      const doc = scope || document;
-      const fragment = doc.createDocumentFragment();
-      each$e(elements, element => {
-        fragment.appendChild(element.dom);
-      });
-      return SugarElement.fromDom(fragment);
-    };
-
-    const toNative = selection => {
-      const win = SimSelection.getWin(selection).dom;
-      const getDomRange = (start, soffset, finish, foffset) => exactToNative(win, start, soffset, finish, foffset);
-      const filtered = preprocess(selection);
-      return diagnose(win, filtered).match({
-        ltr: getDomRange,
-        rtl: getDomRange
-      });
-    };
-    const getAtPoint = (win, x, y) => fromPoint$1(win, x, y);
-
-    const fromPoint = (clientX, clientY, doc) => {
-      const win = defaultView(SugarElement.fromDom(doc));
-      return getAtPoint(win.dom, clientX, clientY).map(simRange => {
-        const rng = doc.createRange();
-        rng.setStart(simRange.start.dom, simRange.soffset);
-        rng.setEnd(simRange.finish.dom, simRange.foffset);
-        return rng;
-      }).getOrUndefined();
-    };
-
-    const isEq$4 = (rng1, rng2) => {
-      return isNonNullable(rng1) && isNonNullable(rng2) && (rng1.startContainer === rng2.startContainer && rng1.startOffset === rng2.startOffset) && (rng1.endContainer === rng2.endContainer && rng1.endOffset === rng2.endOffset);
-    };
-
-    const findParent = (node, rootNode, predicate) => {
-      let currentNode = node;
-      while (currentNode && currentNode !== rootNode) {
-        if (predicate(currentNode)) {
-          return currentNode;
-        }
-        currentNode = currentNode.parentNode;
-      }
-      return null;
-    };
-    const hasParent$1 = (node, rootNode, predicate) => findParent(node, rootNode, predicate) !== null;
-    const hasParentWithName = (node, rootNode, name) => hasParent$1(node, rootNode, node => node.nodeName === name);
-    const isCeFalseCaretContainer = (node, rootNode) => isCaretContainer$2(node) && !hasParent$1(node, rootNode, isCaretNode);
-    const hasBrBeforeAfter = (dom, node, left) => {
-      const parentNode = node.parentNode;
-      if (parentNode) {
-        const walker = new DomTreeWalker(node, dom.getParent(parentNode, dom.isBlock) || dom.getRoot());
-        let currentNode;
-        while (currentNode = walker[left ? 'prev' : 'next']()) {
-          if (isBr$6(currentNode)) {
-            return true;
-          }
-        }
-      }
-      return false;
-    };
-    const isPrevNode = (node, name) => {
-      var _a;
-      return ((_a = node.previousSibling) === null || _a === void 0 ? void 0 : _a.nodeName) === name;
+    const normalizeSelection = (editor, rng) => {
+      getFocusInElement(SugarElement.fromDom(editor.getBody()), rng).bind(elm => {
+        return firstPositionIn(elm.dom);
+      }).fold(() => {
+        editor.selection.normalize();
+      }, caretPos => editor.selection.setRng(caretPos.toRange()));
     };
-    const hasContentEditableFalseParent$1 = (root, node) => {
-      let currentNode = node;
-      while (currentNode && currentNode !== root) {
-        if (isContentEditableFalse$b(currentNode)) {
-          return true;
+    const focusBody = body => {
+      if (body.setActive) {
+        try {
+          body.setActive();
+        } catch (ex) {
+          body.focus();
         }
-        currentNode = currentNode.parentNode;
-      }
-      return false;
-    };
-    const findTextNodeRelative = (dom, isAfterNode, collapsed, left, startNode) => {
-      const body = dom.getRoot();
-      const nonEmptyElementsMap = dom.schema.getNonEmptyElements();
-      const parentNode = startNode.parentNode;
-      let lastInlineElement;
-      let node;
-      if (!parentNode) {
-        return Optional.none();
+      } else {
+        body.focus();
       }
-      const parentBlockContainer = dom.getParent(parentNode, dom.isBlock) || body;
-      if (left && isBr$6(startNode) && isAfterNode && dom.isEmpty(parentBlockContainer)) {
-        return Optional.some(CaretPosition(parentNode, dom.nodeIndex(startNode)));
+    };
+    const hasElementFocus = elm => hasFocus$1(elm) || search(elm).isSome();
+    const hasIframeFocus = editor => isNonNullable(editor.iframeElement) && hasFocus$1(SugarElement.fromDom(editor.iframeElement));
+    const hasInlineFocus = editor => {
+      const rawBody = editor.getBody();
+      return rawBody && hasElementFocus(SugarElement.fromDom(rawBody));
+    };
+    const hasUiFocus = editor => {
+      const dos = getRootNode(SugarElement.fromDom(editor.getElement()));
+      return active$1(dos).filter(elem => !isEditorContentAreaElement(elem.dom) && isUIElement(editor, elem.dom)).isSome();
+    };
+    const hasFocus = editor => editor.inline ? hasInlineFocus(editor) : hasIframeFocus(editor);
+    const hasEditorOrUiFocus = editor => hasFocus(editor) || hasUiFocus(editor);
+    const focusEditor = editor => {
+      const selection = editor.selection;
+      const body = editor.getBody();
+      let rng = selection.getRng();
+      editor.quirks.refreshContentEditable();
+      const restoreBookmark = editor => {
+        getRng(editor).each(bookmarkRng => {
+          editor.selection.setRng(bookmarkRng);
+          rng = bookmarkRng;
+        });
+      };
+      if (!hasFocus(editor) && editor.hasEditableRoot()) {
+        restoreBookmark(editor);
       }
-      const walker = new DomTreeWalker(startNode, parentBlockContainer);
-      while (node = walker[left ? 'prev' : 'next']()) {
-        if (dom.getContentEditableParent(node) === 'false' || isCeFalseCaretContainer(node, body)) {
-          return Optional.none();
-        }
-        if (isText$b(node) && node.data.length > 0) {
-          if (!hasParentWithName(node, body, 'A')) {
-            return Optional.some(CaretPosition(node, left ? node.data.length : 0));
-          }
-          return Optional.none();
+      const contentEditableHost = getContentEditableHost(editor, selection.getNode());
+      if (contentEditableHost && editor.dom.isChildOf(contentEditableHost, body)) {
+        if (!hasContentEditableFalseParent$1(editor, contentEditableHost)) {
+          focusBody(body);
         }
-        if (dom.isBlock(node) || nonEmptyElementsMap[node.nodeName.toLowerCase()]) {
-          return Optional.none();
+        focusBody(contentEditableHost);
+        if (!editor.hasEditableRoot()) {
+          restoreBookmark(editor);
         }
-        lastInlineElement = node;
+        normalizeSelection(editor, rng);
+        activateEditor(editor);
+        return;
       }
-      if (isComment(lastInlineElement)) {
-        return Optional.none();
+      if (!editor.inline) {
+        if (!Env.browser.isOpera()) {
+          focusBody(body);
+        }
+        editor.getWin().focus();
       }
-      if (collapsed && lastInlineElement) {
-        return Optional.some(CaretPosition(lastInlineElement, 0));
+      if (Env.browser.isFirefox() || editor.inline) {
+        focusBody(body);
+        normalizeSelection(editor, rng);
       }
-      return Optional.none();
+      activateEditor(editor);
     };
-    const normalizeEndPoint = (dom, collapsed, start, rng) => {
-      const body = dom.getRoot();
-      let node;
-      let normalized = false;
-      let container = start ? rng.startContainer : rng.endContainer;
-      let offset = start ? rng.startOffset : rng.endOffset;
-      const isAfterNode = isElement$6(container) && offset === container.childNodes.length;
-      const nonEmptyElementsMap = dom.schema.getNonEmptyElements();
-      let directionLeft = start;
-      if (isCaretContainer$2(container)) {
-        return Optional.none();
+    const activateEditor = editor => editor.editorManager.setActive(editor);
+    const focus = (editor, skipFocus) => {
+      if (editor.removed) {
+        return;
       }
-      if (isElement$6(container) && offset > container.childNodes.length - 1) {
-        directionLeft = false;
+      if (skipFocus) {
+        activateEditor(editor);
+      } else {
+        focusEditor(editor);
       }
-      if (isDocument$1(container)) {
-        container = body;
-        offset = 0;
+    };
+
+    const VK = {
+      BACKSPACE: 8,
+      DELETE: 46,
+      DOWN: 40,
+      ENTER: 13,
+      ESC: 27,
+      LEFT: 37,
+      RIGHT: 39,
+      SPACEBAR: 32,
+      TAB: 9,
+      UP: 38,
+      PAGE_UP: 33,
+      PAGE_DOWN: 34,
+      END: 35,
+      HOME: 36,
+      modifierPressed: e => {
+        return e.shiftKey || e.ctrlKey || e.altKey || VK.metaKeyPressed(e);
+      },
+      metaKeyPressed: e => {
+        return Env.os.isMacOS() || Env.os.isiOS() ? e.metaKey : e.ctrlKey && !e.altKey;
       }
-      if (container === body) {
-        if (directionLeft) {
-          node = container.childNodes[offset > 0 ? offset - 1 : 0];
-          if (node) {
-            if (isCaretContainer$2(node)) {
-              return Optional.none();
-            }
-            if (nonEmptyElementsMap[node.nodeName] || isTable$2(node)) {
-              return Optional.none();
-            }
-          }
+    };
+
+    const elementSelectionAttr = 'data-mce-selected';
+    const controlElmSelector = 'table,img,figure.image,hr,video,span.mce-preview-object,details';
+    const abs = Math.abs;
+    const round$1 = Math.round;
+    const resizeHandles = {
+      nw: [
+        0,
+        0,
+        -1,
+        -1
+      ],
+      ne: [
+        1,
+        0,
+        1,
+        -1
+      ],
+      se: [
+        1,
+        1,
+        1,
+        1
+      ],
+      sw: [
+        0,
+        1,
+        -1,
+        1
+      ]
+    };
+    const isTouchEvent = evt => evt.type === 'longpress' || evt.type.indexOf('touch') === 0;
+    const ControlSelection = (selection, editor) => {
+      const dom = editor.dom;
+      const editableDoc = editor.getDoc();
+      const rootDocument = document;
+      const rootElement = editor.getBody();
+      let selectedElm, selectedElmGhost, resizeHelper, selectedHandle, resizeBackdrop;
+      let startX, startY, selectedElmX, selectedElmY, startW, startH, ratio, resizeStarted;
+      let width;
+      let height;
+      let startScrollWidth;
+      let startScrollHeight;
+      const isImage = elm => isNonNullable(elm) && (isImg(elm) || dom.is(elm, 'figure.image'));
+      const isMedia = elm => isMedia$2(elm) || dom.hasClass(elm, 'mce-preview-object');
+      const isEventOnImageOutsideRange = (evt, range) => {
+        if (isTouchEvent(evt)) {
+          const touch = evt.touches[0];
+          return isImage(evt.target) && !isXYWithinRange(touch.clientX, touch.clientY, range);
+        } else {
+          return isImage(evt.target) && !isXYWithinRange(evt.clientX, evt.clientY, range);
         }
-        if (container.hasChildNodes()) {
-          offset = Math.min(!directionLeft && offset > 0 ? offset - 1 : offset, container.childNodes.length - 1);
-          container = container.childNodes[offset];
-          offset = isText$b(container) && isAfterNode ? container.data.length : 0;
-          if (!collapsed && container === body.lastChild && isTable$2(container)) {
-            return Optional.none();
-          }
-          if (hasContentEditableFalseParent$1(body, container) || isCaretContainer$2(container)) {
-            return Optional.none();
-          }
-          if (isDetails(container)) {
-            return Optional.none();
-          }
-          if (container.hasChildNodes() && !isTable$2(container)) {
-            node = container;
-            const walker = new DomTreeWalker(container, body);
-            do {
-              if (isContentEditableFalse$b(node) || isCaretContainer$2(node)) {
-                normalized = false;
-                break;
-              }
-              if (isText$b(node) && node.data.length > 0) {
-                offset = directionLeft ? 0 : node.data.length;
-                container = node;
-                normalized = true;
-                break;
-              }
-              if (nonEmptyElementsMap[node.nodeName.toLowerCase()] && !isTableCellOrCaption(node)) {
-                offset = dom.nodeIndex(node);
-                container = node.parentNode;
-                if (!directionLeft) {
-                  offset++;
-                }
-                normalized = true;
-                break;
-              }
-            } while (node = directionLeft ? walker.next() : walker.prev());
-          }
+      };
+      const contextMenuSelectImage = evt => {
+        const target = evt.target;
+        if (isEventOnImageOutsideRange(evt, editor.selection.getRng()) && !evt.isDefaultPrevented()) {
+          editor.selection.select(target);
+        }
+      };
+      const getResizeTargets = elm => {
+        if (dom.hasClass(elm, 'mce-preview-object') && isNonNullable(elm.firstElementChild)) {
+          return [
+            elm,
+            elm.firstElementChild
+          ];
+        } else if (dom.is(elm, 'figure.image')) {
+          return [elm.querySelector('img')];
+        } else {
+          return [elm];
+        }
+      };
+      const isResizable = elm => {
+        const selector = getObjectResizing(editor);
+        if (!selector || editor.mode.isReadOnly()) {
+          return false;
+        }
+        if (elm.getAttribute('data-mce-resize') === 'false') {
+          return false;
+        }
+        if (elm === editor.getBody()) {
+          return false;
+        }
+        if (dom.hasClass(elm, 'mce-preview-object') && isNonNullable(elm.firstElementChild)) {
+          return is$1(SugarElement.fromDom(elm.firstElementChild), selector);
+        } else {
+          return is$1(SugarElement.fromDom(elm), selector);
+        }
+      };
+      const createGhostElement = (dom, elm) => {
+        if (isMedia(elm)) {
+          return dom.create('img', { src: Env.transparentSrc });
+        } else if (isTable$2(elm)) {
+          const isNorth = startsWith(selectedHandle.name, 'n');
+          const rowSelect = isNorth ? head : last$2;
+          const tableElm = elm.cloneNode(true);
+          rowSelect(dom.select('tr', tableElm)).each(tr => {
+            const cells = dom.select('td,th', tr);
+            dom.setStyle(tr, 'height', null);
+            each$e(cells, cell => dom.setStyle(cell, 'height', null));
+          });
+          return tableElm;
+        } else {
+          return elm.cloneNode(true);
         }
-      }
-      if (collapsed) {
-        if (isText$b(container) && offset === 0) {
-          findTextNodeRelative(dom, isAfterNode, collapsed, true, container).each(pos => {
-            container = pos.container();
-            offset = pos.offset();
-            normalized = true;
+      };
+      const setSizeProp = (element, name, value) => {
+        if (isNonNullable(value)) {
+          const targets = getResizeTargets(element);
+          each$e(targets, target => {
+            if (target.style[name] || !editor.schema.isValid(target.nodeName.toLowerCase(), name)) {
+              dom.setStyle(target, name, value);
+            } else {
+              dom.setAttrib(target, name, '' + value);
+            }
           });
         }
-        if (isElement$6(container)) {
-          node = container.childNodes[offset];
-          if (!node) {
-            node = container.childNodes[offset - 1];
-          }
-          if (node && isBr$6(node) && !isPrevNode(node, 'A') && !hasBrBeforeAfter(dom, node, false) && !hasBrBeforeAfter(dom, node, true)) {
-            findTextNodeRelative(dom, isAfterNode, collapsed, true, node).each(pos => {
-              container = pos.container();
-              offset = pos.offset();
-              normalized = true;
-            });
+      };
+      const setGhostElmSize = (ghostElm, width, height) => {
+        setSizeProp(ghostElm, 'width', width);
+        setSizeProp(ghostElm, 'height', height);
+      };
+      const resizeGhostElement = e => {
+        let deltaX, deltaY, proportional;
+        let resizeHelperX, resizeHelperY;
+        deltaX = e.screenX - startX;
+        deltaY = e.screenY - startY;
+        width = deltaX * selectedHandle[2] + startW;
+        height = deltaY * selectedHandle[3] + startH;
+        width = width < 5 ? 5 : width;
+        height = height < 5 ? 5 : height;
+        if ((isImage(selectedElm) || isMedia(selectedElm)) && getResizeImgProportional(editor) !== false) {
+          proportional = !VK.modifierPressed(e);
+        } else {
+          proportional = VK.modifierPressed(e);
+        }
+        if (proportional) {
+          if (abs(deltaX) > abs(deltaY)) {
+            height = round$1(width * ratio);
+            width = round$1(height / ratio);
+          } else {
+            width = round$1(height / ratio);
+            height = round$1(width * ratio);
           }
         }
-      }
-      if (directionLeft && !collapsed && isText$b(container) && offset === container.data.length) {
-        findTextNodeRelative(dom, isAfterNode, collapsed, false, container).each(pos => {
-          container = pos.container();
-          offset = pos.offset();
-          normalized = true;
+        setGhostElmSize(selectedElmGhost, width, height);
+        resizeHelperX = selectedHandle.startPos.x + deltaX;
+        resizeHelperY = selectedHandle.startPos.y + deltaY;
+        resizeHelperX = resizeHelperX > 0 ? resizeHelperX : 0;
+        resizeHelperY = resizeHelperY > 0 ? resizeHelperY : 0;
+        dom.setStyles(resizeHelper, {
+          left: resizeHelperX,
+          top: resizeHelperY,
+          display: 'block'
         });
-      }
-      return normalized && container ? Optional.some(CaretPosition(container, offset)) : Optional.none();
-    };
-    const normalize$2 = (dom, rng) => {
-      const collapsed = rng.collapsed, normRng = rng.cloneRange();
-      const startPos = CaretPosition.fromRangeStart(rng);
-      normalizeEndPoint(dom, collapsed, true, normRng).each(pos => {
-        if (!collapsed || !CaretPosition.isAbove(startPos, pos)) {
-          normRng.setStart(pos.container(), pos.offset());
+        resizeHelper.innerHTML = width + ' &times; ' + height;
+        if (selectedHandle[2] < 0 && selectedElmGhost.clientWidth <= width) {
+          dom.setStyle(selectedElmGhost, 'left', selectedElmX + (startW - width));
         }
-      });
-      if (!collapsed) {
-        normalizeEndPoint(dom, collapsed, false, normRng).each(pos => {
-          normRng.setEnd(pos.container(), pos.offset());
-        });
-      }
-      if (collapsed) {
-        normRng.collapse(true);
-      }
-      return isEq$4(rng, normRng) ? Optional.none() : Optional.some(normRng);
-    };
-
-    const splitText = (node, offset) => {
-      return node.splitText(offset);
-    };
-    const split = rng => {
-      let startContainer = rng.startContainer, startOffset = rng.startOffset, endContainer = rng.endContainer, endOffset = rng.endOffset;
-      if (startContainer === endContainer && isText$b(startContainer)) {
-        if (startOffset > 0 && startOffset < startContainer.data.length) {
-          endContainer = splitText(startContainer, startOffset);
-          startContainer = endContainer.previousSibling;
-          if (endOffset > startOffset) {
-            endOffset = endOffset - startOffset;
-            const newContainer = splitText(endContainer, endOffset).previousSibling;
-            startContainer = endContainer = newContainer;
-            endOffset = newContainer.data.length;
-            startOffset = 0;
-          } else {
-            endOffset = 0;
-          }
+        if (selectedHandle[3] < 0 && selectedElmGhost.clientHeight <= height) {
+          dom.setStyle(selectedElmGhost, 'top', selectedElmY + (startH - height));
         }
-      } else {
-        if (isText$b(startContainer) && startOffset > 0 && startOffset < startContainer.data.length) {
-          startContainer = splitText(startContainer, startOffset);
-          startOffset = 0;
+        deltaX = rootElement.scrollWidth - startScrollWidth;
+        deltaY = rootElement.scrollHeight - startScrollHeight;
+        if (deltaX + deltaY !== 0) {
+          dom.setStyles(resizeHelper, {
+            left: resizeHelperX - deltaX,
+            top: resizeHelperY - deltaY
+          });
         }
-        if (isText$b(endContainer) && endOffset > 0 && endOffset < endContainer.data.length) {
-          const newContainer = splitText(endContainer, endOffset).previousSibling;
-          endContainer = newContainer;
-          endOffset = newContainer.data.length;
+        if (!resizeStarted) {
+          fireObjectResizeStart(editor, selectedElm, startW, startH, 'corner-' + selectedHandle.name);
+          resizeStarted = true;
         }
-      }
-      return {
-        startContainer,
-        startOffset,
-        endContainer,
-        endOffset
-      };
-    };
-
-    const RangeUtils = dom => {
-      const walk = (rng, callback) => {
-        return walk$3(dom, rng, callback);
       };
-      const split$1 = split;
-      const normalize = rng => {
-        return normalize$2(dom, rng).fold(never, normalizedRng => {
-          rng.setStart(normalizedRng.startContainer, normalizedRng.startOffset);
-          rng.setEnd(normalizedRng.endContainer, normalizedRng.endOffset);
-          return true;
-        });
+      const endGhostResize = () => {
+        const wasResizeStarted = resizeStarted;
+        resizeStarted = false;
+        if (wasResizeStarted) {
+          setSizeProp(selectedElm, 'width', width);
+          setSizeProp(selectedElm, 'height', height);
+        }
+        dom.unbind(editableDoc, 'mousemove', resizeGhostElement);
+        dom.unbind(editableDoc, 'mouseup', endGhostResize);
+        if (rootDocument !== editableDoc) {
+          dom.unbind(rootDocument, 'mousemove', resizeGhostElement);
+          dom.unbind(rootDocument, 'mouseup', endGhostResize);
+        }
+        dom.remove(selectedElmGhost);
+        dom.remove(resizeHelper);
+        dom.remove(resizeBackdrop);
+        showResizeRect(selectedElm);
+        if (wasResizeStarted) {
+          fireObjectResized(editor, selectedElm, width, height, 'corner-' + selectedHandle.name);
+          dom.setAttrib(selectedElm, 'style', dom.getAttrib(selectedElm, 'style'));
+        }
+        editor.nodeChanged();
       };
-      const expand = (rng, options = { type: 'word' }) => {
-        if (options.type === 'word') {
-          const rangeLike = expandRng(dom, rng, [{ inline: 'span' }]);
-          const newRange = dom.createRng();
-          newRange.setStart(rangeLike.startContainer, rangeLike.startOffset);
-          newRange.setEnd(rangeLike.endContainer, rangeLike.endOffset);
-          return newRange;
+      const showResizeRect = targetElm => {
+        unbindResizeHandleEvents();
+        const position = dom.getPos(targetElm, rootElement);
+        const selectedElmX = position.x;
+        const selectedElmY = position.y;
+        const rect = targetElm.getBoundingClientRect();
+        const targetWidth = rect.width || rect.right - rect.left;
+        const targetHeight = rect.height || rect.bottom - rect.top;
+        if (selectedElm !== targetElm) {
+          hideResizeRect();
+          selectedElm = targetElm;
+          width = height = 0;
+        }
+        const e = editor.dispatch('ObjectSelected', { target: targetElm });
+        if (isResizable(targetElm) && !e.isDefaultPrevented()) {
+          each$d(resizeHandles, (handle, name) => {
+            const startDrag = e => {
+              const target = getResizeTargets(selectedElm)[0];
+              startX = e.screenX;
+              startY = e.screenY;
+              startW = target.clientWidth;
+              startH = target.clientHeight;
+              ratio = startH / startW;
+              selectedHandle = handle;
+              selectedHandle.name = name;
+              selectedHandle.startPos = {
+                x: targetWidth * handle[0] + selectedElmX,
+                y: targetHeight * handle[1] + selectedElmY
+              };
+              startScrollWidth = rootElement.scrollWidth;
+              startScrollHeight = rootElement.scrollHeight;
+              resizeBackdrop = dom.add(rootElement, 'div', {
+                'class': 'mce-resize-backdrop',
+                'data-mce-bogus': 'all'
+              });
+              dom.setStyles(resizeBackdrop, {
+                position: 'fixed',
+                left: '0',
+                top: '0',
+                width: '100%',
+                height: '100%'
+              });
+              selectedElmGhost = createGhostElement(dom, selectedElm);
+              dom.addClass(selectedElmGhost, 'mce-clonedresizable');
+              dom.setAttrib(selectedElmGhost, 'data-mce-bogus', 'all');
+              selectedElmGhost.contentEditable = 'false';
+              dom.setStyles(selectedElmGhost, {
+                left: selectedElmX,
+                top: selectedElmY,
+                margin: 0
+              });
+              setGhostElmSize(selectedElmGhost, targetWidth, targetHeight);
+              selectedElmGhost.removeAttribute(elementSelectionAttr);
+              rootElement.appendChild(selectedElmGhost);
+              dom.bind(editableDoc, 'mousemove', resizeGhostElement);
+              dom.bind(editableDoc, 'mouseup', endGhostResize);
+              if (rootDocument !== editableDoc) {
+                dom.bind(rootDocument, 'mousemove', resizeGhostElement);
+                dom.bind(rootDocument, 'mouseup', endGhostResize);
+              }
+              resizeHelper = dom.add(rootElement, 'div', {
+                'class': 'mce-resize-helper',
+                'data-mce-bogus': 'all'
+              }, startW + ' &times; ' + startH);
+            };
+            let handleElm = dom.get('mceResizeHandle' + name);
+            if (handleElm) {
+              dom.remove(handleElm);
+            }
+            handleElm = dom.add(rootElement, 'div', {
+              'id': 'mceResizeHandle' + name,
+              'data-mce-bogus': 'all',
+              'class': 'mce-resizehandle',
+              'unselectable': true,
+              'style': 'cursor:' + name + '-resize; margin:0; padding:0'
+            });
+            dom.bind(handleElm, 'mousedown', e => {
+              e.stopImmediatePropagation();
+              e.preventDefault();
+              startDrag(e);
+            });
+            handle.elm = handleElm;
+            dom.setStyles(handleElm, {
+              left: targetWidth * handle[0] + selectedElmX - handleElm.offsetWidth / 2,
+              top: targetHeight * handle[1] + selectedElmY - handleElm.offsetHeight / 2
+            });
+          });
+        } else {
+          hideResizeRect(false);
         }
-        return rng;
       };
-      return {
-        walk,
-        split: split$1,
-        expand,
-        normalize
+      const throttledShowResizeRect = first$1(showResizeRect, 0);
+      const hideResizeRect = (removeSelected = true) => {
+        throttledShowResizeRect.cancel();
+        unbindResizeHandleEvents();
+        if (selectedElm && removeSelected) {
+          selectedElm.removeAttribute(elementSelectionAttr);
+        }
+        each$d(resizeHandles, (value, name) => {
+          const handleElm = dom.get('mceResizeHandle' + name);
+          if (handleElm) {
+            dom.unbind(handleElm);
+            dom.remove(handleElm);
+          }
+        });
       };
-    };
-    RangeUtils.compareRanges = isEq$4;
-    RangeUtils.getCaretRangeFromPoint = fromPoint;
-    RangeUtils.getSelectedNode = getSelectedNode;
-    RangeUtils.getNode = getNode$1;
-
-    const Dimension = (name, getOffset) => {
-      const set = (element, h) => {
-        if (!isNumber(h) && !h.match(/^[0-9]+$/)) {
-          throw new Error(name + '.set accepts only positive integer values. Value was ' + h);
+      const isChildOrEqual = (node, parent) => dom.isChildOf(node, parent);
+      const updateResizeRect = e => {
+        if (resizeStarted || editor.removed || editor.composing) {
+          return;
         }
-        const dom = element.dom;
-        if (isSupported(dom)) {
-          dom.style[name] = h + 'px';
+        const targetElm = e.type === 'mousedown' ? e.target : selection.getNode();
+        const controlElm = closest$3(SugarElement.fromDom(targetElm), controlElmSelector).map(e => e.dom).filter(e => dom.isEditable(e.parentElement) || e.nodeName === 'IMG' && dom.isEditable(e)).getOrUndefined();
+        const selectedValue = isNonNullable(controlElm) ? dom.getAttrib(controlElm, elementSelectionAttr, '1') : '1';
+        each$e(dom.select(`img[${ elementSelectionAttr }],hr[${ elementSelectionAttr }]`), img => {
+          img.removeAttribute(elementSelectionAttr);
+        });
+        if (isNonNullable(controlElm) && isChildOrEqual(controlElm, rootElement) && hasEditorOrUiFocus(editor)) {
+          disableGeckoResize();
+          const startElm = selection.getStart(true);
+          if (isChildOrEqual(startElm, controlElm) && isChildOrEqual(selection.getEnd(true), controlElm)) {
+            dom.setAttrib(controlElm, elementSelectionAttr, selectedValue);
+            throttledShowResizeRect.throttle(controlElm);
+            return;
+          }
         }
+        hideResizeRect();
       };
-      const get = element => {
-        const r = getOffset(element);
-        if (r <= 0 || r === null) {
-          const css = get$7(element, name);
-          return parseFloat(css) || 0;
+      const unbindResizeHandleEvents = () => {
+        each$d(resizeHandles, handle => {
+          if (handle.elm) {
+            dom.unbind(handle.elm);
+            delete handle.elm;
+          }
+        });
+      };
+      const disableGeckoResize = () => {
+        try {
+          editor.getDoc().execCommand('enableObjectResizing', false, 'false');
+        } catch (ex) {
         }
-        return r;
       };
-      const getOuter = get;
-      const aggregate = (element, properties) => foldl(properties, (acc, property) => {
-        const val = get$7(element, property);
-        const value = val === undefined ? 0 : parseInt(val, 10);
-        return isNaN(value) ? acc : acc + value;
-      }, 0);
-      const max = (element, value, properties) => {
-        const cumulativeInclusions = aggregate(element, properties);
-        const absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0;
-        return absoluteMax;
+      editor.on('init', () => {
+        disableGeckoResize();
+        editor.on('NodeChange ResizeEditor ResizeWindow ResizeContent drop', updateResizeRect);
+        editor.on('keyup compositionend', e => {
+          if (selectedElm && selectedElm.nodeName === 'TABLE') {
+            updateResizeRect(e);
+          }
+        });
+        editor.on('hide blur', hideResizeRect);
+        editor.on('contextmenu longpress', contextMenuSelectImage, true);
+      });
+      editor.on('remove', unbindResizeHandleEvents);
+      const destroy = () => {
+        throttledShowResizeRect.cancel();
+        selectedElm = selectedElmGhost = resizeBackdrop = null;
       };
       return {
-        set,
-        get,
-        getOuter,
-        aggregate,
-        max
+        isResizable,
+        showResizeRect,
+        hideResizeRect,
+        updateResizeRect,
+        destroy
       };
     };
 
-    const api = Dimension('height', element => {
-      const dom = element.dom;
-      return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight;
-    });
-    const get$2 = element => api.get(element);
-
-    const getDocument = () => SugarElement.fromDom(document);
-
-    const walkUp = (navigation, doc) => {
-      const frame = navigation.view(doc);
-      return frame.fold(constant([]), f => {
-        const parent = navigation.owner(f);
-        const rest = walkUp(navigation, parent);
-        return [f].concat(rest);
-      });
-    };
-    const pathTo = (element, navigation) => {
-      const d = navigation.owner(element);
-      return walkUp(navigation, d);
-    };
-
-    const view = doc => {
-      var _a;
-      const element = doc.dom === document ? Optional.none() : Optional.from((_a = doc.dom.defaultView) === null || _a === void 0 ? void 0 : _a.frameElement);
-      return element.map(SugarElement.fromDom);
-    };
-    const owner = element => documentOrOwner(element);
-
-    var Navigation = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        view: view,
-        owner: owner
-    });
-
-    const find = element => {
-      const doc = getDocument();
-      const scroll = get$5(doc);
-      const frames = pathTo(element, Navigation);
-      const offset = viewport(element);
-      const r = foldr(frames, (b, a) => {
-        const loc = viewport(a);
-        return {
-          left: b.left + loc.left,
-          top: b.top + loc.top
-        };
-      }, {
-        left: 0,
-        top: 0
-      });
-      return SugarPosition(r.left + offset.left + scroll.left, r.top + offset.top + scroll.top);
-    };
-
-    const excludeFromDescend = element => name(element) === 'textarea';
-    const fireScrollIntoViewEvent = (editor, data) => {
-      const scrollEvent = editor.dispatch('ScrollIntoView', data);
-      return scrollEvent.isDefaultPrevented();
-    };
-    const fireAfterScrollIntoViewEvent = (editor, data) => {
-      editor.dispatch('AfterScrollIntoView', data);
-    };
-    const descend = (element, offset) => {
-      const children = children$1(element);
-      if (children.length === 0 || excludeFromDescend(element)) {
-        return {
-          element,
-          offset
-        };
-      } else if (offset < children.length && !excludeFromDescend(children[offset])) {
-        return {
-          element: children[offset],
-          offset: 0
-        };
-      } else {
-        const last = children[children.length - 1];
-        if (excludeFromDescend(last)) {
-          return {
-            element,
-            offset
-          };
-        } else {
-          if (name(last) === 'img') {
-            return {
-              element: last,
-              offset: 1
-            };
-          } else if (isText$c(last)) {
-            return {
-              element: last,
-              offset: get$3(last).length
-            };
-          } else {
-            return {
-              element: last,
-              offset: children$1(last).length
-            };
-          }
-        }
-      }
-    };
-    const markerInfo = (element, cleanupFun) => {
-      const pos = absolute(element);
-      const height = get$2(element);
-      return {
-        element,
-        bottom: pos.top + height,
-        height,
-        pos,
-        cleanup: cleanupFun
-      };
-    };
-    const createMarker$1 = (element, offset) => {
-      const startPoint = descend(element, offset);
-      const span = SugarElement.fromHtml('<span data-mce-bogus="all" style="display: inline-block;">' + ZWSP$1 + '</span>');
-      before$3(startPoint.element, span);
-      return markerInfo(span, () => remove$4(span));
-    };
-    const elementMarker = element => markerInfo(SugarElement.fromDom(element), noop);
-    const withMarker = (editor, f, rng, alignToTop) => {
-      preserveWith(editor, (_s, _e) => applyWithMarker(editor, f, rng, alignToTop), rng);
-    };
-    const withScrollEvents = (editor, doc, f, marker, alignToTop) => {
-      const data = {
-        elm: marker.element.dom,
-        alignToTop
-      };
-      if (fireScrollIntoViewEvent(editor, data)) {
-        return;
-      }
-      const scrollTop = get$5(doc).top;
-      f(editor, doc, scrollTop, marker, alignToTop);
-      fireAfterScrollIntoViewEvent(editor, data);
+    const setStart = (rng, situ) => {
+      situ.fold(e => {
+        rng.setStartBefore(e.dom);
+      }, (e, o) => {
+        rng.setStart(e.dom, o);
+      }, e => {
+        rng.setStartAfter(e.dom);
+      });
     };
-    const applyWithMarker = (editor, f, rng, alignToTop) => {
-      const body = SugarElement.fromDom(editor.getBody());
-      const doc = SugarElement.fromDom(editor.getDoc());
-      reflow(body);
-      const marker = createMarker$1(SugarElement.fromDom(rng.startContainer), rng.startOffset);
-      withScrollEvents(editor, doc, f, marker, alignToTop);
-      marker.cleanup();
+    const setFinish = (rng, situ) => {
+      situ.fold(e => {
+        rng.setEndBefore(e.dom);
+      }, (e, o) => {
+        rng.setEnd(e.dom, o);
+      }, e => {
+        rng.setEndAfter(e.dom);
+      });
     };
-    const withElement = (editor, element, f, alignToTop) => {
-      const doc = SugarElement.fromDom(editor.getDoc());
-      withScrollEvents(editor, doc, f, elementMarker(element), alignToTop);
+    const relativeToNative = (win, startSitu, finishSitu) => {
+      const range = win.document.createRange();
+      setStart(range, startSitu);
+      setFinish(range, finishSitu);
+      return range;
     };
-    const preserveWith = (editor, f, rng) => {
-      const startElement = rng.startContainer;
-      const startOffset = rng.startOffset;
-      const endElement = rng.endContainer;
-      const endOffset = rng.endOffset;
-      f(SugarElement.fromDom(startElement), SugarElement.fromDom(endElement));
-      const newRng = editor.dom.createRng();
-      newRng.setStart(startElement, startOffset);
-      newRng.setEnd(endElement, endOffset);
-      editor.selection.setRng(rng);
+    const exactToNative = (win, start, soffset, finish, foffset) => {
+      const rng = win.document.createRange();
+      rng.setStart(start.dom, soffset);
+      rng.setEnd(finish.dom, foffset);
+      return rng;
     };
-    const scrollToMarker = (editor, marker, viewHeight, alignToTop, doc) => {
-      const pos = marker.pos;
-      if (alignToTop) {
-        to(pos.left, pos.top, doc);
-      } else {
-        const y = pos.top - viewHeight + marker.height;
-        to(-editor.getBody().getBoundingClientRect().left, y, doc);
+
+    const adt$1 = Adt.generate([
+      {
+        ltr: [
+          'start',
+          'soffset',
+          'finish',
+          'foffset'
+        ]
+      },
+      {
+        rtl: [
+          'start',
+          'soffset',
+          'finish',
+          'foffset'
+        ]
       }
-    };
-    const intoWindowIfNeeded = (editor, doc, scrollTop, viewHeight, marker, alignToTop) => {
-      const viewportBottom = viewHeight + scrollTop;
-      const markerTop = marker.pos.top;
-      const markerBottom = marker.bottom;
-      const largerThanViewport = markerBottom - markerTop >= viewHeight;
-      if (markerTop < scrollTop) {
-        scrollToMarker(editor, marker, viewHeight, alignToTop !== false, doc);
-      } else if (markerTop > viewportBottom) {
-        const align = largerThanViewport ? alignToTop !== false : alignToTop === true;
-        scrollToMarker(editor, marker, viewHeight, align, doc);
-      } else if (markerBottom > viewportBottom && !largerThanViewport) {
-        scrollToMarker(editor, marker, viewHeight, alignToTop === true, doc);
+    ]);
+    const fromRange = (win, type, range) => type(SugarElement.fromDom(range.startContainer), range.startOffset, SugarElement.fromDom(range.endContainer), range.endOffset);
+    const getRanges = (win, selection) => selection.match({
+      domRange: rng => {
+        return {
+          ltr: constant(rng),
+          rtl: Optional.none
+        };
+      },
+      relative: (startSitu, finishSitu) => {
+        return {
+          ltr: cached(() => relativeToNative(win, startSitu, finishSitu)),
+          rtl: cached(() => Optional.some(relativeToNative(win, finishSitu, startSitu)))
+        };
+      },
+      exact: (start, soffset, finish, foffset) => {
+        return {
+          ltr: cached(() => exactToNative(win, start, soffset, finish, foffset)),
+          rtl: cached(() => Optional.some(exactToNative(win, finish, foffset, start, soffset)))
+        };
       }
-    };
-    const intoWindow = (editor, doc, scrollTop, marker, alignToTop) => {
-      const viewHeight = defaultView(doc).dom.innerHeight;
-      intoWindowIfNeeded(editor, doc, scrollTop, viewHeight, marker, alignToTop);
-    };
-    const intoFrame = (editor, doc, scrollTop, marker, alignToTop) => {
-      const frameViewHeight = defaultView(doc).dom.innerHeight;
-      intoWindowIfNeeded(editor, doc, scrollTop, frameViewHeight, marker, alignToTop);
-      const op = find(marker.element);
-      const viewportBounds = getBounds(window);
-      if (op.top < viewportBounds.y) {
-        intoView(marker.element, alignToTop !== false);
-      } else if (op.top > viewportBounds.bottom) {
-        intoView(marker.element, alignToTop === true);
+    });
+    const doDiagnose = (win, ranges) => {
+      const rng = ranges.ltr();
+      if (rng.collapsed) {
+        const reversed = ranges.rtl().filter(rev => rev.collapsed === false);
+        return reversed.map(rev => adt$1.rtl(SugarElement.fromDom(rev.endContainer), rev.endOffset, SugarElement.fromDom(rev.startContainer), rev.startOffset)).getOrThunk(() => fromRange(win, adt$1.ltr, rng));
+      } else {
+        return fromRange(win, adt$1.ltr, rng);
       }
     };
-    const rangeIntoWindow = (editor, rng, alignToTop) => withMarker(editor, intoWindow, rng, alignToTop);
-    const elementIntoWindow = (editor, element, alignToTop) => withElement(editor, element, intoWindow, alignToTop);
-    const rangeIntoFrame = (editor, rng, alignToTop) => withMarker(editor, intoFrame, rng, alignToTop);
-    const elementIntoFrame = (editor, element, alignToTop) => withElement(editor, element, intoFrame, alignToTop);
-    const scrollElementIntoView = (editor, element, alignToTop) => {
-      const scroller = editor.inline ? elementIntoWindow : elementIntoFrame;
-      scroller(editor, element, alignToTop);
-    };
-    const scrollRangeIntoView = (editor, rng, alignToTop) => {
-      const scroller = editor.inline ? rangeIntoWindow : rangeIntoFrame;
-      scroller(editor, rng, alignToTop);
-    };
-
-    const focus$1 = (element, preventScroll = false) => element.dom.focus({ preventScroll });
-    const hasFocus$1 = element => {
-      const root = getRootNode(element).dom;
-      return element.dom === root.activeElement;
+    const diagnose = (win, selection) => {
+      const ranges = getRanges(win, selection);
+      return doDiagnose(win, ranges);
     };
-    const active$1 = (root = getDocument()) => Optional.from(root.dom.activeElement).map(SugarElement.fromDom);
-    const search = element => active$1(getRootNode(element)).filter(e => element.dom.contains(e.dom));
+    adt$1.ltr;
+    adt$1.rtl;
 
-    const clamp$1 = (offset, element) => {
-      const max = isText$c(element) ? get$3(element).length : children$1(element).length + 1;
-      if (offset > max) {
-        return max;
-      } else if (offset < 0) {
-        return 0;
-      }
-      return offset;
-    };
-    const normalizeRng = rng => SimSelection.range(rng.start, clamp$1(rng.soffset, rng.start), rng.finish, clamp$1(rng.foffset, rng.finish));
-    const isOrContains = (root, elm) => !isRestrictedNode(elm.dom) && (contains(root, elm) || eq(root, elm));
-    const isRngInRoot = root => rng => isOrContains(root, rng.start) && isOrContains(root, rng.finish);
-    const shouldStore = editor => editor.inline || Env.browser.isFirefox();
-    const nativeRangeToSelectionRange = r => SimSelection.range(SugarElement.fromDom(r.startContainer), r.startOffset, SugarElement.fromDom(r.endContainer), r.endOffset);
-    const readRange = win => {
-      const selection = win.getSelection();
-      const rng = !selection || selection.rangeCount === 0 ? Optional.none() : Optional.from(selection.getRangeAt(0));
-      return rng.map(nativeRangeToSelectionRange);
+    const caretPositionFromPoint = (doc, x, y) => {
+      var _a;
+      return Optional.from((_a = doc.caretPositionFromPoint) === null || _a === void 0 ? void 0 : _a.call(doc, x, y)).bind(pos => {
+        if (pos.offsetNode === null) {
+          return Optional.none();
+        }
+        const r = doc.createRange();
+        r.setStart(pos.offsetNode, pos.offset);
+        r.collapse();
+        return Optional.some(r);
+      });
     };
-    const getBookmark$1 = root => {
-      const win = defaultView(root);
-      return readRange(win.dom).filter(isRngInRoot(root));
+    const caretRangeFromPoint = (doc, x, y) => {
+      var _a;
+      return Optional.from((_a = doc.caretRangeFromPoint) === null || _a === void 0 ? void 0 : _a.call(doc, x, y));
     };
-    const validate = (root, bookmark) => Optional.from(bookmark).filter(isRngInRoot(root)).map(normalizeRng);
-    const bookmarkToNativeRng = bookmark => {
-      const rng = document.createRange();
-      try {
-        rng.setStart(bookmark.start.dom, bookmark.soffset);
-        rng.setEnd(bookmark.finish.dom, bookmark.foffset);
-        return Optional.some(rng);
-      } catch (_) {
+    const availableSearch = (doc, x, y) => {
+      if (doc.caretPositionFromPoint) {
+        return caretPositionFromPoint(doc, x, y);
+      } else if (doc.caretRangeFromPoint) {
+        return caretRangeFromPoint(doc, x, y);
+      } else {
         return Optional.none();
       }
     };
-    const store = editor => {
-      const newBookmark = shouldStore(editor) ? getBookmark$1(SugarElement.fromDom(editor.getBody())) : Optional.none();
-      editor.bookmark = newBookmark.isSome() ? newBookmark : editor.bookmark;
-    };
-    const getRng = editor => {
-      const bookmark = editor.bookmark ? editor.bookmark : Optional.none();
-      return bookmark.bind(x => validate(SugarElement.fromDom(editor.getBody()), x)).bind(bookmarkToNativeRng);
-    };
-    const restore = editor => {
-      getRng(editor).each(rng => editor.selection.setRng(rng));
-    };
-
-    const isEditorUIElement$1 = elm => {
-      const className = elm.className.toString();
-      return className.indexOf('tox-') !== -1 || className.indexOf('mce-') !== -1;
+    const fromPoint$1 = (win, x, y) => {
+      const doc = win.document;
+      return availableSearch(doc, x, y).map(rng => SimRange.create(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset));
     };
-    const FocusManager = { isEditorUIElement: isEditorUIElement$1 };
 
-    const wrappedSetTimeout = (callback, time) => {
-      if (!isNumber(time)) {
-        time = 0;
+    const beforeSpecial = (element, offset) => {
+      const name$1 = name(element);
+      if ('input' === name$1) {
+        return Situ.after(element);
+      } else if (!contains$2([
+          'br',
+          'img'
+        ], name$1)) {
+        return Situ.on(element, offset);
+      } else {
+        return offset === 0 ? Situ.before(element) : Situ.after(element);
       }
-      return setTimeout(callback, time);
     };
-    const wrappedSetInterval = (callback, time) => {
-      if (!isNumber(time)) {
-        time = 0;
-      }
-      return setInterval(callback, time);
+    const preprocessRelative = (startSitu, finishSitu) => {
+      const start = startSitu.fold(Situ.before, beforeSpecial, Situ.after);
+      const finish = finishSitu.fold(Situ.before, beforeSpecial, Situ.after);
+      return SimSelection.relative(start, finish);
     };
-    const Delay = {
-      setEditorTimeout: (editor, callback, time) => {
-        return wrappedSetTimeout(() => {
-          if (!editor.removed) {
-            callback();
-          }
-        }, time);
-      },
-      setEditorInterval: (editor, callback, time) => {
-        const timer = wrappedSetInterval(() => {
-          if (!editor.removed) {
-            callback();
-          } else {
-            clearInterval(timer);
-          }
-        }, time);
-        return timer;
-      }
+    const preprocessExact = (start, soffset, finish, foffset) => {
+      const startSitu = beforeSpecial(start, soffset);
+      const finishSitu = beforeSpecial(finish, foffset);
+      return SimSelection.relative(startSitu, finishSitu);
     };
+    const preprocess = selection => selection.match({
+      domRange: rng => {
+        const start = SugarElement.fromDom(rng.startContainer);
+        const finish = SugarElement.fromDom(rng.endContainer);
+        return preprocessExact(start, rng.startOffset, finish, rng.endOffset);
+      },
+      relative: preprocessRelative,
+      exact: preprocessExact
+    });
 
-    const isManualNodeChange = e => {
-      return e.type === 'nodechange' && e.selectionChange;
-    };
-    const registerPageMouseUp = (editor, throttledStore) => {
-      const mouseUpPage = () => {
-        throttledStore.throttle();
-      };
-      DOMUtils.DOM.bind(document, 'mouseup', mouseUpPage);
-      editor.on('remove', () => {
-        DOMUtils.DOM.unbind(document, 'mouseup', mouseUpPage);
+    const fromElements = (elements, scope) => {
+      const doc = scope || document;
+      const fragment = doc.createDocumentFragment();
+      each$e(elements, element => {
+        fragment.appendChild(element.dom);
       });
+      return SugarElement.fromDom(fragment);
     };
-    const registerMouseUp = (editor, throttledStore) => {
-      editor.on('mouseup touchend', _e => {
-        throttledStore.throttle();
+
+    const toNative = selection => {
+      const win = SimSelection.getWin(selection).dom;
+      const getDomRange = (start, soffset, finish, foffset) => exactToNative(win, start, soffset, finish, foffset);
+      const filtered = preprocess(selection);
+      return diagnose(win, filtered).match({
+        ltr: getDomRange,
+        rtl: getDomRange
       });
     };
-    const registerEditorEvents = (editor, throttledStore) => {
-      registerMouseUp(editor, throttledStore);
-      editor.on('keyup NodeChange AfterSetSelectionRange', e => {
-        if (!isManualNodeChange(e)) {
-          store(editor);
-        }
-      });
+    const getAtPoint = (win, x, y) => fromPoint$1(win, x, y);
+
+    const fromPoint = (clientX, clientY, doc) => {
+      const win = defaultView(SugarElement.fromDom(doc));
+      return getAtPoint(win.dom, clientX, clientY).map(simRange => {
+        const rng = doc.createRange();
+        rng.setStart(simRange.start.dom, simRange.soffset);
+        rng.setEnd(simRange.finish.dom, simRange.foffset);
+        return rng;
+      }).getOrUndefined();
     };
-    const register$6 = editor => {
-      const throttledStore = first$1(() => {
-        store(editor);
-      }, 0);
-      editor.on('init', () => {
-        if (editor.inline) {
-          registerPageMouseUp(editor, throttledStore);
-        }
-        registerEditorEvents(editor, throttledStore);
-      });
-      editor.on('remove', () => {
-        throttledStore.cancel();
-      });
+
+    const isEq$4 = (rng1, rng2) => {
+      return isNonNullable(rng1) && isNonNullable(rng2) && (rng1.startContainer === rng2.startContainer && rng1.startOffset === rng2.startOffset) && (rng1.endContainer === rng2.endContainer && rng1.endOffset === rng2.endOffset);
     };
 
-    let documentFocusInHandler;
-    const DOM$9 = DOMUtils.DOM;
-    const isEditorUIElement = elm => {
-      return isElement$6(elm) && FocusManager.isEditorUIElement(elm);
+    const findParent = (node, rootNode, predicate) => {
+      let currentNode = node;
+      while (currentNode && currentNode !== rootNode) {
+        if (predicate(currentNode)) {
+          return currentNode;
+        }
+        currentNode = currentNode.parentNode;
+      }
+      return null;
     };
-    const isEditorContentAreaElement = elm => {
-      const classList = elm.classList;
-      if (classList !== undefined) {
-        return classList.contains('tox-edit-area') || classList.contains('tox-edit-area__iframe') || classList.contains('mce-content-body');
-      } else {
-        return false;
+    const hasParent$1 = (node, rootNode, predicate) => findParent(node, rootNode, predicate) !== null;
+    const hasParentWithName = (node, rootNode, name) => hasParent$1(node, rootNode, node => node.nodeName === name);
+    const isCeFalseCaretContainer = (node, rootNode) => isCaretContainer$2(node) && !hasParent$1(node, rootNode, isCaretNode);
+    const hasBrBeforeAfter = (dom, node, left) => {
+      const parentNode = node.parentNode;
+      if (parentNode) {
+        const walker = new DomTreeWalker(node, dom.getParent(parentNode, dom.isBlock) || dom.getRoot());
+        let currentNode;
+        while (currentNode = walker[left ? 'prev' : 'next']()) {
+          if (isBr$6(currentNode)) {
+            return true;
+          }
+        }
       }
+      return false;
     };
-    const isUIElement = (editor, elm) => {
-      const customSelector = getCustomUiSelector(editor);
-      const parent = DOM$9.getParent(elm, elm => {
-        return isEditorUIElement(elm) || (customSelector ? editor.dom.is(elm, customSelector) : false);
-      });
-      return parent !== null;
+    const isPrevNode = (node, name) => {
+      var _a;
+      return ((_a = node.previousSibling) === null || _a === void 0 ? void 0 : _a.nodeName) === name;
     };
-    const getActiveElement = editor => {
-      try {
-        const root = getRootNode(SugarElement.fromDom(editor.getElement()));
-        return active$1(root).fold(() => document.body, x => x.dom);
-      } catch (ex) {
-        return document.body;
+    const hasContentEditableFalseParent = (root, node) => {
+      let currentNode = node;
+      while (currentNode && currentNode !== root) {
+        if (isContentEditableFalse$b(currentNode)) {
+          return true;
+        }
+        currentNode = currentNode.parentNode;
       }
+      return false;
     };
-    const registerEvents$1 = (editorManager, e) => {
-      const editor = e.editor;
-      register$6(editor);
-      const toggleContentAreaOnFocus = (editor, fn) => {
-        if (shouldHighlightOnFocus(editor) && editor.inline !== true) {
-          const contentArea = SugarElement.fromDom(editor.getContainer());
-          fn(contentArea, 'tox-edit-focus');
+    const findTextNodeRelative = (dom, isAfterNode, collapsed, left, startNode) => {
+      const body = dom.getRoot();
+      const nonEmptyElementsMap = dom.schema.getNonEmptyElements();
+      const parentNode = startNode.parentNode;
+      let lastInlineElement;
+      let node;
+      if (!parentNode) {
+        return Optional.none();
+      }
+      const parentBlockContainer = dom.getParent(parentNode, dom.isBlock) || body;
+      if (left && isBr$6(startNode) && isAfterNode && dom.isEmpty(parentBlockContainer)) {
+        return Optional.some(CaretPosition(parentNode, dom.nodeIndex(startNode)));
+      }
+      const walker = new DomTreeWalker(startNode, parentBlockContainer);
+      while (node = walker[left ? 'prev' : 'next']()) {
+        if (dom.getContentEditableParent(node) === 'false' || isCeFalseCaretContainer(node, body)) {
+          return Optional.none();
         }
-      };
-      editor.on('focusin', () => {
-        const focusedEditor = editorManager.focusedEditor;
-        if (isEditorContentAreaElement(getActiveElement(editor))) {
-          toggleContentAreaOnFocus(editor, add$2);
+        if (isText$b(node) && node.data.length > 0) {
+          if (!hasParentWithName(node, body, 'A')) {
+            return Optional.some(CaretPosition(node, left ? node.data.length : 0));
+          }
+          return Optional.none();
         }
-        if (focusedEditor !== editor) {
-          if (focusedEditor) {
-            focusedEditor.dispatch('blur', { focusedEditor: editor });
+        if (dom.isBlock(node) || nonEmptyElementsMap[node.nodeName.toLowerCase()]) {
+          return Optional.none();
+        }
+        lastInlineElement = node;
+      }
+      if (isComment(lastInlineElement)) {
+        return Optional.none();
+      }
+      if (collapsed && lastInlineElement) {
+        return Optional.some(CaretPosition(lastInlineElement, 0));
+      }
+      return Optional.none();
+    };
+    const normalizeEndPoint = (dom, collapsed, start, rng) => {
+      const body = dom.getRoot();
+      let node;
+      let normalized = false;
+      let container = start ? rng.startContainer : rng.endContainer;
+      let offset = start ? rng.startOffset : rng.endOffset;
+      const isAfterNode = isElement$6(container) && offset === container.childNodes.length;
+      const nonEmptyElementsMap = dom.schema.getNonEmptyElements();
+      let directionLeft = start;
+      if (isCaretContainer$2(container)) {
+        return Optional.none();
+      }
+      if (isElement$6(container) && offset > container.childNodes.length - 1) {
+        directionLeft = false;
+      }
+      if (isDocument$1(container)) {
+        container = body;
+        offset = 0;
+      }
+      if (container === body) {
+        if (directionLeft) {
+          node = container.childNodes[offset > 0 ? offset - 1 : 0];
+          if (node) {
+            if (isCaretContainer$2(node)) {
+              return Optional.none();
+            }
+            if (nonEmptyElementsMap[node.nodeName] || isTable$2(node)) {
+              return Optional.none();
+            }
           }
-          editorManager.setActive(editor);
-          editorManager.focusedEditor = editor;
-          editor.dispatch('focus', { blurredEditor: focusedEditor });
-          editor.focus(true);
         }
-      });
-      editor.on('focusout', () => {
-        Delay.setEditorTimeout(editor, () => {
-          const focusedEditor = editorManager.focusedEditor;
-          if (!isEditorContentAreaElement(getActiveElement(editor)) || focusedEditor !== editor) {
-            toggleContentAreaOnFocus(editor, remove$6);
+        if (container.hasChildNodes()) {
+          offset = Math.min(!directionLeft && offset > 0 ? offset - 1 : offset, container.childNodes.length - 1);
+          container = container.childNodes[offset];
+          offset = isText$b(container) && isAfterNode ? container.data.length : 0;
+          if (!collapsed && container === body.lastChild && isTable$2(container)) {
+            return Optional.none();
           }
-          if (!isUIElement(editor, getActiveElement(editor)) && focusedEditor === editor) {
-            editor.dispatch('blur', { focusedEditor: null });
-            editorManager.focusedEditor = null;
+          if (hasContentEditableFalseParent(body, container) || isCaretContainer$2(container)) {
+            return Optional.none();
           }
-        });
-      });
-      if (!documentFocusInHandler) {
-        documentFocusInHandler = e => {
-          const activeEditor = editorManager.activeEditor;
-          if (activeEditor) {
-            getOriginalEventTarget(e).each(target => {
-              const elem = target;
-              if (elem.ownerDocument === document) {
-                if (elem !== document.body && !isUIElement(activeEditor, elem) && editorManager.focusedEditor === activeEditor) {
-                  activeEditor.dispatch('blur', { focusedEditor: null });
-                  editorManager.focusedEditor = null;
+          if (isDetails(container)) {
+            return Optional.none();
+          }
+          if (container.hasChildNodes() && !isTable$2(container)) {
+            node = container;
+            const walker = new DomTreeWalker(container, body);
+            do {
+              if (isContentEditableFalse$b(node) || isCaretContainer$2(node)) {
+                normalized = false;
+                break;
+              }
+              if (isText$b(node) && node.data.length > 0) {
+                offset = directionLeft ? 0 : node.data.length;
+                container = node;
+                normalized = true;
+                break;
+              }
+              if (nonEmptyElementsMap[node.nodeName.toLowerCase()] && !isTableCellOrCaption(node)) {
+                offset = dom.nodeIndex(node);
+                container = node.parentNode;
+                if (!directionLeft) {
+                  offset++;
                 }
+                normalized = true;
+                break;
               }
+            } while (node = directionLeft ? walker.next() : walker.prev());
+          }
+        }
+      }
+      if (collapsed) {
+        if (isText$b(container) && offset === 0) {
+          findTextNodeRelative(dom, isAfterNode, collapsed, true, container).each(pos => {
+            container = pos.container();
+            offset = pos.offset();
+            normalized = true;
+          });
+        }
+        if (isElement$6(container)) {
+          node = container.childNodes[offset];
+          if (!node) {
+            node = container.childNodes[offset - 1];
+          }
+          if (node && isBr$6(node) && !isPrevNode(node, 'A') && !hasBrBeforeAfter(dom, node, false) && !hasBrBeforeAfter(dom, node, true)) {
+            findTextNodeRelative(dom, isAfterNode, collapsed, true, node).each(pos => {
+              container = pos.container();
+              offset = pos.offset();
+              normalized = true;
             });
           }
-        };
-        DOM$9.bind(document, 'focusin', documentFocusInHandler);
+        }
+      }
+      if (directionLeft && !collapsed && isText$b(container) && offset === container.data.length) {
+        findTextNodeRelative(dom, isAfterNode, collapsed, false, container).each(pos => {
+          container = pos.container();
+          offset = pos.offset();
+          normalized = true;
+        });
       }
+      return normalized && container ? Optional.some(CaretPosition(container, offset)) : Optional.none();
     };
-    const unregisterDocumentEvents = (editorManager, e) => {
-      if (editorManager.focusedEditor === e.editor) {
-        editorManager.focusedEditor = null;
+    const normalize$2 = (dom, rng) => {
+      const collapsed = rng.collapsed, normRng = rng.cloneRange();
+      const startPos = CaretPosition.fromRangeStart(rng);
+      normalizeEndPoint(dom, collapsed, true, normRng).each(pos => {
+        if (!collapsed || !CaretPosition.isAbove(startPos, pos)) {
+          normRng.setStart(pos.container(), pos.offset());
+        }
+      });
+      if (!collapsed) {
+        normalizeEndPoint(dom, collapsed, false, normRng).each(pos => {
+          normRng.setEnd(pos.container(), pos.offset());
+        });
       }
-      if (!editorManager.activeEditor && documentFocusInHandler) {
-        DOM$9.unbind(document, 'focusin', documentFocusInHandler);
-        documentFocusInHandler = null;
+      if (collapsed) {
+        normRng.collapse(true);
       }
-    };
-    const setup$w = editorManager => {
-      editorManager.on('AddEditor', curry(registerEvents$1, editorManager));
-      editorManager.on('RemoveEditor', curry(unregisterDocumentEvents, editorManager));
+      return isEq$4(rng, normRng) ? Optional.none() : Optional.some(normRng);
     };
 
-    const getContentEditableHost = (editor, node) => editor.dom.getParent(node, node => editor.dom.getContentEditable(node) === 'true');
-    const hasContentEditableFalseParent = (editor, node) => editor.dom.getParent(node, node => editor.dom.getContentEditable(node) === 'false') !== null;
-    const getCollapsedNode = rng => rng.collapsed ? Optional.from(getNode$1(rng.startContainer, rng.startOffset)).map(SugarElement.fromDom) : Optional.none();
-    const getFocusInElement = (root, rng) => getCollapsedNode(rng).bind(node => {
-      if (isTableSection(node)) {
-        return Optional.some(node);
-      } else if (!contains(root, node)) {
-        return Optional.some(root);
+    const splitText = (node, offset) => {
+      return node.splitText(offset);
+    };
+    const split = rng => {
+      let startContainer = rng.startContainer, startOffset = rng.startOffset, endContainer = rng.endContainer, endOffset = rng.endOffset;
+      if (startContainer === endContainer && isText$b(startContainer)) {
+        if (startOffset > 0 && startOffset < startContainer.data.length) {
+          endContainer = splitText(startContainer, startOffset);
+          startContainer = endContainer.previousSibling;
+          if (endOffset > startOffset) {
+            endOffset = endOffset - startOffset;
+            const newContainer = splitText(endContainer, endOffset).previousSibling;
+            startContainer = endContainer = newContainer;
+            endOffset = newContainer.data.length;
+            startOffset = 0;
+          } else {
+            endOffset = 0;
+          }
+        }
       } else {
-        return Optional.none();
+        if (isText$b(startContainer) && startOffset > 0 && startOffset < startContainer.data.length) {
+          startContainer = splitText(startContainer, startOffset);
+          startOffset = 0;
+        }
+        if (isText$b(endContainer) && endOffset > 0 && endOffset < endContainer.data.length) {
+          const newContainer = splitText(endContainer, endOffset).previousSibling;
+          endContainer = newContainer;
+          endOffset = newContainer.data.length;
+        }
       }
-    });
-    const normalizeSelection = (editor, rng) => {
-      getFocusInElement(SugarElement.fromDom(editor.getBody()), rng).bind(elm => {
-        return firstPositionIn(elm.dom);
-      }).fold(() => {
-        editor.selection.normalize();
-      }, caretPos => editor.selection.setRng(caretPos.toRange()));
+      return {
+        startContainer,
+        startOffset,
+        endContainer,
+        endOffset
+      };
     };
-    const focusBody = body => {
-      if (body.setActive) {
-        try {
-          body.setActive();
-        } catch (ex) {
-          body.focus();
+
+    const RangeUtils = dom => {
+      const walk = (rng, callback) => {
+        return walk$3(dom, rng, callback);
+      };
+      const split$1 = split;
+      const normalize = rng => {
+        return normalize$2(dom, rng).fold(never, normalizedRng => {
+          rng.setStart(normalizedRng.startContainer, normalizedRng.startOffset);
+          rng.setEnd(normalizedRng.endContainer, normalizedRng.endOffset);
+          return true;
+        });
+      };
+      const expand = (rng, options = { type: 'word' }) => {
+        if (options.type === 'word') {
+          const rangeLike = expandRng(dom, rng, [{ inline: 'span' }]);
+          const newRange = dom.createRng();
+          newRange.setStart(rangeLike.startContainer, rangeLike.startOffset);
+          newRange.setEnd(rangeLike.endContainer, rangeLike.endOffset);
+          return newRange;
+        }
+        return rng;
+      };
+      return {
+        walk,
+        split: split$1,
+        expand,
+        normalize
+      };
+    };
+    RangeUtils.compareRanges = isEq$4;
+    RangeUtils.getCaretRangeFromPoint = fromPoint;
+    RangeUtils.getSelectedNode = getSelectedNode;
+    RangeUtils.getNode = getNode$1;
+
+    const Dimension = (name, getOffset) => {
+      const set = (element, h) => {
+        if (!isNumber(h) && !h.match(/^[0-9]+$/)) {
+          throw new Error(name + '.set accepts only positive integer values. Value was ' + h);
+        }
+        const dom = element.dom;
+        if (isSupported(dom)) {
+          dom.style[name] = h + 'px';
+        }
+      };
+      const get = element => {
+        const r = getOffset(element);
+        if (r <= 0 || r === null) {
+          const css = get$7(element, name);
+          return parseFloat(css) || 0;
         }
+        return r;
+      };
+      const getOuter = get;
+      const aggregate = (element, properties) => foldl(properties, (acc, property) => {
+        const val = get$7(element, property);
+        const value = val === undefined ? 0 : parseInt(val, 10);
+        return isNaN(value) ? acc : acc + value;
+      }, 0);
+      const max = (element, value, properties) => {
+        const cumulativeInclusions = aggregate(element, properties);
+        const absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0;
+        return absoluteMax;
+      };
+      return {
+        set,
+        get,
+        getOuter,
+        aggregate,
+        max
+      };
+    };
+
+    const api = Dimension('height', element => {
+      const dom = element.dom;
+      return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight;
+    });
+    const get$2 = element => api.get(element);
+
+    const walkUp = (navigation, doc) => {
+      const frame = navigation.view(doc);
+      return frame.fold(constant([]), f => {
+        const parent = navigation.owner(f);
+        const rest = walkUp(navigation, parent);
+        return [f].concat(rest);
+      });
+    };
+    const pathTo = (element, navigation) => {
+      const d = navigation.owner(element);
+      return walkUp(navigation, d);
+    };
+
+    const view = doc => {
+      var _a;
+      const element = doc.dom === document ? Optional.none() : Optional.from((_a = doc.dom.defaultView) === null || _a === void 0 ? void 0 : _a.frameElement);
+      return element.map(SugarElement.fromDom);
+    };
+    const owner = element => documentOrOwner(element);
+
+    var Navigation = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        view: view,
+        owner: owner
+    });
+
+    const find = element => {
+      const doc = getDocument();
+      const scroll = get$5(doc);
+      const frames = pathTo(element, Navigation);
+      const offset = viewport(element);
+      const r = foldr(frames, (b, a) => {
+        const loc = viewport(a);
+        return {
+          left: b.left + loc.left,
+          top: b.top + loc.top
+        };
+      }, {
+        left: 0,
+        top: 0
+      });
+      return SugarPosition(r.left + offset.left + scroll.left, r.top + offset.top + scroll.top);
+    };
+
+    const excludeFromDescend = element => name(element) === 'textarea';
+    const fireScrollIntoViewEvent = (editor, data) => {
+      const scrollEvent = editor.dispatch('ScrollIntoView', data);
+      return scrollEvent.isDefaultPrevented();
+    };
+    const fireAfterScrollIntoViewEvent = (editor, data) => {
+      editor.dispatch('AfterScrollIntoView', data);
+    };
+    const descend = (element, offset) => {
+      const children = children$1(element);
+      if (children.length === 0 || excludeFromDescend(element)) {
+        return {
+          element,
+          offset
+        };
+      } else if (offset < children.length && !excludeFromDescend(children[offset])) {
+        return {
+          element: children[offset],
+          offset: 0
+        };
       } else {
-        body.focus();
+        const last = children[children.length - 1];
+        if (excludeFromDescend(last)) {
+          return {
+            element,
+            offset
+          };
+        } else {
+          if (name(last) === 'img') {
+            return {
+              element: last,
+              offset: 1
+            };
+          } else if (isText$c(last)) {
+            return {
+              element: last,
+              offset: get$3(last).length
+            };
+          } else {
+            return {
+              element: last,
+              offset: children$1(last).length
+            };
+          }
+        }
       }
     };
-    const hasElementFocus = elm => hasFocus$1(elm) || search(elm).isSome();
-    const hasIframeFocus = editor => isNonNullable(editor.iframeElement) && hasFocus$1(SugarElement.fromDom(editor.iframeElement));
-    const hasInlineFocus = editor => {
-      const rawBody = editor.getBody();
-      return rawBody && hasElementFocus(SugarElement.fromDom(rawBody));
+    const markerInfo = (element, cleanupFun) => {
+      const pos = absolute(element);
+      const height = get$2(element);
+      return {
+        element,
+        bottom: pos.top + height,
+        height,
+        pos,
+        cleanup: cleanupFun
+      };
     };
-    const hasUiFocus = editor => {
-      const dos = getRootNode(SugarElement.fromDom(editor.getElement()));
-      return active$1(dos).filter(elem => !isEditorContentAreaElement(elem.dom) && isUIElement(editor, elem.dom)).isSome();
+    const createMarker$1 = (element, offset) => {
+      const startPoint = descend(element, offset);
+      const span = SugarElement.fromHtml('<span data-mce-bogus="all" style="display: inline-block;">' + ZWSP$1 + '</span>');
+      before$3(startPoint.element, span);
+      return markerInfo(span, () => remove$4(span));
     };
-    const hasFocus = editor => editor.inline ? hasInlineFocus(editor) : hasIframeFocus(editor);
-    const hasEditorOrUiFocus = editor => hasFocus(editor) || hasUiFocus(editor);
-    const focusEditor = editor => {
-      const selection = editor.selection;
-      const body = editor.getBody();
-      let rng = selection.getRng();
-      editor.quirks.refreshContentEditable();
-      const restoreBookmark = editor => {
-        getRng(editor).each(bookmarkRng => {
-          editor.selection.setRng(bookmarkRng);
-          rng = bookmarkRng;
-        });
+    const elementMarker = element => markerInfo(SugarElement.fromDom(element), noop);
+    const withMarker = (editor, f, rng, alignToTop) => {
+      preserveWith(editor, (_s, _e) => applyWithMarker(editor, f, rng, alignToTop), rng);
+    };
+    const withScrollEvents = (editor, doc, f, marker, alignToTop) => {
+      const data = {
+        elm: marker.element.dom,
+        alignToTop
       };
-      if (!hasFocus(editor) && editor.hasEditableRoot()) {
-        restoreBookmark(editor);
-      }
-      const contentEditableHost = getContentEditableHost(editor, selection.getNode());
-      if (contentEditableHost && editor.dom.isChildOf(contentEditableHost, body)) {
-        if (!hasContentEditableFalseParent(editor, contentEditableHost)) {
-          focusBody(body);
-        }
-        focusBody(contentEditableHost);
-        if (!editor.hasEditableRoot()) {
-          restoreBookmark(editor);
-        }
-        normalizeSelection(editor, rng);
-        activateEditor(editor);
+      if (fireScrollIntoViewEvent(editor, data)) {
         return;
       }
-      if (!editor.inline) {
-        if (!Env.browser.isOpera()) {
-          focusBody(body);
-        }
-        editor.getWin().focus();
-      }
-      if (Env.browser.isFirefox() || editor.inline) {
-        focusBody(body);
-        normalizeSelection(editor, rng);
+      const scrollTop = get$5(doc).top;
+      f(editor, doc, scrollTop, marker, alignToTop);
+      fireAfterScrollIntoViewEvent(editor, data);
+    };
+    const applyWithMarker = (editor, f, rng, alignToTop) => {
+      const body = SugarElement.fromDom(editor.getBody());
+      const doc = SugarElement.fromDom(editor.getDoc());
+      reflow(body);
+      const marker = createMarker$1(SugarElement.fromDom(rng.startContainer), rng.startOffset);
+      withScrollEvents(editor, doc, f, marker, alignToTop);
+      marker.cleanup();
+    };
+    const withElement = (editor, element, f, alignToTop) => {
+      const doc = SugarElement.fromDom(editor.getDoc());
+      withScrollEvents(editor, doc, f, elementMarker(element), alignToTop);
+    };
+    const preserveWith = (editor, f, rng) => {
+      const startElement = rng.startContainer;
+      const startOffset = rng.startOffset;
+      const endElement = rng.endContainer;
+      const endOffset = rng.endOffset;
+      f(SugarElement.fromDom(startElement), SugarElement.fromDom(endElement));
+      const newRng = editor.dom.createRng();
+      newRng.setStart(startElement, startOffset);
+      newRng.setEnd(endElement, endOffset);
+      editor.selection.setRng(rng);
+    };
+    const scrollToMarker = (editor, marker, viewHeight, alignToTop, doc) => {
+      const pos = marker.pos;
+      if (alignToTop) {
+        to(pos.left, pos.top, doc);
+      } else {
+        const y = pos.top - viewHeight + marker.height;
+        to(-editor.getBody().getBoundingClientRect().left, y, doc);
       }
-      activateEditor(editor);
     };
-    const activateEditor = editor => editor.editorManager.setActive(editor);
-    const focus = (editor, skipFocus) => {
-      if (editor.removed) {
-        return;
+    const intoWindowIfNeeded = (editor, doc, scrollTop, viewHeight, marker, alignToTop) => {
+      const viewportBottom = viewHeight + scrollTop;
+      const markerTop = marker.pos.top;
+      const markerBottom = marker.bottom;
+      const largerThanViewport = markerBottom - markerTop >= viewHeight;
+      if (markerTop < scrollTop) {
+        scrollToMarker(editor, marker, viewHeight, alignToTop !== false, doc);
+      } else if (markerTop > viewportBottom) {
+        const align = largerThanViewport ? alignToTop !== false : alignToTop === true;
+        scrollToMarker(editor, marker, viewHeight, align, doc);
+      } else if (markerBottom > viewportBottom && !largerThanViewport) {
+        scrollToMarker(editor, marker, viewHeight, alignToTop === true, doc);
       }
-      if (skipFocus) {
-        activateEditor(editor);
-      } else {
-        focusEditor(editor);
+    };
+    const intoWindow = (editor, doc, scrollTop, marker, alignToTop) => {
+      const viewHeight = defaultView(doc).dom.innerHeight;
+      intoWindowIfNeeded(editor, doc, scrollTop, viewHeight, marker, alignToTop);
+    };
+    const intoFrame = (editor, doc, scrollTop, marker, alignToTop) => {
+      const frameViewHeight = defaultView(doc).dom.innerHeight;
+      intoWindowIfNeeded(editor, doc, scrollTop, frameViewHeight, marker, alignToTop);
+      const op = find(marker.element);
+      const viewportBounds = getBounds(window);
+      if (op.top < viewportBounds.y) {
+        intoView(marker.element, alignToTop !== false);
+      } else if (op.top > viewportBounds.bottom) {
+        intoView(marker.element, alignToTop === true);
       }
     };
+    const rangeIntoWindow = (editor, rng, alignToTop) => withMarker(editor, intoWindow, rng, alignToTop);
+    const elementIntoWindow = (editor, element, alignToTop) => withElement(editor, element, intoWindow, alignToTop);
+    const rangeIntoFrame = (editor, rng, alignToTop) => withMarker(editor, intoFrame, rng, alignToTop);
+    const elementIntoFrame = (editor, element, alignToTop) => withElement(editor, element, intoFrame, alignToTop);
+    const scrollElementIntoView = (editor, element, alignToTop) => {
+      const scroller = editor.inline ? elementIntoWindow : elementIntoFrame;
+      scroller(editor, element, alignToTop);
+    };
+    const scrollRangeIntoView = (editor, rng, alignToTop) => {
+      const scroller = editor.inline ? rangeIntoWindow : rangeIntoFrame;
+      scroller(editor, rng, alignToTop);
+    };
 
     const isEditableRange = (dom, rng) => {
       if (rng.collapsed) {
@@ -11521,7 +11547,7 @@
       const doc = editor.getDoc();
       const dos = getRootNode(SugarElement.fromDom(editor.getBody()));
       const offscreenDiv = SugarElement.fromTag('div', doc);
-      set$3(offscreenDiv, 'data-mce-bogus', 'all');
+      set$4(offscreenDiv, 'data-mce-bogus', 'all');
       setAll(offscreenDiv, {
         position: 'fixed',
         left: '-9999999px',
@@ -12466,7 +12492,7 @@
         editor.selection.collapse(true);
       }
       if (selectedCells.length > 1 && exists(selectedCells, cell => eq(cell, selectedNode))) {
-        set$3(selectedNode, 'data-mce-selected', '1');
+        set$4(selectedNode, 'data-mce-selected', '1');
       }
     };
     const emptySingleTableCells = (editor, cells, outsideDetails) => Optional.some(() => {
@@ -15001,13 +15027,21 @@
       const matches = /([a-z0-9+\/=\s]+)/i.exec(data);
       return matches ? matches[1] : '';
     };
+    const decodeData = data => {
+      try {
+        return decodeURIComponent(data);
+      } catch (_a) {
+        return data;
+      }
+    };
     const parseDataUri = uri => {
       const [type, ...rest] = uri.split(',');
       const data = rest.join(',');
       const matches = /data:([^/]+\/[^;]+)(;.+)?/.exec(type);
       if (matches) {
         const base64Encoded = matches[2] === ';base64';
-        const extractedData = base64Encoded ? extractBase64Data(data) : decodeURIComponent(data);
+        const decodedData = decodeData(data);
+        const extractedData = base64Encoded ? extractBase64Data(decodedData) : decodedData;
         return Optional.some({
           type: matches[1],
           data: extractedData,
@@ -17182,11 +17216,11 @@
       }
       if (validate && rule && !isInternalElement) {
         each$e((_c = rule.attributesForced) !== null && _c !== void 0 ? _c : [], attr => {
-          set$3(element, attr.name, attr.value === '{$uid}' ? `mce_${ uid++ }` : attr.value);
+          set$4(element, attr.name, attr.value === '{$uid}' ? `mce_${ uid++ }` : attr.value);
         });
         each$e((_d = rule.attributesDefault) !== null && _d !== void 0 ? _d : [], attr => {
           if (!has$1(element, attr.name)) {
-            set$3(element, attr.name, attr.value === '{$uid}' ? `mce_${ uid++ }` : attr.value);
+            set$4(element, attr.name, attr.value === '{$uid}' ? `mce_${ uid++ }` : attr.value);
           }
         });
         if (rule.attributesRequired && !exists(rule.attributesRequired, attr => has$1(element, attr))) {
@@ -19800,41 +19834,182 @@
       fireError(editor, errorType, { message: msg });
       console.error(msg);
     };
-    const createLoadError = (type, url, name) => name ? `Failed to load ${ type }: ${ name } from url ${ url }` : `Failed to load ${ type } url: ${ url }`;
-    const pluginLoadError = (editor, url, name) => {
-      logError(editor, 'PluginLoadError', createLoadError('plugin', url, name));
+    const createLoadError = (type, url, name) => name ? `Failed to load ${ type }: ${ name } from url ${ url }` : `Failed to load ${ type } url: ${ url }`;
+    const pluginLoadError = (editor, url, name) => {
+      logError(editor, 'PluginLoadError', createLoadError('plugin', url, name));
+    };
+    const iconsLoadError = (editor, url, name) => {
+      logError(editor, 'IconsLoadError', createLoadError('icons', url, name));
+    };
+    const languageLoadError = (editor, url, name) => {
+      logError(editor, 'LanguageLoadError', createLoadError('language', url, name));
+    };
+    const themeLoadError = (editor, url, name) => {
+      logError(editor, 'ThemeLoadError', createLoadError('theme', url, name));
+    };
+    const modelLoadError = (editor, url, name) => {
+      logError(editor, 'ModelLoadError', createLoadError('model', url, name));
+    };
+    const pluginInitError = (editor, name, err) => {
+      const message = I18n.translate([
+        'Failed to initialize plugin: {0}',
+        name
+      ]);
+      fireError(editor, 'PluginLoadError', { message });
+      initError(message, err);
+      displayError(editor, message);
+    };
+    const initError = (message, ...x) => {
+      const console = window.console;
+      if (console) {
+        if (console.error) {
+          console.error(message, ...x);
+        } else {
+          console.log(message, ...x);
+        }
+      }
+    };
+
+    const removeFakeSelection = editor => {
+      Optional.from(editor.selection.getNode()).each(elm => {
+        elm.removeAttribute('data-mce-selected');
+      });
+    };
+    const setEditorCommandState = (editor, cmd, state) => {
+      try {
+        editor.getDoc().execCommand(cmd, false, String(state));
+      } catch (ex) {
+      }
+    };
+    const setCommonEditorCommands = (editor, state) => {
+      setEditorCommandState(editor, 'StyleWithCSS', state);
+      setEditorCommandState(editor, 'enableInlineTableEditing', state);
+      setEditorCommandState(editor, 'enableObjectResizing', state);
+    };
+    const restoreFakeSelection = editor => {
+      editor.selection.setRng(editor.selection.getRng());
+    };
+    const toggleClass = (elm, cls, state) => {
+      if (has(elm, cls) && !state) {
+        remove$6(elm, cls);
+      } else if (state) {
+        add$2(elm, cls);
+      }
+    };
+    const disableEditor = editor => {
+      const body = SugarElement.fromDom(editor.getBody());
+      toggleClass(body, 'mce-content-readonly', true);
+      editor.selection.controlSelection.hideResizeRect();
+      editor._selectionOverrides.hideFakeCaret();
+      removeFakeSelection(editor);
+    };
+    const enableEditor = editor => {
+      const body = SugarElement.fromDom(editor.getBody());
+      toggleClass(body, 'mce-content-readonly', false);
+      if (editor.hasEditableRoot()) {
+        set$3(body, true);
+      }
+      setCommonEditorCommands(editor, false);
+      if (hasEditorOrUiFocus(editor)) {
+        editor.focus();
+      }
+      restoreFakeSelection(editor);
+      editor.nodeChanged();
+    };
+
+    const isDisabled = editor => isDisabled$1(editor);
+    const internalContentEditableAttr = 'data-mce-contenteditable';
+    const switchOffContentEditableTrue = elm => {
+      each$e(descendants(elm, '*[contenteditable="true"]'), elm => {
+        set$4(elm, internalContentEditableAttr, 'true');
+        set$3(elm, false);
+      });
     };
-    const iconsLoadError = (editor, url, name) => {
-      logError(editor, 'IconsLoadError', createLoadError('icons', url, name));
+    const switchOnContentEditableTrue = elm => {
+      each$e(descendants(elm, `*[${ internalContentEditableAttr }="true"]`), elm => {
+        remove$9(elm, internalContentEditableAttr);
+        set$3(elm, true);
+      });
     };
-    const languageLoadError = (editor, url, name) => {
-      logError(editor, 'LanguageLoadError', createLoadError('language', url, name));
+    const toggleDisabled = (editor, state) => {
+      const body = SugarElement.fromDom(editor.getBody());
+      if (state) {
+        disableEditor(editor);
+        set$3(body, false);
+        switchOffContentEditableTrue(body);
+      } else {
+        switchOnContentEditableTrue(body);
+        enableEditor(editor);
+      }
     };
-    const themeLoadError = (editor, url, name) => {
-      logError(editor, 'ThemeLoadError', createLoadError('theme', url, name));
+    const registerDisabledContentFilters = editor => {
+      if (editor.serializer) {
+        registerFilters(editor);
+      } else {
+        editor.on('PreInit', () => {
+          registerFilters(editor);
+        });
+      }
     };
-    const modelLoadError = (editor, url, name) => {
-      logError(editor, 'ModelLoadError', createLoadError('model', url, name));
+    const registerFilters = editor => {
+      editor.parser.addAttributeFilter('contenteditable', nodes => {
+        if (isDisabled(editor)) {
+          each$e(nodes, node => {
+            node.attr(internalContentEditableAttr, node.attr('contenteditable'));
+            node.attr('contenteditable', 'false');
+          });
+        }
+      });
+      editor.serializer.addAttributeFilter(internalContentEditableAttr, nodes => {
+        if (isDisabled(editor)) {
+          each$e(nodes, node => {
+            node.attr('contenteditable', node.attr(internalContentEditableAttr));
+          });
+        }
+      });
+      editor.serializer.addTempAttr(internalContentEditableAttr);
     };
-    const pluginInitError = (editor, name, err) => {
-      const message = I18n.translate([
-        'Failed to initialize plugin: {0}',
-        name
-      ]);
-      fireError(editor, 'PluginLoadError', { message });
-      initError(message, err);
-      displayError(editor, message);
+    const isClickEvent = e => e.type === 'click';
+    const allowedEvents = ['copy'];
+    const isAllowedEventInDisabledMode = e => contains$2(allowedEvents, e.type);
+    const getAnchorHrefOpt = (editor, elm) => {
+      const isRoot = elm => eq(elm, SugarElement.fromDom(editor.getBody()));
+      return closest$3(elm, 'a', isRoot).bind(a => getOpt(a, 'href'));
     };
-    const initError = (message, ...x) => {
-      const console = window.console;
-      if (console) {
-        if (console.error) {
-          console.error(message, ...x);
-        } else {
-          console.log(message, ...x);
-        }
+    const processDisabledEvents = (editor, e) => {
+      if (isClickEvent(e) && !VK.metaKeyPressed(e)) {
+        const elm = SugarElement.fromDom(e.target);
+        getAnchorHrefOpt(editor, elm).each(href => {
+          e.preventDefault();
+          if (/^#/.test(href)) {
+            const targetEl = editor.dom.select(`${ href },[name="${ removeLeading(href, '#') }"]`);
+            if (targetEl.length) {
+              editor.selection.scrollIntoView(targetEl[0], true);
+            }
+          } else {
+            window.open(href, '_blank', 'rel=noopener noreferrer,menubar=yes,toolbar=yes,location=yes,status=yes,resizable=yes,scrollbars=yes');
+          }
+        });
+      } else if (isAllowedEventInDisabledMode(e)) {
+        editor.dispatch(e.type, e);
       }
     };
+    const registerDisabledModeEventHandlers = editor => {
+      editor.on('ShowCaret ObjectSelected', e => {
+        if (isDisabled(editor)) {
+          e.preventDefault();
+        }
+      });
+      editor.on('DisabledStateChange', e => {
+        if (!e.isDefaultPrevented()) {
+          toggleDisabled(editor, e.state);
+        }
+      });
+    };
+    const registerEventsAndFilters$1 = editor => {
+      registerDisabledContentFilters(editor);
+      registerDisabledModeEventHandlers(editor);
+    };
 
     const isContentCssSkinName = url => /^[a-z0-9\-]+$/i.test(url);
     const toContentSkinResourceName = url => 'content/' + url + '/content.css';
@@ -20431,6 +20606,11 @@
             styles: { float: 'left' },
             preview: 'font-family font-size'
           },
+          {
+            selector: '.mce-placeholder',
+            styles: { float: 'left' },
+            ceFalseOverride: true
+          },
           {
             selector: 'table',
             collapsed: false,
@@ -20473,6 +20653,15 @@
             },
             preview: false
           },
+          {
+            selector: '.mce-placeholder',
+            styles: {
+              display: 'block',
+              marginLeft: 'auto',
+              marginRight: 'auto'
+            },
+            ceFalseOverride: true
+          },
           {
             selector: 'table',
             collapsed: false,
@@ -20522,6 +20711,11 @@
             styles: { float: 'right' },
             preview: 'font-family font-size'
           },
+          {
+            selector: '.mce-placeholder',
+            styles: { float: 'right' },
+            ceFalseOverride: true
+          },
           {
             selector: 'table',
             collapsed: false,
@@ -20680,6 +20874,7 @@
         subscript: { inline: 'sub' },
         superscript: { inline: 'sup' },
         code: { inline: 'code' },
+        samp: { inline: 'samp' },
         link: {
           inline: 'a',
           selector: 'a',
@@ -20739,7 +20934,7 @@
           }
         ]
       };
-      Tools.each('p h1 h2 h3 h4 h5 h6 div address pre dt dd samp'.split(/\s/), name => {
+      Tools.each('p h1 h2 h3 h4 h5 h6 div address pre dt dd'.split(/\s/), name => {
         formats[name] = {
           block: name,
           remove: 'all'
@@ -24076,6 +24271,29 @@
         toString
       };
     };
+    const oneOf = (props, rawF) => {
+      const f = rawF !== undefined ? rawF : identity;
+      const extract = (path, val) => {
+        const errors = [];
+        for (const prop of props) {
+          const res = prop.extract(path, val);
+          if (res.stype === SimpleResultType.Value) {
+            return {
+              stype: SimpleResultType.Value,
+              svalue: f(res.svalue)
+            };
+          }
+          errors.push(res);
+        }
+        return ResultCombine.consolidateArr(errors);
+      };
+      const toString = () => 'oneOf(' + map$3(props, prop => prop.toString()).join(', ') + ')';
+      return {
+        extract,
+        toString
+      };
+    };
+    const arrOfObj = compose(arrOf, objOf);
 
     const valueOf = validator => value(v => validator(v).fold(SimpleResult.serror, SimpleResult.svalue));
     const extractValue = (label, prop, obj) => {
@@ -24106,6 +24324,7 @@
     const validateEnum = values => valueOf(value => contains$2(values, value) ? Result.value(value) : Result.error(`Unsupported value: "${ value }", choose one of "${ values.join(', ') }".`));
     const requiredOf = (key, schema) => field(key, key, required(), schema);
     const requiredString = key => requiredOf(key, string);
+    const requiredStringEnum = (key, values) => field(key, key, required(), validateEnum(values));
     const requiredFunction = key => requiredOf(key, functionProcessor);
     const requiredArrayOf = (key, schema) => field(key, key, required(), arrOf(schema));
     const optionOf = (key, schema) => field(key, key, asOption(), schema);
@@ -24173,12 +24392,14 @@
 
     const contextButtonFields = baseToolbarButtonFields.concat([
       defaultedType('contextformbutton'),
+      defaultedString('align', 'end'),
       primary,
       onAction,
       customField('original', identity)
     ]);
     const contextToggleButtonFields = baseToolbarToggleButtonFields.concat([
       defaultedType('contextformbutton'),
+      defaultedString('align', 'end'),
       primary,
       onAction,
       customField('original', identity)
@@ -24189,15 +24410,56 @@
       contextformbutton: contextButtonFields,
       contextformtogglebutton: contextToggleButtonFields
     });
-    objOf([
-      defaultedType('contextform'),
-      defaultedFunction('initValue', constant('')),
+    const baseContextFormFields = [
       optionalLabel,
       requiredArrayOf('commands', toggleOrNormal),
       optionOf('launch', choose('type', {
         contextformbutton: launchButtonFields,
         contextformtogglebutton: launchToggleButtonFields
+      })),
+      defaultedFunction('onInput', noop),
+      defaultedFunction('onSetup', noop)
+    ];
+    const contextFormFields = [
+      ...contextBarFields,
+      ...baseContextFormFields,
+      requiredStringEnum('type', ['contextform']),
+      defaultedFunction('initValue', constant('')),
+      optionString('placeholder')
+    ];
+    const contextSliderFormFields = [
+      ...contextBarFields,
+      ...baseContextFormFields,
+      requiredStringEnum('type', ['contextsliderform']),
+      defaultedFunction('initValue', constant(0)),
+      defaultedFunction('min', constant(0)),
+      defaultedFunction('max', constant(100))
+    ];
+    const contextSizeInputFormFields = [
+      ...contextBarFields,
+      ...baseContextFormFields,
+      requiredStringEnum('type', ['contextsizeinputform']),
+      defaultedFunction('initValue', constant({
+        width: '',
+        height: ''
       }))
+    ];
+    choose('type', {
+      contextform: contextFormFields,
+      contextsliderform: contextSliderFormFields,
+      contextsizeinputform: contextSizeInputFormFields
+    });
+
+    objOf([
+      defaultedType('contexttoolbar'),
+      requiredOf('items', oneOf([
+        string,
+        arrOfObj([
+          optionString('name'),
+          optionString('label'),
+          requiredArrayOf('items', string)
+        ])
+      ]))
     ].concat(contextBarFields));
 
     const register$2 = editor => {
@@ -25930,7 +26192,7 @@
         const editor = this.editor;
         const selection = editor.selection;
         let node;
-        if (editor.initialized && selection && !shouldDisableNodeChange(editor)) {
+        if (editor.initialized && selection && !shouldDisableNodeChange(editor) && !isDisabled$1(editor)) {
           const root = editor.getBody();
           node = selection.getStart(true) || root;
           if (node.ownerDocument !== editor.getDoc() || !editor.dom.isChildOf(node, root)) {
@@ -27761,7 +28023,7 @@
         const doc = editor.getDoc();
         const realSelectionContainer = descendant$1(body, '#' + realSelectionId).getOrThunk(() => {
           const newContainer = SugarElement.fromHtml('<div data-mce-bogus="all" class="mce-offscreen-selection"></div>', doc);
-          set$3(newContainer, 'id', realSelectionId);
+          set$4(newContainer, 'id', realSelectionId);
           append$1(body, newContainer);
           return newContainer;
         });
@@ -28864,7 +29126,7 @@
       const body = SugarElement.fromDom(editor.getBody());
       const container = getStyleContainer(getRootNode(body));
       const style = SugarElement.fromTag('style');
-      set$3(style, 'type', 'text/css');
+      set$4(style, 'type', 'text/css');
       append$1(style, SugarElement.fromText(text));
       append$1(container, style);
       editor.on('remove', () => {
@@ -29038,6 +29300,9 @@
         initInstanceCallback.call(editor, editor);
       }
       autoFocus(editor);
+      if (isDisabled(editor)) {
+        toggleDisabled(editor, true);
+      }
     };
     const getStyleSheetLoader$1 = editor => editor.inline ? editor.ui.styleSheetLoader : editor.dom.styleSheetLoader;
     const makeStylesheetLoadingPromises = (editor, css, framedFonts) => {
@@ -29165,7 +29430,7 @@
       body.disabled = true;
       editor.readonly = isReadOnly$1(editor);
       editor._editableRoot = hasEditableRoot$1(editor);
-      if (editor.hasEditableRoot()) {
+      if (!isDisabled$1(editor) && editor.hasEditableRoot()) {
         if (editor.inline && DOM$6.getStyle(body, 'position', true) === 'static') {
           body.style.position = 'relative';
         }
@@ -29242,7 +29507,7 @@
     const DOM$5 = DOMUtils.DOM;
     const createIframeElement = (id, title, customAttrs, tabindex) => {
       const iframe = SugarElement.fromTag('iframe');
-      tabindex.each(t => set$3(iframe, 'tabindex', t));
+      tabindex.each(t => set$4(iframe, 'tabindex', t));
       setAll$1(iframe, customAttrs);
       setAll$1(iframe, {
         id: id + '_ifr',
@@ -29424,7 +29689,7 @@
         hide: Optional.from(api.hide).getOr(noop),
         isEnabled: Optional.from(api.isEnabled).getOr(always),
         setEnabled: state => {
-          const shouldSkip = state && editor.mode.get() === 'readonly';
+          const shouldSkip = state && (editor.mode.get() === 'readonly' || isDisabled(editor));
           if (!shouldSkip) {
             Optional.from(api.setEnabled).each(f => f(state));
           }
@@ -29638,8 +29903,10 @@
     const setEditableRoot = (editor, state) => {
       if (editor._editableRoot !== state) {
         editor._editableRoot = state;
-        editor.getBody().contentEditable = String(editor.hasEditableRoot());
-        editor.nodeChanged();
+        if (!isDisabled(editor)) {
+          editor.getBody().contentEditable = String(editor.hasEditableRoot());
+          editor.nodeChanged();
+        }
         fireEditableRootStateChange(editor, state);
       }
     };
@@ -30327,120 +30594,6 @@
       }
     }
 
-    const toggleClass = (elm, cls, state) => {
-      if (has(elm, cls) && !state) {
-        remove$6(elm, cls);
-      } else if (state) {
-        add$2(elm, cls);
-      }
-    };
-    const setEditorCommandState = (editor, cmd, state) => {
-      try {
-        editor.getDoc().execCommand(cmd, false, String(state));
-      } catch (ex) {
-      }
-    };
-    const setContentEditable = (elm, state) => {
-      elm.dom.contentEditable = state ? 'true' : 'false';
-    };
-    const removeFakeSelection = editor => {
-      Optional.from(editor.selection.getNode()).each(elm => {
-        elm.removeAttribute('data-mce-selected');
-      });
-    };
-    const restoreFakeSelection = editor => {
-      editor.selection.setRng(editor.selection.getRng());
-    };
-    const setCommonEditorCommands = (editor, state) => {
-      setEditorCommandState(editor, 'StyleWithCSS', state);
-      setEditorCommandState(editor, 'enableInlineTableEditing', state);
-      setEditorCommandState(editor, 'enableObjectResizing', state);
-    };
-    const setEditorReadonly = editor => {
-      editor.readonly = true;
-      editor.selection.controlSelection.hideResizeRect();
-      editor._selectionOverrides.hideFakeCaret();
-      removeFakeSelection(editor);
-    };
-    const unsetEditorReadonly = (editor, body) => {
-      editor.readonly = false;
-      if (editor.hasEditableRoot()) {
-        setContentEditable(body, true);
-      }
-      setCommonEditorCommands(editor, false);
-      if (hasEditorOrUiFocus(editor)) {
-        editor.focus();
-      }
-      restoreFakeSelection(editor);
-      editor.nodeChanged();
-    };
-    const toggleReadOnly = (editor, state) => {
-      const body = SugarElement.fromDom(editor.getBody());
-      toggleClass(body, 'mce-content-readonly', state);
-      if (state) {
-        setEditorReadonly(editor);
-        if (editor.hasEditableRoot()) {
-          setContentEditable(body, true);
-        }
-      } else {
-        unsetEditorReadonly(editor, body);
-      }
-    };
-    const isReadOnly = editor => editor.readonly;
-    const isClickEvent = e => e.type === 'click';
-    const allowedEvents = ['copy'];
-    const isReadOnlyAllowedEvent = e => contains$2(allowedEvents, e.type);
-    const getAnchorHrefOpt = (editor, elm) => {
-      const isRoot = elm => eq(elm, SugarElement.fromDom(editor.getBody()));
-      return closest$3(elm, 'a', isRoot).bind(a => getOpt(a, 'href'));
-    };
-    const processReadonlyEvents = (editor, e) => {
-      if (isClickEvent(e) && !VK.metaKeyPressed(e)) {
-        const elm = SugarElement.fromDom(e.target);
-        getAnchorHrefOpt(editor, elm).each(href => {
-          e.preventDefault();
-          if (/^#/.test(href)) {
-            const targetEl = editor.dom.select(`${ href },[name="${ removeLeading(href, '#') }"]`);
-            if (targetEl.length) {
-              editor.selection.scrollIntoView(targetEl[0], true);
-            }
-          } else {
-            window.open(href, '_blank', 'rel=noopener noreferrer,menubar=yes,toolbar=yes,location=yes,status=yes,resizable=yes,scrollbars=yes');
-          }
-        });
-      } else if (isReadOnlyAllowedEvent(e)) {
-        editor.dispatch(e.type, e);
-      }
-    };
-    const registerReadOnlySelectionBlockers = editor => {
-      editor.on('beforeinput paste cut dragend dragover draggesture dragdrop drop drag', e => {
-        if (isReadOnly(editor)) {
-          e.preventDefault();
-        }
-      });
-      editor.on('BeforeExecCommand', e => {
-        if ((e.command === 'Undo' || e.command === 'Redo') && isReadOnly(editor)) {
-          e.preventDefault();
-        }
-      });
-      editor.on('input', e => {
-        if (!e.isComposing && isReadOnly(editor)) {
-          const undoLevel = editor.undoManager.add();
-          if (isNonNullable(undoLevel)) {
-            editor.undoManager.undo();
-          }
-        }
-      });
-      editor.on('compositionend', () => {
-        if (isReadOnly(editor)) {
-          const undoLevel = editor.undoManager.add();
-          if (isNonNullable(undoLevel)) {
-            editor.undoManager.undo();
-          }
-        }
-      });
-    };
-
     const nativeEvents = Tools.makeMap('focus blur focusin focusout click dblclick mousedown mouseup mousemove mouseover beforepaste paste cut copy selectionchange ' + 'mouseout mouseenter mouseleave wheel keydown keypress keyup input beforeinput contextmenu dragstart dragend dragover ' + 'draggesture dragdrop drop drag submit ' + 'compositionstart compositionend compositionupdate touchstart touchmove touchend touchcancel', ' ');
     class EventDispatcher {
       static isNative(name) {
@@ -30632,12 +30785,12 @@
       }
       return editor.getBody();
     };
-    const isListening = editor => !editor.hidden;
+    const isListening = editor => !editor.hidden && !isDisabled(editor);
     const fireEvent = (editor, eventName, e) => {
       if (isListening(editor)) {
         editor.dispatch(eventName, e);
-      } else if (isReadOnly(editor)) {
-        processReadonlyEvents(editor, e);
+      } else if (isDisabled(editor)) {
+        processDisabledEvents(editor, e);
       }
     };
     const bindEventDelegate = (editor, eventName) => {
@@ -30886,6 +31039,52 @@
       };
     };
 
+    const setContentEditable = (elm, state) => {
+      elm.dom.contentEditable = state ? 'true' : 'false';
+    };
+    const toggleReadOnly = (editor, state) => {
+      const body = SugarElement.fromDom(editor.getBody());
+      if (state) {
+        editor.readonly = true;
+        if (editor.hasEditableRoot()) {
+          setContentEditable(body, true);
+        }
+        disableEditor(editor);
+      } else {
+        editor.readonly = false;
+        enableEditor(editor);
+      }
+    };
+    const isReadOnly = editor => editor.readonly;
+    const registerReadOnlyInputBlockers = editor => {
+      editor.on('beforeinput paste cut dragend dragover draggesture dragdrop drop drag', e => {
+        if (isReadOnly(editor)) {
+          e.preventDefault();
+        }
+      });
+      editor.on('BeforeExecCommand', e => {
+        if ((e.command === 'Undo' || e.command === 'Redo') && isReadOnly(editor)) {
+          e.preventDefault();
+        }
+      });
+      editor.on('input', e => {
+        if (!e.isComposing && isReadOnly(editor)) {
+          const undoLevel = editor.undoManager.add();
+          if (isNonNullable(undoLevel)) {
+            editor.undoManager.undo();
+          }
+        }
+      });
+      editor.on('compositionend', () => {
+        if (isReadOnly(editor)) {
+          const undoLevel = editor.undoManager.add();
+          if (isNonNullable(undoLevel)) {
+            editor.undoManager.undo();
+          }
+        }
+      });
+    };
+
     const defaultModes = [
       'design',
       'readonly'
@@ -30907,7 +31106,7 @@
       fireSwitchMode(editor, mode);
     };
     const setMode = (editor, availableModes, activeMode, mode) => {
-      if (mode === activeMode.get()) {
+      if (mode === activeMode.get() || editor.initialized && isDisabled(editor)) {
         return;
       } else if (!has$2(availableModes, mode)) {
         throw new Error(`Editor mode '${ mode }' is invalid`);
@@ -30951,7 +31150,8 @@
           editorReadOnly: true
         }
       });
-      registerReadOnlySelectionBlockers(editor);
+      registerReadOnlyInputBlockers(editor);
+      registerEventsAndFilters$1(editor);
       return {
         isReadOnly: () => isReadOnly(editor),
         set: mode => setMode(editor, availableModes.get(), activeMode, mode),
@@ -31135,6 +31335,12 @@
           type
         };
       };
+      const addDefaulted = (collection, type) => (name, spec) => {
+        collection[name.toLowerCase()] = {
+          type,
+          ...spec
+        };
+      };
       const addIcon = (name, svgData) => icons[name.toLowerCase()] = svgData;
       const addContext = (name, pred) => contexts[name.toLowerCase()] = pred;
       return {
@@ -31149,7 +31355,7 @@
         addAutocompleter: add(popups, 'autocompleter'),
         addContextMenu: add(contextMenus, 'contextmenu'),
         addContextToolbar: add(contextToolbars, 'contexttoolbar'),
-        addContextForm: add(contextToolbars, 'contextform'),
+        addContextForm: addDefaulted(contextToolbars, 'contextform'),
         addSidebar: add(sidebars, 'sidebar'),
         addView: add(views, 'views'),
         addIcon,
@@ -31623,8 +31829,8 @@
       documentBaseURL: null,
       suffix: null,
       majorVersion: '7',
-      minorVersion: '5.1',
-      releaseDate: 'TBD',
+      minorVersion: '6.0',
+      releaseDate: '2024-12-11',
       i18n: I18n,
       activeEditor: null,
       focusedEditor: null,