WebSVN – oidplus – Diff – /trunk/vendor/tinymce/tinymce/themes/silver/theme.js

  * Copyright (c) Tiny Technologies, Inc. All rights reserved.
  * Licensed under the LGPL or a commercial license.
  * For LGPL see License.txt in the project root for license information.
  * For commercial licenses see https://www.tiny.cloud/
+ *
- * Version: 5.9.2 (2021-09-08)
+ * Version: 5.10.2 (2021-11-17)
  */
 (function () {
     'use strict';
     var typeOf = function (x) {
       };
     };
     var never = constant$1(false);
     var always = constant$1(true);
-    var global$h = tinymce.util.Tools.resolve('tinymce.ThemeManager');
+    var global$g = tinymce.util.Tools.resolve('tinymce.ThemeManager');
     var __assign = function () {
       __assign = Object.assign || function __assign(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
           s = arguments[i];
+        }
+      }
       return Optional.none();
     };
+    var keys = Object.keys;
+    var hasOwnProperty = Object.hasOwnProperty;
+    var each = function (obj, f) {
+      var props = keys(obj);
+      for (var k = 0, len = props.length; k < len; k++) {
+        var i = props[k];
+        var x = obj[i];
+        f(x, i);
+      }
+    };
+    var map$1 = function (obj, f) {
+      return tupleMap(obj, function (x, i) {
+        return {
+          k: i,
+          v: f(x, i)
+        };
+      });
+    };
+    var tupleMap = function (obj, f) {
+      var r = {};
+      each(obj, function (x, i) {
+        var tuple = f(x, i);
+        r[tuple.k] = tuple.v;
+      });
+      return r;
+    };
+    var objAcc = function (r) {
+      return function (x, i) {
+        r[i] = x;
+      };
+    };
+    var internalFilter = function (obj, pred, onTrue, onFalse) {
+      var r = {};
+      each(obj, function (x, i) {
+        (pred(x, i) ? onTrue : onFalse)(x, i);
+      });
+      return r;
+    };
+    var filter$1 = function (obj, pred) {
+      var t = {};
+      internalFilter(obj, pred, objAcc(t), noop);
+      return t;
+    };
+    var mapToArray = function (obj, f) {
+      var r = [];
+      each(obj, function (value, name) {
+        r.push(f(value, name));
+      });
+      return r;
+    };
+    var find$4 = function (obj, pred) {
+      var props = keys(obj);
+      for (var k = 0, len = props.length; k < len; k++) {
+        var i = props[k];
+        var x = obj[i];
+        if (pred(x, i, obj)) {
+          return Optional.some(x);
+        }
+      }
+      return Optional.none();
+    };
+    var values = function (obj) {
+      return mapToArray(obj, identity$1);
+    };
+    var get$e = function (obj, key) {
+      return has$2(obj, key) ? Optional.from(obj[key]) : Optional.none();
+    };
+    var has$2 = function (obj, key) {
+      return hasOwnProperty.call(obj, key);
+    };
+    var hasNonNullableKey = function (obj, key) {
+      return has$2(obj, key) && obj[key] !== undefined && obj[key] !== null;
+    };
+    var is$1 = function (lhs, rhs, comparator) {
+      if (comparator === void 0) {
+        comparator = tripleEquals;
+      }
+      return lhs.exists(function (left) {
+        return comparator(left, rhs);
+      });
+    };
+    var equals = function (lhs, rhs, comparator) {
+      if (comparator === void 0) {
+        comparator = tripleEquals;
+      }
+      return lift2(lhs, rhs, comparator).getOr(lhs.isNone() && rhs.isNone());
+    };
+    var cat = function (arr) {
+      var r = [];
+      var push = function (x) {
+        r.push(x);
+      };
+      for (var i = 0; i < arr.length; i++) {
+        arr[i].each(push);
+      }
+      return r;
+    };
+    var sequence = function (arr) {
+      var r = [];
+      for (var i = 0; i < arr.length; i++) {
+        var x = arr[i];
+        if (x.isSome()) {
+          r.push(x.getOrDie());
+        } else {
+          return Optional.none();
+        }
+      }
+      return Optional.some(r);
+    };
+    var lift2 = function (oa, ob, f) {
+      return oa.isSome() && ob.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie())) : Optional.none();
+    };
+    var lift3 = function (oa, ob, oc, f) {
+      return oa.isSome() && ob.isSome() && oc.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie(), oc.getOrDie())) : Optional.none();
+    };
+    var mapFrom = function (a, f) {
+      return a !== undefined && a !== null ? Optional.some(f(a)) : Optional.none();
+    };
+    var someIf = function (b, a) {
+      return b ? Optional.some(a) : Optional.none();
+    };
+    var addToEnd = function (str, suffix) {
+      return str + suffix;
+    };
+    var removeFromStart = function (str, numChars) {
+      return str.substring(numChars);
+    };
+    var checkRange = function (str, substr, start) {
+      return substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
+    };
+    var removeLeading = function (str, prefix) {
+      return startsWith(str, prefix) ? removeFromStart(str, prefix.length) : str;
+    };
+    var ensureTrailing = function (str, suffix) {
+      return endsWith(str, suffix) ? str : addToEnd(str, suffix);
+    };
+    var contains$1 = function (str, substr) {
+      return str.indexOf(substr) !== -1;
+    };
+    var startsWith = function (str, prefix) {
+      return checkRange(str, prefix, 0);
+    };
+    var endsWith = function (str, suffix) {
+      return checkRange(str, suffix, str.length - suffix.length);
+    };
+    var blank = function (r) {
+      return function (s) {
+        return s.replace(r, '');
+      };
+    };
+    var trim$1 = blank(/^\s+|\s+$/g);
+    var isNotEmpty = function (s) {
+      return s.length > 0;
+    };
+    var isEmpty = function (s) {
+      return !isNotEmpty(s);
+    };
+    var isSupported$1 = function (dom) {
+      return dom.style !== undefined && isFunction(dom.style.getPropertyValue);
+    };
+    var fromHtml$2 = function (html, scope) {
+      var doc = scope || document;
+      var div = doc.createElement('div');
+      div.innerHTML = html;
+      if (!div.hasChildNodes() || div.childNodes.length > 1) {
+        console.error('HTML does not have a single root node', html);
+        throw new Error('HTML must have a single root node');
+      }
+      return fromDom(div.childNodes[0]);
+    };
+    var fromTag = function (tag, scope) {
+      var doc = scope || document;
+      var node = doc.createElement(tag);
+      return fromDom(node);
+    };
+    var fromText = function (text, scope) {
+      var doc = scope || document;
+      var node = doc.createTextNode(text);
+      return fromDom(node);
+    };
+    var fromDom = function (node) {
+      if (node === null || node === undefined) {
+        throw new Error('Node cannot be null or undefined');
+      }
+      return { dom: node };
+    };
+    var fromPoint = function (docElm, x, y) {
+      return Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom);
+    };
+    var SugarElement = {
+      fromHtml: fromHtml$2,
+      fromTag: fromTag,
+      fromText: fromText,
+      fromDom: fromDom,
+      fromPoint: fromPoint
+    };
+    typeof window !== 'undefined' ? window : Function('return this;')();
+    var DOCUMENT = 9;
+    var DOCUMENT_FRAGMENT = 11;
+    var ELEMENT = 1;
+    var TEXT = 3;
+    var name$2 = function (element) {
+      var r = element.dom.nodeName;
+      return r.toLowerCase();
+    };
+    var type = function (element) {
+      return element.dom.nodeType;
+    };
+    var isType = function (t) {
+      return function (element) {
+        return type(element) === t;
+      };
+    };
+    var isElement$2 = isType(ELEMENT);
+    var isText$1 = isType(TEXT);
+    var isDocument = isType(DOCUMENT);
+    var isDocumentFragment = isType(DOCUMENT_FRAGMENT);
+    var cached = function (f) {
+      var called = false;
+      var r;
+      return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        if (!called) {
+          called = true;
+          r = f.apply(null, args);
+        }
+        return r;
+      };
+    };
+    var DeviceType = function (os, browser, userAgent, mediaMatch) {
+      var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
+      var isiPhone = os.isiOS() && !isiPad;
+      var isMobile = os.isiOS() || os.isAndroid();
+      var isTouch = isMobile || mediaMatch('(pointer:coarse)');
+      var isTablet = isiPad || !isiPhone && isMobile && mediaMatch('(min-device-width:768px)');
+      var isPhone = isiPhone || isMobile && !isTablet;
+      var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
+      var isDesktop = !isPhone && !isTablet && !iOSwebview;
+      return {
+        isiPad: constant$1(isiPad),
+        isiPhone: constant$1(isiPhone),
+        isTablet: constant$1(isTablet),
+        isPhone: constant$1(isPhone),
+        isTouch: constant$1(isTouch),
+        isAndroid: os.isAndroid,
+        isiOS: os.isiOS,
+        isWebView: constant$1(iOSwebview),
+        isDesktop: constant$1(isDesktop)
+      };
+    };
+    var firstMatch = function (regexes, s) {
+      for (var i = 0; i < regexes.length; i++) {
+        var x = regexes[i];
+        if (x.test(s)) {
+          return x;
+        }
+      }
+      return undefined;
+    };
+    var find$3 = function (regexes, agent) {
+      var r = firstMatch(regexes, agent);
+      if (!r) {
+        return {
+          major: 0,
+          minor: 0
+        };
+      }
+      var group = function (i) {
+        return Number(agent.replace(r, '$' + i));
+      };
+      return nu$d(group(1), group(2));
+    };
+    var detect$4 = function (versionRegexes, agent) {
+      var cleanedAgent = String(agent).toLowerCase();
+      if (versionRegexes.length === 0) {
+        return unknown$3();
+      }
+      return find$3(versionRegexes, cleanedAgent);
+    };
+    var unknown$3 = function () {
+      return nu$d(0, 0);
+    };
+    var nu$d = function (major, minor) {
+      return {
+        major: major,
+        minor: minor
+      };
+    };
+    var Version = {
+      nu: nu$d,
+      detect: detect$4,
+      unknown: unknown$3
+    };
+    var detectBrowser$1 = function (browsers, userAgentData) {
+      return findMap(userAgentData.brands, function (uaBrand) {
+        var lcBrand = uaBrand.brand.toLowerCase();
+        return find$5(browsers, function (browser) {
+          var _a;
+          return lcBrand === ((_a = browser.brand) === null || _a === void 0 ? void 0 : _a.toLowerCase());
+        }).map(function (info) {
+          return {
+            current: info.name,
+            version: Version.nu(parseInt(uaBrand.version, 10), 0)
+          };
+        });
+      });
+    };
+    var detect$3 = function (candidates, userAgent) {
+      var agent = String(userAgent).toLowerCase();
+      return find$5(candidates, function (candidate) {
+        return candidate.search(agent);
+      });
+    };
+    var detectBrowser = function (browsers, userAgent) {
+      return detect$3(browsers, userAgent).map(function (browser) {
+        var version = Version.detect(browser.versionRegexes, userAgent);
+        return {
+          current: browser.name,
+          version: version
+        };
+      });
+    };
+    var detectOs = function (oses, userAgent) {
+      return detect$3(oses, userAgent).map(function (os) {
+        var version = Version.detect(os.versionRegexes, userAgent);
+        return {
+          current: os.name,
+          version: version
+        };
+      });
+    };
+    var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
+    var checkContains = function (target) {
+      return function (uastring) {
+        return contains$1(uastring, target);
+      };
+    };
+    var browsers = [
+      {
+        name: 'Edge',
+        versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
+        search: function (uastring) {
+          return contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit');
+        }
+      },
+      {
+        name: 'Chrome',
+        brand: 'Chromium',
+        versionRegexes: [
+          /.*?chrome\/([0-9]+)\.([0-9]+).*/,
+          normalVersionRegex
+        ],
+        search: function (uastring) {
+          return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe');
+        }
+      },
+      {
+        name: 'IE',
+        versionRegexes: [
+          /.*?msie\ ?([0-9]+)\.([0-9]+).*/,
+          /.*?rv:([0-9]+)\.([0-9]+).*/
+        ],
+        search: function (uastring) {
+          return contains$1(uastring, 'msie') || contains$1(uastring, 'trident');
+        }
+      },
+      {
+        name: 'Opera',
+        versionRegexes: [
+          normalVersionRegex,
+          /.*?opera\/([0-9]+)\.([0-9]+).*/
+        ],
+        search: checkContains('opera')
+      },
+      {
+        name: 'Firefox',
+        versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
+        search: checkContains('firefox')
+      },
+      {
+        name: 'Safari',
+        versionRegexes: [
+          normalVersionRegex,
+          /.*?cpu os ([0-9]+)_([0-9]+).*/
+        ],
+        search: function (uastring) {
+          return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit');
+        }
+      }
+    ];
+    var oses = [
+      {
+        name: 'Windows',
+        search: checkContains('win'),
+        versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
+      },
+      {
+        name: 'iOS',
+        search: function (uastring) {
+          return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad');
+        },
+        versionRegexes: [
+          /.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
+          /.*cpu os ([0-9]+)_([0-9]+).*/,
+          /.*cpu iphone os ([0-9]+)_([0-9]+).*/
+        ]
+      },
+      {
+        name: 'Android',
+        search: checkContains('android'),
+        versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
+      },
+      {
+        name: 'OSX',
+        search: checkContains('mac os x'),
+        versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]
+      },
+      {
+        name: 'Linux',
+        search: checkContains('linux'),
+        versionRegexes: []
+      },
+      {
+        name: 'Solaris',
+        search: checkContains('sunos'),
+        versionRegexes: []
+      },
+      {
+        name: 'FreeBSD',
+        search: checkContains('freebsd'),
+        versionRegexes: []
+      },
+      {
+        name: 'ChromeOS',
+        search: checkContains('cros'),
+        versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/]
+      }
+    ];
+    var PlatformInfo = {
+      browsers: constant$1(browsers),
+      oses: constant$1(oses)
+    };
+    var edge = 'Edge';
+    var chrome = 'Chrome';
+    var ie = 'IE';
+    var opera = 'Opera';
+    var firefox = 'Firefox';
+    var safari = 'Safari';
+    var unknown$2 = function () {
+      return nu$c({
+        current: undefined,
+        version: Version.unknown()
+      });
+    };
+    var nu$c = function (info) {
+      var current = info.current;
+      var version = info.version;
+      var isBrowser = function (name) {
+        return function () {
+          return current === name;
+        };
+      };
+      return {
+        current: current,
+        version: version,
+        isEdge: isBrowser(edge),
+        isChrome: isBrowser(chrome),
+        isIE: isBrowser(ie),
+        isOpera: isBrowser(opera),
+        isFirefox: isBrowser(firefox),
+        isSafari: isBrowser(safari)
+      };
+    };
+    var Browser = {
+      unknown: unknown$2,
+      nu: nu$c,
+      edge: constant$1(edge),
+      chrome: constant$1(chrome),
+      ie: constant$1(ie),
+      opera: constant$1(opera),
+      firefox: constant$1(firefox),
+      safari: constant$1(safari)
+    };
+    var windows = 'Windows';
+    var ios = 'iOS';
+    var android = 'Android';
+    var linux = 'Linux';
+    var osx = 'OSX';
+    var solaris = 'Solaris';
+    var freebsd = 'FreeBSD';
+    var chromeos = 'ChromeOS';
+    var unknown$1 = function () {
+      return nu$b({
+        current: undefined,
+        version: Version.unknown()
+      });
+    };
+    var nu$b = function (info) {
+      var current = info.current;
+      var version = info.version;
+      var isOS = function (name) {
+        return function () {
+          return current === name;
+        };
+      };
+      return {
+        current: current,
+        version: version,
+        isWindows: isOS(windows),
+        isiOS: isOS(ios),
+        isAndroid: isOS(android),
+        isOSX: isOS(osx),
+        isLinux: isOS(linux),
+        isSolaris: isOS(solaris),
+        isFreeBSD: isOS(freebsd),
+        isChromeOS: isOS(chromeos)
+      };
+    };
+    var OperatingSystem = {
+      unknown: unknown$1,
+      nu: nu$b,
+      windows: constant$1(windows),
+      ios: constant$1(ios),
+      android: constant$1(android),
+      linux: constant$1(linux),
+      osx: constant$1(osx),
+      solaris: constant$1(solaris),
+      freebsd: constant$1(freebsd),
+      chromeos: constant$1(chromeos)
+    };
+    var detect$2 = function (userAgent, userAgentDataOpt, mediaMatch) {
+      var browsers = PlatformInfo.browsers();
+      var oses = PlatformInfo.oses();
+      var browser = userAgentDataOpt.bind(function (userAgentData) {
+        return detectBrowser$1(browsers, userAgentData);
+      }).orThunk(function () {
+        return detectBrowser(browsers, userAgent);
+      }).fold(Browser.unknown, Browser.nu);
+      var os = detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
+      var deviceType = DeviceType(os, browser, userAgent, mediaMatch);
+      return {
+        browser: browser,
+        os: os,
+        deviceType: deviceType
+      };
+    };
+    var PlatformDetection = { detect: detect$2 };
+    var mediaMatch = function (query) {
+      return window.matchMedia(query).matches;
+    };
+    var platform = cached(function () {
+      return PlatformDetection.detect(navigator.userAgent, Optional.from(navigator.userAgentData), mediaMatch);
+    });
+    var detect$1 = function () {
+      return platform();
+    };
+    var compareDocumentPosition = function (a, b, match) {
+      return (a.compareDocumentPosition(b) & match) !== 0;
+    };
+    var documentPositionContainedBy = function (a, b) {
+      return compareDocumentPosition(a, b, Node.DOCUMENT_POSITION_CONTAINED_BY);
+    };
+    var is = function (element, selector) {
+      var dom = element.dom;
+      if (dom.nodeType !== ELEMENT) {
+        return false;
+      } else {
+        var elem = dom;
+        if (elem.matches !== undefined) {
+          return elem.matches(selector);
+        } else if (elem.msMatchesSelector !== undefined) {
+          return elem.msMatchesSelector(selector);
+        } else if (elem.webkitMatchesSelector !== undefined) {
+          return elem.webkitMatchesSelector(selector);
+        } else if (elem.mozMatchesSelector !== undefined) {
+          return elem.mozMatchesSelector(selector);
+        } else {
+          throw new Error('Browser lacks native selectors');
+        }
+      }
+    };
+    var bypassSelector = function (dom) {
+      return dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT && dom.nodeType !== DOCUMENT_FRAGMENT || dom.childElementCount === 0;
+    };
+    var all$3 = function (selector, scope) {
+      var base = scope === undefined ? document : scope.dom;
+      return bypassSelector(base) ? [] : map$2(base.querySelectorAll(selector), SugarElement.fromDom);
+    };
+    var one = function (selector, scope) {
+      var base = scope === undefined ? document : scope.dom;
+      return bypassSelector(base) ? Optional.none() : Optional.from(base.querySelector(selector)).map(SugarElement.fromDom);
+    };
+    var eq = function (e1, e2) {
+      return e1.dom === e2.dom;
+    };
+    var regularContains = function (e1, e2) {
+      var d1 = e1.dom;
+      var d2 = e2.dom;
+      return d1 === d2 ? false : d1.contains(d2);
+    };
+    var ieContains = function (e1, e2) {
+      return documentPositionContainedBy(e1.dom, e2.dom);
+    };
+    var contains = function (e1, e2) {
+      return detect$1().browser.isIE() ? ieContains(e1, e2) : regularContains(e1, e2);
+    };
+    var owner$4 = function (element) {
+      return SugarElement.fromDom(element.dom.ownerDocument);
+    };
+    var documentOrOwner = function (dos) {
+      return isDocument(dos) ? dos : owner$4(dos);
+    };
+    var documentElement = function (element) {
+      return SugarElement.fromDom(documentOrOwner(element).dom.documentElement);
+    };
+    var defaultView = function (element) {
+      return SugarElement.fromDom(documentOrOwner(element).dom.defaultView);
+    };
+    var parent = function (element) {
+      return Optional.from(element.dom.parentNode).map(SugarElement.fromDom);
+    };
+    var parentNode = function (element) {
+      return parent(element);
+    };
+    var offsetParent = function (element) {
+      return Optional.from(element.dom.offsetParent).map(SugarElement.fromDom);
+    };
+    var nextSibling = function (element) {
+      return Optional.from(element.dom.nextSibling).map(SugarElement.fromDom);
+    };
+    var children = function (element) {
+      return map$2(element.dom.childNodes, SugarElement.fromDom);
+    };
+    var child$2 = function (element, index) {
+      var cs = element.dom.childNodes;
+      return Optional.from(cs[index]).map(SugarElement.fromDom);
+    };
+    var firstChild = function (element) {
+      return child$2(element, 0);
+    };
+    var spot = function (element, offset) {
+      return {
+        element: element,
+        offset: offset
+      };
+    };
+    var leaf = function (element, offset) {
+      var cs = children(element);
+      return cs.length > 0 && offset < cs.length ? spot(cs[offset], 0) : spot(element, offset);
+    };
+    var isShadowRoot = function (dos) {
+      return isDocumentFragment(dos) && isNonNullable(dos.dom.host);
+    };
+    var supported = isFunction(Element.prototype.attachShadow) && isFunction(Node.prototype.getRootNode);
+    var isSupported = constant$1(supported);
+    var getRootNode = supported ? function (e) {
+      return SugarElement.fromDom(e.dom.getRootNode());
+    } : documentOrOwner;
+    var getContentContainer = function (dos) {
+      return isShadowRoot(dos) ? dos : SugarElement.fromDom(documentOrOwner(dos).dom.body);
+    };
+    var isInShadowRoot = function (e) {
+      return getShadowRoot(e).isSome();
+    };
+    var getShadowRoot = function (e) {
+      var r = getRootNode(e);
+      return isShadowRoot(r) ? Optional.some(r) : Optional.none();
+    };
+    var getShadowHost = function (e) {
+      return SugarElement.fromDom(e.dom.host);
+    };
+    var getOriginalEventTarget = function (event) {
+      if (isSupported() && isNonNullable(event.target)) {
+        var el = SugarElement.fromDom(event.target);
+        if (isElement$2(el) && isOpenShadowHost(el)) {
+          if (event.composed && event.composedPath) {
+            var composedPath = event.composedPath();
+            if (composedPath) {
+              return head(composedPath);
+            }
+          }
+        }
+      }
+      return Optional.from(event.target);
+    };
+    var isOpenShadowHost = function (element) {
+      return isNonNullable(element.dom.shadowRoot);
+    };
+    var inBody = function (element) {
+      var dom = isText$1(element) ? element.dom.parentNode : element.dom;
+      if (dom === undefined || dom === null || dom.ownerDocument === null) {
+        return false;
+      }
+      var doc = dom.ownerDocument;
+      return getShadowRoot(SugarElement.fromDom(dom)).fold(function () {
+        return doc.body.contains(dom);
+      }, compose1(inBody, getShadowHost));
+    };
+    var body = function () {
+      return getBody(SugarElement.fromDom(document));
+    };
+    var getBody = function (doc) {
+      var b = doc.dom.body;
+      if (b === null || b === undefined) {
+        throw new Error('Body is not available yet');
+      }
+      return SugarElement.fromDom(b);
+    };
+    var rawSet = function (dom, key, value) {
+      if (isString(value) || isBoolean(value) || isNumber(value)) {
+        dom.setAttribute(key, value + '');
+      } else {
+        console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);
+        throw new Error('Attribute value was not simple');
+      }
+    };
+    var set$8 = function (element, key, value) {
+      rawSet(element.dom, key, value);
+    };
+    var setAll$1 = function (element, attrs) {
+      var dom = element.dom;
+      each(attrs, function (v, k) {
+        rawSet(dom, k, v);
+      });
+    };
+    var get$d = function (element, key) {
+      var v = element.dom.getAttribute(key);
+      return v === null ? undefined : v;
+    };
+    var getOpt = function (element, key) {
+      return Optional.from(get$d(element, key));
+    };
+    var has$1 = function (element, key) {
+      var dom = element.dom;
+      return dom && dom.hasAttribute ? dom.hasAttribute(key) : false;
+    };
+    var remove$7 = function (element, key) {
+      element.dom.removeAttribute(key);
+    };
+    var internalSet = function (dom, property, value) {
+      if (!isString(value)) {
+        console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom);
+        throw new Error('CSS value must be a string: ' + value);
+      }
+      if (isSupported$1(dom)) {
+        dom.style.setProperty(property, value);
+      }
+    };
+    var internalRemove = function (dom, property) {
+      if (isSupported$1(dom)) {
+        dom.style.removeProperty(property);
+      }
+    };
+    var set$7 = function (element, property, value) {
+      var dom = element.dom;
+      internalSet(dom, property, value);
+    };
+    var setAll = function (element, css) {
+      var dom = element.dom;
+      each(css, function (v, k) {
+        internalSet(dom, k, v);
+      });
+    };
+    var setOptions = function (element, css) {
+      var dom = element.dom;
+      each(css, function (v, k) {
+        v.fold(function () {
+          internalRemove(dom, k);
+        }, function (value) {
+          internalSet(dom, k, value);
+        });
+      });
+    };
+    var get$c = function (element, property) {
+      var dom = element.dom;
+      var styles = window.getComputedStyle(dom);
+      var r = styles.getPropertyValue(property);
+      return r === '' && !inBody(element) ? getUnsafeProperty(dom, property) : r;
+    };
+    var getUnsafeProperty = function (dom, property) {
+      return isSupported$1(dom) ? dom.style.getPropertyValue(property) : '';
+    };
+    var getRaw = function (element, property) {
+      var dom = element.dom;
+      var raw = getUnsafeProperty(dom, property);
+      return Optional.from(raw).filter(function (r) {
+        return r.length > 0;
+      });
+    };
+    var getAllRaw = function (element) {
+      var css = {};
+      var dom = element.dom;
+      if (isSupported$1(dom)) {
+        for (var i = 0; i < dom.style.length; i++) {
+          var ruleName = dom.style.item(i);
+          css[ruleName] = dom.style[ruleName];
+        }
+      }
+      return css;
+    };
+    var isValidValue = function (tag, property, value) {
+      var element = SugarElement.fromTag(tag);
+      set$7(element, property, value);
+      var style = getRaw(element, property);
+      return style.isSome();
+    };
+    var remove$6 = function (element, property) {
+      var dom = element.dom;
+      internalRemove(dom, property);
+      if (is$1(getOpt(element, 'style').map(trim$1), '')) {
+        remove$7(element, 'style');
+      }
+    };
+    var reflow = function (e) {
+      return e.dom.offsetWidth;
+    };
+    var Dimension = function (name, getOffset) {
+      var set = function (element, h) {
+        if (!isNumber(h) && !h.match(/^[0-9]+$/)) {
+          throw new Error(name + '.set accepts only positive integer values. Value was ' + h);
+        }
+        var dom = element.dom;
+        if (isSupported$1(dom)) {
+          dom.style[name] = h + 'px';
+        }
+      };
+      var get = function (element) {
+        var r = getOffset(element);
+        if (r <= 0 || r === null) {
+          var css = get$c(element, name);
+          return parseFloat(css) || 0;
+        }
+        return r;
+      };
+      var getOuter = get;
+      var aggregate = function (element, properties) {
+        return foldl(properties, function (acc, property) {
+          var val = get$c(element, property);
+          var value = val === undefined ? 0 : parseInt(val, 10);
+          return isNaN(value) ? acc : acc + value;
+        }, 0);
+      };
+      var max = function (element, value, properties) {
+        var cumulativeInclusions = aggregate(element, properties);
+        var absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0;
+        return absoluteMax;
+      };
+      return {
+        set: set,
+        get: get,
+        getOuter: getOuter,
+        aggregate: aggregate,
+        max: max
+      };
+    };
+    var api$3 = Dimension('height', function (element) {
+      var dom = element.dom;
+      return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight;
+    });
+    var get$b = function (element) {
+      return api$3.get(element);
+    };
+    var getOuter$2 = function (element) {
+      return api$3.getOuter(element);
+    };
+    var setMax$1 = function (element, value) {
+      var inclusions = [
+        'margin-top',
+        'border-top-width',
+        'padding-top',
+        'padding-bottom',
+        'border-bottom-width',
+        'margin-bottom'
+      ];
+      var absMax = api$3.max(element, value, inclusions);
+      set$7(element, 'max-height', absMax + 'px');
+    };
+    var r$1 = function (left, top) {
+      var translate = function (x, y) {
+        return r$1(left + x, top + y);
+      };
+      return {
+        left: left,
+        top: top,
+        translate: translate
+      };
+    };
+    var SugarPosition = r$1;
+    var boxPosition = function (dom) {
+      var box = dom.getBoundingClientRect();
+      return SugarPosition(box.left, box.top);
+    };
+    var firstDefinedOrZero = function (a, b) {
+      if (a !== undefined) {
+        return a;
+      } else {
+        return b !== undefined ? b : 0;
+      }
+    };
+    var absolute$3 = function (element) {
+      var doc = element.dom.ownerDocument;
+      var body = doc.body;
+      var win = doc.defaultView;
+      var html = doc.documentElement;
+      if (body === element.dom) {
+        return SugarPosition(body.offsetLeft, body.offsetTop);
+      }
+      var scrollTop = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageYOffset, html.scrollTop);
+      var scrollLeft = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageXOffset, html.scrollLeft);
+      var clientTop = firstDefinedOrZero(html.clientTop, body.clientTop);
+      var clientLeft = firstDefinedOrZero(html.clientLeft, body.clientLeft);
+      return viewport$1(element).translate(scrollLeft - clientLeft, scrollTop - clientTop);
+    };
+    var viewport$1 = function (element) {
+      var dom = element.dom;
+      var doc = dom.ownerDocument;
+      var body = doc.body;
+      if (body === dom) {
+        return SugarPosition(body.offsetLeft, body.offsetTop);
+      }
+      if (!inBody(element)) {
+        return SugarPosition(0, 0);
+      }
+      return boxPosition(dom);
+    };
+    var api$2 = Dimension('width', function (element) {
+      return element.dom.offsetWidth;
+    });
+    var set$6 = function (element, h) {
+      return api$2.set(element, h);
+    };
+    var get$a = function (element) {
+      return api$2.get(element);
+    };
+    var getOuter$1 = function (element) {
+      return api$2.getOuter(element);
+    };
+    var setMax = function (element, value) {
+      var inclusions = [
+        'margin-left',
+        'border-left-width',
+        'padding-left',
+        'padding-right',
+        'border-right-width',
+        'margin-right'
+      ];
+      var absMax = api$2.max(element, value, inclusions);
+      set$7(element, 'max-width', absMax + 'px');
+    };
+    var mkEvent = function (target, x, y, stop, prevent, kill, raw) {
+      return {
+        target: target,
+        x: x,
+        y: y,
+        stop: stop,
+        prevent: prevent,
+        kill: kill,
+        raw: raw
+      };
+    };
+    var fromRawEvent$1 = function (rawEvent) {
+      var target = SugarElement.fromDom(getOriginalEventTarget(rawEvent).getOr(rawEvent.target));
+      var stop = function () {
+        return rawEvent.stopPropagation();
+      };
+      var prevent = function () {
+        return rawEvent.preventDefault();
+      };
+      var kill = compose(prevent, stop);
+      return mkEvent(target, rawEvent.clientX, rawEvent.clientY, stop, prevent, kill, rawEvent);
+    };
+    var handle = function (filter, handler) {
+      return function (rawEvent) {
+        if (filter(rawEvent)) {
+          handler(fromRawEvent$1(rawEvent));
+        }
+      };
+    };
+    var binder = function (element, event, filter, handler, useCapture) {
+      var wrapped = handle(filter, handler);
+      element.dom.addEventListener(event, wrapped, useCapture);
+      return { unbind: curry(unbind, element, event, wrapped, useCapture) };
+    };
+    var bind$2 = function (element, event, filter, handler) {
+      return binder(element, event, filter, handler, false);
+    };
+    var capture$1 = function (element, event, filter, handler) {
+      return binder(element, event, filter, handler, true);
+    };
+    var unbind = function (element, event, handler, useCapture) {
+      element.dom.removeEventListener(event, handler, useCapture);
+    };
+    var before$2 = function (marker, element) {
+      var parent$1 = parent(marker);
+      parent$1.each(function (v) {
+        v.dom.insertBefore(element.dom, marker.dom);
+      });
+    };
+    var after$2 = function (marker, element) {
+      var sibling = nextSibling(marker);
+      sibling.fold(function () {
+        var parent$1 = parent(marker);
+        parent$1.each(function (v) {
+          append$2(v, element);
+        });
+      }, function (v) {
+        before$2(v, element);
+      });
+    };
+    var prepend$1 = function (parent, element) {
+      var firstChild$1 = firstChild(parent);
+      firstChild$1.fold(function () {
+        append$2(parent, element);
+      }, function (v) {
+        parent.dom.insertBefore(element.dom, v.dom);
+      });
+    };
+    var append$2 = function (parent, element) {
+      parent.dom.appendChild(element.dom);
+    };
+    var appendAt = function (parent, element, index) {
+      child$2(parent, index).fold(function () {
+        append$2(parent, element);
+      }, function (v) {
+        before$2(v, element);
+      });
+    };
+    var before$1 = function (marker, elements) {
+      each$1(elements, function (x) {
+        before$2(marker, x);
+      });
+    };
+    var append$1 = function (parent, elements) {
+      each$1(elements, function (x) {
+        append$2(parent, x);
+      });
+    };
+    var empty = function (element) {
+      element.dom.textContent = '';
+      each$1(children(element), function (rogue) {
+        remove$5(rogue);
+      });
+    };
+    var remove$5 = function (element) {
+      var dom = element.dom;
+      if (dom.parentNode !== null) {
+        dom.parentNode.removeChild(dom);
+      }
+    };
+    var unwrap = function (wrapper) {
+      var children$1 = children(wrapper);
+      if (children$1.length > 0) {
+        before$1(wrapper, children$1);
+      }
+      remove$5(wrapper);
+    };
+    var get$9 = function (_DOC) {
+      var doc = _DOC !== undefined ? _DOC.dom : document;
+      var x = doc.body.scrollLeft || doc.documentElement.scrollLeft;
+      var y = doc.body.scrollTop || doc.documentElement.scrollTop;
+      return SugarPosition(x, y);
+    };
+    var to = function (x, y, _DOC) {
+      var doc = _DOC !== undefined ? _DOC.dom : document;
+      var win = doc.defaultView;
+      if (win) {
+        win.scrollTo(x, y);
+      }
+    };
+    var get$8 = function (_win) {
+      var win = _win === undefined ? window : _win;
+      if (detect$1().browser.isFirefox()) {
+        return Optional.none();
+      } else {
+        return Optional.from(win['visualViewport']);
+      }
+    };
+    var bounds$1 = function (x, y, width, height) {
+      return {
+        x: x,
+        y: y,
+        width: width,
+        height: height,
+        right: x + width,
+        bottom: y + height
+      };
+    };
+    var getBounds$3 = function (_win) {
+      var win = _win === undefined ? window : _win;
+      var doc = win.document;
+      var scroll = get$9(SugarElement.fromDom(doc));
+      return get$8(win).fold(function () {
+        var html = win.document.documentElement;
+        var width = html.clientWidth;
+        var height = html.clientHeight;
+        return bounds$1(scroll.left, scroll.top, width, height);
+      }, function (visualViewport) {
+        return bounds$1(Math.max(visualViewport.pageLeft, scroll.left), Math.max(visualViewport.pageTop, scroll.top), visualViewport.width, visualViewport.height);
+      });
+    };
+    var walkUp = function (navigation, doc) {
+      var frame = navigation.view(doc);
+      return frame.fold(constant$1([]), function (f) {
+        var parent = navigation.owner(f);
+        var rest = walkUp(navigation, parent);
+        return [f].concat(rest);
+      });
+    };
+    var pathTo = function (element, navigation) {
+      var d = navigation.owner(element);
+      var paths = walkUp(navigation, d);
+      return Optional.some(paths);
+    };
+    var view = function (doc) {
+      var _a;
+      var element = doc.dom === document ? Optional.none() : Optional.from((_a = doc.dom.defaultView) === null || _a === void 0 ? void 0 : _a.frameElement);
+      return element.map(SugarElement.fromDom);
+    };
+    var owner$3 = function (element) {
+      return owner$4(element);
+    };
+    var Navigation = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        view: view,
+        owner: owner$3
+    });
+    var find$2 = function (element) {
+      var doc = SugarElement.fromDom(document);
+      var scroll = get$9(doc);
+      var path = pathTo(element, Navigation);
+      return path.fold(curry(absolute$3, element), function (frames) {
+        var offset = viewport$1(element);
+        var r = foldr(frames, function (b, a) {
+          var loc = viewport$1(a);
+          return {
+            left: b.left + loc.left,
+            top: b.top + loc.top
+          };
+        }, {
+          left: 0,
+          top: 0
+        });
+        return SugarPosition(r.left + offset.left + scroll.left, r.top + offset.top + scroll.top);
+      });
+    };
+    var pointed = function (point, width, height) {
+      return {
+        point: point,
+        width: width,
+        height: height
+      };
+    };
+    var rect = function (x, y, width, height) {
+      return {
+        x: x,
+        y: y,
+        width: width,
+        height: height
+      };
+    };
+    var bounds = function (x, y, width, height) {
+      return {
+        x: x,
+        y: y,
+        width: width,
+        height: height,
+        right: x + width,
+        bottom: y + height
+      };
+    };
+    var box$1 = function (element) {
+      var xy = absolute$3(element);
+      var w = getOuter$1(element);
+      var h = getOuter$2(element);
+      return bounds(xy.left, xy.top, w, h);
+    };
+    var absolute$2 = function (element) {
+      var position = find$2(element);
+      var width = getOuter$1(element);
+      var height = getOuter$2(element);
+      return bounds(position.left, position.top, width, height);
+    };
+    var win = function () {
+      return getBounds$3(window);
+    };
     var value$3 = function (o) {
       var or = function (_opt) {
         return value$3(o);
       };
       var orThunk = function (_f) {
         };
       } else {
         return res;
+      }
     };
-    var map$1 = function (res, f) {
+    var map = function (res, f) {
       if (res.stype === SimpleResultType.Value) {
         return {
           stype: SimpleResultType.Value,
           svalue: f(res.svalue)
         };
       } else {
         return res;
+      }
     };
-    var bind$2 = function (res, f) {
+    var bind$1 = function (res, f) {
       if (res.stype === SimpleResultType.Value) {
         return f(res.svalue);
       } else {
         return res;
+      }
       fromResult: fromResult$1,
       toResult: toResult$1,
       svalue: svalue,
       partition: partition$2,
       serror: serror,
-      bind: bind$2,
+      bind: bind$1,
       bindError: bindError,
-      map: map$1,
+      map: map,
       mapError: mapError,
       fold: fold$1
     };
     var field$2 = function (key, newKey, presence, prop) {
       case 'custom':
         return ifCustom(value.newKey, value.instantiator);
+      }
     };
-    var keys = Object.keys;
-    var hasOwnProperty = Object.hasOwnProperty;
-    var each = function (obj, f) {
-      var props = keys(obj);
-      for (var k = 0, len = props.length; k < len; k++) {
-        var i = props[k];
-        var x = obj[i];
-        f(x, i);
-      }
-    };
-    var map = function (obj, f) {
-      return tupleMap(obj, function (x, i) {
-        return {
-          k: i,
-          v: f(x, i)
-        };
-      });
-    };
-    var tupleMap = function (obj, f) {
-      var r = {};
-      each(obj, function (x, i) {
-        var tuple = f(x, i);
-        r[tuple.k] = tuple.v;
-      });
-      return r;
-    };
-    var objAcc = function (r) {
-      return function (x, i) {
-        r[i] = x;
-      };
-    };
-    var internalFilter = function (obj, pred, onTrue, onFalse) {
-      var r = {};
-      each(obj, function (x, i) {
-        (pred(x, i) ? onTrue : onFalse)(x, i);
-      });
-      return r;
-    };
-    var filter$1 = function (obj, pred) {
-      var t = {};
-      internalFilter(obj, pred, objAcc(t), noop);
-      return t;
-    };
-    var mapToArray = function (obj, f) {
-      var r = [];
-      each(obj, function (value, name) {
-        r.push(f(value, name));
-      });
-      return r;
-    };
-    var find$4 = function (obj, pred) {
-      var props = keys(obj);
-      for (var k = 0, len = props.length; k < len; k++) {
-        var i = props[k];
-        var x = obj[i];
-        if (pred(x, i, obj)) {
-          return Optional.some(x);
-        }
-      }
-      return Optional.none();
-    };
-    var values = function (obj) {
-      return mapToArray(obj, identity$1);
-    };
-    var get$e = function (obj, key) {
-      return has$2(obj, key) ? Optional.from(obj[key]) : Optional.none();
-    };
-    var has$2 = function (obj, key) {
-      return hasOwnProperty.call(obj, key);
-    };
-    var hasNonNullableKey = function (obj, key) {
-      return has$2(obj, key) && obj[key] !== undefined && obj[key] !== null;
-    };
     var shallow$1 = function (old, nu) {
       return nu;
     };
     var deep = function (old, nu) {
       var bothObjects = isObject(old) && isObject(nu);
       };
     };
     var deepMerge = baseMerge(deep);
     var merge$1 = baseMerge(shallow$1);
-    var cached = function (f) {
-      var called = false;
-      var r;
-      return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-        if (!called) {
-          called = true;
-          r = f.apply(null, args);
-        }
-        return r;
-      };
-    };
     var required$2 = function () {
       return {
         tag: 'required',
         process: {}
       };
       return map$2(es, function (e) {
         return 'Failed path: (' + e.path.join(' > ') + ')\n' + e.getErrorInfo();
       });
     };
-    var nu$d = function (path, getErrorInfo) {
+    var nu$a = function (path, getErrorInfo) {
       return SimpleResult.serror([{
           path: path,
           getErrorInfo: getErrorInfo
         }]);
     };
     var missingRequired = function (path, key, obj) {
-      return nu$d(path, function () {
+      return nu$a(path, function () {
         return 'Could not find valid *required* value for "' + key + '" in ' + formatObj(obj);
       });
     };
     var missingKey = function (path, key) {
-      return nu$d(path, function () {
+      return nu$a(path, function () {
         return 'Choice schema did not contain choice key: "' + key + '"';
       });
     };
     var missingBranch = function (path, branches, branch) {
-      return nu$d(path, function () {
+      return nu$a(path, function () {
         return 'The chosen schema: "' + branch + '" did not exist in branches: ' + formatObj(branches);
       });
     };
     var unsupportedFields = function (path, unsupported) {
-      return nu$d(path, function () {
+      return nu$a(path, function () {
         return 'There are unsupported fields: [' + unsupported.join(', ') + '] specified';
       });
     };
     var custom = function (path, err) {
-      return nu$d(path, constant$1(err));
+      return nu$a(path, constant$1(err));
     };
     var value$2 = function (validator) {
       var extract = function (path, val) {
         return SimpleResult.bindError(validator(val), function (err) {
     };
     var formatError = function (errInfo) {
       return 'Errors: \n' + formatErrors(errInfo.errors).join('\n') + '\n\nInput object: ' + formatObj(errInfo.input);
     };
     var choose$1 = function (key, branches) {
-      return choose$2(key, map(branches, objOf));
+      return choose$2(key, map$1(branches, objOf));
     };
     var thunkOf = function (desc, schema) {
       return thunk(desc, schema);
     };
         get: get,
         set: set
       };
     };
-    var fromHtml$2 = function (html, scope) {
-      var doc = scope || document;
-      var div = doc.createElement('div');
-      div.innerHTML = html;
-      if (!div.hasChildNodes() || div.childNodes.length > 1) {
-        console.error('HTML does not have a single root node', html);
-        throw new Error('HTML must have a single root node');
-      }
-      return fromDom(div.childNodes[0]);
-    };
-    var fromTag = function (tag, scope) {
-      var doc = scope || document;
-      var node = doc.createElement(tag);
-      return fromDom(node);
-    };
-    var fromText = function (text, scope) {
-      var doc = scope || document;
-      var node = doc.createTextNode(text);
-      return fromDom(node);
-    };
-    var fromDom = function (node) {
-      if (node === null || node === undefined) {
-        throw new Error('Node cannot be null or undefined');
-      }
-      return { dom: node };
-    };
-    var fromPoint = function (docElm, x, y) {
-      return Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom);
-    };
-    var SugarElement = {
-      fromHtml: fromHtml$2,
-      fromTag: fromTag,
-      fromText: fromText,
-      fromDom: fromDom,
-      fromPoint: fromPoint
-    };
-    var DeviceType = function (os, browser, userAgent, mediaMatch) {
-      var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
-      var isiPhone = os.isiOS() && !isiPad;
-      var isMobile = os.isiOS() || os.isAndroid();
-      var isTouch = isMobile || mediaMatch('(pointer:coarse)');
-      var isTablet = isiPad || !isiPhone && isMobile && mediaMatch('(min-device-width:768px)');
-      var isPhone = isiPhone || isMobile && !isTablet;
-      var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
-      var isDesktop = !isPhone && !isTablet && !iOSwebview;
-      return {
-        isiPad: constant$1(isiPad),
-        isiPhone: constant$1(isiPhone),
-        isTablet: constant$1(isTablet),
-        isPhone: constant$1(isPhone),
-        isTouch: constant$1(isTouch),
-        isAndroid: os.isAndroid,
-        isiOS: os.isiOS,
-        isWebView: constant$1(iOSwebview),
-        isDesktop: constant$1(isDesktop)
-      };
-    };
-    var firstMatch = function (regexes, s) {
-      for (var i = 0; i < regexes.length; i++) {
-        var x = regexes[i];
-        if (x.test(s)) {
-          return x;
-        }
-      }
-      return undefined;
-    };
-    var find$3 = function (regexes, agent) {
-      var r = firstMatch(regexes, agent);
-      if (!r) {
-        return {
-          major: 0,
-          minor: 0
-        };
-      }
-      var group = function (i) {
-        return Number(agent.replace(r, '$' + i));
-      };
-      return nu$c(group(1), group(2));
-    };
-    var detect$4 = function (versionRegexes, agent) {
-      var cleanedAgent = String(agent).toLowerCase();
-      if (versionRegexes.length === 0) {
-        return unknown$3();
-      }
-      return find$3(versionRegexes, cleanedAgent);
-    };
-    var unknown$3 = function () {
-      return nu$c(0, 0);
-    };
-    var nu$c = function (major, minor) {
-      return {
-        major: major,
-        minor: minor
-      };
-    };
-    var Version = {
-      nu: nu$c,
-      detect: detect$4,
-      unknown: unknown$3
-    };
-    var detectBrowser$1 = function (browsers, userAgentData) {
-      return findMap(userAgentData.brands, function (uaBrand) {
-        var lcBrand = uaBrand.brand.toLowerCase();
-        return find$5(browsers, function (browser) {
-          var _a;
-          return lcBrand === ((_a = browser.brand) === null || _a === void 0 ? void 0 : _a.toLowerCase());
-        }).map(function (info) {
-          return {
-            current: info.name,
-            version: Version.nu(parseInt(uaBrand.version, 10), 0)
-          };
-        });
-      });
-    };
-    var detect$3 = function (candidates, userAgent) {
-      var agent = String(userAgent).toLowerCase();
-      return find$5(candidates, function (candidate) {
-        return candidate.search(agent);
-      });
-    };
-    var detectBrowser = function (browsers, userAgent) {
-      return detect$3(browsers, userAgent).map(function (browser) {
-        var version = Version.detect(browser.versionRegexes, userAgent);
-        return {
-          current: browser.name,
-          version: version
-        };
-      });
-    };
-    var detectOs = function (oses, userAgent) {
-      return detect$3(oses, userAgent).map(function (os) {
-        var version = Version.detect(os.versionRegexes, userAgent);
-        return {
-          current: os.name,
-          version: version
-        };
-      });
-    };
-    var addToEnd = function (str, suffix) {
-      return str + suffix;
-    };
-    var removeFromStart = function (str, numChars) {
-      return str.substring(numChars);
-    };
-    var checkRange = function (str, substr, start) {
-      return substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
-    };
-    var removeLeading = function (str, prefix) {
-      return startsWith(str, prefix) ? removeFromStart(str, prefix.length) : str;
-    };
-    var ensureTrailing = function (str, suffix) {
-      return endsWith(str, suffix) ? str : addToEnd(str, suffix);
-    };
-    var contains$1 = function (str, substr) {
-      return str.indexOf(substr) !== -1;
-    };
-    var startsWith = function (str, prefix) {
-      return checkRange(str, prefix, 0);
-    };
-    var endsWith = function (str, suffix) {
-      return checkRange(str, suffix, str.length - suffix.length);
-    };
-    var blank = function (r) {
-      return function (s) {
-        return s.replace(r, '');
-      };
-    };
-    var trim$1 = blank(/^\s+|\s+$/g);
-    var isNotEmpty = function (s) {
-      return s.length > 0;
-    };
-    var isEmpty = function (s) {
-      return !isNotEmpty(s);
-    };
-    var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
-    var checkContains = function (target) {
-      return function (uastring) {
-        return contains$1(uastring, target);
-      };
-    };
-    var browsers = [
-      {
-        name: 'Edge',
-        versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
-        search: function (uastring) {
-          return contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit');
-        }
-      },
-      {
-        name: 'Chrome',
-        brand: 'Chromium',
-        versionRegexes: [
-          /.*?chrome\/([0-9]+)\.([0-9]+).*/,
-          normalVersionRegex
-        ],
-        search: function (uastring) {
-          return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe');
-        }
-      },
-      {
-        name: 'IE',
-        versionRegexes: [
-          /.*?msie\ ?([0-9]+)\.([0-9]+).*/,
-          /.*?rv:([0-9]+)\.([0-9]+).*/
-        ],
-        search: function (uastring) {
-          return contains$1(uastring, 'msie') || contains$1(uastring, 'trident');
-        }
-      },
-      {
-        name: 'Opera',
-        versionRegexes: [
-          normalVersionRegex,
-          /.*?opera\/([0-9]+)\.([0-9]+).*/
-        ],
-        search: checkContains('opera')
-      },
-      {
-        name: 'Firefox',
-        versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
-        search: checkContains('firefox')
-      },
-      {
-        name: 'Safari',
-        versionRegexes: [
-          normalVersionRegex,
-          /.*?cpu os ([0-9]+)_([0-9]+).*/
-        ],
-        search: function (uastring) {
-          return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit');
-        }
-      }
-    ];
-    var oses = [
-      {
-        name: 'Windows',
-        search: checkContains('win'),
-        versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
-      },
-      {
-        name: 'iOS',
-        search: function (uastring) {
-          return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad');
-        },
-        versionRegexes: [
-          /.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
-          /.*cpu os ([0-9]+)_([0-9]+).*/,
-          /.*cpu iphone os ([0-9]+)_([0-9]+).*/
-        ]
-      },
-      {
-        name: 'Android',
-        search: checkContains('android'),
-        versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
-      },
-      {
-        name: 'OSX',
-        search: checkContains('mac os x'),
-        versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]
-      },
-      {
-        name: 'Linux',
-        search: checkContains('linux'),
-        versionRegexes: []
-      },
-      {
-        name: 'Solaris',
-        search: checkContains('sunos'),
-        versionRegexes: []
-      },
-      {
-        name: 'FreeBSD',
-        search: checkContains('freebsd'),
-        versionRegexes: []
-      },
-      {
-        name: 'ChromeOS',
-        search: checkContains('cros'),
-        versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/]
-      }
-    ];
-    var PlatformInfo = {
-      browsers: constant$1(browsers),
-      oses: constant$1(oses)
-    };
-    var edge = 'Edge';
-    var chrome = 'Chrome';
-    var ie = 'IE';
-    var opera = 'Opera';
-    var firefox = 'Firefox';
-    var safari = 'Safari';
-    var unknown$2 = function () {
-      return nu$b({
-        current: undefined,
-        version: Version.unknown()
-      });
-    };
-    var nu$b = function (info) {
-      var current = info.current;
-      var version = info.version;
-      var isBrowser = function (name) {
-        return function () {
-          return current === name;
-        };
-      };
-      return {
-        current: current,
-        version: version,
-        isEdge: isBrowser(edge),
-        isChrome: isBrowser(chrome),
-        isIE: isBrowser(ie),
-        isOpera: isBrowser(opera),
-        isFirefox: isBrowser(firefox),
-        isSafari: isBrowser(safari)
-      };
-    };
-    var Browser = {
-      unknown: unknown$2,
-      nu: nu$b,
-      edge: constant$1(edge),
-      chrome: constant$1(chrome),
-      ie: constant$1(ie),
-      opera: constant$1(opera),
-      firefox: constant$1(firefox),
-      safari: constant$1(safari)
-    };
-    var windows = 'Windows';
-    var ios = 'iOS';
-    var android = 'Android';
-    var linux = 'Linux';
-    var osx = 'OSX';
-    var solaris = 'Solaris';
-    var freebsd = 'FreeBSD';
-    var chromeos = 'ChromeOS';
-    var unknown$1 = function () {
-      return nu$a({
-        current: undefined,
-        version: Version.unknown()
-      });
-    };
-    var nu$a = function (info) {
-      var current = info.current;
-      var version = info.version;
-      var isOS = function (name) {
-        return function () {
-          return current === name;
-        };
-      };
-      return {
-        current: current,
-        version: version,
-        isWindows: isOS(windows),
-        isiOS: isOS(ios),
-        isAndroid: isOS(android),
-        isOSX: isOS(osx),
-        isLinux: isOS(linux),
-        isSolaris: isOS(solaris),
-        isFreeBSD: isOS(freebsd),
-        isChromeOS: isOS(chromeos)
-      };
-    };
-    var OperatingSystem = {
-      unknown: unknown$1,
-      nu: nu$a,
-      windows: constant$1(windows),
-      ios: constant$1(ios),
-      android: constant$1(android),
-      linux: constant$1(linux),
-      osx: constant$1(osx),
-      solaris: constant$1(solaris),
-      freebsd: constant$1(freebsd),
-      chromeos: constant$1(chromeos)
-    };
-    var detect$2 = function (userAgent, userAgentDataOpt, mediaMatch) {
-      var browsers = PlatformInfo.browsers();
-      var oses = PlatformInfo.oses();
-      var browser = userAgentDataOpt.bind(function (userAgentData) {
-        return detectBrowser$1(browsers, userAgentData);
-      }).orThunk(function () {
-        return detectBrowser(browsers, userAgent);
-      }).fold(Browser.unknown, Browser.nu);
-      var os = detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
-      var deviceType = DeviceType(os, browser, userAgent, mediaMatch);
-      return {
-        browser: browser,
-        os: os,
-        deviceType: deviceType
-      };
-    };
-    var PlatformDetection = { detect: detect$2 };
-    var mediaMatch = function (query) {
-      return window.matchMedia(query).matches;
-    };
-    var platform = cached(function () {
-      return PlatformDetection.detect(navigator.userAgent, Optional.from(navigator.userAgentData), mediaMatch);
-    });
-    var detect$1 = function () {
-      return platform();
-    };
-    var compareDocumentPosition = function (a, b, match) {
-      return (a.compareDocumentPosition(b) & match) !== 0;
-    };
-    var documentPositionContainedBy = function (a, b) {
-      return compareDocumentPosition(a, b, Node.DOCUMENT_POSITION_CONTAINED_BY);
-    };
-    var DOCUMENT = 9;
-    var DOCUMENT_FRAGMENT = 11;
-    var ELEMENT = 1;
-    var TEXT = 3;
-    var is$1 = function (element, selector) {
-      var dom = element.dom;
-      if (dom.nodeType !== ELEMENT) {
-        return false;
-      } else {
-        var elem = dom;
-        if (elem.matches !== undefined) {
-          return elem.matches(selector);
-        } else if (elem.msMatchesSelector !== undefined) {
-          return elem.msMatchesSelector(selector);
-        } else if (elem.webkitMatchesSelector !== undefined) {
-          return elem.webkitMatchesSelector(selector);
-        } else if (elem.mozMatchesSelector !== undefined) {
-          return elem.mozMatchesSelector(selector);
-        } else {
-          throw new Error('Browser lacks native selectors');
-        }
-      }
-    };
-    var bypassSelector = function (dom) {
-      return dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT && dom.nodeType !== DOCUMENT_FRAGMENT || dom.childElementCount === 0;
-    };
-    var all$3 = function (selector, scope) {
-      var base = scope === undefined ? document : scope.dom;
-      return bypassSelector(base) ? [] : map$2(base.querySelectorAll(selector), SugarElement.fromDom);
-    };
-    var one = function (selector, scope) {
-      var base = scope === undefined ? document : scope.dom;
-      return bypassSelector(base) ? Optional.none() : Optional.from(base.querySelector(selector)).map(SugarElement.fromDom);
-    };
-    var eq = function (e1, e2) {
-      return e1.dom === e2.dom;
-    };
-    var regularContains = function (e1, e2) {
-      var d1 = e1.dom;
-      var d2 = e2.dom;
-      return d1 === d2 ? false : d1.contains(d2);
-    };
-    var ieContains = function (e1, e2) {
-      return documentPositionContainedBy(e1.dom, e2.dom);
-    };
-    var contains = function (e1, e2) {
-      return detect$1().browser.isIE() ? ieContains(e1, e2) : regularContains(e1, e2);
-    };
     var generate$7 = function (cases) {
       if (!isArray(cases)) {
         throw new Error('cases must be an array');
+      }
       if (cases.length === 0) {
     var runOnAttached = runOnSourceName(attachedToDom());
     var runOnDetached = runOnSourceName(detachedFromDom());
     var runOnInit = runOnSourceName(systemInit());
     var runOnExecute$1 = runOnName(execute$5());
-    typeof window !== 'undefined' ? window : Function('return this;')();
-    var name$2 = function (element) {
-      var r = element.dom.nodeName;
-      return r.toLowerCase();
-    };
-    var type = function (element) {
-      return element.dom.nodeType;
-    };
-    var isType = function (t) {
-      return function (element) {
-        return type(element) === t;
-      };
-    };
-    var isElement$2 = isType(ELEMENT);
-    var isText$1 = isType(TEXT);
-    var isDocument = isType(DOCUMENT);
-    var isDocumentFragment = isType(DOCUMENT_FRAGMENT);
-    var owner$4 = function (element) {
-      return SugarElement.fromDom(element.dom.ownerDocument);
-    };
-    var documentOrOwner = function (dos) {
-      return isDocument(dos) ? dos : owner$4(dos);
-    };
-    var documentElement = function (element) {
-      return SugarElement.fromDom(documentOrOwner(element).dom.documentElement);
-    };
-    var defaultView = function (element) {
-      return SugarElement.fromDom(documentOrOwner(element).dom.defaultView);
-    };
-    var parent = function (element) {
-      return Optional.from(element.dom.parentNode).map(SugarElement.fromDom);
-    };
-    var parentNode = function (element) {
-      return parent(element);
-    };
-    var offsetParent = function (element) {
-      return Optional.from(element.dom.offsetParent).map(SugarElement.fromDom);
-    };
-    var nextSibling = function (element) {
-      return Optional.from(element.dom.nextSibling).map(SugarElement.fromDom);
-    };
-    var children = function (element) {
-      return map$2(element.dom.childNodes, SugarElement.fromDom);
-    };
-    var child$2 = function (element, index) {
-      var cs = element.dom.childNodes;
-      return Optional.from(cs[index]).map(SugarElement.fromDom);
-    };
-    var firstChild = function (element) {
-      return child$2(element, 0);
-    };
-    var spot = function (element, offset) {
-      return {
-        element: element,
-        offset: offset
-      };
-    };
-    var leaf = function (element, offset) {
-      var cs = children(element);
-      return cs.length > 0 && offset < cs.length ? spot(cs[offset], 0) : spot(element, offset);
-    };
-    var isShadowRoot = function (dos) {
-      return isDocumentFragment(dos) && isNonNullable(dos.dom.host);
-    };
-    var supported = isFunction(Element.prototype.attachShadow) && isFunction(Node.prototype.getRootNode);
-    var isSupported$1 = constant$1(supported);
-    var getRootNode = supported ? function (e) {
-      return SugarElement.fromDom(e.dom.getRootNode());
-    } : documentOrOwner;
-    var getContentContainer = function (dos) {
-      return isShadowRoot(dos) ? dos : SugarElement.fromDom(documentOrOwner(dos).dom.body);
-    };
-    var isInShadowRoot = function (e) {
-      return getShadowRoot(e).isSome();
-    };
-    var getShadowRoot = function (e) {
-      var r = getRootNode(e);
-      return isShadowRoot(r) ? Optional.some(r) : Optional.none();
-    };
-    var getShadowHost = function (e) {
-      return SugarElement.fromDom(e.dom.host);
-    };
-    var getOriginalEventTarget = function (event) {
-      if (isSupported$1() && isNonNullable(event.target)) {
-        var el = SugarElement.fromDom(event.target);
-        if (isElement$2(el) && isOpenShadowHost(el)) {
-          if (event.composed && event.composedPath) {
-            var composedPath = event.composedPath();
-            if (composedPath) {
-              return head(composedPath);
-            }
-          }
-        }
-      }
-      return Optional.from(event.target);
-    };
-    var isOpenShadowHost = function (element) {
-      return isNonNullable(element.dom.shadowRoot);
-    };
-    var before$2 = function (marker, element) {
-      var parent$1 = parent(marker);
-      parent$1.each(function (v) {
-        v.dom.insertBefore(element.dom, marker.dom);
-      });
-    };
-    var after$2 = function (marker, element) {
-      var sibling = nextSibling(marker);
-      sibling.fold(function () {
-        var parent$1 = parent(marker);
-        parent$1.each(function (v) {
-          append$2(v, element);
-        });
-      }, function (v) {
-        before$2(v, element);
-      });
-    };
-    var prepend$1 = function (parent, element) {
-      var firstChild$1 = firstChild(parent);
-      firstChild$1.fold(function () {
-        append$2(parent, element);
-      }, function (v) {
-        parent.dom.insertBefore(element.dom, v.dom);
-      });
-    };
-    var append$2 = function (parent, element) {
-      parent.dom.appendChild(element.dom);
-    };
-    var appendAt = function (parent, element, index) {
-      child$2(parent, index).fold(function () {
-        append$2(parent, element);
-      }, function (v) {
-        before$2(v, element);
-      });
-    };
-    var before$1 = function (marker, elements) {
-      each$1(elements, function (x) {
-        before$2(marker, x);
-      });
-    };
-    var append$1 = function (parent, elements) {
-      each$1(elements, function (x) {
-        append$2(parent, x);
-      });
-    };
-    var empty = function (element) {
-      element.dom.textContent = '';
-      each$1(children(element), function (rogue) {
-        remove$7(rogue);
-      });
-    };
-    var remove$7 = function (element) {
-      var dom = element.dom;
-      if (dom.parentNode !== null) {
-        dom.parentNode.removeChild(dom);
-      }
-    };
-    var unwrap = function (wrapper) {
-      var children$1 = children(wrapper);
-      if (children$1.length > 0) {
-        before$1(wrapper, children$1);
-      }
-      remove$7(wrapper);
-    };
     var fromHtml$1 = function (html, scope) {
       var doc = scope || document;
       var div = doc.createElement('div');
       div.innerHTML = html;
       return children(SugarElement.fromDom(div));
     };
-    var get$d = function (element) {
+    var get$7 = function (element) {
       return element.dom.innerHTML;
     };
-    var set$8 = function (element, content) {
+    var set$5 = function (element, content) {
       var owner = owner$4(element);
       var docDom = owner.dom;
       var fragment = SugarElement.fromDom(docDom.createDocumentFragment());
       var contentElements = fromHtml$1(content, docDom);
       append$1(fragment, contentElements);
       empty(element);
       append$2(element, fragment);
     };
-    var getOuter$2 = function (element) {
+    var getOuter = function (element) {
       var container = SugarElement.fromTag('div');
       var clone = SugarElement.fromDom(element.dom.cloneNode(true));
       append$2(container, clone);
-      return get$d(container);
+      return get$7(container);
-    };
-    var rawSet = function (dom, key, value) {
-      if (isString(value) || isBoolean(value) || isNumber(value)) {
-        dom.setAttribute(key, value + '');
-      } else {
-        console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);
-        throw new Error('Attribute value was not simple');
-      }
-    };
-    var set$7 = function (element, key, value) {
-      rawSet(element.dom, key, value);
-    };
-    var setAll$1 = function (element, attrs) {
-      var dom = element.dom;
-      each(attrs, function (v, k) {
-        rawSet(dom, k, v);
-      });
-    };
-    var get$c = function (element, key) {
-      var v = element.dom.getAttribute(key);
-      return v === null ? undefined : v;
-    };
-    var getOpt = function (element, key) {
-      return Optional.from(get$c(element, key));
-    };
-    var has$1 = function (element, key) {
-      var dom = element.dom;
-      return dom && dom.hasAttribute ? dom.hasAttribute(key) : false;
-    };
-    var remove$6 = function (element, key) {
-      element.dom.removeAttribute(key);
     };
     var clone$1 = function (original, isDeep) {
       return SugarElement.fromDom(original.dom.cloneNode(isDeep));
     };
     var getHtml = function (element) {
       if (isShadowRoot(element)) {
         return '#shadow-root';
       } else {
         var clone = shallow(element);
-        return getOuter$2(clone);
+        return getOuter(clone);
+      }
     };
     var element = function (elem) {
       return getHtml(elem);
           rest[_i - 1] = arguments[_i];
+        }
         return f.apply(void 0, __spreadArray([
           component.getApis(),
           component
-        ], rest));
+        ], rest, false));
       }, f);
     };
     var NoState = {
       init: function () {
       var validated = asRaw('component.behaviours', objOf(schema), spec.behaviours).fold(function (errInfo) {
         throw new Error(formatError(errInfo) + '\nComplete spec:\n' + JSON.stringify(spec, null, 2));
       }, identity$1);
       return {
         list: all,
-        data: map(validated, function (optBlobThunk) {
+        data: map$1(validated, function (optBlobThunk) {
           var output = optBlobThunk.map(function (blob) {
             return {
               config: blob.config,
               state: blob.state.init(blob.config)
             };
     var toEvents = function (info) {
       return info.events;
     };
     var read = function (element, attr) {
-      var value = get$c(element, attr);
+      var value = get$d(element, attr);
       return value === undefined || value === '' ? [] : value.split(' ');
     };
     var add$4 = function (element, attr, id) {
       var old = read(element, attr);
       var nu = old.concat([id]);
-      set$7(element, attr, nu.join(' '));
+      set$8(element, attr, nu.join(' '));
       return true;
     };
-    var remove$5 = function (element, attr, id) {
+    var remove$4 = function (element, attr, id) {
       var nu = filter$2(read(element, attr), function (v) {
         return v !== id;
       });
       if (nu.length > 0) {
-        set$7(element, attr, nu.join(' '));
+        set$8(element, attr, nu.join(' '));
       } else {
-        remove$6(element, attr);
+        remove$7(element, attr);
+      }
       return false;
     };
     var supports = function (element) {
       return element.dom.classList !== undefined;
     };
-    var get$b = function (element) {
+    var get$6 = function (element) {
       return read(element, 'class');
     };
     var add$3 = function (element, clazz) {
       return add$4(element, 'class', clazz);
     };
-    var remove$4 = function (element, clazz) {
+    var remove$3 = function (element, clazz) {
-      return remove$5(element, 'class', clazz);
+      return remove$4(element, 'class', clazz);
     };
     var add$2 = function (element, clazz) {
       if (supports(element)) {
         element.dom.classList.add(clazz);
       } else {
         add$3(element, clazz);
+      }
     };
     var cleanClass = function (element) {
-      var classList = supports(element) ? element.dom.classList : get$b(element);
+      var classList = supports(element) ? element.dom.classList : get$6(element);
       if (classList.length === 0) {
-        remove$6(element, 'class');
+        remove$7(element, 'class');
+      }
     };
-    var remove$3 = function (element, clazz) {
+    var remove$2 = function (element, clazz) {
       if (supports(element)) {
         var classList = element.dom.classList;
         classList.remove(clazz);
       } else {
-        remove$4(element, clazz);
+        remove$3(element, clazz);
+      }
       cleanClass(element);
     };
     var has = function (element, clazz) {
       return supports(element) && element.dom.classList.contains(clazz);
     var add$1 = function (element, classes) {
       each$1(classes, function (x) {
         add$2(element, x);
       });
     };
-    var remove$2 = function (element, classes) {
+    var remove$1 = function (element, classes) {
       each$1(classes, function (x) {
-        remove$3(element, x);
+        remove$2(element, x);
       });
     };
     var hasAll = function (element, classes) {
       return forall(classes, function (clazz) {
         return has(element, clazz);
       });
     };
-    var is = function (lhs, rhs, comparator) {
-      if (comparator === void 0) {
-        comparator = tripleEquals;
-      }
-      return lhs.exists(function (left) {
-        return comparator(left, rhs);
-      });
-    };
-    var equals = function (lhs, rhs, comparator) {
-      if (comparator === void 0) {
-        comparator = tripleEquals;
-      }
-      return lift2(lhs, rhs, comparator).getOr(lhs.isNone() && rhs.isNone());
-    };
-    var cat = function (arr) {
-      var r = [];
-      var push = function (x) {
-        r.push(x);
-      };
-      for (var i = 0; i < arr.length; i++) {
-        arr[i].each(push);
-      }
-      return r;
-    };
-    var sequence = function (arr) {
-      var r = [];
-      for (var i = 0; i < arr.length; i++) {
-        var x = arr[i];
-        if (x.isSome()) {
-          r.push(x.getOrDie());
-        } else {
-          return Optional.none();
-        }
-      }
-      return Optional.some(r);
-    };
-    var lift2 = function (oa, ob, f) {
-      return oa.isSome() && ob.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie())) : Optional.none();
-    };
-    var lift3 = function (oa, ob, oc, f) {
-      return oa.isSome() && ob.isSome() && oc.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie(), oc.getOrDie())) : Optional.none();
-    };
-    var mapFrom = function (a, f) {
-      return a !== undefined && a !== null ? Optional.some(f(a)) : Optional.none();
-    };
-    var someIf = function (b, a) {
-      return b ? Optional.some(a) : Optional.none();
-    };
-    var isSupported = function (dom) {
-      return dom.style !== undefined && isFunction(dom.style.getPropertyValue);
-    };
-    var inBody = function (element) {
-      var dom = isText$1(element) ? element.dom.parentNode : element.dom;
-      if (dom === undefined || dom === null || dom.ownerDocument === null) {
-        return false;
-      }
-      var doc = dom.ownerDocument;
-      return getShadowRoot(SugarElement.fromDom(dom)).fold(function () {
-        return doc.body.contains(dom);
-      }, compose1(inBody, getShadowHost));
-    };
-    var body = function () {
-      return getBody(SugarElement.fromDom(document));
-    };
-    var getBody = function (doc) {
-      var b = doc.dom.body;
-      if (b === null || b === undefined) {
-        throw new Error('Body is not available yet');
-      }
-      return SugarElement.fromDom(b);
-    };
-    var internalSet = function (dom, property, value) {
-      if (!isString(value)) {
-        console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom);
-        throw new Error('CSS value must be a string: ' + value);
-      }
-      if (isSupported(dom)) {
-        dom.style.setProperty(property, value);
-      }
-    };
-    var internalRemove = function (dom, property) {
-      if (isSupported(dom)) {
-        dom.style.removeProperty(property);
-      }
-    };
-    var set$6 = function (element, property, value) {
-      var dom = element.dom;
-      internalSet(dom, property, value);
-    };
-    var setAll = function (element, css) {
-      var dom = element.dom;
-      each(css, function (v, k) {
-        internalSet(dom, k, v);
-      });
-    };
-    var setOptions = function (element, css) {
-      var dom = element.dom;
-      each(css, function (v, k) {
-        v.fold(function () {
-          internalRemove(dom, k);
-        }, function (value) {
-          internalSet(dom, k, value);
-        });
-      });
-    };
-    var get$a = function (element, property) {
-      var dom = element.dom;
-      var styles = window.getComputedStyle(dom);
-      var r = styles.getPropertyValue(property);
-      return r === '' && !inBody(element) ? getUnsafeProperty(dom, property) : r;
-    };
-    var getUnsafeProperty = function (dom, property) {
-      return isSupported(dom) ? dom.style.getPropertyValue(property) : '';
-    };
-    var getRaw = function (element, property) {
-      var dom = element.dom;
-      var raw = getUnsafeProperty(dom, property);
-      return Optional.from(raw).filter(function (r) {
-        return r.length > 0;
-      });
-    };
-    var getAllRaw = function (element) {
-      var css = {};
-      var dom = element.dom;
-      if (isSupported(dom)) {
-        for (var i = 0; i < dom.style.length; i++) {
-          var ruleName = dom.style.item(i);
-          css[ruleName] = dom.style[ruleName];
-        }
-      }
-      return css;
-    };
-    var isValidValue = function (tag, property, value) {
-      var element = SugarElement.fromTag(tag);
-      set$6(element, property, value);
-      var style = getRaw(element, property);
-      return style.isSome();
-    };
-    var remove$1 = function (element, property) {
-      var dom = element.dom;
-      internalRemove(dom, property);
-      if (is(getOpt(element, 'style').map(trim$1), '')) {
-        remove$6(element, 'style');
-      }
-    };
-    var reflow = function (e) {
-      return e.dom.offsetWidth;
-    };
-    var get$9 = function (element) {
+    var get$5 = function (element) {
       return element.dom.value;
     };
-    var set$5 = function (element, value) {
+    var set$4 = function (element, value) {
       if (value === undefined) {
         throw new Error('Value.set was undefined');
+      }
       element.dom.value = value;
     };
       var subject = SugarElement.fromTag(definition.tag);
       setAll$1(subject, definition.attributes);
       add$1(subject, definition.classes);
       setAll(subject, definition.styles);
       definition.innerHtml.each(function (html) {
-        return set$8(subject, html);
+        return set$5(subject, html);
       });
       var children = definition.domChildren;
       append$1(subject, children);
       definition.value.each(function (value) {
-        set$5(subject, value);
+        set$4(subject, value);
       });
       if (!definition.uid) {
         debugger;
+      }
       writeOnly(subject, definition.uid);
       return subject;
     };
     var getBehaviours$2 = function (spec) {
       var behaviours = get$e(spec, 'behaviours').getOr({});
-      var keys$1 = filter$2(keys(behaviours), function (k) {
+      return bind$3(keys(behaviours), function (name) {
-        return behaviours[k] !== undefined;
+        var behaviour = behaviours[name];
-      });
-      return map$2(keys$1, function (k) {
-        return behaviours[k].me;
+        return isNonNullable(behaviour) ? [behaviour.me] : [];
       });
     };
     var generateFrom = function (spec, all) {
       return generateFrom$1(spec, all);
     };
         return buildFromSpec(userSpecWithUid).getOrDie();
       });
     };
     var premade = premade$1;
-    var Dimension = function (name, getOffset) {
-      var set = function (element, h) {
-        if (!isNumber(h) && !h.match(/^[0-9]+$/)) {
-          throw new Error(name + '.set accepts only positive integer values. Value was ' + h);
-        }
-        var dom = element.dom;
-        if (isSupported(dom)) {
-          dom.style[name] = h + 'px';
-        }
-      };
-      var get = function (element) {
-        var r = getOffset(element);
-        if (r <= 0 || r === null) {
-          var css = get$a(element, name);
-          return parseFloat(css) || 0;
-        }
-        return r;
-      };
-      var getOuter = get;
-      var aggregate = function (element, properties) {
-        return foldl(properties, function (acc, property) {
-          var val = get$a(element, property);
-          var value = val === undefined ? 0 : parseInt(val, 10);
-          return isNaN(value) ? acc : acc + value;
-        }, 0);
-      };
-      var max = function (element, value, properties) {
-        var cumulativeInclusions = aggregate(element, properties);
-        var absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0;
-        return absoluteMax;
-      };
-      return {
-        set: set,
-        get: get,
-        getOuter: getOuter,
-        aggregate: aggregate,
-        max: max
-      };
-    };
-    var api$2 = Dimension('height', function (element) {
-      var dom = element.dom;
-      return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight;
-    });
-    var get$8 = function (element) {
-      return api$2.get(element);
-    };
-    var getOuter$1 = function (element) {
-      return api$2.getOuter(element);
-    };
-    var setMax$1 = function (element, value) {
-      var inclusions = [
-        'margin-top',
-        'border-top-width',
-        'padding-top',
-        'padding-bottom',
-        'border-bottom-width',
-        'margin-bottom'
-      ];
-      var absMax = api$2.max(element, value, inclusions);
-      set$6(element, 'max-height', absMax + 'px');
-    };
-    var r$1 = function (left, top) {
-      var translate = function (x, y) {
-        return r$1(left + x, top + y);
-      };
-      return {
-        left: left,
-        top: top,
-        translate: translate
-      };
-    };
-    var SugarPosition = r$1;
-    var boxPosition = function (dom) {
-      var box = dom.getBoundingClientRect();
-      return SugarPosition(box.left, box.top);
-    };
-    var firstDefinedOrZero = function (a, b) {
-      if (a !== undefined) {
-        return a;
-      } else {
-        return b !== undefined ? b : 0;
-      }
-    };
-    var absolute$3 = function (element) {
-      var doc = element.dom.ownerDocument;
-      var body = doc.body;
-      var win = doc.defaultView;
-      var html = doc.documentElement;
-      if (body === element.dom) {
-        return SugarPosition(body.offsetLeft, body.offsetTop);
-      }
-      var scrollTop = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageYOffset, html.scrollTop);
-      var scrollLeft = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageXOffset, html.scrollLeft);
-      var clientTop = firstDefinedOrZero(html.clientTop, body.clientTop);
-      var clientLeft = firstDefinedOrZero(html.clientLeft, body.clientLeft);
-      return viewport$1(element).translate(scrollLeft - clientLeft, scrollTop - clientTop);
-    };
-    var viewport$1 = function (element) {
-      var dom = element.dom;
-      var doc = dom.ownerDocument;
-      var body = doc.body;
-      if (body === dom) {
-        return SugarPosition(body.offsetLeft, body.offsetTop);
-      }
-      if (!inBody(element)) {
-        return SugarPosition(0, 0);
-      }
-      return boxPosition(dom);
-    };
-    var api$1 = Dimension('width', function (element) {
-      return element.dom.offsetWidth;
-    });
-    var set$4 = function (element, h) {
-      return api$1.set(element, h);
-    };
-    var get$7 = function (element) {
-      return api$1.get(element);
-    };
-    var getOuter = function (element) {
-      return api$1.getOuter(element);
-    };
-    var setMax = function (element, value) {
-      var inclusions = [
-        'margin-left',
-        'border-left-width',
-        'padding-left',
-        'padding-right',
-        'border-right-width',
-        'margin-right'
-      ];
-      var absMax = api$1.max(element, value, inclusions);
-      set$6(element, 'max-width', absMax + 'px');
-    };
-    var mkEvent = function (target, x, y, stop, prevent, kill, raw) {
-      return {
-        target: target,
-        x: x,
-        y: y,
-        stop: stop,
-        prevent: prevent,
-        kill: kill,
-        raw: raw
-      };
-    };
-    var fromRawEvent$1 = function (rawEvent) {
-      var target = SugarElement.fromDom(getOriginalEventTarget(rawEvent).getOr(rawEvent.target));
-      var stop = function () {
-        return rawEvent.stopPropagation();
-      };
-      var prevent = function () {
-        return rawEvent.preventDefault();
-      };
-      var kill = compose(prevent, stop);
-      return mkEvent(target, rawEvent.clientX, rawEvent.clientY, stop, prevent, kill, rawEvent);
-    };
-    var handle = function (filter, handler) {
-      return function (rawEvent) {
-        if (filter(rawEvent)) {
-          handler(fromRawEvent$1(rawEvent));
-        }
-      };
-    };
-    var binder = function (element, event, filter, handler, useCapture) {
-      var wrapped = handle(filter, handler);
-      element.dom.addEventListener(event, wrapped, useCapture);
-      return { unbind: curry(unbind, element, event, wrapped, useCapture) };
-    };
-    var bind$1 = function (element, event, filter, handler) {
-      return binder(element, event, filter, handler, false);
-    };
-    var capture$1 = function (element, event, filter, handler) {
-      return binder(element, event, filter, handler, true);
-    };
-    var unbind = function (element, event, handler, useCapture) {
-      element.dom.removeEventListener(event, handler, useCapture);
-    };
-    var get$6 = function (_DOC) {
-      var doc = _DOC !== undefined ? _DOC.dom : document;
-      var x = doc.body.scrollLeft || doc.documentElement.scrollLeft;
-      var y = doc.body.scrollTop || doc.documentElement.scrollTop;
-      return SugarPosition(x, y);
-    };
-    var to = function (x, y, _DOC) {
-      var doc = _DOC !== undefined ? _DOC.dom : document;
-      var win = doc.defaultView;
-      if (win) {
-        win.scrollTo(x, y);
-      }
-    };
-    var get$5 = function (_win) {
-      var win = _win === undefined ? window : _win;
-      return Optional.from(win['visualViewport']);
-    };
-    var bounds$1 = function (x, y, width, height) {
-      return {
-        x: x,
-        y: y,
-        width: width,
-        height: height,
-        right: x + width,
-        bottom: y + height
-      };
-    };
-    var getBounds$3 = function (_win) {
-      var win = _win === undefined ? window : _win;
-      var doc = win.document;
-      var scroll = get$6(SugarElement.fromDom(doc));
-      return get$5(win).fold(function () {
-        var html = win.document.documentElement;
-        var width = html.clientWidth;
-        var height = html.clientHeight;
-        return bounds$1(scroll.left, scroll.top, width, height);
-      }, function (visualViewport) {
-        return bounds$1(Math.max(visualViewport.pageLeft, scroll.left), Math.max(visualViewport.pageTop, scroll.top), visualViewport.width, visualViewport.height);
-      });
-    };
-    var walkUp = function (navigation, doc) {
-      var frame = navigation.view(doc);
-      return frame.fold(constant$1([]), function (f) {
-        var parent = navigation.owner(f);
-        var rest = walkUp(navigation, parent);
-        return [f].concat(rest);
-      });
-    };
-    var pathTo = function (element, navigation) {
-      var d = navigation.owner(element);
-      var paths = walkUp(navigation, d);
-      return Optional.some(paths);
-    };
-    var view = function (doc) {
-      var _a;
-      var element = doc.dom === document ? Optional.none() : Optional.from((_a = doc.dom.defaultView) === null || _a === void 0 ? void 0 : _a.frameElement);
-      return element.map(SugarElement.fromDom);
-    };
-    var owner$3 = function (element) {
-      return owner$4(element);
-    };
-    var Navigation = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        view: view,
-        owner: owner$3
-    });
-    var find$2 = function (element) {
-      var doc = SugarElement.fromDom(document);
-      var scroll = get$6(doc);
-      var path = pathTo(element, Navigation);
-      return path.fold(curry(absolute$3, element), function (frames) {
-        var offset = viewport$1(element);
-        var r = foldr(frames, function (b, a) {
-          var loc = viewport$1(a);
-          return {
-            left: b.left + loc.left,
-            top: b.top + loc.top
-          };
-        }, {
-          left: 0,
-          top: 0
-        });
-        return SugarPosition(r.left + offset.left + scroll.left, r.top + offset.top + scroll.top);
-      });
-    };
-    var pointed = function (point, width, height) {
-      return {
-        point: point,
-        width: width,
-        height: height
-      };
-    };
-    var rect = function (x, y, width, height) {
-      return {
-        x: x,
-        y: y,
-        width: width,
-        height: height
-      };
-    };
-    var bounds = function (x, y, width, height) {
-      return {
-        x: x,
-        y: y,
-        width: width,
-        height: height,
-        right: x + width,
-        bottom: y + height
-      };
-    };
-    var box$1 = function (element) {
-      var xy = absolute$3(element);
-      var w = getOuter(element);
-      var h = getOuter$1(element);
-      return bounds(xy.left, xy.top, w, h);
-    };
-    var absolute$2 = function (element) {
-      var position = find$2(element);
-      var width = getOuter(element);
-      var height = getOuter$1(element);
-      return bounds(position.left, position.top, width, height);
-    };
-    var win = function () {
-      return getBounds$3(window);
-    };
     function ClosestOrAncestor (is, ancestor, scope, a, isRoot) {
       if (is(scope, a)) {
         return Optional.some(scope);
       } else if (isFunction(isRoot) && isRoot(scope)) {
         return Optional.none();
       return closest$3(scope, predicate, isRoot).isSome();
     };
     var ancestor = function (scope, selector, isRoot) {
       return ancestor$1(scope, function (e) {
-        return is$1(e, selector);
+        return is(e, selector);
       }, isRoot);
     };
     var child = function (scope, selector) {
       return child$1(scope, function (e) {
-        return is$1(e, selector);
+        return is(e, selector);
       });
     };
     var descendant = function (scope, selector) {
       return one(selector, scope);
     };
     var closest$1 = function (scope, selector, isRoot) {
-      var is = function (element, selector) {
+      var is$1 = function (element, selector) {
-        return is$1(element, selector);
+        return is(element, selector);
       };
-      return ClosestOrAncestor(is, ancestor, scope, selector, isRoot);
+      return ClosestOrAncestor(is$1, ancestor, scope, selector, isRoot);
     };
     var find$1 = function (queryElem) {
       var dependent = closest$3(queryElem, function (elem) {
         if (!isElement$2(elem)) {
           return false;
+        }
-        var id = get$c(elem, 'id');
+        var id = get$d(elem, 'id');
         return id !== undefined && id.indexOf('aria-owns') > -1;
       });
       return dependent.bind(function (dep) {
-        var id = get$c(dep, 'id');
+        var id = get$d(dep, 'id');
         var dos = getRootNode(dep);
         return descendant(dos, '[aria-owns="' + id + '"]');
       });
     };
     var manager = function () {
       var ariaId = generate$6('aria-owns');
       var link = function (elem) {
-        set$7(elem, 'aria-owns', ariaId);
+        set$8(elem, 'aria-owns', ariaId);
       };
       var unlink = function (elem) {
-        remove$6(elem, 'aria-owns');
+        remove$7(elem, 'aria-owns');
       };
       return {
         id: ariaId,
         link: link,
         unlink: unlink
     };
     var doCreate = function (configSchema, schemaSchema, name, active, apis, extra, state) {
       var getConfig = function (info) {
         return hasNonNullableKey(info, name) ? info[name]() : Optional.none();
       };
-      var wrappedApis = map(apis, function (apiF, apiName) {
+      var wrappedApis = map$1(apis, function (apiF, apiName) {
         return wrapApi(name, apiF, apiName);
       });
-      var wrappedExtra = map(extra, function (extraF, extraName) {
+      var wrappedExtra = map$1(extra, function (extraF, extraName) {
         return markAsExtraApi(extraF, extraName);
       });
       var me = __assign(__assign(__assign({}, wrappedExtra), wrappedApis), {
         revoke: curry(revokeBehaviour, name),
         config: function (spec) {
       });
     };
     var toBox = function (origin, element) {
       var rel = curry(find$2, element);
       var position = origin.fold(rel, rel, function () {
-        var scroll = get$6();
+        var scroll = get$9();
         return find$2(element).translate(-scroll.left, -scroll.top);
       });
-      var width = getOuter(element);
+      var width = getOuter$1(element);
-      var height = getOuter$1(element);
+      var height = getOuter$2(element);
       return bounds(position.left, position.top, width, height);
     };
     var viewport = function (origin, getBounds) {
       return getBounds.fold(function () {
         return origin.fold(win, win, bounds);
       });
     };
     var translate$2 = function (origin, x, y) {
       var pos = SugarPosition(x, y);
       var removeScroll = function () {
-        var outerScroll = get$6();
+        var outerScroll = get$9();
         return pos.translate(-outerScroll.left, -outerScroll.top);
       };
       return origin.fold(constant$1(pos), constant$1(pos), removeScroll);
     };
     var cata$1 = function (subject, onNone, onRelative, onFixed) {
       return anchor(anchorBox, origin);
     };
     var placementAttribute = 'data-alloy-placement';
     var setPlacement$1 = function (element, placement) {
-      set$7(element, placementAttribute, placement);
+      set$8(element, placementAttribute, placement);
     };
     var getPlacement = function (element) {
       return getOpt(element, placementAttribute);
     };
     var reset$2 = function (element) {
-      return remove$6(element, placementAttribute);
+      return remove$7(element, placementAttribute);
     };
     var adt$8 = Adt.generate([
       { fit: ['reposition'] },
+      {
     var unbindable = function () {
       return singleton(function (s) {
         return s.unbind();
       });
     };
+    var api$1 = function () {
+      var subject = destroyable();
+      var run = function (f) {
+        return subject.get().each(f);
+      };
+      return __assign(__assign({}, subject), { run: run });
+    };
     var value$1 = function () {
       var subject = singleton(noop);
       var on = function (f) {
         return subject.get().each(f);
       };
       return __assign(__assign({}, subject), { on: on });
     };
     var filter = always;
     var bind = function (element, event, handler) {
-      return bind$1(element, event, filter, handler);
+      return bind$2(element, event, filter, handler);
     };
     var capture = function (element, event, handler) {
       return capture$1(element, event, filter, handler);
     };
     var fromRawEvent = fromRawEvent$1;
         return mode === 'all' ? true : placer[mode] !== decision[mode];
       });
     };
     var hasChanges = function (position, intermediate) {
       var round = function (value) {
-        return parseFloat(value).toPrecision(3);
+        return parseFloat(value).toFixed(3);
       };
       return find$4(intermediate, function (value, key) {
         var newValue = position[key].map(round);
         var val = value.map(round);
         return !equals(newValue, val);
       }).isSome();
     };
     var getTransitionDuration = function (element) {
       var get = function (name) {
-        var style = get$a(element, name);
+        var style = get$c(element, name);
         var times = isString(style) ? style.split(/\s*,\s*/) : [];
         return filter$2(times, isNotEmpty);
       };
       var parse = function (value) {
         if (isString(value) && /^[\d.]+/.test(value)) {
           transitionEnd.clear();
           transitionCancel.clear();
           var type = e === null || e === void 0 ? void 0 : e.raw.type;
           if (isNullable(type) || type === transitionend()) {
             clearTimeout(timer);
-            remove$6(element, timerAttr);
+            remove$7(element, timerAttr);
-            remove$2(element, transition.classes);
+            remove$1(element, transition.classes);
+          }
+        }
       };
       var transitionStarted = function () {
         transitionEnd.set(bind(element, transitionend(), transitionDone));
         transitionStarted();
+      }
       var duration = getTransitionDuration(element);
       requestAnimationFrame(function () {
         timer = setTimeout(transitionDone, duration + 17);
-        set$7(element, timerAttr, timer);
+        set$8(element, timerAttr, timer);
       });
     };
     var startTransitioning = function (element, transition) {
       add$1(element, transition.classes);
       getOpt(element, timerAttr).each(function (timerId) {
         clearTimeout(parseInt(timerId, 10));
-        remove$6(element, timerAttr);
+        remove$7(element, timerAttr);
       });
       setupTransitionListeners(element, transition);
     };
     var applyTransitionCss = function (element, origin, position, transition, decision, lastPlacement) {
       var shouldTransition = shouldApplyTransitionCss(transition, decision, lastPlacement);
       if (shouldTransition || isTransitioning$1(element, transition)) {
-        set$6(element, 'position', position.position);
+        set$7(element, 'position', position.position);
         var rect = toBox(origin, element);
         var intermediatePosition_1 = reposition(origin, __assign(__assign({}, decision), { rect: rect }));
         var intermediateCssOptions = mapToObject(properties, function (prop) {
           return intermediatePosition_1[prop];
         });
             startTransitioning(element, transition);
+          }
           reflow(element);
+        }
       } else {
-        remove$2(element, transition.classes);
+        remove$1(element, transition.classes);
+      }
     };
     var elementSize = function (p) {
       return {
-        width: getOuter(p),
+        width: getOuter$1(p),
-        height: getOuter$1(p)
+        height: getOuter$2(p)
       };
     };
     var layout = function (anchorBox, element, bubbles, options) {
-      remove$1(element, 'max-height');
+      remove$6(element, 'max-height');
-      remove$1(element, 'max-width');
+      remove$6(element, 'max-width');
       var elementBox = elementSize(element);
       return attempts(element, options.preference, anchorBox, elementBox, bubbles, options.bounds);
     };
     var setClasses = function (element, decision) {
       var classInfo = decision.classes;
-      remove$2(element, classInfo.off);
+      remove$1(element, classInfo.off);
       add$1(element, classInfo.on);
     };
     var setHeight = function (element, decision, options) {
       var maxHeightFunction = options.maxHeightFunction;
       maxHeightFunction(element, decision.maxHeight);
       return function (element) {
         return getDirection(element) === 'rtl' ? isRtl : isLtr;
       };
     };
     var getDirection = function (element) {
-      return get$a(element, 'direction') === 'rtl' ? 'rtl' : 'ltr';
+      return get$c(element, 'direction') === 'rtl' ? 'rtl' : 'ltr';
     };
     var AttributeValue;
     (function (AttributeValue) {
       AttributeValue['TopToBottom'] = 'toptobottom';
       AttributeValue['BottomToTop'] = 'bottomtotop';
     }(AttributeValue || (AttributeValue = {})));
     var Attribute = 'data-alloy-vertical-dir';
     var isBottomToTopDir = function (el) {
       return closest$2(el, function (current) {
-        return isElement$2(current) && get$c(current, 'data-alloy-vertical-dir') === AttributeValue.BottomToTop;
+        return isElement$2(current) && get$d(current, 'data-alloy-vertical-dir') === AttributeValue.BottomToTop;
       });
     };
     var schema$y = function () {
       return optionObjOf('layouts', [
       };
       return Optional.from(win.frameElement).map(SugarElement.fromDom).filter(hasSameOwner).map(absolute$3);
     };
     var getRootPoint = function (component, origin, anchorInfo) {
       var doc = owner$4(component.element);
-      var outerScroll = get$6(doc);
+      var outerScroll = get$9(doc);
       var offset = getOffset(component, origin, anchorInfo).getOr(outerScroll);
       return absolute$1(offset, outerScroll.left, outerScroll.top);
     };
     var getBox = function (left, top, width, height) {
       var selectionBox = getAnchorSelection(win, anchorInfo).bind(function (sel) {
         var optRect = getBounds$1(win, SimSelection.exactFromRange(sel)).orThunk(function () {
           var x = SugarElement.fromText(zeroWidth);
           before$2(sel.start, x);
           var rect = getFirstRect(win, SimSelection.exact(x, 0, x, 1));
-          remove$7(x);
+          remove$5(x);
           return rect;
         });
         return optRect.bind(function (rawRect) {
           return getBox(rawRect.left, rawRect.top, rawRect.width, rawRect.height);
         });
       var placeeDetail = asRawOrDie$1('placement.info', objOf(PlacementSchema), placementSpec);
       var anchorage = placeeDetail.anchor;
       var element = placee.element;
       var placeeState = posState.get(placee.uid);
       preserve$1(function () {
-        set$6(element, 'position', 'fixed');
+        set$7(element, 'position', 'fixed');
         var oldVisibility = getRaw(element, 'visibility');
-        set$6(element, 'visibility', 'hidden');
+        set$7(element, 'visibility', 'hidden');
         var origin = posConfig.useFixed() ? getFixedOrigin() : getRelativeOrigin(component);
         var placer = anchorage.placement;
         var getBounds = bounds.map(constant$1).or(posConfig.getBounds);
         placer(component, anchorage, origin).each(function (anchoring) {
           var doPlace = anchoring.placer.getOr(place);
           var newState = doPlace(component, origin, anchoring, getBounds, placee, placeeState, placeeDetail.transition);
           posState.set(placee.uid, newState);
         });
         oldVisibility.fold(function () {
-          remove$1(element, 'visibility');
+          remove$6(element, 'visibility');
         }, function (vis) {
-          set$6(element, 'visibility', vis);
+          set$7(element, 'visibility', vis);
         });
-        if (getRaw(element, 'left').isNone() && getRaw(element, 'top').isNone() && getRaw(element, 'right').isNone() && getRaw(element, 'bottom').isNone() && is(getRaw(element, 'position'), 'fixed')) {
+        if (getRaw(element, 'left').isNone() && getRaw(element, 'top').isNone() && getRaw(element, 'right').isNone() && getRaw(element, 'bottom').isNone() && is$1(getRaw(element, 'position'), 'fixed')) {
-          remove$1(element, 'position');
+          remove$6(element, 'position');
+        }
       }, element);
     };
     var getMode = function (component, pConfig, _pState) {
       return pConfig.useFixed() ? 'fixed' : 'absolute';
         'left',
         'right',
         'top',
         'bottom'
       ], function (prop) {
-        return remove$1(element, prop);
+        return remove$6(element, prop);
       });
       reset$2(element);
       posState.clear(placee.uid);
     };
     var attach$1 = function (parent, child) {
       append$2(parent.element, child.element);
     };
     var detachChildren$1 = function (component) {
       each$1(component.components(), function (childComp) {
-        return remove$7(childComp.element);
+        return remove$5(childComp.element);
       });
       empty(component.element);
       component.syncComponents();
     };
     var replaceChildren = function (component, newChildren) {
+      }
       parent.syncComponents();
     };
     var doDetach = function (component) {
       fireDetaching(component);
-      remove$7(component.element);
+      remove$5(component.element);
       component.getSystem().removeFromWorld(component);
     };
     var detach = function (component) {
       var parent$1 = parent(component.element).bind(function (p) {
         return component.getSystem().getByDom(p).toOptional();
     var detachSystem = function (guiSystem) {
       var children$1 = children(guiSystem.element);
       each$1(children$1, function (child) {
         guiSystem.getByDom(child).each(fireDetaching);
       });
-      remove$7(guiSystem.element);
+      remove$5(guiSystem.element);
     };
     var rebuild = function (sandbox, sConfig, sState, data) {
       sState.get().each(function (_data) {
         detachChildren(sandbox);
     var getState$2 = function (_sandbox, _sConfig, sState) {
       return sState.get();
     };
     var store = function (sandbox, cssKey, attr, newValue) {
       getRaw(sandbox.element, cssKey).fold(function () {
-        remove$6(sandbox.element, attr);
+        remove$7(sandbox.element, attr);
       }, function (v) {
-        set$7(sandbox.element, attr, v);
+        set$8(sandbox.element, attr, v);
       });
-      set$6(sandbox.element, cssKey, newValue);
+      set$7(sandbox.element, cssKey, newValue);
     };
     var restore = function (sandbox, cssKey, attr) {
       getOpt(sandbox.element, attr).fold(function () {
-        return remove$1(sandbox.element, cssKey);
+        return remove$6(sandbox.element, cssKey);
       }, function (oldValue) {
-        return set$6(sandbox.element, cssKey, oldValue);
+        return set$7(sandbox.element, cssKey, oldValue);
       });
     };
     var cloak = function (sandbox, sConfig, _sState) {
       var sink = sConfig.getAttachPoint(sandbox);
-      set$6(sandbox.element, 'position', Positioning.getMode(sink));
+      set$7(sandbox.element, 'position', Positioning.getMode(sink));
       store(sandbox, 'visibility', sConfig.cloakVisibilityAttr, 'hidden');
     };
     var hasPosition = function (element) {
       return exists([
         'top',
         return getRaw(element, pos).isSome();
       });
     };
     var decloak = function (sandbox, sConfig, _sState) {
       if (!hasPosition(sandbox.element)) {
-        remove$1(sandbox.element, 'position');
+        remove$6(sandbox.element, 'position');
+      }
       restore(sandbox, 'visibility', sConfig.cloakVisibilityAttr);
     };
     var SandboxApis = /*#__PURE__*/Object.freeze({
     };
     var get$2 = function (data) {
       return data.dump;
     };
     var augment = function (data, original) {
-      return __assign(__assign({}, data.dump), derive$1(original));
+      return __assign(__assign({}, derive$1(original)), data.dump);
     };
     var SketchBehaviours = {
       field: field,
       augment: augment,
       get: get$2
         used: used,
         replace: replace
       };
     };
     var substitutePlaces = function (owner, detail, components, placeholders) {
-      var ps = map(placeholders, function (ph, name) {
+      var ps = map$1(placeholders, function (ph, name) {
         return oneReplace(name, ph);
       });
       var outcome = substituteAll(owner, detail, components, ps);
       each(ps, function (p) {
         if (p.used() === false && p.required()) {
       });
       return r;
     };
     var getAllParts = function (component, detail) {
       var system = component.getSystem();
-      return map(detail.partUids, function (pUid, _k) {
+      return map$1(detail.partUids, function (pUid, _k) {
         return constant$1(system.getByUid(pUid));
       });
     };
     var getAllPartNames = function (detail) {
       return keys(detail.partUids);
     var single = function (rawConfig) {
       var config = asRawOrDie$1('Sketcher for ' + rawConfig.name, singleSchema, rawConfig);
       var sketch = function (spec) {
         return single$1(config.name, config.configFields, config.factory, spec);
       };
-      var apis = map(config.apis, makeApi);
+      var apis = map$1(config.apis, makeApi);
-      var extraApis = map(config.extraApis, function (f, k) {
+      var extraApis = map$1(config.extraApis, function (f, k) {
         return markAsExtraApi(f, k);
       });
       return __assign(__assign({
         name: config.name,
         configFields: config.configFields,
       var config = asRawOrDie$1('Sketcher for ' + rawConfig.name, compositeSchema, rawConfig);
       var sketch = function (spec) {
         return composite$1(config.name, config.configFields, config.partFields, config.factory, spec);
       };
       var parts = generate$3(config.name, config.partFields);
-      var apis = map(config.apis, makeApi);
+      var apis = map$1(config.apis, makeApi);
-      var extraApis = map(config.extraApis, function (f, k) {
+      var extraApis = map$1(config.extraApis, function (f, k) {
         return markAsExtraApi(f, k);
       });
       return __assign(__assign({
         name: config.name,
         partFields: config.partFields,
         parts: parts
       }, apis), extraApis);
     };
     var inside = function (target) {
-      return name$2(target) === 'input' && get$c(target, 'type') !== 'radio' || name$2(target) === 'textarea';
+      return name$2(target) === 'input' && get$d(target, 'type') !== 'radio' || name$2(target) === 'textarea';
     };
     var getCurrent = function (component, composeConfig, _composeState) {
       return composeConfig.find(component);
     };
     };
     var nativeIsDisabled = function (component) {
       return has$1(component.element, 'disabled');
     };
     var nativeDisable = function (component) {
-      set$7(component.element, 'disabled', 'disabled');
+      set$8(component.element, 'disabled', 'disabled');
     };
     var nativeEnable = function (component) {
-      remove$6(component.element, 'disabled');
+      remove$7(component.element, 'disabled');
     };
     var ariaIsDisabled = function (component) {
-      return get$c(component.element, 'aria-disabled') === 'true';
+      return get$d(component.element, 'aria-disabled') === 'true';
     };
     var ariaDisable = function (component) {
-      set$7(component.element, 'aria-disabled', 'true');
+      set$8(component.element, 'aria-disabled', 'true');
     };
     var ariaEnable = function (component) {
-      set$7(component.element, 'aria-disabled', 'false');
+      set$8(component.element, 'aria-disabled', 'false');
     };
     var disable$1 = function (component, disableConfig, _disableState) {
       disableConfig.disableClass.each(function (disableClass) {
         add$2(component.element, disableClass);
       });
       f(component);
       disableConfig.onDisabled(component);
     };
     var enable$1 = function (component, disableConfig, _disableState) {
       disableConfig.disableClass.each(function (disableClass) {
-        remove$3(component.element, disableClass);
+        remove$2(component.element, disableClass);
       });
       var f = hasNative(component, disableConfig) ? nativeEnable : ariaEnable;
       f(component);
       disableConfig.onEnabled(component);
     };
       var highlighted = descendants(component.element, '.' + hConfig.highlightClass);
       each$1(highlighted, function (h) {
         if (!exists(skip, function (skipComp) {
             return skipComp.element === h;
           })) {
-          remove$3(h, hConfig.highlightClass);
+          remove$2(h, hConfig.highlightClass);
           component.getSystem().getByDom(h).each(function (target) {
             hConfig.onDehighlight(component, target);
             emit(target, dehighlight$1());
           });
+        }
     var dehighlightAll = function (component, hConfig, hState) {
       return dehighlightAllExcept(component, hConfig, hState, []);
     };
     var dehighlight = function (component, hConfig, hState, target) {
       if (isHighlighted(component, hConfig, hState, target)) {
-        remove$3(target.element, hConfig.highlightClass);
+        remove$2(target.element, hConfig.highlightClass);
         hConfig.onDehighlight(component, target);
         emit(target, dehighlight$1());
+      }
     };
     var highlight = function (component, hConfig, hState, target) {
       ].concat([cyclicField]);
       var isVisible = function (tabbingConfig, element) {
         var target = tabbingConfig.visibilitySelector.bind(function (sel) {
           return closest$1(element, sel);
         }).getOr(element);
-        return get$8(target) > 0;
+        return get$b(target) > 0;
       };
       var findInitial = function (component, tabbingConfig) {
         var tabstops = descendants(component.element, tabbingConfig.selector);
         var visibles = filter$2(tabstops, function (elem) {
           return isVisible(tabbingConfig, elem);
       return Optional.some(focusIn$3);
     });
     var horizontal = function (container, selector, current, delta) {
       var isDisabledButton = function (candidate) {
-        return name$2(candidate) === 'button' && get$c(candidate, 'disabled') === 'disabled';
+        return name$2(candidate) === 'button' && get$d(candidate, 'disabled') === 'disabled';
       };
       var tryCycle = function (initial, index, candidates) {
         var newIndex = cycleBy(index, delta, 0, candidates.length - 1);
         if (newIndex === initial) {
           return Optional.none();
     var updateClass = function (component, toggleConfig, toggleState) {
       toggleConfig.toggleClass.each(function (toggleClass) {
         if (toggleState.get()) {
           add$2(component.element, toggleClass);
         } else {
-          remove$3(component.element, toggleClass);
+          remove$2(component.element, toggleClass);
+        }
       });
     };
     var toggle$2 = function (component, toggleConfig, toggleState) {
       set$1(component, toggleConfig, toggleState, !toggleState.get());
         exhibit: exhibit$3,
         events: events$b
     });
     var updatePressed = function (component, ariaInfo, status) {
-      set$7(component.element, 'aria-pressed', status);
+      set$8(component.element, 'aria-pressed', status);
       if (ariaInfo.syncWithExpanded) {
         updateExpanded(component, ariaInfo, status);
+      }
     };
     var updateSelected = function (component, ariaInfo, status) {
-      set$7(component.element, 'aria-selected', status);
+      set$8(component.element, 'aria-selected', status);
     };
     var updateChecked = function (component, ariaInfo, status) {
-      set$7(component.element, 'aria-checked', status);
+      set$8(component.element, 'aria-checked', status);
     };
     var updateExpanded = function (component, ariaInfo, status) {
-      set$7(component.element, 'aria-expanded', status);
+      set$8(component.element, 'aria-expanded', status);
     };
     var ToggleSchema = [
       defaulted('selected', false),
       option('toggleClass'),
             store: {
               mode: 'memory',
               initialValue: detail.data
+            }
           }),
-          config('item-type-events', __spreadArray(__spreadArray([], pointerEvents()), [
+          config('item-type-events', __spreadArray(__spreadArray([], pointerEvents(), true), [
             run$1(mouseover(), onHover),
             run$1(focusItem(), Focusing.focus)
-          ]))
+          ], false))
         ]),
         components: detail.components,
         eventOrder: detail.eventOrder
       };
     };
           items[item] = menu;
         });
       });
       var byItem = expansions;
       var byMenu = transpose$1(expansions);
-      var menuPaths = map(byMenu, function (_triggerItem, submenu) {
+      var menuPaths = map$1(byMenu, function (_triggerItem, submenu) {
         return [submenu].concat(trace(items, byItem, byMenu, submenu));
       });
-      return map(items, function (menu) {
+      return map$1(items, function (menu) {
         return get$e(menuPaths, menu).getOr([menu]);
       });
     };
     var init$c = function () {
         });
         return get$e(paths.get(), itemValue).bind(function (path) {
           var revPath = reverse(extraPath.concat(path));
           var triggers = bind$3(revPath, function (menuValue, menuIndex) {
             return getTriggerData(menuValue, getItemByValue, revPath.slice(0, menuIndex + 1)).fold(function () {
-              return is(primary.get(), menuValue) ? [] : [Optional.none()];
+              return is$1(primary.get(), menuValue) ? [] : [Optional.none()];
             }, function (data) {
               return [Optional.some(data)];
             });
           });
           return sequence(triggers);
     };
     var make$6 = function (detail, _rawUiSpec) {
       var submenuParentItems = value$1();
       var buildMenus = function (container, primaryName, menus) {
-        return map(menus, function (spec, name) {
+        return map$1(menus, function (spec, name) {
           var makeSketch = function () {
             return Menu.sketch(__assign(__assign({}, spec), {
               value: name,
               markers: detail.markers,
               fakeFocus: detail.fakeFocus,
             return getItemValue(c) === itemValue;
           });
         });
       };
       var toDirectory = function (_container) {
-        return map(detail.data.menus, function (data, _menuName) {
+        return map$1(detail.data.menus, function (data, _menuName) {
           return bind$3(data.items, function (item) {
             return item.type === 'separator' ? [] : [item.data.value];
           });
         });
       };
         }));
       };
       var closeOthers = function (container, state, path) {
         var others = getMenus(state, state.otherMenus(path));
         each$1(others, function (o) {
-          remove$2(o.element, [detail.markers.backgroundMenu]);
+          remove$1(o.element, [detail.markers.backgroundMenu]);
           if (!detail.stayInDom) {
             Replacing.remove(container, o);
+          }
         });
       };
       var getSubmenuParents = function (container) {
         return submenuParentItems.get().getOrThunk(function () {
           var r = {};
           var items = descendants(container.element, '.' + detail.markers.item);
           var parentItems = filter$2(items, function (i) {
-            return get$c(i, 'aria-haspopup') === 'true';
+            return get$d(i, 'aria-haspopup') === 'true';
           });
           each$1(parentItems, function (i) {
             container.getSystem().getByDom(i).each(function (itemComp) {
               var key = getItemValue(itemComp);
               r[key] = itemComp;
       };
       var updateAriaExpansions = function (container, path) {
         var parentItems = getSubmenuParents(container);
         each(parentItems, function (v, k) {
           var expanded = contains$2(path, k);
-          set$7(v.element, 'aria-expanded', expanded);
+          set$8(v.element, 'aria-expanded', expanded);
         });
       };
       var updateMenuPath = function (container, state, path) {
         return Optional.from(path[0]).bind(function (latestMenuName) {
           return state.lookupMenu(latestMenuName).bind(function (menuPrep) {
                 add$2(r.element, detail.markers.backgroundMenu);
               });
               if (!inBody(activeMenu.element)) {
                 Replacing.append(container, premade(activeMenu));
+              }
-              remove$2(activeMenu.element, [detail.markers.backgroundMenu]);
+              remove$1(activeMenu.element, [detail.markers.backgroundMenu]);
               setActiveMenu(container, activeMenu);
               closeOthers(container, state, path);
               return Optional.some(activeMenu);
+            }
           });
           setActiveMenu(container, primary);
         });
       };
       var extractMenuFromContainer = function (container) {
         return Optional.from(container.components()[0]).filter(function (comp) {
-          return get$c(comp.element, 'role') === 'menu';
+          return get$d(comp.element, 'role') === 'menu';
         });
       };
       var repositionMenus = function (container) {
         var maybeActivePrimary = layeredState.getPrimary().bind(function (primary) {
           return getActiveItem(container).bind(function (currentItem) {
     var flip$2 = function (anchor, element, bubbles, placee, bounds) {
       var layout = getPlacement(placee).map(lookupFlippedLayout).getOr(north);
       return layout(anchor, element, bubbles, placee, bounds);
     };
-    var global$g = tinymce.util.Tools.resolve('tinymce.util.Delay');
+    var global$f = tinymce.util.Tools.resolve('tinymce.util.Delay');
     var factory$l = function (detail) {
       var events = events$a(detail.action);
       var tag = detail.dom.tag;
       var lookupAttr = function (attr) {
         getOpt: getOpt,
         asSpec: asSpec
       };
     };
-    var global$f = tinymce.util.Tools.resolve('tinymce.util.I18n');
+    var global$e = tinymce.util.Tools.resolve('tinymce.util.I18n');
     var rtlTransform = {
       'indent': true,
       'outdent': true,
       'table-insert-column-after': true,
         return get$e(icons, defaultIconName).getOr('!not found!');
       };
     };
     var getIconName = function (name, icons) {
       var lcName = name.toLowerCase();
-      if (global$f.isRtl()) {
+      if (global$e.isRtl()) {
         var rtlName = ensureTrailing(lcName, '-rtl');
         return has$2(icons, rtlName) ? rtlName : lcName;
       } else {
         return lcName;
+      }
     var getOr = function (name, iconProvider, fallbackIcon) {
       var icons = iconProvider();
       return lookupIcon(name, icons).or(fallbackIcon).getOrThunk(defaultIcon(icons));
     };
     var needsRtlTransform = function (iconName) {
-      return global$f.isRtl() ? has$2(rtlTransform, iconName) : false;
+      return global$e.isRtl() ? has$2(rtlTransform, iconName) : false;
     };
     var addFocusableBehaviour = function () {
       return config('add-focusable', [runOnAttached(function (comp) {
           child(comp.element, 'svg').each(function (svg) {
-            return set$7(svg, 'focusable', 'false');
+            return set$8(svg, 'focusable', 'false');
           });
         })]);
     };
     var renderIcon$2 = function (spec, iconName, icons, fallbackIcon) {
       var _a, _b;
           tag: spec.tag,
           attributes: (_a = spec.attributes) !== null && _a !== void 0 ? _a : {},
           classes: spec.classes.concat(rtlIconClasses),
           innerHtml: iconHtml
         },
-        behaviours: derive$1(__spreadArray(__spreadArray([], (_b = spec.behaviours) !== null && _b !== void 0 ? _b : []), [addFocusableBehaviour()]))
+        behaviours: derive$1(__spreadArray(__spreadArray([], (_b = spec.behaviours) !== null && _b !== void 0 ? _b : [], true), [addFocusableBehaviour()], false))
       };
     };
     var render$3 = function (iconName, spec, iconProvider, fallbackIcon) {
       if (fallbackIcon === void 0) {
         fallbackIcon = Optional.none();
         case 'bc-tc':
         default:
           return south$2;
+        }
       };
-      var prePositionNotifications = function (notifications) {
+      var reposition = function (notifications) {
-        each$1(notifications, function (notification) {
-          return notification.moveTo(0, 0);
-        });
-      };
-      var positionNotifications = function (notifications) {
         if (notifications.length > 0) {
-          head(notifications).each(function (firstItem) {
-            return firstItem.moveRel(null, 'banner');
-          });
           each$1(notifications, function (notification, index) {
-            if (index > 0) {
+            if (index === 0) {
+              notification.moveRel(null, 'banner');
+            } else {
               notification.moveRel(notifications[index - 1].getEl(), 'bc-tc');
+            }
           });
+        }
       };
-      var reposition = function (notifications) {
-        prePositionNotifications(notifications);
-        positionNotifications(notifications);
-      };
       var open = function (settings, closeCallback) {
         var hideCloseButton = !settings.closeButton && settings.timeout && (settings.timeout > 0 || settings.timeout < 0);
         var close = function () {
           closeCallback();
           InlineView.hide(notificationWrapper);
           lazySink: sharedBackstage.getSink,
           fireDismissalEventInstead: {}
         }, sharedBackstage.header.isPositionedAtTop() ? {} : { fireRepositionEventInstead: {} })));
         uiMothership.add(notificationWrapper);
         if (settings.timeout > 0) {
-          global$g.setTimeout(function () {
+          global$f.setTimeout(function () {
             close();
           }, settings.timeout);
+        }
+        var getBounds = function () {
+          var contentArea = box$1(SugarElement.fromDom(editor.getContentAreaContainer()));
+          var win$1 = win();
+          var x = clamp$1(win$1.x, contentArea.x, contentArea.right);
+          var y = clamp$1(win$1.y, contentArea.y, contentArea.bottom);
+          var right = Math.max(contentArea.right, win$1.right);
+          var bottom = Math.max(contentArea.bottom, win$1.bottom);
+          return Optional.some(bounds(x, y, right - x, bottom - y));
+        };
         return {
           close: close,
           moveTo: function (x, y) {
             InlineView.showAt(notificationWrapper, premade(notification), {
               anchor: {
                 y: y
+              }
             });
           },
           moveRel: function (element, rel) {
+            var notificationSpec = premade(notification);
+            var anchorOverrides = { maxHeightFunction: expandable$1() };
-            if (rel !== 'banner') {
+            if (rel !== 'banner' && isNonNullable(element)) {
               var layoutDirection_1 = getLayoutDirection(rel);
               var nodeAnchor = {
                 type: 'node',
                 root: body(),
                 node: Optional.some(SugarElement.fromDom(element)),
+                overrides: anchorOverrides,
                 layouts: {
                   onRtl: function () {
                     return [layoutDirection_1];
                   },
                   onLtr: function () {
                     return [layoutDirection_1];
+                  }
+                }
               };
-              InlineView.showAt(notificationWrapper, premade(notification), { anchor: nodeAnchor });
+              InlineView.showWithinBounds(notificationWrapper, notificationSpec, { anchor: nodeAnchor }, getBounds);
             } else {
+              var anchor = __assign(__assign({}, sharedBackstage.anchors.banner()), { overrides: anchorOverrides });
-              InlineView.showAt(notificationWrapper, premade(notification), { anchor: sharedBackstage.anchors.banner() });
+              InlineView.showWithinBounds(notificationWrapper, notificationSpec, { anchor: anchor }, getBounds);
+            }
           },
           text: function (nuText) {
             Notification.updateText(notification, nuText);
           },
         cancel: cancel,
         throttle: throttle
       };
     };
-    var global$e = tinymce.util.Tools.resolve('tinymce.dom.TextSeeker');
+    var global$d = tinymce.util.Tools.resolve('tinymce.dom.TextSeeker');
     var isBoundary = function (dom, node) {
       return dom.isBlock(node) || contains$2([
         'BR',
         'IMG',
         'HR',
         'INPUT'
       ], node.nodeName) || dom.getContentEditable(node) === 'false';
     };
     var repeatLeft = function (dom, node, offset, process, rootNode) {
-      var search = global$e(dom, function (node) {
+      var search = global$d(dom, function (node) {
         return isBoundary(dom, node);
       });
       return Optional.from(search.backwards(node, offset, process, rootNode));
     };
+        }
       });
     };
     var AutocompleterEditorEvents = { setup: setup$e };
-    var global$d = tinymce.util.Tools.resolve('tinymce.util.Promise');
+    var global$c = tinymce.util.Tools.resolve('tinymce.util.Promise');
     var point = function (container, offset) {
       return {
         container: container,
         offset: offset
         })(context.range, startText, context.text);
       });
       if (autocompleters.length === 0) {
         return Optional.none();
+      }
-      var lookupData = global$d.all(map$2(autocompleters, function (ac) {
+      var lookupData = global$c.all(map$2(autocompleters, function (ac) {
         var fetchResult = ac.fetch(context.text, ac.maxResults, fetchOptions);
         return fetchResult.then(function (results) {
           return {
             matchText: context.text,
             items: results,
       return keys(all);
     };
     var register$b = function (editor) {
       var popups = editor.ui.registry.getAll().popups;
-      var dataset = map(popups, function (popup) {
+      var dataset = map$1(popups, function (popup) {
         return createAutocompleter(popup).fold(function (err) {
           throw new Error(formatError(err));
         }, identity$1);
       });
       var triggerChars = stringArray(mapToArray(dataset, function (v) {
     var escape = function (text) {
       return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     };
-    var global$c = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
+    var global$b = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
-    var global$b = tinymce.util.Tools.resolve('tinymce.EditorManager');
+    var global$a = tinymce.util.Tools.resolve('tinymce.EditorManager');
     var getSkinUrl = function (editor) {
       var skin = editor.getParam('skin');
       var skinUrl = editor.getParam('skin_url');
       if (skin !== false) {
         var skinName = skin ? skin : 'oxide';
         if (skinUrl) {
           skinUrl = editor.documentBaseURI.toAbsolute(skinUrl);
         } else {
-          skinUrl = global$b.baseURL + '/skins/ui/' + skinName;
+          skinUrl = global$a.baseURL + '/skins/ui/' + skinName;
+        }
+      }
       return skinUrl;
     };
     var isReadOnly = function (editor) {
     };
     var getHeightSetting = function (editor) {
       return editor.getParam('height', Math.max(editor.getElement().offsetHeight, 200));
     };
     var getWidthSetting = function (editor) {
-      return editor.getParam('width', global$c.DOM.getStyle(editor.getElement(), 'width'));
+      return editor.getParam('width', global$b.DOM.getStyle(editor.getElement(), 'width'));
     };
     var getMinWidthSetting = function (editor) {
       return Optional.from(editor.getParam('min_width')).filter(isNumber);
     };
     var getMinHeightSetting = function (editor) {
       return editor.getParam('draggable_modal', false, 'boolean');
     };
     var getMenus = function (editor) {
       var menu = editor.getParam('menu');
       if (menu) {
-        return map(menu, function (menu) {
+        return map$1(menu, function (menu) {
           return __assign(__assign({}, menu), { items: menu.items });
         });
       } else {
         return {};
+      }
         value: source.value,
         meta: __assign({ text: source.text.getOr('') }, source.meta)
       };
     };
-    var global$a = tinymce.util.Tools.resolve('tinymce.Env');
+    var global$9 = tinymce.util.Tools.resolve('tinymce.Env');
     var convertText = function (source) {
       var mac = {
         alt: '&#x2325;',
         ctrl: '&#x2303;',
       };
       var other = {
         meta: 'Ctrl',
         access: 'Shift+Alt'
       };
-      var replace = global$a.mac ? mac : other;
+      var replace = global$9.mac ? mac : other;
       var shortcut = source.split('+');
       var updated = map$2(shortcut, function (segment) {
         var search = segment.toLowerCase().trim();
         return has$2(replace, search) ? replace[search] : segment;
       });
-      return global$a.mac ? updated.join('') : updated.join('+');
+      return global$9.mac ? updated.join('') : updated.join('+');
     };
     var renderIcon$1 = function (name, icons, classes) {
       if (classes === void 0) {
         classes = [iconClass];
       return {
         dom: {
           tag: 'div',
           classes: [textClass]
         },
-        components: [text(global$f.translate(text$1))]
+        components: [text(global$e.translate(text$1))]
       };
     };
     var renderHtml = function (html, classes) {
       return {
         dom: {
         components: [{
             dom: {
               tag: style.tag,
               styles: style.styles
             },
-            components: [text(global$f.translate(text$1))]
+            components: [text(global$e.translate(text$1))]
           }]
       };
     };
     var renderShortcut = function (shortcut) {
       return {
           classes: [common]
         };
         if (itemValue === colorPickerCommand) {
           return __assign(__assign({}, baseDom), {
             tag: 'button',
-            classes: __spreadArray(__spreadArray([], baseDom.classes), ['tox-swatches__picker-btn']),
+            classes: __spreadArray(__spreadArray([], baseDom.classes, true), ['tox-swatches__picker-btn'], false),
             innerHtml: icon
           });
         } else if (itemValue === removeColorCommand) {
           return __assign(__assign({}, baseDom), {
-            classes: __spreadArray(__spreadArray([], baseDom.classes), ['tox-swatch--remove']),
+            classes: __spreadArray(__spreadArray([], baseDom.classes, true), ['tox-swatch--remove'], false),
             innerHtml: icon
           });
         } else {
           return __assign(__assign({}, baseDom), {
             attributes: __assign(__assign({}, baseDom.attributes), { 'data-mce-color': itemValue }),
         optComponents: []
       };
     };
     var renderItemDomStructure = function (ariaLabel) {
       var domTitle = ariaLabel.map(function (label) {
-        return { attributes: { title: global$f.translate(label) } };
+        return { attributes: { title: global$e.translate(label) } };
       }).getOr({});
       return __assign({
         tag: 'div',
         classes: [
           navClass,
+            }
           })];
       }).getOr([]);
     };
     var encodeText = function (text) {
-      return global$c.DOM.encode(text);
+      return global$b.DOM.encode(text);
     };
     var replaceText = function (text, matchText) {
-      var translated = global$f.translate(text);
+      var translated = global$e.translate(text);
       var encoded = encodeText(translated);
       if (matchText.length > 0) {
         var escapedMatchRegex = new RegExp(escape(matchText), 'gi');
         return encoded.replace(escapedMatchRegex, function (match) {
           return '<span class="tox-autocompleter-highlight">' + match + '</span>';
         var a = rgba[3];
         return fromRgba(rgbaColour(r, g, b, a));
       });
     };
-    var global$9 = tinymce.util.Tools.resolve('tinymce.util.LocalStorage');
+    var global$8 = tinymce.util.Tools.resolve('tinymce.util.LocalStorage');
     var storageName = 'tinymce-custom-colors';
     function ColorCache (max) {
       if (max === void 0) {
         max = 10;
+      }
-      var storageString = global$9.getItem(storageName);
+      var storageString = global$8.getItem(storageName);
       var localstorage = isString(storageString) ? JSON.parse(storageString) : [];
       var prune = function (list) {
         var diff = max - list.length;
         return diff < 0 ? list.slice(0, max) : list;
       };
         indexOf(cache, key).each(remove);
         cache.unshift(key);
         if (cache.length > max) {
           cache.pop();
+        }
-        global$9.setItem(storageName, JSON.stringify(cache));
+        global$8.setItem(storageName, JSON.stringify(cache));
       };
       var remove = function (idx) {
         cache.splice(idx, 1);
       };
       var state = function () {
     };
     var addColor = function (color) {
       colorCache.add(color);
     };
+    var fallbackColor = '#000000';
     var getCurrentColor = function (editor, format) {
       var color;
       editor.dom.getParents(editor.selection.getStart(), function (elm) {
         var value;
         if (value = elm.style[format === 'forecolor' ? 'color' : 'background-color']) {
           color = color ? color : value;
+        }
       });
-      return color;
+      return Optional.from(color);
     };
     var applyFormat = function (editor, format, value) {
       editor.undoManager.transact(function () {
         editor.focus();
         editor.formatter.apply(format, { value: value });
           colorOpt.each(function (color) {
             addColor(color);
             editor.execCommand('mceApplyTextcolor', format, color);
             onChoice(color);
           });
-        }, '#000000');
+        }, fallbackColor);
       } else if (value === 'remove') {
         onChoice('');
         editor.execCommand('mceRemoveTextcolor', format);
       } else {
         onChoice(value);
       editor.ui.registry.addSplitButton(name, {
         tooltip: tooltip,
         presets: 'color',
         icon: name === 'forecolor' ? 'text-color' : 'highlight-bg-color',
         select: function (value) {
-          var optCurrentRgb = Optional.from(getCurrentColor(editor, format));
+          var optCurrentRgb = getCurrentColor(editor, format);
           return optCurrentRgb.bind(function (currentRgb) {
             return fromString(currentRgb).map(function (rgba) {
               var currentHex = fromRgba(rgba).value;
               return contains$1(value.toLowerCase(), currentHex);
             });
           }).getOr(false);
         },
         columns: getColorCols$1(editor),
         fetch: getFetch$1(getColors$2(editor), hasCustomColors$1(editor)),
         onAction: function (_splitButtonApi) {
-          if (lastColor.get() !== null) {
-            applyColor(editor, format, lastColor.get(), noop);
+          applyColor(editor, format, lastColor.get(), noop);
-          }
         },
         onItemAction: function (_splitButtonApi, value) {
           applyColor(editor, format, value, function (newColor) {
             lastColor.set(newColor);
             fireTextColorChange(editor, {
               color: newColor
             });
           });
         },
         onSetup: function (splitButtonApi) {
-          if (lastColor.get() !== null) {
-            setIconColor(splitButtonApi, name, lastColor.get());
+          setIconColor(splitButtonApi, name, lastColor.get());
-          }
           var handler = function (e) {
             if (e.name === name) {
               setIconColor(splitButtonApi, e.name, e.color);
+            }
           };
         });
       };
     };
     var register$a = function (editor) {
       registerCommands(editor);
-      var lastForeColor = Cell(null);
+      var lastForeColor = Cell(fallbackColor);
-      var lastBackColor = Cell(null);
+      var lastBackColor = Cell(fallbackColor);
       registerTextColorButton(editor, 'forecolor', 'forecolor', 'Text color', lastForeColor);
       registerTextColorButton(editor, 'backcolor', 'hilitecolor', 'Background color', lastBackColor);
       registerTextColorMenuItem(editor, 'forecolor', 'forecolor', 'Text color');
       registerTextColorMenuItem(editor, 'backcolor', 'hilitecolor', 'Background color');
     };
       return bind$3(cells, function (cellRow) {
         return map$2(cellRow, premade);
       });
     };
     var makeLabelText = function (row, col) {
-      return text(col + 1 + 'x' + (row + 1));
+      return text(col + 'x' + row);
     };
     var renderInsertTableMenuItem = function (spec) {
       var numRows = 10;
       var numColumns = 10;
       var sizeLabelId = generate$6('size-label');
       var cells = makeCells(sizeLabelId, numRows, numColumns);
+      var emptyLabelText = makeLabelText(0, 0);
       var memLabel = record({
         dom: {
           tag: 'span',
           classes: ['tox-insert-table-picker__label'],
           attributes: { id: sizeLabelId }
         },
-        components: [text('0x0')],
+        components: [emptyLabelText],
         behaviours: derive$1([Replacing.config({})])
       });
       return {
         type: 'widget',
         data: { value: generate$6('widget-id') },
               classes: ['tox-insert-table-picker']
             },
             components: makeComponents(cells).concat(memLabel.asSpec()),
             behaviours: derive$1([
               config('insert-table-picker', [
+                runOnAttached(function (c) {
+                  Replacing.set(memLabel.get(c), [emptyLabelText]);
+                }),
                 runWithTarget(cellOverEvent, function (c, t, e) {
-                  var row = e.event.row;
-                  var col = e.event.col;
+                  var _a = e.event, row = _a.row, col = _a.col;
                   selectCells(cells, row, col, numRows, numColumns);
-                  Replacing.set(memLabel.get(c), [makeLabelText(row, col)]);
+                  Replacing.set(memLabel.get(c), [makeLabelText(row + 1, col + 1)]);
                 }),
                 runWithTarget(cellExecuteEvent, function (c, _, e) {
+                  var _a = e.event, row = _a.row, col = _a.col;
                   spec.onAction({
-                    numRows: e.event.row + 1,
+                    numRows: row + 1,
-                    numColumns: e.event.col + 1
+                    numColumns: col + 1
                   });
                   emit(c, sandboxClose());
                 })
               ]),
               Keying.config({
       ], name$2(event.target)) && !closest(event.target, '[contenteditable="true"]');
     };
     var isFirefox = function () {
       return detect$1().browser.isFirefox();
     };
-    var settingsSchema = objOfOnly([
-      requiredFunction('triggerEvent'),
-      defaulted('stopBackspace', true)
-    ]);
     var bindFocus = function (container, handler) {
       if (isFirefox()) {
         return capture(container, 'focus', handler);
       } else {
         return bind(container, 'focusin', handler);
       } else {
         return bind(container, 'focusout', handler);
+      }
     };
     var setup$d = function (container, rawSettings) {
-      var settings = asRawOrDie$1('Getting GUI events settings', settingsSchema, rawSettings);
+      var settings = __assign({ stopBackspace: true }, rawSettings);
       var pointerEvents = [
         'touchstart',
         'touchmove',
         'touchend',
         'touchcancel',
       });
       var onKeydown = bind(container, 'keydown', function (event) {
         var stopped = settings.triggerEvent('keydown', event);
         if (stopped) {
           event.kill();
-        } else if (settings.stopBackspace === true && isDangerous(event)) {
+        } else if (settings.stopBackspace && isDangerous(event)) {
           event.prevent();
+        }
       });
       var onFocusIn = bindFocus(container, function (event) {
         var stopped = settings.triggerEvent('focusin', event);
           handlers[id] = curryArgs(v, extraArgs);
           registry[k] = handlers;
         });
       };
       var findHandler = function (handlers, elem) {
-        return read$1(elem).fold(function () {
+        return read$1(elem).bind(function (id) {
-          return Optional.none();
-        }, function (id) {
-          return handlers.bind(function (h) {
-            return get$e(h, id);
+          return get$e(handlers, id);
-          }).map(function (descHandler) {
+        }).map(function (descHandler) {
-            return eventHandler(elem, descHandler);
+          return eventHandler(elem, descHandler);
-          });
+        });
-        });
       };
       var filterByType = function (type) {
         return get$e(registry, type).map(function (handlers) {
           return mapToArray(handlers, function (f, id) {
             return broadcastHandler(id, f);
           });
         }).getOr([]);
       };
       var find = function (isAboveRoot, type, target) {
-        var handlers = get$e(registry, type);
+        return get$e(registry, type).bind(function (handlers) {
-        return closest$4(target, function (elem) {
+          return closest$4(target, function (elem) {
-          return findHandler(handlers, elem);
+            return findHandler(handlers, elem);
-        }, isAboveRoot);
+          }, isAboveRoot);
+        });
       };
       var unregisterId = function (id) {
         each(registry, function (handlersById, _eventName) {
           if (has$2(handlersById, id)) {
             delete handlersById[id];
       var remove = function (component) {
         detach(component);
       };
       var destroy = function () {
         domEvents.unbind();
-        remove$7(root.element);
+        remove$5(root.element);
       };
       var broadcastData = function (data) {
         var receivers = registry.filter(receive());
         each$1(receivers, function (receiver) {
           var descHandler = receiver.descHandler;
             'aria-descriptor'
           ]);
           ps.field().each(function (field) {
             var id = generate$6(detail.prefix);
             ps.label().each(function (label) {
-              set$7(label.element, 'for', id);
+              set$8(label.element, 'for', id);
-              set$7(field.element, 'id', id);
+              set$8(field.element, 'id', id);
             });
             ps['aria-descriptor']().each(function (descriptor) {
               var descriptorId = generate$6(detail.prefix);
-              set$7(descriptor.element, 'id', descriptorId);
+              set$8(descriptor.element, 'id', descriptorId);
-              set$7(field.element, 'aria-describedby', descriptorId);
+              set$8(field.element, 'aria-describedby', descriptorId);
             });
           });
         })]);
       var apis = {
         getField: function (container) {
       fields: TabstopSchema,
       name: 'tabstopping',
       active: ActiveTabstopping
     });
-    var global$8 = tinymce.util.Tools.resolve('tinymce.html.Entities');
+    var global$7 = tinymce.util.Tools.resolve('tinymce.html.Entities');
     var renderFormFieldWith = function (pLabel, pField, extraClasses, extraBehaviours) {
       var spec = renderFormFieldSpecWith(pLabel, pField, extraClasses, extraBehaviours);
       return FormField.sketch(spec);
     };
         return renderLabel$2(label, providersBackstage);
       });
       var runOnItem = function (f) {
         return function (comp, se) {
           closest$1(se.event.target, '[data-collection-item-value]').each(function (target) {
-            f(comp, se, target, get$c(target, 'data-collection-item-value'));
+            f(comp, se, target, get$d(target, 'data-collection-item-value'));
           });
         };
       };
       var setContents = function (comp, items) {
         var htmlLines = map$2(items, function (item) {
-          var itemText = global$f.translate(item.text);
+          var itemText = global$e.translate(item.text);
           var textContent = spec.columns === 1 ? '<div class="tox-collection__item-label">' + itemText + '</div>' : '';
           var iconContent = '<div class="tox-collection__item-icon">' + item.icon + '</div>';
           var mapItemName = {
             '_': ' ',
             ' - ': ' ',
           };
           var ariaLabel = itemText.replace(/\_| \- |\-/g, function (match) {
             return mapItemName[match];
           });
           var disabledClass = providersBackstage.isDisabled() ? ' tox-collection__item--state-disabled' : '';
-          return '<div class="tox-collection__item' + disabledClass + '" tabindex="-1" data-collection-item-value="' + global$8.encodeAllRaw(item.value) + '" title="' + ariaLabel + '" aria-label="' + ariaLabel + '">' + iconContent + textContent + '</div>';
+          return '<div class="tox-collection__item' + disabledClass + '" tabindex="-1" data-collection-item-value="' + global$7.encodeAllRaw(item.value) + '" title="' + ariaLabel + '" aria-label="' + ariaLabel + '">' + iconContent + textContent + '</div>';
         });
         var chunks = spec.columns !== 'auto' && spec.columns > 1 ? chunk$1(htmlLines, spec.columns) : [htmlLines];
         var html = map$2(chunks, function (ch) {
           return '<div class="tox-collection__group">' + ch.join('') + '</div>';
         });
-        set$8(comp.element, html.join(''));
+        set$5(comp.element, html.join(''));
       };
       var onClick = runOnItem(function (comp, se, tgt, itemValue) {
         se.stop();
         if (!providersBackstage.isDisabled()) {
           emitWith(comp, formActionEvent, {
         })),
         run$1(click(), onClick),
         run$1(tap(), onClick),
         run$1(focusin(), runOnItem(function (comp, se, tgt) {
           descendant(comp.element, '.' + activeClass).each(function (currentActive) {
-            remove$3(currentActive, activeClass);
+            remove$2(currentActive, activeClass);
           });
           add$2(tgt, activeClass);
         })),
         run$1(focusout(), runOnItem(function (comp) {
           descendant(comp.element, '.' + activeClass).each(function (currentActive) {
-            remove$3(currentActive, activeClass);
+            remove$2(currentActive, activeClass);
           });
         })),
         runOnExecute$1(runOnItem(function (comp, se, tgt, itemValue) {
           emitWith(comp, formActionEvent, {
             name: spec.name,
           Disabling.config({
             disabled: providersBackstage.isDisabled,
             onDisabled: function (comp) {
               iterCollectionItems(comp, function (childElm) {
                 add$2(childElm, 'tox-collection__item--state-disabled');
-                set$7(childElm, 'aria-disabled', true);
+                set$8(childElm, 'aria-disabled', true);
               });
             },
             onEnabled: function (comp) {
               iterCollectionItems(comp, function (childElm) {
-                remove$3(childElm, 'tox-collection__item--state-disabled');
+                remove$2(childElm, 'tox-collection__item--state-disabled');
-                remove$6(childElm, 'aria-disabled');
+                remove$7(childElm, 'aria-disabled');
               });
+            }
           }),
           receivingConfig(),
           Replacing.config({}),
     ]);
     var focusBehaviours = function (detail) {
       return derive$1([Focusing.config({
           onFocus: !detail.selectOnFocus ? noop : function (component) {
             var input = component.element;
-            var value = get$9(input);
+            var value = get$5(input);
             input.dom.setSelectionRange(0, value.length);
+          }
         })]);
     };
     var behaviours = function (detail) {
       return __assign(__assign({}, focusBehaviours(detail)), augment(detail.inputBehaviours, [Representing.config({
           store: __assign(__assign({ mode: 'manual' }, detail.data.map(function (data) {
             return { initialValue: data };
           }).getOr({})), {
             getValue: function (input) {
-              return get$9(input.element);
+              return get$5(input.element);
             },
             setValue: function (input, data) {
-              var current = get$9(input.element);
+              var current = get$5(input.element);
               if (current !== data) {
-                set$5(input.element, data);
+                set$4(input.element, data);
+              }
+            }
           }),
           onSetValue: detail.onSetValue
         })]));
       factory: factory$h
     });
     var exports$1 = {}, module = { exports: exports$1 };
     (function (define, exports, module, require) {
-      (function (f) {
+      (function (global, factory) {
-        if (typeof exports === 'object' && typeof module !== 'undefined') {
+        typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.EphoxContactWrapper = factory());
-          module.exports = f();
-        } else if (typeof define === 'function' && define.amd) {
-          define([], f);
-        } else {
-          var g;
-          if (typeof window !== 'undefined') {
-            g = window;
-          } else if (typeof global !== 'undefined') {
-            g = global;
-          } else if (typeof self !== 'undefined') {
-            g = self;
-          } else {
-            g = this;
-          }
-          g.EphoxContactWrapper = f();
-        }
-      }(function () {
+      }(this, function () {
-        return function () {
-          function r(e, n, t) {
-            function o(i, f) {
-              if (!n[i]) {
-                if (!e[i]) {
-                  var c = 'function' == typeof require && require;
-                  if (!f && c)
-                    return c(i, !0);
-                  if (u)
-                    return u(i, !0);
-                  var a = new Error('Cannot find module \'' + i + '\'');
+        var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-                  throw a.code = 'MODULE_NOT_FOUND', a;
-                }
-                var p = n[i] = { exports: {} };
+        var promise = { exports: {} };
-                e[i][0].call(p.exports, function (r) {
-                  var n = e[i][1][r];
-                  return o(n || r);
-                }, p, p.exports, r, e, n, t);
-              }
-              return n[i].exports;
-            }
-            for (var u = 'function' == typeof require && require, i = 0; i < t.length; i++)
-              o(t[i]);
-            return o;
-          }
-          return r;
-        }()({
-: [
-            function (require, module, exports) {
-              var process = module.exports = {};
-              var cachedSetTimeout;
-              var cachedClearTimeout;
-              function defaultSetTimout() {
-                throw new Error('setTimeout has not been defined');
-              }
-              function defaultClearTimeout() {
-                throw new Error('clearTimeout has not been defined');
-              }
-              (function () {
-                try {
-                  if (typeof setTimeout === 'function') {
-                    cachedSetTimeout = setTimeout;
-                  } else {
-                    cachedSetTimeout = defaultSetTimout;
-                  }
-                } catch (e) {
-                  cachedSetTimeout = defaultSetTimout;
-                }
-                try {
-                  if (typeof clearTimeout === 'function') {
-                    cachedClearTimeout = clearTimeout;
-                  } else {
-                    cachedClearTimeout = defaultClearTimeout;
-                  }
-                } catch (e) {
-                  cachedClearTimeout = defaultClearTimeout;
-                }
-              }());
-              function runTimeout(fun) {
-                if (cachedSetTimeout === setTimeout) {
-                  return setTimeout(fun, 0);
-                }
-                if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
-                  cachedSetTimeout = setTimeout;
-                  return setTimeout(fun, 0);
-                }
-                try {
-                  return cachedSetTimeout(fun, 0);
-                } catch (e) {
-                  try {
-                    return cachedSetTimeout.call(null, fun, 0);
-                  } catch (e) {
-                    return cachedSetTimeout.call(this, fun, 0);
-                  }
-                }
-              }
-              function runClearTimeout(marker) {
-                if (cachedClearTimeout === clearTimeout) {
-                  return clearTimeout(marker);
-                }
-                if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
-                  cachedClearTimeout = clearTimeout;
-                  return clearTimeout(marker);
-                }
-                try {
-                  return cachedClearTimeout(marker);
-                } catch (e) {
-                  try {
-                    return cachedClearTimeout.call(null, marker);
-                  } catch (e) {
-                    return cachedClearTimeout.call(this, marker);
-                  }
-                }
-              }
-              var queue = [];
-              var draining = false;
-              var currentQueue;
-              var queueIndex = -1;
-              function cleanUpNextTick() {
-                if (!draining || !currentQueue) {
-                  return;
-                }
-                draining = false;
-                if (currentQueue.length) {
-                  queue = currentQueue.concat(queue);
-                } else {
-                  queueIndex = -1;
-                }
-                if (queue.length) {
-                  drainQueue();
-                }
-              }
-              function drainQueue() {
-                if (draining) {
-                  return;
-                }
-                var timeout = runTimeout(cleanUpNextTick);
-                draining = true;
-                var len = queue.length;
-                while (len) {
-                  currentQueue = queue;
-                  queue = [];
-                  while (++queueIndex < len) {
-                    if (currentQueue) {
-                      currentQueue[queueIndex].run();
-                    }
-                  }
-                  queueIndex = -1;
-                  len = queue.length;
-                }
-                currentQueue = null;
-                draining = false;
-                runClearTimeout(timeout);
-              }
-              process.nextTick = function (fun) {
-                var args = new Array(arguments.length - 1);
-                if (arguments.length > 1) {
-                  for (var i = 1; i < arguments.length; i++) {
-                    args[i - 1] = arguments[i];
-                  }
-                }
-                queue.push(new Item(fun, args));
-                if (queue.length === 1 && !draining) {
-                  runTimeout(drainQueue);
-                }
-              };
-              function Item(fun, array) {
-                this.fun = fun;
-                this.array = array;
-              }
-              Item.prototype.run = function () {
-                this.fun.apply(null, this.array);
-              };
-              process.title = 'browser';
-              process.browser = true;
-              process.env = {};
-              process.argv = [];
-              process.version = '';
-              process.versions = {};
-              function noop() {
+        (function (module) {
-              }
-              process.on = noop;
-              process.addListener = noop;
-              process.once = noop;
-              process.off = noop;
-              process.removeListener = noop;
-              process.removeAllListeners = noop;
-              process.emit = noop;
-              process.prependListener = noop;
-              process.prependOnceListener = noop;
-              process.listeners = function (name) {
-                return [];
-              };
-              process.binding = function (name) {
-                throw new Error('process.binding is not supported');
-              };
-              process.cwd = function () {
-                return '/';
-              };
-              process.chdir = function (dir) {
-                throw new Error('process.chdir is not supported');
-              };
-              process.umask = function () {
-                return 0;
-              };
-            },
-            {}
-          ],
-: [
-            function (require, module, exports) {
-              (function (setImmediate) {
-                (function (root) {
+          (function (root) {
-                  var setTimeoutFunc = setTimeout;
+            var setTimeoutFunc = setTimeout;
-                  function noop() {
+            function noop() {
+            }
-                  function bind(fn, thisArg) {
+            function bind(fn, thisArg) {
-                    Promise._immediateFn = fn;
+              Promise._immediateFn = fn;
-                  };
+            };
-                  Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
+            Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
-                    Promise._unhandledRejectionFn = fn;
+              Promise._unhandledRejectionFn = fn;
-                  };
+            };
-                  if (typeof module !== 'undefined' && module.exports) {
+            if (module.exports) {
-                    module.exports = Promise;
+              module.exports = Promise;
-                  } else if (!root.Promise) {
+            } else if (!root.Promise) {
-                    root.Promise = Promise;
+              root.Promise = Promise;
+            }
-                }(this));
+          }(commonjsGlobal));
-              }.call(this, require('timers').setImmediate));
-            },
-            { 'timers': 3 }
-          ],
-: [
-            function (require, module, exports) {
-              (function (setImmediate, clearImmediate) {
-                var nextTick = require('process/browser.js').nextTick;
-                var apply = Function.prototype.apply;
-                var slice = Array.prototype.slice;
-                var immediateIds = {};
-                var nextImmediateId = 0;
-                exports.setTimeout = function () {
-                  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
-                };
-                exports.setInterval = function () {
-                  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
-                };
-                exports.clearTimeout = exports.clearInterval = function (timeout) {
-                  timeout.close();
-                };
-                function Timeout(id, clearFn) {
-                  this._id = id;
-                  this._clearFn = clearFn;
-                }
-                Timeout.prototype.unref = Timeout.prototype.ref = function () {
-                };
-                Timeout.prototype.close = function () {
-                  this._clearFn.call(window, this._id);
-                };
-                exports.enroll = function (item, msecs) {
-                  clearTimeout(item._idleTimeoutId);
-                  item._idleTimeout = msecs;
-                };
-                exports.unenroll = function (item) {
-                  clearTimeout(item._idleTimeoutId);
-                  item._idleTimeout = -1;
-                };
-                exports._unrefActive = exports.active = function (item) {
-                  clearTimeout(item._idleTimeoutId);
-                  var msecs = item._idleTimeout;
-                  if (msecs >= 0) {
-                    item._idleTimeoutId = setTimeout(function onTimeout() {
-                      if (item._onTimeout)
-                        item._onTimeout();
-                    }, msecs);
-                  }
-                };
-                exports.setImmediate = typeof setImmediate === 'function' ? setImmediate : function (fn) {
-                  var id = nextImmediateId++;
-                  var args = arguments.length < 2 ? false : slice.call(arguments, 1);
-                  immediateIds[id] = true;
-                  nextTick(function onNextTick() {
-                    if (immediateIds[id]) {
-                      if (args) {
-                        fn.apply(null, args);
-                      } else {
-                        fn.call(null);
-                      }
-                      exports.clearImmediate(id);
-                    }
-                  });
+        }(promise));
-                  return id;
-                };
-                exports.clearImmediate = typeof clearImmediate === 'function' ? clearImmediate : function (id) {
-                  delete immediateIds[id];
-                };
-              }.call(this, require('timers').setImmediate, require('timers').clearImmediate));
-            },
-            {
-              'process/browser.js': 1,
-              'timers': 3
-            }
-          ],
-: [
-            function (require, module, exports) {
-              var promisePolyfill = require('promise-polyfill');
+        var promisePolyfill = promise.exports;
-              var Global = function () {
+        var Global = function () {
-                if (typeof window !== 'undefined') {
+          if (typeof window !== 'undefined') {
-                  return window;
+            return window;
-                } else {
+          } else {
-                  return Function('return this;')();
+            return Function('return this;')();
+          }
-              }();
+        }();
-              module.exports = { boltExport: Global.Promise || promisePolyfill };
+        var promisePolyfill_1 = { boltExport: Global.Promise || promisePolyfill };
-            },
-            { 'promise-polyfill': 2 }
+        return promisePolyfill_1;
-          ]
-        }, {}, [4])(4);
       }));
-    }(undefined, exports$1, module, undefined));
+    }(undefined, exports$1, module));
-    var Promise$2 = module.exports.boltExport;
+    var Promise$1 = module.exports.boltExport;
     var nu$3 = function (baseFn) {
       var data = Optional.none();
       var callbacks = [];
       var map = function (f) {
         get: get
       };
     };
     var nu$2 = function (baseFn) {
       return make$5(function () {
-        return new Promise$2(baseFn);
+        return new Promise$1(baseFn);
       });
     };
     var pure = function (a) {
       return make$5(function () {
-        return Promise$2.resolve(a);
+        return Promise$1.resolve(a);
       });
     };
     var Future = {
       nu: nu$2,
       pure: pure
       var name = name$2(elem);
       return contains$2(ariaElements, name);
     };
     var markValid = function (component, invalidConfig) {
       var elem = invalidConfig.getRoot(component).getOr(component.element);
-      remove$3(elem, invalidConfig.invalidClass);
+      remove$2(elem, invalidConfig.invalidClass);
       invalidConfig.notify.each(function (notifyInfo) {
         if (isAriaElement(component.element)) {
-          set$7(component.element, 'aria-invalid', false);
+          set$8(component.element, 'aria-invalid', false);
+        }
         notifyInfo.getContainer(component).each(function (container) {
-          set$8(container, notifyInfo.validHtml);
+          set$5(container, notifyInfo.validHtml);
         });
         notifyInfo.onValid(component);
       });
     };
     var markInvalid = function (component, invalidConfig, invalidState, text) {
       var elem = invalidConfig.getRoot(component).getOr(component.element);
       add$2(elem, invalidConfig.invalidClass);
       invalidConfig.notify.each(function (notifyInfo) {
         if (isAriaElement(component.element)) {
-          set$7(component.element, 'aria-invalid', true);
+          set$8(component.element, 'aria-invalid', true);
+        }
         notifyInfo.getContainer(component).each(function (container) {
-          set$8(container, text);
+          set$5(container, text);
         });
         notifyInfo.onInvalid(component, text);
       });
     };
     var query = function (component, invalidConfig, _invalidState) {
       var action = showing ? close : open;
       return action(detail, mapFetch, hotspot, sandbox, externals, onOpenSync, highlightOnOpen);
     };
     var matchWidth = function (hotspot, container, useMinWidth) {
       var menu = Composing.getCurrent(container).getOr(container);
-      var buttonWidth = get$7(hotspot.element);
+      var buttonWidth = get$a(hotspot.element);
       if (useMinWidth) {
-        set$6(menu.element, 'min-width', buttonWidth + 'px');
+        set$7(menu.element, 'min-width', buttonWidth + 'px');
       } else {
-        set$4(menu.element, buttonWidth);
+        set$6(menu.element, buttonWidth);
+      }
     };
     var getSink = function (anyInSystem, sinkDetail) {
       return anyInSystem.getSystem().getByUid(sinkDetail.uid + '-' + suffix()).map(function (internalSink) {
         return function () {
                 var inputValue = Representing.getValue(input);
                 if (inputValue.length === 0) {
                   return Future.pure(Result.value(true));
                 } else {
                   var span = SugarElement.fromTag('span');
-                  set$6(span, 'background-color', inputValue);
+                  set$7(span, 'background-color', inputValue);
                   var res = getRaw(span, 'background-color').fold(function () {
                     return Result.error('blah');
                   }, function (_) {
                     return Result.value(inputValue);
                   });
+            ]
           }]),
         fieldBehaviours: derive$1([config('form-field-events', [
             run$1(colorInputChangeEvent, function (comp, se) {
               memColorButton.getOpt(comp).each(function (colorButton) {
-                set$6(colorButton.element, 'background-color', se.event.color);
+                set$7(colorButton.element, 'background-color', se.event.color);
               });
               emitWith(comp, formChangeEvent, { name: spec.name });
             }),
             run$1(colorSwatchChangeEvent, function (comp, se) {
               FormField.getField(comp).each(function (field) {
       spectrumPart
     ];
     var _sliderChangeEvent = 'slider.change.value';
     var sliderChangeEvent = constant$1(_sliderChangeEvent);
-    var isTouchEvent$1 = function (evt) {
+    var isTouchEvent$2 = function (evt) {
       return evt.type.indexOf('touch') !== -1;
     };
     var getEventSource = function (simulatedEvent) {
       var evt = simulatedEvent.event.raw;
-      if (isTouchEvent$1(evt)) {
+      if (isTouchEvent$2(evt)) {
         var touchEvent = evt;
         return touchEvent.touches !== undefined && touchEvent.touches.length === 1 ? Optional.some(touchEvent.touches[0]).map(function (t) {
           return SugarPosition(t.clientX, t.clientY);
         }) : Optional.none();
       } else {
       return getMinXBounds(spectrum) - getMinXBounds(slider) + offset;
     };
     var setPositionFromValue$2 = function (slider, thumb, detail, edges) {
       var value = currentValue(detail);
       var pos = findPositionOfValue$1(slider, edges.getSpectrum(slider), value.x, edges.getLeftEdge(slider), edges.getRightEdge(slider), detail);
-      var thumbRadius = get$7(thumb.element) / 2;
+      var thumbRadius = get$a(thumb.element) / 2;
-      set$6(thumb.element, 'left', pos - thumbRadius + 'px');
+      set$7(thumb.element, 'left', pos - thumbRadius + 'px');
     };
     var onLeft$2 = handleMovement$2(-1);
     var onRight$2 = handleMovement$2(1);
     var onUp$2 = Optional.none;
     var onDown$2 = Optional.none;
       return getMinYBounds(spectrum) - getMinYBounds(slider) + offset;
     };
     var setPositionFromValue$1 = function (slider, thumb, detail, edges) {
       var value = currentValue(detail);
       var pos = findPositionOfValue(slider, edges.getSpectrum(slider), value.y, edges.getTopEdge(slider), edges.getBottomEdge(slider), detail);
-      var thumbRadius = get$8(thumb.element) / 2;
+      var thumbRadius = get$b(thumb.element) / 2;
-      set$6(thumb.element, 'top', pos - thumbRadius + 'px');
+      set$7(thumb.element, 'top', pos - thumbRadius + 'px');
     };
     var onLeft$1 = Optional.none;
     var onRight$1 = Optional.none;
     var onUp$1 = handleMovement$1(-1);
     var onDown$1 = handleMovement$1(1);
     };
     var setPositionFromValue = function (slider, thumb, detail, edges) {
       var value = currentValue(detail);
       var xPos = findPositionOfValue$1(slider, edges.getSpectrum(slider), value.x, edges.getLeftEdge(slider), edges.getRightEdge(slider), detail);
       var yPos = findPositionOfValue(slider, edges.getSpectrum(slider), value.y, edges.getTopEdge(slider), edges.getBottomEdge(slider), detail);
-      var thumbXRadius = get$7(thumb.element) / 2;
+      var thumbXRadius = get$a(thumb.element) / 2;
-      var thumbYRadius = get$8(thumb.element) / 2;
+      var thumbYRadius = get$b(thumb.element) / 2;
-      set$6(thumb.element, 'left', xPos - thumbXRadius + 'px');
+      set$7(thumb.element, 'left', xPos - thumbXRadius + 'px');
-      set$6(thumb.element, 'top', yPos - thumbYRadius + 'px');
+      set$7(thumb.element, 'top', yPos - thumbYRadius + 'px');
     };
     var onLeft = handleMovement(-1, false);
     var onRight = handleMovement(1, false);
     var onUp = handleMovement(-1, true);
     var onDown = handleMovement(1, true);
         behaviours: augment(detail.formBehaviours, [Representing.config({
             store: {
               mode: 'manual',
               getValue: function (form) {
                 var resPs = getAllParts(form, detail);
-                return map(resPs, function (resPThunk, pName) {
+                return map$1(resPs, function (resPThunk, pName) {
                   return resPThunk().bind(function (v) {
                     var opt = Composing.getCurrent(v);
                     return toResult(opt, new Error('Cannot find a current component to extract the value from for form part \'' + pName + '\': ' + element(v.element)));
                   }).map(Representing.getValue);
                 });
           attributes: { role: 'presentation' }
+        }
       });
       var updatePreview = function (anyInSystem, hex) {
         memPreview.getOpt(anyInSystem).each(function (preview) {
-          set$6(preview.element, 'background-color', '#' + hex.value);
+          set$7(preview.element, 'background-color', '#' + hex.value);
         });
       };
       var factory = function () {
         var state = {
           red: Cell(Optional.some(255)),
           ComposingConfigs.self()
         ])
       };
     };
-    var global$7 = tinymce.util.Tools.resolve('tinymce.Resource');
+    var global$6 = tinymce.util.Tools.resolve('tinymce.Resource');
     var isOldCustomEditor = function (spec) {
       return has$2(spec, 'init');
     };
     var renderCustomEditor = function (spec) {
           classes: ['tox-custom-editor']
         },
         behaviours: derive$1([
           config('custom-editor-events', [runOnAttached(function (component) {
               memReplaced.getOpt(component).each(function (ta) {
-                (isOldCustomEditor(spec) ? spec.init(ta.element.dom) : global$7.load(spec.scriptId, spec.scriptUrl).then(function (init) {
+                (isOldCustomEditor(spec) ? spec.init(ta.element.dom) : global$6.load(spec.scriptId, spec.scriptUrl).then(function (init) {
                   return init(ta.element.dom, spec.settings);
                 })).then(function (ea) {
                   initialValue.on(function (cvalue) {
                     ea.setValue(cvalue);
                   });
         ]),
         components: [memReplaced.asSpec()]
       };
     };
-    var global$6 = tinymce.util.Tools.resolve('tinymce.util.Tools');
+    var global$5 = tinymce.util.Tools.resolve('tinymce.util.Tools');
     var processors = objOf([
       defaulted('preprocess', identity$1),
       defaulted('postprocess', identity$1)
     ]);
       }, function (c, v) {
         return setter(c.element, v);
       });
     };
     var domValue = function (optInitialValue) {
-      return withElement(optInitialValue, get$9, set$5);
+      return withElement(optInitialValue, get$5, set$4);
     };
     var domHtml = function (optInitialValue) {
-      return withElement(optInitialValue, get$d, set$8);
+      return withElement(optInitialValue, get$7, set$5);
     };
     var memory = function (initialValue) {
       return Representing.config({
         store: {
           mode: 'memory',
       memory: memory
     };
     var defaultImageFileTypes = 'jpeg,jpg,jpe,jfi,jif,jfif,png,gif,bmp,webp';
     var filterByExtension = function (files, providersBackstage) {
-      var allowedImageFileTypes = global$6.explode(providersBackstage.getSetting('images_file_types', defaultImageFileTypes, 'string'));
+      var allowedImageFileTypes = global$5.explode(providersBackstage.getSetting('images_file_types', defaultImageFileTypes, 'string'));
       var isFileInAllowedTypes = function (file) {
         return exists(allowedImageFileTypes, function (type) {
           return endsWith(file.name.toLowerCase(), '.' + type.toLowerCase());
         });
       };
         getValue: function (_frameComponent) {
           return cachedValue.get();
         },
         setValue: function (frameComponent, html) {
           if (!isSandbox) {
-            set$7(frameComponent.element, 'src', 'javascript:\'\'');
+            set$8(frameComponent.element, 'src', 'javascript:\'\'');
             var doc = frameComponent.element.dom.contentWindow.document;
             doc.open();
             doc.write(html);
             doc.close();
           } else {
-            set$7(frameComponent.element, 'srcdoc', html);
+            set$8(frameComponent.element, 'srcdoc', html);
+          }
           cachedValue.set(html);
+        }
       };
     };
     };
     var getHeight$1 = function (image) {
       return image.naturalHeight || image.height;
     };
-    var promise = function () {
-      var Promise = function (fn) {
-        if (typeof this !== 'object') {
-          throw new TypeError('Promises must be constructed via new');
-        }
-        if (typeof fn !== 'function') {
-          throw new TypeError('not a function');
-        }
-        this._state = null;
-        this._value = null;
-        this._deferreds = [];
-        doResolve(fn, bind(resolve, this), bind(reject, this));
-      };
-      var anyWindow = window;
-      var asap = Promise.immediateFn || typeof anyWindow.setImmediate === 'function' && anyWindow.setImmediate || function (fn) {
-        return setTimeout(fn, 1);
-      };
-      var bind = function (fn, thisArg) {
-        return function () {
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-          }
-          return fn.apply(thisArg, args);
-        };
-      };
-      var isArray = Array.isArray || function (value) {
-        return Object.prototype.toString.call(value) === '[object Array]';
-      };
-      function handle(deferred) {
-        var me = this;
-        if (this._state === null) {
-          this._deferreds.push(deferred);
-          return;
-        }
-        asap(function () {
-          var cb = me._state ? deferred.onFulfilled : deferred.onRejected;
-          if (cb === null) {
-            (me._state ? deferred.resolve : deferred.reject)(me._value);
-            return;
-          }
-          var ret;
-          try {
-            ret = cb(me._value);
-          } catch (e) {
-            deferred.reject(e);
-            return;
-          }
-          deferred.resolve(ret);
-        });
-      }
-      function resolve(newValue) {
-        try {
-          if (newValue === this) {
-            throw new TypeError('A promise cannot be resolved with itself.');
-          }
-          if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
-            var then = newValue.then;
-            if (typeof then === 'function') {
-              doResolve(bind(then, newValue), bind(resolve, this), bind(reject, this));
-              return;
-            }
-          }
-          this._state = true;
-          this._value = newValue;
-          finale.call(this);
-        } catch (e) {
-          reject.call(this, e);
-        }
-      }
-      function reject(newValue) {
-        this._state = false;
-        this._value = newValue;
-        finale.call(this);
-      }
-      function finale() {
-        for (var _i = 0, _a = this._deferreds; _i < _a.length; _i++) {
-          var deferred = _a[_i];
-          handle.call(this, deferred);
-        }
-        this._deferreds = [];
-      }
-      function Handler(onFulfilled, onRejected, resolve, reject) {
-        this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
-        this.onRejected = typeof onRejected === 'function' ? onRejected : null;
-        this.resolve = resolve;
-        this.reject = reject;
-      }
-      var doResolve = function (fn, onFulfilled, onRejected) {
-        var done = false;
-        try {
-          fn(function (value) {
-            if (done) {
-              return;
-            }
-            done = true;
-            onFulfilled(value);
-          }, function (reason) {
-            if (done) {
-              return;
-            }
-            done = true;
-            onRejected(reason);
-          });
-        } catch (ex) {
-          if (done) {
-            return;
-          }
-          done = true;
-          onRejected(ex);
-        }
-      };
-      Promise.prototype.catch = function (onRejected) {
-        return this.then(null, onRejected);
-      };
-      Promise.prototype.then = function (onFulfilled, onRejected) {
-        var me = this;
-        return new Promise(function (resolve, reject) {
-          handle.call(me, new Handler(onFulfilled, onRejected, resolve, reject));
-        });
-      };
-      Promise.all = function () {
-        var values = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          values[_i] = arguments[_i];
-        }
-        var args = Array.prototype.slice.call(values.length === 1 && isArray(values[0]) ? values[0] : values);
-        return new Promise(function (resolve, reject) {
-          if (args.length === 0) {
-            return resolve([]);
-          }
-          var remaining = args.length;
-          var res = function (i, val) {
-            try {
-              if (val && (typeof val === 'object' || typeof val === 'function')) {
-                var then = val.then;
-                if (typeof then === 'function') {
-                  then.call(val, function (val) {
-                    res(i, val);
-                  }, reject);
-                  return;
-                }
-              }
-              args[i] = val;
-              if (--remaining === 0) {
-                resolve(args);
-              }
-            } catch (ex) {
-              reject(ex);
-            }
-          };
-          for (var i = 0; i < args.length; i++) {
-            res(i, args[i]);
-          }
-        });
-      };
-      Promise.resolve = function (value) {
-        if (value && typeof value === 'object' && value.constructor === Promise) {
-          return value;
-        }
-        return new Promise(function (resolve) {
-          resolve(value);
-        });
-      };
-      Promise.reject = function (reason) {
-        return new Promise(function (resolve, reject) {
-          reject(reason);
-        });
-      };
-      Promise.race = function (values) {
-        return new Promise(function (resolve, reject) {
-          for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
-            var value = values_1[_i];
-            value.then(resolve, reject);
-          }
-        });
-      };
-      return Promise;
-    };
-    var Promise$1 = window.Promise ? window.Promise : promise();
     var blobToImage = function (blob) {
       return new Promise$1(function (resolve, reject) {
         var blobUrl = URL.createObjectURL(blob);
         var image = new Image();
         var removeListeners = function () {
           }),
           Optional.some(iconSpec)
         ]),
         matchWidth: true,
         useMinWidth: true,
-        dropdownBehaviours: derive$1(__spreadArray(__spreadArray([], spec.dropdownBehaviours), [
+        dropdownBehaviours: derive$1(__spreadArray(__spreadArray([], spec.dropdownBehaviours, true), [
           DisablingConfigs.button(function () {
             return spec.disabled || sharedBackstage.providers.isDisabled();
           }),
           receivingConfig(),
           Unselecting.config({}),
               }).each(function (displayIcon) {
                 Replacing.set(displayIcon, [renderReplacableIconFromPack(se.event.icon, sharedBackstage.providers.icons)]);
               });
             })
           ])
-        ])),
+        ], false)),
         eventOrder: deepMerge(toolbarButtonEventOrder, {
           mousedown: [
             'focusing',
             'alloy.base.behaviour',
             'item-type-events',
       var data = expand(items, backstage.shared.providers.menuItems());
       if (data.items.length === 0) {
         return Optional.none();
+      }
       var mainMenu = createPartialMenu(primary, data.items, itemResponse, backstage, isHorizontalMenu);
-      var submenus = map(data.menus, function (menuItems, menuName) {
+      var submenus = map$1(data.menus, function (menuItems, menuName) {
         return createPartialMenu(menuName, menuItems, itemResponse, backstage, false);
       });
       var menus = deepMerge(submenus, wrap$1(primary, mainMenu));
       return Optional.from(tieredMenu.tieredData(primary, menus, data.expansions));
     };
         },
         setActive: function (state) {
           var elm = component.element;
           if (state) {
             add$2(elm, 'tox-tbtn--enabled');
-            set$7(elm, 'aria-pressed', true);
+            set$8(elm, 'aria-pressed', true);
           } else {
-            remove$3(elm, 'tox-tbtn--enabled');
+            remove$2(elm, 'tox-tbtn--enabled');
-            remove$6(elm, 'aria-pressed');
+            remove$7(elm, 'aria-pressed');
+          }
         },
         isActive: function () {
           return has(component.element, 'tox-tbtn--enabled');
+        }
       var components = icon.isSome() ? componentRenderPipeline([icon]) : [];
       var innerHtml = icon.isSome() ? {} : { innerHtml: translatedText };
       var classes = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], !spec.primary && !spec.borderless ? [
         'tox-button',
         'tox-button--secondary'
-      ] : ['tox-button']), icon.isSome() ? ['tox-button--icon'] : []), spec.borderless ? ['tox-button--naked'] : []), extraClasses);
+      ] : ['tox-button'], true), icon.isSome() ? ['tox-button--icon'] : [], true), spec.borderless ? ['tox-button--naked'] : [], true), extraClasses, true);
       var dom = __assign(__assign({
         tag: 'button',
         classes: classes
       }, innerHtml), { attributes: { title: translatedText } });
       return renderCommonSpec(spec, action, extraBehaviours, dom, components, providersBackstage);
         memContainer: memContainer,
         getApplyButton: getApplyButton
       };
     };
-    var global$5 = tinymce.util.Tools.resolve('tinymce.geom.Rect');
+    var global$4 = tinymce.util.Tools.resolve('tinymce.geom.Rect');
-    var global$4 = tinymce.util.Tools.resolve('tinymce.dom.DomQuery');
     var global$3 = tinymce.util.Tools.resolve('tinymce.util.Observable');
     var global$2 = tinymce.util.Tools.resolve('tinymce.util.VK');
       return {
         width: scrollWidth < offsetWidth ? clientWidth : scrollWidth,
         height: scrollHeight < offsetHeight ? clientHeight : scrollHeight
       };
     };
+    var isTouchEvent$1 = function (e) {
+      return isNonNullable(e.changedTouches);
+    };
     var updateWithTouchData = function (e) {
-      var keys, i;
-      if (e.changedTouches) {
+      if (isTouchEvent$1(e)) {
-        keys = 'screenX screenY pageX pageY clientX clientY'.split(' ');
+        var keys = 'screenX screenY pageX pageY clientX clientY'.split(' ');
-        for (i = 0; i < keys.length; i++) {
+        for (var i = 0; i < keys.length; i++) {
           e[keys[i]] = e.changedTouches[0][keys[i]];
+        }
+      }
     };
     function DragHelper (id, settings) {
+      var _a, _b, _c;
-      var $eventOverlay;
+      var eventOverlay;
+      var handleEvents = [];
+      var overlayEvents = [];
-      var doc = settings.document || document;
+      var doc = (_a = settings.document) !== null && _a !== void 0 ? _a : document;
+      var root = (_b = settings.root) !== null && _b !== void 0 ? _b : doc;
+      var sugarDoc = SugarElement.fromDom(doc);
       var downButton;
+      var startX;
-      var startX, startY;
+      var startY;
-      var handleElement = doc.getElementById(settings.handle || id);
+      var handleElement = SugarElement.fromDom(root.getElementById((_c = settings.handle) !== null && _c !== void 0 ? _c : id));
       var start = function (e) {
+        var rawEvent = e.raw;
         var docSize = getDocumentSize(doc);
-        var cursor;
-        updateWithTouchData(e);
+        updateWithTouchData(rawEvent);
-        e.preventDefault();
+        e.prevent();
-        downButton = e.button;
+        downButton = rawEvent.button;
-        var handleElm = handleElement;
-        startX = e.screenX;
+        startX = rawEvent.screenX;
-        startY = e.screenY;
+        startY = rawEvent.screenY;
-        if (window.getComputedStyle) {
-          cursor = window.getComputedStyle(handleElm, null).getPropertyValue('cursor');
+        var cursor = get$c(handleElement, 'cursor');
-        } else {
-          cursor = handleElm.runtimeStyle.cursor;
+        eventOverlay = SugarElement.fromTag('div', doc);
-        }
-        $eventOverlay = global$4('<div></div>').css({
+        setAll(eventOverlay, {
-          position: 'absolute',
+          'position': 'absolute',
-          top: 0,
+          'top': '0',
-          left: 0,
+          'left': '0',
-          width: docSize.width,
+          'width': docSize.width + 'px',
-          height: docSize.height,
+          'height': docSize.height + 'px',
-          zIndex: 2147483647,
+          'z-index': 2147483647 + '',
-          opacity: 0.0001,
+          'opacity': '0.0001',
           cursor: cursor
+        });
-        }).appendTo(doc.body);
+        append$2(getBody(sugarDoc), eventOverlay);
-        global$4(doc).on('mousemove touchmove', drag).on('mouseup touchend', stop);
+        overlayEvents.push(bind(sugarDoc, 'mousemove', drag), bind(sugarDoc, 'touchmove', drag), bind(sugarDoc, 'mouseup', stop), bind(sugarDoc, 'touchend', stop));
-        settings.start(e);
+        settings.start(rawEvent);
       };
       var drag = function (e) {
+        var rawEvent = e.raw;
-        updateWithTouchData(e);
+        updateWithTouchData(rawEvent);
-        if (e.button !== downButton) {
+        if (rawEvent.button !== downButton) {
           return stop(e);
+        }
-        e.deltaX = e.screenX - startX;
+        rawEvent.deltaX = rawEvent.screenX - startX;
-        e.deltaY = e.screenY - startY;
+        rawEvent.deltaY = rawEvent.screenY - startY;
-        e.preventDefault();
+        e.prevent();
-        settings.drag(e);
+        settings.drag(rawEvent);
       };
       var stop = function (e) {
-        updateWithTouchData(e);
+        updateWithTouchData(e.raw);
-        global$4(doc).off('mousemove touchmove', drag).off('mouseup touchend', stop);
+        each$1(overlayEvents, function (e) {
+          return e.unbind();
+        });
+        overlayEvents = [];
-        $eventOverlay.remove();
+        remove$5(eventOverlay);
         if (settings.stop) {
-          settings.stop(e);
+          settings.stop(e.raw);
+        }
       };
       var destroy = function () {
+        each$1(overlayEvents.concat(handleEvents), function (e) {
+          return e.unbind();
+        });
+        overlayEvents = [];
-        global$4(handleElement).off();
+        handleEvents = [];
+        if (isNonNullable(eventOverlay)) {
+          remove$5(eventOverlay);
+        }
       };
-      global$4(handleElement).on('mousedown touchstart', start);
+      handleEvents.push(bind(handleElement, 'mousedown', start), bind(handleElement, 'touchstart', start));
       return { destroy: destroy };
+    }
     var count = 0;
     var create$1 = function (currentRect, viewPortRect, clampRect, containerElm, action) {
       var dragHelpers;
+      var events = [];
       var prefix = 'tox-';
       var id = prefix + 'crid-' + count++;
+      var container = SugarElement.fromDom(containerElm);
       var handles = [
+        {
           name: 'move',
           xMul: 0,
           yMul: 0,
       };
       var getInnerRect = function () {
         return getRelativeRect(clampRect, currentRect);
       };
       var moveRect = function (handle, startRect, deltaX, deltaY) {
-        var x, y, w, h, rect;
-        x = startRect.x;
-        y = startRect.y;
-        w = startRect.w;
-        h = startRect.h;
-        x += deltaX * handle.deltaX;
+        var x = startRect.x + deltaX * handle.deltaX;
-        y += deltaY * handle.deltaY;
+        var y = startRect.y + deltaY * handle.deltaY;
-        w += deltaX * handle.deltaW;
+        var w = Math.max(20, startRect.w + deltaX * handle.deltaW);
-        h += deltaY * handle.deltaH;
+        var h = Math.max(20, startRect.h + deltaY * handle.deltaH);
-        if (w < 20) {
-          w = 20;
-        }
-        if (h < 20) {
-          h = 20;
-        }
-        rect = currentRect = global$5.clamp({
+        var rect = currentRect = global$4.clamp({
           x: x,
           y: y,
           w: w,
           h: h
         }, clampRect, handle.name === 'move');
       var render = function () {
         var createDragHelper = function (handle) {
           var startRect;
           return DragHelper(id, {
             document: containerElm.ownerDocument,
+            root: getRootNode(container).dom,
             handle: id + '-' + handle.name,
             start: function () {
               startRect = currentRect;
             },
             drag: function (e) {
               moveRect(handle, startRect, e.deltaX, e.deltaY);
+            }
           });
         };
+        var cropContainer = SugarElement.fromTag('div');
+        setAll$1(cropContainer, {
+          id: id,
-        global$4('<div id="' + id + '" class="' + prefix + 'croprect-container"' + ' role="grid" aria-dropeffect="execute">').appendTo(containerElm);
+          'class': prefix + 'croprect-container',
+          'role': 'grid',
+          'aria-dropeffect': 'execute'
+        });
+        append$2(container, cropContainer);
-        global$6.each(blockers, function (blocker) {
+        each$1(blockers, function (blocker) {
-          global$4('#' + id, containerElm).append('<div id="' + id + '-' + blocker + '"class="' + prefix + 'croprect-block" style="display: none" data-mce-bogus="all">');
+          descendant(container, '#' + id).each(function (blockerElm) {
+            var cropBlocker = SugarElement.fromTag('div');
+            setAll$1(cropBlocker, {
+              'id': id + '-' + blocker,
+              'class': prefix + 'croprect-block',
+              'data-mce-bogus': 'all'
+            });
+            set$7(cropBlocker, 'display', 'none');
+            append$2(blockerElm, cropBlocker);
+          });
+        });
+        each$1(handles, function (handle) {
+          descendant(container, '#' + id).each(function (handleElm) {
+            var cropHandle = SugarElement.fromTag('div');
+            setAll$1(cropHandle, {
+              'id': id + '-' + handle.name,
+              'aria-label': handle.label,
+              'aria-grabbed': 'false',
+              'data-mce-bogus': 'all',
+              'role': 'gridcell',
+              'tabindex': '-1',
+              'title': handle.label
+            });
+            add$1(cropHandle, [
+              prefix + 'croprect-handle',
+              prefix + 'croprect-handle-' + handle.name
+            ]);
+            set$7(cropHandle, 'display', 'none');
+            append$2(handleElm, cropHandle);
-        });
+          });
-        global$6.each(handles, function (handle) {
-          global$4('#' + id, containerElm).append('<div id="' + id + '-' + handle.name + '" class="' + prefix + 'croprect-handle ' + prefix + 'croprect-handle-' + handle.name + '"' + 'style="display: none" data-mce-bogus="all" role="gridcell" tabindex="-1"' + ' aria-label="' + handle.label + '" aria-grabbed="false" title="' + handle.label + '">');
         });
-        dragHelpers = global$6.map(handles, createDragHelper);
+        dragHelpers = map$2(handles, createDragHelper);
         repaint(currentRect);
-        global$4(containerElm).on('focusin focusout', function (e) {
+        var handleFocus = function (e) {
-          global$4(e.target).attr('aria-grabbed', e.type === 'focus' ? 'true' : 'false');
+          set$8(e.target, 'aria-grabbed', e.raw.type === 'focus' ? 'true' : 'false');
-        });
+        };
-        global$4(containerElm).on('keydown', function (e) {
+        var handleKeydown = function (e) {
           var activeHandle;
-          global$6.each(handles, function (handle) {
+          each$1(handles, function (handle) {
-            if (e.target.id === id + '-' + handle.name) {
+            if (get$d(e.target, 'id') === id + '-' + handle.name) {
               activeHandle = handle;
               return false;
+            }
           });
           var moveAndBlock = function (evt, handle, startRect, deltaX, deltaY) {
             evt.stopPropagation();
             evt.preventDefault();
             moveRect(activeHandle, startRect, deltaX, deltaY);
           };
-          switch (e.keyCode) {
+          switch (e.raw.keyCode) {
           case global$2.LEFT:
             moveAndBlock(e, activeHandle, currentRect, -10, 0);
             break;
           case global$2.RIGHT:
             moveAndBlock(e, activeHandle, currentRect, 10, 0);
           case global$2.DOWN:
             moveAndBlock(e, activeHandle, currentRect, 0, 10);
             break;
           case global$2.ENTER:
           case global$2.SPACEBAR:
-            e.preventDefault();
+            e.prevent();
             action();
             break;
+          }
-        });
+        };
+        events.push(bind(container, 'focusin', handleFocus), bind(container, 'focusout', handleFocus), bind(container, 'keydown', handleKeydown));
       };
       var toggleVisibility = function (state) {
-        var selectors = global$6.map(handles, function (handle) {
+        var selectors = __spreadArray(__spreadArray([], map$2(handles, function (handle) {
           return '#' + id + '-' + handle.name;
-        }).concat(global$6.map(blockers, function (blocker) {
+        }), true), map$2(blockers, function (blocker) {
           return '#' + id + '-' + blocker;
-        })).join(',');
+        }), true).join(',');
+        var elems = descendants(container, selectors);
         if (state) {
-          global$4(selectors, containerElm).show();
+          each$1(elems, function (elm) {
+            return remove$6(elm, 'display');
+          });
         } else {
-          global$4(selectors, containerElm).hide();
+          each$1(elems, function (elm) {
+            return set$7(elm, 'display', 'none');
+          });
+        }
       };
       var repaint = function (rect) {
-        var updateElementRect = function (name, rect) {
+        var updateElementRect = function (name, newRect) {
-          if (rect.h < 0) {
+          descendant(container, '#' + id + '-' + name).each(function (elm) {
-            rect.h = 0;
+            setAll(elm, {
-          }
-          if (rect.w < 0) {
+              left: newRect.x + 'px',
-            rect.w = 0;
+              top: newRect.y + 'px',
-          }
-          global$4('#' + id + '-' + name, containerElm).css({
+              width: Math.max(0, newRect.w) + 'px',
-            left: rect.x,
+              height: Math.max(0, newRect.h) + 'px'
-            top: rect.y,
+            });
-            width: rect.w,
-            height: rect.h
           });
         };
-        global$6.each(handles, function (handle) {
+        each$1(handles, function (handle) {
-          global$4('#' + id + '-' + handle.name, containerElm).css({
+          descendant(container, '#' + id + '-' + handle.name).each(function (elm) {
+            setAll(elm, {
-            left: rect.w * handle.xMul + rect.x,
+              left: rect.w * handle.xMul + rect.x + 'px',
-            top: rect.h * handle.yMul + rect.y
+              top: rect.h * handle.yMul + rect.y + 'px'
+            });
           });
         });
         updateElementRect('top', {
           x: viewPortRect.x,
           y: viewPortRect.y,
       var setClampRect = function (rect) {
         clampRect = rect;
         repaint(currentRect);
       };
       var destroy = function () {
-        global$6.each(dragHelpers, function (helper) {
+        each$1(dragHelpers, function (helper) {
-          helper.destroy();
+          return helper.destroy();
         });
         dragHelpers = [];
+        each$1(events, function (e) {
+          return e.unbind();
+        });
+        events = [];
       };
       render();
-      var instance = global$6.extend({
+      var instance = __assign(__assign({}, global$3), {
         toggleVisibility: toggleVisibility,
         setClampRect: setClampRect,
         setRect: setRect,
         getInnerRect: getInnerRect,
         setInnerRect: setInnerRect,
         setViewPortRect: setViewPortRect,
         destroy: destroy
-      }, global$3);
+      });
       return instance;
     };
     var CropRect = { create: create$1 };
     var loadImage = function (image) {
-      return new global$d(function (resolve) {
+      return new global$c(function (resolve) {
         var loaded = function () {
           image.removeEventListener('load', loaded);
           resolve(image);
         };
         if (image.complete) {
           classes: ['tox-image-tools__image-bg'],
           attributes: { role: 'presentation' }
+        }
       });
       var zoomState = Cell(1);
-      var cropRect = value$1();
+      var cropRect = api$1();
       var rectState = Cell({
         x: 0,
         y: 0,
         w: 1,
         h: 1
         h: 1
       });
       var repaintImg = function (anyInSystem, img) {
         memContainer.getOpt(anyInSystem).each(function (panel) {
           var zoom = zoomState.get();
-          var panelW = get$7(panel.element);
+          var panelW = get$a(panel.element);
-          var panelH = get$8(panel.element);
+          var panelH = get$b(panel.element);
           var width = img.dom.naturalWidth * zoom;
           var height = img.dom.naturalHeight * zoom;
           var left = Math.max(0, panelW / 2 - width / 2);
           var top = Math.max(0, panelH / 2 - height / 2);
           var css = {
           };
           setAll(img, css);
           memBg.getOpt(panel).each(function (bg) {
             setAll(bg.element, css);
           });
-          cropRect.on(function (cRect) {
+          cropRect.run(function (cRect) {
             var rect = rectState.get();
             cRect.setRect({
               x: rect.x * zoom + left,
               y: rect.y * zoom + top,
               w: rect.w * zoom,
           });
         });
       };
       var zoomFit = function (anyInSystem, img) {
         memContainer.getOpt(anyInSystem).each(function (panel) {
-          var panelW = get$7(panel.element);
+          var panelW = get$a(panel.element);
-          var panelH = get$8(panel.element);
+          var panelH = get$b(panel.element);
           var width = img.dom.naturalWidth;
           var height = img.dom.naturalHeight;
           var zoom = Math.min(panelW / width, panelH / height);
           if (zoom >= 1) {
             zoomState.set(1);
+          }
         });
       };
       var updateSrc = function (anyInSystem, url) {
         var img = SugarElement.fromTag('img');
-        set$7(img, 'src', url);
+        set$8(img, 'src', url);
         return loadImage(img.dom).then(function () {
           if (anyInSystem.getSystem().isConnected()) {
             memContainer.getOpt(anyInSystem).map(function (panel) {
               var aImg = external$2({ element: img });
               Replacing.replaceAt(panel, 1, Optional.some(aImg));
                 y: 0,
                 w: img.dom.naturalWidth,
                 h: img.dom.naturalHeight
               };
               viewRectState.set(viewRect);
-              var rect = global$5.inflate(viewRect, -20, -20);
+              var rect = global$4.inflate(viewRect, -20, -20);
               rectState.set(rect);
               if (lastViewRect.w !== viewRect.w || lastViewRect.h !== viewRect.h) {
                 zoomFit(panel, img);
+              }
               repaintImg(panel, img);
           var img = panel.components()[1].element;
           repaintImg(panel, img);
         });
       };
       var showCrop = function () {
-        cropRect.on(function (cRect) {
+        cropRect.run(function (cRect) {
           cRect.toggleVisibility(true);
         });
       };
       var hideCrop = function () {
-        cropRect.on(function (cRect) {
+        cropRect.run(function (cRect) {
           cRect.toggleVisibility(false);
         });
       };
       var getRect = function () {
         return rectState.get();
               attributes: { src: initialUrl }
+            }
           },
+          {
             dom: { tag: 'div' },
-            behaviours: derive$1([config('image-panel-crop-events', [runOnAttached(function (comp) {
+            behaviours: derive$1([config('image-panel-crop-events', [
+                runOnAttached(function (comp) {
                   memContainer.getOpt(comp).each(function (container) {
                     var el = container.element.dom;
                     var cRect = CropRect.create({
                       x: 10,
                       y: 10,
                       };
                       rectState.set(newRect);
                     });
                     cropRect.set(cRect);
                   });
-                })])])
+                }),
+                runOnDetached(function () {
+                  cropRect.clear();
+                })
+              ])])
+          }
         ],
         containerBehaviours: derive$1([
           Replacing.config({}),
           config('image-panel-events', [runOnAttached(function (comp) {
       };
       var destroyState = function (state) {
         URL.revokeObjectURL(state.url);
       };
       var destroyStates = function (states) {
-        global$6.each(states, destroyState);
+        global$5.each(states, destroyState);
       };
       var destroyTempState = function () {
         tempState.on(destroyState);
         tempState.clear();
       };
                     mode: 'manual',
                     initialValue: initialItem.map(function (item) {
                       return item.value;
                     }).getOr(''),
                     getValue: function (comp) {
-                      return get$c(comp.element, dataAttribute);
+                      return get$d(comp.element, dataAttribute);
                     },
                     setValue: function (comp, data) {
                       findItemByValue(spec.items, data).each(function (item) {
-                        set$7(comp.element, dataAttribute, item.value);
+                        set$8(comp.element, dataAttribute, item.value);
                         emitWith(comp, updateMenuText, { text: item.text });
                       });
+                    }
+                  }
                 })
           Focusing.config({}),
           Representing.config({
             store: __assign({
               mode: 'manual',
               getValue: function (select) {
-                return get$9(select.element);
+                return get$5(select.element);
               },
               setValue: function (select, newValue) {
                 var found = find$5(detail.options, function (opt) {
                   return opt.value === newValue;
                 });
                 if (found.isSome()) {
-                  set$5(select.element, newValue);
+                  set$4(select.element, newValue);
+                }
+              }
             }, initialValues)
           })
         ])
       Representing.setValue(input, itemData);
       setCursorAtEnd(input);
     };
     var setSelectionOn = function (input, f) {
       var el = input.element;
-      var value = get$9(el);
+      var value = get$5(el);
       var node = el.dom;
-      if (get$c(el, 'type') !== 'number') {
+      if (get$d(el, 'type') !== 'number') {
         f(node, value);
+      }
     };
     var setCursorAtEnd = function (input) {
       setSelectionOn(input, function (node, value) {
         Representing.config({
           onSetValue: detail.onSetValue,
           store: __assign({
             mode: 'dataset',
             getDataKey: function (comp) {
-              return get$9(comp.element);
+              return get$5(comp.element);
             },
             getFallbackEntry: function (itemString) {
               return {
                 value: itemString,
                 meta: {}
               };
             },
             setValue: function (comp, data) {
-              set$5(comp.element, detail.model.getDisplayText(data));
+              set$4(comp.element, detail.model.getDisplayText(data));
+            }
           }, detail.initialData.map(function (d) {
             return wrap$1('initialValue', d);
           }).getOr({}))
         }),
           },
           onStream: function (component, _simulatedEvent) {
             var sandbox = Coupling.getCoupled(component, 'sandbox');
             var focusInInput = Focusing.isFocused(component);
             if (focusInInput) {
-              if (get$9(component.element).length >= detail.minChars) {
+              if (get$5(component.element).length >= detail.minChars) {
                 var previousValue_1 = Composing.getCurrent(sandbox).bind(function (menu) {
                   return Highlighting.getHighlighted(menu).map(Representing.getValue);
                 });
                 detail.previewing.set(true);
                 var onOpenSync = function (_sandbox) {
               },
               invalidClass: 'tox-control-wrap--status-invalid',
               notify: {
                 onInvalid: function (comp, err) {
                   memInvalidIcon.getOpt(comp).each(function (invalidComp) {
-                    set$7(invalidComp.element, 'title', providersBackstage.translate(err));
+                    set$8(invalidComp.element, 'title', providersBackstage.translate(err));
                   });
+                }
               },
               validator: {
                 validate: function (input) {
     };
     var isElement = function (node) {
       return isNonNullable(node) && node.nodeType === 1;
     };
-    var trim = global$6.trim;
+    var trim = global$5.trim;
     var hasContentEditableState = function (value) {
       return function (node) {
         if (isElement(node)) {
           if (node.contentEditable === value) {
             return true;
       return isObject(r) && find$4(r, function (value) {
         return !isArrayOfUrl(value);
       }).isNone();
     };
     var getAllHistory = function () {
-      var unparsedHistory = global$9.getItem(STORAGE_KEY);
+      var unparsedHistory = global$8.getItem(STORAGE_KEY);
       if (unparsedHistory === null) {
         return {};
+      }
       var history;
       try {
     };
     var setAllHistory = function (history) {
       if (!isRecordOfUrlArray(history)) {
         throw new Error('Bad format for history:\n' + JSON.stringify(history));
+      }
-      global$9.setItem(STORAGE_KEY, JSON.stringify(history));
+      global$8.setItem(STORAGE_KEY, JSON.stringify(history));
     };
     var getHistory = function (fileType) {
       var history = getAllHistory();
       return get$e(history, fileType).getOr([]);
     };
     var isTruthy = function (value) {
       return !!value;
     };
     var makeMap = function (value) {
-      return map(global$6.makeMap(value, /[, ]/), isTruthy);
+      return map$1(global$5.makeMap(value, /[, ]/), isTruthy);
     };
     var getPicker = function (editor) {
       return Optional.from(getFilePickerCallback(editor)).filter(isFunction);
     };
     var getPickerTypes = function (editor) {
               return editor.ui.registry.getAll().icons;
             },
             menuItems: function () {
               return editor.ui.registry.getAll().menuItems;
             },
-            translate: global$f.translate,
+            translate: global$e.translate,
             isDisabled: function () {
               return editor.mode.isReadOnly() || editor.ui.isDisabled();
             },
             getSetting: editor.getParam.bind(editor)
           },
         });
       };
       var fireDismissPopups = function (evt) {
         return broadcastOn(dismissPopups(), { target: evt.target });
       };
+      var doc = getDocument();
-      var onTouchstart = bind(SugarElement.fromDom(document), 'touchstart', fireDismissPopups);
+      var onTouchstart = bind(doc, 'touchstart', fireDismissPopups);
-      var onTouchmove = bind(SugarElement.fromDom(document), 'touchmove', function (evt) {
+      var onTouchmove = bind(doc, 'touchmove', function (evt) {
         return broadcastEvent(documentTouchmove(), evt);
       });
-      var onTouchend = bind(SugarElement.fromDom(document), 'touchend', function (evt) {
+      var onTouchend = bind(doc, 'touchend', function (evt) {
         return broadcastEvent(documentTouchend(), evt);
       });
-      var onMousedown = bind(SugarElement.fromDom(document), 'mousedown', fireDismissPopups);
+      var onMousedown = bind(doc, 'mousedown', fireDismissPopups);
-      var onMouseup = bind(SugarElement.fromDom(document), 'mouseup', function (evt) {
+      var onMouseup = bind(doc, 'mouseup', function (evt) {
         if (evt.raw.button === 0) {
           broadcastOn(mouseReleased(), { target: evt.target });
+        }
       });
       var onContentClick = function (raw) {
         isDocked: isDocked$2,
         getBehaviours: getBehaviours$1
     });
     var getOffsetParent = function (element) {
-      var isFixed = is(getRaw(element, 'position'), 'fixed');
+      var isFixed = is$1(getRaw(element, 'position'), 'fixed');
       var offsetParent$1 = isFixed ? Optional.none() : offsetParent(element);
       return offsetParent$1.orThunk(function () {
         var marker = SugarElement.fromTag('span');
         return parent(element).bind(function (parent) {
           append$2(parent, marker);
           var offsetParent$1 = offsetParent(marker);
-          remove$7(marker);
+          remove$5(marker);
           return offsetParent$1;
         });
       });
     };
     var getOrigin = function (element) {
       { fixed: ['positionCss'] }
     ]);
     var appear = function (component, contextualInfo) {
       var elem = component.element;
       add$2(elem, contextualInfo.transitionClass);
-      remove$3(elem, contextualInfo.fadeOutClass);
+      remove$2(elem, contextualInfo.fadeOutClass);
       add$2(elem, contextualInfo.fadeInClass);
       contextualInfo.onShow(component);
     };
     var disappear = function (component, contextualInfo) {
       var elem = component.element;
       add$2(elem, contextualInfo.transitionClass);
-      remove$3(elem, contextualInfo.fadeInClass);
+      remove$2(elem, contextualInfo.fadeInClass);
       add$2(elem, contextualInfo.fadeOutClass);
       contextualInfo.onHide(component);
     };
     var isPartiallyVisible = function (box, viewport) {
       return box.y < viewport.bottom && box.bottom > viewport.y;
+        }
       });
     };
     var getPrior = function (elem, state) {
       return state.getInitialPos().map(function (pos) {
-        return bounds(pos.bounds.x, pos.bounds.y, get$7(elem), get$8(elem));
+        return bounds(pos.bounds.x, pos.bounds.y, get$a(elem), get$b(elem));
       });
     };
     var storePrior = function (elem, box, state) {
       state.setInitialPos({
         style: getAllRaw(elem),
-        position: get$a(elem, 'position') || 'static',
+        position: get$c(elem, 'position') || 'static',
         bounds: box
       });
     };
     var revertToOriginal = function (elem, box, state) {
       return state.getInitialPos().bind(function (position) {
         return Optional.none();
+      }
     };
     var getMorph = function (component, viewport, state) {
       var elem = component.element;
-      var isDocked = is(getRaw(elem, 'position'), 'fixed');
+      var isDocked = is$1(getRaw(elem, 'position'), 'fixed');
       return isDocked ? morphToOriginal(elem, viewport, state) : morphToFixed(elem, viewport, state);
     };
     var getMorphToOriginal = function (component, state) {
       var elem = component.element;
       return getPrior(elem, state).bind(function (box) {
         return revertToOriginal(elem, box, state);
       });
     };
-    var morphToStatic = function (component, config) {
+    var morphToStatic = function (component, config, state) {
+      state.setDocked(false);
       each$1([
         'left',
         'right',
         'top',
         'bottom',
         'position'
       ], function (prop) {
-        return remove$1(component.element, prop);
+        return remove$6(component.element, prop);
       });
       config.onUndocked(component);
     };
-    var morphToCoord = function (component, config, position) {
+    var morphToCoord = function (component, config, state, position) {
+      var isDocked = position.position === 'fixed';
+      state.setDocked(isDocked);
       applyPositionCss(component.element, position);
-      var method = position.position === 'fixed' ? config.onDocked : config.onUndocked;
+      var method = isDocked ? config.onDocked : config.onUndocked;
       method(component);
     };
     var updateVisibility = function (component, config, state, viewport, morphToDocked) {
       if (morphToDocked === void 0) {
         morphToDocked = false;
       var isDocked = state.isDocked();
       if (isDocked) {
         updateVisibility(component, config, state, viewport);
+      }
       getMorph(component, viewport, state).each(function (morph) {
-        state.setDocked(!isDocked);
         morph.fold(function () {
-          return morphToStatic(component, config);
+          return morphToStatic(component, config, state);
         }, function (position) {
-          return morphToCoord(component, config, position);
+          return morphToCoord(component, config, state, position);
         }, function (position) {
           updateVisibility(component, config, state, viewport, true);
-          morphToCoord(component, config, position);
+          morphToCoord(component, config, state, position);
         });
       });
     };
     var resetInternal = function (component, config, state) {
       var elem = component.element;
       state.setDocked(false);
       getMorphToOriginal(component, state).each(function (morph) {
         morph.fold(function () {
-          return morphToStatic(component, config);
+          return morphToStatic(component, config, state);
         }, function (position) {
-          return morphToCoord(component, config, position);
+          return morphToCoord(component, config, state, position);
         }, noop);
       });
       state.setVisible(true);
       config.contextual.each(function (contextInfo) {
-        remove$2(elem, [
+        remove$1(elem, [
           contextInfo.fadeInClass,
           contextInfo.fadeOutClass,
           contextInfo.transitionClass
         ]);
         contextInfo.onShow(component);
     var events$5 = function (dockInfo, dockState) {
       return derive$2([
         runOnSource(transitionend(), function (component, simulatedEvent) {
           dockInfo.contextual.each(function (contextInfo) {
             if (has(component.element, contextInfo.transitionClass)) {
-              remove$2(component.element, [
+              remove$1(component.element, [
                 contextInfo.transitionClass,
                 contextInfo.fadeInClass
               ]);
               var notify = dockState.isVisible() ? contextInfo.onShown : contextInfo.onHidden;
               notify(component);
     var editorStickyOnClass = 'tox-tinymce--toolbar-sticky-on';
     var editorStickyOffClass = 'tox-tinymce--toolbar-sticky-off';
     var scrollFromBehindHeader = function (e, containerHeader) {
       var doc = owner$4(containerHeader);
       var viewHeight = doc.dom.defaultView.innerHeight;
-      var scrollPos = get$6(doc);
+      var scrollPos = get$9(doc);
       var markerElement = SugarElement.fromDom(e.elm);
       var markerPos = absolute$2(markerElement);
-      var markerHeight = get$8(markerElement);
+      var markerHeight = get$b(markerElement);
       var markerTop = markerPos.y;
       var markerBottom = markerTop + markerHeight;
       var editorHeaderPos = absolute$3(containerHeader);
-      var editorHeaderHeight = get$8(containerHeader);
+      var editorHeaderHeight = get$b(containerHeader);
       var editorHeaderTop = editorHeaderPos.top;
       var editorHeaderBottom = editorHeaderTop + editorHeaderHeight;
       var editorHeaderDockedAtTop = Math.abs(editorHeaderTop - scrollPos.top) < 2;
       var editorHeaderDockedAtBottom = Math.abs(editorHeaderBottom - (scrollPos.top + viewHeight)) < 2;
       if (editorHeaderDockedAtTop && markerTop < editorHeaderBottom) {
     var isDockedMode = function (header, mode) {
       return contains$2(Docking.getModes(header), mode);
     };
     var updateIframeContentFlow = function (header) {
       var getOccupiedHeight = function (elm) {
-        return getOuter$1(elm) + (parseInt(get$a(elm, 'margin-top'), 10) || 0) + (parseInt(get$a(elm, 'margin-bottom'), 10) || 0);
+        return getOuter$2(elm) + (parseInt(get$c(elm, 'margin-top'), 10) || 0) + (parseInt(get$c(elm, 'margin-bottom'), 10) || 0);
       };
       var elm = header.element;
       parent(elm).each(function (parentElem) {
         var padding = 'padding-' + Docking.getModes(header)[0];
         if (Docking.isDocked(header)) {
-          var parentWidth = get$7(parentElem);
+          var parentWidth = get$a(parentElem);
-          set$6(elm, 'width', parentWidth + 'px');
+          set$7(elm, 'width', parentWidth + 'px');
-          set$6(parentElem, padding, getOccupiedHeight(elm) + 'px');
+          set$7(parentElem, padding, getOccupiedHeight(elm) + 'px');
         } else {
-          remove$1(elm, 'width');
+          remove$6(elm, 'width');
-          remove$1(parentElem, padding);
+          remove$6(parentElem, padding);
+        }
       });
     };
     var updateSinkVisibility = function (sinkElem, visible) {
       if (visible) {
-        remove$3(sinkElem, visibility.fadeOutClass);
+        remove$2(sinkElem, visibility.fadeOutClass);
         add$1(sinkElem, [
           visibility.transitionClass,
           visibility.fadeInClass
         ]);
       } else {
-        remove$3(sinkElem, visibility.fadeInClass);
+        remove$2(sinkElem, visibility.fadeInClass);
         add$1(sinkElem, [
           visibility.fadeOutClass,
           visibility.transitionClass
         ]);
+      }
     };
     var updateEditorClasses = function (editor, docked) {
       var editorContainer = SugarElement.fromDom(editor.getContainer());
       if (docked) {
         add$2(editorContainer, editorStickyOnClass);
-        remove$3(editorContainer, editorStickyOffClass);
+        remove$2(editorContainer, editorStickyOffClass);
       } else {
         add$2(editorContainer, editorStickyOffClass);
-        remove$3(editorContainer, editorStickyOnClass);
+        remove$2(editorContainer, editorStickyOnClass);
+      }
     };
     var restoreFocus = function (headerElem, focusedElem) {
       var ownerDoc = owner$4(focusedElem);
       active(ownerDoc).filter(function (activeElm) {
       return __spreadArray([
         Focusing.config({}),
         Docking.config({
           contextual: __assign({
             lazyContext: function (comp) {
-              var headerHeight = getOuter$1(comp.element);
+              var headerHeight = getOuter$2(comp.element);
               var container = editor.inline ? editor.getContentAreaContainer() : editor.getContainer();
               var box = box$1(SugarElement.fromDom(container));
               var boxHeight = box.height - headerHeight;
               var topBound = box.y + (isDockedMode(comp, 'top') ? 0 : headerHeight);
               return Optional.some(bounds(box.x, topBound, box.width, boxHeight));
                 return updateSinkVisibility(elem, true);
               });
             },
             onShown: function (comp) {
               runOnSinkElement(function (elem) {
-                return remove$2(elem, [
+                return remove$1(elem, [
                   visibility.transitionClass,
                   visibility.fadeInClass
                 ]);
               });
               focusedElm.get().each(function (elem) {
                 return updateSinkVisibility(elem, false);
               });
             },
             onHidden: function () {
               runOnSinkElement(function (elem) {
-                return remove$2(elem, [visibility.transitionClass]);
+                return remove$1(elem, [visibility.transitionClass]);
               });
+            }
           }, visibility),
           lazyViewport: function (comp) {
             var win$1 = win();
           },
           modes: [sharedBackstage.header.getDockingMode()],
           onDocked: onDockingSwitch,
           onUndocked: onDockingSwitch
         })
-      ], additionalBehaviours);
+      ], additionalBehaviours, true);
     };
     var StickyHeader = /*#__PURE__*/Object.freeze({
         __proto__: null,
         setup: setup$9,
       defaultedFunction('onSetup', function () {
         return noop;
       })
     ];
-    var MenuButtonSchema = objOf(__spreadArray([requiredString('type')], baseMenuButtonFields));
+    var MenuButtonSchema = objOf(__spreadArray([requiredString('type')], baseMenuButtonFields, true));
     var createMenuButton = function (spec) {
       return asRaw('menubutton', MenuButtonSchema, spec);
     };
     var splitButtonSchema = objOf([
     var getDimension = function (slideConfig, elem) {
       return slideConfig.dimension.getDimension(elem);
     };
     var disableTransitions = function (component, slideConfig) {
       var root = getAnimationRoot(component, slideConfig);
-      remove$2(root, [
+      remove$1(root, [
         slideConfig.shrinkingClass,
         slideConfig.growingClass
       ]);
     };
     var setShrunk = function (component, slideConfig) {
-      remove$3(component.element, slideConfig.openClass);
+      remove$2(component.element, slideConfig.openClass);
       add$2(component.element, slideConfig.closedClass);
-      set$6(component.element, getDimensionProperty(slideConfig), '0px');
+      set$7(component.element, getDimensionProperty(slideConfig), '0px');
       reflow(component.element);
     };
     var setGrown = function (component, slideConfig) {
-      remove$3(component.element, slideConfig.closedClass);
+      remove$2(component.element, slideConfig.closedClass);
       add$2(component.element, slideConfig.openClass);
-      remove$1(component.element, getDimensionProperty(slideConfig));
+      remove$6(component.element, getDimensionProperty(slideConfig));
     };
     var doImmediateShrink = function (component, slideConfig, slideState, _calculatedSize) {
       slideState.setCollapsed();
-      set$6(component.element, getDimensionProperty(slideConfig), getDimension(slideConfig, component.element));
+      set$7(component.element, getDimensionProperty(slideConfig), getDimension(slideConfig, component.element));
       reflow(component.element);
       disableTransitions(component, slideConfig);
       setShrunk(component, slideConfig);
       slideConfig.onStartShrink(component);
       slideConfig.onShrunk(component);
     var doStartShrink = function (component, slideConfig, slideState, calculatedSize) {
       var size = calculatedSize.getOrThunk(function () {
         return getDimension(slideConfig, component.element);
       });
       slideState.setCollapsed();
-      set$6(component.element, getDimensionProperty(slideConfig), size);
+      set$7(component.element, getDimensionProperty(slideConfig), size);
       reflow(component.element);
       var root = getAnimationRoot(component, slideConfig);
-      remove$3(root, slideConfig.growingClass);
+      remove$2(root, slideConfig.growingClass);
       add$2(root, slideConfig.shrinkingClass);
       setShrunk(component, slideConfig);
       slideConfig.onStartShrink(component);
     };
     var doStartSmartShrink = function (component, slideConfig, slideState) {
       var wasShrinking = has(root, slideConfig.shrinkingClass);
       var beforeSize = getDimension(slideConfig, component.element);
       setGrown(component, slideConfig);
       var fullSize = getDimension(slideConfig, component.element);
       var startPartialGrow = function () {
-        set$6(component.element, getDimensionProperty(slideConfig), beforeSize);
+        set$7(component.element, getDimensionProperty(slideConfig), beforeSize);
         reflow(component.element);
       };
       var startCompleteGrow = function () {
         setShrunk(component, slideConfig);
       };
       var setStartSize = wasShrinking ? startPartialGrow : startCompleteGrow;
       setStartSize();
-      remove$3(root, slideConfig.shrinkingClass);
+      remove$2(root, slideConfig.shrinkingClass);
       add$2(root, slideConfig.growingClass);
       setGrown(component, slideConfig);
-      set$6(component.element, getDimensionProperty(slideConfig), fullSize);
+      set$7(component.element, getDimensionProperty(slideConfig), fullSize);
       slideState.setExpanded();
       slideConfig.onStartGrow(component);
     };
     var refresh$3 = function (component, slideConfig, slideState) {
       if (slideState.isExpanded()) {
-        remove$1(component.element, getDimensionProperty(slideConfig));
+        remove$6(component.element, getDimensionProperty(slideConfig));
         var fullSize = getDimension(slideConfig, component.element);
-        set$6(component.element, getDimensionProperty(slideConfig), fullSize);
+        set$7(component.element, getDimensionProperty(slideConfig), fullSize);
+      }
     };
     var grow = function (component, slideConfig, slideState) {
       if (!slideState.isExpanded()) {
         doStartGrow(component, slideConfig, slideState);
       return derive$2([runOnSource(transitionend(), function (component, simulatedEvent) {
           var raw = simulatedEvent.event.raw;
           if (raw.propertyName === slideConfig.dimension.property) {
             disableTransitions(component, slideConfig);
             if (slideState.isExpanded()) {
-              remove$1(component.element, slideConfig.dimension.property);
+              remove$6(component.element, slideConfig.dimension.property);
+            }
             var notify = slideState.isExpanded() ? slideConfig.onGrown : slideConfig.onShrunk;
             notify(component);
+          }
         })]);
       defaulted('expanded', false),
       requiredOf('dimension', choose$1('property', {
         width: [
           output$1('property', 'width'),
           output$1('getDimension', function (elem) {
-            return get$7(elem) + 'px';
+            return get$a(elem) + 'px';
           })
         ],
         height: [
           output$1('property', 'height'),
           output$1('getDimension', function (elem) {
-            return get$8(elem) + 'px';
+            return get$b(elem) + 'px';
           })
+        ]
       }))
     ];
             return f(container, key);
           });
         };
       };
       var doShowing = function (comp, _key) {
-        return get$c(comp.element, 'aria-hidden') !== 'true';
+        return get$d(comp.element, 'aria-hidden') !== 'true';
       };
       var doShow = function (comp, key) {
         if (!doShowing(comp)) {
           var element = comp.element;
-          remove$1(element, 'display');
+          remove$6(element, 'display');
-          remove$6(element, 'aria-hidden');
+          remove$7(element, 'aria-hidden');
           emitWith(comp, slotVisibility(), {
             name: key,
             visible: true
           });
+        }
       };
       var doHide = function (comp, key) {
         if (doShowing(comp)) {
           var element = comp.element;
-          set$6(element, 'display', 'none');
+          set$7(element, 'display', 'none');
-          set$7(element, 'aria-hidden', 'true');
+          set$8(element, 'aria-hidden', 'true');
           emitWith(comp, slotVisibility(), {
             name: key,
             visible: false
           });
+        }
         components: components,
         behaviours: get$2(detail.slotBehaviours),
         apis: apis
       };
     };
-    var slotApis = map({
+    var slotApis = map$1({
       getSlotNames: function (apis, c) {
         return apis.getSlotNames(c);
       },
       getSlot: function (apis, c, key) {
         return apis.getSlot(c, key);
     var setup$8 = function (editor) {
       var sidebars = editor.ui.registry.getAll().sidebars;
       each$1(keys(sidebars), function (name) {
         var spec = sidebars[name];
         var isActive = function () {
-          return is(Optional.from(editor.queryCommandValue('ToggleSidebar')), name);
+          return is$1(Optional.from(editor.queryCommandValue('ToggleSidebar')), name);
         };
         editor.ui.registry.addToggleButton(name, {
           icon: spec.icon,
           tooltip: spec.tooltip,
           onAction: function (buttonApi) {
                 },
                 onStartGrow: function (slider) {
                   emitWith(slider, fixSize, { width: getRaw(slider.element, 'width').getOr('') });
                 },
                 onStartShrink: function (slider) {
-                  emitWith(slider, fixSize, { width: get$7(slider.element) + 'px' });
+                  emitWith(slider, fixSize, { width: get$a(slider.element) + 'px' });
+                }
               }),
               Replacing.config({}),
               Composing.config({
                 find: function (comp) {
           }],
         behaviours: derive$1([
           ComposingConfigs.childAt(0),
           config('sidebar-sliding-events', [
             run$1(fixSize, function (comp, se) {
-              set$6(comp.element, 'width', se.event.width);
+              set$7(comp.element, 'width', se.event.width);
             }),
             run$1(autoSize, function (comp, _se) {
-              remove$1(comp.element, 'width');
+              remove$6(comp.element, 'width');
             })
           ])
         ])
       };
     };
     var block = function (component, config, state, getBusySpec) {
-      set$7(component.element, 'aria-busy', true);
+      set$8(component.element, 'aria-busy', true);
       var root = config.getRoot(component).getOr(component);
       var blockerBehaviours = derive$1([
         Keying.config({
           mode: 'special',
           onTab: function () {
       state.blockWith(function () {
         return Replacing.remove(root, blocker);
       });
     };
     var unblock = function (component, config, state) {
-      remove$6(component.element, 'aria-busy');
+      remove$7(component.element, 'aria-busy');
       if (state.isBlocked()) {
         config.onUnblock(component);
+      }
       state.clear();
     };
     var fromHtml = function (html) {
       var elem = SugarElement.fromHtml(html);
       var children$1 = children(elem);
       var attrs = getAttrs(elem);
       var classes = getClasses(elem);
-      var contents = children$1.length === 0 ? {} : { innerHtml: get$d(elem) };
+      var contents = children$1.length === 0 ? {} : { innerHtml: get$7(elem) };
       return __assign({
         tag: name$2(elem),
         classes: classes,
         attributes: attrs
       }, contents);
       var tabIndexAttr = 'tabindex';
       var dataTabIndexAttr = 'data-mce-' + tabIndexAttr;
       Optional.from(editor.iframeElement).map(SugarElement.fromDom).each(function (iframe) {
         if (state) {
           getOpt(iframe, tabIndexAttr).each(function (tabIndex) {
-            return set$7(iframe, dataTabIndexAttr, tabIndex);
+            return set$8(iframe, dataTabIndexAttr, tabIndex);
           });
-          set$7(iframe, tabIndexAttr, -1);
+          set$8(iframe, tabIndexAttr, -1);
         } else {
-          remove$6(iframe, tabIndexAttr);
+          remove$7(iframe, tabIndexAttr);
           getOpt(iframe, dataTabIndexAttr).each(function (tabIndex) {
-            set$7(iframe, tabIndexAttr, tabIndex);
+            set$8(iframe, tabIndexAttr, tabIndex);
-            remove$6(iframe, dataTabIndexAttr);
+            remove$7(iframe, dataTabIndexAttr);
           });
+        }
       });
     };
     var toggleThrobber = function (editor, comp, state, providerBackstage) {
       var element = comp.element;
       toggleEditorTabIndex(editor, state);
       if (state) {
         Blocking.block(comp, getBusySpec$1(providerBackstage));
-        remove$1(element, 'display');
+        remove$6(element, 'display');
-        remove$6(element, 'aria-hidden');
+        remove$7(element, 'aria-hidden');
         if (editor.hasFocus()) {
           focusBusyComponent(comp);
+        }
       } else {
         var throbberFocus = Composing.getCurrent(comp).exists(function (busyComp) {
           return hasFocus(busyComp.element);
         });
         Blocking.unblock(comp);
-        set$6(element, 'display', 'none');
+        set$7(element, 'display', 'none');
-        set$7(element, 'aria-hidden', 'true');
+        set$8(element, 'aria-hidden', 'true');
         if (throbberFocus) {
           editor.focus();
+        }
+      }
     };
           toggleThrobber(editor, lazyThrobber(), state, sharedBackstage.providers);
           editor.fire('AfterProgressState', { state: state });
+        }
       };
       editor.on('ProgressState', function (e) {
-        timer.on(global$g.clearTimeout);
+        timer.on(global$f.clearTimeout);
         if (isNumber(e.time)) {
-          var timerId = global$g.setEditorTimeout(editor, function () {
+          var timerId = global$f.setEditorTimeout(editor, function () {
             return toggle(e.state);
           }, e.time);
           timer.set(timerId);
         } else {
           toggle(e.state);
       if (builtGroups.length === 0) {
         return;
+      }
       var primary = getPartOrDie(toolbar, detail, 'primary');
       var overflowGroup = Coupling.getCoupled(toolbar, 'overflowGroup');
-      set$6(primary.element, 'visibility', 'hidden');
+      set$7(primary.element, 'visibility', 'hidden');
       var groups = builtGroups.concat([overflowGroup]);
       var focusedComp = findFocusedComp(groups);
       setOverflow([]);
       setGroups$1(primary, groups);
-      var availableWidth = get$7(primary.element);
+      var availableWidth = get$a(primary.element);
       var overflows = partition(availableWidth, detail.builtGroups.get(), function (comp) {
-        return get$7(comp.element);
+        return get$a(comp.element);
       }, overflowGroup);
       if (overflows.extra.length === 0) {
         Replacing.remove(primary, overflowGroup);
         setOverflow([]);
       } else {
         setGroups$1(primary, overflows.within);
         setOverflow(overflows.extra);
+      }
-      remove$1(primary.element, 'visibility');
+      remove$6(primary.element, 'visibility');
       reflow(primary.element);
       focusedComp.each(Focusing.focus);
     };
     var schema$c = constant$1([
         return fireSkinLoadError$1(editor, { message: err });
       };
     };
     var loadStylesheet = function (editor, stylesheetUrl, styleSheetLoader) {
-      return new global$d(function (resolve, reject) {
+      return new global$c(function (resolve, reject) {
         styleSheetLoader.load(stylesheetUrl, resolve, reject);
         editor.on('remove', function () {
           return styleSheetLoader.unload(stylesheetUrl);
         });
       });
     };
     var loadShadowDomUiSkins = function (editor, skinUrl) {
       var isInShadowRoot$1 = isInShadowRoot(SugarElement.fromDom(editor.getElement()));
       if (isInShadowRoot$1) {
         var shadowDomSkinCss = skinUrl + '/skin.shadowdom.min.css';
-        return loadStylesheet(editor, shadowDomSkinCss, global$c.DOM.styleSheetLoader);
+        return loadStylesheet(editor, shadowDomSkinCss, global$b.DOM.styleSheetLoader);
       } else {
-        return global$d.resolve();
+        return global$c.resolve();
+      }
     };
     var loadSkin = function (isInline, editor) {
       var skinUrl = getSkinUrl(editor);
       if (skinUrl) {
         editor.contentCSS.push(skinUrl + (isInline ? '/content.inline' : '/content') + '.min.css');
+      }
       if (isSkinDisabled(editor) === false && isString(skinUrl)) {
-        global$d.all([
+        global$c.all([
           loadUiSkins(editor, skinUrl),
           loadShadowDomUiSkins(editor, skinUrl)
         ]).then(fireSkinLoaded(editor), fireSkinLoadError(editor, 'Skin could not be loaded'));
       } else {
         fireSkinLoaded(editor)();
       };
       var buttonEvents = __assign(__assign({}, derive$2([runOnAttached(function (component, _simulatedEvent) {
           var ariaDescriptor = getPart(component, detail, 'aria-descriptor');
           ariaDescriptor.each(function (descriptor) {
             var descriptorId = generate$6('aria');
-            set$7(descriptor.element, 'id', descriptorId);
+            set$8(descriptor.element, 'id', descriptorId);
-            set$7(component.element, 'aria-describedby', descriptorId);
+            set$8(component.element, 'aria-describedby', descriptorId);
           });
         })])), events$a(Optional.some(action)));
       var apis = {
         repositionMenus: function (comp) {
           if (Toggling.isOn(comp)) {
           setDisabled: function (state) {
             return Disabling.set(comp, state);
           },
           setIconFill: function (id, value) {
             descendant(comp.element, 'svg path[id="' + id + '"], rect[id="' + id + '"]').each(function (underlinePath) {
-              set$7(underlinePath, 'fill', value);
+              set$8(underlinePath, 'fill', value);
             });
           },
           setIconStroke: function (id, value) {
             descendant(comp.element, 'svg path[id="' + id + '"], rect[id="' + id + '"]').each(function (underlinePath) {
-              set$7(underlinePath, 'stroke', value);
+              set$8(underlinePath, 'stroke', value);
             });
           },
           setActive: function (state) {
-            set$7(comp.element, 'aria-pressed', state);
+            set$8(comp.element, 'aria-pressed', state);
             descendant(comp.element, 'span').each(function (button) {
               comp.getSystem().getByDom(button).each(function (buttonComp) {
                 return Toggling.set(buttonComp, state);
               });
             });
       dom.bind(contentWindow, 'resize', resizeWindow);
       dom.bind(contentWindow, 'scroll', scroll);
       var elementLoad = capture(SugarElement.fromDom(editor.getBody()), 'load', resizeDocument);
       var mothership = uiComponents.uiMothership.element;
       editor.on('hide', function () {
-        set$6(mothership, 'display', 'none');
+        set$7(mothership, 'display', 'none');
       });
       editor.on('show', function () {
-        remove$1(mothership, 'display');
+        remove$6(mothership, 'display');
       });
       editor.on('NodeChange', resizeDocument);
       editor.on('remove', function () {
         elementLoad.unbind();
         dom.unbind(contentWindow, 'resize', resizeWindow);
       return width.getOr(getWidthSetting(editor));
     };
     var InlineHeader = function (editor, targetElm, uiComponents, backstage, floatContainer) {
       var uiMothership = uiComponents.uiMothership, outerContainer = uiComponents.outerContainer;
-      var DOM = global$c.DOM;
+      var DOM = global$b.DOM;
       var useFixedToolbarContainer = useFixedContainer(editor);
       var isSticky = isStickyToolbar(editor);
       var editorMaxWidthOpt = getMaxWidthSetting(editor).or(getWidth(editor));
       var headerBackstage = backstage.shared.header;
       var isPositionedAtTop = headerBackstage.isPositionedAtTop;
       var isVisible = function () {
         return visible.get() && !editor.removed;
       };
       var calcToolbarOffset = function (toolbar) {
         return isSplitToolbar ? toolbar.fold(constant$1(0), function (tbar) {
-          return tbar.components().length > 1 ? get$8(tbar.components()[1].element) : 0;
+          return tbar.components().length > 1 ? get$b(tbar.components()[1].element) : 0;
         }) : 0;
       };
       var calcMode = function (container) {
         switch (getToolbarLocation(editor)) {
         case ToolbarLocation.auto:
           var toolbar_1 = OuterContainer.getToolbar(outerContainer);
           var offset = calcToolbarOffset(toolbar_1);
-          var toolbarHeight = get$8(container.element) - offset;
+          var toolbarHeight = get$b(container.element) - offset;
           var targetBounds = box$1(targetElm);
           var roomAtTop = targetBounds.y > toolbarHeight;
           if (roomAtTop) {
             return 'top';
           } else {
             var doc = documentElement(targetElm);
-            var docHeight = Math.max(doc.dom.scrollHeight, get$8(doc));
+            var docHeight = Math.max(doc.dom.scrollHeight, get$b(doc));
             var roomAtBottom = targetBounds.bottom < docHeight - toolbarHeight;
             if (roomAtBottom) {
               return 'bottom';
             } else {
               var winBounds = win();
       var setupMode = function (mode) {
         var container = floatContainer.get();
         Docking.setModes(container, [mode]);
         headerBackstage.setDockingMode(mode);
         var verticalDir = isPositionedAtTop() ? AttributeValue.TopToBottom : AttributeValue.BottomToTop;
-        set$7(container.element, Attribute, verticalDir);
+        set$8(container.element, Attribute, verticalDir);
       };
       var updateChromeWidth = function () {
         var maxWidth = editorMaxWidthOpt.getOrThunk(function () {
-          var bodyMargin = parseToInt(get$a(body(), 'margin-left')).getOr(0);
+          var bodyMargin = parseToInt(get$c(body(), 'margin-left')).getOr(0);
-          return get$7(body()) - absolute$3(targetElm).left + bodyMargin;
+          return get$a(body()) - absolute$3(targetElm).left + bodyMargin;
         });
-        set$6(floatContainer.get().element, 'max-width', maxWidth + 'px');
+        set$7(floatContainer.get().element, 'max-width', maxWidth + 'px');
       };
       var updateChromePosition = function () {
         var toolbar = OuterContainer.getToolbar(outerContainer);
         var offset = calcToolbarOffset(toolbar);
         var targetBounds = box$1(targetElm);
-        var top = isPositionedAtTop() ? Math.max(targetBounds.y - get$8(floatContainer.get().element) + offset, 0) : targetBounds.bottom;
+        var top = isPositionedAtTop() ? Math.max(targetBounds.y - get$b(floatContainer.get().element) + offset, 0) : targetBounds.bottom;
         setAll(outerContainer.element, {
           position: 'absolute',
           top: Math.round(top) + 'px',
           left: Math.round(targetBounds.x) + 'px'
         });
+          }
+        }
       };
       var show = function () {
         visible.set(true);
-        set$6(outerContainer.element, 'display', 'flex');
+        set$7(outerContainer.element, 'display', 'flex');
         DOM.addClass(editor.getBody(), 'mce-edit-focus');
-        remove$1(uiMothership.element, 'display');
+        remove$6(uiMothership.element, 'display');
         updateMode(false);
         updateChromeUi();
       };
       var hide = function () {
         visible.set(false);
         if (uiComponents.outerContainer) {
-          set$6(outerContainer.element, 'display', 'none');
+          set$7(outerContainer.element, 'display', 'none');
           DOM.removeClass(editor.getBody(), 'mce-edit-focus');
+        }
-        set$6(uiMothership.element, 'display', 'none');
+        set$7(uiMothership.element, 'display', 'none');
       };
       return {
         isVisible: isVisible,
         isPositionedAtTop: isPositionedAtTop,
         show: show,
+      }
       editor.on('SkinLoaded ResizeWindow', function () {
         return ui.update(true);
       });
       editor.on('NodeChange keydown', function (e) {
-        global$g.requestAnimationFrame(function () {
+        global$f.requestAnimationFrame(function () {
           return resizeContent(e);
         });
       });
       editor.on('ScrollWindow', function () {
         return ui.updateMode();
         ui.show();
         setupEvents(editor, targetElm, ui, toolbarPersist);
         editor.nodeChanged();
       };
       var delayedRender = function () {
-        return global$g.setEditorTimeout(editor, render, 0);
+        return global$f.setEditorTimeout(editor, render, 0);
       };
       editor.on('show', render);
       editor.on('hide', ui.hide);
       if (!toolbarPersist) {
         editor.on('focus', delayedRender);
     };
     var getSelectionBounds = function (editor) {
       var rng = editor.selection.getRng();
       var rect = getRangeRect(rng);
       if (editor.inline) {
-        var scroll_1 = get$6();
+        var scroll_1 = get$9();
         return bounds(scroll_1.left + rect.left, scroll_1.top + rect.top, rect.width, rect.height);
       } else {
         var bodyPos = absolute$2(SugarElement.fromDom(editor.getBody()));
         return bounds(bodyPos.x + rect.left, bodyPos.y + rect.top, rect.width, rect.height);
+      }
       var leaf$1 = leaf(SugarElement.fromDom(rng.startContainer), rng.startOffset);
       return rng.startContainer === rng.endContainer && rng.startOffset === rng.endOffset - 1 && eq(leaf$1.element, elem);
     };
     var preservePosition = function (elem, position, f) {
       var currentPosition = getRaw(elem, 'position');
-      set$6(elem, 'position', position);
+      set$7(elem, 'position', position);
       var result = f(elem);
       currentPosition.each(function (pos) {
-        return set$6(elem, 'position', pos);
+        return set$7(elem, 'position', pos);
       });
       return result;
     };
     var shouldUseInsetLayouts = function (position) {
       return position === 'node';
         return preservePosition(contextbar, data.getMode(), function () {
           var isOverlapping = isVerticalOverlap(selectionBounds, box$1(contextbar));
           return isOverlapping && !data.isReposition() ? flip$2 : preserve;
         });
       } else {
-        var yBounds = data.getMode() === 'fixed' ? bounds.y + get$6().top : bounds.y;
+        var yBounds = data.getMode() === 'fixed' ? bounds.y + get$9().top : bounds.y;
-        var contextbarHeight = get$8(contextbar) + bubbleSize$1;
+        var contextbarHeight = get$b(contextbar) + bubbleSize$1;
         return yBounds + contextbarHeight <= selectionBounds.y ? north : south;
+      }
     };
     var getAnchorSpec$2 = function (editor, mobile, data, position) {
       var smartInsetLayout = function (elem) {
         },
         fireDismissalEventInstead: { event: 'doNotDismissYet' },
         onShow: function (comp) {
           stack.set([]);
           InlineView.getContent(comp).each(function (c) {
-            remove$1(c.element, 'visibility');
+            remove$6(c.element, 'visibility');
           });
-          remove$3(comp.element, resizingClass);
+          remove$2(comp.element, resizingClass);
-          remove$1(comp.element, 'width');
+          remove$6(comp.element, 'width');
         },
         inlineBehaviours: derive$1([
           config('context-toolbar-events', [
             runOnSource(transitionend(), function (comp, se) {
               if (se.event.raw.propertyName === 'width') {
-                remove$3(comp.element, resizingClass);
+                remove$2(comp.element, resizingClass);
-                remove$1(comp.element, 'width');
+                remove$6(comp.element, 'width');
+              }
             }),
             run$1(changeSlideEvent, function (comp, se) {
               var elem = comp.element;
-              remove$1(elem, 'width');
+              remove$6(elem, 'width');
-              var currentWidth = get$7(elem);
+              var currentWidth = get$a(elem);
               InlineView.setContent(comp, se.event.contents);
               add$2(elem, resizingClass);
-              var newWidth = get$7(elem);
+              var newWidth = get$a(elem);
-              set$6(elem, 'width', currentWidth + 'px');
+              set$7(elem, 'width', currentWidth + 'px');
               InlineView.getContent(comp).each(function (newContents) {
                 se.event.focus.bind(function (f) {
                   focus$3(f);
                   return search(elem);
                 }).orThunk(function () {
                   Keying.focusIn(newContents);
                   return active(getRootNode(elem));
                 });
               });
-              global$g.setTimeout(function () {
+              global$f.setTimeout(function () {
-                set$6(comp.element, 'width', newWidth + 'px');
+                set$7(comp.element, 'width', newWidth + 'px');
               }, 0);
             }),
             run$1(forwardSlideEvent, function (comp, se) {
               InlineView.getContent(comp).each(function (oldContents) {
                 stack.set(stack.get().concat([{
       };
       var canLaunchToolbar = function () {
         return !editor.removed && !(isTouch() && backstage.isContextMenuOpen());
       };
       var isSameLaunchElement = function (elem) {
-        return is(lift2(elem, lastElement.get(), eq), true);
+        return is$1(lift2(elem, lastElement.get(), eq), true);
       };
       var shouldContextToolbarHide = function () {
         if (!canLaunchToolbar()) {
           return true;
         } else {
           var contextToolbarBounds = getBounds();
-          var anchorBounds = is(lastContextPosition.get(), 'node') ? getAnchorElementBounds(editor, lastElement.get()) : getSelectionBounds(editor);
+          var anchorBounds = is$1(lastContextPosition.get(), 'node') ? getAnchorElementBounds(editor, lastElement.get()) : getSelectionBounds(editor);
           return contextToolbarBounds.height <= 0 || !isVerticalOverlap(anchorBounds, contextToolbarBounds);
+        }
       };
       var close = function () {
         lastElement.clear();
         InlineView.hide(contextbar);
       };
       var hideOrRepositionIfNecessary = function () {
         if (InlineView.isOpen(contextbar)) {
           var contextBarEle = contextbar.element;
-          remove$1(contextBarEle, 'display');
+          remove$6(contextBarEle, 'display');
           if (shouldContextToolbarHide()) {
-            set$6(contextBarEle, 'display', 'none');
+            set$7(contextBarEle, 'display', 'none');
           } else {
             lastTrigger.set(0);
             InlineView.reposition(contextbar);
+          }
+        }
       var getAnchor = function (position, element) {
         var anchorage = position === 'node' ? sharedBackstage.anchors.node(element) : sharedBackstage.anchors.cursor();
         var anchorLayout = getAnchorLayout(editor, position, isTouch(), {
           lastElement: lastElement.get,
           isReposition: function () {
-            return is(lastTrigger.get(), 0);
+            return is$1(lastTrigger.get(), 0);
           },
           getMode: function () {
             return Positioning.getMode(sink);
+          }
         });
         var position = toolbarApi[0].position;
         var anchor = getAnchor(position, elem);
         lastContextPosition.set(position);
         lastTrigger.set(1);
         var contextBarEle = contextbar.element;
-        remove$1(contextBarEle, 'display');
+        remove$6(contextBarEle, 'display');
         if (!isSameLaunchElement(elem)) {
-          remove$3(contextBarEle, transitionClass);
+          remove$2(contextBarEle, transitionClass);
           Positioning.reset(sink, contextbar);
+        }
         InlineView.showWithinBounds(contextbar, wrapInPopDialog(toolbarSpec), {
           anchor: anchor,
           transition: {
         }, function () {
           return Optional.some(getBounds());
         });
         elem.fold(lastElement.clear, lastElement.set);
         if (shouldContextToolbarHide()) {
-          set$6(contextBarEle, 'display', 'none');
+          set$7(contextBarEle, 'display', 'none');
+        }
       };
       var launchContextToolbar = last(function () {
         if (!editor.hasFocus() || editor.removed) {
           return;
             launchContext([ctx], someIf(e.target !== editor, e.target));
             InlineView.getContent(contextbar).each(Keying.focusIn);
           });
         });
         editor.on('focusout', function (_e) {
-          global$g.setEditorTimeout(editor, function () {
+          global$f.setEditorTimeout(editor, function () {
             if (search(sink.element).isNone() && search(contextbar.element).isNone()) {
               close();
+            }
           }, 0);
         });
                   });
                   current.set(api);
+                }
                 api.setActive(active);
               };
-              setActive(is(initial, spec.hash(value)));
+              setActive(is$1(initial, spec.hash(value)));
               var unbindWatcher = spec.watcher(editor, value, setActive);
               return function () {
                 current.clear();
                 unbindWatcher();
               };
       return function () {
         editor.execCommand('mceToggleFormat', false, fmt);
       };
     };
     var registerFormatButtons = function (editor) {
-      global$6.each([
+      global$5.each([
+        {
           name: 'bold',
           text: 'Bold',
           icon: 'bold'
         },
           onAction: onActionToggleFormat(editor, name_1)
         });
+      }
     };
     var registerCommandButtons = function (editor) {
-      global$6.each([
+      global$5.each([
+        {
           name: 'cut',
           text: 'Cut',
           action: 'Cut',
           icon: 'cut'
           onAction: onActionExecCommand(editor, btn.action)
         });
       });
     };
     var registerCommandToggleButtons = function (editor) {
-      global$6.each([{
+      global$5.each([{
           name: 'blockquote',
           text: 'Blockquote',
           action: 'mceBlockQuote',
           icon: 'quote'
         }], function (btn) {
       registerFormatButtons(editor);
       registerCommandButtons(editor);
       registerCommandToggleButtons(editor);
     };
     var registerMenuItems$2 = function (editor) {
-      global$6.each([
+      global$5.each([
+        {
           name: 'bold',
           text: 'Bold',
           action: 'Bold',
           icon: 'bold',
       } else {
         return nu(e.clientX, e.clientY);
+      }
     };
     var transposeContentAreaContainer = function (element, pos) {
-      var containerPos = global$c.DOM.getPos(element);
+      var containerPos = global$b.DOM.getPos(element);
       return transpose(pos, containerPos.x, containerPos.y);
     };
     var getPointAnchor = function (editor, e) {
       if (e.type === 'contextmenu' || e.type === 'longpress') {
         if (editor.inline) {
+      }
     };
     var setupiOSOverrides = function (editor) {
       var originalSelection = editor.selection.getRng();
       var selectionReset = function () {
-        global$g.setEditorTimeout(editor, function () {
+        global$f.setEditorTimeout(editor, function () {
           editor.selection.setRng(originalSelection);
         }, 10);
         unbindEventListeners();
       };
       editor.once('touchend', selectionReset);
     var offset = adt.offset;
     var absolute = adt.absolute;
     var fixed = adt.fixed;
     var parseAttrToInt = function (element, name) {
-      var value = get$c(element, name);
+      var value = get$d(element, name);
       return isUndefined(value) ? NaN : parseInt(value, 10);
     };
     var get = function (component, snapsInfo) {
       var element = component.element;
       var x = parseAttrToInt(element, snapsInfo.leftAttr);
       var y = parseAttrToInt(element, snapsInfo.topAttr);
       return isNaN(x) || isNaN(y) ? Optional.none() : Optional.some(SugarPosition(x, y));
     };
     var set = function (component, snapsInfo, pt) {
       var element = component.element;
-      set$7(element, snapsInfo.leftAttr, pt.left + 'px');
+      set$8(element, snapsInfo.leftAttr, pt.left + 'px');
-      set$7(element, snapsInfo.topAttr, pt.top + 'px');
+      set$8(element, snapsInfo.topAttr, pt.top + 'px');
     };
     var clear = function (component, snapsInfo) {
       var element = component.element;
-      remove$6(element, snapsInfo.leftAttr);
+      remove$7(element, snapsInfo.leftAttr);
-      remove$6(element, snapsInfo.topAttr);
+      remove$7(element, snapsInfo.topAttr);
     };
     var getCoords = function (component, snapInfo, coord, delta) {
       return get(component, snapInfo).fold(function () {
         return coord;
     var snapTo = function (component, dragConfig, _state, snap) {
       var target = dragConfig.getTarget(component.element);
       if (dragConfig.repositionTarget) {
         var doc = owner$4(component.element);
-        var scroll_1 = get$6(doc);
+        var scroll_1 = get$9(doc);
         var origin_1 = getOrigin(target);
         var snapPin = snapTo$1(snap, scroll_1, origin_1);
         var styles = toStyles(snapPin.coord, scroll_1, origin_1);
         setOptions(target, styles);
+      }
     var initialAttribute = 'data-initial-z-index';
     var resetZIndex = function (blocker) {
       parent(blocker.element).filter(isElement$2).each(function (root) {
         getOpt(root, initialAttribute).fold(function () {
-          return remove$1(root, 'z-index');
+          return remove$6(root, 'z-index');
         }, function (zIndex) {
-          return set$6(root, 'z-index', zIndex);
+          return set$7(root, 'z-index', zIndex);
         });
-        remove$6(root, initialAttribute);
+        remove$7(root, initialAttribute);
       });
     };
     var changeZIndex = function (blocker) {
       parent(blocker.element).filter(isElement$2).each(function (root) {
         getRaw(root, 'z-index').each(function (zindex) {
-          set$7(root, initialAttribute, zindex);
+          set$8(root, initialAttribute, zindex);
         });
-        set$6(root, 'z-index', get$a(blocker.element, 'z-index'));
+        set$7(root, 'z-index', get$c(blocker.element, 'z-index'));
       });
     };
     var instigate = function (anyComponent, blocker) {
       anyComponent.getSystem().addToGui(blocker);
       changeZIndex(blocker);
     };
     var dragBy = function (component, dragConfig, startData, delta) {
       var target = dragConfig.getTarget(component.element);
       if (dragConfig.repositionTarget) {
         var doc = owner$4(component.element);
-        var scroll_1 = get$6(doc);
+        var scroll_1 = get$9(doc);
         var origin_1 = getOrigin(target);
         var currentCoord = getCurrentCoord(target);
         var newCoord = calcNewCoord(component, dragConfig.snaps, currentCoord, scroll_1, origin_1, delta, startData);
         var styles = toStyles(newCoord, scroll_1, origin_1);
         setOptions(target, styles);
     };
     var calcStartData = function (dragConfig, comp) {
       return {
         bounds: dragConfig.getBounds(),
-        height: getOuter$1(comp.element),
+        height: getOuter$2(comp.element),
-        width: getOuter(comp.element)
+        width: getOuter$1(comp.element)
       };
     };
     var move = function (component, dragConfig, dragState, dragMode, event) {
       var delta = dragState.update(dragMode, event);
       var dragStartData = dragState.getStartData().getOrThunk(function () {
         };
         return derive$2(__spreadArray([run$1(windowScroll(), function (comp) {
             dragState.getStartData().each(function () {
               return updateStartState(comp);
             });
-          })], events(dragConfig, dragState, updateStartState)));
+          })], events(dragConfig, dragState, updateStartState), true));
       };
     };
     var init$2 = function (dragApi) {
       return derive$2([
             instigate(component, blocker);
           };
           start();
         })];
     };
-    var schema$5 = __spreadArray(__spreadArray([], schema$6), [output$1('dragger', { handlers: handlers(events$2) })]);
+    var schema$5 = __spreadArray(__spreadArray([], schema$6, true), [output$1('dragger', { handlers: handlers(events$2) })], false);
     var init$1 = function (dragApi) {
       return derive$2([
         run$1(touchstart(), dragApi.forceDrop),
         run$1(touchend(), dragApi.drop),
           stopBlocking(component);
         }),
         run$1(touchcancel(), stopBlocking)
       ];
     };
-    var schema$4 = __spreadArray(__spreadArray([], schema$6), [output$1('dragger', { handlers: handlers(events$1) })]);
+    var schema$4 = __spreadArray(__spreadArray([], schema$6, true), [output$1('dragger', { handlers: handlers(events$1) })], false);
     var events = function (dragConfig, dragState, updateStartState) {
-      return __spreadArray(__spreadArray([], events$2(dragConfig, dragState, updateStartState)), events$1(dragConfig, dragState, updateStartState));
+      return __spreadArray(__spreadArray([], events$2(dragConfig, dragState, updateStartState), true), events$1(dragConfig, dragState, updateStartState), true);
     };
-    var schema$3 = __spreadArray(__spreadArray([], schema$6), [output$1('dragger', { handlers: handlers(events) })]);
+    var schema$3 = __spreadArray(__spreadArray([], schema$6, true), [output$1('dragger', { handlers: handlers(events) })], false);
     var mouse = schema$5;
     var touch = schema$4;
     var mouseOrTouch = schema$3;
       var memBottomRight = createSelector(bottomRightSnaps);
       var topLeft = build$1(memTopLeft.asSpec());
       var bottomRight = build$1(memBottomRight.asSpec());
       var showOrHideHandle = function (selector, cell, isAbove, isBelow) {
         var cellRect = cell.dom.getBoundingClientRect();
-        remove$1(selector.element, 'display');
+        remove$6(selector.element, 'display');
         var viewportHeight = defaultView(SugarElement.fromDom(editor.getBody())).dom.innerHeight;
         var aboveViewport = isAbove(cellRect);
         var belowViewport = isBelow(cellRect, viewportHeight);
         if (aboveViewport || belowViewport) {
-          set$6(selector.element, 'display', 'none');
+          set$7(selector.element, 'display', 'none');
+        }
       };
       var snapTo = function (selector, cell, getSnapConfig, pos) {
         var snap = getSnapConfig(cell);
         Dragging.snapTo(selector, snap);
+      }
       return dimensions;
     };
     var resize = function (editor, deltas, resizeType) {
       var container = SugarElement.fromDom(editor.getContainer());
-      var dimensions = getDimensions(editor, deltas, resizeType, get$8(container), get$7(container));
+      var dimensions = getDimensions(editor, deltas, resizeType, get$b(container), get$a(container));
       each(dimensions, function (val, dim) {
-        return set$6(container, dim, numToPx(val));
+        return set$7(container, dim, numToPx(val));
       });
       fireResizeEditor(editor);
     };
     var getResizeType = function (editor) {
       });
     };
     var renderStatusbar = function (editor, providersBackstage) {
       var renderBranding = function () {
-        var label = global$f.translate([
+        var label = global$e.translate([
           'Powered by {0}',
           'Tiny'
         ]);
         var linkHtml = '<a href="https://www.tiny.cloud/?utm_campaign=editor_referral&amp;utm_medium=poweredby&amp;utm_source=tinymce&amp;utm_content=v5" rel="noopener" target="_blank" tabindex="-1" aria-label="' + label + '">' + label + '</a>';
         return {
       var isTouch = platform.deviceType.isTouch();
       var touchPlatformClass = 'tox-platform-touch';
       var deviceClasses = isTouch ? [touchPlatformClass] : [];
       var isToolbarBottom = isToolbarLocationBottom(editor);
       var uiContainer = getUiContainer(editor);
-      var dirAttributes = global$f.isRtl() ? { attributes: { dir: 'rtl' } } : {};
+      var dirAttributes = global$e.isRtl() ? { attributes: { dir: 'rtl' } } : {};
       var verticalDirAttributes = { attributes: (_a = {}, _a[Attribute] = isToolbarBottom ? AttributeValue.BottomToTop : AttributeValue.TopToBottom, _a) };
       var lazyHeader = function () {
         return lazyOuterContainer.bind(OuterContainer.getHeader);
       };
       var isHeaderDocked = function () {
         return header.isDocked(lazyHeader);
       };
       var resizeUiMothership = function () {
-        set$6(uiMothership.element, 'width', document.body.clientWidth + 'px');
+        set$7(uiMothership.element, 'width', document.body.clientWidth + 'px');
       };
       var makeSinkDefinition = function () {
-        var isGridUiContainer = eq(body(), uiContainer) && get$a(uiContainer, 'display') === 'grid';
+        var isGridUiContainer = eq(body(), uiContainer) && get$c(uiContainer, 'display') === 'grid';
         var sinkSpec = {
           dom: __assign({
             tag: 'div',
             classes: [
               'tox',
         [editorContainer],
         isInline ? [] : statusbar.toArray(),
         [partThrobber]
       ]);
       var isHidden = isDistractionFree(editor);
-      var attributes = __assign(__assign({ role: 'application' }, global$f.isRtl() ? { dir: 'rtl' } : {}), isHidden ? { 'aria-hidden': 'true' } : {});
+      var attributes = __assign(__assign({ role: 'application' }, global$e.isRtl() ? { dir: 'rtl' } : {}), isHidden ? { 'aria-hidden': 'true' } : {});
       var outerContainer = build$1(OuterContainer.sketch({
         dom: {
           tag: 'div',
           classes: [
             'tox',
       var setEditorSize = function () {
         var parsedHeight = numToPx(getHeightWithFallback(editor));
         var parsedWidth = numToPx(getWidthWithFallback(editor));
         if (!editor.inline) {
           if (isValidValue('div', 'width', parsedWidth)) {
-            set$6(outerContainer.element, 'width', parsedWidth);
+            set$7(outerContainer.element, 'width', parsedWidth);
+          }
           if (isValidValue('div', 'height', parsedHeight)) {
-            set$6(outerContainer.element, 'height', parsedHeight);
+            set$7(outerContainer.element, 'height', parsedHeight);
           } else {
-            set$6(outerContainer.element, 'height', '200px');
+            set$7(outerContainer.element, 'height', '200px');
+          }
+        }
         return parsedHeight;
       };
       var renderUI = function () {
         header.setup(editor, backstage.shared, lazyHeader);
         setup$6(editor, backstage);
         setup$5(editor, lazySink, backstage);
         setup$8(editor);
         setup$7(editor, lazyThrobber, backstage.shared);
-        map(getToolbarGroups(editor), function (toolbarGroupButtonConfig, name) {
+        map$1(getToolbarGroups(editor), function (toolbarGroupButtonConfig, name) {
           editor.ui.registry.addGroupToolbarButton(name, toolbarGroupButtonConfig);
         });
         var _a = editor.ui.registry.getAll(), buttons = _a.buttons, menuItems = _a.menuItems, contextToolbars = _a.contextToolbars, sidebars = _a.sidebars;
         var toolbarOpt = getMultipleToolbarsSetting(editor);
         var rawUiConfig = {
         getUi: getUi
       };
     };
     var describedBy = function (describedElement, describeElement) {
-      var describeId = Optional.from(get$c(describedElement, 'id')).fold(function () {
+      var describeId = Optional.from(get$d(describedElement, 'id')).fold(function () {
         var id = generate$6('dialog-describe');
-        set$7(describeElement, 'id', id);
+        set$8(describeElement, 'id', id);
         return id;
       }, identity$1);
-      set$7(describedElement, 'aria-describedby', describeId);
+      set$8(describedElement, 'aria-describedby', describeId);
     };
     var labelledBy = function (labelledElement, labelElement) {
       var labelId = getOpt(labelledElement, 'id').fold(function () {
         var id = generate$6('dialog-label');
-        set$7(labelElement, 'id', id);
+        set$8(labelElement, 'id', id);
         return id;
       }, identity$1);
-      set$7(labelledElement, 'aria-labelledby', labelId);
+      set$8(labelledElement, 'aria-labelledby', labelId);
     };
     var schema$2 = constant$1([
       required$1('lazySink'),
       option('dragBlockClass'),
         'end'
       ]),
       defaultedBoolean('primary', false),
       defaultedBoolean('disabled', false)
     ];
-    var dialogFooterButtonFields = __spreadArray(__spreadArray([], baseFooterButtonFields), [requiredString('text')]);
+    var dialogFooterButtonFields = __spreadArray(__spreadArray([], baseFooterButtonFields, true), [requiredString('text')], false);
     var normalFooterButtonFields = __spreadArray([requiredStringEnum('type', [
         'submit',
         'cancel',
         'custom'
-      ])], dialogFooterButtonFields);
+      ])], dialogFooterButtonFields, true);
     var menuFooterButtonFields = __spreadArray([
       requiredStringEnum('type', ['menu']),
       optionString('text'),
       optionString('tooltip'),
       optionString('icon'),
       requiredArrayOf('items', dialogToggleMenuItemSchema)
-    ], baseFooterButtonFields);
+    ], baseFooterButtonFields, true);
     var dialogFooterButtonSchema = choose$1('type', {
       submit: normalFooterButtonFields,
       cancel: normalFooterButtonFields,
       custom: normalFooterButtonFields,
       menu: menuFooterButtonFields
     };
     var urlDialogButtonSchema = objOf(__spreadArray([requiredStringEnum('type', [
         'cancel',
         'custom'
-      ])], dialogButtonFields));
+      ])], dialogButtonFields, true));
     var urlDialogSchema = objOf([
       requiredString('title'),
       requiredString('url'),
       optionNumber('height'),
       optionNumber('width'),
         'behaviours': augment(detail.tabbarBehaviours, [
           Highlighting.config({
             highlightClass: detail.markers.selectedClass,
             itemClass: detail.markers.tabClass,
             onHighlight: function (tabbar, tab) {
-              set$7(tab.element, 'aria-selected', 'true');
+              set$8(tab.element, 'aria-selected', 'true');
             },
             onDehighlight: function (tabbar, tab) {
-              set$7(tab.element, 'aria-selected', 'false');
+              set$8(tab.element, 'aria-selected', 'false');
+            }
           }),
           Keying.config({
             mode: 'flow',
             getInitial: function (tabbar) {
             return t.value === tabValue;
           });
           tabWithValue.each(function (tabData) {
             var panel = tabData.view();
             getOpt(button.element, 'id').each(function (id) {
-              set$7(tabview.element, 'aria-labelledby', id);
+              set$8(tabview.element, 'aria-labelledby', id);
             });
             Replacing.set(tabview, panel);
             detail.onChangeTab(tabview, button, panel);
           });
         });
       }));
     };
     var getMaxTabviewHeight = function (dialog, tabview, tablist) {
       var documentElement$1 = documentElement(dialog).dom;
       var rootElm = ancestor(dialog, '.tox-dialog-wrap').getOr(dialog);
-      var isFixed = get$a(rootElm, 'position') === 'fixed';
+      var isFixed = get$c(rootElm, 'position') === 'fixed';
       var maxHeight;
       if (isFixed) {
         maxHeight = Math.max(documentElement$1.clientHeight, window.innerHeight);
       } else {
         maxHeight = Math.max(documentElement$1.offsetHeight, documentElement$1.scrollHeight);
+      }
-      var tabviewHeight = get$8(tabview);
+      var tabviewHeight = get$b(tabview);
-      var isTabListBeside = tabview.dom.offsetLeft >= tablist.dom.offsetLeft + get$7(tablist);
+      var isTabListBeside = tabview.dom.offsetLeft >= tablist.dom.offsetLeft + get$a(tablist);
-      var currentTabHeight = isTabListBeside ? Math.max(get$8(tablist), tabviewHeight) : tabviewHeight;
+      var currentTabHeight = isTabListBeside ? Math.max(get$b(tablist), tabviewHeight) : tabviewHeight;
-      var dialogTopMargin = parseInt(get$a(dialog, 'margin-top'), 10) || 0;
+      var dialogTopMargin = parseInt(get$c(dialog, 'margin-top'), 10) || 0;
-      var dialogBottomMargin = parseInt(get$a(dialog, 'margin-bottom'), 10) || 0;
+      var dialogBottomMargin = parseInt(get$c(dialog, 'margin-bottom'), 10) || 0;
-      var dialogHeight = get$8(dialog) + dialogTopMargin + dialogBottomMargin;
+      var dialogHeight = get$b(dialog) + dialogTopMargin + dialogBottomMargin;
       var chromeHeight = dialogHeight - currentTabHeight;
       return maxHeight - chromeHeight;
     };
     var showTab = function (allTabs, comp) {
       head(allTabs).each(function (tab) {
         return TabSection.showTab(comp, tab.value);
       });
     };
     var setTabviewHeight = function (tabview, height) {
-      set$6(tabview, 'height', height + 'px');
+      set$7(tabview, 'height', height + 'px');
       if (!detect$1().browser.isIE()) {
-        set$6(tabview, 'flex-basis', height + 'px');
+        set$7(tabview, 'flex-basis', height + 'px');
       } else {
-        remove$1(tabview, 'flex-basis');
+        remove$6(tabview, 'flex-basis');
+      }
     };
     var updateTabviewHeight = function (dialogBody, tabview, maxTabHeight) {
       ancestor(dialogBody, '[role="dialog"]').each(function (dialog) {
         descendant(dialog, '[role="tablist"]').each(function (tablist) {
           maxTabHeight.get().map(function (height) {
-            set$6(tabview, 'height', '0');
+            set$7(tabview, 'height', '0');
-            set$6(tabview, 'flex-basis', '0');
+            set$7(tabview, 'flex-basis', '0');
             return Math.min(height, getMaxTabviewHeight(dialog, tabview, tablist));
           }).each(function (height) {
             setTabviewHeight(tabview, height);
           });
         });
         var maxTabHeight = value$1();
         var extraEvents = [
           runOnAttached(function (comp) {
             var dialog = comp.element;
             getTabview(dialog).each(function (tabview) {
-              set$6(tabview, 'visibility', 'hidden');
+              set$7(tabview, 'visibility', 'hidden');
               comp.getSystem().getByDom(tabview).toOptional().each(function (tabviewComp) {
                 var heights = measureHeights(allTabs, tabview, tabviewComp);
                 var maxTabHeightOpt = getMaxHeight(heights);
                 maxTabHeightOpt.fold(maxTabHeight.clear, maxTabHeight.set);
               });
               updateTabviewHeight(dialog, tabview, maxTabHeight);
-              remove$1(tabview, 'visibility');
+              remove$6(tabview, 'visibility');
               showTab(allTabs, comp);
-              global$g.requestAnimationFrame(function () {
+              global$f.requestAnimationFrame(function () {
                 updateTabviewHeight(dialog, tabview, maxTabHeight);
               });
             });
           }),
           run$1(windowResize(), function (comp) {
           }),
           run$1(formResizeEvent, function (comp, _se) {
             var dialog = comp.element;
             getTabview(dialog).each(function (tabview) {
               var oldFocus = active(getRootNode(tabview));
-              set$6(tabview, 'visibility', 'hidden');
+              set$7(tabview, 'visibility', 'hidden');
               var oldHeight = getRaw(tabview, 'height').map(function (h) {
                 return parseInt(h, 10);
               });
-              remove$1(tabview, 'height');
+              remove$6(tabview, 'height');
-              remove$1(tabview, 'flex-basis');
+              remove$6(tabview, 'flex-basis');
               var newHeight = tabview.dom.getBoundingClientRect().height;
               var hasGrown = oldHeight.forall(function (h) {
                 return newHeight > h;
               });
               if (hasGrown) {
               } else {
                 oldHeight.each(function (h) {
                   setTabviewHeight(tabview, h);
                 });
+              }
-              remove$1(tabview, 'visibility');
+              remove$6(tabview, 'visibility');
               oldFocus.each(focus$3);
             });
           })
         ];
         var selectFirst = false;
           })])
       };
       return ModalDialog.parts.body(bodySpec);
     };
-    var isTouch = global$a.deviceType.isTouch();
+    var isTouch = global$9.deviceType.isTouch();
     var hiddenHeader = function (title, close) {
       return {
         dom: {
           tag: 'div',
           styles: { display: 'none' },
           styles: __assign({ position: 'relative' }, spec.extraStyles)
         },
         components: __spreadArray([
           spec.header,
           spec.body
-        ], spec.footer.toArray()),
+        ], spec.footer.toArray(), true),
         parts: {
           blocker: {
             dom: fromHtml('<div class="' + blockerClass + '"></div>'),
             components: [{
                 dom: {
           config('scroll-lock', [
             runOnAttached(function () {
               add$2(body(), scrollLockClass);
             }),
             runOnDetached(function () {
-              remove$3(body(), scrollLockClass);
+              remove$2(body(), scrollLockClass);
             })
           ])
-        ], spec.extraBehaviours)),
+        ], spec.extraBehaviours, true)),
         eventOrder: __assign((_a = {}, _a[execute$5()] = ['dialog-events'], _a[attachedToDom()] = [
           'scroll-lock',
           'dialog-events',
           'alloy.base.behaviour'
         ], _a[detachedFromDom()] = [
             channel: dialogChannel,
             updateState: updateState,
             initialData: initialData
           }),
           RepresentingConfigs.memory({})
-        ], spec.extraBehaviours),
+        ], spec.extraBehaviours, true),
         onEscape: function (comp) {
           emit(comp, formCancelEvent);
         },
         dialogEvents: dialogEvents,
         eventOrder: (_a = {}, _a[receive()] = [
       var withSpec = function (c, f) {
         Reflecting.getState(c).get().each(function (currentDialog) {
           f(currentDialog, c);
         });
       };
-      return __spreadArray(__spreadArray([], initCommonEvents(fireApiEvent, extras)), [fireApiEvent(formActionEvent, function (api, spec, event) {
+      return __spreadArray(__spreadArray([], initCommonEvents(fireApiEvent, extras), true), [fireApiEvent(formActionEvent, function (api, spec, event) {
           spec.onAction(api, { name: event.name });
-        })]);
+        })], false);
     };
     var initDialog = function (getInstanceApi, extras, getSink) {
       var fireApiEvent = function (eventName, f) {
         return run$1(eventName, function (c, se) {
           withSpec(c, function (spec, _c) {
       var withSpec = function (c, f) {
         Reflecting.getState(c).get().each(function (currentDialogInit) {
           f(currentDialogInit.internalDialog, c);
         });
       };
-      return __spreadArray(__spreadArray([], initCommonEvents(fireApiEvent, extras)), [
+      return __spreadArray(__spreadArray([], initCommonEvents(fireApiEvent, extras), true), [
         fireApiEvent(formSubmitEvent, function (api, spec) {
           return spec.onSubmit(api);
         }),
         fireApiEvent(formChangeEvent, function (api, spec, event) {
           spec.onChange(api, { name: event.name });
         }),
         runOnDetached(function (component) {
           var api = getInstanceApi();
           Representing.setValue(component, api.getData());
         })
-      ]);
+      ], false);
     };
     var SilverDialogEvents = {
       initUrlDialog: initUrlDialog,
       initDialog: initDialog
     };
       };
       var getData = function () {
         var root = access.getRoot();
         var valueComp = root.getSystem().isConnected() ? access.getFormWrapper() : root;
         var representedValues = Representing.getValue(valueComp);
-        var menuItemCurrentState = map(menuItemStates, function (cell) {
+        var menuItemCurrentState = map$1(menuItemStates, function (cell) {
           return cell.get();
         });
         return __assign(__assign({}, representedValues), menuItemCurrentState);
       };
       var setData = function (newData) {
             onEscape: function (c) {
               emit(c, formCloseEvent);
               return Optional.some(true);
             },
             useTabstopAt: function (elem) {
-              return !isPseudoStop(elem) && (name$2(elem) !== 'button' || get$c(elem, 'disabled') !== 'disabled');
+              return !isPseudoStop(elem) && (name$2(elem) !== 'button' || get$d(elem, 'disabled') !== 'disabled');
+            }
           }),
           Reflecting.config({
             channel: dialogChannel,
             updateState: updateState,
             },
             fireDismissalEventInstead: {}
           }, isToolbarLocationTop ? {} : { fireRepositionEventInstead: {} }), {
             inlineBehaviours: derive$1(__spreadArray([config('window-manager-inline-events', [run$1(dismissRequested(), function (_comp, _se) {
                   emit(dialogUi.dialog, formCancelEvent);
-                })])], inlineAdditionalBehaviours(editor, isStickyToolbar$1, isToolbarLocationTop))),
+                })])], inlineAdditionalBehaviours(editor, isStickyToolbar$1, isToolbarLocationTop), true)),
             isExtraPart: function (_comp, target) {
               return isAlertOrConfirmDialog(target);
+            }
           })));
           inlineDialog.set(inlineDialogComp);
         confirm: confirm
       };
     };
     function Theme () {
-      global$h.add('silver', function (editor) {
+      global$g.add('silver', function (editor) {
         var _a = setup$3(editor), uiMothership = _a.uiMothership, backstage = _a.backstage, renderUI = _a.renderUI, getUi = _a.getUi;
         Autocompleter.register(editor, backstage.shared);
         var windowMgr = setup({
           editor: editor,
           backstage: backstage

Subversion Repositories oidplus

oidplus/trunk/vendor/tinymce/tinymce/themes/silver/theme.js – Rev 637 → 679