WebSVN – Moodle – Diff – /lib/editor/tiny/js/tinymce/tinymce.js

 /**
- * TinyMCE version 6.8.3 (2024-02-08)
+ * TinyMCE version 7.7.1 (2025-03-05)
  */
 (function () {
       copy.sort(comparator);
       return copy;
     };
     const get$b = (xs, i) => i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
     const head = xs => get$b(xs, 0);
-    const last$3 = xs => get$b(xs, xs.length - 1);
+    const last$2 = xs => get$b(xs, xs.length - 1);
     const from = isFunction(Array.from) ? Array.from : x => nativeSlice.call(x);
     const findMap = (arr, f) => {
       for (let i = 0; i < arr.length; i++) {
         const r = f(arr[i], i);
         if (r.isSome()) {
           return i;
+        }
+      }
       return -1;
     };
-    const last$2 = collection => collection[collection.length - 1];
+    const last$1 = collection => collection[collection.length - 1];
     const cached = f => {
       let called = false;
       let r;
       const group = i => {
         return Number(agent.replace(r, '$' + i));
       };
       return nu$3(group(1), group(2));
     };
-    const detect$5 = (versionRegexes, agent) => {
+    const detect$4 = (versionRegexes, agent) => {
       const cleanedAgent = String(agent).toLowerCase();
       if (versionRegexes.length === 0) {
         return unknown$2();
+      }
       return find$1(versionRegexes, cleanedAgent);
         minor
       };
     };
     const Version = {
       nu: nu$3,
-      detect: detect$5,
+      detect: detect$4,
       unknown: unknown$2
     };
     const detectBrowser$1 = (browsers, userAgentData) => {
           version: Version.nu(parseInt(uaBrand.version, 10), 0)
         }));
       });
     };
-    const detect$4 = (candidates, userAgent) => {
+    const detect$3 = (candidates, userAgent) => {
       const agent = String(userAgent).toLowerCase();
       return find$2(candidates, candidate => {
         return candidate.search(agent);
       });
     };
     const detectBrowser = (browsers, userAgent) => {
-      return detect$4(browsers, userAgent).map(browser => {
+      return detect$3(browsers, userAgent).map(browser => {
         const version = Version.detect(browser.versionRegexes, userAgent);
         return {
           current: browser.name,
           version
         };
       });
     };
     const detectOs = (oses, userAgent) => {
-      return detect$4(oses, userAgent).map(os => {
+      return detect$3(oses, userAgent).map(os => {
         const version = Version.detect(os.versionRegexes, userAgent);
         return {
           current: os.name,
           version
       solaris: constant(solaris),
       freebsd: constant(freebsd),
       chromeos: constant(chromeos)
     };
-    const detect$3 = (userAgent, userAgentDataOpt, mediaMatch) => {
+    const detect$2 = (userAgent, userAgentDataOpt, mediaMatch) => {
       const browsers = PlatformInfo.browsers();
       const oses = PlatformInfo.oses();
       const browser = userAgentDataOpt.bind(userAgentData => detectBrowser$1(browsers, userAgentData)).orThunk(() => detectBrowser(browsers, userAgent)).fold(Browser.unknown, Browser.nu);
       const os = detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
         browser,
         os,
         deviceType
       };
     };
-    const PlatformDetection = { detect: detect$3 };
+    const PlatformDetection = { detect: detect$2 };
     const mediaMatch = query => window.matchMedia(query).matches;
-    let platform$4 = cached(() => PlatformDetection.detect(navigator.userAgent, Optional.from(navigator.userAgentData), mediaMatch));
+    let platform$4 = cached(() => PlatformDetection.detect(window.navigator.userAgent, Optional.from(window.navigator.userAgentData), mediaMatch));
-    const detect$2 = () => platform$4();
+    const detect$1 = () => platform$4();
-    const userAgent = navigator.userAgent;
+    const userAgent = window.navigator.userAgent;
-    const platform$3 = detect$2();
+    const platform$3 = detect$1();
     const browser$3 = platform$3.browser;
     const os$1 = platform$3.os;
     const deviceType = platform$3.deviceType;
     const type$1 = element => element.dom.nodeType;
     const isType = t => element => type$1(element) === t;
     const isComment$1 = element => type$1(element) === COMMENT || name(element) === '#comment';
     const isHTMLElement$1 = element => isElement$7(element) && isPrototypeOf(element.dom);
     const isElement$7 = isType(ELEMENT);
-    const isText$b = isType(TEXT);
+    const isText$c = isType(TEXT);
     const isDocument$2 = isType(DOCUMENT);
     const isDocumentFragment$1 = isType(DOCUMENT_FRAGMENT);
     const isTag = tag => e => isElement$7(e) && name(e) === tag;
       } else {
         console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);
         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) => {
       const dom = element.dom;
       each$d(attrs, (v, k) => {
     const getOpt = (element, key) => Optional.from(get$9(element, key));
     const has$1 = (element, key) => {
       const dom = element.dom;
       return dom && dom.hasAttribute ? dom.hasAttribute(key) : false;
     };
-    const remove$a = (element, key) => {
+    const remove$9 = (element, key) => {
       element.dom.removeAttribute(key);
     };
     const hasNone = element => {
       const attrs = element.dom.attributes;
       return attrs === undefined || attrs === null || attrs.length === 0;
       return value === undefined || value === '' ? [] : value.split(' ');
     };
     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$9 = (element, attr, id) => {
+    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$a(element, attr);
+        remove$9(element, attr);
+      }
       return false;
     };
     const supports = element => element.dom.classList !== undefined;
     const get$8 = element => read$4(element, 'class');
     const add$3 = (element, clazz) => add$4(element, 'class', clazz);
-    const remove$8 = (element, clazz) => remove$9(element, 'class', clazz);
+    const remove$7 = (element, clazz) => remove$8(element, 'class', clazz);
     const toggle$2 = (element, clazz) => {
       if (contains$2(get$8(element), clazz)) {
-        return remove$8(element, clazz);
+        return remove$7(element, clazz);
       } else {
         return add$3(element, clazz);
+      }
+      }
     };
     const cleanClass = element => {
       const classList = supports(element) ? element.dom.classList : get$8(element);
       if (classList.length === 0) {
-        remove$a(element, 'class');
+        remove$9(element, 'class');
+      }
     };
-    const remove$7 = (element, clazz) => {
+    const remove$6 = (element, clazz) => {
       if (supports(element)) {
         const classList = element.dom.classList;
         classList.remove(clazz);
       } else {
-        remove$8(element, clazz);
+        remove$7(element, clazz);
+      }
       cleanClass(element);
     };
     const toggle$1 = (element, clazz) => {
       const result = supports(element) ? element.dom.classList.toggle(clazz) : toggle$2(element, clazz);
       return Optional.from(cs[index]).map(SugarElement.fromDom);
     };
     const firstChild = element => child$1(element, 0);
     const lastChild = element => child$1(element, element.dom.childNodes.length - 1);
     const childNodesCount = element => element.dom.childNodes.length;
-    const hasChildNodes = element => element.dom.hasChildNodes();
     const getHead = doc => {
       const b = doc.dom.head;
       if (b === null || b === undefined) {
         throw new Error('Head is not available yet');
+      }
       return SugarElement.fromDom(b);
     };
-    const isShadowRoot = dos => isDocumentFragment$1(dos) && isNonNullable(dos.dom.host);
-    const supported = isFunction(Element.prototype.attachShadow) && isFunction(Node.prototype.getRootNode);
-    const isSupported$1 = constant(supported);
+    const isShadowRoot = dos => isDocumentFragment$1(dos) && isNonNullable(dos.dom.host);
-    const getRootNode = supported ? e => SugarElement.fromDom(e.dom.getRootNode()) : documentOrOwner;
+    const getRootNode = e => SugarElement.fromDom(e.dom.getRootNode());
     const getStyleContainer = dos => isShadowRoot(dos) ? dos : getHead(documentOrOwner(dos));
     const getContentContainer = dos => isShadowRoot(dos) ? dos : SugarElement.fromDom(documentOrOwner(dos).dom.body);
     const getShadowRoot = e => {
       const r = getRootNode(e);
       return isShadowRoot(r) ? Optional.some(r) : Optional.none();
     };
     const getShadowHost = e => SugarElement.fromDom(e.dom.host);
     const getOriginalEventTarget = event => {
-      if (isSupported$1() && isNonNullable(event.target)) {
+      if (isNonNullable(event.target)) {
         const el = SugarElement.fromDom(event.target);
         if (isElement$7(el) && isOpenShadowHost(el)) {
           if (event.composed && event.composedPath) {
       return Optional.from(event.target);
     };
     const isOpenShadowHost = element => isNonNullable(element.dom.shadowRoot);
     const inBody = element => {
-      const dom = isText$b(element) ? element.dom.parentNode : element.dom;
+      const dom = isText$c(element) ? element.dom.parentNode : element.dom;
       if (dom === undefined || dom === null || dom.ownerDocument === null) {
         return false;
+      }
       const doc = dom.ownerDocument;
       } else {
         return closest$2(element).fold(constant(assumeEditable), editable => getRaw$1(editable) === 'true');
+      }
     };
     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);
           css[ruleName] = dom.style[ruleName];
+        }
+      }
       return css;
     };
-    const remove$6 = (element, property) => {
+    const remove$5 = (element, property) => {
       const dom = element.dom;
       internalRemove(dom, property);
       if (is$2(getOpt(element, 'style').map(trim$4), '')) {
-        remove$a(element, 'style');
+        remove$9(element, 'style');
+      }
     };
     const reflow = e => e.dom.offsetWidth;
     };
     const empty = element => {
       element.dom.textContent = '';
       each$e(children$1(element), rogue => {
-        remove$5(rogue);
+        remove$4(rogue);
       });
     };
-    const remove$5 = element => {
+    const remove$4 = element => {
       const dom = element.dom;
       if (dom.parentNode !== null) {
         dom.parentNode.removeChild(dom);
+      }
     };
     const unwrap = wrapper => {
       const children = children$1(wrapper);
       if (children.length > 0) {
         after$3(wrapper, children);
       }
-      remove$5(wrapper);
+      remove$4(wrapper);
     };
     const fromHtml = (html, scope) => {
       if (win) {
         win.scrollTo(x, y);
+      }
     };
     const intoView = (element, alignToTop) => {
-      const isSafari = detect$2().browser.isSafari();
+      const isSafari = detect$1().browser.isSafari();
       if (isSafari && isFunction(element.dom.scrollIntoViewIfNeeded)) {
         element.dom.scrollIntoViewIfNeeded(false);
       } else {
         element.dom.scrollIntoView(alignToTop);
+      }
     };
     const get$4 = _win => {
       const win = _win === undefined ? window : _win;
-      if (detect$2().browser.isFirefox()) {
+      if (detect$1().browser.isFirefox()) {
         return Optional.none();
       } else {
         return Optional.from(win.visualViewport);
+      }
       return result;
     };
     const descendants = (scope, selector) => all(selector, scope);
+    const ancestor$2 = (scope, predicate, isRoot) => ancestor$4(scope, predicate, isRoot).isSome();
     const sibling = (scope, predicate) => sibling$1(scope, predicate).isSome();
-    const ancestor$2 = (scope, selector, isRoot) => ancestor$3(scope, selector, isRoot).isSome();
+    const descendant = (scope, predicate) => descendant$2(scope, predicate).isSome();
     class DomTreeWalker {
+        }
         return undefined;
+      }
+    }
+    const zeroWidth = '\uFEFF';
+    const nbsp = '\xA0';
+    const isZwsp$2 = char => char === zeroWidth;
+    const removeZwsp = s => s.replace(/\uFEFF/g, '');
+    const whiteSpaceRegExp = /^[ \t\r\n]*$/;
+    const isWhitespaceText = text => whiteSpaceRegExp.test(text);
+    const isZwsp$1 = text => {
+      for (const c of text) {
+        if (!isZwsp$2(c)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    const isCollapsibleWhitespace$1 = c => ' \f\t\x0B'.indexOf(c) !== -1;
+    const isNewLineChar = c => c === '\n' || c === '\r';
+    const isNewline = (text, idx) => idx < text.length && idx >= 0 ? isNewLineChar(text[idx]) : false;
+    const normalize$4 = (text, tabSpaces = 4, isStartOfContent = true, isEndOfContent = true) => {
+      const tabSpace = repeat(' ', tabSpaces);
+      const normalizedText = text.replace(/\t/g, tabSpace);
+      const result = foldl(normalizedText, (acc, c) => {
+        if (isCollapsibleWhitespace$1(c) || c === nbsp) {
+          if (acc.pcIsSpace || acc.str === '' && isStartOfContent || acc.str.length === normalizedText.length - 1 && isEndOfContent || isNewline(normalizedText, acc.str.length + 1)) {
+            return {
+              pcIsSpace: false,
+              str: acc.str + nbsp
+            };
+          } else {
+            return {
+              pcIsSpace: true,
+              str: acc.str + ' '
+            };
+          }
+        } else {
+          return {
+            pcIsSpace: isNewLineChar(c),
+            str: acc.str + c
+          };
+        }
+      }, {
+        pcIsSpace: false,
+        str: ''
+      });
+      return result.str;
+    };
     const isNodeType = type => {
       return node => {
         return !!node && node.nodeType === type;
       };
     const hasAttribute = attrName => {
       return node => {
         return isElement$6(node) && node.hasAttribute(attrName);
       };
     };
-    const hasAttributeValue = (attrName, attrValue) => {
-      return node => {
-        return isElement$6(node) && node.getAttribute(attrName) === attrValue;
-      };
-    };
-    const isBogus$2 = node => isElement$6(node) && node.hasAttribute('data-mce-bogus');
+    const isBogus$1 = node => isElement$6(node) && node.hasAttribute('data-mce-bogus');
-    const isBogusAll$1 = node => isElement$6(node) && node.getAttribute('data-mce-bogus') === 'all';
+    const isBogusAll = node => isElement$6(node) && node.getAttribute('data-mce-bogus') === 'all';
     const isTable$2 = node => isElement$6(node) && node.tagName === 'TABLE';
     const hasContentEditableState = value => {
       return node => {
         if (isHTMLElement(node)) {
           if (node.contentEditable === value) {
     };
     const isTextareaOrInput = matchNodeNames([
       'textarea',
       'input'
     ]);
-    const isText$a = isNodeType(3);
+    const isText$b = isNodeType(3);
     const isCData = isNodeType(4);
     const isPi = isNodeType(7);
     const isComment = isNodeType(8);
     const isDocument$1 = isNodeType(9);
     const isDocumentFragment = isNodeType(11);
     const isBr$6 = matchNodeName('br');
     const isImg = matchNodeName('img');
     const isContentEditableTrue$3 = hasContentEditableState('true');
     const isContentEditableFalse$b = hasContentEditableState('false');
+    const isEditingHost = node => isHTMLElement(node) && node.isContentEditable && isNonNullable(node.parentElement) && !node.parentElement.isContentEditable;
     const isTableCell$3 = matchNodeNames([
       'td',
       'th'
     ]);
     const isTableCellOrCaption = matchNodeNames([
     ]);
     const isListItem$2 = matchNodeName('li');
     const isDetails = matchNodeName('details');
     const isSummary$1 = matchNodeName('summary');
-    const zeroWidth = '\uFEFF';
-    const nbsp = '\xA0';
-    const isZwsp$2 = char => char === zeroWidth;
-    const removeZwsp = s => s.replace(/\uFEFF/g, '');
-    const NodeValue = (is, name) => {
-      const get = element => {
+    const defaultOptionValues = {
-        if (!is(element)) {
-          throw new Error('Can only get ' + name + ' value of a ' + name + ' node');
-        }
-        return getOption(element).getOr('');
-      };
-      const getOption = element => is(element) ? Optional.from(element.dom.nodeValue) : Optional.none();
-      const set = (element, value) => {
+      skipBogus: true,
-        if (!is(element)) {
-          throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node');
-        }
+      includeZwsp: false,
-        element.dom.nodeValue = value;
-      };
-      return {
-        get,
-        getOption,
-        set
-      };
+      checkRootAsContent: false
-    };
-    const api$1 = NodeValue(isText$b, 'text');
-    const get$3 = element => api$1.get(element);
-    const getOption = element => api$1.getOption(element);
-    const set = (element, value) => api$1.set(element, value);
-    const tableCells = [
-      'td',
-      'th'
-    ];
-    const tableSections = [
-      'thead',
-      'tbody',
-      'tfoot'
-    ];
-    const textBlocks = [
-      'h1',
-      'h2',
-      'h3',
-      'h4',
-      'h5',
-      'h6',
-      'p',
-      'div',
-      'address',
-      'pre',
-      'form',
-      'blockquote',
-      'center',
-      'dir',
-      'fieldset',
-      'header',
-      'footer',
-      'article',
-      'section',
-      'hgroup',
-      'aside',
-      'nav',
-      'figure'
-    ];
-    const listItems$1 = [
-      'li',
-      'dd',
-      'dt'
-    ];
-    const lists = [
-      'ul',
-      'ol',
-      'dl'
-    ];
-    const wsElements = [
-      'pre',
-      'script',
-      'textarea',
-      'style'
-    ];
-    const lazyLookup = items => {
-      let lookup;
-      return node => {
-        lookup = lookup ? lookup : mapToObject(items, always);
-        return has$2(lookup, name(node));
-      };
-    };
-    const isTable$1 = node => name(node) === 'table';
-    const isBr$5 = node => isElement$7(node) && name(node) === 'br';
-    const isTextBlock$2 = lazyLookup(textBlocks);
-    const isList = lazyLookup(lists);
-    const isListItem$1 = lazyLookup(listItems$1);
-    const isTableSection = lazyLookup(tableSections);
-    const isTableCell$2 = lazyLookup(tableCells);
+    };
-    const isWsPreserveElement = lazyLookup(wsElements);
-    const getLastChildren$1 = elm => {
-      const children = [];
-      let rawNode = elm.dom;
-      while (rawNode) {
+    const hasWhitespacePreserveParent = (node, rootNode, schema) => {
-        children.push(SugarElement.fromDom(rawNode));
-        rawNode = rawNode.lastChild;
-      }
-      return children;
-    };
-    const removeTrailingBr = elm => {
+      const rootElement = SugarElement.fromDom(rootNode);
-      const allBrs = descendants(elm, 'br');
+      const startNode = SugarElement.fromDom(node);
-      const brs = filter$5(getLastChildren$1(elm).slice(-1), isBr$5);
-      if (allBrs.length === brs.length) {
-        each$e(brs, remove$5);
-      }
-    };
-    const createPaddingBr = () => {
+      const whitespaceElements = schema.getWhitespaceElements();
-      const br = SugarElement.fromTag('br');
+      const predicate = node => has$2(whitespaceElements, name(node));
-      set$3(br, 'data-mce-bogus', '1');
-      return br;
+      return ancestor$2(startNode, predicate, curry(eq, rootElement));
     };
-    const fillWithPaddingBr = elm => {
-      empty(elm);
+    const isNamedAnchor = node => {
-      append$1(elm, createPaddingBr());
+      return isElement$6(node) && node.nodeName === 'A' && !node.hasAttribute('href') && (node.hasAttribute('name') || node.hasAttribute('id'));
     };
-    const trimBlockTrailingBr = (elm, schema) => {
-      lastChild(elm).each(lastChild => {
-        prevSibling(lastChild).each(lastChildPrevSibling => {
+    const isNonEmptyElement$1 = (node, schema) => {
-          if (schema.isBlock(name(elm)) && isBr$5(lastChild) && schema.isBlock(name(lastChildPrevSibling))) {
-            remove$5(lastChild);
-          }
-        });
-      });
+      return isElement$6(node) && has$2(schema.getNonEmptyElements(), node.nodeName);
-    };
-    const ZWSP$1 = zeroWidth;
-    const isZwsp$1 = isZwsp$2;
-    const trim$2 = removeZwsp;
-    const insert$5 = editor => editor.insertContent(ZWSP$1, { preserve_zwsp: true });
-    const isElement$5 = isElement$6;
-    const isText$9 = isText$a;
-    const isCaretContainerBlock$1 = node => {
-      if (isText$9(node)) {
-        node = node.parentNode;
-      }
+    };
-      return isElement$5(node) && node.hasAttribute('data-mce-caret');
-    };
+    const isBookmark = hasAttribute('data-mce-bookmark');
-    const isCaretContainerInline = node => isText$9(node) && isZwsp$1(node.data);
+    const hasNonEditableParent = node => parentElement(SugarElement.fromDom(node)).exists(parent => !isEditable$2(parent));
-    const isCaretContainer$2 = node => isCaretContainerBlock$1(node) || isCaretContainerInline(node);
+    const isWhitespace$1 = (node, rootNode, schema) => isWhitespaceText(node.data) && !hasWhitespacePreserveParent(node, rootNode, schema);
-    const hasContent = node => node.firstChild !== node.lastChild || !isBr$6(node.firstChild);
+    const isText$a = (node, rootNode, schema, options) => isText$b(node) && !isWhitespace$1(node, rootNode, schema) && (!options.includeZwsp || !isZwsp$1(node.data));
-    const insertInline$1 = (node, before) => {
-      var _a;
-      const doc = (_a = node.ownerDocument) !== null && _a !== void 0 ? _a : document;
+    const isContentNode = (schema, node, rootNode, options) => {
-      const textNode = doc.createTextNode(ZWSP$1);
-      const parentNode = node.parentNode;
-      if (!before) {
-        const sibling = node.nextSibling;
-        if (isText$9(sibling)) {
-          if (isCaretContainer$2(sibling)) {
-            return sibling;
+      return isFunction(options.isContent) && options.isContent(node) || isNonEmptyElement$1(node, schema) || isBookmark(node) || isNamedAnchor(node) || isText$a(node, rootNode, schema, options) || isContentEditableFalse$b(node) || isContentEditableTrue$3(node) && hasNonEditableParent(node);
-          }
+    };
-          if (startsWithCaretContainer$1(sibling)) {
-            sibling.splitText(1);
+    const isEmptyNode = (schema, targetNode, opts) => {
-            return sibling;
-          }
-        }
+      const options = {
-        if (node.nextSibling) {
-          parentNode === null || parentNode === void 0 ? void 0 : parentNode.insertBefore(textNode, node.nextSibling);
+        ...defaultOptionValues,
-        } else {
-          parentNode === null || parentNode === void 0 ? void 0 : parentNode.appendChild(textNode);
+        ...opts
-        }
-      } else {
-        const sibling = node.previousSibling;
+      };
-        if (isText$9(sibling)) {
+      if (options.checkRootAsContent) {
-          if (isCaretContainer$2(sibling)) {
+        if (isContentNode(schema, targetNode, targetNode, options)) {
-            return sibling;
-          }
-          if (endsWithCaretContainer$1(sibling)) {
-            return sibling.splitText(sibling.data.length - 1);
           return false;
-        }
         parentNode === null || parentNode === void 0 ? void 0 : parentNode.insertBefore(textNode, node);
-      }
-      return textNode;
-    };
-    const isBeforeInline = pos => {
+      }
-      const container = pos.container();
-      if (!isText$a(container)) {
+      let node = targetNode.firstChild;
-        return false;
-      }
-      return container.data.charAt(pos.offset()) === ZWSP$1 || pos.isAtStart() && isCaretContainerInline(container.previousSibling);
-    };
-    const isAfterInline = pos => {
-      const container = pos.container();
+      let brCount = 0;
-      if (!isText$a(container)) {
+      if (!node) {
-        return false;
+        return true;
-      }
-      return container.data.charAt(pos.offset() - 1) === ZWSP$1 || pos.isAtEnd() && isCaretContainerInline(container.nextSibling);
-    };
+      }
-    const insertBlock = (blockName, node, before) => {
+      const walker = new DomTreeWalker(node, targetNode);
-      var _a;
-      const doc = (_a = node.ownerDocument) !== null && _a !== void 0 ? _a : document;
+      do {
-      const blockNode = doc.createElement(blockName);
-      blockNode.setAttribute('data-mce-caret', before ? 'before' : 'after');
+        if (options.skipBogus && isElement$6(node)) {
-      blockNode.setAttribute('data-mce-bogus', 'all');
+          const bogusValue = node.getAttribute('data-mce-bogus');
-      blockNode.appendChild(createPaddingBr().dom);
+          if (bogusValue) {
-      const parentNode = node.parentNode;
-      if (!before) {
+            node = walker.next(bogusValue === 'all');
-        if (node.nextSibling) {
-          parentNode === null || parentNode === void 0 ? void 0 : parentNode.insertBefore(blockNode, node.nextSibling);
+            continue;
-        } else {
           parentNode === null || parentNode === void 0 ? void 0 : parentNode.appendChild(blockNode);
-        }
-      } else {
-        parentNode === null || parentNode === void 0 ? void 0 : parentNode.insertBefore(blockNode, node);
-      }
-      return blockNode;
-    };
-    const startsWithCaretContainer$1 = node => isText$9(node) && node.data[0] === ZWSP$1;
-    const endsWithCaretContainer$1 = node => isText$9(node) && node.data[node.data.length - 1] === ZWSP$1;
-    const trimBogusBr = elm => {
-      var _a;
-      const brs = elm.getElementsByTagName('br');
-      const lastBr = brs[brs.length - 1];
-      if (isBogus$2(lastBr)) {
-        (_a = lastBr.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(lastBr);
-      }
-    };
-    const showCaretContainerBlock = caretContainer => {
-      if (caretContainer && caretContainer.hasAttribute('data-mce-caret')) {
-        trimBogusBr(caretContainer);
-        caretContainer.removeAttribute('data-mce-caret');
-        caretContainer.removeAttribute('data-mce-bogus');
-        caretContainer.removeAttribute('style');
-        caretContainer.removeAttribute('data-mce-style');
-        caretContainer.removeAttribute('_moz_abspos');
-        return caretContainer;
-      }
-      return null;
-    };
-    const isRangeInCaretContainerBlock = range => isCaretContainerBlock$1(range.startContainer);
-    const isContentEditableTrue$2 = isContentEditableTrue$3;
-    const isContentEditableFalse$a = isContentEditableFalse$b;
-    const isBr$4 = isBr$6;
-    const isText$8 = isText$a;
-    const isInvalidTextElement = matchNodeNames([
-      'script',
-      'style',
-      'textarea'
-    ]);
-    const isAtomicInline = matchNodeNames([
-      'img',
-      'input',
-      'textarea',
-      'hr',
-      'iframe',
-      'video',
-      'audio',
-      'object',
-      'embed'
-    ]);
-    const isTable = matchNodeNames(['table']);
-    const isCaretContainer$1 = isCaretContainer$2;
-    const isCaretCandidate$3 = node => {
-      if (isCaretContainer$1(node)) {
-        return false;
-      }
+        }
-      if (isText$8(node)) {
-        return !isInvalidTextElement(node.parentNode);
-      }
-      return isAtomicInline(node) || isBr$4(node) || isTable(node) || isNonUiContentEditableFalse(node);
-    };
-    const isUnselectable = node => isElement$6(node) && node.getAttribute('unselectable') === 'true';
-    const isNonUiContentEditableFalse = node => !isUnselectable(node) && isContentEditableFalse$a(node);
+        if (isComment(node)) {
-    const isInEditable = (node, root) => {
-      for (let tempNode = node.parentNode; tempNode && tempNode !== root; tempNode = tempNode.parentNode) {
-        if (isNonUiContentEditableFalse(tempNode)) {
+          node = walker.next(true);
-          return false;
+          continue;
         }
-        if (isContentEditableTrue$2(tempNode)) {
+        if (isBr$6(node)) {
+          brCount++;
+          node = walker.next();
-          return true;
+          continue;
-        }
-      }
-      return true;
-    };
-    const isAtomicContentEditableFalse = node => {
+        }
-      if (!isNonUiContentEditableFalse(node)) {
-        return false;
-      }
-      return !foldl(from(node.getElementsByTagName('*')), (result, elm) => {
-        return result || isContentEditableTrue$2(elm);
-      }, false);
-    };
-    const isAtomic$1 = node => isAtomicInline(node) || isAtomicContentEditableFalse(node);
-    const isEditableCaretCandidate$1 = (node, root) => isCaretCandidate$3(node) && isInEditable(node, root);
-    const whiteSpaceRegExp = /^[ \t\r\n]*$/;
-    const isWhitespaceText = text => whiteSpaceRegExp.test(text);
-    const isZwsp = text => {
-      for (const c of text) {
-        if (!isZwsp$2(c)) {
+        if (isContentNode(schema, node, targetNode, options)) {
           return false;
+        }
+        node = walker.next();
+      } while (node);
-        }
+      return brCount <= 1;
+    };
+    const isEmpty$2 = (schema, elm, options) => {
+      return isEmptyNode(schema, elm.dom, {
-      }
+        checkRootAsContent: true,
+        ...options
-      return true;
+      });
-    };
-    const isCollapsibleWhitespace$1 = c => ' \f\t\x0B'.indexOf(c) !== -1;
+    };
-    const isNewLineChar = c => c === '\n' || c === '\r';
-    const isNewline = (text, idx) => idx < text.length && idx >= 0 ? isNewLineChar(text[idx]) : false;
-    const normalize$4 = (text, tabSpaces = 4, isStartOfContent = true, isEndOfContent = true) => {
-      const tabSpace = repeat(' ', tabSpaces);
-      const normalizedText = text.replace(/\t/g, tabSpace);
+    const isContent$1 = (schema, node, options) => {
-      const result = foldl(normalizedText, (acc, c) => {
+      return isContentNode(schema, node, node, {
-        if (isCollapsibleWhitespace$1(c) || c === nbsp) {
-          if (acc.pcIsSpace || acc.str === '' && isStartOfContent || acc.str.length === normalizedText.length - 1 && isEndOfContent || isNewline(normalizedText, acc.str.length + 1)) {
-            return {
-              pcIsSpace: false,
-              str: acc.str + nbsp
-            };
-          } else {
-            return {
-              pcIsSpace: true,
-              str: acc.str + ' '
-            };
-          }
-        } else {
+        includeZwsp: defaultOptionValues.includeZwsp,
-          return {
-            pcIsSpace: isNewLineChar(c),
-            str: acc.str + c
-          };
-        }
-      }, {
-        pcIsSpace: false,
-        str: ''
+        ...options
-      });
-      return result.str;
+      });
     };
-    const hasWhitespacePreserveParent = (node, rootNode) => {
+    const Cell = initial => {
-      const rootElement = SugarElement.fromDom(rootNode);
+      let value = initial;
+      const get = () => {
+        return value;
+      };
+      const set = v => {
+        value = v;
+      };
+      return {
+        get,
-      const startNode = SugarElement.fromDom(node);
+        set
+      };
-      return ancestor$2(startNode, 'pre,code', curry(eq, rootElement));
+    };
-    };
+    const singleton = doRevoke => {
+      const subject = Cell(Optional.none());
+      const revoke = () => subject.get().each(doRevoke);
+      const clear = () => {
+        revoke();
+        subject.set(Optional.none());
+      };
+      const isSet = () => subject.get().isSome();
+      const get = () => subject.get();
+      const set = s => {
+        revoke();
+        subject.set(Optional.some(s));
+      };
+      return {
+        clear,
+        isSet,
+        get,
-    const isWhitespace$1 = (node, rootNode) => {
+        set
-      return isText$a(node) && isWhitespaceText(node.data) && !hasWhitespacePreserveParent(node, rootNode);
+      };
+    };
-    };
+    const repeatable = delay => {
+      const intervalId = Cell(Optional.none());
+      const revoke = () => intervalId.get().each(id => clearInterval(id));
+      const clear = () => {
+        revoke();
+        intervalId.set(Optional.none());
+      };
+      const isSet = () => intervalId.get().isSome();
+      const get = () => intervalId.get();
+      const set = functionToRepeat => {
+        revoke();
+        intervalId.set(Optional.some(setInterval(functionToRepeat, delay)));
+      };
+      return {
+        clear,
+        isSet,
+        get,
-    const isNamedAnchor = node => {
+        set
-      return isElement$6(node) && node.nodeName === 'A' && !node.hasAttribute('href') && (node.hasAttribute('name') || node.hasAttribute('id'));
+      };
+    };
-    };
+    const value$2 = () => {
+      const subject = singleton(noop);
+      const on = f => subject.get().each(f);
+      return {
+        ...subject,
-    const isContent$1 = (node, rootNode) => {
+        on
+      };
-      return isCaretCandidate$3(node) && !isWhitespace$1(node, rootNode) || isNamedAnchor(node) || isBookmark(node);
+    };
-    };
-    const isBookmark = hasAttribute('data-mce-bookmark');
-    const isBogus$1 = hasAttribute('data-mce-bogus');
-    const isBogusAll = hasAttributeValue('data-mce-bogus', 'all');
+    const nodeNameToNamespaceType = name => {
-    const hasNonEditableParent = node => parentElement(SugarElement.fromDom(node)).exists(parent => !isEditable$2(parent));
+      const lowerCaseName = name.toLowerCase();
-    const isEmptyNode = (targetNode, skipBogus) => {
+      if (lowerCaseName === 'svg') {
-      let brCount = 0;
+        return 'svg';
-      if (isContent$1(targetNode, targetNode)) {
+      } else if (lowerCaseName === 'math') {
-        return false;
-      } else {
-        let node = targetNode.firstChild;
+        return 'math';
-        if (!node) {
-          return true;
-        }
-        const walker = new DomTreeWalker(node, targetNode);
-        do {
-          if (skipBogus) {
-            if (isBogusAll(node)) {
-              node = walker.next(true);
-              continue;
-            }
-            if (isBogus$1(node)) {
-              node = walker.next();
-              continue;
-            }
-          }
-          if (isContentEditableTrue$3(node) && hasNonEditableParent(node)) {
-            return false;
-          }
-          if (isBr$6(node)) {
-            brCount++;
-            node = walker.next();
-            continue;
-          }
-          if (isContent$1(node, targetNode)) {
-            return false;
-          }
-          node = walker.next();
-        } while (node);
+      } else {
-        return brCount <= 1;
+        return 'html';
-      }
-    };
-    const isEmpty$2 = (elm, skipBogus = true) => isEmptyNode(elm.dom, skipBogus);
+      }
     };
-    const isNonHtmlElementRootName = name => name.toLowerCase() === 'svg';
+    const isNonHtmlElementRootName = name => nodeNameToNamespaceType(name) !== 'html';
     const isNonHtmlElementRoot = node => isNonHtmlElementRootName(node.nodeName);
+    const toScopeType = node => nodeNameToNamespaceType(node.nodeName);
+    const namespaceElements = [
+      'svg',
-    const toScopeType = node => (node === null || node === void 0 ? void 0 : node.nodeName) === 'svg' ? 'svg' : 'html';
+      'math'
-    const namespaceElements = ['svg'];
+    ];
     const createNamespaceTracker = () => {
-      let scopes = [];
+      const currentScope = value$2();
-      const peek = () => scopes[scopes.length - 1];
+      const current = () => currentScope.get().map(toScopeType).getOr('html');
       const track = node => {
+        if (isNonHtmlElementRoot(node)) {
+          currentScope.set(node);
-        if (isNonHtmlElementRoot(node)) {
+        } else if (currentScope.get().exists(scopeNode => !scopeNode.contains(node))) {
-          scopes.push(node);
-        }
-        let currentScope = peek();
-        if (currentScope && !currentScope.contains(node)) {
-          scopes.pop();
-          currentScope = peek();
+          currentScope.clear();
+        }
-        return toScopeType(currentScope);
-      };
+        return current();
-      const current = () => toScopeType(peek());
+      };
       const reset = () => {
-        scopes = [];
+        currentScope.clear();
       };
       return {
         track,
     };
     const transparentBlockAttr = 'data-mce-block';
     const elementNames = map => filter$5(keys(map), key => !/[A-Z]/.test(key));
+    const makeSelectorFromSchemaMap = map => map$3(elementNames(map), name => {
-    const makeSelectorFromSchemaMap = map => map$3(elementNames(map), name => {
+      const escapedName = CSS.escape(name);
-      return `${ name }:` + map$3(namespaceElements, ns => `not(${ ns } ${ name })`).join(':');
+      return `${ escapedName }:` + map$3(namespaceElements, ns => `not(${ ns } ${ escapedName })`).join(':');
     }).join(',');
     const updateTransparent = (blocksSelector, transparent) => {
       if (isNonNullable(transparent.querySelector(blocksSelector))) {
         transparent.setAttribute(transparentBlockAttr, 'true');
     const updateBlockStateOnChildren = (schema, scope) => {
       const transparentSelector = makeSelectorFromSchemaMap(schema.getTransparentElements());
       const blocksSelector = makeSelectorFromSchemaMap(schema.getBlockElements());
       return filter$5(scope.querySelectorAll(transparentSelector), transparent => updateTransparent(blocksSelector, transparent));
     };
-    const trimEdge = (el, leftSide) => {
+    const trimEdge = (schema, el, leftSide) => {
       var _a;
       const childPropertyName = leftSide ? 'lastChild' : 'firstChild';
       for (let child = el[childPropertyName]; child; child = child[childPropertyName]) {
-        if (isEmpty$2(SugarElement.fromDom(child))) {
+        if (isEmptyNode(schema, child, { checkRootAsContent: true })) {
           (_a = child.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(child);
           return;
+        }
+      }
     };
-    const split$2 = (parentElm, splitElm) => {
+    const split$2 = (schema, parentElm, splitElm) => {
       const range = document.createRange();
       const parentNode = parentElm.parentNode;
       if (parentNode) {
         range.setStartBefore(parentElm);
         range.setEndBefore(splitElm);
         const beforeFragment = range.extractContents();
-        trimEdge(beforeFragment, true);
+        trimEdge(schema, beforeFragment, true);
         range.setStartAfter(splitElm);
         range.setEndAfter(parentElm);
         const afterFragment = range.extractContents();
-        trimEdge(afterFragment, false);
+        trimEdge(schema, afterFragment, false);
-        if (!isEmpty$2(SugarElement.fromDom(beforeFragment))) {
+        if (!isEmptyNode(schema, beforeFragment, { checkRootAsContent: true })) {
           parentNode.insertBefore(beforeFragment, parentElm);
+        }
-        if (!isEmpty$2(SugarElement.fromDom(splitElm))) {
+        if (!isEmptyNode(schema, splitElm, { checkRootAsContent: true })) {
           parentNode.insertBefore(splitElm, parentElm);
+        }
-        if (!isEmpty$2(SugarElement.fromDom(afterFragment))) {
+        if (!isEmptyNode(schema, afterFragment, { checkRootAsContent: true })) {
           parentNode.insertBefore(afterFragment, parentElm);
+        }
         parentNode.removeChild(parentElm);
+      }
     };
           const invalidChildren = children(transparentBlock, el => isBlock(el) && !schema.isValidChild(name(parentBlock), name(el)));
           if (invalidChildren.length > 0) {
             const stateScope = parentElement(parentBlock);
             each$e(invalidChildren, child => {
               ancestor$4(child, isBlock, isRoot).each(parentBlock => {
-                split$2(parentBlock.dom, child.dom);
+                split$2(schema, parentBlock.dom, child.dom);
               });
             });
             stateScope.each(scope => updateBlockStateOnChildren(schema, scope.dom));
+          }
         });
     const isTransparentElement = (schema, node) => isElement$6(node) && isTransparentElementName(schema, node.nodeName);
     const isTransparentBlock = (schema, node) => isTransparentElement(schema, node) && hasBlockAttr(node);
     const isTransparentInline = (schema, node) => isTransparentElement(schema, node) && !hasBlockAttr(node);
     const isTransparentAstBlock = (schema, node) => node.type === 1 && isTransparentElementName(schema, node.name) && isString(node.attr(transparentBlockAttr));
-    const browser$2 = detect$2().browser;
+    const browser$2 = detect$1().browser;
     const firstElement = nodes => find$2(nodes, isElement$7);
     const getTableCaptionDeltaY = elm => {
       if (browser$2.isFirefox() && name(elm) === 'table') {
         return firstElement(children$1(elm)).filter(elm => {
       const addStyle = element => {
         append$1(getStyleContainer(edos), element);
       };
       const removeStyle = id => {
         const styleContainer = getStyleContainer(edos);
-        descendant$1(styleContainer, '#' + id).each(remove$5);
+        descendant$1(styleContainer, '#' + id).each(remove$4);
       };
       const getOrCreateState = url => get$a(loadedStates, url).getOrThunk(() => ({
         id: 'mce-u' + idCount++,
         passed: [],
         failed: [],
           rel: 'stylesheet',
           type: 'text/css',
           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);
         loadedStates[key] = state;
         state.count++;
         const styleElem = SugarElement.fromTag('style', doc.dom);
         setAll$1(styleElem, {
-          rel: 'stylesheet',
+          'rel': 'stylesheet',
-          type: 'text/css',
+          'type': 'text/css',
-          id: state.id
+          'id': state.id,
+          'data-mce-key': key
         });
         styleElem.dom.innerHTML = css;
         addStyle(styleElem);
       };
       const loadAll = urls => {
         _setReferrerPolicy,
         _setContentCssCors
       };
     };
-    const create$d = () => {
+    const create$c = () => {
       const map = new WeakMap();
       const forElement = (referenceElement, settings) => {
         const root = getRootNode(referenceElement);
         const rootDom = root.dom;
           return sl;
         });
       };
       return { forElement };
     };
-    const instance = create$d();
+    const instance = create$c();
     const isSpan = node => node.nodeName.toLowerCase() === 'span';
-    const isInlineContent = (node, root, schema) => isNonNullable(node) && (isContent$1(node, root) || schema.isInline(node.nodeName.toLowerCase()));
+    const isInlineContent = (node, schema) => isNonNullable(node) && (isContent$1(schema, node) || schema.isInline(node.nodeName.toLowerCase()));
     const surroundedByInlineContent = (node, root, schema) => {
       const prev = new DomTreeWalker(node, root).prev(false);
       const next = new DomTreeWalker(node, root).next(false);
-      const prevIsInline = isUndefined(prev) || isInlineContent(prev, root, schema);
+      const prevIsInline = isUndefined(prev) || isInlineContent(prev, schema);
-      const nextIsInline = isUndefined(next) || isInlineContent(next, root, schema);
+      const nextIsInline = isUndefined(next) || isInlineContent(next, schema);
       return prevIsInline && nextIsInline;
     };
     const isBookmarkNode$2 = node => isSpan(node) && node.getAttribute('data-mce-type') === 'bookmark';
-    const isKeepTextNode = (node, root, schema) => isText$a(node) && node.data.length > 0 && surroundedByInlineContent(node, root, schema);
+    const isKeepTextNode = (node, root, schema) => isText$b(node) && node.data.length > 0 && surroundedByInlineContent(node, root, schema);
     const isKeepElement = node => isElement$6(node) ? node.childNodes.length > 0 : false;
     const isDocument = node => isDocumentFragment(node) || isDocument$1(node);
     const trimNode = (dom, node, schema, root) => {
       var _a;
         const currentChildren = node.childNodes;
         if (currentChildren.length === 1 && isBookmarkNode$2(currentChildren[0])) {
           (_a = node.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(currentChildren[0], node);
+        }
+      }
-      if (!isDocument(node) && !isContent$1(node, rootNode) && !isKeepElement(node) && !isKeepTextNode(node, rootNode, schema)) {
+      if (!isDocument(node) && !isContent$1(schema, node) && !isKeepElement(node) && !isKeepTextNode(node, rootNode, schema)) {
         dom.remove(node);
+      }
       return node;
     };
     const split$1 = (items, delim) => {
       items = Tools.trim(items);
       return items ? items.split(delim || ' ') : [];
     };
     const patternToRegExp = str => new RegExp('^' + str.replace(/([?+*])/g, '.$1') + '$');
+    const isRegExp$1 = obj => isObject(obj) && obj.source && Object.prototype.toString.call(obj) === '[object RegExp]';
+    const deepCloneElementRule = obj => {
+      const helper = value => {
+        if (isArray$1(value)) {
+          return map$3(value, helper);
+        } else if (isRegExp$1(value)) {
+          return new RegExp(value.source, value.flags);
+        } else if (isObject(value)) {
+          return map$2(value, helper);
+        } else {
+          return value;
+        }
+      };
+      return helper(obj);
+    };
     const parseCustomElementsRules = value => {
       const customElementRegExp = /^(~)?(.+)$/;
       return bind$3(split$1(value, ','), rule => {
         const matches = customElementRegExp.exec(rule);
         if (matches) {
           const inline = matches[1] === '~';
           const cloneName = inline ? 'span' : 'div';
           const name = matches[2];
-          return [{
-              inline,
+          return [{
               cloneName,
               name
             }];
         } else {
           return [];
+        }
       });
+    };
+    const getGlobalAttributeSet = type => {
+      return Object.freeze([
+        'id',
+        'accesskey',
+        'class',
+        'dir',
+        'lang',
+        'style',
+        'tabindex',
+        'title',
+        'role',
+        ...type !== 'html4' ? [
+          'contenteditable',
+          'contextmenu',
+          'draggable',
+          'dropzone',
+          'hidden',
+          'spellcheck',
+          'translate',
+          'itemprop',
+          'itemscope',
+          'itemtype'
+        ] : [],
+        ...type !== 'html5-strict' ? ['xml:lang'] : []
+      ]);
     };
     const getElementSetsAsStrings = type => {
-      let globalAttributes, blockContent;
-      let phrasingContent;
+      let blockContent;
-      globalAttributes = 'id accesskey class dir lang style tabindex title role';
+      let phrasingContent;
       blockContent = 'address blockquote div dl fieldset form h1 h2 h3 h4 h5 h6 hr menu ol p pre table ul';
       phrasingContent = 'a abbr b bdo br button cite code del dfn em embed i iframe img input ins kbd ' + 'label map noscript object q s samp script select small span strong sub sup ' + 'textarea u var #text #comment';
-      if (type !== 'html4') {
-        const transparentContent = 'a ins del canvas map';
+      if (type !== 'html4') {
-        globalAttributes += ' contenteditable contextmenu draggable dropzone ' + 'hidden spellcheck translate';
+        const transparentContent = 'a ins del canvas map';
         blockContent += ' article aside details dialog figure main header footer hgroup section nav ' + transparentContent;
-        phrasingContent += ' audio canvas command datalist mark meter output picture ' + 'progress time wbr video ruby bdi keygen svg';
+        phrasingContent += ' audio canvas command data datalist mark meter output picture ' + 'progress time wbr video ruby bdi keygen svg';
-      }
       if (type !== 'html5-strict') {
-        globalAttributes += ' xml:lang';
+      if (type !== 'html5-strict') {
         const html4PhrasingContent = 'acronym applet basefont big font strike tt';
         phrasingContent = [
           phrasingContent,
       const flowContent = [
         blockContent,
         phrasingContent
       ].join(' ');
       return {
-        globalAttributes,
         blockContent,
         phrasingContent,
         flowContent
       };
     };
+    const getElementSets = type => {
+      const {blockContent, phrasingContent, flowContent} = getElementSetsAsStrings(type);
+      const toArr = value => {
+        return Object.freeze(value.split(' '));
+      };
+      return Object.freeze({
+        blockContent: toArr(blockContent),
+        phrasingContent: toArr(phrasingContent),
+        flowContent: toArr(flowContent)
+      });
+    };
+    const cachedSets = {
+      'html4': cached(() => getElementSets('html4')),
+      'html5': cached(() => getElementSets('html5')),
+      'html5-strict': cached(() => getElementSets('html5-strict'))
+    };
+    const getElementsPreset = (type, name) => {
+      const {blockContent, phrasingContent, flowContent} = cachedSets[type]();
+      if (name === 'blocks') {
+        return Optional.some(blockContent);
+      } else if (name === 'phrasing') {
+        return Optional.some(phrasingContent);
+      } else if (name === 'flow') {
+        return Optional.some(flowContent);
+      } else {
+        return Optional.none();
+      }
+    };
+    const makeSchema = type => {
-    const makeSchema = type => {
+      const globalAttributes = getGlobalAttributeSet(type);
-      const {globalAttributes, phrasingContent, flowContent} = getElementSetsAsStrings(type);
+      const {phrasingContent, flowContent} = getElementSetsAsStrings(type);
       const schema = {};
       const addElement = (name, attributes, children) => {
         schema[name] = {
           attributes: mapToObject(attributes, constant({})),
       };
       const add = (name, attributes = '', children = '') => {
         const childNames = split$1(children);
         const names = split$1(name);
         let ni = names.length;
-        const allAttributes = split$1([
+        const allAttributes = [
-          globalAttributes,
+          ...globalAttributes,
-          attributes
+          ...split$1(attributes)
-        ].join(' '));
+        ];
         while (ni--) {
           addElement(names[ni], allAttributes.slice(), childNames);
+        }
       };
       const addAttrs = (name, attributes) => {
         add('summary', '', [
           phrasingContent,
           'h1 h2 h3 h4 h5 h6'
         ].join(' '));
         add('canvas', 'width height', flowContent);
+        add('data', 'value', phrasingContent);
         add('video', 'src crossorigin poster preload autoplay mediagroup loop ' + 'muted controls width height buffered', [
           flowContent,
           'track source'
         ].join(' '));
         add('audio', 'src crossorigin preload autoplay mediagroup loop muted controls ' + 'buffered volume', [
         addAttrs('input button select textarea', 'autofocus');
         addAttrs('input textarea', 'placeholder');
         addAttrs('a', 'download');
         addAttrs('link script img', 'crossorigin');
         addAttrs('img', 'loading');
-        addAttrs('iframe', 'sandbox seamless allow allowfullscreen loading');
+        addAttrs('iframe', 'sandbox seamless allow allowfullscreen loading referrerpolicy');
+      }
       if (type !== 'html4') {
         each$e([
           schema.video,
           schema.audio
       delete schema.script;
       return schema;
     };
+    const prefixToOperation = prefix => prefix === '-' ? 'remove' : 'add';
+    const parseValidChild = name => {
+      const validChildRegExp = /^(@?)([A-Za-z0-9_\-.\u00b7\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u037d\u037f-\u1fff\u200c-\u200d\u203f-\u2040\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd]+)$/;
+      return Optional.from(validChildRegExp.exec(name)).map(matches => ({
+        preset: matches[1] === '@',
+        name: matches[2]
+      }));
-    const prefixToOperation = prefix => prefix === '-' ? 'remove' : 'add';
+    };
     const parseValidChildrenRules = value => {
       const childRuleRegExp = /^([+\-]?)([A-Za-z0-9_\-.\u00b7\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u037d\u037f-\u1fff\u200c-\u200d\u203f-\u2040\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd]+)\[([^\]]+)]$/;
       return bind$3(split$1(value, ','), rule => {
         const matches = childRuleRegExp.exec(rule);
         if (matches) {
           const prefix = matches[1];
           const operation = prefix ? prefixToOperation(prefix) : 'replace';
           const name = matches[2];
-          const validChildren = split$1(matches[3], '|');
+          const validChildren = bind$3(split$1(matches[3], '|'), validChild => parseValidChild(validChild).toArray());
           return [{
               operation,
               name,
               validChildren
       const whitespaceElementsMap = createLookupTable('whitespace_elements', 'pre script noscript style textarea video audio iframe object code');
       const selfClosingElementsMap = createLookupTable('self_closing_elements', 'colgroup dd dt li option p td tfoot th thead tr');
       const voidElementsMap = createLookupTable('void_elements', 'area base basefont br col frame hr img input isindex link ' + 'meta param embed source wbr track');
       const boolAttrMap = createLookupTable('boolean_attributes', 'checked compact declare defer disabled ismap multiple nohref noresize ' + 'noshade nowrap readonly selected autoplay loop controls allowfullscreen');
       const nonEmptyOrMoveCaretBeforeOnEnter = 'td th iframe video audio object script code';
-      const nonEmptyElementsMap = createLookupTable('non_empty_elements', nonEmptyOrMoveCaretBeforeOnEnter + ' pre svg', voidElementsMap);
+      const nonEmptyElementsMap = createLookupTable('non_empty_elements', nonEmptyOrMoveCaretBeforeOnEnter + ' pre svg textarea summary', voidElementsMap);
       const moveCaretBeforeOnEnterElementsMap = createLookupTable('move_caret_before_on_enter_elements', nonEmptyOrMoveCaretBeforeOnEnter + ' table', voidElementsMap);
       const headings = 'h1 h2 h3 h4 h5 h6';
       const textBlockElementsMap = createLookupTable('text_block_elements', headings + ' p div address pre form ' + 'blockquote center dir fieldset header footer article section hgroup aside main nav figure');
       const blockElementsMap = createLookupTable('block_elements', 'hr table tbody thead tfoot ' + 'th tr td li ol ul caption dl dt dd noscript menu isindex option ' + 'datalist select optgroup figcaption details summary html body multicol listing', textBlockElementsMap);
       const textInlineElementsMap = createLookupTable('text_inline_elements', 'span strong b em i font s strike u var cite ' + 'dfn code mark q sup sub samp');
         each$e(keys(elements), name => {
           delete elements[name];
         });
         addValidElements(validElements);
       };
-      const addCustomElements = customElements => {
+      const addCustomElement = (name, spec) => {
+        var _a, _b;
         delete mapCache.text_block_elements;
         delete mapCache.block_elements;
-        each$e(parseCustomElementsRules(customElements !== null && customElements !== void 0 ? customElements : ''), ({inline, name, cloneName}) => {
+        const inline = spec.extends ? !isBlock(spec.extends) : false;
+        const cloneName = spec.extends;
-          children[name] = children[cloneName];
+        children[name] = cloneName ? children[cloneName] : {};
-          customElementsMap[name] = cloneName;
+        customElementsMap[name] = cloneName !== null && cloneName !== void 0 ? cloneName : name;
-          nonEmptyElementsMap[name.toUpperCase()] = {};
+        nonEmptyElementsMap[name.toUpperCase()] = {};
-          nonEmptyElementsMap[name] = {};
+        nonEmptyElementsMap[name] = {};
-          if (!inline) {
+        if (!inline) {
-            blockElementsMap[name.toUpperCase()] = {};
+          blockElementsMap[name.toUpperCase()] = {};
-            blockElementsMap[name] = {};
+          blockElementsMap[name] = {};
-          }
+        }
+        if (cloneName && !elements[name] && elements[cloneName]) {
+          const customRule = deepCloneElementRule(elements[cloneName]);
+          delete customRule.removeEmptyAttrs;
+          delete customRule.removeEmpty;
+          elements[name] = customRule;
+        } else {
-          if (!elements[name]) {
+          elements[name] = {
+            attributesOrder: [],
+            attributes: {}
+          };
+        }
+        if (isArray$1(spec.attributes)) {
+          const processAttrName = name => {
+            customRule.attributesOrder.push(name);
+            customRule.attributes[name] = {};
+          };
+          const customRule = (_a = elements[name]) !== null && _a !== void 0 ? _a : {};
-            let customRule = elements[cloneName];
+          delete customRule.attributesDefault;
-            customRule = extend$2({}, customRule);
+          delete customRule.attributesForced;
-            delete customRule.removeEmptyAttrs;
+          delete customRule.attributePatterns;
-            delete customRule.removeEmpty;
+          delete customRule.attributesRequired;
+          customRule.attributesOrder = [];
+          customRule.attributes = {};
+          each$e(spec.attributes, attrName => {
+            const globalAttrs = getGlobalAttributeSet(schemaType);
+            parseValidChild(attrName).each(({preset, name}) => {
+              if (preset) {
+                if (name === 'global') {
+                  each$e(globalAttrs, processAttrName);
+                }
+              } else {
+                processAttrName(name);
+              }
+            });
+          });
-            elements[name] = customRule;
+          elements[name] = customRule;
+        }
+        if (isBoolean(spec.padEmpty)) {
+          const customRule = (_b = elements[name]) !== null && _b !== void 0 ? _b : {};
+          customRule.paddEmpty = spec.padEmpty;
+          elements[name] = customRule;
+        }
+        if (isArray$1(spec.children)) {
+          const customElementChildren = {};
+          const processNodeName = name => {
+            customElementChildren[name] = {};
+          };
+          const processPreset = name => {
+            getElementsPreset(schemaType, name).each(names => {
+              each$e(names, processNodeName);
+            });
-          }
+          };
+          each$e(spec.children, child => {
+            parseValidChild(child).each(({preset, name}) => {
+              if (preset) {
+                processPreset(name);
+              } else {
+                processNodeName(name);
+              }
+            });
+          });
+          children[name] = customElementChildren;
+        }
+        if (cloneName) {
           each$d(children, (element, elmName) => {
             if (element[cloneName]) {
               children[elmName] = element = extend$2({}, children[elmName]);
               element[name] = element[cloneName];
+            }
           });
+        }
+      };
+      const addCustomElementsFromString = customElements => {
+        each$e(parseCustomElementsRules(customElements !== null && customElements !== void 0 ? customElements : ''), ({name, cloneName}) => {
+          addCustomElement(name, { extends: cloneName });
         });
       };
+      const addCustomElements = customElements => {
+        if (isObject(customElements)) {
+          each$d(customElements, (spec, name) => addCustomElement(name, spec));
+        } else if (isString(customElements)) {
+          addCustomElementsFromString(customElements);
+        }
+      };
       const addValidChildren = validChildren => {
         each$e(parseValidChildrenRules(validChildren !== null && validChildren !== void 0 ? validChildren : ''), ({operation, name, validChildren}) => {
           const parent = operation === 'replace' ? { '#comment': {} } : children[name];
-          each$e(validChildren, child => {
+          const processNodeName = name => {
             if (operation === 'remove') {
-              delete parent[child];
+              delete parent[name];
             } else {
-              parent[child] = {};
+              parent[name] = {};
+            }
+          };
+          const processPreset = name => {
+            getElementsPreset(schemaType, name).each(names => {
+              each$e(names, processNodeName);
+            });
+          };
+          each$e(validChildren, ({preset, name}) => {
+            if (preset) {
+              processPreset(name);
+            } else {
+              processNodeName(name);
+            }
           });
           children[name] = parent;
         });
       };
             return patternElement;
+          }
+        }
         return undefined;
       };
+      const setup = () => {
-      if (!settings.valid_elements) {
+        if (!settings.valid_elements) {
-        each$b(schemaItems, (element, name) => {
+          each$b(schemaItems, (element, name) => {
-          elements[name] = {
+            elements[name] = {
-            attributes: element.attributes,
+              attributes: element.attributes,
-            attributesOrder: element.attributesOrder
+              attributesOrder: element.attributesOrder
-          };
+            };
-          children[name] = element.children;
+            children[name] = element.children;
-        });
+          });
-        each$b(split$1('strong/b em/i'), item => {
+          each$b(split$1('strong/b em/i'), item => {
-          const items = split$1(item, '/');
+            const items = split$1(item, '/');
-          elements[items[1]].outputName = items[0];
+            elements[items[1]].outputName = items[0];
-        });
+          });
-        each$b(textInlineElementsMap, (_val, name) => {
+          each$b(textInlineElementsMap, (_val, name) => {
-          if (elements[name]) {
+            if (elements[name]) {
-            if (settings.padd_empty_block_inline_children) {
+              if (settings.padd_empty_block_inline_children) {
-              elements[name].paddInEmptyBlock = true;
+                elements[name].paddInEmptyBlock = true;
-            }
+              }
-            elements[name].removeEmpty = true;
+              elements[name].removeEmpty = true;
-          }
+            }
-        });
+          });
-        each$b(split$1('ol ul blockquote a table tbody'), name => {
+          each$b(split$1('ol ul blockquote a table tbody'), name => {
-          if (elements[name]) {
+            if (elements[name]) {
-            elements[name].removeEmpty = true;
+              elements[name].removeEmpty = true;
-          }
+            }
-        });
+          });
-        each$b(split$1('p h1 h2 h3 h4 h5 h6 th td pre div address caption li summary'), name => {
+          each$b(split$1('p h1 h2 h3 h4 h5 h6 th td pre div address caption li summary'), name => {
-          if (elements[name]) {
+            if (elements[name]) {
-            elements[name].paddEmpty = true;
+              elements[name].paddEmpty = true;
-          }
+            }
-        });
+          });
-        each$b(split$1('span'), name => {
+          each$b(split$1('span'), name => {
-          elements[name].removeEmptyAttrs = true;
+            elements[name].removeEmptyAttrs = true;
-        });
+          });
-      } else {
+        } else {
-        setValidElements(settings.valid_elements);
+          setValidElements(settings.valid_elements);
-        each$b(schemaItems, (element, name) => {
+          each$b(schemaItems, (element, name) => {
-          children[name] = element.children;
+            children[name] = element.children;
-        });
+          });
-      }
+        }
-      delete elements.svg;
+        delete elements.svg;
-      addCustomElements(settings.custom_elements);
+        addCustomElements(settings.custom_elements);
-      addValidChildren(settings.valid_children);
+        addValidChildren(settings.valid_children);
-      addValidElements(settings.extended_valid_elements);
+        addValidElements(settings.extended_valid_elements);
-      addValidChildren('+ol[ul|ol],+ul[ul|ol]');
+        addValidChildren('+ol[ul|ol],+ul[ul|ol]');
-      each$b({
+        each$b({
-        dd: 'dl',
+          dd: 'dl',
-        dt: 'dl',
+          dt: 'dl',
-        li: 'ul ol',
+          li: 'ul ol',
-        td: 'tr',
+          td: 'tr',
-        th: 'tr',
+          th: 'tr',
-        tr: 'tbody thead tfoot',
+          tr: 'tbody thead tfoot',
-        tbody: 'table',
+          tbody: 'table',
-        thead: 'table',
+          thead: 'table',
-        tfoot: 'table',
+          tfoot: 'table',
-        legend: 'fieldset',
+          legend: 'fieldset',
-        area: 'map',
+          area: 'map',
-        param: 'video audio object'
+          param: 'video audio object'
-      }, (parents, item) => {
+        }, (parents, item) => {
-        if (elements[item]) {
-          elements[item].parentsRequired = split$1(parents);
-        }
-      });
-      if (settings.invalid_elements) {
-        each$b(explode$2(settings.invalid_elements), item => {
           if (elements[item]) {
-            delete elements[item];
+            elements[item].parentsRequired = split$1(parents);
+          }
         });
+        if (settings.invalid_elements) {
+          each$b(explode$2(settings.invalid_elements), item => {
+            if (elements[item]) {
+              delete elements[item];
+            }
+          });
-      }
+        }
-      if (!getElementRule('span')) {
+        if (!getElementRule('span')) {
-        addValidElements('span[!data-mce-type|*]');
+          addValidElements('span[!data-mce-type|*]');
+        }
-      }
+      };
       const getValidStyles = constant(validStyles);
       const getInvalidStyles = constant(invalidStyles);
       const getValidClasses = constant(validClasses);
       const getBoolAttrs = constant(boolAttrMap);
       const getBlockElements = constant(blockElementsMap);
       };
       const isBlock = name => has$2(getBlockElements(), name);
       const isInline = name => !startsWith(name, '#') && isValid(name) && !isBlock(name);
       const isWrapper = name => has$2(getWrapBlockElements(), name) || isInline(name);
       const getCustomElements = constant(customElementsMap);
+      setup();
       return {
         type: schemaType,
         children,
         elements,
         getValidStyles,
     const fromRgba = rgbaColour => {
       const value = toHex(rgbaColour.red) + toHex(rgbaColour.green) + toHex(rgbaColour.blue);
       return hexColour(value);
     };
-    const rgbRegex = /^\s*rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\s*$/i;
+    const rgbRegex = /^\s*rgb\s*\(\s*(\d+)\s*[,\s]\s*(\d+)\s*[,\s]\s*(\d+)\s*\)\s*$/i;
-    const rgbaRegex = /^\s*rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d?(?:\.\d+)?)\s*\)\s*$/i;
+    const rgbaRegex = /^\s*rgba\s*\(\s*(\d+)\s*[,\s]\s*(\d+)\s*[,\s]\s*(\d+)\s*[,\s]\s*((?:\d?\.\d+|\d+)%?)\s*\)\s*$/i;
     const rgbaColour = (red, green, blue, alpha) => ({
       red,
       green,
       blue,
       const g = parseInt(green, 10);
       const b = parseInt(blue, 10);
       const a = parseFloat(alpha);
       return rgbaColour(r, g, b, a);
     };
-    const fromString = rgbaString => {
+    const getColorFormat = colorString => {
-      if (rgbaString === 'transparent') {
+      if (rgbRegex.test(colorString)) {
+        return 'rgb';
-        return Optional.some(rgbaColour(0, 0, 0, 0));
+      } else if (rgbaRegex.test(colorString)) {
+        return 'rgba';
+      }
+      return 'other';
+    };
+    const fromString = rgbaString => {
       const rgbMatch = rgbRegex.exec(rgbaString);
       if (rgbMatch !== null) {
         return Optional.some(fromStringValues(rgbMatch[1], rgbMatch[2], rgbMatch[3], '1'));
+      }
       const rgbaMatch = rgbaRegex.exec(rgbaString);
                 if (name === 'font-weight' && value === '700') {
                   value = 'bold';
                 } else if (name === 'color' || name === 'background-color') {
                   value = value.toLowerCase();
+                }
-                if (isString(settings.force_hex_color) && settings.force_hex_color !== 'off') {
+                if (getColorFormat(value) === 'rgb') {
                   fromString(value).each(rgba => {
-                    if (settings.force_hex_color === 'always' || rgba.alpha === 1) {
-                      value = rgbaToHexString(toString(rgba));
+                    value = rgbaToHexString(toString(rgba)).toLowerCase();
-                    }
                   });
+                }
                 value = value.replace(urlOrStrRegExp, processUrl);
                 styles[name] = isEncoded ? decode(value, true) : value;
+              }
         let callbackList;
         const win = window;
         const defaultNativeHandler = evt => {
           self.executeHandlers(fix(evt || win.event), id);
         };
-        if (!target || isText$a(target) || isComment(target)) {
+        if (!target || isText$b(target) || isComment(target)) {
           return callback;
+        }
         let id;
         if (!target[self.expando]) {
           id = self.count++;
+        }
         target = callbackList = null;
         return callback;
+      }
       unbind(target, names, callback) {
-        if (!target || isText$a(target) || isComment(target)) {
+        if (!target || isText$b(target) || isComment(target)) {
           return this;
+        }
         const id = target[this.expando];
         if (id) {
           let eventMap = this.events[id];
+            }
+          }
           delete this.events[id];
           try {
             delete target[this.expando];
-          } catch (ex) {
+          } catch (_a) {
             target[this.expando] = null;
+          }
+        }
         return this;
+      }
       fire(target, name, args) {
         return this.dispatch(target, name, args);
+      }
       dispatch(target, name, args) {
-        if (!target || isText$a(target) || isComment(target)) {
+        if (!target || isText$b(target) || isComment(target)) {
           return this;
+        }
         const event = fix({
           type: name,
           target
           target = target.parentNode || target.ownerDocument || target.defaultView || target.parentWindow;
         } while (target && !event.isPropagationStopped());
         return this;
+      }
       clean(target) {
-        if (!target || isText$a(target) || isComment(target)) {
+        if (!target || isText$b(target) || isComment(target)) {
           return this;
+        }
         if (target[this.expando]) {
           this.unbind(target);
+        }
     const grep = Tools.grep;
     const internalStyleName = 'data-mce-style';
     const numericalCssMap = Tools.makeMap('fill-opacity font-weight line-height opacity orphans widows z-index zoom', ' ');
     const legacySetAttribute = (elm, name, value) => {
       if (isNullable(value) || value === '') {
-        remove$a(elm, name);
+        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());
     const findNodeIndex = (node, normalized) => {
       let idx = 0;
       if (node) {
         for (let lastNodeType = node.nodeType, tempNode = node.previousSibling; tempNode; tempNode = tempNode.previousSibling) {
           const nodeType = tempNode.nodeType;
-          if (normalized && isText$a(tempNode)) {
+          if (normalized && isText$b(tempNode)) {
             if (nodeType === lastNodeType || !tempNode.data.length) {
               continue;
+            }
+          }
           idx++;
+      }
     };
     const applyStyle$1 = ($elm, cssName, cssValue) => {
       const normalizedName = camelCaseToHyphens(cssName);
       if (isNullable(cssValue) || cssValue === '') {
-        remove$6($elm, normalizedName);
+        remove$5($elm, normalizedName);
       } else {
         set$2($elm, normalizedName, convertStyleToString(cssValue, normalizedName));
+      }
     };
     const setupAttrHooks = (styles, settings, getContext) => {
           set: (elm, value) => {
             const sugarElm = SugarElement.fromDom(elm);
             if (keepValues) {
               legacySetAttribute(sugarElm, internalStyleName, value);
+            }
-            remove$a(sugarElm, 'style');
+            remove$9(sugarElm, 'style');
             if (isString(value)) {
               setAll(sugarElm, styles.parse(value));
+            }
           },
           get: elm => {
       });
       const boundEvents = [];
       const schema = settings.schema ? settings.schema : Schema({});
       const styles = Styles({
         url_converter: settings.url_converter,
-        url_converter_scope: settings.url_converter_scope,
+        url_converter_scope: settings.url_converter_scope
-        force_hex_color: settings.force_hex_color
       }, settings.schema);
       const events = settings.ownEvents ? new EventUtils() : EventUtils.Event;
       const blockElementsMap = schema.getBlockElements();
       const isBlock = node => {
         if (isString(node)) {
       const remove = (node, keepChildren) => {
         return run(node, n => {
           const $node = SugarElement.fromDom(n);
           if (keepChildren) {
             each$e(children$1($node), child => {
-              if (isText$b(child) && child.dom.length === 0) {
+              if (isText$c(child) && child.dom.length === 0) {
-                remove$5(child);
+                remove$4(child);
               } else {
                 before$3($node, child);
+              }
             });
+          }
-          remove$5($node);
+          remove$4($node);
           return $node.dom;
         });
       };
       const removeAllAttribs = e => run(e, e => {
         const attrs = e.attributes;
           if (isElement$6(e)) {
             const $elm = SugarElement.fromDom(e);
             const classes = cls.split(' ');
             each$e(classes, c => {
               if (isNonNullable(state)) {
-                const fn = state ? add$2 : remove$7;
+                const fn = state ? add$2 : remove$6;
                 fn($elm, c);
               } else {
                 toggle$1($elm, c);
+              }
             });
         const $elm = _get(elm);
         const classes = cls.split(' ');
         return isNonNullable($elm) && forall(classes, c => has($elm, c));
       };
       const show = elm => {
-        run(elm, e => remove$6(SugarElement.fromDom(e), 'display'));
+        run(elm, e => remove$5(SugarElement.fromDom(e), 'display'));
       };
       const hide = elm => {
         run(elm, e => set$2(SugarElement.fromDom(e), 'display', 'none'));
       };
       const isHidden = elm => {
           return a.ownerDocument.documentElement;
         } else {
           return ps;
+        }
       };
-      const isNonEmptyElement = node => {
-        if (isElement$6(node)) {
-          const isNamedAnchor = node.nodeName.toLowerCase() === 'a' && !getAttrib(node, 'href') && getAttrib(node, 'id');
-          if (getAttrib(node, 'name') || getAttrib(node, 'data-mce-bookmark') || isNamedAnchor) {
-            return true;
-          }
-        }
-        return false;
-      };
       const isEmpty = (node, elements, options) => {
-        let brCount = 0;
-        if (isNonEmptyElement(node)) {
+        if (isPlainObject(elements)) {
-          return false;
-        }
-        const firstChild = node.firstChild;
-        if (firstChild) {
-          const walker = new DomTreeWalker(firstChild, node);
-          const whitespaceElements = schema ? schema.getWhitespaceElements() : {};
-          const nonEmptyElements = elements || (schema ? schema.getNonEmptyElements() : null);
-          let tempNode = firstChild;
-          do {
-            if (isElement$6(tempNode)) {
+          const isContent = node => {
-              const bogusVal = tempNode.getAttribute('data-mce-bogus');
-              if (bogusVal) {
-                tempNode = walker.next(bogusVal === 'all');
-                continue;
-              }
-              const name = tempNode.nodeName.toLowerCase();
+            const name = node.nodeName.toLowerCase();
-              if (nonEmptyElements && nonEmptyElements[name]) {
-                if (name === 'br') {
-                  brCount++;
-                  tempNode = walker.next();
-                  continue;
-                }
-                return false;
-              }
-              if (isNonEmptyElement(tempNode)) {
+            return Boolean(elements[name]);
-                return false;
-              }
-            }
+          };
-            if (isComment(tempNode)) {
+          return isEmptyNode(schema, node, {
-              return false;
+            ...options,
-            }
+            isContent
-            if (isText$a(tempNode) && !isWhitespaceText(tempNode.data) && (!(options === null || options === void 0 ? void 0 : options.includeZwsp) || !isZwsp(tempNode.data))) {
-              return false;
-            }
+          });
-            if (isText$a(tempNode) && tempNode.parentNode && whitespaceElements[tempNode.parentNode.nodeName] && isWhitespaceText(tempNode.data)) {
-              return false;
-            }
+        } else {
-            tempNode = walker.next();
+          return isEmptyNode(schema, node, options);
-          } while (tempNode);
+        }
-        return brCount <= 1;
       };
       const createRng = () => doc.createRange();
       const split = (parentElm, splitElm, replacementElm) => {
         let range = createRng();
         let beforeFragment;
+        }
+      }
+    }
     ScriptLoader.ScriptLoader = new ScriptLoader();
-    const Cell = initial => {
-      let value = initial;
-      const get = () => {
-        return value;
-      };
-      const set = v => {
-        value = v;
-      };
-      return {
-        get,
-        set
-      };
-    };
     const isDuplicated = (items, item) => {
       const firstIndex = items.indexOf(item);
       return firstIndex !== -1 && items.indexOf(item, firstIndex + 1) > firstIndex;
     };
     AddOnManager.baseURL = '';
     AddOnManager.PluginManager = AddOnManager();
     AddOnManager.ThemeManager = AddOnManager();
     AddOnManager.ModelManager = AddOnManager();
-    const singleton = doRevoke => {
-      const subject = Cell(Optional.none());
-      const revoke = () => subject.get().each(doRevoke);
-      const clear = () => {
-        revoke();
-        subject.set(Optional.none());
-      };
-      const isSet = () => subject.get().isSome();
-      const get = () => subject.get();
-      const set = s => {
-        revoke();
-        subject.set(Optional.some(s));
-      };
-      return {
-        clear,
-        isSet,
-        get,
-        set
-      };
-    };
-    const repeatable = delay => {
-      const intervalId = Cell(Optional.none());
-      const revoke = () => intervalId.get().each(id => clearInterval(id));
-      const clear = () => {
-        revoke();
-        intervalId.set(Optional.none());
-      };
-      const isSet = () => intervalId.get().isSome();
-      const get = () => intervalId.get();
-      const set = functionToRepeat => {
-        revoke();
-        intervalId.set(Optional.some(setInterval(functionToRepeat, delay)));
-      };
-      return {
-        clear,
-        isSet,
-        get,
-        set
-      };
-    };
-    const value$2 = () => {
-      const subject = singleton(noop);
-      const on = f => subject.get().each(f);
-      return {
-        ...subject,
-        on
-      };
-    };
     const first$1 = (fn, rate) => {
       let timer = null;
       const cancel = () => {
         if (!isNull(timer)) {
       return {
         cancel,
         throttle
       };
     };
-    const last$1 = (fn, rate) => {
+    const last = (fn, rate) => {
       let timer = null;
       const cancel = () => {
         if (!isNull(timer)) {
           clearTimeout(timer);
           timer = null;
         cancel,
         throttle
       };
     };
+    const ancestor$1 = (scope, selector, isRoot) => ancestor$3(scope, selector, isRoot).isSome();
     const annotation = constant('mce-annotation');
     const dataAnnotation = constant('data-mce-annotation');
     const dataAnnotationId = constant('data-mce-annotation-uid');
     const dataAnnotationActive = constant('data-mce-annotation-active');
           elements
         };
       })));
     };
     const isAnnotation = elem => isElement$7(elem) && has(elem, annotation());
-    const isBogusElement = (elem, root) => has$1(elem, 'data-mce-bogus') || ancestor$2(elem, '[data-mce-bogus="all"]', isRoot$1(root));
+    const isBogusElement = (elem, root) => has$1(elem, 'data-mce-bogus') || ancestor$1(elem, '[data-mce-bogus="all"]', isRoot$1(root));
     const findMarkers = (editor, uid) => {
       const body = SugarElement.fromDom(editor.getBody());
       const descendants$1 = descendants(body, `[${ dataAnnotationId() }="${ uid }"]`);
       return filter$5(descendants$1, descendant => !isBogusElement(descendant, body));
     };
         });
       };
       const toggleActiveAttr = (uid, state) => {
         each$e(findMarkers(editor, uid), elem => {
           if (state) {
-            set$3(elem, dataAnnotationActive(), 'true');
+            set$4(elem, dataAnnotationActive(), 'true');
           } else {
-            remove$a(elem, dataAnnotationActive());
+            remove$9(elem, dataAnnotationActive());
+          }
         });
       };
-      const onNodeChange = last$1(() => {
+      const onNodeChange = last(() => {
         const annotations = sort(registry.getNames());
         each$e(annotations, name => {
           updateCallbacks(name, data => {
             const prev = data.previous.get();
             identify(editor, Optional.some(name)).fold(() => {
           });
+        }
       });
     };
-    const create$c = () => {
+    const create$b = () => {
       const annotations = {};
       const register = (name, settings) => {
         annotations[name] = {
           name,
         lookup,
         getNames
       };
     };
+    const clamp$2 = (value, min, max) => Math.min(Math.max(value, min), max);
+    const random = () => window.crypto.getRandomValues(new Uint32Array(1))[0] / 4294967295;
     let unique = 0;
     const generate$1 = prefix => {
       const date = new Date();
       const time = date.getTime();
-      const random = Math.floor(Math.random() * 1000000000);
+      const random$1 = Math.floor(random() * 1000000000);
       unique++;
-      return prefix + '_' + random + unique + String(time);
+      return prefix + '_' + random$1 + unique + String(time);
     };
     const add = (element, classes) => {
       each$e(classes, x => {
         add$2(element, x);
       });
     };
-    const remove$4 = (element, classes) => {
+    const remove$3 = (element, classes) => {
       each$e(classes, x => {
-        remove$7(element, x);
+        remove$6(element, x);
       });
     };
     const mutate = (original, tag) => {
       const nu = shallowAs(original, tag);
       after$4(original, nu);
       const children = children$1(original);
       append(nu, children);
-      remove$5(original);
+      remove$4(original);
       return nu;
     };
     const TextWalker = (startNode, rootNode, isBoundary = never) => {
       const walker = new DomTreeWalker(startNode, rootNode);
       const walk = direction => {
         let next;
         do {
           next = walker[direction]();
-        } while (next && !isText$a(next) && !isBoundary(next));
+        } while (next && !isText$b(next) && !isBoundary(next));
-        return Optional.from(next).filter(isText$a);
+        return Optional.from(next).filter(isText$b);
       };
       return {
-        current: () => Optional.from(walker.current()).filter(isText$a),
+        current: () => Optional.from(walker.current()).filter(isText$b),
         next: () => walk('next'),
         prev: () => walk('prev'),
         prev2: () => walk('prev2')
       };
     };
     const TextSeeker = (dom, isBoundary) => {
       const isBlockBoundary = isBoundary ? isBoundary : node => dom.isBlock(node) || isBr$6(node) || isContentEditableFalse$b(node);
       const walk = (node, offset, walker, process) => {
-        if (isText$a(node)) {
+        if (isText$b(node)) {
           const newOffset = process(node, offset, node.data);
           if (newOffset !== -1) {
             return Optional.some({
         backwards,
         forwards
       };
     };
+    const NodeValue = (is, name) => {
+      const get = element => {
+        if (!is(element)) {
+          throw new Error('Can only get ' + name + ' value of a ' + name + ' node');
+        }
+        return getOption(element).getOr('');
+      };
+      const getOption = element => is(element) ? Optional.from(element.dom.nodeValue) : Optional.none();
+      const set = (element, value) => {
+        if (!is(element)) {
+          throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node');
+        }
+        element.dom.nodeValue = value;
+      };
+      return {
+        get,
+        getOption,
+        set
+      };
+    };
+    const api$1 = NodeValue(isText$c, 'text');
+    const get$3 = element => api$1.get(element);
+    const getOption = element => api$1.getOption(element);
+    const set = (element, value) => api$1.set(element, value);
+    const tableCells = [
+      'td',
+      'th'
+    ];
+    const tableSections = [
+      'thead',
+      'tbody',
+      'tfoot'
+    ];
+    const textBlocks = [
+      'h1',
+      'h2',
+      'h3',
+      'h4',
+      'h5',
+      'h6',
+      'p',
+      'div',
+      'address',
+      'pre',
+      'form',
+      'blockquote',
+      'center',
+      'dir',
+      'fieldset',
+      'header',
+      'footer',
+      'article',
+      'section',
+      'hgroup',
+      'aside',
+      'nav',
+      'figure'
+    ];
+    const listItems$1 = [
+      'li',
+      'dd',
+      'dt'
+    ];
+    const lists = [
+      'ul',
+      'ol',
+      'dl'
+    ];
+    const wsElements = [
+      'pre',
+      'script',
+      'textarea',
+      'style'
+    ];
+    const lazyLookup = items => {
+      let lookup;
+      return node => {
+        lookup = lookup ? lookup : mapToObject(items, always);
+        return has$2(lookup, name(node));
+      };
+    };
+    const isTable$1 = node => name(node) === 'table';
+    const isBr$5 = node => isElement$7(node) && name(node) === 'br';
+    const isTextBlock$2 = lazyLookup(textBlocks);
+    const isList = lazyLookup(lists);
+    const isListItem$1 = lazyLookup(listItems$1);
+    const isTableSection = lazyLookup(tableSections);
+    const isTableCell$2 = lazyLookup(tableCells);
+    const isWsPreserveElement = lazyLookup(wsElements);
+    const getLastChildren$1 = elm => {
+      const children = [];
+      let rawNode = elm.dom;
+      while (rawNode) {
+        children.push(SugarElement.fromDom(rawNode));
+        rawNode = rawNode.lastChild;
+      }
+      return children;
+    };
+    const removeTrailingBr = elm => {
+      const allBrs = descendants(elm, 'br');
+      const brs = filter$5(getLastChildren$1(elm).slice(-1), isBr$5);
+      if (allBrs.length === brs.length) {
+        each$e(brs, remove$4);
+      }
+    };
+    const createPaddingBr = () => {
+      const br = SugarElement.fromTag('br');
+      set$4(br, 'data-mce-bogus', '1');
+      return br;
+    };
+    const fillWithPaddingBr = elm => {
+      empty(elm);
+      append$1(elm, createPaddingBr());
+    };
+    const trimBlockTrailingBr = (elm, schema) => {
+      lastChild(elm).each(lastChild => {
+        prevSibling(lastChild).each(lastChildPrevSibling => {
+          if (schema.isBlock(name(elm)) && isBr$5(lastChild) && schema.isBlock(name(lastChildPrevSibling))) {
+            remove$4(lastChild);
+          }
+        });
+      });
+    };
+    const ZWSP$1 = zeroWidth;
+    const isZwsp = isZwsp$2;
+    const trim$2 = removeZwsp;
+    const insert$5 = editor => editor.insertContent(ZWSP$1, { preserve_zwsp: true });
+    const isElement$5 = isElement$6;
+    const isText$9 = isText$b;
+    const isCaretContainerBlock$1 = node => {
+      if (isText$9(node)) {
+        node = node.parentNode;
+      }
+      return isElement$5(node) && node.hasAttribute('data-mce-caret');
+    };
+    const isCaretContainerInline = node => isText$9(node) && isZwsp(node.data);
+    const isCaretContainer$2 = node => isCaretContainerBlock$1(node) || isCaretContainerInline(node);
+    const hasContent = node => node.firstChild !== node.lastChild || !isBr$6(node.firstChild);
+    const insertInline$1 = (node, before) => {
+      var _a;
+      const doc = (_a = node.ownerDocument) !== null && _a !== void 0 ? _a : document;
+      const textNode = doc.createTextNode(ZWSP$1);
+      const parentNode = node.parentNode;
+      if (!before) {
+        const sibling = node.nextSibling;
+        if (isText$9(sibling)) {
+          if (isCaretContainer$2(sibling)) {
+            return sibling;
+          }
+          if (startsWithCaretContainer$1(sibling)) {
+            sibling.splitText(1);
+            return sibling;
+          }
+        }
+        if (node.nextSibling) {
+          parentNode === null || parentNode === void 0 ? void 0 : parentNode.insertBefore(textNode, node.nextSibling);
+        } else {
+          parentNode === null || parentNode === void 0 ? void 0 : parentNode.appendChild(textNode);
+        }
+      } else {
+        const sibling = node.previousSibling;
+        if (isText$9(sibling)) {
+          if (isCaretContainer$2(sibling)) {
+            return sibling;
+          }
+          if (endsWithCaretContainer$1(sibling)) {
+            return sibling.splitText(sibling.data.length - 1);
+          }
+        }
+        parentNode === null || parentNode === void 0 ? void 0 : parentNode.insertBefore(textNode, node);
+      }
+      return textNode;
+    };
+    const isBeforeInline = pos => {
+      const container = pos.container();
+      if (!isText$b(container)) {
+        return false;
+      }
+      return container.data.charAt(pos.offset()) === ZWSP$1 || pos.isAtStart() && isCaretContainerInline(container.previousSibling);
+    };
+    const isAfterInline = pos => {
+      const container = pos.container();
+      if (!isText$b(container)) {
+        return false;
+      }
+      return container.data.charAt(pos.offset() - 1) === ZWSP$1 || pos.isAtEnd() && isCaretContainerInline(container.nextSibling);
+    };
+    const insertBlock = (blockName, node, before) => {
+      var _a;
+      const doc = (_a = node.ownerDocument) !== null && _a !== void 0 ? _a : document;
+      const blockNode = doc.createElement(blockName);
+      blockNode.setAttribute('data-mce-caret', before ? 'before' : 'after');
+      blockNode.setAttribute('data-mce-bogus', 'all');
+      blockNode.appendChild(createPaddingBr().dom);
+      const parentNode = node.parentNode;
+      if (!before) {
+        if (node.nextSibling) {
+          parentNode === null || parentNode === void 0 ? void 0 : parentNode.insertBefore(blockNode, node.nextSibling);
+        } else {
+          parentNode === null || parentNode === void 0 ? void 0 : parentNode.appendChild(blockNode);
+        }
+      } else {
+        parentNode === null || parentNode === void 0 ? void 0 : parentNode.insertBefore(blockNode, node);
+      }
+      return blockNode;
+    };
+    const startsWithCaretContainer$1 = node => isText$9(node) && node.data[0] === ZWSP$1;
+    const endsWithCaretContainer$1 = node => isText$9(node) && node.data[node.data.length - 1] === ZWSP$1;
+    const trimBogusBr = elm => {
+      var _a;
+      const brs = elm.getElementsByTagName('br');
+      const lastBr = brs[brs.length - 1];
+      if (isBogus$1(lastBr)) {
+        (_a = lastBr.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(lastBr);
+      }
+    };
+    const showCaretContainerBlock = caretContainer => {
+      if (caretContainer && caretContainer.hasAttribute('data-mce-caret')) {
+        trimBogusBr(caretContainer);
+        caretContainer.removeAttribute('data-mce-caret');
+        caretContainer.removeAttribute('data-mce-bogus');
+        caretContainer.removeAttribute('style');
+        caretContainer.removeAttribute('data-mce-style');
+        caretContainer.removeAttribute('_moz_abspos');
+        return caretContainer;
+      }
+      return null;
+    };
+    const isRangeInCaretContainerBlock = range => isCaretContainerBlock$1(range.startContainer);
     const round$2 = Math.round;
     const clone$1 = rect => {
       if (!rect) {
         return {
       const cy = Math.max(Math.min(y, rect.top + rect.height), rect.top);
       return Math.sqrt((x - cx) * (x - cx) + (y - cy) * (y - cy));
     };
     const overlapY = (r1, r2) => Math.max(0, Math.min(r1.bottom, r2.bottom) - Math.max(r1.top, r2.top));
-    const clamp$2 = (value, min, max) => Math.min(Math.max(value, min), max);
     const getSelectedNode = range => {
       const startContainer = range.startContainer, startOffset = range.startOffset;
       if (startContainer === range.endContainer && startContainer.hasChildNodes() && range.endOffset === startOffset + 1) {
         return startContainer.childNodes[startOffset];
+        }
         return true;
       };
     };
+    const isContentEditableTrue$2 = isContentEditableTrue$3;
+    const isContentEditableFalse$a = isContentEditableFalse$b;
+    const isBr$4 = isBr$6;
+    const isText$8 = isText$b;
+    const isInvalidTextElement = matchNodeNames([
+      'script',
+      'style',
+      'textarea'
+    ]);
+    const isAtomicInline = matchNodeNames([
+      'img',
+      'input',
+      'textarea',
+      'hr',
+      'iframe',
+      'video',
+      'audio',
+      'object',
+      'embed'
+    ]);
+    const isTable = matchNodeNames(['table']);
+    const isCaretContainer$1 = isCaretContainer$2;
+    const isCaretCandidate$3 = node => {
+      if (isCaretContainer$1(node)) {
+        return false;
+      }
+      if (isText$8(node)) {
+        return !isInvalidTextElement(node.parentNode);
+      }
+      return isAtomicInline(node) || isBr$4(node) || isTable(node) || isNonUiContentEditableFalse(node);
+    };
+    const isUnselectable = node => isElement$6(node) && node.getAttribute('unselectable') === 'true';
+    const isNonUiContentEditableFalse = node => !isUnselectable(node) && isContentEditableFalse$a(node);
+    const isInEditable = (node, root) => {
+      for (let tempNode = node.parentNode; tempNode && tempNode !== root; tempNode = tempNode.parentNode) {
+        if (isNonUiContentEditableFalse(tempNode)) {
+          return false;
+        }
+        if (isContentEditableTrue$2(tempNode)) {
+          return true;
+        }
+      }
+      return true;
+    };
+    const isAtomicContentEditableFalse = node => {
+      if (!isNonUiContentEditableFalse(node)) {
+        return false;
+      }
+      return !foldl(from(node.getElementsByTagName('*')), (result, elm) => {
+        return result || isContentEditableTrue$2(elm);
+      }, false);
+    };
+    const isAtomic$1 = node => isAtomicInline(node) || isAtomicContentEditableFalse(node);
+    const isEditableCaretCandidate$1 = (node, root) => isCaretCandidate$3(node) && isInEditable(node, root);
     const isElement$4 = isElement$6;
     const isCaretCandidate$2 = isCaretCandidate$3;
     const isBlock$2 = matchStyleValues('display', 'block table');
     const isFloated = matchStyleValues('float', 'left right');
     const isValidElementCaretCandidate = and(isElement$4, isCaretCandidate$2, not(isFloated));
     const isNotPre = not(matchStyleValues('white-space', 'pre pre-line pre-wrap'));
-    const isText$7 = isText$a;
+    const isText$7 = isText$b;
     const isBr$3 = isBr$6;
     const nodeIndex$1 = DOMUtils.nodeIndex;
     const resolveIndex$1 = getNodeUnsafe;
     const createRange$1 = doc => doc ? doc.createRange() : DOMUtils.DOM.createRng();
     const isWhiteSpace$1 = chr => isString(chr) && /[\r\n\t ]/.test(chr);
     const isRange = rng => !!rng.setStart && !!rng.setEnd;
     const isHiddenWhiteSpaceRange = range => {
       const container = range.startContainer;
       const offset = range.startOffset;
-      if (isWhiteSpace$1(range.toString()) && isNotPre(container.parentNode) && isText$a(container)) {
+      if (isWhiteSpace$1(range.toString()) && isNotPre(container.parentNode) && isText$b(container)) {
         const text = container.data;
         if (isWhiteSpace$1(text[offset - 1]) || isWhiteSpace$1(text[offset + 1])) {
           return true;
+        }
     const getBoundingClientRectWebKitText = rng => {
       const sc = rng.startContainer;
       const ec = rng.endContainer;
       const so = rng.startOffset;
       const eo = rng.endOffset;
-      if (sc === ec && isText$a(ec) && so === 0 && eo === 1) {
+      if (sc === ec && isText$b(ec) && so === 0 && eo === 1) {
         const newRng = rng.cloneRange();
         newRng.setEndAfter(ec);
         return getBoundingClientRect$1(newRng);
       } else {
         return null;
     };
     CaretPosition.fromRangeStart = range => CaretPosition(range.startContainer, range.startOffset);
     CaretPosition.fromRangeEnd = range => CaretPosition(range.endContainer, range.endOffset);
     CaretPosition.after = node => CaretPosition(node.parentNode, nodeIndex$1(node) + 1);
     CaretPosition.before = node => CaretPosition(node.parentNode, nodeIndex$1(node));
-    CaretPosition.isAbove = (pos1, pos2) => lift2(head(pos2.getClientRects()), last$3(pos1.getClientRects()), isAbove$1).getOr(false);
+    CaretPosition.isAbove = (pos1, pos2) => lift2(head(pos2.getClientRects()), last$2(pos1.getClientRects()), isAbove$1).getOr(false);
-    CaretPosition.isBelow = (pos1, pos2) => lift2(last$3(pos2.getClientRects()), head(pos1.getClientRects()), isBelow$1).getOr(false);
+    CaretPosition.isBelow = (pos1, pos2) => lift2(last$2(pos2.getClientRects()), head(pos1.getClientRects()), isBelow$1).getOr(false);
     CaretPosition.isAtStart = pos => pos ? pos.isAtStart() : false;
     CaretPosition.isAtEnd = pos => pos ? pos.isAtEnd() : false;
-    CaretPosition.isTextPosition = pos => pos ? isText$a(pos.container()) : false;
+    CaretPosition.isTextPosition = pos => pos ? isText$b(pos.container()) : false;
     CaretPosition.isElementPosition = pos => !CaretPosition.isTextPosition(pos);
     const trimEmptyTextNode$1 = (dom, node) => {
-      if (isText$a(node) && node.data.length === 0) {
+      if (isText$b(node) && node.data.length === 0) {
         dom.remove(node);
+      }
     };
     const insertNode = (dom, rng, node) => {
       } else {
         insertNode(dom, rng, node);
+      }
     };
-    const isText$6 = isText$a;
+    const isText$6 = isText$b;
-    const isBogus = isBogus$2;
+    const isBogus = isBogus$1;
     const nodeIndex = DOMUtils.nodeIndex;
     const normalizedParent = node => {
       const parentNode = node.parentNode;
       if (isBogus(parentNode)) {
+        }
         parents.push(tempNode);
+      }
       return parents;
     };
-    const create$b = (root, caretPosition) => {
+    const create$a = (root, caretPosition) => {
       let path = [];
       let container = caretPosition.container();
       let offset = caretPosition.offset();
       let outputOffset;
       if (isText$6(container)) {
+        }
         container = childNodes[offset];
+      }
       path.push(createPathItem(container));
       let parents = parentsUntil$1(root, container);
-      parents = filter$3(parents, not(isBogus$2));
+      parents = filter$3(parents, not(isBogus$1));
       path = path.concat(map$1(parents, node => {
         return createPathItem(node);
       }));
       return path.reverse().join('/') + ',' + outputOffset;
     };
     };
     const isContentEditableFalse$9 = isContentEditableFalse$b;
     const getNormalizedTextOffset$1 = (trim, container, offset) => {
       let trimmedOffset = trim(container.data.slice(0, offset)).length;
-      for (let node = container.previousSibling; node && isText$a(node); node = node.previousSibling) {
+      for (let node = container.previousSibling; node && isText$b(node); node = node.previousSibling) {
         trimmedOffset += trim(node.data).length;
+      }
       return trimmedOffset;
     };
     const getPoint = (dom, trim, normalized, rng, start) => {
       const container = start ? rng.startContainer : rng.endContainer;
       let offset = start ? rng.startOffset : rng.endOffset;
       const point = [];
       const root = dom.getRoot();
-      if (isText$a(container)) {
+      if (isText$b(container)) {
         point.push(normalized ? getNormalizedTextOffset$1(trim, container, offset) : offset);
       } else {
         let after = 0;
         const childNodes = container.childNodes;
         if (isContentEditableFalse$9(node)) {
           return node;
+        }
+      }
       if (isCaretContainer$2(node)) {
-        if (isText$a(node) && isCaretContainerBlock$1(node)) {
+        if (isText$b(node) && isCaretContainerBlock$1(node)) {
           node = node.parentNode;
+        }
         let sibling = node.previousSibling;
         if (isContentEditableFalse$9(sibling)) {
           return sibling;
       return getLocation(trim, selection, normalized, rng);
     };
     const getCaretBookmark = selection => {
       const rng = selection.getRng();
       return {
-        start: create$b(selection.dom.getRoot(), CaretPosition.fromRangeStart(rng)),
+        start: create$a(selection.dom.getRoot(), CaretPosition.fromRangeStart(rng)),
-        end: create$b(selection.dom.getRoot(), CaretPosition.fromRangeEnd(rng)),
+        end: create$a(selection.dom.getRoot(), CaretPosition.fromRangeEnd(rng)),
         forward: selection.isForward()
       };
     };
     const getRangeBookmark = selection => {
       return {
       return {
         id,
         forward
       };
     };
-    const getBookmark$2 = (selection, type, normalized = false) => {
+    const getBookmark$3 = (selection, type, normalized = false) => {
       if (type === 2) {
         return getOffsetBookmark(trim$2, normalized, selection);
       } else if (type === 3) {
         return getCaretBookmark(selection);
       } else if (type) {
       };
     };
     const isInlinePattern = pattern => pattern.type === 'inline-command' || pattern.type === 'inline-format';
+    const isBlockPattern = pattern => pattern.type === 'block-command' || pattern.type === 'block-format';
-    const isBlockPattern = pattern => pattern.type === 'block-command' || pattern.type === 'block-format';
+    const hasBlockTrigger = (pattern, trigger) => (pattern.type === 'block-command' || pattern.type === 'block-format') && pattern.trigger === trigger;
+    const normalizePattern = pattern => {
-    const normalizePattern = pattern => {
+      var _a;
       const err = message => Result.error({
         message,
         pattern
       });
           end: pattern.start,
           cmd: 'mceInsertContent',
           value: pattern.replacement
         });
       } else {
+        const trigger = (_a = pattern.trigger) !== null && _a !== void 0 ? _a : 'space';
         if (pattern.start.length === 0) {
           return err('Block pattern has empty `start` parameter');
+        }
         return formatOrCmd('Block', formats => ({
           type: 'block-format',
           start: pattern.start,
-          format: formats[0]
+          format: formats[0],
+          trigger
         }), (command, commandValue) => ({
           type: 'block-command',
           start: pattern.start,
           cmd: command,
-          value: commandValue
+          value: commandValue,
+          trigger
         }));
+      }
     };
     const getBlockPatterns = patterns => filter$5(patterns, isBlockPattern);
     const getInlinePatterns = patterns => filter$5(patterns, isInlinePattern);
     const createPatternSet = (patterns, dynamicPatternsLookup) => ({
       inlinePatterns: getInlinePatterns(patterns),
       blockPatterns: getBlockPatterns(patterns),
       dynamicPatternsLookup
     });
+    const filterByTrigger = (patterns, trigger) => {
+      return {
+        ...patterns,
+        blockPatterns: filter$5(patterns.blockPatterns, pattern => hasBlockTrigger(pattern, trigger))
+      };
+    };
     const fromRawPatterns = patterns => {
       const normalized = partition$1(map$3(patterns, normalizePattern));
       each$e(normalized.errors, err => console.error(err.message, err.pattern));
       return normalized.values;
     };
         const rawPatterns = lookupFn(ctx);
         return fromRawPatterns(rawPatterns);
       };
     };
+    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$2().deviceType;
+    const deviceDetection$1 = detect$1().deviceType;
     const isTouch = deviceDetection$1.isTouch();
     const DOM$a = DOMUtils.DOM;
     const getHash = value => {
       const items = value.indexOf('=') > 0 ? value.split(/[;,](?![^=;,]*(?:[;,]|$))/) : value.split(',');
       });
       registerOption('resize_img_proportional', {
         processor: 'boolean',
         default: true
       });
-      registerOption('event_root', { processor: 'object' });
+      registerOption('event_root', { processor: 'string' });
       registerOption('service_message', { processor: 'string' });
       registerOption('theme', {
         processor: value => value === false || isString(value) || isFunction(value),
         default: 'silver'
       });
       });
       registerOption('disable_nodechange', {
         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
       });
       registerOption('editable_root', {
         processor: 'string',
         default: 'mce-item-anchor'
       });
       registerOption('iframe_aria_text', {
         processor: 'string',
-        default: 'Rich Text Area. Press ALT-0 for help.'
+        default: 'Rich Text Area'.concat(editor.hasPlugin('help') ? '. Press ALT-0 for help.' : '')
       });
       registerOption('setup', { processor: 'function' });
       registerOption('init_instance_callback', { processor: 'function' });
       registerOption('url_converter', {
         processor: 'function',
       });
       registerOption('allow_unsafe_link_target', {
         processor: 'boolean',
         default: false
       });
+      registerOption('allow_mathml_annotation_encodings', {
+        processor: value => {
+          const valid = isArrayOf(value, isString);
+          return valid ? {
+            value,
+            valid
+          } : {
+            valid: false,
+            message: 'Must be an array of strings.'
+          };
+        },
+        default: []
+      });
       registerOption('convert_fonts_to_spans', {
         processor: 'boolean',
         default: true,
         deprecated: true
       });
       });
       registerOption('remove_script_host', {
         processor: 'boolean',
         default: true
       });
-      registerOption('custom_elements', { processor: 'string' });
+      registerOption('custom_elements', { processor: stringOrObjectProcessor });
       registerOption('extended_valid_elements', { processor: 'string' });
       registerOption('invalid_elements', { processor: 'string' });
       registerOption('invalid_styles', { processor: stringOrObjectProcessor });
       registerOption('valid_children', { processor: 'string' });
       registerOption('valid_classes', { processor: stringOrObjectProcessor });
       registerOption('a11y_advanced_options', {
         processor: 'boolean',
         default: false
       });
       registerOption('api_key', { processor: 'string' });
+      registerOption('license_key', { processor: 'string' });
       registerOption('paste_block_drop', {
         processor: 'boolean',
         default: false
       });
       registerOption('paste_data_images', {
             end: '**',
             format: 'bold'
           },
+          {
             start: '#',
-            format: 'h1'
+            format: 'h1',
+            trigger: 'space'
           },
+          {
             start: '##',
-            format: 'h2'
+            format: 'h2',
+            trigger: 'space'
           },
+          {
             start: '###',
-            format: 'h3'
+            format: 'h3',
+            trigger: 'space'
           },
+          {
             start: '####',
-            format: 'h4'
+            format: 'h4',
+            trigger: 'space'
           },
+          {
             start: '#####',
-            format: 'h5'
+            format: 'h5',
+            trigger: 'space'
           },
+          {
             start: '######',
-            format: 'h6'
+            format: 'h6',
+            trigger: 'space'
           },
+          {
-            start: '1. ',
+            start: '1.',
-            cmd: 'InsertOrderedList'
+            cmd: 'InsertOrderedList',
+            trigger: 'space'
+          },
+          {
+            start: '*',
+            cmd: 'InsertUnorderedList',
+            trigger: 'space'
           },
+          {
-            start: '* ',
+            start: '-',
-            cmd: 'InsertUnorderedList'
+            cmd: 'InsertUnorderedList',
+            trigger: 'space'
           },
+          {
+            start: '>',
+            cmd: 'mceBlockQuote',
+            trigger: 'space'
+          },
+          {
-            start: '- ',
+            start: '---',
-            cmd: 'InsertUnorderedList'
+            cmd: 'InsertHorizontalRule',
+            trigger: 'space'
+          }
+        ]
       });
       registerOption('text_patterns_lookup', {
         processor: value => {
         processor: 'boolean',
         default: true
       });
       registerOption('highlight_on_focus', {
         processor: 'boolean',
-        default: false
+        default: true
       });
       registerOption('xss_sanitization', {
         processor: 'boolean',
         default: true
       });
       });
       registerOption('newdocument_content', {
         processor: 'string',
         default: ''
       });
-      registerOption('force_hex_color', {
-        processor: value => {
-          const options = [
-            'always',
-            'rgb_only',
-            'off'
-          ];
-          const valid = contains$2(options, value);
-          return valid ? {
-            value,
-            valid
-          } : {
-            valid: false,
-            message: `Must be one of: ${ options.join(', ') }.`
-          };
-        },
-        default: 'off'
-      });
       registerOption('sandbox_iframes', {
         processor: 'boolean',
-        default: false
+        default: true
+      });
+      registerOption('sandbox_iframes_exclusions', {
+        processor: 'string[]',
+        default: [
+          'youtube.com',
+          'youtu.be',
+          'vimeo.com',
+          'player.vimeo.com',
+          'dailymotion.com',
+          'embed.music.apple.com',
+          'open.spotify.com',
+          'giphy.com',
+          'dai.ly',
+          'codepen.io'
+        ]
       });
       registerOption('convert_unsafe_embeds', {
         processor: 'boolean',
-        default: false
+        default: true
       });
       editor.on('ScriptsLoaded', () => {
         registerOption('directionality', {
           processor: 'string',
           default: I18n.isRtl() ? 'rtl' : undefined
     const isEncodingXml = editor => editor.options.get('encoding') === 'xml';
     const getAllowedImageFileTypes = editor => Tools.explode(editor.options.get('images_file_types'));
     const hasTableTabNavigation = option('table_tab_navigation');
     const getDetailsInitialState = option('details_initial_state');
     const getDetailsSerializedState = option('details_serialized_state');
-    const shouldForceHexColor = option('force_hex_color');
     const shouldSandboxIframes = option('sandbox_iframes');
+    const getSandboxIframesExclusions = editor => editor.options.get('sandbox_iframes_exclusions');
+    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$a;
+    const isText$5 = isText$b;
     const removeNode$1 = node => {
       const parentNode = node.parentNode;
       if (parentNode) {
         parentNode.removeChild(node);
       while ((idx = caretContainer.data.lastIndexOf(ZWSP$1)) !== -1) {
         caretContainer.deleteData(idx, 1);
+      }
     };
     const removeUnchanged = (caretContainer, pos) => {
-      remove$3(caretContainer);
+      remove$2(caretContainer);
       return pos;
     };
     const removeTextAndReposition = (caretContainer, pos) => {
       const before = trimCount(caretContainer.data.substr(0, pos.offset()));
       const after = trimCount(caretContainer.data.substr(pos.offset()));
     const removeElementAndReposition = (caretContainer, pos) => {
       const parentNode = pos.container();
       const newPosition = indexOf$1(from(parentNode.childNodes), caretContainer).map(index => {
         return index < pos.offset() ? CaretPosition(parentNode, pos.offset() - 1) : pos;
       }).getOr(pos);
-      remove$3(caretContainer);
+      remove$2(caretContainer);
       return newPosition;
     };
     const removeTextCaretContainer = (caretContainer, pos) => isText$5(caretContainer) && pos.container() === caretContainer ? removeTextAndReposition(caretContainer, pos) : removeUnchanged(caretContainer, pos);
     const removeElementCaretContainer = (caretContainer, pos) => pos.container() === caretContainer.parentNode ? removeElementAndReposition(caretContainer, pos) : removeUnchanged(caretContainer, pos);
     const removeAndReposition = (container, pos) => CaretPosition.isTextPosition(pos) ? removeTextCaretContainer(container, pos) : removeElementCaretContainer(container, pos);
-    const remove$3 = caretContainerNode => {
+    const remove$2 = caretContainerNode => {
       if (isElement$3(caretContainerNode) && isCaretContainer$2(caretContainerNode)) {
         if (hasContent(caretContainerNode)) {
           caretContainerNode.removeAttribute('data-mce-caret');
         } else {
           removeNode$1(caretContainerNode);
+        }
         if (isBlock(element)) {
           const caretContainer = insertBlock(caretBlock, element, before);
           const clientRect = getAbsoluteClientRect(root, element, before);
           dom.setStyle(caretContainer, 'top', clientRect.top);
+          dom.setStyle(caretContainer, 'caret-color', 'transparent');
           caretContainerNode = caretContainer;
           const caret = dom.create('div', {
             'class': 'mce-visual-caret',
             'data-mce-bogus': 'all'
           });
         return rng;
       };
       const hide = () => {
         trimInlineCaretContainers(root);
         if (caretContainerNode) {
-          remove$3(caretContainerNode);
+          remove$2(caretContainerNode);
           caretContainerNode = null;
+        }
         lastVisualCaret.on(caretState => {
           dom.remove(caretState.caret);
           lastVisualCaret.clear();
     };
     const isContentEditableTrue$1 = isContentEditableTrue$3;
     const isContentEditableFalse$7 = isContentEditableFalse$b;
     const isMedia = isMedia$2;
-    const isBlockLike = matchStyleValues('display', 'block table table-cell table-caption list-item');
+    const isBlockLike = matchStyleValues('display', 'block table table-cell table-row table-caption list-item');
     const isCaretContainer = isCaretContainer$2;
     const isCaretContainerBlock = isCaretContainerBlock$1;
     const isElement$2 = isElement$6;
-    const isText$4 = isText$a;
+    const isText$4 = isText$b;
     const isCaretCandidate$1 = isCaretCandidate$3;
-    const isForwards = direction => direction > 0;
+    const isForwards = direction => direction === 1;
-    const isBackwards = direction => direction < 0;
+    const isBackwards = direction => direction === -1;
     const skipCaretContainers = (walk, shallow) => {
       let node;
       while (node = walk(shallow)) {
         if (!isCaretContainerBlock(node)) {
+        }
+      }
       if (!range.collapsed) {
         return range;
+      }
-      if (isText$a(container)) {
+      if (isText$b(container)) {
         if (isCaretContainer(container)) {
           if (direction === 1) {
             node = leanRight(container);
             if (node) {
               return before$2(node);
         return true;
+      }
       return inSameBlock;
     };
-    var HDirection;
-    (function (HDirection) {
-      HDirection[HDirection['Backwards'] = -1] = 'Backwards';
-      HDirection[HDirection['Forwards'] = 1] = 'Forwards';
     }(HDirection || (HDirection = {})));
     const isContentEditableFalse$6 = isContentEditableFalse$b;
-    const isText$3 = isText$a;
+    const isText$3 = isText$b;
     const isElement$1 = isElement$6;
     const isBr$2 = isBr$6;
     const isCaretCandidate = isCaretCandidate$3;
     const isAtomic = isAtomic$1;
           return CaretPosition(nextSibling, 0);
         } else {
           return CaretPosition.before(nextSibling);
+        }
       } else {
-        return findCaretPosition$1(HDirection.Forwards, CaretPosition.after(nextNode), root);
+        return findCaretPosition$1(1, CaretPosition.after(nextNode), root);
+      }
     };
     const findCaretPosition$1 = (direction, startPos, root) => {
       let node;
       let nextNode;
         if (isEditableCaretCandidate(node, root)) {
           return getCaretCandidatePosition(direction, node);
+        }
+      }
       nextNode = node ? findNode(node, direction, isEditableCaretCandidate, root) : node;
-      const rootContentEditableFalseElm = last$2(filter$5(getParents$3(container, root), isContentEditableFalse$6));
+      const rootContentEditableFalseElm = last$1(filter$5(getParents$3(container, root), isContentEditableFalse$6));
       if (rootContentEditableFalseElm && (!nextNode || !rootContentEditableFalseElm.contains(nextNode))) {
         if (isForwards(direction)) {
           caretPosition = CaretPosition.after(rootContentEditableFalseElm);
         } else {
           caretPosition = CaretPosition.before(rootContentEditableFalseElm);
+      }
       return null;
     };
     const CaretWalker = root => ({
       next: caretPosition => {
-        return findCaretPosition$1(HDirection.Forwards, caretPosition, root);
+        return findCaretPosition$1(1, caretPosition, root);
       },
       prev: caretPosition => {
-        return findCaretPosition$1(HDirection.Backwards, caretPosition, root);
+        return findCaretPosition$1(-1, caretPosition, root);
+      }
     });
     const walkToPositionIn = (forward, root, start) => {
+      }
     });
     const navigateIgnore = (forward, root, from, ignoreFilter) => navigate(forward, root, from).bind(pos => ignoreFilter(pos) ? navigateIgnore(forward, root, pos, ignoreFilter) : Optional.some(pos));
     const positionIn = (forward, element) => {
       const startNode = forward ? element.firstChild : element.lastChild;
-      if (isText$a(startNode)) {
+      if (isText$b(startNode)) {
         return Optional.some(CaretPosition(startNode, forward ? 0 : startNode.data.length));
       } else if (startNode) {
         if (isCaretCandidate$3(startNode)) {
           return Optional.some(forward ? CaretPosition.before(startNode) : afterElement(startNode));
         } else {
+            }
             return tryFindRangePosition(node, rng);
+          }
           node = children[point[i]];
+        }
-        if (isText$a(node)) {
+        if (isText$b(node)) {
           offset = Math.min(point[0], node.data.length);
+        }
         if (isElement$6(node)) {
           offset = Math.min(point[0], node.childNodes.length);
+        }
           rng.setEnd(node, offset);
+        }
+      }
       return true;
     };
-    const isValidTextNode = node => isText$a(node) && node.data.length > 0;
+    const isValidTextNode = node => isText$b(node) && node.data.length > 0;
     const restoreEndPoint = (dom, suffix, bookmark) => {
       const marker = dom.get(bookmark.id + '_' + suffix);
       const markerParent = marker === null || marker === void 0 ? void 0 : marker.parentNode;
       const keep = bookmark.keep;
       if (marker && markerParent) {
+        }
         if (!keep) {
           const prev = marker.previousSibling;
           const next = marker.nextSibling;
           Tools.each(Tools.grep(marker.childNodes), node => {
-            if (isText$a(node)) {
+            if (isText$b(node)) {
               node.data = node.data.replace(/\uFEFF/g, '');
+            }
           });
           let otherMarker;
           while (otherMarker = dom.get(bookmark.id + '_' + suffix)) {
             dom.remove(otherMarker, true);
+          }
-          if (isText$a(next) && isText$a(prev) && !Env.browser.isOpera()) {
+          if (isText$b(next) && isText$b(prev) && !Env.browser.isOpera()) {
             const idx = prev.data.length;
             prev.appendData(next.data);
             dom.remove(next);
             container = prev;
             offset = idx;
+        }
+      }
       return Optional.none();
     };
-    const getBookmark$1 = (selection, type, normalized) => {
+    const getBookmark$2 = (selection, type, normalized) => {
-      return getBookmark$2(selection, type, normalized);
+      return getBookmark$3(selection, type, normalized);
     };
     const moveToBookmark = (selection, bookmark) => {
       resolve(selection, bookmark).each(({range, forward}) => {
         selection.setRng(range, forward);
     const getCellsFromEditor = editor => getCellsFromElementOrRanges(getRanges$1(editor.selection.getSel()), SugarElement.fromDom(editor.getBody()));
     const getClosestTable = (cell, isRoot) => ancestor$3(cell, 'table', isRoot);
     const getStartNode = rng => {
       const sc = rng.startContainer, so = rng.startOffset;
-      if (isText$a(sc)) {
+      if (isText$b(sc)) {
         return so === 0 ? Optional.some(SugarElement.fromDom(sc)) : Optional.none();
       } else {
         return Optional.from(sc.childNodes[so]).map(SugarElement.fromDom);
+      }
     };
     const getEndNode = rng => {
       const ec = rng.endContainer, eo = rng.endOffset;
-      if (isText$a(ec)) {
+      if (isText$b(ec)) {
         return eo === ec.data.length ? Optional.some(SugarElement.fromDom(ec)) : Optional.none();
       } else {
         return Optional.from(ec.childNodes[eo - 1]).map(SugarElement.fromDom);
+      }
         'th',
         'table'
       ], name.toLowerCase()));
       let currentNode = node;
       do {
-        if (isText$a(currentNode) && Tools.trim(currentNode.data).length !== 0) {
+        if (isText$b(currentNode) && Tools.trim(currentNode.data).length !== 0) {
           if (start) {
             rng.setStart(currentNode, 0);
           } else {
             rng.setEnd(currentNode, currentNode.data.length);
+          }
       executor(bookmark);
       selection.moveToBookmark(bookmark);
     };
     const isNode = node => isNumber(node === null || node === void 0 ? void 0 : node.nodeType);
-    const isElementNode$1 = node => isElement$6(node) && !isBookmarkNode$1(node) && !isCaretNode(node) && !isBogus$2(node);
+    const isElementNode$1 = node => isElement$6(node) && !isBookmarkNode$1(node) && !isCaretNode(node) && !isBogus$1(node);
     const isElementDirectlySelected = (dom, node) => {
       if (isElementNode$1(node) && !/^(TD|TH)$/.test(node.nodeName)) {
         const selectedAttr = dom.getAttrib(node, 'data-mce-selected');
         const value = parseInt(selectedAttr, 10);
           walker.next(true);
+        }
         for (let node = walker.current(); node; node = walker.next()) {
           if (dom.getContentEditable(node) === 'false') {
             return;
-          } else if (isText$a(node) && !isWhiteSpaceNode$1(node)) {
+          } else if (isText$b(node) && !isWhiteSpaceNode$1(node)) {
             rng.setStart(node, 0);
             selection.setRng(rng);
             return;
+          }
+        }
     const isTextBlock$1 = (schema, node) => !!schema.getTextBlockElements()[node.nodeName.toLowerCase()] || isTransparentBlock(schema, node);
     const isValid = (ed, parent, child) => {
       return ed.schema.isValidChild(parent, child);
     };
     const isWhiteSpaceNode$1 = (node, allowSpaces = false) => {
-      if (isNonNullable(node) && isText$a(node)) {
+      if (isNonNullable(node) && isText$b(node)) {
         const data = allowSpaces ? node.data.replace(/ /g, '\xA0') : node.data;
         return isWhitespaceText(data);
       } else {
         return false;
+      }
     };
     const isEmptyTextNode$1 = node => {
-      return isNonNullable(node) && isText$a(node) && node.length === 0;
+      return isNonNullable(node) && isText$b(node) && node.length === 0;
     };
     const isWrapNoneditableTarget = (editor, node) => {
       const baseDataSelector = '[data-mce-cef-wrappable]';
       const formatNoneditableSelector = getFormatNoneditableSelector(editor);
       const selector = isEmpty$3(formatNoneditableSelector) ? baseDataSelector : `${ baseDataSelector },${ formatNoneditableSelector }`;
     const shouldExpandToSelector = format => isSelectorFormat(format) && format.expand !== false && !isInlineFormat(format);
     const getEmptyCaretContainers = node => {
       const nodes = [];
       let tempNode = node;
       while (tempNode) {
-        if (isText$a(tempNode) && tempNode.data !== ZWSP$1 || tempNode.childNodes.length > 1) {
+        if (isText$b(tempNode) && tempNode.data !== ZWSP$1 || tempNode.childNodes.length > 1) {
           return [];
+        }
         if (isElement$6(tempNode)) {
           nodes.push(tempNode);
+        }
     };
     const findSpace = (start, node, offset) => walkText(start, node, offset, c => isNbsp(c) || isWhiteSpace(c));
     const findContent = (start, node, offset) => walkText(start, node, offset, isContent);
     const findWordEndPoint = (dom, body, container, offset, start, includeTrailingSpaces) => {
       let lastTextNode;
+      const closestRoot = dom.getParent(container, node => isEditingHost(node) || dom.isBlock(node));
-      const rootNode = dom.getParent(container, dom.isBlock) || body;
+      const rootNode = isNonNullable(closestRoot) ? closestRoot : body;
       const walk = (container, offset, pred) => {
         const textSeeker = TextSeeker(dom);
         const walker = start ? textSeeker.backwards : textSeeker.forwards;
         return Optional.from(walker(container, offset, (text, textOffset) => {
           if (isBookmarkNode(text.parentNode)) {
         offset: start ? 0 : lastTextNode.length
       }) : Optional.none());
     };
     const findSelectorEndPoint = (dom, formatList, rng, container, siblingName) => {
       const sibling = container[siblingName];
-      if (isText$a(container) && isEmpty$3(container.data) && sibling) {
+      if (isText$b(container) && isEmpty$3(container.data) && sibling) {
         container = sibling;
+      }
       const parents = getParents$1(dom, container);
       for (let i = 0; i < parents.length; i++) {
         for (let y = 0; y < formatList.length; y++) {
       if (isBlockFormat(format)) {
         node = format.wrapper ? null : dom.getParent(container, format.block, root);
+      }
       if (!node) {
         const scopeRoot = (_a = dom.getParent(container, 'LI,TD,TH,SUMMARY')) !== null && _a !== void 0 ? _a : root;
-        node = dom.getParent(isText$a(container) ? container.parentNode : container, node => node !== root && isTextBlock(dom.schema, node), scopeRoot);
+        node = dom.getParent(isText$b(container) ? container.parentNode : container, node => node !== root && isTextBlock(dom.schema, node), scopeRoot);
+      }
       if (node && isBlockFormat(format) && format.wrapper) {
         node = getParents$1(dom, node, 'ul,ol').reverse()[0] || node;
+      }
       if (!node) {
         return true;
       } else {
         return isAtBlockBoundary$1(dom, root, parent, siblingName);
+      }
     };
-    const findParentContainer = (dom, formatList, container, offset, start) => {
+    const findParentContainer = (dom, formatList, container, offset, start, expandToBlock) => {
       let parent = container;
       const siblingName = start ? 'previousSibling' : 'nextSibling';
       const root = dom.getRoot();
-      if (isText$a(container) && !isWhiteSpaceNode(container)) {
+      if (isText$b(container) && !isWhiteSpaceNode(container)) {
         if (start ? offset > 0 : offset < container.data.length) {
           return container;
+        }
+      }
       while (parent) {
+        if (isEditingHost(parent)) {
+          return container;
+        }
         if (!formatList[0].block_expand && dom.isBlock(parent)) {
-          return parent;
+          return expandToBlock ? parent : container;
+        }
         for (let sibling = parent[siblingName]; sibling; sibling = sibling[siblingName]) {
-          const allowSpaces = isText$a(sibling) && !isAtBlockBoundary$1(dom, root, sibling, siblingName);
+          const allowSpaces = isText$b(sibling) && !isAtBlockBoundary$1(dom, root, sibling, siblingName);
           if (!isBookmarkNode(sibling) && !isBogusBr(sibling) && !isWhiteSpaceNode(sibling, allowSpaces)) {
             return parent;
+          }
+        }
         if (parent === root || parent.parentNode === root) {
         parent = parent.parentNode;
+      }
       return container;
     };
     const isSelfOrParentBookmark = container => isBookmarkNode(container.parentNode) || isBookmarkNode(container);
-    const expandRng = (dom, rng, formatList, includeTrailingSpace = false) => {
+    const expandRng = (dom, rng, formatList, expandOptions = {}) => {
+      const {includeTrailingSpace = false, expandToBlock = true} = expandOptions;
+      const editableHost = dom.getParent(rng.commonAncestorContainer, node => isEditingHost(node));
+      const root = isNonNullable(editableHost) ? editableHost : dom.getRoot();
       let {startContainer, startOffset, endContainer, endOffset} = rng;
       const format = formatList[0];
       if (isElement$6(startContainer) && startContainer.hasChildNodes()) {
         startContainer = getNode$1(startContainer, startOffset);
-        if (isText$a(startContainer)) {
+        if (isText$b(startContainer)) {
           startOffset = 0;
+        }
+      }
       if (isElement$6(endContainer) && endContainer.hasChildNodes()) {
         endContainer = getNode$1(endContainer, rng.collapsed ? endOffset : endOffset - 1);
-        if (isText$a(endContainer)) {
+        if (isText$b(endContainer)) {
           endOffset = endContainer.data.length;
+        }
+      }
       startContainer = findParentContentEditable(dom, startContainer);
       endContainer = findParentContentEditable(dom, endContainer);
         if (rng.collapsed) {
           startContainer = startContainer.previousSibling || startContainer;
         } else {
           startContainer = startContainer.nextSibling || startContainer;
+        }
-        if (isText$a(startContainer)) {
+        if (isText$b(startContainer)) {
           startOffset = rng.collapsed ? startContainer.length : 0;
+        }
+      }
       if (isSelfOrParentBookmark(endContainer)) {
         endContainer = isBookmarkNode(endContainer) ? endContainer : endContainer.parentNode;
         if (rng.collapsed) {
           endContainer = endContainer.nextSibling || endContainer;
         } else {
           endContainer = endContainer.previousSibling || endContainer;
+        }
-        if (isText$a(endContainer)) {
+        if (isText$b(endContainer)) {
           endOffset = rng.collapsed ? 0 : endContainer.length;
+        }
+      }
       if (rng.collapsed) {
-        const startPoint = findWordEndPoint(dom, dom.getRoot(), startContainer, startOffset, true, includeTrailingSpace);
+        const startPoint = findWordEndPoint(dom, root, startContainer, startOffset, true, includeTrailingSpace);
         startPoint.each(({container, offset}) => {
           startContainer = container;
           startOffset = offset;
         });
-        const endPoint = findWordEndPoint(dom, dom.getRoot(), endContainer, endOffset, false, includeTrailingSpace);
+        const endPoint = findWordEndPoint(dom, root, endContainer, endOffset, false, includeTrailingSpace);
         endPoint.each(({container, offset}) => {
           endContainer = container;
           endOffset = offset;
         });
+      }
       if (isInlineFormat(format) || format.block_expand) {
-        if (!isInlineFormat(format) || (!isText$a(startContainer) || startOffset === 0)) {
+        if (!isInlineFormat(format) || (!isText$b(startContainer) || startOffset === 0)) {
-          startContainer = findParentContainer(dom, formatList, startContainer, startOffset, true);
+          startContainer = findParentContainer(dom, formatList, startContainer, startOffset, true, expandToBlock);
+        }
-        if (!isInlineFormat(format) || (!isText$a(endContainer) || endOffset === endContainer.data.length)) {
+        if (!isInlineFormat(format) || (!isText$b(endContainer) || endOffset === endContainer.data.length)) {
-          endContainer = findParentContainer(dom, formatList, endContainer, endOffset, false);
+          endContainer = findParentContainer(dom, formatList, endContainer, endOffset, false, expandToBlock);
+        }
+      }
       if (shouldExpandToSelector(format)) {
         startContainer = findSelectorEndPoint(dom, formatList, rng, startContainer, 'previousSibling');
         endContainer = findSelectorEndPoint(dom, formatList, rng, endContainer, 'nextSibling');
       if (isBlockFormat(format) || isSelectorFormat(format)) {
         startContainer = findBlockEndPoint(dom, formatList, startContainer, 'previousSibling');
         endContainer = findBlockEndPoint(dom, formatList, endContainer, 'nextSibling');
         if (isBlockFormat(format)) {
           if (!dom.isBlock(startContainer)) {
-            startContainer = findParentContainer(dom, formatList, startContainer, startOffset, true);
+            startContainer = findParentContainer(dom, formatList, startContainer, startOffset, true, expandToBlock);
+            if (isText$b(startContainer)) {
+              startOffset = 0;
+            }
+          }
           if (!dom.isBlock(endContainer)) {
-            endContainer = findParentContainer(dom, formatList, endContainer, endOffset, false);
+            endContainer = findParentContainer(dom, formatList, endContainer, endOffset, false, expandToBlock);
+            if (isText$b(endContainer)) {
+              endOffset = endContainer.data.length;
+            }
+          }
+        }
+      }
       if (isElement$6(startContainer) && startContainer.parentNode) {
         startOffset = dom.nodeIndex(startContainer);
       const startContainer = getNode$1(rng.startContainer, startOffset);
       const endOffset = rng.endOffset;
       const endContainer = getNode$1(rng.endContainer, endOffset - 1);
       const exclude = nodes => {
         const firstNode = nodes[0];
-        if (isText$a(firstNode) && firstNode === startContainer && startOffset >= firstNode.data.length) {
+        if (isText$b(firstNode) && firstNode === startContainer && startOffset >= firstNode.data.length) {
           nodes.splice(0, 1);
+        }
         const lastNode = nodes[nodes.length - 1];
-        if (endOffset === 0 && nodes.length > 0 && lastNode === endContainer && isText$a(lastNode)) {
+        if (endOffset === 0 && nodes.length > 0 && lastNode === endContainer && isText$b(lastNode)) {
           nodes.splice(nodes.length - 1, 1);
+        }
         return nodes;
       };
       const collectSiblings = (node, name, endNode) => {
       'div[data-ephox-embed-iri]',
       'div.tiny-pageembed',
       'div.mce-toc',
       'div[data-mce-toc]'
     ];
-    const isZeroWidth = elem => isText$b(elem) && get$3(elem) === ZWSP$1;
+    const isZeroWidth = elem => isText$c(elem) && get$3(elem) === ZWSP$1;
     const context = (editor, elem, wrapName, nodeName) => parent(elem).fold(() => 'skipping', parent => {
       if (nodeName === 'br' || isZeroWidth(elem)) {
         return 'valid';
       } else if (isAnnotation(elem)) {
         return 'existing';
       editor.selection.setRng(rng);
     };
     const applyAnnotation = (elem, masterUId, data, annotationName, decorate, directAnnotation) => {
       const {uid = masterUId, ...otherData} = data;
       add$2(elem, annotation());
-      set$3(elem, `${ dataAnnotationId() }`, uid);
+      set$4(elem, `${ dataAnnotationId() }`, uid);
-      set$3(elem, `${ dataAnnotation() }`, annotationName);
+      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(','));
+        }
+      }
     };
     const removeDirectAnnotation = elem => {
-      remove$7(elem, annotation());
+      remove$6(elem, annotation());
-      remove$a(elem, `${ dataAnnotationId() }`);
+      remove$9(elem, `${ dataAnnotationId() }`);
-      remove$a(elem, `${ dataAnnotation() }`);
+      remove$9(elem, `${ dataAnnotation() }`);
-      remove$a(elem, `${ dataAnnotationActive() }`);
+      remove$9(elem, `${ dataAnnotationActive() }`);
       const customAttrNames = getOpt(elem, `${ dataAnnotationAttributes() }`).map(names => names.split(',')).getOr([]);
       const customClasses = getOpt(elem, `${ dataAnnotationClasses() }`).map(names => names.split(',')).getOr([]);
-      each$e(customAttrNames, name => remove$a(elem, name));
+      each$e(customAttrNames, name => remove$9(elem, name));
-      remove$4(elem, customClasses);
+      remove$3(elem, customClasses);
-      remove$a(elem, `${ dataAnnotationClasses() }`);
+      remove$9(elem, `${ dataAnnotationClasses() }`);
-      remove$a(elem, `${ dataAnnotationAttributes() }`);
+      remove$9(elem, `${ dataAnnotationAttributes() }`);
     };
     const makeAnnotation = (eDoc, uid, data, annotationName, decorate) => {
       const master = SugarElement.fromTag('span', eDoc);
       applyAnnotation(master, uid, data, annotationName, decorate, false);
       return master;
+        }
       });
     };
     const Annotator = editor => {
-      const registry = create$c();
+      const registry = create$b();
       setup$x(editor, registry);
       const changes = setup$y(editor, registry);
       const isSpan = isTag('span');
       const removeAnnotations = elements => {
       };
     };
     const BookmarkManager = selection => {
       return {
-        getBookmark: curry(getBookmark$1, selection),
+        getBookmark: curry(getBookmark$2, selection),
         moveToBookmark: curry(moveToBookmark, selection)
       };
     };
       } else {
         return exists(range.getClientRects(), rect => containsXY(rect, clientX, clientY));
+      }
     };
+    const getDocument = () => SugarElement.fromDom(document);
-    const firePreProcess = (editor, args) => editor.dispatch('PreProcess', args);
-    const firePostProcess = (editor, args) => editor.dispatch('PostProcess', args);
+    const focus$1 = (element, preventScroll = false) => element.dom.focus({ preventScroll });
-    const fireRemove = editor => {
+    const hasFocus$1 = element => {
+      const root = getRootNode(element).dom;
-      editor.dispatch('remove');
+      return element.dom === root.activeElement;
+    };
+    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,
-    const fireDetach = editor => {
+      cata,
-      editor.dispatch('detach');
+      getStart: getStart$2
+    };
+    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 fireSwitchMode = (editor, mode) => {
+    const getWin = selection => {
+      const start = getStart$1(selection);
-      editor.dispatch('SwitchMode', { mode });
+      return defaultView(start);
     };
-    const fireObjectResizeStart = (editor, target, width, height, origin) => {
+    const range = SimRange.create;
-      editor.dispatch('ObjectResizeStart', {
+    const SimSelection = {
-        target,
+      domRange,
-        width,
+      relative,
+      exact,
-        height,
+      exactFromRange,
-        origin
+      getWin,
-      });
+      range
+    };
-    };
-    const fireObjectResized = (editor, target, width, height, origin) => {
+    const clamp$1 = (offset, element) => {
-      editor.dispatch('ObjectResized', {
+      const max = isText$c(element) ? get$3(element).length : children$1(element).length + 1;
-        target,
+      if (offset > max) {
-        width,
+        return max;
-        height,
+      } else if (offset < 0) {
-        origin
+        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 firePreInit = editor => {
+    const readRange = win => {
+      const selection = win.getSelection();
+      const rng = !selection || selection.rangeCount === 0 ? Optional.none() : Optional.from(selection.getRangeAt(0));
-      editor.dispatch('PreInit');
+      return rng.map(nativeRangeToSelectionRange);
     };
-    const firePostRender = editor => {
+    const getBookmark$1 = root => {
+      const win = defaultView(root);
-      editor.dispatch('PostRender');
+      return readRange(win.dom).filter(isRngInRoot(root));
+    };
-    };
+    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);
-    const fireInit = editor => {
+      } catch (_a) {
+        return Optional.none();
       editor.dispatch('Init');
     };
+    const store = editor => {
-    const firePlaceholderToggle = (editor, state) => {
+      const newBookmark = shouldStore(editor) ? getBookmark$1(SugarElement.fromDom(editor.getBody())) : Optional.none();
-      editor.dispatch('PlaceholderToggle', { state });
+      editor.bookmark = newBookmark.isSome() ? newBookmark : editor.bookmark;
     };
-    const fireError = (editor, errorType, error) => {
+    const getRng = editor => {
+      const bookmark = editor.bookmark ? editor.bookmark : Optional.none();
-      editor.dispatch(errorType, error);
+      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 FocusManager = { isEditorUIElement: isEditorUIElement$1 };
-    };
+    const wrappedSetTimeout = (callback, time) => {
+      if (!isNumber(time)) {
+        time = 0;
+      }
+      return setTimeout(callback, time);
+    };
-    const fireFormatApply = (editor, format, node, vars) => {
+    const wrappedSetInterval = (callback, time) => {
-      editor.dispatch('FormatApply', {
+      if (!isNumber(time)) {
+        time = 0;
+      }
+      return setInterval(callback, time);
+    };
+    const Delay = {
+      setEditorTimeout: (editor, callback, time) => {
+        return wrappedSetTimeout(() => {
+          if (!editor.removed) {
-        format,
+            callback();
+          }
+        }, time);
+      },
+      setEditorInterval: (editor, callback, time) => {
+        const timer = wrappedSetInterval(() => {
+          if (!editor.removed) {
+            callback();
+          } else {
-        node,
+            clearInterval(timer);
+          }
+        }, time);
+        return timer;
+      }
+    };
+    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', () => {
-        vars
+        DOMUtils.DOM.unbind(document, 'mouseup', mouseUpPage);
       });
     };
-    const fireFormatRemove = (editor, format, node, vars) => {
+    const registerMouseUp = (editor, throttledStore) => {
-      editor.dispatch('FormatRemove', {
+      editor.on('mouseup touchend', _e => {
-        format,
-        node,
-        vars
+        throttledStore.throttle();
       });
     };
-    const fireBeforeSetContent = (editor, args) => editor.dispatch('BeforeSetContent', args);
+    const registerEditorEvents = (editor, throttledStore) => {
-    const fireSetContent = (editor, args) => editor.dispatch('SetContent', args);
+      registerMouseUp(editor, throttledStore);
-    const fireBeforeGetContent = (editor, args) => editor.dispatch('BeforeGetContent', args);
+      editor.on('keyup NodeChange AfterSetSelectionRange', e => {
-    const fireGetContent = (editor, args) => editor.dispatch('GetContent', args);
+        if (!isManualNodeChange(e)) {
+          store(editor);
-    const fireAutocompleterStart = (editor, args) => {
+        }
-      editor.dispatch('AutocompleterStart', args);
+      });
     };
+    const register$6 = editor => {
+      const throttledStore = first$1(() => {
+        store(editor);
+      }, 0);
+      editor.on('init', () => {
+        if (editor.inline) {
+          registerPageMouseUp(editor, throttledStore);
-    const fireAutocompleterUpdate = (editor, args) => {
+        }
+        registerEditorEvents(editor, throttledStore);
+      });
+      editor.on('remove', () => {
+        throttledStore.cancel();
-      editor.dispatch('AutocompleterUpdate', args);
+      });
+    };
+    let documentFocusInHandler;
-    };
+    const DOM$9 = DOMUtils.DOM;
-    const fireAutocompleterEnd = editor => {
+    const isEditorUIElement = elm => {
-      editor.dispatch('AutocompleterEnd');
+      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);
-    const firePastePreProcess = (editor, html, internal) => editor.dispatch('PastePreProcess', {
+      });
+      return parent !== null;
+    };
-      content: html,
+    const getActiveElement = editor => {
+      try {
+        const root = getRootNode(SugarElement.fromDom(editor.getElement()));
+        return active$1(root).fold(() => document.body, x => x.dom);
+      } catch (_a) {
+        return document.body;
-      internal
+      }
+    };
+    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');
+        }
+      };
+      editor.on('focusin', () => {
+        const focusedEditor = editorManager.focusedEditor;
+        if (isEditorContentAreaElement(getActiveElement(editor))) {
+          toggleContentAreaOnFocus(editor, add$2);
+        }
+        if (focusedEditor !== editor) {
+          if (focusedEditor) {
+            focusedEditor.dispatch('blur', { focusedEditor: editor });
+          }
+          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 (!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;
+                }
+              }
-    const firePastePostProcess = (editor, node, internal) => editor.dispatch('PastePostProcess', {
+            });
+          }
+        };
+        DOM$9.bind(document, 'focusin', documentFocusInHandler);
+      }
+    };
+    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 setup$w = editorManager => {
+      editorManager.on('AddEditor', curry(registerEvents$1, editorManager));
+      editorManager.on('RemoveEditor', curry(unregisterDocumentEvents, editorManager));
+    };
+    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)) {
-      node,
+        return Optional.some(root);
+      } else {
+        return Optional.none();
       internal
+    });
+    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 focusBody = body => {
+      if (body.setActive) {
+        try {
+          body.setActive();
+        } catch (_a) {
+          body.focus();
+        }
+      } else {
+        body.focus();
+      }
+    };
+    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 contentEditableHost = getContentEditableHost(editor, selection.getNode());
+      if (contentEditableHost && editor.dom.isChildOf(contentEditableHost, body)) {
+        if (!hasContentEditableFalseParent$1(editor, contentEditableHost)) {
+          focusBody(body);
+        }
+        focusBody(contentEditableHost);
+        if (!editor.hasEditableRoot()) {
+          restoreBookmark(editor);
+        }
+        normalizeSelection(editor, rng);
+        activateEditor(editor);
+        return;
+      }
+      if (!editor.inline) {
+        if (!Env.browser.isOpera()) {
+          focusBody(body);
+        }
+        editor.getWin().focus();
+      }
+      if (Env.browser.isFirefox() || editor.inline) {
+        focusBody(body);
+        normalizeSelection(editor, rng);
+      }
+      activateEditor(editor);
-    const firePastePlainTextToggle = (editor, state) => editor.dispatch('PastePlainTextToggle', { state });
+    };
+    const activateEditor = editor => editor.editorManager.setActive(editor);
+    const focus = (editor, skipFocus) => {
+      if (editor.removed) {
+        return;
+      }
+      if (skipFocus) {
+        activateEditor(editor);
+      } else {
+        focusEditor(editor);
+      }
-    const fireEditableRootStateChange = (editor, state) => editor.dispatch('EditableRootStateChange', { state });
+    };
     const VK = {
       BACKSPACE: 8,
       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 startX, startY, startW, startH, ratio, resizeStarted;
       let width;
       let height;
       let startScrollWidth;
       let startScrollHeight;
       const isImage = elm => isNonNullable(elm) && (isImg(elm) || dom.is(elm, 'figure.image'));
           return [elm];
+        }
       };
       const isResizable = elm => {
         const selector = getObjectResizing(editor);
-        if (!selector) {
+        if (!selector || editor.mode.isReadOnly()) {
           return false;
+        }
         if (elm.getAttribute('data-mce-resize') === 'false') {
           return false;
+        }
           return is$1(SugarElement.fromDom(elm.firstElementChild), selector);
         } else {
           return is$1(SugarElement.fromDom(elm), selector);
+        }
       };
-      const createGhostElement = elm => {
+      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);
+        }
       };
       const setSizeProp = (element, name, value) => {
           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,
                 left: '0',
                 top: '0',
                 width: '100%',
                 height: '100%'
               });
-              selectedElmGhost = createGhostElement(selectedElm);
+              selectedElmGhost = createGhostElement(dom, selectedElm);
               dom.addClass(selectedElmGhost, 'mce-clonedresizable');
               dom.setAttrib(selectedElmGhost, 'data-mce-bogus', 'all');
               selectedElmGhost.contentEditable = 'false';
               dom.setStyles(selectedElmGhost, {
                 left: selectedElmX,
         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()) {
+        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);
         });
       };
       const disableGeckoResize = () => {
         try {
           editor.getDoc().execCommand('enableObjectResizing', false, 'false');
-        } catch (ex) {
+        } catch (_a) {
+        }
       };
       editor.on('init', () => {
         disableGeckoResize();
         editor.on('NodeChange ResizeEditor ResizeWindow ResizeContent drop', updateResizeRect);
       rng.setStart(start.dom, soffset);
       rng.setEnd(finish.dom, foffset);
       return rng;
     };
-    const adt$3 = Adt.generate([
+    const adt$1 = Adt.generate([
+      {
         ltr: [
           '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));
+        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$3.ltr, rng);
+        return fromRange(win, adt$1.ltr, rng);
+      }
     };
     const diagnose = (win, selection) => {
       const ranges = getRanges(win, selection);
       return doDiagnose(win, ranges);
     };
-    adt$3.ltr;
+    adt$1.ltr;
-    adt$3.rtl;
+    adt$1.rtl;
-    const create$a = (start, soffset, finish, foffset) => ({
-      start,
-      soffset,
-      finish,
-      foffset
-    });
-    const SimRange = { create: create$a };
     const caretPositionFromPoint = (doc, x, y) => {
-      var _a, _b;
+      var _a;
-      return Optional.from((_b = (_a = doc.dom).caretPositionFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y)).bind(pos => {
+      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.dom.createRange();
+        const r = doc.createRange();
         r.setStart(pos.offsetNode, pos.offset);
         r.collapse();
         return Optional.some(r);
       });
     };
     const caretRangeFromPoint = (doc, x, y) => {
-      var _a, _b;
+      var _a;
-      return Optional.from((_b = (_a = doc.dom).caretRangeFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y));
+      return Optional.from((_a = doc.caretRangeFromPoint) === null || _a === void 0 ? void 0 : _a.call(doc, x, y));
     };
-    const availableSearch = (() => {
+    const availableSearch = (doc, x, y) => {
-      if (document.caretPositionFromPoint) {
+      if (doc.caretPositionFromPoint) {
-        return caretPositionFromPoint;
+        return caretPositionFromPoint(doc, x, y);
-      } else if (document.caretRangeFromPoint) {
+      } else if (doc.caretRangeFromPoint) {
-        return caretRangeFromPoint;
+        return caretRangeFromPoint(doc, x, y);
       } else {
-        return Optional.none;
+        return Optional.none();
       }
-    })();
+    };
     const fromPoint$1 = (win, x, y) => {
-      const doc = SugarElement.fromDom(win.document);
+      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 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 beforeSpecial = (element, offset) => {
       const name$1 = name(element);
       if ('input' === name$1) {
       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$a(node) && node.data.length > 0) {
+        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 (container.hasChildNodes()) {
           offset = Math.min(!directionLeft && offset > 0 ? offset - 1 : offset, container.childNodes.length - 1);
           container = container.childNodes[offset];
-          offset = isText$a(container) && isAfterNode ? container.data.length : 0;
+          offset = isText$b(container) && isAfterNode ? container.data.length : 0;
           if (!collapsed && container === body.lastChild && isTable$2(container)) {
             return Optional.none();
+          }
           if (hasContentEditableFalseParent(body, container) || isCaretContainer$2(container)) {
             return Optional.none();
             do {
               if (isContentEditableFalse$b(node) || isCaretContainer$2(node)) {
                 normalized = false;
                 break;
+              }
-              if (isText$a(node) && node.data.length > 0) {
+              if (isText$b(node) && node.data.length > 0) {
                 offset = directionLeft ? 0 : node.data.length;
                 container = node;
                 normalized = true;
                 break;
+              }
             } while (node = directionLeft ? walker.next() : walker.prev());
+          }
+        }
+      }
       if (collapsed) {
-        if (isText$a(container) && offset === 0) {
+        if (isText$b(container) && offset === 0) {
           findTextNodeRelative(dom, isAfterNode, collapsed, true, container).each(pos => {
             container = pos.container();
             offset = pos.offset();
             normalized = true;
           });
               normalized = true;
             });
+          }
+        }
+      }
-      if (directionLeft && !collapsed && isText$a(container) && offset === container.data.length) {
+      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;
         });
     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$a(startContainer)) {
+      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;
           } else {
             endOffset = 0;
+          }
+        }
       } else {
-        if (isText$a(startContainer) && startOffset > 0 && startOffset < startContainer.data.length) {
+        if (isText$b(startContainer) && startOffset > 0 && startOffset < startContainer.data.length) {
           startContainer = splitText(startContainer, startOffset);
           startOffset = 0;
+        }
-        if (isText$a(endContainer) && endOffset > 0 && endOffset < endContainer.data.length) {
+        if (isText$b(endContainer) && endOffset > 0 && endOffset < endContainer.data.length) {
           const newContainer = splitText(endContainer, endOffset).previousSibling;
           endContainer = newContainer;
           endOffset = newContainer.data.length;
+        }
+      }
           return true;
         });
       };
       const expand = (rng, options = { type: 'word' }) => {
         if (options.type === 'word') {
-          const rangeLike = expandRng(dom, rng, [{ inline: 'span' }]);
+          const rangeLike = expandRng(dom, rng, [{ inline: 'span' }], {
+            includeTrailingSpace: false,
+            expandToBlock: false
+          });
           const newRange = dom.createRng();
           newRange.setStart(rangeLike.startContainer, rangeLike.startOffset);
           newRange.setEnd(rangeLike.endContainer, rangeLike.endOffset);
           return newRange;
+        }
       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);
           if (name(last) === 'img') {
             return {
               element: last,
               offset: 1
             };
-          } else if (isText$b(last)) {
+          } else if (isText$c(last)) {
             return {
               element: last,
               offset: get$3(last).length
             };
           } else {
     };
     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$5(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 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 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 clamp$1 = (offset, element) => {
-      const max = isText$b(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 getBookmark = root => {
-      const win = defaultView(root);
-      return readRange(win.dom).filter(isRngInRoot(root));
-    };
-    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 store = editor => {
-      const newBookmark = shouldStore(editor) ? getBookmark(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 FocusManager = { isEditorUIElement: isEditorUIElement$1 };
-    const wrappedSetTimeout = (callback, time) => {
-      if (!isNumber(time)) {
-        time = 0;
-      }
-      return setTimeout(callback, time);
-    };
-    const wrappedSetInterval = (callback, time) => {
-      if (!isNumber(time)) {
-        time = 0;
-      }
-      return setInterval(callback, time);
-    };
-    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 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 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);
-        }
-      });
-    };
-    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();
-      });
-    };
-    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');
-        }
-      };
-      editor.on('focusin', () => {
-        const focusedEditor = editorManager.focusedEditor;
-        if (isEditorContentAreaElement(getActiveElement(editor))) {
-          toggleContentAreaOnFocus(editor, add$2);
-        }
-        if (focusedEditor !== editor) {
-          if (focusedEditor) {
-            focusedEditor.dispatch('blur', { focusedEditor: editor });
-          }
-          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$7);
-          }
-          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 unregisterDocumentEvents = (editorManager, e) => {
-      if (editorManager.focusedEditor === e.editor) {
-        editorManager.focusedEditor = null;
-      }
-      if (!editorManager.activeEditor && documentFocusInHandler) {
-        DOM$9.unbind(document, 'focusin', documentFocusInHandler);
-        documentFocusInHandler = null;
-      }
-    };
-    const setup$w = editorManager => {
-      editorManager.on('AddEditor', curry(registerEvents$1, editorManager));
-      editorManager.on('RemoveEditor', curry(unregisterDocumentEvents, editorManager));
-    };
-    const getContentEditableHost = (editor, node) => editor.dom.getParent(node, node => editor.dom.getContentEditable(node) === 'true');
-    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 Optional.none();
-      }
-    });
-    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 focusBody = body => {
-      if (body.setActive) {
-        try {
-          body.setActive();
-        } catch (ex) {
-          body.focus();
-        }
-      } else {
-        body.focus();
-      }
-    };
-    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();
-      if (isNonNullable(editor.bookmark) && !hasFocus(editor)) {
-        getRng(editor).each(bookmarkRng => {
-          editor.selection.setRng(bookmarkRng);
-          rng = bookmarkRng;
-        });
-      }
-      const contentEditableHost = getContentEditableHost(editor, selection.getNode());
-      if (contentEditableHost && editor.dom.isChildOf(contentEditableHost, body)) {
-        focusBody(contentEditableHost);
-        normalizeSelection(editor, rng);
-        activateEditor(editor);
-        return;
-      }
-      if (!editor.inline) {
-        if (!Env.browser.isOpera()) {
-          focusBody(body);
-        }
-        editor.getWin().focus();
-      }
-      if (Env.browser.isFirefox() || editor.inline) {
-        focusBody(body);
-        normalizeSelection(editor, rng);
-      }
-      activateEditor(editor);
-    };
-    const activateEditor = editor => editor.editorManager.setActive(editor);
-    const focus = (editor, skipFocus) => {
-      if (editor.removed) {
-        return;
-      }
-      if (skipFocus) {
-        activateEditor(editor);
-      } else {
-        focusEditor(editor);
-      }
-    };
     const isEditableRange = (dom, rng) => {
       if (rng.collapsed) {
         return dom.isEditable(rng.startContainer);
       } else {
       const container = start ? rng.startContainer : rng.endContainer;
       const offset = start ? rng.startOffset : rng.endOffset;
       return Optional.from(container).map(SugarElement.fromDom).map(elm => !real || !rng.collapsed ? child$1(elm, resolve(elm, offset)).getOr(elm) : elm).bind(elm => isElement$7(elm) ? Optional.some(elm) : parent(elm).filter(isElement$7)).map(elm => elm.dom).getOr(root);
     };
     const getStart = (root, rng, real = false) => getEndpointElement(root, rng, true, real, (elm, offset) => Math.min(childNodesCount(elm), offset));
-    const getEnd$1 = (root, rng, real = false) => getEndpointElement(root, rng, false, real, (elm, offset) => offset > 0 ? offset - 1 : offset);
+    const getEnd = (root, rng, real = false) => getEndpointElement(root, rng, false, real, (elm, offset) => offset > 0 ? offset - 1 : offset);
     const skipEmptyTextNodes = (node, forwards) => {
       const orig = node;
-      while (node && isText$a(node) && node.length === 0) {
+      while (node && isText$b(node) && node.length === 0) {
         node = forwards ? node.nextSibling : node.previousSibling;
+      }
       return node || orig;
     };
     const getNode = (root, rng) => {
             if (startContainer.hasChildNodes()) {
               node = startContainer.childNodes[startOffset];
+            }
+          }
+        }
-        if (isText$a(startContainer) && isText$a(endContainer)) {
+        if (isText$b(startContainer) && isText$b(endContainer)) {
           if (startContainer.length === startOffset) {
             startContainer = skipEmptyTextNodes(startContainer.nextSibling, true);
           } else {
             startContainer = startContainer.parentNode;
+          }
           if (startContainer && startContainer === endContainer) {
             node = startContainer;
+          }
+        }
+      }
-      const elm = isText$a(node) ? node.parentNode : node;
+      const elm = isText$b(node) ? node.parentNode : node;
       return isHTMLElement(elm) ? elm : root;
     };
     const getSelectedBlocks = (dom, rng, startElm, endElm) => {
       const selectedBlocks = [];
       const root = dom.getRoot();
       const start = dom.getParent(startElm || getStart(root, rng, rng.collapsed), dom.isBlock);
-      const end = dom.getParent(endElm || getEnd$1(root, rng, rng.collapsed), dom.isBlock);
+      const end = dom.getParent(endElm || getEnd(root, rng, rng.collapsed), dom.isBlock);
       if (start && start !== root) {
         selectedBlocks.push(start);
+      }
       if (start && end && start !== end) {
         let node;
     const processRanges = (editor, ranges) => map$3(ranges, range => {
       const evt = editor.dispatch('GetSelectionRange', { range });
       return evt.range !== range ? evt.range : range;
     });
-    const getEnd = element => name(element) === 'img' ? 1 : getOption(element).fold(() => children$1(element).length, v => v.length);
-    const isTextNodeWithCursorPosition = el => getOption(el).filter(text => text.trim().length !== 0 || text.indexOf(nbsp) > -1).isSome();
-    const isContentEditableFalse$5 = elem => isHTMLElement$1(elem) && get$9(elem, 'contenteditable') === 'false';
-    const elementsWithCursorPosition = [
-      'img',
-      'br'
-    ];
-    const isCursorPosition = elem => {
-      const hasCursorPosition = isTextNodeWithCursorPosition(elem);
-      return hasCursorPosition || contains$2(elementsWithCursorPosition, name(elem)) || isContentEditableFalse$5(elem);
-    };
-    const first = element => descendant$2(element, isCursorPosition);
-    const last = element => descendantRtl(element, isCursorPosition);
-    const descendantRtl = (scope, predicate) => {
-      const descend = element => {
-        const children = children$1(element);
-        for (let i = children.length - 1; i >= 0; i--) {
-          const child = children[i];
-          if (predicate(child)) {
-            return Optional.some(child);
-          }
-          const res = descend(child);
-          if (res.isSome()) {
-            return res;
-          }
-        }
-        return Optional.none();
-      };
-      return descend(scope);
-    };
-    const autocompleteSelector = '[data-mce-autocompleter]';
-    const create$9 = (editor, range) => {
-      if (findIn(SugarElement.fromDom(editor.getBody())).isNone()) {
-        const wrapper = SugarElement.fromHtml('<span data-mce-autocompleter="1" data-mce-bogus="1"></span>', editor.getDoc());
-        append$1(wrapper, SugarElement.fromDom(range.extractContents()));
-        range.insertNode(wrapper.dom);
-        parent(wrapper).each(elm => elm.dom.normalize());
-        last(wrapper).map(last => {
-          editor.selection.setCursorLocation(last.dom, getEnd(last));
-        });
-      }
-    };
-    const detect$1 = elm => closest$3(elm, autocompleteSelector);
-    const findIn = elm => descendant$1(elm, autocompleteSelector);
-    const remove$2 = (editor, elm) => findIn(elm).each(wrapper => {
-      const bookmark = editor.selection.getBookmark();
-      unwrap(wrapper);
-      editor.selection.moveToBookmark(bookmark);
-    });
     const typeLookup = {
       '#text': 3,
       '#comment': 8,
       '#cdata': 4,
     const hasTemporaryNode = (tempAttrs, body) => body.querySelector(getTemporaryNodeSelector(tempAttrs)) !== null;
     const trimTemporaryNodes = (tempAttrs, body) => {
       each$e(getTemporaryNodes(tempAttrs, body), elm => {
         const element = SugarElement.fromDom(elm);
         if (get$9(element, 'data-mce-bogus') === 'all') {
-          remove$5(element);
+          remove$4(element);
         } else {
           each$e(tempAttrs, attr => {
             if (has$1(element, attr)) {
-              remove$a(element, attr);
+              remove$9(element, attr);
+            }
           });
+        }
       });
     };
     const cleanupBogusElements = parent => {
       const bogusElements = descendants(parent, '[data-mce-bogus]');
       each$e(bogusElements, elem => {
         const bogusValue = get$9(elem, 'data-mce-bogus');
         if (bogusValue === 'all') {
-          remove$5(elem);
+          remove$4(elem);
         } else if (isBr$5(elem)) {
           before$3(elem, SugarElement.fromText(zeroWidth));
-          remove$5(elem);
+          remove$4(elem);
         } else {
           unwrap(elem);
+        }
       });
     };
     const cleanupInputNames = parent => {
       const inputs = descendants(parent, 'input');
       each$e(inputs, input => {
-        remove$a(input, 'name');
+        remove$9(input, 'name');
       });
     };
     const trimEmptyContents = (editor, html) => {
     };
     const getPlainTextContent = (editor, body) => {
       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',
         top: '0'
       });
       cleanupBogusElements(offscreenDiv);
       cleanupInputNames(offscreenDiv);
       const root = getContentContainer(dos);
       append$1(root, offscreenDiv);
       const content = trim$2(offscreenDiv.dom.innerText);
-      remove$5(offscreenDiv);
+      remove$4(offscreenDiv);
       return content;
     };
     const getContentFromBody = (editor, args, body) => {
       let content;
       if (args.format === 'raw') {
         'border-style',
         'border-color',
         'background',
         'background-attachment',
         'background-clip',
-        'background-color',
         'background-image',
         'background-origin',
         'background-position',
         'background-repeat',
         'background-size',
       ];
       each$e(nonInheritableStylesArr, style => {
         nonInheritableStyles.add(style);
       });
     })();
+    const conditionalNonInheritableStyles = new Set();
+    (() => {
+      const conditionalNonInheritableStylesArr = ['background-color'];
+      each$e(conditionalNonInheritableStylesArr, style => {
+        conditionalNonInheritableStyles.add(style);
+      });
+    })();
     const shorthandStyleProps = [
       'font',
       'text-decoration',
       'text-emphasis'
     ];
-    const getStyleProps = (dom, node) => keys(dom.parseStyle(dom.getAttrib(node, 'style')));
+    const getStyles$1 = (dom, node) => dom.parseStyle(dom.getAttrib(node, 'style'));
+    const getStyleProps = (dom, node) => keys(getStyles$1(dom, node));
     const isNonInheritableStyle = style => nonInheritableStyles.has(style);
+    const isConditionalNonInheritableStyle = style => conditionalNonInheritableStyles.has(style);
-    const hasInheritableStyles = (dom, node) => forall(getStyleProps(dom, node), style => !isNonInheritableStyle(style));
+    const hasNonInheritableStyles = (dom, node) => exists(getStyleProps(dom, node), style => isNonInheritableStyle(style));
+    const hasConditionalNonInheritableStyles = (dom, node) => hasNonInheritableStyles(dom, node) && exists(getStyleProps(dom, node), style => isConditionalNonInheritableStyle(style));
     const getLonghandStyleProps = styles => filter$5(styles, style => exists(shorthandStyleProps, prop => startsWith(style, prop)));
     const hasStyleConflict = (dom, node, parentNode) => {
       const nodeStyleProps = getStyleProps(dom, node);
       const parentNodeStyleProps = getStyleProps(dom, parentNode);
       const valueMismatch = prop => {
           return valueMismatch(nodeStyleProp);
+        }
       });
     };
-    const isChar = (forward, predicate, pos) => Optional.from(pos.container()).filter(isText$a).exists(text => {
+    const isChar = (forward, predicate, pos) => Optional.from(pos.container()).filter(isText$b).exists(text => {
       const delta = forward ? 0 : -1;
       return predicate(text.data.charAt(pos.offset() + delta));
     });
     const isBeforeSpace = curry(isChar, true, isWhiteSpace);
     const isAfterSpace = curry(isChar, false, isWhiteSpace);
     const isEmptyText = pos => {
       const container = pos.container();
-      return isText$a(container) && (container.data.length === 0 || isZwsp$1(container.data) && BookmarkManager.isBookmarkNode(container.parentNode));
+      return isText$b(container) && (container.data.length === 0 || isZwsp(container.data) && BookmarkManager.isBookmarkNode(container.parentNode));
     };
     const matchesElementPosition = (before, predicate) => pos => getChildNodeAtRelativeOffset(before ? 0 : -1, pos).filter(predicate).isSome();
     const isImageBlock = node => isImg(node) && get$7(SugarElement.fromDom(node), 'display') === 'block';
-    const isCefNode = node => isContentEditableFalse$b(node) && !isBogusAll$1(node);
+    const isCefNode = node => isContentEditableFalse$b(node) && !isBogusAll(node);
     const isBeforeImageBlock = matchesElementPosition(true, isImageBlock);
     const isAfterImageBlock = matchesElementPosition(false, isImageBlock);
     const isBeforeMedia = matchesElementPosition(true, isMedia$2);
     const isAfterMedia = matchesElementPosition(false, isMedia$2);
+      }
     };
     const leanRight = pos => {
       const container = pos.container();
       const offset = pos.offset();
-      if (isText$a(container) && offset < container.data.length) {
+      if (isText$b(container) && offset < container.data.length) {
         return CaretPosition(container, offset + 1);
       } else {
         return pos;
+      }
     };
     const needsToBeNbsp = (root, pos, schema) => needsToBeNbspLeft(root, pos, schema) || needsToBeNbspRight(root, leanRight(pos), schema);
     const isNbspAt = (text, offset) => isNbsp(text.charAt(offset));
     const isWhiteSpaceAt = (text, offset) => isWhiteSpace(text.charAt(offset));
     const hasNbsp = pos => {
       const container = pos.container();
-      return isText$a(container) && contains$1(container.data, nbsp);
+      return isText$b(container) && contains$1(container.data, nbsp);
     };
     const normalizeNbspMiddle = text => {
       const chars = text.split('');
       return map$3(chars, (chr, i) => {
         if (isNbsp(chr) && i > 0 && i < chars.length - 1 && isContent(chars[i - 1]) && isContent(chars[i + 1])) {
         return true;
       } else {
         return false;
+      }
     };
-    const normalizeNbsps = (root, pos, schema) => {
+    const normalizeNbsps$1 = (root, pos, schema) => {
       const container = pos.container();
-      if (!isText$a(container)) {
+      if (!isText$b(container)) {
         return Optional.none();
+      }
       if (hasNbsp(pos)) {
         const normalized = normalizeNbspAtStart(root, container, false, schema) || normalizeNbspInMiddleOfTextNode(container) || normalizeNbspAtEnd(root, container, false, schema);
         return someIf(normalized, pos);
+      }
     };
     const normalizeNbspsInEditor = editor => {
       const root = SugarElement.fromDom(editor.getBody());
       if (editor.selection.isCollapsed()) {
-        normalizeNbsps(root, CaretPosition.fromRangeStart(editor.selection.getRng()), editor.schema).each(pos => {
+        normalizeNbsps$1(root, CaretPosition.fromRangeStart(editor.selection.getRng()), editor.schema).each(pos => {
           editor.selection.setRng(pos.toRange());
         });
+      }
     };
       if (mergeToPrev) {
         newNode.appendData(removeNode.data);
       } else {
         newNode.insertData(0, removeNode.data);
+      }
-      remove$5(SugarElement.fromDom(removeNode));
+      remove$4(SugarElement.fromDom(removeNode));
       if (normalizeWhitespace) {
         normalizeWhitespaceAfter(newNode, whitespaceOffset, schema);
+      }
       return newNode;
     };
       const container = pos.container();
       const offset = pos.offset();
       return !CaretPosition.isTextPosition(pos) && container === elm.parentNode && offset > CaretPosition.before(elm).offset();
     };
     const reposition = (elm, pos) => needsReposition(pos, elm) ? CaretPosition(pos.container(), pos.offset() - 1) : pos;
-    const beforeOrStartOf = node => isText$a(node) ? CaretPosition(node, 0) : CaretPosition.before(node);
+    const beforeOrStartOf = node => isText$b(node) ? CaretPosition(node, 0) : CaretPosition.before(node);
-    const afterOrEndOf = node => isText$a(node) ? CaretPosition(node, node.data.length) : CaretPosition.after(node);
+    const afterOrEndOf = node => isText$b(node) ? CaretPosition(node, node.data.length) : CaretPosition.after(node);
     const getPreviousSiblingCaretPosition = elm => {
       if (isCaretCandidate$3(elm.previousSibling)) {
         return Optional.some(afterOrEndOf(elm.previousSibling));
       } else {
         return elm.previousSibling ? lastPositionIn(elm.previousSibling) : Optional.none();
         editor.selection.setRng(pos.toRange(), forward);
       });
     };
     const eqRawNode = rawNode => elm => elm.dom === rawNode;
     const isBlock = (editor, elm) => elm && has$2(editor.schema.getBlockElements(), name(elm));
-    const paddEmptyBlock = (elm, preserveEmptyCaret) => {
+    const paddEmptyBlock = (schema, elm, preserveEmptyCaret) => {
-      if (isEmpty$2(elm)) {
+      if (isEmpty$2(schema, elm)) {
         const br = SugarElement.fromHtml('<br data-mce-bogus="1">');
         if (preserveEmptyCaret) {
           each$e(children$1(elm), node => {
             if (!isEmptyCaretFormatElement(node)) {
-              remove$5(node);
+              remove$4(node);
+            }
           });
         } else {
           empty(elm);
+        }
       } else {
         return Optional.none();
+      }
     };
     const deleteNormalized = (elm, afterDeletePosOpt, schema, normalizeWhitespace) => {
-      const prevTextOpt = prevSibling(elm).filter(isText$b);
+      const prevTextOpt = prevSibling(elm).filter(isText$c);
-      const nextTextOpt = nextSibling(elm).filter(isText$b);
+      const nextTextOpt = nextSibling(elm).filter(isText$c);
-      remove$5(elm);
+      remove$4(elm);
       return lift3(prevTextOpt, nextTextOpt, afterDeletePosOpt, (prev, next, pos) => {
         const prevNode = prev.dom, nextNode = next.dom;
         const offset = prevNode.data.length;
         mergeTextNodes(prevNode, nextNode, schema, normalizeWhitespace);
         return pos.container() === nextNode ? CaretPosition(prevNode, offset) : pos;
       const normalizedAfterDeletePos = deleteNormalized(elm, afterDeletePos, editor.schema, isInlineElement(editor, elm));
       if (editor.dom.isEmpty(editor.getBody())) {
         editor.setContent('');
         editor.selection.setCursorLocation();
       } else {
-        parentBlock.bind(elm => paddEmptyBlock(elm, preserveEmptyCaret)).fold(() => {
+        parentBlock.bind(elm => paddEmptyBlock(editor.schema, elm, preserveEmptyCaret)).fold(() => {
           if (moveCaret) {
             setSelection$1(editor, forward, normalizedAfterDeletePos);
+          }
         }, paddPos => {
           if (moveCaret) {
     const isAtZwsp = pos => isBeforeInline(pos) || isAfterInline(pos);
     const normalizePosition = (forward, pos) => {
       const container = pos.container(), offset = pos.offset();
       if (forward) {
         if (isCaretContainerInline(container)) {
-          if (isText$a(container.nextSibling)) {
+          if (isText$b(container.nextSibling)) {
             return CaretPosition(container.nextSibling, 0);
           } else {
             return CaretPosition.after(container);
+          }
         } else {
           return isBeforeInline(pos) ? CaretPosition(container, offset + 1) : pos;
+        }
       } else {
         if (isCaretContainerInline(container)) {
-          if (isText$a(container.previousSibling)) {
+          if (isText$b(container.previousSibling)) {
             return CaretPosition(container.previousSibling, container.previousSibling.data.length);
           } else {
             return CaretPosition.before(container);
+          }
         } else {
       rng.deleteContents();
       const lastNode = freefallRtl(root).getOr(root);
       const lastBlock = SugarElement.fromDom((_a = editor.dom.getParent(lastNode.dom, editor.dom.isBlock)) !== null && _a !== void 0 ? _a : root.dom);
       if (lastBlock.dom === editor.getBody()) {
         paddEmptyBody(editor, moveSelection);
-      } else if (isEmpty$2(lastBlock)) {
+      } else if (isEmpty$2(editor.schema, lastBlock, { checkRootAsContent: false })) {
         fillWithPaddingBr(lastBlock);
         if (moveSelection) {
           editor.selection.setCursorLocation(lastBlock.dom, 0);
+        }
+      }
       if (!eq(root, lastBlock)) {
         const additionalCleanupNodes = is$2(parent(lastBlock), root) ? [] : siblings(lastBlock);
         each$e(additionalCleanupNodes.concat(children$1(root)), node => {
-          if (!eq(node, lastBlock) && !contains(node, lastBlock) && isEmpty$2(node)) {
+          if (!eq(node, lastBlock) && !contains(node, lastBlock) && isEmpty$2(editor.schema, node)) {
-            remove$5(node);
+            remove$4(node);
+          }
         });
+      }
     };
-    const ancestor$1 = (scope, predicate, isRoot) => ancestor$4(scope, predicate, isRoot).isSome();
-    const sibling = (scope, predicate) => sibling$1(scope, predicate).isSome();
-    const descendant = (scope, predicate) => descendant$2(scope, predicate).isSome();
     const isRootFromElement = root => cur => eq(root, cur);
     const getTableCells = table => descendants(table, 'td,th');
     const getTable$1 = (node, isRoot) => getClosestTable(SugarElement.fromDom(node), isRoot);
     const selectionInTableWithNestedTable = details => {
     const getCellRng = (rng, isRoot) => {
       const startCell = getClosestCell$1(rng.startContainer, isRoot);
       const endCell = getClosestCell$1(rng.endContainer, isRoot);
       return lift2(startCell, endCell, tableCellRng);
     };
-    const getCellRangeFromStartTable = isRoot => startCell => getClosestTable(startCell, isRoot).bind(table => last$3(getTableCells(table)).map(endCell => tableCellRng(startCell, endCell)));
+    const getCellRangeFromStartTable = isRoot => startCell => getClosestTable(startCell, isRoot).bind(table => last$2(getTableCells(table)).map(endCell => tableCellRng(startCell, endCell)));
     const getCellRangeFromEndTable = isRoot => endCell => getClosestTable(endCell, isRoot).bind(table => head(getTableCells(table)).map(startCell => tableCellRng(startCell, endCell)));
     const getTableSelectionFromCellRng = isRoot => cellRng => getTableFromCellRng(cellRng, isRoot).map(table => tableSelection(cellRng, table, getTableCells(table)));
     const getTableSelections = (cellRng, selectionDetails, rng, isRoot) => {
       if (rng.collapsed || !cellRng.forall(isExpandedCellRng)) {
         return Optional.none();
         return handleSingleTable(optCellRng, selectionDetails, rng, isRoot);
+      }
     };
     const cleanCells = cells => each$e(cells, cell => {
-      remove$a(cell, 'contenteditable');
+      remove$9(cell, 'contenteditable');
       fillWithPaddingBr(cell);
     });
     const getOutsideBlock = (editor, container) => Optional.from(editor.dom.getParent(container, editor.dom.isBlock)).map(SugarElement.fromDom);
     const handleEmptyBlock = (editor, startInTable, emptyBlock) => {
       emptyBlock.each(block => {
         if (startInTable) {
-          remove$5(block);
+          remove$4(block);
         } else {
           fillWithPaddingBr(block);
           editor.selection.setCursorLocation(block.dom, 0);
+        }
       deleteCellContents(editor, insideTableRng, cell, false).each(action => action());
     };
     const collapseAndRestoreCellSelection = editor => {
       const selectedCells = getCellsFromEditor(editor);
       const selectedNode = SugarElement.fromDom(editor.selection.getNode());
-      if (isTableCell$3(selectedNode.dom) && isEmpty$2(selectedNode)) {
+      if (isTableCell$3(selectedNode.dom) && isEmpty$2(editor.schema, selectedNode)) {
         editor.selection.setCursorLocation(selectedNode.dom, 0);
       } else {
         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(() => {
       const editorRng = editor.selection.getRng();
       const cellsToClean = outsideDetails.bind(({rng, isStartInTable}) => {
         const outsideBlock = getOutsideBlock(editor, isStartInTable ? rng.endContainer : rng.startContainer);
         rng.deleteContents();
-        handleEmptyBlock(editor, isStartInTable, outsideBlock.filter(isEmpty$2));
+        handleEmptyBlock(editor, isStartInTable, outsideBlock.filter(curry(isEmpty$2, editor.schema)));
         const endPointCell = isStartInTable ? cells[0] : cells[cells.length - 1];
         deleteContentInsideCell(editor, endPointCell, editorRng, isStartInTable);
-        if (!isEmpty$2(endPointCell)) {
+        if (!isEmpty$2(editor.schema, endPointCell)) {
           return Optional.some(isStartInTable ? cells.slice(1) : cells.slice(0, -1));
         } else {
           return Optional.none();
+        }
       }).getOr(cells);
       const rng = editor.selection.getRng();
       const startCell = startTableCells[0];
       const endCell = endTableCells[endTableCells.length - 1];
       deleteContentInsideCell(editor, startCell, rng, true);
       deleteContentInsideCell(editor, endCell, rng, false);
-      const startTableCellsToClean = isEmpty$2(startCell) ? startTableCells : startTableCells.slice(1);
+      const startTableCellsToClean = isEmpty$2(editor.schema, startCell) ? startTableCells : startTableCells.slice(1);
-      const endTableCellsToClean = isEmpty$2(endCell) ? endTableCells : endTableCells.slice(0, -1);
+      const endTableCellsToClean = isEmpty$2(editor.schema, endCell) ? endTableCells : endTableCells.slice(0, -1);
       cleanCells(startTableCellsToClean.concat(endTableCellsToClean));
       betweenRng.deleteContents();
       collapseAndRestoreCellSelection(editor);
     });
     const deleteCellContents = (editor, rng, cell, moveSelection = true) => Optional.some(() => {
     const emptyCaretCaption = (editor, elm) => emptyElement(editor, elm);
     const validateCaretCaption = (rootElm, fromCaption, to) => getParentCaption(rootElm, SugarElement.fromDom(to.getNode())).fold(() => Optional.some(noop), toCaption => someIf(!eq(toCaption, fromCaption), noop));
     const deleteCaretInsideCaption = (editor, rootElm, forward, fromCaption, from) => navigate(forward, editor.getBody(), from).fold(() => Optional.some(noop), to => isDeleteOfLastCharPos(fromCaption, forward, from, to) ? emptyCaretCaption(editor, fromCaption) : validateCaretCaption(rootElm, fromCaption, to));
     const deleteCaretCells = (editor, forward, rootElm, startElm) => {
       const from = CaretPosition.fromRangeStart(editor.selection.getRng());
-      return getParentCell(rootElm, startElm).bind(fromCell => isEmpty$2(fromCell) ? emptyElement(editor, fromCell) : deleteBetweenCells(editor, rootElm, forward, fromCell, from));
+      return getParentCell(rootElm, startElm).bind(fromCell => isEmpty$2(editor.schema, fromCell, { checkRootAsContent: false }) ? emptyElement(editor, fromCell) : deleteBetweenCells(editor, rootElm, forward, fromCell, from));
     };
     const deleteCaretCaption = (editor, forward, rootElm, fromCaption) => {
       const from = CaretPosition.fromRangeStart(editor.selection.getRng());
-      return isEmpty$2(fromCaption) ? emptyElement(editor, fromCaption) : deleteCaretInsideCaption(editor, rootElm, forward, fromCaption, from);
+      return isEmpty$2(editor.schema, fromCaption) ? emptyElement(editor, fromCaption) : deleteCaretInsideCaption(editor, rootElm, forward, fromCaption, from);
     };
     const isNearTable = (forward, pos) => forward ? isBeforeTable(pos) : isAfterTable(pos);
     const isBeforeOrAfterTable = (editor, forward) => {
       const fromPos = CaretPosition.fromRangeStart(editor.selection.getRng());
       return isNearTable(forward, fromPos) || fromPosition(forward, editor.getBody(), fromPos).exists(pos => isNearTable(forward, pos));
     };
     const deleteCaret$3 = (editor, forward, startElm) => {
       const rootElm = SugarElement.fromDom(editor.getBody());
       return getParentCaption(rootElm, startElm).fold(() => deleteCaretCells(editor, forward, rootElm, startElm).orThunk(() => someIf(isBeforeOrAfterTable(editor, forward), noop)), fromCaption => deleteCaretCaption(editor, forward, rootElm, fromCaption));
     };
-    const backspaceDelete$a = (editor, forward) => {
+    const backspaceDelete$b = (editor, forward) => {
       const startElm = SugarElement.fromDom(editor.selection.getStart(true));
       const cells = getCellsFromEditor(editor);
       return editor.selection.isCollapsed() && cells.length === 0 ? deleteCaret$3(editor, forward, startElm) : deleteRange$3(editor, startElm, cells);
     };
         return cell === endCell && hasAllContentsSelected(SugarElement.fromDom(cell), rng);
       } else {
         return false;
+      }
     };
+    const isEditableEmptyBlock = (dom, node) => {
+      if (dom.isBlock(node) && dom.isEditable(node)) {
+        const childNodes = node.childNodes;
+        return childNodes.length === 1 && isBr$6(childNodes[0]) || childNodes.length === 0;
+      } else {
+        return false;
+      }
+    };
     const validInsertion = (editor, value, parentNode) => {
       var _a;
       if (parentNode.getAttribute('data-mce-bogus') === 'all') {
         (_a = parentNode.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(editor.dom.createFragment(value), parentNode);
       } else {
-        const node = parentNode.firstChild;
-        const node2 = parentNode.lastChild;
-        if (!node || node === node2 && node.nodeName === 'BR') {
+        if (isEditableEmptyBlock(editor.dom, parentNode)) {
           editor.dom.setHTML(parentNode, value);
         } else {
           editor.selection.setContent(value, { no_events: true });
+        }
+      }
       const textInlineElements = editor.schema.getTextInlineElements();
       const dom = editor.dom;
       if (merge) {
         const root = editor.getBody();
         const elementUtils = ElementUtils(editor);
+        const fragmentSelector = '*[data-mce-fragment]';
+        const fragments = dom.select(fragmentSelector);
-        Tools.each(dom.select('*[data-mce-fragment]'), node => {
+        Tools.each(fragments, node => {
-          const isInline = isNonNullable(textInlineElements[node.nodeName.toLowerCase()]);
+          const isInline = currentNode => isNonNullable(textInlineElements[currentNode.nodeName.toLowerCase()]);
-          if (isInline && hasInheritableStyles(dom, node)) {
+          const hasOneChild = currentNode => currentNode.childNodes.length === 1;
-            for (let parentNode = node.parentElement; isNonNullable(parentNode) && parentNode !== root; parentNode = parentNode.parentElement) {
+          const hasNoNonInheritableStyles = currentNode => !(hasNonInheritableStyles(dom, currentNode) || hasConditionalNonInheritableStyles(dom, currentNode));
-              const styleConflict = hasStyleConflict(dom, node, parentNode);
+          if (hasNoNonInheritableStyles(node) && isInline(node) && hasOneChild(node)) {
-              if (styleConflict) {
+            const styles = getStyleProps(dom, node);
-                break;
+            const isOverridden = (oldStyles, newStyles) => forall(oldStyles, style => contains$2(newStyles, style));
-              }
+            const overriddenByAllChildren = childNode => hasOneChild(node) && dom.is(childNode, fragmentSelector) && isInline(childNode) && (childNode.nodeName === node.nodeName && isOverridden(styles, getStyleProps(dom, childNode)) || overriddenByAllChildren(childNode.children[0]));
+            const identicalToParent = parentNode => isNonNullable(parentNode) && parentNode !== root && (elementUtils.compare(node, parentNode) || identicalToParent(parentNode.parentElement));
+            const conflictWithInsertedParent = parentNode => isNonNullable(parentNode) && parentNode !== root && dom.is(parentNode, fragmentSelector) && (hasStyleConflict(dom, node, parentNode) || conflictWithInsertedParent(parentNode.parentElement));
-              if (elementUtils.compare(parentNode, node)) {
+            if (overriddenByAllChildren(node.children[0]) || identicalToParent(node.parentElement) && !conflictWithInsertedParent(node.parentElement)) {
-                dom.remove(node, true);
+              dom.remove(node, true);
-                break;
-              }
+            }
+          }
         });
+      }
     };
         selection.select(parentEditableElm);
         return;
+      }
       let rng = dom.createRng();
       const node = marker.previousSibling;
-      if (isText$a(node)) {
+      if (isText$b(node)) {
         rng.setStart(node, (_b = (_a = node.nodeValue) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0);
         const node2 = marker.nextSibling;
-        if (isText$a(node2)) {
+        if (isText$b(node2)) {
           node.appendData(node2.data);
           (_c = node2.parentNode) === null || _c === void 0 ? void 0 : _c.removeChild(node2);
+        }
       } else {
         rng.setStartBefore(marker);
       const rng = normalize(editor.selection.getRng());
       editor.selection.setRng(rng);
       const startCell = dom.getParent(rng.startContainer, isTableCell);
       if (isTableCellContentSelected(dom, rng, startCell)) {
         deleteCellContents(editor, rng, SugarElement.fromDom(startCell));
-      } else if (rng.startContainer === rng.endContainer && rng.endOffset - rng.startOffset === 1 && isText$a(rng.startContainer.childNodes[rng.startOffset])) {
+      } else if (rng.startContainer === rng.endContainer && rng.endOffset - rng.startOffset === 1 && isText$b(rng.startContainer.childNodes[rng.startOffset])) {
         rng.deleteContents();
       } else {
         editor.getDoc().execCommand('Delete', false);
+      }
     };
       markFragmentElements(fragment);
       let node = fragment.lastChild;
       if (node && node.attr('id') === 'mce_marker') {
         const marker = node;
         for (node = node.prev; node; node = node.walk(true)) {
+          if (node.name === 'table') {
+            break;
+          }
           if (node.type === 3 || !dom.isBlock(node.name)) {
             if (node.parent && editor.schema.isValidChild(node.parent.name, 'span')) {
               node.parent.insert(marker, node, node.name === 'br');
+            }
             break;
     };
     const findFirstTextNode = node => {
       if (node) {
         const walker = new DomTreeWalker(node, node);
         for (let tempNode = walker.current(); tempNode; tempNode = walker.next()) {
-          if (isText$a(tempNode)) {
+          if (isText$b(tempNode)) {
             return tempNode;
+          }
+        }
+      }
       return null;
         return Optional.some(clonedFormatNode);
       } else {
         return Optional.none();
+      }
     };
+    const normalizeNbsps = node => set(node, get$3(node).replace(new RegExp(`${ nbsp }$`), ' '));
+    const normalizeNbspsBetween = (editor, caretContainer) => {
+      const handler = () => {
+        if (caretContainer !== null && !editor.dom.isEmpty(caretContainer)) {
+          prevSibling(SugarElement.fromDom(caretContainer)).each(node => {
+            if (isText$c(node)) {
+              normalizeNbsps(node);
+            } else {
+              descendant$2(node, e => isText$c(e)).each(textNode => {
+                if (isText$c(textNode)) {
+                  normalizeNbsps(textNode);
+                }
+              });
+            }
+          });
+        }
+      };
+      editor.once('input', e => {
+        if (e.data && !isWhiteSpace(e.data)) {
+          if (!e.isComposing) {
+            handler();
+          } else {
+            editor.once('compositionend', () => {
+              handler();
+            });
+          }
+        }
+      });
+    };
     const applyCaretFormat = (editor, name, vars) => {
       let caretContainer;
       const selection = editor.selection;
       const formatList = editor.formatter.get(name);
       if (!formatList) {
         if (!caretContainer || (textNode === null || textNode === void 0 ? void 0 : textNode.data) !== ZWSP) {
           caretContainer = importNode(editor.getDoc(), createCaretContainer(true).dom);
           textNode = caretContainer.firstChild;
           selectionRng.insertNode(caretContainer);
           offset = 1;
+          normalizeNbspsBetween(editor, caretContainer);
           editor.formatter.apply(name, vars, caretContainer);
         } else {
           editor.formatter.apply(name, vars, caretContainer);
+        }
         selection.setCursorLocation(textNode, offset);
+      }
       const rng = selection.getRng();
       const container = rng.startContainer;
       const offset = rng.startOffset;
       let node = container;
-      if (isText$a(container)) {
+      if (isText$b(container)) {
         if (offset !== container.data.length) {
           hasContentAfter = true;
+        }
         node = node.parentNode;
+      }
         return;
+      }
       if (hasContentAfter) {
         const bookmark = selection.getBookmark();
         rng.collapse(true);
-        let expandedRng = expandRng(dom, rng, formatList, true);
+        let expandedRng = expandRng(dom, rng, formatList, { includeTrailingSpace: true });
         expandedRng = split(expandedRng);
         editor.formatter.remove(name, vars, expandedRng, similar);
         selection.moveToBookmark(bookmark);
       } else {
         const caretContainer = getParentCaretContainer(editor.getBody(), formatNode);
         ], newCaretContainer);
         if (caretContainer) {
           removeCaretContainerNode(editor, caretContainer, isNonNullable(caretContainer));
+        }
         selection.setCursorLocation(caretTextNode, 1);
+        normalizeNbspsBetween(editor, newCaretContainer);
         if (dom.isEmpty(formatNode)) {
           dom.remove(formatNode);
+        }
+      }
     };
+      }
       if (keyCode === 37 || keyCode === 39) {
         removeCaretContainer(editor, getParentCaretContainer(body, selection.getStart()), true);
+      }
     };
-    const endsWithNbsp = element => isText$a(element) && endsWith(element.data, nbsp);
+    const endsWithNbsp = element => isText$b(element) && endsWith(element.data, nbsp);
     const setup$v = editor => {
       editor.on('mouseup keydown', e => {
         disableCaretContainer(editor, e.keyCode, endsWithNbsp(editor.selection.getRng().endContainer));
       });
     };
       };
     };
     const replaceWithCaretFormat = (targetNode, formatNodes) => {
       const {caretContainer, caretPosition} = createCaretFormat(formatNodes);
       before$3(SugarElement.fromDom(targetNode), caretContainer);
-      remove$5(SugarElement.fromDom(targetNode));
+      remove$4(SugarElement.fromDom(targetNode));
       return caretPosition;
     };
     const createCaretFormatAtStart$1 = (rng, formatNodes) => {
       const {caretContainer, caretPosition} = createCaretFormat(formatNodes);
       rng.insertNode(caretContainer.dom);
     const isFormatElement = (editor, element) => {
       if (isCaretNode(element.dom)) {
         return false;
+      }
       const inlineElements = editor.schema.getTextInlineElements();
-      return has$2(inlineElements, name(element)) && !isCaretNode(element.dom) && !isBogus$2(element.dom);
+      return has$2(inlineElements, name(element)) && !isCaretNode(element.dom) && !isBogus$1(element.dom);
     };
     const postProcessHooks = {};
     const isPre = matchNodeNames(['pre']);
         return isPre(prev) && contains$2(blocks, prev);
       };
       const joinPre = (pre1, pre2) => {
         const sPre2 = SugarElement.fromDom(pre2);
         const doc = documentOrOwner(sPre2).dom;
-        remove$5(sPre2);
+        remove$4(sPre2);
         append(SugarElement.fromDom(pre1), [
           SugarElement.fromTag('br', doc),
           SugarElement.fromTag('br', doc),
           ...children$1(sPre2)
         ]);
+      }
       if (blocks.length === 1) {
         return isRngStartAtStartOfElement(rng, blocks[0]) && isRngEndAtEndOfElement(rng, blocks[0]) ? blocks : [];
       } else {
         const first = head(blocks).filter(elm => isRngStartAtStartOfElement(rng, elm)).toArray();
-        const last = last$3(blocks).filter(elm => isRngEndAtEndOfElement(rng, elm)).toArray();
+        const last = last$2(blocks).filter(elm => isRngEndAtEndOfElement(rng, elm)).toArray();
         const middle = blocks.slice(1, -1);
         return first.concat(middle).concat(last);
+      }
     };
     const getFullySelectedListItems = selection => filter$5(getFullySelectedBlocks(selection), isEditableListItem(selection.dom));
     const getPartiallySelectedListItems = selection => filter$5(selection.getSelectedBlocks(), isEditableListItem(selection.dom));
     const each$8 = Tools.each;
-    const isElementNode = node => isElement$6(node) && !isBookmarkNode$1(node) && !isCaretNode(node) && !isBogus$2(node);
+    const isElementNode = node => isElement$6(node) && !isBookmarkNode$1(node) && !isCaretNode(node) && !isBogus$1(node);
     const findElementSibling = (node, siblingName) => {
       for (let sibling = node; sibling; sibling = sibling[siblingName]) {
-        if (isText$a(sibling) && isNotEmpty(sibling.data)) {
+        if (isText$b(sibling) && isNotEmpty(sibling.data)) {
           return node;
+        }
         if (isElement$6(sibling) && !isBookmarkNode$1(sibling)) {
           return sibling;
         if (!start && offset) {
           offset--;
+        }
         container = container.childNodes[offset > lastIdx ? lastIdx : offset];
+      }
-      if (isText$a(container) && start && offset >= container.data.length) {
+      if (isText$b(container) && start && offset >= container.data.length) {
         container = new DomTreeWalker(container, ed.getBody()).next() || container;
+      }
-      if (isText$a(container) && !start && offset === 0) {
+      if (isText$b(container) && !start && offset === 0) {
         container = new DomTreeWalker(container, ed.getBody()).prev() || container;
+      }
       return container;
     };
     const normalizeTableSelection = (node, start) => {
         if (node) {
           let out = node[start ? 'firstChild' : 'lastChild'];
           if (isRemoveBookmarkNode(out)) {
             out = out[start ? 'firstChild' : 'lastChild'];
+          }
-          if (isText$a(out) && out.data.length === 0) {
+          if (isText$b(out) && out.data.length === 0) {
             out = start ? node.previousSibling || node.nextSibling : node.nextSibling || node.previousSibling;
+          }
           dom.remove(node, true);
           return out;
         } else {
+        }
       };
       const removeRngStyle = rng => {
         let startContainer;
         let endContainer;
-        let expandedRng = expandRng(dom, rng, formatList, rng.collapsed);
+        let expandedRng = expandRng(dom, rng, formatList, { includeTrailingSpace: rng.collapsed });
         if (format.split) {
           expandedRng = split(expandedRng);
           startContainer = getContainer(ed, expandedRng, true);
           endContainer = getContainer(ed, expandedRng);
           if (startContainer !== endContainer) {
     const each$5 = Tools.each;
     const canFormatBR = (editor, format, node, parentName) => {
       if (canFormatEmptyLines(editor) && isInlineFormat(format) && node.parentNode) {
         const validBRParentElements = getTextRootBlockElements(editor.schema);
         const hasCaretNodeSibling = sibling(SugarElement.fromDom(node), sibling => isCaretNode(sibling.dom));
-        return hasNonNullableKey(validBRParentElements, parentName) && isEmpty$2(SugarElement.fromDom(node.parentNode), false) && !hasCaretNodeSibling;
+        return hasNonNullableKey(validBRParentElements, parentName) && isEmptyNode(editor.schema, node.parentNode, {
+          skipBogus: false,
+          includeZwsp: true
+        }) && !hasCaretNodeSibling;
       } else {
         return false;
+      }
     };
     const applyStyles = (dom, elm, format, vars) => {
           return isEditableDescendant && isValidBlockFormatForNode;
         };
         const canWrapNode = (node, parentName, isEditableDescendant, isWrappableNoneditableElm) => {
           const nodeName = node.nodeName.toLowerCase();
           const isValidWrapNode = isValid(ed, wrapName, nodeName) && isValid(ed, parentName, wrapName);
-          const isZwsp = !nodeSpecific && isText$a(node) && isZwsp$1(node.data);
+          const isZwsp$1 = !nodeSpecific && isText$b(node) && isZwsp(node.data);
           const isCaret = isCaretNode(node);
           const isCorrectFormatForNode = !isInlineFormat(format) || !dom.isBlock(node);
-          return (isEditableDescendant || isWrappableNoneditableElm) && isValidWrapNode && !isZwsp && !isCaret && isCorrectFormatForNode;
+          return (isEditableDescendant || isWrappableNoneditableElm) && isValidWrapNode && !isZwsp$1 && !isCaret && isCorrectFormatForNode;
         };
         walk$3(dom, rng, nodes => {
           let currentWrapElm;
           const process = node => {
             let hasContentEditableState = false;
       };
       return findUntil$1(parents, isMatchingNode, isUnableToMatch);
     };
     const getParents = (editor, elm) => {
       const element = elm !== null && elm !== void 0 ? elm : fallbackElement(editor);
-      return filter$5(getParents$2(editor.dom, element), node => isElement$6(node) && !isBogus$2(node));
+      return filter$5(getParents$2(editor.dom, element), node => isElement$6(node) && !isBogus$1(node));
     };
     const updateAndFireChangeCallbacks = (editor, elm, registeredCallbacks) => {
       const parents = getParents(editor, elm);
       each$d(registeredCallbacks, (data, format) => {
         const runIfChanged = spec => {
       if (settings.inline_styles) {
         addFilters(domParser, settings, schema);
+      }
     };
-    const addNodeFilter = (settings, htmlParser, schema) => {
-      htmlParser.addNodeFilter('br', (nodes, _, args) => {
-        const blockElements = Tools.extend({}, schema.getBlockElements());
-        const nonEmptyElements = schema.getNonEmptyElements();
-        const whitespaceElements = schema.getWhitespaceElements();
-        blockElements.body = 1;
-        const isBlock = node => node.name in blockElements || isTransparentAstBlock(schema, node);
-        for (let i = 0, l = nodes.length; i < l; i++) {
-          let node = nodes[i];
-          let parent = node.parent;
-          if (parent && isBlock(parent) && node === parent.lastChild) {
-            let prev = node.prev;
-            while (prev) {
-              const prevName = prev.name;
-              if (prevName !== 'span' || prev.attr('data-mce-type') !== 'bookmark') {
-                if (prevName === 'br') {
-                  node = null;
-                }
-                break;
-              }
-              prev = prev.prev;
-            }
-            if (node) {
-              node.remove();
-              if (isEmpty(schema, nonEmptyElements, whitespaceElements, parent)) {
-                const elementRule = schema.getElementRule(parent.name);
-                if (elementRule) {
-                  if (elementRule.removeEmpty) {
-                    parent.remove();
-                  } else if (elementRule.paddEmpty) {
-                    paddEmptyNode(settings, args, isBlock, parent);
-                  }
-                }
-              }
-            }
-          } else {
-            let lastParent = node;
-            while (parent && parent.firstChild === lastParent && parent.lastChild === lastParent) {
-              lastParent = parent;
-              if (blockElements[parent.name]) {
-                break;
-              }
-              parent = parent.parent;
-            }
-            if (lastParent === parent) {
-              const textNode = new AstNode('#text', 3);
-              textNode.value = nbsp;
-              node.replace(textNode);
-            }
-          }
-        }
-      });
-    };
     const blobUriToBlob = url => fetch(url).then(res => res.ok ? res.blob() : Promise.reject()).catch(() => Promise.reject({
       message: `Cannot convert ${ url } to Blob. Resource might not exist or is inaccessible.`,
       uriType: 'blob'
     }));
     const extractBase64Data = data => {
       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 base64Encoded = matches[2] === ';base64';
+        const decodedData = decodeData(data);
-        const extractedData = base64Encoded ? extractBase64Data(data) : decodeURIComponent(data);
+        const extractedData = base64Encoded ? extractBase64Data(decodedData) : decodedData;
         return Optional.some({
           type: matches[1],
           data: extractedData,
           base64Encoded
     const buildBlob = (type, data, base64Encoded = true) => {
       let str = data;
       if (base64Encoded) {
         try {
           str = atob(data);
-        } catch (e) {
+        } catch (_a) {
           return Optional.none();
+        }
+      }
       const arr = new Uint8Array(str.length);
       for (let i = 0; i < arr.length; i++) {
       } else {
         return Promise.reject('Unknown image data format');
+      }
     };
-    const isBogusImage = img => isNonNullable(img.attr('data-mce-bogus'));
+    const hostCaptureRegex = /^(?:(?:(?:[A-Za-z][A-Za-z\d.+-]{0,14}:\/\/(?:[-.~*+=!&;:'%@?^${}(),\w]+@)?|www\.|[-;:&=+$,.\w]+@)([A-Za-z\d-]+(?:\.[A-Za-z\d-]+)*))(?::\d+)?(?:\/(?:[-.~*+=!;:'%@$(),\/\w]*[-~*+=%@$()\/\w])?)?(?:\?(?:[-.~*+=!&;:'%@?^${}(),\/\w]+)?)?(?:#(?:[-.~*+=!&;:'%@?^${}(),\/\w]+)?)?)$/;
+    const extractHost = url => Optional.from(url.match(hostCaptureRegex)).bind(ms => get$b(ms, 1)).map(h => startsWith(h, 'www.') ? h.substring(4) : h);
-    const isInternalImageSource = img => img.attr('src') === Env.transparentSrc || isNonNullable(img.attr('data-mce-placeholder'));
-    const registerBase64ImageFilter = (parser, settings) => {
-      const {blob_cache: blobCache} = settings;
-      if (blobCache) {
-        const processImage = img => {
-          const inputSrc = img.attr('src');
+    const sandboxIframe = (iframeNode, exclusions) => {
-          if (isInternalImageSource(img) || isBogusImage(img) || isNullable(inputSrc)) {
-            return;
-          }
-          dataUriToBlobInfo(blobCache, inputSrc, true).each(blobInfo => {
+      if (Optional.from(iframeNode.attr('src')).bind(extractHost).forall(host => !contains$2(exclusions, host))) {
-            img.attr('src', blobInfo.blobUri());
-          });
-        };
-        parser.addAttributeFilter('src', nodes => each$e(nodes, processImage));
+        iframeNode.attr('sandbox', '');
+      }
     };
     const isMimeType = (mime, type) => startsWith(mime, `${ type }/`);
-    const createSafeEmbed = (mime, src, width, height, sandboxIframes) => {
-      let name;
+    const getEmbedType = type => {
-      if (isUndefined(mime)) {
+      if (isUndefined(type)) {
-        name = 'iframe';
+        return 'iframe';
-      } else if (isMimeType(mime, 'image')) {
+      } else if (isMimeType(type, 'image')) {
-        name = 'img';
+        return 'img';
-      } else if (isMimeType(mime, 'video')) {
+      } else if (isMimeType(type, 'video')) {
-        name = 'video';
+        return 'video';
-      } else if (isMimeType(mime, 'audio')) {
+      } else if (isMimeType(type, 'audio')) {
-        name = 'audio';
+        return 'audio';
       } else {
-        name = 'iframe';
+        return 'iframe';
+      }
+    };
+    const createSafeEmbed = ({type, src, width, height} = {}, sandboxIframes, sandboxIframesExclusions) => {
       const name = getEmbedType(type);
       const embed = new AstNode(name, 1);
       embed.attr(name === 'audio' ? { src } : {
         src,
         width,
         height
       });
       if (name === 'audio' || name === 'video') {
         embed.attr('controls', '');
+      }
       if (name === 'iframe' && sandboxIframes) {
-        embed.attr('sandbox', '');
+        sandboxIframe(embed, sandboxIframesExclusions);
+      }
       return embed;
+    };
+    const isBogusImage = img => isNonNullable(img.attr('data-mce-bogus'));
+    const isInternalImageSource = img => img.attr('src') === Env.transparentSrc || isNonNullable(img.attr('data-mce-placeholder'));
+    const registerBase64ImageFilter = (parser, settings) => {
+      const {blob_cache: blobCache} = settings;
+      if (blobCache) {
+        const processImage = img => {
+          const inputSrc = img.attr('src');
+          if (isInternalImageSource(img) || isBogusImage(img) || isNullable(inputSrc)) {
+            return;
+          }
+          dataUriToBlobInfo(blobCache, inputSrc, true).each(blobInfo => {
+            img.attr('src', blobInfo.blobUri());
+          });
+        };
+        parser.addAttributeFilter('src', nodes => each$e(nodes, processImage));
+      }
     };
+    const register$4 = (parser, settings) => {
-    const register$4 = (parser, settings) => {
+      var _a, _b;
-      const schema = parser.schema;
-      if (settings.remove_trailing_brs) {
-        addNodeFilter(settings, parser, schema);
       const schema = parser.schema;
       parser.addAttributeFilter('href', nodes => {
         let i = nodes.length;
         const appendRel = rel => {
           const parts = rel.split(' ').filter(p => p.length > 0);
             node.attr('class', classValue);
+          }
         });
+      }
       registerBase64ImageFilter(parser, settings);
+      const shouldSandboxIframes = (_a = settings.sandbox_iframes) !== null && _a !== void 0 ? _a : false;
+      const sandboxIframesExclusions = unique$1((_b = settings.sandbox_iframes_exclusions) !== null && _b !== void 0 ? _b : []);
       if (settings.convert_unsafe_embeds) {
         parser.addNodeFilter('object,embed', nodes => each$e(nodes, node => {
+          node.replace(createSafeEmbed({
+            type: node.attr('type'),
-          node.replace(createSafeEmbed(node.attr('type'), node.name === 'object' ? node.attr('data') : node.attr('src'), node.attr('width'), node.attr('height'), settings.sandbox_iframes));
+            src: node.name === 'object' ? node.attr('data') : node.attr('src'),
+            width: node.attr('width'),
+            height: node.attr('height')
+          }, shouldSandboxIframes, sandboxIframesExclusions));
         }));
+      }
-      if (settings.sandbox_iframes) {
+      if (shouldSandboxIframes) {
-        parser.addNodeFilter('iframe', nodes => each$e(nodes, node => node.attr('sandbox', '')));
+        parser.addNodeFilter('iframe', nodes => each$e(nodes, node => sandboxIframe(node, sandboxIframesExclusions)));
+      }
     };
+    /*! @license DOMPurify 3.2.4 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.4/LICENSE */
-    const {entries, setPrototypeOf, isFrozen, getPrototypeOf, getOwnPropertyDescriptor} = Object;
+    const {
-    let {freeze, seal, create: create$7} = Object;
+      entries,
-    let {apply, construct} = typeof Reflect !== 'undefined' && Reflect;
+      setPrototypeOf,
-    if (!apply) {
+      isFrozen,
-      apply = function apply(fun, thisValue, args) {
+      getPrototypeOf,
+      getOwnPropertyDescriptor
+    } = Object;
+    let {
-        return fun.apply(thisValue, args);
+      freeze,
+      seal,
+      create: create$7
-      };
+    } = Object; // eslint-disable-line import/no-mutable-exports
+    let {
+      apply,
+      construct
     } = typeof Reflect !== 'undefined' && Reflect;
     if (!freeze) {
       freeze = function freeze(x) {
         return x;
       };
+    }
     if (!seal) {
       seal = function seal(x) {
         return x;
       };
+    }
+    if (!apply) {
+      apply = function apply(fun, thisValue, args) {
+        return fun.apply(thisValue, args);
+      };
+    }
     if (!construct) {
       construct = function construct(Func, args) {
         return new Func(...args);
       };
+    }
+    const arrayForEach = unapply(Array.prototype.forEach);
-    const arrayForEach = unapply(Array.prototype.forEach);
+    const arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
     const arrayPop = unapply(Array.prototype.pop);
+    const arrayPush = unapply(Array.prototype.push);
-    const arrayPush = unapply(Array.prototype.push);
+    const arraySplice = unapply(Array.prototype.splice);
     const stringToLowerCase = unapply(String.prototype.toLowerCase);
     const stringToString = unapply(String.prototype.toString);
     const stringMatch = unapply(String.prototype.match);
     const stringReplace = unapply(String.prototype.replace);
     const stringIndexOf = unapply(String.prototype.indexOf);
+    const stringTrim = unapply(String.prototype.trim);
-    const stringTrim = unapply(String.prototype.trim);
+    const objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
     const regExpTest = unapply(RegExp.prototype.test);
+    const typeErrorCreate = unconstruct(TypeError);
+    /**
+     * Creates a new function that calls the given function with a specified thisArg and arguments.
+     *
+     * @param func - The function to be wrapped and called.
+     * @returns A new function that calls the given function with a specified thisArg and arguments.
-    const typeErrorCreate = unconstruct(TypeError);
+     */
     function unapply(func) {
       return function (thisArg) {
         for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
           args[_key - 1] = arguments[_key];
+        }
         return apply(func, thisArg, args);
       };
+    }
+    /**
+     * Creates a new function that constructs an instance of the given constructor function with the provided arguments.
+     *
+     * @param func - The constructor function to be wrapped and called.
+     * @returns A new function that constructs an instance of the given constructor function with the provided arguments.
      */
     function unconstruct(func) {
       return function () {
         for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
           args[_key2] = arguments[_key2];
+        }
         return construct(func, args);
       };
+    }
+    /**
+     * Add properties to a lookup table
+     *
+     * @param set - The set to which elements will be added.
+     * @param array - The array containing elements to be added to the set.
-    }
+     * @param transformCaseFunc - An optional function to transform the case of each element before adding to the set.
+     * @returns The modified set with added elements.
-    function addToSet(set, array, transformCaseFunc) {
+     */
-      var _transformCaseFunc;
+    function addToSet(set, array) {
-      transformCaseFunc = (_transformCaseFunc = transformCaseFunc) !== null && _transformCaseFunc !== void 0 ? _transformCaseFunc : stringToLowerCase;
+      let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase;
+      if (setPrototypeOf) {
+        // Make 'in' and truthy checks like Boolean(set.constructor)
+        // independent of any properties defined on Object.prototype.
-      if (setPrototypeOf) {
+        // Prevent prototype setters from intercepting set as a this value.
         setPrototypeOf(set, null);
+      }
       let l = array.length;
       while (l--) {
         let element = array[l];
         if (typeof element === 'string') {
           const lcElement = transformCaseFunc(element);
+          if (lcElement !== element) {
-          if (lcElement !== element) {
+            // Config presets (e.g. tags.js, attrs.js) are immutable.
             if (!isFrozen(array)) {
               array[l] = lcElement;
+            }
             element = lcElement;
+          }
+        }
         set[element] = true;
+      }
       return set;
+    }
+    /**
+     * Clean up an array to harden against CSPP
+     *
+     * @param array - The array to be cleaned.
+     * @returns The cleaned version of the array
+     */
+    function cleanArray(array) {
+      for (let index = 0; index < array.length; index++) {
+        const isPropertyExist = objectHasOwnProperty(array, index);
+        if (!isPropertyExist) {
+          array[index] = null;
+        }
+      }
+      return array;
+    }
+    /**
+     * Shallow clone an object
+     *
+     * @param object - The object to be cloned.
+     * @returns A new object that copies the original.
      */
     function clone(object) {
       const newObject = create$7(null);
+      for (const [property, value] of entries(object)) {
+        const isPropertyExist = objectHasOwnProperty(object, property);
+        if (isPropertyExist) {
+          if (Array.isArray(value)) {
+            newObject[property] = cleanArray(value);
+          } else if (value && typeof value === 'object' && value.constructor === Object) {
+            newObject[property] = clone(value);
-      for (const [property, value] of entries(object)) {
+          } else {
+            newObject[property] = value;
+          }
         newObject[property] = value;
+      }
       return newObject;
+    }
+    /**
+     * This method automatically checks if the prop is function or getter and behaves accordingly.
+     *
+     * @param object - The object to look up the getter function in its prototype chain.
+     * @param prop - The property name for which to find the getter function.
+     * @returns The getter function found in the prototype chain or a fallback function.
      */
     function lookupGetter(object, prop) {
       while (object !== null) {
         const desc = getOwnPropertyDescriptor(object, prop);
         if (desc) {
             return unapply(desc.value);
+          }
+        }
         object = getPrototypeOf(object);
+      }
-      function fallbackValue(element) {
+      function fallbackValue() {
-        console.warn('fallback value for', element);
         return null;
+      }
       return fallbackValue;
+    }
-    const html$1 = freeze([
-      'a',
-      'abbr',
-      'acronym',
-      'address',
-      'area',
-      'article',
-      'aside',
-      'audio',
-      'b',
-      'bdi',
-      'bdo',
-      'big',
-      'blink',
-      'blockquote',
-      'body',
-      'br',
-      'button',
-      'canvas',
-      'caption',
-      'center',
-      'cite',
-      'code',
-      'col',
-      'colgroup',
-      'content',
-      'data',
-      'datalist',
-      'dd',
-      'decorator',
-      'del',
-      'details',
-      'dfn',
-      'dialog',
-      'dir',
-      'div',
-      'dl',
-      'dt',
-      'element',
-      'em',
-      'fieldset',
-      'figcaption',
-      'figure',
-      'font',
-      'footer',
-      'form',
-      'h1',
-      'h2',
-      'h3',
-      'h4',
-      'h5',
-      'h6',
-      'head',
-      'header',
-      'hgroup',
-      'hr',
-      'html',
-      'i',
-      'img',
-      'input',
-      'ins',
-      'kbd',
-      'label',
-      'legend',
-      'li',
-      'main',
-      'map',
-      'mark',
-      'marquee',
-      'menu',
-      'menuitem',
-      'meter',
-      'nav',
-      'nobr',
-      'ol',
-      'optgroup',
-      'option',
-      'output',
-      'p',
-      'picture',
-      'pre',
-      'progress',
-      'q',
-      'rp',
-      'rt',
-      'ruby',
-      's',
-      'samp',
-      'section',
-      'select',
-      'shadow',
-      'small',
-      'source',
-      'spacer',
-      'span',
-      'strike',
-      'strong',
-      'style',
-      'sub',
-      'summary',
-      'sup',
-      'table',
-      'tbody',
-      'td',
-      'template',
-      'textarea',
-      'tfoot',
-      'th',
-      'thead',
-      'time',
-      'tr',
-      'track',
-      'tt',
-      'u',
-      'ul',
-      'var',
-      'video',
-      'wbr'
-    ]);
-    const svg$1 = freeze([
+    const html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);
-      'svg',
-      'a',
-      'altglyph',
-      'altglyphdef',
-      'altglyphitem',
-      'animatecolor',
-      'animatemotion',
-      'animatetransform',
+    const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
-      'circle',
-      'clippath',
-      'defs',
-      'desc',
-      'ellipse',
-      'filter',
-      'font',
-      'g',
-      'glyph',
-      'glyphref',
-      'hkern',
-      'image',
-      'line',
-      'lineargradient',
+    const svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);
-      'marker',
-      'mask',
-      'metadata',
-      'mpath',
-      'path',
-      'pattern',
-      'polygon',
-      'polyline',
-      'radialgradient',
-      'rect',
-      'stop',
-      'style',
-      'switch',
-      'symbol',
-      'text',
-      'textpath',
-      'title',
-      'tref',
-      'tspan',
-      'view',
-      'vkern'
-    ]);
-    const svgFilters = freeze([
+    // List of SVG elements that are disallowed by default.
-      'feBlend',
-      'feColorMatrix',
-      'feComponentTransfer',
+    // We still need to know them so that we can do namespace
-      'feComposite',
-      'feConvolveMatrix',
-      'feDiffuseLighting',
-      'feDisplacementMap',
+    // checks properly in case one wants to add them to
-      'feDistantLight',
-      'feDropShadow',
-      'feFlood',
-      'feFuncA',
-      'feFuncB',
-      'feFuncG',
-      'feFuncR',
+    // allow-list.
-      'feGaussianBlur',
+    const svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);
-      'feImage',
-      'feMerge',
-      'feMergeNode',
-      'feMorphology',
-      'feOffset',
-      'fePointLight',
+    const mathMl$1 = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover', 'mprescripts']);
-      'feSpecularLighting',
+    // Similarly to SVG, we want to know all MathML elements,
-      'feSpotLight',
-      'feTile',
-      'feTurbulence'
-    ]);
-    const svgDisallowed = freeze([
+    // even those that we disallow by default.
-      'animate',
-      'color-profile',
-      'cursor',
-      'discard',
-      'font-face',
-      'font-face-format',
-      'font-face-name',
-      'font-face-src',
-      'font-face-uri',
-      'foreignobject',
-      'hatch',
-      'hatchpath',
-      'mesh',
-      'meshgradient',
-      'meshpatch',
-      'meshrow',
-      'missing-glyph',
-      'script',
-      'set',
-      'solidcolor',
-      'unknown',
-      'use'
-    ]);
-    const mathMl$1 = freeze([
-      'math',
-      'menclose',
-      'merror',
-      'mfenced',
-      'mfrac',
-      'mglyph',
-      'mi',
-      'mlabeledtr',
-      'mmultiscripts',
-      'mn',
-      'mo',
-      'mover',
-      'mpadded',
-      'mphantom',
-      'mroot',
-      'mrow',
-      'ms',
-      'mspace',
-      'msqrt',
-      'mstyle',
-      'msub',
-      'msup',
-      'msubsup',
-      'mtable',
-      'mtd',
-      'mtext',
-      'mtr',
-      'munder',
-      'munderover',
-      'mprescripts'
-    ]);
-    const mathMlDisallowed = freeze([
+    const mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);
-      'maction',
-      'maligngroup',
-      'malignmark',
-      'mlongdiv',
-      'mscarries',
-      'mscarry',
-      'msgroup',
-      'mstack',
-      'msline',
-      'msrow',
-      'semantics',
-      'annotation',
-      'annotation-xml',
-      'mprescripts',
-      'none'
-    ]);
     const text = freeze(['#text']);
-    const html = freeze([
-      'accept',
-      'action',
-      'align',
-      'alt',
-      'autocapitalize',
-      'autocomplete',
-      'autopictureinpicture',
-      'autoplay',
-      'background',
-      'bgcolor',
-      'border',
-      'capture',
-      'cellpadding',
-      'cellspacing',
-      'checked',
-      'cite',
-      'class',
-      'clear',
-      'color',
-      'cols',
-      'colspan',
-      'controls',
-      'controlslist',
-      'coords',
-      'crossorigin',
-      'datetime',
-      'decoding',
-      'default',
-      'dir',
-      'disabled',
-      'disablepictureinpicture',
-      'disableremoteplayback',
-      'download',
-      'draggable',
-      'enctype',
-      'enterkeyhint',
-      'face',
-      'for',
-      'headers',
-      'height',
-      'hidden',
-      'high',
-      'href',
-      'hreflang',
-      'id',
-      'inputmode',
-      'integrity',
-      'ismap',
-      'kind',
-      'label',
-      'lang',
-      'list',
-      'loading',
-      'loop',
-      'low',
-      'max',
-      'maxlength',
-      'media',
-      'method',
-      'min',
-      'minlength',
-      'multiple',
-      'muted',
-      'name',
-      'nonce',
-      'noshade',
-      'novalidate',
-      'nowrap',
-      'open',
-      'optimum',
-      'pattern',
-      'placeholder',
-      'playsinline',
-      'poster',
-      'preload',
-      'pubdate',
-      'radiogroup',
-      'readonly',
-      'rel',
-      'required',
-      'rev',
-      'reversed',
-      'role',
-      'rows',
-      'rowspan',
-      'spellcheck',
-      'scope',
-      'selected',
-      'shape',
-      'size',
-      'sizes',
-      'span',
-      'srclang',
-      'start',
-      'src',
-      'srcset',
-      'step',
-      'style',
-      'summary',
-      'tabindex',
-      'title',
-      'translate',
-      'type',
-      'usemap',
-      'valign',
-      'value',
-      'width',
-      'xmlns',
-      'slot'
-    ]);
-    const svg = freeze([
+    const html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'popover', 'popovertarget', 'popovertargetaction', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'wrap', 'xmlns', 'slot']);
-      'accent-height',
-      'accumulate',
-      'additive',
-      'alignment-baseline',
+    const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
-      'ascent',
-      'attributename',
-      'attributetype',
-      'azimuth',
-      'basefrequency',
-      'baseline-shift',
-      'begin',
-      'bias',
-      'by',
-      'class',
-      'clip',
-      'clippathunits',
-      'clip-path',
-      'clip-rule',
-      'color',
-      'color-interpolation',
+    const mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
-      'color-interpolation-filters',
+    const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
-      'color-profile',
-      'color-rendering',
-      'cx',
-      'cy',
-      'd',
-      'dx',
-      'dy',
-      'diffuseconstant',
-      'direction',
-      'display',
-      'divisor',
-      'dur',
-      'edgemode',
-      'elevation',
-      'end',
-      'fill',
-      'fill-opacity',
-      'fill-rule',
-      'filter',
-      'filterunits',
-      'flood-color',
-      'flood-opacity',
-      'font-family',
-      'font-size',
-      'font-size-adjust',
-      'font-stretch',
-      'font-style',
-      'font-variant',
-      'font-weight',
-      'fx',
-      'fy',
-      'g1',
-      'g2',
-      'glyph-name',
-      'glyphref',
-      'gradientunits',
-      'gradienttransform',
-      'height',
-      'href',
-      'id',
-      'image-rendering',
-      'in',
-      'in2',
-      'k',
-      'k1',
-      'k2',
-      'k3',
-      'k4',
-      'kerning',
-      'keypoints',
-      'keysplines',
-      'keytimes',
-      'lang',
-      'lengthadjust',
-      'letter-spacing',
-      'kernelmatrix',
-      'kernelunitlength',
-      'lighting-color',
-      'local',
-      'marker-end',
-      'marker-mid',
-      'marker-start',
-      'markerheight',
-      'markerunits',
-      'markerwidth',
-      'maskcontentunits',
-      'maskunits',
-      'max',
-      'mask',
-      'media',
-      'method',
-      'mode',
-      'min',
-      'name',
-      'numoctaves',
-      'offset',
-      'operator',
-      'opacity',
-      'order',
-      'orient',
-      'orientation',
-      'origin',
-      'overflow',
-      'paint-order',
-      'path',
-      'pathlength',
-      'patterncontentunits',
-      'patterntransform',
-      'patternunits',
-      'points',
-      'preservealpha',
-      'preserveaspectratio',
-      'primitiveunits',
-      'r',
-      'rx',
-      'ry',
-      'radius',
-      'refx',
-      'refy',
-      'repeatcount',
-      'repeatdur',
-      'restart',
-      'result',
-      'rotate',
-      'scale',
-      'seed',
-      'shape-rendering',
-      'specularconstant',
-      'specularexponent',
-      'spreadmethod',
-      'startoffset',
-      'stddeviation',
-      'stitchtiles',
-      'stop-color',
-      'stop-opacity',
-      'stroke-dasharray',
-      'stroke-dashoffset',
-      'stroke-linecap',
-      'stroke-linejoin',
-      'stroke-miterlimit',
-      'stroke-opacity',
-      'stroke',
-      'stroke-width',
-      'style',
-      'surfacescale',
-      'systemlanguage',
-      'tabindex',
-      'targetx',
-      'targety',
-      'transform',
-      'transform-origin',
-      'text-anchor',
-      'text-decoration',
-      'text-rendering',
-      'textlength',
-      'type',
-      'u1',
-      'u2',
-      'unicode',
-      'values',
-      'viewbox',
-      'visibility',
-      'version',
-      'vert-adv-y',
-      'vert-origin-x',
-      'vert-origin-y',
-      'width',
-      'word-spacing',
-      'wrap',
-      'writing-mode',
-      'xchannelselector',
-      'ychannelselector',
-      'x',
-      'x1',
-      'x2',
-      'xmlns',
-      'y',
-      'y1',
-      'y2',
-      'z',
-      'zoomandpan'
-    ]);
-    const mathMl = freeze([
-      'accent',
-      'accentunder',
-      'align',
-      'bevelled',
-      'close',
-      'columnsalign',
-      'columnlines',
-      'columnspan',
-      'denomalign',
-      'depth',
-      'dir',
-      'display',
-      'displaystyle',
-      'encoding',
-      'fence',
-      'frame',
-      'height',
-      'href',
-      'id',
-      'largeop',
-      'length',
-      'linethickness',
-      'lspace',
-      'lquote',
-      'mathbackground',
-      'mathcolor',
-      'mathsize',
-      'mathvariant',
-      'maxsize',
-      'minsize',
-      'movablelimits',
-      'notation',
-      'numalign',
-      'open',
-      'rowalign',
-      'rowlines',
-      'rowspacing',
-      'rowspan',
-      'rspace',
-      'rquote',
-      'scriptlevel',
-      'scriptminsize',
-      'scriptsizemultiplier',
+    // eslint-disable-next-line unicorn/better-regex
-      'selection',
-      'separator',
-      'separators',
-      'stretchy',
-      'subscriptshift',
-      'supscriptshift',
-      'symmetric',
-      'voffset',
-      'width',
-      'xmlns'
-    ]);
-    const xml = freeze([
-      'xlink:href',
-      'xml:id',
-      'xlink:title',
-      'xml:space',
-      'xmlns:xlink'
-    ]);
-    const MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm);
+    const MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
     const ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
-    const TMPLIT_EXPR = seal(/\${[\w\W]*}/gm);
+    const TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm); // eslint-disable-line unicorn/better-regex
-    const DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]/);
+    const DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/); // eslint-disable-line no-useless-escape
-    const ARIA_ATTR = seal(/^aria-[\-\w]+$/);
+    const ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
-    const IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i);
+    const IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape
+    );
     const IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
-    const ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g);
+    const ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g // eslint-disable-line no-control-regex
+    );
     const DOCTYPE_NAME = seal(/^html$/i);
+    const CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
-    var EXPRESSIONS = Object.freeze({
+    var EXPRESSIONS = /*#__PURE__*/Object.freeze({
       __proto__: null,
-      MUSTACHE_EXPR: MUSTACHE_EXPR,
-      ERB_EXPR: ERB_EXPR,
-      TMPLIT_EXPR: TMPLIT_EXPR,
-      DATA_ATTR: DATA_ATTR,
       ARIA_ATTR: ARIA_ATTR,
+      ATTR_WHITESPACE: ATTR_WHITESPACE,
+      CUSTOM_ELEMENT: CUSTOM_ELEMENT,
+      DATA_ATTR: DATA_ATTR,
+      DOCTYPE_NAME: DOCTYPE_NAME,
+      ERB_EXPR: ERB_EXPR,
       IS_ALLOWED_URI: IS_ALLOWED_URI,
       IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA,
-      ATTR_WHITESPACE: ATTR_WHITESPACE,
+      MUSTACHE_EXPR: MUSTACHE_EXPR,
-      DOCTYPE_NAME: DOCTYPE_NAME
+      TMPLIT_EXPR: TMPLIT_EXPR
     });
+    /* eslint-disable @typescript-eslint/indent */
+    // https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
+    const NODE_TYPE = {
+      element: 1,
+      attribute: 2,
+      text: 3,
+      cdataSection: 4,
+      entityReference: 5,
+      // Deprecated
+      entityNode: 6,
+      // Deprecated
+      progressingInstruction: 7,
+      comment: 8,
+      document: 9,
+      documentType: 10,
+      documentFragment: 11,
+      notation: 12 // Deprecated
+    };
+    const getGlobal = function getGlobal() {
-    const getGlobal = () => typeof window === 'undefined' ? null : window;
+      return typeof window === 'undefined' ? null : window;
+    };
+    /**
+     * Creates a no-op policy for internal use only.
+     * Don't export this function outside this module!
+     * @param trustedTypes The policy factory.
+     * @param purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).
+     * @return The policy created (or null, if Trusted Types
+     * are not supported or creating the policy failed).
+     */
     const _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, purifyHostElement) {
       if (typeof trustedTypes !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
         return null;
+      }
+      // Allow the callers to control the unique policy name
+      // by adding a data-tt-policy-suffix to the script element with the DOMPurify.
+      // Policy creation with duplicate names throws in Trusted Types.
       let suffix = null;
       const ATTR_NAME = 'data-tt-policy-suffix';
       if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
         suffix = purifyHostElement.getAttribute(ATTR_NAME);
+      }
           createScriptURL(scriptUrl) {
             return scriptUrl;
+          }
         });
       } catch (_) {
+        // Policy creation failed (most likely another DOMPurify script has
+        // already run). Skip creating the policy, as this will only cause errors
+        // if TT are enforced.
         console.warn('TrustedTypes policy ' + policyName + ' could not be created.');
         return null;
+      }
     };
+    const _createHooksMap = function _createHooksMap() {
+      return {
+        afterSanitizeAttributes: [],
+        afterSanitizeElements: [],
+        afterSanitizeShadowDOM: [],
+        beforeSanitizeAttributes: [],
+        beforeSanitizeElements: [],
+        beforeSanitizeShadowDOM: [],
+        uponSanitizeAttribute: [],
+        uponSanitizeElement: [],
+        uponSanitizeShadowNode: []
+      };
+    };
     function createDOMPurify() {
       let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
       const DOMPurify = root => createDOMPurify(root);
-      DOMPurify.version = '3.0.5';
+      DOMPurify.version = '3.2.4';
       DOMPurify.removed = [];
-      if (!window || !window.document || window.document.nodeType !== 9) {
+      if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
+        // Not running in a browser, provide a factory function
+        // so that you can pass your own Window
         DOMPurify.isSupported = false;
         return DOMPurify;
+      }
+      let {
+        document
+      } = window;
-      const originalDocument = window.document;
+      const originalDocument = document;
       const currentScript = originalDocument.currentScript;
+      const {
-      let {document} = window;
+        DocumentFragment,
+        HTMLTemplateElement,
+        Node,
+        Element,
+        NodeFilter,
-      const {DocumentFragment, HTMLTemplateElement, Node, Element, NodeFilter, NamedNodeMap = window.NamedNodeMap || window.MozNamedAttrMap, HTMLFormElement, DOMParser, trustedTypes} = window;
+        NamedNodeMap = window.NamedNodeMap || window.MozNamedAttrMap,
+        HTMLFormElement,
+        DOMParser,
+        trustedTypes
+      } = window;
       const ElementPrototype = Element.prototype;
       const cloneNode = lookupGetter(ElementPrototype, 'cloneNode');
+      const remove = lookupGetter(ElementPrototype, 'remove');
       const getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
       const getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
       const getParentNode = lookupGetter(ElementPrototype, 'parentNode');
+      // As per issue #47, the web-components registry is inherited by a
+      // new document created via createHTMLDocument. As per the spec
+      // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
+      // a new empty registry is used when creating a template contents owner
+      // document, so we use that as our parent document to ensure nothing
+      // is inherited.
       if (typeof HTMLTemplateElement === 'function') {
         const template = document.createElement('template');
         if (template.content && template.content.ownerDocument) {
           document = template.content.ownerDocument;
+        }
+      }
       let trustedTypesPolicy;
       let emptyHTML = '';
+      const {
+        implementation,
+        createNodeIterator,
-      const {implementation, createNodeIterator, createDocumentFragment, getElementsByTagName} = document;
+        createDocumentFragment,
+        getElementsByTagName
+      } = document;
+      const {
+        importNode
-      const {importNode} = originalDocument;
+      } = originalDocument;
-      let hooks = {};
+      let hooks = _createHooksMap();
+      /**
+       * Expose whether this browser supports running the full DOMPurify.
+       */
       DOMPurify.isSupported = typeof entries === 'function' && typeof getParentNode === 'function' && implementation && implementation.createHTMLDocument !== undefined;
+      const {
+        MUSTACHE_EXPR,
+        ERB_EXPR,
+        TMPLIT_EXPR,
+        DATA_ATTR,
+        ARIA_ATTR,
-      const {MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR, DATA_ATTR, ARIA_ATTR, IS_SCRIPT_OR_DATA, ATTR_WHITESPACE} = EXPRESSIONS;
+        IS_SCRIPT_OR_DATA,
+        ATTR_WHITESPACE,
+        CUSTOM_ELEMENT
+      } = EXPRESSIONS;
+      let {
-      let {IS_ALLOWED_URI: IS_ALLOWED_URI$1} = EXPRESSIONS;
+        IS_ALLOWED_URI: IS_ALLOWED_URI$1
+      } = EXPRESSIONS;
+      /**
+       * We consider the elements and attributes below to be safe. Ideally
+       * don't add any new ones but feel free to remove unwanted ones.
+       */
+      /* allowed element names */
       let ALLOWED_TAGS = null;
-      const DEFAULT_ALLOWED_TAGS = addToSet({}, [
+      const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);
-        ...html$1,
-        ...svg$1,
-        ...svgFilters,
+      /* Allowed attribute names */
-        ...mathMl$1,
-        ...text
-      ]);
       let ALLOWED_ATTR = null;
-      const DEFAULT_ALLOWED_ATTR = addToSet({}, [
+      const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);
-        ...html,
-        ...svg,
+      /*
-        ...mathMl,
+       * Configure how DOMPurify should handle custom elements and their attributes as well as customized built-in elements.
-        ...xml
+       * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)
+       * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)
+       * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.
-      ]);
+       */
-      let CUSTOM_ELEMENT_HANDLING = Object.seal(Object.create(null, {
+      let CUSTOM_ELEMENT_HANDLING = Object.seal(create$7(null, {
         tagNameCheck: {
           writable: true,
           configurable: false,
           enumerable: true,
           value: null
           configurable: false,
           enumerable: true,
           value: false
+        }
       }));
+      /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
       let FORBID_TAGS = null;
+      /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
       let FORBID_ATTR = null;
+      /* Decide if ARIA attributes are okay */
       let ALLOW_ARIA_ATTR = true;
+      /* Decide if custom data attributes are okay */
       let ALLOW_DATA_ATTR = true;
+      /* Decide if unknown protocols are okay */
       let ALLOW_UNKNOWN_PROTOCOLS = false;
+      /* Decide if self-closing tags in attributes are allowed.
+       * Usually removed due to a mXSS issue in jQuery 3.0 */
       let ALLOW_SELF_CLOSE_IN_ATTR = true;
+      /* Output should be safe for common template engines.
+       * This means, DOMPurify removes data attributes, mustaches and ERB
+       */
       let SAFE_FOR_TEMPLATES = false;
+      /* Output should be safe even for XML used within HTML and alike.
+       * This means, DOMPurify removes comments when containing risky content.
+       */
+      let SAFE_FOR_XML = true;
+      /* Decide if document with <html>... should be returned */
       let WHOLE_DOCUMENT = false;
+      /* Track whether config is already set on this instance of DOMPurify. */
       let SET_CONFIG = false;
+      /* Decide if all elements (e.g. style, script) must be children of
+       * document.body. By default, browsers might move them to document.head */
       let FORCE_BODY = false;
+      /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
+       * string (or a TrustedHTML object if Trusted Types are supported).
+       * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
+       */
       let RETURN_DOM = false;
+      /* Decide if a DOM `DocumentFragment` should be returned, instead of a html
+       * string  (or a TrustedHTML object if Trusted Types are supported) */
       let RETURN_DOM_FRAGMENT = false;
+      /* Try to return a Trusted Type object instead of a string, return a string in
+       * case Trusted Types are not supported  */
       let RETURN_TRUSTED_TYPE = false;
+      /* Output should be free from DOM clobbering attacks?
+       * This sanitizes markups named with colliding, clobberable built-in DOM APIs.
+       */
       let SANITIZE_DOM = true;
+      /* Achieve full DOM Clobbering protection by isolating the namespace of named
+       * properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.
+       *
+       * HTML/DOM spec rules that enable DOM Clobbering:
+       *   - Named Access on Window (§7.3.3)
+       *   - DOM Tree Accessors (§3.1.5)
+       *   - Form Element Parent-Child Relations (§4.10.3)
+       *   - Iframe srcdoc / Nested WindowProxies (§4.8.5)
+       *   - HTMLCollection (§4.2.10.2)
+       *
+       * Namespace isolation is implemented by prefixing `id` and `name` attributes
+       * with a constant string, i.e., `user-content-`
+       */
       let SANITIZE_NAMED_PROPS = false;
       const SANITIZE_NAMED_PROPS_PREFIX = 'user-content-';
+      /* Keep element content when removing element? */
       let KEEP_CONTENT = true;
+      /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
+       * of importing it into a new Document and returning a sanitized copy */
       let IN_PLACE = false;
+      /* Allow usage of profiles like html, svg and mathMl */
       let USE_PROFILES = {};
+      /* Tags to ignore content of when KEEP_CONTENT is true */
       let FORBID_CONTENTS = null;
-      const DEFAULT_FORBID_CONTENTS = addToSet({}, [
+      const DEFAULT_FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);
-        'annotation-xml',
+      /* Tags that are safe for data: URIs */
-        'audio',
-        'colgroup',
-        'desc',
-        'foreignobject',
-        'head',
-        'iframe',
-        'math',
-        'mi',
-        'mn',
-        'mo',
-        'ms',
-        'mtext',
-        'noembed',
-        'noframes',
-        'noscript',
-        'plaintext',
-        'script',
-        'style',
-        'svg',
-        'template',
-        'thead',
-        'title',
-        'video',
-        'xmp'
-      ]);
       let DATA_URI_TAGS = null;
-      const DEFAULT_DATA_URI_TAGS = addToSet({}, [
+      const DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);
-        'audio',
-        'video',
-        'img',
-        'source',
+      /* Attributes safe for values like "javascript:" */
-        'image',
-        'track'
-      ]);
       let URI_SAFE_ATTRIBUTES = null;
-      const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, [
+      const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);
-        'alt',
-        'class',
-        'for',
-        'id',
-        'label',
-        'name',
-        'pattern',
-        'placeholder',
-        'role',
-        'summary',
-        'title',
-        'value',
-        'style',
-        'xmlns'
-      ]);
       const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
       const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
       const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+      /* Document namespace */
       let NAMESPACE = HTML_NAMESPACE;
       let IS_EMPTY_INPUT = false;
+      /* Allowed XHTML+XML namespaces */
       let ALLOWED_NAMESPACES = null;
+      const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
+      let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);
-      const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [
+      let HTML_INTEGRATION_POINTS = addToSet({}, ['annotation-xml']);
-        MATHML_NAMESPACE,
+      // Certain elements are allowed in both SVG and HTML
-        SVG_NAMESPACE,
+      // namespace. We need to specify them explicitly
+      // so that they don't get erroneously deleted from
-        HTML_NAMESPACE
+      // HTML namespace.
+      const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
-      ], stringToString);
+      /* Parsing of strict XHTML documents */
-      let PARSER_MEDIA_TYPE;
+      let PARSER_MEDIA_TYPE = null;
-      const SUPPORTED_PARSER_MEDIA_TYPES = [
+      const SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];
-        'application/xhtml+xml',
-        'text/html'
-      ];
       const DEFAULT_PARSER_MEDIA_TYPE = 'text/html';
-      let transformCaseFunc;
+      let transformCaseFunc = null;
+      /* Keep a reference to config to pass to hooks */
       let CONFIG = null;
+      /* Ideally, do not touch anything below this line */
+      /* ______________________________________________ */
       const formElement = document.createElement('form');
       const isRegexOrFunction = function isRegexOrFunction(testValue) {
         return testValue instanceof RegExp || testValue instanceof Function;
       };
+      /**
+       * _parseConfig
+       *
+       * @param cfg optional config literal
+       */
+      // eslint-disable-next-line complexity
-      const _parseConfig = function _parseConfig(cfg) {
+      const _parseConfig = function _parseConfig() {
+        let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
         if (CONFIG && CONFIG === cfg) {
           return;
+        }
+        /* Shield configuration object from tampering */
         if (!cfg || typeof cfg !== 'object') {
           cfg = {};
+        }
+        /* Shield configuration object from prototype pollution */
         cfg = clone(cfg);
+        PARSER_MEDIA_TYPE =
+        // eslint-disable-next-line unicorn/prefer-includes
-        PARSER_MEDIA_TYPE = SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? PARSER_MEDIA_TYPE = DEFAULT_PARSER_MEDIA_TYPE : PARSER_MEDIA_TYPE = cfg.PARSER_MEDIA_TYPE;
+        SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
+        // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.
         transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? stringToString : stringToLowerCase;
+        /* Set configuration parameters */
-        ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
+        ALLOWED_TAGS = objectHasOwnProperty(cfg, 'ALLOWED_TAGS') ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
-        ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
+        ALLOWED_ATTR = objectHasOwnProperty(cfg, 'ALLOWED_ATTR') ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
-        ALLOWED_NAMESPACES = 'ALLOWED_NAMESPACES' in cfg ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
+        ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, 'ALLOWED_NAMESPACES') ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
-        URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
+        URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, 'ADD_URI_SAFE_ATTR') ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
-        DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
+        DATA_URI_TAGS = objectHasOwnProperty(cfg, 'ADD_DATA_URI_TAGS') ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
-        FORBID_CONTENTS = 'FORBID_CONTENTS' in cfg ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
+        FORBID_CONTENTS = objectHasOwnProperty(cfg, 'FORBID_CONTENTS') ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
-        FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : {};
+        FORBID_TAGS = objectHasOwnProperty(cfg, 'FORBID_TAGS') ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : {};
-        FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : {};
+        FORBID_ATTR = objectHasOwnProperty(cfg, 'FORBID_ATTR') ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : {};
-        USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false;
+        USE_PROFILES = objectHasOwnProperty(cfg, 'USE_PROFILES') ? cfg.USE_PROFILES : false;
-        ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
+        ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true
-        ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
+        ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true
-        ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false;
+        ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false
-        ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false;
+        ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false; // Default true
-        SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false;
+        SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false
+        SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false; // Default true
-        WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false;
+        WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false
-        RETURN_DOM = cfg.RETURN_DOM || false;
+        RETURN_DOM = cfg.RETURN_DOM || false; // Default false
-        RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false;
+        RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false
-        RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false;
+        RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false
-        FORCE_BODY = cfg.FORCE_BODY || false;
+        FORCE_BODY = cfg.FORCE_BODY || false; // Default false
-        SANITIZE_DOM = cfg.SANITIZE_DOM !== false;
+        SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true
-        SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false;
+        SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false; // Default false
-        KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
+        KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true
-        IN_PLACE = cfg.IN_PLACE || false;
+        IN_PLACE = cfg.IN_PLACE || false; // Default false
         IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
         NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+        MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS || MATHML_TEXT_INTEGRATION_POINTS;
+        HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS || HTML_INTEGRATION_POINTS;
         CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
         if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
           CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+        }
         if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
           ALLOW_DATA_ATTR = false;
+        }
         if (RETURN_DOM_FRAGMENT) {
           RETURN_DOM = true;
+        }
+        /* Parse profile info */
         if (USE_PROFILES) {
-          ALLOWED_TAGS = addToSet({}, [...text]);
+          ALLOWED_TAGS = addToSet({}, text);
           ALLOWED_ATTR = [];
           if (USE_PROFILES.html === true) {
             addToSet(ALLOWED_TAGS, html$1);
             addToSet(ALLOWED_ATTR, html);
+          }
             addToSet(ALLOWED_TAGS, mathMl$1);
             addToSet(ALLOWED_ATTR, mathMl);
             addToSet(ALLOWED_ATTR, xml);
+          }
+        }
+        /* Merge configuration parameters */
         if (cfg.ADD_TAGS) {
           if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
             ALLOWED_TAGS = clone(ALLOWED_TAGS);
+          }
           addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
           if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
             FORBID_CONTENTS = clone(FORBID_CONTENTS);
+          }
           addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
+        }
+        /* Add #text in case KEEP_CONTENT is set to true */
         if (KEEP_CONTENT) {
           ALLOWED_TAGS['#text'] = true;
+        }
+        /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
         if (WHOLE_DOCUMENT) {
-          addToSet(ALLOWED_TAGS, [
+          addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);
-            'html',
-            'head',
-            'body'
-          ]);
+        }
+        /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
         if (ALLOWED_TAGS.table) {
           addToSet(ALLOWED_TAGS, ['tbody']);
           delete FORBID_TAGS.tbody;
+        }
         if (cfg.TRUSTED_TYPES_POLICY) {
             throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+          }
           if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== 'function') {
             throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+          }
+          // Overwrite existing TrustedTypes policy.
           trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
+          // Sign local variables required by `sanitize`.
           emptyHTML = trustedTypesPolicy.createHTML('');
         } else {
+          // Uninitialized policy, attempt to initialize the internal dompurify policy.
           if (trustedTypesPolicy === undefined) {
             trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+          }
+          // If creating the internal policy succeeded sign internal variables.
           if (trustedTypesPolicy !== null && typeof emptyHTML === 'string') {
             emptyHTML = trustedTypesPolicy.createHTML('');
+          }
+        }
+        // Prevent further manipulation of configuration.
+        // Not available in IE8, Safari 5, etc.
         if (freeze) {
           freeze(cfg);
+        }
         CONFIG = cfg;
       };
-      const MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, [
+      /* Keep track of all possible SVG and MathML tags
-        'mi',
-        'mo',
-        'mn',
-        'ms',
-        'mtext'
-      ]);
-      const HTML_INTEGRATION_POINTS = addToSet({}, [
+       * so that we can perform the namespace checks
-        'foreignobject',
-        'desc',
-        'title',
+       * correctly. */
-        'annotation-xml'
+      const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
-      ]);
-      const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, [
+      const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
-        'title',
-        'style',
-        'font',
-        'a',
-        'script'
-      ]);
+      /**
-      const ALL_SVG_TAGS = addToSet({}, svg$1);
+       * @param element a DOM element whose namespace is being checked
-      addToSet(ALL_SVG_TAGS, svgFilters);
+       * @returns Return false if the element has a
-      addToSet(ALL_SVG_TAGS, svgDisallowed);
+       *  namespace that a spec-compliant parser would never
-      const ALL_MATHML_TAGS = addToSet({}, mathMl$1);
+       *  return. Return true otherwise.
-      addToSet(ALL_MATHML_TAGS, mathMlDisallowed);
+       */
       const _checkValidNamespace = function _checkValidNamespace(element) {
         let parent = getParentNode(element);
+        // In JSDOM, if we're inside shadow DOM, then parentNode
+        // can be null. We just simulate parent in this case.
         if (!parent || !parent.tagName) {
           parent = {
             namespaceURI: NAMESPACE,
             tagName: 'template'
           };
         const parentTagName = stringToLowerCase(parent.tagName);
         if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
           return false;
+        }
         if (element.namespaceURI === SVG_NAMESPACE) {
+          // The only way to switch from HTML namespace to SVG
+          // is via <svg>. If it happens via any other tag, then
+          // it should be killed.
           if (parent.namespaceURI === HTML_NAMESPACE) {
             return tagName === 'svg';
+          }
+          // The only way to switch from MathML to SVG is via`
+          // svg if parent is either <annotation-xml> or MathML
+          // text integration points.
           if (parent.namespaceURI === MATHML_NAMESPACE) {
             return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+          }
+          // We only allow elements that are defined in SVG
+          // spec. All others are disallowed in SVG namespace.
           return Boolean(ALL_SVG_TAGS[tagName]);
+        }
         if (element.namespaceURI === MATHML_NAMESPACE) {
+          // The only way to switch from HTML namespace to MathML
+          // is via <math>. If it happens via any other tag, then
+          // it should be killed.
           if (parent.namespaceURI === HTML_NAMESPACE) {
             return tagName === 'math';
+          }
+          // The only way to switch from SVG to MathML is via
+          // <math> and HTML integration points
           if (parent.namespaceURI === SVG_NAMESPACE) {
             return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];
+          }
+          // We only allow elements that are defined in MathML
+          // spec. All others are disallowed in MathML namespace.
           return Boolean(ALL_MATHML_TAGS[tagName]);
+        }
         if (element.namespaceURI === HTML_NAMESPACE) {
+          // The only way to switch from SVG to HTML is via
+          // HTML integration points, and from MathML to HTML
+          // is via MathML text integration points
           if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
             return false;
+          }
           if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
             return false;
+          }
+          // We disallow tags that are specific for MathML
+          // or SVG and should never appear in HTML namespace
           return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+        }
+        // For XHTML and XML documents that support custom namespaces
         if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && ALLOWED_NAMESPACES[element.namespaceURI]) {
           return true;
+        }
+        // The code should never reach this place (this means
+        // that the element somehow got namespace that is not
+        // HTML, SVG, MathML or allowed via ALLOWED_NAMESPACES).
+        // Return false just in case.
         return false;
       };
+      /**
+       * _forceRemove
+       *
+       * @param node a DOM node
+       */
       const _forceRemove = function _forceRemove(node) {
-        arrayPush(DOMPurify.removed, { element: node });
+        arrayPush(DOMPurify.removed, {
+          element: node
+        });
         try {
+          // eslint-disable-next-line unicorn/prefer-dom-node-remove
-          node.parentNode.removeChild(node);
+          getParentNode(node).removeChild(node);
         } catch (_) {
-          node.remove();
+          remove(node);
+        }
       };
+      /**
+       * _removeAttribute
+       *
+       * @param name an Attribute name
+       * @param element a DOM node
+       */
-      const _removeAttribute = function _removeAttribute(name, node) {
+      const _removeAttribute = function _removeAttribute(name, element) {
         try {
           arrayPush(DOMPurify.removed, {
-            attribute: node.getAttributeNode(name),
+            attribute: element.getAttributeNode(name),
-            from: node
+            from: element
           });
         } catch (_) {
           arrayPush(DOMPurify.removed, {
             attribute: null,
-            from: node
+            from: element
           });
+        }
-        node.removeAttribute(name);
+        element.removeAttribute(name);
+        // We void attribute values for unremovable "is" attributes
-        if (name === 'is' && !ALLOWED_ATTR[name]) {
+        if (name === 'is') {
           if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
             try {
-              _forceRemove(node);
+              _forceRemove(element);
-            } catch (_) {
+            } catch (_) {}
-            }
           } else {
             try {
-              node.setAttribute(name, '');
+              element.setAttribute(name, '');
-            } catch (_) {
+            } catch (_) {}
-            }
+          }
+        }
       };
+      /**
+       * _initDocument
+       *
+       * @param dirty - a string of dirty markup
+       * @return a DOM, filled with the dirty markup
+       */
       const _initDocument = function _initDocument(dirty) {
+        /* Create a HTML document */
-        let doc;
+        let doc = null;
-        let leadingWhitespace;
+        let leadingWhitespace = null;
         if (FORCE_BODY) {
           dirty = '<remove></remove>' + dirty;
         } else {
+          /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */
           const matches = stringMatch(dirty, /^[\r\n\t ]+/);
           leadingWhitespace = matches && matches[0];
+        }
         if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && NAMESPACE === HTML_NAMESPACE) {
+          // Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)
           dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + '</body></html>';
+        }
         const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+        /*
+         * Use the DOMParser API by default, fallback later if needs be
+         * DOMParser not work for svg when has multiple root element.
+         */
         if (NAMESPACE === HTML_NAMESPACE) {
           try {
             doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
-          } catch (_) {
+          } catch (_) {}
-          }
+        }
+        /* Use createHTMLDocument in case DOMParser is not available */
         if (!doc || !doc.documentElement) {
           doc = implementation.createDocument(NAMESPACE, 'template', null);
           try {
             doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
           } catch (_) {
+            // Syntax error if dirtyPayload is invalid xml
+          }
+        }
         const body = doc.body || doc.documentElement;
         if (dirty && leadingWhitespace) {
           body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+        }
+        /* Work on whole document or just its body */
         if (NAMESPACE === HTML_NAMESPACE) {
           return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
+        }
         return WHOLE_DOCUMENT ? doc.documentElement : body;
       };
+      /**
+       * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
+       *
+       * @param root The root element or node to start traversing on.
+       * @return The created NodeIterator
+       */
-      const _createIterator = function _createIterator(root) {
+      const _createNodeIterator = function _createNodeIterator(root) {
+        return createNodeIterator.call(root.ownerDocument || root, root,
+        // eslint-disable-next-line no-bitwise
+        NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION, null);
+      };
+      /**
+       * _isClobbered
+       *
+       * @param element element to check for clobbering attacks
+       * @return true if clobbered, false if safe
+       */
+      const _isClobbered = function _isClobbered(element) {
-        return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, null, false);
+        return element instanceof HTMLFormElement && (typeof element.nodeName !== 'string' || typeof element.textContent !== 'string' || typeof element.removeChild !== 'function' || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== 'function' || typeof element.setAttribute !== 'function' || typeof element.namespaceURI !== 'string' || typeof element.insertBefore !== 'function' || typeof element.hasChildNodes !== 'function');
+      };
+      /**
+       * Checks whether the given object is a DOM node.
+       *
+       * @param value object to check whether it's a DOM node
+       * @return true is object is a DOM node
+       */
+      const _isNode = function _isNode(value) {
+        return typeof Node === 'function' && value instanceof Node;
       };
-      const _isClobbered = function _isClobbered(elm) {
-        return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function');
+      function _executeHooks(hooks, currentNode, data) {
-      };
-      const _isNode = function _isNode(object) {
-        return typeof Node === 'object' ? object instanceof Node : object && typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string';
-      };
-      const _executeHook = function _executeHook(entryPoint, currentNode, data) {
-        if (!hooks[entryPoint]) {
-          return;
-        }
-        arrayForEach(hooks[entryPoint], hook => {
+        arrayForEach(hooks, hook => {
           hook.call(DOMPurify, currentNode, data, CONFIG);
         });
-      };
+      }
+      /**
+       * _sanitizeElements
+       *
+       * @protect nodeName
+       * @protect textContent
+       * @protect removeChild
+       * @param currentNode to check for permission to exist
+       * @return true if node was killed, false if left alive
+       */
       const _sanitizeElements = function _sanitizeElements(currentNode) {
-        let content;
+        let content = null;
+        /* Execute a hook if present */
-        _executeHook('beforeSanitizeElements', currentNode, null);
+        _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+        /* Check if element is clobbered or can clobber */
         if (_isClobbered(currentNode)) {
           _forceRemove(currentNode);
           return true;
+        }
+        /* Now let's check the element's type and name */
         const tagName = transformCaseFunc(currentNode.nodeName);
+        /* Execute a hook if present */
-        _executeHook('uponSanitizeElement', currentNode, {
+        _executeHooks(hooks.uponSanitizeElement, currentNode, {
           tagName,
           allowedTags: ALLOWED_TAGS
         });
+        /* Detect mXSS attempts abusing namespace confusion */
-        if (currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
+        if (currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
+          _forceRemove(currentNode);
+          return true;
+        }
+        /* Remove any occurrence of processing instructions */
+        if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
           _forceRemove(currentNode);
           return true;
+        }
+        /* Remove any kind of possibly harmful comments */
+        if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
+          _forceRemove(currentNode);
+          return true;
+        }
+        /* Remove element if anything forbids its presence */
         if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+          /* Check if we have a custom element to handle */
-          if (!FORBID_TAGS[tagName] && _basicCustomElementTest(tagName)) {
+          if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
-            if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName))
+            if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
               return false;
+            }
-            if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName))
+            if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
               return false;
+            }
+          }
+          /* Keep content except for bad-listed elements */
           if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
             const parentNode = getParentNode(currentNode) || currentNode.parentNode;
             const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
             if (childNodes && parentNode) {
               const childCount = childNodes.length;
               for (let i = childCount - 1; i >= 0; --i) {
+                const childClone = cloneNode(childNodes[i], true);
+                childClone.__removalCount = (currentNode.__removalCount || 0) + 1;
-                parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode));
+                parentNode.insertBefore(childClone, getNextSibling(currentNode));
+              }
+            }
+          }
           _forceRemove(currentNode);
           return true;
+        }
+        /* Check whether element has a valid namespace */
         if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
           _forceRemove(currentNode);
           return true;
+        }
+        /* Make sure that older browsers don't get fallback-tag mXSS */
         if ((tagName === 'noscript' || tagName === 'noembed' || tagName === 'noframes') && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
           _forceRemove(currentNode);
           return true;
+        }
+        /* Sanitize element content to be template-safe */
-        if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {
+        if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
+          /* Get the element's text content */
           content = currentNode.textContent;
-          content = stringReplace(content, MUSTACHE_EXPR, ' ');
+          arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
-          content = stringReplace(content, ERB_EXPR, ' ');
+            content = stringReplace(content, expr, ' ');
-          content = stringReplace(content, TMPLIT_EXPR, ' ');
+          });
           if (currentNode.textContent !== content) {
+            arrayPush(DOMPurify.removed, {
-            arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });
+              element: currentNode.cloneNode()
+            });
             currentNode.textContent = content;
+          }
+        }
+        /* Execute a hook if present */
-        _executeHook('afterSanitizeElements', currentNode, null);
+        _executeHooks(hooks.afterSanitizeElements, currentNode, null);
         return false;
       };
+      /**
+       * _isValidAttribute
+       *
+       * @param lcTag Lowercase tag name of containing element.
+       * @param lcName Lowercase attribute name.
+       * @param value Attribute value.
+       * @return Returns true if `value` is valid, otherwise false.
+       */
+      // eslint-disable-next-line complexity
       const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
+        /* Make sure attribute cannot clobber */
         if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
           return false;
+        }
-        if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName));
+        /* Allow valid data-* attributes: At least one character after "-"
+            (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
+            XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
-        else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName));
+            We don't need to check the value; it's always URI safe. */
+        if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+          if (
+          // First condition does a very basic check if a) it's basically a valid custom element tagname AND
+          // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+          // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
-        else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+          _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) ||
+          // Alternative, second condition checks if it's an `is`-attribute, AND
-          if (_basicCustomElementTest(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) || lcName === 'is' && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value)));
+          // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
-          else {
+          lcName === 'is' && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))) ; else {
             return false;
+          }
-        } else if (URI_SAFE_ATTRIBUTES[lcName]);
+          /* Check value is safe. First, is attr inert? If so, is safe */
-        else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE, '')));
-        else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]);
+        } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if (value) {
-        else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA, stringReplace(value, ATTR_WHITESPACE, '')));
-        else if (value) {
           return false;
         } else ;
         return true;
       };
+      /**
+       * _isBasicCustomElement
+       * checks if at least one dash is included in tagName, and it's not the first char
+       * for more sophisticated checking see https://github.com/sindresorhus/validate-element-name
+       *
+       * @param tagName name of the tag of the node to sanitize
+       * @returns Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
+       */
-      const _basicCustomElementTest = function _basicCustomElementTest(tagName) {
+      const _isBasicCustomElement = function _isBasicCustomElement(tagName) {
-        return tagName.indexOf('-') > 0;
+        return tagName !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT);
       };
+      /**
+       * _sanitizeAttributes
+       *
+       * @protect attributes
+       * @protect nodeName
+       * @protect removeAttribute
+       * @protect setAttribute
+       *
+       * @param currentNode to sanitize
+       */
       const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
-        let attr;
+        /* Execute a hook if present */
+        _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
-        let value;
+        const {
-        let lcName;
+          attributes
-        let l;
+        } = currentNode;
-        _executeHook('beforeSanitizeAttributes', currentNode, null);
+        /* Check if we have attributes; if not we might have a text node */
-        const {attributes} = currentNode;
+        if (!attributes || _isClobbered(currentNode)) {
-        if (!attributes) {
           return;
+        }
         const hookEvent = {
           attrName: '',
           attrValue: '',
           keepAttr: true,
-          allowedAttributes: ALLOWED_ATTR
+          allowedAttributes: ALLOWED_ATTR,
+          forceKeepAttr: undefined
         };
-        l = attributes.length;
+        let l = attributes.length;
+        /* Go backwards over all attributes; safely remove bad ones */
         while (l--) {
-          attr = attributes[l];
+          const attr = attributes[l];
+          const {
+            name,
+            namespaceURI,
+            value: attrValue
+          } = attr;
-          const {name, namespaceURI} = attr;
+          const lcName = transformCaseFunc(name);
-          value = name === 'value' ? attr.value : stringTrim(attr.value);
+          let value = name === 'value' ? attrValue : stringTrim(attrValue);
           const initValue = value;
-          lcName = transformCaseFunc(name);
+          /* Execute a hook if present */
           hookEvent.attrName = lcName;
           hookEvent.attrValue = value;
           hookEvent.keepAttr = true;
-          hookEvent.forceKeepAttr = undefined;
+          hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set
-          _executeHook('uponSanitizeAttribute', currentNode, hookEvent);
+          _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
           value = hookEvent.attrValue;
+          /* Full DOM Clobbering protection via namespace isolation,
+           * Prefix id and name attributes with `user-content-`
+           */
+          if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {
+            // Remove the attribute with this value
+            _removeAttribute(name, currentNode);
+            // Prefix the value and later re-create the attribute with the sanitized value
+            value = SANITIZE_NAMED_PROPS_PREFIX + value;
+          }
+          /* Work around a security issue with comments inside attributes */
+          if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|title)/i, value)) {
+            _removeAttribute(name, currentNode);
+            continue;
+          }
+          /* Did the hooks approve of the attribute? */
           if (hookEvent.forceKeepAttr) {
             continue;
+          }
+          /* Remove attribute */
+          /* Did the hooks approve of the attribute? */
           if (!hookEvent.keepAttr) {
             _removeAttribute(name, currentNode);
             continue;
+          }
+          /* Work around a security issue in jQuery 3.0 */
           if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
             _removeAttribute(name, currentNode);
             continue;
+          }
+          /* Sanitize attribute content to be template-safe */
           if (SAFE_FOR_TEMPLATES) {
-            value = stringReplace(value, MUSTACHE_EXPR, ' ');
+            arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
-            value = stringReplace(value, ERB_EXPR, ' ');
+              value = stringReplace(value, expr, ' ');
-            value = stringReplace(value, TMPLIT_EXPR, ' ');
+            });
+          }
+          /* Is `value` valid for this attribute? */
           const lcTag = transformCaseFunc(currentNode.nodeName);
           if (!_isValidAttribute(lcTag, lcName, value)) {
             _removeAttribute(name, currentNode);
             continue;
+          }
-          if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {
-            _removeAttribute(name, currentNode);
+          /* Handle attributes that require Trusted Types */
-            value = SANITIZE_NAMED_PROPS_PREFIX + value;
-          }
           if (trustedTypesPolicy && typeof trustedTypes === 'object' && typeof trustedTypes.getAttributeType === 'function') {
-            if (namespaceURI);
+            if (namespaceURI) ; else {
-            else {
               switch (trustedTypes.getAttributeType(lcTag, lcName)) {
-              case 'TrustedHTML': {
+                case 'TrustedHTML':
+                  {
-                  value = trustedTypesPolicy.createHTML(value);
+                    value = trustedTypesPolicy.createHTML(value);
-                  break;
+                    break;
-                }
+                  }
-              case 'TrustedScriptURL': {
+                case 'TrustedScriptURL':
+                  {
-                  value = trustedTypesPolicy.createScriptURL(value);
+                    value = trustedTypesPolicy.createScriptURL(value);
-                  break;
+                    break;
-                }
+                  }
+              }
+            }
+          }
+          /* Handle invalid data-* attribute set by try-catching it */
           if (value !== initValue) {
             try {
               if (namespaceURI) {
                 currentNode.setAttributeNS(namespaceURI, name, value);
               } else {
+                /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
                 currentNode.setAttribute(name, value);
+              }
+              if (_isClobbered(currentNode)) {
+                _forceRemove(currentNode);
-            } catch (_) {
+              } else {
-              _removeAttribute(name, currentNode);
+                arrayPop(DOMPurify.removed);
-            }
+              }
+            } catch (_) {}
+          }
+        }
+        /* Execute a hook if present */
-        _executeHook('afterSanitizeAttributes', currentNode, null);
+        _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
       };
+      /**
+       * _sanitizeShadowDOM
+       *
+       * @param fragment to iterate over recursively
+       */
       const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
-        let shadowNode;
+        let shadowNode = null;
-        const shadowIterator = _createIterator(fragment);
+        const shadowIterator = _createNodeIterator(fragment);
+        /* Execute a hook if present */
-        _executeHook('beforeSanitizeShadowDOM', fragment, null);
+        _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
         while (shadowNode = shadowIterator.nextNode()) {
+          /* Execute a hook if present */
-          _executeHook('uponSanitizeShadowNode', shadowNode, null);
+          _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
+          /* Sanitize tags and elements */
-          if (_sanitizeElements(shadowNode)) {
+          _sanitizeElements(shadowNode);
-            continue;
+          /* Check attributes next */
+          _sanitizeAttributes(shadowNode);
-          }
+          /* Deep shadow DOM detected */
           if (shadowNode.content instanceof DocumentFragment) {
             _sanitizeShadowDOM(shadowNode.content);
+          }
-          _sanitizeAttributes(shadowNode);
+        }
+        /* Execute a hook if present */
-        _executeHook('afterSanitizeShadowDOM', fragment, null);
+        _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
       };
+      // eslint-disable-next-line complexity
       DOMPurify.sanitize = function (dirty) {
         let cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-        let body;
+        let body = null;
-        let importedNode;
+        let importedNode = null;
-        let currentNode;
+        let currentNode = null;
-        let returnNode;
+        let returnNode = null;
+        /* Make sure we have a string to sanitize.
+          DO NOT return early, as this will return the wrong type if
+          the user has requested a DOM object rather than a string */
         IS_EMPTY_INPUT = !dirty;
         if (IS_EMPTY_INPUT) {
           dirty = '<!-->';
+        }
+        /* Stringify, in case dirty is an object */
         if (typeof dirty !== 'string' && !_isNode(dirty)) {
           if (typeof dirty.toString === 'function') {
             dirty = dirty.toString();
             if (typeof dirty !== 'string') {
               throw typeErrorCreate('dirty is not a string, aborting');
+            }
           } else {
             throw typeErrorCreate('toString is not a function');
+          }
+        }
+        /* Return dirty HTML if DOMPurify cannot run */
         if (!DOMPurify.isSupported) {
           return dirty;
+        }
+        /* Assign config vars */
         if (!SET_CONFIG) {
           _parseConfig(cfg);
+        }
+        /* Clean up removed elements */
         DOMPurify.removed = [];
+        /* Check if dirty is correctly typed for IN_PLACE */
         if (typeof dirty === 'string') {
           IN_PLACE = false;
+        }
         if (IN_PLACE) {
+          /* Do some early pre-sanitization to avoid unsafe root nodes */
           if (dirty.nodeName) {
             const tagName = transformCaseFunc(dirty.nodeName);
             if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
               throw typeErrorCreate('root node is forbidden and cannot be sanitized in-place');
+            }
+          }
         } else if (dirty instanceof Node) {
+          /* If dirty is a DOM element, append to an empty document to avoid
+             elements being stripped by the parser */
           body = _initDocument('<!---->');
           importedNode = body.ownerDocument.importNode(dirty, true);
-          if (importedNode.nodeType === 1 && importedNode.nodeName === 'BODY') {
+          if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === 'BODY') {
+            /* Node is already a body, use as is */
             body = importedNode;
           } else if (importedNode.nodeName === 'HTML') {
             body = importedNode;
           } else {
+            // eslint-disable-next-line unicorn/prefer-dom-node-append
             body.appendChild(importedNode);
+          }
         } else {
+          /* Exit directly if we have nothing to do */
-          if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && dirty.indexOf('<') === -1) {
+          if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&
+          // eslint-disable-next-line unicorn/prefer-includes
+          dirty.indexOf('<') === -1) {
             return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+          }
+          /* Initialize the document to work on */
           body = _initDocument(dirty);
+          /* Check we have a DOM node from the data */
           if (!body) {
             return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : '';
+          }
+        }
+        /* Remove first element node (ours) if FORCE_BODY is set */
         if (body && FORCE_BODY) {
           _forceRemove(body.firstChild);
+        }
+        /* Get node iterator */
-        const nodeIterator = _createIterator(IN_PLACE ? dirty : body);
+        const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
+        /* Now start iterating over the created document */
         while (currentNode = nodeIterator.nextNode()) {
+          /* Sanitize tags and elements */
-          if (_sanitizeElements(currentNode)) {
+          _sanitizeElements(currentNode);
-            continue;
+          /* Check attributes next */
-          }
+          _sanitizeAttributes(currentNode);
+          /* Shadow DOM detected, sanitize it */
           if (currentNode.content instanceof DocumentFragment) {
             _sanitizeShadowDOM(currentNode.content);
+          }
-          _sanitizeAttributes(currentNode);
+        }
+        /* If we sanitized `dirty` in-place, return it. */
         if (IN_PLACE) {
           return dirty;
+        }
+        /* Return sanitized string or DOM */
         if (RETURN_DOM) {
           if (RETURN_DOM_FRAGMENT) {
             returnNode = createDocumentFragment.call(body.ownerDocument);
             while (body.firstChild) {
+              // eslint-disable-next-line unicorn/prefer-dom-node-append
               returnNode.appendChild(body.firstChild);
+            }
           } else {
             returnNode = body;
+          }
           if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {
+            /*
+              AdoptNode() is not used because internal state is not reset
+              (e.g. the past names map of a HTMLFormElement), this is safe
+              in theory but we would rather not risk another attack vector.
+              The state that is cloned by importNode() is explicitly defined
+              by the specs.
+            */
             returnNode = importNode.call(originalDocument, returnNode, true);
+          }
           return returnNode;
+        }
         let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+        /* Serialize doctype if allowed */
         if (WHOLE_DOCUMENT && ALLOWED_TAGS['!doctype'] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
           serializedHTML = '<!DOCTYPE ' + body.ownerDocument.doctype.name + '>\n' + serializedHTML;
+        }
+        /* Sanitize final string template-safe */
         if (SAFE_FOR_TEMPLATES) {
-          serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR, ' ');
+          arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
-          serializedHTML = stringReplace(serializedHTML, ERB_EXPR, ' ');
+            serializedHTML = stringReplace(serializedHTML, expr, ' ');
-          serializedHTML = stringReplace(serializedHTML, TMPLIT_EXPR, ' ');
+          });
+        }
         return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
       };
-      DOMPurify.setConfig = function (cfg) {
+      DOMPurify.setConfig = function () {
+        let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
         _parseConfig(cfg);
         SET_CONFIG = true;
       };
       DOMPurify.clearConfig = function () {
         CONFIG = null;
         SET_CONFIG = false;
       };
       DOMPurify.isValidAttribute = function (tag, attr, value) {
+        /* Initialize shared config vars if necessary. */
         if (!CONFIG) {
           _parseConfig({});
+        }
         const lcTag = transformCaseFunc(tag);
         const lcName = transformCaseFunc(attr);
       };
       DOMPurify.addHook = function (entryPoint, hookFunction) {
         if (typeof hookFunction !== 'function') {
           return;
+        }
-        hooks[entryPoint] = hooks[entryPoint] || [];
         arrayPush(hooks[entryPoint], hookFunction);
       };
-      DOMPurify.removeHook = function (entryPoint) {
+      DOMPurify.removeHook = function (entryPoint, hookFunction) {
-        if (hooks[entryPoint]) {
+        if (hookFunction !== undefined) {
-          return arrayPop(hooks[entryPoint]);
+          const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+          return index === -1 ? undefined : arraySplice(hooks[entryPoint], index, 1)[0];
+        }
+        return arrayPop(hooks[entryPoint]);
       };
       DOMPurify.removeHooks = function (entryPoint) {
-        if (hooks[entryPoint]) {
-          hooks[entryPoint] = [];
+        hooks[entryPoint] = [];
-        }
       };
       DOMPurify.removeAllHooks = function () {
-        hooks = {};
+        hooks = _createHooksMap();
       };
       return DOMPurify;
+    }
     var purify = createDOMPurify();
+      }
     };
     const decodeUri = encodedUri => {
       try {
         return decodeURIComponent(encodedUri);
-      } catch (ex) {
+      } catch (_a) {
         return unescape(encodedUri);
+      }
     };
     const isInvalidUri = (settings, uri, tagName) => {
       const decodedUri = decodeUri(uri).replace(/\s/g, '');
       const element = SugarElement.fromDom(node);
       const isInternalElement = has$1(element, internalElementAttr);
       const bogus = get$9(element, 'data-mce-bogus');
       if (!isInternalElement && isString(bogus)) {
         if (bogus === 'all') {
-          remove$5(element);
+          remove$4(element);
         } else {
           unwrap(element);
+        }
         return;
+      }
       const rule = schema.getElementRule(lcTagName);
       if (validate && !rule) {
         if (has$2(specialElements, lcTagName)) {
-          remove$5(element);
+          remove$4(element);
         } else {
           unwrap(element);
+        }
         return;
       } else {
           evt.allowedTags[lcTagName] = true;
+        }
+      }
       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))) {
           unwrap(element);
           return;
         ALLOWED_TAGS: [
           '#comment',
           '#cdata-section',
           'body'
         ],
-        ALLOWED_ATTR: []
+        ALLOWED_ATTR: [],
+        SAFE_FOR_XML: false
       };
       const config = { ...basePurifyConfig };
       config.PARSER_MEDIA_TYPE = mimeType;
       if (settings.allow_script_urls) {
         config.ALLOWED_URI_REGEXP = /.*/;
       } else if (settings.allow_html_data_urls) {
         config.ALLOWED_URI_REGEXP = /^(?!(\w+script|mhtml):)/i;
+      }
       return config;
     };
-    const sanitizeNamespaceElement = ele => {
+    const sanitizeSvgElement = ele => {
       const xlinkAttrs = [
         'type',
         'href',
         'role',
         'arcrole',
           svgFilters: true
         },
         ALLOWED_ATTR: xlinkAttrs
       };
       purify().sanitize(ele, config);
+    };
+    const sanitizeMathmlElement = (node, settings) => {
+      const config = {
+        IN_PLACE: true,
+        USE_PROFILES: { mathMl: true }
+      };
+      const purify$1 = purify();
+      const allowedEncodings = settings.allow_mathml_annotation_encodings;
+      const hasAllowedEncodings = isArray$1(allowedEncodings) && allowedEncodings.length > 0;
+      const hasValidEncoding = el => {
+        const encoding = el.getAttribute('encoding');
+        return hasAllowedEncodings && isString(encoding) && contains$2(allowedEncodings, encoding);
+      };
+      purify$1.addHook('uponSanitizeElement', (node, evt) => {
+        var _a;
+        const lcTagName = (_a = evt.tagName) !== null && _a !== void 0 ? _a : node.nodeName.toLowerCase();
+        if (hasAllowedEncodings && lcTagName === 'semantics') {
+          evt.allowedTags[lcTagName] = true;
+        }
+        if (lcTagName === 'annotation') {
+          const elm = node;
+          const keepElement = hasValidEncoding(elm);
+          evt.allowedTags[lcTagName] = keepElement;
+          if (!keepElement) {
-      return ele.innerHTML;
+            elm.remove();
+          }
+        }
+      });
+      purify$1.sanitize(node, config);
+    };
+    const mkSanitizeNamespaceElement = settings => ele => {
+      const namespaceType = toScopeType(ele);
+      if (namespaceType === 'svg') {
+        sanitizeSvgElement(ele);
+      } else if (namespaceType === 'math') {
+        sanitizeMathmlElement(ele, settings);
+      } else {
+        throw new Error('Not a namespace element');
+      }
     };
     const getSanitizer = (settings, schema) => {
       const namespaceTracker = createNamespaceTracker();
       if (settings.sanitize) {
         const purify = setupPurify(settings, schema, namespaceTracker);
           purify.removed = [];
           namespaceTracker.reset();
         };
         return {
           sanitizeHtmlElement,
-          sanitizeNamespaceElement
+          sanitizeNamespaceElement: mkSanitizeNamespaceElement(settings)
         };
       } else {
         const sanitizeHtmlElement = (body, _mimeType) => {
           const nodeIterator = document.createNodeIterator(body, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT);
           let node;
     };
     const makeMap = Tools.makeMap, extend$1 = Tools.extend;
     const transferChildren = (parent, nativeParent, specialElements, nsSanitizer) => {
       const parentName = parent.name;
-      const isSpecial = parentName in specialElements && parentName !== 'title' && parentName !== 'textarea';
+      const isSpecial = parentName in specialElements && parentName !== 'title' && parentName !== 'textarea' && parentName !== 'noscript';
       const childNodes = nativeParent.childNodes;
       for (let ni = 0, nl = childNodes.length; ni < nl; ni++) {
         const nativeChild = childNodes[ni];
         const child = new AstNode(nativeChild.nodeName.toLowerCase(), nativeChild.nodeType);
+          }
           if (isNonHtmlElementRootName(child.name)) {
             nsSanitizer(nativeChild);
             child.value = nativeChild.innerHTML;
+          }
-        } else if (isText$a(nativeChild)) {
+        } else if (isText$b(nativeChild)) {
           child.value = nativeChild.data;
           if (isSpecial) {
             child.raw = true;
+          }
         } else if (isComment(nativeChild) || isCData(nativeChild) || isPi(nativeChild)) {
             if (isLineBreakNode(node.prev, isBlock) || isAtEdgeOfBlock(node, true)) {
               text = text.replace(startWhiteSpaceRegExp, '');
+            }
             if (text.length === 0) {
               node.remove();
+            } else if (text === ' ' && node.prev && node.prev.type === COMMENT && node.next && node.next.type === COMMENT) {
+              node.remove();
             } else {
               node.value = text;
+            }
+          }
+        }
       const sanitizer = getSanitizer(defaultedSettings, schema);
       const parseAndSanitizeWithContext = (html, rootName, format = 'html') => {
         const mimeType = format === 'xhtml' ? 'application/xhtml+xml' : 'text/html';
         const isSpecialRoot = has$2(schema.getSpecialElements(), rootName.toLowerCase());
         const content = isSpecialRoot ? `<${ rootName }>${ html }</${ rootName }>` : html;
+        const makeWrap = () => {
+          if (format === 'xhtml') {
-        const wrappedHtml = format === 'xhtml' ? `<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>${ content }</body></html>` : `<body>${ content }</body>`;
+            return `<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>${ content }</body></html>`;
+          } else if (/^[\s]*<head/i.test(html) || /^[\s]*<html/i.test(html) || /^[\s]*<!DOCTYPE/i.test(html)) {
+            return `<html>${ content }</html>`;
+          } else {
+            return `<body>${ content }</body>`;
+          }
+        };
-        const body = parser.parseFromString(wrappedHtml, mimeType).body;
+        const body = parser.parseFromString(makeWrap(), mimeType).body;
         sanitizer.sanitizeHtmlElement(body, mimeType);
         return isSpecialRoot ? body.firstChild : body;
       };
       const addNodeFilter = nodeFilterRegistry.addFilter;
       const getNodeFilters = nodeFilterRegistry.getFilters;
+        }
       } else {
         return eventArgs;
+      }
     };
+    const makeParserSettings = editor => ({
+      sanitize: shouldSanitizeXss(editor),
+      sandbox_iframes: shouldSandboxIframes(editor),
+      sandbox_iframes_exclusions: getSandboxIframesExclusions(editor)
+    });
     const preProcessGetContent = (editor, args) => {
       if (args.no_events) {
         return Result.value(args);
       } else {
         const eventArgs = fireBeforeGetContent(editor, args);
         return content;
       } else {
         const processedEventArgs = withSerializedContent(content, content => fireGetContent(editor, {
           ...args,
           content
-        }), {
-          sanitize: shouldSanitizeXss(editor),
+        }), makeParserSettings(editor));
-          sandbox_iframes: shouldSandboxIframes(editor)
-        });
         return processedEventArgs.content;
+      }
     };
     const preProcessSetContent = (editor, args) => {
       if (args.no_events) {
         return Result.value(args);
       } else {
         const processedEventArgs = withSerializedContent(args.content, content => fireBeforeSetContent(editor, {
           ...args,
           content
-        }), {
-          sanitize: shouldSanitizeXss(editor),
+        }), makeParserSettings(editor));
-          sandbox_iframes: shouldSandboxIframes(editor)
-        });
         if (processedEventArgs.isDefaultPrevented()) {
           fireSetContent(editor, processedEventArgs);
           return Result.error(undefined);
         } else {
           return Result.value(processedEventArgs);
     };
     const modelRowsToDomRows = table => {
       return map$3(table.rows, row => {
         const cells = map$3(row.cells, cell => {
           const td = deep$1(cell);
-          remove$a(td, 'colspan');
+          remove$9(td, 'colspan');
-          remove$a(td, 'rowspan');
+          remove$9(td, 'rowspan');
           return td;
         });
         const tr = shallow$1(row.element);
         append(tr, cells);
         return tr;
     };
     const getOuterHtml = elm => {
       if (isElement$6(elm)) {
         return elm.outerHTML;
-      } else if (isText$a(elm)) {
+      } else if (isText$b(elm)) {
         return Entities.encodeRaw(elm.data, false);
       } else if (isComment(elm)) {
         return '<!--' + elm.data + '-->';
+      }
         insertContent: (value, details) => insertHtmlAtCaret(editor, value, details),
         addVisual: elm => addVisualInternal(editor, elm)
       },
       selection: { getContent: (format, args) => getSelectedContentInternal(editor, format, args) },
       autocompleter: {
-        addDecoration: range => create$9(editor, range),
+        addDecoration: noop,
-        removeDecoration: () => remove$2(editor, SugarElement.fromDom(editor.getBody()))
+        removeDecoration: noop
       },
       raw: { getModel: () => Optional.none() }
     });
     const makeRtcAdaptor = rtcEditor => {
       const defaultVars = vars => isObject(vars) ? vars : {};
     const setContent$2 = (editor, content, args) => getRtcInstanceWithFallback(editor).editor.setContent(content, args);
     const insertContent$1 = (editor, value, details) => getRtcInstanceWithFallback(editor).editor.insertContent(value, details);
     const getSelectedContent = (editor, format, args) => getRtcInstanceWithError(editor).selection.getContent(format, args);
     const addVisual$1 = (editor, elm) => getRtcInstanceWithError(editor).editor.addVisual(elm);
     const bindEvents = editor => getRtcInstanceWithError(editor).init.bindEvents();
-    const addAutocompleterDecoration = (editor, range) => getRtcInstanceWithError(editor).autocompleter.addDecoration(range);
-    const removeAutocompleterDecoration = editor => getRtcInstanceWithError(editor).autocompleter.removeDecoration();
     const getContent$1 = (editor, args = {}) => {
       const format = args.format ? args.format : 'html';
       return getSelectedContent(editor, format, args);
     };
     const removeEmpty = text => {
       if (text.dom.length === 0) {
-        remove$5(text);
+        remove$4(text);
         return Optional.none();
       } else {
         return Optional.some(text);
     };
     const mergeAndNormalizeText = (outerNode, innerNode, rng, start, schema) => {
       outerNode.bind(outer => {
         const normalizer = start ? normalizeWhitespaceBefore : normalizeWhitespaceAfter;
         normalizer(outer.dom, start ? outer.dom.length : 0, schema);
-        return innerNode.filter(isText$b).map(inner => merge$1(outer, inner, rng, start, schema));
+        return innerNode.filter(isText$c).map(inner => merge$1(outer, inner, rng, start, schema));
       }).orThunk(() => {
-        const innerTextNode = walkPastBookmark(innerNode, start).or(innerNode).filter(isText$b);
+        const innerTextNode = walkPastBookmark(innerNode, start).or(innerNode).filter(isText$c);
         return innerTextNode.map(inner => normalizeTextIfRequired(inner, start, schema));
       });
     };
     const rngSetContent = (rng, fragment, schema) => {
       const firstChild = Optional.from(fragment.firstChild).map(SugarElement.fromDom);
       const lastChild = Optional.from(fragment.lastChild).map(SugarElement.fromDom);
       rng.deleteContents();
       rng.insertNode(fragment);
-      const prevText = firstChild.bind(prevSibling).filter(isText$b).bind(removeEmpty);
+      const prevText = firstChild.bind(prevSibling).filter(isText$c).bind(removeEmpty);
-      const nextText = lastChild.bind(nextSibling).filter(isText$b).bind(removeEmpty);
+      const nextText = lastChild.bind(nextSibling).filter(isText$c).bind(removeEmpty);
       mergeAndNormalizeText(prevText, firstChild, rng, true, schema);
       mergeAndNormalizeText(nextText, lastChild, rng, false, schema);
       rng.collapse(false);
     };
     const setupArgs$2 = (args, content) => ({
+        }
       };
       const getContent = args => getContent$1(editor, args);
       const setContent = (content, args) => setContent$1(editor, content, args);
       const getStart$1 = real => getStart(editor.getBody(), getRng$1(), real);
-      const getEnd = real => getEnd$1(editor.getBody(), getRng$1(), real);
+      const getEnd$1 = real => getEnd(editor.getBody(), getRng$1(), real);
       const getBookmark = (type, normalized) => bookmarkManager.getBookmark(type, normalized);
       const moveToBookmark = bookmark => bookmarkManager.moveToBookmark(bookmark);
       const select$1 = (node, content) => {
         select(dom, node, content).each(setRng);
         return node;
           return rng.compareEndPoints('StartToEnd', rng) === 0;
+        }
         return !sel || rng.collapsed;
       };
       const isEditable = () => {
+        if (editor.mode.isReadOnly()) {
+          return false;
+        }
         const rng = getRng$1();
         const fakeSelectedElements = editor.getBody().querySelectorAll('[data-mce-selected="1"]');
         if (fakeSelectedElements.length > 0) {
           return forall(fakeSelectedElements, el => dom.isEditable(el.parentElement));
         } else {
       const getRng$1 = () => {
         let rng;
         const tryCompareBoundaryPoints = (how, sourceRange, destinationRange) => {
           try {
             return sourceRange.compareBoundaryPoints(how, destinationRange);
-          } catch (ex) {
+          } catch (_a) {
             return -1;
+          }
         };
         const doc = win.document;
         if (isNonNullable(editor.bookmark) && !hasFocus(editor)) {
             } else {
               rng = doc.createRange();
+            }
             rng = processRanges(editor, [rng])[0];
+          }
-        } catch (ex) {
+        } catch (_a) {
+        }
         if (!rng) {
           rng = doc.createRange();
+        }
         if (isDocument$1(rng.startContainer) && rng.collapsed) {
         if (sel) {
           explicitRange = rng;
           try {
             sel.removeAllRanges();
             sel.addRange(rng);
-          } catch (ex) {
+          } catch (_a) {
+          }
           if (forward === false && sel.extend) {
             sel.collapse(rng.endContainer, rng.endOffset);
             sel.extend(rng.startContainer, rng.startOffset);
+          }
         try {
           anchorRange.setStart(anchorNode, sel.anchorOffset);
           anchorRange.collapse(true);
           focusRange.setStart(focusNode, sel.focusOffset);
           focusRange.collapse(true);
-        } catch (e) {
+        } catch (_a) {
           return true;
+        }
         return anchorRange.compareBoundaryPoints(anchorRange.START_TO_START, focusRange) <= 0;
       };
       const normalize = () => {
         getNode: getNode$1,
         getSel,
         setRng,
         getRng: getRng$1,
         getStart: getStart$1,
-        getEnd,
+        getEnd: getEnd$1,
         getSelectedBlocks: getSelectedBlocks$1,
         normalize,
         selectorChanged,
         selectorChangedWithUnbind,
         getScrollContainer,
       exports.bookmarkManager = bookmarkManager;
       exports.controlSelection = controlSelection;
       return exports;
     };
+    const addNodeFilter = (settings, htmlParser, schema) => {
+      htmlParser.addNodeFilter('br', (nodes, _, args) => {
+        const blockElements = Tools.extend({}, schema.getBlockElements());
+        const nonEmptyElements = schema.getNonEmptyElements();
+        const whitespaceElements = schema.getWhitespaceElements();
+        blockElements.body = 1;
+        const isBlock = node => node.name in blockElements || isTransparentAstBlock(schema, node);
+        for (let i = 0, l = nodes.length; i < l; i++) {
+          let node = nodes[i];
+          let parent = node.parent;
+          if (parent && isBlock(parent) && node === parent.lastChild) {
+            let prev = node.prev;
+            while (prev) {
+              const prevName = prev.name;
+              if (prevName !== 'span' || prev.attr('data-mce-type') !== 'bookmark') {
+                if (prevName === 'br') {
+                  node = null;
+                }
+                break;
+              }
+              prev = prev.prev;
+            }
+            if (node) {
+              node.remove();
+              if (isEmpty(schema, nonEmptyElements, whitespaceElements, parent)) {
+                const elementRule = schema.getElementRule(parent.name);
+                if (elementRule) {
+                  if (elementRule.removeEmpty) {
+                    parent.remove();
+                  } else if (elementRule.paddEmpty) {
+                    paddEmptyNode(settings, args, isBlock, parent);
+                  }
+                }
+              }
+            }
+          } else {
+            let lastParent = node;
+            while (parent && parent.firstChild === lastParent && parent.lastChild === lastParent) {
+              lastParent = parent;
+              if (blockElements[parent.name]) {
+                break;
+              }
+              parent = parent.parent;
+            }
+            if (lastParent === parent) {
+              const textNode = new AstNode('#text', 3);
+              textNode.value = nbsp;
+              node.replace(textNode);
+            }
+          }
+        }
+      });
+    };
     const register$3 = (htmlParser, settings, dom) => {
       htmlParser.addAttributeFilter('data-mce-tabindex', (nodes, name) => {
         let i = nodes.length;
         while (i--) {
         while (i--) {
           const node = nodes[i];
           if (node.attr('data-mce-type') === 'bookmark' && !args.cleanup) {
             const hasChildren = Optional.from(node.firstChild).exists(firstChild => {
               var _a;
-              return !isZwsp$1((_a = firstChild.value) !== null && _a !== void 0 ? _a : '');
+              return !isZwsp((_a = firstChild.value) !== null && _a !== void 0 ? _a : '');
             });
             if (hasChildren) {
               node.unwrap();
             } else {
               node.remove();
+            }
+          }
+        }
       });
-      htmlParser.addNodeFilter('noscript', nodes => {
-        var _a;
-        let i = nodes.length;
-        while (i--) {
-          const node = nodes[i].firstChild;
-          if (node) {
-            node.value = Entities.decode((_a = node.value) !== null && _a !== void 0 ? _a : '');
-          }
-        }
-      });
       htmlParser.addNodeFilter('script,style', (nodes, name) => {
         var _a;
         const trim = value => {
           return value.replace(/(<!--\[CDATA\[|\]\]-->)/g, '\n').replace(/^[\r\n]*|[\r\n]*$/g, '').replace(/^\s*((<!--)?(\s*\/\/)?\s*<!\[CDATA\[|(<!--\s*)?\/\*\s*<!\[CDATA\[\s*\*\/|(\/\/)?\s*<!--|\/\*\s*<!--\s*\*\/)\s*[\r\n]*/gi, '').replace(/\s*(\/\*\s*\]\]>\s*\*\/(-->)?|\s*\/\/\s*\]\]>(-->)?|\/\/\s*(-->)?|\]\]>|\/\*\s*-->\s*\*\/|\s*-->\s*)\s*$/g, '');
         };
         postProcessSetContent(editor, result.html, updatedArgs);
         return result.content;
       }).getOr(content);
     };
-    const removedOptions = ('autoresize_on_init,content_editable_state,padd_empty_with_br,block_elements,' + 'boolean_attributes,editor_deselector,editor_selector,elements,file_browser_callback_types,filepicker_validator_handler,' + 'force_hex_style_colors,force_p_newlines,gecko_spellcheck,images_dataimg_filter,media_scripts,mode,move_caret_before_on_enter_elements,' + 'non_empty_elements,self_closing_elements,short_ended_elements,special,spellchecker_select_languages,spellchecker_whitelist,' + 'tab_focus,tabfocus_elements,table_responsive_width,text_block_elements,text_inline_elements,toolbar_drawer,types,validate,whitespace_elements,' + 'paste_enable_default_filters,paste_filter_drop,paste_word_valid_elements,paste_retain_style_properties,paste_convert_word_fake_lists').split(',');
+    const removedOptions = ('autoresize_on_init,content_editable_state,padd_empty_with_br,block_elements,' + 'boolean_attributes,editor_deselector,editor_selector,elements,file_browser_callback_types,filepicker_validator_handler,' + 'force_hex_style_colors,force_p_newlines,gecko_spellcheck,images_dataimg_filter,media_scripts,mode,move_caret_before_on_enter_elements,' + 'non_empty_elements,self_closing_elements,short_ended_elements,special,spellchecker_select_languages,spellchecker_whitelist,' + 'tab_focus,tabfocus_elements,table_responsive_width,text_block_elements,text_inline_elements,toolbar_drawer,types,validate,whitespace_elements,' + 'paste_enable_default_filters,paste_filter_drop,paste_word_valid_elements,paste_retain_style_properties,paste_convert_word_fake_lists,' + 'template_cdate_classes,template_mdate_classes,template_selected_content_classes,template_preview_replace_values,template_replace_values,templates,template_cdate_format,template_mdate_format').split(',');
-    const deprecatedOptions = 'template_cdate_classes,template_mdate_classes,template_selected_content_classes,template_preview_replace_values,template_replace_values,templates,template_cdate_format,template_mdate_format'.split(',');
+    const deprecatedOptions = [];
-    const removedPlugins = 'bbcode,colorpicker,contextmenu,fullpage,legacyoutput,spellchecker,textcolor'.split(',');
+    const removedPlugins = 'bbcode,colorpicker,contextmenu,fullpage,legacyoutput,spellchecker,template,textcolor,rtc'.split(',');
-    const deprecatedPlugins = [
-      {
-        name: 'template',
-        replacedWith: 'Advanced Template'
-      },
-      { name: 'rtc' }
-    ];
+    const deprecatedPlugins = [];
     const getMatchingOptions = (options, searchingFor) => {
       const settingNames = filter$5(searchingFor, setting => has$2(options, setting));
       return sort(settingNames);
     };
       if (hasRemovedPlugins || hasRemovedOptions || isLegacyMobileTheme) {
         const listJoiner = '\n- ';
         const themesMessage = isLegacyMobileTheme ? `\n\nThemes:${ listJoiner }mobile` : '';
         const pluginsMessage = hasRemovedPlugins ? `\n\nPlugins:${ listJoiner }${ removedPlugins.join(listJoiner) }` : '';
         const optionsMessage = hasRemovedOptions ? `\n\nOptions:${ listJoiner }${ removedOptions.join(listJoiner) }` : '';
-        console.warn('The following deprecated features are currently enabled and have been removed in TinyMCE 6.0. These features will no longer work and should be removed from the TinyMCE configuration. ' + 'See https://www.tiny.cloud/docs/tinymce/6/migration-from-5x/ for more information.' + themesMessage + pluginsMessage + optionsMessage);
+        console.warn('The following deprecated features are currently enabled and have been removed in TinyMCE 7.0. These features will no longer work and should be removed from the TinyMCE configuration. ' + 'See https://www.tiny.cloud/docs/tinymce/7/migration-from-6x/ for more information.' + themesMessage + pluginsMessage + optionsMessage);
+      }
     };
     const getPluginDescription = name => find$2(deprecatedPlugins, entry => entry.name === name).fold(() => name, entry => {
       if (entry.replacedWith) {
         return `${ name }, replaced by ${ entry.replacedWith }`;
       };
       const isEqual = (a, b) => {
         return a.type === b.type && a.text === b.text && !a.progressBar && !a.timeout && !b.progressBar && !b.timeout;
       };
       const reposition = () => {
-        each$e(notifications, notification => {
+        getTopNotification().each(notification => {
           notification.reposition();
         });
       };
       const addNotification = notification => {
         notifications.push(notification);
           return isEqual(getImplementation().getArgs(notification), spec);
         }).getOrThunk(() => {
           editor.editorManager.setActive(editor);
           const notification = getImplementation().open(spec, () => {
             closeNotification(notification);
-            reposition();
-            if (hasEditorOrUiFocus(editor)) {
+          }, () => hasEditorOrUiFocus(editor));
-              getTopNotification().fold(() => editor.focus(), top => focus$1(SugarElement.fromDom(top.getEl())));
-            }
-          });
           addNotification(notification);
           reposition();
           editor.dispatch('OpenNotification', { notification: { ...notification } });
           return notification;
         });
               timeout: 0
             }, false);
+          }
           reposition();
         });
-        editor.on('show ResizeEditor ResizeWindow NodeChange', () => {
+        editor.on('show ResizeEditor ResizeWindow NodeChange ToggleView FullscreenStateChanged', () => {
           requestAnimationFrame(reposition);
         });
         editor.on('remove', () => {
           each$e(notifications.slice(), notification => {
             getImplementation().close(notification);
           });
         });
+        editor.on('keydown', e => {
+          var _a;
+          const isF12 = ((_a = e.key) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'f12' || e.keyCode === 123;
+          if (e.altKey && isF12) {
+            e.preventDefault();
+            getTopNotification().map(notificationApi => SugarElement.fromDom(notificationApi.getEl())).each(elm => focus$1(elm));
+          }
+        });
       };
       registerEvents(editor);
       return {
         open,
         close,
           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 (_a) {
+      }
+    };
+    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 switchOnContentEditableTrue = elm => {
+      each$e(descendants(elm, `*[${ internalContentEditableAttr }="true"]`), elm => {
+        remove$9(elm, internalContentEditableAttr);
+        set$3(elm, true);
+      });
+    };
+    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 registerDisabledContentFilters = editor => {
+      if (editor.serializer) {
+        registerFilters(editor);
+      } else {
+        editor.on('PreInit', () => {
+          registerFilters(editor);
+        });
+      }
+    };
+    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 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 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';
     const isBundledCssSkinName = url => tinymce.Resource.has(toContentSkinResourceName(url));
     const getContentCssUrls = editor => {
     };
     let count = 0;
     const seed = () => {
       const rnd = () => {
-        return Math.round(Math.random() * 4294967295).toString(36);
+        return Math.round(random() * 4294967295).toString(36);
       };
       const now = new Date().getTime();
       return 's' + now.toString(36) + rnd() + rnd() + rnd();
     };
             });
             if (imagesToRemove.length > 0 && !isRtc(editor)) {
               editor.undoManager.transact(() => {
                 each$e(fromDom$1(imagesToRemove), sugarElement => {
                   const parentOpt = parent(sugarElement);
-                  remove$5(sugarElement);
+                  remove$4(sugarElement);
                   parentOpt.each(addPaddingToEmpty(editor));
                   blobCache.removeByUri(sugarElement.dom.src);
                 });
               });
             } else if (shouldDispatchChange) {
             collapsed: false,
             styles: { float: 'left' },
             preview: 'font-family font-size'
           },
+          {
+            selector: '.mce-placeholder',
+            styles: { float: 'left' },
+            ceFalseOverride: true
+          },
+          {
             selector: 'table',
             collapsed: false,
             styles: {
               marginLeft: '0px',
               marginRight: 'auto'
               marginRight: 'auto'
             },
             preview: false
           },
+          {
+            selector: '.mce-placeholder',
+            styles: {
+              display: 'block',
+              marginLeft: 'auto',
+              marginRight: 'auto'
+            },
+            ceFalseOverride: true
+          },
+          {
             selector: 'table',
             collapsed: false,
             styles: {
               marginLeft: 'auto',
               marginRight: 'auto'
             collapsed: false,
             styles: { float: 'right' },
             preview: 'font-family font-size'
           },
+          {
+            selector: '.mce-placeholder',
+            styles: { float: 'right' },
+            ceFalseOverride: true
+          },
+          {
             selector: 'table',
             collapsed: false,
             styles: {
               marginRight: '0px',
               marginLeft: 'auto'
           remove: 'all'
         },
         subscript: { inline: 'sub' },
         superscript: { inline: 'sup' },
         code: { inline: 'code' },
+        samp: { inline: 'samp' },
         link: {
           inline: 'a',
           selector: 'a',
           remove: 'all',
           split: true,
             expand: false,
             deep: true
+          }
+        ]
       };
-      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'
         };
       });
         return false;
+      }
     };
     const isTypingKeyboardEvent = e => isKeyboardEvent(e) && !(isDeleteEvent(e) || e.type === 'keyup' && e.keyCode === 229);
     const isVisuallyEmpty = (dom, rootElm, forcedRootBlock) => {
-      if (isEmpty$2(SugarElement.fromDom(rootElm), false)) {
+      if (dom.isEmpty(rootElm, undefined, {
+          skipBogus: false,
+          includeZwsp: true
+        })) {
         const firstElement = rootElm.firstElementChild;
         if (!firstElement) {
           return true;
         } else if (dom.getStyle(rootElm.firstElementChild, 'padding-left') || dom.getStyle(rootElm.firstElementChild, 'padding-right')) {
           return false;
         const body = editor.getBody();
         const showPlaceholder = isTypingKeyboardEvent(e) ? false : isVisuallyEmpty(dom, body, rootBlock);
         const isPlaceholderShown = dom.getAttrib(body, placeholderAttr) !== '';
         if (isPlaceholderShown !== showPlaceholder || initial) {
           dom.setAttrib(body, placeholderAttr, showPlaceholder ? placeholder : null);
-          dom.setAttrib(body, 'aria-placeholder', showPlaceholder ? placeholder : null);
           firePlaceholderToggle(editor, showPlaceholder);
           editor.on(showPlaceholder ? 'keydown' : 'keyup', updatePlaceholder);
           editor.off(showPlaceholder ? 'keyup' : 'keydown', updatePlaceholder);
+        }
       };
     const getBlockPosition = (rootNode, pos) => {
       const rootElm = SugarElement.fromDom(rootNode);
       const containerElm = SugarElement.fromDom(pos.container());
       return getParentBlock$2(rootElm, containerElm).map(block => blockPosition(block, pos));
     };
+    const isNotAncestorial = blockBoundary => !(contains(blockBoundary.to.block, blockBoundary.from.block) || contains(blockBoundary.from.block, blockBoundary.to.block));
     const isDifferentBlocks = blockBoundary => !eq(blockBoundary.from.block, blockBoundary.to.block);
     const getClosestHost = (root, scope) => {
       const isRoot = node => eq(node, root);
       const isHost = node => isTableCell$2(node) || isContentEditableTrue$3(node.dom);
       return closest$4(scope, isHost, isRoot).filter(isElement$7).getOr(root);
       const root = SugarElement.fromDom(rootNode);
       return eq(getClosestHost(root, blockBoundary.from.block), getClosestHost(root, blockBoundary.to.block));
     };
     const isEditable$1 = blockBoundary => isContentEditableFalse$b(blockBoundary.from.block.dom) === false && isContentEditableFalse$b(blockBoundary.to.block.dom) === false;
     const hasValidBlocks = blockBoundary => {
-      const isValidBlock = block => isTextBlock$2(block) || hasBlockAttr(block.dom);
+      const isValidBlock = block => isTextBlock$2(block) || hasBlockAttr(block.dom) || isListItem$1(block);
       return isValidBlock(blockBoundary.from.block) && isValidBlock(blockBoundary.to.block);
     };
-    const skipLastBr = (rootNode, forward, blockPosition) => {
+    const skipLastBr = (schema, rootNode, forward, blockPosition) => {
-      if (isBr$6(blockPosition.position.getNode()) && !isEmpty$2(blockPosition.block)) {
+      if (isBr$6(blockPosition.position.getNode()) && !isEmpty$2(schema, blockPosition.block)) {
         return positionIn(false, blockPosition.block.dom).bind(lastPositionInBlock => {
           if (lastPositionInBlock.isEqual(blockPosition.position)) {
             return fromPosition(forward, rootNode, lastPositionInBlock).bind(to => getBlockPosition(rootNode, to));
           } else {
             return Optional.some(blockPosition);
         }).getOr(blockPosition);
       } else {
         return blockPosition;
+      }
     };
-    const readFromRange = (rootNode, forward, rng) => {
+    const readFromRange = (schema, rootNode, forward, rng) => {
       const fromBlockPos = getBlockPosition(rootNode, CaretPosition.fromRangeStart(rng));
-      const toBlockPos = fromBlockPos.bind(blockPos => fromPosition(forward, rootNode, blockPos.position).bind(to => getBlockPosition(rootNode, to).map(blockPos => skipLastBr(rootNode, forward, blockPos))));
+      const toBlockPos = fromBlockPos.bind(blockPos => fromPosition(forward, rootNode, blockPos.position).bind(to => getBlockPosition(rootNode, to).map(blockPos => skipLastBr(schema, rootNode, forward, blockPos))));
-      return lift2(fromBlockPos, toBlockPos, blockBoundary).filter(blockBoundary => isDifferentBlocks(blockBoundary) && hasSameHost(rootNode, blockBoundary) && isEditable$1(blockBoundary) && hasValidBlocks(blockBoundary));
+      return lift2(fromBlockPos, toBlockPos, blockBoundary).filter(blockBoundary => isDifferentBlocks(blockBoundary) && hasSameHost(rootNode, blockBoundary) && isEditable$1(blockBoundary) && hasValidBlocks(blockBoundary) && isNotAncestorial(blockBoundary));
     };
-    const read$1 = (rootNode, forward, rng) => rng.collapsed ? readFromRange(rootNode, forward, rng) : Optional.none();
+    const read$1 = (schema, rootNode, forward, rng) => rng.collapsed ? readFromRange(schema, rootNode, forward, rng) : Optional.none();
     const getChildrenUntilBlockBoundary = (block, schema) => {
       const children = children$1(block);
       return findIndex$2(children, el => schema.isBlock(name(el))).fold(constant(children), index => children.slice(0, index));
     };
     const extractChildren = (block, schema) => {
       const children = getChildrenUntilBlockBoundary(block, schema);
-      each$e(children, remove$5);
+      each$e(children, remove$4);
       return children;
     };
-    const removeEmptyRoot = (rootNode, block) => {
+    const removeEmptyRoot = (schema, rootNode, block) => {
       const parents = parentsAndSelf(block, rootNode);
-      return find$2(parents.reverse(), element => isEmpty$2(element)).each(remove$5);
+      return find$2(parents.reverse(), element => isEmpty$2(schema, element)).each(remove$4);
     };
-    const isEmptyBefore = el => filter$5(prevSiblings(el), el => !isEmpty$2(el)).length === 0;
+    const isEmptyBefore = (schema, el) => filter$5(prevSiblings(el), el => !isEmpty$2(schema, el)).length === 0;
     const nestedBlockMerge = (rootNode, fromBlock, toBlock, schema, insertionPoint) => {
-      if (isEmpty$2(toBlock)) {
+      if (isEmpty$2(schema, toBlock)) {
         fillWithPaddingBr(toBlock);
         return firstPositionIn(toBlock.dom);
       }
-      if (isEmptyBefore(insertionPoint) && isEmpty$2(fromBlock)) {
+      if (isEmptyBefore(schema, insertionPoint) && isEmpty$2(schema, fromBlock)) {
         before$3(insertionPoint, SugarElement.fromTag('br'));
+      }
       const position = prevPosition(toBlock.dom, CaretPosition.before(insertionPoint.dom));
       each$e(extractChildren(fromBlock, schema), child => {
         before$3(insertionPoint, child);
       });
-      removeEmptyRoot(rootNode, fromBlock);
+      removeEmptyRoot(schema, rootNode, fromBlock);
       return position;
     };
     const isInline = (schema, node) => schema.isInline(name(node));
     const sidelongBlockMerge = (rootNode, fromBlock, toBlock, schema) => {
-      if (isEmpty$2(toBlock)) {
+      if (isEmpty$2(schema, toBlock)) {
-        if (isEmpty$2(fromBlock)) {
+        if (isEmpty$2(schema, fromBlock)) {
           const getInlineToBlockDescendants = el => {
             const helper = (node, elements) => firstChild(node).fold(() => elements, child => isInline(schema, child) ? helper(child, elements.concat(shallow$1(child))) : elements);
             return helper(el, []);
           };
             return descendant;
           }, createPaddingBr());
           empty(fromBlock);
           append$1(fromBlock, newFromBlockDescendants);
+        }
-        remove$5(toBlock);
+        remove$4(toBlock);
         return firstPositionIn(fromBlock.dom);
+      }
       const position = lastPositionIn(toBlock.dom);
       each$e(extractChildren(fromBlock, schema), child => {
         append$1(toBlock, child);
       });
-      removeEmptyRoot(rootNode, fromBlock);
+      removeEmptyRoot(schema, rootNode, fromBlock);
       return position;
     };
     const findInsertionPoint = (toBlock, block) => {
       const parentsAndSelf$1 = parentsAndSelf(block, toBlock);
       return Optional.from(parentsAndSelf$1[parentsAndSelf$1.length - 1]);
     };
     const getInsertionPoint = (fromBlock, toBlock) => contains(toBlock, fromBlock) ? findInsertionPoint(toBlock, fromBlock) : Optional.none();
     const trimBr = (first, block) => {
-      positionIn(first, block.dom).bind(position => Optional.from(position.getNode())).map(SugarElement.fromDom).filter(isBr$5).each(remove$5);
+      positionIn(first, block.dom).bind(position => Optional.from(position.getNode())).map(SugarElement.fromDom).filter(isBr$5).each(remove$4);
     };
     const mergeBlockInto = (rootNode, fromBlock, toBlock, schema) => {
       trimBr(true, fromBlock);
       trimBr(false, toBlock);
       return getInsertionPoint(fromBlock, toBlock).fold(curry(sidelongBlockMerge, rootNode, fromBlock, toBlock, schema), curry(nestedBlockMerge, rootNode, fromBlock, toBlock, schema));
     };
     const mergeBlocks = (rootNode, forward, block1, block2, schema) => forward ? mergeBlockInto(rootNode, block2, block1, schema) : mergeBlockInto(rootNode, block1, block2, schema);
-    const backspaceDelete$9 = (editor, forward) => {
+    const backspaceDelete$a = (editor, forward) => {
       const rootNode = SugarElement.fromDom(editor.getBody());
-      const position = read$1(rootNode.dom, forward, editor.selection.getRng()).map(blockBoundary => () => {
+      const position = read$1(editor.schema, rootNode.dom, forward, editor.selection.getRng()).map(blockBoundary => () => {
         mergeBlocks(rootNode, forward, blockBoundary.from.block, blockBoundary.to.block, editor.schema).each(pos => {
           editor.selection.setRng(pos.toRange());
         });
       });
     const deleteRange$2 = editor => {
       const rootNode = SugarElement.fromDom(editor.getBody());
       const rng = editor.selection.getRng();
       return isEverythingSelected(rootNode, rng) ? emptyEditor(editor) : deleteRangeMergeBlocks(rootNode, editor.selection, editor.schema);
     };
-    const backspaceDelete$8 = (editor, _forward) => editor.selection.isCollapsed() ? Optional.none() : deleteRange$2(editor);
+    const backspaceDelete$9 = (editor, _forward) => editor.selection.isCollapsed() ? Optional.none() : deleteRange$2(editor);
     const showCaret = (direction, editor, node, before, scrollIntoView) => Optional.from(editor._selectionOverrides.showCaret(direction, node, before, scrollIntoView));
     const getNodeRange = node => {
       const rng = node.ownerDocument.createRange();
     const renderRangeCaret = (editor, range, scrollIntoView) => range.collapsed ? renderCaretAtRange(editor, range, scrollIntoView).getOr(range) : range;
     const isBeforeBoundary = pos => isBeforeContentEditableFalse(pos) || isBeforeMedia(pos);
     const isAfterBoundary = pos => isAfterContentEditableFalse(pos) || isAfterMedia(pos);
     const trimEmptyTextNode = (dom, node) => {
-      if (isText$a(node) && node.data.length === 0) {
+      if (isText$b(node) && node.data.length === 0) {
         dom.remove(node);
+      }
     };
     const deleteContentAndShowCaret = (editor, range, node, direction, forward, peekCaretPosition) => {
       });
       trimEmptyTextNode(editor.dom, node);
     };
     const deleteBoundaryText = (editor, forward) => {
       const range = editor.selection.getRng();
-      if (!isText$a(range.commonAncestorContainer)) {
+      if (!isText$b(range.commonAncestorContainer)) {
         return Optional.none();
+      }
-      const direction = forward ? HDirection.Forwards : HDirection.Backwards;
+      const direction = forward ? 1 : -1;
       const caretWalker = CaretWalker(editor.getBody());
       const getNextPosFn = curry(getVisualCaretPosition, forward ? caretWalker.next : caretWalker.prev);
       const isBeforeFn = forward ? isBeforeBoundary : isAfterBoundary;
       const caretPosition = getNormalizedRangeEndPoint(direction, editor.getBody(), range);
       const nextCaretPosition = getNextPosFn(caretPosition);
           return Optional.some(() => deleteContentAndShowCaret(editor, range, caretPosition.getNode(), direction, forward, peekCaretPosition));
+        }
+      }
       return Optional.none();
     };
-    const backspaceDelete$7 = (editor, forward) => deleteBoundaryText(editor, forward);
+    const backspaceDelete$8 = (editor, forward) => deleteBoundaryText(editor, forward);
     const getEdgeCefPosition = (editor, atStart) => {
       const root = editor.getBody();
       return atStart ? firstPositionIn(root).filter(isBeforeContentEditableFalse) : lastPositionIn(root).filter(isAfterContentEditableFalse);
     };
     const isDeleteFromCefDifferentBlocks = (root, forward, from, to, schema) => {
       const inSameBlock = elm => schema.isInline(elm.nodeName.toLowerCase()) && !isInSameBlock(from, to, root);
       return getRelativeCefElm(!forward, from).fold(() => getRelativeCefElm(forward, to).fold(never, inSameBlock), inSameBlock);
     };
-    const deleteEmptyBlockOrMoveToCef = (root, forward, from, to) => {
+    const deleteEmptyBlockOrMoveToCef = (schema, root, forward, from, to) => {
       const toCefElm = to.getNode(!forward);
-      return getParentBlock$2(SugarElement.fromDom(root), SugarElement.fromDom(from.getNode())).map(blockElm => isEmpty$2(blockElm) ? DeleteAction.remove(blockElm.dom) : DeleteAction.moveToElement(toCefElm)).orThunk(() => Optional.some(DeleteAction.moveToElement(toCefElm)));
+      return getParentBlock$2(SugarElement.fromDom(root), SugarElement.fromDom(from.getNode())).map(blockElm => isEmpty$2(schema, blockElm) ? DeleteAction.remove(blockElm.dom) : DeleteAction.moveToElement(toCefElm)).orThunk(() => Optional.some(DeleteAction.moveToElement(toCefElm)));
     };
     const findCefPosition = (root, forward, from, schema) => fromPosition(forward, root, from).bind(to => {
       if (isCompoundElement(to.getNode())) {
         return Optional.none();
       } else if (isDeleteFromCefDifferentBlocks(root, forward, from, to, schema)) {
         return Optional.none();
       } else if (forward && isContentEditableFalse$b(to.getNode())) {
-        return deleteEmptyBlockOrMoveToCef(root, forward, from, to);
+        return deleteEmptyBlockOrMoveToCef(schema, root, forward, from, to);
       } else if (!forward && isContentEditableFalse$b(to.getNode(true))) {
-        return deleteEmptyBlockOrMoveToCef(root, forward, from, to);
+        return deleteEmptyBlockOrMoveToCef(schema, root, forward, from, to);
       } else if (forward && isAfterContentEditableFalse(from)) {
         return Optional.some(DeleteAction.moveToPosition(to));
       } else if (!forward && isBeforeContentEditableFalse(from)) {
         return Optional.some(DeleteAction.moveToPosition(to));
       } else {
     const backspaceDeleteCaret = (editor, forward) => {
       const selectedNode = editor.selection.getNode();
       return getAncestorCe(editor, selectedNode).filter(isContentEditableFalse$b).fold(() => read(editor.getBody(), forward, editor.selection.getRng(), editor.schema).map(deleteAction => () => deleteAction.fold(deleteElement$1(editor, forward), moveToElement(editor, forward), moveToPosition(editor))), () => Optional.some(noop));
     };
     const deleteOffscreenSelection = rootElement => {
-      each$e(descendants(rootElement, '.mce-offscreen-selection'), remove$5);
+      each$e(descendants(rootElement, '.mce-offscreen-selection'), remove$4);
     };
     const backspaceDeleteRange = (editor, forward) => {
       const selectedNode = editor.selection.getNode();
       if (isContentEditableFalse$b(selectedNode) && !isTableCell$3(selectedNode)) {
         const hasCefAncestor = getAncestorCe(editor, selectedNode.parentNode).filter(isContentEditableFalse$b);
         ceRoot.appendChild(br);
         selection.setRng(CaretPosition.before(br).toRange());
+      }
       return true;
     };
-    const backspaceDelete$6 = (editor, forward) => {
+    const backspaceDelete$7 = (editor, forward) => {
       if (editor.selection.isCollapsed()) {
         return backspaceDeleteCaret(editor, forward);
       } else {
         return backspaceDeleteRange(editor, forward);
+      }
     };
+    const isTextEndpoint = endpoint => endpoint.hasOwnProperty('text');
+    const isElementEndpoint = endpoint => endpoint.hasOwnProperty('marker');
+    const getBookmark = (range, createMarker) => {
+      const getEndpoint = (container, offset) => {
+        if (isText$b(container)) {
+          return {
+            text: container,
+            offset
+          };
+        } else {
+          const marker = createMarker();
+          const children = container.childNodes;
+          if (offset < children.length) {
+            container.insertBefore(marker, children[offset]);
+            return {
+              marker,
+              before: true
+            };
+          } else {
+            container.appendChild(marker);
+            return {
+              marker,
+              before: false
+            };
+          }
+        }
+      };
+      const end = getEndpoint(range.endContainer, range.endOffset);
+      const start = getEndpoint(range.startContainer, range.startOffset);
+      return {
+        start,
+        end
+      };
+    };
+    const resolveBookmark = bm => {
+      var _a, _b;
+      const {start, end} = bm;
+      const rng = new window.Range();
+      if (isTextEndpoint(start)) {
+        rng.setStart(start.text, start.offset);
+      } else {
+        if (isElementEndpoint(start)) {
+          if (start.before) {
+            rng.setStartBefore(start.marker);
+          } else {
+            rng.setStartAfter(start.marker);
+          }
+          (_a = start.marker.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(start.marker);
+        }
+      }
+      if (isTextEndpoint(end)) {
+        rng.setEnd(end.text, end.offset);
+      } else {
+        if (isElementEndpoint(end)) {
+          if (end.before) {
+            rng.setEndBefore(end.marker);
+          } else {
+            rng.setEndAfter(end.marker);
+          }
+          (_b = end.marker.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(end.marker);
+        }
+      }
+      return rng;
+    };
+    const backspaceDelete$6 = (editor, forward) => {
+      var _a;
+      const dom = editor.dom;
+      const startBlock = dom.getParent(editor.selection.getStart(), dom.isBlock);
+      const endBlock = dom.getParent(editor.selection.getEnd(), dom.isBlock);
+      const body = editor.getBody();
+      const startBlockName = (_a = startBlock === null || startBlock === void 0 ? void 0 : startBlock.nodeName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+      if (startBlockName === 'div' && startBlock && endBlock && startBlock === body.firstChild && endBlock === body.lastChild && !dom.isEmpty(body)) {
+        const wrapper = startBlock.cloneNode(false);
+        const deleteAction = () => {
+          if (forward) {
+            execNativeForwardDeleteCommand(editor);
+          } else {
+            execNativeDeleteCommand(editor);
+          }
+          if (body.firstChild !== startBlock) {
+            const bookmark = getBookmark(editor.selection.getRng(), () => document.createElement('span'));
+            Array.from(body.childNodes).forEach(node => wrapper.appendChild(node));
+            body.appendChild(wrapper);
+            editor.selection.setRng(resolveBookmark(bookmark));
+          }
+        };
+        return Optional.some(deleteAction);
+      }
+      return Optional.none();
+    };
     const deleteCaret$2 = (editor, forward) => {
       const fromPos = CaretPosition.fromRangeStart(editor.selection.getRng());
       return fromPosition(forward, editor.getBody(), fromPos).filter(pos => forward ? isBeforeImageBlock(pos) : isAfterImageBlock(pos)).bind(pos => getChildNodeAtRelativeOffset(forward ? 0 : -1, pos)).map(elm => () => editor.selection.select(elm));
     };
     const backspaceDelete$5 = (editor, forward) => editor.selection.isCollapsed() ? deleteCaret$2(editor, forward) : Optional.none();
-    const isText$2 = isText$a;
+    const isText$2 = isText$b;
     const startsWithCaretContainer = node => isText$2(node) && node.data[0] === ZWSP$1;
     const endsWithCaretContainer = node => isText$2(node) && node.data[node.data.length - 1] === ZWSP$1;
     const createZwsp = node => {
     const insertInline = (before, node) => before ? insertBefore$1(node) : insertAfter$1(node);
     const insertInlineBefore = curry(insertInline, true);
     const insertInlineAfter = curry(insertInline, false);
     const insertInlinePos = (pos, before) => {
-      if (isText$a(pos.container())) {
+      if (isText$b(pos.container())) {
         return insertInline(before, pos.container());
       } else {
         return insertInline(before, pos.getNode());
+      }
     };
     const isPosCaretContainer = (pos, caret) => {
       const caretNode = caret.get();
       return caretNode && pos.container() === caretNode && isCaretContainerInline(caretNode);
     };
     const renderCaret = (caret, location) => location.fold(element => {
-      remove$3(caret.get());
+      remove$2(caret.get());
       const text = insertInlineBefore(element);
       caret.set(text);
       return Optional.some(CaretPosition(text, text.length - 1));
     }, element => firstPositionIn(element).map(pos => {
       if (!isPosCaretContainer(pos, caret)) {
-        remove$3(caret.get());
+        remove$2(caret.get());
         const text = insertInlinePos(pos, true);
         caret.set(text);
         return CaretPosition(text, 1);
       } else {
         const node = caret.get();
         return CaretPosition(node, 1);
+      }
     }), element => lastPositionIn(element).map(pos => {
       if (!isPosCaretContainer(pos, caret)) {
-        remove$3(caret.get());
+        remove$2(caret.get());
         const text = insertInlinePos(pos, false);
         caret.set(text);
         return CaretPosition(text, text.length - 1);
       } else {
         const node = caret.get();
         return CaretPosition(node, node.length - 1);
+      }
     }), element => {
-      remove$3(caret.get());
+      remove$2(caret.get());
       const text = insertInlineAfter(element);
       caret.set(text);
       return Optional.some(CaretPosition(text, 1));
       BreakType[BreakType['Br'] = 0] = 'Br';
       BreakType[BreakType['Block'] = 1] = 'Block';
       BreakType[BreakType['Wrap'] = 2] = 'Wrap';
       BreakType[BreakType['Eol'] = 3] = 'Eol';
     }(BreakType || (BreakType = {})));
-    const flip = (direction, positions) => direction === HDirection.Backwards ? reverse(positions) : positions;
+    const flip = (direction, positions) => direction === -1 ? reverse(positions) : positions;
-    const walk$1 = (direction, caretWalker, pos) => direction === HDirection.Forwards ? caretWalker.next(pos) : caretWalker.prev(pos);
+    const walk$1 = (direction, caretWalker, pos) => direction === 1 ? caretWalker.next(pos) : caretWalker.prev(pos);
     const getBreakType = (scope, direction, currentPos, nextPos) => {
-      if (isBr$6(nextPos.getNode(direction === HDirection.Forwards))) {
+      if (isBr$6(nextPos.getNode(direction === 1))) {
         return BreakType.Br;
       } else if (isInSameBlock(currentPos, nextPos) === false) {
         return BreakType.Block;
       } else {
         return BreakType.Wrap;
         const nextPos = walk$1(direction, caretWalker, currentPos);
         if (!nextPos) {
           break;
+        }
         if (isBr$6(nextPos.getNode(false))) {
-          if (direction === HDirection.Forwards) {
+          if (direction === 1) {
             return {
               positions: flip(direction, positions).concat([nextPos]),
               breakType: BreakType.Br,
               breakAt: Optional.some(nextPos)
             };
         breakAt: Optional.none()
       };
     };
     const getAdjacentLinePositions = (direction, getPositionsUntilBreak, scope, start) => getPositionsUntilBreak(scope, start).breakAt.map(pos => {
       const positions = getPositionsUntilBreak(scope, pos).positions;
-      return direction === HDirection.Backwards ? positions.concat(pos) : [pos].concat(positions);
+      return direction === -1 ? positions.concat(pos) : [pos].concat(positions);
     }).getOr([]);
     const findClosestHorizontalPositionFromPoint = (positions, x) => foldl(positions, (acc, newPos) => acc.fold(() => Optional.some(newPos), lastPos => lift2(head(lastPos.getClientRects()), head(newPos.getClientRects()), (lastRect, newRect) => {
       const lastDist = Math.abs(x - lastRect.left);
       const newDist = Math.abs(x - newRect.left);
       return newDist <= lastDist ? newPos : lastPos;
     const getFirstLinePositions = scope => firstPositionIn(scope).map(pos => [pos].concat(getPositionsUntilNextLine(scope, pos).positions)).getOr([]);
     const getLastLinePositions = scope => lastPositionIn(scope).map(pos => getPositionsUntilPreviousLine(scope, pos).positions.concat(pos)).getOr([]);
     const getClosestPositionAbove = (scope, pos) => findClosestHorizontalPosition(getPositionsAbove(scope, pos), pos);
     const getClosestPositionBelow = (scope, pos) => findClosestHorizontalPosition(getPositionsBelow(scope, pos), pos);
-    const isContentEditableFalse$4 = isContentEditableFalse$b;
+    const isContentEditableFalse$5 = isContentEditableFalse$b;
     const distanceToRectLeft$1 = (clientRect, clientX) => Math.abs(clientRect.left - clientX);
     const distanceToRectRight$1 = (clientRect, clientX) => Math.abs(clientRect.right - clientX);
     const isNodeClientRect = rect => hasNonNullableKey(rect, 'node');
     const findClosestClientRect = (clientRects, clientX) => reduce(clientRects, (oldClientRect, clientRect) => {
       const oldDistance = Math.min(distanceToRectLeft$1(oldClientRect, clientX), distanceToRectRight$1(oldClientRect, clientX));
       const newDistance = Math.min(distanceToRectLeft$1(clientRect, clientX), distanceToRectRight$1(clientRect, clientX));
-      if (newDistance === oldDistance && isNodeClientRect(clientRect) && isContentEditableFalse$4(clientRect.node)) {
+      if (newDistance === oldDistance && isNodeClientRect(clientRect) && isContentEditableFalse$5(clientRect.node)) {
         return clientRect;
+      }
       if (newDistance < oldDistance) {
         return clientRect;
           return clientRect;
         });
       };
       if (isElement$6(node)) {
         return toArrayWithNode(node.getClientRects());
-      } else if (isText$a(node)) {
+      } else if (isText$b(node)) {
         const rng = node.ownerDocument.createRange();
         rng.setStart(node, 0);
         rng.setEnd(node, node.data.length);
         return toArrayWithNode(rng.getClientRects());
       } else {
     const walkUntil = (direction, isAboveFn, isBeflowFn, root, predicateFn, caretPosition) => {
       let line = 0;
       const result = [];
       const add = node => {
         let clientRects = getClientRects([node]);
-        if (direction === -1) {
+        if (direction === VDirection.Up) {
           clientRects = clientRects.reverse();
+        }
         for (let i = 0; i < clientRects.length; i++) {
           const clientRect = clientRects[i];
           if (isBeflowFn(clientRect, targetClientRect)) {
             continue;
+          }
-          if (result.length > 0 && isAboveFn(clientRect, last$2(result))) {
+          if (result.length > 0 && isAboveFn(clientRect, last$1(result))) {
             line++;
+          }
           clientRect.line = line;
           if (predicateFn(clientRect)) {
             return true;
+          }
           result.push(clientRect);
+        }
         return false;
       };
-      const targetClientRect = last$2(caretPosition.getClientRects());
+      const targetClientRect = last$1(caretPosition.getClientRects());
       if (!targetClientRect) {
         return result;
+      }
       const node = caretPosition.getNode();
       if (node) {
     const aboveLineNumber = (lineNumber, clientRect) => clientRect.line > lineNumber;
     const isLineNumber = (lineNumber, clientRect) => clientRect.line === lineNumber;
     const upUntil = curry(walkUntil, VDirection.Up, isAbove$1, isBelow$1);
     const downUntil = curry(walkUntil, VDirection.Down, isBelow$1, isAbove$1);
     const getLastClientRect = caretPosition => {
-      return last$2(caretPosition.getClientRects());
+      return last$1(caretPosition.getClientRects());
     };
     const positionsUntil = (direction, root, predicateFn, node) => {
       const caretWalker = CaretWalker(root);
       let walkFn;
       let isBelowFn;
       let isAboveFn;
       let caretPosition;
       const result = [];
       let line = 0;
-      if (direction === 1) {
+      if (direction === VDirection.Down) {
         walkFn = caretWalker.next;
         isBelowFn = isBelow$1;
         isAboveFn = isAbove$1;
         caretPosition = CaretPosition.after(node);
       } else {
+        }
         const rect = getLastClientRect(caretPosition);
         if (isAboveFn(rect, targetClientRect)) {
           continue;
+        }
-        if (result.length > 0 && isBelowFn(rect, last$2(result))) {
+        if (result.length > 0 && isBelowFn(rect, last$1(result))) {
           line++;
+        }
         const clientRect = clone$1(rect);
         clientRect.position = caretPosition;
         clientRect.line = line;
       editor.selection.setRng(rng);
       scrollRangeIntoView(editor, editor.selection.getRng());
     };
     const renderRangeCaretOpt = (editor, range, scrollIntoView) => Optional.some(renderRangeCaret(editor, range, scrollIntoView));
     const moveHorizontally = (editor, direction, range, isBefore, isAfter, isElement) => {
-      const forwards = direction === HDirection.Forwards;
+      const forwards = direction === 1;
       const caretWalker = CaretWalker(editor.getBody());
       const getNextPosFn = curry(getVisualCaretPosition, forwards ? caretWalker.next : caretWalker.prev);
       const isBeforeFn = forwards ? isBefore : isAfter;
       if (!range.collapsed) {
         const node = getSelectedNode(range);
         if (isElement(node)) {
-          return showCaret(direction, editor, node, direction === HDirection.Backwards, false);
+          return showCaret(direction, editor, node, direction === -1, false);
         } else if (isCefAtEdgeSelected(editor)) {
           const newRange = range.cloneRange();
-          newRange.collapse(direction === HDirection.Backwards);
+          newRange.collapse(direction === -1);
           return Optional.from(newRange);
+        }
+      }
       const caretPosition = getNormalizedRangeEndPoint(direction, editor.getBody(), range);
       if (isBeforeFn(caretPosition)) {
+      }
       return Optional.none();
     };
     const moveVertically = (editor, direction, range, isBefore, isAfter, isElement) => {
       const caretPosition = getNormalizedRangeEndPoint(direction, editor.getBody(), range);
-      const caretClientRect = last$2(caretPosition.getClientRects());
+      const caretClientRect = last$1(caretPosition.getClientRects());
       const forwards = direction === VDirection.Down;
       const root = editor.getBody();
       if (!caretClientRect) {
         return Optional.none();
+      }
         const caretPositions = positionsUntil(direction, root, isAboveLine(1), currentNode);
         let closestNextLineRect = findClosestClientRect(filter$5(caretPositions, isLine(1)), clientX);
         if (closestNextLineRect) {
           return renderRangeCaretOpt(editor, closestNextLineRect.position.toRange(), false);
+        }
-        closestNextLineRect = last$2(filter$5(caretPositions, isLine(0)));
+        closestNextLineRect = last$1(filter$5(caretPositions, isLine(0)));
         if (closestNextLineRect) {
           return renderRangeCaretOpt(editor, closestNextLineRect.position.toRange(), false);
+        }
+      }
       if (nextLinePositions.length === 0) {
       const rng = editor.selection.getRng();
       const from = forward ? CaretPosition.fromRangeEnd(rng) : CaretPosition.fromRangeStart(rng);
       const host = getEditingHost(from.container(), editor.getBody());
       if (forward) {
         const lineInfo = getPositionsUntilNextLine(host, from);
-        return last$3(lineInfo.positions);
+        return last$2(lineInfo.positions);
       } else {
         const lineInfo = getPositionsUntilPreviousLine(host, from);
         return head(lineInfo.positions);
+      }
     };
         editor.selection.setRng(pos.toRange());
+      }
     };
     const deleteCaret$1 = (editor, forward) => {
       const parentInlines = filter$5(getParentInlinesUntilMultichildInline(editor), hasOnlyOneChild);
-      return last$3(parentInlines).bind(target => {
+      return last$2(parentInlines).bind(target => {
         const fromPos = CaretPosition.fromRangeStart(editor.selection.getRng());
         if (willDeleteLastPositionInElement(forward, fromPos, target.dom) && !isEmptyCaretFormatElement(target)) {
           return Optional.some(() => deleteLastPosition(forward, editor, target, parentInlines));
         } else {
           return Optional.none();
       const missingFormats = difference(updateFormats, getFormatNodesAtStart(editor));
       if (missingFormats.length > 0) {
         createCaretFormatAtStart(editor, missingFormats);
+      }
     };
-    const rangeStartsAtTextContainer = rng => isText$a(rng.startContainer);
+    const rangeStartsAtTextContainer = rng => isText$b(rng.startContainer);
     const rangeStartsAtStartOfTextContainer = rng => rng.startOffset === 0 && rangeStartsAtTextContainer(rng);
     const rangeStartParentIsFormatElement = (editor, rng) => {
       const startParent = rng.startContainer.parentElement;
       return !isNull(startParent) && isFormatElement(editor, SugarElement.fromDom(startParent));
     };
       const endParent = rng.endContainer.parentNode;
       return !isNull(startParent) && !isNull(endParent) && startParent.isEqualNode(endParent);
     };
     const rangeEndsAtEndOfEndContainer = rng => {
       const endContainer = rng.endContainer;
-      return rng.endOffset === (isText$a(endContainer) ? endContainer.length : endContainer.childNodes.length);
+      return rng.endOffset === (isText$b(endContainer) ? endContainer.length : endContainer.childNodes.length);
     };
     const rangeEndsAtEndOfStartContainer = rng => rangeStartAndEndHaveSameParent(rng) && rangeEndsAtEndOfEndContainer(rng);
     const rangeEndsAfterEndOfStartContainer = rng => !rng.endContainer.isEqualNode(rng.commonAncestorContainer);
     const rangeEndsAtOrAfterEndOfStartContainer = rng => rangeEndsAtEndOfStartContainer(rng) || rangeEndsAfterEndOfStartContainer(rng);
     const requiresDeleteRangeOverride = editor => {
       } else {
         return Optional.none();
+      }
     };
     const backspaceDelete$3 = (editor, forward) => editor.selection.isCollapsed() ? deleteCaret$1(editor, forward) : deleteRange$1(editor);
-    const hasAncestorInlineCaret = (elm, schema) => ancestor$1(elm, node => isCaretNode(node.dom), el => schema.isBlock(name(el)));
+    const hasAncestorInlineCaret = (elm, schema) => ancestor$2(elm, node => isCaretNode(node.dom), el => schema.isBlock(name(el)));
     const hasAncestorInlineCaretAtStart = editor => hasAncestorInlineCaret(SugarElement.fromDom(editor.selection.getStart()), editor.schema);
     const requiresRefreshCaretOverride = editor => {
       const rng = editor.selection.getRng();
       return rng.collapsed && (rangeStartsAtTextContainer(rng) || editor.dom.isEmpty(rng.startContainer)) && !hasAncestorInlineCaretAtStart(editor);
     };
         return Optional.none();
+      }
     };
     const deleteCaret = (editor, forward) => {
       const isNearMedia = forward ? isBeforeMedia : isAfterMedia;
-      const direction = forward ? HDirection.Forwards : HDirection.Backwards;
+      const direction = forward ? 1 : -1;
       const fromPos = getNormalizedRangeEndPoint(direction, editor.getBody(), editor.selection.getRng());
       if (isNearMedia(fromPos)) {
         return deleteElement(editor, forward, fromPos.getNode(!forward));
       } else {
         return Optional.from(normalizePosition(forward, fromPos)).filter(pos => isNearMedia(pos) && isMoveInsideSameBlock(fromPos, pos)).bind(pos => deleteElement(editor, forward, pos.getNode(!forward)));
     const isListComponent = el => isList(el) || isListItem$1(el);
     const parentIsListComponent = el => parent(el).exists(isListComponent);
     const getBlocksToIndent = editor => filter$5(fromDom$1(editor.selection.getSelectedBlocks()), el => !isListComponent(el) && !parentIsListComponent(el) && isEditable(el));
     const handle = (editor, command) => {
       var _a, _b;
+      if (editor.mode.isReadOnly()) {
+        return;
+      }
       const {dom} = editor;
       const indentation = getIndentation(editor);
       const indentUnit = (_b = (_a = /[a-z%]+$/i.exec(indentation)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : 'px';
       const indentValue = parseIndentValue(indentation);
       const useMargin = shouldIndentUseMargin(editor);
       return Optional.none();
     };
     const findAction = (editor, caret, forward) => findMap([
-      backspaceDelete$1,
-      backspaceDelete$6,
+      backspaceDelete$1,
+      backspaceDelete$7,
-      backspaceDelete$7,
+      backspaceDelete$8,
-      (editor, forward) => backspaceDelete$4(editor, caret, forward),
-      backspaceDelete$9,
+      (editor, forward) => backspaceDelete$4(editor, caret, forward),
+      backspaceDelete$a,
-      backspaceDelete$a,
+      backspaceDelete$b,
       backspaceDelete$5,
       backspaceDelete$2,
-      backspaceDelete$8,
+      backspaceDelete$9,
+      backspaceDelete$3,
-      backspaceDelete$3
+      backspaceDelete$6
     ], item => item(editor, forward)).filter(_ => editor.selection.isEditable());
     const deleteCommand = (editor, caret) => {
       const result = findAction(editor, caret, false);
       result.fold(() => {
       return distX > SIGNIFICANT_MOVE || distY > SIGNIFICANT_MOVE;
     };
     const setup$p = editor => {
       const startData = value$2();
       const longpressFired = Cell(false);
-      const debounceLongpress = last$1(e => {
+      const debounceLongpress = last(e => {
         editor.dispatch('longpress', {
           ...e,
           type: 'longpress'
         });
         longpressFired.set(true);
       }, true);
     };
     const isBlockElement = (blockElements, node) => has$2(blockElements, node.nodeName);
     const isValidTarget = (schema, node) => {
-      if (isText$a(node)) {
+      if (isText$b(node)) {
         return true;
       } else if (isElement$6(node)) {
         return !isBlockElement(schema.getBlockElements(), node) && !isBookmarkNode$1(node) && !isTransparentBlock(schema, node) && !isNonHtmlElementRoot(node);
       } else {
       return exists(parents(SugarElement.fromDom(node), SugarElement.fromDom(root)), elm => {
         return isBlockElement(blockElements, elm.dom);
       });
     };
     const shouldRemoveTextNode = (blockElements, node) => {
-      if (isText$a(node)) {
+      if (isText$b(node)) {
         if (node.data.length === 0) {
           return true;
         } else if (/^\s+$/.test(node.data)) {
           return !node.nextSibling || isBlockElement(blockElements, node.nextSibling) || isNonHtmlElementRoot(node.nextSibling);
+        }
       const blockElements = schema.getBlockElements();
       const startNode = selection.getStart();
       const rootNode = editor.getBody();
       let rootBlockNode;
       let tempNode;
-      let wrapped = false;
+      let bm = null;
       const forcedRootBlock = getForcedRootBlock(editor);
       if (!startNode || !isElement$6(startNode)) {
         return;
+      }
       const rootNodeName = rootNode.nodeName.toLowerCase();
       if (!schema.isValidChild(rootNodeName, forcedRootBlock.toLowerCase()) || hasBlockParent(blockElements, rootNode, startNode)) {
         return;
+      }
+      if (rootNode.firstChild === rootNode.lastChild && isBr$6(rootNode.firstChild)) {
-      const rng = selection.getRng();
+        rootBlockNode = createRootBlock(editor);
+        rootBlockNode.appendChild(createPaddingBr().dom);
-      const {startContainer, startOffset, endContainer, endOffset} = rng;
+        rootNode.replaceChild(rootBlockNode, rootNode.firstChild);
-      const restoreSelection = hasFocus(editor);
+        editor.selection.setCursorLocation(rootBlockNode, 0);
+        editor.nodeChanged();
+        return;
+      }
       let node = rootNode.firstChild;
       while (node) {
         if (isElement$6(node)) {
           updateElement(schema, node);
+        }
             node = node.nextSibling;
             dom.remove(tempNode);
             continue;
+          }
           if (!rootBlockNode) {
+            if (!bm && editor.hasFocus()) {
+              bm = getBookmark(editor.selection.getRng(), () => document.createElement('span'));
+            }
+            if (!node.parentNode) {
+              node = null;
+              break;
+            }
             rootBlockNode = createRootBlock(editor);
             rootNode.insertBefore(rootBlockNode, node);
-            wrapped = true;
+          }
           tempNode = node;
           node = node.nextSibling;
           rootBlockNode.appendChild(tempNode);
         } else {
           rootBlockNode = null;
           node = node.nextSibling;
+        }
+      }
-      if (wrapped && restoreSelection) {
+      if (bm) {
-        rng.setStart(startContainer, startOffset);
-        rng.setEnd(endContainer, endOffset);
-        selection.setRng(rng);
+        editor.selection.setRng(resolveBookmark(bm));
         editor.nodeChanged();
+      }
     };
     const insertEmptyLine = (editor, root, insertBlock) => {
       const block = SugarElement.fromDom(createRootBlock(editor));
       rng.setStartBefore(br.dom);
       rng.setEndBefore(br.dom);
       return rng;
     };
     const setup$o = editor => {
-      editor.on('NodeChange', curry(addRootBlocks, editor));
+      editor.on('NodeChange', () => addRootBlocks(editor));
     };
     const hasClass = checkClassName => node => (' ' + node.attr('class') + ' ').indexOf(checkClassName) !== -1;
     const replaceMatchWithSpan = (editor, content, cls) => {
       while (i--) {
         content = content.replace(nonEditableRegExps[i], replaceMatchWithSpan(editor, content, getNonEditableClass(editor)));
+      }
       e.content = content;
     };
+    const isValidContent = (nonEditableRegExps, content) => {
+      return forall(nonEditableRegExps, re => {
+        const matches = content.match(re);
+        return matches !== null && matches[0].length === content.length;
+      });
+    };
     const setup$n = editor => {
       const contentEditableAttrName = 'contenteditable';
       const editClass = ' ' + Tools.trim(getEditableClass(editor)) + ' ';
       const nonEditClass = ' ' + Tools.trim(getNonEditableClass(editor)) + ' ';
       const hasEditClass = hasClass(editClass);
         while (i--) {
           const node = nodes[i];
           if (!hasEditClass(node) && !hasNonEditClass(node)) {
             continue;
+          }
+          const content = node.attr('data-mce-content');
-          if (nonEditableRegExps.length > 0 && node.attr('data-mce-content')) {
+          if (nonEditableRegExps.length > 0 && content) {
+            if (isValidContent(nonEditableRegExps, content)) {
-            node.name = '#text';
+              node.name = '#text';
-            node.type = 3;
+              node.type = 3;
-            node.raw = true;
+              node.raw = true;
-            node.value = node.attr('data-mce-content');
+              node.value = content;
+            } else {
+              node.remove();
+            }
           } else {
             node.attr(contentEditableAttrName, null);
+          }
+        }
       });
     };
     const setup$m = editor => {
       editor.on('keyup compositionstart', curry(handleBlockContainer, editor));
     };
-    const isContentEditableFalse$3 = isContentEditableFalse$b;
+    const isContentEditableFalse$4 = isContentEditableFalse$b;
-    const moveToCeFalseHorizontally = (direction, editor, range) => moveHorizontally(editor, direction, range, isBeforeContentEditableFalse, isAfterContentEditableFalse, isContentEditableFalse$3);
+    const moveToCeFalseHorizontally = (direction, editor, range) => moveHorizontally(editor, direction, range, isBeforeContentEditableFalse, isAfterContentEditableFalse, isContentEditableFalse$4);
     const moveToCeFalseVertically = (direction, editor, range) => {
       const isBefore = caretPosition => isBeforeContentEditableFalse(caretPosition) || isBeforeTable(caretPosition);
       const isAfter = caretPosition => isAfterContentEditableFalse(caretPosition) || isAfterTable(caretPosition);
-      return moveVertically(editor, direction, range, isBefore, isAfter, isContentEditableFalse$3);
+      return moveVertically(editor, direction, range, isBefore, isAfter, isContentEditableFalse$4);
     };
     const createTextBlock = editor => {
       const textBlock = editor.dom.create(getForcedRootBlock(editor));
       textBlock.innerHTML = '<br data-mce-bogus="1">';
           editor.selection.collapse();
+        }
+      }
     };
     const getHorizontalRange = (editor, forward) => {
-      const direction = forward ? HDirection.Forwards : HDirection.Backwards;
+      const direction = forward ? 1 : -1;
       const range = editor.selection.getRng();
       return moveToCeFalseHorizontally(direction, editor, range).orThunk(() => {
         exitPreBlock(editor, direction, range);
         return Optional.none();
       });
     const action = (f, ...x) => () => f.apply(null, x);
     const execute = (patterns, evt) => find$2(match$1(patterns, evt), pattern => pattern.action());
     const executeWithDelayedAction = (patterns, evt) => findMap(matchDelayed(patterns, evt), pattern => pattern.action());
     const moveH$1 = (editor, forward) => {
-      const direction = forward ? HDirection.Forwards : HDirection.Backwards;
+      const direction = forward ? 1 : -1;
       const range = editor.selection.getRng();
       return moveHorizontally(editor, direction, range, isBeforeMedia, isAfterMedia, isMedia$2).exists(newRange => {
         moveToRange(editor, newRange);
         return true;
       }, info => {
         return walk(info.all, current, info.index, -1, isEligible);
       });
     };
+    const isTextNodeWithCursorPosition = el => getOption(el).filter(text => text.trim().length !== 0 || text.indexOf(nbsp) > -1).isSome();
+    const isContentEditableFalse$3 = elem => isHTMLElement$1(elem) && get$9(elem, 'contenteditable') === 'false';
+    const elementsWithCursorPosition = [
+      'img',
+      'br'
+    ];
+    const isCursorPosition = elem => {
+      const hasCursorPosition = isTextNodeWithCursorPosition(elem);
+      return hasCursorPosition || contains$2(elementsWithCursorPosition, name(elem)) || isContentEditableFalse$3(elem);
+    };
+    const first = element => descendant$2(element, isCursorPosition);
     const deflate = (rect, delta) => ({
       left: rect.left - delta,
       top: rect.top - delta,
       right: rect.right + delta * 2,
     const isAbove = (corner, y) => corner.y < y;
     const isBelow = (corner, y) => corner.y > y;
     const getClosestCellAbove = curry(getClosestCell, getBottomValue, isAbove);
     const getClosestCellBelow = curry(getClosestCell, getTopValue, isBelow);
     const findClosestPositionInAboveCell = (table, pos) => head(pos.getClientRects()).bind(rect => getClosestCellAbove(table, rect.left, rect.top)).bind(cell => findClosestHorizontalPosition(getLastLinePositions(cell), pos));
-    const findClosestPositionInBelowCell = (table, pos) => last$3(pos.getClientRects()).bind(rect => getClosestCellBelow(table, rect.left, rect.top)).bind(cell => findClosestHorizontalPosition(getFirstLinePositions(cell), pos));
+    const findClosestPositionInBelowCell = (table, pos) => last$2(pos.getClientRects()).bind(rect => getClosestCellBelow(table, rect.left, rect.top)).bind(cell => findClosestHorizontalPosition(getFirstLinePositions(cell), pos));
     const hasNextBreak = (getPositionsUntil, scope, lineInfo) => lineInfo.breakAt.exists(breakPos => getPositionsUntil(scope, breakPos).breakAt.isSome());
     const startsWithWrapBreak = lineInfo => lineInfo.breakType === BreakType.Wrap && lineInfo.positions.length === 0;
     const startsWithBrBreak = lineInfo => lineInfo.breakType === BreakType.Br && lineInfo.positions.length === 1;
       return cell.fold(Optional.none, Optional.none, (_current, next) => {
         return first(next).map(cell => {
           return getCellFirstCursorPosition(cell);
         });
       }, current => {
+        if (editor.mode.isReadOnly()) {
+          return Optional.none();
+        }
         editor.execCommand('mceTableInsertRowAfter');
         return tabForward(editor, isRoot, current);
       });
     };
     const tabForward = (editor, isRoot, cell) => tabGo(editor, isRoot, next(cell, isEditable$2));
       'IMG',
       'HR',
       'INPUT'
     ], node.nodeName) || dom.getContentEditable(node) === 'false';
     const textBefore = (node, offset, rootNode) => {
-      if (isText$a(node) && offset >= 0) {
+      if (isText$b(node) && offset >= 0) {
         return Optional.some(point(node, offset));
       } else {
         const textSeeker = TextSeeker(DOM$7);
         return Optional.from(textSeeker.backwards(node, offset, alwaysNext(node), rootNode)).map(prev => point(prev.container, prev.container.data.length));
+      }
     };
     const textAfter = (node, offset, rootNode) => {
-      if (isText$a(node) && offset >= node.length) {
+      if (isText$b(node) && offset >= node.length) {
         return Optional.some(point(node, offset));
       } else {
         const textSeeker = TextSeeker(DOM$7);
         return Optional.from(textSeeker.forwards(node, offset, alwaysNext(node), rootNode)).map(prev => point(prev.container, 0));
+      }
     };
     const scanLeft = (node, offset, rootNode) => {
-      if (!isText$a(node)) {
+      if (!isText$b(node)) {
         return Optional.none();
+      }
       const text = node.data;
       if (offset >= 0 && offset <= text.length) {
         return Optional.some(point(node, offset));
           return scanLeft(prev.container, offset + prevText.length, rootNode);
         });
+      }
     };
     const scanRight = (node, offset, rootNode) => {
-      if (!isText$a(node)) {
+      if (!isText$b(node)) {
         return Optional.none();
+      }
       const text = node.data;
       if (offset <= text.length) {
         return Optional.some(point(node, offset));
     const repeatLeft = (dom, node, offset, process, rootNode) => {
       const search = TextSeeker(dom, isBoundary(dom));
       return Optional.from(search.backwards(node, offset, process, rootNode));
     };
-    const isValidTextRange = rng => rng.collapsed && isText$a(rng.startContainer);
+    const isValidTextRange = rng => rng.collapsed && isText$b(rng.startContainer);
     const getText = rng => trim$2(rng.toString().replace(/\u00A0/g, ' '));
-    const isWhitespace = chr => chr !== '' && ' \xA0\f\n\r\t\x0B'.indexOf(chr) !== -1;
+    const isWhitespace = chr => chr !== '' && ' \xA0\uFEFF\f\n\r\t\x0B'.indexOf(chr) !== -1;
     const stripTrigger = (text, trigger) => text.substring(trigger.length);
-    const findTrigger = (text, index, trigger) => {
+    const findTrigger = (text, index, trigger, includeWhitespace = false) => {
       let i;
       const firstChar = trigger.charAt(0);
       for (i = index - 1; i >= 0; i--) {
         const char = text.charAt(i);
-        if (isWhitespace(char)) {
+        if (!includeWhitespace && isWhitespace(char)) {
           return Optional.none();
+        }
         if (firstChar === char && contains$1(text, trigger, i, index)) {
           break;
+        }
+      }
       return Optional.some(i);
     };
-    const findStart = (dom, initRange, trigger, minChars = 0) => {
+    const getContext = (dom, initRange, trigger, includeWhitespace = false) => {
       if (!isValidTextRange(initRange)) {
         return Optional.none();
+      }
       const buffer = {
         text: '',
         offset: 0
       };
       const findTriggerIndex = (element, offset, text) => {
         buffer.text = text + buffer.text;
         buffer.offset += offset;
-        return findTrigger(buffer.text, buffer.offset, trigger).getOr(offset);
+        return findTrigger(buffer.text, buffer.offset, trigger, includeWhitespace).getOr(offset);
       };
       const root = dom.getParent(initRange.startContainer, dom.isBlock) || dom.getRoot();
       return repeatLeft(dom, initRange.startContainer, initRange.startOffset, findTriggerIndex, root).bind(spot => {
         if (range.collapsed) {
           return Optional.none();
+        }
         const text = getText(range);
         const triggerIndex = text.lastIndexOf(trigger);
-        if (triggerIndex !== 0 || stripTrigger(text, trigger).length < minChars) {
+        if (triggerIndex !== 0) {
           return Optional.none();
         } else {
           return Optional.some({
             text: stripTrigger(text, trigger),
             range,
             trigger
           });
+        }
       });
     };
-    const getContext = (dom, initRange, trigger, minChars = 0) => detect$1(SugarElement.fromDom(initRange.startContainer)).fold(() => findStart(dom, initRange, trigger, minChars), elm => {
-      const range = dom.createRng();
-      range.selectNode(elm.dom);
-      const text = getText(range);
-      return Optional.some({
-        range,
-        text: stripTrigger(text, trigger),
-        trigger
-      });
-    });
     const isText$1 = node => node.nodeType === TEXT;
     const isElement = node => node.nodeType === ELEMENT;
     const toLast = node => {
       return {
         extract,
         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) => {
       const res = prop.extract([label], obj);
     const field = field$1;
     const customField = customField$1;
     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);
     const optionString = key => optionOf(key, string);
     const optionFunction = key => optionOf(key, functionProcessor);
       optionFunction('matches'),
       fetch$1,
       onAction,
       defaultedArrayOf('highlightOn', [], string)
     ]);
-    const createAutocompleter = spec => asRaw('Autocompleter', autocompleterSchema, {
+    const createAutocompleter = spec => asRaw('Autocompleter', autocompleterSchema, spec);
-      trigger: spec.ch,
-      ...spec
-    });
     const baseToolbarButtonFields = [
       enabled,
       optionalTooltip,
       optionalIcon,
       optionalText,
+      onSetup,
-      onSetup
+      defaultedString('context', 'mode:design')
     ];
       ])
     ];
     const contextButtonFields = baseToolbarButtonFields.concat([
+      defaultedType('contextformbutton'),
-      defaultedType('contextformbutton'),
+      defaultedString('align', 'end'),
       primary,
       onAction,
       customField('original', identity)
     ]);
     const contextToggleButtonFields = baseToolbarToggleButtonFields.concat([
+      defaultedType('contextformbutton'),
-      defaultedType('contextformbutton'),
+      defaultedString('align', 'end'),
       primary,
       onAction,
       customField('original', identity)
     ]);
     const launchButtonFields = baseToolbarButtonFields.concat([defaultedType('contextformbutton')]);
     const launchToggleButtonFields = baseToolbarToggleButtonFields.concat([defaultedType('contextformtogglebutton')]);
     const toggleOrNormal = choose('type', {
       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: '',
-        contextformtogglebutton: launchToggleButtonFields
+        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 => {
         lookupByTrigger
       };
     };
     const setupEditorInput = (editor, api) => {
-      const update = last$1(api.load, 50);
+      const update = last(api.load, 50);
-      editor.on('keypress compositionend', e => {
+      editor.on('input', e => {
-        if (e.which === 27) {
+        if (e.inputType === 'insertCompositionText' && !editor.composing) {
           return;
+        }
         update.throttle();
       });
       editor.on('keydown', e => {
         const keyCode = e.which;
         if (keyCode === 8) {
           update.throttle();
+        } else if (keyCode === 27) {
-        } else if (keyCode === 27) {
+          update.cancel();
+          api.cancelIfNecessary();
+        } else if (keyCode === 38 || keyCode === 40) {
-          api.cancelIfNecessary();
+          update.cancel();
         }
-      });
+      }, true);
       editor.on('remove', update.cancel);
     };
     const setup$k = editor => {
       const activeAutocompleter = value$2();
       const uiActive = Cell(false);
       const isActive = activeAutocompleter.isSet;
       const cancelIfNecessary = () => {
-        if (isActive()) {
-          removeAutocompleterDecoration(editor);
+        if (isActive()) {
           fireAutocompleterEnd(editor);
           uiActive.set(false);
           activeAutocompleter.clear();
+        }
       };
       const commenceIfNecessary = context => {
-        if (!isActive()) {
-          addAutocompleterDecoration(editor, context.range);
+        if (!isActive()) {
           activeAutocompleter.set({
             trigger: context.trigger,
             matchLength: context.text.length
           });
+        }
       };
       const getAutocompleters = cached(() => register$2(editor));
-      const doLookup = fetchOptions => activeAutocompleter.get().map(ac => getContext(editor.dom, editor.selection.getRng(), ac.trigger).bind(newContext => lookupWithContext(editor, getAutocompleters, newContext, fetchOptions))).getOrThunk(() => lookup(editor, getAutocompleters));
+      const doLookup = fetchOptions => activeAutocompleter.get().map(ac => getContext(editor.dom, editor.selection.getRng(), ac.trigger, true).bind(newContext => lookupWithContext(editor, getAutocompleters, newContext, fetchOptions))).getOrThunk(() => lookup(editor, getAutocompleters));
       const load = fetchOptions => {
         doLookup(fetchOptions).fold(cancelIfNecessary, lookupInfo => {
           commenceIfNecessary(lookupInfo.context);
           lookupInfo.lookupData.then(lookupData => {
             activeAutocompleter.get().map(ac => {
               const context = lookupInfo.context;
-              if (ac.trigger === context.trigger) {
-                if (context.text.length - ac.matchLength >= 10) {
+              if (ac.trigger !== context.trigger) {
-                  cancelIfNecessary();
+                return;
-                } else {
+              }
-                  activeAutocompleter.set({
+              activeAutocompleter.set({
-                    ...ac,
+                ...ac,
-                    matchLength: context.text.length
+                matchLength: context.text.length
-                  });
+              });
+              if (uiActive.get()) {
-                  if (uiActive.get()) {
+                fireAutocompleterUpdateActiveRange(editor, { range: context.range });
-                    fireAutocompleterUpdate(editor, { lookupData });
+                fireAutocompleterUpdate(editor, { lookupData });
-                  } else {
+              } else {
-                    uiActive.set(true);
+                uiActive.set(true);
-                    fireAutocompleterStart(editor, { lookupData });
+                fireAutocompleterUpdateActiveRange(editor, { range: context.range });
-                  }
                 fireAutocompleterStart(editor, { lookupData });
+              }
             });
           });
         });
+      };
+      const isRangeInsideOrEqual = (innerRange, outerRange) => {
+        const startComparison = innerRange.compareBoundaryPoints(window.Range.START_TO_START, outerRange);
+        const endComparison = innerRange.compareBoundaryPoints(window.Range.END_TO_END, outerRange);
+        return startComparison >= 0 && endComparison <= 0;
+      };
+      const readActiveRange = () => {
+        return activeAutocompleter.get().bind(({trigger}) => {
+          const selRange = editor.selection.getRng();
+          return getContext(editor.dom, selRange, trigger, uiActive.get()).filter(({range}) => isRangeInsideOrEqual(selRange, range)).map(({range}) => range);
+        });
       };
       editor.addCommand('mceAutocompleterReload', (_ui, value) => {
         const fetchOptions = isObject(value) ? value.fetchOptions : {};
         load(fetchOptions);
       });
+      editor.addCommand('mceAutocompleterClose', cancelIfNecessary);
+      editor.addCommand('mceAutocompleterRefreshActiveRange', () => {
+        readActiveRange().each(range => {
+          fireAutocompleterUpdateActiveRange(editor, { range });
+        });
+      });
-      editor.addCommand('mceAutocompleterClose', cancelIfNecessary);
+      editor.editorCommands.addQueryStateHandler('mceAutoCompleterInRange', () => readActiveRange().isSome());
       setupEditorInput(editor, {
         cancelIfNecessary,
         load
       });
     };
-    const browser$1 = detect$2().browser;
+    const browser$1 = detect$1().browser;
     const isSafari = browser$1.isSafari();
     const emptyNodeContents = node => fillWithPaddingBr(SugarElement.fromDom(node));
     const isEntireNodeSelected = (rng, node) => {
       });
     };
     const fireInputEvent = createAndFireInputEvent('input');
     const fireBeforeInputEvent = createAndFireInputEvent('beforeinput');
-    const platform$2 = detect$2();
+    const platform$2 = detect$1();
     const os = platform$2.os;
     const isMacOSOriOS = os.isMacOS() || os.isiOS();
     const browser = platform$2.browser;
     const isFirefox = browser.isFirefox();
           keyCode: VK.BACKSPACE,
           action: action(backspaceDelete$1, editor)
         },
+        {
           keyCode: VK.BACKSPACE,
-          action: action(backspaceDelete$6, editor, false)
+          action: action(backspaceDelete$7, editor, false)
         },
+        {
           keyCode: VK.DELETE,
-          action: action(backspaceDelete$6, editor, true)
+          action: action(backspaceDelete$7, editor, true)
         },
+        {
           keyCode: VK.BACKSPACE,
-          action: action(backspaceDelete$7, editor, false)
+          action: action(backspaceDelete$8, editor, false)
         },
+        {
           keyCode: VK.DELETE,
-          action: action(backspaceDelete$7, editor, true)
+          action: action(backspaceDelete$8, editor, true)
         },
+        {
           keyCode: VK.BACKSPACE,
           action: action(backspaceDelete$4, editor, caret, false)
         },
           keyCode: VK.DELETE,
           action: action(backspaceDelete$4, editor, caret, true)
         },
+        {
           keyCode: VK.BACKSPACE,
-          action: action(backspaceDelete$a, editor, false)
+          action: action(backspaceDelete$b, editor, false)
         },
+        {
           keyCode: VK.DELETE,
-          action: action(backspaceDelete$a, editor, true)
+          action: action(backspaceDelete$b, editor, true)
         },
+        {
           keyCode: VK.BACKSPACE,
           action: action(backspaceDelete, editor, false, unmodifiedGranularity)
         },
           keyCode: VK.DELETE,
           action: action(backspaceDelete$2, editor, true)
         },
+        {
           keyCode: VK.BACKSPACE,
-          action: action(backspaceDelete$8, editor, false)
+          action: action(backspaceDelete$9, editor, false)
         },
+        {
           keyCode: VK.DELETE,
-          action: action(backspaceDelete$8, editor, true)
+          action: action(backspaceDelete$9, editor, true)
         },
+        {
           keyCode: VK.BACKSPACE,
-          action: action(backspaceDelete$9, editor, false)
+          action: action(backspaceDelete$a, editor, false)
         },
+        {
           keyCode: VK.DELETE,
-          action: action(backspaceDelete$9, editor, true)
+          action: action(backspaceDelete$a, editor, true)
         },
+        {
           keyCode: VK.BACKSPACE,
           action: action(backspaceDelete$3, editor, false)
         },
+        {
           keyCode: VK.DELETE,
           action: action(backspaceDelete$3, editor, true)
+        },
+        {
+          keyCode: VK.BACKSPACE,
+          action: action(backspaceDelete$6, editor, false)
+        },
+        {
+          keyCode: VK.DELETE,
+          action: action(backspaceDelete$6, editor, true)
+        }
       ], evt).filter(_ => editor.selection.isEditable()).each(applyAction => {
         evt.preventDefault();
         const beforeInput = fireBeforeInputEvent(editor, inputType);
         if (!beforeInput.isDefaultPrevented()) {
       });
     };
     const firstNonWhiteSpaceNodeSibling = node => {
       while (node) {
-        if (isElement$6(node) || isText$a(node) && node.data && /[\r\n\s]/.test(node.data)) {
+        if (isElement$6(node) || isText$b(node) && node.data && /[\r\n\s]/.test(node.data)) {
           return node;
+        }
         node = node.nextSibling;
+      }
       if (root.hasChildNodes()) {
         const walker = new DomTreeWalker(root, root);
         let lastNode = root;
         let node;
         while (node = walker.current()) {
-          if (isText$a(node)) {
+          if (isText$b(node)) {
             rng.setStart(node, 0);
             rng.setEnd(node, 0);
             break;
+          }
           if (moveCaretBeforeOnEnterElementsMap[node.nodeName.toLowerCase()]) {
+      }
       moveToCaretPosition(editor, newBlock);
     };
     const trimZwsp = fragment => {
-      each$e(descendants$1(SugarElement.fromDom(fragment), isText$b), text => {
+      each$e(descendants$1(SugarElement.fromDom(fragment), isText$c), text => {
         const rawNode = text.dom;
         rawNode.nodeValue = trim$2(rawNode.data);
       });
     };
       return parentList !== null && editor.dom.getContentEditableParent(parentList) === 'false';
     };
     const isEmptyAnchor = (dom, elm) => {
       return elm && elm.nodeName === 'A' && dom.isEmpty(elm);
     };
-    const containerAndSiblingName = (container, nodeName) => {
+    const containerAndPreviousSiblingName = (container, nodeName) => {
       return container.nodeName === nodeName || container.previousSibling && container.previousSibling.nodeName === nodeName;
     };
+    const containerAndNextSiblingName = (container, nodeName) => {
+      return container.nodeName === nodeName || container.nextSibling && container.nextSibling.nodeName === nodeName;
+    };
     const canSplitBlock = (dom, node) => {
       return isNonNullable(node) && dom.isBlock(node) && !/^(TD|TH|CAPTION|FORM)$/.test(node.nodeName) && !/^(fixed|absolute)/i.test(node.style.position) && dom.isEditable(node.parentNode) && dom.getContentEditable(node) !== 'false';
     };
     const trimInlineElementsOnLeftSideOfBlock = (dom, nonEmptyElementsMap, block) => {
       var _a;
+          }
+        }
+      }
     };
     const normalizeZwspOffset = (start, container, offset) => {
-      if (!isText$a(container)) {
+      if (!isText$b(container)) {
         return offset;
       } else if (start) {
         return offset === 1 && container.data.charAt(offset - 1) === ZWSP$1 ? 0 : offset;
       } else {
         return offset === container.data.length - 1 && container.data.charAt(offset) === ZWSP$1 ? container.data.length : offset;
       return newRng;
     };
     const trimLeadingLineBreaks = node => {
       let currentNode = node;
       do {
-        if (isText$a(currentNode)) {
+        if (isText$b(currentNode)) {
           currentNode.data = currentNode.data.replace(/^[\r\n]+/, '');
+        }
         currentNode = currentNode.firstChild;
       } while (currentNode);
     };
       const createNewBlock$1 = (name, styles) => {
         return createNewBlock(editor, container, parentBlock, editableRoot, shouldKeepStyles(editor), name, styles);
       };
       const isCaretAtStartOrEndOfBlock = start => {
         const normalizedOffset = normalizeZwspOffset(start, container, offset);
-        if (isText$a(container) && (start ? normalizedOffset > 0 : normalizedOffset < container.data.length)) {
+        if (isText$b(container) && (start ? normalizedOffset > 0 : normalizedOffset < container.data.length)) {
           return false;
+        }
-        if (container.parentNode === parentBlock && isAfterLastNodeInContainer && !start) {
+        if ((container.parentNode === parentBlock || container === parentBlock) && isAfterLastNodeInContainer && !start) {
           return true;
+        }
         if (start && isElement$6(container) && container === parentBlock.firstChild) {
           return true;
+        }
-        if (containerAndSiblingName(container, 'TABLE') || containerAndSiblingName(container, 'HR')) {
+        if (containerAndPreviousSiblingName(container, 'TABLE') || containerAndPreviousSiblingName(container, 'HR')) {
+          if (containerAndNextSiblingName(container, 'BR')) {
+            return !start;
+          }
           return isAfterLastNodeInContainer && !start || !isAfterLastNodeInContainer && start;
+        }
         const walker = new DomTreeWalker(container, parentBlock);
-        if (isText$a(container)) {
+        if (isText$b(container)) {
           if (start && normalizedOffset === 0) {
             walker.prev();
           } else if (!start && normalizedOffset === container.data.length) {
             walker.next();
+          }
               const name = node.nodeName.toLowerCase();
               if (nonEmptyElementsMap[name] && name !== 'br') {
                 return false;
+              }
+            }
-          } else if (isText$a(node) && !isWhitespaceText(node.data)) {
+          } else if (isText$b(node) && !isWhitespaceText(node.data)) {
             return false;
+          }
           if (start) {
             walker.prev();
           } else {
       const shiftKey = !!(evt && evt.shiftKey);
       const ctrlKey = !!(evt && evt.ctrlKey);
       if (isElement$6(container) && container.hasChildNodes() && !collapsedAndCef) {
         isAfterLastNodeInContainer = offset > container.childNodes.length - 1;
         container = container.childNodes[Math.min(offset, container.childNodes.length - 1)] || container;
-        if (isAfterLastNodeInContainer && isText$a(container)) {
+        if (isAfterLastNodeInContainer && isText$b(container)) {
           offset = container.data.length;
         } else {
           offset = 0;
+        }
+      }
         setForcedBlockAttrs(editor, newBlock);
         moveToCaretPosition(editor, newBlock);
       } else if (isCaretAtStartOrEndOfBlock(false)) {
         newBlock = insertNewBlockAfter();
       } else if (isCaretAtStartOrEndOfBlock(true) && parentBlockParent) {
+        const caretPos = CaretPosition.fromRangeStart(rng);
+        const afterTable = isAfterTable(caretPos);
+        const parentBlockSugar = SugarElement.fromDom(parentBlock);
+        const afterBr = isAfterBr(parentBlockSugar, caretPos, editor.schema);
+        const prevBrOpt = afterBr ? findPreviousBr(parentBlockSugar, caretPos, editor.schema).bind(pos => Optional.from(pos.getNode())) : Optional.none();
         newBlock = parentBlockParent.insertBefore(createNewBlock$1(), parentBlock);
-        const isNearChildren = hasChildNodes(SugarElement.fromDom(rng.startContainer)) && rng.collapsed;
+        const root = containerAndPreviousSiblingName(parentBlock, 'HR') || afterTable ? newBlock : prevBrOpt.getOr(parentBlock);
-        moveToCaretPosition(editor, containerAndSiblingName(parentBlock, 'HR') || isNearChildren ? newBlock : parentBlock);
+        moveToCaretPosition(editor, root);
       } else {
         const tmpRng = includeZwspInRange(rng).cloneRange();
         tmpRng.setEndAfter(parentBlock);
         const fragment = tmpRng.extractContents();
         trimZwsp(fragment);
     const hasRightSideContent = (schema, container, parentBlock) => {
       const walker = new DomTreeWalker(container, parentBlock);
       let node;
       const nonEmptyElementsMap = schema.getNonEmptyElements();
       while (node = walker.next()) {
-        if (nonEmptyElementsMap[node.nodeName.toLowerCase()] || isText$a(node) && node.length > 0) {
+        if (nonEmptyElementsMap[node.nodeName.toLowerCase()] || isText$b(node) && node.length > 0) {
           return true;
+        }
+      }
       return false;
     };
       let offset = rng.startOffset;
       let container = rng.startContainer;
       if (isElement$6(container) && container.hasChildNodes()) {
         const isAfterLastNodeInContainer = offset > container.childNodes.length - 1;
         container = container.childNodes[Math.min(offset, container.childNodes.length - 1)] || container;
-        if (isAfterLastNodeInContainer && isText$a(container)) {
+        if (isAfterLastNodeInContainer && isText$b(container)) {
           offset = container.data.length;
         } else {
           offset = 0;
+        }
+      }
       const containerBlockName = containerBlock ? containerBlock.nodeName.toUpperCase() : '';
       const isControlKey = !!(evt && evt.ctrlKey);
       if (containerBlockName === 'LI' && !isControlKey) {
         parentBlock = containerBlock;
+      }
-      if (isText$a(container) && offset >= container.data.length) {
+      if (isText$b(container) && offset >= container.data.length) {
         if (!hasRightSideContent(editor.schema, container, parentBlock || dom.getRoot())) {
           brElm = dom.create('br');
           rng.insertNode(brElm);
           rng.setStartAfter(brElm);
           rng.setEndAfter(brElm);
         !!(evt && evt.shiftKey)
       ]).getOr(newLineAction.none());
     };
+    const insertBreak = (breakType, editor, evt) => {
+      if (editor.mode.isReadOnly()) {
+        return;
     const insertBreak = (breakType, editor, evt) => {
       if (!editor.selection.isCollapsed()) {
         execEditorDeleteCommand(editor);
+      }
       if (isNonNullable(evt)) {
       if (isNonNullable(evt)) {
         fireInputEvent(editor, breakType.fakeEventName);
+      }
     };
     const insert$1 = (editor, evt) => {
+      if (editor.mode.isReadOnly()) {
+        return;
+      }
       const br = () => insertBreak(linebreak, editor, evt);
       const block = () => insertBreak(blockbreak, editor, evt);
       const logicalAction = getAction(editor, evt);
       switch (getNewlineBehavior(editor)) {
       case 'linebreak':
         logicalAction.fold(br, block, noop);
         break;
+      }
     };
-    const platform$1 = detect$2();
+    const platform$1 = detect$1();
     const isIOSSafari = platform$1.os.isiOS() && platform$1.browser.isSafari();
     const handleEnterKeyEvent = (editor, event) => {
       if (event.isDefaultPrevented()) {
         return;
     const isCaretAfterKoreanCharacter = rng => {
       if (!rng.collapsed) {
         return false;
+      }
       const startContainer = rng.startContainer;
-      if (isText$a(startContainer)) {
+      if (isText$b(startContainer)) {
         const koreanCharRegex = /^[\uAC00-\uD7AF\u1100-\u11FF\u3130-\u318F\uA960-\uA97F\uD7B0-\uD7FF]$/;
         const char = startContainer.data.charAt(rng.startOffset - 1);
         return koreanCharRegex.test(char);
       } else {
         return false;
           normalizeNbspsInEditor(editor);
+        }
       });
     };
-    const platform = detect$2();
+    const platform = detect$1();
     const executeKeyupAction = (editor, caret, evt) => {
       execute([
+        {
           keyCode: VK.PAGE_UP,
           editor.nodeChanged();
+        }
       });
     };
+    const isValidContainer = (root, container) => root === container || root.contains(container);
+    const isInEditableRange = (editor, range) => {
+      if (!isValidContainer(editor.getBody(), range.startContainer) || !isValidContainer(editor.getBody(), range.endContainer)) {
+        return true;
+      }
+      return isEditableRange(editor.dom, range);
     };
     const setup$e = editor => {
       editor.on('beforeinput', e => {
-        if (!editor.selection.isEditable() || exists(e.getTargetRanges(), rng => !isEditableRange(editor.dom, rng))) {
+        if (!editor.selection.isEditable() || exists(e.getTargetRanges(), rng => !isInEditableRange(editor, rng))) {
           e.preventDefault();
+        }
       });
     };
     const insertTextAtPosition = (text, pos) => {
       const container = pos.container();
       const offset = pos.offset();
-      if (isText$a(container)) {
+      if (isText$b(container)) {
         container.insertData(offset, text);
         return Optional.some(CaretPosition(container, offset + text.length));
       } else {
+            }
             lastRng = fakeRng;
           });
+        }
         editor.on('contextmenu', () => {
+          store(editor);
           editor.dispatch('SelectionChange');
         });
         editor.on('SelectionChange', () => {
           const startElm = editor.selection.getStart(true);
           if (!startElm) {
+            }
+          }
         });
+      }
       nodeChanged(args = {}) {
+        const editor = this.editor;
-        const selection = this.editor.selection;
+        const selection = editor.selection;
         let node;
-        if (this.editor.initialized && selection && !shouldDisableNodeChange(this.editor) && !this.editor.mode.isReadOnly()) {
+        if (editor.initialized && selection && !shouldDisableNodeChange(editor) && !isDisabled$1(editor)) {
-          const root = this.editor.getBody();
+          const root = editor.getBody();
           node = selection.getStart(true) || root;
-          if (node.ownerDocument !== this.editor.getDoc() || !this.editor.dom.isChildOf(node, root)) {
+          if (node.ownerDocument !== editor.getDoc() || !editor.dom.isChildOf(node, root)) {
             node = root;
+          }
           const parents = [];
-          this.editor.dom.getParent(node, node => {
+          editor.dom.getParent(node, node => {
             if (node === root) {
               return true;
             } else {
               parents.push(node);
               return false;
+            }
           });
-          this.editor.dispatch('NodeChange', {
+          editor.dispatch('NodeChange', {
             ...args,
             element: node,
             parents
           });
+        }
     };
     const preProcess = (editor, html) => {
       const parser = DomParser({
         sanitize: shouldSanitizeXss(editor),
+        sandbox_iframes: shouldSandboxIframes(editor),
+        sandbox_iframes_exclusions: getSandboxIframesExclusions(editor),
-        sandbox_iframes: shouldSandboxIframes(editor)
+        convert_unsafe_embeds: shouldConvertUnsafeEmbeds(editor)
       }, editor.schema);
       parser.addNodeFilter('meta', nodes => {
         Tools.each(nodes, node => {
           node.remove();
       if (dataTransfer && dataTransfer.types) {
         for (let i = 0; i < dataTransfer.types.length; i++) {
           const contentType = dataTransfer.types[i];
           try {
             items[contentType] = dataTransfer.getData(contentType);
-          } catch (ex) {
+          } catch (_a) {
             items[contentType] = '';
+          }
+        }
+      }
       return items;
           clipboardData.clearData();
           clipboardData.setData('text/html', html);
           clipboardData.setData('text/plain', text);
           clipboardData.setData(internalHtmlMime(), html);
           return true;
-        } catch (e) {
+        } catch (_a) {
           return false;
+        }
       } else {
         return false;
+      }
       const pasteFormat = Cell(isPasteAsTextEnabled(editor) ? 'text' : 'html');
       const pasteBin = PasteBin(editor);
       setup$8(editor);
       register$1(editor, pasteFormat);
       setup$9(editor);
+      editor.addQueryStateHandler('mceTogglePlainTextPaste', () => pasteFormat.get() === 'text');
       editor.on('PreInit', () => {
         register(editor);
         setup$a(editor, draggingInternallyState);
         registerEventsAndFilters(editor, pasteBin, pasteFormat);
       });
       preventSummaryToggle(editor);
       filterDetails(editor);
     };
     const isBr = isBr$6;
-    const isText = isText$a;
+    const isText = isText$b;
     const isContentEditableFalse$2 = elm => isContentEditableFalse$b(elm.dom);
     const isContentEditableTrue = elm => isContentEditableTrue$3(elm.dom);
     const isRoot = rootNode => elm => eq(SugarElement.fromDom(rootNode), elm);
     const getClosestScope = (node, rootNode, schema) => closest$4(SugarElement.fromDom(node), elm => isContentEditableTrue(elm) || schema.isBlock(name(elm)), isRoot(rootNode)).getOr(SugarElement.fromDom(rootNode)).dom;
+        }
       };
       const tryFindSecondBestTextNode = (closest, sndClosest, distance) => {
         return caretCandidateRect(sndClosest).filter(rect => {
           const deltaDistance = Math.abs(distance(closest, clientX, clientY) - distance(rect, clientX, clientY));
-          return deltaDistance < 2 && isText$a(rect.node);
+          return deltaDistance < 2 && isText$b(rect.node);
         });
       };
       const findClosestCaretCandidateNodeRect = (rects, distance) => {
         const sortedRects = sort(rects, (r1, r2) => distance(r1, clientX, clientY) - distance(r2, clientX, clientY));
         return findMap(sortedRects, caretCandidateRect).map(closest => {
-          if (findCloserTextNode && !isText$a(closest.node) && sortedRects.length > 1) {
+          if (findCloserTextNode && !isText$b(closest.node) && sortedRects.length > 1) {
             return tryFindSecondBestTextNode(closest, sortedRects[1], distance).getOr(closest);
           } else {
             return closest;
+          }
         });
         button: 0,
         buttons: 0,
         clientX: 0,
         clientY: 0,
         ctrlKey: false,
+        layerX: 0,
+        layerY: 0,
         metaKey: false,
         movementX: 0,
         movementY: 0,
         offsetX: 0,
         offsetY: 0,
     const getRawTarget = selection => {
       const sel = selection.getSel();
       if (isNonNullable(sel)) {
         const rng = sel.getRangeAt(0);
         const startContainer = rng.startContainer;
-        return isText$a(startContainer) ? startContainer.parentNode : startContainer;
+        return isText$b(startContainer) ? startContainer.parentNode : startContainer;
       } else {
         return null;
+      }
     };
     const drop = (state, editor) => e => {
       const setupOffscreenSelection = (node, targetClone) => {
         const body = SugarElement.fromDom(editor.getBody());
         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;
         });
         const newRange = dom.createRng();
         empty(realSelectionContainer);
+        }
         const range = setupOffscreenSelection(elm, e.targetClone);
         const nodeElm = SugarElement.fromDom(elm);
         each$e(descendants(SugarElement.fromDom(editor.getBody()), `*[${ elementSelectionAttr }]`), elm => {
           if (!eq(nodeElm, elm)) {
-            remove$a(elm, elementSelectionAttr);
+            remove$9(elm, elementSelectionAttr);
+          }
         });
         if (!dom.getAttrib(elm, elementSelectionAttr)) {
           elm.setAttribute(elementSelectionAttr, '1');
+        }
           return null;
+        }
         let startContainer = range.startContainer;
         let startOffset = range.startOffset;
         const endOffset = range.endOffset;
-        if (isText$a(startContainer) && startOffset === 0 && isContentEditableFalse(startContainer.parentNode)) {
+        if (isText$b(startContainer) && startOffset === 0 && isContentEditableFalse(startContainer.parentNode)) {
           startContainer = startContainer.parentNode;
           startOffset = dom.nodeIndex(startContainer);
           startContainer = startContainer.parentNode;
+        }
         if (!isElement$6(startContainer)) {
       };
       const removeElementSelection = () => {
         if (selectedElement) {
           selectedElement.removeAttribute(elementSelectionAttr);
+        }
-        descendant$1(SugarElement.fromDom(editor.getBody()), '#' + realSelectionId).each(remove$5);
+        descendant$1(SugarElement.fromDom(editor.getBody()), '#' + realSelectionId).each(remove$4);
         selectedElement = null;
       };
       const destroy = () => {
         fakeCaret.destroy();
         selectedElement = null;
       };
     };
     const getNormalizedTextOffset = (container, offset) => {
       let normalizedOffset = offset;
-      for (let node = container.previousSibling; isText$a(node); node = node.previousSibling) {
+      for (let node = container.previousSibling; isText$b(node); node = node.previousSibling) {
         normalizedOffset += node.data.length;
+      }
       return normalizedOffset;
     };
     const generatePath = (dom, root, node, offset, normalized) => {
-      if (isText$a(node) && (offset < 0 || offset > node.data.length)) {
+      if (isText$b(node) && (offset < 0 || offset > node.data.length)) {
         return [];
       }
-      const p = normalized && isText$a(node) ? [getNormalizedTextOffset(node, offset)] : [offset];
+      const p = normalized && isText$b(node) ? [getNormalizedTextOffset(node, offset)] : [offset];
       let current = node;
       while (current !== root && current.parentNode) {
         p.push(dom.nodeIndex(current, normalized));
         current = current.parentNode;
       if (!isNumber(offset)) {
         return Optional.none();
       } else {
         const resolvedNode = foldl(nodePath, (optNode, index) => optNode.bind(node => Optional.from(node.childNodes[index])), Optional.some(root));
         return resolvedNode.bind(node => {
-          if (isText$a(node) && (offset < 0 || offset > node.data.length)) {
+          if (isText$b(node) && (offset < 0 || offset > node.data.length)) {
             return Optional.none();
           } else {
             return Optional.some({
               node,
               offset
     const generatePathRangeFromRange = (dom, root, range, normalized = false) => generatePathRange(dom, root, range.startContainer, range.startOffset, range.endContainer, range.endOffset, normalized);
     const cleanEmptyNodes = (dom, node, isRoot) => {
       if (node && dom.isEmpty(node) && !isRoot(node)) {
         const parent = node.parentNode;
-        dom.remove(node, isText$a(node.firstChild) && isWhitespaceText(node.firstChild.data));
+        dom.remove(node, isText$b(node.firstChild) && isWhitespaceText(node.firstChild.data));
         cleanEmptyNodes(dom, parent, isRoot);
+      }
     };
     const deleteRng = (dom, rng, isRoot, clean = true) => {
       const startParent = rng.startContainer.parentNode;
       const endParent = rng.endContainer.parentNode;
       rng.deleteContents();
       if (clean && !isRoot(rng.startContainer)) {
-        if (isText$a(rng.startContainer) && rng.startContainer.data.length === 0) {
+        if (isText$b(rng.startContainer) && rng.startContainer.data.length === 0) {
           dom.remove(rng.startContainer);
         }
-        if (isText$a(rng.endContainer) && rng.endContainer.data.length === 0) {
+        if (isText$b(rng.endContainer) && rng.endContainer.data.length === 0) {
           dom.remove(rng.endContainer);
+        }
         cleanEmptyNodes(dom, startParent, isRoot);
         if (startParent !== endParent) {
       rng.setStart(block, 0);
       rng.setEnd(node, offset);
       return rng.toString();
     };
-    const startsWithSingleSpace = s => /^\s[^\s]/.test(s);
-    const stripPattern = (dom, block, pattern) => {
-      const firstTextNode = textAfter(block, 0, block);
-      firstTextNode.each(spot => {
-        const node = spot.container;
-        scanRight(node, pattern.start.length, block).each(end => {
-          const rng = dom.createRng();
-          rng.setStart(node, 0);
-          rng.setEnd(end.container, end.offset);
-          deleteRng(dom, rng, e => e === block);
-        });
-        const text = SugarElement.fromDom(node);
-        const textContent = get$3(text);
-        if (startsWithSingleSpace(textContent)) {
-          set(text, textContent.slice(1));
-        }
-      });
-    };
-    const applyPattern$1 = (editor, match) => {
-      const dom = editor.dom;
-      const pattern = match.pattern;
-      const rng = resolvePathRange(dom.getRoot(), match.range).getOrDie('Unable to resolve path range');
-      const isBlockFormatName = (name, formatter) => {
-        const formatSet = formatter.get(name);
-        return isArray$1(formatSet) && head(formatSet).exists(format => has$2(format, 'block'));
-      };
-      getParentBlock(editor, rng).each(block => {
-        if (pattern.type === 'block-format') {
-          if (isBlockFormatName(pattern.format, editor.formatter)) {
-            editor.undoManager.transact(() => {
-              stripPattern(editor.dom, block, pattern);
-              editor.formatter.apply(pattern.format);
-            });
-          }
-        } else if (pattern.type === 'block-command') {
-          editor.undoManager.transact(() => {
-            stripPattern(editor.dom, block, pattern);
-            editor.execCommand(pattern.cmd, false, pattern.value);
-          });
-        }
-      });
-      return true;
-    };
-    const sortPatterns$1 = patterns => sort(patterns, (a, b) => b.start.length - a.start.length);
-    const findPattern$1 = (patterns, text) => {
-      const sortedPatterns = sortPatterns$1(patterns);
-      const nuText = text.replace(nbsp, ' ');
-      return find$2(sortedPatterns, pattern => text.indexOf(pattern.start) === 0 || nuText.indexOf(pattern.start) === 0);
-    };
-    const findPatterns$1 = (editor, block, patternSet, normalizedMatches) => {
-      var _a;
-      const dom = editor.dom;
-      const forcedRootBlock = getForcedRootBlock(editor);
-      if (!dom.is(block, forcedRootBlock)) {
-        return [];
-      }
-      const blockText = (_a = block.textContent) !== null && _a !== void 0 ? _a : '';
-      return findPattern$1(patternSet.blockPatterns, blockText).map(pattern => {
-        if (Tools.trim(blockText).length === pattern.start.length) {
-          return [];
-        }
-        return [{
-            pattern,
-            range: generatePathRange(dom, dom.getRoot(), block, 0, block, 0, normalizedMatches)
-          }];
-      }).getOr([]);
-    };
-    const applyMatches$1 = (editor, matches) => {
-      if (matches.length === 0) {
-        return;
-      }
-      const bookmark = editor.selection.getBookmark();
-      each$e(matches, match => applyPattern$1(editor, match));
-      editor.selection.moveToBookmark(bookmark);
-    };
     const newMarker = (dom, id) => dom.create('span', {
       'data-mce-type': 'bookmark',
       id
     });
+          }
           return Optional.some(startRange);
         });
       });
     };
-    const findPattern = (editor, block, details, normalizedMatches) => {
+    const findPattern$3 = (editor, block, details, normalizedMatches) => {
       const dom = editor.dom;
       const root = dom.getRoot();
       const pattern = details.pattern;
       const endNode = details.position.container;
       const endOffset = details.position.offset;
           if (!endsWith(text, pattern.end)) {
             continue;
+          }
           const patternsWithoutCurrent = patterns.slice();
           patternsWithoutCurrent.splice(i, 1);
-          const result = findPattern(editor, block, {
+          const result = findPattern$3(editor, block, {
             pattern,
             remainingPatterns: patternsWithoutCurrent,
             position: endSpot
           }, normalizedMatches);
           if (result.isNone() && offset > 0) {
+          }
+        }
         return Optional.none();
       });
     };
-    const applyPattern = (editor, pattern, patternRange) => {
+    const applyPattern$2 = (editor, pattern, patternRange) => {
       editor.selection.setRng(patternRange);
       if (pattern.type === 'inline-format') {
         each$e(pattern.format, format => {
           editor.formatter.apply(format);
         });
+      }
     };
     const applyReplacementPattern = (editor, pattern, marker, isRoot) => {
       const markerRange = rangeFromMarker(editor.dom, marker);
       deleteRng(editor.dom, markerRange, isRoot);
-      applyPattern(editor, pattern, markerRange);
+      applyPattern$2(editor, pattern, markerRange);
     };
     const applyPatternWithContent = (editor, pattern, startMarker, endMarker, isRoot) => {
       const dom = editor.dom;
       const markerEndRange = rangeFromMarker(dom, endMarker);
       const markerStartRange = rangeFromMarker(dom, startMarker);
         prefix: startMarker.prefix,
         start: startMarker.end,
         end: endMarker.start
       };
       const patternRange = rangeFromMarker(dom, patternMarker);
-      applyPattern(editor, pattern, patternRange);
+      applyPattern$2(editor, pattern, patternRange);
     };
     const addMarkers = (dom, matches) => {
       const markerPrefix = generate$1('mce_textpattern');
       const matchesWithEnds = foldr(matches, (acc, match) => {
         const endMarker = createMarker(dom, markerPrefix + `_end${ acc.length }`, match.endRng);
             ...match,
             startMarker
           }]);
       }, []);
     };
-    const sortPatterns = patterns => sort(patterns, (a, b) => b.end.length - a.end.length);
+    const sortPatterns$1 = patterns => sort(patterns, (a, b) => b.end.length - a.end.length);
     const getBestMatches = (matches, matchesWithSortedPatterns) => {
       const hasSameMatches = forall(matches, match => exists(matchesWithSortedPatterns, sortedMatch => match.pattern.start === sortedMatch.pattern.start && match.pattern.end === sortedMatch.pattern.end));
       if (matches.length === matchesWithSortedPatterns.length) {
         if (hasSameMatches) {
           return matches;
           return matchesWithSortedPatterns;
+        }
+      }
       return matches.length > matchesWithSortedPatterns.length ? matches : matchesWithSortedPatterns;
     };
-    const findPatterns = (editor, block, node, offset, patternSet, normalizedMatches) => {
+    const findPatterns$2 = (editor, block, node, offset, patternSet, normalizedMatches) => {
       const matches = findPatternsRec(editor, patternSet.inlinePatterns, node, offset, block, normalizedMatches).fold(() => [], result => result.matches);
-      const matchesWithSortedPatterns = findPatternsRec(editor, sortPatterns(patternSet.inlinePatterns), node, offset, block, normalizedMatches).fold(() => [], result => result.matches);
+      const matchesWithSortedPatterns = findPatternsRec(editor, sortPatterns$1(patternSet.inlinePatterns), node, offset, block, normalizedMatches).fold(() => [], result => result.matches);
       return getBestMatches(matches, matchesWithSortedPatterns);
     };
-    const applyMatches = (editor, matches) => {
+    const applyMatches$2 = (editor, matches) => {
       if (matches.length === 0) {
         return;
+      }
       const dom = editor.dom;
       const bookmark = editor.selection.getBookmark();
         removeMarker(dom, match.startMarker, isRoot);
       });
       editor.selection.moveToBookmark(bookmark);
     };
+    const stripPattern$1 = (dom, block, pattern) => {
+      return textAfter(block, 0, block).map(spot => {
+        const node = spot.container;
+        scanRight(node, pattern.start.length, block).each(end => {
+          const rng = dom.createRng();
+          rng.setStart(node, 0);
+          rng.setEnd(end.container, end.offset);
+          deleteRng(dom, rng, e => e === block);
+        });
+        return node;
+      });
+    };
+    const createApplyPattern = stripPattern => (editor, match) => {
+      const dom = editor.dom;
+      const pattern = match.pattern;
+      const rng = resolvePathRange(dom.getRoot(), match.range).getOrDie('Unable to resolve path range');
+      const isBlockFormatName = (name, formatter) => {
+        const formatSet = formatter.get(name);
+        return isArray$1(formatSet) && head(formatSet).exists(format => has$2(format, 'block'));
+      };
+      getParentBlock(editor, rng).each(block => {
+        if (pattern.type === 'block-format') {
+          if (isBlockFormatName(pattern.format, editor.formatter)) {
+            editor.undoManager.transact(() => {
+              stripPattern(editor.dom, block, pattern);
+              editor.formatter.apply(pattern.format);
+            });
+          }
+        } else if (pattern.type === 'block-command') {
+          editor.undoManager.transact(() => {
+            stripPattern(editor.dom, block, pattern);
+            editor.execCommand(pattern.cmd, false, pattern.value);
+          });
+        }
+      });
+      return true;
+    };
+    const sortPatterns = patterns => sort(patterns, (a, b) => b.start.length - a.start.length);
+    const findPattern$2 = predicate => (patterns, text) => {
+      const sortedPatterns = sortPatterns(patterns);
+      const nuText = text.replace(nbsp, ' ');
+      return find$2(sortedPatterns, pattern => predicate(pattern, text, nuText));
+    };
+    const createFindPatterns = (findPattern, skipFullMatch) => (editor, block, patternSet, normalizedMatches, text) => {
+      var _a;
+      if (text === void 0) {
+        text = (_a = block.textContent) !== null && _a !== void 0 ? _a : '';
+      }
+      const dom = editor.dom;
+      const forcedRootBlock = getForcedRootBlock(editor);
+      if (!dom.is(block, forcedRootBlock)) {
+        return [];
+      }
+      return findPattern(patternSet.blockPatterns, text).map(pattern => {
+        if (skipFullMatch && Tools.trim(text).length === pattern.start.length) {
+          return [];
+        }
+        return [{
+            pattern,
+            range: generatePathRange(dom, dom.getRoot(), block, 0, block, 0, normalizedMatches)
+          }];
+      }).getOr([]);
+    };
+    const startsWithSingleSpace = s => /^\s[^\s]/.test(s);
+    const stripPattern = (dom, block, pattern) => {
+      stripPattern$1(dom, block, pattern).each(node => {
+        const text = SugarElement.fromDom(node);
+        const textContent = get$3(text);
+        if (startsWithSingleSpace(textContent)) {
+          set(text, textContent.slice(1));
+        }
+      });
+    };
+    const applyPattern$1 = createApplyPattern(stripPattern);
+    const findPattern$1 = findPattern$2((pattern, text, nuText) => text.indexOf(pattern.start) === 0 || nuText.indexOf(pattern.start) === 0);
+    const findPatterns$1 = createFindPatterns(findPattern$1, true);
-    const handleEnter = (editor, patternSet) => {
+    const getMatches$1 = (editor, patternSet) => {
       const rng = editor.selection.getRng();
       return getParentBlock(editor, rng).map(block => {
         var _a;
         const offset = Math.max(0, rng.startOffset);
         const dynamicPatternSet = resolveFromDynamicPatterns(patternSet, block, (_a = block.textContent) !== null && _a !== void 0 ? _a : '');
-        const inlineMatches = findPatterns(editor, block, rng.startContainer, offset, dynamicPatternSet, true);
+        const inlineMatches = findPatterns$2(editor, block, rng.startContainer, offset, dynamicPatternSet, true);
-        const blockMatches = findPatterns$1(editor, block, dynamicPatternSet, true);
-        if (blockMatches.length > 0 || inlineMatches.length > 0) {
+        const blockMatches = findPatterns$1(editor, block, dynamicPatternSet, true);
-          editor.undoManager.add();
+        return {
-          editor.undoManager.extra(() => {
-            editor.execCommand('mceInsertNewLine');
+          inlineMatches,
-          }, () => {
+          blockMatches
-            insert$5(editor);
+        };
+      }).filter(({inlineMatches, blockMatches}) => blockMatches.length > 0 || inlineMatches.length > 0);
-            applyMatches(editor, inlineMatches);
+    };
-            applyMatches$1(editor, blockMatches);
-            const range = editor.selection.getRng();
-            const spot = textBefore(range.startContainer, range.startOffset, editor.dom.getRoot());
-            editor.execCommand('mceInsertNewLine');
+    const applyMatches$1 = (editor, matches) => {
-            spot.each(s => {
-              const node = s.container;
-              if (node.data.charAt(s.offset - 1) === zeroWidth) {
-                node.deleteData(s.offset - 1, 1);
-                cleanEmptyNodes(editor.dom, node.parentNode, e => e === editor.dom.getRoot());
-              }
+      if (matches.length === 0) {
-            });
+        return;
-          });
+      }
-          return true;
-        }
+      const bookmark = editor.selection.getBookmark();
-        return false;
+      each$e(matches, match => applyPattern$1(editor, match));
-      }).getOr(false);
+      editor.selection.moveToBookmark(bookmark);
+    };
+    const applyPattern = createApplyPattern(stripPattern$1);
+    const findPattern = findPattern$2((pattern, text, nuText) => text === pattern.start || nuText === pattern.start);
+    const findPatterns = createFindPatterns(findPattern, false);
+    const getMatches = (editor, patternSet) => {
+      const rng = editor.selection.getRng();
+      return getParentBlock(editor, rng).map(block => {
+        const offset = Math.max(0, rng.startOffset);
+        const beforeText = getBeforeText(editor.dom, block, rng.startContainer, offset);
+        const dynamicPatternSet = resolveFromDynamicPatterns(patternSet, block, beforeText);
+        return findPatterns(editor, block, dynamicPatternSet, false, beforeText);
+      }).filter(matches => matches.length > 0);
+    };
+    const applyMatches = (editor, matches) => {
+      each$e(matches, match => applyPattern(editor, match));
+    };
+    const handleEnter = (editor, patternSet) => getMatches$1(editor, patternSet).fold(never, ({inlineMatches, blockMatches}) => {
+      editor.undoManager.add();
+      editor.undoManager.extra(() => {
+        editor.execCommand('mceInsertNewLine');
+      }, () => {
+        insert$5(editor);
+        applyMatches$2(editor, inlineMatches);
+        applyMatches$1(editor, blockMatches);
+        const range = editor.selection.getRng();
+        const spot = textBefore(range.startContainer, range.startOffset, editor.dom.getRoot());
+        editor.execCommand('mceInsertNewLine');
+        spot.each(s => {
+          const node = s.container;
+          if (node.data.charAt(s.offset - 1) === zeroWidth) {
+            node.deleteData(s.offset - 1, 1);
+            cleanEmptyNodes(editor.dom, node.parentNode, e => e === editor.dom.getRoot());
+          }
+        });
+      });
+      return true;
-    };
+    });
     const handleInlineKey = (editor, patternSet) => {
       const rng = editor.selection.getRng();
       getParentBlock(editor, rng).map(block => {
         const offset = Math.max(0, rng.startOffset - 1);
         const beforeText = getBeforeText(editor.dom, block, rng.startContainer, offset);
         const dynamicPatternSet = resolveFromDynamicPatterns(patternSet, block, beforeText);
-        const inlineMatches = findPatterns(editor, block, rng.startContainer, offset, dynamicPatternSet, false);
+        const inlineMatches = findPatterns$2(editor, block, rng.startContainer, offset, dynamicPatternSet, false);
         if (inlineMatches.length > 0) {
           editor.undoManager.transact(() => {
-            applyMatches(editor, inlineMatches);
+            applyMatches$2(editor, inlineMatches);
           });
+        }
       });
+    };
+    const handleBlockPatternOnSpace = (editor, patternSet) => getMatches(editor, patternSet).fold(never, matches => {
+      editor.undoManager.transact(() => {
+        applyMatches(editor, matches);
+      });
+      return true;
-    };
+    });
     const checkKeyEvent = (codes, event, predicate) => {
       for (let i = 0; i < codes.length; i++) {
         if (predicate(codes[i], event)) {
           return true;
         ':',
         '!',
         '?'
       ];
       const keyCodes = [32];
-      const getPatternSet = () => createPatternSet(getTextPatterns(editor), getTextPatternsLookup(editor));
+      const getPatternSet = () => createPatternSet(getTextPatterns(editor).filter(pattern => {
+        if (pattern.type === 'inline-command' || pattern.type === 'block-command') {
+          return editor.queryCommandSupported(pattern.cmd);
+        }
+        return true;
+      }), getTextPatternsLookup(editor));
       const hasDynamicPatterns = () => hasTextPatternsLookup(editor);
       editor.on('keydown', e => {
-        if (e.keyCode === 13 && !VK.modifierPressed(e) && editor.selection.isCollapsed()) {
+        if (e.keyCode === 13 && !VK.modifierPressed(e) && editor.selection.isCollapsed() && editor.selection.isEditable()) {
-          const patternSet = getPatternSet();
+          const patternSet = filterByTrigger(getPatternSet(), 'enter');
           const hasPatterns = patternSet.inlinePatterns.length > 0 || patternSet.blockPatterns.length > 0 || hasDynamicPatterns();
           if (hasPatterns && handleEnter(editor, patternSet)) {
             e.preventDefault();
+          }
+        }
       }, true);
+      editor.on('keydown', e => {
+        if (e.keyCode === 32 && editor.selection.isCollapsed() && editor.selection.isEditable()) {
+          const patternSet = filterByTrigger(getPatternSet(), 'space');
+          const hasPatterns = patternSet.blockPatterns.length > 0 || hasDynamicPatterns();
+          if (hasPatterns && handleBlockPatternOnSpace(editor, patternSet)) {
+            e.preventDefault();
+          }
+        }
+      }, true);
       const handleInlineTrigger = () => {
-        if (editor.selection.isCollapsed()) {
+        if (editor.selection.isCollapsed() && editor.selection.isEditable()) {
-          const patternSet = getPatternSet();
+          const patternSet = filterByTrigger(getPatternSet(), 'space');
           const hasPatterns = patternSet.inlinePatterns.length > 0 || hasDynamicPatterns();
           if (hasPatterns) {
             handleInlineKey(editor, patternSet);
+          }
+        }
       const isiOS = Env.deviceType.isiPhone() || Env.deviceType.isiPad();
       const isMac = Env.os.isMacOS() || Env.os.isiOS();
       const setEditorCommandState = (cmd, state) => {
         try {
           editor.getDoc().execCommand(cmd, false, String(state));
-        } catch (ex) {
+        } catch (_a) {
+        }
       };
       const isDefaultPrevented = e => {
         return e.isDefaultPrevented();
       };
         editor.on('keydown', e => {
           const keyCode = e.keyCode;
           if (!isDefaultPrevented(e) && (keyCode === DELETE || keyCode === BACKSPACE) && editor.selection.isEditable()) {
             const isCollapsed = editor.selection.isCollapsed();
             const body = editor.getBody();
-            if (isCollapsed && !isEmpty$2(SugarElement.fromDom(body))) {
+            if (isCollapsed && !isEmptyNode(editor.schema, body)) {
               return;
+            }
             if (!isCollapsed && !allContentsSelected(editor.selection.getRng())) {
               return;
+            }
           setGeckoEditingOptions();
           showBrokenImageIcon();
           blockCmdArrowNavigation();
+        }
       };
-      const dropDragEndEvent = () => {
-        editor.on('drop', event => {
-          var _a;
-          const data = (_a = event.dataTransfer) === null || _a === void 0 ? void 0 : _a.getData('text/html');
-          if (isString(data) && /^<img[^>]*>$/.test(data)) {
-            editor.dispatch('dragend', new window.DragEvent('dragend', event));
-          }
-        });
-      };
       const setup = () => {
         removeBlockQuoteOnBackSpace();
         emptyEditorWhenDeleting();
         if (!Env.windowsPhone) {
           normalizeSelection();
           setGeckoEditingOptions();
           addBrAfterLastLinks();
           showBrokenImageIcon();
           blockCmdArrowNavigation();
           disableBackspaceIntoATable();
-          dropDragEndEvent();
+        }
       };
       if (isRtc(editor)) {
         setupRtc();
       } else {
         refreshContentEditable,
         isHidden
       };
     };
+    const isGplKey = key => key.toLowerCase() === 'gpl';
+    const isValidGeneratedKey = key => key.length >= 64 && key.length <= 255;
+    const validateLicenseKey = key => isGplKey(key) || isValidGeneratedKey(key) ? 'VALID' : 'INVALID';
+    const validateEditorLicenseKey = editor => {
+      const licenseKey = getLicenseKey(editor);
+      const hasApiKey = isString(getApiKey(editor));
+      if (!hasApiKey && (isUndefined(licenseKey) || validateLicenseKey(licenseKey) === 'INVALID')) {
+        console.warn(`TinyMCE is running in evaluation mode. Provide a valid license key or add license_key: 'gpl' to the init config to agree to the open source license terms. Read more at https://www.tiny.cloud/license-key/`);
+      }
+    };
     const DOM$6 = DOMUtils.DOM;
     const appendStyle = (editor, text) => {
       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', () => {
-        remove$5(style);
+        remove$4(style);
       });
     };
     const getRootName = editor => editor.inline ? editor.getElement().nodeName.toLowerCase() : undefined;
     const removeUndefined = obj => filter$4(obj, v => isUndefined(v) === false);
         allow_conditional_comments: getOption('allow_conditional_comments'),
         allow_html_data_urls: getOption('allow_html_data_urls'),
         allow_svg_data_urls: getOption('allow_svg_data_urls'),
         allow_html_in_named_anchor: getOption('allow_html_in_named_anchor'),
         allow_script_urls: getOption('allow_script_urls'),
+        allow_mathml_annotation_encodings: getOption('allow_mathml_annotation_encodings'),
         allow_unsafe_link_target: getOption('allow_unsafe_link_target'),
         convert_unsafe_embeds: getOption('convert_unsafe_embeds'),
         convert_fonts_to_spans: getOption('convert_fonts_to_spans'),
         fix_list_elements: getOption('fix_list_elements'),
         font_size_legacy_values: getOption('font_size_legacy_values'),
         forced_root_block_attrs: getOption('forced_root_block_attrs'),
         preserve_cdata: getOption('preserve_cdata'),
         inline_styles: getOption('inline_styles'),
         root_name: getRootName(editor),
         sandbox_iframes: getOption('sandbox_iframes'),
+        sandbox_iframes_exclusions: getSandboxIframesExclusions(editor),
         sanitize: getOption('xss_sanitization'),
         validate: true,
         blob_cache: blobCache,
         document: editor.getDoc()
       });
       const initInstanceCallback = getInitInstanceCallback(editor);
       if (isFunction(initInstanceCallback)) {
         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) => {
       const {
         pass: bundledCss,
+      }
       const body = editor.getBody();
       body.disabled = true;
       editor.readonly = isReadOnly$1(editor);
       editor._editableRoot = hasEditableRoot$1(editor);
-      if (!editor.readonly && editor.hasEditableRoot()) {
+      if (!isDisabled$1(editor) && editor.hasEditableRoot()) {
         if (editor.inline && DOM$6.getStyle(body, 'position', true) === 'static') {
           body.style.position = 'relative';
+        }
         body.contentEditable = 'true';
+      }
         schema: editor.schema,
         contentCssCors: shouldUseContentCssCors(editor),
         referrerPolicy: getReferrerPolicy(editor),
         onSetAttrib: e => {
           editor.dispatch('SetAttrib', e);
-        },
+        }
-        force_hex_color: shouldForceHexColor(editor)
       });
       editor.parser = createParser(editor);
       editor.serializer = DomSerializer(mkSerializerSettings(editor), editor);
       editor.selection = EditorSelection(editor.dom, editor.getWin(), editor.serializer, editor);
       editor.annotator = Annotator(editor);
       setup$o(editor);
       setup$r(editor);
       setup$7(editor);
       const setupRtcThunk = setup$t(editor);
       preInit(editor);
+      validateEditorLicenseKey(editor);
       setupRtcThunk.fold(() => {
         const cancelProgress = startProgress(editor);
         loadContentCss(editor).then(() => {
           initEditorWithInitialContent(editor);
           cancelProgress();
     const bind = (element, event, handler) => bind$2(element, event, filter, handler);
     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',
         frameBorder: '0',
+      }
       iframeHTML += '</head>' + `<body id="${ bodyId }" class="mce-content-body ${ bodyClass }" data-id="${ editor.id }" aria-label="${ translatedAriaText }">` + '<br>' + '</body></html>';
       return iframeHTML;
     };
     const createIframe = (editor, boxInfo) => {
+      const iframeTitle = Env.browser.isFirefox() ? getIframeAriaText(editor) : 'Rich Text Area';
-      const iframeTitle = editor.translate('Rich Text Area');
+      const translatedTitle = editor.translate(iframeTitle);
       const tabindex = getOpt(SugarElement.fromDom(editor.getElement()), 'tabindex').bind(toInt);
-      const ifr = createIframeElement(editor.id, iframeTitle, getIframeAttrs(editor), tabindex).dom;
+      const ifr = createIframeElement(editor.id, translatedTitle, getIframeAttrs(editor), tabindex).dom;
       ifr.onload = () => {
         ifr.onload = null;
         editor.dispatch('load');
       };
       editor.contentAreaContainer = boxInfo.iframeContainer;
       const uiApiFacade = {
         show: Optional.from(api.show).getOr(noop),
         hide: Optional.from(api.hide).getOr(noop),
         isEnabled: Optional.from(api.isEnabled).getOr(always),
         setEnabled: state => {
+          const shouldSkip = state && (editor.mode.get() === 'readonly' || isDisabled(editor));
-          if (!editor.mode.isReadOnly()) {
+          if (!shouldSkip) {
             Optional.from(api.setEnabled).each(f => f(state));
+          }
+        }
       };
       editor.ui = {
         return;
+      }
       const element = SugarElement.fromDom(editor.getElement());
       const snapshot = clone$4(element);
       editor.on('remove', () => {
-        eachr(element.dom.attributes, attr => remove$a(element, attr.name));
+        eachr(element.dom.attributes, attr => remove$9(element, attr.name));
         setAll$1(element, snapshot);
       });
       editor.ui.styleSheetLoader = getStyleSheetLoader(element, editor);
       if (!isInline$1(editor)) {
         editor.orgVisibility = editor.getElement().style.visibility;
     };
     const setEditableRoot = (editor, state) => {
       if (editor._editableRoot !== state) {
         editor._editableRoot = state;
-        if (!editor.readonly) {
+        if (!isDisabled(editor)) {
           editor.getBody().contentEditable = String(editor.hasEditableRoot());
           editor.nodeChanged();
+        }
         fireEditableRootStateChange(editor, state);
     const sectionResult = (sections, settings) => ({
       sections: constant(sections),
       options: constant(settings)
     });
-    const deviceDetection = detect$2().deviceType;
+    const deviceDetection = detect$1().deviceType;
     const isPhone = deviceDetection.isPhone();
     const isTablet = deviceDetection.isTablet();
     const normalizePlugins = plugins => {
       if (isNullable(plugins)) {
       const deviceOverrideOptions = isMobileDevice ? { mobile: getMobileOverrideOptions((_a = options.mobile) !== null && _a !== void 0 ? _a : {}, isPhone) } : {};
       const sectionResult = extractSections(['mobile'], deepMerge(deviceOverrideOptions, options));
       const extendedOptions = Tools.extend(defaultOptions, defaultOverrideOptions, sectionResult.options(), isOnMobile(isMobileDevice, sectionResult) ? getSection(sectionResult, 'mobile') : {}, { external_plugins: getExternalPlugins(defaultOverrideOptions, sectionResult.options()) });
       return processPlugins(isMobileDevice, sectionResult, defaultOverrideOptions, extendedOptions);
     };
+    const normalizeOptions = (defaultOverrideOptions, options) => {
+      const copiedOptions = merge(options);
-    const normalizeOptions = (defaultOverrideOptions, options) => combineOptions(isPhone || isTablet, isPhone, options, defaultOverrideOptions, options);
+      return combineOptions(isPhone || isTablet, isPhone, copiedOptions, defaultOverrideOptions, copiedOptions);
+    };
     const addVisual = (editor, elm) => addVisual$1(editor, elm);
-    const registerExecCommands$3 = editor => {
+    const registerExecCommands$2 = editor => {
       const toggleFormat = (name, value) => {
         editor.formatter.toggle(name, value);
         editor.nodeChanged();
         JustifyRight: toggleAlign('right'),
         JustifyFull: toggleAlign('justify'),
         JustifyNone: toggleAlign('none')
       });
     };
-    const registerQueryStateCommands$1 = editor => {
+    const registerQueryStateCommands = editor => {
       const alignStates = name => () => {
         const selection = editor.selection;
         const nodes = selection.isCollapsed() ? [editor.dom.getParent(selection.getNode(), editor.dom.isBlock)] : selection.getSelectedBlocks();
         return exists(nodes, node => isNonNullable(editor.formatter.matchNode(node, name)));
       };
         JustifyCenter: alignStates('aligncenter'),
         JustifyRight: alignStates('alignright'),
         JustifyFull: alignStates('alignjustify')
       }, 'state');
     };
-    const registerCommands$b = editor => {
+    const registerCommands$a = editor => {
-      registerExecCommands$3(editor);
+      registerExecCommands$2(editor);
-      registerQueryStateCommands$1(editor);
+      registerQueryStateCommands(editor);
     };
-    const registerCommands$a = editor => {
+    const registerCommands$9 = editor => {
       editor.editorCommands.addCommands({
         'Cut,Copy,Paste': command => {
           const doc = editor.getDoc();
           let failed;
           try {
             doc.execCommand(command);
-          } catch (ex) {
+          } catch (_a) {
             failed = true;
+          }
           if (command === 'paste' && !doc.queryCommandEnabled(command)) {
             failed = true;
           editor.addVisual();
         });
+      }
     };
-    const registerCommands$9 = editor => {
+    const registerCommands$8 = editor => {
       editor.editorCommands.addCommands({
         mceCleanup: () => {
           const bm = editor.selection.getBookmark();
           editor.setContent(editor.getContent());
     const getFontSize = getFontProp('font-size');
     const getFontFamily = compose(normalizeFontFamily, getFontProp('font-family'));
     const findFirstCaretElement = editor => firstPositionIn(editor.getBody()).bind(caret => {
       const container = caret.container();
-      return Optional.from(isText$a(container) ? container.parentNode : container);
+      return Optional.from(isText$b(container) ? container.parentNode : container);
     });
     const getCaretElement = editor => Optional.from(editor.selection.getRng()).bind(rng => {
       const root = editor.getBody();
       const atStartOfNode = rng.startContainer === root && rng.startOffset === 0;
     const lineHeightAction = (editor, lineHeight) => {
       editor.formatter.toggle('lineheight', { value: String(lineHeight) });
       editor.nodeChanged();
     };
-    const registerExecCommands$2 = editor => {
+    const registerExecCommands$1 = editor => {
       const toggleFormat = (name, value) => {
         editor.formatter.toggle(name, value);
         editor.nodeChanged();
       };
       }, 'state');
       editor.editorCommands.addQueryValueHandler('FontName', () => fontNameQuery(editor));
       editor.editorCommands.addQueryValueHandler('FontSize', () => fontSizeQuery(editor));
       editor.editorCommands.addQueryValueHandler('LineHeight', () => lineHeightQuery(editor));
     };
-    const registerCommands$8 = editor => {
+    const registerCommands$7 = editor => {
-      registerExecCommands$2(editor);
+      registerExecCommands$1(editor);
       registerQueryValueCommands(editor);
     };
-    const registerCommands$7 = editor => {
+    const registerCommands$6 = editor => {
       editor.editorCommands.addCommands({
         mceAddUndoLevel: () => {
           editor.undoManager.add();
         },
           editor.undoManager.redo();
+        }
       });
     };
-    const registerCommands$6 = editor => {
+    const registerCommands$5 = editor => {
       editor.editorCommands.addCommands({
         Indent: () => {
           indent(editor);
         },
+        }
       });
       editor.editorCommands.addCommands({ Outdent: () => canOutdent(editor) }, 'state');
     };
-    const registerCommands$5 = editor => {
+    const registerCommands$4 = editor => {
+      const applyLinkToSelection = (_command, _ui, value) => {
+        if (editor.mode.isReadOnly()) {
+          return;
       const applyLinkToSelection = (_command, _ui, value) => {
         const linkDetails = isString(value) ? { href: value } : value;
         const anchor = editor.dom.getParent(editor.selection.getNode(), 'a');
         if (isObject(linkDetails) && isString(linkDetails.href)) {
           linkDetails.href = linkDetails.href.replace(/ /g, '%20');
         mceInsertLink: applyLinkToSelection,
         createLink: applyLinkToSelection
       });
     };
-    const registerExecCommands$1 = editor => {
-      editor.editorCommands.addCommands({
-        'InsertUnorderedList,InsertOrderedList': command => {
-          editor.getDoc().execCommand(command);
-          const listElm = editor.dom.getParent(editor.selection.getNode(), 'ol,ul');
-          if (listElm) {
-            const listParent = listElm.parentNode;
-            if (listParent && /^(H[1-6]|P|ADDRESS|PRE)$/.test(listParent.nodeName)) {
-              const bm = editor.selection.getBookmark();
-              editor.dom.split(listParent, listElm);
-              editor.selection.moveToBookmark(bm);
-            }
-          }
-        }
-      });
-    };
-    const registerQueryStateCommands = editor => {
-      editor.editorCommands.addCommands({
-        'InsertUnorderedList,InsertOrderedList': command => {
-          const list = editor.dom.getParent(editor.selection.getNode(), 'ul,ol');
-          return list && (command === 'insertunorderedlist' && list.tagName === 'UL' || command === 'insertorderedlist' && list.tagName === 'OL');
-        }
-      }, 'state');
-    };
-    const registerCommands$4 = editor => {
-      registerExecCommands$1(editor);
-      registerQueryStateCommands(editor);
-    };
     const getTopParentBlock = (editor, node, root, container) => {
       const dom = editor.dom;
       const selector = node => dom.isBlock(node) && node.parentElement === root;
       const topParentBlock = selector(node) ? node : dom.getParent(container, selector, root);
       return Optional.from(topParentBlock).map(SugarElement.fromDom);
     };
+    const insert = (editor, before) => {
+      if (editor.mode.isReadOnly()) {
+        return;
     const insert = (editor, before) => {
       const dom = editor.dom;
       const rng = editor.selection.getRng();
       const node = before ? editor.selection.getStart() : editor.selection.getEnd();
       const container = before ? rng.startContainer : rng.endContainer;
           editor.addVisual();
+        }
       });
     };
     const registerCommands = editor => {
-      registerCommands$b(editor);
       registerCommands$a(editor);
-      registerCommands$7(editor);
-      registerCommands$1(editor);
       registerCommands$9(editor);
-      registerCommands$5(editor);
       registerCommands$6(editor);
+      registerCommands$1(editor);
+      registerCommands$8(editor);
+      registerCommands$4(editor);
+      registerCommands$5(editor);
       registerCommands$3(editor);
       registerCommands$2(editor);
-      registerCommands$4(editor);
-      registerCommands$8(editor);
+      registerCommands$7(editor);
       registerExecCommands(editor);
     };
     const selectionSafeCommands = ['toggleview'];
       addQueryValueHandler(command, callback, scope) {
         this.commands.value[command.toLowerCase()] = () => callback.call(scope !== null && scope !== void 0 ? scope : this.editor);
+      }
+    }
-    const internalContentEditableAttr = 'data-mce-contenteditable';
-    const toggleClass = (elm, cls, state) => {
-      if (has(elm, cls) && !state) {
-        remove$7(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 switchOffContentEditableTrue = elm => {
-      each$e(descendants(elm, '*[contenteditable="true"]'), elm => {
-        set$3(elm, internalContentEditableAttr, 'true');
-        setContentEditable(elm, false);
-      });
-    };
-    const switchOnContentEditableTrue = elm => {
-      each$e(descendants(elm, `*[${ internalContentEditableAttr }="true"]`), elm => {
-        remove$a(elm, internalContentEditableAttr);
-        setContentEditable(elm, true);
-      });
-    };
-    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 toggleReadOnly = (editor, state) => {
-      const body = SugarElement.fromDom(editor.getBody());
-      toggleClass(body, 'mce-content-readonly', state);
-      if (state) {
-        editor.selection.controlSelection.hideResizeRect();
-        editor._selectionOverrides.hideFakeCaret();
-        removeFakeSelection(editor);
-        editor.readonly = true;
-        setContentEditable(body, false);
-        switchOffContentEditableTrue(body);
-      } else {
-        editor.readonly = false;
-        if (editor.hasEditableRoot()) {
-          setContentEditable(body, true);
-        }
-        switchOnContentEditableTrue(body);
-        setEditorCommandState(editor, 'StyleWithCSS', false);
-        setEditorCommandState(editor, 'enableInlineTableEditing', false);
-        setEditorCommandState(editor, 'enableObjectResizing', false);
-        if (hasEditorOrUiFocus(editor)) {
-          editor.focus();
-        }
-        restoreFakeSelection(editor);
-        editor.nodeChanged();
-      }
-    };
-    const isReadOnly = editor => editor.readonly;
-    const registerFilters = editor => {
-      editor.parser.addAttributeFilter('contenteditable', nodes => {
-        if (isReadOnly(editor)) {
-          each$e(nodes, node => {
-            node.attr(internalContentEditableAttr, node.attr('contenteditable'));
-            node.attr('contenteditable', 'false');
-          });
-        }
-      });
-      editor.serializer.addAttributeFilter(internalContentEditableAttr, nodes => {
-        if (isReadOnly(editor)) {
-          each$e(nodes, node => {
-            node.attr('contenteditable', node.attr(internalContentEditableAttr));
-          });
-        }
-      });
-      editor.serializer.addTempAttr(internalContentEditableAttr);
-    };
-    const registerReadOnlyContentFilters = editor => {
-      if (editor.serializer) {
-        registerFilters(editor);
-      } else {
-        editor.on('PreInit', () => {
-          registerFilters(editor);
-        });
-      }
-    };
-    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('ShowCaret', e => {
-        if (isReadOnly(editor)) {
-          e.preventDefault();
-        }
-      });
-      editor.on('ObjectSelected', e => {
-        if (isReadOnly(editor)) {
-          e.preventDefault();
-        }
-      });
-    };
     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) {
         return !!nativeEvents[name.toLowerCase()];
+        }
         return editor.eventRoot;
+      }
       return editor.getBody();
     };
-    const isListening = editor => !editor.hidden && !isReadOnly(editor);
+    const isListening = editor => !editor.hidden && !isDisabled(editor);
     const fireEvent = (editor, eventName, e) => {
       if (isListening(editor)) {
         editor.dispatch(eventName, e);
-      } else if (isReadOnly(editor)) {
+      } else if (isDisabled(editor)) {
-        processReadonlyEvents(editor, e);
+        processDisabledEvents(editor, e);
+      }
     };
     const bindEventDelegate = (editor, eventName) => {
       if (!editor.delegates) {
         editor.delegates = {};
           console.error(getErrorMessage(`Invalid default value passed for the "${ name }" option`, result));
+        }
+      }
       return undefined;
     };
-    const create$5 = (editor, initialOptions) => {
+    const create$5 = (editor, initialOptions, rawInitialOptions = initialOptions) => {
       const registry = {};
       const values = {};
       const setValue = (name, value, processor) => {
         const result = processValue(value, processor);
         if (isValidResult(result)) {
           delete values[name];
+        }
         return registered;
       };
       const isSet = name => has$2(values, name);
+      const debug = () => {
+        try {
+          console.log(JSON.parse(JSON.stringify(rawInitialOptions, (_key, value) => {
+            if (isBoolean(value) || isNumber(value) || isString(value) || isNull(value) || isArray$1(value) || isPlainObject(value)) {
+              return value;
+            }
+            return Object.prototype.toString.call(value);
+          })));
+        } catch (error) {
+          console.error(error);
+        }
+      };
       return {
         register,
         isRegistered,
         get,
         set,
         unset,
-        isSet
+        isSet,
+        debug
       };
     };
+    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'
     ];
+      }
       activeMode.set(mode);
       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`);
+      }
       if (editor.initialized) {
           activate: noop,
           deactivate: noop,
           editorReadOnly: true
+        }
       });
-      registerReadOnlyContentFilters(editor);
+      registerReadOnlyInputBlockers(editor);
-      registerReadOnlySelectionBlockers(editor);
+      registerEventsAndFilters$1(editor);
       return {
         isReadOnly: () => isReadOnly(editor),
         set: mode => setMode(editor, availableModes.get(), activeMode, mode),
         get: () => activeMode.get(),
         register: (mode, api) => {
       const menuItems = {};
       const popups = {};
       const icons = {};
       const contextMenus = {};
       const contextToolbars = {};
+      const contexts = {};
       const sidebars = {};
       const views = {};
       const add = (collection, type) => (name, spec) => {
         collection[name.toLowerCase()] = {
           ...spec,
           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 {
         addButton: add(buttons, 'button'),
         addGroupToolbarButton: add(buttons, 'grouptoolbarbutton'),
         addToggleButton: add(buttons, 'togglebutton'),
         addMenuButton: add(buttons, 'menubutton'),
         addNestedMenuItem: add(menuItems, 'nestedmenuitem'),
         addToggleMenuItem: add(menuItems, 'togglemenuitem'),
         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,
+        addContext,
         getAll: () => ({
           buttons,
           menuItems,
           icons,
           popups,
           contextMenus,
           contextToolbars,
           sidebars,
-          views
+          views,
+          contexts
         })
       };
     };
         addSplitButton: bridge.addSplitButton,
         addToggleButton: bridge.addToggleButton,
         addGroupToolbarButton: bridge.addGroupToolbarButton,
         addToggleMenuItem: bridge.addToggleMenuItem,
         addView: bridge.addView,
+        addContext: bridge.addContext,
         getAll: bridge.getAll
       };
     };
         extend(this, EditorObservable);
         const self = this;
         this.id = id;
         this.hidden = false;
         const normalizedOptions = normalizeOptions(editorManager.defaultOptions, options);
-        this.options = create$5(self, normalizedOptions);
+        this.options = create$5(self, normalizedOptions, options);
         register$7(self);
         const getOption = this.options.get;
         if (getOption('deprecation_warnings')) {
           logWarnings(options, normalizedOptions);
+        }
       baseURI: null,
       baseURL: null,
       defaultOptions: {},
       documentBaseURL: null,
       suffix: null,
-      majorVersion: '6',
+      majorVersion: '7',
-      minorVersion: '8.3',
+      minorVersion: '7.1',
-      releaseDate: '2024-02-08',
+      releaseDate: '2025-03-05',
       i18n: I18n,
       activeEditor: null,
       focusedEditor: null,
       setup() {
         const self = this;
+          }
           return callback.apply(self, []);
         };
         const findTargets = options => {
           if (Env.browser.isIE() || Env.browser.isEdge()) {
-            initError('TinyMCE does not support the browser you are using. For a list of supported' + ' browsers please see: https://www.tiny.cloud/docs/tinymce/6/support/#supportedwebbrowsers');
+            initError('TinyMCE does not support the browser you are using. For a list of supported' + ' browsers please see: https://www.tiny.cloud/docs/tinymce/7/support/#supportedwebbrowsers');
             return [];
           } else if (isQuirksMode) {
             initError('Failed to initialize the editor as the document is not in standards mode. ' + 'TinyMCE requires standards mode.');
             return [];
           } else if (isString(options.selector)) {
       const has = id => {
         return id in resources;
       };
       const unload = id => {
         delete tasks[id];
+        delete resources[id];
       };
       const get = id => resources[id];
       return {
         load,
         add,
     try {
       const test = '__storage_test__';
       localStorage = window.localStorage;
       localStorage.setItem(test, test);
       localStorage.removeItem(test);
-    } catch (e) {
+    } catch (_a) {
       localStorage = create();
+    }
     var LocalStorage = localStorage;
     const exportToModuleLoaders = tinymce => {
       if (typeof module === 'object') {
         try {
           module.exports = tinymce;
-        } catch (_) {
+        } catch (_a) {
+        }
+      }
     };
     const exportToWindowGlobal = tinymce => {

Proyectos de Subversion Moodle

(root)/lib/editor/tiny/js/tinymce/tinymce.js – Rev 1 → 1441