diff --git a/ant-design-vue-jeecg/public/tinymce/themes/mobile/index.js b/ant-design-vue-jeecg/public/tinymce/themes/mobile/index.js
new file mode 100644
index 0000000..ad02e83
--- /dev/null
+++ b/ant-design-vue-jeecg/public/tinymce/themes/mobile/index.js
@@ -0,0 +1,7 @@
+// Exports the "mobile" theme for usage with module loaders
+// Usage:
+//   CommonJS:
+//     require('tinymce/themes/mobile')
+//   ES2015:
+//     import 'tinymce/themes/mobile'
+require('./theme.js');
\ No newline at end of file
diff --git a/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.js b/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.js
new file mode 100644
index 0000000..c430636
--- /dev/null
+++ b/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.js
@@ -0,0 +1,13130 @@
+/**
+ * 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.10.7 (2022-12-06)
+ */
+(function () {
+    'use strict';
+
+    var __assign = function () {
+      __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+      var t = {};
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+          t[p] = s[p];
+      if (s != null && typeof Object.getOwnPropertySymbols === 'function')
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+            t[p[i]] = s[p[i]];
+        }
+      return t;
+    }
+    function __spreadArray(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    var typeOf = function (x) {
+      var t = typeof x;
+      if (x === null) {
+        return 'null';
+      } else if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
+        return 'array';
+      } else if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
+        return 'string';
+      } else {
+        return t;
+      }
+    };
+    var isType$1 = function (type) {
+      return function (value) {
+        return typeOf(value) === type;
+      };
+    };
+    var isSimpleType = function (type) {
+      return function (value) {
+        return typeof value === type;
+      };
+    };
+    var eq$1 = function (t) {
+      return function (a) {
+        return t === a;
+      };
+    };
+    var isString = isType$1('string');
+    var isObject = isType$1('object');
+    var isArray = isType$1('array');
+    var isNull = eq$1(null);
+    var isBoolean = isSimpleType('boolean');
+    var isUndefined = eq$1(undefined);
+    var isNullable = function (a) {
+      return a === null || a === undefined;
+    };
+    var isNonNullable = function (a) {
+      return !isNullable(a);
+    };
+    var isFunction = isSimpleType('function');
+    var isNumber = isSimpleType('number');
+
+    var noop = function () {
+    };
+    var compose = function (fa, fb) {
+      return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return fa(fb.apply(null, args));
+      };
+    };
+    var compose1 = function (fbc, fab) {
+      return function (a) {
+        return fbc(fab(a));
+      };
+    };
+    var constant$1 = function (value) {
+      return function () {
+        return value;
+      };
+    };
+    var identity = function (x) {
+      return x;
+    };
+    var tripleEquals = function (a, b) {
+      return a === b;
+    };
+    function curry(fn) {
+      var initialArgs = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+        initialArgs[_i - 1] = arguments[_i];
+      }
+      return function () {
+        var restArgs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          restArgs[_i] = arguments[_i];
+        }
+        var all = initialArgs.concat(restArgs);
+        return fn.apply(null, all);
+      };
+    }
+    var not = function (f) {
+      return function (t) {
+        return !f(t);
+      };
+    };
+    var die = function (msg) {
+      return function () {
+        throw new Error(msg);
+      };
+    };
+    var apply$1 = function (f) {
+      return f();
+    };
+    var never = constant$1(false);
+    var always = constant$1(true);
+
+    var none = function () {
+      return NONE;
+    };
+    var NONE = function () {
+      var call = function (thunk) {
+        return thunk();
+      };
+      var id = identity;
+      var me = {
+        fold: function (n, _s) {
+          return n();
+        },
+        isSome: never,
+        isNone: always,
+        getOr: id,
+        getOrThunk: call,
+        getOrDie: function (msg) {
+          throw new Error(msg || 'error: getOrDie called on none.');
+        },
+        getOrNull: constant$1(null),
+        getOrUndefined: constant$1(undefined),
+        or: id,
+        orThunk: call,
+        map: none,
+        each: noop,
+        bind: none,
+        exists: never,
+        forall: always,
+        filter: function () {
+          return none();
+        },
+        toArray: function () {
+          return [];
+        },
+        toString: constant$1('none()')
+      };
+      return me;
+    }();
+    var some = function (a) {
+      var constant_a = constant$1(a);
+      var self = function () {
+        return me;
+      };
+      var bind = function (f) {
+        return f(a);
+      };
+      var me = {
+        fold: function (n, s) {
+          return s(a);
+        },
+        isSome: always,
+        isNone: never,
+        getOr: constant_a,
+        getOrThunk: constant_a,
+        getOrDie: constant_a,
+        getOrNull: constant_a,
+        getOrUndefined: constant_a,
+        or: self,
+        orThunk: self,
+        map: function (f) {
+          return some(f(a));
+        },
+        each: function (f) {
+          f(a);
+        },
+        bind: bind,
+        exists: bind,
+        forall: bind,
+        filter: function (f) {
+          return f(a) ? me : NONE;
+        },
+        toArray: function () {
+          return [a];
+        },
+        toString: function () {
+          return 'some(' + a + ')';
+        }
+      };
+      return me;
+    };
+    var from = function (value) {
+      return value === null || value === undefined ? NONE : some(value);
+    };
+    var Optional = {
+      some: some,
+      none: none,
+      from: from
+    };
+
+    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 nativeSlice = Array.prototype.slice;
+    var nativeIndexOf = Array.prototype.indexOf;
+    var nativePush = Array.prototype.push;
+    var rawIndexOf = function (ts, t) {
+      return nativeIndexOf.call(ts, t);
+    };
+    var contains$1 = function (xs, x) {
+      return rawIndexOf(xs, x) > -1;
+    };
+    var exists = function (xs, pred) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    var map$2 = function (xs, f) {
+      var len = xs.length;
+      var r = new Array(len);
+      for (var i = 0; i < len; i++) {
+        var x = xs[i];
+        r[i] = f(x, i);
+      }
+      return r;
+    };
+    var each$1 = function (xs, f) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        f(x, i);
+      }
+    };
+    var eachr = function (xs, f) {
+      for (var i = xs.length - 1; i >= 0; i--) {
+        var x = xs[i];
+        f(x, i);
+      }
+    };
+    var filter$2 = function (xs, pred) {
+      var r = [];
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          r.push(x);
+        }
+      }
+      return r;
+    };
+    var foldr = function (xs, f, acc) {
+      eachr(xs, function (x, i) {
+        acc = f(acc, x, i);
+      });
+      return acc;
+    };
+    var foldl = function (xs, f, acc) {
+      each$1(xs, function (x, i) {
+        acc = f(acc, x, i);
+      });
+      return acc;
+    };
+    var findUntil = function (xs, pred, until) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          return Optional.some(x);
+        } else if (until(x, i)) {
+          break;
+        }
+      }
+      return Optional.none();
+    };
+    var find$2 = function (xs, pred) {
+      return findUntil(xs, pred, never);
+    };
+    var findIndex$1 = function (xs, pred) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          return Optional.some(i);
+        }
+      }
+      return Optional.none();
+    };
+    var flatten = function (xs) {
+      var r = [];
+      for (var i = 0, len = xs.length; i < len; ++i) {
+        if (!isArray(xs[i])) {
+          throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
+        }
+        nativePush.apply(r, xs[i]);
+      }
+      return r;
+    };
+    var bind$3 = function (xs, f) {
+      return flatten(map$2(xs, f));
+    };
+    var forall = function (xs, pred) {
+      for (var i = 0, len = xs.length; i < len; ++i) {
+        var x = xs[i];
+        if (pred(x, i) !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var reverse = function (xs) {
+      var r = nativeSlice.call(xs, 0);
+      r.reverse();
+      return r;
+    };
+    var difference = function (a1, a2) {
+      return filter$2(a1, function (x) {
+        return !contains$1(a2, x);
+      });
+    };
+    var pure$2 = function (x) {
+      return [x];
+    };
+    var sort = function (xs, comparator) {
+      var copy = nativeSlice.call(xs, 0);
+      copy.sort(comparator);
+      return copy;
+    };
+    var get$d = function (xs, i) {
+      return i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
+    };
+    var head = function (xs) {
+      return get$d(xs, 0);
+    };
+    var findMap = function (arr, f) {
+      for (var i = 0; i < arr.length; i++) {
+        var r = f(arr[i], i);
+        if (r.isSome()) {
+          return r;
+        }
+      }
+      return Optional.none();
+    };
+
+    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$1 = 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$8(group(1), group(2));
+    };
+    var detect$4 = function (versionRegexes, agent) {
+      var cleanedAgent = String(agent).toLowerCase();
+      if (versionRegexes.length === 0) {
+        return unknown$3();
+      }
+      return find$1(versionRegexes, cleanedAgent);
+    };
+    var unknown$3 = function () {
+      return nu$8(0, 0);
+    };
+    var nu$8 = function (major, minor) {
+      return {
+        major: major,
+        minor: minor
+      };
+    };
+    var Version = {
+      nu: nu$8,
+      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$2(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$2(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 checkRange = function (str, substr, start) {
+      return substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
+    };
+    var supplant = function (str, obj) {
+      var isStringOrNumber = function (a) {
+        var t = typeof a;
+        return t === 'string' || t === 'number';
+      };
+      return str.replace(/\$\{([^{}]*)\}/g, function (fullMatch, key) {
+        var value = obj[key];
+        return isStringOrNumber(value) ? value.toString() : fullMatch;
+      });
+    };
+    var contains = function (str, substr) {
+      return str.indexOf(substr) !== -1;
+    };
+    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 = blank(/^\s+|\s+$/g);
+
+    var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
+    var checkContains = function (target) {
+      return function (uastring) {
+        return contains(uastring, target);
+      };
+    };
+    var browsers = [
+      {
+        name: 'Edge',
+        versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
+        search: function (uastring) {
+          return contains(uastring, 'edge/') && contains(uastring, 'chrome') && contains(uastring, 'safari') && contains(uastring, 'applewebkit');
+        }
+      },
+      {
+        name: 'Chrome',
+        brand: 'Chromium',
+        versionRegexes: [
+          /.*?chrome\/([0-9]+)\.([0-9]+).*/,
+          normalVersionRegex
+        ],
+        search: function (uastring) {
+          return contains(uastring, 'chrome') && !contains(uastring, 'chromeframe');
+        }
+      },
+      {
+        name: 'IE',
+        versionRegexes: [
+          /.*?msie\ ?([0-9]+)\.([0-9]+).*/,
+          /.*?rv:([0-9]+)\.([0-9]+).*/
+        ],
+        search: function (uastring) {
+          return contains(uastring, 'msie') || contains(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(uastring, 'safari') || contains(uastring, 'mobile/')) && contains(uastring, 'applewebkit');
+        }
+      }
+    ];
+    var oses = [
+      {
+        name: 'Windows',
+        search: checkContains('win'),
+        versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
+      },
+      {
+        name: 'iOS',
+        search: function (uastring) {
+          return contains(uastring, 'iphone') || contains(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$7({
+        current: undefined,
+        version: Version.unknown()
+      });
+    };
+    var nu$7 = 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$7,
+      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$6({
+        current: undefined,
+        version: Version.unknown()
+      });
+    };
+    var nu$6 = 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$6,
+      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$1 = cached(function () {
+      return PlatformDetection.detect(navigator.userAgent, Optional.from(navigator.userAgentData), mediaMatch);
+    });
+    var detect$1 = function () {
+      return platform$1();
+    };
+
+    var constant = constant$1;
+    var touchstart = constant('touchstart');
+    var touchmove = constant('touchmove');
+    var touchend = constant('touchend');
+    var mousedown = constant('mousedown');
+    var mousemove = constant('mousemove');
+    var mouseup = constant('mouseup');
+    var mouseover = constant('mouseover');
+    var keydown = constant('keydown');
+    var keyup = constant('keyup');
+    var input$1 = constant('input');
+    var change = constant('change');
+    var click = constant('click');
+    var transitionend = constant('transitionend');
+    var selectstart = constant('selectstart');
+
+    var prefixName = function (name) {
+      return constant$1('alloy.' + name);
+    };
+    var alloy = { tap: prefixName('tap') };
+    var focus$4 = prefixName('focus');
+    var postBlur = prefixName('blur.post');
+    var postPaste = prefixName('paste.post');
+    var receive$1 = prefixName('receive');
+    var execute$5 = prefixName('execute');
+    var focusItem = prefixName('focus.item');
+    var tap = alloy.tap;
+    var longpress = prefixName('longpress');
+    var systemInit = prefixName('system.init');
+    var attachedToDom = prefixName('system.attached');
+    var detachedFromDom = prefixName('system.detached');
+    var focusShifted = prefixName('focusmanager.shifted');
+    var highlight$1 = prefixName('highlight');
+    var dehighlight$1 = prefixName('dehighlight');
+
+    var emit = function (component, event) {
+      dispatchWith(component, component.element, event, {});
+    };
+    var emitWith = function (component, event, properties) {
+      dispatchWith(component, component.element, event, properties);
+    };
+    var emitExecute = function (component) {
+      emit(component, execute$5());
+    };
+    var dispatch = function (component, target, event) {
+      dispatchWith(component, target, event, {});
+    };
+    var dispatchWith = function (component, target, event, properties) {
+      var data = __assign({ target: target }, properties);
+      component.getSystem().triggerEvent(event, target, data);
+    };
+    var dispatchEvent = function (component, target, event, simulatedEvent) {
+      component.getSystem().triggerEvent(event, target, simulatedEvent.event);
+    };
+    var dispatchFocus = function (component, target) {
+      component.getSystem().triggerFocus(target, component.element);
+    };
+
+    var DOCUMENT = 9;
+    var DOCUMENT_FRAGMENT = 11;
+    var ELEMENT = 1;
+    var TEXT = 3;
+
+    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 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$2 = 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;
+    };
+
+    typeof window !== 'undefined' ? window : Function('return this;')();
+
+    var name$1 = 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 = isType(ELEMENT);
+    var isText = isType(TEXT);
+    var isDocument = isType(DOCUMENT);
+    var isDocumentFragment = isType(DOCUMENT_FRAGMENT);
+
+    var owner$2 = function (element) {
+      return SugarElement.fromDom(element.dom.ownerDocument);
+    };
+    var documentOrOwner = function (dos) {
+      return isDocument(dos) ? dos : owner$2(dos);
+    };
+    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 parents = function (element, isRoot) {
+      var stop = isFunction(isRoot) ? isRoot : never;
+      var dom = element.dom;
+      var ret = [];
+      while (dom.parentNode !== null && dom.parentNode !== undefined) {
+        var rawParent = dom.parentNode;
+        var p = SugarElement.fromDom(rawParent);
+        ret.push(p);
+        if (stop(p) === true) {
+          break;
+        } else {
+          dom = rawParent;
+        }
+      }
+      return ret;
+    };
+    var siblings$2 = function (element) {
+      var filterSelf = function (elements) {
+        return filter$2(elements, function (x) {
+          return !eq(element, x);
+        });
+      };
+      return parent(element).map(children).map(filterSelf).getOr([]);
+    };
+    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 = function (element, index) {
+      var cs = element.dom.childNodes;
+      return Optional.from(cs[index]).map(SugarElement.fromDom);
+    };
+    var firstChild = function (element) {
+      return child(element, 0);
+    };
+
+    var before$1 = 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$1(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(parent, index).fold(function () {
+        append$2(parent, element);
+      }, function (v) {
+        before$1(v, element);
+      });
+    };
+
+    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 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 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(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(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 fireDetaching = function (component) {
+      emit(component, detachedFromDom());
+      var children = component.components();
+      each$1(children, fireDetaching);
+    };
+    var fireAttaching = function (component) {
+      var children = component.components();
+      each$1(children, fireAttaching);
+      emit(component, attachedToDom());
+    };
+    var attach$1 = function (parent, child) {
+      append$2(parent.element, child.element);
+    };
+    var detachChildren = function (component) {
+      each$1(component.components(), function (childComp) {
+        return remove$7(childComp.element);
+      });
+      empty(component.element);
+      component.syncComponents();
+    };
+    var replaceChildren = function (component, newChildren) {
+      var subs = component.components();
+      detachChildren(component);
+      var deleted = difference(subs, newChildren);
+      each$1(deleted, function (comp) {
+        fireDetaching(comp);
+        component.getSystem().removeFromWorld(comp);
+      });
+      each$1(newChildren, function (childComp) {
+        if (!childComp.getSystem().isConnected()) {
+          component.getSystem().addToWorld(childComp);
+          attach$1(component, childComp);
+          if (inBody(component.element)) {
+            fireAttaching(childComp);
+          }
+        } else {
+          attach$1(component, childComp);
+        }
+        component.syncComponents();
+      });
+    };
+
+    var attach = function (parent, child) {
+      attachWith(parent, child, append$2);
+    };
+    var attachWith = function (parent, child, insertion) {
+      parent.getSystem().addToWorld(child);
+      insertion(parent.element, child.element);
+      if (inBody(parent.element)) {
+        fireAttaching(child);
+      }
+      parent.syncComponents();
+    };
+    var doDetach = function (component) {
+      fireDetaching(component);
+      remove$7(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();
+      });
+      doDetach(component);
+      parent$1.each(function (p) {
+        p.syncComponents();
+      });
+    };
+    var attachSystemAfter = function (element, guiSystem) {
+      attachSystemWith(element, guiSystem, after$2);
+    };
+    var attachSystemWith = function (element, guiSystem, inserter) {
+      inserter(element, guiSystem.element);
+      var children$1 = children(guiSystem.element);
+      each$1(children$1, function (child) {
+        guiSystem.getByDom(child).each(fireAttaching);
+      });
+    };
+    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);
+    };
+
+    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 = 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);
+    };
+    var get$c = 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 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$b = function (element, key) {
+      var v = element.dom.getAttribute(key);
+      return v === null ? undefined : v;
+    };
+    var getOpt = function (element, key) {
+      return Optional.from(get$b(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 read$2 = function (element, attr) {
+      var value = get$b(element, attr);
+      return value === undefined || value === '' ? [] : value.split(' ');
+    };
+    var add$3 = function (element, attr, id) {
+      var old = read$2(element, attr);
+      var nu = old.concat([id]);
+      set$8(element, attr, nu.join(' '));
+      return true;
+    };
+    var remove$5 = function (element, attr, id) {
+      var nu = filter$2(read$2(element, attr), function (v) {
+        return v !== id;
+      });
+      if (nu.length > 0) {
+        set$8(element, attr, nu.join(' '));
+      } else {
+        remove$6(element, attr);
+      }
+      return false;
+    };
+
+    var supports = function (element) {
+      return element.dom.classList !== undefined;
+    };
+    var get$a = function (element) {
+      return read$2(element, 'class');
+    };
+    var add$2 = function (element, clazz) {
+      return add$3(element, 'class', clazz);
+    };
+    var remove$4 = function (element, clazz) {
+      return remove$5(element, 'class', clazz);
+    };
+
+    var add$1 = function (element, clazz) {
+      if (supports(element)) {
+        element.dom.classList.add(clazz);
+      } else {
+        add$2(element, clazz);
+      }
+    };
+    var cleanClass = function (element) {
+      var classList = supports(element) ? element.dom.classList : get$a(element);
+      if (classList.length === 0) {
+        remove$6(element, 'class');
+      }
+    };
+    var remove$3 = function (element, clazz) {
+      if (supports(element)) {
+        var classList = element.dom.classList;
+        classList.remove(clazz);
+      } else {
+        remove$4(element, clazz);
+      }
+      cleanClass(element);
+    };
+    var has = function (element, clazz) {
+      return supports(element) && element.dom.classList.contains(clazz);
+    };
+
+    var swap = function (element, addCls, removeCls) {
+      remove$3(element, removeCls);
+      add$1(element, addCls);
+    };
+    var toAlpha = function (component, swapConfig, _swapState) {
+      swap(component.element, swapConfig.alpha, swapConfig.omega);
+    };
+    var toOmega = function (component, swapConfig, _swapState) {
+      swap(component.element, swapConfig.omega, swapConfig.alpha);
+    };
+    var clear$1 = function (component, swapConfig, _swapState) {
+      remove$3(component.element, swapConfig.alpha);
+      remove$3(component.element, swapConfig.omega);
+    };
+    var isAlpha = function (component, swapConfig, _swapState) {
+      return has(component.element, swapConfig.alpha);
+    };
+    var isOmega = function (component, swapConfig, _swapState) {
+      return has(component.element, swapConfig.omega);
+    };
+
+    var SwapApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        toAlpha: toAlpha,
+        toOmega: toOmega,
+        isAlpha: isAlpha,
+        isOmega: isOmega,
+        clear: clear$1
+    });
+
+    var value$2 = function (o) {
+      var or = function (_opt) {
+        return value$2(o);
+      };
+      var orThunk = function (_f) {
+        return value$2(o);
+      };
+      var map = function (f) {
+        return value$2(f(o));
+      };
+      var mapError = function (_f) {
+        return value$2(o);
+      };
+      var each = function (f) {
+        f(o);
+      };
+      var bind = function (f) {
+        return f(o);
+      };
+      var fold = function (_, onValue) {
+        return onValue(o);
+      };
+      var exists = function (f) {
+        return f(o);
+      };
+      var forall = function (f) {
+        return f(o);
+      };
+      var toOptional = function () {
+        return Optional.some(o);
+      };
+      return {
+        isValue: always,
+        isError: never,
+        getOr: constant$1(o),
+        getOrThunk: constant$1(o),
+        getOrDie: constant$1(o),
+        or: or,
+        orThunk: orThunk,
+        fold: fold,
+        map: map,
+        mapError: mapError,
+        each: each,
+        bind: bind,
+        exists: exists,
+        forall: forall,
+        toOptional: toOptional
+      };
+    };
+    var error = function (message) {
+      var getOrThunk = function (f) {
+        return f();
+      };
+      var getOrDie = function () {
+        return die(String(message))();
+      };
+      var or = identity;
+      var orThunk = function (f) {
+        return f();
+      };
+      var map = function (_f) {
+        return error(message);
+      };
+      var mapError = function (f) {
+        return error(f(message));
+      };
+      var bind = function (_f) {
+        return error(message);
+      };
+      var fold = function (onError, _) {
+        return onError(message);
+      };
+      return {
+        isValue: never,
+        isError: always,
+        getOr: identity,
+        getOrThunk: getOrThunk,
+        getOrDie: getOrDie,
+        or: or,
+        orThunk: orThunk,
+        fold: fold,
+        map: map,
+        mapError: mapError,
+        each: noop,
+        bind: bind,
+        exists: never,
+        forall: always,
+        toOptional: Optional.none
+      };
+    };
+    var fromOption = function (opt, err) {
+      return opt.fold(function () {
+        return error(err);
+      }, value$2);
+    };
+    var Result = {
+      value: value$2,
+      error: error,
+      fromOption: fromOption
+    };
+
+    var SimpleResultType;
+    (function (SimpleResultType) {
+      SimpleResultType[SimpleResultType['Error'] = 0] = 'Error';
+      SimpleResultType[SimpleResultType['Value'] = 1] = 'Value';
+    }(SimpleResultType || (SimpleResultType = {})));
+    var fold$1 = function (res, onError, onValue) {
+      return res.stype === SimpleResultType.Error ? onError(res.serror) : onValue(res.svalue);
+    };
+    var partition$1 = function (results) {
+      var values = [];
+      var errors = [];
+      each$1(results, function (obj) {
+        fold$1(obj, function (err) {
+          return errors.push(err);
+        }, function (val) {
+          return values.push(val);
+        });
+      });
+      return {
+        values: values,
+        errors: errors
+      };
+    };
+    var mapError = function (res, f) {
+      if (res.stype === SimpleResultType.Error) {
+        return {
+          stype: SimpleResultType.Error,
+          serror: f(res.serror)
+        };
+      } else {
+        return res;
+      }
+    };
+    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) {
+      if (res.stype === SimpleResultType.Value) {
+        return f(res.svalue);
+      } else {
+        return res;
+      }
+    };
+    var bindError = function (res, f) {
+      if (res.stype === SimpleResultType.Error) {
+        return f(res.serror);
+      } else {
+        return res;
+      }
+    };
+    var svalue = function (v) {
+      return {
+        stype: SimpleResultType.Value,
+        svalue: v
+      };
+    };
+    var serror = function (e) {
+      return {
+        stype: SimpleResultType.Error,
+        serror: e
+      };
+    };
+    var toResult$1 = function (res) {
+      return fold$1(res, Result.error, Result.value);
+    };
+    var fromResult = function (res) {
+      return res.fold(serror, svalue);
+    };
+    var SimpleResult = {
+      fromResult: fromResult,
+      toResult: toResult$1,
+      svalue: svalue,
+      partition: partition$1,
+      serror: serror,
+      bind: bind$2,
+      bindError: bindError,
+      map: map,
+      mapError: mapError,
+      fold: fold$1
+    };
+
+    var field$3 = function (key, newKey, presence, prop) {
+      return {
+        tag: 'field',
+        key: key,
+        newKey: newKey,
+        presence: presence,
+        prop: prop
+      };
+    };
+    var customField$1 = function (newKey, instantiator) {
+      return {
+        tag: 'custom',
+        newKey: newKey,
+        instantiator: instantiator
+      };
+    };
+    var fold = function (value, ifField, ifCustom) {
+      switch (value.tag) {
+      case 'field':
+        return ifField(value.key, value.newKey, value.presence, value.prop);
+      case 'custom':
+        return ifCustom(value.newKey, value.instantiator);
+      }
+    };
+
+    var shallow$1 = function (old, nu) {
+      return nu;
+    };
+    var deep = function (old, nu) {
+      var bothObjects = isObject(old) && isObject(nu);
+      return bothObjects ? deepMerge(old, nu) : nu;
+    };
+    var baseMerge = function (merger) {
+      return function () {
+        var objects = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          objects[_i] = arguments[_i];
+        }
+        if (objects.length === 0) {
+          throw new Error('Can\'t merge zero objects');
+        }
+        var ret = {};
+        for (var j = 0; j < objects.length; j++) {
+          var curObject = objects[j];
+          for (var key in curObject) {
+            if (has$2(curObject, key)) {
+              ret[key] = merger(ret[key], curObject[key]);
+            }
+          }
+        }
+        return ret;
+      };
+    };
+    var deepMerge = baseMerge(deep);
+    var merge$1 = baseMerge(shallow$1);
+
+    var required$2 = function () {
+      return {
+        tag: 'required',
+        process: {}
+      };
+    };
+    var defaultedThunk = function (fallbackThunk) {
+      return {
+        tag: 'defaultedThunk',
+        process: fallbackThunk
+      };
+    };
+    var defaulted$1 = function (fallback) {
+      return defaultedThunk(constant$1(fallback));
+    };
+    var asOption = function () {
+      return {
+        tag: 'option',
+        process: {}
+      };
+    };
+    var mergeWithThunk = function (baseThunk) {
+      return {
+        tag: 'mergeWithThunk',
+        process: baseThunk
+      };
+    };
+    var mergeWith = function (base) {
+      return mergeWithThunk(constant$1(base));
+    };
+
+    var mergeValues$1 = function (values, base) {
+      return values.length > 0 ? SimpleResult.svalue(deepMerge(base, merge$1.apply(undefined, values))) : SimpleResult.svalue(base);
+    };
+    var mergeErrors$1 = function (errors) {
+      return compose(SimpleResult.serror, flatten)(errors);
+    };
+    var consolidateObj = function (objects, base) {
+      var partition = SimpleResult.partition(objects);
+      return partition.errors.length > 0 ? mergeErrors$1(partition.errors) : mergeValues$1(partition.values, base);
+    };
+    var consolidateArr = function (objects) {
+      var partitions = SimpleResult.partition(objects);
+      return partitions.errors.length > 0 ? mergeErrors$1(partitions.errors) : SimpleResult.svalue(partitions.values);
+    };
+    var ResultCombine = {
+      consolidateObj: consolidateObj,
+      consolidateArr: consolidateArr
+    };
+
+    var formatObj = function (input) {
+      return isObject(input) && keys(input).length > 100 ? ' removed due to size' : JSON.stringify(input, null, 2);
+    };
+    var formatErrors = function (errors) {
+      var es = errors.length > 10 ? errors.slice(0, 10).concat([{
+          path: [],
+          getErrorInfo: constant$1('... (only showing first ten failures)')
+        }]) : errors;
+      return map$2(es, function (e) {
+        return 'Failed path: (' + e.path.join(' > ') + ')\n' + e.getErrorInfo();
+      });
+    };
+
+    var nu$5 = function (path, getErrorInfo) {
+      return SimpleResult.serror([{
+          path: path,
+          getErrorInfo: getErrorInfo
+        }]);
+    };
+    var missingRequired = function (path, key, obj) {
+      return nu$5(path, function () {
+        return 'Could not find valid *required* value for "' + key + '" in ' + formatObj(obj);
+      });
+    };
+    var missingKey = function (path, key) {
+      return nu$5(path, function () {
+        return 'Choice schema did not contain choice key: "' + key + '"';
+      });
+    };
+    var missingBranch = function (path, branches, branch) {
+      return nu$5(path, function () {
+        return 'The chosen schema: "' + branch + '" did not exist in branches: ' + formatObj(branches);
+      });
+    };
+    var unsupportedFields = function (path, unsupported) {
+      return nu$5(path, function () {
+        return 'There are unsupported fields: [' + unsupported.join(', ') + '] specified';
+      });
+    };
+    var custom = function (path, err) {
+      return nu$5(path, constant$1(err));
+    };
+
+    var value$1 = function (validator) {
+      var extract = function (path, val) {
+        return SimpleResult.bindError(validator(val), function (err) {
+          return custom(path, err);
+        });
+      };
+      var toString = constant$1('val');
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+    var anyValue$1 = value$1(SimpleResult.svalue);
+
+    var requiredAccess = function (path, obj, key, bundle) {
+      return get$c(obj, key).fold(function () {
+        return missingRequired(path, key, obj);
+      }, bundle);
+    };
+    var fallbackAccess = function (obj, key, fallback, bundle) {
+      var v = get$c(obj, key).getOrThunk(function () {
+        return fallback(obj);
+      });
+      return bundle(v);
+    };
+    var optionAccess = function (obj, key, bundle) {
+      return bundle(get$c(obj, key));
+    };
+    var optionDefaultedAccess = function (obj, key, fallback, bundle) {
+      var opt = get$c(obj, key).map(function (val) {
+        return val === true ? fallback(obj) : val;
+      });
+      return bundle(opt);
+    };
+    var extractField = function (field, path, obj, key, prop) {
+      var bundle = function (av) {
+        return prop.extract(path.concat([key]), av);
+      };
+      var bundleAsOption = function (optValue) {
+        return optValue.fold(function () {
+          return SimpleResult.svalue(Optional.none());
+        }, function (ov) {
+          var result = prop.extract(path.concat([key]), ov);
+          return SimpleResult.map(result, Optional.some);
+        });
+      };
+      switch (field.tag) {
+      case 'required':
+        return requiredAccess(path, obj, key, bundle);
+      case 'defaultedThunk':
+        return fallbackAccess(obj, key, field.process, bundle);
+      case 'option':
+        return optionAccess(obj, key, bundleAsOption);
+      case 'defaultedOptionThunk':
+        return optionDefaultedAccess(obj, key, field.process, bundleAsOption);
+      case 'mergeWithThunk': {
+          return fallbackAccess(obj, key, constant$1({}), function (v) {
+            var result = deepMerge(field.process(obj), v);
+            return bundle(result);
+          });
+        }
+      }
+    };
+    var extractFields = function (path, obj, fields) {
+      var success = {};
+      var errors = [];
+      for (var _i = 0, fields_1 = fields; _i < fields_1.length; _i++) {
+        var field = fields_1[_i];
+        fold(field, function (key, newKey, presence, prop) {
+          var result = extractField(presence, path, obj, key, prop);
+          SimpleResult.fold(result, function (err) {
+            errors.push.apply(errors, err);
+          }, function (res) {
+            success[newKey] = res;
+          });
+        }, function (newKey, instantiator) {
+          success[newKey] = instantiator(obj);
+        });
+      }
+      return errors.length > 0 ? SimpleResult.serror(errors) : SimpleResult.svalue(success);
+    };
+    var getSetKeys = function (obj) {
+      return keys(filter$1(obj, isNonNullable));
+    };
+    var objOfOnly = function (fields) {
+      var delegate = objOf(fields);
+      var fieldNames = foldr(fields, function (acc, value) {
+        return fold(value, function (key) {
+          var _a;
+          return deepMerge(acc, (_a = {}, _a[key] = true, _a));
+        }, constant$1(acc));
+      }, {});
+      var extract = function (path, o) {
+        var keys = isBoolean(o) ? [] : getSetKeys(o);
+        var extra = filter$2(keys, function (k) {
+          return !hasNonNullableKey(fieldNames, k);
+        });
+        return extra.length === 0 ? delegate.extract(path, o) : unsupportedFields(path, extra);
+      };
+      return {
+        extract: extract,
+        toString: delegate.toString
+      };
+    };
+    var objOf = function (values) {
+      var extract = function (path, o) {
+        return extractFields(path, o, values);
+      };
+      var toString = function () {
+        var fieldStrings = map$2(values, function (value) {
+          return fold(value, function (key, _okey, _presence, prop) {
+            return key + ' -> ' + prop.toString();
+          }, function (newKey, _instantiator) {
+            return 'state(' + newKey + ')';
+          });
+        });
+        return 'obj{\n' + fieldStrings.join('\n') + '}';
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+    var arrOf = function (prop) {
+      var extract = function (path, array) {
+        var results = map$2(array, function (a, i) {
+          return prop.extract(path.concat(['[' + i + ']']), a);
+        });
+        return ResultCombine.consolidateArr(results);
+      };
+      var toString = function () {
+        return 'array(' + prop.toString() + ')';
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+    var setOf$1 = function (validator, prop) {
+      var validateKeys = function (path, keys) {
+        return arrOf(value$1(validator)).extract(path, keys);
+      };
+      var extract = function (path, o) {
+        var keys$1 = keys(o);
+        var validatedKeys = validateKeys(path, keys$1);
+        return SimpleResult.bind(validatedKeys, function (validKeys) {
+          var schema = map$2(validKeys, function (vk) {
+            return field$3(vk, vk, required$2(), prop);
+          });
+          return objOf(schema).extract(path, o);
+        });
+      };
+      var toString = function () {
+        return 'setOf(' + prop.toString() + ')';
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+
+    var anyValue = constant$1(anyValue$1);
+    var typedValue = function (validator, expectedType) {
+      return value$1(function (a) {
+        var actualType = typeof a;
+        return validator(a) ? SimpleResult.svalue(a) : SimpleResult.serror('Expected type: ' + expectedType + ' but got: ' + actualType);
+      });
+    };
+    var functionProcessor = typedValue(isFunction, 'function');
+
+    var chooseFrom = function (path, input, branches, ch) {
+      var fields = get$c(branches, ch);
+      return fields.fold(function () {
+        return missingBranch(path, branches, ch);
+      }, function (vp) {
+        return vp.extract(path.concat(['branch: ' + ch]), input);
+      });
+    };
+    var choose$2 = function (key, branches) {
+      var extract = function (path, input) {
+        var choice = get$c(input, key);
+        return choice.fold(function () {
+          return missingKey(path, key);
+        }, function (chosen) {
+          return chooseFrom(path, input, branches, chosen);
+        });
+      };
+      var toString = function () {
+        return 'chooseOn(' + key + '). Possible values: ' + keys(branches);
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+
+    var valueOf = function (validator) {
+      return value$1(function (v) {
+        return validator(v).fold(SimpleResult.serror, SimpleResult.svalue);
+      });
+    };
+    var setOf = function (validator, prop) {
+      return setOf$1(function (v) {
+        return SimpleResult.fromResult(validator(v));
+      }, prop);
+    };
+    var extractValue = function (label, prop, obj) {
+      var res = prop.extract([label], obj);
+      return SimpleResult.mapError(res, function (errs) {
+        return {
+          input: obj,
+          errors: errs
+        };
+      });
+    };
+    var asRaw = function (label, prop, obj) {
+      return SimpleResult.toResult(extractValue(label, prop, obj));
+    };
+    var getOrDie = function (extraction) {
+      return extraction.fold(function (errInfo) {
+        throw new Error(formatError(errInfo));
+      }, identity);
+    };
+    var asRawOrDie$1 = function (label, prop, obj) {
+      return getOrDie(asRaw(label, prop, obj));
+    };
+    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$1(branches, objOf));
+    };
+
+    var field$2 = field$3;
+    var customField = customField$1;
+    var required$1 = function (key) {
+      return field$2(key, key, required$2(), anyValue());
+    };
+    var requiredOf = function (key, schema) {
+      return field$2(key, key, required$2(), schema);
+    };
+    var forbid = function (key, message) {
+      return field$2(key, key, asOption(), value$1(function (_v) {
+        return SimpleResult.serror('The field: ' + key + ' is forbidden. ' + message);
+      }));
+    };
+    var requiredObjOf = function (key, objSchema) {
+      return field$2(key, key, required$2(), objOf(objSchema));
+    };
+    var option = function (key) {
+      return field$2(key, key, asOption(), anyValue());
+    };
+    var optionOf = function (key, schema) {
+      return field$2(key, key, asOption(), schema);
+    };
+    var optionObjOf = function (key, objSchema) {
+      return optionOf(key, objOf(objSchema));
+    };
+    var optionObjOfOnly = function (key, objSchema) {
+      return optionOf(key, objOfOnly(objSchema));
+    };
+    var defaulted = function (key, fallback) {
+      return field$2(key, key, defaulted$1(fallback), anyValue());
+    };
+    var defaultedOf = function (key, fallback, schema) {
+      return field$2(key, key, defaulted$1(fallback), schema);
+    };
+    var defaultedFunction = function (key, fallback) {
+      return defaultedOf(key, fallback, functionProcessor);
+    };
+    var defaultedObjOf = function (key, fallback, objSchema) {
+      return defaultedOf(key, fallback, objOf(objSchema));
+    };
+
+    var SwapSchema = [
+      required$1('alpha'),
+      required$1('omega')
+    ];
+
+    var generate$5 = function (cases) {
+      if (!isArray(cases)) {
+        throw new Error('cases must be an array');
+      }
+      if (cases.length === 0) {
+        throw new Error('there must be at least one case');
+      }
+      var constructors = [];
+      var adt = {};
+      each$1(cases, function (acase, count) {
+        var keys$1 = keys(acase);
+        if (keys$1.length !== 1) {
+          throw new Error('one and only one name per case');
+        }
+        var key = keys$1[0];
+        var value = acase[key];
+        if (adt[key] !== undefined) {
+          throw new Error('duplicate key detected:' + key);
+        } else if (key === 'cata') {
+          throw new Error('cannot have a case named cata (sorry)');
+        } else if (!isArray(value)) {
+          throw new Error('case arguments must be an array');
+        }
+        constructors.push(key);
+        adt[key] = function () {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          var argLength = args.length;
+          if (argLength !== value.length) {
+            throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength);
+          }
+          var match = function (branches) {
+            var branchKeys = keys(branches);
+            if (constructors.length !== branchKeys.length) {
+              throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(','));
+            }
+            var allReqd = forall(constructors, function (reqKey) {
+              return contains$1(branchKeys, reqKey);
+            });
+            if (!allReqd) {
+              throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', '));
+            }
+            return branches[key].apply(null, args);
+          };
+          return {
+            fold: function () {
+              var foldArgs = [];
+              for (var _i = 0; _i < arguments.length; _i++) {
+                foldArgs[_i] = arguments[_i];
+              }
+              if (foldArgs.length !== cases.length) {
+                throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + foldArgs.length);
+              }
+              var target = foldArgs[count];
+              return target.apply(null, args);
+            },
+            match: match,
+            log: function (label) {
+              console.log(label, {
+                constructors: constructors,
+                constructor: key,
+                params: args
+              });
+            }
+          };
+        };
+      });
+      return adt;
+    };
+    var Adt = { generate: generate$5 };
+
+    Adt.generate([
+      {
+        bothErrors: [
+          'error1',
+          'error2'
+        ]
+      },
+      {
+        firstError: [
+          'error1',
+          'value2'
+        ]
+      },
+      {
+        secondError: [
+          'value1',
+          'error2'
+        ]
+      },
+      {
+        bothValues: [
+          'value1',
+          'value2'
+        ]
+      }
+    ]);
+    var partition = function (results) {
+      var errors = [];
+      var values = [];
+      each$1(results, function (result) {
+        result.fold(function (err) {
+          errors.push(err);
+        }, function (value) {
+          values.push(value);
+        });
+      });
+      return {
+        errors: errors,
+        values: values
+      };
+    };
+
+    var exclude$1 = function (obj, fields) {
+      var r = {};
+      each(obj, function (v, k) {
+        if (!contains$1(fields, k)) {
+          r[k] = v;
+        }
+      });
+      return r;
+    };
+
+    var wrap$1 = function (key, value) {
+      var _a;
+      return _a = {}, _a[key] = value, _a;
+    };
+    var wrapAll$1 = function (keyvalues) {
+      var r = {};
+      each$1(keyvalues, function (kv) {
+        r[kv.key] = kv.value;
+      });
+      return r;
+    };
+
+    var exclude = function (obj, fields) {
+      return exclude$1(obj, fields);
+    };
+    var wrap = function (key, value) {
+      return wrap$1(key, value);
+    };
+    var wrapAll = function (keyvalues) {
+      return wrapAll$1(keyvalues);
+    };
+    var mergeValues = function (values, base) {
+      return values.length === 0 ? Result.value(base) : Result.value(deepMerge(base, merge$1.apply(undefined, values)));
+    };
+    var mergeErrors = function (errors) {
+      return Result.error(flatten(errors));
+    };
+    var consolidate = function (objs, base) {
+      var partitions = partition(objs);
+      return partitions.errors.length > 0 ? mergeErrors(partitions.errors) : mergeValues(partitions.values, base);
+    };
+
+    var is = function (lhs, rhs, comparator) {
+      if (comparator === void 0) {
+        comparator = tripleEquals;
+      }
+      return lhs.exists(function (left) {
+        return comparator(left, rhs);
+      });
+    };
+    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 someIf = function (b, a) {
+      return b ? Optional.some(a) : Optional.none();
+    };
+
+    var ensureIsRoot = function (isRoot) {
+      return isFunction(isRoot) ? isRoot : never;
+    };
+    var ancestor$2 = function (scope, transform, isRoot) {
+      var element = scope.dom;
+      var stop = ensureIsRoot(isRoot);
+      while (element.parentNode) {
+        element = element.parentNode;
+        var el = SugarElement.fromDom(element);
+        var transformed = transform(el);
+        if (transformed.isSome()) {
+          return transformed;
+        } else if (stop(el)) {
+          break;
+        }
+      }
+      return Optional.none();
+    };
+    var closest$3 = function (scope, transform, isRoot) {
+      var current = transform(scope);
+      var stop = ensureIsRoot(isRoot);
+      return current.orThunk(function () {
+        return stop(scope) ? Optional.none() : ancestor$2(scope, transform, stop);
+      });
+    };
+
+    var isSource = function (component, simulatedEvent) {
+      return eq(component.element, simulatedEvent.event.target);
+    };
+
+    var defaultEventHandler = {
+      can: always,
+      abort: never,
+      run: noop
+    };
+    var nu$4 = function (parts) {
+      if (!hasNonNullableKey(parts, 'can') && !hasNonNullableKey(parts, 'abort') && !hasNonNullableKey(parts, 'run')) {
+        throw new Error('EventHandler defined by: ' + JSON.stringify(parts, null, 2) + ' does not have can, abort, or run!');
+      }
+      return __assign(__assign({}, defaultEventHandler), parts);
+    };
+    var all$1 = function (handlers, f) {
+      return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return foldl(handlers, function (acc, handler) {
+          return acc && f(handler).apply(undefined, args);
+        }, true);
+      };
+    };
+    var any = function (handlers, f) {
+      return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return foldl(handlers, function (acc, handler) {
+          return acc || f(handler).apply(undefined, args);
+        }, false);
+      };
+    };
+    var read$1 = function (handler) {
+      return isFunction(handler) ? {
+        can: always,
+        abort: never,
+        run: handler
+      } : handler;
+    };
+    var fuse$1 = function (handlers) {
+      var can = all$1(handlers, function (handler) {
+        return handler.can;
+      });
+      var abort = any(handlers, function (handler) {
+        return handler.abort;
+      });
+      var run = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        each$1(handlers, function (handler) {
+          handler.run.apply(undefined, args);
+        });
+      };
+      return {
+        can: can,
+        abort: abort,
+        run: run
+      };
+    };
+
+    var derive$3 = function (configs) {
+      return wrapAll(configs);
+    };
+    var abort = function (name, predicate) {
+      return {
+        key: name,
+        value: nu$4({ abort: predicate })
+      };
+    };
+    var can = function (name, predicate) {
+      return {
+        key: name,
+        value: nu$4({ can: predicate })
+      };
+    };
+    var run = function (name, handler) {
+      return {
+        key: name,
+        value: nu$4({ run: handler })
+      };
+    };
+    var runActionExtra = function (name, action, extra) {
+      return {
+        key: name,
+        value: nu$4({
+          run: function (component, simulatedEvent) {
+            action.apply(undefined, [
+              component,
+              simulatedEvent
+            ].concat(extra));
+          }
+        })
+      };
+    };
+    var runOnName = function (name) {
+      return function (handler) {
+        return run(name, handler);
+      };
+    };
+    var runOnSourceName = function (name) {
+      return function (handler) {
+        return {
+          key: name,
+          value: nu$4({
+            run: function (component, simulatedEvent) {
+              if (isSource(component, simulatedEvent)) {
+                handler(component, simulatedEvent);
+              }
+            }
+          })
+        };
+      };
+    };
+    var redirectToUid = function (name, uid) {
+      return run(name, function (component, simulatedEvent) {
+        component.getSystem().getByUid(uid).each(function (redirectee) {
+          dispatchEvent(redirectee, redirectee.element, name, simulatedEvent);
+        });
+      });
+    };
+    var redirectToPart = function (name, detail, partName) {
+      var uid = detail.partUids[partName];
+      return redirectToUid(name, uid);
+    };
+    var cutter = function (name) {
+      return run(name, function (component, simulatedEvent) {
+        simulatedEvent.cut();
+      });
+    };
+    var stopper = function (name) {
+      return run(name, function (component, simulatedEvent) {
+        simulatedEvent.stop();
+      });
+    };
+    var runOnSource = function (name, f) {
+      return runOnSourceName(name)(f);
+    };
+    var runOnAttached = runOnSourceName(attachedToDom());
+    var runOnDetached = runOnSourceName(detachedFromDom());
+    var runOnInit = runOnSourceName(systemInit());
+    var runOnExecute = runOnName(execute$5());
+
+    var markAsBehaviourApi = function (f, apiName, apiFunction) {
+      var delegate = apiFunction.toString();
+      var endIndex = delegate.indexOf(')') + 1;
+      var openBracketIndex = delegate.indexOf('(');
+      var parameters = delegate.substring(openBracketIndex + 1, endIndex - 1).split(/,\s*/);
+      f.toFunctionAnnotation = function () {
+        return {
+          name: apiName,
+          parameters: cleanParameters(parameters.slice(0, 1).concat(parameters.slice(3)))
+        };
+      };
+      return f;
+    };
+    var cleanParameters = function (parameters) {
+      return map$2(parameters, function (p) {
+        return endsWith(p, '/*') ? p.substring(0, p.length - '/*'.length) : p;
+      });
+    };
+    var markAsExtraApi = function (f, extraName) {
+      var delegate = f.toString();
+      var endIndex = delegate.indexOf(')') + 1;
+      var openBracketIndex = delegate.indexOf('(');
+      var parameters = delegate.substring(openBracketIndex + 1, endIndex - 1).split(/,\s*/);
+      f.toFunctionAnnotation = function () {
+        return {
+          name: extraName,
+          parameters: cleanParameters(parameters)
+        };
+      };
+      return f;
+    };
+    var markAsSketchApi = function (f, apiFunction) {
+      var delegate = apiFunction.toString();
+      var endIndex = delegate.indexOf(')') + 1;
+      var openBracketIndex = delegate.indexOf('(');
+      var parameters = delegate.substring(openBracketIndex + 1, endIndex - 1).split(/,\s*/);
+      f.toFunctionAnnotation = function () {
+        return {
+          name: 'OVERRIDE',
+          parameters: cleanParameters(parameters.slice(1))
+        };
+      };
+      return f;
+    };
+
+    var nu$3 = function (s) {
+      return {
+        classes: isUndefined(s.classes) ? [] : s.classes,
+        attributes: isUndefined(s.attributes) ? {} : s.attributes,
+        styles: isUndefined(s.styles) ? {} : s.styles
+      };
+    };
+    var merge = function (defnA, mod) {
+      return __assign(__assign({}, defnA), {
+        attributes: __assign(__assign({}, defnA.attributes), mod.attributes),
+        styles: __assign(__assign({}, defnA.styles), mod.styles),
+        classes: defnA.classes.concat(mod.classes)
+      });
+    };
+
+    var executeEvent = function (bConfig, bState, executor) {
+      return runOnExecute(function (component) {
+        executor(component, bConfig, bState);
+      });
+    };
+    var loadEvent = function (bConfig, bState, f) {
+      return runOnInit(function (component, _simulatedEvent) {
+        f(component, bConfig, bState);
+      });
+    };
+    var create$6 = function (schema, name, active, apis, extra, state) {
+      var configSchema = objOfOnly(schema);
+      var schemaSchema = optionObjOf(name, [optionObjOfOnly('config', schema)]);
+      return doCreate(configSchema, schemaSchema, name, active, apis, extra, state);
+    };
+    var createModes$1 = function (modes, name, active, apis, extra, state) {
+      var configSchema = modes;
+      var schemaSchema = optionObjOf(name, [optionOf('config', modes)]);
+      return doCreate(configSchema, schemaSchema, name, active, apis, extra, state);
+    };
+    var wrapApi = function (bName, apiFunction, apiName) {
+      var f = function (component) {
+        var rest = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+          rest[_i - 1] = arguments[_i];
+        }
+        var args = [component].concat(rest);
+        return component.config({ name: constant$1(bName) }).fold(function () {
+          throw new Error('We could not find any behaviour configuration for: ' + bName + '. Using API: ' + apiName);
+        }, function (info) {
+          var rest = Array.prototype.slice.call(args, 1);
+          return apiFunction.apply(undefined, [
+            component,
+            info.config,
+            info.state
+          ].concat(rest));
+        });
+      };
+      return markAsBehaviourApi(f, apiName, apiFunction);
+    };
+    var revokeBehaviour = function (name) {
+      return {
+        key: name,
+        value: undefined
+      };
+    };
+    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$1(apis, function (apiF, apiName) {
+        return wrapApi(name, apiF, apiName);
+      });
+      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 prepared = asRawOrDie$1(name + '-config', configSchema, spec);
+          return {
+            key: name,
+            value: {
+              config: prepared,
+              me: me,
+              configAsRaw: cached(function () {
+                return asRawOrDie$1(name + '-config', configSchema, spec);
+              }),
+              initialConfig: spec,
+              state: state
+            }
+          };
+        },
+        schema: constant$1(schemaSchema),
+        exhibit: function (info, base) {
+          return lift2(getConfig(info), get$c(active, 'exhibit'), function (behaviourInfo, exhibitor) {
+            return exhibitor(base, behaviourInfo.config, behaviourInfo.state);
+          }).getOrThunk(function () {
+            return nu$3({});
+          });
+        },
+        name: constant$1(name),
+        handlers: function (info) {
+          return getConfig(info).map(function (behaviourInfo) {
+            var getEvents = get$c(active, 'events').getOr(function () {
+              return {};
+            });
+            return getEvents(behaviourInfo.config, behaviourInfo.state);
+          }).getOr({});
+        }
+      });
+      return me;
+    };
+
+    var NoState = {
+      init: function () {
+        return nu$2({ readState: constant$1('No State required') });
+      }
+    };
+    var nu$2 = function (spec) {
+      return spec;
+    };
+
+    var derive$2 = function (capabilities) {
+      return wrapAll(capabilities);
+    };
+    var simpleSchema = objOfOnly([
+      required$1('fields'),
+      required$1('name'),
+      defaulted('active', {}),
+      defaulted('apis', {}),
+      defaulted('state', NoState),
+      defaulted('extra', {})
+    ]);
+    var create$5 = function (data) {
+      var value = asRawOrDie$1('Creating behaviour: ' + data.name, simpleSchema, data);
+      return create$6(value.fields, value.name, value.active, value.apis, value.extra, value.state);
+    };
+    var modeSchema = objOfOnly([
+      required$1('branchKey'),
+      required$1('branches'),
+      required$1('name'),
+      defaulted('active', {}),
+      defaulted('apis', {}),
+      defaulted('state', NoState),
+      defaulted('extra', {})
+    ]);
+    var createModes = function (data) {
+      var value = asRawOrDie$1('Creating behaviour: ' + data.name, modeSchema, data);
+      return createModes$1(choose$1(value.branchKey, value.branches), value.name, value.active, value.apis, value.extra, value.state);
+    };
+    var revoke = constant$1(undefined);
+
+    var Swapping = create$5({
+      fields: SwapSchema,
+      name: 'swapping',
+      apis: SwapApis
+    });
+
+    var Cell = function (initial) {
+      var value = initial;
+      var get = function () {
+        return value;
+      };
+      var set = function (v) {
+        value = v;
+      };
+      return {
+        get: get,
+        set: set
+      };
+    };
+
+    var getDocument = function () {
+      return SugarElement.fromDom(document);
+    };
+
+    var focus$3 = function (element) {
+      return element.dom.focus();
+    };
+    var blur$1 = function (element) {
+      return element.dom.blur();
+    };
+    var hasFocus = function (element) {
+      var root = getRootNode(element).dom;
+      return element.dom === root.activeElement;
+    };
+    var active = function (root) {
+      if (root === void 0) {
+        root = getDocument();
+      }
+      return Optional.from(root.dom.activeElement).map(SugarElement.fromDom);
+    };
+    var search = function (element) {
+      return active(getRootNode(element)).filter(function (e) {
+        return element.dom.contains(e.dom);
+      });
+    };
+
+    var global$5 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
+
+    var global$4 = tinymce.util.Tools.resolve('tinymce.ThemeManager');
+
+    var openLink = function (target) {
+      var link = document.createElement('a');
+      link.target = '_blank';
+      link.href = target.href;
+      link.rel = 'noreferrer noopener';
+      var nuEvt = document.createEvent('MouseEvents');
+      nuEvt.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+      document.body.appendChild(link);
+      link.dispatchEvent(nuEvt);
+      document.body.removeChild(link);
+    };
+
+    var DefaultStyleFormats = [
+      {
+        title: 'Headings',
+        items: [
+          {
+            title: 'Heading 1',
+            format: 'h1'
+          },
+          {
+            title: 'Heading 2',
+            format: 'h2'
+          },
+          {
+            title: 'Heading 3',
+            format: 'h3'
+          },
+          {
+            title: 'Heading 4',
+            format: 'h4'
+          },
+          {
+            title: 'Heading 5',
+            format: 'h5'
+          },
+          {
+            title: 'Heading 6',
+            format: 'h6'
+          }
+        ]
+      },
+      {
+        title: 'Inline',
+        items: [
+          {
+            title: 'Bold',
+            icon: 'bold',
+            format: 'bold'
+          },
+          {
+            title: 'Italic',
+            icon: 'italic',
+            format: 'italic'
+          },
+          {
+            title: 'Underline',
+            icon: 'underline',
+            format: 'underline'
+          },
+          {
+            title: 'Strikethrough',
+            icon: 'strikethrough',
+            format: 'strikethrough'
+          },
+          {
+            title: 'Superscript',
+            icon: 'superscript',
+            format: 'superscript'
+          },
+          {
+            title: 'Subscript',
+            icon: 'subscript',
+            format: 'subscript'
+          },
+          {
+            title: 'Code',
+            icon: 'code',
+            format: 'code'
+          }
+        ]
+      },
+      {
+        title: 'Blocks',
+        items: [
+          {
+            title: 'Paragraph',
+            format: 'p'
+          },
+          {
+            title: 'Blockquote',
+            format: 'blockquote'
+          },
+          {
+            title: 'Div',
+            format: 'div'
+          },
+          {
+            title: 'Pre',
+            format: 'pre'
+          }
+        ]
+      },
+      {
+        title: 'Alignment',
+        items: [
+          {
+            title: 'Left',
+            icon: 'alignleft',
+            format: 'alignleft'
+          },
+          {
+            title: 'Center',
+            icon: 'aligncenter',
+            format: 'aligncenter'
+          },
+          {
+            title: 'Right',
+            icon: 'alignright',
+            format: 'alignright'
+          },
+          {
+            title: 'Justify',
+            icon: 'alignjustify',
+            format: 'alignjustify'
+          }
+        ]
+      }
+    ];
+
+    var defaults = [
+      'undo',
+      'bold',
+      'italic',
+      'link',
+      'image',
+      'bullist',
+      'styleselect'
+    ];
+    var isSkinDisabled = function (editor) {
+      return editor.getParam('skin') === false;
+    };
+    var readOnlyOnInit = function (_editor) {
+      return false;
+    };
+    var getToolbar = function (editor) {
+      return editor.getParam('toolbar', defaults, 'array');
+    };
+    var getStyleFormats = function (editor) {
+      return editor.getParam('style_formats', DefaultStyleFormats, 'array');
+    };
+    var getSkinUrl = function (editor) {
+      return editor.getParam('skin_url');
+    };
+
+    var formatChanged = 'formatChanged';
+    var orientationChanged = 'orientationChanged';
+    var dropupDismissed = 'dropupDismissed';
+
+    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$9 = function (element) {
+      return element.dom.innerHTML;
+    };
+    var set$7 = function (element, content) {
+      var owner = owner$2(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 = function (element) {
+      var container = SugarElement.fromTag('div');
+      var clone = SugarElement.fromDom(element.dom.cloneNode(true));
+      append$2(container, clone);
+      return get$9(container);
+    };
+
+    var clone = function (original, isDeep) {
+      return SugarElement.fromDom(original.dom.cloneNode(isDeep));
+    };
+    var shallow = function (original) {
+      return clone(original, false);
+    };
+
+    var getHtml = function (element) {
+      if (isShadowRoot(element)) {
+        return '#shadow-root';
+      } else {
+        var clone = shallow(element);
+        return getOuter(clone);
+      }
+    };
+
+    var element = function (elem) {
+      return getHtml(elem);
+    };
+
+    var chooseChannels = function (channels, message) {
+      return message.universal ? channels : filter$2(channels, function (ch) {
+        return contains$1(message.channels, ch);
+      });
+    };
+    var events$a = function (receiveConfig) {
+      return derive$3([run(receive$1(), function (component, message) {
+          var channelMap = receiveConfig.channels;
+          var channels = keys(channelMap);
+          var receivingData = message;
+          var targetChannels = chooseChannels(channels, receivingData);
+          each$1(targetChannels, function (ch) {
+            var channelInfo = channelMap[ch];
+            var channelSchema = channelInfo.schema;
+            var data = asRawOrDie$1('channel[' + ch + '] data\nReceiver: ' + element(component.element), channelSchema, receivingData.data);
+            channelInfo.onReceive(component, data);
+          });
+        })]);
+    };
+
+    var ActiveReceiving = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$a
+    });
+
+    var unknown = 'unknown';
+    var EventConfiguration;
+    (function (EventConfiguration) {
+      EventConfiguration[EventConfiguration['STOP'] = 0] = 'STOP';
+      EventConfiguration[EventConfiguration['NORMAL'] = 1] = 'NORMAL';
+      EventConfiguration[EventConfiguration['LOGGING'] = 2] = 'LOGGING';
+    }(EventConfiguration || (EventConfiguration = {})));
+    var eventConfig = Cell({});
+    var makeEventLogger = function (eventName, initialTarget) {
+      var sequence = [];
+      var startTime = new Date().getTime();
+      return {
+        logEventCut: function (_name, target, purpose) {
+          sequence.push({
+            outcome: 'cut',
+            target: target,
+            purpose: purpose
+          });
+        },
+        logEventStopped: function (_name, target, purpose) {
+          sequence.push({
+            outcome: 'stopped',
+            target: target,
+            purpose: purpose
+          });
+        },
+        logNoParent: function (_name, target, purpose) {
+          sequence.push({
+            outcome: 'no-parent',
+            target: target,
+            purpose: purpose
+          });
+        },
+        logEventNoHandlers: function (_name, target) {
+          sequence.push({
+            outcome: 'no-handlers-left',
+            target: target
+          });
+        },
+        logEventResponse: function (_name, target, purpose) {
+          sequence.push({
+            outcome: 'response',
+            purpose: purpose,
+            target: target
+          });
+        },
+        write: function () {
+          var finishTime = new Date().getTime();
+          if (contains$1([
+              'mousemove',
+              'mouseover',
+              'mouseout',
+              systemInit()
+            ], eventName)) {
+            return;
+          }
+          console.log(eventName, {
+            event: eventName,
+            time: finishTime - startTime,
+            target: initialTarget.dom,
+            sequence: map$2(sequence, function (s) {
+              if (!contains$1([
+                  'cut',
+                  'stopped',
+                  'response'
+                ], s.outcome)) {
+                return s.outcome;
+              } else {
+                return '{' + s.purpose + '} ' + s.outcome + ' at (' + element(s.target) + ')';
+              }
+            })
+          });
+        }
+      };
+    };
+    var processEvent = function (eventName, initialTarget, f) {
+      var status = get$c(eventConfig.get(), eventName).orThunk(function () {
+        var patterns = keys(eventConfig.get());
+        return findMap(patterns, function (p) {
+          return eventName.indexOf(p) > -1 ? Optional.some(eventConfig.get()[p]) : Optional.none();
+        });
+      }).getOr(EventConfiguration.NORMAL);
+      switch (status) {
+      case EventConfiguration.NORMAL:
+        return f(noLogger());
+      case EventConfiguration.LOGGING: {
+          var logger = makeEventLogger(eventName, initialTarget);
+          var output = f(logger);
+          logger.write();
+          return output;
+        }
+      case EventConfiguration.STOP:
+        return true;
+      }
+    };
+    var path = [
+      'alloy/data/Fields',
+      'alloy/debugging/Debugging'
+    ];
+    var getTrace = function () {
+      var err = new Error();
+      if (err.stack !== undefined) {
+        var lines = err.stack.split('\n');
+        return find$2(lines, function (line) {
+          return line.indexOf('alloy') > 0 && !exists(path, function (p) {
+            return line.indexOf(p) > -1;
+          });
+        }).getOr(unknown);
+      } else {
+        return unknown;
+      }
+    };
+    var ignoreEvent = {
+      logEventCut: noop,
+      logEventStopped: noop,
+      logNoParent: noop,
+      logEventNoHandlers: noop,
+      logEventResponse: noop,
+      write: noop
+    };
+    var monitorEvent = function (eventName, initialTarget, f) {
+      return processEvent(eventName, initialTarget, f);
+    };
+    var noLogger = constant$1(ignoreEvent);
+
+    var menuFields = constant$1([
+      required$1('menu'),
+      required$1('selectedMenu')
+    ]);
+    var itemFields = constant$1([
+      required$1('item'),
+      required$1('selectedItem')
+    ]);
+    constant$1(objOf(itemFields().concat(menuFields())));
+    var itemSchema$1 = constant$1(objOf(itemFields()));
+
+    var _initSize = requiredObjOf('initSize', [
+      required$1('numColumns'),
+      required$1('numRows')
+    ]);
+    var itemMarkers = function () {
+      return requiredOf('markers', itemSchema$1());
+    };
+    var tieredMenuMarkers = function () {
+      return requiredObjOf('markers', [required$1('backgroundMenu')].concat(menuFields()).concat(itemFields()));
+    };
+    var markers = function (required) {
+      return requiredObjOf('markers', map$2(required, required$1));
+    };
+    var onPresenceHandler = function (label, fieldName, presence) {
+      getTrace();
+      return field$2(fieldName, fieldName, presence, valueOf(function (f) {
+        return Result.value(function () {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return f.apply(undefined, args);
+        });
+      }));
+    };
+    var onHandler = function (fieldName) {
+      return onPresenceHandler('onHandler', fieldName, defaulted$1(noop));
+    };
+    var onKeyboardHandler = function (fieldName) {
+      return onPresenceHandler('onKeyboardHandler', fieldName, defaulted$1(Optional.none));
+    };
+    var onStrictHandler = function (fieldName) {
+      return onPresenceHandler('onHandler', fieldName, required$2());
+    };
+    var onStrictKeyboardHandler = function (fieldName) {
+      return onPresenceHandler('onKeyboardHandler', fieldName, required$2());
+    };
+    var output = function (name, value) {
+      return customField(name, constant$1(value));
+    };
+    var snapshot = function (name) {
+      return customField(name, identity);
+    };
+    var initSize = constant$1(_initSize);
+
+    var ReceivingSchema = [requiredOf('channels', setOf(Result.value, objOfOnly([
+        onStrictHandler('onReceive'),
+        defaulted('schema', anyValue())
+      ])))];
+
+    var Receiving = create$5({
+      fields: ReceivingSchema,
+      name: 'receiving',
+      active: ActiveReceiving
+    });
+
+    var SetupBehaviourCellState = function (initialState) {
+      var init = function () {
+        var cell = Cell(initialState);
+        var get = function () {
+          return cell.get();
+        };
+        var set = function (newState) {
+          return cell.set(newState);
+        };
+        var clear = function () {
+          return cell.set(initialState);
+        };
+        var readState = function () {
+          return cell.get();
+        };
+        return {
+          get: get,
+          set: set,
+          clear: clear,
+          readState: readState
+        };
+      };
+      return { init: init };
+    };
+
+    var updateAriaState = function (component, toggleConfig, toggleState) {
+      var ariaInfo = toggleConfig.aria;
+      ariaInfo.update(component, ariaInfo, toggleState.get());
+    };
+    var updateClass = function (component, toggleConfig, toggleState) {
+      toggleConfig.toggleClass.each(function (toggleClass) {
+        if (toggleState.get()) {
+          add$1(component.element, toggleClass);
+        } else {
+          remove$3(component.element, toggleClass);
+        }
+      });
+    };
+    var toggle = function (component, toggleConfig, toggleState) {
+      set$6(component, toggleConfig, toggleState, !toggleState.get());
+    };
+    var on$1 = function (component, toggleConfig, toggleState) {
+      toggleState.set(true);
+      updateClass(component, toggleConfig, toggleState);
+      updateAriaState(component, toggleConfig, toggleState);
+    };
+    var off = function (component, toggleConfig, toggleState) {
+      toggleState.set(false);
+      updateClass(component, toggleConfig, toggleState);
+      updateAriaState(component, toggleConfig, toggleState);
+    };
+    var set$6 = function (component, toggleConfig, toggleState, state) {
+      var action = state ? on$1 : off;
+      action(component, toggleConfig, toggleState);
+    };
+    var isOn = function (component, toggleConfig, toggleState) {
+      return toggleState.get();
+    };
+    var onLoad$5 = function (component, toggleConfig, toggleState) {
+      set$6(component, toggleConfig, toggleState, toggleConfig.selected);
+    };
+
+    var ToggleApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        onLoad: onLoad$5,
+        toggle: toggle,
+        isOn: isOn,
+        on: on$1,
+        off: off,
+        set: set$6
+    });
+
+    var exhibit$5 = function () {
+      return nu$3({});
+    };
+    var events$9 = function (toggleConfig, toggleState) {
+      var execute = executeEvent(toggleConfig, toggleState, toggle);
+      var load = loadEvent(toggleConfig, toggleState, onLoad$5);
+      return derive$3(flatten([
+        toggleConfig.toggleOnExecute ? [execute] : [],
+        [load]
+      ]));
+    };
+
+    var ActiveToggle = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit$5,
+        events: events$9
+    });
+
+    var updatePressed = function (component, ariaInfo, status) {
+      set$8(component.element, 'aria-pressed', status);
+      if (ariaInfo.syncWithExpanded) {
+        updateExpanded(component, ariaInfo, status);
+      }
+    };
+    var updateSelected = function (component, ariaInfo, status) {
+      set$8(component.element, 'aria-selected', status);
+    };
+    var updateChecked = function (component, ariaInfo, status) {
+      set$8(component.element, 'aria-checked', status);
+    };
+    var updateExpanded = function (component, ariaInfo, status) {
+      set$8(component.element, 'aria-expanded', status);
+    };
+
+    var ToggleSchema = [
+      defaulted('selected', false),
+      option('toggleClass'),
+      defaulted('toggleOnExecute', true),
+      defaultedOf('aria', { mode: 'none' }, choose$1('mode', {
+        pressed: [
+          defaulted('syncWithExpanded', false),
+          output('update', updatePressed)
+        ],
+        checked: [output('update', updateChecked)],
+        expanded: [output('update', updateExpanded)],
+        selected: [output('update', updateSelected)],
+        none: [output('update', noop)]
+      }))
+    ];
+
+    var Toggling = create$5({
+      fields: ToggleSchema,
+      name: 'toggling',
+      active: ActiveToggle,
+      apis: ToggleApis,
+      state: SetupBehaviourCellState(false)
+    });
+
+    var format = function (command, update) {
+      return Receiving.config({
+        channels: wrap(formatChanged, {
+          onReceive: function (button, data) {
+            if (data.command === command) {
+              update(button, data.state);
+            }
+          }
+        })
+      });
+    };
+    var orientation = function (onReceive) {
+      return Receiving.config({ channels: wrap(orientationChanged, { onReceive: onReceive }) });
+    };
+    var receive = function (channel, onReceive) {
+      return {
+        key: channel,
+        value: { onReceive: onReceive }
+      };
+    };
+
+    var prefix$2 = 'tinymce-mobile';
+    var resolve = function (p) {
+      return prefix$2 + '-' + p;
+    };
+
+    var pointerEvents = function () {
+      var onClick = function (component, simulatedEvent) {
+        simulatedEvent.stop();
+        emitExecute(component);
+      };
+      return [
+        run(click(), onClick),
+        run(tap(), onClick),
+        cutter(touchstart()),
+        cutter(mousedown())
+      ];
+    };
+    var events$8 = function (optAction) {
+      var executeHandler = function (action) {
+        return runOnExecute(function (component, simulatedEvent) {
+          action(component);
+          simulatedEvent.stop();
+        });
+      };
+      return derive$3(flatten([
+        optAction.map(executeHandler).toArray(),
+        pointerEvents()
+      ]));
+    };
+
+    var focus$2 = function (component, focusConfig) {
+      if (!focusConfig.ignore) {
+        focus$3(component.element);
+        focusConfig.onFocus(component);
+      }
+    };
+    var blur = function (component, focusConfig) {
+      if (!focusConfig.ignore) {
+        blur$1(component.element);
+      }
+    };
+    var isFocused = function (component) {
+      return hasFocus(component.element);
+    };
+
+    var FocusApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        focus: focus$2,
+        blur: blur,
+        isFocused: isFocused
+    });
+
+    var exhibit$4 = function (base, focusConfig) {
+      var mod = focusConfig.ignore ? {} : { attributes: { tabindex: '-1' } };
+      return nu$3(mod);
+    };
+    var events$7 = function (focusConfig) {
+      return derive$3([run(focus$4(), function (component, simulatedEvent) {
+          focus$2(component, focusConfig);
+          simulatedEvent.stop();
+        })].concat(focusConfig.stopMousedown ? [run(mousedown(), function (_, simulatedEvent) {
+          simulatedEvent.event.prevent();
+        })] : []));
+    };
+
+    var ActiveFocus = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit$4,
+        events: events$7
+    });
+
+    var FocusSchema = [
+      onHandler('onFocus'),
+      defaulted('stopMousedown', false),
+      defaulted('ignore', false)
+    ];
+
+    var Focusing = create$5({
+      fields: FocusSchema,
+      name: 'focusing',
+      active: ActiveFocus,
+      apis: FocusApis
+    });
+
+    var isSupported = function (dom) {
+      return dom.style !== undefined && isFunction(dom.style.getPropertyValue);
+    };
+
+    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$5 = 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 get$8 = 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 remove$2 = function (element, property) {
+      var dom = element.dom;
+      internalRemove(dom, property);
+      if (is(getOpt(element, 'style').map(trim), '')) {
+        remove$6(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(dom)) {
+          dom.style[name] = h + 'px';
+        }
+      };
+      var get = function (element) {
+        var r = getOffset(element);
+        if (r <= 0 || r === null) {
+          var css = get$8(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$8(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$7 = function (element) {
+      return api$3.get(element);
+    };
+
+    var ancestors$1 = function (scope, predicate, isRoot) {
+      return filter$2(parents(scope, isRoot), predicate);
+    };
+    var siblings$1 = function (scope, predicate) {
+      return filter$2(siblings$2(scope), predicate);
+    };
+
+    var all = function (selector) {
+      return all$2(selector);
+    };
+    var ancestors = function (scope, selector, isRoot) {
+      return ancestors$1(scope, function (e) {
+        return is$1(e, selector);
+      }, isRoot);
+    };
+    var siblings = function (scope, selector) {
+      return siblings$1(scope, function (e) {
+        return is$1(e, selector);
+      });
+    };
+    var descendants = function (scope, selector) {
+      return all$2(selector, scope);
+    };
+
+    function ClosestOrAncestor (is, ancestor, scope, a, isRoot) {
+      if (is(scope, a)) {
+        return Optional.some(scope);
+      } else if (isFunction(isRoot) && isRoot(scope)) {
+        return Optional.none();
+      } else {
+        return ancestor(scope, a, isRoot);
+      }
+    }
+
+    var ancestor$1 = function (scope, predicate, isRoot) {
+      var element = scope.dom;
+      var stop = isFunction(isRoot) ? isRoot : never;
+      while (element.parentNode) {
+        element = element.parentNode;
+        var el = SugarElement.fromDom(element);
+        if (predicate(el)) {
+          return Optional.some(el);
+        } else if (stop(el)) {
+          break;
+        }
+      }
+      return Optional.none();
+    };
+    var closest$2 = function (scope, predicate, isRoot) {
+      var is = function (s, test) {
+        return test(s);
+      };
+      return ClosestOrAncestor(is, ancestor$1, scope, predicate, isRoot);
+    };
+    var descendant$1 = function (scope, predicate) {
+      var descend = function (node) {
+        for (var i = 0; i < node.childNodes.length; i++) {
+          var child_1 = SugarElement.fromDom(node.childNodes[i]);
+          if (predicate(child_1)) {
+            return Optional.some(child_1);
+          }
+          var res = descend(node.childNodes[i]);
+          if (res.isSome()) {
+            return res;
+          }
+        }
+        return Optional.none();
+      };
+      return descend(scope.dom);
+    };
+
+    var first$1 = function (selector) {
+      return one(selector);
+    };
+    var ancestor = function (scope, selector, isRoot) {
+      return ancestor$1(scope, function (e) {
+        return is$1(e, selector);
+      }, isRoot);
+    };
+    var descendant = function (scope, selector) {
+      return one(selector, scope);
+    };
+    var closest$1 = function (scope, selector, isRoot) {
+      var is = function (element, selector) {
+        return is$1(element, selector);
+      };
+      return ClosestOrAncestor(is, ancestor, scope, selector, isRoot);
+    };
+
+    var BACKSPACE = [8];
+    var TAB = [9];
+    var ENTER = [13];
+    var ESCAPE = [27];
+    var SPACE = [32];
+    var LEFT = [37];
+    var UP = [38];
+    var RIGHT = [39];
+    var DOWN = [40];
+
+    var cyclePrev = function (values, index, predicate) {
+      var before = reverse(values.slice(0, index));
+      var after = reverse(values.slice(index + 1));
+      return find$2(before.concat(after), predicate);
+    };
+    var tryPrev = function (values, index, predicate) {
+      var before = reverse(values.slice(0, index));
+      return find$2(before, predicate);
+    };
+    var cycleNext = function (values, index, predicate) {
+      var before = values.slice(0, index);
+      var after = values.slice(index + 1);
+      return find$2(after.concat(before), predicate);
+    };
+    var tryNext = function (values, index, predicate) {
+      var after = values.slice(index + 1);
+      return find$2(after, predicate);
+    };
+
+    var inSet = function (keys) {
+      return function (event) {
+        var raw = event.raw;
+        return contains$1(keys, raw.which);
+      };
+    };
+    var and = function (preds) {
+      return function (event) {
+        return forall(preds, function (pred) {
+          return pred(event);
+        });
+      };
+    };
+    var isShift = function (event) {
+      var raw = event.raw;
+      return raw.shiftKey === true;
+    };
+    var isControl = function (event) {
+      var raw = event.raw;
+      return raw.ctrlKey === true;
+    };
+    var isNotShift = not(isShift);
+
+    var rule = function (matches, action) {
+      return {
+        matches: matches,
+        classification: action
+      };
+    };
+    var choose = function (transitions, event) {
+      var transition = find$2(transitions, function (t) {
+        return t.matches(event);
+      });
+      return transition.map(function (t) {
+        return t.classification;
+      });
+    };
+
+    var cycleBy = function (value, delta, min, max) {
+      var r = value + delta;
+      if (r > max) {
+        return min;
+      } else if (r < min) {
+        return max;
+      } else {
+        return r;
+      }
+    };
+    var clamp = function (value, min, max) {
+      return Math.min(Math.max(value, min), max);
+    };
+
+    var dehighlightAllExcept = function (component, hConfig, hState, skip) {
+      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);
+          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);
+        hConfig.onDehighlight(component, target);
+        emit(target, dehighlight$1());
+      }
+    };
+    var highlight = function (component, hConfig, hState, target) {
+      dehighlightAllExcept(component, hConfig, hState, [target]);
+      if (!isHighlighted(component, hConfig, hState, target)) {
+        add$1(target.element, hConfig.highlightClass);
+        hConfig.onHighlight(component, target);
+        emit(target, highlight$1());
+      }
+    };
+    var highlightFirst = function (component, hConfig, hState) {
+      getFirst(component, hConfig).each(function (firstComp) {
+        highlight(component, hConfig, hState, firstComp);
+      });
+    };
+    var highlightLast = function (component, hConfig, hState) {
+      getLast(component, hConfig).each(function (lastComp) {
+        highlight(component, hConfig, hState, lastComp);
+      });
+    };
+    var highlightAt = function (component, hConfig, hState, index) {
+      getByIndex(component, hConfig, hState, index).fold(function (err) {
+        throw err;
+      }, function (firstComp) {
+        highlight(component, hConfig, hState, firstComp);
+      });
+    };
+    var highlightBy = function (component, hConfig, hState, predicate) {
+      var candidates = getCandidates(component, hConfig);
+      var targetComp = find$2(candidates, predicate);
+      targetComp.each(function (c) {
+        highlight(component, hConfig, hState, c);
+      });
+    };
+    var isHighlighted = function (component, hConfig, hState, queryTarget) {
+      return has(queryTarget.element, hConfig.highlightClass);
+    };
+    var getHighlighted = function (component, hConfig, _hState) {
+      return descendant(component.element, '.' + hConfig.highlightClass).bind(function (e) {
+        return component.getSystem().getByDom(e).toOptional();
+      });
+    };
+    var getByIndex = function (component, hConfig, hState, index) {
+      var items = descendants(component.element, '.' + hConfig.itemClass);
+      return Optional.from(items[index]).fold(function () {
+        return Result.error(new Error('No element found with index ' + index));
+      }, component.getSystem().getByDom);
+    };
+    var getFirst = function (component, hConfig, _hState) {
+      return descendant(component.element, '.' + hConfig.itemClass).bind(function (e) {
+        return component.getSystem().getByDom(e).toOptional();
+      });
+    };
+    var getLast = function (component, hConfig, _hState) {
+      var items = descendants(component.element, '.' + hConfig.itemClass);
+      var last = items.length > 0 ? Optional.some(items[items.length - 1]) : Optional.none();
+      return last.bind(function (c) {
+        return component.getSystem().getByDom(c).toOptional();
+      });
+    };
+    var getDelta = function (component, hConfig, hState, delta) {
+      var items = descendants(component.element, '.' + hConfig.itemClass);
+      var current = findIndex$1(items, function (item) {
+        return has(item, hConfig.highlightClass);
+      });
+      return current.bind(function (selected) {
+        var dest = cycleBy(selected, delta, 0, items.length - 1);
+        return component.getSystem().getByDom(items[dest]).toOptional();
+      });
+    };
+    var getPrevious = function (component, hConfig, hState) {
+      return getDelta(component, hConfig, hState, -1);
+    };
+    var getNext = function (component, hConfig, hState) {
+      return getDelta(component, hConfig, hState, +1);
+    };
+    var getCandidates = function (component, hConfig, _hState) {
+      var items = descendants(component.element, '.' + hConfig.itemClass);
+      return cat(map$2(items, function (i) {
+        return component.getSystem().getByDom(i).toOptional();
+      }));
+    };
+
+    var HighlightApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        dehighlightAll: dehighlightAll,
+        dehighlight: dehighlight,
+        highlight: highlight,
+        highlightFirst: highlightFirst,
+        highlightLast: highlightLast,
+        highlightAt: highlightAt,
+        highlightBy: highlightBy,
+        isHighlighted: isHighlighted,
+        getHighlighted: getHighlighted,
+        getFirst: getFirst,
+        getLast: getLast,
+        getPrevious: getPrevious,
+        getNext: getNext,
+        getCandidates: getCandidates
+    });
+
+    var HighlightSchema = [
+      required$1('highlightClass'),
+      required$1('itemClass'),
+      onHandler('onHighlight'),
+      onHandler('onDehighlight')
+    ];
+
+    var Highlighting = create$5({
+      fields: HighlightSchema,
+      name: 'highlighting',
+      apis: HighlightApis
+    });
+
+    var reportFocusShifting = function (component, prevFocus, newFocus) {
+      var noChange = prevFocus.exists(function (p) {
+        return newFocus.exists(function (n) {
+          return eq(n, p);
+        });
+      });
+      if (!noChange) {
+        emitWith(component, focusShifted(), {
+          prevFocus: prevFocus,
+          newFocus: newFocus
+        });
+      }
+    };
+    var dom$2 = function () {
+      var get = function (component) {
+        return search(component.element);
+      };
+      var set = function (component, focusee) {
+        var prevFocus = get(component);
+        component.getSystem().triggerFocus(focusee, component.element);
+        var newFocus = get(component);
+        reportFocusShifting(component, prevFocus, newFocus);
+      };
+      return {
+        get: get,
+        set: set
+      };
+    };
+    var highlights = function () {
+      var get = function (component) {
+        return Highlighting.getHighlighted(component).map(function (item) {
+          return item.element;
+        });
+      };
+      var set = function (component, element) {
+        var prevFocus = get(component);
+        component.getSystem().getByDom(element).fold(noop, function (item) {
+          Highlighting.highlight(component, item);
+        });
+        var newFocus = get(component);
+        reportFocusShifting(component, prevFocus, newFocus);
+      };
+      return {
+        get: get,
+        set: set
+      };
+    };
+
+    var FocusInsideModes;
+    (function (FocusInsideModes) {
+      FocusInsideModes['OnFocusMode'] = 'onFocus';
+      FocusInsideModes['OnEnterOrSpaceMode'] = 'onEnterOrSpace';
+      FocusInsideModes['OnApiMode'] = 'onApi';
+    }(FocusInsideModes || (FocusInsideModes = {})));
+
+    var typical = function (infoSchema, stateInit, getKeydownRules, getKeyupRules, optFocusIn) {
+      var schema = function () {
+        return infoSchema.concat([
+          defaulted('focusManager', dom$2()),
+          defaultedOf('focusInside', 'onFocus', valueOf(function (val) {
+            return contains$1([
+              'onFocus',
+              'onEnterOrSpace',
+              'onApi'
+            ], val) ? Result.value(val) : Result.error('Invalid value for focusInside');
+          })),
+          output('handler', me),
+          output('state', stateInit),
+          output('sendFocusIn', optFocusIn)
+        ]);
+      };
+      var processKey = function (component, simulatedEvent, getRules, keyingConfig, keyingState) {
+        var rules = getRules(component, simulatedEvent, keyingConfig, keyingState);
+        return choose(rules, simulatedEvent.event).bind(function (rule) {
+          return rule(component, simulatedEvent, keyingConfig, keyingState);
+        });
+      };
+      var toEvents = function (keyingConfig, keyingState) {
+        var onFocusHandler = keyingConfig.focusInside !== FocusInsideModes.OnFocusMode ? Optional.none() : optFocusIn(keyingConfig).map(function (focusIn) {
+          return run(focus$4(), function (component, simulatedEvent) {
+            focusIn(component, keyingConfig, keyingState);
+            simulatedEvent.stop();
+          });
+        });
+        var tryGoInsideComponent = function (component, simulatedEvent) {
+          var isEnterOrSpace = inSet(SPACE.concat(ENTER))(simulatedEvent.event);
+          if (keyingConfig.focusInside === FocusInsideModes.OnEnterOrSpaceMode && isEnterOrSpace && isSource(component, simulatedEvent)) {
+            optFocusIn(keyingConfig).each(function (focusIn) {
+              focusIn(component, keyingConfig, keyingState);
+              simulatedEvent.stop();
+            });
+          }
+        };
+        var keyboardEvents = [
+          run(keydown(), function (component, simulatedEvent) {
+            processKey(component, simulatedEvent, getKeydownRules, keyingConfig, keyingState).fold(function () {
+              tryGoInsideComponent(component, simulatedEvent);
+            }, function (_) {
+              simulatedEvent.stop();
+            });
+          }),
+          run(keyup(), function (component, simulatedEvent) {
+            processKey(component, simulatedEvent, getKeyupRules, keyingConfig, keyingState).each(function (_) {
+              simulatedEvent.stop();
+            });
+          })
+        ];
+        return derive$3(onFocusHandler.toArray().concat(keyboardEvents));
+      };
+      var me = {
+        schema: schema,
+        processKey: processKey,
+        toEvents: toEvents
+      };
+      return me;
+    };
+
+    var create$4 = function (cyclicField) {
+      var schema = [
+        option('onEscape'),
+        option('onEnter'),
+        defaulted('selector', '[data-alloy-tabstop="true"]:not(:disabled)'),
+        defaulted('firstTabstop', 0),
+        defaulted('useTabstopAt', always),
+        option('visibilitySelector')
+      ].concat([cyclicField]);
+      var isVisible = function (tabbingConfig, element) {
+        var target = tabbingConfig.visibilitySelector.bind(function (sel) {
+          return closest$1(element, sel);
+        }).getOr(element);
+        return get$7(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.from(visibles[tabbingConfig.firstTabstop]);
+      };
+      var findCurrent = function (component, tabbingConfig) {
+        return tabbingConfig.focusManager.get(component).bind(function (elem) {
+          return closest$1(elem, tabbingConfig.selector);
+        });
+      };
+      var isTabstop = function (tabbingConfig, element) {
+        return isVisible(tabbingConfig, element) && tabbingConfig.useTabstopAt(element);
+      };
+      var focusIn = function (component, tabbingConfig, _tabbingState) {
+        findInitial(component, tabbingConfig).each(function (target) {
+          tabbingConfig.focusManager.set(component, target);
+        });
+      };
+      var goFromTabstop = function (component, tabstops, stopIndex, tabbingConfig, cycle) {
+        return cycle(tabstops, stopIndex, function (elem) {
+          return isTabstop(tabbingConfig, elem);
+        }).fold(function () {
+          return tabbingConfig.cyclic ? Optional.some(true) : Optional.none();
+        }, function (target) {
+          tabbingConfig.focusManager.set(component, target);
+          return Optional.some(true);
+        });
+      };
+      var go = function (component, _simulatedEvent, tabbingConfig, cycle) {
+        var tabstops = descendants(component.element, tabbingConfig.selector);
+        return findCurrent(component, tabbingConfig).bind(function (tabstop) {
+          var optStopIndex = findIndex$1(tabstops, curry(eq, tabstop));
+          return optStopIndex.bind(function (stopIndex) {
+            return goFromTabstop(component, tabstops, stopIndex, tabbingConfig, cycle);
+          });
+        });
+      };
+      var goBackwards = function (component, simulatedEvent, tabbingConfig) {
+        var navigate = tabbingConfig.cyclic ? cyclePrev : tryPrev;
+        return go(component, simulatedEvent, tabbingConfig, navigate);
+      };
+      var goForwards = function (component, simulatedEvent, tabbingConfig) {
+        var navigate = tabbingConfig.cyclic ? cycleNext : tryNext;
+        return go(component, simulatedEvent, tabbingConfig, navigate);
+      };
+      var execute = function (component, simulatedEvent, tabbingConfig) {
+        return tabbingConfig.onEnter.bind(function (f) {
+          return f(component, simulatedEvent);
+        });
+      };
+      var exit = function (component, simulatedEvent, tabbingConfig) {
+        return tabbingConfig.onEscape.bind(function (f) {
+          return f(component, simulatedEvent);
+        });
+      };
+      var getKeydownRules = constant$1([
+        rule(and([
+          isShift,
+          inSet(TAB)
+        ]), goBackwards),
+        rule(inSet(TAB), goForwards),
+        rule(inSet(ESCAPE), exit),
+        rule(and([
+          isNotShift,
+          inSet(ENTER)
+        ]), execute)
+      ]);
+      var getKeyupRules = constant$1([]);
+      return typical(schema, NoState.init, getKeydownRules, getKeyupRules, function () {
+        return Optional.some(focusIn);
+      });
+    };
+
+    var AcyclicType = create$4(customField('cyclic', never));
+
+    var CyclicType = create$4(customField('cyclic', always));
+
+    var inside = function (target) {
+      return name$1(target) === 'input' && get$b(target, 'type') !== 'radio' || name$1(target) === 'textarea';
+    };
+
+    var doDefaultExecute = function (component, _simulatedEvent, focused) {
+      dispatch(component, focused, execute$5());
+      return Optional.some(true);
+    };
+    var defaultExecute = function (component, simulatedEvent, focused) {
+      var isComplex = inside(focused) && inSet(SPACE)(simulatedEvent.event);
+      return isComplex ? Optional.none() : doDefaultExecute(component, simulatedEvent, focused);
+    };
+    var stopEventForFirefox = function (_component, _simulatedEvent) {
+      return Optional.some(true);
+    };
+
+    var schema$f = [
+      defaulted('execute', defaultExecute),
+      defaulted('useSpace', false),
+      defaulted('useEnter', true),
+      defaulted('useControlEnter', false),
+      defaulted('useDown', false)
+    ];
+    var execute$4 = function (component, simulatedEvent, executeConfig) {
+      return executeConfig.execute(component, simulatedEvent, component.element);
+    };
+    var getKeydownRules$5 = function (component, _simulatedEvent, executeConfig, _executeState) {
+      var spaceExec = executeConfig.useSpace && !inside(component.element) ? SPACE : [];
+      var enterExec = executeConfig.useEnter ? ENTER : [];
+      var downExec = executeConfig.useDown ? DOWN : [];
+      var execKeys = spaceExec.concat(enterExec).concat(downExec);
+      return [rule(inSet(execKeys), execute$4)].concat(executeConfig.useControlEnter ? [rule(and([
+          isControl,
+          inSet(ENTER)
+        ]), execute$4)] : []);
+    };
+    var getKeyupRules$5 = function (component, _simulatedEvent, executeConfig, _executeState) {
+      return executeConfig.useSpace && !inside(component.element) ? [rule(inSet(SPACE), stopEventForFirefox)] : [];
+    };
+    var ExecutionType = typical(schema$f, NoState.init, getKeydownRules$5, getKeyupRules$5, function () {
+      return Optional.none();
+    });
+
+    var singleton$1 = function (doRevoke) {
+      var subject = Cell(Optional.none());
+      var revoke = function () {
+        return subject.get().each(doRevoke);
+      };
+      var clear = function () {
+        revoke();
+        subject.set(Optional.none());
+      };
+      var isSet = function () {
+        return subject.get().isSome();
+      };
+      var get = function () {
+        return subject.get();
+      };
+      var set = function (s) {
+        revoke();
+        subject.set(Optional.some(s));
+      };
+      return {
+        clear: clear,
+        isSet: isSet,
+        get: get,
+        set: set
+      };
+    };
+    var destroyable = function () {
+      return singleton$1(function (s) {
+        return s.destroy();
+      });
+    };
+    var api$2 = function () {
+      var subject = destroyable();
+      var run = function (f) {
+        return subject.get().each(f);
+      };
+      return __assign(__assign({}, subject), { run: run });
+    };
+    var value = function () {
+      var subject = singleton$1(noop);
+      var on = function (f) {
+        return subject.get().each(f);
+      };
+      return __assign(__assign({}, subject), { on: on });
+    };
+
+    var flatgrid$1 = function () {
+      var dimensions = value();
+      var setGridSize = function (numRows, numColumns) {
+        dimensions.set({
+          numRows: numRows,
+          numColumns: numColumns
+        });
+      };
+      var getNumRows = function () {
+        return dimensions.get().map(function (d) {
+          return d.numRows;
+        });
+      };
+      var getNumColumns = function () {
+        return dimensions.get().map(function (d) {
+          return d.numColumns;
+        });
+      };
+      return nu$2({
+        readState: function () {
+          return dimensions.get().map(function (d) {
+            return {
+              numRows: String(d.numRows),
+              numColumns: String(d.numColumns)
+            };
+          }).getOr({
+            numRows: '?',
+            numColumns: '?'
+          });
+        },
+        setGridSize: setGridSize,
+        getNumRows: getNumRows,
+        getNumColumns: getNumColumns
+      });
+    };
+    var init$5 = function (spec) {
+      return spec.state(spec);
+    };
+
+    var KeyingState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        flatgrid: flatgrid$1,
+        init: init$5
+    });
+
+    var onDirection = function (isLtr, isRtl) {
+      return function (element) {
+        return getDirection(element) === 'rtl' ? isRtl : isLtr;
+      };
+    };
+    var getDirection = function (element) {
+      return get$8(element, 'direction') === 'rtl' ? 'rtl' : 'ltr';
+    };
+
+    var useH = function (movement) {
+      return function (component, simulatedEvent, config, state) {
+        var move = movement(component.element);
+        return use(move, component, simulatedEvent, config, state);
+      };
+    };
+    var west = function (moveLeft, moveRight) {
+      var movement = onDirection(moveLeft, moveRight);
+      return useH(movement);
+    };
+    var east = function (moveLeft, moveRight) {
+      var movement = onDirection(moveRight, moveLeft);
+      return useH(movement);
+    };
+    var useV = function (move) {
+      return function (component, simulatedEvent, config, state) {
+        return use(move, component, simulatedEvent, config, state);
+      };
+    };
+    var use = function (move, component, simulatedEvent, config, state) {
+      var outcome = config.focusManager.get(component).bind(function (focused) {
+        return move(component.element, focused, config, state);
+      });
+      return outcome.map(function (newFocus) {
+        config.focusManager.set(component, newFocus);
+        return true;
+      });
+    };
+    var north = useV;
+    var south = useV;
+    var move$1 = useV;
+
+    var isHidden = function (dom) {
+      return dom.offsetWidth <= 0 && dom.offsetHeight <= 0;
+    };
+    var isVisible = function (element) {
+      return !isHidden(element.dom);
+    };
+
+    var locate = function (candidates, predicate) {
+      return findIndex$1(candidates, predicate).map(function (index) {
+        return {
+          index: index,
+          candidates: candidates
+        };
+      });
+    };
+
+    var locateVisible = function (container, current, selector) {
+      var predicate = function (x) {
+        return eq(x, current);
+      };
+      var candidates = descendants(container, selector);
+      var visible = filter$2(candidates, isVisible);
+      return locate(visible, predicate);
+    };
+    var findIndex = function (elements, target) {
+      return findIndex$1(elements, function (elem) {
+        return eq(target, elem);
+      });
+    };
+
+    var withGrid = function (values, index, numCols, f) {
+      var oldRow = Math.floor(index / numCols);
+      var oldColumn = index % numCols;
+      return f(oldRow, oldColumn).bind(function (address) {
+        var newIndex = address.row * numCols + address.column;
+        return newIndex >= 0 && newIndex < values.length ? Optional.some(values[newIndex]) : Optional.none();
+      });
+    };
+    var cycleHorizontal$1 = function (values, index, numRows, numCols, delta) {
+      return withGrid(values, index, numCols, function (oldRow, oldColumn) {
+        var onLastRow = oldRow === numRows - 1;
+        var colsInRow = onLastRow ? values.length - oldRow * numCols : numCols;
+        var newColumn = cycleBy(oldColumn, delta, 0, colsInRow - 1);
+        return Optional.some({
+          row: oldRow,
+          column: newColumn
+        });
+      });
+    };
+    var cycleVertical$1 = function (values, index, numRows, numCols, delta) {
+      return withGrid(values, index, numCols, function (oldRow, oldColumn) {
+        var newRow = cycleBy(oldRow, delta, 0, numRows - 1);
+        var onLastRow = newRow === numRows - 1;
+        var colsInRow = onLastRow ? values.length - newRow * numCols : numCols;
+        var newCol = clamp(oldColumn, 0, colsInRow - 1);
+        return Optional.some({
+          row: newRow,
+          column: newCol
+        });
+      });
+    };
+    var cycleRight$1 = function (values, index, numRows, numCols) {
+      return cycleHorizontal$1(values, index, numRows, numCols, +1);
+    };
+    var cycleLeft$1 = function (values, index, numRows, numCols) {
+      return cycleHorizontal$1(values, index, numRows, numCols, -1);
+    };
+    var cycleUp$1 = function (values, index, numRows, numCols) {
+      return cycleVertical$1(values, index, numRows, numCols, -1);
+    };
+    var cycleDown$1 = function (values, index, numRows, numCols) {
+      return cycleVertical$1(values, index, numRows, numCols, +1);
+    };
+
+    var schema$e = [
+      required$1('selector'),
+      defaulted('execute', defaultExecute),
+      onKeyboardHandler('onEscape'),
+      defaulted('captureTab', false),
+      initSize()
+    ];
+    var focusIn$3 = function (component, gridConfig, _gridState) {
+      descendant(component.element, gridConfig.selector).each(function (first) {
+        gridConfig.focusManager.set(component, first);
+      });
+    };
+    var findCurrent$1 = function (component, gridConfig) {
+      return gridConfig.focusManager.get(component).bind(function (elem) {
+        return closest$1(elem, gridConfig.selector);
+      });
+    };
+    var execute$3 = function (component, simulatedEvent, gridConfig, _gridState) {
+      return findCurrent$1(component, gridConfig).bind(function (focused) {
+        return gridConfig.execute(component, simulatedEvent, focused);
+      });
+    };
+    var doMove$2 = function (cycle) {
+      return function (element, focused, gridConfig, gridState) {
+        return locateVisible(element, focused, gridConfig.selector).bind(function (identified) {
+          return cycle(identified.candidates, identified.index, gridState.getNumRows().getOr(gridConfig.initSize.numRows), gridState.getNumColumns().getOr(gridConfig.initSize.numColumns));
+        });
+      };
+    };
+    var handleTab = function (_component, _simulatedEvent, gridConfig) {
+      return gridConfig.captureTab ? Optional.some(true) : Optional.none();
+    };
+    var doEscape$1 = function (component, simulatedEvent, gridConfig) {
+      return gridConfig.onEscape(component, simulatedEvent);
+    };
+    var moveLeft$3 = doMove$2(cycleLeft$1);
+    var moveRight$3 = doMove$2(cycleRight$1);
+    var moveNorth$1 = doMove$2(cycleUp$1);
+    var moveSouth$1 = doMove$2(cycleDown$1);
+    var getKeydownRules$4 = constant$1([
+      rule(inSet(LEFT), west(moveLeft$3, moveRight$3)),
+      rule(inSet(RIGHT), east(moveLeft$3, moveRight$3)),
+      rule(inSet(UP), north(moveNorth$1)),
+      rule(inSet(DOWN), south(moveSouth$1)),
+      rule(and([
+        isShift,
+        inSet(TAB)
+      ]), handleTab),
+      rule(and([
+        isNotShift,
+        inSet(TAB)
+      ]), handleTab),
+      rule(inSet(ESCAPE), doEscape$1),
+      rule(inSet(SPACE.concat(ENTER)), execute$3)
+    ]);
+    var getKeyupRules$4 = constant$1([rule(inSet(SPACE), stopEventForFirefox)]);
+    var FlatgridType = typical(schema$e, flatgrid$1, getKeydownRules$4, getKeyupRules$4, function () {
+      return Optional.some(focusIn$3);
+    });
+
+    var horizontal = function (container, selector, current, delta) {
+      var isDisabledButton = function (candidate) {
+        return name$1(candidate) === 'button' && get$b(candidate, 'disabled') === 'disabled';
+      };
+      var tryCycle = function (initial, index, candidates) {
+        var newIndex = cycleBy(index, delta, 0, candidates.length - 1);
+        if (newIndex === initial) {
+          return Optional.none();
+        } else {
+          return isDisabledButton(candidates[newIndex]) ? tryCycle(initial, newIndex, candidates) : Optional.from(candidates[newIndex]);
+        }
+      };
+      return locateVisible(container, current, selector).bind(function (identified) {
+        var index = identified.index;
+        var candidates = identified.candidates;
+        return tryCycle(index, index, candidates);
+      });
+    };
+
+    var schema$d = [
+      required$1('selector'),
+      defaulted('getInitial', Optional.none),
+      defaulted('execute', defaultExecute),
+      onKeyboardHandler('onEscape'),
+      defaulted('executeOnMove', false),
+      defaulted('allowVertical', true)
+    ];
+    var findCurrent = function (component, flowConfig) {
+      return flowConfig.focusManager.get(component).bind(function (elem) {
+        return closest$1(elem, flowConfig.selector);
+      });
+    };
+    var execute$2 = function (component, simulatedEvent, flowConfig) {
+      return findCurrent(component, flowConfig).bind(function (focused) {
+        return flowConfig.execute(component, simulatedEvent, focused);
+      });
+    };
+    var focusIn$2 = function (component, flowConfig, _state) {
+      flowConfig.getInitial(component).orThunk(function () {
+        return descendant(component.element, flowConfig.selector);
+      }).each(function (first) {
+        flowConfig.focusManager.set(component, first);
+      });
+    };
+    var moveLeft$2 = function (element, focused, info) {
+      return horizontal(element, info.selector, focused, -1);
+    };
+    var moveRight$2 = function (element, focused, info) {
+      return horizontal(element, info.selector, focused, +1);
+    };
+    var doMove$1 = function (movement) {
+      return function (component, simulatedEvent, flowConfig, flowState) {
+        return movement(component, simulatedEvent, flowConfig, flowState).bind(function () {
+          return flowConfig.executeOnMove ? execute$2(component, simulatedEvent, flowConfig) : Optional.some(true);
+        });
+      };
+    };
+    var doEscape = function (component, simulatedEvent, flowConfig) {
+      return flowConfig.onEscape(component, simulatedEvent);
+    };
+    var getKeydownRules$3 = function (_component, _se, flowConfig, _flowState) {
+      var westMovers = LEFT.concat(flowConfig.allowVertical ? UP : []);
+      var eastMovers = RIGHT.concat(flowConfig.allowVertical ? DOWN : []);
+      return [
+        rule(inSet(westMovers), doMove$1(west(moveLeft$2, moveRight$2))),
+        rule(inSet(eastMovers), doMove$1(east(moveLeft$2, moveRight$2))),
+        rule(inSet(ENTER), execute$2),
+        rule(inSet(SPACE), execute$2),
+        rule(inSet(ESCAPE), doEscape)
+      ];
+    };
+    var getKeyupRules$3 = constant$1([rule(inSet(SPACE), stopEventForFirefox)]);
+    var FlowType = typical(schema$d, NoState.init, getKeydownRules$3, getKeyupRules$3, function () {
+      return Optional.some(focusIn$2);
+    });
+
+    var toCell = function (matrix, rowIndex, columnIndex) {
+      return Optional.from(matrix[rowIndex]).bind(function (row) {
+        return Optional.from(row[columnIndex]).map(function (cell) {
+          return {
+            rowIndex: rowIndex,
+            columnIndex: columnIndex,
+            cell: cell
+          };
+        });
+      });
+    };
+    var cycleHorizontal = function (matrix, rowIndex, startCol, deltaCol) {
+      var row = matrix[rowIndex];
+      var colsInRow = row.length;
+      var newColIndex = cycleBy(startCol, deltaCol, 0, colsInRow - 1);
+      return toCell(matrix, rowIndex, newColIndex);
+    };
+    var cycleVertical = function (matrix, colIndex, startRow, deltaRow) {
+      var nextRowIndex = cycleBy(startRow, deltaRow, 0, matrix.length - 1);
+      var colsInNextRow = matrix[nextRowIndex].length;
+      var nextColIndex = clamp(colIndex, 0, colsInNextRow - 1);
+      return toCell(matrix, nextRowIndex, nextColIndex);
+    };
+    var moveHorizontal = function (matrix, rowIndex, startCol, deltaCol) {
+      var row = matrix[rowIndex];
+      var colsInRow = row.length;
+      var newColIndex = clamp(startCol + deltaCol, 0, colsInRow - 1);
+      return toCell(matrix, rowIndex, newColIndex);
+    };
+    var moveVertical = function (matrix, colIndex, startRow, deltaRow) {
+      var nextRowIndex = clamp(startRow + deltaRow, 0, matrix.length - 1);
+      var colsInNextRow = matrix[nextRowIndex].length;
+      var nextColIndex = clamp(colIndex, 0, colsInNextRow - 1);
+      return toCell(matrix, nextRowIndex, nextColIndex);
+    };
+    var cycleRight = function (matrix, startRow, startCol) {
+      return cycleHorizontal(matrix, startRow, startCol, +1);
+    };
+    var cycleLeft = function (matrix, startRow, startCol) {
+      return cycleHorizontal(matrix, startRow, startCol, -1);
+    };
+    var cycleUp = function (matrix, startRow, startCol) {
+      return cycleVertical(matrix, startCol, startRow, -1);
+    };
+    var cycleDown = function (matrix, startRow, startCol) {
+      return cycleVertical(matrix, startCol, startRow, +1);
+    };
+    var moveLeft$1 = function (matrix, startRow, startCol) {
+      return moveHorizontal(matrix, startRow, startCol, -1);
+    };
+    var moveRight$1 = function (matrix, startRow, startCol) {
+      return moveHorizontal(matrix, startRow, startCol, +1);
+    };
+    var moveUp$1 = function (matrix, startRow, startCol) {
+      return moveVertical(matrix, startCol, startRow, -1);
+    };
+    var moveDown$1 = function (matrix, startRow, startCol) {
+      return moveVertical(matrix, startCol, startRow, +1);
+    };
+
+    var schema$c = [
+      requiredObjOf('selectors', [
+        required$1('row'),
+        required$1('cell')
+      ]),
+      defaulted('cycles', true),
+      defaulted('previousSelector', Optional.none),
+      defaulted('execute', defaultExecute)
+    ];
+    var focusIn$1 = function (component, matrixConfig, _state) {
+      var focused = matrixConfig.previousSelector(component).orThunk(function () {
+        var selectors = matrixConfig.selectors;
+        return descendant(component.element, selectors.cell);
+      });
+      focused.each(function (cell) {
+        matrixConfig.focusManager.set(component, cell);
+      });
+    };
+    var execute$1 = function (component, simulatedEvent, matrixConfig) {
+      return search(component.element).bind(function (focused) {
+        return matrixConfig.execute(component, simulatedEvent, focused);
+      });
+    };
+    var toMatrix = function (rows, matrixConfig) {
+      return map$2(rows, function (row) {
+        return descendants(row, matrixConfig.selectors.cell);
+      });
+    };
+    var doMove = function (ifCycle, ifMove) {
+      return function (element, focused, matrixConfig) {
+        var move = matrixConfig.cycles ? ifCycle : ifMove;
+        return closest$1(focused, matrixConfig.selectors.row).bind(function (inRow) {
+          var cellsInRow = descendants(inRow, matrixConfig.selectors.cell);
+          return findIndex(cellsInRow, focused).bind(function (colIndex) {
+            var allRows = descendants(element, matrixConfig.selectors.row);
+            return findIndex(allRows, inRow).bind(function (rowIndex) {
+              var matrix = toMatrix(allRows, matrixConfig);
+              return move(matrix, rowIndex, colIndex).map(function (next) {
+                return next.cell;
+              });
+            });
+          });
+        });
+      };
+    };
+    var moveLeft = doMove(cycleLeft, moveLeft$1);
+    var moveRight = doMove(cycleRight, moveRight$1);
+    var moveNorth = doMove(cycleUp, moveUp$1);
+    var moveSouth = doMove(cycleDown, moveDown$1);
+    var getKeydownRules$2 = constant$1([
+      rule(inSet(LEFT), west(moveLeft, moveRight)),
+      rule(inSet(RIGHT), east(moveLeft, moveRight)),
+      rule(inSet(UP), north(moveNorth)),
+      rule(inSet(DOWN), south(moveSouth)),
+      rule(inSet(SPACE.concat(ENTER)), execute$1)
+    ]);
+    var getKeyupRules$2 = constant$1([rule(inSet(SPACE), stopEventForFirefox)]);
+    var MatrixType = typical(schema$c, NoState.init, getKeydownRules$2, getKeyupRules$2, function () {
+      return Optional.some(focusIn$1);
+    });
+
+    var schema$b = [
+      required$1('selector'),
+      defaulted('execute', defaultExecute),
+      defaulted('moveOnTab', false)
+    ];
+    var execute = function (component, simulatedEvent, menuConfig) {
+      return menuConfig.focusManager.get(component).bind(function (focused) {
+        return menuConfig.execute(component, simulatedEvent, focused);
+      });
+    };
+    var focusIn = function (component, menuConfig, _state) {
+      descendant(component.element, menuConfig.selector).each(function (first) {
+        menuConfig.focusManager.set(component, first);
+      });
+    };
+    var moveUp = function (element, focused, info) {
+      return horizontal(element, info.selector, focused, -1);
+    };
+    var moveDown = function (element, focused, info) {
+      return horizontal(element, info.selector, focused, +1);
+    };
+    var fireShiftTab = function (component, simulatedEvent, menuConfig, menuState) {
+      return menuConfig.moveOnTab ? move$1(moveUp)(component, simulatedEvent, menuConfig, menuState) : Optional.none();
+    };
+    var fireTab = function (component, simulatedEvent, menuConfig, menuState) {
+      return menuConfig.moveOnTab ? move$1(moveDown)(component, simulatedEvent, menuConfig, menuState) : Optional.none();
+    };
+    var getKeydownRules$1 = constant$1([
+      rule(inSet(UP), move$1(moveUp)),
+      rule(inSet(DOWN), move$1(moveDown)),
+      rule(and([
+        isShift,
+        inSet(TAB)
+      ]), fireShiftTab),
+      rule(and([
+        isNotShift,
+        inSet(TAB)
+      ]), fireTab),
+      rule(inSet(ENTER), execute),
+      rule(inSet(SPACE), execute)
+    ]);
+    var getKeyupRules$1 = constant$1([rule(inSet(SPACE), stopEventForFirefox)]);
+    var MenuType = typical(schema$b, NoState.init, getKeydownRules$1, getKeyupRules$1, function () {
+      return Optional.some(focusIn);
+    });
+
+    var schema$a = [
+      onKeyboardHandler('onSpace'),
+      onKeyboardHandler('onEnter'),
+      onKeyboardHandler('onShiftEnter'),
+      onKeyboardHandler('onLeft'),
+      onKeyboardHandler('onRight'),
+      onKeyboardHandler('onTab'),
+      onKeyboardHandler('onShiftTab'),
+      onKeyboardHandler('onUp'),
+      onKeyboardHandler('onDown'),
+      onKeyboardHandler('onEscape'),
+      defaulted('stopSpaceKeyup', false),
+      option('focusIn')
+    ];
+    var getKeydownRules = function (component, simulatedEvent, specialInfo) {
+      return [
+        rule(inSet(SPACE), specialInfo.onSpace),
+        rule(and([
+          isNotShift,
+          inSet(ENTER)
+        ]), specialInfo.onEnter),
+        rule(and([
+          isShift,
+          inSet(ENTER)
+        ]), specialInfo.onShiftEnter),
+        rule(and([
+          isShift,
+          inSet(TAB)
+        ]), specialInfo.onShiftTab),
+        rule(and([
+          isNotShift,
+          inSet(TAB)
+        ]), specialInfo.onTab),
+        rule(inSet(UP), specialInfo.onUp),
+        rule(inSet(DOWN), specialInfo.onDown),
+        rule(inSet(LEFT), specialInfo.onLeft),
+        rule(inSet(RIGHT), specialInfo.onRight),
+        rule(inSet(SPACE), specialInfo.onSpace),
+        rule(inSet(ESCAPE), specialInfo.onEscape)
+      ];
+    };
+    var getKeyupRules = function (component, simulatedEvent, specialInfo) {
+      return specialInfo.stopSpaceKeyup ? [rule(inSet(SPACE), stopEventForFirefox)] : [];
+    };
+    var SpecialType = typical(schema$a, NoState.init, getKeydownRules, getKeyupRules, function (specialInfo) {
+      return specialInfo.focusIn;
+    });
+
+    var acyclic = AcyclicType.schema();
+    var cyclic = CyclicType.schema();
+    var flow = FlowType.schema();
+    var flatgrid = FlatgridType.schema();
+    var matrix = MatrixType.schema();
+    var execution = ExecutionType.schema();
+    var menu = MenuType.schema();
+    var special = SpecialType.schema();
+
+    var KeyboardBranches = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        acyclic: acyclic,
+        cyclic: cyclic,
+        flow: flow,
+        flatgrid: flatgrid,
+        matrix: matrix,
+        execution: execution,
+        menu: menu,
+        special: special
+    });
+
+    var isFlatgridState = function (keyState) {
+      return hasNonNullableKey(keyState, 'setGridSize');
+    };
+    var Keying = createModes({
+      branchKey: 'mode',
+      branches: KeyboardBranches,
+      name: 'keying',
+      active: {
+        events: function (keyingConfig, keyingState) {
+          var handler = keyingConfig.handler;
+          return handler.toEvents(keyingConfig, keyingState);
+        }
+      },
+      apis: {
+        focusIn: function (component, keyConfig, keyState) {
+          keyConfig.sendFocusIn(keyConfig).fold(function () {
+            component.getSystem().triggerFocus(component.element, component.element);
+          }, function (sendFocusIn) {
+            sendFocusIn(component, keyConfig, keyState);
+          });
+        },
+        setGridSize: function (component, keyConfig, keyState, numRows, numColumns) {
+          if (!isFlatgridState(keyState)) {
+            console.error('Layout does not support setGridSize');
+          } else {
+            keyState.setGridSize(numRows, numColumns);
+          }
+        }
+      },
+      state: KeyingState
+    });
+
+    var field$1 = function (name, forbidden) {
+      return defaultedObjOf(name, {}, map$2(forbidden, function (f) {
+        return forbid(f.name(), 'Cannot configure ' + f.name() + ' for ' + name);
+      }).concat([customField('dump', identity)]));
+    };
+    var get$6 = function (data) {
+      return data.dump;
+    };
+    var augment = function (data, original) {
+      return __assign(__assign({}, derive$2(original)), data.dump);
+    };
+    var SketchBehaviours = {
+      field: field$1,
+      augment: augment,
+      get: get$6
+    };
+
+    var _placeholder = 'placeholder';
+    var adt$5 = Adt.generate([
+      {
+        single: [
+          'required',
+          'valueThunk'
+        ]
+      },
+      {
+        multiple: [
+          'required',
+          'valueThunks'
+        ]
+      }
+    ]);
+    var isSubstituted = function (spec) {
+      return has$2(spec, 'uiType');
+    };
+    var subPlaceholder = function (owner, detail, compSpec, placeholders) {
+      if (owner.exists(function (o) {
+          return o !== compSpec.owner;
+        })) {
+        return adt$5.single(true, constant$1(compSpec));
+      }
+      return get$c(placeholders, compSpec.name).fold(function () {
+        throw new Error('Unknown placeholder component: ' + compSpec.name + '\nKnown: [' + keys(placeholders) + ']\nNamespace: ' + owner.getOr('none') + '\nSpec: ' + JSON.stringify(compSpec, null, 2));
+      }, function (newSpec) {
+        return newSpec.replace();
+      });
+    };
+    var scan = function (owner, detail, compSpec, placeholders) {
+      if (isSubstituted(compSpec) && compSpec.uiType === _placeholder) {
+        return subPlaceholder(owner, detail, compSpec, placeholders);
+      } else {
+        return adt$5.single(false, constant$1(compSpec));
+      }
+    };
+    var substitute = function (owner, detail, compSpec, placeholders) {
+      var base = scan(owner, detail, compSpec, placeholders);
+      return base.fold(function (req, valueThunk) {
+        var value = isSubstituted(compSpec) ? valueThunk(detail, compSpec.config, compSpec.validated) : valueThunk(detail);
+        var childSpecs = get$c(value, 'components').getOr([]);
+        var substituted = bind$3(childSpecs, function (c) {
+          return substitute(owner, detail, c, placeholders);
+        });
+        return [__assign(__assign({}, value), { components: substituted })];
+      }, function (req, valuesThunk) {
+        if (isSubstituted(compSpec)) {
+          var values = valuesThunk(detail, compSpec.config, compSpec.validated);
+          var preprocessor = compSpec.validated.preprocess.getOr(identity);
+          return preprocessor(values);
+        } else {
+          return valuesThunk(detail);
+        }
+      });
+    };
+    var substituteAll = function (owner, detail, components, placeholders) {
+      return bind$3(components, function (c) {
+        return substitute(owner, detail, c, placeholders);
+      });
+    };
+    var oneReplace = function (label, replacements) {
+      var called = false;
+      var used = function () {
+        return called;
+      };
+      var replace = function () {
+        if (called) {
+          throw new Error('Trying to use the same placeholder more than once: ' + label);
+        }
+        called = true;
+        return replacements;
+      };
+      var required = function () {
+        return replacements.fold(function (req, _) {
+          return req;
+        }, function (req, _) {
+          return req;
+        });
+      };
+      return {
+        name: constant$1(label),
+        required: required,
+        used: used,
+        replace: replace
+      };
+    };
+    var substitutePlaces = function (owner, detail, components, placeholders) {
+      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()) {
+          throw new Error('Placeholder: ' + p.name() + ' was not found in components list\nNamespace: ' + owner.getOr('none') + '\nComponents: ' + JSON.stringify(detail.components, null, 2));
+        }
+      });
+      return outcome;
+    };
+    var single$2 = adt$5.single;
+    var multiple = adt$5.multiple;
+    var placeholder = constant$1(_placeholder);
+
+    var unique = 0;
+    var generate$4 = function (prefix) {
+      var date = new Date();
+      var time = date.getTime();
+      var random = Math.floor(Math.random() * 1000000000);
+      unique++;
+      return prefix + '_' + random + unique + String(time);
+    };
+
+    var adt$4 = Adt.generate([
+      { required: ['data'] },
+      { external: ['data'] },
+      { optional: ['data'] },
+      { group: ['data'] }
+    ]);
+    var fFactory = defaulted('factory', { sketch: identity });
+    var fSchema = defaulted('schema', []);
+    var fName = required$1('name');
+    var fPname = field$2('pname', 'pname', defaultedThunk(function (typeSpec) {
+      return '<alloy.' + generate$4(typeSpec.name) + '>';
+    }), anyValue());
+    var fGroupSchema = customField('schema', function () {
+      return [option('preprocess')];
+    });
+    var fDefaults = defaulted('defaults', constant$1({}));
+    var fOverrides = defaulted('overrides', constant$1({}));
+    var requiredSpec = objOf([
+      fFactory,
+      fSchema,
+      fName,
+      fPname,
+      fDefaults,
+      fOverrides
+    ]);
+    var externalSpec = objOf([
+      fFactory,
+      fSchema,
+      fName,
+      fDefaults,
+      fOverrides
+    ]);
+    var optionalSpec = objOf([
+      fFactory,
+      fSchema,
+      fName,
+      fPname,
+      fDefaults,
+      fOverrides
+    ]);
+    var groupSpec = objOf([
+      fFactory,
+      fGroupSchema,
+      fName,
+      required$1('unit'),
+      fPname,
+      fDefaults,
+      fOverrides
+    ]);
+    var asNamedPart = function (part) {
+      return part.fold(Optional.some, Optional.none, Optional.some, Optional.some);
+    };
+    var name = function (part) {
+      var get = function (data) {
+        return data.name;
+      };
+      return part.fold(get, get, get, get);
+    };
+    var convert$1 = function (adtConstructor, partSchema) {
+      return function (spec) {
+        var data = asRawOrDie$1('Converting part type', partSchema, spec);
+        return adtConstructor(data);
+      };
+    };
+    var required = convert$1(adt$4.required, requiredSpec);
+    convert$1(adt$4.external, externalSpec);
+    var optional = convert$1(adt$4.optional, optionalSpec);
+    var group = convert$1(adt$4.group, groupSpec);
+    var original = constant$1('entirety');
+
+    var combine$2 = function (detail, data, partSpec, partValidated) {
+      return deepMerge(data.defaults(detail, partSpec, partValidated), partSpec, { uid: detail.partUids[data.name] }, data.overrides(detail, partSpec, partValidated));
+    };
+    var subs = function (owner, detail, parts) {
+      var internals = {};
+      var externals = {};
+      each$1(parts, function (part) {
+        part.fold(function (data) {
+          internals[data.pname] = single$2(true, function (detail, partSpec, partValidated) {
+            return data.factory.sketch(combine$2(detail, data, partSpec, partValidated));
+          });
+        }, function (data) {
+          var partSpec = detail.parts[data.name];
+          externals[data.name] = constant$1(data.factory.sketch(combine$2(detail, data, partSpec[original()]), partSpec));
+        }, function (data) {
+          internals[data.pname] = single$2(false, function (detail, partSpec, partValidated) {
+            return data.factory.sketch(combine$2(detail, data, partSpec, partValidated));
+          });
+        }, function (data) {
+          internals[data.pname] = multiple(true, function (detail, _partSpec, _partValidated) {
+            var units = detail[data.name];
+            return map$2(units, function (u) {
+              return data.factory.sketch(deepMerge(data.defaults(detail, u, _partValidated), u, data.overrides(detail, u)));
+            });
+          });
+        });
+      });
+      return {
+        internals: constant$1(internals),
+        externals: constant$1(externals)
+      };
+    };
+
+    var generate$3 = function (owner, parts) {
+      var r = {};
+      each$1(parts, function (part) {
+        asNamedPart(part).each(function (np) {
+          var g = doGenerateOne(owner, np.pname);
+          r[np.name] = function (config) {
+            var validated = asRawOrDie$1('Part: ' + np.name + ' in ' + owner, objOf(np.schema), config);
+            return __assign(__assign({}, g), {
+              config: config,
+              validated: validated
+            });
+          };
+        });
+      });
+      return r;
+    };
+    var doGenerateOne = function (owner, pname) {
+      return {
+        uiType: placeholder(),
+        owner: owner,
+        name: pname
+      };
+    };
+    var generateOne = function (owner, pname, config) {
+      return {
+        uiType: placeholder(),
+        owner: owner,
+        name: pname,
+        config: config,
+        validated: {}
+      };
+    };
+    var schemas = function (parts) {
+      return bind$3(parts, function (part) {
+        return part.fold(Optional.none, Optional.some, Optional.none, Optional.none).map(function (data) {
+          return requiredObjOf(data.name, data.schema.concat([snapshot(original())]));
+        }).toArray();
+      });
+    };
+    var names = function (parts) {
+      return map$2(parts, name);
+    };
+    var substitutes = function (owner, detail, parts) {
+      return subs(owner, detail, parts);
+    };
+    var components = function (owner, detail, internals) {
+      return substitutePlaces(Optional.some(owner), detail, detail.components, internals);
+    };
+    var getPart = function (component, detail, partKey) {
+      var uid = detail.partUids[partKey];
+      return component.getSystem().getByUid(uid).toOptional();
+    };
+    var getPartOrDie = function (component, detail, partKey) {
+      return getPart(component, detail, partKey).getOrDie('Could not find part: ' + partKey);
+    };
+    var getAllParts = function (component, detail) {
+      var system = component.getSystem();
+      return map$1(detail.partUids, function (pUid, _k) {
+        return constant$1(system.getByUid(pUid));
+      });
+    };
+    var defaultUids = function (baseUid, partTypes) {
+      var partNames = names(partTypes);
+      return wrapAll(map$2(partNames, function (pn) {
+        return {
+          key: pn,
+          value: baseUid + '-' + pn
+        };
+      }));
+    };
+    var defaultUidsSchema = function (partTypes) {
+      return field$2('partUids', 'partUids', mergeWithThunk(function (spec) {
+        return defaultUids(spec.uid, partTypes);
+      }), anyValue());
+    };
+
+    var premadeTag = generate$4('alloy-premade');
+    var premade$1 = function (comp) {
+      return wrap(premadeTag, comp);
+    };
+    var getPremade = function (spec) {
+      return get$c(spec, premadeTag);
+    };
+    var makeApi = function (f) {
+      return markAsSketchApi(function (component) {
+        var rest = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+          rest[_i - 1] = arguments[_i];
+        }
+        return f.apply(void 0, __spreadArray([
+          component.getApis(),
+          component
+        ], rest, false));
+      }, f);
+    };
+
+    var prefix$1 = constant$1('alloy-id-');
+    var idAttr$1 = constant$1('data-alloy-id');
+
+    var prefix = prefix$1();
+    var idAttr = idAttr$1();
+    var write = function (label, elem) {
+      var id = generate$4(prefix + label);
+      writeOnly(elem, id);
+      return id;
+    };
+    var writeOnly = function (elem, uid) {
+      Object.defineProperty(elem.dom, idAttr, {
+        value: uid,
+        writable: true
+      });
+    };
+    var read = function (elem) {
+      var id = isElement(elem) ? elem.dom[idAttr] : null;
+      return Optional.from(id);
+    };
+    var generate$2 = function (prefix) {
+      return generate$4(prefix);
+    };
+
+    var base = function (partSchemas, partUidsSchemas) {
+      var ps = partSchemas.length > 0 ? [requiredObjOf('parts', partSchemas)] : [];
+      return ps.concat([
+        required$1('uid'),
+        defaulted('dom', {}),
+        defaulted('components', []),
+        snapshot('originalSpec'),
+        defaulted('debug.sketcher', {})
+      ]).concat(partUidsSchemas);
+    };
+    var asRawOrDie = function (label, schema, spec, partSchemas, partUidsSchemas) {
+      var baseS = base(partSchemas, partUidsSchemas);
+      return asRawOrDie$1(label + ' [SpecSchema]', objOfOnly(baseS.concat(schema)), spec);
+    };
+
+    var single$1 = function (owner, schema, factory, spec) {
+      var specWithUid = supplyUid(spec);
+      var detail = asRawOrDie(owner, schema, specWithUid, [], []);
+      return factory(detail, specWithUid);
+    };
+    var composite$1 = function (owner, schema, partTypes, factory, spec) {
+      var specWithUid = supplyUid(spec);
+      var partSchemas = schemas(partTypes);
+      var partUidsSchema = defaultUidsSchema(partTypes);
+      var detail = asRawOrDie(owner, schema, specWithUid, partSchemas, [partUidsSchema]);
+      var subs = substitutes(owner, detail, partTypes);
+      var components$1 = components(owner, detail, subs.internals());
+      return factory(detail, components$1, specWithUid, subs.externals());
+    };
+    var hasUid = function (spec) {
+      return has$2(spec, 'uid');
+    };
+    var supplyUid = function (spec) {
+      return hasUid(spec) ? spec : __assign(__assign({}, spec), { uid: generate$2('uid') });
+    };
+
+    var isSketchSpec$1 = function (spec) {
+      return spec.uid !== undefined;
+    };
+    var singleSchema = objOfOnly([
+      required$1('name'),
+      required$1('factory'),
+      required$1('configFields'),
+      defaulted('apis', {}),
+      defaulted('extraApis', {})
+    ]);
+    var compositeSchema = objOfOnly([
+      required$1('name'),
+      required$1('factory'),
+      required$1('configFields'),
+      required$1('partFields'),
+      defaulted('apis', {}),
+      defaulted('extraApis', {})
+    ]);
+    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$1(config.apis, makeApi);
+      var extraApis = map$1(config.extraApis, function (f, k) {
+        return markAsExtraApi(f, k);
+      });
+      return __assign(__assign({
+        name: config.name,
+        configFields: config.configFields,
+        sketch: sketch
+      }, apis), extraApis);
+    };
+    var composite = function (rawConfig) {
+      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$1(config.apis, makeApi);
+      var extraApis = map$1(config.extraApis, function (f, k) {
+        return markAsExtraApi(f, k);
+      });
+      return __assign(__assign({
+        name: config.name,
+        partFields: config.partFields,
+        configFields: config.configFields,
+        sketch: sketch,
+        parts: parts
+      }, apis), extraApis);
+    };
+
+    var factory$5 = function (detail) {
+      var events = events$8(detail.action);
+      var tag = detail.dom.tag;
+      var lookupAttr = function (attr) {
+        return get$c(detail.dom, 'attributes').bind(function (attrs) {
+          return get$c(attrs, attr);
+        });
+      };
+      var getModAttributes = function () {
+        if (tag === 'button') {
+          var type = lookupAttr('type').getOr('button');
+          var roleAttrs = lookupAttr('role').map(function (role) {
+            return { role: role };
+          }).getOr({});
+          return __assign({ type: type }, roleAttrs);
+        } else {
+          var role = lookupAttr('role').getOr('button');
+          return { role: role };
+        }
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: detail.components,
+        events: events,
+        behaviours: SketchBehaviours.augment(detail.buttonBehaviours, [
+          Focusing.config({}),
+          Keying.config({
+            mode: 'execution',
+            useSpace: true,
+            useEnter: true
+          })
+        ]),
+        domModification: { attributes: getModAttributes() },
+        eventOrder: detail.eventOrder
+      };
+    };
+    var Button = single({
+      name: 'Button',
+      factory: factory$5,
+      configFields: [
+        defaulted('uid', undefined),
+        required$1('dom'),
+        defaulted('components', []),
+        SketchBehaviours.field('buttonBehaviours', [
+          Focusing,
+          Keying
+        ]),
+        option('action'),
+        option('role'),
+        defaulted('eventOrder', {})
+      ]
+    });
+
+    var exhibit$3 = function () {
+      return nu$3({
+        styles: {
+          '-webkit-user-select': 'none',
+          'user-select': 'none',
+          '-ms-user-select': 'none',
+          '-moz-user-select': '-moz-none'
+        },
+        attributes: { unselectable: 'on' }
+      });
+    };
+    var events$6 = function () {
+      return derive$3([abort(selectstart(), always)]);
+    };
+
+    var ActiveUnselecting = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$6,
+        exhibit: exhibit$3
+    });
+
+    var Unselecting = create$5({
+      fields: [],
+      name: 'unselecting',
+      active: ActiveUnselecting
+    });
+
+    var getAttrs$1 = function (elem) {
+      var attributes = elem.dom.attributes !== undefined ? elem.dom.attributes : [];
+      return foldl(attributes, function (b, attr) {
+        var _a;
+        if (attr.name === 'class') {
+          return b;
+        } else {
+          return __assign(__assign({}, b), (_a = {}, _a[attr.name] = attr.value, _a));
+        }
+      }, {});
+    };
+    var getClasses = function (elem) {
+      return Array.prototype.slice.call(elem.dom.classList, 0);
+    };
+    var fromHtml = function (html) {
+      var elem = SugarElement.fromHtml(html);
+      var children$1 = children(elem);
+      var attrs = getAttrs$1(elem);
+      var classes = getClasses(elem);
+      var contents = children$1.length === 0 ? {} : { innerHtml: get$9(elem) };
+      return __assign({
+        tag: name$1(elem),
+        classes: classes,
+        attributes: attrs
+      }, contents);
+    };
+
+    var dom$1 = function (rawHtml) {
+      var html = supplant(rawHtml, { prefix: prefix$2 });
+      return fromHtml(html);
+    };
+    var spec = function (rawHtml) {
+      return { dom: dom$1(rawHtml) };
+    };
+
+    var forToolbarCommand = function (editor, command) {
+      return forToolbar(command, function () {
+        editor.execCommand(command);
+      }, {}, editor);
+    };
+    var getToggleBehaviours = function (command) {
+      return derive$2([
+        Toggling.config({
+          toggleClass: resolve('toolbar-button-selected'),
+          toggleOnExecute: false,
+          aria: { mode: 'pressed' }
+        }),
+        format(command, function (button, status) {
+          var toggle = status ? Toggling.on : Toggling.off;
+          toggle(button);
+        })
+      ]);
+    };
+    var forToolbarStateCommand = function (editor, command) {
+      var extraBehaviours = getToggleBehaviours(command);
+      return forToolbar(command, function () {
+        editor.execCommand(command);
+      }, extraBehaviours, editor);
+    };
+    var forToolbarStateAction = function (editor, clazz, command, action) {
+      var extraBehaviours = getToggleBehaviours(command);
+      return forToolbar(clazz, action, extraBehaviours, editor);
+    };
+    var getToolbarIconButton = function (clazz, editor) {
+      var icons = editor.ui.registry.getAll().icons;
+      var optOxideIcon = Optional.from(icons[clazz]);
+      return optOxideIcon.fold(function () {
+        return dom$1('<span class="${prefix}-toolbar-button ${prefix}-toolbar-group-item ${prefix}-icon-' + clazz + ' ${prefix}-icon"></span>');
+      }, function (icon) {
+        return dom$1('<span class="${prefix}-toolbar-button ${prefix}-toolbar-group-item">' + icon + '</span>');
+      });
+    };
+    var forToolbar = function (clazz, action, extraBehaviours, editor) {
+      return Button.sketch({
+        dom: getToolbarIconButton(clazz, editor),
+        action: action,
+        buttonBehaviours: deepMerge(derive$2([Unselecting.config({})]), extraBehaviours)
+      });
+    };
+
+    var labelPart = optional({
+      schema: [required$1('dom')],
+      name: 'label'
+    });
+    var edgePart = function (name) {
+      return optional({
+        name: '' + name + '-edge',
+        overrides: function (detail) {
+          var action = detail.model.manager.edgeActions[name];
+          return action.fold(function () {
+            return {};
+          }, function (a) {
+            return {
+              events: derive$3([
+                runActionExtra(touchstart(), function (comp, se, d) {
+                  return a(comp, d);
+                }, [detail]),
+                runActionExtra(mousedown(), function (comp, se, d) {
+                  return a(comp, d);
+                }, [detail]),
+                runActionExtra(mousemove(), function (comp, se, det) {
+                  if (det.mouseIsDown.get()) {
+                    a(comp, det);
+                  }
+                }, [detail])
+              ])
+            };
+          });
+        }
+      });
+    };
+    var tlEdgePart = edgePart('top-left');
+    var tedgePart = edgePart('top');
+    var trEdgePart = edgePart('top-right');
+    var redgePart = edgePart('right');
+    var brEdgePart = edgePart('bottom-right');
+    var bedgePart = edgePart('bottom');
+    var blEdgePart = edgePart('bottom-left');
+    var ledgePart = edgePart('left');
+    var thumbPart = required({
+      name: 'thumb',
+      defaults: constant$1({ dom: { styles: { position: 'absolute' } } }),
+      overrides: function (detail) {
+        return {
+          events: derive$3([
+            redirectToPart(touchstart(), detail, 'spectrum'),
+            redirectToPart(touchmove(), detail, 'spectrum'),
+            redirectToPart(touchend(), detail, 'spectrum'),
+            redirectToPart(mousedown(), detail, 'spectrum'),
+            redirectToPart(mousemove(), detail, 'spectrum'),
+            redirectToPart(mouseup(), detail, 'spectrum')
+          ])
+        };
+      }
+    });
+    var spectrumPart = required({
+      schema: [customField('mouseIsDown', function () {
+          return Cell(false);
+        })],
+      name: 'spectrum',
+      overrides: function (detail) {
+        var modelDetail = detail.model;
+        var model = modelDetail.manager;
+        var setValueFrom = function (component, simulatedEvent) {
+          return model.getValueFromEvent(simulatedEvent).map(function (value) {
+            return model.setValueFrom(component, detail, value);
+          });
+        };
+        return {
+          behaviours: derive$2([
+            Keying.config({
+              mode: 'special',
+              onLeft: function (spectrum) {
+                return model.onLeft(spectrum, detail);
+              },
+              onRight: function (spectrum) {
+                return model.onRight(spectrum, detail);
+              },
+              onUp: function (spectrum) {
+                return model.onUp(spectrum, detail);
+              },
+              onDown: function (spectrum) {
+                return model.onDown(spectrum, detail);
+              }
+            }),
+            Focusing.config({})
+          ]),
+          events: derive$3([
+            run(touchstart(), setValueFrom),
+            run(touchmove(), setValueFrom),
+            run(mousedown(), setValueFrom),
+            run(mousemove(), function (spectrum, se) {
+              if (detail.mouseIsDown.get()) {
+                setValueFrom(spectrum, se);
+              }
+            })
+          ])
+        };
+      }
+    });
+    var SliderParts = [
+      labelPart,
+      ledgePart,
+      redgePart,
+      tedgePart,
+      bedgePart,
+      tlEdgePart,
+      trEdgePart,
+      blEdgePart,
+      brEdgePart,
+      thumbPart,
+      spectrumPart
+    ];
+
+    var onLoad$4 = function (component, repConfig, repState) {
+      repConfig.store.manager.onLoad(component, repConfig, repState);
+    };
+    var onUnload$2 = function (component, repConfig, repState) {
+      repConfig.store.manager.onUnload(component, repConfig, repState);
+    };
+    var setValue$3 = function (component, repConfig, repState, data) {
+      repConfig.store.manager.setValue(component, repConfig, repState, data);
+    };
+    var getValue$4 = function (component, repConfig, repState) {
+      return repConfig.store.manager.getValue(component, repConfig, repState);
+    };
+    var getState$1 = function (component, repConfig, repState) {
+      return repState;
+    };
+
+    var RepresentApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        onLoad: onLoad$4,
+        onUnload: onUnload$2,
+        setValue: setValue$3,
+        getValue: getValue$4,
+        getState: getState$1
+    });
+
+    var events$5 = function (repConfig, repState) {
+      var es = repConfig.resetOnDom ? [
+        runOnAttached(function (comp, _se) {
+          onLoad$4(comp, repConfig, repState);
+        }),
+        runOnDetached(function (comp, _se) {
+          onUnload$2(comp, repConfig, repState);
+        })
+      ] : [loadEvent(repConfig, repState, onLoad$4)];
+      return derive$3(es);
+    };
+
+    var ActiveRepresenting = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$5
+    });
+
+    var memory = function () {
+      var data = Cell(null);
+      var readState = function () {
+        return {
+          mode: 'memory',
+          value: data.get()
+        };
+      };
+      var isNotSet = function () {
+        return data.get() === null;
+      };
+      var clear = function () {
+        data.set(null);
+      };
+      return nu$2({
+        set: data.set,
+        get: data.get,
+        isNotSet: isNotSet,
+        clear: clear,
+        readState: readState
+      });
+    };
+    var manual = function () {
+      var readState = noop;
+      return nu$2({ readState: readState });
+    };
+    var dataset = function () {
+      var dataByValue = Cell({});
+      var dataByText = Cell({});
+      var readState = function () {
+        return {
+          mode: 'dataset',
+          dataByValue: dataByValue.get(),
+          dataByText: dataByText.get()
+        };
+      };
+      var clear = function () {
+        dataByValue.set({});
+        dataByText.set({});
+      };
+      var lookup = function (itemString) {
+        return get$c(dataByValue.get(), itemString).orThunk(function () {
+          return get$c(dataByText.get(), itemString);
+        });
+      };
+      var update = function (items) {
+        var currentDataByValue = dataByValue.get();
+        var currentDataByText = dataByText.get();
+        var newDataByValue = {};
+        var newDataByText = {};
+        each$1(items, function (item) {
+          newDataByValue[item.value] = item;
+          get$c(item, 'meta').each(function (meta) {
+            get$c(meta, 'text').each(function (text) {
+              newDataByText[text] = item;
+            });
+          });
+        });
+        dataByValue.set(__assign(__assign({}, currentDataByValue), newDataByValue));
+        dataByText.set(__assign(__assign({}, currentDataByText), newDataByText));
+      };
+      return nu$2({
+        readState: readState,
+        lookup: lookup,
+        update: update,
+        clear: clear
+      });
+    };
+    var init$4 = function (spec) {
+      return spec.store.manager.state(spec);
+    };
+
+    var RepresentState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        memory: memory,
+        dataset: dataset,
+        manual: manual,
+        init: init$4
+    });
+
+    var setValue$2 = function (component, repConfig, repState, data) {
+      var store = repConfig.store;
+      repState.update([data]);
+      store.setValue(component, data);
+      repConfig.onSetValue(component, data);
+    };
+    var getValue$3 = function (component, repConfig, repState) {
+      var store = repConfig.store;
+      var key = store.getDataKey(component);
+      return repState.lookup(key).getOrThunk(function () {
+        return store.getFallbackEntry(key);
+      });
+    };
+    var onLoad$3 = function (component, repConfig, repState) {
+      var store = repConfig.store;
+      store.initialValue.each(function (data) {
+        setValue$2(component, repConfig, repState, data);
+      });
+    };
+    var onUnload$1 = function (component, repConfig, repState) {
+      repState.clear();
+    };
+    var DatasetStore = [
+      option('initialValue'),
+      required$1('getFallbackEntry'),
+      required$1('getDataKey'),
+      required$1('setValue'),
+      output('manager', {
+        setValue: setValue$2,
+        getValue: getValue$3,
+        onLoad: onLoad$3,
+        onUnload: onUnload$1,
+        state: dataset
+      })
+    ];
+
+    var getValue$2 = function (component, repConfig, _repState) {
+      return repConfig.store.getValue(component);
+    };
+    var setValue$1 = function (component, repConfig, _repState, data) {
+      repConfig.store.setValue(component, data);
+      repConfig.onSetValue(component, data);
+    };
+    var onLoad$2 = function (component, repConfig, _repState) {
+      repConfig.store.initialValue.each(function (data) {
+        repConfig.store.setValue(component, data);
+      });
+    };
+    var ManualStore = [
+      required$1('getValue'),
+      defaulted('setValue', noop),
+      option('initialValue'),
+      output('manager', {
+        setValue: setValue$1,
+        getValue: getValue$2,
+        onLoad: onLoad$2,
+        onUnload: noop,
+        state: NoState.init
+      })
+    ];
+
+    var setValue = function (component, repConfig, repState, data) {
+      repState.set(data);
+      repConfig.onSetValue(component, data);
+    };
+    var getValue$1 = function (component, repConfig, repState) {
+      return repState.get();
+    };
+    var onLoad$1 = function (component, repConfig, repState) {
+      repConfig.store.initialValue.each(function (initVal) {
+        if (repState.isNotSet()) {
+          repState.set(initVal);
+        }
+      });
+    };
+    var onUnload = function (component, repConfig, repState) {
+      repState.clear();
+    };
+    var MemoryStore = [
+      option('initialValue'),
+      output('manager', {
+        setValue: setValue,
+        getValue: getValue$1,
+        onLoad: onLoad$1,
+        onUnload: onUnload,
+        state: memory
+      })
+    ];
+
+    var RepresentSchema = [
+      defaultedOf('store', { mode: 'memory' }, choose$1('mode', {
+        memory: MemoryStore,
+        manual: ManualStore,
+        dataset: DatasetStore
+      })),
+      onHandler('onSetValue'),
+      defaulted('resetOnDom', false)
+    ];
+
+    var Representing = create$5({
+      fields: RepresentSchema,
+      name: 'representing',
+      active: ActiveRepresenting,
+      apis: RepresentApis,
+      extra: {
+        setValueFrom: function (component, source) {
+          var value = Representing.getValue(source);
+          Representing.setValue(component, value);
+        }
+      },
+      state: RepresentState
+    });
+
+    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$5 = function (element) {
+      return api$1.get(element);
+    };
+
+    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 _sliderChangeEvent = 'slider.change.value';
+    var sliderChangeEvent = constant$1(_sliderChangeEvent);
+    var isTouchEvent = function (evt) {
+      return evt.type.indexOf('touch') !== -1;
+    };
+    var getEventSource = function (simulatedEvent) {
+      var evt = simulatedEvent.event.raw;
+      if (isTouchEvent(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 {
+        var mouseEvent = evt;
+        return mouseEvent.clientX !== undefined ? Optional.some(mouseEvent).map(function (me) {
+          return SugarPosition(me.clientX, me.clientY);
+        }) : Optional.none();
+      }
+    };
+
+    var t = 'top', r = 'right', b = 'bottom', l = 'left';
+    var minX = function (detail) {
+      return detail.model.minX;
+    };
+    var minY = function (detail) {
+      return detail.model.minY;
+    };
+    var min1X = function (detail) {
+      return detail.model.minX - 1;
+    };
+    var min1Y = function (detail) {
+      return detail.model.minY - 1;
+    };
+    var maxX = function (detail) {
+      return detail.model.maxX;
+    };
+    var maxY = function (detail) {
+      return detail.model.maxY;
+    };
+    var max1X = function (detail) {
+      return detail.model.maxX + 1;
+    };
+    var max1Y = function (detail) {
+      return detail.model.maxY + 1;
+    };
+    var range$1 = function (detail, max, min) {
+      return max(detail) - min(detail);
+    };
+    var xRange = function (detail) {
+      return range$1(detail, maxX, minX);
+    };
+    var yRange = function (detail) {
+      return range$1(detail, maxY, minY);
+    };
+    var halfX = function (detail) {
+      return xRange(detail) / 2;
+    };
+    var halfY = function (detail) {
+      return yRange(detail) / 2;
+    };
+    var step = function (detail) {
+      return detail.stepSize;
+    };
+    var snap = function (detail) {
+      return detail.snapToGrid;
+    };
+    var snapStart = function (detail) {
+      return detail.snapStart;
+    };
+    var rounded = function (detail) {
+      return detail.rounded;
+    };
+    var hasEdge = function (detail, edgeName) {
+      return detail[edgeName + '-edge'] !== undefined;
+    };
+    var hasLEdge = function (detail) {
+      return hasEdge(detail, l);
+    };
+    var hasREdge = function (detail) {
+      return hasEdge(detail, r);
+    };
+    var hasTEdge = function (detail) {
+      return hasEdge(detail, t);
+    };
+    var hasBEdge = function (detail) {
+      return hasEdge(detail, b);
+    };
+    var currentValue = function (detail) {
+      return detail.model.value.get();
+    };
+
+    var xValue = function (x) {
+      return { x: x };
+    };
+    var yValue = function (y) {
+      return { y: y };
+    };
+    var xyValue = function (x, y) {
+      return {
+        x: x,
+        y: y
+      };
+    };
+    var fireSliderChange$3 = function (component, value) {
+      emitWith(component, sliderChangeEvent(), { value: value });
+    };
+    var setToTLEdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(min1X(detail), min1Y(detail)));
+    };
+    var setToTEdge = function (edge, detail) {
+      fireSliderChange$3(edge, yValue(min1Y(detail)));
+    };
+    var setToTEdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(halfX(detail), min1Y(detail)));
+    };
+    var setToTREdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(max1X(detail), min1Y(detail)));
+    };
+    var setToREdge = function (edge, detail) {
+      fireSliderChange$3(edge, xValue(max1X(detail)));
+    };
+    var setToREdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(max1X(detail), halfY(detail)));
+    };
+    var setToBREdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(max1X(detail), max1Y(detail)));
+    };
+    var setToBEdge = function (edge, detail) {
+      fireSliderChange$3(edge, yValue(max1Y(detail)));
+    };
+    var setToBEdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(halfX(detail), max1Y(detail)));
+    };
+    var setToBLEdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(min1X(detail), max1Y(detail)));
+    };
+    var setToLEdge = function (edge, detail) {
+      fireSliderChange$3(edge, xValue(min1X(detail)));
+    };
+    var setToLEdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(min1X(detail), halfY(detail)));
+    };
+
+    var reduceBy = function (value, min, max, step) {
+      if (value < min) {
+        return value;
+      } else if (value > max) {
+        return max;
+      } else if (value === min) {
+        return min - 1;
+      } else {
+        return Math.max(min, value - step);
+      }
+    };
+    var increaseBy = function (value, min, max, step) {
+      if (value > max) {
+        return value;
+      } else if (value < min) {
+        return min;
+      } else if (value === max) {
+        return max + 1;
+      } else {
+        return Math.min(max, value + step);
+      }
+    };
+    var capValue = function (value, min, max) {
+      return Math.max(min, Math.min(max, value));
+    };
+    var snapValueOf = function (value, min, max, step, snapStart) {
+      return snapStart.fold(function () {
+        var initValue = value - min;
+        var extraValue = Math.round(initValue / step) * step;
+        return capValue(min + extraValue, min - 1, max + 1);
+      }, function (start) {
+        var remainder = (value - start) % step;
+        var adjustment = Math.round(remainder / step);
+        var rawSteps = Math.floor((value - start) / step);
+        var maxSteps = Math.floor((max - start) / step);
+        var numSteps = Math.min(maxSteps, rawSteps + adjustment);
+        var r = start + numSteps * step;
+        return Math.max(start, r);
+      });
+    };
+    var findOffsetOf = function (value, min, max) {
+      return Math.min(max, Math.max(value, min)) - min;
+    };
+    var findValueOf = function (args) {
+      var min = args.min, max = args.max, range = args.range, value = args.value, step = args.step, snap = args.snap, snapStart = args.snapStart, rounded = args.rounded, hasMinEdge = args.hasMinEdge, hasMaxEdge = args.hasMaxEdge, minBound = args.minBound, maxBound = args.maxBound, screenRange = args.screenRange;
+      var capMin = hasMinEdge ? min - 1 : min;
+      var capMax = hasMaxEdge ? max + 1 : max;
+      if (value < minBound) {
+        return capMin;
+      } else if (value > maxBound) {
+        return capMax;
+      } else {
+        var offset = findOffsetOf(value, minBound, maxBound);
+        var newValue = capValue(offset / screenRange * range + min, capMin, capMax);
+        if (snap && newValue >= min && newValue <= max) {
+          return snapValueOf(newValue, min, max, step, snapStart);
+        } else if (rounded) {
+          return Math.round(newValue);
+        } else {
+          return newValue;
+        }
+      }
+    };
+    var findOffsetOfValue$2 = function (args) {
+      var min = args.min, max = args.max, range = args.range, value = args.value, hasMinEdge = args.hasMinEdge, hasMaxEdge = args.hasMaxEdge, maxBound = args.maxBound, maxOffset = args.maxOffset, centerMinEdge = args.centerMinEdge, centerMaxEdge = args.centerMaxEdge;
+      if (value < min) {
+        return hasMinEdge ? 0 : centerMinEdge;
+      } else if (value > max) {
+        return hasMaxEdge ? maxBound : centerMaxEdge;
+      } else {
+        return (value - min) / range * maxOffset;
+      }
+    };
+
+    var top = 'top', right = 'right', bottom = 'bottom', left = 'left', width = 'width', height = 'height';
+    var getBounds$1 = function (component) {
+      return component.element.dom.getBoundingClientRect();
+    };
+    var getBoundsProperty = function (bounds, property) {
+      return bounds[property];
+    };
+    var getMinXBounds = function (component) {
+      var bounds = getBounds$1(component);
+      return getBoundsProperty(bounds, left);
+    };
+    var getMaxXBounds = function (component) {
+      var bounds = getBounds$1(component);
+      return getBoundsProperty(bounds, right);
+    };
+    var getMinYBounds = function (component) {
+      var bounds = getBounds$1(component);
+      return getBoundsProperty(bounds, top);
+    };
+    var getMaxYBounds = function (component) {
+      var bounds = getBounds$1(component);
+      return getBoundsProperty(bounds, bottom);
+    };
+    var getXScreenRange = function (component) {
+      var bounds = getBounds$1(component);
+      return getBoundsProperty(bounds, width);
+    };
+    var getYScreenRange = function (component) {
+      var bounds = getBounds$1(component);
+      return getBoundsProperty(bounds, height);
+    };
+    var getCenterOffsetOf = function (componentMinEdge, componentMaxEdge, spectrumMinEdge) {
+      return (componentMinEdge + componentMaxEdge) / 2 - spectrumMinEdge;
+    };
+    var getXCenterOffSetOf = function (component, spectrum) {
+      var componentBounds = getBounds$1(component);
+      var spectrumBounds = getBounds$1(spectrum);
+      var componentMinEdge = getBoundsProperty(componentBounds, left);
+      var componentMaxEdge = getBoundsProperty(componentBounds, right);
+      var spectrumMinEdge = getBoundsProperty(spectrumBounds, left);
+      return getCenterOffsetOf(componentMinEdge, componentMaxEdge, spectrumMinEdge);
+    };
+    var getYCenterOffSetOf = function (component, spectrum) {
+      var componentBounds = getBounds$1(component);
+      var spectrumBounds = getBounds$1(spectrum);
+      var componentMinEdge = getBoundsProperty(componentBounds, top);
+      var componentMaxEdge = getBoundsProperty(componentBounds, bottom);
+      var spectrumMinEdge = getBoundsProperty(spectrumBounds, top);
+      return getCenterOffsetOf(componentMinEdge, componentMaxEdge, spectrumMinEdge);
+    };
+
+    var fireSliderChange$2 = function (spectrum, value) {
+      emitWith(spectrum, sliderChangeEvent(), { value: value });
+    };
+    var sliderValue$2 = function (x) {
+      return { x: x };
+    };
+    var findValueOfOffset$1 = function (spectrum, detail, left) {
+      var args = {
+        min: minX(detail),
+        max: maxX(detail),
+        range: xRange(detail),
+        value: left,
+        step: step(detail),
+        snap: snap(detail),
+        snapStart: snapStart(detail),
+        rounded: rounded(detail),
+        hasMinEdge: hasLEdge(detail),
+        hasMaxEdge: hasREdge(detail),
+        minBound: getMinXBounds(spectrum),
+        maxBound: getMaxXBounds(spectrum),
+        screenRange: getXScreenRange(spectrum)
+      };
+      return findValueOf(args);
+    };
+    var setValueFrom$2 = function (spectrum, detail, value) {
+      var xValue = findValueOfOffset$1(spectrum, detail, value);
+      var sliderVal = sliderValue$2(xValue);
+      fireSliderChange$2(spectrum, sliderVal);
+      return xValue;
+    };
+    var setToMin$2 = function (spectrum, detail) {
+      var min = minX(detail);
+      fireSliderChange$2(spectrum, sliderValue$2(min));
+    };
+    var setToMax$2 = function (spectrum, detail) {
+      var max = maxX(detail);
+      fireSliderChange$2(spectrum, sliderValue$2(max));
+    };
+    var moveBy$2 = function (direction, spectrum, detail) {
+      var f = direction > 0 ? increaseBy : reduceBy;
+      var xValue = f(currentValue(detail).x, minX(detail), maxX(detail), step(detail));
+      fireSliderChange$2(spectrum, sliderValue$2(xValue));
+      return Optional.some(xValue);
+    };
+    var handleMovement$2 = function (direction) {
+      return function (spectrum, detail) {
+        return moveBy$2(direction, spectrum, detail).map(always);
+      };
+    };
+    var getValueFromEvent$2 = function (simulatedEvent) {
+      var pos = getEventSource(simulatedEvent);
+      return pos.map(function (p) {
+        return p.left;
+      });
+    };
+    var findOffsetOfValue$1 = function (spectrum, detail, value, minEdge, maxEdge) {
+      var minOffset = 0;
+      var maxOffset = getXScreenRange(spectrum);
+      var centerMinEdge = minEdge.bind(function (edge) {
+        return Optional.some(getXCenterOffSetOf(edge, spectrum));
+      }).getOr(minOffset);
+      var centerMaxEdge = maxEdge.bind(function (edge) {
+        return Optional.some(getXCenterOffSetOf(edge, spectrum));
+      }).getOr(maxOffset);
+      var args = {
+        min: minX(detail),
+        max: maxX(detail),
+        range: xRange(detail),
+        value: value,
+        hasMinEdge: hasLEdge(detail),
+        hasMaxEdge: hasREdge(detail),
+        minBound: getMinXBounds(spectrum),
+        minOffset: minOffset,
+        maxBound: getMaxXBounds(spectrum),
+        maxOffset: maxOffset,
+        centerMinEdge: centerMinEdge,
+        centerMaxEdge: centerMaxEdge
+      };
+      return findOffsetOfValue$2(args);
+    };
+    var findPositionOfValue$1 = function (slider, spectrum, value, minEdge, maxEdge, detail) {
+      var offset = findOffsetOfValue$1(spectrum, detail, value, minEdge, maxEdge);
+      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$5(thumb.element) / 2;
+      set$5(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;
+    var edgeActions$2 = {
+      'top-left': Optional.none(),
+      'top': Optional.none(),
+      'top-right': Optional.none(),
+      'right': Optional.some(setToREdge),
+      'bottom-right': Optional.none(),
+      'bottom': Optional.none(),
+      'bottom-left': Optional.none(),
+      'left': Optional.some(setToLEdge)
+    };
+
+    var HorizontalModel = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        setValueFrom: setValueFrom$2,
+        setToMin: setToMin$2,
+        setToMax: setToMax$2,
+        findValueOfOffset: findValueOfOffset$1,
+        getValueFromEvent: getValueFromEvent$2,
+        findPositionOfValue: findPositionOfValue$1,
+        setPositionFromValue: setPositionFromValue$2,
+        onLeft: onLeft$2,
+        onRight: onRight$2,
+        onUp: onUp$2,
+        onDown: onDown$2,
+        edgeActions: edgeActions$2
+    });
+
+    var fireSliderChange$1 = function (spectrum, value) {
+      emitWith(spectrum, sliderChangeEvent(), { value: value });
+    };
+    var sliderValue$1 = function (y) {
+      return { y: y };
+    };
+    var findValueOfOffset = function (spectrum, detail, top) {
+      var args = {
+        min: minY(detail),
+        max: maxY(detail),
+        range: yRange(detail),
+        value: top,
+        step: step(detail),
+        snap: snap(detail),
+        snapStart: snapStart(detail),
+        rounded: rounded(detail),
+        hasMinEdge: hasTEdge(detail),
+        hasMaxEdge: hasBEdge(detail),
+        minBound: getMinYBounds(spectrum),
+        maxBound: getMaxYBounds(spectrum),
+        screenRange: getYScreenRange(spectrum)
+      };
+      return findValueOf(args);
+    };
+    var setValueFrom$1 = function (spectrum, detail, value) {
+      var yValue = findValueOfOffset(spectrum, detail, value);
+      var sliderVal = sliderValue$1(yValue);
+      fireSliderChange$1(spectrum, sliderVal);
+      return yValue;
+    };
+    var setToMin$1 = function (spectrum, detail) {
+      var min = minY(detail);
+      fireSliderChange$1(spectrum, sliderValue$1(min));
+    };
+    var setToMax$1 = function (spectrum, detail) {
+      var max = maxY(detail);
+      fireSliderChange$1(spectrum, sliderValue$1(max));
+    };
+    var moveBy$1 = function (direction, spectrum, detail) {
+      var f = direction > 0 ? increaseBy : reduceBy;
+      var yValue = f(currentValue(detail).y, minY(detail), maxY(detail), step(detail));
+      fireSliderChange$1(spectrum, sliderValue$1(yValue));
+      return Optional.some(yValue);
+    };
+    var handleMovement$1 = function (direction) {
+      return function (spectrum, detail) {
+        return moveBy$1(direction, spectrum, detail).map(always);
+      };
+    };
+    var getValueFromEvent$1 = function (simulatedEvent) {
+      var pos = getEventSource(simulatedEvent);
+      return pos.map(function (p) {
+        return p.top;
+      });
+    };
+    var findOffsetOfValue = function (spectrum, detail, value, minEdge, maxEdge) {
+      var minOffset = 0;
+      var maxOffset = getYScreenRange(spectrum);
+      var centerMinEdge = minEdge.bind(function (edge) {
+        return Optional.some(getYCenterOffSetOf(edge, spectrum));
+      }).getOr(minOffset);
+      var centerMaxEdge = maxEdge.bind(function (edge) {
+        return Optional.some(getYCenterOffSetOf(edge, spectrum));
+      }).getOr(maxOffset);
+      var args = {
+        min: minY(detail),
+        max: maxY(detail),
+        range: yRange(detail),
+        value: value,
+        hasMinEdge: hasTEdge(detail),
+        hasMaxEdge: hasBEdge(detail),
+        minBound: getMinYBounds(spectrum),
+        minOffset: minOffset,
+        maxBound: getMaxYBounds(spectrum),
+        maxOffset: maxOffset,
+        centerMinEdge: centerMinEdge,
+        centerMaxEdge: centerMaxEdge
+      };
+      return findOffsetOfValue$2(args);
+    };
+    var findPositionOfValue = function (slider, spectrum, value, minEdge, maxEdge, detail) {
+      var offset = findOffsetOfValue(spectrum, detail, value, minEdge, maxEdge);
+      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$7(thumb.element) / 2;
+      set$5(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 edgeActions$1 = {
+      'top-left': Optional.none(),
+      'top': Optional.some(setToTEdge),
+      'top-right': Optional.none(),
+      'right': Optional.none(),
+      'bottom-right': Optional.none(),
+      'bottom': Optional.some(setToBEdge),
+      'bottom-left': Optional.none(),
+      'left': Optional.none()
+    };
+
+    var VerticalModel = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        setValueFrom: setValueFrom$1,
+        setToMin: setToMin$1,
+        setToMax: setToMax$1,
+        findValueOfOffset: findValueOfOffset,
+        getValueFromEvent: getValueFromEvent$1,
+        findPositionOfValue: findPositionOfValue,
+        setPositionFromValue: setPositionFromValue$1,
+        onLeft: onLeft$1,
+        onRight: onRight$1,
+        onUp: onUp$1,
+        onDown: onDown$1,
+        edgeActions: edgeActions$1
+    });
+
+    var fireSliderChange = function (spectrum, value) {
+      emitWith(spectrum, sliderChangeEvent(), { value: value });
+    };
+    var sliderValue = function (x, y) {
+      return {
+        x: x,
+        y: y
+      };
+    };
+    var setValueFrom = function (spectrum, detail, value) {
+      var xValue = findValueOfOffset$1(spectrum, detail, value.left);
+      var yValue = findValueOfOffset(spectrum, detail, value.top);
+      var val = sliderValue(xValue, yValue);
+      fireSliderChange(spectrum, val);
+      return val;
+    };
+    var moveBy = function (direction, isVerticalMovement, spectrum, detail) {
+      var f = direction > 0 ? increaseBy : reduceBy;
+      var xValue = isVerticalMovement ? currentValue(detail).x : f(currentValue(detail).x, minX(detail), maxX(detail), step(detail));
+      var yValue = !isVerticalMovement ? currentValue(detail).y : f(currentValue(detail).y, minY(detail), maxY(detail), step(detail));
+      fireSliderChange(spectrum, sliderValue(xValue, yValue));
+      return Optional.some(xValue);
+    };
+    var handleMovement = function (direction, isVerticalMovement) {
+      return function (spectrum, detail) {
+        return moveBy(direction, isVerticalMovement, spectrum, detail).map(always);
+      };
+    };
+    var setToMin = function (spectrum, detail) {
+      var mX = minX(detail);
+      var mY = minY(detail);
+      fireSliderChange(spectrum, sliderValue(mX, mY));
+    };
+    var setToMax = function (spectrum, detail) {
+      var mX = maxX(detail);
+      var mY = maxY(detail);
+      fireSliderChange(spectrum, sliderValue(mX, mY));
+    };
+    var getValueFromEvent = function (simulatedEvent) {
+      return getEventSource(simulatedEvent);
+    };
+    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$5(thumb.element) / 2;
+      var thumbYRadius = get$7(thumb.element) / 2;
+      set$5(thumb.element, 'left', xPos - thumbXRadius + 'px');
+      set$5(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);
+    var edgeActions = {
+      'top-left': Optional.some(setToTLEdgeXY),
+      'top': Optional.some(setToTEdgeXY),
+      'top-right': Optional.some(setToTREdgeXY),
+      'right': Optional.some(setToREdgeXY),
+      'bottom-right': Optional.some(setToBREdgeXY),
+      'bottom': Optional.some(setToBEdgeXY),
+      'bottom-left': Optional.some(setToBLEdgeXY),
+      'left': Optional.some(setToLEdgeXY)
+    };
+
+    var TwoDModel = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        setValueFrom: setValueFrom,
+        setToMin: setToMin,
+        setToMax: setToMax,
+        getValueFromEvent: getValueFromEvent,
+        setPositionFromValue: setPositionFromValue,
+        onLeft: onLeft,
+        onRight: onRight,
+        onUp: onUp,
+        onDown: onDown,
+        edgeActions: edgeActions
+    });
+
+    var SliderSchema = [
+      defaulted('stepSize', 1),
+      defaulted('onChange', noop),
+      defaulted('onChoose', noop),
+      defaulted('onInit', noop),
+      defaulted('onDragStart', noop),
+      defaulted('onDragEnd', noop),
+      defaulted('snapToGrid', false),
+      defaulted('rounded', true),
+      option('snapStart'),
+      requiredOf('model', choose$1('mode', {
+        x: [
+          defaulted('minX', 0),
+          defaulted('maxX', 100),
+          customField('value', function (spec) {
+            return Cell(spec.mode.minX);
+          }),
+          required$1('getInitialValue'),
+          output('manager', HorizontalModel)
+        ],
+        y: [
+          defaulted('minY', 0),
+          defaulted('maxY', 100),
+          customField('value', function (spec) {
+            return Cell(spec.mode.minY);
+          }),
+          required$1('getInitialValue'),
+          output('manager', VerticalModel)
+        ],
+        xy: [
+          defaulted('minX', 0),
+          defaulted('maxX', 100),
+          defaulted('minY', 0),
+          defaulted('maxY', 100),
+          customField('value', function (spec) {
+            return Cell({
+              x: spec.mode.minX,
+              y: spec.mode.minY
+            });
+          }),
+          required$1('getInitialValue'),
+          output('manager', TwoDModel)
+        ]
+      })),
+      field$1('sliderBehaviours', [
+        Keying,
+        Representing
+      ]),
+      customField('mouseIsDown', function () {
+        return Cell(false);
+      })
+    ];
+
+    var mouseReleased = constant$1('mouse.released');
+
+    var sketch$9 = function (detail, components, _spec, _externals) {
+      var _a;
+      var getThumb = function (component) {
+        return getPartOrDie(component, detail, 'thumb');
+      };
+      var getSpectrum = function (component) {
+        return getPartOrDie(component, detail, 'spectrum');
+      };
+      var getLeftEdge = function (component) {
+        return getPart(component, detail, 'left-edge');
+      };
+      var getRightEdge = function (component) {
+        return getPart(component, detail, 'right-edge');
+      };
+      var getTopEdge = function (component) {
+        return getPart(component, detail, 'top-edge');
+      };
+      var getBottomEdge = function (component) {
+        return getPart(component, detail, 'bottom-edge');
+      };
+      var modelDetail = detail.model;
+      var model = modelDetail.manager;
+      var refresh = function (slider, thumb) {
+        model.setPositionFromValue(slider, thumb, detail, {
+          getLeftEdge: getLeftEdge,
+          getRightEdge: getRightEdge,
+          getTopEdge: getTopEdge,
+          getBottomEdge: getBottomEdge,
+          getSpectrum: getSpectrum
+        });
+      };
+      var setValue = function (slider, newValue) {
+        modelDetail.value.set(newValue);
+        var thumb = getThumb(slider);
+        refresh(slider, thumb);
+      };
+      var changeValue = function (slider, newValue) {
+        setValue(slider, newValue);
+        var thumb = getThumb(slider);
+        detail.onChange(slider, thumb, newValue);
+        return Optional.some(true);
+      };
+      var resetToMin = function (slider) {
+        model.setToMin(slider, detail);
+      };
+      var resetToMax = function (slider) {
+        model.setToMax(slider, detail);
+      };
+      var choose = function (slider) {
+        var fireOnChoose = function () {
+          getPart(slider, detail, 'thumb').each(function (thumb) {
+            var value = modelDetail.value.get();
+            detail.onChoose(slider, thumb, value);
+          });
+        };
+        var wasDown = detail.mouseIsDown.get();
+        detail.mouseIsDown.set(false);
+        if (wasDown) {
+          fireOnChoose();
+        }
+      };
+      var onDragStart = function (slider, simulatedEvent) {
+        simulatedEvent.stop();
+        detail.mouseIsDown.set(true);
+        detail.onDragStart(slider, getThumb(slider));
+      };
+      var onDragEnd = function (slider, simulatedEvent) {
+        simulatedEvent.stop();
+        detail.onDragEnd(slider, getThumb(slider));
+        choose(slider);
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: augment(detail.sliderBehaviours, [
+          Keying.config({
+            mode: 'special',
+            focusIn: function (slider) {
+              return getPart(slider, detail, 'spectrum').map(Keying.focusIn).map(always);
+            }
+          }),
+          Representing.config({
+            store: {
+              mode: 'manual',
+              getValue: function (_) {
+                return modelDetail.value.get();
+              }
+            }
+          }),
+          Receiving.config({ channels: (_a = {}, _a[mouseReleased()] = { onReceive: choose }, _a) })
+        ]),
+        events: derive$3([
+          run(sliderChangeEvent(), function (slider, simulatedEvent) {
+            changeValue(slider, simulatedEvent.event.value);
+          }),
+          runOnAttached(function (slider, _simulatedEvent) {
+            var getInitial = modelDetail.getInitialValue();
+            modelDetail.value.set(getInitial);
+            var thumb = getThumb(slider);
+            refresh(slider, thumb);
+            var spectrum = getSpectrum(slider);
+            detail.onInit(slider, thumb, spectrum, modelDetail.value.get());
+          }),
+          run(touchstart(), onDragStart),
+          run(touchend(), onDragEnd),
+          run(mousedown(), onDragStart),
+          run(mouseup(), onDragEnd)
+        ]),
+        apis: {
+          resetToMin: resetToMin,
+          resetToMax: resetToMax,
+          setValue: setValue,
+          refresh: refresh
+        },
+        domModification: { styles: { position: 'relative' } }
+      };
+    };
+
+    var Slider = composite({
+      name: 'Slider',
+      configFields: SliderSchema,
+      partFields: SliderParts,
+      factory: sketch$9,
+      apis: {
+        setValue: function (apis, slider, value) {
+          apis.setValue(slider, value);
+        },
+        resetToMin: function (apis, slider) {
+          apis.resetToMin(slider);
+        },
+        resetToMax: function (apis, slider) {
+          apis.resetToMax(slider);
+        },
+        refresh: function (apis, slider) {
+          apis.refresh(slider);
+        }
+      }
+    });
+
+    var button = function (realm, clazz, makeItems, editor) {
+      return forToolbar(clazz, function () {
+        var items = makeItems();
+        realm.setContextToolbar([{
+            label: clazz + ' group',
+            items: items
+          }]);
+      }, {}, editor);
+    };
+
+    var BLACK = -1;
+    var makeSlider$1 = function (spec$1) {
+      var getColor = function (hue) {
+        if (hue < 0) {
+          return 'black';
+        } else if (hue > 360) {
+          return 'white';
+        } else {
+          return 'hsl(' + hue + ', 100%, 50%)';
+        }
+      };
+      var onInit = function (slider, thumb, spectrum, value) {
+        var color = getColor(value.x());
+        set$5(thumb.element, 'background-color', color);
+      };
+      var onChange = function (slider, thumb, value) {
+        var color = getColor(value.x());
+        set$5(thumb.element, 'background-color', color);
+        spec$1.onChange(slider, thumb, color);
+      };
+      return Slider.sketch({
+        dom: dom$1('<div class="${prefix}-slider ${prefix}-hue-slider-container"></div>'),
+        components: [
+          Slider.parts['left-edge'](spec('<div class="${prefix}-hue-slider-black"></div>')),
+          Slider.parts.spectrum({
+            dom: dom$1('<div class="${prefix}-slider-gradient-container"></div>'),
+            components: [spec('<div class="${prefix}-slider-gradient"></div>')],
+            behaviours: derive$2([Toggling.config({ toggleClass: resolve('thumb-active') })])
+          }),
+          Slider.parts['right-edge'](spec('<div class="${prefix}-hue-slider-white"></div>')),
+          Slider.parts.thumb({
+            dom: dom$1('<div class="${prefix}-slider-thumb"></div>'),
+            behaviours: derive$2([Toggling.config({ toggleClass: resolve('thumb-active') })])
+          })
+        ],
+        onChange: onChange,
+        onDragStart: function (slider, thumb) {
+          Toggling.on(thumb);
+        },
+        onDragEnd: function (slider, thumb) {
+          Toggling.off(thumb);
+        },
+        onInit: onInit,
+        stepSize: 10,
+        model: {
+          mode: 'x',
+          minX: 0,
+          maxX: 360,
+          getInitialValue: function () {
+            return { x: spec$1.getInitialValue() };
+          }
+        },
+        sliderBehaviours: derive$2([orientation(Slider.refresh)])
+      });
+    };
+    var makeItems$1 = function (spec) {
+      return [makeSlider$1(spec)];
+    };
+    var sketch$8 = function (realm, editor) {
+      var spec = {
+        onChange: function (slider, thumb, color) {
+          editor.undoManager.transact(function () {
+            editor.formatter.apply('forecolor', { value: color });
+            editor.nodeChanged();
+          });
+        },
+        getInitialValue: constant$1(BLACK)
+      };
+      return button(realm, 'color-levels', function () {
+        return makeItems$1(spec);
+      }, editor);
+    };
+
+    var candidatesArray = [
+      '9px',
+      '10px',
+      '11px',
+      '12px',
+      '14px',
+      '16px',
+      '18px',
+      '20px',
+      '24px',
+      '32px',
+      '36px'
+    ];
+    var defaultSize = 'medium';
+    var defaultIndex = 2;
+    var indexToSize = function (index) {
+      return Optional.from(candidatesArray[index]);
+    };
+    var sizeToIndex = function (size) {
+      return findIndex$1(candidatesArray, function (v) {
+        return v === size;
+      });
+    };
+    var getRawOrComputed = function (isRoot, rawStart) {
+      var optStart = isElement(rawStart) ? Optional.some(rawStart) : parent(rawStart).filter(isElement);
+      return optStart.map(function (start) {
+        var inline = closest$2(start, function (elem) {
+          return getRaw(elem, 'font-size').isSome();
+        }, isRoot).bind(function (elem) {
+          return getRaw(elem, 'font-size');
+        });
+        return inline.getOrThunk(function () {
+          return get$8(start, 'font-size');
+        });
+      }).getOr('');
+    };
+    var getSize = function (editor) {
+      var node = editor.selection.getStart();
+      var elem = SugarElement.fromDom(node);
+      var root = SugarElement.fromDom(editor.getBody());
+      var isRoot = function (e) {
+        return eq(root, e);
+      };
+      var elemSize = getRawOrComputed(isRoot, elem);
+      return find$2(candidatesArray, function (size) {
+        return elemSize === size;
+      }).getOr(defaultSize);
+    };
+    var applySize = function (editor, value) {
+      var currentValue = getSize(editor);
+      if (currentValue !== value) {
+        editor.execCommand('fontSize', false, value);
+      }
+    };
+    var get$4 = function (editor) {
+      var size = getSize(editor);
+      return sizeToIndex(size).getOr(defaultIndex);
+    };
+    var apply = function (editor, index) {
+      indexToSize(index).each(function (size) {
+        applySize(editor, size);
+      });
+    };
+    var candidates = constant$1(candidatesArray);
+
+    var schema$9 = objOfOnly([
+      required$1('getInitialValue'),
+      required$1('onChange'),
+      required$1('category'),
+      required$1('sizes')
+    ]);
+    var sketch$7 = function (rawSpec) {
+      var spec$1 = asRawOrDie$1('SizeSlider', schema$9, rawSpec);
+      var isValidValue = function (valueIndex) {
+        return valueIndex >= 0 && valueIndex < spec$1.sizes.length;
+      };
+      var onChange = function (slider, thumb, valueIndex) {
+        var index = valueIndex.x();
+        if (isValidValue(index)) {
+          spec$1.onChange(index);
+        }
+      };
+      return Slider.sketch({
+        dom: {
+          tag: 'div',
+          classes: [
+            resolve('slider-' + spec$1.category + '-size-container'),
+            resolve('slider'),
+            resolve('slider-size-container')
+          ]
+        },
+        onChange: onChange,
+        onDragStart: function (slider, thumb) {
+          Toggling.on(thumb);
+        },
+        onDragEnd: function (slider, thumb) {
+          Toggling.off(thumb);
+        },
+        model: {
+          mode: 'x',
+          minX: 0,
+          maxX: spec$1.sizes.length - 1,
+          getInitialValue: function () {
+            return { x: spec$1.getInitialValue() };
+          }
+        },
+        stepSize: 1,
+        snapToGrid: true,
+        sliderBehaviours: derive$2([orientation(Slider.refresh)]),
+        components: [
+          Slider.parts.spectrum({
+            dom: dom$1('<div class="${prefix}-slider-size-container"></div>'),
+            components: [spec('<div class="${prefix}-slider-size-line"></div>')]
+          }),
+          Slider.parts.thumb({
+            dom: dom$1('<div class="${prefix}-slider-thumb"></div>'),
+            behaviours: derive$2([Toggling.config({ toggleClass: resolve('thumb-active') })])
+          })
+        ]
+      });
+    };
+
+    var sizes = candidates();
+    var makeSlider = function (spec) {
+      return sketch$7({
+        onChange: spec.onChange,
+        sizes: sizes,
+        category: 'font',
+        getInitialValue: spec.getInitialValue
+      });
+    };
+    var makeItems = function (spec$1) {
+      return [
+        spec('<span class="${prefix}-toolbar-button ${prefix}-icon-small-font ${prefix}-icon"></span>'),
+        makeSlider(spec$1),
+        spec('<span class="${prefix}-toolbar-button ${prefix}-icon-large-font ${prefix}-icon"></span>')
+      ];
+    };
+    var sketch$6 = function (realm, editor) {
+      var spec = {
+        onChange: function (value) {
+          apply(editor, value);
+        },
+        getInitialValue: function () {
+          return get$4(editor);
+        }
+      };
+      return button(realm, 'font-size', function () {
+        return makeItems(spec);
+      }, editor);
+    };
+
+    var record = function (spec) {
+      var uid = isSketchSpec$1(spec) && hasNonNullableKey(spec, 'uid') ? spec.uid : generate$2('memento');
+      var get = function (anyInSystem) {
+        return anyInSystem.getSystem().getByUid(uid).getOrDie();
+      };
+      var getOpt = function (anyInSystem) {
+        return anyInSystem.getSystem().getByUid(uid).toOptional();
+      };
+      var asSpec = function () {
+        return __assign(__assign({}, spec), { uid: uid });
+      };
+      return {
+        get: get,
+        getOpt: getOpt,
+        asSpec: asSpec
+      };
+    };
+
+    var exports$1 = {}, module = { exports: exports$1 };
+    (function (define, exports, module, require) {
+      (function (global, factory) {
+        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());
+      }(this, function () {
+        var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+        var promise = { exports: {} };
+        (function (module) {
+          (function (root) {
+            var setTimeoutFunc = setTimeout;
+            function noop() {
+            }
+            function bind(fn, thisArg) {
+              return function () {
+                fn.apply(thisArg, arguments);
+              };
+            }
+            function Promise(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 = 0;
+              this._handled = false;
+              this._value = undefined;
+              this._deferreds = [];
+              doResolve(fn, this);
+            }
+            function handle(self, deferred) {
+              while (self._state === 3) {
+                self = self._value;
+              }
+              if (self._state === 0) {
+                self._deferreds.push(deferred);
+                return;
+              }
+              self._handled = true;
+              Promise._immediateFn(function () {
+                var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
+                if (cb === null) {
+                  (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
+                  return;
+                }
+                var ret;
+                try {
+                  ret = cb(self._value);
+                } catch (e) {
+                  reject(deferred.promise, e);
+                  return;
+                }
+                resolve(deferred.promise, ret);
+              });
+            }
+            function resolve(self, newValue) {
+              try {
+                if (newValue === self)
+                  throw new TypeError('A promise cannot be resolved with itself.');
+                if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+                  var then = newValue.then;
+                  if (newValue instanceof Promise) {
+                    self._state = 3;
+                    self._value = newValue;
+                    finale(self);
+                    return;
+                  } else if (typeof then === 'function') {
+                    doResolve(bind(then, newValue), self);
+                    return;
+                  }
+                }
+                self._state = 1;
+                self._value = newValue;
+                finale(self);
+              } catch (e) {
+                reject(self, e);
+              }
+            }
+            function reject(self, newValue) {
+              self._state = 2;
+              self._value = newValue;
+              finale(self);
+            }
+            function finale(self) {
+              if (self._state === 2 && self._deferreds.length === 0) {
+                Promise._immediateFn(function () {
+                  if (!self._handled) {
+                    Promise._unhandledRejectionFn(self._value);
+                  }
+                });
+              }
+              for (var i = 0, len = self._deferreds.length; i < len; i++) {
+                handle(self, self._deferreds[i]);
+              }
+              self._deferreds = null;
+            }
+            function Handler(onFulfilled, onRejected, promise) {
+              this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+              this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+              this.promise = promise;
+            }
+            function doResolve(fn, self) {
+              var done = false;
+              try {
+                fn(function (value) {
+                  if (done)
+                    return;
+                  done = true;
+                  resolve(self, value);
+                }, function (reason) {
+                  if (done)
+                    return;
+                  done = true;
+                  reject(self, reason);
+                });
+              } catch (ex) {
+                if (done)
+                  return;
+                done = true;
+                reject(self, ex);
+              }
+            }
+            Promise.prototype['catch'] = function (onRejected) {
+              return this.then(null, onRejected);
+            };
+            Promise.prototype.then = function (onFulfilled, onRejected) {
+              var prom = new this.constructor(noop);
+              handle(this, new Handler(onFulfilled, onRejected, prom));
+              return prom;
+            };
+            Promise.all = function (arr) {
+              var args = Array.prototype.slice.call(arr);
+              return new Promise(function (resolve, reject) {
+                if (args.length === 0)
+                  return resolve([]);
+                var remaining = args.length;
+                function res(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 (value) {
+              return new Promise(function (resolve, reject) {
+                reject(value);
+              });
+            };
+            Promise.race = function (values) {
+              return new Promise(function (resolve, reject) {
+                for (var i = 0, len = values.length; i < len; i++) {
+                  values[i].then(resolve, reject);
+                }
+              });
+            };
+            Promise._immediateFn = typeof setImmediate === 'function' ? function (fn) {
+              setImmediate(fn);
+            } : function (fn) {
+              setTimeoutFunc(fn, 0);
+            };
+            Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
+              if (typeof console !== 'undefined' && console) {
+                console.warn('Possible Unhandled Promise Rejection:', err);
+              }
+            };
+            Promise._setImmediateFn = function _setImmediateFn(fn) {
+              Promise._immediateFn = fn;
+            };
+            Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
+              Promise._unhandledRejectionFn = fn;
+            };
+            if (module.exports) {
+              module.exports = Promise;
+            } else if (!root.Promise) {
+              root.Promise = Promise;
+            }
+          }(commonjsGlobal));
+        }(promise));
+        var promisePolyfill = promise.exports;
+        var Global = function () {
+          if (typeof window !== 'undefined') {
+            return window;
+          } else {
+            return Function('return this;')();
+          }
+        }();
+        var promisePolyfill_1 = { boltExport: Global.Promise || promisePolyfill };
+        return promisePolyfill_1;
+      }));
+    }(undefined, exports$1, module));
+    var Promise$1 = module.exports.boltExport;
+
+    var blobToDataUri = function (blob) {
+      return new Promise$1(function (resolve) {
+        var reader = new FileReader();
+        reader.onloadend = function () {
+          resolve(reader.result);
+        };
+        reader.readAsDataURL(blob);
+      });
+    };
+    var blobToBase64$1 = function (blob) {
+      return blobToDataUri(blob).then(function (dataUri) {
+        return dataUri.split(',')[1];
+      });
+    };
+
+    var blobToBase64 = function (blob) {
+      return blobToBase64$1(blob);
+    };
+
+    var addImage = function (editor, blob) {
+      blobToBase64(blob).then(function (base64) {
+        editor.undoManager.transact(function () {
+          var cache = editor.editorUpload.blobCache;
+          var info = cache.create(generate$4('mceu'), blob, base64);
+          cache.add(info);
+          var img = editor.dom.createHTML('img', { src: info.blobUri() });
+          editor.insertContent(img);
+        });
+      });
+    };
+    var extractBlob = function (simulatedEvent) {
+      var event = simulatedEvent.event.raw;
+      var files = event.target.files || event.dataTransfer.files;
+      return Optional.from(files[0]);
+    };
+    var sketch$5 = function (editor) {
+      var pickerDom = {
+        tag: 'input',
+        attributes: {
+          accept: 'image/*',
+          type: 'file',
+          title: ''
+        },
+        styles: {
+          visibility: 'hidden',
+          position: 'absolute'
+        }
+      };
+      var memPicker = record({
+        dom: pickerDom,
+        events: derive$3([
+          cutter(click()),
+          run(change(), function (picker, simulatedEvent) {
+            extractBlob(simulatedEvent).each(function (blob) {
+              addImage(editor, blob);
+            });
+          })
+        ])
+      });
+      return Button.sketch({
+        dom: getToolbarIconButton('image', editor),
+        components: [memPicker.asSpec()],
+        action: function (button) {
+          var picker = memPicker.get(button);
+          picker.element.dom.click();
+        }
+      });
+    };
+
+    var get$3 = function (element) {
+      return element.dom.textContent;
+    };
+    var set$3 = function (element, value) {
+      element.dom.textContent = value;
+    };
+
+    var isNotEmpty = function (val) {
+      return val.length > 0;
+    };
+    var defaultToEmpty = function (str) {
+      return str === undefined || str === null ? '' : str;
+    };
+    var noLink = function (editor) {
+      var text = editor.selection.getContent({ format: 'text' });
+      return {
+        url: '',
+        text: text,
+        title: '',
+        target: '',
+        link: Optional.none()
+      };
+    };
+    var fromLink = function (link) {
+      var text = get$3(link);
+      var url = get$b(link, 'href');
+      var title = get$b(link, 'title');
+      var target = get$b(link, 'target');
+      return {
+        url: defaultToEmpty(url),
+        text: text !== url ? defaultToEmpty(text) : '',
+        title: defaultToEmpty(title),
+        target: defaultToEmpty(target),
+        link: Optional.some(link)
+      };
+    };
+    var getInfo = function (editor) {
+      return query(editor).fold(function () {
+        return noLink(editor);
+      }, function (link) {
+        return fromLink(link);
+      });
+    };
+    var wasSimple = function (link) {
+      var prevHref = get$b(link, 'href');
+      var prevText = get$3(link);
+      return prevHref === prevText;
+    };
+    var getTextToApply = function (link, url, info) {
+      return info.text.toOptional().filter(isNotEmpty).fold(function () {
+        return wasSimple(link) ? Optional.some(url) : Optional.none();
+      }, Optional.some);
+    };
+    var unlinkIfRequired = function (editor, info) {
+      var activeLink = info.link.bind(identity);
+      activeLink.each(function (_link) {
+        editor.execCommand('unlink');
+      });
+    };
+    var getAttrs = function (url, info) {
+      var attrs = {};
+      attrs.href = url;
+      info.title.toOptional().filter(isNotEmpty).each(function (title) {
+        attrs.title = title;
+      });
+      info.target.toOptional().filter(isNotEmpty).each(function (target) {
+        attrs.target = target;
+      });
+      return attrs;
+    };
+    var applyInfo = function (editor, info) {
+      info.url.toOptional().filter(isNotEmpty).fold(function () {
+        unlinkIfRequired(editor, info);
+      }, function (url) {
+        var attrs = getAttrs(url, info);
+        var activeLink = info.link.bind(identity);
+        activeLink.fold(function () {
+          var text = info.text.toOptional().filter(isNotEmpty).getOr(url);
+          editor.insertContent(editor.dom.createHTML('a', attrs, editor.dom.encode(text)));
+        }, function (link) {
+          var text = getTextToApply(link, url, info);
+          setAll$1(link, attrs);
+          text.each(function (newText) {
+            set$3(link, newText);
+          });
+        });
+      });
+    };
+    var query = function (editor) {
+      var start = SugarElement.fromDom(editor.selection.getStart());
+      return closest$1(start, 'a');
+    };
+
+    var platform = detect$1();
+    var preserve$1 = function (f, editor) {
+      var rng = editor.selection.getRng();
+      f();
+      editor.selection.setRng(rng);
+    };
+    var forAndroid = function (editor, f) {
+      var wrapper = platform.os.isAndroid() ? preserve$1 : apply$1;
+      wrapper(f, editor);
+    };
+
+    var events$4 = function (name, eventHandlers) {
+      var events = derive$3(eventHandlers);
+      return create$5({
+        fields: [required$1('enabled')],
+        name: name,
+        active: { events: constant$1(events) }
+      });
+    };
+    var config = function (name, eventHandlers) {
+      var me = events$4(name, eventHandlers);
+      return {
+        key: name,
+        value: {
+          config: {},
+          me: me,
+          configAsRaw: constant$1({}),
+          initialConfig: {},
+          state: NoState
+        }
+      };
+    };
+
+    var getCurrent = function (component, composeConfig, _composeState) {
+      return composeConfig.find(component);
+    };
+
+    var ComposeApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        getCurrent: getCurrent
+    });
+
+    var ComposeSchema = [required$1('find')];
+
+    var Composing = create$5({
+      fields: ComposeSchema,
+      name: 'composing',
+      apis: ComposeApis
+    });
+
+    var factory$4 = function (detail) {
+      var _a = detail.dom, attributes = _a.attributes, domWithoutAttributes = __rest(_a, ['attributes']);
+      return {
+        uid: detail.uid,
+        dom: __assign({
+          tag: 'div',
+          attributes: __assign({ role: 'presentation' }, attributes)
+        }, domWithoutAttributes),
+        components: detail.components,
+        behaviours: get$6(detail.containerBehaviours),
+        events: detail.events,
+        domModification: detail.domModification,
+        eventOrder: detail.eventOrder
+      };
+    };
+    var Container = single({
+      name: 'Container',
+      factory: factory$4,
+      configFields: [
+        defaulted('components', []),
+        field$1('containerBehaviours', []),
+        defaulted('events', {}),
+        defaulted('domModification', {}),
+        defaulted('eventOrder', {})
+      ]
+    });
+
+    var factory$3 = function (detail) {
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        behaviours: SketchBehaviours.augment(detail.dataBehaviours, [
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: detail.getInitialValue()
+            }
+          }),
+          Composing.config({ find: Optional.some })
+        ]),
+        events: derive$3([runOnAttached(function (component, _simulatedEvent) {
+            Representing.setValue(component, detail.getInitialValue());
+          })])
+      };
+    };
+    var DataField = single({
+      name: 'DataField',
+      factory: factory$3,
+      configFields: [
+        required$1('uid'),
+        required$1('dom'),
+        required$1('getInitialValue'),
+        SketchBehaviours.field('dataBehaviours', [
+          Representing,
+          Composing
+        ])
+      ]
+    });
+
+    var get$2 = function (element) {
+      return element.dom.value;
+    };
+    var set$2 = function (element, value) {
+      if (value === undefined) {
+        throw new Error('Value.set was undefined');
+      }
+      element.dom.value = value;
+    };
+
+    var schema$8 = constant$1([
+      option('data'),
+      defaulted('inputAttributes', {}),
+      defaulted('inputStyles', {}),
+      defaulted('tag', 'input'),
+      defaulted('inputClasses', []),
+      onHandler('onSetValue'),
+      defaulted('styles', {}),
+      defaulted('eventOrder', {}),
+      field$1('inputBehaviours', [
+        Representing,
+        Focusing
+      ]),
+      defaulted('selectOnFocus', true)
+    ]);
+    var focusBehaviours = function (detail) {
+      return derive$2([Focusing.config({
+          onFocus: !detail.selectOnFocus ? noop : function (component) {
+            var input = component.element;
+            var value = get$2(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$2(input.element);
+            },
+            setValue: function (input, data) {
+              var current = get$2(input.element);
+              if (current !== data) {
+                set$2(input.element, data);
+              }
+            }
+          }),
+          onSetValue: detail.onSetValue
+        })]));
+    };
+    var dom = function (detail) {
+      return {
+        tag: detail.tag,
+        attributes: __assign({ type: 'text' }, detail.inputAttributes),
+        styles: detail.inputStyles,
+        classes: detail.inputClasses
+      };
+    };
+
+    var factory$2 = function (detail, _spec) {
+      return {
+        uid: detail.uid,
+        dom: dom(detail),
+        components: [],
+        behaviours: behaviours(detail),
+        eventOrder: detail.eventOrder
+      };
+    };
+    var Input = single({
+      name: 'Input',
+      configFields: schema$8(),
+      factory: factory$2
+    });
+
+    var exhibit$2 = function (base, tabConfig) {
+      return nu$3({
+        attributes: wrapAll([{
+            key: tabConfig.tabAttr,
+            value: 'true'
+          }])
+      });
+    };
+
+    var ActiveTabstopping = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit$2
+    });
+
+    var TabstopSchema = [defaulted('tabAttr', 'data-alloy-tabstop')];
+
+    var Tabstopping = create$5({
+      fields: TabstopSchema,
+      name: 'tabstopping',
+      active: ActiveTabstopping
+    });
+
+    var global$3 = tinymce.util.Tools.resolve('tinymce.util.I18n');
+
+    var clearInputBehaviour = 'input-clearing';
+    var field = function (name, placeholder) {
+      var inputSpec = record(Input.sketch({
+        inputAttributes: { placeholder: global$3.translate(placeholder) },
+        onSetValue: function (input, _data) {
+          emit(input, input$1());
+        },
+        inputBehaviours: derive$2([
+          Composing.config({ find: Optional.some }),
+          Tabstopping.config({}),
+          Keying.config({ mode: 'execution' })
+        ]),
+        selectOnFocus: false
+      }));
+      var buttonSpec = record(Button.sketch({
+        dom: dom$1('<button class="${prefix}-input-container-x ${prefix}-icon-cancel-circle ${prefix}-icon"></button>'),
+        action: function (button) {
+          var input = inputSpec.get(button);
+          Representing.setValue(input, '');
+        }
+      }));
+      return {
+        name: name,
+        spec: Container.sketch({
+          dom: dom$1('<div class="${prefix}-input-container"></div>'),
+          components: [
+            inputSpec.asSpec(),
+            buttonSpec.asSpec()
+          ],
+          containerBehaviours: derive$2([
+            Toggling.config({ toggleClass: resolve('input-container-empty') }),
+            Composing.config({
+              find: function (comp) {
+                return Optional.some(inputSpec.get(comp));
+              }
+            }),
+            config(clearInputBehaviour, [run(input$1(), function (iContainer) {
+                var input = inputSpec.get(iContainer);
+                var val = Representing.getValue(input);
+                var f = val.length > 0 ? Toggling.off : Toggling.on;
+                f(iContainer);
+              })])
+          ])
+        })
+      };
+    };
+    var hidden = function (name) {
+      return {
+        name: name,
+        spec: DataField.sketch({
+          dom: {
+            tag: 'span',
+            styles: { display: 'none' }
+          },
+          getInitialValue: function () {
+            return Optional.none();
+          }
+        })
+      };
+    };
+
+    var nativeDisabled = [
+      'input',
+      'button',
+      'textarea',
+      'select'
+    ];
+    var onLoad = function (component, disableConfig, disableState) {
+      var f = disableConfig.disabled() ? disable : enable;
+      f(component, disableConfig);
+    };
+    var hasNative = function (component, config) {
+      return config.useNative === true && contains$1(nativeDisabled, name$1(component.element));
+    };
+    var nativeIsDisabled = function (component) {
+      return has$1(component.element, 'disabled');
+    };
+    var nativeDisable = function (component) {
+      set$8(component.element, 'disabled', 'disabled');
+    };
+    var nativeEnable = function (component) {
+      remove$6(component.element, 'disabled');
+    };
+    var ariaIsDisabled = function (component) {
+      return get$b(component.element, 'aria-disabled') === 'true';
+    };
+    var ariaDisable = function (component) {
+      set$8(component.element, 'aria-disabled', 'true');
+    };
+    var ariaEnable = function (component) {
+      set$8(component.element, 'aria-disabled', 'false');
+    };
+    var disable = function (component, disableConfig, _disableState) {
+      disableConfig.disableClass.each(function (disableClass) {
+        add$1(component.element, disableClass);
+      });
+      var f = hasNative(component, disableConfig) ? nativeDisable : ariaDisable;
+      f(component);
+      disableConfig.onDisabled(component);
+    };
+    var enable = function (component, disableConfig, _disableState) {
+      disableConfig.disableClass.each(function (disableClass) {
+        remove$3(component.element, disableClass);
+      });
+      var f = hasNative(component, disableConfig) ? nativeEnable : ariaEnable;
+      f(component);
+      disableConfig.onEnabled(component);
+    };
+    var isDisabled = function (component, disableConfig) {
+      return hasNative(component, disableConfig) ? nativeIsDisabled(component) : ariaIsDisabled(component);
+    };
+    var set$1 = function (component, disableConfig, disableState, disabled) {
+      var f = disabled ? disable : enable;
+      f(component, disableConfig);
+    };
+
+    var DisableApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        enable: enable,
+        disable: disable,
+        isDisabled: isDisabled,
+        onLoad: onLoad,
+        set: set$1
+    });
+
+    var exhibit$1 = function (base, disableConfig) {
+      return nu$3({ classes: disableConfig.disabled() ? disableConfig.disableClass.toArray() : [] });
+    };
+    var events$3 = function (disableConfig, disableState) {
+      return derive$3([
+        abort(execute$5(), function (component, _simulatedEvent) {
+          return isDisabled(component, disableConfig);
+        }),
+        loadEvent(disableConfig, disableState, onLoad)
+      ]);
+    };
+
+    var ActiveDisable = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit$1,
+        events: events$3
+    });
+
+    var DisableSchema = [
+      defaultedFunction('disabled', never),
+      defaulted('useNative', true),
+      option('disableClass'),
+      onHandler('onDisabled'),
+      onHandler('onEnabled')
+    ];
+
+    var Disabling = create$5({
+      fields: DisableSchema,
+      name: 'disabling',
+      active: ActiveDisable,
+      apis: DisableApis
+    });
+
+    var owner$1 = 'form';
+    var schema$7 = [field$1('formBehaviours', [Representing])];
+    var getPartName = function (name) {
+      return '<alloy.field.' + name + '>';
+    };
+    var sketch$4 = function (fSpec) {
+      var parts = function () {
+        var record = [];
+        var field = function (name, config) {
+          record.push(name);
+          return generateOne(owner$1, getPartName(name), config);
+        };
+        return {
+          field: field,
+          record: constant$1(record)
+        };
+      }();
+      var spec = fSpec(parts);
+      var partNames = parts.record();
+      var fieldParts = map$2(partNames, function (n) {
+        return required({
+          name: n,
+          pname: getPartName(n)
+        });
+      });
+      return composite$1(owner$1, schema$7, fieldParts, make$4, spec);
+    };
+    var toResult = function (o, e) {
+      return o.fold(function () {
+        return Result.error(e);
+      }, Result.value);
+    };
+    var make$4 = function (detail, components) {
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: augment(detail.formBehaviours, [Representing.config({
+            store: {
+              mode: 'manual',
+              getValue: function (form) {
+                var resPs = getAllParts(form, detail);
+                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);
+                });
+              },
+              setValue: function (form, values) {
+                each(values, function (newValue, key) {
+                  getPart(form, detail, key).each(function (wrapper) {
+                    Composing.getCurrent(wrapper).each(function (field) {
+                      Representing.setValue(field, newValue);
+                    });
+                  });
+                });
+              }
+            }
+          })]),
+        apis: {
+          getField: function (form, key) {
+            return getPart(form, detail, key).bind(Composing.getCurrent);
+          }
+        }
+      };
+    };
+    var Form = {
+      getField: makeApi(function (apis, component, key) {
+        return apis.getField(component, key);
+      }),
+      sketch: sketch$4
+    };
+
+    var SWIPING_LEFT = 1;
+    var SWIPING_RIGHT = -1;
+    var SWIPING_NONE = 0;
+    var init$3 = function (xValue) {
+      return {
+        xValue: xValue,
+        points: []
+      };
+    };
+    var move = function (model, xValue) {
+      if (xValue === model.xValue) {
+        return model;
+      }
+      var currentDirection = xValue - model.xValue > 0 ? SWIPING_LEFT : SWIPING_RIGHT;
+      var newPoint = {
+        direction: currentDirection,
+        xValue: xValue
+      };
+      var priorPoints = function () {
+        if (model.points.length === 0) {
+          return [];
+        } else {
+          var prev = model.points[model.points.length - 1];
+          return prev.direction === currentDirection ? model.points.slice(0, model.points.length - 1) : model.points;
+        }
+      }();
+      return {
+        xValue: xValue,
+        points: priorPoints.concat([newPoint])
+      };
+    };
+    var complete = function (model) {
+      if (model.points.length === 0) {
+        return SWIPING_NONE;
+      } else {
+        var firstDirection = model.points[0].direction;
+        var lastDirection = model.points[model.points.length - 1].direction;
+        return firstDirection === SWIPING_RIGHT && lastDirection === SWIPING_RIGHT ? SWIPING_RIGHT : firstDirection === SWIPING_LEFT && lastDirection === SWIPING_LEFT ? SWIPING_LEFT : SWIPING_NONE;
+      }
+    };
+
+    var sketch$3 = function (rawSpec) {
+      var navigateEvent = 'navigateEvent';
+      var wrapperAdhocEvents = 'serializer-wrapper-events';
+      var formAdhocEvents = 'form-events';
+      var schema = objOf([
+        required$1('fields'),
+        defaulted('maxFieldIndex', rawSpec.fields.length - 1),
+        required$1('onExecute'),
+        required$1('getInitialValue'),
+        customField('state', function () {
+          return {
+            dialogSwipeState: value(),
+            currentScreen: Cell(0)
+          };
+        })
+      ]);
+      var spec$1 = asRawOrDie$1('SerialisedDialog', schema, rawSpec);
+      var navigationButton = function (direction, directionName, enabled) {
+        return Button.sketch({
+          dom: dom$1('<span class="${prefix}-icon-' + directionName + ' ${prefix}-icon"></span>'),
+          action: function (button) {
+            emitWith(button, navigateEvent, { direction: direction });
+          },
+          buttonBehaviours: derive$2([Disabling.config({
+              disableClass: resolve('toolbar-navigation-disabled'),
+              disabled: function () {
+                return !enabled;
+              }
+            })])
+        });
+      };
+      var reposition = function (dialog, message) {
+        descendant(dialog.element, '.' + resolve('serialised-dialog-chain')).each(function (parent) {
+          set$5(parent, 'left', -spec$1.state.currentScreen.get() * message.width + 'px');
+        });
+      };
+      var navigate = function (dialog, direction) {
+        var screens = descendants(dialog.element, '.' + resolve('serialised-dialog-screen'));
+        descendant(dialog.element, '.' + resolve('serialised-dialog-chain')).each(function (parent) {
+          if (spec$1.state.currentScreen.get() + direction >= 0 && spec$1.state.currentScreen.get() + direction < screens.length) {
+            getRaw(parent, 'left').each(function (left) {
+              var currentLeft = parseInt(left, 10);
+              var w = get$5(screens[0]);
+              set$5(parent, 'left', currentLeft - direction * w + 'px');
+            });
+            spec$1.state.currentScreen.set(spec$1.state.currentScreen.get() + direction);
+          }
+        });
+      };
+      var focusInput = function (dialog) {
+        var inputs = descendants(dialog.element, 'input');
+        var optInput = Optional.from(inputs[spec$1.state.currentScreen.get()]);
+        optInput.each(function (input) {
+          dialog.getSystem().getByDom(input).each(function (inputComp) {
+            dispatchFocus(dialog, inputComp.element);
+          });
+        });
+        var dotitems = memDots.get(dialog);
+        Highlighting.highlightAt(dotitems, spec$1.state.currentScreen.get());
+      };
+      var resetState = function () {
+        spec$1.state.currentScreen.set(0);
+        spec$1.state.dialogSwipeState.clear();
+      };
+      var memForm = record(Form.sketch(function (parts) {
+        return {
+          dom: dom$1('<div class="${prefix}-serialised-dialog"></div>'),
+          components: [Container.sketch({
+              dom: dom$1('<div class="${prefix}-serialised-dialog-chain" style="left: 0px; position: absolute;"></div>'),
+              components: map$2(spec$1.fields, function (field, i) {
+                return i <= spec$1.maxFieldIndex ? Container.sketch({
+                  dom: dom$1('<div class="${prefix}-serialised-dialog-screen"></div>'),
+                  components: [
+                    navigationButton(-1, 'previous', i > 0),
+                    parts.field(field.name, field.spec),
+                    navigationButton(+1, 'next', i < spec$1.maxFieldIndex)
+                  ]
+                }) : parts.field(field.name, field.spec);
+              })
+            })],
+          formBehaviours: derive$2([
+            orientation(function (dialog, message) {
+              reposition(dialog, message);
+            }),
+            Keying.config({
+              mode: 'special',
+              focusIn: function (dialog, _specialInfo) {
+                focusInput(dialog);
+              },
+              onTab: function (dialog, _specialInfo) {
+                navigate(dialog, +1);
+                return Optional.some(true);
+              },
+              onShiftTab: function (dialog, _specialInfo) {
+                navigate(dialog, -1);
+                return Optional.some(true);
+              }
+            }),
+            config(formAdhocEvents, [
+              runOnAttached(function (dialog, _simulatedEvent) {
+                resetState();
+                var dotitems = memDots.get(dialog);
+                Highlighting.highlightFirst(dotitems);
+                spec$1.getInitialValue(dialog).each(function (v) {
+                  Representing.setValue(dialog, v);
+                });
+              }),
+              runOnExecute(spec$1.onExecute),
+              run(transitionend(), function (dialog, simulatedEvent) {
+                var event = simulatedEvent.event;
+                if (event.raw.propertyName === 'left') {
+                  focusInput(dialog);
+                }
+              }),
+              run(navigateEvent, function (dialog, simulatedEvent) {
+                var event = simulatedEvent.event;
+                var direction = event.direction;
+                navigate(dialog, direction);
+              })
+            ])
+          ])
+        };
+      }));
+      var memDots = record({
+        dom: dom$1('<div class="${prefix}-dot-container"></div>'),
+        behaviours: derive$2([Highlighting.config({
+            highlightClass: resolve('dot-active'),
+            itemClass: resolve('dot-item')
+          })]),
+        components: bind$3(spec$1.fields, function (_f, i) {
+          return i <= spec$1.maxFieldIndex ? [spec('<div class="${prefix}-dot-item ${prefix}-icon-full-dot ${prefix}-icon"></div>')] : [];
+        })
+      });
+      return {
+        dom: dom$1('<div class="${prefix}-serializer-wrapper"></div>'),
+        components: [
+          memForm.asSpec(),
+          memDots.asSpec()
+        ],
+        behaviours: derive$2([
+          Keying.config({
+            mode: 'special',
+            focusIn: function (wrapper) {
+              var form = memForm.get(wrapper);
+              Keying.focusIn(form);
+            }
+          }),
+          config(wrapperAdhocEvents, [
+            run(touchstart(), function (_wrapper, simulatedEvent) {
+              var event = simulatedEvent.event;
+              spec$1.state.dialogSwipeState.set(init$3(event.raw.touches[0].clientX));
+            }),
+            run(touchmove(), function (_wrapper, simulatedEvent) {
+              var event = simulatedEvent.event;
+              spec$1.state.dialogSwipeState.on(function (state) {
+                simulatedEvent.event.prevent();
+                spec$1.state.dialogSwipeState.set(move(state, event.raw.touches[0].clientX));
+              });
+            }),
+            run(touchend(), function (wrapper, _simulatedEvent) {
+              spec$1.state.dialogSwipeState.on(function (state) {
+                var dialog = memForm.get(wrapper);
+                var direction = -1 * complete(state);
+                navigate(dialog, direction);
+              });
+            })
+          ])
+        ])
+      };
+    };
+
+    var getGroups = cached(function (realm, editor) {
+      return [{
+          label: 'the link group',
+          items: [sketch$3({
+              fields: [
+                field('url', 'Type or paste URL'),
+                field('text', 'Link text'),
+                field('title', 'Link title'),
+                field('target', 'Link target'),
+                hidden('link')
+              ],
+              maxFieldIndex: [
+                'url',
+                'text',
+                'title',
+                'target'
+              ].length - 1,
+              getInitialValue: function () {
+                return Optional.some(getInfo(editor));
+              },
+              onExecute: function (dialog, _simulatedEvent) {
+                var info = Representing.getValue(dialog);
+                applyInfo(editor, info);
+                realm.restoreToolbar();
+                editor.focus();
+              }
+            })]
+        }];
+    });
+    var sketch$2 = function (realm, editor) {
+      return forToolbarStateAction(editor, 'link', 'link', function () {
+        var groups = getGroups(realm, editor);
+        realm.setContextToolbar(groups);
+        forAndroid(editor, function () {
+          realm.focusToolbar();
+        });
+        query(editor).each(function (link) {
+          editor.selection.select(link.dom);
+        });
+      });
+    };
+
+    var isRecursive = function (component, originator, target) {
+      return eq(originator, component.element) && !eq(originator, target);
+    };
+    var events$2 = derive$3([can(focus$4(), function (component, simulatedEvent) {
+        var event = simulatedEvent.event;
+        var originator = event.originator;
+        var target = event.target;
+        if (isRecursive(component, originator, target)) {
+          console.warn(focus$4() + ' did not get interpreted by the desired target. ' + '\nOriginator: ' + element(originator) + '\nTarget: ' + element(target) + '\nCheck the ' + focus$4() + ' event handlers');
+          return false;
+        } else {
+          return true;
+        }
+      })]);
+
+    var DefaultEvents = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$2
+    });
+
+    var make$3 = identity;
+
+    var NoContextApi = function (getComp) {
+      var getMessage = function (event) {
+        return 'The component must be in a context to execute: ' + event + (getComp ? '\n' + element(getComp().element) + ' is not in context.' : '');
+      };
+      var fail = function (event) {
+        return function () {
+          throw new Error(getMessage(event));
+        };
+      };
+      var warn = function (event) {
+        return function () {
+          console.warn(getMessage(event));
+        };
+      };
+      return {
+        debugInfo: constant$1('fake'),
+        triggerEvent: warn('triggerEvent'),
+        triggerFocus: warn('triggerFocus'),
+        triggerEscape: warn('triggerEscape'),
+        broadcast: warn('broadcast'),
+        broadcastOn: warn('broadcastOn'),
+        broadcastEvent: warn('broadcastEvent'),
+        build: fail('build'),
+        addToWorld: fail('addToWorld'),
+        removeFromWorld: fail('removeFromWorld'),
+        addToGui: fail('addToGui'),
+        removeFromGui: fail('removeFromGui'),
+        getByUid: fail('getByUid'),
+        getByDom: fail('getByDom'),
+        isConnected: never
+      };
+    };
+    var singleton = NoContextApi();
+
+    var generateFrom$1 = function (spec, all) {
+      var schema = map$2(all, function (a) {
+        return optionObjOf(a.name(), [
+          required$1('config'),
+          defaulted('state', NoState)
+        ]);
+      });
+      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);
+      return {
+        list: all,
+        data: map$1(validated, function (optBlobThunk) {
+          var output = optBlobThunk.map(function (blob) {
+            return {
+              config: blob.config,
+              state: blob.state.init(blob.config)
+            };
+          });
+          return constant$1(output);
+        })
+      };
+    };
+    var getBehaviours$1 = function (bData) {
+      return bData.list;
+    };
+    var getData = function (bData) {
+      return bData.data;
+    };
+
+    var byInnerKey = function (data, tuple) {
+      var r = {};
+      each(data, function (detail, key) {
+        each(detail, function (value, indexKey) {
+          var chain = get$c(r, indexKey).getOr([]);
+          r[indexKey] = chain.concat([tuple(key, value)]);
+        });
+      });
+      return r;
+    };
+
+    var combine$1 = function (info, baseMod, behaviours, base) {
+      var modsByBehaviour = __assign({}, baseMod);
+      each$1(behaviours, function (behaviour) {
+        modsByBehaviour[behaviour.name()] = behaviour.exhibit(info, base);
+      });
+      var byAspect = byInnerKey(modsByBehaviour, function (name, modification) {
+        return {
+          name: name,
+          modification: modification
+        };
+      });
+      var combineObjects = function (objects) {
+        return foldr(objects, function (b, a) {
+          return __assign(__assign({}, a.modification), b);
+        }, {});
+      };
+      var combinedClasses = foldr(byAspect.classes, function (b, a) {
+        return a.modification.concat(b);
+      }, []);
+      var combinedAttributes = combineObjects(byAspect.attributes);
+      var combinedStyles = combineObjects(byAspect.styles);
+      return nu$3({
+        classes: combinedClasses,
+        attributes: combinedAttributes,
+        styles: combinedStyles
+      });
+    };
+
+    var sortKeys = function (label, keyName, array, order) {
+      try {
+        var sorted = sort(array, function (a, b) {
+          var aKey = a[keyName];
+          var bKey = b[keyName];
+          var aIndex = order.indexOf(aKey);
+          var bIndex = order.indexOf(bKey);
+          if (aIndex === -1) {
+            throw new Error('The ordering for ' + label + ' does not have an entry for ' + aKey + '.\nOrder specified: ' + JSON.stringify(order, null, 2));
+          }
+          if (bIndex === -1) {
+            throw new Error('The ordering for ' + label + ' does not have an entry for ' + bKey + '.\nOrder specified: ' + JSON.stringify(order, null, 2));
+          }
+          if (aIndex < bIndex) {
+            return -1;
+          } else if (bIndex < aIndex) {
+            return 1;
+          } else {
+            return 0;
+          }
+        });
+        return Result.value(sorted);
+      } catch (err) {
+        return Result.error([err]);
+      }
+    };
+
+    var uncurried = function (handler, purpose) {
+      return {
+        handler: handler,
+        purpose: purpose
+      };
+    };
+    var curried = function (handler, purpose) {
+      return {
+        cHandler: handler,
+        purpose: purpose
+      };
+    };
+    var curryArgs = function (descHandler, extraArgs) {
+      return curried(curry.apply(undefined, [descHandler.handler].concat(extraArgs)), descHandler.purpose);
+    };
+    var getCurried = function (descHandler) {
+      return descHandler.cHandler;
+    };
+
+    var behaviourTuple = function (name, handler) {
+      return {
+        name: name,
+        handler: handler
+      };
+    };
+    var nameToHandlers = function (behaviours, info) {
+      var r = {};
+      each$1(behaviours, function (behaviour) {
+        r[behaviour.name()] = behaviour.handlers(info);
+      });
+      return r;
+    };
+    var groupByEvents = function (info, behaviours, base) {
+      var behaviourEvents = __assign(__assign({}, base), nameToHandlers(behaviours, info));
+      return byInnerKey(behaviourEvents, behaviourTuple);
+    };
+    var combine = function (info, eventOrder, behaviours, base) {
+      var byEventName = groupByEvents(info, behaviours, base);
+      return combineGroups(byEventName, eventOrder);
+    };
+    var assemble = function (rawHandler) {
+      var handler = read$1(rawHandler);
+      return function (component, simulatedEvent) {
+        var rest = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+          rest[_i - 2] = arguments[_i];
+        }
+        var args = [
+          component,
+          simulatedEvent
+        ].concat(rest);
+        if (handler.abort.apply(undefined, args)) {
+          simulatedEvent.stop();
+        } else if (handler.can.apply(undefined, args)) {
+          handler.run.apply(undefined, args);
+        }
+      };
+    };
+    var missingOrderError = function (eventName, tuples) {
+      return Result.error(['The event (' + eventName + ') has more than one behaviour that listens to it.\nWhen this occurs, you must ' + 'specify an event ordering for the behaviours in your spec (e.g. [ "listing", "toggling" ]).\nThe behaviours that ' + 'can trigger it are: ' + JSON.stringify(map$2(tuples, function (c) {
+          return c.name;
+        }), null, 2)]);
+    };
+    var fuse = function (tuples, eventOrder, eventName) {
+      var order = eventOrder[eventName];
+      if (!order) {
+        return missingOrderError(eventName, tuples);
+      } else {
+        return sortKeys('Event: ' + eventName, 'name', tuples, order).map(function (sortedTuples) {
+          var handlers = map$2(sortedTuples, function (tuple) {
+            return tuple.handler;
+          });
+          return fuse$1(handlers);
+        });
+      }
+    };
+    var combineGroups = function (byEventName, eventOrder) {
+      var r = mapToArray(byEventName, function (tuples, eventName) {
+        var combined = tuples.length === 1 ? Result.value(tuples[0].handler) : fuse(tuples, eventOrder, eventName);
+        return combined.map(function (handler) {
+          var assembled = assemble(handler);
+          var purpose = tuples.length > 1 ? filter$2(eventOrder[eventName], function (o) {
+            return exists(tuples, function (t) {
+              return t.name === o;
+            });
+          }).join(' > ') : tuples[0].name;
+          return wrap(eventName, uncurried(assembled, purpose));
+        });
+      });
+      return consolidate(r, {});
+    };
+
+    var _a;
+    var baseBehaviour = 'alloy.base.behaviour';
+    var schema$6 = objOf([
+      field$2('dom', 'dom', required$2(), objOf([
+        required$1('tag'),
+        defaulted('styles', {}),
+        defaulted('classes', []),
+        defaulted('attributes', {}),
+        option('value'),
+        option('innerHtml')
+      ])),
+      required$1('components'),
+      required$1('uid'),
+      defaulted('events', {}),
+      defaulted('apis', {}),
+      field$2('eventOrder', 'eventOrder', mergeWith((_a = {}, _a[execute$5()] = [
+        'disabling',
+        baseBehaviour,
+        'toggling',
+        'typeaheadevents'
+      ], _a[focus$4()] = [
+        baseBehaviour,
+        'focusing',
+        'keying'
+      ], _a[systemInit()] = [
+        baseBehaviour,
+        'disabling',
+        'toggling',
+        'representing'
+      ], _a[input$1()] = [
+        baseBehaviour,
+        'representing',
+        'streaming',
+        'invalidating'
+      ], _a[detachedFromDom()] = [
+        baseBehaviour,
+        'representing',
+        'item-events',
+        'tooltipping'
+      ], _a[mousedown()] = [
+        'focusing',
+        baseBehaviour,
+        'item-type-events'
+      ], _a[touchstart()] = [
+        'focusing',
+        baseBehaviour,
+        'item-type-events'
+      ], _a[mouseover()] = [
+        'item-type-events',
+        'tooltipping'
+      ], _a[receive$1()] = [
+        'receiving',
+        'reflecting',
+        'tooltipping'
+      ], _a)), anyValue()),
+      option('domModification')
+    ]);
+    var toInfo = function (spec) {
+      return asRaw('custom.definition', schema$6, spec);
+    };
+    var toDefinition = function (detail) {
+      return __assign(__assign({}, detail.dom), {
+        uid: detail.uid,
+        domChildren: map$2(detail.components, function (comp) {
+          return comp.element;
+        })
+      });
+    };
+    var toModification = function (detail) {
+      return detail.domModification.fold(function () {
+        return nu$3({});
+      }, nu$3);
+    };
+    var toEvents = function (info) {
+      return info.events;
+    };
+
+    var add = function (element, classes) {
+      each$1(classes, function (x) {
+        add$1(element, x);
+      });
+    };
+    var remove$1 = function (element, classes) {
+      each$1(classes, function (x) {
+        remove$3(element, x);
+      });
+    };
+
+    var renderToDom = function (definition) {
+      var subject = SugarElement.fromTag(definition.tag);
+      setAll$1(subject, definition.attributes);
+      add(subject, definition.classes);
+      setAll(subject, definition.styles);
+      definition.innerHtml.each(function (html) {
+        return set$7(subject, html);
+      });
+      var children = definition.domChildren;
+      append$1(subject, children);
+      definition.value.each(function (value) {
+        set$2(subject, value);
+      });
+      if (!definition.uid) {
+        debugger;
+      }
+      writeOnly(subject, definition.uid);
+      return subject;
+    };
+
+    var getBehaviours = function (spec) {
+      var behaviours = get$c(spec, 'behaviours').getOr({});
+      return bind$3(keys(behaviours), function (name) {
+        var behaviour = behaviours[name];
+        return isNonNullable(behaviour) ? [behaviour.me] : [];
+      });
+    };
+    var generateFrom = function (spec, all) {
+      return generateFrom$1(spec, all);
+    };
+    var generate$1 = function (spec) {
+      var all = getBehaviours(spec);
+      return generateFrom(spec, all);
+    };
+
+    var getDomDefinition = function (info, bList, bData) {
+      var definition = toDefinition(info);
+      var infoModification = toModification(info);
+      var baseModification = { 'alloy.base.modification': infoModification };
+      var modification = bList.length > 0 ? combine$1(bData, baseModification, bList, definition) : infoModification;
+      return merge(definition, modification);
+    };
+    var getEvents = function (info, bList, bData) {
+      var baseEvents = { 'alloy.base.behaviour': toEvents(info) };
+      return combine(bData, info.eventOrder, bList, baseEvents).getOrDie();
+    };
+    var build$2 = function (spec) {
+      var getMe = function () {
+        return me;
+      };
+      var systemApi = Cell(singleton);
+      var info = getOrDie(toInfo(spec));
+      var bBlob = generate$1(spec);
+      var bList = getBehaviours$1(bBlob);
+      var bData = getData(bBlob);
+      var modDefinition = getDomDefinition(info, bList, bData);
+      var item = renderToDom(modDefinition);
+      var events = getEvents(info, bList, bData);
+      var subcomponents = Cell(info.components);
+      var connect = function (newApi) {
+        systemApi.set(newApi);
+      };
+      var disconnect = function () {
+        systemApi.set(NoContextApi(getMe));
+      };
+      var syncComponents = function () {
+        var children$1 = children(item);
+        var subs = bind$3(children$1, function (child) {
+          return systemApi.get().getByDom(child).fold(function () {
+            return [];
+          }, pure$2);
+        });
+        subcomponents.set(subs);
+      };
+      var config = function (behaviour) {
+        var b = bData;
+        var f = isFunction(b[behaviour.name()]) ? b[behaviour.name()] : function () {
+          throw new Error('Could not find ' + behaviour.name() + ' in ' + JSON.stringify(spec, null, 2));
+        };
+        return f();
+      };
+      var hasConfigured = function (behaviour) {
+        return isFunction(bData[behaviour.name()]);
+      };
+      var getApis = function () {
+        return info.apis;
+      };
+      var readState = function (behaviourName) {
+        return bData[behaviourName]().map(function (b) {
+          return b.state.readState();
+        }).getOr('not enabled');
+      };
+      var me = {
+        uid: spec.uid,
+        getSystem: systemApi.get,
+        config: config,
+        hasConfigured: hasConfigured,
+        spec: spec,
+        readState: readState,
+        getApis: getApis,
+        connect: connect,
+        disconnect: disconnect,
+        element: item,
+        syncComponents: syncComponents,
+        components: subcomponents.get,
+        events: events
+      };
+      return me;
+    };
+
+    var buildSubcomponents = function (spec) {
+      var components = get$c(spec, 'components').getOr([]);
+      return map$2(components, build$1);
+    };
+    var buildFromSpec = function (userSpec) {
+      var _a = make$3(userSpec), specEvents = _a.events, spec = __rest(_a, ['events']);
+      var components = buildSubcomponents(spec);
+      var completeSpec = __assign(__assign({}, spec), {
+        events: __assign(__assign({}, DefaultEvents), specEvents),
+        components: components
+      });
+      return Result.value(build$2(completeSpec));
+    };
+    var text = function (textContent) {
+      var element = SugarElement.fromText(textContent);
+      return external({ element: element });
+    };
+    var external = function (spec) {
+      var extSpec = asRawOrDie$1('external.component', objOfOnly([
+        required$1('element'),
+        option('uid')
+      ]), spec);
+      var systemApi = Cell(NoContextApi());
+      var connect = function (newApi) {
+        systemApi.set(newApi);
+      };
+      var disconnect = function () {
+        systemApi.set(NoContextApi(function () {
+          return me;
+        }));
+      };
+      var uid = extSpec.uid.getOrThunk(function () {
+        return generate$2('external');
+      });
+      writeOnly(extSpec.element, uid);
+      var me = {
+        uid: uid,
+        getSystem: systemApi.get,
+        config: Optional.none,
+        hasConfigured: never,
+        connect: connect,
+        disconnect: disconnect,
+        getApis: function () {
+          return {};
+        },
+        element: extSpec.element,
+        spec: spec,
+        readState: constant$1('No state'),
+        syncComponents: noop,
+        components: constant$1([]),
+        events: {}
+      };
+      return premade$1(me);
+    };
+    var uids = generate$2;
+    var isSketchSpec = function (spec) {
+      return has$2(spec, 'uid');
+    };
+    var build$1 = function (spec) {
+      return getPremade(spec).getOrThunk(function () {
+        var userSpecWithUid = isSketchSpec(spec) ? spec : __assign({ uid: uids('') }, spec);
+        return buildFromSpec(userSpecWithUid).getOrDie();
+      });
+    };
+    var premade = premade$1;
+
+    var hoverEvent = 'alloy.item-hover';
+    var focusEvent = 'alloy.item-focus';
+    var onHover = function (item) {
+      if (search(item.element).isNone() || Focusing.isFocused(item)) {
+        if (!Focusing.isFocused(item)) {
+          Focusing.focus(item);
+        }
+        emitWith(item, hoverEvent, { item: item });
+      }
+    };
+    var onFocus = function (item) {
+      emitWith(item, focusEvent, { item: item });
+    };
+    var hover = constant$1(hoverEvent);
+    var focus$1 = constant$1(focusEvent);
+
+    var builder$2 = function (detail) {
+      return {
+        dom: detail.dom,
+        domModification: __assign(__assign({}, detail.domModification), { attributes: __assign(__assign(__assign({ 'role': detail.toggling.isSome() ? 'menuitemcheckbox' : 'menuitem' }, detail.domModification.attributes), { 'aria-haspopup': detail.hasSubmenu }), detail.hasSubmenu ? { 'aria-expanded': false } : {}) }),
+        behaviours: SketchBehaviours.augment(detail.itemBehaviours, [
+          detail.toggling.fold(Toggling.revoke, function (tConfig) {
+            return Toggling.config(__assign({ aria: { mode: 'checked' } }, tConfig));
+          }),
+          Focusing.config({
+            ignore: detail.ignoreFocus,
+            stopMousedown: detail.ignoreFocus,
+            onFocus: function (component) {
+              onFocus(component);
+            }
+          }),
+          Keying.config({ mode: 'execution' }),
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: detail.data
+            }
+          }),
+          config('item-type-events', __spreadArray(__spreadArray([], pointerEvents(), true), [
+            run(mouseover(), onHover),
+            run(focusItem(), Focusing.focus)
+          ], false))
+        ]),
+        components: detail.components,
+        eventOrder: detail.eventOrder
+      };
+    };
+    var schema$5 = [
+      required$1('data'),
+      required$1('components'),
+      required$1('dom'),
+      defaulted('hasSubmenu', false),
+      option('toggling'),
+      SketchBehaviours.field('itemBehaviours', [
+        Toggling,
+        Focusing,
+        Keying,
+        Representing
+      ]),
+      defaulted('ignoreFocus', false),
+      defaulted('domModification', {}),
+      output('builder', builder$2),
+      defaulted('eventOrder', {})
+    ];
+
+    var builder$1 = function (detail) {
+      return {
+        dom: detail.dom,
+        components: detail.components,
+        events: derive$3([stopper(focusItem())])
+      };
+    };
+    var schema$4 = [
+      required$1('dom'),
+      required$1('components'),
+      output('builder', builder$1)
+    ];
+
+    var owner = constant$1('item-widget');
+    var parts$3 = constant$1([required({
+        name: 'widget',
+        overrides: function (detail) {
+          return {
+            behaviours: derive$2([Representing.config({
+                store: {
+                  mode: 'manual',
+                  getValue: function (_component) {
+                    return detail.data;
+                  },
+                  setValue: noop
+                }
+              })])
+          };
+        }
+      })]);
+
+    var builder = function (detail) {
+      var subs = substitutes(owner(), detail, parts$3());
+      var components$1 = components(owner(), detail, subs.internals());
+      var focusWidget = function (component) {
+        return getPart(component, detail, 'widget').map(function (widget) {
+          Keying.focusIn(widget);
+          return widget;
+        });
+      };
+      var onHorizontalArrow = function (component, simulatedEvent) {
+        return inside(simulatedEvent.event.target) ? Optional.none() : function () {
+          if (detail.autofocus) {
+            simulatedEvent.setSource(component.element);
+            return Optional.none();
+          } else {
+            return Optional.none();
+          }
+        }();
+      };
+      return {
+        dom: detail.dom,
+        components: components$1,
+        domModification: detail.domModification,
+        events: derive$3([
+          runOnExecute(function (component, simulatedEvent) {
+            focusWidget(component).each(function (_widget) {
+              simulatedEvent.stop();
+            });
+          }),
+          run(mouseover(), onHover),
+          run(focusItem(), function (component, _simulatedEvent) {
+            if (detail.autofocus) {
+              focusWidget(component);
+            } else {
+              Focusing.focus(component);
+            }
+          })
+        ]),
+        behaviours: SketchBehaviours.augment(detail.widgetBehaviours, [
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: detail.data
+            }
+          }),
+          Focusing.config({
+            ignore: detail.ignoreFocus,
+            onFocus: function (component) {
+              onFocus(component);
+            }
+          }),
+          Keying.config({
+            mode: 'special',
+            focusIn: detail.autofocus ? function (component) {
+              focusWidget(component);
+            } : revoke(),
+            onLeft: onHorizontalArrow,
+            onRight: onHorizontalArrow,
+            onEscape: function (component, simulatedEvent) {
+              if (!Focusing.isFocused(component) && !detail.autofocus) {
+                Focusing.focus(component);
+                return Optional.some(true);
+              } else if (detail.autofocus) {
+                simulatedEvent.setSource(component.element);
+                return Optional.none();
+              } else {
+                return Optional.none();
+              }
+            }
+          })
+        ])
+      };
+    };
+    var schema$3 = [
+      required$1('uid'),
+      required$1('data'),
+      required$1('components'),
+      required$1('dom'),
+      defaulted('autofocus', false),
+      defaulted('ignoreFocus', false),
+      SketchBehaviours.field('widgetBehaviours', [
+        Representing,
+        Focusing,
+        Keying
+      ]),
+      defaulted('domModification', {}),
+      defaultUidsSchema(parts$3()),
+      output('builder', builder)
+    ];
+
+    var itemSchema = choose$1('type', {
+      widget: schema$3,
+      item: schema$5,
+      separator: schema$4
+    });
+    var configureGrid = function (detail, movementInfo) {
+      return {
+        mode: 'flatgrid',
+        selector: '.' + detail.markers.item,
+        initSize: {
+          numColumns: movementInfo.initSize.numColumns,
+          numRows: movementInfo.initSize.numRows
+        },
+        focusManager: detail.focusManager
+      };
+    };
+    var configureMatrix = function (detail, movementInfo) {
+      return {
+        mode: 'matrix',
+        selectors: {
+          row: movementInfo.rowSelector,
+          cell: '.' + detail.markers.item
+        },
+        focusManager: detail.focusManager
+      };
+    };
+    var configureMenu = function (detail, movementInfo) {
+      return {
+        mode: 'menu',
+        selector: '.' + detail.markers.item,
+        moveOnTab: movementInfo.moveOnTab,
+        focusManager: detail.focusManager
+      };
+    };
+    var parts$2 = constant$1([group({
+        factory: {
+          sketch: function (spec) {
+            var itemInfo = asRawOrDie$1('menu.spec item', itemSchema, spec);
+            return itemInfo.builder(itemInfo);
+          }
+        },
+        name: 'items',
+        unit: 'item',
+        defaults: function (detail, u) {
+          return has$2(u, 'uid') ? u : __assign(__assign({}, u), { uid: generate$2('item') });
+        },
+        overrides: function (detail, u) {
+          return {
+            type: u.type,
+            ignoreFocus: detail.fakeFocus,
+            domModification: { classes: [detail.markers.item] }
+          };
+        }
+      })]);
+    var schema$2 = constant$1([
+      required$1('value'),
+      required$1('items'),
+      required$1('dom'),
+      required$1('components'),
+      defaulted('eventOrder', {}),
+      field$1('menuBehaviours', [
+        Highlighting,
+        Representing,
+        Composing,
+        Keying
+      ]),
+      defaultedOf('movement', {
+        mode: 'menu',
+        moveOnTab: true
+      }, choose$1('mode', {
+        grid: [
+          initSize(),
+          output('config', configureGrid)
+        ],
+        matrix: [
+          output('config', configureMatrix),
+          required$1('rowSelector')
+        ],
+        menu: [
+          defaulted('moveOnTab', true),
+          output('config', configureMenu)
+        ]
+      })),
+      itemMarkers(),
+      defaulted('fakeFocus', false),
+      defaulted('focusManager', dom$2()),
+      onHandler('onHighlight')
+    ]);
+
+    var focus = constant$1('alloy.menu-focus');
+
+    var make$2 = function (detail, components, _spec, _externals) {
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        markers: detail.markers,
+        behaviours: augment(detail.menuBehaviours, [
+          Highlighting.config({
+            highlightClass: detail.markers.selectedItem,
+            itemClass: detail.markers.item,
+            onHighlight: detail.onHighlight
+          }),
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: detail.value
+            }
+          }),
+          Composing.config({ find: Optional.some }),
+          Keying.config(detail.movement.config(detail, detail.movement))
+        ]),
+        events: derive$3([
+          run(focus$1(), function (menu, simulatedEvent) {
+            var event = simulatedEvent.event;
+            menu.getSystem().getByDom(event.target).each(function (item) {
+              Highlighting.highlight(menu, item);
+              simulatedEvent.stop();
+              emitWith(menu, focus(), {
+                menu: menu,
+                item: item
+              });
+            });
+          }),
+          run(hover(), function (menu, simulatedEvent) {
+            var item = simulatedEvent.event.item;
+            Highlighting.highlight(menu, item);
+          })
+        ]),
+        components: components,
+        eventOrder: detail.eventOrder,
+        domModification: { attributes: { role: 'menu' } }
+      };
+    };
+
+    var Menu = composite({
+      name: 'Menu',
+      configFields: schema$2(),
+      partFields: parts$2(),
+      factory: make$2
+    });
+
+    var preserve = function (f, container) {
+      var dos = getRootNode(container);
+      var refocus = active(dos).bind(function (focused) {
+        var hasFocus = function (elem) {
+          return eq(focused, elem);
+        };
+        return hasFocus(container) ? Optional.some(container) : descendant$1(container, hasFocus);
+      });
+      var result = f(container);
+      refocus.each(function (oldFocus) {
+        active(dos).filter(function (newFocus) {
+          return eq(newFocus, oldFocus);
+        }).fold(function () {
+          focus$3(oldFocus);
+        }, noop);
+      });
+      return result;
+    };
+
+    var set = function (component, replaceConfig, replaceState, data) {
+      preserve(function () {
+        var newChildren = map$2(data, component.getSystem().build);
+        replaceChildren(component, newChildren);
+      }, component.element);
+    };
+    var insert = function (component, replaceConfig, insertion, childSpec) {
+      var child = component.getSystem().build(childSpec);
+      attachWith(component, child, insertion);
+    };
+    var append = function (component, replaceConfig, replaceState, appendee) {
+      insert(component, replaceConfig, append$2, appendee);
+    };
+    var prepend = function (component, replaceConfig, replaceState, prependee) {
+      insert(component, replaceConfig, prepend$1, prependee);
+    };
+    var remove = function (component, replaceConfig, replaceState, removee) {
+      var children = contents(component);
+      var foundChild = find$2(children, function (child) {
+        return eq(removee.element, child.element);
+      });
+      foundChild.each(detach);
+    };
+    var contents = function (component, _replaceConfig) {
+      return component.components();
+    };
+    var replaceAt = function (component, replaceConfig, replaceState, replaceeIndex, replacer) {
+      var children = contents(component);
+      return Optional.from(children[replaceeIndex]).map(function (replacee) {
+        remove(component, replaceConfig, replaceState, replacee);
+        replacer.each(function (r) {
+          insert(component, replaceConfig, function (p, c) {
+            appendAt(p, c, replaceeIndex);
+          }, r);
+        });
+        return replacee;
+      });
+    };
+    var replaceBy = function (component, replaceConfig, replaceState, replaceePred, replacer) {
+      var children = contents(component);
+      return findIndex$1(children, replaceePred).bind(function (replaceeIndex) {
+        return replaceAt(component, replaceConfig, replaceState, replaceeIndex, replacer);
+      });
+    };
+
+    var ReplaceApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        append: append,
+        prepend: prepend,
+        remove: remove,
+        replaceAt: replaceAt,
+        replaceBy: replaceBy,
+        set: set,
+        contents: contents
+    });
+
+    var Replacing = create$5({
+      fields: [],
+      name: 'replacing',
+      apis: ReplaceApis
+    });
+
+    var transpose = function (obj) {
+      return tupleMap(obj, function (v, k) {
+        return {
+          k: v,
+          v: k
+        };
+      });
+    };
+    var trace = function (items, byItem, byMenu, finish) {
+      return get$c(byMenu, finish).bind(function (triggerItem) {
+        return get$c(items, triggerItem).bind(function (triggerMenu) {
+          var rest = trace(items, byItem, byMenu, triggerMenu);
+          return Optional.some([triggerMenu].concat(rest));
+        });
+      }).getOr([]);
+    };
+    var generate = function (menus, expansions) {
+      var items = {};
+      each(menus, function (menuItems, menu) {
+        each$1(menuItems, function (item) {
+          items[item] = menu;
+        });
+      });
+      var byItem = expansions;
+      var byMenu = transpose(expansions);
+      var menuPaths = map$1(byMenu, function (_triggerItem, submenu) {
+        return [submenu].concat(trace(items, byItem, byMenu, submenu));
+      });
+      return map$1(items, function (menu) {
+        return get$c(menuPaths, menu).getOr([menu]);
+      });
+    };
+
+    var init$2 = function () {
+      var expansions = Cell({});
+      var menus = Cell({});
+      var paths = Cell({});
+      var primary = value();
+      var directory = Cell({});
+      var clear = function () {
+        expansions.set({});
+        menus.set({});
+        paths.set({});
+        primary.clear();
+      };
+      var isClear = function () {
+        return primary.get().isNone();
+      };
+      var setMenuBuilt = function (menuName, built) {
+        var _a;
+        menus.set(__assign(__assign({}, menus.get()), (_a = {}, _a[menuName] = {
+          type: 'prepared',
+          menu: built
+        }, _a)));
+      };
+      var setContents = function (sPrimary, sMenus, sExpansions, dir) {
+        primary.set(sPrimary);
+        expansions.set(sExpansions);
+        menus.set(sMenus);
+        directory.set(dir);
+        var sPaths = generate(dir, sExpansions);
+        paths.set(sPaths);
+      };
+      var getTriggeringItem = function (menuValue) {
+        return find(expansions.get(), function (v, _k) {
+          return v === menuValue;
+        });
+      };
+      var getTriggerData = function (menuValue, getItemByValue, path) {
+        return getPreparedMenu(menuValue).bind(function (menu) {
+          return getTriggeringItem(menuValue).bind(function (triggeringItemValue) {
+            return getItemByValue(triggeringItemValue).map(function (triggeredItem) {
+              return {
+                triggeredMenu: menu,
+                triggeringItem: triggeredItem,
+                triggeringPath: path
+              };
+            });
+          });
+        });
+      };
+      var getTriggeringPath = function (itemValue, getItemByValue) {
+        var extraPath = filter$2(lookupItem(itemValue).toArray(), function (menuValue) {
+          return getPreparedMenu(menuValue).isSome();
+        });
+        return get$c(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()];
+            }, function (data) {
+              return [Optional.some(data)];
+            });
+          });
+          return sequence(triggers);
+        });
+      };
+      var expand = function (itemValue) {
+        return get$c(expansions.get(), itemValue).map(function (menu) {
+          var current = get$c(paths.get(), itemValue).getOr([]);
+          return [menu].concat(current);
+        });
+      };
+      var collapse = function (itemValue) {
+        return get$c(paths.get(), itemValue).bind(function (path) {
+          return path.length > 1 ? Optional.some(path.slice(1)) : Optional.none();
+        });
+      };
+      var refresh = function (itemValue) {
+        return get$c(paths.get(), itemValue);
+      };
+      var getPreparedMenu = function (menuValue) {
+        return lookupMenu(menuValue).bind(extractPreparedMenu);
+      };
+      var lookupMenu = function (menuValue) {
+        return get$c(menus.get(), menuValue);
+      };
+      var lookupItem = function (itemValue) {
+        return get$c(expansions.get(), itemValue);
+      };
+      var otherMenus = function (path) {
+        var menuValues = directory.get();
+        return difference(keys(menuValues), path);
+      };
+      var getPrimary = function () {
+        return primary.get().bind(getPreparedMenu);
+      };
+      var getMenus = function () {
+        return menus.get();
+      };
+      return {
+        setMenuBuilt: setMenuBuilt,
+        setContents: setContents,
+        expand: expand,
+        refresh: refresh,
+        collapse: collapse,
+        lookupMenu: lookupMenu,
+        lookupItem: lookupItem,
+        otherMenus: otherMenus,
+        getPrimary: getPrimary,
+        getMenus: getMenus,
+        clear: clear,
+        isClear: isClear,
+        getTriggeringPath: getTriggeringPath
+      };
+    };
+    var extractPreparedMenu = function (prep) {
+      return prep.type === 'prepared' ? Optional.some(prep.menu) : Optional.none();
+    };
+    var LayeredState = {
+      init: init$2,
+      extractPreparedMenu: extractPreparedMenu
+    };
+
+    var make$1 = function (detail, _rawUiSpec) {
+      var submenuParentItems = value();
+      var buildMenus = function (container, primaryName, menus) {
+        return map$1(menus, function (spec, name) {
+          var makeSketch = function () {
+            return Menu.sketch(__assign(__assign({}, spec), {
+              value: name,
+              markers: detail.markers,
+              fakeFocus: detail.fakeFocus,
+              onHighlight: detail.onHighlight,
+              focusManager: detail.fakeFocus ? highlights() : dom$2()
+            }));
+          };
+          return name === primaryName ? {
+            type: 'prepared',
+            menu: container.getSystem().build(makeSketch())
+          } : {
+            type: 'notbuilt',
+            nbMenu: makeSketch
+          };
+        });
+      };
+      var layeredState = LayeredState.init();
+      var setup = function (container) {
+        var componentMap = buildMenus(container, detail.data.primary, detail.data.menus);
+        var directory = toDirectory();
+        layeredState.setContents(detail.data.primary, componentMap, detail.data.expansions, directory);
+        return layeredState.getPrimary();
+      };
+      var getItemValue = function (item) {
+        return Representing.getValue(item).value;
+      };
+      var getItemByValue = function (_container, menus, itemValue) {
+        return findMap(menus, function (menu) {
+          if (!menu.getSystem().isConnected()) {
+            return Optional.none();
+          }
+          var candidates = Highlighting.getCandidates(menu);
+          return find$2(candidates, function (c) {
+            return getItemValue(c) === itemValue;
+          });
+        });
+      };
+      var toDirectory = function (_container) {
+        return map$1(detail.data.menus, function (data, _menuName) {
+          return bind$3(data.items, function (item) {
+            return item.type === 'separator' ? [] : [item.data.value];
+          });
+        });
+      };
+      var setActiveMenu = function (container, menu) {
+        Highlighting.highlight(container, menu);
+        Highlighting.getHighlighted(menu).orThunk(function () {
+          return Highlighting.getFirst(menu);
+        }).each(function (item) {
+          dispatch(container, item.element, focusItem());
+        });
+      };
+      var getMenus = function (state, menuValues) {
+        return cat(map$2(menuValues, function (mv) {
+          return state.lookupMenu(mv).bind(function (prep) {
+            return prep.type === 'prepared' ? Optional.some(prep.menu) : Optional.none();
+          });
+        }));
+      };
+      var closeOthers = function (container, state, path) {
+        var others = getMenus(state, state.otherMenus(path));
+        each$1(others, function (o) {
+          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$b(i, 'aria-haspopup') === 'true';
+          });
+          each$1(parentItems, function (i) {
+            container.getSystem().getByDom(i).each(function (itemComp) {
+              var key = getItemValue(itemComp);
+              r[key] = itemComp;
+            });
+          });
+          submenuParentItems.set(r);
+          return r;
+        });
+      };
+      var updateAriaExpansions = function (container, path) {
+        var parentItems = getSubmenuParents(container);
+        each(parentItems, function (v, k) {
+          var expanded = contains$1(path, k);
+          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) {
+            if (menuPrep.type === 'notbuilt') {
+              return Optional.none();
+            } else {
+              var activeMenu = menuPrep.menu;
+              var rest = getMenus(state, path.slice(1));
+              each$1(rest, function (r) {
+                add$1(r.element, detail.markers.backgroundMenu);
+              });
+              if (!inBody(activeMenu.element)) {
+                Replacing.append(container, premade(activeMenu));
+              }
+              remove$1(activeMenu.element, [detail.markers.backgroundMenu]);
+              setActiveMenu(container, activeMenu);
+              closeOthers(container, state, path);
+              return Optional.some(activeMenu);
+            }
+          });
+        });
+      };
+      var ExpandHighlightDecision;
+      (function (ExpandHighlightDecision) {
+        ExpandHighlightDecision[ExpandHighlightDecision['HighlightSubmenu'] = 0] = 'HighlightSubmenu';
+        ExpandHighlightDecision[ExpandHighlightDecision['HighlightParent'] = 1] = 'HighlightParent';
+      }(ExpandHighlightDecision || (ExpandHighlightDecision = {})));
+      var buildIfRequired = function (container, menuName, menuPrep) {
+        if (menuPrep.type === 'notbuilt') {
+          var menu = container.getSystem().build(menuPrep.nbMenu());
+          layeredState.setMenuBuilt(menuName, menu);
+          return menu;
+        } else {
+          return menuPrep.menu;
+        }
+      };
+      var expandRight = function (container, item, decision) {
+        if (decision === void 0) {
+          decision = ExpandHighlightDecision.HighlightSubmenu;
+        }
+        if (item.hasConfigured(Disabling) && Disabling.isDisabled(item)) {
+          return Optional.some(item);
+        } else {
+          var value = getItemValue(item);
+          return layeredState.expand(value).bind(function (path) {
+            updateAriaExpansions(container, path);
+            return Optional.from(path[0]).bind(function (menuName) {
+              return layeredState.lookupMenu(menuName).bind(function (activeMenuPrep) {
+                var activeMenu = buildIfRequired(container, menuName, activeMenuPrep);
+                if (!inBody(activeMenu.element)) {
+                  Replacing.append(container, premade(activeMenu));
+                }
+                detail.onOpenSubmenu(container, item, activeMenu, reverse(path));
+                if (decision === ExpandHighlightDecision.HighlightSubmenu) {
+                  Highlighting.highlightFirst(activeMenu);
+                  return updateMenuPath(container, layeredState, path);
+                } else {
+                  Highlighting.dehighlightAll(activeMenu);
+                  return Optional.some(item);
+                }
+              });
+            });
+          });
+        }
+      };
+      var collapseLeft = function (container, item) {
+        var value = getItemValue(item);
+        return layeredState.collapse(value).bind(function (path) {
+          updateAriaExpansions(container, path);
+          return updateMenuPath(container, layeredState, path).map(function (activeMenu) {
+            detail.onCollapseMenu(container, item, activeMenu);
+            return activeMenu;
+          });
+        });
+      };
+      var updateView = function (container, item) {
+        var value = getItemValue(item);
+        return layeredState.refresh(value).bind(function (path) {
+          updateAriaExpansions(container, path);
+          return updateMenuPath(container, layeredState, path);
+        });
+      };
+      var onRight = function (container, item) {
+        return inside(item.element) ? Optional.none() : expandRight(container, item, ExpandHighlightDecision.HighlightSubmenu);
+      };
+      var onLeft = function (container, item) {
+        return inside(item.element) ? Optional.none() : collapseLeft(container, item);
+      };
+      var onEscape = function (container, item) {
+        return collapseLeft(container, item).orThunk(function () {
+          return detail.onEscape(container, item).map(function () {
+            return container;
+          });
+        });
+      };
+      var keyOnItem = function (f) {
+        return function (container, simulatedEvent) {
+          return closest$1(simulatedEvent.getSource(), '.' + detail.markers.item).bind(function (target) {
+            return container.getSystem().getByDom(target).toOptional().bind(function (item) {
+              return f(container, item).map(always);
+            });
+          });
+        };
+      };
+      var events = derive$3([
+        run(focus(), function (sandbox, simulatedEvent) {
+          var item = simulatedEvent.event.item;
+          layeredState.lookupItem(getItemValue(item)).each(function () {
+            var menu = simulatedEvent.event.menu;
+            Highlighting.highlight(sandbox, menu);
+            var value = getItemValue(simulatedEvent.event.item);
+            layeredState.refresh(value).each(function (path) {
+              return closeOthers(sandbox, layeredState, path);
+            });
+          });
+        }),
+        runOnExecute(function (component, simulatedEvent) {
+          var target = simulatedEvent.event.target;
+          component.getSystem().getByDom(target).each(function (item) {
+            var itemValue = getItemValue(item);
+            if (itemValue.indexOf('collapse-item') === 0) {
+              collapseLeft(component, item);
+            }
+            expandRight(component, item, ExpandHighlightDecision.HighlightSubmenu).fold(function () {
+              detail.onExecute(component, item);
+            }, noop);
+          });
+        }),
+        runOnAttached(function (container, _simulatedEvent) {
+          setup(container).each(function (primary) {
+            Replacing.append(container, premade(primary));
+            detail.onOpenMenu(container, primary);
+            if (detail.highlightImmediately) {
+              setActiveMenu(container, primary);
+            }
+          });
+        })
+      ].concat(detail.navigateOnHover ? [run(hover(), function (sandbox, simulatedEvent) {
+          var item = simulatedEvent.event.item;
+          updateView(sandbox, item);
+          expandRight(sandbox, item, ExpandHighlightDecision.HighlightParent);
+          detail.onHover(sandbox, item);
+        })] : []));
+      var getActiveItem = function (container) {
+        return Highlighting.getHighlighted(container).bind(Highlighting.getHighlighted);
+      };
+      var collapseMenuApi = function (container) {
+        getActiveItem(container).each(function (currentItem) {
+          collapseLeft(container, currentItem);
+        });
+      };
+      var highlightPrimary = function (container) {
+        layeredState.getPrimary().each(function (primary) {
+          setActiveMenu(container, primary);
+        });
+      };
+      var extractMenuFromContainer = function (container) {
+        return Optional.from(container.components()[0]).filter(function (comp) {
+          return get$b(comp.element, 'role') === 'menu';
+        });
+      };
+      var repositionMenus = function (container) {
+        var maybeActivePrimary = layeredState.getPrimary().bind(function (primary) {
+          return getActiveItem(container).bind(function (currentItem) {
+            var itemValue = getItemValue(currentItem);
+            var allMenus = values(layeredState.getMenus());
+            var preparedMenus = cat(map$2(allMenus, LayeredState.extractPreparedMenu));
+            return layeredState.getTriggeringPath(itemValue, function (v) {
+              return getItemByValue(container, preparedMenus, v);
+            });
+          }).map(function (triggeringPath) {
+            return {
+              primary: primary,
+              triggeringPath: triggeringPath
+            };
+          });
+        });
+        maybeActivePrimary.fold(function () {
+          extractMenuFromContainer(container).each(function (primaryMenu) {
+            detail.onRepositionMenu(container, primaryMenu, []);
+          });
+        }, function (_a) {
+          var primary = _a.primary, triggeringPath = _a.triggeringPath;
+          detail.onRepositionMenu(container, primary, triggeringPath);
+        });
+      };
+      var apis = {
+        collapseMenu: collapseMenuApi,
+        highlightPrimary: highlightPrimary,
+        repositionMenus: repositionMenus
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        markers: detail.markers,
+        behaviours: augment(detail.tmenuBehaviours, [
+          Keying.config({
+            mode: 'special',
+            onRight: keyOnItem(onRight),
+            onLeft: keyOnItem(onLeft),
+            onEscape: keyOnItem(onEscape),
+            focusIn: function (container, _keyInfo) {
+              layeredState.getPrimary().each(function (primary) {
+                dispatch(container, primary.element, focusItem());
+              });
+            }
+          }),
+          Highlighting.config({
+            highlightClass: detail.markers.selectedMenu,
+            itemClass: detail.markers.menu
+          }),
+          Composing.config({
+            find: function (container) {
+              return Highlighting.getHighlighted(container);
+            }
+          }),
+          Replacing.config({})
+        ]),
+        eventOrder: detail.eventOrder,
+        apis: apis,
+        events: events
+      };
+    };
+    var collapseItem$1 = constant$1('collapse-item');
+
+    var tieredData = function (primary, menus, expansions) {
+      return {
+        primary: primary,
+        menus: menus,
+        expansions: expansions
+      };
+    };
+    var singleData = function (name, menu) {
+      return {
+        primary: name,
+        menus: wrap(name, menu),
+        expansions: {}
+      };
+    };
+    var collapseItem = function (text) {
+      return {
+        value: generate$4(collapseItem$1()),
+        meta: { text: text }
+      };
+    };
+    var tieredMenu = single({
+      name: 'TieredMenu',
+      configFields: [
+        onStrictKeyboardHandler('onExecute'),
+        onStrictKeyboardHandler('onEscape'),
+        onStrictHandler('onOpenMenu'),
+        onStrictHandler('onOpenSubmenu'),
+        onHandler('onRepositionMenu'),
+        onHandler('onCollapseMenu'),
+        defaulted('highlightImmediately', true),
+        requiredObjOf('data', [
+          required$1('primary'),
+          required$1('menus'),
+          required$1('expansions')
+        ]),
+        defaulted('fakeFocus', false),
+        onHandler('onHighlight'),
+        onHandler('onHover'),
+        tieredMenuMarkers(),
+        required$1('dom'),
+        defaulted('navigateOnHover', true),
+        defaulted('stayInDom', false),
+        field$1('tmenuBehaviours', [
+          Keying,
+          Highlighting,
+          Composing,
+          Replacing
+        ]),
+        defaulted('eventOrder', {})
+      ],
+      apis: {
+        collapseMenu: function (apis, tmenu) {
+          apis.collapseMenu(tmenu);
+        },
+        highlightPrimary: function (apis, tmenu) {
+          apis.highlightPrimary(tmenu);
+        },
+        repositionMenus: function (apis, tmenu) {
+          apis.repositionMenus(tmenu);
+        }
+      },
+      factory: make$1,
+      extraApis: {
+        tieredData: tieredData,
+        singleData: singleData,
+        collapseItem: collapseItem
+      }
+    });
+
+    var findRoute = function (component, transConfig, transState, route) {
+      return get$c(transConfig.routes, route.start).bind(function (sConfig) {
+        return get$c(sConfig, route.destination);
+      });
+    };
+    var getTransition = function (comp, transConfig, transState) {
+      var route = getCurrentRoute(comp, transConfig);
+      return route.bind(function (r) {
+        return getTransitionOf(comp, transConfig, transState, r);
+      });
+    };
+    var getTransitionOf = function (comp, transConfig, transState, route) {
+      return findRoute(comp, transConfig, transState, route).bind(function (r) {
+        return r.transition.map(function (t) {
+          return {
+            transition: t,
+            route: r
+          };
+        });
+      });
+    };
+    var disableTransition = function (comp, transConfig, transState) {
+      getTransition(comp, transConfig, transState).each(function (routeTransition) {
+        var t = routeTransition.transition;
+        remove$3(comp.element, t.transitionClass);
+        remove$6(comp.element, transConfig.destinationAttr);
+      });
+    };
+    var getNewRoute = function (comp, transConfig, transState, destination) {
+      return {
+        start: get$b(comp.element, transConfig.stateAttr),
+        destination: destination
+      };
+    };
+    var getCurrentRoute = function (comp, transConfig, _transState) {
+      var el = comp.element;
+      return getOpt(el, transConfig.destinationAttr).map(function (destination) {
+        return {
+          start: get$b(comp.element, transConfig.stateAttr),
+          destination: destination
+        };
+      });
+    };
+    var jumpTo = function (comp, transConfig, transState, destination) {
+      disableTransition(comp, transConfig, transState);
+      if (has$1(comp.element, transConfig.stateAttr) && get$b(comp.element, transConfig.stateAttr) !== destination) {
+        transConfig.onFinish(comp, destination);
+      }
+      set$8(comp.element, transConfig.stateAttr, destination);
+    };
+    var fasttrack = function (comp, transConfig, _transState, _destination) {
+      if (has$1(comp.element, transConfig.destinationAttr)) {
+        getOpt(comp.element, transConfig.destinationAttr).each(function (destination) {
+          set$8(comp.element, transConfig.stateAttr, destination);
+        });
+        remove$6(comp.element, transConfig.destinationAttr);
+      }
+    };
+    var progressTo = function (comp, transConfig, transState, destination) {
+      fasttrack(comp, transConfig);
+      var route = getNewRoute(comp, transConfig, transState, destination);
+      getTransitionOf(comp, transConfig, transState, route).fold(function () {
+        jumpTo(comp, transConfig, transState, destination);
+      }, function (routeTransition) {
+        disableTransition(comp, transConfig, transState);
+        var t = routeTransition.transition;
+        add$1(comp.element, t.transitionClass);
+        set$8(comp.element, transConfig.destinationAttr, destination);
+      });
+    };
+    var getState = function (comp, transConfig, _transState) {
+      return getOpt(comp.element, transConfig.stateAttr);
+    };
+
+    var TransitionApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        findRoute: findRoute,
+        disableTransition: disableTransition,
+        getCurrentRoute: getCurrentRoute,
+        jumpTo: jumpTo,
+        progressTo: progressTo,
+        getState: getState
+    });
+
+    var events$1 = function (transConfig, transState) {
+      return derive$3([
+        run(transitionend(), function (component, simulatedEvent) {
+          var raw = simulatedEvent.event.raw;
+          getCurrentRoute(component, transConfig).each(function (route) {
+            findRoute(component, transConfig, transState, route).each(function (rInfo) {
+              rInfo.transition.each(function (rTransition) {
+                if (raw.propertyName === rTransition.property) {
+                  jumpTo(component, transConfig, transState, route.destination);
+                  transConfig.onTransition(component, route);
+                }
+              });
+            });
+          });
+        }),
+        runOnAttached(function (comp, _se) {
+          jumpTo(comp, transConfig, transState, transConfig.initialState);
+        })
+      ]);
+    };
+
+    var ActiveTransitioning = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$1
+    });
+
+    var TransitionSchema = [
+      defaulted('destinationAttr', 'data-transitioning-destination'),
+      defaulted('stateAttr', 'data-transitioning-state'),
+      required$1('initialState'),
+      onHandler('onTransition'),
+      onHandler('onFinish'),
+      requiredOf('routes', setOf(Result.value, setOf(Result.value, objOfOnly([optionObjOfOnly('transition', [
+          required$1('property'),
+          required$1('transitionClass')
+        ])]))))
+    ];
+
+    var createRoutes = function (routes) {
+      var r = {};
+      each(routes, function (v, k) {
+        var waypoints = k.split('<->');
+        r[waypoints[0]] = wrap(waypoints[1], v);
+        r[waypoints[1]] = wrap(waypoints[0], v);
+      });
+      return r;
+    };
+    var createBistate = function (first, second, transitions) {
+      return wrapAll([
+        {
+          key: first,
+          value: wrap(second, transitions)
+        },
+        {
+          key: second,
+          value: wrap(first, transitions)
+        }
+      ]);
+    };
+    var createTristate = function (first, second, third, transitions) {
+      return wrapAll([
+        {
+          key: first,
+          value: wrapAll([
+            {
+              key: second,
+              value: transitions
+            },
+            {
+              key: third,
+              value: transitions
+            }
+          ])
+        },
+        {
+          key: second,
+          value: wrapAll([
+            {
+              key: first,
+              value: transitions
+            },
+            {
+              key: third,
+              value: transitions
+            }
+          ])
+        },
+        {
+          key: third,
+          value: wrapAll([
+            {
+              key: first,
+              value: transitions
+            },
+            {
+              key: second,
+              value: transitions
+            }
+          ])
+        }
+      ]);
+    };
+    var Transitioning = create$5({
+      fields: TransitionSchema,
+      name: 'transitioning',
+      active: ActiveTransitioning,
+      apis: TransitionApis,
+      extra: {
+        createRoutes: createRoutes,
+        createBistate: createBistate,
+        createTristate: createTristate
+      }
+    });
+
+    var scrollableStyle = resolve('scrollable');
+    var register$2 = function (element) {
+      add$1(element, scrollableStyle);
+    };
+    var deregister = function (element) {
+      remove$3(element, scrollableStyle);
+    };
+    var scrollable = scrollableStyle;
+
+    var getValue = function (item) {
+      return get$c(item, 'format').getOr(item.title);
+    };
+    var convert = function (formats, memMenuThunk) {
+      var mainMenu = makeMenu('Styles', [].concat(map$2(formats.items, function (k) {
+        return makeItem(getValue(k), k.title, k.isSelected(), k.getPreview(), hasNonNullableKey(formats.expansions, getValue(k)));
+      })), memMenuThunk, false);
+      var submenus = map$1(formats.menus, function (menuItems, menuName) {
+        var items = map$2(menuItems, function (item) {
+          return makeItem(getValue(item), item.title, item.isSelected !== undefined ? item.isSelected() : false, item.getPreview !== undefined ? item.getPreview() : '', hasNonNullableKey(formats.expansions, getValue(item)));
+        });
+        return makeMenu(menuName, items, memMenuThunk, true);
+      });
+      var menus = deepMerge(submenus, wrap('styles', mainMenu));
+      var tmenu = tieredMenu.tieredData('styles', menus, formats.expansions);
+      return { tmenu: tmenu };
+    };
+    var makeItem = function (value, text, selected, preview, isMenu) {
+      return {
+        data: {
+          value: value,
+          text: text
+        },
+        type: 'item',
+        dom: {
+          tag: 'div',
+          classes: isMenu ? [resolve('styles-item-is-menu')] : []
+        },
+        toggling: {
+          toggleOnExecute: false,
+          toggleClass: resolve('format-matches'),
+          selected: selected
+        },
+        itemBehaviours: derive$2(isMenu ? [] : [format(value, function (comp, status) {
+            var toggle = status ? Toggling.on : Toggling.off;
+            toggle(comp);
+          })]),
+        components: [{
+            dom: {
+              tag: 'div',
+              attributes: { style: preview },
+              innerHtml: text
+            }
+          }]
+      };
+    };
+    var makeMenu = function (value, items, memMenuThunk, collapsable) {
+      return {
+        value: value,
+        dom: { tag: 'div' },
+        components: [
+          Button.sketch({
+            dom: {
+              tag: 'div',
+              classes: [resolve('styles-collapser')]
+            },
+            components: collapsable ? [
+              {
+                dom: {
+                  tag: 'span',
+                  classes: [resolve('styles-collapse-icon')]
+                }
+              },
+              text(value)
+            ] : [text(value)],
+            action: function (item) {
+              if (collapsable) {
+                var comp = memMenuThunk().get(item);
+                tieredMenu.collapseMenu(comp);
+              }
+            }
+          }),
+          {
+            dom: {
+              tag: 'div',
+              classes: [resolve('styles-menu-items-container')]
+            },
+            components: [Menu.parts.items({})],
+            behaviours: derive$2([config('adhoc-scrollable-menu', [
+                runOnAttached(function (component, _simulatedEvent) {
+                  set$5(component.element, 'overflow-y', 'auto');
+                  set$5(component.element, '-webkit-overflow-scrolling', 'touch');
+                  register$2(component.element);
+                }),
+                runOnDetached(function (component) {
+                  remove$2(component.element, 'overflow-y');
+                  remove$2(component.element, '-webkit-overflow-scrolling');
+                  deregister(component.element);
+                })
+              ])])
+          }
+        ],
+        items: items,
+        menuBehaviours: derive$2([Transitioning.config({
+            initialState: 'after',
+            routes: Transitioning.createTristate('before', 'current', 'after', {
+              transition: {
+                property: 'transform',
+                transitionClass: 'transitioning'
+              }
+            })
+          })])
+      };
+    };
+    var sketch$1 = function (settings) {
+      var dataset = convert(settings.formats, function () {
+        return memMenu;
+      });
+      var memMenu = record(tieredMenu.sketch({
+        dom: {
+          tag: 'div',
+          classes: [resolve('styles-menu')]
+        },
+        components: [],
+        fakeFocus: true,
+        stayInDom: true,
+        onExecute: function (_tmenu, item) {
+          var v = Representing.getValue(item);
+          settings.handle(item, v.value);
+          return Optional.none();
+        },
+        onEscape: function () {
+          return Optional.none();
+        },
+        onOpenMenu: function (container, menu) {
+          var w = get$5(container.element);
+          set$4(menu.element, w);
+          Transitioning.jumpTo(menu, 'current');
+        },
+        onOpenSubmenu: function (container, item, submenu) {
+          var w = get$5(container.element);
+          var menu = ancestor(item.element, '[role="menu"]').getOrDie('hacky');
+          var menuComp = container.getSystem().getByDom(menu).getOrDie();
+          set$4(submenu.element, w);
+          Transitioning.progressTo(menuComp, 'before');
+          Transitioning.jumpTo(submenu, 'after');
+          Transitioning.progressTo(submenu, 'current');
+        },
+        onCollapseMenu: function (container, item, menu) {
+          var submenu = ancestor(item.element, '[role="menu"]').getOrDie('hacky');
+          var submenuComp = container.getSystem().getByDom(submenu).getOrDie();
+          Transitioning.progressTo(submenuComp, 'after');
+          Transitioning.progressTo(menu, 'current');
+        },
+        navigateOnHover: false,
+        highlightImmediately: true,
+        data: dataset.tmenu,
+        markers: {
+          backgroundMenu: resolve('styles-background-menu'),
+          menu: resolve('styles-menu'),
+          selectedMenu: resolve('styles-selected-menu'),
+          item: resolve('styles-item'),
+          selectedItem: resolve('styles-selected-item')
+        }
+      }));
+      return memMenu.asSpec();
+    };
+
+    var getFromExpandingItem = function (item) {
+      var newItem = deepMerge(exclude(item, ['items']), { menu: true });
+      var rest = expand(item.items);
+      var newMenus = deepMerge(rest.menus, wrap(item.title, rest.items));
+      var newExpansions = deepMerge(rest.expansions, wrap(item.title, item.title));
+      return {
+        item: newItem,
+        menus: newMenus,
+        expansions: newExpansions
+      };
+    };
+    var getFromItem = function (item) {
+      return hasNonNullableKey(item, 'items') ? getFromExpandingItem(item) : {
+        item: item,
+        menus: {},
+        expansions: {}
+      };
+    };
+    var expand = function (items) {
+      return foldr(items, function (acc, item) {
+        var newData = getFromItem(item);
+        return {
+          menus: deepMerge(acc.menus, newData.menus),
+          items: [newData.item].concat(acc.items),
+          expansions: deepMerge(acc.expansions, newData.expansions)
+        };
+      }, {
+        menus: {},
+        expansions: {},
+        items: []
+      });
+    };
+
+    var register$1 = function (editor) {
+      var isSelectedFor = function (format) {
+        return function () {
+          return editor.formatter.match(format);
+        };
+      };
+      var getPreview = function (format) {
+        return function () {
+          return editor.formatter.getCssText(format);
+        };
+      };
+      var enrichSupported = function (item) {
+        return deepMerge(item, {
+          isSelected: isSelectedFor(item.format),
+          getPreview: getPreview(item.format)
+        });
+      };
+      var enrichMenu = function (item) {
+        return deepMerge(item, {
+          isSelected: never,
+          getPreview: constant$1('')
+        });
+      };
+      var enrichCustom = function (item) {
+        var formatName = generate$4(item.title);
+        var newItem = deepMerge(item, {
+          format: formatName,
+          isSelected: isSelectedFor(formatName),
+          getPreview: getPreview(formatName)
+        });
+        editor.formatter.register(formatName, newItem);
+        return newItem;
+      };
+      var doEnrich = function (items) {
+        return map$2(items, function (item) {
+          if (hasNonNullableKey(item, 'items')) {
+            var newItems = doEnrich(item.items);
+            return deepMerge(enrichMenu(item), { items: newItems });
+          } else if (hasNonNullableKey(item, 'format')) {
+            return enrichSupported(item);
+          } else {
+            return enrichCustom(item);
+          }
+        });
+      };
+      return doEnrich(getStyleFormats(editor));
+    };
+    var prune = function (editor, formats) {
+      var doPrune = function (items) {
+        return bind$3(items, function (item) {
+          if (item.items !== undefined) {
+            var newItems = doPrune(item.items);
+            return newItems.length > 0 ? [item] : [];
+          } else {
+            var keep = hasNonNullableKey(item, 'format') ? editor.formatter.canApply(item.format) : true;
+            return keep ? [item] : [];
+          }
+        });
+      };
+      var prunedItems = doPrune(formats);
+      return expand(prunedItems);
+    };
+    var ui = function (editor, formats, onDone) {
+      var pruned = prune(editor, formats);
+      return sketch$1({
+        formats: pruned,
+        handle: function (item, value) {
+          editor.undoManager.transact(function () {
+            if (Toggling.isOn(item)) {
+              editor.formatter.remove(value);
+            } else {
+              editor.formatter.apply(value);
+            }
+          });
+          onDone();
+        }
+      });
+    };
+
+    var extract = function (rawToolbar) {
+      var toolbar = rawToolbar.replace(/\|/g, ' ').trim();
+      return toolbar.length > 0 ? toolbar.split(/\s+/) : [];
+    };
+    var identifyFromArray = function (toolbar) {
+      return bind$3(toolbar, function (item) {
+        return isArray(item) ? identifyFromArray(item) : extract(item);
+      });
+    };
+    var identify = function (editor) {
+      var toolbar = getToolbar(editor);
+      return isArray(toolbar) ? identifyFromArray(toolbar) : extract(toolbar);
+    };
+    var setup$3 = function (realm, editor) {
+      var commandSketch = function (name) {
+        return function () {
+          return forToolbarCommand(editor, name);
+        };
+      };
+      var stateCommandSketch = function (name) {
+        return function () {
+          return forToolbarStateCommand(editor, name);
+        };
+      };
+      var actionSketch = function (name, query, action) {
+        return function () {
+          return forToolbarStateAction(editor, name, query, action);
+        };
+      };
+      var undo = commandSketch('undo');
+      var redo = commandSketch('redo');
+      var bold = stateCommandSketch('bold');
+      var italic = stateCommandSketch('italic');
+      var underline = stateCommandSketch('underline');
+      var removeformat = commandSketch('removeformat');
+      var link = function () {
+        return sketch$2(realm, editor);
+      };
+      var unlink = actionSketch('unlink', 'link', function () {
+        editor.execCommand('unlink', null, false);
+      });
+      var image = function () {
+        return sketch$5(editor);
+      };
+      var bullist = actionSketch('unordered-list', 'ul', function () {
+        editor.execCommand('InsertUnorderedList', null, false);
+      });
+      var numlist = actionSketch('ordered-list', 'ol', function () {
+        editor.execCommand('InsertOrderedList', null, false);
+      });
+      var fontsizeselect = function () {
+        return sketch$6(realm, editor);
+      };
+      var forecolor = function () {
+        return sketch$8(realm, editor);
+      };
+      var styleFormats = register$1(editor);
+      var styleFormatsMenu = function () {
+        return ui(editor, styleFormats, function () {
+          editor.fire('scrollIntoView');
+        });
+      };
+      var styleselect = function () {
+        return forToolbar('style-formats', function (button) {
+          editor.fire('toReading');
+          realm.dropup.appear(styleFormatsMenu, Toggling.on, button);
+        }, derive$2([
+          Toggling.config({
+            toggleClass: resolve('toolbar-button-selected'),
+            toggleOnExecute: false,
+            aria: { mode: 'pressed' }
+          }),
+          Receiving.config({
+            channels: wrapAll([
+              receive(orientationChanged, Toggling.off),
+              receive(dropupDismissed, Toggling.off)
+            ])
+          })
+        ]), editor);
+      };
+      var feature = function (prereq, sketch) {
+        return {
+          isSupported: function () {
+            var buttons = editor.ui.registry.getAll().buttons;
+            return prereq.forall(function (p) {
+              return hasNonNullableKey(buttons, p);
+            });
+          },
+          sketch: sketch
+        };
+      };
+      return {
+        undo: feature(Optional.none(), undo),
+        redo: feature(Optional.none(), redo),
+        bold: feature(Optional.none(), bold),
+        italic: feature(Optional.none(), italic),
+        underline: feature(Optional.none(), underline),
+        removeformat: feature(Optional.none(), removeformat),
+        link: feature(Optional.none(), link),
+        unlink: feature(Optional.none(), unlink),
+        image: feature(Optional.none(), image),
+        bullist: feature(Optional.some('bullist'), bullist),
+        numlist: feature(Optional.some('numlist'), numlist),
+        fontsizeselect: feature(Optional.none(), fontsizeselect),
+        forecolor: feature(Optional.none(), forecolor),
+        styleselect: feature(Optional.none(), styleselect)
+      };
+    };
+    var detect = function (editor, features) {
+      var itemNames = identify(editor);
+      var present = {};
+      return bind$3(itemNames, function (iName) {
+        var r = !hasNonNullableKey(present, iName) && hasNonNullableKey(features, iName) && features[iName].isSupported() ? [features[iName].sketch()] : [];
+        present[iName] = true;
+        return r;
+      });
+    };
+
+    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 = 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(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 filter = always;
+    var bind = function (element, event, handler) {
+      return bind$1(element, event, filter, handler);
+    };
+    var capture = function (element, event, handler) {
+      return capture$1(element, event, filter, handler);
+    };
+
+    var global$2 = tinymce.util.Tools.resolve('tinymce.util.Delay');
+
+    var INTERVAL = 50;
+    var INSURANCE = 1000 / INTERVAL;
+    var get$1 = function (outerWindow) {
+      var isPortrait = outerWindow.matchMedia('(orientation: portrait)').matches;
+      return { isPortrait: constant$1(isPortrait) };
+    };
+    var getActualWidth = function (outerWindow) {
+      var isIos = detect$1().os.isiOS();
+      var isPortrait = get$1(outerWindow).isPortrait();
+      return isIos && !isPortrait ? outerWindow.screen.height : outerWindow.screen.width;
+    };
+    var onChange = function (outerWindow, listeners) {
+      var win = SugarElement.fromDom(outerWindow);
+      var poller = null;
+      var change = function () {
+        global$2.clearInterval(poller);
+        var orientation = get$1(outerWindow);
+        listeners.onChange(orientation);
+        onAdjustment(function () {
+          listeners.onReady(orientation);
+        });
+      };
+      var orientationHandle = bind(win, 'orientationchange', change);
+      var onAdjustment = function (f) {
+        global$2.clearInterval(poller);
+        var flag = outerWindow.innerHeight;
+        var insurance = 0;
+        poller = global$2.setInterval(function () {
+          if (flag !== outerWindow.innerHeight) {
+            global$2.clearInterval(poller);
+            f(Optional.some(outerWindow.innerHeight));
+          } else if (insurance > INSURANCE) {
+            global$2.clearInterval(poller);
+            f(Optional.none());
+          }
+          insurance++;
+        }, INTERVAL);
+      };
+      var destroy = function () {
+        orientationHandle.unbind();
+      };
+      return {
+        onAdjustment: onAdjustment,
+        destroy: destroy
+      };
+    };
+
+    var setStart = function (rng, situ) {
+      situ.fold(function (e) {
+        rng.setStartBefore(e.dom);
+      }, function (e, o) {
+        rng.setStart(e.dom, o);
+      }, function (e) {
+        rng.setStartAfter(e.dom);
+      });
+    };
+    var setFinish = function (rng, situ) {
+      situ.fold(function (e) {
+        rng.setEndBefore(e.dom);
+      }, function (e, o) {
+        rng.setEnd(e.dom, o);
+      }, function (e) {
+        rng.setEndAfter(e.dom);
+      });
+    };
+    var relativeToNative = function (win, startSitu, finishSitu) {
+      var range = win.document.createRange();
+      setStart(range, startSitu);
+      setFinish(range, finishSitu);
+      return range;
+    };
+    var exactToNative = function (win, start, soffset, finish, foffset) {
+      var rng = win.document.createRange();
+      rng.setStart(start.dom, soffset);
+      rng.setEnd(finish.dom, foffset);
+      return rng;
+    };
+    var toRect$1 = function (rect) {
+      return {
+        left: rect.left,
+        top: rect.top,
+        right: rect.right,
+        bottom: rect.bottom,
+        width: rect.width,
+        height: rect.height
+      };
+    };
+    var getFirstRect$1 = function (rng) {
+      var rects = rng.getClientRects();
+      var rect = rects.length > 0 ? rects[0] : rng.getBoundingClientRect();
+      return rect.width > 0 || rect.height > 0 ? Optional.some(rect).map(toRect$1) : Optional.none();
+    };
+
+    var adt$3 = Adt.generate([
+      {
+        ltr: [
+          'start',
+          'soffset',
+          'finish',
+          'foffset'
+        ]
+      },
+      {
+        rtl: [
+          'start',
+          'soffset',
+          'finish',
+          'foffset'
+        ]
+      }
+    ]);
+    var fromRange = function (win, type, range) {
+      return type(SugarElement.fromDom(range.startContainer), range.startOffset, SugarElement.fromDom(range.endContainer), range.endOffset);
+    };
+    var getRanges = function (win, selection) {
+      return selection.match({
+        domRange: function (rng) {
+          return {
+            ltr: constant$1(rng),
+            rtl: Optional.none
+          };
+        },
+        relative: function (startSitu, finishSitu) {
+          return {
+            ltr: cached(function () {
+              return relativeToNative(win, startSitu, finishSitu);
+            }),
+            rtl: cached(function () {
+              return Optional.some(relativeToNative(win, finishSitu, startSitu));
+            })
+          };
+        },
+        exact: function (start, soffset, finish, foffset) {
+          return {
+            ltr: cached(function () {
+              return exactToNative(win, start, soffset, finish, foffset);
+            }),
+            rtl: cached(function () {
+              return Optional.some(exactToNative(win, finish, foffset, start, soffset));
+            })
+          };
+        }
+      });
+    };
+    var doDiagnose = function (win, ranges) {
+      var rng = ranges.ltr();
+      if (rng.collapsed) {
+        var reversed = ranges.rtl().filter(function (rev) {
+          return rev.collapsed === false;
+        });
+        return reversed.map(function (rev) {
+          return adt$3.rtl(SugarElement.fromDom(rev.endContainer), rev.endOffset, SugarElement.fromDom(rev.startContainer), rev.startOffset);
+        }).getOrThunk(function () {
+          return fromRange(win, adt$3.ltr, rng);
+        });
+      } else {
+        return fromRange(win, adt$3.ltr, rng);
+      }
+    };
+    var diagnose = function (win, selection) {
+      var ranges = getRanges(win, selection);
+      return doDiagnose(win, ranges);
+    };
+    var asLtrRange = function (win, selection) {
+      var diagnosis = diagnose(win, selection);
+      return diagnosis.match({
+        ltr: function (start, soffset, finish, foffset) {
+          var rng = win.document.createRange();
+          rng.setStart(start.dom, soffset);
+          rng.setEnd(finish.dom, foffset);
+          return rng;
+        },
+        rtl: function (start, soffset, finish, foffset) {
+          var rng = win.document.createRange();
+          rng.setStart(finish.dom, foffset);
+          rng.setEnd(start.dom, soffset);
+          return rng;
+        }
+      });
+    };
+    adt$3.ltr;
+    adt$3.rtl;
+
+    var create$3 = function (start, soffset, finish, foffset) {
+      return {
+        start: start,
+        soffset: soffset,
+        finish: finish,
+        foffset: foffset
+      };
+    };
+    var SimRange = { create: create$3 };
+
+    var NodeValue = function (is, name) {
+      var get = function (element) {
+        if (!is(element)) {
+          throw new Error('Can only get ' + name + ' value of a ' + name + ' node');
+        }
+        return getOption(element).getOr('');
+      };
+      var getOption = function (element) {
+        return is(element) ? Optional.from(element.dom.nodeValue) : Optional.none();
+      };
+      var set = function (element, value) {
+        if (!is(element)) {
+          throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node');
+        }
+        element.dom.nodeValue = value;
+      };
+      return {
+        get: get,
+        getOption: getOption,
+        set: set
+      };
+    };
+
+    var api = NodeValue(isText, 'text');
+    var getOption = function (element) {
+      return api.getOption(element);
+    };
+
+    var getEnd = function (element) {
+      return name$1(element) === 'img' ? 1 : getOption(element).fold(function () {
+        return children(element).length;
+      }, function (v) {
+        return v.length;
+      });
+    };
+
+    var adt$2 = Adt.generate([
+      { before: ['element'] },
+      {
+        on: [
+          'element',
+          'offset'
+        ]
+      },
+      { after: ['element'] }
+    ]);
+    var cata = function (subject, onBefore, onOn, onAfter) {
+      return subject.fold(onBefore, onOn, onAfter);
+    };
+    var getStart$1 = function (situ) {
+      return situ.fold(identity, identity, identity);
+    };
+    var before = adt$2.before;
+    var on = adt$2.on;
+    var after$1 = adt$2.after;
+    var Situ = {
+      before: before,
+      on: on,
+      after: after$1,
+      cata: cata,
+      getStart: getStart$1
+    };
+
+    var adt$1 = Adt.generate([
+      { domRange: ['rng'] },
+      {
+        relative: [
+          'startSitu',
+          'finishSitu'
+        ]
+      },
+      {
+        exact: [
+          'start',
+          'soffset',
+          'finish',
+          'foffset'
+        ]
+      }
+    ]);
+    var exactFromRange = function (simRange) {
+      return adt$1.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset);
+    };
+    var getStart = function (selection) {
+      return selection.match({
+        domRange: function (rng) {
+          return SugarElement.fromDom(rng.startContainer);
+        },
+        relative: function (startSitu, _finishSitu) {
+          return Situ.getStart(startSitu);
+        },
+        exact: function (start, _soffset, _finish, _foffset) {
+          return start;
+        }
+      });
+    };
+    var domRange = adt$1.domRange;
+    var relative = adt$1.relative;
+    var exact = adt$1.exact;
+    var getWin$1 = function (selection) {
+      var start = getStart(selection);
+      return defaultView(start);
+    };
+    var range = SimRange.create;
+    var SimSelection = {
+      domRange: domRange,
+      relative: relative,
+      exact: exact,
+      exactFromRange: exactFromRange,
+      getWin: getWin$1,
+      range: range
+    };
+
+    var beforeSpecial = function (element, offset) {
+      var name = name$1(element);
+      if ('input' === name) {
+        return Situ.after(element);
+      } else if (!contains$1([
+          'br',
+          'img'
+        ], name)) {
+        return Situ.on(element, offset);
+      } else {
+        return offset === 0 ? Situ.before(element) : Situ.after(element);
+      }
+    };
+    var preprocessExact = function (start, soffset, finish, foffset) {
+      var startSitu = beforeSpecial(start, soffset);
+      var finishSitu = beforeSpecial(finish, foffset);
+      return SimSelection.relative(startSitu, finishSitu);
+    };
+
+    var makeRange = function (start, soffset, finish, foffset) {
+      var doc = owner$2(start);
+      var rng = doc.dom.createRange();
+      rng.setStart(start.dom, soffset);
+      rng.setEnd(finish.dom, foffset);
+      return rng;
+    };
+    var after = function (start, soffset, finish, foffset) {
+      var r = makeRange(start, soffset, finish, foffset);
+      var same = eq(start, finish) && soffset === foffset;
+      return r.collapsed && !same;
+    };
+
+    var getNativeSelection = function (win) {
+      return Optional.from(win.getSelection());
+    };
+    var doSetNativeRange = function (win, rng) {
+      getNativeSelection(win).each(function (selection) {
+        selection.removeAllRanges();
+        selection.addRange(rng);
+      });
+    };
+    var doSetRange = function (win, start, soffset, finish, foffset) {
+      var rng = exactToNative(win, start, soffset, finish, foffset);
+      doSetNativeRange(win, rng);
+    };
+    var setLegacyRtlRange = function (win, selection, start, soffset, finish, foffset) {
+      selection.collapse(start.dom, soffset);
+      selection.extend(finish.dom, foffset);
+    };
+    var setRangeFromRelative = function (win, relative) {
+      return diagnose(win, relative).match({
+        ltr: function (start, soffset, finish, foffset) {
+          doSetRange(win, start, soffset, finish, foffset);
+        },
+        rtl: function (start, soffset, finish, foffset) {
+          getNativeSelection(win).each(function (selection) {
+            if (selection.setBaseAndExtent) {
+              selection.setBaseAndExtent(start.dom, soffset, finish.dom, foffset);
+            } else if (selection.extend) {
+              try {
+                setLegacyRtlRange(win, selection, start, soffset, finish, foffset);
+              } catch (e) {
+                doSetRange(win, finish, foffset, start, soffset);
+              }
+            } else {
+              doSetRange(win, finish, foffset, start, soffset);
+            }
+          });
+        }
+      });
+    };
+    var setExact = function (win, start, soffset, finish, foffset) {
+      var relative = preprocessExact(start, soffset, finish, foffset);
+      setRangeFromRelative(win, relative);
+    };
+    var readRange = function (selection) {
+      if (selection.rangeCount > 0) {
+        var firstRng = selection.getRangeAt(0);
+        var lastRng = selection.getRangeAt(selection.rangeCount - 1);
+        return Optional.some(SimRange.create(SugarElement.fromDom(firstRng.startContainer), firstRng.startOffset, SugarElement.fromDom(lastRng.endContainer), lastRng.endOffset));
+      } else {
+        return Optional.none();
+      }
+    };
+    var doGetExact = function (selection) {
+      if (selection.anchorNode === null || selection.focusNode === null) {
+        return readRange(selection);
+      } else {
+        var anchor = SugarElement.fromDom(selection.anchorNode);
+        var focus_1 = SugarElement.fromDom(selection.focusNode);
+        return after(anchor, selection.anchorOffset, focus_1, selection.focusOffset) ? Optional.some(SimRange.create(anchor, selection.anchorOffset, focus_1, selection.focusOffset)) : readRange(selection);
+      }
+    };
+    var getExact = function (win) {
+      return getNativeSelection(win).filter(function (sel) {
+        return sel.rangeCount > 0;
+      }).bind(doGetExact);
+    };
+    var get = function (win) {
+      return getExact(win).map(function (range) {
+        return SimSelection.exact(range.start, range.soffset, range.finish, range.foffset);
+      });
+    };
+    var getFirstRect = function (win, selection) {
+      var rng = asLtrRange(win, selection);
+      return getFirstRect$1(rng);
+    };
+    var clear = function (win) {
+      getNativeSelection(win).each(function (selection) {
+        return selection.removeAllRanges();
+      });
+    };
+
+    var getBodyFromFrame = function (frame) {
+      return Optional.some(SugarElement.fromDom(frame.dom.contentWindow.document.body));
+    };
+    var getDocFromFrame = function (frame) {
+      return Optional.some(SugarElement.fromDom(frame.dom.contentWindow.document));
+    };
+    var getWinFromFrame = function (frame) {
+      return Optional.from(frame.dom.contentWindow);
+    };
+    var getSelectionFromFrame = function (frame) {
+      var optWin = getWinFromFrame(frame);
+      return optWin.bind(getExact);
+    };
+    var getFrame = function (editor) {
+      return editor.getFrame();
+    };
+    var getOrDerive = function (name, f) {
+      return function (editor) {
+        var g = editor[name].getOrThunk(function () {
+          var frame = getFrame(editor);
+          return function () {
+            return f(frame);
+          };
+        });
+        return g();
+      };
+    };
+    var getOrListen = function (editor, doc, name, type) {
+      return editor[name].getOrThunk(function () {
+        return function (handler) {
+          return bind(doc, type, handler);
+        };
+      });
+    };
+    var getActiveApi = function (editor) {
+      var frame = getFrame(editor);
+      var tryFallbackBox = function (win) {
+        var isCollapsed = function (sel) {
+          return eq(sel.start, sel.finish) && sel.soffset === sel.foffset;
+        };
+        var toStartRect = function (sel) {
+          var rect = sel.start.dom.getBoundingClientRect();
+          return rect.width > 0 || rect.height > 0 ? Optional.some(rect) : Optional.none();
+        };
+        return getExact(win).filter(isCollapsed).bind(toStartRect);
+      };
+      return getBodyFromFrame(frame).bind(function (body) {
+        return getDocFromFrame(frame).bind(function (doc) {
+          return getWinFromFrame(frame).map(function (win) {
+            var html = SugarElement.fromDom(doc.dom.documentElement);
+            var getCursorBox = editor.getCursorBox.getOrThunk(function () {
+              return function () {
+                return get(win).bind(function (sel) {
+                  return getFirstRect(win, sel).orThunk(function () {
+                    return tryFallbackBox(win);
+                  });
+                });
+              };
+            });
+            var setSelection = editor.setSelection.getOrThunk(function () {
+              return function (start, soffset, finish, foffset) {
+                setExact(win, start, soffset, finish, foffset);
+              };
+            });
+            var clearSelection = editor.clearSelection.getOrThunk(function () {
+              return function () {
+                clear(win);
+              };
+            });
+            return {
+              body: body,
+              doc: doc,
+              win: win,
+              html: html,
+              getSelection: curry(getSelectionFromFrame, frame),
+              setSelection: setSelection,
+              clearSelection: clearSelection,
+              frame: frame,
+              onKeyup: getOrListen(editor, doc, 'onKeyup', 'keyup'),
+              onNodeChanged: getOrListen(editor, doc, 'onNodeChanged', 'SelectionChange'),
+              onDomChanged: editor.onDomChanged,
+              onScrollToCursor: editor.onScrollToCursor,
+              onScrollToElement: editor.onScrollToElement,
+              onToReading: editor.onToReading,
+              onToEditing: editor.onToEditing,
+              onToolbarScrollStart: editor.onToolbarScrollStart,
+              onTouchContent: editor.onTouchContent,
+              onTapContent: editor.onTapContent,
+              onTouchToolstrip: editor.onTouchToolstrip,
+              getCursorBox: getCursorBox
+            };
+          });
+        });
+      });
+    };
+    var getWin = getOrDerive('getWin', getWinFromFrame);
+
+    var tag = function () {
+      var head = first$1('head').getOrDie();
+      var nu = function () {
+        var meta = SugarElement.fromTag('meta');
+        set$8(meta, 'name', 'viewport');
+        append$2(head, meta);
+        return meta;
+      };
+      var element = first$1('meta[name="viewport"]').getOrThunk(nu);
+      var backup = get$b(element, 'content');
+      var maximize = function () {
+        set$8(element, 'content', 'width=device-width, initial-scale=1.0, user-scalable=no, maximum-scale=1.0');
+      };
+      var restore = function () {
+        if (backup !== undefined && backup !== null && backup.length > 0) {
+          set$8(element, 'content', backup);
+        } else {
+          set$8(element, 'content', 'user-scalable=yes');
+        }
+      };
+      return {
+        maximize: maximize,
+        restore: restore
+      };
+    };
+
+    var attr = 'data-ephox-mobile-fullscreen-style';
+    var siblingStyles = 'display:none!important;';
+    var ancestorPosition = 'position:absolute!important;';
+    var ancestorStyles = 'top:0!important;left:0!important;margin:0!important;padding:0!important;width:100%!important;height:100%!important;overflow:visible!important;';
+    var bgFallback = 'background-color:rgb(255,255,255)!important;';
+    var isAndroid = detect$1().os.isAndroid();
+    var matchColor = function (editorBody) {
+      var color = get$8(editorBody, 'background-color');
+      return color !== undefined && color !== '' ? 'background-color:' + color + '!important' : bgFallback;
+    };
+    var clobberStyles = function (container, editorBody) {
+      var gatherSiblings = function (element) {
+        return siblings(element, '*');
+      };
+      var clobber = function (clobberStyle) {
+        return function (element) {
+          var styles = get$b(element, 'style');
+          var backup = styles === undefined ? 'no-styles' : styles.trim();
+          if (backup === clobberStyle) {
+            return;
+          } else {
+            set$8(element, attr, backup);
+            set$8(element, 'style', clobberStyle);
+          }
+        };
+      };
+      var ancestors$1 = ancestors(container, '*');
+      var siblings$1 = bind$3(ancestors$1, gatherSiblings);
+      var bgColor = matchColor(editorBody);
+      each$1(siblings$1, clobber(siblingStyles));
+      each$1(ancestors$1, clobber(ancestorPosition + ancestorStyles + bgColor));
+      var containerStyles = isAndroid === true ? '' : ancestorPosition;
+      clobber(containerStyles + ancestorStyles + bgColor)(container);
+    };
+    var restoreStyles = function () {
+      var clobberedEls = all('[' + attr + ']');
+      each$1(clobberedEls, function (element) {
+        var restore = get$b(element, attr);
+        if (restore !== 'no-styles') {
+          set$8(element, 'style', restore);
+        } else {
+          remove$6(element, 'style');
+        }
+        remove$6(element, attr);
+      });
+    };
+
+    var DelayedFunction = function (fun, delay) {
+      var ref = null;
+      var schedule = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        ref = setTimeout(function () {
+          fun.apply(null, args);
+          ref = null;
+        }, delay);
+      };
+      var cancel = function () {
+        if (ref !== null) {
+          clearTimeout(ref);
+          ref = null;
+        }
+      };
+      return {
+        cancel: cancel,
+        schedule: schedule
+      };
+    };
+
+    var SIGNIFICANT_MOVE = 5;
+    var LONGPRESS_DELAY = 400;
+    var getTouch = function (event) {
+      var raw = event.raw;
+      if (raw.touches === undefined || raw.touches.length !== 1) {
+        return Optional.none();
+      }
+      return Optional.some(raw.touches[0]);
+    };
+    var isFarEnough = function (touch, data) {
+      var distX = Math.abs(touch.clientX - data.x);
+      var distY = Math.abs(touch.clientY - data.y);
+      return distX > SIGNIFICANT_MOVE || distY > SIGNIFICANT_MOVE;
+    };
+    var monitor$1 = function (settings) {
+      var startData = value();
+      var longpressFired = Cell(false);
+      var longpress$1 = DelayedFunction(function (event) {
+        settings.triggerEvent(longpress(), event);
+        longpressFired.set(true);
+      }, LONGPRESS_DELAY);
+      var handleTouchstart = function (event) {
+        getTouch(event).each(function (touch) {
+          longpress$1.cancel();
+          var data = {
+            x: touch.clientX,
+            y: touch.clientY,
+            target: event.target
+          };
+          longpress$1.schedule(event);
+          longpressFired.set(false);
+          startData.set(data);
+        });
+        return Optional.none();
+      };
+      var handleTouchmove = function (event) {
+        longpress$1.cancel();
+        getTouch(event).each(function (touch) {
+          startData.on(function (data) {
+            if (isFarEnough(touch, data)) {
+              startData.clear();
+            }
+          });
+        });
+        return Optional.none();
+      };
+      var handleTouchend = function (event) {
+        longpress$1.cancel();
+        var isSame = function (data) {
+          return eq(data.target, event.target);
+        };
+        return startData.get().filter(isSame).map(function (_data) {
+          if (longpressFired.get()) {
+            event.prevent();
+            return false;
+          } else {
+            return settings.triggerEvent(tap(), event);
+          }
+        });
+      };
+      var handlers = wrapAll([
+        {
+          key: touchstart(),
+          value: handleTouchstart
+        },
+        {
+          key: touchmove(),
+          value: handleTouchmove
+        },
+        {
+          key: touchend(),
+          value: handleTouchend
+        }
+      ]);
+      var fireIfReady = function (event, type) {
+        return get$c(handlers, type).bind(function (handler) {
+          return handler(event);
+        });
+      };
+      return { fireIfReady: fireIfReady };
+    };
+
+    var monitor = function (editorApi) {
+      var tapEvent = monitor$1({
+        triggerEvent: function (type, evt) {
+          editorApi.onTapContent(evt);
+        }
+      });
+      var onTouchend = function () {
+        return bind(editorApi.body, 'touchend', function (evt) {
+          tapEvent.fireIfReady(evt, 'touchend');
+        });
+      };
+      var onTouchmove = function () {
+        return bind(editorApi.body, 'touchmove', function (evt) {
+          tapEvent.fireIfReady(evt, 'touchmove');
+        });
+      };
+      var fireTouchstart = function (evt) {
+        tapEvent.fireIfReady(evt, 'touchstart');
+      };
+      return {
+        fireTouchstart: fireTouchstart,
+        onTouchend: onTouchend,
+        onTouchmove: onTouchmove
+      };
+    };
+
+    var isAndroid6 = detect$1().os.version.major >= 6;
+    var initEvents$1 = function (editorApi, toolstrip, alloy) {
+      var tapping = monitor(editorApi);
+      var outerDoc = owner$2(toolstrip);
+      var isRanged = function (sel) {
+        return !eq(sel.start, sel.finish) || sel.soffset !== sel.foffset;
+      };
+      var hasRangeInUi = function () {
+        return active(outerDoc).filter(function (input) {
+          return name$1(input) === 'input';
+        }).exists(function (input) {
+          return input.dom.selectionStart !== input.dom.selectionEnd;
+        });
+      };
+      var updateMargin = function () {
+        var rangeInContent = editorApi.doc.dom.hasFocus() && editorApi.getSelection().exists(isRanged);
+        alloy.getByDom(toolstrip).each((rangeInContent || hasRangeInUi()) === true ? Toggling.on : Toggling.off);
+      };
+      var listeners = [
+        bind(editorApi.body, 'touchstart', function (evt) {
+          editorApi.onTouchContent();
+          tapping.fireTouchstart(evt);
+        }),
+        tapping.onTouchmove(),
+        tapping.onTouchend(),
+        bind(toolstrip, 'touchstart', function (_evt) {
+          editorApi.onTouchToolstrip();
+        }),
+        editorApi.onToReading(function () {
+          blur$1(editorApi.body);
+        }),
+        editorApi.onToEditing(noop),
+        editorApi.onScrollToCursor(function (tinyEvent) {
+          tinyEvent.preventDefault();
+          editorApi.getCursorBox().each(function (bounds) {
+            var cWin = editorApi.win;
+            var isOutside = bounds.top > cWin.innerHeight || bounds.bottom > cWin.innerHeight;
+            var cScrollBy = isOutside ? bounds.bottom - cWin.innerHeight + 50 : 0;
+            if (cScrollBy !== 0) {
+              cWin.scrollTo(cWin.pageXOffset, cWin.pageYOffset + cScrollBy);
+            }
+          });
+        })
+      ].concat(isAndroid6 === true ? [] : [
+        bind(SugarElement.fromDom(editorApi.win), 'blur', function () {
+          alloy.getByDom(toolstrip).each(Toggling.off);
+        }),
+        bind(outerDoc, 'select', updateMargin),
+        bind(editorApi.doc, 'selectionchange', updateMargin)
+      ]);
+      var destroy = function () {
+        each$1(listeners, function (l) {
+          l.unbind();
+        });
+      };
+      return { destroy: destroy };
+    };
+
+    var safeParse = function (element, attribute) {
+      var parsed = parseInt(get$b(element, attribute), 10);
+      return isNaN(parsed) ? 0 : parsed;
+    };
+
+    var COLLAPSED_WIDTH = 2;
+    var collapsedRect = function (rect) {
+      return __assign(__assign({}, rect), { width: COLLAPSED_WIDTH });
+    };
+    var toRect = function (rawRect) {
+      return {
+        left: rawRect.left,
+        top: rawRect.top,
+        right: rawRect.right,
+        bottom: rawRect.bottom,
+        width: rawRect.width,
+        height: rawRect.height
+      };
+    };
+    var getRectsFromRange = function (range) {
+      if (!range.collapsed) {
+        return map$2(range.getClientRects(), toRect);
+      } else {
+        var start_1 = SugarElement.fromDom(range.startContainer);
+        return parent(start_1).bind(function (parent) {
+          var selection = SimSelection.exact(start_1, range.startOffset, parent, getEnd(parent));
+          var optRect = getFirstRect(range.startContainer.ownerDocument.defaultView, selection);
+          return optRect.map(collapsedRect).map(pure$2);
+        }).getOr([]);
+      }
+    };
+    var getRectangles = function (cWin) {
+      var sel = cWin.getSelection();
+      return sel !== undefined && sel.rangeCount > 0 ? getRectsFromRange(sel.getRangeAt(0)) : [];
+    };
+
+    var autocompleteHack = function () {
+      return function (f) {
+        global$2.setTimeout(function () {
+          f();
+        }, 0);
+      };
+    };
+    var resume$1 = function (cWin) {
+      cWin.focus();
+      var iBody = SugarElement.fromDom(cWin.document.body);
+      var inInput = active().exists(function (elem) {
+        return contains$1([
+          'input',
+          'textarea'
+        ], name$1(elem));
+      });
+      var transaction = inInput ? autocompleteHack() : apply$1;
+      transaction(function () {
+        active().each(blur$1);
+        focus$3(iBody);
+      });
+    };
+
+    var EXTRA_SPACING = 50;
+    var data = 'data-' + resolve('last-outer-height');
+    var setLastHeight = function (cBody, value) {
+      set$8(cBody, data, value);
+    };
+    var getLastHeight = function (cBody) {
+      return safeParse(cBody, data);
+    };
+    var getBoundsFrom = function (rect) {
+      return {
+        top: rect.top,
+        bottom: rect.top + rect.height
+      };
+    };
+    var getBounds = function (cWin) {
+      var rects = getRectangles(cWin);
+      return rects.length > 0 ? Optional.some(rects[0]).map(getBoundsFrom) : Optional.none();
+    };
+    var findDelta = function (outerWindow, cBody) {
+      var last = getLastHeight(cBody);
+      var current = outerWindow.innerHeight;
+      return last > current ? Optional.some(last - current) : Optional.none();
+    };
+    var calculate = function (cWin, bounds, delta) {
+      var isOutside = bounds.top > cWin.innerHeight || bounds.bottom > cWin.innerHeight;
+      return isOutside ? Math.min(delta, bounds.bottom - cWin.innerHeight + EXTRA_SPACING) : 0;
+    };
+    var setup$2 = function (outerWindow, cWin) {
+      var cBody = SugarElement.fromDom(cWin.document.body);
+      var toEditing = function () {
+        resume$1(cWin);
+      };
+      var onResize = bind(SugarElement.fromDom(outerWindow), 'resize', function () {
+        findDelta(outerWindow, cBody).each(function (delta) {
+          getBounds(cWin).each(function (bounds) {
+            var cScrollBy = calculate(cWin, bounds, delta);
+            if (cScrollBy !== 0) {
+              cWin.scrollTo(cWin.pageXOffset, cWin.pageYOffset + cScrollBy);
+            }
+          });
+        });
+        setLastHeight(cBody, outerWindow.innerHeight);
+      });
+      setLastHeight(cBody, outerWindow.innerHeight);
+      var destroy = function () {
+        onResize.unbind();
+      };
+      return {
+        toEditing: toEditing,
+        destroy: destroy
+      };
+    };
+
+    var create$2 = function (platform, mask) {
+      var meta = tag();
+      var androidApi = api$2();
+      var androidEvents = api$2();
+      var enter = function () {
+        mask.hide();
+        add$1(platform.container, resolve('fullscreen-maximized'));
+        add$1(platform.container, resolve('android-maximized'));
+        meta.maximize();
+        add$1(platform.body, resolve('android-scroll-reload'));
+        androidApi.set(setup$2(platform.win, getWin(platform.editor).getOrDie('no')));
+        getActiveApi(platform.editor).each(function (editorApi) {
+          clobberStyles(platform.container, editorApi.body);
+          androidEvents.set(initEvents$1(editorApi, platform.toolstrip, platform.alloy));
+        });
+      };
+      var exit = function () {
+        meta.restore();
+        mask.show();
+        remove$3(platform.container, resolve('fullscreen-maximized'));
+        remove$3(platform.container, resolve('android-maximized'));
+        restoreStyles();
+        remove$3(platform.body, resolve('android-scroll-reload'));
+        androidEvents.clear();
+        androidApi.clear();
+      };
+      return {
+        enter: enter,
+        exit: exit
+      };
+    };
+
+    var first = function (fn, rate) {
+      var timer = null;
+      var cancel = function () {
+        if (!isNull(timer)) {
+          clearTimeout(timer);
+          timer = null;
+        }
+      };
+      var throttle = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        if (isNull(timer)) {
+          timer = setTimeout(function () {
+            timer = null;
+            fn.apply(null, args);
+          }, rate);
+        }
+      };
+      return {
+        cancel: cancel,
+        throttle: throttle
+      };
+    };
+    var last = function (fn, rate) {
+      var timer = null;
+      var cancel = function () {
+        if (!isNull(timer)) {
+          clearTimeout(timer);
+          timer = null;
+        }
+      };
+      var throttle = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        cancel();
+        timer = setTimeout(function () {
+          timer = null;
+          fn.apply(null, args);
+        }, rate);
+      };
+      return {
+        cancel: cancel,
+        throttle: throttle
+      };
+    };
+
+    var sketch = function (onView, _translate) {
+      var memIcon = record(Container.sketch({
+        dom: dom$1('<div aria-hidden="true" class="${prefix}-mask-tap-icon"></div>'),
+        containerBehaviours: derive$2([Toggling.config({
+            toggleClass: resolve('mask-tap-icon-selected'),
+            toggleOnExecute: false
+          })])
+      }));
+      var onViewThrottle = first(onView, 200);
+      return Container.sketch({
+        dom: dom$1('<div class="${prefix}-disabled-mask"></div>'),
+        components: [Container.sketch({
+            dom: dom$1('<div class="${prefix}-content-container"></div>'),
+            components: [Button.sketch({
+                dom: dom$1('<div class="${prefix}-content-tap-section"></div>'),
+                components: [memIcon.asSpec()],
+                action: function (_button) {
+                  onViewThrottle.throttle();
+                },
+                buttonBehaviours: derive$2([Toggling.config({ toggleClass: resolve('mask-tap-icon-selected') })])
+              })]
+          })]
+      });
+    };
+
+    var unbindNoop = constant$1({ unbind: noop });
+    var MobileSchema = objOf([
+      requiredObjOf('editor', [
+        required$1('getFrame'),
+        option('getBody'),
+        option('getDoc'),
+        option('getWin'),
+        option('getSelection'),
+        option('setSelection'),
+        option('clearSelection'),
+        option('cursorSaver'),
+        option('onKeyup'),
+        option('onNodeChanged'),
+        option('getCursorBox'),
+        required$1('onDomChanged'),
+        defaulted('onTouchContent', noop),
+        defaulted('onTapContent', noop),
+        defaulted('onTouchToolstrip', noop),
+        defaulted('onScrollToCursor', unbindNoop),
+        defaulted('onScrollToElement', unbindNoop),
+        defaulted('onToEditing', unbindNoop),
+        defaulted('onToReading', unbindNoop),
+        defaulted('onToolbarScrollStart', identity)
+      ]),
+      required$1('socket'),
+      required$1('toolstrip'),
+      required$1('dropup'),
+      required$1('toolbar'),
+      required$1('container'),
+      required$1('alloy'),
+      customField('win', function (spec) {
+        return owner$2(spec.socket).dom.defaultView;
+      }),
+      customField('body', function (spec) {
+        return SugarElement.fromDom(spec.socket.dom.ownerDocument.body);
+      }),
+      defaulted('translate', identity),
+      defaulted('setReadOnly', noop),
+      defaulted('readOnlyOnInit', always)
+    ]);
+
+    var produce$1 = function (raw) {
+      var mobile = asRawOrDie$1('Getting AndroidWebapp schema', MobileSchema, raw);
+      set$5(mobile.toolstrip, 'width', '100%');
+      var onTap = function () {
+        mobile.setReadOnly(mobile.readOnlyOnInit());
+        mode.enter();
+      };
+      var mask = build$1(sketch(onTap, mobile.translate));
+      mobile.alloy.add(mask);
+      var maskApi = {
+        show: function () {
+          mobile.alloy.add(mask);
+        },
+        hide: function () {
+          mobile.alloy.remove(mask);
+        }
+      };
+      append$2(mobile.container, mask.element);
+      var mode = create$2(mobile, maskApi);
+      return {
+        setReadOnly: mobile.setReadOnly,
+        refreshStructure: noop,
+        enter: mode.enter,
+        exit: mode.exit,
+        destroy: noop
+      };
+    };
+
+    var schema$1 = constant$1([
+      required$1('dom'),
+      defaulted('shell', true),
+      field$1('toolbarBehaviours', [Replacing])
+    ]);
+    var enhanceGroups = function () {
+      return { behaviours: derive$2([Replacing.config({})]) };
+    };
+    var parts$1 = constant$1([optional({
+        name: 'groups',
+        overrides: enhanceGroups
+      })]);
+
+    var factory$1 = function (detail, components, _spec, _externals) {
+      var setGroups = function (toolbar, groups) {
+        getGroupContainer(toolbar).fold(function () {
+          console.error('Toolbar was defined to not be a shell, but no groups container was specified in components');
+          throw new Error('Toolbar was defined to not be a shell, but no groups container was specified in components');
+        }, function (container) {
+          Replacing.set(container, groups);
+        });
+      };
+      var getGroupContainer = function (component) {
+        return detail.shell ? Optional.some(component) : getPart(component, detail, 'groups');
+      };
+      var extra = detail.shell ? {
+        behaviours: [Replacing.config({})],
+        components: []
+      } : {
+        behaviours: [],
+        components: components
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: extra.components,
+        behaviours: augment(detail.toolbarBehaviours, extra.behaviours),
+        apis: { setGroups: setGroups },
+        domModification: { attributes: { role: 'group' } }
+      };
+    };
+    var Toolbar = composite({
+      name: 'Toolbar',
+      configFields: schema$1(),
+      partFields: parts$1(),
+      factory: factory$1,
+      apis: {
+        setGroups: function (apis, toolbar, groups) {
+          apis.setGroups(toolbar, groups);
+        }
+      }
+    });
+
+    var schema = constant$1([
+      required$1('items'),
+      markers(['itemSelector']),
+      field$1('tgroupBehaviours', [Keying])
+    ]);
+    var parts = constant$1([group({
+        name: 'items',
+        unit: 'item'
+      })]);
+
+    var factory = function (detail, components, _spec, _externals) {
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: augment(detail.tgroupBehaviours, [Keying.config({
+            mode: 'flow',
+            selector: detail.markers.itemSelector
+          })]),
+        domModification: { attributes: { role: 'toolbar' } }
+      };
+    };
+    var ToolbarGroup = composite({
+      name: 'ToolbarGroup',
+      configFields: schema(),
+      partFields: parts(),
+      factory: factory
+    });
+
+    var dataHorizontal = 'data-' + resolve('horizontal-scroll');
+    var canScrollVertically = function (container) {
+      container.dom.scrollTop = 1;
+      var result = container.dom.scrollTop !== 0;
+      container.dom.scrollTop = 0;
+      return result;
+    };
+    var canScrollHorizontally = function (container) {
+      container.dom.scrollLeft = 1;
+      var result = container.dom.scrollLeft !== 0;
+      container.dom.scrollLeft = 0;
+      return result;
+    };
+    var hasVerticalScroll = function (container) {
+      return container.dom.scrollTop > 0 || canScrollVertically(container);
+    };
+    var hasHorizontalScroll = function (container) {
+      return container.dom.scrollLeft > 0 || canScrollHorizontally(container);
+    };
+    var markAsHorizontal = function (container) {
+      set$8(container, dataHorizontal, 'true');
+    };
+    var hasScroll = function (container) {
+      return get$b(container, dataHorizontal) === 'true' ? hasHorizontalScroll(container) : hasVerticalScroll(container);
+    };
+    var exclusive = function (scope, selector) {
+      return bind(scope, 'touchmove', function (event) {
+        closest$1(event.target, selector).filter(hasScroll).fold(function () {
+          event.prevent();
+        }, noop);
+      });
+    };
+
+    var ScrollingToolbar = function () {
+      var makeGroup = function (gSpec) {
+        var scrollClass = gSpec.scrollable === true ? '${prefix}-toolbar-scrollable-group' : '';
+        return {
+          dom: dom$1('<div aria-label="' + gSpec.label + '" class="${prefix}-toolbar-group ' + scrollClass + '"></div>'),
+          tgroupBehaviours: derive$2([config('adhoc-scrollable-toolbar', gSpec.scrollable === true ? [runOnInit(function (component, _simulatedEvent) {
+                set$5(component.element, 'overflow-x', 'auto');
+                markAsHorizontal(component.element);
+                register$2(component.element);
+              })] : [])]),
+          components: [Container.sketch({ components: [ToolbarGroup.parts.items({})] })],
+          markers: { itemSelector: '.' + resolve('toolbar-group-item') },
+          items: gSpec.items
+        };
+      };
+      var toolbar = build$1(Toolbar.sketch({
+        dom: dom$1('<div class="${prefix}-toolbar"></div>'),
+        components: [Toolbar.parts.groups({})],
+        toolbarBehaviours: derive$2([
+          Toggling.config({
+            toggleClass: resolve('context-toolbar'),
+            toggleOnExecute: false,
+            aria: { mode: 'none' }
+          }),
+          Keying.config({ mode: 'cyclic' })
+        ]),
+        shell: true
+      }));
+      var wrapper = build$1(Container.sketch({
+        dom: { classes: [resolve('toolstrip')] },
+        components: [premade(toolbar)],
+        containerBehaviours: derive$2([Toggling.config({
+            toggleClass: resolve('android-selection-context-toolbar'),
+            toggleOnExecute: false
+          })])
+      }));
+      var resetGroups = function () {
+        Toolbar.setGroups(toolbar, initGroups.get());
+        Toggling.off(toolbar);
+      };
+      var initGroups = Cell([]);
+      var setGroups = function (gs) {
+        initGroups.set(gs);
+        resetGroups();
+      };
+      var createGroups = function (gs) {
+        return map$2(gs, compose(ToolbarGroup.sketch, makeGroup));
+      };
+      var refresh = function () {
+      };
+      var setContextToolbar = function (gs) {
+        Toggling.on(toolbar);
+        Toolbar.setGroups(toolbar, gs);
+      };
+      var restoreToolbar = function () {
+        if (Toggling.isOn(toolbar)) {
+          resetGroups();
+        }
+      };
+      var focus = function () {
+        Keying.focusIn(toolbar);
+      };
+      return {
+        wrapper: wrapper,
+        toolbar: toolbar,
+        createGroups: createGroups,
+        setGroups: setGroups,
+        setContextToolbar: setContextToolbar,
+        restoreToolbar: restoreToolbar,
+        refresh: refresh,
+        focus: focus
+      };
+    };
+
+    var makeEditSwitch = function (webapp) {
+      return build$1(Button.sketch({
+        dom: dom$1('<div class="${prefix}-mask-edit-icon ${prefix}-icon"></div>'),
+        action: function () {
+          webapp.run(function (w) {
+            w.setReadOnly(false);
+          });
+        }
+      }));
+    };
+    var makeSocket = function () {
+      return build$1(Container.sketch({
+        dom: dom$1('<div class="${prefix}-editor-socket"></div>'),
+        components: [],
+        containerBehaviours: derive$2([Replacing.config({})])
+      }));
+    };
+    var showEdit = function (socket, switchToEdit) {
+      Replacing.append(socket, premade(switchToEdit));
+    };
+    var hideEdit = function (socket, switchToEdit) {
+      Replacing.remove(socket, switchToEdit);
+    };
+    var updateMode = function (socket, switchToEdit, readOnly, root) {
+      var swap = readOnly === true ? Swapping.toAlpha : Swapping.toOmega;
+      swap(root);
+      var f = readOnly ? showEdit : hideEdit;
+      f(socket, switchToEdit);
+    };
+
+    var getAnimationRoot = function (component, slideConfig) {
+      return slideConfig.getAnimationRoot.fold(function () {
+        return component.element;
+      }, function (get) {
+        return get(component);
+      });
+    };
+
+    var getDimensionProperty = function (slideConfig) {
+      return slideConfig.dimension.property;
+    };
+    var getDimension = function (slideConfig, elem) {
+      return slideConfig.dimension.getDimension(elem);
+    };
+    var disableTransitions = function (component, slideConfig) {
+      var root = getAnimationRoot(component, slideConfig);
+      remove$1(root, [
+        slideConfig.shrinkingClass,
+        slideConfig.growingClass
+      ]);
+    };
+    var setShrunk = function (component, slideConfig) {
+      remove$3(component.element, slideConfig.openClass);
+      add$1(component.element, slideConfig.closedClass);
+      set$5(component.element, getDimensionProperty(slideConfig), '0px');
+      reflow(component.element);
+    };
+    var setGrown = function (component, slideConfig) {
+      remove$3(component.element, slideConfig.closedClass);
+      add$1(component.element, slideConfig.openClass);
+      remove$2(component.element, getDimensionProperty(slideConfig));
+    };
+    var doImmediateShrink = function (component, slideConfig, slideState, _calculatedSize) {
+      slideState.setCollapsed();
+      set$5(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$5(component.element, getDimensionProperty(slideConfig), size);
+      reflow(component.element);
+      var root = getAnimationRoot(component, slideConfig);
+      remove$3(root, slideConfig.growingClass);
+      add$1(root, slideConfig.shrinkingClass);
+      setShrunk(component, slideConfig);
+      slideConfig.onStartShrink(component);
+    };
+    var doStartSmartShrink = function (component, slideConfig, slideState) {
+      var size = getDimension(slideConfig, component.element);
+      var shrinker = size === '0px' ? doImmediateShrink : doStartShrink;
+      shrinker(component, slideConfig, slideState, Optional.some(size));
+    };
+    var doStartGrow = function (component, slideConfig, slideState) {
+      var root = getAnimationRoot(component, slideConfig);
+      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$5(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);
+      add$1(root, slideConfig.growingClass);
+      setGrown(component, slideConfig);
+      set$5(component.element, getDimensionProperty(slideConfig), fullSize);
+      slideState.setExpanded();
+      slideConfig.onStartGrow(component);
+    };
+    var refresh$1 = function (component, slideConfig, slideState) {
+      if (slideState.isExpanded()) {
+        remove$2(component.element, getDimensionProperty(slideConfig));
+        var fullSize = getDimension(slideConfig, component.element);
+        set$5(component.element, getDimensionProperty(slideConfig), fullSize);
+      }
+    };
+    var grow = function (component, slideConfig, slideState) {
+      if (!slideState.isExpanded()) {
+        doStartGrow(component, slideConfig, slideState);
+      }
+    };
+    var shrink = function (component, slideConfig, slideState) {
+      if (slideState.isExpanded()) {
+        doStartSmartShrink(component, slideConfig, slideState);
+      }
+    };
+    var immediateShrink = function (component, slideConfig, slideState) {
+      if (slideState.isExpanded()) {
+        doImmediateShrink(component, slideConfig, slideState);
+      }
+    };
+    var hasGrown = function (component, slideConfig, slideState) {
+      return slideState.isExpanded();
+    };
+    var hasShrunk = function (component, slideConfig, slideState) {
+      return slideState.isCollapsed();
+    };
+    var isGrowing = function (component, slideConfig, _slideState) {
+      var root = getAnimationRoot(component, slideConfig);
+      return has(root, slideConfig.growingClass) === true;
+    };
+    var isShrinking = function (component, slideConfig, _slideState) {
+      var root = getAnimationRoot(component, slideConfig);
+      return has(root, slideConfig.shrinkingClass) === true;
+    };
+    var isTransitioning = function (component, slideConfig, slideState) {
+      return isGrowing(component, slideConfig) || isShrinking(component, slideConfig);
+    };
+    var toggleGrow = function (component, slideConfig, slideState) {
+      var f = slideState.isExpanded() ? doStartSmartShrink : doStartGrow;
+      f(component, slideConfig, slideState);
+    };
+
+    var SlidingApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        refresh: refresh$1,
+        grow: grow,
+        shrink: shrink,
+        immediateShrink: immediateShrink,
+        hasGrown: hasGrown,
+        hasShrunk: hasShrunk,
+        isGrowing: isGrowing,
+        isShrinking: isShrinking,
+        isTransitioning: isTransitioning,
+        toggleGrow: toggleGrow,
+        disableTransitions: disableTransitions
+    });
+
+    var exhibit = function (base, slideConfig, _slideState) {
+      var expanded = slideConfig.expanded;
+      return expanded ? nu$3({
+        classes: [slideConfig.openClass],
+        styles: {}
+      }) : nu$3({
+        classes: [slideConfig.closedClass],
+        styles: wrap(slideConfig.dimension.property, '0px')
+      });
+    };
+    var events = function (slideConfig, slideState) {
+      return derive$3([runOnSource(transitionend(), function (component, simulatedEvent) {
+          var raw = simulatedEvent.event.raw;
+          if (raw.propertyName === slideConfig.dimension.property) {
+            disableTransitions(component, slideConfig);
+            if (slideState.isExpanded()) {
+              remove$2(component.element, slideConfig.dimension.property);
+            }
+            var notify = slideState.isExpanded() ? slideConfig.onGrown : slideConfig.onShrunk;
+            notify(component);
+          }
+        })]);
+    };
+
+    var ActiveSliding = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit,
+        events: events
+    });
+
+    var SlidingSchema = [
+      required$1('closedClass'),
+      required$1('openClass'),
+      required$1('shrinkingClass'),
+      required$1('growingClass'),
+      option('getAnimationRoot'),
+      onHandler('onShrunk'),
+      onHandler('onStartShrink'),
+      onHandler('onGrown'),
+      onHandler('onStartGrow'),
+      defaulted('expanded', false),
+      requiredOf('dimension', choose$1('property', {
+        width: [
+          output('property', 'width'),
+          output('getDimension', function (elem) {
+            return get$5(elem) + 'px';
+          })
+        ],
+        height: [
+          output('property', 'height'),
+          output('getDimension', function (elem) {
+            return get$7(elem) + 'px';
+          })
+        ]
+      }))
+    ];
+
+    var init$1 = function (spec) {
+      var state = Cell(spec.expanded);
+      var readState = function () {
+        return 'expanded: ' + state.get();
+      };
+      return nu$2({
+        isExpanded: function () {
+          return state.get() === true;
+        },
+        isCollapsed: function () {
+          return state.get() === false;
+        },
+        setCollapsed: curry(state.set, false),
+        setExpanded: curry(state.set, true),
+        readState: readState
+      });
+    };
+
+    var SlidingState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init$1
+    });
+
+    var Sliding = create$5({
+      fields: SlidingSchema,
+      name: 'sliding',
+      active: ActiveSliding,
+      apis: SlidingApis,
+      state: SlidingState
+    });
+
+    var build = function (refresh, scrollIntoView) {
+      var dropup = build$1(Container.sketch({
+        dom: {
+          tag: 'div',
+          classes: [resolve('dropup')]
+        },
+        components: [],
+        containerBehaviours: derive$2([
+          Replacing.config({}),
+          Sliding.config({
+            closedClass: resolve('dropup-closed'),
+            openClass: resolve('dropup-open'),
+            shrinkingClass: resolve('dropup-shrinking'),
+            growingClass: resolve('dropup-growing'),
+            dimension: { property: 'height' },
+            onShrunk: function (component) {
+              refresh();
+              scrollIntoView();
+              Replacing.set(component, []);
+            },
+            onGrown: function (_component) {
+              refresh();
+              scrollIntoView();
+            }
+          }),
+          orientation(function (_component, _data) {
+            disappear(noop);
+          })
+        ])
+      }));
+      var appear = function (menu, update, component) {
+        if (Sliding.hasShrunk(dropup) === true && Sliding.isTransitioning(dropup) === false) {
+          window.requestAnimationFrame(function () {
+            update(component);
+            Replacing.set(dropup, [menu()]);
+            Sliding.grow(dropup);
+          });
+        }
+      };
+      var disappear = function (onReadyToShrink) {
+        window.requestAnimationFrame(function () {
+          onReadyToShrink();
+          Sliding.shrink(dropup);
+        });
+      };
+      return {
+        appear: appear,
+        disappear: disappear,
+        component: dropup,
+        element: dropup.element
+      };
+    };
+
+    var closest = function (scope, selector, isRoot) {
+      return closest$1(scope, selector, isRoot).isSome();
+    };
+
+    var isDangerous = function (event) {
+      var keyEv = event.raw;
+      return keyEv.which === BACKSPACE[0] && !contains$1([
+        'input',
+        'textarea'
+      ], name$1(event.target)) && !closest(event.target, '[contenteditable="true"]');
+    };
+    var isFirefox = function () {
+      return detect$1().browser.isFirefox();
+    };
+    var bindFocus = function (container, handler) {
+      if (isFirefox()) {
+        return capture(container, 'focus', handler);
+      } else {
+        return bind(container, 'focusin', handler);
+      }
+    };
+    var bindBlur = function (container, handler) {
+      if (isFirefox()) {
+        return capture(container, 'blur', handler);
+      } else {
+        return bind(container, 'focusout', handler);
+      }
+    };
+    var setup$1 = function (container, rawSettings) {
+      var settings = __assign({ stopBackspace: true }, rawSettings);
+      var pointerEvents = [
+        'touchstart',
+        'touchmove',
+        'touchend',
+        'touchcancel',
+        'gesturestart',
+        'mousedown',
+        'mouseup',
+        'mouseover',
+        'mousemove',
+        'mouseout',
+        'click'
+      ];
+      var tapEvent = monitor$1(settings);
+      var simpleEvents = map$2(pointerEvents.concat([
+        'selectstart',
+        'input',
+        'contextmenu',
+        'change',
+        'transitionend',
+        'transitioncancel',
+        'drag',
+        'dragstart',
+        'dragend',
+        'dragenter',
+        'dragleave',
+        'dragover',
+        'drop',
+        'keyup'
+      ]), function (type) {
+        return bind(container, type, function (event) {
+          tapEvent.fireIfReady(event, type).each(function (tapStopped) {
+            if (tapStopped) {
+              event.kill();
+            }
+          });
+          var stopped = settings.triggerEvent(type, event);
+          if (stopped) {
+            event.kill();
+          }
+        });
+      });
+      var pasteTimeout = value();
+      var onPaste = bind(container, 'paste', function (event) {
+        tapEvent.fireIfReady(event, 'paste').each(function (tapStopped) {
+          if (tapStopped) {
+            event.kill();
+          }
+        });
+        var stopped = settings.triggerEvent('paste', event);
+        if (stopped) {
+          event.kill();
+        }
+        pasteTimeout.set(setTimeout(function () {
+          settings.triggerEvent(postPaste(), event);
+        }, 0));
+      });
+      var onKeydown = bind(container, 'keydown', function (event) {
+        var stopped = settings.triggerEvent('keydown', event);
+        if (stopped) {
+          event.kill();
+        } else if (settings.stopBackspace && isDangerous(event)) {
+          event.prevent();
+        }
+      });
+      var onFocusIn = bindFocus(container, function (event) {
+        var stopped = settings.triggerEvent('focusin', event);
+        if (stopped) {
+          event.kill();
+        }
+      });
+      var focusoutTimeout = value();
+      var onFocusOut = bindBlur(container, function (event) {
+        var stopped = settings.triggerEvent('focusout', event);
+        if (stopped) {
+          event.kill();
+        }
+        focusoutTimeout.set(setTimeout(function () {
+          settings.triggerEvent(postBlur(), event);
+        }, 0));
+      });
+      var unbind = function () {
+        each$1(simpleEvents, function (e) {
+          e.unbind();
+        });
+        onKeydown.unbind();
+        onFocusIn.unbind();
+        onFocusOut.unbind();
+        onPaste.unbind();
+        pasteTimeout.on(clearTimeout);
+        focusoutTimeout.on(clearTimeout);
+      };
+      return { unbind: unbind };
+    };
+
+    var derive$1 = function (rawEvent, rawTarget) {
+      var source = get$c(rawEvent, 'target').getOr(rawTarget);
+      return Cell(source);
+    };
+
+    var fromSource = function (event, source) {
+      var stopper = Cell(false);
+      var cutter = Cell(false);
+      var stop = function () {
+        stopper.set(true);
+      };
+      var cut = function () {
+        cutter.set(true);
+      };
+      return {
+        stop: stop,
+        cut: cut,
+        isStopped: stopper.get,
+        isCut: cutter.get,
+        event: event,
+        setSource: source.set,
+        getSource: source.get
+      };
+    };
+    var fromExternal = function (event) {
+      var stopper = Cell(false);
+      var stop = function () {
+        stopper.set(true);
+      };
+      return {
+        stop: stop,
+        cut: noop,
+        isStopped: stopper.get,
+        isCut: never,
+        event: event,
+        setSource: die('Cannot set source of a broadcasted event'),
+        getSource: die('Cannot get source of a broadcasted event')
+      };
+    };
+
+    var adt = Adt.generate([
+      { stopped: [] },
+      { resume: ['element'] },
+      { complete: [] }
+    ]);
+    var doTriggerHandler = function (lookup, eventType, rawEvent, target, source, logger) {
+      var handler = lookup(eventType, target);
+      var simulatedEvent = fromSource(rawEvent, source);
+      return handler.fold(function () {
+        logger.logEventNoHandlers(eventType, target);
+        return adt.complete();
+      }, function (handlerInfo) {
+        var descHandler = handlerInfo.descHandler;
+        var eventHandler = getCurried(descHandler);
+        eventHandler(simulatedEvent);
+        if (simulatedEvent.isStopped()) {
+          logger.logEventStopped(eventType, handlerInfo.element, descHandler.purpose);
+          return adt.stopped();
+        } else if (simulatedEvent.isCut()) {
+          logger.logEventCut(eventType, handlerInfo.element, descHandler.purpose);
+          return adt.complete();
+        } else {
+          return parent(handlerInfo.element).fold(function () {
+            logger.logNoParent(eventType, handlerInfo.element, descHandler.purpose);
+            return adt.complete();
+          }, function (parent) {
+            logger.logEventResponse(eventType, handlerInfo.element, descHandler.purpose);
+            return adt.resume(parent);
+          });
+        }
+      });
+    };
+    var doTriggerOnUntilStopped = function (lookup, eventType, rawEvent, rawTarget, source, logger) {
+      return doTriggerHandler(lookup, eventType, rawEvent, rawTarget, source, logger).fold(always, function (parent) {
+        return doTriggerOnUntilStopped(lookup, eventType, rawEvent, parent, source, logger);
+      }, never);
+    };
+    var triggerHandler = function (lookup, eventType, rawEvent, target, logger) {
+      var source = derive$1(rawEvent, target);
+      return doTriggerHandler(lookup, eventType, rawEvent, target, source, logger);
+    };
+    var broadcast = function (listeners, rawEvent, _logger) {
+      var simulatedEvent = fromExternal(rawEvent);
+      each$1(listeners, function (listener) {
+        var descHandler = listener.descHandler;
+        var handler = getCurried(descHandler);
+        handler(simulatedEvent);
+      });
+      return simulatedEvent.isStopped();
+    };
+    var triggerUntilStopped = function (lookup, eventType, rawEvent, logger) {
+      return triggerOnUntilStopped(lookup, eventType, rawEvent, rawEvent.target, logger);
+    };
+    var triggerOnUntilStopped = function (lookup, eventType, rawEvent, rawTarget, logger) {
+      var source = derive$1(rawEvent, rawTarget);
+      return doTriggerOnUntilStopped(lookup, eventType, rawEvent, rawTarget, source, logger);
+    };
+
+    var eventHandler = function (element, descHandler) {
+      return {
+        element: element,
+        descHandler: descHandler
+      };
+    };
+    var broadcastHandler = function (id, handler) {
+      return {
+        id: id,
+        descHandler: handler
+      };
+    };
+    var EventRegistry = function () {
+      var registry = {};
+      var registerId = function (extraArgs, id, events) {
+        each(events, function (v, k) {
+          var handlers = registry[k] !== undefined ? registry[k] : {};
+          handlers[id] = curryArgs(v, extraArgs);
+          registry[k] = handlers;
+        });
+      };
+      var findHandler = function (handlers, elem) {
+        return read(elem).bind(function (id) {
+          return get$c(handlers, id);
+        }).map(function (descHandler) {
+          return eventHandler(elem, descHandler);
+        });
+      };
+      var filterByType = function (type) {
+        return get$c(registry, type).map(function (handlers) {
+          return mapToArray(handlers, function (f, id) {
+            return broadcastHandler(id, f);
+          });
+        }).getOr([]);
+      };
+      var find = function (isAboveRoot, type, target) {
+        return get$c(registry, type).bind(function (handlers) {
+          return closest$3(target, function (elem) {
+            return findHandler(handlers, elem);
+          }, isAboveRoot);
+        });
+      };
+      var unregisterId = function (id) {
+        each(registry, function (handlersById, _eventName) {
+          if (has$2(handlersById, id)) {
+            delete handlersById[id];
+          }
+        });
+      };
+      return {
+        registerId: registerId,
+        unregisterId: unregisterId,
+        filterByType: filterByType,
+        find: find
+      };
+    };
+
+    var Registry = function () {
+      var events = EventRegistry();
+      var components = {};
+      var readOrTag = function (component) {
+        var elem = component.element;
+        return read(elem).getOrThunk(function () {
+          return write('uid-', component.element);
+        });
+      };
+      var failOnDuplicate = function (component, tagId) {
+        var conflict = components[tagId];
+        if (conflict === component) {
+          unregister(component);
+        } else {
+          throw new Error('The tagId "' + tagId + '" is already used by: ' + element(conflict.element) + '\nCannot use it for: ' + element(component.element) + '\n' + 'The conflicting element is' + (inBody(conflict.element) ? ' ' : ' not ') + 'already in the DOM');
+        }
+      };
+      var register = function (component) {
+        var tagId = readOrTag(component);
+        if (hasNonNullableKey(components, tagId)) {
+          failOnDuplicate(component, tagId);
+        }
+        var extraArgs = [component];
+        events.registerId(extraArgs, tagId, component.events);
+        components[tagId] = component;
+      };
+      var unregister = function (component) {
+        read(component.element).each(function (tagId) {
+          delete components[tagId];
+          events.unregisterId(tagId);
+        });
+      };
+      var filter = function (type) {
+        return events.filterByType(type);
+      };
+      var find = function (isAboveRoot, type, target) {
+        return events.find(isAboveRoot, type, target);
+      };
+      var getById = function (id) {
+        return get$c(components, id);
+      };
+      return {
+        find: find,
+        filter: filter,
+        register: register,
+        unregister: unregister,
+        getById: getById
+      };
+    };
+
+    var takeover$1 = function (root) {
+      var isAboveRoot = function (el) {
+        return parent(root.element).fold(always, function (parent) {
+          return eq(el, parent);
+        });
+      };
+      var registry = Registry();
+      var lookup = function (eventName, target) {
+        return registry.find(isAboveRoot, eventName, target);
+      };
+      var domEvents = setup$1(root.element, {
+        triggerEvent: function (eventName, event) {
+          return monitorEvent(eventName, event.target, function (logger) {
+            return triggerUntilStopped(lookup, eventName, event, logger);
+          });
+        }
+      });
+      var systemApi = {
+        debugInfo: constant$1('real'),
+        triggerEvent: function (eventName, target, data) {
+          monitorEvent(eventName, target, function (logger) {
+            return triggerOnUntilStopped(lookup, eventName, data, target, logger);
+          });
+        },
+        triggerFocus: function (target, originator) {
+          read(target).fold(function () {
+            focus$3(target);
+          }, function (_alloyId) {
+            monitorEvent(focus$4(), target, function (logger) {
+              triggerHandler(lookup, focus$4(), {
+                originator: originator,
+                kill: noop,
+                prevent: noop,
+                target: target
+              }, target, logger);
+              return false;
+            });
+          });
+        },
+        triggerEscape: function (comp, simulatedEvent) {
+          systemApi.triggerEvent('keydown', comp.element, simulatedEvent.event);
+        },
+        getByUid: function (uid) {
+          return getByUid(uid);
+        },
+        getByDom: function (elem) {
+          return getByDom(elem);
+        },
+        build: build$1,
+        addToGui: function (c) {
+          add(c);
+        },
+        removeFromGui: function (c) {
+          remove(c);
+        },
+        addToWorld: function (c) {
+          addToWorld(c);
+        },
+        removeFromWorld: function (c) {
+          removeFromWorld(c);
+        },
+        broadcast: function (message) {
+          broadcast$1(message);
+        },
+        broadcastOn: function (channels, message) {
+          broadcastOn(channels, message);
+        },
+        broadcastEvent: function (eventName, event) {
+          broadcastEvent(eventName, event);
+        },
+        isConnected: always
+      };
+      var addToWorld = function (component) {
+        component.connect(systemApi);
+        if (!isText(component.element)) {
+          registry.register(component);
+          each$1(component.components(), addToWorld);
+          systemApi.triggerEvent(systemInit(), component.element, { target: component.element });
+        }
+      };
+      var removeFromWorld = function (component) {
+        if (!isText(component.element)) {
+          each$1(component.components(), removeFromWorld);
+          registry.unregister(component);
+        }
+        component.disconnect();
+      };
+      var add = function (component) {
+        attach(root, component);
+      };
+      var remove = function (component) {
+        detach(component);
+      };
+      var destroy = function () {
+        domEvents.unbind();
+        remove$7(root.element);
+      };
+      var broadcastData = function (data) {
+        var receivers = registry.filter(receive$1());
+        each$1(receivers, function (receiver) {
+          var descHandler = receiver.descHandler;
+          var handler = getCurried(descHandler);
+          handler(data);
+        });
+      };
+      var broadcast$1 = function (message) {
+        broadcastData({
+          universal: true,
+          data: message
+        });
+      };
+      var broadcastOn = function (channels, message) {
+        broadcastData({
+          universal: false,
+          channels: channels,
+          data: message
+        });
+      };
+      var broadcastEvent = function (eventName, event) {
+        var listeners = registry.filter(eventName);
+        return broadcast(listeners, event);
+      };
+      var getByUid = function (uid) {
+        return registry.getById(uid).fold(function () {
+          return Result.error(new Error('Could not find component with uid: "' + uid + '" in system.'));
+        }, Result.value);
+      };
+      var getByDom = function (elem) {
+        var uid = read(elem).getOr('not found');
+        return getByUid(uid);
+      };
+      addToWorld(root);
+      return {
+        root: root,
+        element: root.element,
+        destroy: destroy,
+        add: add,
+        remove: remove,
+        getByUid: getByUid,
+        getByDom: getByDom,
+        addToWorld: addToWorld,
+        removeFromWorld: removeFromWorld,
+        broadcast: broadcast$1,
+        broadcastOn: broadcastOn,
+        broadcastEvent: broadcastEvent
+      };
+    };
+
+    var READ_ONLY_MODE_CLASS = resolve('readonly-mode');
+    var EDIT_MODE_CLASS = resolve('edit-mode');
+    function OuterContainer (spec) {
+      var root = build$1(Container.sketch({
+        dom: { classes: [resolve('outer-container')].concat(spec.classes) },
+        containerBehaviours: derive$2([Swapping.config({
+            alpha: READ_ONLY_MODE_CLASS,
+            omega: EDIT_MODE_CLASS
+          })])
+      }));
+      return takeover$1(root);
+    }
+
+    function AndroidRealm (scrollIntoView) {
+      var alloy = OuterContainer({ classes: [resolve('android-container')] });
+      var toolbar = ScrollingToolbar();
+      var webapp = api$2();
+      var switchToEdit = makeEditSwitch(webapp);
+      var socket = makeSocket();
+      var dropup = build(noop, scrollIntoView);
+      alloy.add(toolbar.wrapper);
+      alloy.add(socket);
+      alloy.add(dropup.component);
+      var setToolbarGroups = function (rawGroups) {
+        var groups = toolbar.createGroups(rawGroups);
+        toolbar.setGroups(groups);
+      };
+      var setContextToolbar = function (rawGroups) {
+        var groups = toolbar.createGroups(rawGroups);
+        toolbar.setContextToolbar(groups);
+      };
+      var focusToolbar = function () {
+        toolbar.focus();
+      };
+      var restoreToolbar = function () {
+        toolbar.restoreToolbar();
+      };
+      var init = function (spec) {
+        webapp.set(produce$1(spec));
+      };
+      var exit = function () {
+        webapp.run(function (w) {
+          w.exit();
+          Replacing.remove(socket, switchToEdit);
+        });
+      };
+      var updateMode$1 = function (readOnly) {
+        updateMode(socket, switchToEdit, readOnly, alloy.root);
+      };
+      return {
+        system: alloy,
+        element: alloy.element,
+        init: init,
+        exit: exit,
+        setToolbarGroups: setToolbarGroups,
+        setContextToolbar: setContextToolbar,
+        focusToolbar: focusToolbar,
+        restoreToolbar: restoreToolbar,
+        updateMode: updateMode$1,
+        socket: socket,
+        dropup: dropup
+      };
+    }
+
+    var input = function (parent, operation) {
+      var input = SugarElement.fromTag('input');
+      setAll(input, {
+        opacity: '0',
+        position: 'absolute',
+        top: '-1000px',
+        left: '-1000px'
+      });
+      append$2(parent, input);
+      focus$3(input);
+      operation(input);
+      remove$7(input);
+    };
+
+    var refresh = function (winScope) {
+      var sel = winScope.getSelection();
+      if (sel.rangeCount > 0) {
+        var br = sel.getRangeAt(0);
+        var r = winScope.document.createRange();
+        r.setStart(br.startContainer, br.startOffset);
+        r.setEnd(br.endContainer, br.endOffset);
+        sel.removeAllRanges();
+        sel.addRange(r);
+      }
+    };
+
+    var resume = function (cWin, frame) {
+      active().each(function (active) {
+        if (!eq(active, frame)) {
+          blur$1(active);
+        }
+      });
+      cWin.focus();
+      focus$3(SugarElement.fromDom(cWin.document.body));
+      refresh(cWin);
+    };
+
+    var stubborn = function (outerBody, cWin, page, frame) {
+      var toEditing = function () {
+        resume(cWin, frame);
+      };
+      var toReading = function () {
+        input(outerBody, blur$1);
+      };
+      var captureInput = bind(page, 'keydown', function (evt) {
+        if (!contains$1([
+            'input',
+            'textarea'
+          ], name$1(evt.target))) {
+          toEditing();
+        }
+      });
+      var onToolbarTouch = noop;
+      var destroy = function () {
+        captureInput.unbind();
+      };
+      return {
+        toReading: toReading,
+        toEditing: toEditing,
+        onToolbarTouch: onToolbarTouch,
+        destroy: destroy
+      };
+    };
+
+    var initEvents = function (editorApi, iosApi, toolstrip, socket, _dropup) {
+      var saveSelectionFirst = function () {
+        iosApi.run(function (api) {
+          api.highlightSelection();
+        });
+      };
+      var refreshIosSelection = function () {
+        iosApi.run(function (api) {
+          api.refreshSelection();
+        });
+      };
+      var scrollToY = function (yTop, height) {
+        var y = yTop - socket.dom.scrollTop;
+        iosApi.run(function (api) {
+          api.scrollIntoView(y, y + height);
+        });
+      };
+      var scrollToElement = function (_target) {
+        scrollToY(iosApi, socket);
+      };
+      var scrollToCursor = function () {
+        editorApi.getCursorBox().each(function (box) {
+          scrollToY(box.top, box.height);
+        });
+      };
+      var clearSelection = function () {
+        iosApi.run(function (api) {
+          api.clearSelection();
+        });
+      };
+      var clearAndRefresh = function () {
+        clearSelection();
+        refreshThrottle.throttle();
+      };
+      var refreshView = function () {
+        scrollToCursor();
+        iosApi.run(function (api) {
+          api.syncHeight();
+        });
+      };
+      var reposition = function () {
+        var toolbarHeight = get$7(toolstrip);
+        iosApi.run(function (api) {
+          api.setViewportOffset(toolbarHeight);
+        });
+        refreshIosSelection();
+        refreshView();
+      };
+      var toEditing = function () {
+        iosApi.run(function (api) {
+          api.toEditing();
+        });
+      };
+      var toReading = function () {
+        iosApi.run(function (api) {
+          api.toReading();
+        });
+      };
+      var onToolbarTouch = function (event) {
+        iosApi.run(function (api) {
+          api.onToolbarTouch(event);
+        });
+      };
+      var tapping = monitor(editorApi);
+      var refreshThrottle = last(refreshView, 300);
+      var listeners = [
+        editorApi.onKeyup(clearAndRefresh),
+        editorApi.onNodeChanged(refreshIosSelection),
+        editorApi.onDomChanged(refreshThrottle.throttle),
+        editorApi.onDomChanged(refreshIosSelection),
+        editorApi.onScrollToCursor(function (tinyEvent) {
+          tinyEvent.preventDefault();
+          refreshThrottle.throttle();
+        }),
+        editorApi.onScrollToElement(function (event) {
+          scrollToElement(event.element);
+        }),
+        editorApi.onToEditing(toEditing),
+        editorApi.onToReading(toReading),
+        bind(editorApi.doc, 'touchend', function (touchEvent) {
+          if (eq(editorApi.html, touchEvent.target) || eq(editorApi.body, touchEvent.target)) ;
+        }),
+        bind(toolstrip, 'transitionend', function (transitionEvent) {
+          if (transitionEvent.raw.propertyName === 'height') {
+            reposition();
+          }
+        }),
+        capture(toolstrip, 'touchstart', function (touchEvent) {
+          saveSelectionFirst();
+          onToolbarTouch(touchEvent);
+          editorApi.onTouchToolstrip();
+        }),
+        bind(editorApi.body, 'touchstart', function (evt) {
+          clearSelection();
+          editorApi.onTouchContent();
+          tapping.fireTouchstart(evt);
+        }),
+        tapping.onTouchmove(),
+        tapping.onTouchend(),
+        bind(editorApi.body, 'click', function (event) {
+          event.kill();
+        }),
+        bind(toolstrip, 'touchmove', function () {
+          editorApi.onToolbarScrollStart();
+        })
+      ];
+      var destroy = function () {
+        each$1(listeners, function (l) {
+          l.unbind();
+        });
+      };
+      return { destroy: destroy };
+    };
+
+    function FakeSelection (win, frame) {
+      var doc = win.document;
+      var container = SugarElement.fromTag('div');
+      add$1(container, resolve('unfocused-selections'));
+      append$2(SugarElement.fromDom(doc.documentElement), container);
+      var onTouch = bind(container, 'touchstart', function (event) {
+        event.prevent();
+        resume(win, frame);
+        clear();
+      });
+      var make = function (rectangle) {
+        var span = SugarElement.fromTag('span');
+        add(span, [
+          resolve('layer-editor'),
+          resolve('unfocused-selection')
+        ]);
+        setAll(span, {
+          left: rectangle.left + 'px',
+          top: rectangle.top + 'px',
+          width: rectangle.width + 'px',
+          height: rectangle.height + 'px'
+        });
+        return span;
+      };
+      var update = function () {
+        clear();
+        var rectangles = getRectangles(win);
+        var spans = map$2(rectangles, make);
+        append$1(container, spans);
+      };
+      var clear = function () {
+        empty(container);
+      };
+      var destroy = function () {
+        onTouch.unbind();
+        remove$7(container);
+      };
+      var isActive = function () {
+        return children(container).length > 0;
+      };
+      return {
+        update: update,
+        isActive: isActive,
+        destroy: destroy,
+        clear: clear
+      };
+    }
+
+    var nu$1 = function (baseFn) {
+      var data = Optional.none();
+      var callbacks = [];
+      var map = function (f) {
+        return nu$1(function (nCallback) {
+          get(function (data) {
+            nCallback(f(data));
+          });
+        });
+      };
+      var get = function (nCallback) {
+        if (isReady()) {
+          call(nCallback);
+        } else {
+          callbacks.push(nCallback);
+        }
+      };
+      var set = function (x) {
+        if (!isReady()) {
+          data = Optional.some(x);
+          run(callbacks);
+          callbacks = [];
+        }
+      };
+      var isReady = function () {
+        return data.isSome();
+      };
+      var run = function (cbs) {
+        each$1(cbs, call);
+      };
+      var call = function (cb) {
+        data.each(function (x) {
+          setTimeout(function () {
+            cb(x);
+          }, 0);
+        });
+      };
+      baseFn(set);
+      return {
+        get: get,
+        map: map,
+        isReady: isReady
+      };
+    };
+    var pure$1 = function (a) {
+      return nu$1(function (callback) {
+        callback(a);
+      });
+    };
+    var LazyValue = {
+      nu: nu$1,
+      pure: pure$1
+    };
+
+    var errorReporter = function (err) {
+      setTimeout(function () {
+        throw err;
+      }, 0);
+    };
+    var make = function (run) {
+      var get = function (callback) {
+        run().then(callback, errorReporter);
+      };
+      var map = function (fab) {
+        return make(function () {
+          return run().then(fab);
+        });
+      };
+      var bind = function (aFutureB) {
+        return make(function () {
+          return run().then(function (v) {
+            return aFutureB(v).toPromise();
+          });
+        });
+      };
+      var anonBind = function (futureB) {
+        return make(function () {
+          return run().then(function () {
+            return futureB.toPromise();
+          });
+        });
+      };
+      var toLazy = function () {
+        return LazyValue.nu(get);
+      };
+      var toCached = function () {
+        var cache = null;
+        return make(function () {
+          if (cache === null) {
+            cache = run();
+          }
+          return cache;
+        });
+      };
+      var toPromise = run;
+      return {
+        map: map,
+        bind: bind,
+        anonBind: anonBind,
+        toLazy: toLazy,
+        toCached: toCached,
+        toPromise: toPromise,
+        get: get
+      };
+    };
+    var nu = function (baseFn) {
+      return make(function () {
+        return new Promise$1(baseFn);
+      });
+    };
+    var pure = function (a) {
+      return make(function () {
+        return Promise$1.resolve(a);
+      });
+    };
+    var Future = {
+      nu: nu,
+      pure: pure
+    };
+
+    var adjust = function (value, destination, amount) {
+      if (Math.abs(value - destination) <= amount) {
+        return Optional.none();
+      } else if (value < destination) {
+        return Optional.some(value + amount);
+      } else {
+        return Optional.some(value - amount);
+      }
+    };
+    var create$1 = function () {
+      var interval = null;
+      var animate = function (getCurrent, destination, amount, increment, doFinish, rate) {
+        var finished = false;
+        var finish = function (v) {
+          finished = true;
+          doFinish(v);
+        };
+        global$2.clearInterval(interval);
+        var abort = function (v) {
+          global$2.clearInterval(interval);
+          finish(v);
+        };
+        interval = global$2.setInterval(function () {
+          var value = getCurrent();
+          adjust(value, destination, amount).fold(function () {
+            global$2.clearInterval(interval);
+            finish(destination);
+          }, function (s) {
+            increment(s, abort);
+            if (!finished) {
+              var newValue = getCurrent();
+              if (newValue !== s || Math.abs(newValue - destination) > Math.abs(value - destination)) {
+                global$2.clearInterval(interval);
+                finish(destination);
+              }
+            }
+          });
+        }, rate);
+      };
+      return { animate: animate };
+    };
+
+    var findDevice = function (deviceWidth, deviceHeight) {
+      var devices = [
+        {
+          width: 320,
+          height: 480,
+          keyboard: {
+            portrait: 300,
+            landscape: 240
+          }
+        },
+        {
+          width: 320,
+          height: 568,
+          keyboard: {
+            portrait: 300,
+            landscape: 240
+          }
+        },
+        {
+          width: 375,
+          height: 667,
+          keyboard: {
+            portrait: 305,
+            landscape: 240
+          }
+        },
+        {
+          width: 414,
+          height: 736,
+          keyboard: {
+            portrait: 320,
+            landscape: 240
+          }
+        },
+        {
+          width: 768,
+          height: 1024,
+          keyboard: {
+            portrait: 320,
+            landscape: 400
+          }
+        },
+        {
+          width: 1024,
+          height: 1366,
+          keyboard: {
+            portrait: 380,
+            landscape: 460
+          }
+        }
+      ];
+      return findMap(devices, function (device) {
+        return someIf(deviceWidth <= device.width && deviceHeight <= device.height, device.keyboard);
+      }).getOr({
+        portrait: deviceHeight / 5,
+        landscape: deviceWidth / 4
+      });
+    };
+
+    var softKeyboardLimits = function (outerWindow) {
+      return findDevice(outerWindow.screen.width, outerWindow.screen.height);
+    };
+    var accountableKeyboardHeight = function (outerWindow) {
+      var portrait = get$1(outerWindow).isPortrait();
+      var limits = softKeyboardLimits(outerWindow);
+      var keyboard = portrait ? limits.portrait : limits.landscape;
+      var visualScreenHeight = portrait ? outerWindow.screen.height : outerWindow.screen.width;
+      return visualScreenHeight - outerWindow.innerHeight > keyboard ? 0 : keyboard;
+    };
+    var getGreenzone = function (socket, dropup) {
+      var outerWindow = owner$2(socket).dom.defaultView;
+      var viewportHeight = get$7(socket) + get$7(dropup);
+      var acc = accountableKeyboardHeight(outerWindow);
+      return viewportHeight - acc;
+    };
+    var updatePadding = function (contentBody, socket, dropup) {
+      var greenzoneHeight = getGreenzone(socket, dropup);
+      var deltaHeight = get$7(socket) + get$7(dropup) - greenzoneHeight;
+      set$5(contentBody, 'padding-bottom', deltaHeight + 'px');
+    };
+
+    var fixture = Adt.generate([
+      {
+        fixed: [
+          'element',
+          'property',
+          'offsetY'
+        ]
+      },
+      {
+        scroller: [
+          'element',
+          'offsetY'
+        ]
+      }
+    ]);
+    var yFixedData = 'data-' + resolve('position-y-fixed');
+    var yFixedProperty = 'data-' + resolve('y-property');
+    var yScrollingData = 'data-' + resolve('scrolling');
+    var windowSizeData = 'data-' + resolve('last-window-height');
+    var getYFixedData = function (element) {
+      return safeParse(element, yFixedData);
+    };
+    var getYFixedProperty = function (element) {
+      return get$b(element, yFixedProperty);
+    };
+    var getLastWindowSize = function (element) {
+      return safeParse(element, windowSizeData);
+    };
+    var classifyFixed = function (element, offsetY) {
+      var prop = getYFixedProperty(element);
+      return fixture.fixed(element, prop, offsetY);
+    };
+    var classifyScrolling = function (element, offsetY) {
+      return fixture.scroller(element, offsetY);
+    };
+    var classify = function (element) {
+      var offsetY = getYFixedData(element);
+      var classifier = get$b(element, yScrollingData) === 'true' ? classifyScrolling : classifyFixed;
+      return classifier(element, offsetY);
+    };
+    var findFixtures = function (container) {
+      var candidates = descendants(container, '[' + yFixedData + ']');
+      return map$2(candidates, classify);
+    };
+    var takeoverToolbar = function (toolbar) {
+      var oldToolbarStyle = get$b(toolbar, 'style');
+      setAll(toolbar, {
+        position: 'absolute',
+        top: '0px'
+      });
+      set$8(toolbar, yFixedData, '0px');
+      set$8(toolbar, yFixedProperty, 'top');
+      var restore = function () {
+        set$8(toolbar, 'style', oldToolbarStyle || '');
+        remove$6(toolbar, yFixedData);
+        remove$6(toolbar, yFixedProperty);
+      };
+      return { restore: restore };
+    };
+    var takeoverViewport = function (toolbarHeight, height, viewport) {
+      var oldViewportStyle = get$b(viewport, 'style');
+      register$2(viewport);
+      setAll(viewport, {
+        position: 'absolute',
+        height: height + 'px',
+        width: '100%',
+        top: toolbarHeight + 'px'
+      });
+      set$8(viewport, yFixedData, toolbarHeight + 'px');
+      set$8(viewport, yScrollingData, 'true');
+      set$8(viewport, yFixedProperty, 'top');
+      var restore = function () {
+        deregister(viewport);
+        set$8(viewport, 'style', oldViewportStyle || '');
+        remove$6(viewport, yFixedData);
+        remove$6(viewport, yScrollingData);
+        remove$6(viewport, yFixedProperty);
+      };
+      return { restore: restore };
+    };
+    var takeoverDropup = function (dropup) {
+      var oldDropupStyle = get$b(dropup, 'style');
+      setAll(dropup, {
+        position: 'absolute',
+        bottom: '0px'
+      });
+      set$8(dropup, yFixedData, '0px');
+      set$8(dropup, yFixedProperty, 'bottom');
+      var restore = function () {
+        set$8(dropup, 'style', oldDropupStyle || '');
+        remove$6(dropup, yFixedData);
+        remove$6(dropup, yFixedProperty);
+      };
+      return { restore: restore };
+    };
+    var deriveViewportHeight = function (viewport, toolbarHeight, dropupHeight) {
+      var outerWindow = owner$2(viewport).dom.defaultView;
+      var winH = outerWindow.innerHeight;
+      set$8(viewport, windowSizeData, winH + 'px');
+      return winH - toolbarHeight - dropupHeight;
+    };
+    var takeover = function (viewport, contentBody, toolbar, dropup) {
+      var outerWindow = owner$2(viewport).dom.defaultView;
+      var toolbarSetup = takeoverToolbar(toolbar);
+      var toolbarHeight = get$7(toolbar);
+      var dropupHeight = get$7(dropup);
+      var viewportHeight = deriveViewportHeight(viewport, toolbarHeight, dropupHeight);
+      var viewportSetup = takeoverViewport(toolbarHeight, viewportHeight, viewport);
+      var dropupSetup = takeoverDropup(dropup);
+      var isActive = true;
+      var restore = function () {
+        isActive = false;
+        toolbarSetup.restore();
+        viewportSetup.restore();
+        dropupSetup.restore();
+      };
+      var isExpanding = function () {
+        var currentWinHeight = outerWindow.innerHeight;
+        var lastWinHeight = getLastWindowSize(viewport);
+        return currentWinHeight > lastWinHeight;
+      };
+      var refresh = function () {
+        if (isActive) {
+          var newToolbarHeight = get$7(toolbar);
+          var dropupHeight_1 = get$7(dropup);
+          var newHeight = deriveViewportHeight(viewport, newToolbarHeight, dropupHeight_1);
+          set$8(viewport, yFixedData, newToolbarHeight + 'px');
+          set$5(viewport, 'height', newHeight + 'px');
+          updatePadding(contentBody, viewport, dropup);
+        }
+      };
+      var setViewportOffset = function (newYOffset) {
+        var offsetPx = newYOffset + 'px';
+        set$8(viewport, yFixedData, offsetPx);
+        refresh();
+      };
+      updatePadding(contentBody, viewport, dropup);
+      return {
+        setViewportOffset: setViewportOffset,
+        isExpanding: isExpanding,
+        isShrinking: not(isExpanding),
+        refresh: refresh,
+        restore: restore
+      };
+    };
+
+    var animator = create$1();
+    var ANIMATION_STEP = 15;
+    var NUM_TOP_ANIMATION_FRAMES = 10;
+    var ANIMATION_RATE = 10;
+    var lastScroll = 'data-' + resolve('last-scroll-top');
+    var getTop = function (element) {
+      var raw = getRaw(element, 'top').getOr('0');
+      return parseInt(raw, 10);
+    };
+    var getScrollTop = function (element) {
+      return parseInt(element.dom.scrollTop, 10);
+    };
+    var moveScrollAndTop = function (element, destination, finalTop) {
+      return Future.nu(function (callback) {
+        var getCurrent = curry(getScrollTop, element);
+        var update = function (newScroll) {
+          element.dom.scrollTop = newScroll;
+          set$5(element, 'top', getTop(element) + ANIMATION_STEP + 'px');
+        };
+        var finish = function () {
+          element.dom.scrollTop = destination;
+          set$5(element, 'top', finalTop + 'px');
+          callback(destination);
+        };
+        animator.animate(getCurrent, destination, ANIMATION_STEP, update, finish, ANIMATION_RATE);
+      });
+    };
+    var moveOnlyScroll = function (element, destination) {
+      return Future.nu(function (callback) {
+        var getCurrent = curry(getScrollTop, element);
+        set$8(element, lastScroll, getCurrent());
+        var update = function (newScroll, abort) {
+          var previous = safeParse(element, lastScroll);
+          if (previous !== element.dom.scrollTop) {
+            abort(element.dom.scrollTop);
+          } else {
+            element.dom.scrollTop = newScroll;
+            set$8(element, lastScroll, newScroll);
+          }
+        };
+        var finish = function () {
+          element.dom.scrollTop = destination;
+          set$8(element, lastScroll, destination);
+          callback(destination);
+        };
+        var distance = Math.abs(destination - getCurrent());
+        var step = Math.ceil(distance / NUM_TOP_ANIMATION_FRAMES);
+        animator.animate(getCurrent, destination, step, update, finish, ANIMATION_RATE);
+      });
+    };
+    var moveOnlyTop = function (element, destination) {
+      return Future.nu(function (callback) {
+        var getCurrent = curry(getTop, element);
+        var update = function (newTop) {
+          set$5(element, 'top', newTop + 'px');
+        };
+        var finish = function () {
+          update(destination);
+          callback(destination);
+        };
+        var distance = Math.abs(destination - getCurrent());
+        var step = Math.ceil(distance / NUM_TOP_ANIMATION_FRAMES);
+        animator.animate(getCurrent, destination, step, update, finish, ANIMATION_RATE);
+      });
+    };
+    var updateTop = function (element, amount) {
+      var newTop = amount + getYFixedData(element) + 'px';
+      set$5(element, 'top', newTop);
+    };
+    var moveWindowScroll = function (toolbar, viewport, destY) {
+      var outerWindow = owner$2(toolbar).dom.defaultView;
+      return Future.nu(function (callback) {
+        updateTop(toolbar, destY);
+        updateTop(viewport, destY);
+        outerWindow.scrollTo(0, destY);
+        callback(destY);
+      });
+    };
+
+    function BackgroundActivity (doAction) {
+      var action = Cell(LazyValue.pure({}));
+      var start = function (value) {
+        var future = LazyValue.nu(function (callback) {
+          return doAction(value).get(callback);
+        });
+        action.set(future);
+      };
+      var idle = function (g) {
+        action.get().get(function () {
+          g();
+        });
+      };
+      return {
+        start: start,
+        idle: idle
+      };
+    }
+
+    var scrollIntoView = function (cWin, socket, dropup, top, bottom) {
+      var greenzone = getGreenzone(socket, dropup);
+      var refreshCursor = curry(refresh, cWin);
+      if (top > greenzone || bottom > greenzone) {
+        moveOnlyScroll(socket, socket.dom.scrollTop - greenzone + bottom).get(refreshCursor);
+      } else if (top < 0) {
+        moveOnlyScroll(socket, socket.dom.scrollTop + top).get(refreshCursor);
+      } else ;
+    };
+
+    var par$1 = function (asyncValues, nu) {
+      return nu(function (callback) {
+        var r = [];
+        var count = 0;
+        var cb = function (i) {
+          return function (value) {
+            r[i] = value;
+            count++;
+            if (count >= asyncValues.length) {
+              callback(r);
+            }
+          };
+        };
+        if (asyncValues.length === 0) {
+          callback([]);
+        } else {
+          each$1(asyncValues, function (asyncValue, i) {
+            asyncValue.get(cb(i));
+          });
+        }
+      });
+    };
+
+    var par = function (futures) {
+      return par$1(futures, Future.nu);
+    };
+
+    var updateFixed = function (element, property, winY, offsetY) {
+      var destination = winY + offsetY;
+      set$5(element, property, destination + 'px');
+      return Future.pure(offsetY);
+    };
+    var updateScrollingFixed = function (element, winY, offsetY) {
+      var destTop = winY + offsetY;
+      var oldProp = getRaw(element, 'top').getOr(offsetY);
+      var delta = destTop - parseInt(oldProp, 10);
+      var destScroll = element.dom.scrollTop + delta;
+      return moveScrollAndTop(element, destScroll, destTop);
+    };
+    var updateFixture = function (fixture, winY) {
+      return fixture.fold(function (element, property, offsetY) {
+        return updateFixed(element, property, winY, offsetY);
+      }, function (element, offsetY) {
+        return updateScrollingFixed(element, winY, offsetY);
+      });
+    };
+    var updatePositions = function (container, winY) {
+      var fixtures = findFixtures(container);
+      var updates = map$2(fixtures, function (fixture) {
+        return updateFixture(fixture, winY);
+      });
+      return par(updates);
+    };
+
+    var VIEW_MARGIN = 5;
+    var register = function (toolstrip, socket, container, outerWindow, structure, cWin) {
+      var scroller = BackgroundActivity(function (y) {
+        return moveWindowScroll(toolstrip, socket, y);
+      });
+      var scrollBounds = function () {
+        var rects = getRectangles(cWin);
+        return Optional.from(rects[0]).bind(function (rect) {
+          var viewTop = rect.top - socket.dom.scrollTop;
+          var outside = viewTop > outerWindow.innerHeight + VIEW_MARGIN || viewTop < -VIEW_MARGIN;
+          return outside ? Optional.some({
+            top: viewTop,
+            bottom: viewTop + rect.height
+          }) : Optional.none();
+        });
+      };
+      var scrollThrottle = last(function () {
+        scroller.idle(function () {
+          updatePositions(container, outerWindow.pageYOffset).get(function () {
+            var extraScroll = scrollBounds();
+            extraScroll.each(function (extra) {
+              socket.dom.scrollTop = socket.dom.scrollTop + extra.top;
+            });
+            scroller.start(0);
+            structure.refresh();
+          });
+        });
+      }, 1000);
+      var onScroll = bind(SugarElement.fromDom(outerWindow), 'scroll', function () {
+        if (outerWindow.pageYOffset < 0) {
+          return;
+        }
+        scrollThrottle.throttle();
+      });
+      updatePositions(container, outerWindow.pageYOffset).get(identity);
+      return { unbind: onScroll.unbind };
+    };
+    var setup = function (bag) {
+      var cWin = bag.cWin;
+      var ceBody = bag.ceBody;
+      var socket = bag.socket;
+      var toolstrip = bag.toolstrip;
+      var contentElement = bag.contentElement;
+      var keyboardType = bag.keyboardType;
+      var outerWindow = bag.outerWindow;
+      var dropup = bag.dropup;
+      var outerBody = bag.outerBody;
+      var structure = takeover(socket, ceBody, toolstrip, dropup);
+      var keyboardModel = keyboardType(outerBody, cWin, body(), contentElement);
+      var toEditing = function () {
+        keyboardModel.toEditing();
+        clearSelection();
+      };
+      var toReading = function () {
+        keyboardModel.toReading();
+      };
+      var onToolbarTouch = function (_event) {
+        keyboardModel.onToolbarTouch();
+      };
+      var onOrientation = onChange(outerWindow, {
+        onChange: noop,
+        onReady: structure.refresh
+      });
+      onOrientation.onAdjustment(function () {
+        structure.refresh();
+      });
+      var onResize = bind(SugarElement.fromDom(outerWindow), 'resize', function () {
+        if (structure.isExpanding()) {
+          structure.refresh();
+        }
+      });
+      var onScroll = register(toolstrip, socket, outerBody, outerWindow, structure, cWin);
+      var unfocusedSelection = FakeSelection(cWin, contentElement);
+      var refreshSelection = function () {
+        if (unfocusedSelection.isActive()) {
+          unfocusedSelection.update();
+        }
+      };
+      var highlightSelection = function () {
+        unfocusedSelection.update();
+      };
+      var clearSelection = function () {
+        unfocusedSelection.clear();
+      };
+      var scrollIntoView$1 = function (top, bottom) {
+        scrollIntoView(cWin, socket, dropup, top, bottom);
+      };
+      var syncHeight = function () {
+        set$5(contentElement, 'height', contentElement.dom.contentWindow.document.body.scrollHeight + 'px');
+      };
+      var setViewportOffset = function (newYOffset) {
+        structure.setViewportOffset(newYOffset);
+        moveOnlyTop(socket, newYOffset).get(identity);
+      };
+      var destroy = function () {
+        structure.restore();
+        onOrientation.destroy();
+        onScroll.unbind();
+        onResize.unbind();
+        keyboardModel.destroy();
+        unfocusedSelection.destroy();
+        input(body(), blur$1);
+      };
+      return {
+        toEditing: toEditing,
+        toReading: toReading,
+        onToolbarTouch: onToolbarTouch,
+        refreshSelection: refreshSelection,
+        clearSelection: clearSelection,
+        highlightSelection: highlightSelection,
+        scrollIntoView: scrollIntoView$1,
+        updateToolbarPadding: noop,
+        setViewportOffset: setViewportOffset,
+        syncHeight: syncHeight,
+        refreshStructure: structure.refresh,
+        destroy: destroy
+      };
+    };
+
+    var create = function (platform, mask) {
+      var meta = tag();
+      var priorState = value();
+      var scrollEvents = value();
+      var iosApi = api$2();
+      var iosEvents = api$2();
+      var enter = function () {
+        mask.hide();
+        var doc = SugarElement.fromDom(document);
+        getActiveApi(platform.editor).each(function (editorApi) {
+          priorState.set({
+            socketHeight: getRaw(platform.socket, 'height'),
+            iframeHeight: getRaw(editorApi.frame, 'height'),
+            outerScroll: document.body.scrollTop
+          });
+          scrollEvents.set({ exclusives: exclusive(doc, '.' + scrollable) });
+          add$1(platform.container, resolve('fullscreen-maximized'));
+          clobberStyles(platform.container, editorApi.body);
+          meta.maximize();
+          set$5(platform.socket, 'overflow', 'scroll');
+          set$5(platform.socket, '-webkit-overflow-scrolling', 'touch');
+          focus$3(editorApi.body);
+          iosApi.set(setup({
+            cWin: editorApi.win,
+            ceBody: editorApi.body,
+            socket: platform.socket,
+            toolstrip: platform.toolstrip,
+            dropup: platform.dropup.element,
+            contentElement: editorApi.frame,
+            outerBody: platform.body,
+            outerWindow: platform.win,
+            keyboardType: stubborn
+          }));
+          iosApi.run(function (api) {
+            api.syncHeight();
+          });
+          iosEvents.set(initEvents(editorApi, iosApi, platform.toolstrip, platform.socket, platform.dropup));
+        });
+      };
+      var exit = function () {
+        meta.restore();
+        iosEvents.clear();
+        iosApi.clear();
+        mask.show();
+        priorState.on(function (s) {
+          s.socketHeight.each(function (h) {
+            set$5(platform.socket, 'height', h);
+          });
+          s.iframeHeight.each(function (h) {
+            set$5(platform.editor.getFrame(), 'height', h);
+          });
+          document.body.scrollTop = s.scrollTop;
+        });
+        priorState.clear();
+        scrollEvents.on(function (s) {
+          s.exclusives.unbind();
+        });
+        scrollEvents.clear();
+        remove$3(platform.container, resolve('fullscreen-maximized'));
+        restoreStyles();
+        deregister(platform.toolbar);
+        remove$2(platform.socket, 'overflow');
+        remove$2(platform.socket, '-webkit-overflow-scrolling');
+        blur$1(platform.editor.getFrame());
+        getActiveApi(platform.editor).each(function (editorApi) {
+          editorApi.clearSelection();
+        });
+      };
+      var refreshStructure = function () {
+        iosApi.run(function (api) {
+          api.refreshStructure();
+        });
+      };
+      return {
+        enter: enter,
+        refreshStructure: refreshStructure,
+        exit: exit
+      };
+    };
+
+    var produce = function (raw) {
+      var mobile = asRawOrDie$1('Getting IosWebapp schema', MobileSchema, raw);
+      set$5(mobile.toolstrip, 'width', '100%');
+      set$5(mobile.container, 'position', 'relative');
+      var onView = function () {
+        mobile.setReadOnly(mobile.readOnlyOnInit());
+        mode.enter();
+      };
+      var mask = build$1(sketch(onView, mobile.translate));
+      mobile.alloy.add(mask);
+      var maskApi = {
+        show: function () {
+          mobile.alloy.add(mask);
+        },
+        hide: function () {
+          mobile.alloy.remove(mask);
+        }
+      };
+      var mode = create(mobile, maskApi);
+      return {
+        setReadOnly: mobile.setReadOnly,
+        refreshStructure: mode.refreshStructure,
+        enter: mode.enter,
+        exit: mode.exit,
+        destroy: noop
+      };
+    };
+
+    function IosRealm (scrollIntoView) {
+      var alloy = OuterContainer({ classes: [resolve('ios-container')] });
+      var toolbar = ScrollingToolbar();
+      var webapp = api$2();
+      var switchToEdit = makeEditSwitch(webapp);
+      var socket = makeSocket();
+      var dropup = build(function () {
+        webapp.run(function (w) {
+          w.refreshStructure();
+        });
+      }, scrollIntoView);
+      alloy.add(toolbar.wrapper);
+      alloy.add(socket);
+      alloy.add(dropup.component);
+      var setToolbarGroups = function (rawGroups) {
+        var groups = toolbar.createGroups(rawGroups);
+        toolbar.setGroups(groups);
+      };
+      var setContextToolbar = function (rawGroups) {
+        var groups = toolbar.createGroups(rawGroups);
+        toolbar.setContextToolbar(groups);
+      };
+      var focusToolbar = function () {
+        toolbar.focus();
+      };
+      var restoreToolbar = function () {
+        toolbar.restoreToolbar();
+      };
+      var init = function (spec) {
+        webapp.set(produce(spec));
+      };
+      var exit = function () {
+        webapp.run(function (w) {
+          Replacing.remove(socket, switchToEdit);
+          w.exit();
+        });
+      };
+      var updateMode$1 = function (readOnly) {
+        updateMode(socket, switchToEdit, readOnly, alloy.root);
+      };
+      return {
+        system: alloy,
+        element: alloy.element,
+        init: init,
+        exit: exit,
+        setToolbarGroups: setToolbarGroups,
+        setContextToolbar: setContextToolbar,
+        focusToolbar: focusToolbar,
+        restoreToolbar: restoreToolbar,
+        updateMode: updateMode$1,
+        socket: socket,
+        dropup: dropup
+      };
+    }
+
+    var global$1 = tinymce.util.Tools.resolve('tinymce.EditorManager');
+
+    var derive = function (editor) {
+      var base = Optional.from(getSkinUrl(editor)).getOrThunk(function () {
+        return global$1.baseURL + '/skins/ui/oxide';
+      });
+      return {
+        content: base + '/content.mobile.min.css',
+        ui: base + '/skin.mobile.min.css'
+      };
+    };
+
+    var fireChange = function (realm, command, state) {
+      realm.system.broadcastOn([formatChanged], {
+        command: command,
+        state: state
+      });
+    };
+    var init = function (realm, editor) {
+      var allFormats = keys(editor.formatter.get());
+      each$1(allFormats, function (command) {
+        editor.formatter.formatChanged(command, function (state) {
+          fireChange(realm, command, state);
+        });
+      });
+      each$1([
+        'ul',
+        'ol'
+      ], function (command) {
+        editor.selection.selectorChanged(command, function (state, _data) {
+          fireChange(realm, command, state);
+        });
+      });
+    };
+
+    var fireSkinLoaded = function (editor) {
+      return function () {
+        var done = function () {
+          editor._skinLoaded = true;
+          editor.fire('SkinLoaded');
+        };
+        if (editor.initialized) {
+          done();
+        } else {
+          editor.on('init', done);
+        }
+      };
+    };
+
+    var READING = 'toReading';
+    var EDITING = 'toEditing';
+    var renderMobileTheme = function (editor) {
+      var renderUI = function () {
+        var targetNode = editor.getElement();
+        var cssUrls = derive(editor);
+        if (isSkinDisabled(editor) === false) {
+          var styleSheetLoader_1 = global$5.DOM.styleSheetLoader;
+          editor.contentCSS.push(cssUrls.content);
+          styleSheetLoader_1.load(cssUrls.ui, fireSkinLoaded(editor));
+          editor.on('remove', function () {
+            return styleSheetLoader_1.unload(cssUrls.ui);
+          });
+        } else {
+          fireSkinLoaded(editor)();
+        }
+        var doScrollIntoView = function () {
+          editor.fire('ScrollIntoView');
+        };
+        var realm = detect$1().os.isAndroid() ? AndroidRealm(doScrollIntoView) : IosRealm(doScrollIntoView);
+        var original = SugarElement.fromDom(targetNode);
+        attachSystemAfter(original, realm.system);
+        var findFocusIn = function (elem) {
+          return search(elem).bind(function (focused) {
+            return realm.system.getByDom(focused).toOptional();
+          });
+        };
+        var outerWindow = targetNode.ownerDocument.defaultView;
+        var orientation = onChange(outerWindow, {
+          onChange: function () {
+            var alloy = realm.system;
+            alloy.broadcastOn([orientationChanged], { width: getActualWidth(outerWindow) });
+          },
+          onReady: noop
+        });
+        var setReadOnly = function (dynamicGroup, readOnlyGroups, mainGroups, ro) {
+          if (ro === false) {
+            editor.selection.collapse();
+          }
+          var toolbars = configureToolbar(dynamicGroup, readOnlyGroups, mainGroups);
+          realm.setToolbarGroups(ro === true ? toolbars.readOnly : toolbars.main);
+          editor.setMode(ro === true ? 'readonly' : 'design');
+          editor.fire(ro === true ? READING : EDITING);
+          realm.updateMode(ro);
+        };
+        var configureToolbar = function (dynamicGroup, readOnlyGroups, mainGroups) {
+          var dynamic = dynamicGroup.get();
+          var toolbars = {
+            readOnly: dynamic.backToMask.concat(readOnlyGroups.get()),
+            main: dynamic.backToMask.concat(mainGroups.get())
+          };
+          return toolbars;
+        };
+        var bindHandler = function (label, handler) {
+          editor.on(label, handler);
+          return {
+            unbind: function () {
+              editor.off(label);
+            }
+          };
+        };
+        editor.on('init', function () {
+          realm.init({
+            editor: {
+              getFrame: function () {
+                return SugarElement.fromDom(editor.contentAreaContainer.querySelector('iframe'));
+              },
+              onDomChanged: function () {
+                return { unbind: noop };
+              },
+              onToReading: function (handler) {
+                return bindHandler(READING, handler);
+              },
+              onToEditing: function (handler) {
+                return bindHandler(EDITING, handler);
+              },
+              onScrollToCursor: function (handler) {
+                editor.on('ScrollIntoView', function (tinyEvent) {
+                  handler(tinyEvent);
+                });
+                var unbind = function () {
+                  editor.off('ScrollIntoView');
+                  orientation.destroy();
+                };
+                return { unbind: unbind };
+              },
+              onTouchToolstrip: function () {
+                hideDropup();
+              },
+              onTouchContent: function () {
+                var toolbar = SugarElement.fromDom(editor.editorContainer.querySelector('.' + resolve('toolbar')));
+                findFocusIn(toolbar).each(emitExecute);
+                realm.restoreToolbar();
+                hideDropup();
+              },
+              onTapContent: function (evt) {
+                var target = evt.target;
+                if (name$1(target) === 'img') {
+                  editor.selection.select(target.dom);
+                  evt.kill();
+                } else if (name$1(target) === 'a') {
+                  var component = realm.system.getByDom(SugarElement.fromDom(editor.editorContainer));
+                  component.each(function (container) {
+                    if (Swapping.isAlpha(container)) {
+                      openLink(target.dom);
+                    }
+                  });
+                }
+              }
+            },
+            container: SugarElement.fromDom(editor.editorContainer),
+            socket: SugarElement.fromDom(editor.contentAreaContainer),
+            toolstrip: SugarElement.fromDom(editor.editorContainer.querySelector('.' + resolve('toolstrip'))),
+            toolbar: SugarElement.fromDom(editor.editorContainer.querySelector('.' + resolve('toolbar'))),
+            dropup: realm.dropup,
+            alloy: realm.system,
+            translate: noop,
+            setReadOnly: function (ro) {
+              setReadOnly(dynamicGroup, readOnlyGroups, mainGroups, ro);
+            },
+            readOnlyOnInit: function () {
+              return readOnlyOnInit();
+            }
+          });
+          var hideDropup = function () {
+            realm.dropup.disappear(function () {
+              realm.system.broadcastOn([dropupDismissed], {});
+            });
+          };
+          var backToMaskGroup = {
+            label: 'The first group',
+            scrollable: false,
+            items: [forToolbar('back', function () {
+                editor.selection.collapse();
+                realm.exit();
+              }, {}, editor)]
+          };
+          var backToReadOnlyGroup = {
+            label: 'Back to read only',
+            scrollable: false,
+            items: [forToolbar('readonly-back', function () {
+                setReadOnly(dynamicGroup, readOnlyGroups, mainGroups, true);
+              }, {}, editor)]
+          };
+          var readOnlyGroup = {
+            label: 'The read only mode group',
+            scrollable: true,
+            items: []
+          };
+          var features = setup$3(realm, editor);
+          var items = detect(editor, features);
+          var actionGroup = {
+            label: 'the action group',
+            scrollable: true,
+            items: items
+          };
+          var extraGroup = {
+            label: 'The extra group',
+            scrollable: false,
+            items: []
+          };
+          var mainGroups = Cell([
+            actionGroup,
+            extraGroup
+          ]);
+          var readOnlyGroups = Cell([
+            readOnlyGroup,
+            extraGroup
+          ]);
+          var dynamicGroup = Cell({
+            backToMask: [backToMaskGroup],
+            backToReadOnly: [backToReadOnlyGroup]
+          });
+          init(realm, editor);
+        });
+        editor.on('remove', function () {
+          realm.exit();
+        });
+        editor.on('detach', function () {
+          detachSystem(realm.system);
+          realm.system.destroy();
+        });
+        return {
+          iframeContainer: realm.socket.element.dom,
+          editorContainer: realm.element.dom
+        };
+      };
+      return {
+        getNotificationManagerImpl: function () {
+          return {
+            open: constant$1({
+              progressBar: { value: noop },
+              close: noop,
+              text: noop,
+              getEl: constant$1(null),
+              moveTo: noop,
+              moveRel: noop,
+              settings: {}
+            }),
+            close: noop,
+            reposition: noop,
+            getArgs: constant$1({})
+          };
+        },
+        renderUI: renderUI
+      };
+    };
+    function Theme () {
+      global$4.add('mobile', renderMobileTheme);
+    }
+
+    Theme();
+
+}());
diff --git a/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.js.gz b/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.js.gz
new file mode 100644
index 0000000..39042c6
Binary files /dev/null and b/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.js.gz differ
diff --git a/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.min.js b/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.min.js
new file mode 100644
index 0000000..110ac45
--- /dev/null
+++ b/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.min.js
@@ -0,0 +1,9 @@
+/**
+ * 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.10.7 (2022-12-06)
+ */
+!function(){"use strict";var y=function(){return(y=Object.assign||function(n){for(var e,t=1,o=arguments.length;t<o;t++)for(var r in e=arguments[t])Object.prototype.hasOwnProperty.call(e,r)&&(n[r]=e[r]);return n}).apply(this,arguments)};function c(n,e){var t={};for(r in n)Object.prototype.hasOwnProperty.call(n,r)&&e.indexOf(r)<0&&(t[r]=n[r]);if(null!=n&&"function"==typeof Object.getOwnPropertySymbols)for(var o=0,r=Object.getOwnPropertySymbols(n);o<r.length;o++)e.indexOf(r[o])<0&&Object.prototype.propertyIsEnumerable.call(n,r[o])&&(t[r[o]]=n[r[o]]);return t}function u(n,e,t){if(t||2===arguments.length)for(var o,r=0,i=e.length;r<i;r++)!o&&r in e||((o=o||Array.prototype.slice.call(e,0,r))[r]=e[r]);return n.concat(o||Array.prototype.slice.call(e))}function n(o){return function(n){return t=typeof(e=n),(null===e?"null":"object"==t&&(Array.prototype.isPrototypeOf(e)||e.constructor&&"Array"===e.constructor.name)?"array":"object"==t&&(String.prototype.isPrototypeOf(e)||e.constructor&&"String"===e.constructor.name)?"string":t)===o;var e,t}}function e(e){return function(n){return typeof n===e}}function t(e){return function(n){return e===n}}function l(n){return!(null==n)}function Y(){}function i(t,o){return function(){for(var n=[],e=0;e<arguments.length;e++)n[e]=arguments[e];return t(o.apply(null,n))}}function w(n){return function(){return n}}function K(n){return n}function o(n,e){return n===e}var r=n("string"),a=n("object"),D=n("array"),s=t(null),d=e("boolean"),f=t(void 0),m=e("function"),g=e("number");function J(o){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];return function(){for(var n=[],e=0;e<arguments.length;e++)n[e]=arguments[e];var t=r.concat(n);return o.apply(null,t)}}function Q(e){return function(n){return!e(n)}}function h(n){return function(){throw new Error(n)}}function p(n){return n()}function v(){return b}var S=w(!1),x=w(!0),b={fold:function(n,e){return n()},isSome:S,isNone:x,getOr:K,getOrThunk:O,getOrDie:function(n){throw new Error(n||"error: getOrDie called on none.")},getOrNull:w(null),getOrUndefined:w(void 0),or:K,orThunk:O,map:v,each:Y,bind:v,exists:S,forall:x,filter:function(){return b},toArray:function(){return[]},toString:w("none()")};function O(n){return n()}function k(t){var o,r=!1;return function(){for(var n=[],e=0;e<arguments.length;e++)n[e]=arguments[e];return r||(r=!0,o=t.apply(null,n)),o}}function T(n,e){return-1<pn.call(n,e)}function C(n,e){for(var t=0,o=n.length;t<o;t++)if(e(n[t],t))return 1}function Z(n,e){for(var t=n.length,o=new Array(t),r=0;r<t;r++){var i=n[r];o[r]=e(i,r)}return o}function M(n,e){for(var t=0,o=n.length;t<o;t++)e(n[t],t)}function E(n,e){for(var t=[],o=0,r=n.length;o<r;o++){var i=n[o];e(i,o)&&t.push(i)}return t}function _(n,o,r){return function(n){for(var e,t=n.length-1;0<=t;t--)e=n[t],r=o(r,e,t)}(n),r}function R(n,t,o){return M(n,function(n,e){o=t(o,n,e)}),o}function F(n,e){return function(n,e,t){for(var o=0,r=n.length;o<r;o++){var i=n[o];if(e(i,o))return mn.some(i);if(t(i,o))break}return mn.none()}(n,e,S)}function I(n,e){for(var t=0,o=n.length;t<o;t++)if(e(n[t],t))return mn.some(t);return mn.none()}function V(n){for(var e=[],t=0,o=n.length;t<o;++t){if(!D(n[t]))throw new Error("Arr.flatten item "+t+" was not an array, input: "+n);hn.apply(e,n[t])}return e}function B(n,e){return V(Z(n,e))}function A(n,e){for(var t=0,o=n.length;t<o;++t)if(!0!==e(n[t],t))return!1;return!0}function N(n){var e=gn.call(n,0);return e.reverse(),e}function H(n,e){return E(n,function(n){return!T(e,n)})}function P(n){return[n]}function z(n,e){for(var t=0;t<n.length;t++){var o=e(n[t],t);if(o.isSome())return o}return mn.none()}function j(n,e){var t=String(e).toLowerCase();return F(n,function(n){return n.search(t)})}function L(n,e){return-1!==n.indexOf(e)}function $(e){return function(n){return L(n,e)}}function G(n){return window.matchMedia(n).matches}function U(n){return w("alloy."+n)}function W(n,e){se(n,n.element,e,{})}function X(n,e,t){se(n,n.element,e,t)}function q(n){W(n,Zn())}function nn(n,e,t){se(n,e,t,{})}function en(n,e){var t=n.dom;if(1!==t.nodeType)return!1;var o=t;if(void 0!==o.matches)return o.matches(e);if(void 0!==o.msMatchesSelector)return o.msMatchesSelector(e);if(void 0!==o.webkitMatchesSelector)return o.webkitMatchesSelector(e);if(void 0!==o.mozMatchesSelector)return o.mozMatchesSelector(e);throw new Error("Browser lacks native selectors")}function tn(n){return 1!==n.nodeType&&9!==n.nodeType&&11!==n.nodeType||0===n.childElementCount}function on(n,e){var t=void 0===e?document:e.dom;return tn(t)?[]:Z(t.querySelectorAll(n),fe.fromDom)}function rn(n,e){var t=void 0===e?document:e.dom;return tn(t)?mn.none():mn.from(t.querySelector(n)).map(fe.fromDom)}function un(n,e){return n.dom===e.dom}function cn(){return vn(0,0)}function an(n){function e(n){return function(){return t===n}}var t=n.current,o=n.version;return{current:t,version:o,isEdge:e("Edge"),isChrome:e("Chrome"),isIE:e("IE"),isOpera:e("Opera"),isFirefox:e(Sn),isSafari:e("Safari")}}function sn(n){function e(n){return function(){return t===n}}var t=n.current,o=n.version;return{current:t,version:o,isWindows:e(Tn),isiOS:e("iOS"),isAndroid:e(Cn),isOSX:e("OSX"),isLinux:e("Linux"),isSolaris:e(En),isFreeBSD:e(Dn),isChromeOS:e(Mn)}}function fn(n){if(null==n)throw new Error("Node cannot be null or undefined");return{dom:n}}var ln,dn=function(t){function n(){return r}function e(n){return n(t)}var o=w(t),r={fold:function(n,e){return e(t)},isSome:x,isNone:S,getOr:o,getOrThunk:o,getOrDie:o,getOrNull:o,getOrUndefined:o,or:n,orThunk:n,map:function(n){return dn(n(t))},each:function(n){n(t)},bind:e,exists:e,forall:e,filter:function(n){return n(t)?r:b},toArray:function(){return[t]},toString:function(){return"some("+t+")"}};return r},mn={some:dn,none:v,from:function(n){return null==n?b:dn(n)}},gn=Array.prototype.slice,pn=Array.prototype.indexOf,hn=Array.prototype.push,vn=function(n,e){return{major:n,minor:e}},bn={nu:vn,detect:function(n,e){var t,o,r=String(e).toLowerCase();return 0===n.length?cn():(o=function(n,e){for(var t=0;t<n.length;t++){var o=n[t];if(o.test(e))return o}}(n,t=r))?vn(i(1),i(2)):{major:0,minor:0};function i(n){return Number(t.replace(o,"$"+n))}},unknown:cn},yn=(ln=/^\s+|\s+$/g,function(n){return n.replace(ln,"")}),xn=/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,wn={browsers:w([{name:"Edge",versionRegexes:[/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],search:function(n){return L(n,"edge/")&&L(n,"chrome")&&L(n,"safari")&&L(n,"applewebkit")}},{name:"Chrome",brand:"Chromium",versionRegexes:[/.*?chrome\/([0-9]+)\.([0-9]+).*/,xn],search:function(n){return L(n,"chrome")&&!L(n,"chromeframe")}},{name:"IE",versionRegexes:[/.*?msie\ ?([0-9]+)\.([0-9]+).*/,/.*?rv:([0-9]+)\.([0-9]+).*/],search:function(n){return L(n,"msie")||L(n,"trident")}},{name:"Opera",versionRegexes:[xn,/.*?opera\/([0-9]+)\.([0-9]+).*/],search:$("opera")},{name:"Firefox",versionRegexes:[/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],search:$("firefox")},{name:"Safari",versionRegexes:[xn,/.*?cpu os ([0-9]+)_([0-9]+).*/],search:function(n){return(L(n,"safari")||L(n,"mobile/"))&&L(n,"applewebkit")}}]),oses:w([{name:"Windows",search:$("win"),versionRegexes:[/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]},{name:"iOS",search:function(n){return L(n,"iphone")||L(n,"ipad")},versionRegexes:[/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,/.*cpu os ([0-9]+)_([0-9]+).*/,/.*cpu iphone os ([0-9]+)_([0-9]+).*/]},{name:"Android",search:$("android"),versionRegexes:[/.*?android\ ?([0-9]+)\.([0-9]+).*/]},{name:"OSX",search:$("mac os x"),versionRegexes:[/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]},{name:"Linux",search:$("linux"),versionRegexes:[]},{name:"Solaris",search:$("sunos"),versionRegexes:[]},{name:"FreeBSD",search:$("freebsd"),versionRegexes:[]},{name:"ChromeOS",search:$("cros"),versionRegexes:[/.*?chrome\/([0-9]+)\.([0-9]+).*/]}])},Sn="Firefox",On=function(){return an({current:void 0,version:bn.unknown()})},kn=an,Tn=(w("Edge"),w("Chrome"),w("IE"),w("Opera"),w(Sn),w("Safari"),"Windows"),Cn="Android",En="Solaris",Dn="FreeBSD",Mn="ChromeOS",_n=function(){return sn({current:void 0,version:bn.unknown()})},Rn=sn,Fn=(w(Tn),w("iOS"),w(Cn),w("Linux"),w("OSX"),w(En),w(Dn),w(Mn),k(function(){return n=navigator.userAgent,e=mn.from(navigator.userAgentData),t=G,p=wn.browsers(),h=wn.oses(),v=e.bind(function(n){return o=p,z(n.brands,function(e){var t=e.brand.toLowerCase();return F(o,function(n){var e;return t===(null===(e=n.brand)||void 0===e?void 0:e.toLowerCase())}).map(function(n){return{current:n.name,version:bn.nu(parseInt(e.version,10),0)}})});var o}).orThunk(function(){return j(p,t=n).map(function(n){var e=bn.detect(n.versionRegexes,t);return{current:n.name,version:e}});var t}).fold(On,kn),b=j(h,o=n).map(function(n){var e=bn.detect(n.versionRegexes,o);return{current:n.name,version:e}}).fold(_n,Rn),{browser:v,os:b,deviceType:(i=v,u=n,c=t,a=(r=b).isiOS()&&!0===/ipad/i.test(u),s=r.isiOS()&&!a,l=(f=r.isiOS()||r.isAndroid())||c("(pointer:coarse)"),d=a||!s&&f&&c("(min-device-width:768px)"),m=s||f&&!d,g=i.isSafari()&&r.isiOS()&&!1===/safari/i.test(u),{isiPad:w(a),isiPhone:w(s),isTablet:w(d),isPhone:w(m),isTouch:w(l),isAndroid:r.isAndroid,isiOS:r.isiOS,isWebView:w(g),isDesktop:w(!m&&!d&&!g)})};var n,e,t,o,r,i,u,c,a,s,f,l,d,m,g,p,h,v,b})),In=w,Vn=In("touchstart"),Bn=In("touchmove"),An=In("touchend"),Nn=In("mousedown"),Hn=In("mousemove"),Pn=In("mouseup"),zn=In("mouseover"),jn=In("keydown"),Ln=In("keyup"),$n=In("input"),Gn=In("change"),Un=In("click"),Wn=In("transitionend"),Xn=In("selectstart"),qn={tap:U("tap")},Yn=U("focus"),Kn=U("blur.post"),Jn=U("paste.post"),Qn=U("receive"),Zn=U("execute"),ne=U("focus.item"),ee=qn.tap,te=U("longpress"),oe=U("system.init"),re=U("system.attached"),ie=U("system.detached"),ue=U("focusmanager.shifted"),ce=U("highlight"),ae=U("dehighlight"),se=function(n,e,t,o){var r=y({target:e},o);n.getSystem().triggerEvent(t,e,r)},fe={fromHtml:function(n,e){var t=(e||document).createElement("div");if(t.innerHTML=n,!t.hasChildNodes()||1<t.childNodes.length)throw console.error("HTML does not have a single root node",n),new Error("HTML must have a single root node");return fn(t.childNodes[0])},fromTag:function(n,e){var t=(e||document).createElement(n);return fn(t)},fromText:function(n,e){var t=(e||document).createTextNode(n);return fn(t)},fromDom:fn,fromPoint:function(n,e,t){return mn.from(n.dom.elementFromPoint(e,t)).map(fn)}};function le(n){return n.dom.nodeName.toLowerCase()}function de(e){return function(n){return n.dom.nodeType===e}}function me(n){return fe.fromDom(n.dom.ownerDocument)}function ge(n){return Ye(n)?n:me(n)}function pe(n){return mn.from(n.dom.parentNode).map(fe.fromDom)}function he(n,e){var t=n.dom.childNodes;return mn.from(t[e]).map(fe.fromDom)}function ve(e,t){pe(e).each(function(n){n.dom.insertBefore(t.dom,e.dom)})}function be(n,e){mn.from(n.dom.nextSibling).map(fe.fromDom).fold(function(){pe(n).each(function(n){Qe(n,e)})},function(n){ve(n,e)})}function ye(e,t){he(e,0).fold(function(){Qe(e,t)},function(n){e.dom.insertBefore(t.dom,n.dom)})}function xe(e,n){M(n,function(n){Qe(e,n)})}function we(n){n.dom.textContent="",M(Je(n),function(n){Ze(n)})}function Se(n){return Ke(n)&&l(n.dom.host)}function Oe(n){return fe.fromDom(n.dom.host)}function ke(){return it(fe.fromDom(document))}function Te(n,e){Qe(n.element,e.element)}function Ce(e){var n,t=pe(e.element).bind(function(n){return e.getSystem().getByDom(n).toOptional()});ut(n=e),Ze(n.element),n.getSystem().removeFromWorld(n),t.each(function(n){n.syncComponents()})}function Ee(n,e){for(var t=st(n),o=0,r=t.length;o<r;o++){var i=t[o];e(n[i],i)}}function De(n,t){return lt(n,function(n,e){return{k:e,v:t(n,e)}})}function Me(n,t){var o=[];return Ee(n,function(n,e){o.push(t(n,e))}),o}function _e(n,e){return dt(n,e)?mn.from(n[e]):mn.none()}function Re(n,e){return dt(n,e)&&void 0!==n[e]&&null!==n[e]}function Fe(n,e,t){if(!(r(t)||d(t)||g(t)))throw console.error("Invalid call to Attribute.set. Key ",e,":: Value ",t,":: Element ",n),new Error("Attribute value was not simple");n.setAttribute(e,t+"")}function Ie(n,e,t){Fe(n.dom,e,t)}function Ve(n,e){var t=n.dom;Ee(e,function(n,e){Fe(t,e,n)})}function Be(n,e){var t=n.dom.getAttribute(e);return null===t?void 0:t}function Ae(n,e){return mn.from(Be(n,e))}function Ne(n,e){var t=n.dom;return!(!t||!t.hasAttribute)&&t.hasAttribute(e)}function He(n,e){n.dom.removeAttribute(e)}function Pe(n,e){var t=Be(n,e);return void 0===t||""===t?[]:t.split(" ")}function ze(n){return void 0!==n.dom.classList}function je(n,e){var t,o,r;ze(n)?n.dom.classList.add(e):(o=e,r=Pe(t=n,"class").concat([o]),Ie(t,"class",r.join(" ")))}function Le(n,e){var t,o,r,i;ze(n)?n.dom.classList.remove(e):(r=e,0<(i=E(Pe(o=n,"class"),function(n){return n!==r})).length?Ie(o,"class",i.join(" ")):He(o,"class")),0===(ze(t=n)?t.dom.classList:Pe(t,"class")).length&&He(t,"class")}function $e(n,e){return ze(n)&&n.dom.classList.contains(e)}function Ge(n,e,t){Le(n,t),je(n,e)}"undefined"!=typeof window||Function("return this;")();var Ue,We,Xe=de(1),qe=de(3),Ye=de(9),Ke=de(11),Je=function(n){return Z(n.dom.childNodes,fe.fromDom)},Qe=function(n,e){n.dom.appendChild(e.dom)},Ze=function(n){var e=n.dom;null!==e.parentNode&&e.parentNode.removeChild(e)},nt=m(Element.prototype.attachShadow)&&m(Node.prototype.getRootNode),et=w(nt),tt=nt?function(n){return fe.fromDom(n.dom.getRootNode())}:ge,ot=function(n){return l(n.dom.shadowRoot)},rt=function(n){var e=qe(n)?n.dom.parentNode:n.dom;if(null==e||null===e.ownerDocument)return!1;var t,o,r=e.ownerDocument,i=fe.fromDom(e),u=tt(i);return(Se(u)?mn.some(u):mn.none()).fold(function(){return r.body.contains(e)},(t=rt,o=Oe,function(n){return t(o(n))}))},it=function(n){var e=n.dom.body;if(null==e)throw new Error("Body is not available yet");return fe.fromDom(e)},ut=function(n){W(n,ie()),M(n.components(),ut)},ct=function(n){M(n.components(),ct),W(n,re())},at=function(n,e,t){n.getSystem().addToWorld(e),t(n.element,e.element),rt(n.element)&&ct(e),n.syncComponents()},st=Object.keys,ft=Object.hasOwnProperty,lt=function(n,o){var r={};return Ee(n,function(n,e){var t=o(n,e);r[t.k]=t.v}),r},dt=function(n,e){return ft.call(n,e)},mt=Object.freeze({__proto__:null,toAlpha:function(n,e,t){Ge(n.element,e.alpha,e.omega)},toOmega:function(n,e,t){Ge(n.element,e.omega,e.alpha)},isAlpha:function(n,e,t){return $e(n.element,e.alpha)},isOmega:function(n,e,t){return $e(n.element,e.omega)},clear:function(n,e,t){Le(n.element,e.alpha),Le(n.element,e.omega)}}),gt=function(t){return{isValue:x,isError:S,getOr:w(t),getOrThunk:w(t),getOrDie:w(t),or:function(n){return gt(t)},orThunk:function(n){return gt(t)},fold:function(n,e){return e(t)},map:function(n){return gt(n(t))},mapError:function(n){return gt(t)},each:function(n){n(t)},bind:function(n){return n(t)},exists:function(n){return n(t)},forall:function(n){return n(t)},toOptional:function(){return mn.some(t)}}},pt=function(t){return{isValue:S,isError:x,getOr:K,getOrThunk:function(n){return n()},getOrDie:function(){return h(String(t))()},or:K,orThunk:function(n){return n()},fold:function(n,e){return n(t)},map:function(n){return pt(t)},mapError:function(n){return pt(n(t))},each:Y,bind:function(n){return pt(t)},exists:S,forall:x,toOptional:mn.none}},ht={value:gt,error:pt,fromOption:function(n,e){return n.fold(function(){return pt(e)},gt)}};function vt(n,e,t){return n.stype===Ue.Error?e(n.serror):t(n.svalue)}function bt(n){return{stype:Ue.Value,svalue:n}}function yt(n){return{stype:Ue.Error,serror:n}}function xt(n,e,t,o){return{tag:"field",key:n,newKey:e,presence:t,prop:o}}function wt(n,e,t){switch(n.tag){case"field":return e(n.key,n.newKey,n.presence,n.prop);case"custom":return t(n.newKey,n.instantiator)}}function St(u){return function(){for(var n=[],e=0;e<arguments.length;e++)n[e]=arguments[e];if(0===n.length)throw new Error("Can't merge zero objects");for(var t={},o=0;o<n.length;o++){var r,i=n[o];for(r in i)dt(i,r)&&(t[r]=u(t[r],i[r]))}return t}}function Ot(){return{tag:"required",process:{}}}function kt(n){return{tag:"defaultedThunk",process:n}}function Tt(n){return kt(w(n))}function Ct(){return{tag:"option",process:{}}}function Et(n){return{tag:"mergeWithThunk",process:n}}function Dt(n){return a(n)&&100<st(n).length?" removed due to size":JSON.stringify(n,null,2)}function Mt(n,e){return eo([{path:n,getErrorInfo:e}])}function _t(t){return{extract:function(e,n){return oo(t(n),function(n){return Mt(e,w(n))})},toString:w("val")}}function Rt(n,e,t,o){return o(_e(n,e).getOrThunk(function(){return t(n)}))}function Ft(e,t,o,r,i){function u(n){return i.extract(t.concat([r]),n)}function n(n){return n.fold(function(){return no(mn.none())},function(n){var e=i.extract(t.concat([r]),n);return ro(e,mn.some)})}var c,a,s,f,l,d;switch(e.tag){case"required":return s=t,d=u,_e(f=o,l=r).fold(function(){return n=l,e=f,Mt(s,function(){return'Could not find valid *required* value for "'+n+'" in '+Dt(e)});var n,e},d);case"defaultedThunk":return Rt(o,r,e.process,u);case"option":return n(_e(o,r));case"defaultedOptionThunk":return a=e.process,n(_e(c=o,r).map(function(n){return!0===n?a(c):n}));case"mergeWithThunk":return Rt(o,r,w({}),function(n){return u(co(e.process(o),n))})}}function It(n){var s=lo(n),f=_(n,function(t,n){return wt(n,function(n){var e;return co(t,((e={})[n]=!0,e))},w(t))},{});return{extract:function(n,e){var t,o,r,i,u,c,a=E(d(e)?[]:st((r=l,i=o={},u=function(n,e){i[e]=n},c=Y,Ee(e,function(n,e){(r(n,e)?u:c)(n,e)}),o)),function(n){return!Re(f,n)});return 0===a.length?s.extract(n,e):(t=a,Mt(n,function(){return"There are unsupported fields: ["+t.join(", ")+"] specified"}))},toString:s.toString}}function Vt(c,a){return{extract:function(t,o){var r,n,i,e=st(o),u=(i=_t(c),r=t,n=Z(e,function(n,e){return i.extract(r.concat(["["+e+"]"]),n)}),so(n));return to(u,function(n){var e=Z(n,function(n){return xt(n,n,Ot(),a)});return lo(e).extract(t,o)})},toString:function(){return"setOf("+a.toString()+")"}}}function Bt(e,c){return{extract:function(i,u){return _e(u,e).fold(function(){return n=e,Mt(i,function(){return'Choice schema did not contain choice key: "'+n+'"'});var n},function(n){return t=i,e=u,_e(o=c,r=n).fold(function(){return n=o,e=r,Mt(t,function(){return'The chosen schema: "'+e+'" did not exist in branches: '+Dt(n)});var n,e},function(n){return n.extract(t.concat(["branch: "+r]),e)});var t,e,o,r})},toString:function(){return"chooseOn("+e+"). Possible values: "+st(c)}}}function At(e){return _t(function(n){return e(n).fold(eo,no)})}function Nt(e,n){return Vt(function(n){return e(n).fold(yt,bt)},n)}function Ht(n,e,t){return Zt((r=e.extract([n],o=t),io(r,function(n){return{input:o,errors:n}})));var o,r}function Pt(n){return n.fold(function(n){throw new Error(po(n))},K)}function zt(n,e,t){return Pt(Ht(n,e,t))}function jt(n,e){return Bt(n,De(e,lo))}function Lt(n){return ho(n,n,Ot(),mo())}function $t(n,e){return ho(n,n,Ot(),e)}function Gt(n,e){return ho(n,n,Ot(),lo(e))}function Ut(n){return ho(n,n,Ct(),mo())}function Wt(n,e){return ho(n,n,Ct(),e)}function Xt(n,e){return Wt(n,lo(e))}function qt(n,e){return Wt(n,It(e))}function Yt(n,e){return ho(n,n,Tt(e),mo())}function Kt(n,e,t){return ho(n,n,Tt(e),t)}(We=Ue={})[We.Error=0]="Error",We[We.Value=1]="Value";function Jt(u){if(!D(u))throw new Error("cases must be an array");if(0===u.length)throw new Error("there must be at least one case");var c=[],t={};return M(u,function(n,o){var e=st(n);if(1!==e.length)throw new Error("one and only one name per case");var r=e[0],i=n[r];if(void 0!==t[r])throw new Error("duplicate key detected:"+r);if("cata"===r)throw new Error("cannot have a case named cata (sorry)");if(!D(i))throw new Error("case arguments must be an array");c.push(r),t[r]=function(){for(var t=[],n=0;n<arguments.length;n++)t[n]=arguments[n];var e=t.length;if(e!==i.length)throw new Error("Wrong number of arguments to case "+r+". Expected "+i.length+" ("+i+"), got "+e);return{fold:function(){for(var n=[],e=0;e<arguments.length;e++)n[e]=arguments[e];if(n.length!==u.length)throw new Error("Wrong number of arguments to fold. Expected "+u.length+", got "+n.length);return n[o].apply(null,t)},match:function(n){var e=st(n);if(c.length!==e.length)throw new Error("Wrong number of arguments to match. Expected: "+c.join(",")+"\nActual: "+e.join(","));if(!A(c,function(n){return T(e,n)}))throw new Error("Not all branches were specified when using match. Specified: "+e.join(", ")+"\nRequired: "+c.join(", "));return n[r].apply(null,t)},log:function(n){console.log(n,{constructors:c,constructor:r,params:t})}}}}),t}var Qt,Zt=function(n){return vt(n,ht.error,ht.value)},no=bt,eo=yt,to=function(n,e){return n.stype===Ue.Value?e(n.svalue):n},oo=function(n,e){return n.stype===Ue.Error?e(n.serror):n},ro=function(n,e){return n.stype===Ue.Value?{stype:Ue.Value,svalue:e(n.svalue)}:n},io=function(n,e){return n.stype===Ue.Error?{stype:Ue.Error,serror:e(n.serror)}:n},uo=vt,co=St(function(n,e){return a(n)&&a(e)?co(n,e):e}),ao=St(function(n,e){return e}),so=function(n){var e,t,o=(e=[],t=[],M(n,function(n){vt(n,function(n){return t.push(n)},function(n){return e.push(n)})}),{values:e,errors:t});return 0<o.errors.length?i(eo,V)(o.errors):no(o.values)},fo=_t(no),lo=function(t){return{extract:function(i,u){for(var c={},a=[],n=0,e=t;n<e.length;n++)wt(e[n],function(n,e,t,o){var r=Ft(t,i,u,n,o);uo(r,function(n){a.push.apply(a,n)},function(n){c[e]=n})},function(n,e){c[n]=e(u)});return 0<a.length?eo(a):no(c)},toString:function(){return"obj{\n"+Z(t,function(n){return wt(n,function(n,e,t,o){return n+" -> "+o.toString()},function(n,e){return"state("+n+")"})}).join("\n")+"}"}}},mo=w(fo),go=(Qt=m,_t(function(n){var e=typeof n;return Qt(n)?no(n):eo("Expected type: function but got: "+e)})),po=function(n){return"Errors: \n"+Z(10<(e=n.errors).length?e.slice(0,10).concat([{path:[],getErrorInfo:w("... (only showing first ten failures)")}]):e,function(n){return"Failed path: ("+n.path.join(" > ")+")\n"+n.getErrorInfo()}).join("\n")+"\n\nInput object: "+Dt(n.input);var e},ho=xt,vo=function(n,e){return{tag:"custom",newKey:n,instantiator:e}},bo=[Lt("alpha"),Lt("omega")];function yo(n,e){return(t={})[n]=e,t;var t}function xo(n){return e={},M(n,function(n){e[n.key]=n.value}),e;var e}function wo(n,e,t){return void 0===t&&(t=o),n.exists(function(n){return t(n,e)})}function So(n){for(var e=[],t=function(n){e.push(n)},o=0;o<n.length;o++)n[o].each(t);return e}function Oo(n){return m(n)?n:S}function ko(n,e){return un(n.element,e.event.target)}function To(n){if(!Re(n,"can")&&!Re(n,"abort")&&!Re(n,"run"))throw new Error("EventHandler defined by: "+JSON.stringify(n,null,2)+" does not have can, abort, or run!");return y(y({},Xo),n)}function Co(n,e){return{key:n,value:To({abort:e})}}function Eo(n,e){return{key:n,value:To({run:e})}}function Do(n,t,o){return{key:n,value:To({run:function(n,e){t.apply(void 0,[n,e].concat(o))}})}}function Mo(n){return function(t){return{key:n,value:To({run:function(n,e){ko(n,e)&&t(n,e)}})}}}function _o(n,e,t){var i,o,r=e.partUids[t];return o=r,Eo(i=n,function(n,r){n.getSystem().getByUid(o).each(function(n){var e=n.element,t=i,o=r;n.getSystem().triggerEvent(t,e,o.event)})})}function Ro(n){return Eo(n,function(n,e){e.cut()})}function Fo(n,e){var t=n.toString(),o=t.indexOf(")")+1,r=t.indexOf("("),i=t.substring(r+1,o-1).split(/,\s*/);return n.toFunctionAnnotation=function(){return{name:e,parameters:Zo(i)}},n}function Io(n){return{classes:f(n.classes)?[]:n.classes,attributes:f(n.attributes)?{}:n.attributes,styles:f(n.styles)?{}:n.styles}}function Vo(t,o,r){return Jo(function(n,e){r(n,t,o)})}function Bo(n){return{key:n,value:void 0}}function Ao(n){var e=zt("Creating behaviour: "+n.name,rr,n),t=e.fields,o=e.name,r=e.active,i=e.apis,u=e.extra,c=e.state,a=It(t),s=Xt(o,[qt("config",t)]);return nr(a,s,o,r,i,u,c)}function No(n){var e=n;return{get:function(){return e},set:function(n){e=n}}}function Ho(n){return n.dom.focus()}function Po(n){return n.dom.blur()}function zo(n){return void 0===n&&(n=fe.fromDom(document)),mn.from(n.dom.activeElement).map(fe.fromDom)}function jo(e){return zo(tt(e)).filter(function(n){return e.dom.contains(n.dom)})}function Lo(n){return n.dom.innerHTML}function $o(n){if(Se(n))return"#shadow-root";var e=fe.fromDom(n.dom.cloneNode(!1)),t=fe.fromTag("div"),o=fe.fromDom(e.dom.cloneNode(!0));return Qe(t,o),Lo(t)}Jt([{bothErrors:["error1","error2"]},{firstError:["error1","value2"]},{secondError:["value1","error2"]},{bothValues:["value1","value2"]}]);var Go,Uo,Wo,Xo={can:x,abort:S,run:Y},qo=xo,Yo=Mo(re()),Ko=Mo(ie()),Jo=Mo(oe()),Qo=(Go=Zn(),function(n){return Eo(Go,n)}),Zo=function(n){return Z(n,function(n){return 0,e=n.length-"/*".length,n.length>="/*".length&&"/*"===n.substr(e,e+"/*".length)?n.substring(0,n.length-"/*".length):n;var e})},nr=function(t,n,l,i,e,o,r){function u(n){return Re(n,l)?n[l]():mn.none()}var c=De(e,function(n,e){return r=l,t=function(t){for(var n=[],e=1;e<arguments.length;e++)n[e-1]=arguments[e];var o=[t].concat(n);return t.config({name:w(r)}).fold(function(){throw new Error("We could not find any behaviour configuration for: "+r+". Using API: "+u)},function(n){var e=Array.prototype.slice.call(o,1);return i.apply(void 0,[t,n.config,n.state].concat(e))})},o=u=e,c=(i=n).toString(),a=c.indexOf(")")+1,s=c.indexOf("("),f=c.substring(s+1,a-1).split(/,\s*/),t.toFunctionAnnotation=function(){return{name:o,parameters:Zo(f.slice(0,1).concat(f.slice(3)))}},t;var r,i,u,t,o,c,a,s,f}),a=De(o,Fo),s=y(y(y({},a),c),{revoke:J(Bo,l),config:function(n){var e=zt(l+"-config",t,n);return{key:l,value:{config:e,me:s,configAsRaw:k(function(){return zt(l+"-config",t,n)}),initialConfig:n,state:r}}},schema:w(n),exhibit:function(n,t){return e=u(n),o=_e(i,"exhibit"),r=function(n,e){return e(t,n.config,n.state)},(e.isSome()&&o.isSome()?mn.some(r(e.getOrDie(),o.getOrDie())):mn.none()).getOrThunk(function(){return Io({})});var e,o,r},name:w(l),handlers:function(n){return u(n).map(function(n){return _e(i,"events").getOr(function(){return{}})(n.config,n.state)}).getOr({})}});return s},er={init:function(){return tr({readState:w("No State required")})}},tr=function(n){return n},or=xo,rr=It([Lt("fields"),Lt("name"),Yt("active",{}),Yt("apis",{}),Yt("state",er),Yt("extra",{})]),ir=It([Lt("branchKey"),Lt("branches"),Lt("name"),Yt("active",{}),Yt("apis",{}),Yt("state",er),Yt("extra",{})]),ur=w(void 0),cr=Ao({fields:bo,name:"swapping",apis:mt}),ar=tinymce.util.Tools.resolve("tinymce.dom.DOMUtils"),sr=tinymce.util.Tools.resolve("tinymce.ThemeManager"),fr=[{title:"Headings",items:[{title:"Heading 1",format:"h1"},{title:"Heading 2",format:"h2"},{title:"Heading 3",format:"h3"},{title:"Heading 4",format:"h4"},{title:"Heading 5",format:"h5"},{title:"Heading 6",format:"h6"}]},{title:"Inline",items:[{title:"Bold",icon:"bold",format:"bold"},{title:"Italic",icon:"italic",format:"italic"},{title:"Underline",icon:"underline",format:"underline"},{title:"Strikethrough",icon:"strikethrough",format:"strikethrough"},{title:"Superscript",icon:"superscript",format:"superscript"},{title:"Subscript",icon:"subscript",format:"subscript"},{title:"Code",icon:"code",format:"code"}]},{title:"Blocks",items:[{title:"Paragraph",format:"p"},{title:"Blockquote",format:"blockquote"},{title:"Div",format:"div"},{title:"Pre",format:"pre"}]},{title:"Alignment",items:[{title:"Left",icon:"alignleft",format:"alignleft"},{title:"Center",icon:"aligncenter",format:"aligncenter"},{title:"Right",icon:"alignright",format:"alignright"},{title:"Justify",icon:"alignjustify",format:"alignjustify"}]}],lr=["undo","bold","italic","link","image","bullist","styleselect"],dr="formatChanged",mr="orientationChanged",gr="dropupDismissed",pr=Object.freeze({__proto__:null,events:function(o){return qo([Eo(Qn(),function(r,n){var e,i=o.channels,t=st(i),u=n;M((e=u).universal?t:E(t,function(n){return T(e.channels,n)}),function(n){var e=i[n],t=e.schema,o=zt("channel["+n+"] data\nReceiver: "+$o(r.element),t,u.data);e.onReceive(r,o)})})])}}),hr="unknown";function vr(e,n,t){var o,r,i,u;switch(_e(br.get(),e).orThunk(function(){return z(st(br.get()),function(n){return-1<e.indexOf(n)?mn.some(br.get()[n]):mn.none()})}).getOr(Uo.NORMAL)){case Uo.NORMAL:return t(xr());case Uo.LOGGING:var c=(o=e,r=n,i=[],u=(new Date).getTime(),{logEventCut:function(n,e,t){i.push({outcome:"cut",target:e,purpose:t})},logEventStopped:function(n,e,t){i.push({outcome:"stopped",target:e,purpose:t})},logNoParent:function(n,e,t){i.push({outcome:"no-parent",target:e,purpose:t})},logEventNoHandlers:function(n,e){i.push({outcome:"no-handlers-left",target:e})},logEventResponse:function(n,e,t){i.push({outcome:"response",purpose:t,target:e})},write:function(){var n=(new Date).getTime();T(["mousemove","mouseover","mouseout",oe()],o)||console.log(o,{event:o,time:n-u,target:r.dom,sequence:Z(i,function(n){return T(["cut","stopped","response"],n.outcome)?"{"+n.purpose+"} "+n.outcome+" at ("+$o(n.target)+")":n.outcome})})}}),a=t(c);return c.write(),a;case Uo.STOP:return!0}}(Wo=Uo={})[Wo.STOP=0]="STOP",Wo[Wo.NORMAL=1]="NORMAL",Wo[Wo.LOGGING=2]="LOGGING";var br=No({}),yr=["alloy/data/Fields","alloy/debugging/Debugging"],xr=w({logEventCut:Y,logEventStopped:Y,logNoParent:Y,logEventNoHandlers:Y,logEventResponse:Y,write:Y}),wr=w([Lt("menu"),Lt("selectedMenu")]),Sr=w([Lt("item"),Lt("selectedItem")]);function Or(n,e,t){return void 0!==(o=new Error).stack&&F(o.stack.split("\n"),function(e){return 0<e.indexOf("alloy")&&!C(yr,function(n){return-1<e.indexOf(n)})}).getOr(hr),ho(e,e,t,At(function(t){return ht.value(function(){for(var n=[],e=0;e<arguments.length;e++)n[e]=arguments[e];return t.apply(void 0,n)})}));var o}function kr(n){return Or(0,n,Tt(Y))}function Tr(n){return Or(0,n,Tt(mn.none))}function Cr(n){return Or(0,n,Ot())}function Er(n){return Or(0,n,Ot())}function Dr(n,e){return vo(n,w(e))}function Mr(n){return vo(n,K)}function _r(n,e,t){var o=e.aria;o.update(n,o,t.get())}function Rr(e,n,t){n.toggleClass.each(function(n){(t.get()?je:Le)(e.element,n)})}function Fr(n,e,t){Qr(n,e,t,!t.get())}function Ir(n,e,t){t.set(!0),Rr(n,e,t),_r(n,e,t)}function Vr(n,e,t){t.set(!1),Rr(n,e,t),_r(n,e,t)}function Br(n,e,t){Qr(n,e,t,e.selected)}function Ar(t,o){return ti.config({channels:yo(dr,{onReceive:function(n,e){e.command===t&&o(n,e.state)}})})}function Nr(n){return ti.config({channels:yo(mr,{onReceive:n})})}function Hr(n,e){return{key:n,value:{onReceive:e}}}function Pr(){function n(n,e){e.stop(),q(n)}return[Eo(Un(),n),Eo(ee(),n),Ro(Vn()),Ro(Nn())]}function zr(n,e){e.ignore||(Ho(n.element),e.onFocus(n))}function jr(n){return void 0!==n.style&&m(n.style.getPropertyValue)}function Lr(n,e,t){if(!r(t))throw console.error("Invalid call to CSS.set. Property ",e,":: Value ",t,":: Element ",n),new Error("CSS value must be a string: "+t);jr(n)&&n.style.setProperty(e,t)}function $r(n,e,t){Lr(n.dom,e,t)}function Gr(n,e){var t=n.dom;Ee(e,function(n,e){Lr(t,e,n)})}function Ur(n,e){var t=n.dom,o=window.getComputedStyle(t).getPropertyValue(e);return""!==o||rt(n)?o:li(t,e)}function Wr(n,e){var t=n.dom,o=li(t,e);return mn.from(o).filter(function(n){return 0<n.length})}function Xr(n,e){var t,o=e;jr(t=n.dom)&&t.style.removeProperty(o),wo(Ae(n,"style").map(yn),"")&&He(n,"style")}function qr(n){return n.dom.offsetWidth}function Yr(o,r){function n(n){var e=r(n);if(e<=0||null===e){var t=Ur(n,o);return parseFloat(t)||0}return e}function i(r,n){return R(n,function(n,e){var t=Ur(r,e),o=void 0===t?0:parseInt(t,10);return isNaN(o)?n:n+o},0)}return{set:function(n,e){if(!g(e)&&!e.match(/^[0-9]+$/))throw new Error(o+".set accepts only positive integer values. Value was "+e);var t=n.dom;jr(t)&&(t.style[o]=e+"px")},get:n,getOuter:n,aggregate:i,max:function(n,e,t){var o=i(n,t);return o<e?e-o:0}}}function Kr(n){return di.get(n)}function Jr(n,e){return on(e,n)}w(lo(Sr().concat(wr())));function Qr(n,e,t,o){(o?Ir:Vr)(n,e,t)}function Zr(n,e,t){Ie(n.element,"aria-expanded",t)}var ni=w(lo(Sr())),ei=w(Gt("initSize",[Lt("numColumns"),Lt("numRows")])),ti=Ao({fields:[$t("channels",Nt(ht.value,It([Cr("onReceive"),Yt("schema",mo())])))],name:"receiving",active:pr}),oi=Object.freeze({__proto__:null,onLoad:Br,toggle:Fr,isOn:function(n,e,t){return t.get()},on:Ir,off:Vr,set:Qr}),ri=Object.freeze({__proto__:null,exhibit:function(){return Io({})},events:function(n,e){var t,o,r,i=(t=n,o=e,r=Fr,Qo(function(n){r(n,t,o)})),u=Vo(n,e,Br);return qo(V([n.toggleOnExecute?[i]:[],[u]]))}}),ii=Ao({fields:[Yt("selected",!1),Ut("toggleClass"),Yt("toggleOnExecute",!0),Kt("aria",{mode:"none"},jt("mode",{pressed:[Yt("syncWithExpanded",!1),Dr("update",function(n,e,t){Ie(n.element,"aria-pressed",t),e.syncWithExpanded&&Zr(n,0,t)})],checked:[Dr("update",function(n,e,t){Ie(n.element,"aria-checked",t)})],expanded:[Dr("update",Zr)],selected:[Dr("update",function(n,e,t){Ie(n.element,"aria-selected",t)})],none:[Dr("update",Y)]}))],name:"toggling",active:ri,apis:oi,state:{init:function(){var e=No(!1);return{get:function(){return e.get()},set:function(n){return e.set(n)},clear:function(){return e.set(!1)},readState:function(){return e.get()}}}}}),ui="tinymce-mobile",ci=function(n){return ui+"-"+n},ai=Object.freeze({__proto__:null,focus:zr,blur:function(n,e){e.ignore||Po(n.element)},isFocused:function(n){return e=n.element,t=tt(e).dom,e.dom===t.activeElement;var e,t}}),si=Object.freeze({__proto__:null,exhibit:function(n,e){return Io(e.ignore?{}:{attributes:{tabindex:"-1"}})},events:function(t){return qo([Eo(Yn(),function(n,e){zr(n,t),e.stop()})].concat(t.stopMousedown?[Eo(Nn(),function(n,e){e.event.prevent()})]:[]))}}),fi=Ao({fields:[kr("onFocus"),Yt("stopMousedown",!1),Yt("ignore",!1)],name:"focusing",active:si,apis:ai}),li=function(n,e){return jr(n)?n.style.getPropertyValue(e):""},di=Yr("height",function(n){var e=n.dom;return rt(n)?e.getBoundingClientRect().height:e.offsetHeight});function mi(n,e,t,o,r){return n(t,o)?mn.some(t):m(r)&&r(t)?mn.none():e(t,o,r)}function gi(n,e,t){for(var o=n.dom,r=m(t)?t:S;o.parentNode;){var o=o.parentNode,i=fe.fromDom(o);if(e(i))return mn.some(i);if(r(i))break}return mn.none()}function pi(n,e,t){return gi(n,function(n){return en(n,e)},t)}function hi(n,e){return rn(e,n)}function vi(n,e,t){return mi(en,pi,n,e,t)}function bi(n,e,t){var o=N(n.slice(0,e)),r=N(n.slice(e+1));return F(o.concat(r),t)}function yi(n,e,t){return F(N(n.slice(0,e)),t)}function xi(n,e,t){var o=n.slice(0,e);return F(n.slice(e+1).concat(o),t)}function wi(n,e,t){return F(n.slice(e+1),t)}function Si(t){return function(n){var e=n.raw;return T(t,e.which)}}function Oi(n){return function(e){return A(n,function(n){return n(e)})}}function ki(n){return!0===n.raw.shiftKey}function Ti(n){return!0===n.raw.ctrlKey}function Ci(n,e){return{matches:n,classification:e}}function Ei(n,e,t,o){var r=n+e;return o<r?t:r<t?o:r}function Di(n,e,t){return Math.min(Math.max(n,e),t)}function Mi(t,o,n,r){M(Jr(t.element,"."+o.highlightClass),function(e){C(r,function(n){return n.element===e})||(Le(e,o.highlightClass),t.getSystem().getByDom(e).each(function(n){o.onDehighlight(t,n),W(n,ae())}))})}function _i(n,e,t,o){Mi(n,e,0,[o]),Bi(0,e,0,o)||(je(o.element,e.highlightClass),e.onHighlight(n,o),W(o,ce()))}function Ri(t,e,n,o){var r=Jr(t.element,"."+e.itemClass);return I(r,function(n){return $e(n,e.highlightClass)}).bind(function(n){var e=Ei(n,o,0,r.length-1);return t.getSystem().getByDom(r[e]).toOptional()})}function Fi(n,e,t){e.exists(function(e){return t.exists(function(n){return un(n,e)})})||X(n,ue(),{prevFocus:e,newFocus:t})}function Ii(){function o(n){return jo(n.element)}return{get:o,set:function(n,e){var t=o(n);n.getSystem().triggerFocus(e,n.element),Fi(n,t,o(n))}}}function Vi(){function r(n){return Qi.getHighlighted(n).map(function(n){return n.element})}return{get:r,set:function(e,n){var t=r(e);e.getSystem().getByDom(n).fold(Y,function(n){Qi.highlight(e,n)});var o=r(e);Fi(e,t,o)}}}function Bi(n,e,t,o){return $e(o.element,e.highlightClass)}function Ai(e,n,t){return hi(e.element,"."+n.itemClass).bind(function(n){return e.getSystem().getByDom(n).toOptional()})}function Ni(e,n,t){var o=Jr(e.element,"."+n.itemClass);return(0<o.length?mn.some(o[o.length-1]):mn.none()).bind(function(n){return e.getSystem().getByDom(n).toOptional()})}function Hi(e,n,t){return So(Z(Jr(e.element,"."+n.itemClass),function(n){return e.getSystem().getByDom(n).toOptional()}))}var Pi,zi,ji=[8],Li=[9],$i=[13],Gi=[27],Ui=[32],Wi=[37],Xi=[38],qi=[39],Yi=[40],Ki=Q(ki),Ji=Object.freeze({__proto__:null,dehighlightAll:function(n,e,t){return Mi(n,e,0,[])},dehighlight:function(n,e,t,o){Bi(0,e,0,o)&&(Le(o.element,e.highlightClass),e.onDehighlight(n,o),W(o,ae()))},highlight:_i,highlightFirst:function(e,t,n){Ai(e,t).each(function(n){_i(e,t,0,n)})},highlightLast:function(e,t,n){Ni(e,t).each(function(n){_i(e,t,0,n)})},highlightAt:function(e,t,n,o){var r,i,u;i=o,u=Jr((r=e).element,"."+t.itemClass),mn.from(u[i]).fold(function(){return ht.error(new Error("No element found with index "+i))},r.getSystem().getByDom).fold(function(n){throw n},function(n){_i(e,t,0,n)})},highlightBy:function(e,t,n,o){F(Hi(e,t),o).each(function(n){_i(e,t,0,n)})},isHighlighted:Bi,getHighlighted:function(e,n,t){return hi(e.element,"."+n.highlightClass).bind(function(n){return e.getSystem().getByDom(n).toOptional()})},getFirst:Ai,getLast:Ni,getPrevious:function(n,e,t){return Ri(n,e,0,-1)},getNext:function(n,e,t){return Ri(n,e,0,1)},getCandidates:Hi}),Qi=Ao({fields:[Lt("highlightClass"),Lt("itemClass"),kr("onHighlight"),kr("onDehighlight")],name:"highlighting",apis:Ji});function Zi(n,e,t,o,c){function a(e,t,n,o,r){var i=n(e,t,o,r),u=t.event;return F(i,function(n){return n.matches(u)}).map(function(n){return n.classification}).bind(function(n){return n(e,t,o,r)})}var r={schema:function(){return n.concat([Yt("focusManager",Ii()),Kt("focusInside","onFocus",At(function(n){return T(["onFocus","onEnterOrSpace","onApi"],n)?ht.value(n):ht.error("Invalid value for focusInside")})),Dr("handler",r),Dr("state",e),Dr("sendFocusIn",c)])},processKey:a,toEvents:function(i,u){var n=i.focusInside!==Pi.OnFocusMode?mn.none():c(i).map(function(t){return Eo(Yn(),function(n,e){t(n,i,u),e.stop()})}),e=[Eo(jn(),function(o,r){a(o,r,t,i,u).fold(function(){var e=o,t=r,n=Si(Ui.concat($i))(t.event);i.focusInside===Pi.OnEnterOrSpaceMode&&n&&ko(e,t)&&c(i).each(function(n){n(e,i,u),t.stop()})},function(n){r.stop()})}),Eo(Ln(),function(n,e){a(n,e,o,i,u).each(function(n){e.stop()})})];return qo(n.toArray().concat(e))}};return r}function nu(n){function c(n,e){return 0<Kr(n.visibilitySelector.bind(function(n){return vi(e,n)}).getOr(e))}function e(e,t,n){var o=t,r=E(Jr(e.element,o.selector),function(n){return c(o,n)});mn.from(r[o.firstTabstop]).each(function(n){t.focusManager.set(e,n)})}function o(t,n,r,i){var e,u=Jr(t.element,r.selector);return(e=r).focusManager.get(t).bind(function(n){return vi(n,e.selector)}).bind(function(n){return I(u,J(un,n)).bind(function(n){return e=t,o=r,i(u,n,function(n){return c(e=o,t=n)&&e.useTabstopAt(t);var e,t}).fold(function(){return o.cyclic?mn.some(!0):mn.none()},function(n){return o.focusManager.set(e,n),mn.some(!0)});var e,o})})}var t=[Ut("onEscape"),Ut("onEnter"),Yt("selector",'[data-alloy-tabstop="true"]:not(:disabled)'),Yt("firstTabstop",0),Yt("useTabstopAt",x),Ut("visibilitySelector")].concat([n]),r=w([Ci(Oi([ki,Si(Li)]),function(n,e,t){return o(n,0,t,t.cyclic?bi:yi)}),Ci(Si(Li),function(n,e,t){return o(n,0,t,t.cyclic?xi:wi)}),Ci(Si(Gi),function(e,t,n){return n.onEscape.bind(function(n){return n(e,t)})}),Ci(Oi([Ki,Si($i)]),function(e,t,n){return n.onEnter.bind(function(n){return n(e,t)})})]),i=w([]);return Zi(t,er.init,r,i,function(){return mn.some(e)})}function eu(n){return"input"===le(n)&&"radio"!==Be(n,"type")||"textarea"===le(n)}function tu(n,e,t){return eu(t)&&Si(Ui)(e.event)?mn.none():(nn(n,t,Zn()),mn.some(!0))}function ou(n,e){return mn.some(!0)}function ru(n,e,t){return t.execute(n,e,n.element)}function iu(n){function e(){return t.get().each(n)}var t=No(mn.none());return{clear:function(){e(),t.set(mn.none())},isSet:function(){return t.get().isSome()},get:function(){return t.get()},set:function(n){e(),t.set(mn.some(n))}}}function uu(){var e=iu(function(n){return n.destroy()});return y(y({},e),{run:function(n){return e.get().each(n)}})}function cu(){var e=iu(Y);return y(y({},e),{on:function(n){return e.get().each(n)}})}function au(){var t=cu();return tr({readState:function(){return t.get().map(function(n){return{numRows:String(n.numRows),numColumns:String(n.numColumns)}}).getOr({numRows:"?",numColumns:"?"})},setGridSize:function(n,e){t.set({numRows:n,numColumns:e})},getNumRows:function(){return t.get().map(function(n){return n.numRows})},getNumColumns:function(){return t.get().map(function(n){return n.numColumns})}})}function su(e,t){return function(n){return"rtl"===cc(n)?t:e}}function fu(i){return function(n,e,t,o){var r=i(n.element);return ac(r,n,e,t,o)}}function lu(n,e){return fu(su(n,e))}function du(n,e){return fu(su(e,n))}function mu(r){return function(n,e,t,o){return ac(r,n,e,t,o)}}function gu(n){return!((e=n.dom).offsetWidth<=0&&e.offsetHeight<=0);var e}function pu(n,e,t){var o,r=E(Jr(n,t),gu);return I(o=r,function(n){return un(n,e)}).map(function(n){return{index:n,candidates:o}})}function hu(n,e){return I(n,function(n){return un(e,n)})}function vu(t,n,o,e){return e(Math.floor(n/o),n%o).bind(function(n){var e=n.row*o+n.column;return 0<=e&&e<t.length?mn.some(t[e]):mn.none()})}function bu(r,n,i,u,c){return vu(r,n,u,function(n,e){var t=n===i-1?r.length-n*u:u,o=Ei(e,c,0,t-1);return mn.some({row:n,column:o})})}function yu(r,n,i,u,c){return vu(r,n,u,function(n,e){var t=Ei(n,c,0,i-1),o=Di(e,0,(t===i-1?r.length-t*u:u)-1);return mn.some({row:t,column:o})})}function xu(e,t,n){hi(e.element,t.selector).each(function(n){t.focusManager.set(e,n)})}function wu(r){return function(n,e,t,o){return pu(n,e,t.selector).bind(function(n){return r(n.candidates,n.index,o.getNumRows().getOr(t.initSize.numRows),o.getNumColumns().getOr(t.initSize.numColumns))})}}function Su(n,e,t){return t.captureTab?mn.some(!0):mn.none()}function Ou(n,e,t,i){var u=function(n,e,t){var o,r=Ei(e,i,0,t.length-1);return r===n?mn.none():"button"===le(o=t[r])&&"disabled"===Be(o,"disabled")?u(n,r,t):mn.from(t[r])};return pu(n,t,e).bind(function(n){var e=n.index,t=n.candidates;return u(e,e,t)})}function ku(e,t,o){return(r=o).focusManager.get(e).bind(function(n){return vi(n,r.selector)}).bind(function(n){return o.execute(e,t,n)});var r}function Tu(e,t,n){t.getInitial(e).orThunk(function(){return hi(e.element,t.selector)}).each(function(n){t.focusManager.set(e,n)})}function Cu(n,e,t){return Ou(n,t.selector,e,-1)}function Eu(n,e,t){return Ou(n,t.selector,e,1)}function Du(r){return function(n,e,t,o){return r(n,e,t,o).bind(function(){return t.executeOnMove?ku(n,e,t):mn.some(!0)})}}function Mu(n,e,t){return t.onEscape(n,e)}function _u(n,e,t){return mn.from(n[e]).bind(function(n){return mn.from(n[t]).map(function(n){return{rowIndex:e,columnIndex:t,cell:n}})})}function Ru(n,e,t,o){return _u(n,e,Ei(t,o,0,n[e].length-1))}function Fu(n,e,t,o){var r=Ei(t,o,0,n.length-1);return _u(n,r,Di(e,0,n[r].length-1))}function Iu(n,e,t,o){return _u(n,e,Di(t+o,0,n[e].length-1))}function Vu(n,e,t,o){var r=Di(t+o,0,n.length-1);return _u(n,r,Di(e,0,n[r].length-1))}function Bu(e,t,n){t.previousSelector(e).orThunk(function(){var n=t.selectors;return hi(e.element,n.cell)}).each(function(n){t.focusManager.set(e,n)})}function Au(n,o){return function(e,t,i){var u=i.cycles?n:o;return vi(t,i.selectors.row).bind(function(n){return hu(Jr(n,i.selectors.cell),t).bind(function(o){var r=Jr(e,i.selectors.row);return hu(r,n).bind(function(n){var e,t=(e=i,Z(r,function(n){return Jr(n,e.selectors.cell)}));return u(t,n,o).map(function(n){return n.cell})})})})}}function Nu(e,t,o){return o.focusManager.get(e).bind(function(n){return o.execute(e,t,n)})}function Hu(e,t,n){hi(e.element,t.selector).each(function(n){t.focusManager.set(e,n)})}function Pu(n,e,t){return Ou(n,t.selector,e,-1)}function zu(n,e,t){return Ou(n,t.selector,e,1)}function ju(o,n){return e=o,t={},r=Z(n,function(n){return e=n.name(),t="Cannot configure "+n.name()+" for "+o,ho(e,e,Ct(),_t(function(n){return eo("The field: "+e+" is forbidden. "+t)}));var e,t}).concat([vo("dump",K)]),Kt(e,t,lo(r));var e,t,r}function Lu(n,e){return y(y({},or(e)),n.dump)}function $u(n){return dt(n,"uiType")}function Gu(n){var e=(new Date).getTime();return n+"_"+Math.floor(1e9*Math.random())+ ++Kc+String(e)}function Uu(n){function e(n){return n.name}return n.fold(e,e,e,e)}function Wu(t,o){return function(n){var e=zt("Converting part type",o,n);return t(e)}}(zi=Pi=Pi||{}).OnFocusMode="onFocus",zi.OnEnterOrSpaceMode="onEnterOrSpace",zi.OnApiMode="onApi";var Xu,qu,Yu,Ku,Ju,Qu,Zu,nc,ec,tc,oc=nu(vo("cyclic",S)),rc=nu(vo("cyclic",x)),ic=Zi([Yt("execute",tu),Yt("useSpace",!1),Yt("useEnter",!0),Yt("useControlEnter",!1),Yt("useDown",!1)],er.init,function(n,e,t,o){var r=t.useSpace&&!eu(n.element)?Ui:[],i=t.useEnter?$i:[],u=t.useDown?Yi:[];return[Ci(Si(r.concat(i).concat(u)),ru)].concat(t.useControlEnter?[Ci(Oi([Ti,Si($i)]),ru)]:[])},function(n,e,t,o){return t.useSpace&&!eu(n.element)?[Ci(Si(Ui),ou)]:[]},function(){return mn.none()}),uc=Object.freeze({__proto__:null,flatgrid:au,init:function(n){return n.state(n)}}),cc=function(n){return"rtl"===Ur(n,"direction")?"rtl":"ltr"},ac=function(e,t,n,o,r){return o.focusManager.get(t).bind(function(n){return e(t.element,n,o,r)}).map(function(n){return o.focusManager.set(t,n),!0})},sc=mu,fc=mu,lc=mu,dc=wu(function(n,e,t,o){return bu(n,e,t,o,-1)}),mc=wu(function(n,e,t,o){return bu(n,e,t,o,1)}),gc=wu(function(n,e,t,o){return yu(n,e,t,o,-1)}),pc=wu(function(n,e,t,o){return yu(n,e,t,o,1)}),hc=Zi([Lt("selector"),Yt("execute",tu),Tr("onEscape"),Yt("captureTab",!1),ei()],au,w([Ci(Si(Wi),lu(dc,mc)),Ci(Si(qi),du(dc,mc)),Ci(Si(Xi),sc(gc)),Ci(Si(Yi),fc(pc)),Ci(Oi([ki,Si(Li)]),Su),Ci(Oi([Ki,Si(Li)]),Su),Ci(Si(Gi),function(n,e,t){return t.onEscape(n,e)}),Ci(Si(Ui.concat($i)),function(e,t,o,n){return(r=o).focusManager.get(e).bind(function(n){return vi(n,r.selector)}).bind(function(n){return o.execute(e,t,n)});var r})]),w([Ci(Si(Ui),ou)]),function(){return mn.some(xu)}),vc=[Lt("selector"),Yt("getInitial",mn.none),Yt("execute",tu),Tr("onEscape"),Yt("executeOnMove",!1),Yt("allowVertical",!0)],bc=w([Ci(Si(Ui),ou)]),yc=Zi(vc,er.init,function(n,e,t,o){var r=Wi.concat(t.allowVertical?Xi:[]),i=qi.concat(t.allowVertical?Yi:[]);return[Ci(Si(r),Du(lu(Cu,Eu))),Ci(Si(i),Du(du(Cu,Eu))),Ci(Si($i),ku),Ci(Si(Ui),ku),Ci(Si(Gi),Mu)]},bc,function(){return mn.some(Tu)}),xc=[Gt("selectors",[Lt("row"),Lt("cell")]),Yt("cycles",!0),Yt("previousSelector",mn.none),Yt("execute",tu)],wc=Au(function(n,e,t){return Ru(n,e,t,-1)},function(n,e,t){return Iu(n,e,t,-1)}),Sc=Au(function(n,e,t){return Ru(n,e,t,1)},function(n,e,t){return Iu(n,e,t,1)}),Oc=Au(function(n,e,t){return Fu(n,t,e,-1)},function(n,e,t){return Vu(n,t,e,-1)}),kc=Au(function(n,e,t){return Fu(n,t,e,1)},function(n,e,t){return Vu(n,t,e,1)}),Tc=w([Ci(Si(Wi),lu(wc,Sc)),Ci(Si(qi),du(wc,Sc)),Ci(Si(Xi),sc(Oc)),Ci(Si(Yi),fc(kc)),Ci(Si(Ui.concat($i)),function(e,t,o){return jo(e.element).bind(function(n){return o.execute(e,t,n)})})]),Cc=w([Ci(Si(Ui),ou)]),Ec=Zi(xc,er.init,Tc,Cc,function(){return mn.some(Bu)}),Dc=[Lt("selector"),Yt("execute",tu),Yt("moveOnTab",!1)],Mc=w([Ci(Si(Xi),lc(Pu)),Ci(Si(Yi),lc(zu)),Ci(Oi([ki,Si(Li)]),function(n,e,t,o){return t.moveOnTab?lc(Pu)(n,e,t,o):mn.none()}),Ci(Oi([Ki,Si(Li)]),function(n,e,t,o){return t.moveOnTab?lc(zu)(n,e,t,o):mn.none()}),Ci(Si($i),Nu),Ci(Si(Ui),Nu)]),_c=w([Ci(Si(Ui),ou)]),Rc=Zi(Dc,er.init,Mc,_c,function(){return mn.some(Hu)}),Fc=Zi([Tr("onSpace"),Tr("onEnter"),Tr("onShiftEnter"),Tr("onLeft"),Tr("onRight"),Tr("onTab"),Tr("onShiftTab"),Tr("onUp"),Tr("onDown"),Tr("onEscape"),Yt("stopSpaceKeyup",!1),Ut("focusIn")],er.init,function(n,e,t){return[Ci(Si(Ui),t.onSpace),Ci(Oi([Ki,Si($i)]),t.onEnter),Ci(Oi([ki,Si($i)]),t.onShiftEnter),Ci(Oi([ki,Si(Li)]),t.onShiftTab),Ci(Oi([Ki,Si(Li)]),t.onTab),Ci(Si(Xi),t.onUp),Ci(Si(Yi),t.onDown),Ci(Si(Wi),t.onLeft),Ci(Si(qi),t.onRight),Ci(Si(Ui),t.onSpace),Ci(Si(Gi),t.onEscape)]},function(n,e,t){return t.stopSpaceKeyup?[Ci(Si(Ui),ou)]:[]},function(n){return n.focusIn}),Ic=oc.schema(),Vc=rc.schema(),Bc=yc.schema(),Ac=hc.schema(),Nc=Ec.schema(),Hc=ic.schema(),Pc=Rc.schema(),zc=Fc.schema(),jc=(qu=jt((tc=zt("Creating behaviour: "+(Xu={branchKey:"mode",branches:Object.freeze({__proto__:null,acyclic:Ic,cyclic:Vc,flow:Bc,flatgrid:Ac,matrix:Nc,execution:Hc,menu:Pc,special:zc}),name:"keying",active:{events:function(n,e){return n.handler.toEvents(n,e)}},apis:{focusIn:function(e,t,o){t.sendFocusIn(t).fold(function(){e.getSystem().triggerFocus(e.element,e.element)},function(n){n(e,t,o)})},setGridSize:function(n,e,t,o,r){Re(t,"setGridSize")?t.setGridSize(o,r):console.error("Layout does not support setGridSize")}},state:uc}).name,ir,Xu)).branchKey,tc.branches),Yu=tc.name,Ku=tc.active,Ju=tc.apis,Qu=tc.extra,Zu=tc.state,ec=Xt(Yu,[Wt("config",nc=qu)]),nr(nc,ec,Yu,Ku,Ju,Qu,Zu)),Lc=ju,$c=Lu,Gc="placeholder",Uc=Jt([{single:["required","valueThunk"]},{multiple:["required","valueThunks"]}]),Wc=function(r,i,u,c){return n=r,t=c,($u(e=u)&&e.uiType===Gc?(a=e,s=t,(o=n).exists(function(n){return n!==a.owner})?Uc.single(!0,w(a)):_e(s,a.name).fold(function(){throw new Error("Unknown placeholder component: "+a.name+"\nKnown: ["+st(s)+"]\nNamespace: "+o.getOr("none")+"\nSpec: "+JSON.stringify(a,null,2))},function(n){return n.replace()})):Uc.single(!1,w(e))).fold(function(n,e){var t=$u(u)?e(i,u.config,u.validated):e(i),o=B(_e(t,"components").getOr([]),function(n){return Wc(r,i,n,c)});return[y(y({},t),{components:o})]},function(n,e){if($u(u)){var t=e(i,u.config,u.validated);return u.validated.preprocess.getOr(K)(t)}return e(i)});var n,e,t,o,a,s},Xc=Uc.single,qc=Uc.multiple,Yc=w(Gc),Kc=0,Jc=Jt([{required:["data"]},{external:["data"]},{optional:["data"]},{group:["data"]}]),Qc=Yt("factory",{sketch:K}),Zc=Yt("schema",[]),na=Lt("name"),ea=ho("pname","pname",kt(function(n){return"<alloy."+Gu(n.name)+">"}),mo()),ta=vo("schema",function(){return[Ut("preprocess")]}),oa=Yt("defaults",w({})),ra=Yt("overrides",w({})),ia=lo([Qc,Zc,na,ea,oa,ra]),ua=lo([Qc,Zc,na,oa,ra]),ca=lo([Qc,Zc,na,ea,oa,ra]),aa=lo([Qc,ta,na,Lt("unit"),ea,oa,ra]),sa=Wu(Jc.required,ia);function fa(n,e,t,o){return co(e.defaults(n,t,o),t,{uid:n.partUids[e.name]},e.overrides(n,t,o))}function la(n,e,t){return o=e,r={},i={},M(t,function(n){n.fold(function(o){r[o.pname]=Xc(!0,function(n,e,t){return o.factory.sketch(fa(n,o,e,t))})},function(n){var e=o.parts[n.name];i[n.name]=w(n.factory.sketch(fa(o,n,e[zs()]),e))},function(o){r[o.pname]=Xc(!1,function(n,e,t){return o.factory.sketch(fa(n,o,e,t))})},function(o){r[o.pname]=qc(!0,function(e,n,t){return Z(e[o.name],function(n){return o.factory.sketch(co(o.defaults(e,n,t),n,o.overrides(e,n)))})})})}),{internals:w(r),externals:w(i)};var o,r,i}function da(n,e,t){return o=mn.some(n),i=(r=e).components,s=De(t,function(n,e){return o=n,r=!1,{name:w(t=e),required:function(){return o.fold(function(n,e){return n},function(n,e){return n})},used:function(){return r},replace:function(){if(r)throw new Error("Trying to use the same placeholder more than once: "+t);return r=!0,o}};var t,o,r}),u=o,c=r,a=s,f=B(i,function(n){return Wc(u,c,n,a)}),Ee(s,function(n){if(!1===n.used()&&n.required())throw new Error("Placeholder: "+n.name()+" was not found in components list\nNamespace: "+o.getOr("none")+"\nComponents: "+JSON.stringify(r.components,null,2))}),f;var o,r,i,u,c,a,s,f}function ma(n,e,t){var o=e.partUids[t];return n.getSystem().getByUid(o).toOptional()}function ga(n,e,t){return ma(n,e,t).getOrDie("Could not find part: "+t)}function pa(o){return ho("partUids","partUids",Et(function(n){return e=n.uid,t=Z(o,Uu),xo(Z(t,function(n){return{key:n,value:e+"-"+n}}));var e,t}),mo())}function ha(n){return yo(Ls,n)}function va(o){return n=function(n){for(var e=[],t=1;t<arguments.length;t++)e[t-1]=arguments[t];return o.apply(void 0,u([n.getApis(),n],e,!1))},t=(e=o.toString()).indexOf(")")+1,r=e.indexOf("("),i=e.substring(r+1,t-1).split(/,\s*/),n.toFunctionAnnotation=function(){return{name:"OVERRIDE",parameters:Zo(i.slice(1))}},n;var n,e,t,r,i}function ba(n){var e=Xe(n)?n.dom[Ws]:null;return mn.from(e)}function ya(n,e,t,o,r){var i;return zt(n+" [SpecSchema]",It((i=r,(0<o.length?[Gt("parts",o)]:[]).concat([Lt("uid"),Yt("dom",{}),Yt("components",[]),Mr("originalSpec"),Yt("debug.sketcher",{})]).concat(i)).concat(e)),t)}function xa(n,e,t,o,r){var i=Ys(r),u=ya(n,e,i,B(t,function(n){return n.fold(mn.none,mn.some,mn.none,mn.none).map(function(n){return Gt(n.name,n.schema.concat([Mr(zs())]))}).toArray()}),[pa(t)]),c=la(0,u,t);return o(u,da(n,u,c.internals()),i,c.externals())}function wa(n){var r=zt("Sketcher for "+n.name,Ks,n),e=De(r.apis,va),t=De(r.extraApis,Fo);return y(y({name:r.name,configFields:r.configFields,sketch:function(n){return e=r.name,t=r.configFields,(0,r.factory)(ya(e,t,o=Ys(n),[],[]),o);var e,t,o}},e),t)}function Sa(n){var r,e,i,t=zt("Sketcher for "+n.name,Js,n),o=(r=t.name,e=t.partFields,i={},M(e,function(n){n.fold(mn.some,mn.none,mn.some,mn.some).each(function(t){var o=js(r,t.pname);i[t.name]=function(n){var e=zt("Part: "+t.name+" in "+r,lo(t.schema),n);return y(y({},o),{config:n,validated:e})}})}),i),u=De(t.apis,va),c=De(t.extraApis,Fo);return y(y({name:t.name,partFields:t.partFields,configFields:t.configFields,sketch:function(n){return xa(t.name,t.configFields,t.partFields,t.factory,n)},parts:o},u),c)}function Oa(n){var r,e,t,o,i,u,c=(r={prefix:ui},n.replace(/\$\{([^{}]*)\}/g,function(n,e){var t,o=r[e];return"string"==(t=typeof o)||"number"==t?o.toString():n}));return e=fe.fromHtml(c),t=Je(e),o=R(void 0!==e.dom.attributes?e.dom.attributes:[],function(n,e){var t;return"class"===e.name?n:y(y({},n),((t={})[e.name]=e.value,t))},{}),i=Array.prototype.slice.call(e.dom.classList,0),u=0===t.length?{}:{innerHtml:Lo(e)},y({tag:le(e),classes:i,attributes:o},u)}function ka(n){return{dom:Oa(n)}}function Ta(n){return or([ii.config({toggleClass:ci("toolbar-button-selected"),toggleOnExecute:!1,aria:{mode:"pressed"}}),Ar(n,function(n,e){(e?ii.on:ii.off)(n)})])}function Ca(n,e,t,o){var r=Ta(t);return nf(e,o,r,n)}function Ea(n,e){var t=e.ui.registry.getAll().icons;return mn.from(t[n]).fold(function(){return Oa('<span class="${prefix}-toolbar-button ${prefix}-toolbar-group-item ${prefix}-icon-'+n+' ${prefix}-icon"></span>')},function(n){return Oa('<span class="${prefix}-toolbar-button ${prefix}-toolbar-group-item">'+n+"</span>")})}function Da(e){return Hs({name:e+"-edge",overrides:function(n){return n.model.manager.edgeActions[e].fold(function(){return{}},function(o){return{events:qo([Do(Vn(),function(n,e,t){return o(n,t)},[n]),Do(Nn(),function(n,e,t){return o(n,t)},[n]),Do(Hn(),function(n,e,t){t.mouseIsDown.get()&&o(n,t)},[n])])}})}})}function Ma(n,e,t){e.store.manager.onLoad(n,e,t)}function _a(n,e,t){e.store.manager.onUnload(n,e,t)}function Ra(){var n=No(null);return tr({set:n.set,get:n.get,isNotSet:function(){return null===n.get()},clear:function(){n.set(null)},readState:function(){return{mode:"memory",value:n.get()}}})}function Fa(){var i=No({}),u=No({});return tr({readState:function(){return{mode:"dataset",dataByValue:i.get(),dataByText:u.get()}},lookup:function(n){return _e(i.get(),n).orThunk(function(){return _e(u.get(),n)})},update:function(n){var e=i.get(),t=u.get(),o={},r={};M(n,function(e){_e(o[e.value]=e,"meta").each(function(n){_e(n,"text").each(function(n){r[n]=e})})}),i.set(y(y({},e),o)),u.set(y(y({},t),r))},clear:function(){i.set({}),u.set({})}})}function Ia(n,e,t,o){var r=e.store;t.update([o]),r.setValue(n,o),e.onSetValue(n,o)}function Va(n,e){return vf.set(n,e)}function Ba(n){return vf.get(n)}function Aa(n){var e=n.event.raw;return-1===e.type.indexOf("touch")?void 0!==e.clientX?mn.some(e).map(function(n){return yf(n.clientX,n.clientY)}):mn.none():void 0!==e.touches&&1===e.touches.length?mn.some(e.touches[0]).map(function(n){return yf(n.clientX,n.clientY)}):mn.none()}function Na(n){return n.model.minX}function Ha(n){return n.model.minY}function Pa(n){return n.model.minX-1}function za(n){return n.model.minY-1}function ja(n){return n.model.maxX}function La(n){return n.model.maxY}function $a(n){return n.model.maxX+1}function Ga(n){return n.model.maxY+1}function Ua(n,e,t){return e(n)-t(n)}function Wa(n){return Ua(n,ja,Na)}function Xa(n){return Ua(n,La,Ha)}function qa(n){return Wa(n)/2}function Ya(n){return Xa(n)/2}function Ka(n){return n.stepSize}function Ja(n){return n.snapToGrid}function Qa(n){return n.snapStart}function Za(n){return n.rounded}function ns(n,e){return void 0!==n[e+"-edge"]}function es(n){return ns(n,"left")}function ts(n){return ns(n,"right")}function os(n){return ns(n,"top")}function rs(n){return ns(n,"bottom")}function is(n){return n.model.value.get()}function us(n,e){return{x:n,y:e}}function cs(n,e){X(n,xf(),{value:e})}function as(n,e,t,o){return n<e?n:t<n?t:n===e?e-1:Math.max(e,n-o)}function ss(n,e,t,o){return t<n?n:n<e?e:n===t?t+1:Math.min(t,n+o)}function fs(n,e,t){return Math.max(e,Math.min(t,n))}function ls(n){var e=n.min,t=n.max,o=n.range,r=n.value,i=n.step,u=n.snap,c=n.snapStart,a=n.rounded,s=n.hasMinEdge,f=n.hasMaxEdge,l=n.minBound,d=n.maxBound,m=n.screenRange,g=s?e-1:e,p=f?t+1:t;if(r<l)return g;if(d<r)return p;var h,v,b,y,x,w=fs((x=l,Math.min(d,Math.max(r,x))-x)/m*o+e,g,p);return u&&e<=w&&w<=t?(h=w,v=e,b=t,y=i,c.fold(function(){var n=Math.round((h-v)/y)*y;return fs(v+n,v-1,b+1)},function(n){var e=Math.round((h-n)%y/y),t=Math.floor((h-n)/y),o=Math.floor((b-n)/y),r=Math.min(o,t+e);return Math.max(n,n+r*y)})):a?Math.round(w):w}function ds(n){var e=n.min,t=n.max,o=n.range,r=n.value,i=n.hasMinEdge,u=n.hasMaxEdge,c=n.maxBound,a=n.maxOffset,s=n.centerMinEdge,f=n.centerMaxEdge;return r<e?i?0:s:t<r?u?c:f:(r-e)/o*a}function ms(n){return n.element.dom.getBoundingClientRect()}function gs(n){return ms(n)[wf]}function ps(n){return ms(n).right}function hs(n){return ms(n).top}function vs(n){return ms(n).bottom}function bs(n){return ms(n).width}function ys(n){return ms(n).height}function xs(n,e){var t=ms(n),o=ms(e);return(t[wf]+t.right)/2-o[wf]}function ws(n,e){var t=ms(n),o=ms(e);return(t.top+t.bottom)/2-o.top}function Ss(n,e){X(n,xf(),{value:e})}function Os(n,e,t){return ls({min:Na(e),max:ja(e),range:Wa(e),value:t,step:Ka(e),snap:Ja(e),snapStart:Qa(e),rounded:Za(e),hasMinEdge:es(e),hasMaxEdge:ts(e),minBound:gs(n),maxBound:ps(n),screenRange:bs(n)})}function ks(r){return function(n,e){return Ss(n,{x:o=(0<r?ss:as)(is(t=e).x,Na(t),ja(t),Ka(t))}),mn.some(o).map(x);var t,o}}function Ts(n,e,t,o,r,i){var u,c,a,s,f,l,d,m,g=(c=i,a=t,s=o,f=r,l=bs(u=e),d=s.bind(function(n){return mn.some(xs(n,u))}).getOr(0),m=f.bind(function(n){return mn.some(xs(n,u))}).getOr(l),ds({min:Na(c),max:ja(c),range:Wa(c),value:a,hasMinEdge:es(c),hasMaxEdge:ts(c),minBound:gs(u),minOffset:0,maxBound:ps(u),maxOffset:l,centerMinEdge:d,centerMaxEdge:m}));return gs(e)-gs(n)+g}function Cs(n,e){X(n,xf(),{value:e})}function Es(n,e,t){return ls({min:Ha(e),max:La(e),range:Xa(e),value:t,step:Ka(e),snap:Ja(e),snapStart:Qa(e),rounded:Za(e),hasMinEdge:os(e),hasMaxEdge:rs(e),minBound:hs(n),maxBound:vs(n),screenRange:ys(n)})}function Ds(r){return function(n,e){return Cs(n,{y:o=(0<r?ss:as)(is(t=e).y,Ha(t),La(t),Ka(t))}),mn.some(o).map(x);var t,o}}function Ms(n,e,t,o,r,i){var u,c,a,s,f,l,d,m,g=(c=i,a=t,s=o,f=r,l=ys(u=e),d=s.bind(function(n){return mn.some(ws(n,u))}).getOr(0),m=f.bind(function(n){return mn.some(ws(n,u))}).getOr(l),ds({min:Ha(c),max:La(c),range:Xa(c),value:a,hasMinEdge:os(c),hasMaxEdge:rs(c),minBound:hs(u),minOffset:0,maxBound:vs(u),maxOffset:l,centerMinEdge:d,centerMaxEdge:m}));return hs(e)-hs(n)+g}function _s(n,e){X(n,xf(),{value:e})}function Rs(n,e){return{x:n,y:e}}function Fs(u,c){return function(n,e){return o=e,r=0<u?ss:as,_s(n,Rs(i=(t=c)?is(o).x:r(is(o).x,Na(o),ja(o),Ka(o)),t?r(is(o).y,Ha(o),La(o),Ka(o)):is(o).y)),mn.some(i).map(x);var t,o,r,i}}function Is(e,t,o,n){return nf(t,function(){var n=o();e.setContextToolbar([{label:t+" group",items:n}])},{},n)}function Vs(n,o){var e={onChange:function(n,e,t){o.undoManager.transact(function(){o.formatter.apply("forecolor",{value:t}),o.nodeChanged()})},getInitialValue:w(-1)};return Is(n,"color-levels",function(){return[(r=e,$f.sketch({dom:Oa('<div class="${prefix}-slider ${prefix}-hue-slider-container"></div>'),components:[$f.parts["left-edge"](ka('<div class="${prefix}-hue-slider-black"></div>')),$f.parts.spectrum({dom:Oa('<div class="${prefix}-slider-gradient-container"></div>'),components:[ka('<div class="${prefix}-slider-gradient"></div>')],behaviours:or([ii.config({toggleClass:ci("thumb-active")})])}),$f.parts["right-edge"](ka('<div class="${prefix}-hue-slider-white"></div>')),$f.parts.thumb({dom:Oa('<div class="${prefix}-slider-thumb"></div>'),behaviours:or([ii.config({toggleClass:ci("thumb-active")})])})],onChange:function(n,e,t){var o=i(t.x());$r(e.element,"background-color",o),r.onChange(n,e,o)},onDragStart:function(n,e){ii.on(e)},onDragEnd:function(n,e){ii.off(e)},onInit:function(n,e,t,o){var r=i(o.x());$r(e.element,"background-color",r)},stepSize:10,model:{mode:"x",minX:0,maxX:360,getInitialValue:function(){return{x:r.getInitialValue()}}},sliderBehaviours:or([Nr($f.refresh)])}))];function i(n){return n<0?"black":360<n?"white":"hsl("+n+", 100%, 50%)"}var r},o)}function Bs(n){var e,t,o=n.selection.getStart(),r=fe.fromDom(o),i=fe.fromDom(n.getBody()),u=(e=function(n){return un(i,n)},(Xe(t=r)?mn.some(t):pe(t).filter(Xe)).map(function(n){return mi(function(n,e){return e(n)},gi,n,function(n){return Wr(n,"font-size").isSome()},e).bind(function(n){return Wr(n,"font-size")}).getOrThunk(function(){return Ur(n,"font-size")})}).getOr(""));return F(Gf,function(n){return u===n}).getOr("medium")}function As(n){return[ka('<span class="${prefix}-toolbar-button ${prefix}-icon-small-font ${prefix}-icon"></span>'),(e={onChange:n.onChange,sizes:Xf,category:"font",getInitialValue:n.getInitialValue},r=zt("SizeSlider",Wf,e),$f.sketch({dom:{tag:"div",classes:[ci("slider-"+r.category+"-size-container"),ci("slider"),ci("slider-size-container")]},onChange:function(n,e,t){var o=t.x();0<=o&&o<r.sizes.length&&r.onChange(o)},onDragStart:function(n,e){ii.on(e)},onDragEnd:function(n,e){ii.off(e)},model:{mode:"x",minX:0,maxX:r.sizes.length-1,getInitialValue:function(){return{x:r.getInitialValue()}}},stepSize:1,snapToGrid:!0,sliderBehaviours:or([Nr($f.refresh)]),components:[$f.parts.spectrum({dom:Oa('<div class="${prefix}-slider-size-container"></div>'),components:[ka('<div class="${prefix}-slider-size-line"></div>')]}),$f.parts.thumb({dom:Oa('<div class="${prefix}-slider-thumb"></div>'),behaviours:or([ii.config({toggleClass:ci("thumb-active")})])})]})),ka('<span class="${prefix}-toolbar-button ${prefix}-icon-large-font ${prefix}-icon"></span>')];var e,r}function Ns(n){var e=void 0!==n.uid&&Re(n,"uid")?n.uid:qs("memento");return{get:function(n){return n.getSystem().getByUid(e).getOrDie()},getOpt:function(n){return n.getSystem().getByUid(e).toOptional()},asSpec:function(){return y(y({},n),{uid:e})}}}Wu(Jc.external,ua);var Hs=Wu(Jc.optional,ca),Ps=Wu(Jc.group,aa),zs=w("entirety"),js=function(n,e){return{uiType:Yc(),owner:n,name:e}},Ls=Gu("alloy-premade"),$s=w("alloy-id-"),Gs=w("data-alloy-id"),Us=$s(),Ws=Gs(),Xs=function(n,e){Object.defineProperty(n.dom,Ws,{value:e,writable:!0})},qs=Gu,Ys=function(n){return dt(n,"uid")?n:y(y({},n),{uid:qs("uid")})},Ks=It([Lt("name"),Lt("factory"),Lt("configFields"),Yt("apis",{}),Yt("extraApis",{})]),Js=It([Lt("name"),Lt("factory"),Lt("configFields"),Lt("partFields"),Yt("apis",{}),Yt("extraApis",{})]),Qs=wa({name:"Button",factory:function(n){function t(e){return _e(n.dom,"attributes").bind(function(n){return _e(n,e)})}var e,o=(e=n.action,qo(V([e.map(function(t){return Qo(function(n,e){t(n),e.stop()})}).toArray(),Pr()]))),r=n.dom.tag;return{uid:n.uid,dom:n.dom,components:n.components,events:o,behaviours:$c(n.buttonBehaviours,[fi.config({}),jc.config({mode:"execution",useSpace:!0,useEnter:!0})]),domModification:{attributes:function(){if("button"!==r)return{role:t("role").getOr("button")};var n=t("type").getOr("button"),e=t("role").map(function(n){return{role:n}}).getOr({});return y({type:n},e)}()},eventOrder:n.eventOrder}},configFields:[Yt("uid",void 0),Lt("dom"),Yt("components",[]),Lc("buttonBehaviours",[fi,jc]),Ut("action"),Ut("role"),Yt("eventOrder",{})]}),Zs=Ao({fields:[],name:"unselecting",active:Object.freeze({__proto__:null,events:function(){return qo([Co(Xn(),x)])},exhibit:function(){return Io({styles:{"-webkit-user-select":"none","user-select":"none","-ms-user-select":"none","-moz-user-select":"-moz-none"},attributes:{unselectable:"on"}})}})}),nf=function(n,e,t,o){return Qs.sketch({dom:Ea(n,o),action:e,buttonBehaviours:co(or([Zs.config({})]),t)})},ef=Hs({schema:[Lt("dom")],name:"label"}),tf=Da("top-left"),of=Da("top"),rf=Da("top-right"),uf=Da("right"),cf=Da("bottom-right"),af=Da("bottom"),sf=Da("bottom-left"),ff=[ef,Da("left"),uf,of,af,tf,rf,sf,cf,sa({name:"thumb",defaults:w({dom:{styles:{position:"absolute"}}}),overrides:function(n){return{events:qo([_o(Vn(),n,"spectrum"),_o(Bn(),n,"spectrum"),_o(An(),n,"spectrum"),_o(Nn(),n,"spectrum"),_o(Hn(),n,"spectrum"),_o(Pn(),n,"spectrum")])}}}),sa({schema:[vo("mouseIsDown",function(){return No(!1)})],name:"spectrum",overrides:function(t){function o(e,n){return r.getValueFromEvent(n).map(function(n){return r.setValueFrom(e,t,n)})}var r=t.model.manager;return{behaviours:or([jc.config({mode:"special",onLeft:function(n){return r.onLeft(n,t)},onRight:function(n){return r.onRight(n,t)},onUp:function(n){return r.onUp(n,t)},onDown:function(n){return r.onDown(n,t)}}),fi.config({})]),events:qo([Eo(Vn(),o),Eo(Bn(),o),Eo(Nn(),o),Eo(Hn(),function(n,e){t.mouseIsDown.get()&&o(n,e)})])}}})],lf=Object.freeze({__proto__:null,onLoad:Ma,onUnload:_a,setValue:function(n,e,t,o){e.store.manager.setValue(n,e,t,o)},getValue:function(n,e,t){return e.store.manager.getValue(n,e,t)},getState:function(n,e,t){return t}}),df=Object.freeze({__proto__:null,events:function(t,o){var n=t.resetOnDom?[Yo(function(n,e){Ma(n,t,o)}),Ko(function(n,e){_a(n,t,o)})]:[Vo(t,o,Ma)];return qo(n)}}),mf=Object.freeze({__proto__:null,memory:Ra,dataset:Fa,manual:function(){return tr({readState:Y})},init:function(n){return n.store.manager.state(n)}}),gf=[Ut("initialValue"),Lt("getFallbackEntry"),Lt("getDataKey"),Lt("setValue"),Dr("manager",{setValue:Ia,getValue:function(n,e,t){var o=e.store,r=o.getDataKey(n);return t.lookup(r).getOrThunk(function(){return o.getFallbackEntry(r)})},onLoad:function(e,t,o){t.store.initialValue.each(function(n){Ia(e,t,o,n)})},onUnload:function(n,e,t){t.clear()},state:Fa})],pf=[Lt("getValue"),Yt("setValue",Y),Ut("initialValue"),Dr("manager",{setValue:function(n,e,t,o){e.store.setValue(n,o),e.onSetValue(n,o)},getValue:function(n,e,t){return e.store.getValue(n)},onLoad:function(e,t,n){t.store.initialValue.each(function(n){t.store.setValue(e,n)})},onUnload:Y,state:er.init})],hf=Ao({fields:[Kt("store",{mode:"memory"},jt("mode",{memory:[Ut("initialValue"),Dr("manager",{setValue:function(n,e,t,o){t.set(o),e.onSetValue(n,o)},getValue:function(n,e,t){return t.get()},onLoad:function(n,e,t){e.store.initialValue.each(function(n){t.isNotSet()&&t.set(n)})},onUnload:function(n,e,t){t.clear()},state:Ra})],manual:pf,dataset:gf})),kr("onSetValue"),Yt("resetOnDom",!1)],name:"representing",active:df,apis:lf,extra:{setValueFrom:function(n,e){var t=hf.getValue(e);hf.setValue(n,t)}},state:mf}),vf=Yr("width",function(n){return n.dom.offsetWidth}),bf=function(t,o){return{left:t,top:o,translate:function(n,e){return bf(t+n,o+e)}}},yf=bf,xf=w("slider.change.value"),wf="left",Sf=ks(-1),Of=ks(1),kf=mn.none,Tf=mn.none,Cf={"top-left":mn.none(),top:mn.none(),"top-right":mn.none(),right:mn.some(function(n,e){cs(n,{x:$a(e)})}),"bottom-right":mn.none(),bottom:mn.none(),"bottom-left":mn.none(),left:mn.some(function(n,e){cs(n,{x:Pa(e)})})},Ef=Object.freeze({__proto__:null,setValueFrom:function(n,e,t){var o=Os(n,e,t);return Ss(n,{x:o}),o},setToMin:function(n,e){Ss(n,{x:Na(e)})},setToMax:function(n,e){Ss(n,{x:ja(e)})},findValueOfOffset:Os,getValueFromEvent:function(n){return Aa(n).map(function(n){return n.left})},findPositionOfValue:Ts,setPositionFromValue:function(n,e,t,o){var r=is(t),i=Ts(n,o.getSpectrum(n),r.x,o.getLeftEdge(n),o.getRightEdge(n),t),u=Ba(e.element)/2;$r(e.element,"left",i-u+"px")},onLeft:Sf,onRight:Of,onUp:kf,onDown:Tf,edgeActions:Cf}),Df=mn.none,Mf=mn.none,_f=Ds(-1),Rf=Ds(1),Ff={"top-left":mn.none(),top:mn.some(function(n,e){cs(n,{y:za(e)})}),"top-right":mn.none(),right:mn.none(),"bottom-right":mn.none(),bottom:mn.some(function(n,e){cs(n,{y:Ga(e)})}),"bottom-left":mn.none(),left:mn.none()},If=Object.freeze({__proto__:null,setValueFrom:function(n,e,t){var o=Es(n,e,t);return Cs(n,{y:o}),o},setToMin:function(n,e){Cs(n,{y:Ha(e)})},setToMax:function(n,e){Cs(n,{y:La(e)})},findValueOfOffset:Es,getValueFromEvent:function(n){return Aa(n).map(function(n){return n.top})},findPositionOfValue:Ms,setPositionFromValue:function(n,e,t,o){var r=is(t),i=Ms(n,o.getSpectrum(n),r.y,o.getTopEdge(n),o.getBottomEdge(n),t),u=Kr(e.element)/2;$r(e.element,"top",i-u+"px")},onLeft:Df,onRight:Mf,onUp:_f,onDown:Rf,edgeActions:Ff}),Vf=Aa,Bf=Fs(-1,!1),Af=Fs(1,!1),Nf=Fs(-1,!0),Hf=Fs(1,!0),Pf={"top-left":mn.some(function(n,e){cs(n,us(Pa(e),za(e)))}),top:mn.some(function(n,e){cs(n,us(qa(e),za(e)))}),"top-right":mn.some(function(n,e){cs(n,us($a(e),za(e)))}),right:mn.some(function(n,e){cs(n,us($a(e),Ya(e)))}),"bottom-right":mn.some(function(n,e){cs(n,us($a(e),Ga(e)))}),bottom:mn.some(function(n,e){cs(n,us(qa(e),Ga(e)))}),"bottom-left":mn.some(function(n,e){cs(n,us(Pa(e),Ga(e)))}),left:mn.some(function(n,e){cs(n,us(Pa(e),Ya(e)))})},zf=Object.freeze({__proto__:null,setValueFrom:function(n,e,t){var o=Rs(Os(n,e,t.left),Es(n,e,t.top));return _s(n,o),o},setToMin:function(n,e){_s(n,Rs(Na(e),Ha(e)))},setToMax:function(n,e){_s(n,Rs(ja(e),La(e)))},getValueFromEvent:Vf,setPositionFromValue:function(n,e,t,o){var r=is(t),i=Ts(n,o.getSpectrum(n),r.x,o.getLeftEdge(n),o.getRightEdge(n),t),u=Ms(n,o.getSpectrum(n),r.y,o.getTopEdge(n),o.getBottomEdge(n),t),c=Ba(e.element)/2,a=Kr(e.element)/2;$r(e.element,"left",i-c+"px"),$r(e.element,"top",u-a+"px")},onLeft:Bf,onRight:Af,onUp:Nf,onDown:Hf,edgeActions:Pf}),jf=[Yt("stepSize",1),Yt("onChange",Y),Yt("onChoose",Y),Yt("onInit",Y),Yt("onDragStart",Y),Yt("onDragEnd",Y),Yt("snapToGrid",!1),Yt("rounded",!0),Ut("snapStart"),$t("model",jt("mode",{x:[Yt("minX",0),Yt("maxX",100),vo("value",function(n){return No(n.mode.minX)}),Lt("getInitialValue"),Dr("manager",Ef)],y:[Yt("minY",0),Yt("maxY",100),vo("value",function(n){return No(n.mode.minY)}),Lt("getInitialValue"),Dr("manager",If)],xy:[Yt("minX",0),Yt("maxX",100),Yt("minY",0),Yt("maxY",100),vo("value",function(n){return No({x:n.mode.minX,y:n.mode.minY})}),Lt("getInitialValue"),Dr("manager",zf)]})),ju("sliderBehaviours",[jc,hf]),vo("mouseIsDown",function(){return No(!1)})],Lf=w("mouse.released"),$f=Sa({name:"Slider",configFields:jf,partFields:ff,factory:function(i,n,e,t){function u(n){return ga(n,i,"thumb")}function c(n){return ga(n,i,"spectrum")}function o(n){return ma(n,i,"left-edge")}function r(n){return ma(n,i,"right-edge")}function a(n){return ma(n,i,"top-edge")}function s(n){return ma(n,i,"bottom-edge")}function f(n,e){v.setPositionFromValue(n,e,i,{getLeftEdge:o,getRightEdge:r,getTopEdge:a,getBottomEdge:s,getSpectrum:c})}function l(n,e){h.value.set(e),f(n,u(n))}function d(t){var n=i.mouseIsDown.get();i.mouseIsDown.set(!1),n&&ma(t,i,"thumb").each(function(n){var e=h.value.get();i.onChoose(t,n,e)})}function m(n,e){e.stop(),i.mouseIsDown.set(!0),i.onDragStart(n,u(n))}function g(n,e){e.stop(),i.onDragEnd(n,u(n)),d(n)}var p,h=i.model,v=h.manager;return{uid:i.uid,dom:i.dom,components:n,behaviours:Lu(i.sliderBehaviours,[jc.config({mode:"special",focusIn:function(n){return ma(n,i,"spectrum").map(jc.focusIn).map(x)}}),hf.config({store:{mode:"manual",getValue:function(n){return h.value.get()}}}),ti.config({channels:((p={})[Lf()]={onReceive:d},p)})]),events:qo([Eo(xf(),function(n,e){!function(n,e){l(n,e);var t=u(n);i.onChange(n,t,e),mn.some(!0)}(n,e.event.value)}),Yo(function(n,e){var t=h.getInitialValue();h.value.set(t);var o=u(n);f(n,o);var r=c(n);i.onInit(n,o,r,h.value.get())}),Eo(Vn(),m),Eo(An(),g),Eo(Nn(),m),Eo(Pn(),g)]),apis:{resetToMin:function(n){v.setToMin(n,i)},resetToMax:function(n){v.setToMax(n,i)},setValue:l,refresh:f},domModification:{styles:{position:"relative"}}}},apis:{setValue:function(n,e,t){n.setValue(e,t)},resetToMin:function(n,e){n.resetToMin(e)},resetToMax:function(n,e){n.resetToMax(e)},refresh:function(n,e){n.refresh(e)}}}),Gf=["9px","10px","11px","12px","14px","16px","18px","20px","24px","32px","36px"],Uf=w(Gf),Wf=It([Lt("getInitialValue"),Lt("onChange"),Lt("category"),Lt("sizes")]),Xf=Uf(),qf={},Yf={exports:qf};function Kf(u){var e=Ns({dom:{tag:"input",attributes:{accept:"image/*",type:"file",title:""},styles:{visibility:"hidden",position:"absolute"}},events:qo([Ro(Un()),Eo(Gn(),function(n,e){var t=e.event.raw,o=t.target.files||t.dataTransfer.files;mn.from(o[0]).each(function(n){var r,t,i=u;r=n,t=r,new Jl(function(n){var e=new FileReader;e.onloadend=function(){n(e.result)},e.readAsDataURL(t)}).then(function(n){return n.split(",")[1]}).then(function(o){i.undoManager.transact(function(){var n=i.editorUpload.blobCache,e=n.create(Gu("mceu"),r,o);n.add(e);var t=i.dom.createHTML("img",{src:e.blobUri()});i.insertContent(t)})})})})])});return Qs.sketch({dom:Ea("image",u),components:[e.asSpec()],action:function(n){e.get(n).element.dom.click()}})}function Jf(n){return n.dom.textContent}function Qf(n){return 0<n.length}function Zf(n){return null==n?"":n}function nl(t,u){u.url.toOptional().filter(Qf).fold(function(){var e=t;u.link.bind(K).each(function(n){e.execCommand("unlink")})},function(r){var n,e,i=(n=u,(e={}).href=r,n.title.toOptional().filter(Qf).each(function(n){e.title=n}),n.target.toOptional().filter(Qf).each(function(n){e.target=n}),e);u.link.bind(K).fold(function(){var n=u.text.toOptional().filter(Qf).getOr(r);t.insertContent(t.dom.createHTML("a",i,t.dom.encode(n)))},function(e){var t,o,n=(t=e,o=r,u.text.toOptional().filter(Qf).fold(function(){return Be(n=t,"href")===Jf(n)?mn.some(o):mn.none();var n},mn.some));Ve(e,i),n.each(function(n){e.dom.textContent=n})})})}function el(n,e){var t,o;return{key:n,value:{config:{},me:(t=n,o=qo(e),Ao({fields:[Lt("enabled")],name:t,active:{events:w(o)}})),configAsRaw:w({}),initialConfig:{},state:er}}}function tl(n){return n.dom.value}function ol(n,e){if(void 0===e)throw new Error("Value.set was undefined");n.dom.value=e}function rl(n,e){var t=Ns(rd.sketch({inputAttributes:{placeholder:cd.translate(e)},onSetValue:function(n,e){W(n,$n())},inputBehaviours:or([ed.config({find:mn.some}),ud.config({}),jc.config({mode:"execution"})]),selectOnFocus:!1})),o=Ns(Qs.sketch({dom:Oa('<button class="${prefix}-input-container-x ${prefix}-icon-cancel-circle ${prefix}-icon"></button>'),action:function(n){var e=t.get(n);hf.setValue(e,"")}}));return{name:n,spec:td.sketch({dom:Oa('<div class="${prefix}-input-container"></div>'),components:[t.asSpec(),o.asSpec()],containerBehaviours:or([ii.config({toggleClass:ci("input-container-empty")}),ed.config({find:function(n){return mn.some(t.get(n))}}),el("input-clearing",[Eo($n(),function(n){var e=t.get(n);(0<hf.getValue(e).length?ii.off:ii.on)(n)})])])})}}function il(n,e,t){(e.disabled()?sd:fd)(n,e)}function ul(n,e){return!0===e.useNative&&T(ad,le(n.element))}function cl(n,e){return ul(n,e)?Ne(n.element,"disabled"):"true"===Be(n.element,"aria-disabled")}function al(n){return"<alloy.field."+n+">"}function sl(o,r){return Ca(r,"link","link",function(){var n,e,t=hd(o,r);o.setContextToolbar(t),n=r,e=function(){o.focusToolbar()},(Zl.os.isAndroid()?function(n,e){var t=e.selection.getRng();n(),e.selection.setRng(t)}:p)(e,n),Ql(r).each(function(n){r.selection.select(n.dom)})})}function fl(e){function t(n){return"The component must be in a context to execute: "+n+(e?"\n"+$o(e().element)+" is not in context.":"")}function n(n){return function(){throw new Error(t(n))}}function o(n){return function(){console.warn(t(n))}}return{debugInfo:w("fake"),triggerEvent:o("triggerEvent"),triggerFocus:o("triggerFocus"),triggerEscape:o("triggerEscape"),broadcast:o("broadcast"),broadcastOn:o("broadcastOn"),broadcastEvent:o("broadcastEvent"),build:n("build"),addToWorld:n("addToWorld"),removeFromWorld:n("removeFromWorld"),addToGui:n("addToGui"),removeFromGui:n("removeFromGui"),getByUid:n("getByUid"),getByDom:n("getByDom"),isConnected:S}}function ll(n,r){var i={};return Ee(n,function(n,o){Ee(n,function(n,e){var t=_e(i,e).getOr([]);i[e]=t.concat([r(o,n)])})}),i}function dl(n){return n.cHandler}function ml(n,e){return{name:n,handler:e}}function gl(n,e,t){var o=e[t];return o?function(u,c,n,a){try{var e=(t=function(n,e){var t=n[c],o=e[c],r=a.indexOf(t),i=a.indexOf(o);if(-1===r)throw new Error("The ordering for "+u+" does not have an entry for "+t+".\nOrder specified: "+JSON.stringify(a,null,2));if(-1===i)throw new Error("The ordering for "+u+" does not have an entry for "+o+".\nOrder specified: "+JSON.stringify(a,null,2));return r<i?-1:i<r?1:0},(o=gn.call(n,0)).sort(t),o);return ht.value(e)}catch(n){return ht.error([n])}var t,o}("Event: "+t,"name",n,o).map(function(n){var t,e,o,r,i=Z(n,function(n){return n.handler});return{can:function(){for(var t=[],n=0;n<arguments.length;n++)t[n]=arguments[n];return R(e,function(n,e){return n&&e.can.apply(void 0,t)},!0)},abort:(o=e=t=i,r=function(n){return n.abort},function(){for(var t=[],n=0;n<arguments.length;n++)t[n]=arguments[n];return R(o,function(n,e){return n||r(e).apply(void 0,t)},!1)}),run:function(){for(var e=[],n=0;n<arguments.length;n++)e[n]=arguments[n];M(t,function(n){n.run.apply(void 0,e)})}}}):ht.error(["The event ("+t+') has more than one behaviour that listens to it.\nWhen this occurs, you must specify an event ordering for the behaviours in your spec (e.g. [ "listing", "toggling" ]).\nThe behaviours that can trigger it are: '+JSON.stringify(Z(n,function(n){return n.name}),null,2)])}function pl(e,n){M(n,function(n){je(e,n)})}function hl(e,n){M(n,function(n){Le(e,n)})}function vl(n){var t,e,o,r,i=(t=_e(n,"behaviours").getOr({}),B(st(t),function(n){var e=t[n];return l(e)?[e.me]:[]}));return e=n,r=Z(o=i,function(n){return Xt(n.name(),[Lt("config"),Yt("state",er)])}),{list:o,data:De(Ht("component.behaviours",lo(r),e.behaviours).fold(function(n){throw new Error(po(n)+"\nComplete spec:\n"+JSON.stringify(e,null,2))},K),function(n){return w(n.map(function(n){return{config:n.config,state:n.state.init(n.config)}}))})}}function bl(n,e,t){var o,r,i=y(y({},(o=n).dom),{uid:o.uid,domChildren:Z(o.components,function(n){return n.element})}),u=n.domModification.fold(function(){return Io({})},Io),c=0<e.length?function(e,n,t,o){var r=y({},n);function i(n){return _(n,function(n,e){return y(y({},e.modification),n)},{})}M(t,function(n){r[n.name()]=n.exhibit(e,o)});var u=ll(r,function(n,e){return{name:n,modification:e}});return Io({classes:_(u.classes,function(n,e){return e.modification.concat(n)},[]),attributes:i(u.attributes),styles:i(u.styles)})}(t,{"alloy.base.modification":u},e,i):u;return y(y({},r=i),{attributes:y(y({},r.attributes),c.attributes),styles:y(y({},r.styles),c.styles),classes:r.classes.concat(c.classes)})}function yl(n,e,t){var o,r,i,u,c,a={"alloy.base.behaviour":n.events},s=n.eventOrder;return r=t,i=e,o=ll(y(y({},a),(u=r,c={},M(i,function(n){c[n.name()]=n.handlers(u)}),c)),ml),wd(o,s).getOrDie()}function xl(t){function n(){return f}var e=No(xd),o=Pt(Ht("custom.definition",Od,t)),r=vl(t),i=r.list,u=r.data,c=function(n){var c=fe.fromTag(n.tag);Ve(c,n.attributes),pl(c,n.classes),Gr(c,n.styles),n.innerHtml.each(function(n){return t=n,i=me(e=c).dom,xe(u=fe.fromDom(i.createDocumentFragment()),(o=t,(r=(i||document).createElement("div")).innerHTML=o,Je(fe.fromDom(r)))),we(e),void Qe(e,u);var e,t,o,r,i,u});var e=n.domChildren;return xe(c,e),n.value.each(function(n){ol(c,n)}),n.uid,Xs(c,n.uid),c}(bl(o,i,u)),a=yl(o,i,u),s=No(o.components),f={uid:t.uid,getSystem:e.get,config:function(n){var e=u;return(m(e[n.name()])?e[n.name()]:function(){throw new Error("Could not find "+n.name()+" in "+JSON.stringify(t,null,2))})()},hasConfigured:function(n){return m(u[n.name()])},spec:t,readState:function(n){return u[n]().map(function(n){return n.state.readState()}).getOr("not enabled")},getApis:function(){return o.apis},connect:function(n){e.set(n)},disconnect:function(){e.set(fl(n))},element:c,syncComponents:function(){var n=B(Je(c),function(n){return e.get().getByDom(n).fold(function(){return[]},P)});s.set(n)},components:s.get,events:a};return f}function wl(n){return function(n){var e=zt("external.component",It([Lt("element"),Ut("uid")]),n),t=No(fl()),o=e.uid.getOrThunk(function(){return qs("external")});Xs(e.element,o);var r={uid:o,getSystem:t.get,config:mn.none,hasConfigured:S,connect:function(n){t.set(n)},disconnect:function(){t.set(fl(function(){return r}))},getApis:function(){return{}},element:e.element,spec:n,readState:w("No state"),syncComponents:Y,components:w([]),events:{}};return ha(r)}({element:fe.fromText(n)})}function Sl(n){(jo(n.element).isNone()||fi.isFocused(n))&&(fi.isFocused(n)||fi.focus(n),X(n,Ed,{item:n}))}function Ol(n){X(n,Dd,{item:n})}function kl(n,e,t,o){var r=n.getSystem().build(o);at(n,r,t)}function Tl(n,e,t,o){F(zd(n),function(n){return un(o.element,n.element)}).each(Ce)}function Cl(e,n,t,r,o){var i=zd(e);return mn.from(i[r]).map(function(n){return Tl(e,0,0,n),o.each(function(n){kl(e,0,function(n,e){var t,o=e;he(t=n,r).fold(function(){Qe(t,o)},function(n){ve(n,o)})},n)}),n})}function El(n,e,t,o){return _e(e.routes,o.start).bind(function(n){return _e(n,o.destination)})}function Dl(t,o,n){var e,r,i=n;qd(e=t,r=o).bind(function(n){return Xd(e,r,i,n)}).each(function(n){var e=n.transition;Le(t.element,e.transitionClass),He(t.element,o.destinationAttr)})}function Ml(n,e,t,o){Dl(n,e,t),Ne(n.element,e.stateAttr)&&Be(n.element,e.stateAttr)!==o&&e.onFinish(n,o),Ie(n.element,e.stateAttr,o)}function _l(n){je(n,Qd)}function Rl(n){Le(n,Qd)}function Fl(n){return _e(n,"format").getOr(n.title)}function Il(n){return Re(n,"items")?(r=co((e=n,t=["items"],o={},Ee(e,function(n,e){T(t,e)||(o[e]=n)}),o),{menu:!0}),i=tm(e.items),{item:r,menus:co(i.menus,yo(e.title,i.items)),expansions:co(i.expansions,yo(e.title,e.title))}):{item:n,menus:{},expansions:{}};var t,o,e,r,i}function Vl(t,n,o){var e,r,i,u,c,a,s,f,l,d,m,g=(e=t,i=(r=function(n){return B(n,function(n){return void 0===n.items?!Re(n,"format")||e.formatter.canApply(n.format)?[n]:[]:0<r(n.items).length?[n]:[]})})(n),tm(i));return c=(u={formats:g,handle:function(n,e){t.undoManager.transact(function(){ii.isOn(n)?t.formatter.remove(e):t.formatter.apply(e)}),o()}}).formats,a=function(){return m},s=em("Styles",[].concat(Z(c.items,function(n){return nm(Fl(n),n.title,n.isSelected(),n.getPreview(),Re(c.expansions,Fl(n)))})),a,!1),f=De(c.menus,function(n,e){var t=Z(n,function(n){return nm(Fl(n),n.title,void 0!==n.isSelected&&n.isSelected(),void 0!==n.getPreview?n.getPreview():"",Re(c.expansions,Fl(n)))});return em(e,t,a,!0)}),l=co(f,yo("styles",s)),d={tmenu:Wd.tieredData("styles",l,c.expansions)},(m=Ns(Wd.sketch({dom:{tag:"div",classes:[ci("styles-menu")]},components:[],fakeFocus:!0,stayInDom:!0,onExecute:function(n,e){var t=hf.getValue(e);return u.handle(e,t.value),mn.none()},onEscape:function(){return mn.none()},onOpenMenu:function(n,e){var t=Ba(n.element);Va(e.element,t),Jd.jumpTo(e,"current")},onOpenSubmenu:function(n,e,t){var o=Ba(n.element),r=pi(e.element,'[role="menu"]').getOrDie("hacky"),i=n.getSystem().getByDom(r).getOrDie();Va(t.element,o),Jd.progressTo(i,"before"),Jd.jumpTo(t,"after"),Jd.progressTo(t,"current")},onCollapseMenu:function(n,e,t){var o=pi(e.element,'[role="menu"]').getOrDie("hacky"),r=n.getSystem().getByDom(o).getOrDie();Jd.progressTo(r,"after"),Jd.progressTo(t,"current")},navigateOnHover:!1,highlightImmediately:!0,data:d.tmenu,markers:{backgroundMenu:ci("styles-background-menu"),menu:ci("styles-menu"),selectedMenu:ci("styles-selected-menu"),item:ci("styles-item"),selectedItem:ci("styles-selected-item")}}))).asSpec()}function Bl(n){var e=n.replace(/\|/g," ").trim();return 0<e.length?e.split(/\s+/):[]}function Al(e,r){function n(t){return function(){return nf(e=t,function(){n.execCommand(e)},{},n=r);var n,e}}function t(o){return function(){return n=r,t=Ta(e=o),nf(e,function(){n.execCommand(e)},t,n);var n,e,t}}function o(n,e,t){return function(){return Ca(r,n,e,t)}}function i(){return Vl(r,b,function(){r.fire("scrollIntoView")})}function u(n,e){return{isSupported:function(){var e=r.ui.registry.getAll().buttons;return n.forall(function(n){return Re(e,n)})},sketch:e}}var c,a,s=n("undo"),f=n("redo"),l=t("bold"),d=t("italic"),m=t("underline"),g=n("removeformat"),p=o("unlink","link",function(){r.execCommand("unlink",null,!1)}),h=o("unordered-list","ul",function(){r.execCommand("InsertUnorderedList",null,!1)}),v=o("ordered-list","ol",function(){r.execCommand("InsertOrderedList",null,!1)}),b=(a=function(n){return Z(n,function(n){if(Re(n,"items")){var e=a(n.items);return co(co(n,{isSelected:S,getPreview:w("")}),{items:e})}return Re(n,"format")?co(n,{isSelected:y(n.format),getPreview:x(n.format)}):(o=Gu((t=n).title),r=co(t,{format:o,isSelected:y(o),getPreview:x(o)}),c.formatter.register(o,r),r);var t,o,r})})((c=r).getParam("style_formats",fr,"array"));function y(n){return function(){return c.formatter.match(n)}}function x(n){return function(){return c.formatter.getCssText(n)}}return{undo:u(mn.none(),s),redo:u(mn.none(),f),bold:u(mn.none(),l),italic:u(mn.none(),d),underline:u(mn.none(),m),removeformat:u(mn.none(),g),link:u(mn.none(),function(){return sl(e,r)}),unlink:u(mn.none(),p),image:u(mn.none(),function(){return Kf(r)}),bullist:u(mn.some("bullist"),h),numlist:u(mn.some("numlist"),v),fontsizeselect:u(mn.none(),function(){return n={onChange:function(n){var o;o=t,mn.from(Gf[n]).each(function(n){var e,t=n;Bs(e=o)!==t&&e.execCommand("fontSize",!1,t)})},getInitialValue:function(){return e=Bs(t),I(Gf,function(n){return n===e}).getOr(2);var e}},Is(e,"font-size",function(){return As(n)},t=r);var t,n}),forecolor:u(mn.none(),function(){return Vs(e,r)}),styleselect:u(mn.none(),function(){return nf("style-formats",function(n){r.fire("toReading"),e.dropup.appear(i,ii.on,n)},or([ii.config({toggleClass:ci("toolbar-button-selected"),toggleOnExecute:!1,aria:{mode:"pressed"}}),ti.config({channels:xo([Hr(mr,ii.off),Hr(gr,ii.off)])})]),r)})}}function Nl(n){function e(){return n.stopPropagation()}function t(){return n.preventDefault()}var o=i(t,e);return{target:fe.fromDom(function(n){if(et()&&l(n.target)){var e=fe.fromDom(n.target);if(Xe(e)&&ot(e)&&n.composed&&n.composedPath){var t=n.composedPath();if(t)return 0<(o=t).length?mn.some(o[0]):mn.none()}}var o;return mn.from(n.target)}(n).getOr(n.target)),x:n.clientX,y:n.clientY,stop:e,prevent:t,kill:o,raw:n}}function Hl(n,e,t,o,r){var i,u,c=(i=t,u=o,function(n){i(n)&&u(Nl(n))});return n.dom.addEventListener(e,c,r),{unbind:J(rm,n,e,c,r)}}function Pl(n,e,t){return Hl(n,e,im,t,!1)}function zl(n,e,t){return Hl(n,e,im,t,!0)}function jl(n){return{isPortrait:w(n.matchMedia("(orientation: portrait)").matches)}}function Ll(o,e){var n=fe.fromDom(o),r=null,t=Pl(n,"orientationchange",function(){um.clearInterval(r);var n=jl(o);e.onChange(n),i(function(){e.onReady(n)})}),i=function(n){um.clearInterval(r);var e=o.innerHeight,t=0;r=um.setInterval(function(){e!==o.innerHeight?(um.clearInterval(r),n(mn.some(o.innerHeight))):20<t&&(um.clearInterval(r),n(mn.none())),t++},50)};return{onAdjustment:i,destroy:function(){t.unbind()}}}function $l(n,e,t){var o,r=n.document.createRange(),i=r;return e.fold(function(n){i.setStartBefore(n.dom)},function(n,e){i.setStart(n.dom,e)},function(n){i.setStartAfter(n.dom)}),o=r,t.fold(function(n){o.setEndBefore(n.dom)},function(n,e){o.setEnd(n.dom,e)},function(n){o.setEndAfter(n.dom)}),r}function Gl(n,e,t,o,r){var i=n.document.createRange();return i.setStart(e.dom,t),i.setEnd(o.dom,r),i}function Ul(n){return{left:n.left,top:n.top,right:n.right,bottom:n.bottom,width:n.width,height:n.height}}function Wl(n,e,t){return e(fe.fromDom(t.startContainer),t.startOffset,fe.fromDom(t.endContainer),t.endOffset)}function Xl(n,e){var r,t,o,i=(r=n,e.match({domRange:function(n){return{ltr:w(n),rtl:mn.none}},relative:function(n,e){return{ltr:k(function(){return $l(r,n,e)}),rtl:k(function(){return mn.some($l(r,e,n))})}},exact:function(n,e,t,o){return{ltr:k(function(){return Gl(r,n,e,t,o)}),rtl:k(function(){return mn.some(Gl(r,t,o,n,e))})}}}));return(o=(t=i).ltr()).collapsed?t.rtl().filter(function(n){return!1===n.collapsed}).map(function(n){return cm.rtl(fe.fromDom(n.endContainer),n.endOffset,fe.fromDom(n.startContainer),n.startOffset)}).getOrThunk(function(){return Wl(0,cm.ltr,o)}):Wl(0,cm.ltr,o)}!function(){var n=this,e=function(){var n,e,t,o={exports:{}};function r(){}function i(n){if("object"!=typeof this)throw new TypeError("Promises must be constructed via new");if("function"!=typeof n)throw new TypeError("not a function");this._state=0,this._handled=!1,this._value=void 0,this._deferreds=[],l(n,this)}function u(t,o){for(;3===t._state;)t=t._value;0!==t._state?(t._handled=!0,i._immediateFn(function(){var n,e=1===t._state?o.onFulfilled:o.onRejected;if(null!==e){try{n=e(t._value)}catch(n){return void a(o.promise,n)}c(o.promise,n)}else(1===t._state?c:a)(o.promise,t._value)})):t._deferreds.push(o)}function c(e,n){try{if(n===e)throw new TypeError("A promise cannot be resolved with itself.");if(n&&("object"==typeof n||"function"==typeof n)){var t=n.then;if(n instanceof i)return e._state=3,e._value=n,void s(e);if("function"==typeof t)return void l((o=t,r=n,function(){o.apply(r,arguments)}),e)}e._state=1,e._value=n,s(e)}catch(n){a(e,n)}var o,r}function a(n,e){n._state=2,n._value=e,s(n)}function s(n){2===n._state&&0===n._deferreds.length&&i._immediateFn(function(){n._handled||i._unhandledRejectionFn(n._value)});for(var e=0,t=n._deferreds.length;e<t;e++)u(n,n._deferreds[e]);n._deferreds=null}function f(n,e,t){this.onFulfilled="function"==typeof n?n:null,this.onRejected="function"==typeof e?e:null,this.promise=t}function l(n,e){var t=!1;try{n(function(n){t||(t=!0,c(e,n))},function(n){t||(t=!0,a(e,n))})}catch(n){if(t)return;t=!0,a(e,n)}}n=o,e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},t=setTimeout,i.prototype.catch=function(n){return this.then(null,n)},i.prototype.then=function(n,e){var t=new this.constructor(r);return u(this,new f(n,e,t)),t},i.all=function(n){var c=Array.prototype.slice.call(n);return new i(function(r,i){if(0===c.length)return r([]);for(var u=c.length,n=0;n<c.length;n++)!function e(t,n){try{if(n&&("object"==typeof n||"function"==typeof n)){var o=n.then;if("function"==typeof o)return o.call(n,function(n){e(t,n)},i),0}c[t]=n,0==--u&&r(c)}catch(n){i(n)}}(n,c[n])})},i.resolve=function(e){return e&&"object"==typeof e&&e.constructor===i?e:new i(function(n){n(e)})},i.reject=function(t){return new i(function(n,e){e(t)})},i.race=function(r){return new i(function(n,e){for(var t=0,o=r.length;t<o;t++)r[t].then(n,e)})},i._immediateFn="function"==typeof setImmediate?function(n){setImmediate(n)}:function(n){t(n,0)},i._unhandledRejectionFn=function(n){"undefined"!=typeof console&&console&&console.warn("Possible Unhandled Promise Rejection:",n)},i._setImmediateFn=function(n){i._immediateFn=n},i._setUnhandledRejectionFn=function(n){i._unhandledRejectionFn=n},n.exports?n.exports=i:e.Promise||(e.Promise=i);var d=o.exports;return{boltExport:("undefined"!=typeof window?window:Function("return this;")()).Promise||d}};"object"==typeof qf&&void 0!==Yf?Yf.exports=e():(n="undefined"!=typeof globalThis?globalThis:n||self).EphoxContactWrapper=e()}();function ql(r,n){return{uid:r.uid,dom:r.dom,components:n,behaviours:Lu(r.formBehaviours,[hf.config({store:{mode:"manual",getValue:function(n){var e,t,o=(e=r,t=n.getSystem(),De(e.partUids,function(n,e){return w(t.getByUid(n))}));return De(o,function(n,o){return n().bind(function(n){var e=ed.getCurrent(n),t=new Error("Cannot find a current component to extract the value from for form part '"+o+"': "+$o(n.element));return e.fold(function(){return ht.error(t)},ht.value)}).map(hf.getValue)})},setValue:function(t,n){Ee(n,function(e,n){ma(t,r,n).each(function(n){ed.getCurrent(n).each(function(n){hf.setValue(n,e)})})})}}})]),apis:{getField:function(n,e){return ma(n,r,e).bind(ed.getCurrent)}}}}function Yl(n){return"prepared"===n.type?mn.some(n.menu):mn.none()}var Kl,Jl=Yf.exports.boltExport,Ql=function(n){return vi(fe.fromDom(n.selection.getStart()),"a")},Zl=Fn(),nd=Object.freeze({__proto__:null,getCurrent:function(n,e,t){return e.find(n)}}),ed=Ao({fields:[Lt("find")],name:"composing",apis:nd}),td=wa({name:"Container",factory:function(n){var e=n.dom,t=e.attributes,o=c(e,["attributes"]);return{uid:n.uid,dom:y({tag:"div",attributes:y({role:"presentation"},t)},o),components:n.components,behaviours:n.containerBehaviours.dump,events:n.events,domModification:n.domModification,eventOrder:n.eventOrder}},configFields:[Yt("components",[]),ju("containerBehaviours",[]),Yt("events",{}),Yt("domModification",{}),Yt("eventOrder",{})]}),od=wa({name:"DataField",factory:function(t){return{uid:t.uid,dom:t.dom,behaviours:$c(t.dataBehaviours,[hf.config({store:{mode:"memory",initialValue:t.getInitialValue()}}),ed.config({find:mn.some})]),events:qo([Yo(function(n,e){hf.setValue(n,t.getInitialValue())})])}},configFields:[Lt("uid"),Lt("dom"),Lt("getInitialValue"),Lc("dataBehaviours",[hf,ed])]}),rd=wa({name:"Input",configFields:w([Ut("data"),Yt("inputAttributes",{}),Yt("inputStyles",{}),Yt("tag","input"),Yt("inputClasses",[]),kr("onSetValue"),Yt("styles",{}),Yt("eventOrder",{}),ju("inputBehaviours",[hf,fi]),Yt("selectOnFocus",!0)])(),factory:function(n,e){return{uid:n.uid,dom:{tag:(o=n).tag,attributes:y({type:"text"},o.inputAttributes),styles:o.inputStyles,classes:o.inputClasses},components:[],behaviours:(t=n,y(y({},or([fi.config({onFocus:t.selectOnFocus?function(n){var e=n.element,t=tl(e);e.dom.setSelectionRange(0,t.length)}:Y})])),Lu(t.inputBehaviours,[hf.config({store:y(y({mode:"manual"},t.data.map(function(n){return{initialValue:n}}).getOr({})),{getValue:function(n){return tl(n.element)},setValue:function(n,e){tl(n.element)!==e&&ol(n.element,e)}}),onSetValue:t.onSetValue})]))),eventOrder:n.eventOrder};var t,o}}),id=Object.freeze({__proto__:null,exhibit:function(n,e){return Io({attributes:xo([{key:e.tabAttr,value:"true"}])})}}),ud=Ao({fields:[Yt("tabAttr","data-alloy-tabstop")],name:"tabstopping",active:id}),cd=tinymce.util.Tools.resolve("tinymce.util.I18n"),ad=["input","button","textarea","select"],sd=function(e,n,t){n.disableClass.each(function(n){je(e.element,n)}),(ul(e,n)?function(n){Ie(n.element,"disabled","disabled")}:function(n){Ie(n.element,"aria-disabled","true")})(e),n.onDisabled(e)},fd=function(e,n,t){n.disableClass.each(function(n){Le(e.element,n)}),(ul(e,n)?function(n){He(n.element,"disabled")}:function(n){Ie(n.element,"aria-disabled","false")})(e),n.onEnabled(e)},ld=Object.freeze({__proto__:null,enable:fd,disable:sd,isDisabled:cl,onLoad:il,set:function(n,e,t,o){(o?sd:fd)(n,e)}}),dd=Object.freeze({__proto__:null,exhibit:function(n,e){return Io({classes:e.disabled()?e.disableClass.toArray():[]})},events:function(t,n){return qo([Co(Zn(),function(n,e){return cl(n,t)}),Vo(t,n,il)])}}),md=Ao({fields:[Kt("disabled",S,go),Yt("useNative",!0),Ut("disableClass"),kr("onDisabled"),kr("onEnabled")],name:"disabling",active:dd,apis:ld}),gd=[ju("formBehaviours",[hf])],pd=(va(function(n,e,t){return n.getField(e,t)}),function(n){var r,e={field:function(n,e){return r.push(n),t=al(n),o=e,{uiType:Yc(),owner:"form",name:t,config:o,validated:{}};var t,o},record:w(r=[])},t=n(e),o=Z(e.record(),function(n){return sa({name:n,pname:al(n)})});return xa("form",gd,o,ql,t)}),hd=k(function(o,r){return[{label:"the link group",items:[(n={fields:[rl("url","Type or paste URL"),rl("text","Link text"),rl("title","Link title"),rl("target","Link target"),{name:"link",spec:od.sketch({dom:{tag:"span",styles:{display:"none"}},getInitialValue:function(){return mn.none()}})}],maxFieldIndex:["url","text","title","target"].length-1,getInitialValue:function(){return mn.some(Ql(n=r).fold(function(){return{url:"",text:n.selection.getContent({format:"text"}),title:"",target:"",link:mn.none()}},function(n){return t=Jf(e=n),o=Be(e,"href"),r=Be(e,"title"),i=Be(e,"target"),{url:Zf(o),text:t!==o?Zf(t):"",title:Zf(r),target:Zf(i),link:mn.some(e)};var e,t,o,r,i}));var n},onExecute:function(n,e){var t=hf.getValue(n);nl(r,t),o.restoreToolbar(),r.focus()}},a="navigateEvent",s=zt("SerialisedDialog",lo([Lt("fields"),Yt("maxFieldIndex",n.fields.length-1),Lt("onExecute"),Lt("getInitialValue"),vo("state",function(){return{dialogSwipeState:cu(),currentScreen:No(0)}})]),n),f=Ns(pd(function(t){return{dom:Oa('<div class="${prefix}-serialised-dialog"></div>'),components:[td.sketch({dom:Oa('<div class="${prefix}-serialised-dialog-chain" style="left: 0px; position: absolute;"></div>'),components:Z(s.fields,function(n,e){return e<=s.maxFieldIndex?td.sketch({dom:Oa('<div class="${prefix}-serialised-dialog-screen"></div>'),components:[i(-1,"previous",0<e),t.field(n.name,n.spec),i(1,"next",e<s.maxFieldIndex)]}):t.field(n.name,n.spec)})})],formBehaviours:or([Nr(function(n,e){var t=e;hi(n.element,"."+ci("serialised-dialog-chain")).each(function(n){$r(n,"left",-s.state.currentScreen.get()*t.width+"px")})}),jc.config({mode:"special",focusIn:function(n,e){c(n)},onTab:function(n,e){return u(n,1),mn.some(!0)},onShiftTab:function(n,e){return u(n,-1),mn.some(!0)}}),el("form-events",[Yo(function(e,n){s.state.currentScreen.set(0),s.state.dialogSwipeState.clear();var t=l.get(e);Qi.highlightFirst(t),s.getInitialValue(e).each(function(n){hf.setValue(e,n)})}),Qo(s.onExecute),Eo(Wn(),function(n,e){"left"===e.event.raw.propertyName&&c(n)}),Eo(a,function(n,e){u(n,e.event.direction)})])])}})),l=Ns({dom:Oa('<div class="${prefix}-dot-container"></div>'),behaviours:or([Qi.config({highlightClass:ci("dot-active"),itemClass:ci("dot-item")})]),components:B(s.fields,function(n,e){return e<=s.maxFieldIndex?[ka('<div class="${prefix}-dot-item ${prefix}-icon-full-dot ${prefix}-icon"></div>')]:[]})}),{dom:Oa('<div class="${prefix}-serializer-wrapper"></div>'),components:[f.asSpec(),l.asSpec()],behaviours:or([jc.config({mode:"special",focusIn:function(n){var e=f.get(n);jc.focusIn(e)}}),el("serializer-wrapper-events",[Eo(Vn(),function(n,e){var t=e.event;s.state.dialogSwipeState.set({xValue:t.raw.touches[0].clientX,points:[]})}),Eo(Bn(),function(n,e){var t=e.event;s.state.dialogSwipeState.on(function(n){e.event.prevent(),s.state.dialogSwipeState.set(function(n,e){if(e===n.xValue)return n;var t=0<e-n.xValue?1:-1,o={direction:t,xValue:e};return{xValue:e,points:(0===n.points.length?[]:n.points[n.points.length-1].direction===t?n.points.slice(0,n.points.length-1):n.points).concat([o])}}(n,t.raw.touches[0].clientX))})}),Eo(An(),function(n,e){s.state.dialogSwipeState.on(function(t){u(f.get(n),-1*function(){if(0===t.points.length)return 0;var n=t.points[0].direction,e=t.points[t.points.length-1].direction;return-1===n&&-1===e?-1:1===n&&1===e?1:0}())})})])])})]}];function i(e,n,t){return Qs.sketch({dom:Oa('<span class="${prefix}-icon-'+n+' ${prefix}-icon"></span>'),action:function(n){X(n,a,{direction:e})},buttonBehaviours:or([md.config({disableClass:ci("toolbar-navigation-disabled"),disabled:function(){return!t}})])})}function u(n,r){var i=Jr(n.element,"."+ci("serialised-dialog-screen"));hi(n.element,"."+ci("serialised-dialog-chain")).each(function(o){0<=s.state.currentScreen.get()+r&&s.state.currentScreen.get()+r<i.length&&(Wr(o,"left").each(function(n){var e=parseInt(n,10),t=Ba(i[0]);$r(o,"left",e-r*t+"px")}),s.state.currentScreen.set(s.state.currentScreen.get()+r))})}function c(o){var n=Jr(o.element,"input");mn.from(n[s.state.currentScreen.get()]).each(function(n){o.getSystem().getByDom(n).each(function(n){var e=o,t=n.element;e.getSystem().triggerFocus(t,e.element)})});var e=l.get(o);Qi.highlightAt(e,s.state.currentScreen.get())}var n,a,s,f,l}),vd=qo([{key:Yn(),value:To({can:function(n,e){var t,o=e.event,r=o.originator,i=o.target;return!(un(t=r,n.element)&&!un(t,i)&&(console.warn(Yn()+" did not get interpreted by the desired target. \nOriginator: "+$o(r)+"\nTarget: "+$o(i)+"\nCheck the "+Yn()+" event handlers"),1))}})}]),bd=Object.freeze({__proto__:null,events:vd}),yd=K,xd=fl(),wd=function(n,c){var e,t,o,r,i,u,a=Me(n,function(r,u){return(1===r.length?ht.value(r[0].handler):gl(r,c,u)).map(function(n){var e,i,t=(i=m(e=n)?{can:x,abort:S,run:e}:e,function(n,e){for(var t=[],o=2;o<arguments.length;o++)t[o-2]=arguments[o];var r=[n,e].concat(t);i.abort.apply(void 0,r)?e.stop():i.can.apply(void 0,r)&&i.run.apply(void 0,r)}),o=1<r.length?E(c[u],function(e){return C(r,function(n){return n.name===e})}).join(" > "):r[0].name;return yo(u,{handler:t,purpose:o})})});return e={},t=[],o=[],M(a,function(n){n.fold(function(n){t.push(n)},function(n){o.push(n)})}),0<(u={errors:t,values:o}).errors.length?ht.error(V(u.errors)):(i=e,0===(r=u.values).length?ht.value(i):ht.value(co(i,ao.apply(void 0,r))))},Sd="alloy.base.behaviour",Od=lo([ho("dom","dom",Ot(),lo([Lt("tag"),Yt("styles",{}),Yt("classes",[]),Yt("attributes",{}),Ut("value"),Ut("innerHtml")])),Lt("components"),Lt("uid"),Yt("events",{}),Yt("apis",{}),ho("eventOrder","eventOrder",((Kl={})[Zn()]=["disabling",Sd,"toggling","typeaheadevents"],Kl[Yn()]=[Sd,"focusing","keying"],Kl[oe()]=[Sd,"disabling","toggling","representing"],Kl[$n()]=[Sd,"representing","streaming","invalidating"],Kl[ie()]=[Sd,"representing","item-events","tooltipping"],Kl[Nn()]=["focusing",Sd,"item-type-events"],Kl[Vn()]=["focusing",Sd,"item-type-events"],Kl[zn()]=["item-type-events","tooltipping"],Kl[Qn()]=["receiving","reflecting","tooltipping"],Et(w(Kl))),mo()),Ut("domModification")]),kd=qs,Td=function(u){return _e(u,Ls).getOrThunk(function(){var n,e,t,o,r,i=dt(u,"uid")?u:y({uid:kd("")},u);return n=yd(i),e=n.events,t=c(n,["events"]),o=Z(_e(t,"components").getOr([]),Td),r=y(y({},t),{events:y(y({},bd),e),components:o}),ht.value(xl(r)).getOrDie()})},Cd=ha,Ed="alloy.item-hover",Dd="alloy.item-focus",Md=w(Ed),_d=w(Dd),Rd=[Lt("data"),Lt("components"),Lt("dom"),Yt("hasSubmenu",!1),Ut("toggling"),Lc("itemBehaviours",[ii,fi,jc,hf]),Yt("ignoreFocus",!1),Yt("domModification",{}),Dr("builder",function(n){return{dom:n.dom,domModification:y(y({},n.domModification),{attributes:y(y(y({role:n.toggling.isSome()?"menuitemcheckbox":"menuitem"},n.domModification.attributes),{"aria-haspopup":n.hasSubmenu}),n.hasSubmenu?{"aria-expanded":!1}:{})}),behaviours:$c(n.itemBehaviours,[n.toggling.fold(ii.revoke,function(n){return ii.config(y({aria:{mode:"checked"}},n))}),fi.config({ignore:n.ignoreFocus,stopMousedown:n.ignoreFocus,onFocus:function(n){Ol(n)}}),jc.config({mode:"execution"}),hf.config({store:{mode:"memory",initialValue:n.data}}),el("item-type-events",u(u([],Pr(),!0),[Eo(zn(),Sl),Eo(ne(),fi.focus)],!1))]),components:n.components,eventOrder:n.eventOrder}}),Yt("eventOrder",{})],Fd=[Lt("dom"),Lt("components"),Dr("builder",function(n){return{dom:n.dom,components:n.components,events:qo([Eo(ne(),function(n,e){e.stop()})])}})],Id=w("item-widget"),Vd=w([sa({name:"widget",overrides:function(e){return{behaviours:or([hf.config({store:{mode:"manual",getValue:function(n){return e.data},setValue:Y}})])}}})]),Bd=jt("type",{widget:[Lt("uid"),Lt("data"),Lt("components"),Lt("dom"),Yt("autofocus",!1),Yt("ignoreFocus",!1),Lc("widgetBehaviours",[hf,fi,jc]),Yt("domModification",{}),pa(Vd()),Dr("builder",function(t){function o(n){return ma(n,t,"widget").map(function(n){return jc.focusIn(n),n})}function n(n,e){return eu(e.event.target)||t.autofocus&&e.setSource(n.element),mn.none()}var e=la(Id(),t,Vd()),r=da(Id(),t,e.internals());return{dom:t.dom,components:r,domModification:t.domModification,events:qo([Qo(function(n,e){o(n).each(function(n){e.stop()})}),Eo(zn(),Sl),Eo(ne(),function(n,e){t.autofocus?o(n):fi.focus(n)})]),behaviours:$c(t.widgetBehaviours,[hf.config({store:{mode:"memory",initialValue:t.data}}),fi.config({ignore:t.ignoreFocus,onFocus:function(n){Ol(n)}}),jc.config({mode:"special",focusIn:t.autofocus?function(n){o(n)}:ur(),onLeft:n,onRight:n,onEscape:function(n,e){return fi.isFocused(n)||t.autofocus?(t.autofocus&&e.setSource(n.element),mn.none()):(fi.focus(n),mn.some(!0))}})])}})],item:Rd,separator:Fd}),Ad=w([Ps({factory:{sketch:function(n){var e=zt("menu.spec item",Bd,n);return e.builder(e)}},name:"items",unit:"item",defaults:function(n,e){return dt(e,"uid")?e:y(y({},e),{uid:qs("item")})},overrides:function(n,e){return{type:e.type,ignoreFocus:n.fakeFocus,domModification:{classes:[n.markers.item]}}}})]),Nd=w([Lt("value"),Lt("items"),Lt("dom"),Lt("components"),Yt("eventOrder",{}),ju("menuBehaviours",[Qi,hf,ed,jc]),Kt("movement",{mode:"menu",moveOnTab:!0},jt("mode",{grid:[ei(),Dr("config",function(n,e){return{mode:"flatgrid",selector:"."+n.markers.item,initSize:{numColumns:e.initSize.numColumns,numRows:e.initSize.numRows},focusManager:n.focusManager}})],matrix:[Dr("config",function(n,e){return{mode:"matrix",selectors:{row:e.rowSelector,cell:"."+n.markers.item},focusManager:n.focusManager}}),Lt("rowSelector")],menu:[Yt("moveOnTab",!0),Dr("config",function(n,e){return{mode:"menu",selector:"."+n.markers.item,moveOnTab:e.moveOnTab,focusManager:n.focusManager}})]})),$t("markers",ni()),Yt("fakeFocus",!1),Yt("focusManager",Ii()),kr("onHighlight")]),Hd=w("alloy.menu-focus"),Pd=Sa({name:"Menu",configFields:Nd(),partFields:Ad(),factory:function(n,e,t,o){return{uid:n.uid,dom:n.dom,markers:n.markers,behaviours:Lu(n.menuBehaviours,[Qi.config({highlightClass:n.markers.selectedItem,itemClass:n.markers.item,onHighlight:n.onHighlight}),hf.config({store:{mode:"memory",initialValue:n.value}}),ed.config({find:mn.some}),jc.config(n.movement.config(n,n.movement))]),events:qo([Eo(_d(),function(e,t){var n=t.event;e.getSystem().getByDom(n.target).each(function(n){Qi.highlight(e,n),t.stop(),X(e,Hd(),{menu:e,item:n})})}),Eo(Md(),function(n,e){var t=e.event.item;Qi.highlight(n,t)})]),components:e,eventOrder:n.eventOrder,domModification:{attributes:{role:"menu"}}}}}),zd=function(n,e){return n.components()},jd=Ao({fields:[],name:"replacing",apis:Object.freeze({__proto__:null,append:function(n,e,t,o){kl(n,0,Qe,o)},prepend:function(n,e,t,o){kl(n,0,ye,o)},remove:Tl,replaceAt:Cl,replaceBy:function(e,n,t,o,r){return I(zd(e),o).bind(function(n){return Cl(e,0,0,n,r)})},set:function(i,n,e,u){var t,o,r,c;t=function(){var e,n,t,o,r=Z(u,i.getSystem().build);n=r,o=(e=i).components(),M((t=e).components(),function(n){return Ze(n.element)}),we(t.element),t.syncComponents(),M(H(o,n),function(n){ut(n),e.getSystem().removeFromWorld(n)}),M(n,function(n){n.getSystem().isConnected()?Te(e,n):(e.getSystem().addToWorld(n),Te(e,n),rt(e.element)&&ct(n)),e.syncComponents()})},o=i.element,r=tt(o),c=zo(r).bind(function(e){function n(n){return un(e,n)}var r,i;return n(o)?mn.some(o):(r=n,(i=function(n){for(var e=0;e<n.childNodes.length;e++){var t=fe.fromDom(n.childNodes[e]);if(r(t))return mn.some(t);var o=i(n.childNodes[e]);if(o.isSome())return o}return mn.none()})(o.dom))}),t(o),c.each(function(e){zo(r).filter(function(n){return un(n,e)}).fold(function(){Ho(e)},Y)})},contents:zd})}),Ld=function(t,o,r,n){return _e(r,n).bind(function(n){return _e(t,n).bind(function(n){var e=Ld(t,o,r,n);return mn.some([n].concat(e))})}).getOr([])},$d=function(){function c(u){return function(n){for(var e=st(n),t=0,o=e.length;t<o;t++){var r=e[t],i=n[r];if(i===u)return mn.some(i)}return mn.none()}(i.get())}function a(n){return e(n).bind(Yl)}function t(n){return _e(i.get(),n)}var i=No({}),u=No({}),s=No({}),f=cu(),l=No({}),e=function(n){return _e(u.get(),n)};return{setMenuBuilt:function(n,e){var t;u.set(y(y({},u.get()),((t={})[n]={type:"prepared",menu:e},t)))},setContents:function(n,e,t,o){f.set(n),i.set(t),u.set(e),l.set(o);var r=function(n,e){var t={};Ee(n,function(n,e){M(n,function(n){t[n]=e})});var o=e,r=lt(e,function(n,e){return{k:n,v:e}}),i=De(r,function(n,e){return[e].concat(Ld(t,o,r,e))});return De(t,function(n){return _e(i,n).getOr([n])})}(o,t);s.set(r)},expand:function(t){return _e(i.get(),t).map(function(n){var e=_e(s.get(),t).getOr([]);return[n].concat(e)})},refresh:function(n){return _e(s.get(),n)},collapse:function(n){return _e(s.get(),n).bind(function(n){return 1<n.length?mn.some(n.slice(1)):mn.none()})},lookupMenu:e,lookupItem:t,otherMenus:function(n){var e=l.get();return H(st(e),n)},getPrimary:function(){return f.get().bind(a)},getMenus:function(){return u.get()},clear:function(){i.set({}),u.set({}),s.set({}),f.clear()},isClear:function(){return f.get().isNone()},getTriggeringPath:function(n,u){var e=E(t(n).toArray(),function(n){return a(n).isSome()});return _e(s.get(),n).bind(function(n){var i=N(e.concat(n));return function(n){for(var e=[],t=0;t<n.length;t++){var o=n[t];if(!o.isSome())return mn.none();e.push(o.getOrDie())}return mn.some(e)}(B(i,function(n,e){return t=n,o=u,r=i.slice(0,e+1),a(t).bind(function(e){return c(t).bind(function(n){return o(n).map(function(n){return{triggeredMenu:e,triggeringItem:n,triggeringPath:r}})})}).fold(function(){return wo(f.get(),n)?[]:[mn.none()]},function(n){return[mn.some(n)]});var t,o,r}))})}}},Gd=Yl,Ud=w("collapse-item"),Wd=wa({name:"TieredMenu",configFields:[Er("onExecute"),Er("onEscape"),Cr("onOpenMenu"),Cr("onOpenSubmenu"),kr("onRepositionMenu"),kr("onCollapseMenu"),Yt("highlightImmediately",!0),Gt("data",[Lt("primary"),Lt("menus"),Lt("expansions")]),Yt("fakeFocus",!1),kr("onHighlight"),kr("onHover"),Gt("markers",[Lt("backgroundMenu")].concat(wr()).concat(Sr())),Lt("dom"),Yt("navigateOnHover",!0),Yt("stayInDom",!1),ju("tmenuBehaviours",[jc,Qi,ed,jd]),Yt("eventOrder",{})],apis:{collapseMenu:function(n,e){n.collapseMenu(e)},highlightPrimary:function(n,e){n.highlightPrimary(e)},repositionMenus:function(n,e){n.repositionMenus(e)}},factory:function(c,n){function t(n){var o,r,e=(o=n,r=c.data.primary,De(c.data.menus,function(n,e){function t(){return Pd.sketch(y(y({},n),{value:e,markers:c.markers,fakeFocus:c.fakeFocus,onHighlight:c.onHighlight,focusManager:(c.fakeFocus?Vi:Ii)()}))}return e===r?{type:"prepared",menu:o.getSystem().build(t())}:{type:"notbuilt",nbMenu:t}})),t=De(c.data.menus,function(n,e){return B(n.items,function(n){return"separator"===n.type?[]:[n.data.value]})});return m.setContents(c.data.primary,e,c.data.expansions,t),m.getPrimary()}function a(n){return hf.getValue(n).value}function i(e,n){Qi.highlight(e,n),Qi.getHighlighted(n).orThunk(function(){return Qi.getFirst(n)}).each(function(n){nn(e,n.element,ne())})}function u(e,n){return So(Z(n,function(n){return e.lookupMenu(n).bind(function(n){return"prepared"===n.type?mn.some(n.menu):mn.none()})}))}function s(e,n,t){M(u(n,n.otherMenus(t)),function(n){hl(n.element,[c.markers.backgroundMenu]),c.stayInDom||jd.remove(e,n)})}function f(n,o){var e;Ee((e=n,r.get().getOrThunk(function(){var t={};return M(E(Jr(e.element,"."+c.markers.item),function(n){return"true"===Be(n,"aria-haspopup")}),function(n){e.getSystem().getByDom(n).each(function(n){var e=a(n);t[e]=n})}),r.set(t),t})),function(n,e){var t=T(o,e);Ie(n.element,"aria-expanded",t)})}function l(t,o,r){return mn.from(r[0]).bind(function(n){return o.lookupMenu(n).bind(function(n){if("notbuilt"===n.type)return mn.none();var e=n.menu;return M(u(o,r.slice(1)),function(n){je(n.element,c.markers.backgroundMenu)}),rt(e.element)||jd.append(t,Cd(e)),hl(e.element,[c.markers.backgroundMenu]),i(t,e),s(t,o,r),mn.some(e)})})}var d,e,r=cu(),m=$d();function g(r,i,u){if(void 0===u&&(u=d.HighlightSubmenu),i.hasConfigured(md)&&md.isDisabled(i))return mn.some(i);var n=a(i);return m.expand(n).bind(function(o){return f(r,o),mn.from(o[0]).bind(function(t){return m.lookupMenu(t).bind(function(n){var e=function(n,e,t){if("notbuilt"!==t.type)return t.menu;var o=n.getSystem().build(t.nbMenu());return m.setMenuBuilt(e,o),o}(r,t,n);return rt(e.element)||jd.append(r,Cd(e)),c.onOpenSubmenu(r,i,e,N(o)),u===d.HighlightSubmenu?(Qi.highlightFirst(e),l(r,m,o)):(Qi.dehighlightAll(e),mn.some(i))})})})}function o(e,t){var n=a(t);return m.collapse(n).bind(function(n){return f(e,n),l(e,m,n).map(function(n){return c.onCollapseMenu(e,t,n),n})})}function p(t){return function(e,n){return vi(n.getSource(),"."+c.markers.item).bind(function(n){return e.getSystem().getByDom(n).toOptional().bind(function(n){return t(e,n).map(x)})})}}function h(n){return Qi.getHighlighted(n).bind(Qi.getHighlighted)}(e=d={})[e.HighlightSubmenu=0]="HighlightSubmenu",e[e.HighlightParent=1]="HighlightParent";var v=qo([Eo(Hd(),function(t,o){var n=o.event.item;m.lookupItem(a(n)).each(function(){var n=o.event.menu;Qi.highlight(t,n);var e=a(o.event.item);m.refresh(e).each(function(n){return s(t,m,n)})})}),Qo(function(e,n){var t=n.event.target;e.getSystem().getByDom(t).each(function(n){0===a(n).indexOf("collapse-item")&&o(e,n),g(e,n,d.HighlightSubmenu).fold(function(){c.onExecute(e,n)},Y)})}),Yo(function(e,n){t(e).each(function(n){jd.append(e,Cd(n)),c.onOpenMenu(e,n),c.highlightImmediately&&i(e,n)})})].concat(c.navigateOnHover?[Eo(Md(),function(n,e){var t=e.event.item,o=n,r=a(t);m.refresh(r).bind(function(n){return f(o,n),l(o,m,n)}),g(n,t,d.HighlightParent),c.onHover(n,t)})]:[])),b={collapseMenu:function(e){h(e).each(function(n){o(e,n)})},highlightPrimary:function(e){m.getPrimary().each(function(n){i(e,n)})},repositionMenus:function(o){m.getPrimary().bind(function(e){return h(o).bind(function(n){var e=a(n),t=So(Z(Me(m.getMenus(),K),Gd));return m.getTriggeringPath(e,function(n){return e=n,z(t,function(n){return n.getSystem().isConnected()?F(Qi.getCandidates(n),function(n){return a(n)===e}):mn.none()});var e})}).map(function(n){return{primary:e,triggeringPath:n}})}).fold(function(){mn.from(o.components()[0]).filter(function(n){return"menu"===Be(n.element,"role")}).each(function(n){c.onRepositionMenu(o,n,[])})},function(n){var e=n.primary,t=n.triggeringPath;c.onRepositionMenu(o,e,t)})}};return{uid:c.uid,dom:c.dom,markers:c.markers,behaviours:Lu(c.tmenuBehaviours,[jc.config({mode:"special",onRight:p(function(n,e){return eu(e.element)?mn.none():g(n,e,d.HighlightSubmenu)}),onLeft:p(function(n,e){return eu(e.element)?mn.none():o(n,e)}),onEscape:p(function(n,e){return o(n,e).orThunk(function(){return c.onEscape(n,e).map(function(){return n})})}),focusIn:function(e,n){m.getPrimary().each(function(n){nn(e,n.element,ne())})}}),Qi.config({highlightClass:c.markers.selectedMenu,itemClass:c.markers.menu}),ed.config({find:function(n){return Qi.getHighlighted(n)}}),jd.config({})]),eventOrder:c.eventOrder,apis:b,events:v}},extraApis:{tieredData:function(n,e,t){return{primary:n,menus:e,expansions:t}},singleData:function(n,e){return{primary:n,menus:yo(n,e),expansions:{}}},collapseItem:function(n){return{value:Gu(Ud()),meta:{text:n}}}}}),Xd=function(n,e,t,o){return El(0,e,0,o).bind(function(e){return e.transition.map(function(n){return{transition:n,route:e}})})},qd=function(e,t,n){return Ae(e.element,t.destinationAttr).map(function(n){return{start:Be(e.element,t.stateAttr),destination:n}})},Yd=Object.freeze({__proto__:null,findRoute:El,disableTransition:Dl,getCurrentRoute:qd,jumpTo:Ml,progressTo:function(t,o,r,i){var e,u=o;Ne((e=t).element,u.destinationAttr)&&(Ae(e.element,u.destinationAttr).each(function(n){Ie(e.element,u.stateAttr,n)}),He(e.element,u.destinationAttr));var n,c=(n=i,{start:Be(t.element,o.stateAttr),destination:n});Xd(t,o,r,c).fold(function(){Ml(t,o,r,i)},function(n){Dl(t,o,r);var e=n.transition;je(t.element,e.transitionClass),Ie(t.element,o.destinationAttr,i)})},getState:function(n,e,t){return Ae(n.element,e.stateAttr)}}),Kd=Object.freeze({__proto__:null,events:function(r,i){return qo([Eo(Wn(),function(t,n){var o=n.event.raw;qd(t,r).each(function(e){El(0,r,0,e).each(function(n){n.transition.each(function(n){o.propertyName===n.property&&(Ml(t,r,i,e.destination),r.onTransition(t,e))})})})}),Yo(function(n,e){Ml(n,r,i,r.initialState)})])}}),Jd=Ao({fields:[Yt("destinationAttr","data-transitioning-destination"),Yt("stateAttr","data-transitioning-state"),Lt("initialState"),kr("onTransition"),kr("onFinish"),$t("routes",Nt(ht.value,Nt(ht.value,It([qt("transition",[Lt("property"),Lt("transitionClass")])]))))],name:"transitioning",active:Kd,apis:Yd,extra:{createRoutes:function(n){var o={};return Ee(n,function(n,e){var t=e.split("<->");o[t[0]]=yo(t[1],n),o[t[1]]=yo(t[0],n)}),o},createBistate:function(n,e,t){return xo([{key:n,value:yo(e,t)},{key:e,value:yo(n,t)}])},createTristate:function(n,e,t,o){return xo([{key:n,value:xo([{key:e,value:o},{key:t,value:o}])},{key:e,value:xo([{key:n,value:o},{key:t,value:o}])},{key:t,value:xo([{key:n,value:o},{key:e,value:o}])}])}}}),Qd=ci("scrollable"),Zd=Qd,nm=function(n,e,t,o,r){return{data:{value:n,text:e},type:"item",dom:{tag:"div",classes:r?[ci("styles-item-is-menu")]:[]},toggling:{toggleOnExecute:!1,toggleClass:ci("format-matches"),selected:t},itemBehaviours:or(r?[]:[Ar(n,function(n,e){(e?ii.on:ii.off)(n)})]),components:[{dom:{tag:"div",attributes:{style:o},innerHtml:e}}]}},em=function(n,e,t,o){return{value:n,dom:{tag:"div"},components:[Qs.sketch({dom:{tag:"div",classes:[ci("styles-collapser")]},components:o?[{dom:{tag:"span",classes:[ci("styles-collapse-icon")]}},wl(n)]:[wl(n)],action:function(n){var e;o&&(e=t().get(n),Wd.collapseMenu(e))}}),{dom:{tag:"div",classes:[ci("styles-menu-items-container")]},components:[Pd.parts.items({})],behaviours:or([el("adhoc-scrollable-menu",[Yo(function(n,e){$r(n.element,"overflow-y","auto"),$r(n.element,"-webkit-overflow-scrolling","touch"),_l(n.element)}),Ko(function(n){Xr(n.element,"overflow-y"),Xr(n.element,"-webkit-overflow-scrolling"),Rl(n.element)})])])}],items:e,menuBehaviours:or([Jd.config({initialState:"after",routes:Jd.createTristate("before","current","after",{transition:{property:"transform",transitionClass:"transitioning"}})})])}},tm=function(n){return _(n,function(n,e){var t=Il(e);return{menus:co(n.menus,t.menus),items:[t.item].concat(n.items),expansions:co(n.expansions,t.expansions)}},{menus:{},expansions:{},items:[]})},om=function(n){return B(n,function(n){return(D(n)?om:Bl)(n)})},rm=function(n,e,t,o){n.dom.removeEventListener(e,t,o)},im=x,um=tinymce.util.Tools.resolve("tinymce.util.Delay"),cm=Jt([{ltr:["start","soffset","finish","foffset"]},{rtl:["start","soffset","finish","foffset"]}]);function am(n,e){var t=le(n);return"input"===t?mg.after(n):T(["br","img"],t)?0===e?mg.before(n):mg.after(n):mg.on(n,e)}function sm(n){return mn.from(n.getSelection())}function fm(n,e,t,o,r){var i=Gl(n,e,t,o,r);sm(n).each(function(n){n.removeAllRanges(),n.addRange(i)})}function lm(n,e,t,o,r){var i,u,c,a,s,f=(i=o,u=r,c=am(e,t),a=am(i,u),pg.relative(c,a));Xl(s=n,f).match({ltr:function(n,e,t,o){fm(s,n,e,t,o)},rtl:function(r,i,u,c){sm(s).each(function(n){if(n.setBaseAndExtent)n.setBaseAndExtent(r.dom,i,u.dom,c);else if(n.extend)try{t=u,o=c,(e=n).collapse(r.dom,i),e.extend(t.dom,o)}catch(n){fm(s,u,c,r,i)}else fm(s,u,c,r,i);var e,t,o})}})}function dm(n){if(0<n.rangeCount){var e=n.getRangeAt(0),t=n.getRangeAt(n.rangeCount-1);return mn.some(fg(fe.fromDom(e.startContainer),e.startOffset,fe.fromDom(t.endContainer),t.endOffset))}return mn.none()}function mm(n){if(null===n.anchorNode||null===n.focusNode)return dm(n);var e,t,o,r,i,u,c,a,s,f,l,d=fe.fromDom(n.anchorNode),m=fe.fromDom(n.focusNode);return e=d,t=n.anchorOffset,o=m,r=n.focusOffset,u=t,c=o,a=r,(s=me(i=e).dom.createRange()).setStart(i.dom,u),s.setEnd(c.dom,a),f=s,l=un(e,o)&&t===r,f.collapsed&&!l?mn.some(fg(d,n.anchorOffset,m,n.focusOffset)):dm(n)}function gm(n){return sm(n).filter(function(n){return 0<n.rangeCount}).bind(mm)}function pm(n,e){var i,t,o,r=(t=Xl(i=n,e).match({ltr:function(n,e,t,o){var r=i.document.createRange();return r.setStart(n.dom,e),r.setEnd(t.dom,o),r},rtl:function(n,e,t,o){var r=i.document.createRange();return r.setStart(t.dom,o),r.setEnd(n.dom,e),r}})).getClientRects();return 0<(o=0<r.length?r[0]:t.getBoundingClientRect()).width||0<o.height?mn.some(o).map(Ul):mn.none()}function hm(n){return mn.from(n.dom.contentWindow)}function vm(n){return hm(n).bind(gm)}function bm(n){return n.getFrame()}function ym(n,e,t,o){return n[t].getOrThunk(function(){return function(n){return Pl(e,o,n)}})}function xm(c){var a=bm(c);return mn.some(fe.fromDom(a.dom.contentWindow.document.body)).bind(function(u){return mn.some(fe.fromDom(a.dom.contentWindow.document)).bind(function(i){return hm(a).map(function(r){var n=fe.fromDom(i.dom.documentElement),e=c.getCursorBox.getOrThunk(function(){return function(){return gm(r).map(function(n){return pg.exact(n.start,n.soffset,n.finish,n.foffset)}).bind(function(n){return pm(r,n).orThunk(function(){return gm(r).filter(function(n){return un(n.start,n.finish)&&n.soffset===n.foffset}).bind(function(n){var e=n.start.dom.getBoundingClientRect();return 0<e.width||0<e.height?mn.some(e):mn.none()})})})}}),t=c.setSelection.getOrThunk(function(){return function(n,e,t,o){lm(r,n,e,t,o)}}),o=c.clearSelection.getOrThunk(function(){return function(){sm(r).each(function(n){return n.removeAllRanges()})}});return{body:u,doc:i,win:r,html:n,getSelection:J(vm,a),setSelection:t,clearSelection:o,frame:a,onKeyup:ym(c,i,"onKeyup","keyup"),onNodeChanged:ym(c,i,"onNodeChanged","SelectionChange"),onDomChanged:c.onDomChanged,onScrollToCursor:c.onScrollToCursor,onScrollToElement:c.onScrollToElement,onToReading:c.onToReading,onToEditing:c.onToEditing,onToolbarScrollStart:c.onToolbarScrollStart,onTouchContent:c.onTouchContent,onTapContent:c.onTapContent,onTouchToolstrip:c.onTouchToolstrip,getCursorBox:e}})})})}function wm(){var e=rn("head").getOrDie(),n=rn('meta[name="viewport"]').getOrThunk(function(){var n=fe.fromTag("meta");return Ie(n,"name","viewport"),Qe(e,n),n}),t=Be(n,"content");return{maximize:function(){Ie(n,"content","width=device-width, initial-scale=1.0, user-scalable=no, maximum-scale=1.0")},restore:function(){null!=t&&0<t.length?Ie(n,"content",t):Ie(n,"content","user-scalable=yes")}}}function Sm(n,e){function t(o){return function(n){var e=Be(n,"style"),t=void 0===e?"no-styles":e.trim();t===o||(Ie(n,vg,t),Ie(n,"style",o))}}var o,r,i=(r=function(n){return en(n,"*")},E(function(n,e){for(var t=m(e)?e:S,o=n.dom,r=[];null!==o.parentNode&&void 0!==o.parentNode;){var i=o.parentNode,u=fe.fromDom(i);if(r.push(u),!0===t(u))break;o=i}return r}(n,void 0),r)),u=B(i,function(n){return e=function(n){return en(n,"*")},E(pe(t=n).map(Je).map(function(n){return E(n,function(n){return!un(t,n)})}).getOr([]),e);var e,t}),c=void 0!==(o=Ur(e,"background-color"))&&""!==o?"background-color:"+o+"!important":"background-color:rgb(255,255,255)!important;";M(u,t("display:none!important;")),M(i,t(bg+yg+c)),t((!0===xg?"":bg)+yg+c)(n)}function Om(){M(on("["+vg+"]"),function(n){var e=Be(n,vg);"no-styles"!==e?Ie(n,"style",e):He(n,"style"),He(n,vg)})}function km(n){var e=n.raw;return void 0===e.touches||1!==e.touches.length?mn.none():mn.some(e.touches[0])}function Tm(t){var o,r,u=cu(),i=No(!1),c=(o=function(n){t.triggerEvent(te(),n),i.set(!0)},r=null,{cancel:function(){null!==r&&(clearTimeout(r),r=null)},schedule:function(){for(var n=[],e=0;e<arguments.length;e++)n[e]=arguments[e];r=setTimeout(function(){o.apply(null,n),r=null},400)}}),a=xo([{key:Vn(),value:function(t){return km(t).each(function(n){c.cancel();var e={x:n.clientX,y:n.clientY,target:t.target};c.schedule(t),i.set(!1),u.set(e)}),mn.none()}},{key:Bn(),value:function(n){return c.cancel(),km(n).each(function(i){u.on(function(n){var e=i,t=n,o=Math.abs(e.clientX-t.x),r=Math.abs(e.clientY-t.y);(5<o||5<r)&&u.clear()})}),mn.none()}},{key:An(),value:function(e){return c.cancel(),u.get().filter(function(n){return un(n.target,e.target)}).map(function(n){return i.get()?(e.prevent(),!1):t.triggerEvent(ee(),e)})}}]);return{fireIfReady:function(e,n){return _e(a,n).bind(function(n){return n(e)})}}}function Cm(t){var e=Tm({triggerEvent:function(n,e){t.onTapContent(e)}});return{fireTouchstart:function(n){e.fireIfReady(n,"touchstart")},onTouchend:function(){return Pl(t.body,"touchend",function(n){e.fireIfReady(n,"touchend")})},onTouchmove:function(){return Pl(t.body,"touchmove",function(n){e.fireIfReady(n,"touchmove")})}}}function Em(n,e){var t=parseInt(Be(n,e),10);return isNaN(t)?0:t}function Dm(n){return y(y({},n),{width:2})}function Mm(n){return{left:n.left,top:n.top,right:n.right,bottom:n.bottom,width:n.width,height:n.height}}function _m(n){var e=n.getSelection();return void 0!==e&&0<e.rangeCount?function(o){if(o.collapsed){var r=fe.fromDom(o.startContainer);return pe(r).bind(function(n){var e,t=pg.exact(r,o.startOffset,n,"img"===le(e=n)?1:lg.getOption(e).fold(function(){return Je(e).length},function(n){return n.length}));return pm(o.startContainer.ownerDocument.defaultView,t).map(Dm).map(P)}).getOr([])}return Z(o.getClientRects(),Mm)}(e.getRangeAt(0)):[]}function Rm(n,e){Ie(n,Sg,e)}function Fm(n){return{top:n.top,bottom:n.top+n.height}}function Im(o,r){var i=fe.fromDom(r.document.body),n=Pl(fe.fromDom(o),"resize",function(){var n,e,t;n=o,e=Em(i,Sg),((t=n.innerHeight)<e?mn.some(e-t):mn.none()).each(function(t){var n;(0<(n=_m(r)).length?mn.some(n[0]).map(Fm):mn.none()).each(function(n){var e=n.top>r.innerHeight||n.bottom>r.innerHeight?Math.min(t,n.bottom-r.innerHeight+50):0;0!==e&&r.scrollTo(r.pageXOffset,r.pageYOffset+e)})}),Rm(i,o.innerHeight)});return Rm(i,o.innerHeight),{toEditing:function(){!function(n){n.focus();var e=fe.fromDom(n.document.body);(zo().exists(function(n){return T(["input","textarea"],le(n))})?function(n){um.setTimeout(function(){n()},0)}:p)(function(){zo().each(Po),Ho(e)})}(r)},destroy:function(){n.unbind()}}}function Vm(t,o){function r(){s(i)||(clearTimeout(i),i=null)}var i=null;return{cancel:r,throttle:function(){for(var n=[],e=0;e<arguments.length;e++)n[e]=arguments[e];r(),i=setTimeout(function(){i=null,t.apply(null,n)},o)}}}function Bm(n){var t,o,e=Ns(td.sketch({dom:Oa('<div aria-hidden="true" class="${prefix}-mask-tap-icon"></div>'),containerBehaviours:or([ii.config({toggleClass:ci("mask-tap-icon-selected"),toggleOnExecute:!1})])})),r=(t=n,o=null,{cancel:function(){s(o)||(clearTimeout(o),o=null)},throttle:function(){for(var n=[],e=0;e<arguments.length;e++)n[e]=arguments[e];s(o)&&(o=setTimeout(function(){o=null,t.apply(null,n)},200))}});return td.sketch({dom:Oa('<div class="${prefix}-disabled-mask"></div>'),components:[td.sketch({dom:Oa('<div class="${prefix}-content-container"></div>'),components:[Qs.sketch({dom:Oa('<div class="${prefix}-content-tap-section"></div>'),components:[e.asSpec()],action:function(n){r.throttle()},buttonBehaviours:or([ii.config({toggleClass:ci("mask-tap-icon-selected")})])})]})]})}function Am(n){var e=zt("Getting AndroidWebapp schema",kg,n);$r(e.toolstrip,"width","100%");var t=Td(Bm(function(){e.setReadOnly(e.readOnlyOnInit()),c.enter()},e.translate));e.alloy.add(t);var o={show:function(){e.alloy.add(t)},hide:function(){e.alloy.remove(t)}};Qe(e.container,t.element);var s,r,i,u,f,c=(s=e,r=o,i=wm(),u=uu(),f=uu(),{enter:function(){r.hide(),je(s.container,ci("fullscreen-maximized")),je(s.container,ci("android-maximized")),i.maximize(),je(s.body,ci("android-scroll-reload")),u.set(Im(s.win,hg(s.editor).getOrDie("no"))),xm(s.editor).each(function(n){function e(n){return!un(n.start,n.finish)||n.soffset!==n.foffset}function t(){var n=o.doc.dom.hasFocus()&&o.getSelection().exists(e);i.getByDom(r).each(!0===(n||zo(c).filter(function(n){return"input"===le(n)}).exists(function(n){return n.dom.selectionStart!==n.dom.selectionEnd}))?ii.on:ii.off)}var o,r,i,u,c,a;Sm(s.container,n.body),f.set((o=n,r=s.toolstrip,i=s.alloy,u=Cm(o),c=me(r),a=[Pl(o.body,"touchstart",function(n){o.onTouchContent(),u.fireTouchstart(n)}),u.onTouchmove(),u.onTouchend(),Pl(r,"touchstart",function(n){o.onTouchToolstrip()}),o.onToReading(function(){Po(o.body)}),o.onToEditing(Y),o.onScrollToCursor(function(n){n.preventDefault(),o.getCursorBox().each(function(n){var e=o.win,t=n.top>e.innerHeight||n.bottom>e.innerHeight?n.bottom-e.innerHeight+50:0;0!=t&&e.scrollTo(e.pageXOffset,e.pageYOffset+t)})})].concat(1==wg?[]:[Pl(fe.fromDom(o.win),"blur",function(){i.getByDom(r).each(ii.off)}),Pl(c,"select",t),Pl(o.doc,"selectionchange",t)]),{destroy:function(){M(a,function(n){n.unbind()})}}))})},exit:function(){i.restore(),r.show(),Le(s.container,ci("fullscreen-maximized")),Le(s.container,ci("android-maximized")),Om(),Le(s.body,ci("android-scroll-reload")),f.clear(),u.clear()}});return{setReadOnly:e.setReadOnly,refreshStructure:Y,enter:c.enter,exit:c.exit,destroy:Y}}function Nm(n){return"true"===Be(n,Rg)?0<n.dom.scrollLeft||function(n){n.dom.scrollLeft=1;var e=0!==n.dom.scrollLeft;return n.dom.scrollLeft=0,e}(n):0<n.dom.scrollTop||function(n){n.dom.scrollTop=1;var e=0!==n.dom.scrollTop;return n.dom.scrollTop=0,e}(n)}function Hm(){function e(n){var e=!0===n.scrollable?"${prefix}-toolbar-scrollable-group":"";return{dom:Oa('<div aria-label="'+n.label+'" class="${prefix}-toolbar-group '+e+'"></div>'),tgroupBehaviours:or([el("adhoc-scrollable-toolbar",!0===n.scrollable?[Jo(function(n,e){$r(n.element,"overflow-x","auto"),Ie(n.element,Rg,"true"),_l(n.element)})]:[])]),components:[td.sketch({components:[_g.parts.items({})]})],markers:{itemSelector:"."+ci("toolbar-group-item")},items:n.items}}function t(){Eg.setGroups(o,r.get()),ii.off(o)}var o=Td(Eg.sketch({dom:Oa('<div class="${prefix}-toolbar"></div>'),components:[Eg.parts.groups({})],toolbarBehaviours:or([ii.config({toggleClass:ci("context-toolbar"),toggleOnExecute:!1,aria:{mode:"none"}}),jc.config({mode:"cyclic"})]),shell:!0})),n=Td(td.sketch({dom:{classes:[ci("toolstrip")]},components:[Cd(o)],containerBehaviours:or([ii.config({toggleClass:ci("android-selection-context-toolbar"),toggleOnExecute:!1})])})),r=No([]);return{wrapper:n,toolbar:o,createGroups:function(n){return Z(n,i(_g.sketch,e))},setGroups:function(n){r.set(n),t()},setContextToolbar:function(n){ii.on(o),Eg.setGroups(o,n)},restoreToolbar:function(){ii.isOn(o)&&t()},refresh:function(){},focus:function(){jc.focusIn(o)}}}function Pm(n){return Td(Qs.sketch({dom:Oa('<div class="${prefix}-mask-edit-icon ${prefix}-icon"></div>'),action:function(){n.run(function(n){n.setReadOnly(!1)})}}))}function zm(){return Td(td.sketch({dom:Oa('<div class="${prefix}-editor-socket"></div>'),components:[],containerBehaviours:or([jd.config({})])}))}function jm(n,e,t,o){(!0===t?cr.toAlpha:cr.toOmega)(o),(t?function(n,e){jd.append(n,Cd(e))}:function(n,e){jd.remove(n,e)})(n,e)}function Lm(e,n){return n.getAnimationRoot.fold(function(){return e.element},function(n){return n(e)})}function $m(n){return n.dimension.property}function Gm(n,e){return n.dimension.getDimension(e)}function Um(n,e){hl(Lm(n,e),[e.shrinkingClass,e.growingClass])}function Wm(n,e){Le(n.element,e.openClass),je(n.element,e.closedClass),$r(n.element,$m(e),"0px"),qr(n.element)}function Xm(n,e){Le(n.element,e.closedClass),je(n.element,e.openClass),Xr(n.element,$m(e))}function qm(n,e,t,o){t.setCollapsed(),$r(n.element,$m(e),Gm(e,n.element)),qr(n.element),Um(n,e),Wm(n,e),e.onStartShrink(n),e.onShrunk(n)}function Ym(n,e,t){var o=Gm(e,n.element);("0px"===o?qm:function(n,e,t,o){var r=o.getOrThunk(function(){return Gm(e,n.element)});t.setCollapsed(),$r(n.element,$m(e),r),qr(n.element);var i=Lm(n,e);Le(i,e.growingClass),je(i,e.shrinkingClass),Wm(n,e),e.onStartShrink(n)})(n,e,t,mn.some(o))}function Km(n,e,t){var o=Lm(n,e),r=$e(o,e.shrinkingClass),i=Gm(e,n.element);Xm(n,e);var u=Gm(e,n.element);(r?function(){$r(n.element,$m(e),i),qr(n.element)}:function(){Wm(n,e)})(),Le(o,e.shrinkingClass),je(o,e.growingClass),Xm(n,e),$r(n.element,$m(e),u),t.setExpanded(),e.onStartGrow(n)}function Jm(n,e,t){return!0===$e(Lm(n,e),e.growingClass)}function Qm(n,e,t){return!0===$e(Lm(n,e),e.shrinkingClass)}function Zm(e,t){var o=Td(td.sketch({dom:{tag:"div",classes:[ci("dropup")]},components:[],containerBehaviours:or([jd.config({}),Vg.config({closedClass:ci("dropup-closed"),openClass:ci("dropup-open"),shrinkingClass:ci("dropup-shrinking"),growingClass:ci("dropup-growing"),dimension:{property:"height"},onShrunk:function(n){e(),t(),jd.set(n,[])},onGrown:function(n){e(),t()}}),Nr(function(n,e){r(Y)})])})),r=function(n){window.requestAnimationFrame(function(){n(),Vg.shrink(o)})};return{appear:function(n,e,t){!0===Vg.hasShrunk(o)&&!1===Vg.isTransitioning(o)&&window.requestAnimationFrame(function(){e(t),jd.set(o,[n()]),Vg.grow(o)})},disappear:r,component:o,element:o.element}}function ng(){return Fn().browser.isFirefox()}function eg(e,n){var t,o,r,i,u=y({stopBackspace:!0},n),c=Tm(u),a=Z(["touchstart","touchmove","touchend","touchcancel","gesturestart","mousedown","mouseup","mouseover","mousemove","mouseout","click"].concat(["selectstart","input","contextmenu","change","transitionend","transitioncancel","drag","dragstart","dragend","dragenter","dragleave","dragover","drop","keyup"]),function(n){return Pl(e,n,function(e){c.fireIfReady(e,n).each(function(n){n&&e.kill()}),u.triggerEvent(n,e)&&e.kill()})}),s=cu(),f=Pl(e,"paste",function(e){c.fireIfReady(e,"paste").each(function(n){n&&e.kill()}),u.triggerEvent("paste",e)&&e.kill(),s.set(setTimeout(function(){u.triggerEvent(Jn(),e)},0))}),l=Pl(e,"keydown",function(n){var e;u.triggerEvent("keydown",n)?n.kill():!u.stopBackspace||((e=n).raw.which!==ji[0]||T(["input","textarea"],le(e.target))||vi(e.target,'[contenteditable="true"]',void 0).isSome())||n.prevent()}),d=(t=e,o=function(n){u.triggerEvent("focusin",n)&&n.kill()},ng()?zl(t,"focus",o):Pl(t,"focusin",o)),m=cu(),g=(r=e,i=function(n){u.triggerEvent("focusout",n)&&n.kill(),m.set(setTimeout(function(){u.triggerEvent(Kn(),n)},0))},ng()?zl(r,"blur",i):Pl(r,"focusout",i));return{unbind:function(){M(a,function(n){n.unbind()}),l.unbind(),d.unbind(),g.unbind(),f.unbind(),s.on(clearTimeout),m.on(clearTimeout)}}}function tg(n,e){return No(_e(n,"target").getOr(e))}function og(n,o,e,t,r,i){var u,c,a=n(o,t),s=(u=No(!1),c=No(!1),{stop:function(){u.set(!0)},cut:function(){c.set(!0)},isStopped:u.get,isCut:c.get,event:e,setSource:r.set,getSource:r.get});return a.fold(function(){return i.logEventNoHandlers(o,t),Bg.complete()},function(e){var t=e.descHandler;return dl(t)(s),s.isStopped()?(i.logEventStopped(o,e.element,t.purpose),Bg.stopped()):s.isCut()?(i.logEventCut(o,e.element,t.purpose),Bg.complete()):pe(e.element).fold(function(){return i.logNoParent(o,e.element,t.purpose),Bg.complete()},function(n){return i.logEventResponse(o,e.element,t.purpose),Bg.resume(n)})})}function rg(){var u={};return{registerId:function(r,i,n){Ee(n,function(n,e){var t,o=void 0!==u[e]?u[e]:{};o[i]={cHandler:J.apply(void 0,[(t=n).handler].concat(r)),purpose:t.purpose},u[e]=o})},unregisterId:function(t){Ee(u,function(n,e){dt(n,t)&&delete n[t]})},filterByType:function(n){return _e(u,n).map(function(n){return Me(n,function(n,e){return{id:e,descHandler:n}})}).getOr([])},find:function(r,n,c){return _e(u,n).bind(function(o){return e=r,t=(n=function(n){return e=o,ba(t=n).bind(function(n){return _e(e,n)}).map(function(n){return{element:t,descHandler:n}});var e,t})(i=c),u=Oo(e),t.orThunk(function(){return u(i)?mn.none():function(n){for(var e=i.dom,t=Oo(u);e.parentNode;){var e=e.parentNode,o=fe.fromDom(e),r=n(o);if(r.isSome())return r;if(t(o))break}return mn.none()}(n)});var i,n,e,t,u})}}}function ig(){function r(n){ba(n.element).each(function(n){delete u[n],i.unregisterId(n)})}var i=rg(),u={};return{find:function(n,e,t){return i.find(n,e,t)},filter:function(n){return i.filterByType(n)},register:function(n){var t,o=ba((t=n).element).getOrThunk(function(){return n=t.element,e=Gu(Us+"uid-"),Xs(n,e),e;var n,e});Re(u,o)&&function(n){var e=u[o];if(e!==n)throw new Error('The tagId "'+o+'" is already used by: '+$o(e.element)+"\nCannot use it for: "+$o(n.element)+"\nThe conflicting element is"+(rt(e.element)?" ":" not ")+"already in the DOM");r(n)}(n),i.registerId([n],o,n.events),u[o]=n},unregister:r,getById:function(n){return _e(u,n)}}}cm.ltr,cm.rtl;function ug(n,e,t,o,r){var i=tg(t,o);return Ag(n,e,t,o,i,r)}var cg,ag,sg,fg=function(n,e,t,o){return{start:n,soffset:e,finish:t,foffset:o}},lg=(cg=qe,{get:function(n){if(!cg(n))throw new Error("Can only get text value of a text node");return ag(n).getOr("")},getOption:ag=function(n){return cg(n)?mn.from(n.dom.nodeValue):mn.none()},set:function(n,e){if(!cg(n))throw new Error("Can only set raw text value of a text node");n.dom.nodeValue=e}}),dg=Jt([{before:["element"]},{on:["element","offset"]},{after:["element"]}]),mg={before:dg.before,on:dg.on,after:dg.after,cata:function(n,e,t,o){return n.fold(e,t,o)},getStart:function(n){return n.fold(K,K,K)}},gg=Jt([{domRange:["rng"]},{relative:["startSitu","finishSitu"]},{exact:["start","soffset","finish","foffset"]}]),pg={domRange:gg.domRange,relative:gg.relative,exact:gg.exact,exactFromRange:function(n){return gg.exact(n.start,n.soffset,n.finish,n.foffset)},getWin:function(n){var e=n.match({domRange:function(n){return fe.fromDom(n.startContainer)},relative:function(n,e){return mg.getStart(n)},exact:function(n,e,t,o){return n}});return fe.fromDom(ge(e).dom.defaultView)},range:fg},hg=(sg=hm,function(e){return e.getWin.getOrThunk(function(){var n=bm(e);return function(){return sg(n)}})()}),vg="data-ephox-mobile-fullscreen-style",bg="position:absolute!important;",yg="top:0!important;left:0!important;margin:0!important;padding:0!important;width:100%!important;height:100%!important;overflow:visible!important;",xg=Fn().os.isAndroid(),wg=6<=Fn().os.version.major,Sg="data-"+ci("last-outer-height"),Og=w({unbind:Y}),kg=lo([Gt("editor",[Lt("getFrame"),Ut("getBody"),Ut("getDoc"),Ut("getWin"),Ut("getSelection"),Ut("setSelection"),Ut("clearSelection"),Ut("cursorSaver"),Ut("onKeyup"),Ut("onNodeChanged"),Ut("getCursorBox"),Lt("onDomChanged"),Yt("onTouchContent",Y),Yt("onTapContent",Y),Yt("onTouchToolstrip",Y),Yt("onScrollToCursor",Og),Yt("onScrollToElement",Og),Yt("onToEditing",Og),Yt("onToReading",Og),Yt("onToolbarScrollStart",K)]),Lt("socket"),Lt("toolstrip"),Lt("dropup"),Lt("toolbar"),Lt("container"),Lt("alloy"),vo("win",function(n){return me(n.socket).dom.defaultView}),vo("body",function(n){return fe.fromDom(n.socket.dom.ownerDocument.body)}),Yt("translate",K),Yt("setReadOnly",Y),Yt("readOnlyOnInit",x)]),Tg=w([Lt("dom"),Yt("shell",!0),ju("toolbarBehaviours",[jd])]),Cg=w([Hs({name:"groups",overrides:function(){return{behaviours:or([jd.config({})])}}})]),Eg=Sa({name:"Toolbar",configFields:Tg(),partFields:Cg(),factory:function(o,n,e,t){var r=o.shell?{behaviours:[jd.config({})],components:[]}:{behaviours:[],components:n};return{uid:o.uid,dom:o.dom,components:r.components,behaviours:Lu(o.toolbarBehaviours,r.behaviours),apis:{setGroups:function(n,e){var t;t=n,(o.shell?mn.some(t):ma(t,o,"groups")).fold(function(){throw console.error("Toolbar was defined to not be a shell, but no groups container was specified in components"),new Error("Toolbar was defined to not be a shell, but no groups container was specified in components")},function(n){jd.set(n,e)})}},domModification:{attributes:{role:"group"}}}},apis:{setGroups:function(n,e,t){n.setGroups(e,t)}}}),Dg=w([Lt("items"),Gt("markers",Z(["itemSelector"],Lt)),ju("tgroupBehaviours",[jc])]),Mg=w([Ps({name:"items",unit:"item"})]),_g=Sa({name:"ToolbarGroup",configFields:Dg(),partFields:Mg(),factory:function(n,e,t,o){return{uid:n.uid,dom:n.dom,components:e,behaviours:Lu(n.tgroupBehaviours,[jc.config({mode:"flow",selector:n.markers.itemSelector})]),domModification:{attributes:{role:"toolbar"}}}}}),Rg="data-"+ci("horizontal-scroll"),Fg=Object.freeze({__proto__:null,refresh:function(n,e,t){var o;t.isExpanded()&&(Xr(n.element,$m(e)),o=Gm(e,n.element),$r(n.element,$m(e),o))},grow:function(n,e,t){t.isExpanded()||Km(n,e,t)},shrink:function(n,e,t){t.isExpanded()&&Ym(n,e,t)},immediateShrink:function(n,e,t){t.isExpanded()&&qm(n,e,t)},hasGrown:function(n,e,t){return t.isExpanded()},hasShrunk:function(n,e,t){return t.isCollapsed()},isGrowing:Jm,isShrinking:Qm,isTransitioning:function(n,e,t){return Jm(n,e)||Qm(n,e)},toggleGrow:function(n,e,t){(t.isExpanded()?Ym:Km)(n,e,t)},disableTransitions:Um}),Ig=Object.freeze({__proto__:null,exhibit:function(n,e,t){return Io(e.expanded?{classes:[e.openClass],styles:{}}:{classes:[e.closedClass],styles:yo(e.dimension.property,"0px")})},events:function(t,o){return qo([Mo(Wn())(function(n,e){e.event.raw.propertyName===t.dimension.property&&(Um(n,t),o.isExpanded()&&Xr(n.element,t.dimension.property),(o.isExpanded()?t.onGrown:t.onShrunk)(n))})])}}),Vg=Ao({fields:[Lt("closedClass"),Lt("openClass"),Lt("shrinkingClass"),Lt("growingClass"),Ut("getAnimationRoot"),kr("onShrunk"),kr("onStartShrink"),kr("onGrown"),kr("onStartGrow"),Yt("expanded",!1),$t("dimension",jt("property",{width:[Dr("property","width"),Dr("getDimension",function(n){return Ba(n)+"px"})],height:[Dr("property","height"),Dr("getDimension",function(n){return Kr(n)+"px"})]}))],name:"sliding",active:Ig,apis:Fg,state:Object.freeze({__proto__:null,init:function(n){var e=No(n.expanded);return tr({isExpanded:function(){return!0===e.get()},isCollapsed:function(){return!1===e.get()},setCollapsed:J(e.set,!1),setExpanded:J(e.set,!0),readState:function(){return"expanded: "+e.get()}})}})}),Bg=Jt([{stopped:[]},{resume:["element"]},{complete:[]}]),Ag=function(e,t,o,n,r,i){return og(e,t,o,n,r,i).fold(x,function(n){return Ag(e,t,o,n,r,i)},S)},Ng=function(t){function o(e){return pe(t.element).fold(x,function(n){return un(e,n)})}function s(n,e){return i.find(o,n,e)}function r(e){M(i.filter(Qn()),function(n){dl(n.descHandler)(e)})}var i=ig(),n=eg(t.element,{triggerEvent:function(e,t){return vr(e,t.target,function(n){return ug(s,e,t,t.target,n)})}}),u={debugInfo:w("real"),triggerEvent:function(e,t,o){vr(e,t,function(n){return ug(s,e,o,t,n)})},triggerFocus:function(c,a){ba(c).fold(function(){Ho(c)},function(n){vr(Yn(),c,function(n){var e,t,o=s,r=Yn(),i=n,u=tg(e={originator:a,kill:Y,prevent:Y,target:c},t=c);return og(o,r,e,t,u,i),!1})})},triggerEscape:function(n,e){u.triggerEvent("keydown",n.element,e.event)},getByUid:function(n){return g(n)},getByDom:function(n){return p(n)},build:Td,addToGui:function(n){a(n)},removeFromGui:function(n){f(n)},addToWorld:function(n){e(n)},removeFromWorld:function(n){c(n)},broadcast:function(n){l(n)},broadcastOn:function(n,e){d(n,e)},broadcastEvent:function(n,e){m(n,e)},isConnected:x},e=function(n){n.connect(u),qe(n.element)||(i.register(n),M(n.components(),e),u.triggerEvent(oe(),n.element,{target:n.element}))},c=function(n){qe(n.element)||(M(n.components(),c),i.unregister(n)),n.disconnect()},a=function(n){at(t,n,Qe)},f=function(n){Ce(n)},l=function(n){r({universal:!0,data:n})},d=function(n,e){r({universal:!1,channels:n,data:e})},m=function(n,e){var t,o,r=i.filter(n);return o={stop:function(){t.set(!0)},cut:Y,isStopped:(t=No(!1)).get,isCut:S,event:e,setSource:h("Cannot set source of a broadcasted event"),getSource:h("Cannot get source of a broadcasted event")},M(r,function(n){dl(n.descHandler)(o)}),o.isStopped()},g=function(n){return i.getById(n).fold(function(){return ht.error(new Error('Could not find component with uid: "'+n+'" in system.'))},ht.value)},p=function(n){var e=ba(n).getOr("not found");return g(e)};return e(t),{root:t,element:t.element,destroy:function(){n.unbind(),Ze(t.element)},add:a,remove:f,getByUid:g,getByDom:p,addToWorld:e,removeFromWorld:c,broadcast:l,broadcastOn:d,broadcastEvent:m}},Hg=ci("readonly-mode"),Pg=ci("edit-mode");function zg(n){var e=Td(td.sketch({dom:{classes:[ci("outer-container")].concat(n.classes)},containerBehaviours:or([cr.config({alpha:Hg,omega:Pg})])}));return Ng(e)}function jg(n,e){var t=fe.fromTag("input");Gr(t,{opacity:"0",position:"absolute",top:"-1000px",left:"-1000px"}),Qe(n,t),Ho(t),e(t),Ze(t)}function Lg(n){var e,t,o=n.getSelection();0<o.rangeCount&&(e=o.getRangeAt(0),(t=n.document.createRange()).setStart(e.startContainer,e.startOffset),t.setEnd(e.endContainer,e.endOffset),o.removeAllRanges(),o.addRange(t))}function $g(n,e){zo().each(function(n){un(n,e)||Po(n)}),n.focus(),Ho(fe.fromDom(n.document.body)),Lg(n)}function Gg(n,e,t,o){function r(){$g(e,o)}var i=Pl(t,"keydown",function(n){T(["input","textarea"],le(n.target))||r()});return{toReading:function(){jg(n,Po)},toEditing:r,onToolbarTouch:Y,destroy:function(){i.unbind()}}}function Ug(n){setTimeout(function(){throw n},0)}function Wg(n){var o,r,e=jl(n).isPortrait(),t=(o=n.screen.width,r=n.screen.height,z([{width:320,height:480,keyboard:{portrait:300,landscape:240}},{width:320,height:568,keyboard:{portrait:300,landscape:240}},{width:375,height:667,keyboard:{portrait:305,landscape:240}},{width:414,height:736,keyboard:{portrait:320,landscape:240}},{width:768,height:1024,keyboard:{portrait:320,landscape:400}},{width:1024,height:1366,keyboard:{portrait:380,landscape:460}}],function(n){return e=o<=n.width&&r<=n.height,t=n.keyboard,e?mn.some(t):mn.none();var e,t}).getOr({portrait:r/5,landscape:o/4})),i=e?t.portrait:t.landscape;return(e?n.screen.height:n.screen.width)-n.innerHeight>i?0:i}function Xg(n,e){var t=me(n).dom.defaultView;return Kr(n)+Kr(e)-Wg(t)}function qg(n,e,t){var o=Xg(e,t);$r(n,"padding-bottom",Kr(e)+Kr(t)-o+"px")}function Yg(n){return Em(n,lp)}function Kg(n,e){var t=Be(n,dp);return fp.fixed(n,t,e)}function Jg(n,e){return fp.scroller(n,e)}function Qg(n){var e=Yg(n);return("true"===Be(n,mp)?Jg:Kg)(n,e)}function Zg(n,e,t){var o=me(n).dom.defaultView.innerHeight;return Ie(n,gp,o+"px"),o-e-t}function np(n){var e=Wr(n,"top").getOr("0");return parseInt(e,10)}function ep(n){return parseInt(n.dom.scrollTop,10)}function tp(r,i){return ap(function(n){var e=J(ep,r);Ie(r,hp,e());var t=Math.abs(i-e()),o=Math.ceil(t/10);pp.animate(e,i,o,function(n,e){Em(r,hp)!==r.dom.scrollTop?e(r.dom.scrollTop):(r.dom.scrollTop=n,Ie(r,hp,n))},function(){r.dom.scrollTop=i,Ie(r,hp,i),n(i)},10)})}function op(n,e){$r(n,"top",e+Yg(n)+"px")}var rp,ip=function(n){function o(n){r()?i(n):e.push(n)}var t=mn.none(),e=[],r=function(){return t.isSome()},i=function(e){t.each(function(n){setTimeout(function(){e(n)},0)})};return n(function(n){r()||(t=mn.some(n),M(e,i),e=[])}),{get:o,map:function(t){return ip(function(e){o(function(n){e(t(n))})})},isReady:r}},up={nu:ip,pure:function(e){return ip(function(n){n(e)})}},cp=function(t){function n(n){t().then(n,Ug)}return{map:function(n){return cp(function(){return t().then(n)})},bind:function(e){return cp(function(){return t().then(function(n){return e(n).toPromise()})})},anonBind:function(n){return cp(function(){return t().then(function(){return n.toPromise()})})},toLazy:function(){return up.nu(n)},toCached:function(){var n=null;return cp(function(){return n=null===n?t():n})},toPromise:t,get:n}},ap=function(n){return cp(function(){return new Jl(n)})},sp=function(n){return cp(function(){return Jl.resolve(n)})},fp=Jt([{fixed:["element","property","offsetY"]},{scroller:["element","offsetY"]}]),lp="data-"+ci("position-y-fixed"),dp="data-"+ci("y-property"),mp="data-"+ci("scrolling"),gp="data-"+ci("last-window-height"),pp=(rp=null,{animate:function(r,i,u,c,e,n){function a(n){s=!0,e(n)}var s=!1;function f(n){um.clearInterval(rp),a(n)}um.clearInterval(rp),rp=um.setInterval(function(){var t=r(),n=t,e=i,o=u;(Math.abs(n-e)<=o?mn.none():n<e?mn.some(n+o):mn.some(n-o)).fold(function(){um.clearInterval(rp),a(i)},function(n){var e;c(n,f),s||((e=r())!==n||Math.abs(e-i)>Math.abs(t-i))&&(um.clearInterval(rp),a(i))})},n)}}),hp="data-"+ci("last-scroll-top");function vp(n,l){return n.fold(function(n,e,t){return $r(n,e,l+(o=t)+"px"),sp(o);var o},function(n,e){return r=l+(o=e),i=Wr(t=n,"top").getOr(o),u=r-parseInt(i,10),c=t.dom.scrollTop+u,a=t,s=c,f=r,ap(function(n){var e=J(ep,a);pp.animate(e,s,15,function(n){a.dom.scrollTop=n,$r(a,"top",np(a)+15+"px")},function(){a.dom.scrollTop=s,$r(a,"top",f+"px"),n(s)},10)});var t,o,r,i,u,c,a,s,f})}function bp(n,e){var u,t=Z(Jr(n,"["+lp+"]"),Qg),o=Z(t,function(n){return vp(n,e)});return u=o,ap(function(o){var r=[],i=0;0===u.length?o([]):M(u,function(n,e){var t;n.get((t=e,function(n){r[t]=n,++i>=u.length&&o(r)}))})})}function yp(n){var o,r,i,u,e,t,c,a,s,f,l,d,m,g,p,h,v,b,y,x=n.cWin,w=n.ceBody,S=n.socket,O=n.toolstrip,k=n.contentElement,T=n.keyboardType,C=n.outerWindow,E=n.dropup,D=n.outerBody,M=(r=w,i=O,u=E,m=me(o=S).dom.defaultView,d=Be(l=i,"style"),Gr(l,{position:"absolute",top:"0px"}),Ie(l,lp,"0px"),Ie(l,dp,"top"),g={restore:function(){Ie(l,"style",d||""),He(l,lp),He(l,dp)}},p=Kr(i),h=Kr(u),a=Zg(o,c=p,h),f=Be(s=o,"style"),_l(s),Gr(s,{position:"absolute",height:a+"px",width:"100%",top:c+"px"}),Ie(s,lp,c+"px"),Ie(s,mp,"true"),Ie(s,dp,"top"),v={restore:function(){Rl(s),Ie(s,"style",f||""),He(s,lp),He(s,mp),He(s,dp)}},t=Be(e=u,"style"),Gr(e,{position:"absolute",bottom:"0px"}),Ie(e,lp,"0px"),Ie(e,dp,"bottom"),b={restore:function(){Ie(e,"style",t||""),He(e,lp),He(e,dp)}},y=!0,qg(r,o,u),{setViewportOffset:function(n){Ie(o,lp,n+"px"),I()},isExpanding:F,isShrinking:Q(F),refresh:I,restore:function(){y=!1,g.restore(),v.restore(),b.restore()}}),_=T(D,x,ke(),k),R=Ll(C,{onChange:Y,onReady:M.refresh});function F(){var n=m.innerHeight;return Em(o,gp)<n}function I(){var n,e,t;y&&(n=Kr(i),e=Kr(u),t=Zg(o,n,e),Ie(o,lp,n+"px"),$r(o,"height",t+"px"),qg(r,o,u))}R.onAdjustment(function(){M.refresh()});function V(){q.clear()}var B,A,N,H,P,z,j,L,$,G,U,W=Pl(fe.fromDom(C),"resize",function(){M.isExpanding()&&M.refresh()}),X=(B=O,A=S,N=D,H=C,P=M,z=x,j=function(n){return t=A,o=n,r=me(e=B).dom.defaultView,ap(function(n){op(e,o),op(t,o),r.scrollTo(0,o),n(o)});var e,t,o,r},L=No(up.pure({})),$={start:function(e){var n=up.nu(function(n){return j(e).get(n)});L.set(n)},idle:function(n){L.get().get(function(){n()})}},G=Vm(function(){$.idle(function(){bp(N,H.pageYOffset).get(function(){var n=_m(z);mn.from(n[0]).bind(function(n){var e=n.top-A.dom.scrollTop;return e>H.innerHeight+5||e<-5?mn.some({top:e,bottom:e+n.height}):mn.none()}).each(function(n){A.dom.scrollTop=A.dom.scrollTop+n.top}),$.start(0),P.refresh()})})},1e3),U=Pl(fe.fromDom(H),"scroll",function(){H.pageYOffset<0||G.throttle()}),bp(N,H.pageYOffset).get(K),{unbind:U.unbind}),q=function(e,t){var n=e.document,o=fe.fromTag("div");function r(n){var e=fe.fromTag("span");return pl(e,[ci("layer-editor"),ci("unfocused-selection")]),Gr(e,{left:n.left+"px",top:n.top+"px",width:n.width+"px",height:n.height+"px"}),e}je(o,ci("unfocused-selections")),Qe(fe.fromDom(n.documentElement),o);var i=Pl(o,"touchstart",function(n){n.prevent(),$g(e,t),u()}),u=function(){we(o)};return{update:function(){u();var n=Z(_m(e),r);xe(o,n)},isActive:function(){return 0<Je(o).length},destroy:function(){i.unbind(),Ze(o)},clear:u}}(x,k);return{toEditing:function(){_.toEditing(),V()},toReading:function(){_.toReading()},onToolbarTouch:function(n){_.onToolbarTouch()},refreshSelection:function(){q.isActive()&&q.update()},clearSelection:V,highlightSelection:function(){q.update()},scrollIntoView:function(n,e){var t,o=x,r=n,i=e,u=Xg(t=S,E),c=J(Lg,o);u<r||u<i?tp(t,t.dom.scrollTop-u+i).get(c):r<0&&tp(t,t.dom.scrollTop+r).get(c)},updateToolbarPadding:Y,setViewportOffset:function(n){var i,u;M.setViewportOffset(n),i=S,u=n,ap(function(n){function e(n){$r(i,"top",n+"px")}var t=J(np,i),o=Math.abs(u-t()),r=Math.ceil(o/10);pp.animate(t,u,r,e,function(){e(u),n(u)},10)}).get(K)},syncHeight:function(){$r(k,"height",k.dom.contentWindow.document.body.scrollHeight+"px")},refreshStructure:M.refresh,destroy:function(){M.restore(),R.destroy(),X.unbind(),W.unbind(),_.destroy(),q.destroy(),jg(ke(),Po)}}}function xp(g,n){var p=wm(),h=cu(),v=cu(),b=uu(),y=uu();return{enter:function(){n.hide();var m=fe.fromDom(document);xm(g.editor).each(function(n){var e,t,o,r,i,u,c,a;function s(){o.run(function(n){n.refreshSelection()})}function f(n,e){var t=n-i.dom.scrollTop;o.run(function(n){n.scrollIntoView(t,t+e)})}function l(){o.run(function(n){n.clearSelection()})}function d(){t.getCursorBox().each(function(n){f(n.top,n.height)}),o.run(function(n){n.syncHeight()})}h.set({socketHeight:Wr(g.socket,"height"),iframeHeight:Wr(n.frame,"height"),outerScroll:document.body.scrollTop}),v.set({exclusives:(e="."+Zd,Pl(m,"touchmove",function(n){vi(n.target,e).filter(Nm).fold(function(){n.prevent()},Y)}))}),je(g.container,ci("fullscreen-maximized")),Sm(g.container,n.body),p.maximize(),$r(g.socket,"overflow","scroll"),$r(g.socket,"-webkit-overflow-scrolling","touch"),Ho(n.body),b.set(yp({cWin:n.win,ceBody:n.body,socket:g.socket,toolstrip:g.toolstrip,dropup:g.dropup.element,contentElement:n.frame,outerBody:g.body,outerWindow:g.win,keyboardType:Gg})),b.run(function(n){n.syncHeight()}),y.set((t=n,o=b,r=g.toolstrip,i=g.socket,g.dropup,u=Cm(t),c=Vm(d,300),a=[t.onKeyup(function(){l(),c.throttle()}),t.onNodeChanged(s),t.onDomChanged(c.throttle),t.onDomChanged(s),t.onScrollToCursor(function(n){n.preventDefault(),c.throttle()}),t.onScrollToElement(function(n){n.element,f(o,i)}),t.onToEditing(function(){o.run(function(n){n.toEditing()})}),t.onToReading(function(){o.run(function(n){n.toReading()})}),Pl(t.doc,"touchend",function(n){un(t.html,n.target)||un(t.body,n.target)}),Pl(r,"transitionend",function(n){var e;"height"===n.raw.propertyName&&(e=Kr(r),o.run(function(n){n.setViewportOffset(e)}),s(),d())}),zl(r,"touchstart",function(n){var e;o.run(function(n){n.highlightSelection()}),e=n,o.run(function(n){n.onToolbarTouch(e)}),t.onTouchToolstrip()}),Pl(t.body,"touchstart",function(n){l(),t.onTouchContent(),u.fireTouchstart(n)}),u.onTouchmove(),u.onTouchend(),Pl(t.body,"click",function(n){n.kill()}),Pl(r,"touchmove",function(){t.onToolbarScrollStart()})],{destroy:function(){M(a,function(n){n.unbind()})}}))})},refreshStructure:function(){b.run(function(n){n.refreshStructure()})},exit:function(){p.restore(),y.clear(),b.clear(),n.show(),h.on(function(n){n.socketHeight.each(function(n){$r(g.socket,"height",n)}),n.iframeHeight.each(function(n){$r(g.editor.getFrame(),"height",n)}),document.body.scrollTop=n.scrollTop}),h.clear(),v.on(function(n){n.exclusives.unbind()}),v.clear(),Le(g.container,ci("fullscreen-maximized")),Om(),Rl(g.toolbar),Xr(g.socket,"overflow"),Xr(g.socket,"-webkit-overflow-scrolling"),Po(g.editor.getFrame()),xm(g.editor).each(function(n){n.clearSelection()})}}}function wp(n,e,t){n.system.broadcastOn([dr],{command:e,state:t})}function Sp(e){return function(){function n(){e._skinLoaded=!0,e.fire("SkinLoaded")}e.initialized?n():e.on("init",n)}}var Op=tinymce.util.Tools.resolve("tinymce.EditorManager"),kp="toReading",Tp="toEditing";sr.add("mobile",function(E){return{getNotificationManagerImpl:function(){return{open:w({progressBar:{value:Y},close:Y,text:Y,getEl:w(null),moveTo:Y,moveRel:Y,settings:{}}),close:Y,reposition:Y,getArgs:w({})}},renderUI:function(){var n,e,t=E.getElement(),o={content:(n=mn.from(E.getParam("skin_url")).getOrThunk(function(){return Op.baseURL+"/skins/ui/oxide"}))+"/content.mobile.min.css",ui:n+"/skin.mobile.min.css"};function r(){E.fire("ScrollIntoView")}!1===E.getParam("skin")==0?(e=ar.DOM.styleSheetLoader,E.contentCSS.push(o.content),e.load(o.ui,Sp(E)),E.on("remove",function(){return e.unload(o.ui)})):Sp(E)();var i,u,c,a,s,f,l,d,m,g,p,h,v,b,y,x,w=Fn().os.isAndroid()?(i=r,u=zg({classes:[ci("android-container")]}),c=Hm(),a=uu(),s=Pm(a),f=zm(),l=Zm(Y,i),u.add(c.wrapper),u.add(f),u.add(l.component),{system:u,element:u.element,init:function(n){a.set(Am(n))},exit:function(){a.run(function(n){n.exit(),jd.remove(f,s)})},setToolbarGroups:function(n){var e=c.createGroups(n);c.setGroups(e)},setContextToolbar:function(n){var e=c.createGroups(n);c.setContextToolbar(e)},focusToolbar:function(){c.focus()},restoreToolbar:function(){c.restoreToolbar()},updateMode:function(n){jm(f,s,n,u.root)},socket:f,dropup:l}):(m=r,g=zg({classes:[ci("ios-container")]}),p=Hm(),h=uu(),v=Pm(h),b=zm(),y=Zm(function(){h.run(function(n){n.refreshStructure()})},m),g.add(p.wrapper),g.add(b),g.add(y.component),{system:g,element:g.element,init:function(r){h.set(function(){var n=zt("Getting IosWebapp schema",kg,r);$r(n.toolstrip,"width","100%"),$r(n.container,"position","relative");var e=Td(Bm(function(){n.setReadOnly(n.readOnlyOnInit()),o.enter()},n.translate));n.alloy.add(e);var t={show:function(){n.alloy.add(e)},hide:function(){n.alloy.remove(e)}},o=xp(n,t);return{setReadOnly:n.setReadOnly,refreshStructure:o.refreshStructure,enter:o.enter,exit:o.exit,destroy:Y}}())},exit:function(){h.run(function(n){jd.remove(b,v),n.exit()})},setToolbarGroups:function(n){var e=p.createGroups(n);p.setGroups(e)},setContextToolbar:function(n){var e=p.createGroups(n);p.setContextToolbar(e)},focusToolbar:function(){p.focus()},restoreToolbar:function(){p.restoreToolbar()},updateMode:function(n){jm(b,v,n,g.root)},socket:b,dropup:y}),S=fe.fromDom(t);function O(n,e,t,o){!1===o&&E.selection.collapse();var r,i,u,c=(r=e,i=t,{readOnly:(u=n.get()).backToMask.concat(r.get()),main:u.backToMask.concat(i.get())});w.setToolbarGroups(!0===o?c.readOnly:c.main),E.setMode(!0===o?"readonly":"design"),E.fire(!0===o?kp:Tp),w.updateMode(o)}function k(n,e){return E.on(n,e),{unbind:function(){E.off(n)}}}d=w.system,be(S,(x=d).element),M(Je(x.element),function(n){x.getByDom(n).each(ct)});var T=t.ownerDocument.defaultView,C=Ll(T,{onChange:function(){var n,e,t;w.system.broadcastOn([mr],{width:(n=T,e=Fn().os.isiOS(),t=jl(n).isPortrait(),e&&!t?n.screen.height:n.screen.width)})},onReady:Y});return E.on("init",function(){w.init({editor:{getFrame:function(){return fe.fromDom(E.contentAreaContainer.querySelector("iframe"))},onDomChanged:function(){return{unbind:Y}},onToReading:function(n){return k(kp,n)},onToEditing:function(n){return k(Tp,n)},onScrollToCursor:function(e){return E.on("ScrollIntoView",function(n){e(n)}),{unbind:function(){E.off("ScrollIntoView"),C.destroy()}}},onTouchToolstrip:function(){i()},onTouchContent:function(){jo(fe.fromDom(E.editorContainer.querySelector("."+ci("toolbar")))).bind(function(n){return w.system.getByDom(n).toOptional()}).each(q),w.restoreToolbar(),i()},onTapContent:function(n){var e=n.target;"img"===le(e)?(E.selection.select(e.dom),n.kill()):"a"===le(e)&&w.system.getByDom(fe.fromDom(E.editorContainer)).each(function(n){cr.isAlpha(n)&&function(n){var e=document.createElement("a");e.target="_blank",e.href=n.href,e.rel="noreferrer noopener";var t=document.createEvent("MouseEvents");t.initMouseEvent("click",!0,!0,window,0,0,0,0,0,!1,!1,!1,!1,0,null),document.body.appendChild(e),e.dispatchEvent(t),document.body.removeChild(e)}(e.dom)})}},container:fe.fromDom(E.editorContainer),socket:fe.fromDom(E.contentAreaContainer),toolstrip:fe.fromDom(E.editorContainer.querySelector("."+ci("toolstrip"))),toolbar:fe.fromDom(E.editorContainer.querySelector("."+ci("toolbar"))),dropup:w.dropup,alloy:w.system,translate:Y,setReadOnly:function(n){O(d,l,f,n)},readOnlyOnInit:function(){return!1}});var t,n,o,r,e,i=function(){w.dropup.disappear(function(){w.system.broadcastOn([gr],{})})},u={label:"The first group",scrollable:!1,items:[nf("back",function(){E.selection.collapse(),w.exit()},{},E)]},c={label:"Back to read only",scrollable:!1,items:[nf("readonly-back",function(){O(d,l,f,!0)},{},E)]},a=Al(w,E),s={label:"The extra group",scrollable:!1,items:[]},f=No([{label:"the action group",scrollable:!0,items:(t=a,e=E.getParam("toolbar",lr,"array"),n=(D(e)?om:Bl)(e),o={},B(n,function(n){var e=!Re(o,n)&&Re(t,n)&&t[n].isSupported()?[t[n].sketch()]:[];return o[n]=!0,e}))},s]),l=No([{label:"The read only mode group",scrollable:!0,items:[]},s]),d=No({backToMask:[u],backToReadOnly:[c]}),m=w;M(st((r=E).formatter.get()),function(e){r.formatter.formatChanged(e,function(n){wp(m,e,n)})}),M(["ul","ol"],function(t){r.selection.selectorChanged(t,function(n,e){wp(m,t,n)})})}),E.on("remove",function(){w.exit()}),E.on("detach",function(){var e=w.system;M(Je(e.element),function(n){e.getByDom(n).each(ut)}),Ze(e.element),w.system.destroy()}),{iframeContainer:w.socket.element.dom,editorContainer:w.element.dom}}}})}();
\ No newline at end of file
diff --git a/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.min.js.gz b/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.min.js.gz
new file mode 100644
index 0000000..f02de72
Binary files /dev/null and b/ant-design-vue-jeecg/public/tinymce/themes/mobile/theme.min.js.gz differ
diff --git a/ant-design-vue-jeecg/public/tinymce/themes/silver/index.js b/ant-design-vue-jeecg/public/tinymce/themes/silver/index.js
new file mode 100644
index 0000000..09caa86
--- /dev/null
+++ b/ant-design-vue-jeecg/public/tinymce/themes/silver/index.js
@@ -0,0 +1,7 @@
+// Exports the "silver" theme for usage with module loaders
+// Usage:
+//   CommonJS:
+//     require('tinymce/themes/silver')
+//   ES2015:
+//     import 'tinymce/themes/silver'
+require('./theme.js');
\ No newline at end of file
diff --git a/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.js b/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.js
new file mode 100644
index 0000000..a84ffb1
--- /dev/null
+++ b/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.js
@@ -0,0 +1,34078 @@
+/**
+ * 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.10.7 (2022-12-06)
+ */
+(function () {
+    'use strict';
+
+    var typeOf = function (x) {
+      var t = typeof x;
+      if (x === null) {
+        return 'null';
+      } else if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
+        return 'array';
+      } else if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
+        return 'string';
+      } else {
+        return t;
+      }
+    };
+    var isType$1 = function (type) {
+      return function (value) {
+        return typeOf(value) === type;
+      };
+    };
+    var isSimpleType = function (type) {
+      return function (value) {
+        return typeof value === type;
+      };
+    };
+    var eq$1 = function (t) {
+      return function (a) {
+        return t === a;
+      };
+    };
+    var isString = isType$1('string');
+    var isObject = isType$1('object');
+    var isArray = isType$1('array');
+    var isNull = eq$1(null);
+    var isBoolean = isSimpleType('boolean');
+    var isUndefined = eq$1(undefined);
+    var isNullable = function (a) {
+      return a === null || a === undefined;
+    };
+    var isNonNullable = function (a) {
+      return !isNullable(a);
+    };
+    var isFunction = isSimpleType('function');
+    var isNumber = isSimpleType('number');
+    var isArrayOf = function (value, pred) {
+      if (isArray(value)) {
+        for (var i = 0, len = value.length; i < len; ++i) {
+          if (!pred(value[i])) {
+            return false;
+          }
+        }
+        return true;
+      }
+      return false;
+    };
+
+    var noop = function () {
+    };
+    var noarg = function (f) {
+      return function () {
+        return f();
+      };
+    };
+    var compose = function (fa, fb) {
+      return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return fa(fb.apply(null, args));
+      };
+    };
+    var compose1 = function (fbc, fab) {
+      return function (a) {
+        return fbc(fab(a));
+      };
+    };
+    var constant$1 = function (value) {
+      return function () {
+        return value;
+      };
+    };
+    var identity$1 = function (x) {
+      return x;
+    };
+    var tripleEquals = function (a, b) {
+      return a === b;
+    };
+    function curry(fn) {
+      var initialArgs = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+        initialArgs[_i - 1] = arguments[_i];
+      }
+      return function () {
+        var restArgs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          restArgs[_i] = arguments[_i];
+        }
+        var all = initialArgs.concat(restArgs);
+        return fn.apply(null, all);
+      };
+    }
+    var not = function (f) {
+      return function (t) {
+        return !f(t);
+      };
+    };
+    var die = function (msg) {
+      return function () {
+        throw new Error(msg);
+      };
+    };
+    var never = constant$1(false);
+    var always = constant$1(true);
+
+    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];
+          for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+      var t = {};
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+          t[p] = s[p];
+      if (s != null && typeof Object.getOwnPropertySymbols === 'function')
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+            t[p[i]] = s[p[i]];
+        }
+      return t;
+    }
+    function __spreadArray(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    var none = function () {
+      return NONE;
+    };
+    var NONE = function () {
+      var call = function (thunk) {
+        return thunk();
+      };
+      var id = identity$1;
+      var me = {
+        fold: function (n, _s) {
+          return n();
+        },
+        isSome: never,
+        isNone: always,
+        getOr: id,
+        getOrThunk: call,
+        getOrDie: function (msg) {
+          throw new Error(msg || 'error: getOrDie called on none.');
+        },
+        getOrNull: constant$1(null),
+        getOrUndefined: constant$1(undefined),
+        or: id,
+        orThunk: call,
+        map: none,
+        each: noop,
+        bind: none,
+        exists: never,
+        forall: always,
+        filter: function () {
+          return none();
+        },
+        toArray: function () {
+          return [];
+        },
+        toString: constant$1('none()')
+      };
+      return me;
+    }();
+    var some = function (a) {
+      var constant_a = constant$1(a);
+      var self = function () {
+        return me;
+      };
+      var bind = function (f) {
+        return f(a);
+      };
+      var me = {
+        fold: function (n, s) {
+          return s(a);
+        },
+        isSome: always,
+        isNone: never,
+        getOr: constant_a,
+        getOrThunk: constant_a,
+        getOrDie: constant_a,
+        getOrNull: constant_a,
+        getOrUndefined: constant_a,
+        or: self,
+        orThunk: self,
+        map: function (f) {
+          return some(f(a));
+        },
+        each: function (f) {
+          f(a);
+        },
+        bind: bind,
+        exists: bind,
+        forall: bind,
+        filter: function (f) {
+          return f(a) ? me : NONE;
+        },
+        toArray: function () {
+          return [a];
+        },
+        toString: function () {
+          return 'some(' + a + ')';
+        }
+      };
+      return me;
+    };
+    var from$1 = function (value) {
+      return value === null || value === undefined ? NONE : some(value);
+    };
+    var Optional = {
+      some: some,
+      none: none,
+      from: from$1
+    };
+
+    var nativeSlice = Array.prototype.slice;
+    var nativeIndexOf = Array.prototype.indexOf;
+    var nativePush = Array.prototype.push;
+    var rawIndexOf = function (ts, t) {
+      return nativeIndexOf.call(ts, t);
+    };
+    var indexOf = function (xs, x) {
+      var r = rawIndexOf(xs, x);
+      return r === -1 ? Optional.none() : Optional.some(r);
+    };
+    var contains$2 = function (xs, x) {
+      return rawIndexOf(xs, x) > -1;
+    };
+    var exists = function (xs, pred) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    var range$2 = function (num, f) {
+      var r = [];
+      for (var i = 0; i < num; i++) {
+        r.push(f(i));
+      }
+      return r;
+    };
+    var chunk$1 = function (array, size) {
+      var r = [];
+      for (var i = 0; i < array.length; i += size) {
+        var s = nativeSlice.call(array, i, i + size);
+        r.push(s);
+      }
+      return r;
+    };
+    var map$2 = function (xs, f) {
+      var len = xs.length;
+      var r = new Array(len);
+      for (var i = 0; i < len; i++) {
+        var x = xs[i];
+        r[i] = f(x, i);
+      }
+      return r;
+    };
+    var each$1 = function (xs, f) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        f(x, i);
+      }
+    };
+    var eachr = function (xs, f) {
+      for (var i = xs.length - 1; i >= 0; i--) {
+        var x = xs[i];
+        f(x, i);
+      }
+    };
+    var partition$3 = function (xs, pred) {
+      var pass = [];
+      var fail = [];
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        var arr = pred(x, i) ? pass : fail;
+        arr.push(x);
+      }
+      return {
+        pass: pass,
+        fail: fail
+      };
+    };
+    var filter$2 = function (xs, pred) {
+      var r = [];
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          r.push(x);
+        }
+      }
+      return r;
+    };
+    var foldr = function (xs, f, acc) {
+      eachr(xs, function (x, i) {
+        acc = f(acc, x, i);
+      });
+      return acc;
+    };
+    var foldl = function (xs, f, acc) {
+      each$1(xs, function (x, i) {
+        acc = f(acc, x, i);
+      });
+      return acc;
+    };
+    var findUntil = function (xs, pred, until) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          return Optional.some(x);
+        } else if (until(x, i)) {
+          break;
+        }
+      }
+      return Optional.none();
+    };
+    var find$5 = function (xs, pred) {
+      return findUntil(xs, pred, never);
+    };
+    var findIndex$1 = function (xs, pred) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          return Optional.some(i);
+        }
+      }
+      return Optional.none();
+    };
+    var flatten = function (xs) {
+      var r = [];
+      for (var i = 0, len = xs.length; i < len; ++i) {
+        if (!isArray(xs[i])) {
+          throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
+        }
+        nativePush.apply(r, xs[i]);
+      }
+      return r;
+    };
+    var bind$3 = function (xs, f) {
+      return flatten(map$2(xs, f));
+    };
+    var forall = function (xs, pred) {
+      for (var i = 0, len = xs.length; i < len; ++i) {
+        var x = xs[i];
+        if (pred(x, i) !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var reverse = function (xs) {
+      var r = nativeSlice.call(xs, 0);
+      r.reverse();
+      return r;
+    };
+    var difference = function (a1, a2) {
+      return filter$2(a1, function (x) {
+        return !contains$2(a2, x);
+      });
+    };
+    var mapToObject = function (xs, f) {
+      var r = {};
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        r[String(x)] = f(x, i);
+      }
+      return r;
+    };
+    var pure$2 = function (x) {
+      return [x];
+    };
+    var sort = function (xs, comparator) {
+      var copy = nativeSlice.call(xs, 0);
+      copy.sort(comparator);
+      return copy;
+    };
+    var get$f = function (xs, i) {
+      return i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
+    };
+    var head = function (xs) {
+      return get$f(xs, 0);
+    };
+    var last$2 = function (xs) {
+      return get$f(xs, xs.length - 1);
+    };
+    var from = isFunction(Array.from) ? Array.from : function (x) {
+      return nativeSlice.call(x);
+    };
+    var findMap = function (arr, f) {
+      for (var i = 0; i < arr.length; i++) {
+        var r = f(arr[i], i);
+        if (r.isSome()) {
+          return r;
+        }
+      }
+      return Optional.none();
+    };
+
+    var keys = Object.keys;
+    var hasOwnProperty$1 = 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$1.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) {
+        return value$3(o);
+      };
+      var map = function (f) {
+        return value$3(f(o));
+      };
+      var mapError = function (_f) {
+        return value$3(o);
+      };
+      var each = function (f) {
+        f(o);
+      };
+      var bind = function (f) {
+        return f(o);
+      };
+      var fold = function (_, onValue) {
+        return onValue(o);
+      };
+      var exists = function (f) {
+        return f(o);
+      };
+      var forall = function (f) {
+        return f(o);
+      };
+      var toOptional = function () {
+        return Optional.some(o);
+      };
+      return {
+        isValue: always,
+        isError: never,
+        getOr: constant$1(o),
+        getOrThunk: constant$1(o),
+        getOrDie: constant$1(o),
+        or: or,
+        orThunk: orThunk,
+        fold: fold,
+        map: map,
+        mapError: mapError,
+        each: each,
+        bind: bind,
+        exists: exists,
+        forall: forall,
+        toOptional: toOptional
+      };
+    };
+    var error$1 = function (message) {
+      var getOrThunk = function (f) {
+        return f();
+      };
+      var getOrDie = function () {
+        return die(String(message))();
+      };
+      var or = identity$1;
+      var orThunk = function (f) {
+        return f();
+      };
+      var map = function (_f) {
+        return error$1(message);
+      };
+      var mapError = function (f) {
+        return error$1(f(message));
+      };
+      var bind = function (_f) {
+        return error$1(message);
+      };
+      var fold = function (onError, _) {
+        return onError(message);
+      };
+      return {
+        isValue: never,
+        isError: always,
+        getOr: identity$1,
+        getOrThunk: getOrThunk,
+        getOrDie: getOrDie,
+        or: or,
+        orThunk: orThunk,
+        fold: fold,
+        map: map,
+        mapError: mapError,
+        each: noop,
+        bind: bind,
+        exists: never,
+        forall: always,
+        toOptional: Optional.none
+      };
+    };
+    var fromOption = function (opt, err) {
+      return opt.fold(function () {
+        return error$1(err);
+      }, value$3);
+    };
+    var Result = {
+      value: value$3,
+      error: error$1,
+      fromOption: fromOption
+    };
+
+    var SimpleResultType;
+    (function (SimpleResultType) {
+      SimpleResultType[SimpleResultType['Error'] = 0] = 'Error';
+      SimpleResultType[SimpleResultType['Value'] = 1] = 'Value';
+    }(SimpleResultType || (SimpleResultType = {})));
+    var fold$1 = function (res, onError, onValue) {
+      return res.stype === SimpleResultType.Error ? onError(res.serror) : onValue(res.svalue);
+    };
+    var partition$2 = function (results) {
+      var values = [];
+      var errors = [];
+      each$1(results, function (obj) {
+        fold$1(obj, function (err) {
+          return errors.push(err);
+        }, function (val) {
+          return values.push(val);
+        });
+      });
+      return {
+        values: values,
+        errors: errors
+      };
+    };
+    var mapError = function (res, f) {
+      if (res.stype === SimpleResultType.Error) {
+        return {
+          stype: SimpleResultType.Error,
+          serror: f(res.serror)
+        };
+      } else {
+        return res;
+      }
+    };
+    var map = function (res, f) {
+      if (res.stype === SimpleResultType.Value) {
+        return {
+          stype: SimpleResultType.Value,
+          svalue: f(res.svalue)
+        };
+      } else {
+        return res;
+      }
+    };
+    var bind$1 = function (res, f) {
+      if (res.stype === SimpleResultType.Value) {
+        return f(res.svalue);
+      } else {
+        return res;
+      }
+    };
+    var bindError = function (res, f) {
+      if (res.stype === SimpleResultType.Error) {
+        return f(res.serror);
+      } else {
+        return res;
+      }
+    };
+    var svalue = function (v) {
+      return {
+        stype: SimpleResultType.Value,
+        svalue: v
+      };
+    };
+    var serror = function (e) {
+      return {
+        stype: SimpleResultType.Error,
+        serror: e
+      };
+    };
+    var toResult$1 = function (res) {
+      return fold$1(res, Result.error, Result.value);
+    };
+    var fromResult$1 = function (res) {
+      return res.fold(serror, svalue);
+    };
+    var SimpleResult = {
+      fromResult: fromResult$1,
+      toResult: toResult$1,
+      svalue: svalue,
+      partition: partition$2,
+      serror: serror,
+      bind: bind$1,
+      bindError: bindError,
+      map: map,
+      mapError: mapError,
+      fold: fold$1
+    };
+
+    var field$2 = function (key, newKey, presence, prop) {
+      return {
+        tag: 'field',
+        key: key,
+        newKey: newKey,
+        presence: presence,
+        prop: prop
+      };
+    };
+    var customField$1 = function (newKey, instantiator) {
+      return {
+        tag: 'custom',
+        newKey: newKey,
+        instantiator: instantiator
+      };
+    };
+    var fold = function (value, ifField, ifCustom) {
+      switch (value.tag) {
+      case 'field':
+        return ifField(value.key, value.newKey, value.presence, value.prop);
+      case 'custom':
+        return ifCustom(value.newKey, value.instantiator);
+      }
+    };
+
+    var shallow$1 = function (old, nu) {
+      return nu;
+    };
+    var deep = function (old, nu) {
+      var bothObjects = isObject(old) && isObject(nu);
+      return bothObjects ? deepMerge(old, nu) : nu;
+    };
+    var baseMerge = function (merger) {
+      return function () {
+        var objects = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          objects[_i] = arguments[_i];
+        }
+        if (objects.length === 0) {
+          throw new Error('Can\'t merge zero objects');
+        }
+        var ret = {};
+        for (var j = 0; j < objects.length; j++) {
+          var curObject = objects[j];
+          for (var key in curObject) {
+            if (has$2(curObject, key)) {
+              ret[key] = merger(ret[key], curObject[key]);
+            }
+          }
+        }
+        return ret;
+      };
+    };
+    var deepMerge = baseMerge(deep);
+    var merge$1 = baseMerge(shallow$1);
+
+    var required$2 = function () {
+      return {
+        tag: 'required',
+        process: {}
+      };
+    };
+    var defaultedThunk = function (fallbackThunk) {
+      return {
+        tag: 'defaultedThunk',
+        process: fallbackThunk
+      };
+    };
+    var defaulted$1 = function (fallback) {
+      return defaultedThunk(constant$1(fallback));
+    };
+    var asOption = function () {
+      return {
+        tag: 'option',
+        process: {}
+      };
+    };
+    var mergeWithThunk = function (baseThunk) {
+      return {
+        tag: 'mergeWithThunk',
+        process: baseThunk
+      };
+    };
+    var mergeWith = function (base) {
+      return mergeWithThunk(constant$1(base));
+    };
+
+    var mergeValues$1 = function (values, base) {
+      return values.length > 0 ? SimpleResult.svalue(deepMerge(base, merge$1.apply(undefined, values))) : SimpleResult.svalue(base);
+    };
+    var mergeErrors$1 = function (errors) {
+      return compose(SimpleResult.serror, flatten)(errors);
+    };
+    var consolidateObj = function (objects, base) {
+      var partition = SimpleResult.partition(objects);
+      return partition.errors.length > 0 ? mergeErrors$1(partition.errors) : mergeValues$1(partition.values, base);
+    };
+    var consolidateArr = function (objects) {
+      var partitions = SimpleResult.partition(objects);
+      return partitions.errors.length > 0 ? mergeErrors$1(partitions.errors) : SimpleResult.svalue(partitions.values);
+    };
+    var ResultCombine = {
+      consolidateObj: consolidateObj,
+      consolidateArr: consolidateArr
+    };
+
+    var formatObj = function (input) {
+      return isObject(input) && keys(input).length > 100 ? ' removed due to size' : JSON.stringify(input, null, 2);
+    };
+    var formatErrors = function (errors) {
+      var es = errors.length > 10 ? errors.slice(0, 10).concat([{
+          path: [],
+          getErrorInfo: constant$1('... (only showing first ten failures)')
+        }]) : errors;
+      return map$2(es, function (e) {
+        return 'Failed path: (' + e.path.join(' > ') + ')\n' + e.getErrorInfo();
+      });
+    };
+
+    var nu$a = function (path, getErrorInfo) {
+      return SimpleResult.serror([{
+          path: path,
+          getErrorInfo: getErrorInfo
+        }]);
+    };
+    var missingRequired = function (path, key, obj) {
+      return nu$a(path, function () {
+        return 'Could not find valid *required* value for "' + key + '" in ' + formatObj(obj);
+      });
+    };
+    var missingKey = function (path, key) {
+      return nu$a(path, function () {
+        return 'Choice schema did not contain choice key: "' + key + '"';
+      });
+    };
+    var missingBranch = function (path, branches, branch) {
+      return nu$a(path, function () {
+        return 'The chosen schema: "' + branch + '" did not exist in branches: ' + formatObj(branches);
+      });
+    };
+    var unsupportedFields = function (path, unsupported) {
+      return nu$a(path, function () {
+        return 'There are unsupported fields: [' + unsupported.join(', ') + '] specified';
+      });
+    };
+    var custom = function (path, 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) {
+          return custom(path, err);
+        });
+      };
+      var toString = constant$1('val');
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+    var anyValue$1 = value$2(SimpleResult.svalue);
+
+    var requiredAccess = function (path, obj, key, bundle) {
+      return get$e(obj, key).fold(function () {
+        return missingRequired(path, key, obj);
+      }, bundle);
+    };
+    var fallbackAccess = function (obj, key, fallback, bundle) {
+      var v = get$e(obj, key).getOrThunk(function () {
+        return fallback(obj);
+      });
+      return bundle(v);
+    };
+    var optionAccess = function (obj, key, bundle) {
+      return bundle(get$e(obj, key));
+    };
+    var optionDefaultedAccess = function (obj, key, fallback, bundle) {
+      var opt = get$e(obj, key).map(function (val) {
+        return val === true ? fallback(obj) : val;
+      });
+      return bundle(opt);
+    };
+    var extractField = function (field, path, obj, key, prop) {
+      var bundle = function (av) {
+        return prop.extract(path.concat([key]), av);
+      };
+      var bundleAsOption = function (optValue) {
+        return optValue.fold(function () {
+          return SimpleResult.svalue(Optional.none());
+        }, function (ov) {
+          var result = prop.extract(path.concat([key]), ov);
+          return SimpleResult.map(result, Optional.some);
+        });
+      };
+      switch (field.tag) {
+      case 'required':
+        return requiredAccess(path, obj, key, bundle);
+      case 'defaultedThunk':
+        return fallbackAccess(obj, key, field.process, bundle);
+      case 'option':
+        return optionAccess(obj, key, bundleAsOption);
+      case 'defaultedOptionThunk':
+        return optionDefaultedAccess(obj, key, field.process, bundleAsOption);
+      case 'mergeWithThunk': {
+          return fallbackAccess(obj, key, constant$1({}), function (v) {
+            var result = deepMerge(field.process(obj), v);
+            return bundle(result);
+          });
+        }
+      }
+    };
+    var extractFields = function (path, obj, fields) {
+      var success = {};
+      var errors = [];
+      for (var _i = 0, fields_1 = fields; _i < fields_1.length; _i++) {
+        var field = fields_1[_i];
+        fold(field, function (key, newKey, presence, prop) {
+          var result = extractField(presence, path, obj, key, prop);
+          SimpleResult.fold(result, function (err) {
+            errors.push.apply(errors, err);
+          }, function (res) {
+            success[newKey] = res;
+          });
+        }, function (newKey, instantiator) {
+          success[newKey] = instantiator(obj);
+        });
+      }
+      return errors.length > 0 ? SimpleResult.serror(errors) : SimpleResult.svalue(success);
+    };
+    var valueThunk = function (getDelegate) {
+      var extract = function (path, val) {
+        return getDelegate().extract(path, val);
+      };
+      var toString = function () {
+        return getDelegate().toString();
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+    var getSetKeys = function (obj) {
+      return keys(filter$1(obj, isNonNullable));
+    };
+    var objOfOnly = function (fields) {
+      var delegate = objOf(fields);
+      var fieldNames = foldr(fields, function (acc, value) {
+        return fold(value, function (key) {
+          var _a;
+          return deepMerge(acc, (_a = {}, _a[key] = true, _a));
+        }, constant$1(acc));
+      }, {});
+      var extract = function (path, o) {
+        var keys = isBoolean(o) ? [] : getSetKeys(o);
+        var extra = filter$2(keys, function (k) {
+          return !hasNonNullableKey(fieldNames, k);
+        });
+        return extra.length === 0 ? delegate.extract(path, o) : unsupportedFields(path, extra);
+      };
+      return {
+        extract: extract,
+        toString: delegate.toString
+      };
+    };
+    var objOf = function (values) {
+      var extract = function (path, o) {
+        return extractFields(path, o, values);
+      };
+      var toString = function () {
+        var fieldStrings = map$2(values, function (value) {
+          return fold(value, function (key, _okey, _presence, prop) {
+            return key + ' -> ' + prop.toString();
+          }, function (newKey, _instantiator) {
+            return 'state(' + newKey + ')';
+          });
+        });
+        return 'obj{\n' + fieldStrings.join('\n') + '}';
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+    var arrOf = function (prop) {
+      var extract = function (path, array) {
+        var results = map$2(array, function (a, i) {
+          return prop.extract(path.concat(['[' + i + ']']), a);
+        });
+        return ResultCombine.consolidateArr(results);
+      };
+      var toString = function () {
+        return 'array(' + prop.toString() + ')';
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+    var oneOf = function (props) {
+      var extract = function (path, val) {
+        var errors = [];
+        for (var _i = 0, props_1 = props; _i < props_1.length; _i++) {
+          var prop = props_1[_i];
+          var res = prop.extract(path, val);
+          if (res.stype === SimpleResultType.Value) {
+            return res;
+          }
+          errors.push(res);
+        }
+        return ResultCombine.consolidateArr(errors);
+      };
+      var toString = function () {
+        return 'oneOf(' + map$2(props, function (prop) {
+          return prop.toString();
+        }).join(', ') + ')';
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+    var setOf$1 = function (validator, prop) {
+      var validateKeys = function (path, keys) {
+        return arrOf(value$2(validator)).extract(path, keys);
+      };
+      var extract = function (path, o) {
+        var keys$1 = keys(o);
+        var validatedKeys = validateKeys(path, keys$1);
+        return SimpleResult.bind(validatedKeys, function (validKeys) {
+          var schema = map$2(validKeys, function (vk) {
+            return field$2(vk, vk, required$2(), prop);
+          });
+          return objOf(schema).extract(path, o);
+        });
+      };
+      var toString = function () {
+        return 'setOf(' + prop.toString() + ')';
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+    var thunk = function (_desc, processor) {
+      var getP = cached(processor);
+      var extract = function (path, val) {
+        return getP().extract(path, val);
+      };
+      var toString = function () {
+        return getP().toString();
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+    var arrOfObj = compose(arrOf, objOf);
+
+    var anyValue = constant$1(anyValue$1);
+    var typedValue = function (validator, expectedType) {
+      return value$2(function (a) {
+        var actualType = typeof a;
+        return validator(a) ? SimpleResult.svalue(a) : SimpleResult.serror('Expected type: ' + expectedType + ' but got: ' + actualType);
+      });
+    };
+    var number = typedValue(isNumber, 'number');
+    var string = typedValue(isString, 'string');
+    var boolean = typedValue(isBoolean, 'boolean');
+    var functionProcessor = typedValue(isFunction, 'function');
+    var isPostMessageable = function (val) {
+      if (Object(val) !== val) {
+        return true;
+      }
+      switch ({}.toString.call(val).slice(8, -1)) {
+      case 'Boolean':
+      case 'Number':
+      case 'String':
+      case 'Date':
+      case 'RegExp':
+      case 'Blob':
+      case 'FileList':
+      case 'ImageData':
+      case 'ImageBitmap':
+      case 'ArrayBuffer':
+        return true;
+      case 'Array':
+      case 'Object':
+        return Object.keys(val).every(function (prop) {
+          return isPostMessageable(val[prop]);
+        });
+      default:
+        return false;
+      }
+    };
+    var postMessageable = value$2(function (a) {
+      if (isPostMessageable(a)) {
+        return SimpleResult.svalue(a);
+      } else {
+        return SimpleResult.serror('Expected value to be acceptable for sending via postMessage');
+      }
+    });
+
+    var chooseFrom = function (path, input, branches, ch) {
+      var fields = get$e(branches, ch);
+      return fields.fold(function () {
+        return missingBranch(path, branches, ch);
+      }, function (vp) {
+        return vp.extract(path.concat(['branch: ' + ch]), input);
+      });
+    };
+    var choose$2 = function (key, branches) {
+      var extract = function (path, input) {
+        var choice = get$e(input, key);
+        return choice.fold(function () {
+          return missingKey(path, key);
+        }, function (chosen) {
+          return chooseFrom(path, input, branches, chosen);
+        });
+      };
+      var toString = function () {
+        return 'chooseOn(' + key + '). Possible values: ' + keys(branches);
+      };
+      return {
+        extract: extract,
+        toString: toString
+      };
+    };
+
+    var arrOfVal = function () {
+      return arrOf(anyValue$1);
+    };
+    var valueOf = function (validator) {
+      return value$2(function (v) {
+        return validator(v).fold(SimpleResult.serror, SimpleResult.svalue);
+      });
+    };
+    var setOf = function (validator, prop) {
+      return setOf$1(function (v) {
+        return SimpleResult.fromResult(validator(v));
+      }, prop);
+    };
+    var extractValue = function (label, prop, obj) {
+      var res = prop.extract([label], obj);
+      return SimpleResult.mapError(res, function (errs) {
+        return {
+          input: obj,
+          errors: errs
+        };
+      });
+    };
+    var asRaw = function (label, prop, obj) {
+      return SimpleResult.toResult(extractValue(label, prop, obj));
+    };
+    var getOrDie = function (extraction) {
+      return extraction.fold(function (errInfo) {
+        throw new Error(formatError(errInfo));
+      }, identity$1);
+    };
+    var asRawOrDie$1 = function (label, prop, obj) {
+      return getOrDie(asRaw(label, prop, obj));
+    };
+    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$1(branches, objOf));
+    };
+    var thunkOf = function (desc, schema) {
+      return thunk(desc, schema);
+    };
+
+    var field$1 = field$2;
+    var customField = customField$1;
+    var validateEnum = function (values) {
+      return valueOf(function (value) {
+        return contains$2(values, value) ? Result.value(value) : Result.error('Unsupported value: "' + value + '", choose one of "' + values.join(', ') + '".');
+      });
+    };
+    var required$1 = function (key) {
+      return field$1(key, key, required$2(), anyValue());
+    };
+    var requiredOf = function (key, schema) {
+      return field$1(key, key, required$2(), schema);
+    };
+    var requiredNumber = function (key) {
+      return requiredOf(key, number);
+    };
+    var requiredString = function (key) {
+      return requiredOf(key, string);
+    };
+    var requiredStringEnum = function (key, values) {
+      return field$1(key, key, required$2(), validateEnum(values));
+    };
+    var requiredBoolean = function (key) {
+      return requiredOf(key, boolean);
+    };
+    var requiredFunction = function (key) {
+      return requiredOf(key, functionProcessor);
+    };
+    var forbid = function (key, message) {
+      return field$1(key, key, asOption(), value$2(function (_v) {
+        return SimpleResult.serror('The field: ' + key + ' is forbidden. ' + message);
+      }));
+    };
+    var requiredObjOf = function (key, objSchema) {
+      return field$1(key, key, required$2(), objOf(objSchema));
+    };
+    var requiredArrayOfObj = function (key, objFields) {
+      return field$1(key, key, required$2(), arrOfObj(objFields));
+    };
+    var requiredArrayOf = function (key, schema) {
+      return field$1(key, key, required$2(), arrOf(schema));
+    };
+    var option = function (key) {
+      return field$1(key, key, asOption(), anyValue());
+    };
+    var optionOf = function (key, schema) {
+      return field$1(key, key, asOption(), schema);
+    };
+    var optionNumber = function (key) {
+      return optionOf(key, number);
+    };
+    var optionString = function (key) {
+      return optionOf(key, string);
+    };
+    var optionFunction = function (key) {
+      return optionOf(key, functionProcessor);
+    };
+    var optionArrayOf = function (key, schema) {
+      return optionOf(key, arrOf(schema));
+    };
+    var optionObjOf = function (key, objSchema) {
+      return optionOf(key, objOf(objSchema));
+    };
+    var optionObjOfOnly = function (key, objSchema) {
+      return optionOf(key, objOfOnly(objSchema));
+    };
+    var defaulted = function (key, fallback) {
+      return field$1(key, key, defaulted$1(fallback), anyValue());
+    };
+    var defaultedOf = function (key, fallback, schema) {
+      return field$1(key, key, defaulted$1(fallback), schema);
+    };
+    var defaultedNumber = function (key, fallback) {
+      return defaultedOf(key, fallback, number);
+    };
+    var defaultedString = function (key, fallback) {
+      return defaultedOf(key, fallback, string);
+    };
+    var defaultedStringEnum = function (key, fallback, values) {
+      return defaultedOf(key, fallback, validateEnum(values));
+    };
+    var defaultedBoolean = function (key, fallback) {
+      return defaultedOf(key, fallback, boolean);
+    };
+    var defaultedFunction = function (key, fallback) {
+      return defaultedOf(key, fallback, functionProcessor);
+    };
+    var defaultedPostMsg = function (key, fallback) {
+      return defaultedOf(key, fallback, postMessageable);
+    };
+    var defaultedArrayOf = function (key, fallback, schema) {
+      return defaultedOf(key, fallback, arrOf(schema));
+    };
+    var defaultedObjOf = function (key, fallback, objSchema) {
+      return defaultedOf(key, fallback, objOf(objSchema));
+    };
+
+    var Cell = function (initial) {
+      var value = initial;
+      var get = function () {
+        return value;
+      };
+      var set = function (v) {
+        value = v;
+      };
+      return {
+        get: get,
+        set: set
+      };
+    };
+
+    var generate$7 = function (cases) {
+      if (!isArray(cases)) {
+        throw new Error('cases must be an array');
+      }
+      if (cases.length === 0) {
+        throw new Error('there must be at least one case');
+      }
+      var constructors = [];
+      var adt = {};
+      each$1(cases, function (acase, count) {
+        var keys$1 = keys(acase);
+        if (keys$1.length !== 1) {
+          throw new Error('one and only one name per case');
+        }
+        var key = keys$1[0];
+        var value = acase[key];
+        if (adt[key] !== undefined) {
+          throw new Error('duplicate key detected:' + key);
+        } else if (key === 'cata') {
+          throw new Error('cannot have a case named cata (sorry)');
+        } else if (!isArray(value)) {
+          throw new Error('case arguments must be an array');
+        }
+        constructors.push(key);
+        adt[key] = function () {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          var argLength = args.length;
+          if (argLength !== value.length) {
+            throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength);
+          }
+          var match = function (branches) {
+            var branchKeys = keys(branches);
+            if (constructors.length !== branchKeys.length) {
+              throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(','));
+            }
+            var allReqd = forall(constructors, function (reqKey) {
+              return contains$2(branchKeys, reqKey);
+            });
+            if (!allReqd) {
+              throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', '));
+            }
+            return branches[key].apply(null, args);
+          };
+          return {
+            fold: function () {
+              var foldArgs = [];
+              for (var _i = 0; _i < arguments.length; _i++) {
+                foldArgs[_i] = arguments[_i];
+              }
+              if (foldArgs.length !== cases.length) {
+                throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + foldArgs.length);
+              }
+              var target = foldArgs[count];
+              return target.apply(null, args);
+            },
+            match: match,
+            log: function (label) {
+              console.log(label, {
+                constructors: constructors,
+                constructor: key,
+                params: args
+              });
+            }
+          };
+        };
+      });
+      return adt;
+    };
+    var Adt = { generate: generate$7 };
+
+    Adt.generate([
+      {
+        bothErrors: [
+          'error1',
+          'error2'
+        ]
+      },
+      {
+        firstError: [
+          'error1',
+          'value2'
+        ]
+      },
+      {
+        secondError: [
+          'value1',
+          'error2'
+        ]
+      },
+      {
+        bothValues: [
+          'value1',
+          'value2'
+        ]
+      }
+    ]);
+    var partition$1 = function (results) {
+      var errors = [];
+      var values = [];
+      each$1(results, function (result) {
+        result.fold(function (err) {
+          errors.push(err);
+        }, function (value) {
+          values.push(value);
+        });
+      });
+      return {
+        errors: errors,
+        values: values
+      };
+    };
+
+    var exclude$1 = function (obj, fields) {
+      var r = {};
+      each(obj, function (v, k) {
+        if (!contains$2(fields, k)) {
+          r[k] = v;
+        }
+      });
+      return r;
+    };
+
+    var wrap$2 = function (key, value) {
+      var _a;
+      return _a = {}, _a[key] = value, _a;
+    };
+    var wrapAll$1 = function (keyvalues) {
+      var r = {};
+      each$1(keyvalues, function (kv) {
+        r[kv.key] = kv.value;
+      });
+      return r;
+    };
+
+    var exclude = function (obj, fields) {
+      return exclude$1(obj, fields);
+    };
+    var wrap$1 = function (key, value) {
+      return wrap$2(key, value);
+    };
+    var wrapAll = function (keyvalues) {
+      return wrapAll$1(keyvalues);
+    };
+    var mergeValues = function (values, base) {
+      return values.length === 0 ? Result.value(base) : Result.value(deepMerge(base, merge$1.apply(undefined, values)));
+    };
+    var mergeErrors = function (errors) {
+      return Result.error(flatten(errors));
+    };
+    var consolidate = function (objs, base) {
+      var partitions = partition$1(objs);
+      return partitions.errors.length > 0 ? mergeErrors(partitions.errors) : mergeValues(partitions.values, base);
+    };
+
+    var ensureIsRoot = function (isRoot) {
+      return isFunction(isRoot) ? isRoot : never;
+    };
+    var ancestor$2 = function (scope, transform, isRoot) {
+      var element = scope.dom;
+      var stop = ensureIsRoot(isRoot);
+      while (element.parentNode) {
+        element = element.parentNode;
+        var el = SugarElement.fromDom(element);
+        var transformed = transform(el);
+        if (transformed.isSome()) {
+          return transformed;
+        } else if (stop(el)) {
+          break;
+        }
+      }
+      return Optional.none();
+    };
+    var closest$4 = function (scope, transform, isRoot) {
+      var current = transform(scope);
+      var stop = ensureIsRoot(isRoot);
+      return current.orThunk(function () {
+        return stop(scope) ? Optional.none() : ancestor$2(scope, transform, stop);
+      });
+    };
+
+    var isSource = function (component, simulatedEvent) {
+      return eq(component.element, simulatedEvent.event.target);
+    };
+
+    var defaultEventHandler = {
+      can: always,
+      abort: never,
+      run: noop
+    };
+    var nu$9 = function (parts) {
+      if (!hasNonNullableKey(parts, 'can') && !hasNonNullableKey(parts, 'abort') && !hasNonNullableKey(parts, 'run')) {
+        throw new Error('EventHandler defined by: ' + JSON.stringify(parts, null, 2) + ' does not have can, abort, or run!');
+      }
+      return __assign(__assign({}, defaultEventHandler), parts);
+    };
+    var all$2 = function (handlers, f) {
+      return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return foldl(handlers, function (acc, handler) {
+          return acc && f(handler).apply(undefined, args);
+        }, true);
+      };
+    };
+    var any = function (handlers, f) {
+      return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return foldl(handlers, function (acc, handler) {
+          return acc || f(handler).apply(undefined, args);
+        }, false);
+      };
+    };
+    var read$2 = function (handler) {
+      return isFunction(handler) ? {
+        can: always,
+        abort: never,
+        run: handler
+      } : handler;
+    };
+    var fuse$1 = function (handlers) {
+      var can = all$2(handlers, function (handler) {
+        return handler.can;
+      });
+      var abort = any(handlers, function (handler) {
+        return handler.abort;
+      });
+      var run = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        each$1(handlers, function (handler) {
+          handler.run.apply(undefined, args);
+        });
+      };
+      return {
+        can: can,
+        abort: abort,
+        run: run
+      };
+    };
+
+    var constant = constant$1;
+    var touchstart = constant('touchstart');
+    var touchmove = constant('touchmove');
+    var touchend = constant('touchend');
+    var touchcancel = constant('touchcancel');
+    var mousedown = constant('mousedown');
+    var mousemove = constant('mousemove');
+    var mouseout = constant('mouseout');
+    var mouseup = constant('mouseup');
+    var mouseover = constant('mouseover');
+    var focusin = constant('focusin');
+    var focusout = constant('focusout');
+    var keydown = constant('keydown');
+    var keyup = constant('keyup');
+    var input = constant('input');
+    var change = constant('change');
+    var click = constant('click');
+    var transitioncancel = constant('transitioncancel');
+    var transitionend = constant('transitionend');
+    var transitionstart = constant('transitionstart');
+    var selectstart = constant('selectstart');
+
+    var prefixName = function (name) {
+      return constant$1('alloy.' + name);
+    };
+    var alloy = { tap: prefixName('tap') };
+    var focus$4 = prefixName('focus');
+    var postBlur = prefixName('blur.post');
+    var postPaste = prefixName('paste.post');
+    var receive = prefixName('receive');
+    var execute$5 = prefixName('execute');
+    var focusItem = prefixName('focus.item');
+    var tap = alloy.tap;
+    var longpress = prefixName('longpress');
+    var sandboxClose = prefixName('sandbox.close');
+    var typeaheadCancel = prefixName('typeahead.cancel');
+    var systemInit = prefixName('system.init');
+    var documentTouchmove = prefixName('system.touchmove');
+    var documentTouchend = prefixName('system.touchend');
+    var windowScroll = prefixName('system.scroll');
+    var windowResize = prefixName('system.resize');
+    var attachedToDom = prefixName('system.attached');
+    var detachedFromDom = prefixName('system.detached');
+    var dismissRequested = prefixName('system.dismissRequested');
+    var repositionRequested = prefixName('system.repositionRequested');
+    var focusShifted = prefixName('focusmanager.shifted');
+    var slotVisibility = prefixName('slotcontainer.visibility');
+    var changeTab = prefixName('change.tab');
+    var dismissTab = prefixName('dismiss.tab');
+    var highlight$1 = prefixName('highlight');
+    var dehighlight$1 = prefixName('dehighlight');
+
+    var emit = function (component, event) {
+      dispatchWith(component, component.element, event, {});
+    };
+    var emitWith = function (component, event, properties) {
+      dispatchWith(component, component.element, event, properties);
+    };
+    var emitExecute = function (component) {
+      emit(component, execute$5());
+    };
+    var dispatch = function (component, target, event) {
+      dispatchWith(component, target, event, {});
+    };
+    var dispatchWith = function (component, target, event, properties) {
+      var data = __assign({ target: target }, properties);
+      component.getSystem().triggerEvent(event, target, data);
+    };
+    var dispatchEvent = function (component, target, event, simulatedEvent) {
+      component.getSystem().triggerEvent(event, target, simulatedEvent.event);
+    };
+
+    var derive$2 = function (configs) {
+      return wrapAll(configs);
+    };
+    var abort = function (name, predicate) {
+      return {
+        key: name,
+        value: nu$9({ abort: predicate })
+      };
+    };
+    var can = function (name, predicate) {
+      return {
+        key: name,
+        value: nu$9({ can: predicate })
+      };
+    };
+    var preventDefault = function (name) {
+      return {
+        key: name,
+        value: nu$9({
+          run: function (component, simulatedEvent) {
+            simulatedEvent.event.prevent();
+          }
+        })
+      };
+    };
+    var run$1 = function (name, handler) {
+      return {
+        key: name,
+        value: nu$9({ run: handler })
+      };
+    };
+    var runActionExtra = function (name, action, extra) {
+      return {
+        key: name,
+        value: nu$9({
+          run: function (component, simulatedEvent) {
+            action.apply(undefined, [
+              component,
+              simulatedEvent
+            ].concat(extra));
+          }
+        })
+      };
+    };
+    var runOnName = function (name) {
+      return function (handler) {
+        return run$1(name, handler);
+      };
+    };
+    var runOnSourceName = function (name) {
+      return function (handler) {
+        return {
+          key: name,
+          value: nu$9({
+            run: function (component, simulatedEvent) {
+              if (isSource(component, simulatedEvent)) {
+                handler(component, simulatedEvent);
+              }
+            }
+          })
+        };
+      };
+    };
+    var redirectToUid = function (name, uid) {
+      return run$1(name, function (component, simulatedEvent) {
+        component.getSystem().getByUid(uid).each(function (redirectee) {
+          dispatchEvent(redirectee, redirectee.element, name, simulatedEvent);
+        });
+      });
+    };
+    var redirectToPart = function (name, detail, partName) {
+      var uid = detail.partUids[partName];
+      return redirectToUid(name, uid);
+    };
+    var runWithTarget = function (name, f) {
+      return run$1(name, function (component, simulatedEvent) {
+        var ev = simulatedEvent.event;
+        var target = component.getSystem().getByDom(ev.target).getOrThunk(function () {
+          var closest = closest$4(ev.target, function (el) {
+            return component.getSystem().getByDom(el).toOptional();
+          }, never);
+          return closest.getOr(component);
+        });
+        f(component, target, simulatedEvent);
+      });
+    };
+    var cutter = function (name) {
+      return run$1(name, function (component, simulatedEvent) {
+        simulatedEvent.cut();
+      });
+    };
+    var stopper = function (name) {
+      return run$1(name, function (component, simulatedEvent) {
+        simulatedEvent.stop();
+      });
+    };
+    var runOnSource = function (name, f) {
+      return runOnSourceName(name)(f);
+    };
+    var runOnAttached = runOnSourceName(attachedToDom());
+    var runOnDetached = runOnSourceName(detachedFromDom());
+    var runOnInit = runOnSourceName(systemInit());
+    var runOnExecute$1 = runOnName(execute$5());
+
+    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$7 = function (element) {
+      return element.dom.innerHTML;
+    };
+    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 = function (element) {
+      var container = SugarElement.fromTag('div');
+      var clone = SugarElement.fromDom(element.dom.cloneNode(true));
+      append$2(container, clone);
+      return get$7(container);
+    };
+
+    var clone$2 = function (original, isDeep) {
+      return SugarElement.fromDom(original.dom.cloneNode(isDeep));
+    };
+    var shallow = function (original) {
+      return clone$2(original, false);
+    };
+
+    var getHtml = function (element) {
+      if (isShadowRoot(element)) {
+        return '#shadow-root';
+      } else {
+        var clone = shallow(element);
+        return getOuter(clone);
+      }
+    };
+
+    var element = function (elem) {
+      return getHtml(elem);
+    };
+
+    var isRecursive = function (component, originator, target) {
+      return eq(originator, component.element) && !eq(originator, target);
+    };
+    var events$i = derive$2([can(focus$4(), function (component, simulatedEvent) {
+        var event = simulatedEvent.event;
+        var originator = event.originator;
+        var target = event.target;
+        if (isRecursive(component, originator, target)) {
+          console.warn(focus$4() + ' did not get interpreted by the desired target. ' + '\nOriginator: ' + element(originator) + '\nTarget: ' + element(target) + '\nCheck the ' + focus$4() + ' event handlers');
+          return false;
+        } else {
+          return true;
+        }
+      })]);
+
+    var DefaultEvents = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$i
+    });
+
+    var unique = 0;
+    var generate$6 = function (prefix) {
+      var date = new Date();
+      var time = date.getTime();
+      var random = Math.floor(Math.random() * 1000000000);
+      unique++;
+      return prefix + '_' + random + unique + String(time);
+    };
+
+    var prefix$1 = constant$1('alloy-id-');
+    var idAttr$1 = constant$1('data-alloy-id');
+
+    var prefix = prefix$1();
+    var idAttr = idAttr$1();
+    var write = function (label, elem) {
+      var id = generate$6(prefix + label);
+      writeOnly(elem, id);
+      return id;
+    };
+    var writeOnly = function (elem, uid) {
+      Object.defineProperty(elem.dom, idAttr, {
+        value: uid,
+        writable: true
+      });
+    };
+    var read$1 = function (elem) {
+      var id = isElement$2(elem) ? elem.dom[idAttr] : null;
+      return Optional.from(id);
+    };
+    var generate$5 = function (prefix) {
+      return generate$6(prefix);
+    };
+
+    var make$8 = identity$1;
+
+    var NoContextApi = function (getComp) {
+      var getMessage = function (event) {
+        return 'The component must be in a context to execute: ' + event + (getComp ? '\n' + element(getComp().element) + ' is not in context.' : '');
+      };
+      var fail = function (event) {
+        return function () {
+          throw new Error(getMessage(event));
+        };
+      };
+      var warn = function (event) {
+        return function () {
+          console.warn(getMessage(event));
+        };
+      };
+      return {
+        debugInfo: constant$1('fake'),
+        triggerEvent: warn('triggerEvent'),
+        triggerFocus: warn('triggerFocus'),
+        triggerEscape: warn('triggerEscape'),
+        broadcast: warn('broadcast'),
+        broadcastOn: warn('broadcastOn'),
+        broadcastEvent: warn('broadcastEvent'),
+        build: fail('build'),
+        addToWorld: fail('addToWorld'),
+        removeFromWorld: fail('removeFromWorld'),
+        addToGui: fail('addToGui'),
+        removeFromGui: fail('removeFromGui'),
+        getByUid: fail('getByUid'),
+        getByDom: fail('getByDom'),
+        isConnected: never
+      };
+    };
+    var singleton$1 = NoContextApi();
+
+    var markAsBehaviourApi = function (f, apiName, apiFunction) {
+      var delegate = apiFunction.toString();
+      var endIndex = delegate.indexOf(')') + 1;
+      var openBracketIndex = delegate.indexOf('(');
+      var parameters = delegate.substring(openBracketIndex + 1, endIndex - 1).split(/,\s*/);
+      f.toFunctionAnnotation = function () {
+        return {
+          name: apiName,
+          parameters: cleanParameters(parameters.slice(0, 1).concat(parameters.slice(3)))
+        };
+      };
+      return f;
+    };
+    var cleanParameters = function (parameters) {
+      return map$2(parameters, function (p) {
+        return endsWith(p, '/*') ? p.substring(0, p.length - '/*'.length) : p;
+      });
+    };
+    var markAsExtraApi = function (f, extraName) {
+      var delegate = f.toString();
+      var endIndex = delegate.indexOf(')') + 1;
+      var openBracketIndex = delegate.indexOf('(');
+      var parameters = delegate.substring(openBracketIndex + 1, endIndex - 1).split(/,\s*/);
+      f.toFunctionAnnotation = function () {
+        return {
+          name: extraName,
+          parameters: cleanParameters(parameters)
+        };
+      };
+      return f;
+    };
+    var markAsSketchApi = function (f, apiFunction) {
+      var delegate = apiFunction.toString();
+      var endIndex = delegate.indexOf(')') + 1;
+      var openBracketIndex = delegate.indexOf('(');
+      var parameters = delegate.substring(openBracketIndex + 1, endIndex - 1).split(/,\s*/);
+      f.toFunctionAnnotation = function () {
+        return {
+          name: 'OVERRIDE',
+          parameters: cleanParameters(parameters.slice(1))
+        };
+      };
+      return f;
+    };
+
+    var premadeTag = generate$6('alloy-premade');
+    var premade$1 = function (comp) {
+      return wrap$1(premadeTag, comp);
+    };
+    var getPremade = function (spec) {
+      return get$e(spec, premadeTag);
+    };
+    var makeApi = function (f) {
+      return markAsSketchApi(function (component) {
+        var rest = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+          rest[_i - 1] = arguments[_i];
+        }
+        return f.apply(void 0, __spreadArray([
+          component.getApis(),
+          component
+        ], rest, false));
+      }, f);
+    };
+
+    var NoState = {
+      init: function () {
+        return nu$8({ readState: constant$1('No State required') });
+      }
+    };
+    var nu$8 = function (spec) {
+      return spec;
+    };
+
+    var generateFrom$1 = function (spec, all) {
+      var schema = map$2(all, function (a) {
+        return optionObjOf(a.name(), [
+          required$1('config'),
+          defaulted('state', NoState)
+        ]);
+      });
+      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$1(validated, function (optBlobThunk) {
+          var output = optBlobThunk.map(function (blob) {
+            return {
+              config: blob.config,
+              state: blob.state.init(blob.config)
+            };
+          });
+          return constant$1(output);
+        })
+      };
+    };
+    var getBehaviours$3 = function (bData) {
+      return bData.list;
+    };
+    var getData$2 = function (bData) {
+      return bData.data;
+    };
+
+    var byInnerKey = function (data, tuple) {
+      var r = {};
+      each(data, function (detail, key) {
+        each(detail, function (value, indexKey) {
+          var chain = get$e(r, indexKey).getOr([]);
+          r[indexKey] = chain.concat([tuple(key, value)]);
+        });
+      });
+      return r;
+    };
+
+    var nu$7 = function (s) {
+      return {
+        classes: isUndefined(s.classes) ? [] : s.classes,
+        attributes: isUndefined(s.attributes) ? {} : s.attributes,
+        styles: isUndefined(s.styles) ? {} : s.styles
+      };
+    };
+    var merge = function (defnA, mod) {
+      return __assign(__assign({}, defnA), {
+        attributes: __assign(__assign({}, defnA.attributes), mod.attributes),
+        styles: __assign(__assign({}, defnA.styles), mod.styles),
+        classes: defnA.classes.concat(mod.classes)
+      });
+    };
+
+    var combine$2 = function (info, baseMod, behaviours, base) {
+      var modsByBehaviour = __assign({}, baseMod);
+      each$1(behaviours, function (behaviour) {
+        modsByBehaviour[behaviour.name()] = behaviour.exhibit(info, base);
+      });
+      var byAspect = byInnerKey(modsByBehaviour, function (name, modification) {
+        return {
+          name: name,
+          modification: modification
+        };
+      });
+      var combineObjects = function (objects) {
+        return foldr(objects, function (b, a) {
+          return __assign(__assign({}, a.modification), b);
+        }, {});
+      };
+      var combinedClasses = foldr(byAspect.classes, function (b, a) {
+        return a.modification.concat(b);
+      }, []);
+      var combinedAttributes = combineObjects(byAspect.attributes);
+      var combinedStyles = combineObjects(byAspect.styles);
+      return nu$7({
+        classes: combinedClasses,
+        attributes: combinedAttributes,
+        styles: combinedStyles
+      });
+    };
+
+    var sortKeys = function (label, keyName, array, order) {
+      try {
+        var sorted = sort(array, function (a, b) {
+          var aKey = a[keyName];
+          var bKey = b[keyName];
+          var aIndex = order.indexOf(aKey);
+          var bIndex = order.indexOf(bKey);
+          if (aIndex === -1) {
+            throw new Error('The ordering for ' + label + ' does not have an entry for ' + aKey + '.\nOrder specified: ' + JSON.stringify(order, null, 2));
+          }
+          if (bIndex === -1) {
+            throw new Error('The ordering for ' + label + ' does not have an entry for ' + bKey + '.\nOrder specified: ' + JSON.stringify(order, null, 2));
+          }
+          if (aIndex < bIndex) {
+            return -1;
+          } else if (bIndex < aIndex) {
+            return 1;
+          } else {
+            return 0;
+          }
+        });
+        return Result.value(sorted);
+      } catch (err) {
+        return Result.error([err]);
+      }
+    };
+
+    var uncurried = function (handler, purpose) {
+      return {
+        handler: handler,
+        purpose: purpose
+      };
+    };
+    var curried = function (handler, purpose) {
+      return {
+        cHandler: handler,
+        purpose: purpose
+      };
+    };
+    var curryArgs = function (descHandler, extraArgs) {
+      return curried(curry.apply(undefined, [descHandler.handler].concat(extraArgs)), descHandler.purpose);
+    };
+    var getCurried = function (descHandler) {
+      return descHandler.cHandler;
+    };
+
+    var behaviourTuple = function (name, handler) {
+      return {
+        name: name,
+        handler: handler
+      };
+    };
+    var nameToHandlers = function (behaviours, info) {
+      var r = {};
+      each$1(behaviours, function (behaviour) {
+        r[behaviour.name()] = behaviour.handlers(info);
+      });
+      return r;
+    };
+    var groupByEvents = function (info, behaviours, base) {
+      var behaviourEvents = __assign(__assign({}, base), nameToHandlers(behaviours, info));
+      return byInnerKey(behaviourEvents, behaviourTuple);
+    };
+    var combine$1 = function (info, eventOrder, behaviours, base) {
+      var byEventName = groupByEvents(info, behaviours, base);
+      return combineGroups(byEventName, eventOrder);
+    };
+    var assemble = function (rawHandler) {
+      var handler = read$2(rawHandler);
+      return function (component, simulatedEvent) {
+        var rest = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+          rest[_i - 2] = arguments[_i];
+        }
+        var args = [
+          component,
+          simulatedEvent
+        ].concat(rest);
+        if (handler.abort.apply(undefined, args)) {
+          simulatedEvent.stop();
+        } else if (handler.can.apply(undefined, args)) {
+          handler.run.apply(undefined, args);
+        }
+      };
+    };
+    var missingOrderError = function (eventName, tuples) {
+      return Result.error(['The event (' + eventName + ') has more than one behaviour that listens to it.\nWhen this occurs, you must ' + 'specify an event ordering for the behaviours in your spec (e.g. [ "listing", "toggling" ]).\nThe behaviours that ' + 'can trigger it are: ' + JSON.stringify(map$2(tuples, function (c) {
+          return c.name;
+        }), null, 2)]);
+    };
+    var fuse = function (tuples, eventOrder, eventName) {
+      var order = eventOrder[eventName];
+      if (!order) {
+        return missingOrderError(eventName, tuples);
+      } else {
+        return sortKeys('Event: ' + eventName, 'name', tuples, order).map(function (sortedTuples) {
+          var handlers = map$2(sortedTuples, function (tuple) {
+            return tuple.handler;
+          });
+          return fuse$1(handlers);
+        });
+      }
+    };
+    var combineGroups = function (byEventName, eventOrder) {
+      var r = mapToArray(byEventName, function (tuples, eventName) {
+        var combined = tuples.length === 1 ? Result.value(tuples[0].handler) : fuse(tuples, eventOrder, eventName);
+        return combined.map(function (handler) {
+          var assembled = assemble(handler);
+          var purpose = tuples.length > 1 ? filter$2(eventOrder[eventName], function (o) {
+            return exists(tuples, function (t) {
+              return t.name === o;
+            });
+          }).join(' > ') : tuples[0].name;
+          return wrap$1(eventName, uncurried(assembled, purpose));
+        });
+      });
+      return consolidate(r, {});
+    };
+
+    var _a$2;
+    var baseBehaviour = 'alloy.base.behaviour';
+    var schema$z = objOf([
+      field$1('dom', 'dom', required$2(), objOf([
+        required$1('tag'),
+        defaulted('styles', {}),
+        defaulted('classes', []),
+        defaulted('attributes', {}),
+        option('value'),
+        option('innerHtml')
+      ])),
+      required$1('components'),
+      required$1('uid'),
+      defaulted('events', {}),
+      defaulted('apis', {}),
+      field$1('eventOrder', 'eventOrder', mergeWith((_a$2 = {}, _a$2[execute$5()] = [
+        'disabling',
+        baseBehaviour,
+        'toggling',
+        'typeaheadevents'
+      ], _a$2[focus$4()] = [
+        baseBehaviour,
+        'focusing',
+        'keying'
+      ], _a$2[systemInit()] = [
+        baseBehaviour,
+        'disabling',
+        'toggling',
+        'representing'
+      ], _a$2[input()] = [
+        baseBehaviour,
+        'representing',
+        'streaming',
+        'invalidating'
+      ], _a$2[detachedFromDom()] = [
+        baseBehaviour,
+        'representing',
+        'item-events',
+        'tooltipping'
+      ], _a$2[mousedown()] = [
+        'focusing',
+        baseBehaviour,
+        'item-type-events'
+      ], _a$2[touchstart()] = [
+        'focusing',
+        baseBehaviour,
+        'item-type-events'
+      ], _a$2[mouseover()] = [
+        'item-type-events',
+        'tooltipping'
+      ], _a$2[receive()] = [
+        'receiving',
+        'reflecting',
+        'tooltipping'
+      ], _a$2)), anyValue()),
+      option('domModification')
+    ]);
+    var toInfo = function (spec) {
+      return asRaw('custom.definition', schema$z, spec);
+    };
+    var toDefinition = function (detail) {
+      return __assign(__assign({}, detail.dom), {
+        uid: detail.uid,
+        domChildren: map$2(detail.components, function (comp) {
+          return comp.element;
+        })
+      });
+    };
+    var toModification = function (detail) {
+      return detail.domModification.fold(function () {
+        return nu$7({});
+      }, nu$7);
+    };
+    var toEvents = function (info) {
+      return info.events;
+    };
+
+    var read = function (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$8(element, attr, nu.join(' '));
+      return true;
+    };
+    var remove$4 = function (element, attr, id) {
+      var nu = filter$2(read(element, attr), function (v) {
+        return v !== id;
+      });
+      if (nu.length > 0) {
+        set$8(element, attr, nu.join(' '));
+      } else {
+        remove$7(element, attr);
+      }
+      return false;
+    };
+
+    var supports = function (element) {
+      return element.dom.classList !== undefined;
+    };
+    var get$6 = function (element) {
+      return read(element, 'class');
+    };
+    var add$3 = function (element, clazz) {
+      return add$4(element, 'class', clazz);
+    };
+    var remove$3 = function (element, 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$6(element);
+      if (classList.length === 0) {
+        remove$7(element, 'class');
+      }
+    };
+    var remove$2 = function (element, clazz) {
+      if (supports(element)) {
+        var classList = element.dom.classList;
+        classList.remove(clazz);
+      } else {
+        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$1 = function (element, classes) {
+      each$1(classes, function (x) {
+        remove$2(element, x);
+      });
+    };
+    var hasAll = function (element, classes) {
+      return forall(classes, function (clazz) {
+        return has(element, clazz);
+      });
+    };
+
+    var get$5 = function (element) {
+      return element.dom.value;
+    };
+    var set$4 = function (element, value) {
+      if (value === undefined) {
+        throw new Error('Value.set was undefined');
+      }
+      element.dom.value = value;
+    };
+
+    var renderToDom = function (definition) {
+      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$5(subject, html);
+      });
+      var children = definition.domChildren;
+      append$1(subject, children);
+      definition.value.each(function (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({});
+      return bind$3(keys(behaviours), function (name) {
+        var behaviour = behaviours[name];
+        return isNonNullable(behaviour) ? [behaviour.me] : [];
+      });
+    };
+    var generateFrom = function (spec, all) {
+      return generateFrom$1(spec, all);
+    };
+    var generate$4 = function (spec) {
+      var all = getBehaviours$2(spec);
+      return generateFrom(spec, all);
+    };
+
+    var getDomDefinition = function (info, bList, bData) {
+      var definition = toDefinition(info);
+      var infoModification = toModification(info);
+      var baseModification = { 'alloy.base.modification': infoModification };
+      var modification = bList.length > 0 ? combine$2(bData, baseModification, bList, definition) : infoModification;
+      return merge(definition, modification);
+    };
+    var getEvents = function (info, bList, bData) {
+      var baseEvents = { 'alloy.base.behaviour': toEvents(info) };
+      return combine$1(bData, info.eventOrder, bList, baseEvents).getOrDie();
+    };
+    var build$2 = function (spec) {
+      var getMe = function () {
+        return me;
+      };
+      var systemApi = Cell(singleton$1);
+      var info = getOrDie(toInfo(spec));
+      var bBlob = generate$4(spec);
+      var bList = getBehaviours$3(bBlob);
+      var bData = getData$2(bBlob);
+      var modDefinition = getDomDefinition(info, bList, bData);
+      var item = renderToDom(modDefinition);
+      var events = getEvents(info, bList, bData);
+      var subcomponents = Cell(info.components);
+      var connect = function (newApi) {
+        systemApi.set(newApi);
+      };
+      var disconnect = function () {
+        systemApi.set(NoContextApi(getMe));
+      };
+      var syncComponents = function () {
+        var children$1 = children(item);
+        var subs = bind$3(children$1, function (child) {
+          return systemApi.get().getByDom(child).fold(function () {
+            return [];
+          }, pure$2);
+        });
+        subcomponents.set(subs);
+      };
+      var config = function (behaviour) {
+        var b = bData;
+        var f = isFunction(b[behaviour.name()]) ? b[behaviour.name()] : function () {
+          throw new Error('Could not find ' + behaviour.name() + ' in ' + JSON.stringify(spec, null, 2));
+        };
+        return f();
+      };
+      var hasConfigured = function (behaviour) {
+        return isFunction(bData[behaviour.name()]);
+      };
+      var getApis = function () {
+        return info.apis;
+      };
+      var readState = function (behaviourName) {
+        return bData[behaviourName]().map(function (b) {
+          return b.state.readState();
+        }).getOr('not enabled');
+      };
+      var me = {
+        uid: spec.uid,
+        getSystem: systemApi.get,
+        config: config,
+        hasConfigured: hasConfigured,
+        spec: spec,
+        readState: readState,
+        getApis: getApis,
+        connect: connect,
+        disconnect: disconnect,
+        element: item,
+        syncComponents: syncComponents,
+        components: subcomponents.get,
+        events: events
+      };
+      return me;
+    };
+
+    var buildSubcomponents = function (spec) {
+      var components = get$e(spec, 'components').getOr([]);
+      return map$2(components, build$1);
+    };
+    var buildFromSpec = function (userSpec) {
+      var _a = make$8(userSpec), specEvents = _a.events, spec = __rest(_a, ['events']);
+      var components = buildSubcomponents(spec);
+      var completeSpec = __assign(__assign({}, spec), {
+        events: __assign(__assign({}, DefaultEvents), specEvents),
+        components: components
+      });
+      return Result.value(build$2(completeSpec));
+    };
+    var text$1 = function (textContent) {
+      var element = SugarElement.fromText(textContent);
+      return external$2({ element: element });
+    };
+    var external$2 = function (spec) {
+      var extSpec = asRawOrDie$1('external.component', objOfOnly([
+        required$1('element'),
+        option('uid')
+      ]), spec);
+      var systemApi = Cell(NoContextApi());
+      var connect = function (newApi) {
+        systemApi.set(newApi);
+      };
+      var disconnect = function () {
+        systemApi.set(NoContextApi(function () {
+          return me;
+        }));
+      };
+      var uid = extSpec.uid.getOrThunk(function () {
+        return generate$5('external');
+      });
+      writeOnly(extSpec.element, uid);
+      var me = {
+        uid: uid,
+        getSystem: systemApi.get,
+        config: Optional.none,
+        hasConfigured: never,
+        connect: connect,
+        disconnect: disconnect,
+        getApis: function () {
+          return {};
+        },
+        element: extSpec.element,
+        spec: spec,
+        readState: constant$1('No state'),
+        syncComponents: noop,
+        components: constant$1([]),
+        events: {}
+      };
+      return premade$1(me);
+    };
+    var uids = generate$5;
+    var isSketchSpec$1 = function (spec) {
+      return has$2(spec, 'uid');
+    };
+    var build$1 = function (spec) {
+      return getPremade(spec).getOrThunk(function () {
+        var userSpecWithUid = isSketchSpec$1(spec) ? spec : __assign({ uid: uids('') }, spec);
+        return buildFromSpec(userSpecWithUid).getOrDie();
+      });
+    };
+    var premade = premade$1;
+
+    function ClosestOrAncestor (is, ancestor, scope, a, isRoot) {
+      if (is(scope, a)) {
+        return Optional.some(scope);
+      } else if (isFunction(isRoot) && isRoot(scope)) {
+        return Optional.none();
+      } else {
+        return ancestor(scope, a, isRoot);
+      }
+    }
+
+    var ancestor$1 = function (scope, predicate, isRoot) {
+      var element = scope.dom;
+      var stop = isFunction(isRoot) ? isRoot : never;
+      while (element.parentNode) {
+        element = element.parentNode;
+        var el = SugarElement.fromDom(element);
+        if (predicate(el)) {
+          return Optional.some(el);
+        } else if (stop(el)) {
+          break;
+        }
+      }
+      return Optional.none();
+    };
+    var closest$3 = function (scope, predicate, isRoot) {
+      var is = function (s, test) {
+        return test(s);
+      };
+      return ClosestOrAncestor(is, ancestor$1, scope, predicate, isRoot);
+    };
+    var child$1 = function (scope, predicate) {
+      var pred = function (node) {
+        return predicate(SugarElement.fromDom(node));
+      };
+      var result = find$5(scope.dom.childNodes, pred);
+      return result.map(SugarElement.fromDom);
+    };
+    var descendant$1 = function (scope, predicate) {
+      var descend = function (node) {
+        for (var i = 0; i < node.childNodes.length; i++) {
+          var child_1 = SugarElement.fromDom(node.childNodes[i]);
+          if (predicate(child_1)) {
+            return Optional.some(child_1);
+          }
+          var res = descend(node.childNodes[i]);
+          if (res.isSome()) {
+            return res;
+          }
+        }
+        return Optional.none();
+      };
+      return descend(scope.dom);
+    };
+
+    var closest$2 = function (scope, predicate, isRoot) {
+      return closest$3(scope, predicate, isRoot).isSome();
+    };
+
+    var ancestor = function (scope, selector, isRoot) {
+      return ancestor$1(scope, function (e) {
+        return is(e, selector);
+      }, isRoot);
+    };
+    var child = function (scope, selector) {
+      return child$1(scope, function (e) {
+        return is(e, selector);
+      });
+    };
+    var descendant = function (scope, selector) {
+      return one(selector, scope);
+    };
+    var closest$1 = function (scope, selector, isRoot) {
+      var is$1 = function (element, selector) {
+        return is(element, selector);
+      };
+      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$d(elem, 'id');
+        return id !== undefined && id.indexOf('aria-owns') > -1;
+      });
+      return dependent.bind(function (dep) {
+        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$8(elem, 'aria-owns', ariaId);
+      };
+      var unlink = function (elem) {
+        remove$7(elem, 'aria-owns');
+      };
+      return {
+        id: ariaId,
+        link: link,
+        unlink: unlink
+      };
+    };
+
+    var isAriaPartOf = function (component, queryElem) {
+      return find$1(queryElem).exists(function (owner) {
+        return isPartOf$1(component, owner);
+      });
+    };
+    var isPartOf$1 = function (component, queryElem) {
+      return closest$2(queryElem, function (el) {
+        return eq(el, component.element);
+      }, never) || isAriaPartOf(component, queryElem);
+    };
+
+    var unknown = 'unknown';
+    var EventConfiguration;
+    (function (EventConfiguration) {
+      EventConfiguration[EventConfiguration['STOP'] = 0] = 'STOP';
+      EventConfiguration[EventConfiguration['NORMAL'] = 1] = 'NORMAL';
+      EventConfiguration[EventConfiguration['LOGGING'] = 2] = 'LOGGING';
+    }(EventConfiguration || (EventConfiguration = {})));
+    var eventConfig = Cell({});
+    var makeEventLogger = function (eventName, initialTarget) {
+      var sequence = [];
+      var startTime = new Date().getTime();
+      return {
+        logEventCut: function (_name, target, purpose) {
+          sequence.push({
+            outcome: 'cut',
+            target: target,
+            purpose: purpose
+          });
+        },
+        logEventStopped: function (_name, target, purpose) {
+          sequence.push({
+            outcome: 'stopped',
+            target: target,
+            purpose: purpose
+          });
+        },
+        logNoParent: function (_name, target, purpose) {
+          sequence.push({
+            outcome: 'no-parent',
+            target: target,
+            purpose: purpose
+          });
+        },
+        logEventNoHandlers: function (_name, target) {
+          sequence.push({
+            outcome: 'no-handlers-left',
+            target: target
+          });
+        },
+        logEventResponse: function (_name, target, purpose) {
+          sequence.push({
+            outcome: 'response',
+            purpose: purpose,
+            target: target
+          });
+        },
+        write: function () {
+          var finishTime = new Date().getTime();
+          if (contains$2([
+              'mousemove',
+              'mouseover',
+              'mouseout',
+              systemInit()
+            ], eventName)) {
+            return;
+          }
+          console.log(eventName, {
+            event: eventName,
+            time: finishTime - startTime,
+            target: initialTarget.dom,
+            sequence: map$2(sequence, function (s) {
+              if (!contains$2([
+                  'cut',
+                  'stopped',
+                  'response'
+                ], s.outcome)) {
+                return s.outcome;
+              } else {
+                return '{' + s.purpose + '} ' + s.outcome + ' at (' + element(s.target) + ')';
+              }
+            })
+          });
+        }
+      };
+    };
+    var processEvent = function (eventName, initialTarget, f) {
+      var status = get$e(eventConfig.get(), eventName).orThunk(function () {
+        var patterns = keys(eventConfig.get());
+        return findMap(patterns, function (p) {
+          return eventName.indexOf(p) > -1 ? Optional.some(eventConfig.get()[p]) : Optional.none();
+        });
+      }).getOr(EventConfiguration.NORMAL);
+      switch (status) {
+      case EventConfiguration.NORMAL:
+        return f(noLogger());
+      case EventConfiguration.LOGGING: {
+          var logger = makeEventLogger(eventName, initialTarget);
+          var output = f(logger);
+          logger.write();
+          return output;
+        }
+      case EventConfiguration.STOP:
+        return true;
+      }
+    };
+    var path = [
+      'alloy/data/Fields',
+      'alloy/debugging/Debugging'
+    ];
+    var getTrace = function () {
+      var err = new Error();
+      if (err.stack !== undefined) {
+        var lines = err.stack.split('\n');
+        return find$5(lines, function (line) {
+          return line.indexOf('alloy') > 0 && !exists(path, function (p) {
+            return line.indexOf(p) > -1;
+          });
+        }).getOr(unknown);
+      } else {
+        return unknown;
+      }
+    };
+    var ignoreEvent = {
+      logEventCut: noop,
+      logEventStopped: noop,
+      logNoParent: noop,
+      logEventNoHandlers: noop,
+      logEventResponse: noop,
+      write: noop
+    };
+    var monitorEvent = function (eventName, initialTarget, f) {
+      return processEvent(eventName, initialTarget, f);
+    };
+    var noLogger = constant$1(ignoreEvent);
+
+    var menuFields = constant$1([
+      required$1('menu'),
+      required$1('selectedMenu')
+    ]);
+    var itemFields = constant$1([
+      required$1('item'),
+      required$1('selectedItem')
+    ]);
+    constant$1(objOf(itemFields().concat(menuFields())));
+    var itemSchema$3 = constant$1(objOf(itemFields()));
+
+    var _initSize = requiredObjOf('initSize', [
+      required$1('numColumns'),
+      required$1('numRows')
+    ]);
+    var itemMarkers = function () {
+      return requiredOf('markers', itemSchema$3());
+    };
+    var tieredMenuMarkers = function () {
+      return requiredObjOf('markers', [required$1('backgroundMenu')].concat(menuFields()).concat(itemFields()));
+    };
+    var markers$1 = function (required) {
+      return requiredObjOf('markers', map$2(required, required$1));
+    };
+    var onPresenceHandler = function (label, fieldName, presence) {
+      getTrace();
+      return field$1(fieldName, fieldName, presence, valueOf(function (f) {
+        return Result.value(function () {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return f.apply(undefined, args);
+        });
+      }));
+    };
+    var onHandler = function (fieldName) {
+      return onPresenceHandler('onHandler', fieldName, defaulted$1(noop));
+    };
+    var onKeyboardHandler = function (fieldName) {
+      return onPresenceHandler('onKeyboardHandler', fieldName, defaulted$1(Optional.none));
+    };
+    var onStrictHandler = function (fieldName) {
+      return onPresenceHandler('onHandler', fieldName, required$2());
+    };
+    var onStrictKeyboardHandler = function (fieldName) {
+      return onPresenceHandler('onKeyboardHandler', fieldName, required$2());
+    };
+    var output$1 = function (name, value) {
+      return customField(name, constant$1(value));
+    };
+    var snapshot = function (name) {
+      return customField(name, identity$1);
+    };
+    var initSize = constant$1(_initSize);
+
+    var nu$6 = function (x, y, bubble, direction, placement, boundsRestriction, labelPrefix, alwaysFit) {
+      if (alwaysFit === void 0) {
+        alwaysFit = false;
+      }
+      return {
+        x: x,
+        y: y,
+        bubble: bubble,
+        direction: direction,
+        placement: placement,
+        restriction: boundsRestriction,
+        label: labelPrefix + '-' + placement,
+        alwaysFit: alwaysFit
+      };
+    };
+
+    var adt$a = Adt.generate([
+      { southeast: [] },
+      { southwest: [] },
+      { northeast: [] },
+      { northwest: [] },
+      { south: [] },
+      { north: [] },
+      { east: [] },
+      { west: [] }
+    ]);
+    var cata$2 = function (subject, southeast, southwest, northeast, northwest, south, north, east, west) {
+      return subject.fold(southeast, southwest, northeast, northwest, south, north, east, west);
+    };
+    var cataVertical = function (subject, south, middle, north) {
+      return subject.fold(south, south, north, north, south, north, middle, middle);
+    };
+    var cataHorizontal = function (subject, east, middle, west) {
+      return subject.fold(east, west, east, west, middle, middle, east, west);
+    };
+    var southeast$3 = adt$a.southeast;
+    var southwest$3 = adt$a.southwest;
+    var northeast$3 = adt$a.northeast;
+    var northwest$3 = adt$a.northwest;
+    var south$3 = adt$a.south;
+    var north$3 = adt$a.north;
+    var east$3 = adt$a.east;
+    var west$3 = adt$a.west;
+
+    var cycleBy = function (value, delta, min, max) {
+      var r = value + delta;
+      if (r > max) {
+        return min;
+      } else if (r < min) {
+        return max;
+      } else {
+        return r;
+      }
+    };
+    var clamp$1 = function (value, min, max) {
+      return Math.min(Math.max(value, min), max);
+    };
+
+    var getRestriction = function (anchor, restriction) {
+      switch (restriction) {
+      case 1:
+        return anchor.x;
+      case 0:
+        return anchor.x + anchor.width;
+      case 2:
+        return anchor.y;
+      case 3:
+        return anchor.y + anchor.height;
+      }
+    };
+    var boundsRestriction = function (anchor, restrictions) {
+      return mapToObject([
+        'left',
+        'right',
+        'top',
+        'bottom'
+      ], function (dir) {
+        return get$e(restrictions, dir).map(function (restriction) {
+          return getRestriction(anchor, restriction);
+        });
+      });
+    };
+    var adjustBounds = function (bounds$1, restriction, bubbleOffset) {
+      var applyRestriction = function (dir, current) {
+        return restriction[dir].map(function (pos) {
+          var isVerticalAxis = dir === 'top' || dir === 'bottom';
+          var offset = isVerticalAxis ? bubbleOffset.top : bubbleOffset.left;
+          var comparator = dir === 'left' || dir === 'top' ? Math.max : Math.min;
+          var newPos = comparator(pos, current) + offset;
+          return isVerticalAxis ? clamp$1(newPos, bounds$1.y, bounds$1.bottom) : clamp$1(newPos, bounds$1.x, bounds$1.right);
+        }).getOr(current);
+      };
+      var adjustedLeft = applyRestriction('left', bounds$1.x);
+      var adjustedTop = applyRestriction('top', bounds$1.y);
+      var adjustedRight = applyRestriction('right', bounds$1.right);
+      var adjustedBottom = applyRestriction('bottom', bounds$1.bottom);
+      return bounds(adjustedLeft, adjustedTop, adjustedRight - adjustedLeft, adjustedBottom - adjustedTop);
+    };
+
+    var labelPrefix$2 = 'layout';
+    var eastX$1 = function (anchor) {
+      return anchor.x;
+    };
+    var middleX$1 = function (anchor, element) {
+      return anchor.x + anchor.width / 2 - element.width / 2;
+    };
+    var westX$1 = function (anchor, element) {
+      return anchor.x + anchor.width - element.width;
+    };
+    var northY$2 = function (anchor, element) {
+      return anchor.y - element.height;
+    };
+    var southY$2 = function (anchor) {
+      return anchor.y + anchor.height;
+    };
+    var centreY$1 = function (anchor, element) {
+      return anchor.y + anchor.height / 2 - element.height / 2;
+    };
+    var eastEdgeX$1 = function (anchor) {
+      return anchor.x + anchor.width;
+    };
+    var westEdgeX$1 = function (anchor, element) {
+      return anchor.x - element.width;
+    };
+    var southeast$2 = function (anchor, element, bubbles) {
+      return nu$6(eastX$1(anchor), southY$2(anchor), bubbles.southeast(), southeast$3(), 'southeast', boundsRestriction(anchor, {
+        left: 1,
+        top: 3
+      }), labelPrefix$2);
+    };
+    var southwest$2 = function (anchor, element, bubbles) {
+      return nu$6(westX$1(anchor, element), southY$2(anchor), bubbles.southwest(), southwest$3(), 'southwest', boundsRestriction(anchor, {
+        right: 0,
+        top: 3
+      }), labelPrefix$2);
+    };
+    var northeast$2 = function (anchor, element, bubbles) {
+      return nu$6(eastX$1(anchor), northY$2(anchor, element), bubbles.northeast(), northeast$3(), 'northeast', boundsRestriction(anchor, {
+        left: 1,
+        bottom: 2
+      }), labelPrefix$2);
+    };
+    var northwest$2 = function (anchor, element, bubbles) {
+      return nu$6(westX$1(anchor, element), northY$2(anchor, element), bubbles.northwest(), northwest$3(), 'northwest', boundsRestriction(anchor, {
+        right: 0,
+        bottom: 2
+      }), labelPrefix$2);
+    };
+    var north$2 = function (anchor, element, bubbles) {
+      return nu$6(middleX$1(anchor, element), northY$2(anchor, element), bubbles.north(), north$3(), 'north', boundsRestriction(anchor, { bottom: 2 }), labelPrefix$2);
+    };
+    var south$2 = function (anchor, element, bubbles) {
+      return nu$6(middleX$1(anchor, element), southY$2(anchor), bubbles.south(), south$3(), 'south', boundsRestriction(anchor, { top: 3 }), labelPrefix$2);
+    };
+    var east$2 = function (anchor, element, bubbles) {
+      return nu$6(eastEdgeX$1(anchor), centreY$1(anchor, element), bubbles.east(), east$3(), 'east', boundsRestriction(anchor, { left: 0 }), labelPrefix$2);
+    };
+    var west$2 = function (anchor, element, bubbles) {
+      return nu$6(westEdgeX$1(anchor, element), centreY$1(anchor, element), bubbles.west(), west$3(), 'west', boundsRestriction(anchor, { right: 1 }), labelPrefix$2);
+    };
+    var all$1 = function () {
+      return [
+        southeast$2,
+        southwest$2,
+        northeast$2,
+        northwest$2,
+        south$2,
+        north$2,
+        east$2,
+        west$2
+      ];
+    };
+    var allRtl$1 = function () {
+      return [
+        southwest$2,
+        southeast$2,
+        northwest$2,
+        northeast$2,
+        south$2,
+        north$2,
+        east$2,
+        west$2
+      ];
+    };
+    var aboveOrBelow = function () {
+      return [
+        northeast$2,
+        northwest$2,
+        southeast$2,
+        southwest$2,
+        north$2,
+        south$2
+      ];
+    };
+    var aboveOrBelowRtl = function () {
+      return [
+        northwest$2,
+        northeast$2,
+        southwest$2,
+        southeast$2,
+        north$2,
+        south$2
+      ];
+    };
+    var belowOrAbove = function () {
+      return [
+        southeast$2,
+        southwest$2,
+        northeast$2,
+        northwest$2,
+        south$2,
+        north$2
+      ];
+    };
+    var belowOrAboveRtl = function () {
+      return [
+        southwest$2,
+        southeast$2,
+        northwest$2,
+        northeast$2,
+        south$2,
+        north$2
+      ];
+    };
+
+    var chooseChannels = function (channels, message) {
+      return message.universal ? channels : filter$2(channels, function (ch) {
+        return contains$2(message.channels, ch);
+      });
+    };
+    var events$h = function (receiveConfig) {
+      return derive$2([run$1(receive(), function (component, message) {
+          var channelMap = receiveConfig.channels;
+          var channels = keys(channelMap);
+          var receivingData = message;
+          var targetChannels = chooseChannels(channels, receivingData);
+          each$1(targetChannels, function (ch) {
+            var channelInfo = channelMap[ch];
+            var channelSchema = channelInfo.schema;
+            var data = asRawOrDie$1('channel[' + ch + '] data\nReceiver: ' + element(component.element), channelSchema, receivingData.data);
+            channelInfo.onReceive(component, data);
+          });
+        })]);
+    };
+
+    var ActiveReceiving = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$h
+    });
+
+    var ReceivingSchema = [requiredOf('channels', setOf(Result.value, objOfOnly([
+        onStrictHandler('onReceive'),
+        defaulted('schema', anyValue())
+      ])))];
+
+    var executeEvent = function (bConfig, bState, executor) {
+      return runOnExecute$1(function (component) {
+        executor(component, bConfig, bState);
+      });
+    };
+    var loadEvent = function (bConfig, bState, f) {
+      return runOnInit(function (component, _simulatedEvent) {
+        f(component, bConfig, bState);
+      });
+    };
+    var create$9 = function (schema, name, active, apis, extra, state) {
+      var configSchema = objOfOnly(schema);
+      var schemaSchema = optionObjOf(name, [optionObjOfOnly('config', schema)]);
+      return doCreate(configSchema, schemaSchema, name, active, apis, extra, state);
+    };
+    var createModes$1 = function (modes, name, active, apis, extra, state) {
+      var configSchema = modes;
+      var schemaSchema = optionObjOf(name, [optionOf('config', modes)]);
+      return doCreate(configSchema, schemaSchema, name, active, apis, extra, state);
+    };
+    var wrapApi = function (bName, apiFunction, apiName) {
+      var f = function (component) {
+        var rest = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+          rest[_i - 1] = arguments[_i];
+        }
+        var args = [component].concat(rest);
+        return component.config({ name: constant$1(bName) }).fold(function () {
+          throw new Error('We could not find any behaviour configuration for: ' + bName + '. Using API: ' + apiName);
+        }, function (info) {
+          var rest = Array.prototype.slice.call(args, 1);
+          return apiFunction.apply(undefined, [
+            component,
+            info.config,
+            info.state
+          ].concat(rest));
+        });
+      };
+      return markAsBehaviourApi(f, apiName, apiFunction);
+    };
+    var revokeBehaviour = function (name) {
+      return {
+        key: name,
+        value: undefined
+      };
+    };
+    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$1(apis, function (apiF, apiName) {
+        return wrapApi(name, apiF, apiName);
+      });
+      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 prepared = asRawOrDie$1(name + '-config', configSchema, spec);
+          return {
+            key: name,
+            value: {
+              config: prepared,
+              me: me,
+              configAsRaw: cached(function () {
+                return asRawOrDie$1(name + '-config', configSchema, spec);
+              }),
+              initialConfig: spec,
+              state: state
+            }
+          };
+        },
+        schema: constant$1(schemaSchema),
+        exhibit: function (info, base) {
+          return lift2(getConfig(info), get$e(active, 'exhibit'), function (behaviourInfo, exhibitor) {
+            return exhibitor(base, behaviourInfo.config, behaviourInfo.state);
+          }).getOrThunk(function () {
+            return nu$7({});
+          });
+        },
+        name: constant$1(name),
+        handlers: function (info) {
+          return getConfig(info).map(function (behaviourInfo) {
+            var getEvents = get$e(active, 'events').getOr(function () {
+              return {};
+            });
+            return getEvents(behaviourInfo.config, behaviourInfo.state);
+          }).getOr({});
+        }
+      });
+      return me;
+    };
+
+    var derive$1 = function (capabilities) {
+      return wrapAll(capabilities);
+    };
+    var simpleSchema = objOfOnly([
+      required$1('fields'),
+      required$1('name'),
+      defaulted('active', {}),
+      defaulted('apis', {}),
+      defaulted('state', NoState),
+      defaulted('extra', {})
+    ]);
+    var create$8 = function (data) {
+      var value = asRawOrDie$1('Creating behaviour: ' + data.name, simpleSchema, data);
+      return create$9(value.fields, value.name, value.active, value.apis, value.extra, value.state);
+    };
+    var modeSchema = objOfOnly([
+      required$1('branchKey'),
+      required$1('branches'),
+      required$1('name'),
+      defaulted('active', {}),
+      defaulted('apis', {}),
+      defaulted('state', NoState),
+      defaulted('extra', {})
+    ]);
+    var createModes = function (data) {
+      var value = asRawOrDie$1('Creating behaviour: ' + data.name, modeSchema, data);
+      return createModes$1(choose$1(value.branchKey, value.branches), value.name, value.active, value.apis, value.extra, value.state);
+    };
+    var revoke = constant$1(undefined);
+
+    var Receiving = create$8({
+      fields: ReceivingSchema,
+      name: 'receiving',
+      active: ActiveReceiving
+    });
+
+    var exhibit$6 = function (base, posConfig) {
+      return nu$7({
+        classes: [],
+        styles: posConfig.useFixed() ? {} : { position: 'relative' }
+      });
+    };
+
+    var ActivePosition = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit$6
+    });
+
+    var getDocument = function () {
+      return SugarElement.fromDom(document);
+    };
+
+    var focus$3 = function (element) {
+      return element.dom.focus();
+    };
+    var blur$1 = function (element) {
+      return element.dom.blur();
+    };
+    var hasFocus = function (element) {
+      var root = getRootNode(element).dom;
+      return element.dom === root.activeElement;
+    };
+    var active = function (root) {
+      if (root === void 0) {
+        root = getDocument();
+      }
+      return Optional.from(root.dom.activeElement).map(SugarElement.fromDom);
+    };
+    var search = function (element) {
+      return active(getRootNode(element)).filter(function (e) {
+        return element.dom.contains(e.dom);
+      });
+    };
+
+    var preserve$1 = function (f, container) {
+      var dos = getRootNode(container);
+      var refocus = active(dos).bind(function (focused) {
+        var hasFocus = function (elem) {
+          return eq(focused, elem);
+        };
+        return hasFocus(container) ? Optional.some(container) : descendant$1(container, hasFocus);
+      });
+      var result = f(container);
+      refocus.each(function (oldFocus) {
+        active(dos).filter(function (newFocus) {
+          return eq(newFocus, oldFocus);
+        }).fold(function () {
+          focus$3(oldFocus);
+        }, noop);
+      });
+      return result;
+    };
+
+    var NuPositionCss = function (position, left, top, right, bottom) {
+      var toPx = function (num) {
+        return num + 'px';
+      };
+      return {
+        position: position,
+        left: left.map(toPx),
+        top: top.map(toPx),
+        right: right.map(toPx),
+        bottom: bottom.map(toPx)
+      };
+    };
+    var toOptions = function (position) {
+      return __assign(__assign({}, position), { position: Optional.some(position.position) });
+    };
+    var applyPositionCss = function (element, position) {
+      setOptions(element, toOptions(position));
+    };
+
+    var adt$9 = Adt.generate([
+      { none: [] },
+      {
+        relative: [
+          'x',
+          'y',
+          'width',
+          'height'
+        ]
+      },
+      {
+        fixed: [
+          'x',
+          'y',
+          'width',
+          'height'
+        ]
+      }
+    ]);
+    var positionWithDirection = function (posName, decision, x, y, width, height) {
+      var decisionRect = decision.rect;
+      var decisionX = decisionRect.x - x;
+      var decisionY = decisionRect.y - y;
+      var decisionWidth = decisionRect.width;
+      var decisionHeight = decisionRect.height;
+      var decisionRight = width - (decisionX + decisionWidth);
+      var decisionBottom = height - (decisionY + decisionHeight);
+      var left = Optional.some(decisionX);
+      var top = Optional.some(decisionY);
+      var right = Optional.some(decisionRight);
+      var bottom = Optional.some(decisionBottom);
+      var none = Optional.none();
+      return cata$2(decision.direction, function () {
+        return NuPositionCss(posName, left, top, none, none);
+      }, function () {
+        return NuPositionCss(posName, none, top, right, none);
+      }, function () {
+        return NuPositionCss(posName, left, none, none, bottom);
+      }, function () {
+        return NuPositionCss(posName, none, none, right, bottom);
+      }, function () {
+        return NuPositionCss(posName, left, top, none, none);
+      }, function () {
+        return NuPositionCss(posName, left, none, none, bottom);
+      }, function () {
+        return NuPositionCss(posName, left, top, none, none);
+      }, function () {
+        return NuPositionCss(posName, none, top, right, none);
+      });
+    };
+    var reposition = function (origin, decision) {
+      return origin.fold(function () {
+        var decisionRect = decision.rect;
+        return NuPositionCss('absolute', Optional.some(decisionRect.x), Optional.some(decisionRect.y), Optional.none(), Optional.none());
+      }, function (x, y, width, height) {
+        return positionWithDirection('absolute', decision, x, y, width, height);
+      }, function (x, y, width, height) {
+        return positionWithDirection('fixed', decision, x, y, width, height);
+      });
+    };
+    var toBox = function (origin, element) {
+      var rel = curry(find$2, element);
+      var position = origin.fold(rel, rel, function () {
+        var scroll = get$9();
+        return find$2(element).translate(-scroll.left, -scroll.top);
+      });
+      var width = 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);
+      }, function (b) {
+        return origin.fold(b, b, function () {
+          var bounds$1 = b();
+          var pos = translate$2(origin, bounds$1.x, bounds$1.y);
+          return bounds(pos.left, pos.top, bounds$1.width, bounds$1.height);
+        });
+      });
+    };
+    var translate$2 = function (origin, x, y) {
+      var pos = SugarPosition(x, y);
+      var removeScroll = function () {
+        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 subject.fold(onNone, onRelative, onFixed);
+    };
+    adt$9.none;
+    var relative$1 = adt$9.relative;
+    var fixed$1 = adt$9.fixed;
+
+    var anchor = function (anchorBox, origin) {
+      return {
+        anchorBox: anchorBox,
+        origin: origin
+      };
+    };
+    var box = function (anchorBox, origin) {
+      return anchor(anchorBox, origin);
+    };
+
+    var placementAttribute = 'data-alloy-placement';
+    var setPlacement$1 = function (element, placement) {
+      set$8(element, placementAttribute, placement);
+    };
+    var getPlacement = function (element) {
+      return getOpt(element, placementAttribute);
+    };
+    var reset$2 = function (element) {
+      return remove$7(element, placementAttribute);
+    };
+
+    var adt$8 = Adt.generate([
+      { fit: ['reposition'] },
+      {
+        nofit: [
+          'reposition',
+          'visibleW',
+          'visibleH',
+          'isVisible'
+        ]
+      }
+    ]);
+    var determinePosition = function (box, bounds) {
+      var boundsX = bounds.x, boundsY = bounds.y, boundsRight = bounds.right, boundsBottom = bounds.bottom;
+      var x = box.x, y = box.y, right = box.right, bottom = box.bottom, width = box.width, height = box.height;
+      var xInBounds = x >= boundsX && x <= boundsRight;
+      var yInBounds = y >= boundsY && y <= boundsBottom;
+      var originInBounds = xInBounds && yInBounds;
+      var rightInBounds = right <= boundsRight && right >= boundsX;
+      var bottomInBounds = bottom <= boundsBottom && bottom >= boundsY;
+      var sizeInBounds = rightInBounds && bottomInBounds;
+      var visibleW = Math.min(width, x >= boundsX ? boundsRight - x : right - boundsX);
+      var visibleH = Math.min(height, y >= boundsY ? boundsBottom - y : bottom - boundsY);
+      return {
+        originInBounds: originInBounds,
+        sizeInBounds: sizeInBounds,
+        visibleW: visibleW,
+        visibleH: visibleH
+      };
+    };
+    var calcReposition = function (box, bounds$1) {
+      var boundsX = bounds$1.x, boundsY = bounds$1.y, boundsRight = bounds$1.right, boundsBottom = bounds$1.bottom;
+      var x = box.x, y = box.y, width = box.width, height = box.height;
+      var maxX = Math.max(boundsX, boundsRight - width);
+      var maxY = Math.max(boundsY, boundsBottom - height);
+      var restrictedX = clamp$1(x, boundsX, maxX);
+      var restrictedY = clamp$1(y, boundsY, maxY);
+      var restrictedWidth = Math.min(restrictedX + width, boundsRight) - restrictedX;
+      var restrictedHeight = Math.min(restrictedY + height, boundsBottom) - restrictedY;
+      return bounds(restrictedX, restrictedY, restrictedWidth, restrictedHeight);
+    };
+    var calcMaxSizes = function (direction, box, bounds) {
+      var upAvailable = constant$1(box.bottom - bounds.y);
+      var downAvailable = constant$1(bounds.bottom - box.y);
+      var maxHeight = cataVertical(direction, downAvailable, downAvailable, upAvailable);
+      var westAvailable = constant$1(box.right - bounds.x);
+      var eastAvailable = constant$1(bounds.right - box.x);
+      var maxWidth = cataHorizontal(direction, eastAvailable, eastAvailable, westAvailable);
+      return {
+        maxWidth: maxWidth,
+        maxHeight: maxHeight
+      };
+    };
+    var attempt = function (candidate, width, height, bounds$1) {
+      var bubble = candidate.bubble;
+      var bubbleOffset = bubble.offset;
+      var adjustedBounds = adjustBounds(bounds$1, candidate.restriction, bubbleOffset);
+      var newX = candidate.x + bubbleOffset.left;
+      var newY = candidate.y + bubbleOffset.top;
+      var box = bounds(newX, newY, width, height);
+      var _a = determinePosition(box, adjustedBounds), originInBounds = _a.originInBounds, sizeInBounds = _a.sizeInBounds, visibleW = _a.visibleW, visibleH = _a.visibleH;
+      var fits = originInBounds && sizeInBounds;
+      var fittedBox = fits ? box : calcReposition(box, adjustedBounds);
+      var isPartlyVisible = fittedBox.width > 0 && fittedBox.height > 0;
+      var _b = calcMaxSizes(candidate.direction, fittedBox, bounds$1), maxWidth = _b.maxWidth, maxHeight = _b.maxHeight;
+      var reposition = {
+        rect: fittedBox,
+        maxHeight: maxHeight,
+        maxWidth: maxWidth,
+        direction: candidate.direction,
+        placement: candidate.placement,
+        classes: {
+          on: bubble.classesOn,
+          off: bubble.classesOff
+        },
+        layout: candidate.label,
+        testY: newY
+      };
+      return fits || candidate.alwaysFit ? adt$8.fit(reposition) : adt$8.nofit(reposition, visibleW, visibleH, isPartlyVisible);
+    };
+    var attempts = function (element, candidates, anchorBox, elementBox, bubbles, bounds) {
+      var panelWidth = elementBox.width;
+      var panelHeight = elementBox.height;
+      var attemptBestFit = function (layout, reposition, visibleW, visibleH, isVisible) {
+        var next = layout(anchorBox, elementBox, bubbles, element, bounds);
+        var attemptLayout = attempt(next, panelWidth, panelHeight, bounds);
+        return attemptLayout.fold(constant$1(attemptLayout), function (newReposition, newVisibleW, newVisibleH, newIsVisible) {
+          var improved = isVisible === newIsVisible ? newVisibleH > visibleH || newVisibleW > visibleW : !isVisible && newIsVisible;
+          return improved ? attemptLayout : adt$8.nofit(reposition, visibleW, visibleH, isVisible);
+        });
+      };
+      var abc = foldl(candidates, function (b, a) {
+        var bestNext = curry(attemptBestFit, a);
+        return b.fold(constant$1(b), bestNext);
+      }, adt$8.nofit({
+        rect: anchorBox,
+        maxHeight: elementBox.height,
+        maxWidth: elementBox.width,
+        direction: southeast$3(),
+        placement: 'southeast',
+        classes: {
+          on: [],
+          off: []
+        },
+        layout: 'none',
+        testY: anchorBox.y
+      }, -1, -1, false));
+      return abc.fold(identity$1, identity$1);
+    };
+
+    var singleton = function (doRevoke) {
+      var subject = Cell(Optional.none());
+      var revoke = function () {
+        return subject.get().each(doRevoke);
+      };
+      var clear = function () {
+        revoke();
+        subject.set(Optional.none());
+      };
+      var isSet = function () {
+        return subject.get().isSome();
+      };
+      var get = function () {
+        return subject.get();
+      };
+      var set = function (s) {
+        revoke();
+        subject.set(Optional.some(s));
+      };
+      return {
+        clear: clear,
+        isSet: isSet,
+        get: get,
+        set: set
+      };
+    };
+    var destroyable = function () {
+      return singleton(function (s) {
+        return s.destroy();
+      });
+    };
+    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$2(element, event, filter, handler);
+    };
+    var capture = function (element, event, handler) {
+      return capture$1(element, event, filter, handler);
+    };
+    var fromRawEvent = fromRawEvent$1;
+
+    var properties = [
+      'top',
+      'bottom',
+      'right',
+      'left'
+    ];
+    var timerAttr = 'data-alloy-transition-timer';
+    var isTransitioning$1 = function (element, transition) {
+      return hasAll(element, transition.classes);
+    };
+    var shouldApplyTransitionCss = function (transition, decision, lastPlacement) {
+      return lastPlacement.exists(function (placer) {
+        var mode = transition.mode;
+        return mode === 'all' ? true : placer[mode] !== decision[mode];
+      });
+    };
+    var hasChanges = function (position, intermediate) {
+      var round = function (value) {
+        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$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)) {
+          var num = parseFloat(value);
+          return endsWith(value, 'ms') ? num : num * 1000;
+        } else {
+          return 0;
+        }
+      };
+      var delay = get('transition-delay');
+      var duration = get('transition-duration');
+      return foldl(duration, function (acc, dur, i) {
+        var time = parse(delay[i]) + parse(dur);
+        return Math.max(acc, time);
+      }, 0);
+    };
+    var setupTransitionListeners = function (element, transition) {
+      var transitionEnd = unbindable();
+      var transitionCancel = unbindable();
+      var timer;
+      var isSourceTransition = function (e) {
+        var _a;
+        var pseudoElement = (_a = e.raw.pseudoElement) !== null && _a !== void 0 ? _a : '';
+        return eq(e.target, element) && isEmpty(pseudoElement) && contains$2(properties, e.raw.propertyName);
+      };
+      var transitionDone = function (e) {
+        if (isNullable(e) || isSourceTransition(e)) {
+          transitionEnd.clear();
+          transitionCancel.clear();
+          var type = e === null || e === void 0 ? void 0 : e.raw.type;
+          if (isNullable(type) || type === transitionend()) {
+            clearTimeout(timer);
+            remove$7(element, timerAttr);
+            remove$1(element, transition.classes);
+          }
+        }
+      };
+      var transitionStarted = function () {
+        transitionEnd.set(bind(element, transitionend(), transitionDone));
+        transitionCancel.set(bind(element, transitioncancel(), transitionDone));
+      };
+      if ('ontransitionstart' in element.dom) {
+        var transitionStart_1 = bind(element, transitionstart(), function (e) {
+          if (isSourceTransition(e)) {
+            transitionStart_1.unbind();
+            transitionStarted();
+          }
+        });
+      } else {
+        transitionStarted();
+      }
+      var duration = getTransitionDuration(element);
+      requestAnimationFrame(function () {
+        timer = setTimeout(transitionDone, duration + 17);
+        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$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$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];
+        });
+        if (hasChanges(position, intermediateCssOptions)) {
+          setOptions(element, intermediateCssOptions);
+          if (shouldTransition) {
+            startTransitioning(element, transition);
+          }
+          reflow(element);
+        }
+      } else {
+        remove$1(element, transition.classes);
+      }
+    };
+
+    var elementSize = function (p) {
+      return {
+        width: getOuter$1(p),
+        height: getOuter$2(p)
+      };
+    };
+    var layout = function (anchorBox, element, bubbles, options) {
+      remove$6(element, 'max-height');
+      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$1(element, classInfo.off);
+      add$1(element, classInfo.on);
+    };
+    var setHeight = function (element, decision, options) {
+      var maxHeightFunction = options.maxHeightFunction;
+      maxHeightFunction(element, decision.maxHeight);
+    };
+    var setWidth = function (element, decision, options) {
+      var maxWidthFunction = options.maxWidthFunction;
+      maxWidthFunction(element, decision.maxWidth);
+    };
+    var position$2 = function (element, decision, options) {
+      var positionCss = reposition(options.origin, decision);
+      options.transition.each(function (transition) {
+        applyTransitionCss(element, options.origin, positionCss, transition, decision, options.lastPlacement);
+      });
+      applyPositionCss(element, positionCss);
+    };
+    var setPlacement = function (element, decision) {
+      setPlacement$1(element, decision.placement);
+    };
+
+    var setMaxHeight = function (element, maxHeight) {
+      setMax$1(element, Math.floor(maxHeight));
+    };
+    var anchored = constant$1(function (element, available) {
+      setMaxHeight(element, available);
+      setAll(element, {
+        'overflow-x': 'hidden',
+        'overflow-y': 'auto'
+      });
+    });
+    var expandable$1 = constant$1(function (element, available) {
+      setMaxHeight(element, available);
+    });
+
+    var defaultOr = function (options, key, dephault) {
+      return options[key] === undefined ? dephault : options[key];
+    };
+    var simple = function (anchor, element, bubble, layouts, lastPlacement, getBounds, overrideOptions, transition) {
+      var maxHeightFunction = defaultOr(overrideOptions, 'maxHeightFunction', anchored());
+      var maxWidthFunction = defaultOr(overrideOptions, 'maxWidthFunction', noop);
+      var anchorBox = anchor.anchorBox;
+      var origin = anchor.origin;
+      var options = {
+        bounds: viewport(origin, getBounds),
+        origin: origin,
+        preference: layouts,
+        maxHeightFunction: maxHeightFunction,
+        maxWidthFunction: maxWidthFunction,
+        lastPlacement: lastPlacement,
+        transition: transition
+      };
+      return go(anchorBox, element, bubble, options);
+    };
+    var go = function (anchorBox, element, bubble, options) {
+      var decision = layout(anchorBox, element, bubble, options);
+      position$2(element, decision, options);
+      setPlacement(element, decision);
+      setClasses(element, decision);
+      setHeight(element, decision, options);
+      setWidth(element, decision, options);
+      return {
+        layout: decision.layout,
+        placement: decision.placement
+      };
+    };
+
+    var allAlignments = [
+      'valignCentre',
+      'alignLeft',
+      'alignRight',
+      'alignCentre',
+      'top',
+      'bottom',
+      'left',
+      'right',
+      'inset'
+    ];
+    var nu$5 = function (xOffset, yOffset, classes, insetModifier) {
+      if (insetModifier === void 0) {
+        insetModifier = 1;
+      }
+      var insetXOffset = xOffset * insetModifier;
+      var insetYOffset = yOffset * insetModifier;
+      var getClasses = function (prop) {
+        return get$e(classes, prop).getOr([]);
+      };
+      var make = function (xDelta, yDelta, alignmentsOn) {
+        var alignmentsOff = difference(allAlignments, alignmentsOn);
+        return {
+          offset: SugarPosition(xDelta, yDelta),
+          classesOn: bind$3(alignmentsOn, getClasses),
+          classesOff: bind$3(alignmentsOff, getClasses)
+        };
+      };
+      return {
+        southeast: function () {
+          return make(-xOffset, yOffset, [
+            'top',
+            'alignLeft'
+          ]);
+        },
+        southwest: function () {
+          return make(xOffset, yOffset, [
+            'top',
+            'alignRight'
+          ]);
+        },
+        south: function () {
+          return make(-xOffset / 2, yOffset, [
+            'top',
+            'alignCentre'
+          ]);
+        },
+        northeast: function () {
+          return make(-xOffset, -yOffset, [
+            'bottom',
+            'alignLeft'
+          ]);
+        },
+        northwest: function () {
+          return make(xOffset, -yOffset, [
+            'bottom',
+            'alignRight'
+          ]);
+        },
+        north: function () {
+          return make(-xOffset / 2, -yOffset, [
+            'bottom',
+            'alignCentre'
+          ]);
+        },
+        east: function () {
+          return make(xOffset, -yOffset / 2, [
+            'valignCentre',
+            'left'
+          ]);
+        },
+        west: function () {
+          return make(-xOffset, -yOffset / 2, [
+            'valignCentre',
+            'right'
+          ]);
+        },
+        insetNortheast: function () {
+          return make(insetXOffset, insetYOffset, [
+            'top',
+            'alignLeft',
+            'inset'
+          ]);
+        },
+        insetNorthwest: function () {
+          return make(-insetXOffset, insetYOffset, [
+            'top',
+            'alignRight',
+            'inset'
+          ]);
+        },
+        insetNorth: function () {
+          return make(-insetXOffset / 2, insetYOffset, [
+            'top',
+            'alignCentre',
+            'inset'
+          ]);
+        },
+        insetSoutheast: function () {
+          return make(insetXOffset, -insetYOffset, [
+            'bottom',
+            'alignLeft',
+            'inset'
+          ]);
+        },
+        insetSouthwest: function () {
+          return make(-insetXOffset, -insetYOffset, [
+            'bottom',
+            'alignRight',
+            'inset'
+          ]);
+        },
+        insetSouth: function () {
+          return make(-insetXOffset / 2, -insetYOffset, [
+            'bottom',
+            'alignCentre',
+            'inset'
+          ]);
+        },
+        insetEast: function () {
+          return make(-insetXOffset, -insetYOffset / 2, [
+            'valignCentre',
+            'right',
+            'inset'
+          ]);
+        },
+        insetWest: function () {
+          return make(insetXOffset, -insetYOffset / 2, [
+            'valignCentre',
+            'left',
+            'inset'
+          ]);
+        }
+      };
+    };
+    var fallback = function () {
+      return nu$5(0, 0, {});
+    };
+
+    var nu$4 = identity$1;
+
+    var onDirection = function (isLtr, isRtl) {
+      return function (element) {
+        return getDirection(element) === 'rtl' ? isRtl : isLtr;
+      };
+    };
+    var getDirection = function (element) {
+      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$d(current, 'data-alloy-vertical-dir') === AttributeValue.BottomToTop;
+      });
+    };
+
+    var schema$y = function () {
+      return optionObjOf('layouts', [
+        required$1('onLtr'),
+        required$1('onRtl'),
+        option('onBottomLtr'),
+        option('onBottomRtl')
+      ]);
+    };
+    var get$4 = function (elem, info, defaultLtr, defaultRtl, defaultBottomLtr, defaultBottomRtl, dirElement) {
+      var isBottomToTop = dirElement.map(isBottomToTopDir).getOr(false);
+      var customLtr = info.layouts.map(function (ls) {
+        return ls.onLtr(elem);
+      });
+      var customRtl = info.layouts.map(function (ls) {
+        return ls.onRtl(elem);
+      });
+      var ltr = isBottomToTop ? info.layouts.bind(function (ls) {
+        return ls.onBottomLtr.map(function (f) {
+          return f(elem);
+        });
+      }).or(customLtr).getOr(defaultBottomLtr) : customLtr.getOr(defaultLtr);
+      var rtl = isBottomToTop ? info.layouts.bind(function (ls) {
+        return ls.onBottomRtl.map(function (f) {
+          return f(elem);
+        });
+      }).or(customRtl).getOr(defaultBottomRtl) : customRtl.getOr(defaultRtl);
+      var f = onDirection(ltr, rtl);
+      return f(elem);
+    };
+
+    var placement$4 = function (component, anchorInfo, origin) {
+      var hotspot = anchorInfo.hotspot;
+      var anchorBox = toBox(origin, hotspot.element);
+      var layouts = get$4(component.element, anchorInfo, belowOrAbove(), belowOrAboveRtl(), aboveOrBelow(), aboveOrBelowRtl(), Optional.some(anchorInfo.hotspot.element));
+      return Optional.some(nu$4({
+        anchorBox: anchorBox,
+        bubble: anchorInfo.bubble.getOr(fallback()),
+        overrides: anchorInfo.overrides,
+        layouts: layouts,
+        placer: Optional.none()
+      }));
+    };
+    var HotspotAnchor = [
+      required$1('hotspot'),
+      option('bubble'),
+      defaulted('overrides', {}),
+      schema$y(),
+      output$1('placement', placement$4)
+    ];
+
+    var placement$3 = function (component, anchorInfo, origin) {
+      var pos = translate$2(origin, anchorInfo.x, anchorInfo.y);
+      var anchorBox = bounds(pos.left, pos.top, anchorInfo.width, anchorInfo.height);
+      var layouts = get$4(component.element, anchorInfo, all$1(), allRtl$1(), all$1(), allRtl$1(), Optional.none());
+      return Optional.some(nu$4({
+        anchorBox: anchorBox,
+        bubble: anchorInfo.bubble,
+        overrides: anchorInfo.overrides,
+        layouts: layouts,
+        placer: Optional.none()
+      }));
+    };
+    var MakeshiftAnchor = [
+      required$1('x'),
+      required$1('y'),
+      defaulted('height', 0),
+      defaulted('width', 0),
+      defaulted('bubble', fallback()),
+      defaulted('overrides', {}),
+      schema$y(),
+      output$1('placement', placement$3)
+    ];
+
+    var adt$7 = Adt.generate([
+      { screen: ['point'] },
+      {
+        absolute: [
+          'point',
+          'scrollLeft',
+          'scrollTop'
+        ]
+      }
+    ]);
+    var toFixed = function (pos) {
+      return pos.fold(identity$1, function (point, scrollLeft, scrollTop) {
+        return point.translate(-scrollLeft, -scrollTop);
+      });
+    };
+    var toAbsolute = function (pos) {
+      return pos.fold(identity$1, identity$1);
+    };
+    var sum = function (points) {
+      return foldl(points, function (b, a) {
+        return b.translate(a.left, a.top);
+      }, SugarPosition(0, 0));
+    };
+    var sumAsFixed = function (positions) {
+      var points = map$2(positions, toFixed);
+      return sum(points);
+    };
+    var sumAsAbsolute = function (positions) {
+      var points = map$2(positions, toAbsolute);
+      return sum(points);
+    };
+    var screen = adt$7.screen;
+    var absolute$1 = adt$7.absolute;
+
+    var getOffset = function (component, origin, anchorInfo) {
+      var win = defaultView(anchorInfo.root).dom;
+      var hasSameOwner = function (frame) {
+        var frameOwner = owner$4(frame);
+        var compOwner = owner$4(component.element);
+        return eq(frameOwner, compOwner);
+      };
+      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$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 point = screen(SugarPosition(left, top));
+      return Optional.some(pointed(point, width, height));
+    };
+    var calcNewAnchor = function (optBox, rootPoint, anchorInfo, origin, elem) {
+      return optBox.map(function (box) {
+        var points = [
+          rootPoint,
+          box.point
+        ];
+        var topLeft = cata$1(origin, function () {
+          return sumAsAbsolute(points);
+        }, function () {
+          return sumAsAbsolute(points);
+        }, function () {
+          return sumAsFixed(points);
+        });
+        var anchorBox = rect(topLeft.left, topLeft.top, box.width, box.height);
+        var layoutsLtr = anchorInfo.showAbove ? aboveOrBelow() : belowOrAbove();
+        var layoutsRtl = anchorInfo.showAbove ? aboveOrBelowRtl() : belowOrAboveRtl();
+        var layouts = get$4(elem, anchorInfo, layoutsLtr, layoutsRtl, layoutsLtr, layoutsRtl, Optional.none());
+        return nu$4({
+          anchorBox: anchorBox,
+          bubble: anchorInfo.bubble.getOr(fallback()),
+          overrides: anchorInfo.overrides,
+          layouts: layouts,
+          placer: Optional.none()
+        });
+      });
+    };
+
+    var placement$2 = function (component, anchorInfo, origin) {
+      var rootPoint = getRootPoint(component, origin, anchorInfo);
+      return anchorInfo.node.filter(inBody).bind(function (target) {
+        var rect = target.dom.getBoundingClientRect();
+        var nodeBox = getBox(rect.left, rect.top, rect.width, rect.height);
+        var elem = anchorInfo.node.getOr(component.element);
+        return calcNewAnchor(nodeBox, rootPoint, anchorInfo, origin, elem);
+      });
+    };
+    var NodeAnchor = [
+      required$1('node'),
+      required$1('root'),
+      option('bubble'),
+      schema$y(),
+      defaulted('overrides', {}),
+      defaulted('showAbove', false),
+      output$1('placement', placement$2)
+    ];
+
+    var zeroWidth = '\uFEFF';
+    var nbsp = '\xA0';
+
+    var create$7 = function (start, soffset, finish, foffset) {
+      return {
+        start: start,
+        soffset: soffset,
+        finish: finish,
+        foffset: foffset
+      };
+    };
+    var SimRange = { create: create$7 };
+
+    var adt$6 = Adt.generate([
+      { before: ['element'] },
+      {
+        on: [
+          'element',
+          'offset'
+        ]
+      },
+      { after: ['element'] }
+    ]);
+    var cata = function (subject, onBefore, onOn, onAfter) {
+      return subject.fold(onBefore, onOn, onAfter);
+    };
+    var getStart$1 = function (situ) {
+      return situ.fold(identity$1, identity$1, identity$1);
+    };
+    var before = adt$6.before;
+    var on$1 = adt$6.on;
+    var after$1 = adt$6.after;
+    var Situ = {
+      before: before,
+      on: on$1,
+      after: after$1,
+      cata: cata,
+      getStart: getStart$1
+    };
+
+    var adt$5 = Adt.generate([
+      { domRange: ['rng'] },
+      {
+        relative: [
+          'startSitu',
+          'finishSitu'
+        ]
+      },
+      {
+        exact: [
+          'start',
+          'soffset',
+          'finish',
+          'foffset'
+        ]
+      }
+    ]);
+    var exactFromRange = function (simRange) {
+      return adt$5.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset);
+    };
+    var getStart = function (selection) {
+      return selection.match({
+        domRange: function (rng) {
+          return SugarElement.fromDom(rng.startContainer);
+        },
+        relative: function (startSitu, _finishSitu) {
+          return Situ.getStart(startSitu);
+        },
+        exact: function (start, _soffset, _finish, _foffset) {
+          return start;
+        }
+      });
+    };
+    var domRange = adt$5.domRange;
+    var relative = adt$5.relative;
+    var exact = adt$5.exact;
+    var getWin = function (selection) {
+      var start = getStart(selection);
+      return defaultView(start);
+    };
+    var range$1 = SimRange.create;
+    var SimSelection = {
+      domRange: domRange,
+      relative: relative,
+      exact: exact,
+      exactFromRange: exactFromRange,
+      getWin: getWin,
+      range: range$1
+    };
+
+    var setStart = function (rng, situ) {
+      situ.fold(function (e) {
+        rng.setStartBefore(e.dom);
+      }, function (e, o) {
+        rng.setStart(e.dom, o);
+      }, function (e) {
+        rng.setStartAfter(e.dom);
+      });
+    };
+    var setFinish = function (rng, situ) {
+      situ.fold(function (e) {
+        rng.setEndBefore(e.dom);
+      }, function (e, o) {
+        rng.setEnd(e.dom, o);
+      }, function (e) {
+        rng.setEndAfter(e.dom);
+      });
+    };
+    var relativeToNative = function (win, startSitu, finishSitu) {
+      var range = win.document.createRange();
+      setStart(range, startSitu);
+      setFinish(range, finishSitu);
+      return range;
+    };
+    var exactToNative = function (win, start, soffset, finish, foffset) {
+      var rng = win.document.createRange();
+      rng.setStart(start.dom, soffset);
+      rng.setEnd(finish.dom, foffset);
+      return rng;
+    };
+    var toRect = function (rect) {
+      return {
+        left: rect.left,
+        top: rect.top,
+        right: rect.right,
+        bottom: rect.bottom,
+        width: rect.width,
+        height: rect.height
+      };
+    };
+    var getFirstRect$1 = function (rng) {
+      var rects = rng.getClientRects();
+      var rect = rects.length > 0 ? rects[0] : rng.getBoundingClientRect();
+      return rect.width > 0 || rect.height > 0 ? Optional.some(rect).map(toRect) : Optional.none();
+    };
+    var getBounds$2 = function (rng) {
+      var rect = rng.getBoundingClientRect();
+      return rect.width > 0 || rect.height > 0 ? Optional.some(rect).map(toRect) : Optional.none();
+    };
+
+    var adt$4 = Adt.generate([
+      {
+        ltr: [
+          'start',
+          'soffset',
+          'finish',
+          'foffset'
+        ]
+      },
+      {
+        rtl: [
+          'start',
+          'soffset',
+          'finish',
+          'foffset'
+        ]
+      }
+    ]);
+    var fromRange = function (win, type, range) {
+      return type(SugarElement.fromDom(range.startContainer), range.startOffset, SugarElement.fromDom(range.endContainer), range.endOffset);
+    };
+    var getRanges = function (win, selection) {
+      return selection.match({
+        domRange: function (rng) {
+          return {
+            ltr: constant$1(rng),
+            rtl: Optional.none
+          };
+        },
+        relative: function (startSitu, finishSitu) {
+          return {
+            ltr: cached(function () {
+              return relativeToNative(win, startSitu, finishSitu);
+            }),
+            rtl: cached(function () {
+              return Optional.some(relativeToNative(win, finishSitu, startSitu));
+            })
+          };
+        },
+        exact: function (start, soffset, finish, foffset) {
+          return {
+            ltr: cached(function () {
+              return exactToNative(win, start, soffset, finish, foffset);
+            }),
+            rtl: cached(function () {
+              return Optional.some(exactToNative(win, finish, foffset, start, soffset));
+            })
+          };
+        }
+      });
+    };
+    var doDiagnose = function (win, ranges) {
+      var rng = ranges.ltr();
+      if (rng.collapsed) {
+        var reversed = ranges.rtl().filter(function (rev) {
+          return rev.collapsed === false;
+        });
+        return reversed.map(function (rev) {
+          return adt$4.rtl(SugarElement.fromDom(rev.endContainer), rev.endOffset, SugarElement.fromDom(rev.startContainer), rev.startOffset);
+        }).getOrThunk(function () {
+          return fromRange(win, adt$4.ltr, rng);
+        });
+      } else {
+        return fromRange(win, adt$4.ltr, rng);
+      }
+    };
+    var diagnose = function (win, selection) {
+      var ranges = getRanges(win, selection);
+      return doDiagnose(win, ranges);
+    };
+    var asLtrRange = function (win, selection) {
+      var diagnosis = diagnose(win, selection);
+      return diagnosis.match({
+        ltr: function (start, soffset, finish, foffset) {
+          var rng = win.document.createRange();
+          rng.setStart(start.dom, soffset);
+          rng.setEnd(finish.dom, foffset);
+          return rng;
+        },
+        rtl: function (start, soffset, finish, foffset) {
+          var rng = win.document.createRange();
+          rng.setStart(finish.dom, foffset);
+          rng.setEnd(start.dom, soffset);
+          return rng;
+        }
+      });
+    };
+    adt$4.ltr;
+    adt$4.rtl;
+
+    var NodeValue = function (is, name) {
+      var get = function (element) {
+        if (!is(element)) {
+          throw new Error('Can only get ' + name + ' value of a ' + name + ' node');
+        }
+        return getOption(element).getOr('');
+      };
+      var getOption = function (element) {
+        return is(element) ? Optional.from(element.dom.nodeValue) : Optional.none();
+      };
+      var set = function (element, value) {
+        if (!is(element)) {
+          throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node');
+        }
+        element.dom.nodeValue = value;
+      };
+      return {
+        get: get,
+        getOption: getOption,
+        set: set
+      };
+    };
+
+    var api = NodeValue(isText$1, 'text');
+    var get$3 = function (element) {
+      return api.get(element);
+    };
+    var getOption = function (element) {
+      return api.getOption(element);
+    };
+
+    var getEnd = function (element) {
+      return name$2(element) === 'img' ? 1 : getOption(element).fold(function () {
+        return children(element).length;
+      }, function (v) {
+        return v.length;
+      });
+    };
+    var isTextNodeWithCursorPosition = function (el) {
+      return getOption(el).filter(function (text) {
+        return text.trim().length !== 0 || text.indexOf(nbsp) > -1;
+      }).isSome();
+    };
+    var elementsWithCursorPosition = [
+      'img',
+      'br'
+    ];
+    var isCursorPosition = function (elem) {
+      var hasCursorPosition = isTextNodeWithCursorPosition(elem);
+      return hasCursorPosition || contains$2(elementsWithCursorPosition, name$2(elem));
+    };
+
+    var last$1 = function (element) {
+      return descendantRtl(element, isCursorPosition);
+    };
+    var descendantRtl = function (scope, predicate) {
+      var descend = function (element) {
+        var children$1 = children(element);
+        for (var i = children$1.length - 1; i >= 0; i--) {
+          var child = children$1[i];
+          if (predicate(child)) {
+            return Optional.some(child);
+          }
+          var res = descend(child);
+          if (res.isSome()) {
+            return res;
+          }
+        }
+        return Optional.none();
+      };
+      return descend(scope);
+    };
+
+    var descendants = function (scope, selector) {
+      return all$3(selector, scope);
+    };
+
+    var makeRange = function (start, soffset, finish, foffset) {
+      var doc = owner$4(start);
+      var rng = doc.dom.createRange();
+      rng.setStart(start.dom, soffset);
+      rng.setEnd(finish.dom, foffset);
+      return rng;
+    };
+    var after = function (start, soffset, finish, foffset) {
+      var r = makeRange(start, soffset, finish, foffset);
+      var same = eq(start, finish) && soffset === foffset;
+      return r.collapsed && !same;
+    };
+
+    var getNativeSelection = function (win) {
+      return Optional.from(win.getSelection());
+    };
+    var readRange = function (selection) {
+      if (selection.rangeCount > 0) {
+        var firstRng = selection.getRangeAt(0);
+        var lastRng = selection.getRangeAt(selection.rangeCount - 1);
+        return Optional.some(SimRange.create(SugarElement.fromDom(firstRng.startContainer), firstRng.startOffset, SugarElement.fromDom(lastRng.endContainer), lastRng.endOffset));
+      } else {
+        return Optional.none();
+      }
+    };
+    var doGetExact = function (selection) {
+      if (selection.anchorNode === null || selection.focusNode === null) {
+        return readRange(selection);
+      } else {
+        var anchor = SugarElement.fromDom(selection.anchorNode);
+        var focus_1 = SugarElement.fromDom(selection.focusNode);
+        return after(anchor, selection.anchorOffset, focus_1, selection.focusOffset) ? Optional.some(SimRange.create(anchor, selection.anchorOffset, focus_1, selection.focusOffset)) : readRange(selection);
+      }
+    };
+    var getExact = function (win) {
+      return getNativeSelection(win).filter(function (sel) {
+        return sel.rangeCount > 0;
+      }).bind(doGetExact);
+    };
+    var getFirstRect = function (win, selection) {
+      var rng = asLtrRange(win, selection);
+      return getFirstRect$1(rng);
+    };
+    var getBounds$1 = function (win, selection) {
+      var rng = asLtrRange(win, selection);
+      return getBounds$2(rng);
+    };
+
+    var point$1 = function (element, offset) {
+      return {
+        element: element,
+        offset: offset
+      };
+    };
+    var descendOnce$1 = function (element, offset) {
+      var children$1 = children(element);
+      if (children$1.length === 0) {
+        return point$1(element, offset);
+      } else if (offset < children$1.length) {
+        return point$1(children$1[offset], 0);
+      } else {
+        var last = children$1[children$1.length - 1];
+        var len = isText$1(last) ? get$3(last).length : children(last).length;
+        return point$1(last, len);
+      }
+    };
+
+    var descendOnce = function (element, offset) {
+      return isText$1(element) ? point$1(element, offset) : descendOnce$1(element, offset);
+    };
+    var getAnchorSelection = function (win, anchorInfo) {
+      var getSelection = anchorInfo.getSelection.getOrThunk(function () {
+        return function () {
+          return getExact(win);
+        };
+      });
+      return getSelection().map(function (sel) {
+        var modStart = descendOnce(sel.start, sel.soffset);
+        var modFinish = descendOnce(sel.finish, sel.foffset);
+        return SimSelection.range(modStart.element, modStart.offset, modFinish.element, modFinish.offset);
+      });
+    };
+    var placement$1 = function (component, anchorInfo, origin) {
+      var win = defaultView(anchorInfo.root).dom;
+      var rootPoint = getRootPoint(component, origin, anchorInfo);
+      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$5(x);
+          return rect;
+        });
+        return optRect.bind(function (rawRect) {
+          return getBox(rawRect.left, rawRect.top, rawRect.width, rawRect.height);
+        });
+      });
+      var targetElement = getAnchorSelection(win, anchorInfo).bind(function (sel) {
+        return isElement$2(sel.start) ? Optional.some(sel.start) : parentNode(sel.start);
+      });
+      var elem = targetElement.getOr(component.element);
+      return calcNewAnchor(selectionBox, rootPoint, anchorInfo, origin, elem);
+    };
+    var SelectionAnchor = [
+      option('getSelection'),
+      required$1('root'),
+      option('bubble'),
+      schema$y(),
+      defaulted('overrides', {}),
+      defaulted('showAbove', false),
+      output$1('placement', placement$1)
+    ];
+
+    var labelPrefix$1 = 'link-layout';
+    var eastX = function (anchor) {
+      return anchor.x + anchor.width;
+    };
+    var westX = function (anchor, element) {
+      return anchor.x - element.width;
+    };
+    var northY$1 = function (anchor, element) {
+      return anchor.y - element.height + anchor.height;
+    };
+    var southY$1 = function (anchor) {
+      return anchor.y;
+    };
+    var southeast$1 = function (anchor, element, bubbles) {
+      return nu$6(eastX(anchor), southY$1(anchor), bubbles.southeast(), southeast$3(), 'southeast', boundsRestriction(anchor, {
+        left: 0,
+        top: 2
+      }), labelPrefix$1);
+    };
+    var southwest$1 = function (anchor, element, bubbles) {
+      return nu$6(westX(anchor, element), southY$1(anchor), bubbles.southwest(), southwest$3(), 'southwest', boundsRestriction(anchor, {
+        right: 1,
+        top: 2
+      }), labelPrefix$1);
+    };
+    var northeast$1 = function (anchor, element, bubbles) {
+      return nu$6(eastX(anchor), northY$1(anchor, element), bubbles.northeast(), northeast$3(), 'northeast', boundsRestriction(anchor, {
+        left: 0,
+        bottom: 3
+      }), labelPrefix$1);
+    };
+    var northwest$1 = function (anchor, element, bubbles) {
+      return nu$6(westX(anchor, element), northY$1(anchor, element), bubbles.northwest(), northwest$3(), 'northwest', boundsRestriction(anchor, {
+        right: 1,
+        bottom: 3
+      }), labelPrefix$1);
+    };
+    var all = function () {
+      return [
+        southeast$1,
+        southwest$1,
+        northeast$1,
+        northwest$1
+      ];
+    };
+    var allRtl = function () {
+      return [
+        southwest$1,
+        southeast$1,
+        northwest$1,
+        northeast$1
+      ];
+    };
+
+    var placement = function (component, submenuInfo, origin) {
+      var anchorBox = toBox(origin, submenuInfo.item.element);
+      var layouts = get$4(component.element, submenuInfo, all(), allRtl(), all(), allRtl(), Optional.none());
+      return Optional.some(nu$4({
+        anchorBox: anchorBox,
+        bubble: fallback(),
+        overrides: submenuInfo.overrides,
+        layouts: layouts,
+        placer: Optional.none()
+      }));
+    };
+    var SubmenuAnchor = [
+      required$1('item'),
+      schema$y(),
+      defaulted('overrides', {}),
+      output$1('placement', placement)
+    ];
+
+    var AnchorSchema = choose$1('type', {
+      selection: SelectionAnchor,
+      node: NodeAnchor,
+      hotspot: HotspotAnchor,
+      submenu: SubmenuAnchor,
+      makeshift: MakeshiftAnchor
+    });
+
+    var TransitionSchema = [
+      requiredArrayOf('classes', string),
+      defaultedStringEnum('mode', 'all', [
+        'all',
+        'layout',
+        'placement'
+      ])
+    ];
+    var PositionSchema = [
+      defaulted('useFixed', never),
+      option('getBounds')
+    ];
+    var PlacementSchema = [
+      requiredOf('anchor', AnchorSchema),
+      optionObjOf('transition', TransitionSchema)
+    ];
+
+    var getFixedOrigin = function () {
+      var html = document.documentElement;
+      return fixed$1(0, 0, html.clientWidth, html.clientHeight);
+    };
+    var getRelativeOrigin = function (component) {
+      var position = absolute$3(component.element);
+      var bounds = component.element.dom.getBoundingClientRect();
+      return relative$1(position.left, position.top, bounds.width, bounds.height);
+    };
+    var place = function (component, origin, anchoring, getBounds, placee, lastPlace, transition) {
+      var anchor = box(anchoring.anchorBox, origin);
+      return simple(anchor, placee.element, anchoring.bubble, anchoring.layouts, lastPlace, getBounds, anchoring.overrides, transition);
+    };
+    var position$1 = function (component, posConfig, posState, placee, placementSpec) {
+      positionWithin(component, posConfig, posState, placee, placementSpec, Optional.none());
+    };
+    var positionWithin = function (component, posConfig, posState, placee, placementSpec, boxElement) {
+      var boundsBox = boxElement.map(box$1);
+      return positionWithinBounds(component, posConfig, posState, placee, placementSpec, boundsBox);
+    };
+    var positionWithinBounds = function (component, posConfig, posState, placee, placementSpec, bounds) {
+      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$7(element, 'position', 'fixed');
+        var oldVisibility = getRaw(element, 'visibility');
+        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$6(element, 'visibility');
+        }, function (vis) {
+          set$7(element, 'visibility', vis);
+        });
+        if (getRaw(element, 'left').isNone() && getRaw(element, 'top').isNone() && getRaw(element, 'right').isNone() && getRaw(element, 'bottom').isNone() && is$1(getRaw(element, 'position'), 'fixed')) {
+          remove$6(element, 'position');
+        }
+      }, element);
+    };
+    var getMode = function (component, pConfig, _pState) {
+      return pConfig.useFixed() ? 'fixed' : 'absolute';
+    };
+    var reset$1 = function (component, pConfig, posState, placee) {
+      var element = placee.element;
+      each$1([
+        'position',
+        'left',
+        'right',
+        'top',
+        'bottom'
+      ], function (prop) {
+        return remove$6(element, prop);
+      });
+      reset$2(element);
+      posState.clear(placee.uid);
+    };
+
+    var PositionApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        position: position$1,
+        positionWithin: positionWithin,
+        positionWithinBounds: positionWithinBounds,
+        getMode: getMode,
+        reset: reset$1
+    });
+
+    var init$g = function () {
+      var state = {};
+      var set = function (id, data) {
+        state[id] = data;
+      };
+      var get = function (id) {
+        return get$e(state, id);
+      };
+      var clear = function (id) {
+        if (isNonNullable(id)) {
+          delete state[id];
+        } else {
+          state = {};
+        }
+      };
+      return nu$8({
+        readState: function () {
+          return state;
+        },
+        clear: clear,
+        set: set,
+        get: get
+      });
+    };
+
+    var PositioningState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init$g
+    });
+
+    var Positioning = create$8({
+      fields: PositionSchema,
+      name: 'positioning',
+      active: ActivePosition,
+      apis: PositionApis,
+      state: PositioningState
+    });
+
+    var fireDetaching = function (component) {
+      emit(component, detachedFromDom());
+      var children = component.components();
+      each$1(children, fireDetaching);
+    };
+    var fireAttaching = function (component) {
+      var children = component.components();
+      each$1(children, fireAttaching);
+      emit(component, attachedToDom());
+    };
+    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$5(childComp.element);
+      });
+      empty(component.element);
+      component.syncComponents();
+    };
+    var replaceChildren = function (component, newChildren) {
+      var subs = component.components();
+      detachChildren$1(component);
+      var deleted = difference(subs, newChildren);
+      each$1(deleted, function (comp) {
+        fireDetaching(comp);
+        component.getSystem().removeFromWorld(comp);
+      });
+      each$1(newChildren, function (childComp) {
+        if (!childComp.getSystem().isConnected()) {
+          component.getSystem().addToWorld(childComp);
+          attach$1(component, childComp);
+          if (inBody(component.element)) {
+            fireAttaching(childComp);
+          }
+        } else {
+          attach$1(component, childComp);
+        }
+        component.syncComponents();
+      });
+    };
+
+    var attach = function (parent, child) {
+      attachWith(parent, child, append$2);
+    };
+    var attachWith = function (parent, child, insertion) {
+      parent.getSystem().addToWorld(child);
+      insertion(parent.element, child.element);
+      if (inBody(parent.element)) {
+        fireAttaching(child);
+      }
+      parent.syncComponents();
+    };
+    var doDetach = function (component) {
+      fireDetaching(component);
+      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();
+      });
+      doDetach(component);
+      parent$1.each(function (p) {
+        p.syncComponents();
+      });
+    };
+    var detachChildren = function (component) {
+      var subs = component.components();
+      each$1(subs, doDetach);
+      empty(component.element);
+      component.syncComponents();
+    };
+    var attachSystem = function (element, guiSystem) {
+      attachSystemWith(element, guiSystem, append$2);
+    };
+    var attachSystemAfter = function (element, guiSystem) {
+      attachSystemWith(element, guiSystem, after$2);
+    };
+    var attachSystemWith = function (element, guiSystem, inserter) {
+      inserter(element, guiSystem.element);
+      var children$1 = children(guiSystem.element);
+      each$1(children$1, function (child) {
+        guiSystem.getByDom(child).each(fireAttaching);
+      });
+    };
+    var detachSystem = function (guiSystem) {
+      var children$1 = children(guiSystem.element);
+      each$1(children$1, function (child) {
+        guiSystem.getByDom(child).each(fireDetaching);
+      });
+      remove$5(guiSystem.element);
+    };
+
+    var rebuild = function (sandbox, sConfig, sState, data) {
+      sState.get().each(function (_data) {
+        detachChildren(sandbox);
+      });
+      var point = sConfig.getAttachPoint(sandbox);
+      attach(point, sandbox);
+      var built = sandbox.getSystem().build(data);
+      attach(sandbox, built);
+      sState.set(built);
+      return built;
+    };
+    var open$1 = function (sandbox, sConfig, sState, data) {
+      var newState = rebuild(sandbox, sConfig, sState, data);
+      sConfig.onOpen(sandbox, newState);
+      return newState;
+    };
+    var setContent = function (sandbox, sConfig, sState, data) {
+      return sState.get().map(function () {
+        return rebuild(sandbox, sConfig, sState, data);
+      });
+    };
+    var openWhileCloaked = function (sandbox, sConfig, sState, data, transaction) {
+      cloak(sandbox, sConfig);
+      open$1(sandbox, sConfig, sState, data);
+      transaction();
+      decloak(sandbox, sConfig);
+    };
+    var close$1 = function (sandbox, sConfig, sState) {
+      sState.get().each(function (data) {
+        detachChildren(sandbox);
+        detach(sandbox);
+        sConfig.onClose(sandbox, data);
+        sState.clear();
+      });
+    };
+    var isOpen$1 = function (_sandbox, _sConfig, sState) {
+      return sState.isOpen();
+    };
+    var isPartOf = function (sandbox, sConfig, sState, queryElem) {
+      return isOpen$1(sandbox, sConfig, sState) && sState.get().exists(function (data) {
+        return sConfig.isPartOf(sandbox, data, queryElem);
+      });
+    };
+    var getState$2 = function (_sandbox, _sConfig, sState) {
+      return sState.get();
+    };
+    var store = function (sandbox, cssKey, attr, newValue) {
+      getRaw(sandbox.element, cssKey).fold(function () {
+        remove$7(sandbox.element, attr);
+      }, function (v) {
+        set$8(sandbox.element, attr, v);
+      });
+      set$7(sandbox.element, cssKey, newValue);
+    };
+    var restore = function (sandbox, cssKey, attr) {
+      getOpt(sandbox.element, attr).fold(function () {
+        return remove$6(sandbox.element, cssKey);
+      }, function (oldValue) {
+        return set$7(sandbox.element, cssKey, oldValue);
+      });
+    };
+    var cloak = function (sandbox, sConfig, _sState) {
+      var sink = sConfig.getAttachPoint(sandbox);
+      set$7(sandbox.element, 'position', Positioning.getMode(sink));
+      store(sandbox, 'visibility', sConfig.cloakVisibilityAttr, 'hidden');
+    };
+    var hasPosition = function (element) {
+      return exists([
+        'top',
+        'left',
+        'right',
+        'bottom'
+      ], function (pos) {
+        return getRaw(element, pos).isSome();
+      });
+    };
+    var decloak = function (sandbox, sConfig, _sState) {
+      if (!hasPosition(sandbox.element)) {
+        remove$6(sandbox.element, 'position');
+      }
+      restore(sandbox, 'visibility', sConfig.cloakVisibilityAttr);
+    };
+
+    var SandboxApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        cloak: cloak,
+        decloak: decloak,
+        open: open$1,
+        openWhileCloaked: openWhileCloaked,
+        close: close$1,
+        isOpen: isOpen$1,
+        isPartOf: isPartOf,
+        getState: getState$2,
+        setContent: setContent
+    });
+
+    var events$g = function (sandboxConfig, sandboxState) {
+      return derive$2([run$1(sandboxClose(), function (sandbox, _simulatedEvent) {
+          close$1(sandbox, sandboxConfig, sandboxState);
+        })]);
+    };
+
+    var ActiveSandbox = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$g
+    });
+
+    var SandboxSchema = [
+      onHandler('onOpen'),
+      onHandler('onClose'),
+      required$1('isPartOf'),
+      required$1('getAttachPoint'),
+      defaulted('cloakVisibilityAttr', 'data-precloak-visibility')
+    ];
+
+    var init$f = function () {
+      var contents = value$1();
+      var readState = constant$1('not-implemented');
+      return nu$8({
+        readState: readState,
+        isOpen: contents.isSet,
+        clear: contents.clear,
+        set: contents.set,
+        get: contents.get
+      });
+    };
+
+    var SandboxState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init$f
+    });
+
+    var Sandboxing = create$8({
+      fields: SandboxSchema,
+      name: 'sandboxing',
+      active: ActiveSandbox,
+      apis: SandboxApis,
+      state: SandboxState
+    });
+
+    var dismissPopups = constant$1('dismiss.popups');
+    var repositionPopups = constant$1('reposition.popups');
+    var mouseReleased = constant$1('mouse.released');
+
+    var schema$x = objOfOnly([
+      defaulted('isExtraPart', never),
+      optionObjOf('fireEventInstead', [defaulted('event', dismissRequested())])
+    ]);
+    var receivingChannel$1 = function (rawSpec) {
+      var _a;
+      var detail = asRawOrDie$1('Dismissal', schema$x, rawSpec);
+      return _a = {}, _a[dismissPopups()] = {
+        schema: objOfOnly([required$1('target')]),
+        onReceive: function (sandbox, data) {
+          if (Sandboxing.isOpen(sandbox)) {
+            var isPart = Sandboxing.isPartOf(sandbox, data.target) || detail.isExtraPart(sandbox, data.target);
+            if (!isPart) {
+              detail.fireEventInstead.fold(function () {
+                return Sandboxing.close(sandbox);
+              }, function (fe) {
+                return emit(sandbox, fe.event);
+              });
+            }
+          }
+        }
+      }, _a;
+    };
+
+    var schema$w = objOfOnly([
+      optionObjOf('fireEventInstead', [defaulted('event', repositionRequested())]),
+      requiredFunction('doReposition')
+    ]);
+    var receivingChannel = function (rawSpec) {
+      var _a;
+      var detail = asRawOrDie$1('Reposition', schema$w, rawSpec);
+      return _a = {}, _a[repositionPopups()] = {
+        onReceive: function (sandbox) {
+          if (Sandboxing.isOpen(sandbox)) {
+            detail.fireEventInstead.fold(function () {
+              return detail.doReposition(sandbox);
+            }, function (fe) {
+              return emit(sandbox, fe.event);
+            });
+          }
+        }
+      }, _a;
+    };
+
+    var onLoad$5 = function (component, repConfig, repState) {
+      repConfig.store.manager.onLoad(component, repConfig, repState);
+    };
+    var onUnload$2 = function (component, repConfig, repState) {
+      repConfig.store.manager.onUnload(component, repConfig, repState);
+    };
+    var setValue$3 = function (component, repConfig, repState, data) {
+      repConfig.store.manager.setValue(component, repConfig, repState, data);
+    };
+    var getValue$3 = function (component, repConfig, repState) {
+      return repConfig.store.manager.getValue(component, repConfig, repState);
+    };
+    var getState$1 = function (component, repConfig, repState) {
+      return repState;
+    };
+
+    var RepresentApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        onLoad: onLoad$5,
+        onUnload: onUnload$2,
+        setValue: setValue$3,
+        getValue: getValue$3,
+        getState: getState$1
+    });
+
+    var events$f = function (repConfig, repState) {
+      var es = repConfig.resetOnDom ? [
+        runOnAttached(function (comp, _se) {
+          onLoad$5(comp, repConfig, repState);
+        }),
+        runOnDetached(function (comp, _se) {
+          onUnload$2(comp, repConfig, repState);
+        })
+      ] : [loadEvent(repConfig, repState, onLoad$5)];
+      return derive$2(es);
+    };
+
+    var ActiveRepresenting = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$f
+    });
+
+    var memory$1 = function () {
+      var data = Cell(null);
+      var readState = function () {
+        return {
+          mode: 'memory',
+          value: data.get()
+        };
+      };
+      var isNotSet = function () {
+        return data.get() === null;
+      };
+      var clear = function () {
+        data.set(null);
+      };
+      return nu$8({
+        set: data.set,
+        get: data.get,
+        isNotSet: isNotSet,
+        clear: clear,
+        readState: readState
+      });
+    };
+    var manual = function () {
+      var readState = noop;
+      return nu$8({ readState: readState });
+    };
+    var dataset = function () {
+      var dataByValue = Cell({});
+      var dataByText = Cell({});
+      var readState = function () {
+        return {
+          mode: 'dataset',
+          dataByValue: dataByValue.get(),
+          dataByText: dataByText.get()
+        };
+      };
+      var clear = function () {
+        dataByValue.set({});
+        dataByText.set({});
+      };
+      var lookup = function (itemString) {
+        return get$e(dataByValue.get(), itemString).orThunk(function () {
+          return get$e(dataByText.get(), itemString);
+        });
+      };
+      var update = function (items) {
+        var currentDataByValue = dataByValue.get();
+        var currentDataByText = dataByText.get();
+        var newDataByValue = {};
+        var newDataByText = {};
+        each$1(items, function (item) {
+          newDataByValue[item.value] = item;
+          get$e(item, 'meta').each(function (meta) {
+            get$e(meta, 'text').each(function (text) {
+              newDataByText[text] = item;
+            });
+          });
+        });
+        dataByValue.set(__assign(__assign({}, currentDataByValue), newDataByValue));
+        dataByText.set(__assign(__assign({}, currentDataByText), newDataByText));
+      };
+      return nu$8({
+        readState: readState,
+        lookup: lookup,
+        update: update,
+        clear: clear
+      });
+    };
+    var init$e = function (spec) {
+      return spec.store.manager.state(spec);
+    };
+
+    var RepresentState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        memory: memory$1,
+        dataset: dataset,
+        manual: manual,
+        init: init$e
+    });
+
+    var setValue$2 = function (component, repConfig, repState, data) {
+      var store = repConfig.store;
+      repState.update([data]);
+      store.setValue(component, data);
+      repConfig.onSetValue(component, data);
+    };
+    var getValue$2 = function (component, repConfig, repState) {
+      var store = repConfig.store;
+      var key = store.getDataKey(component);
+      return repState.lookup(key).getOrThunk(function () {
+        return store.getFallbackEntry(key);
+      });
+    };
+    var onLoad$4 = function (component, repConfig, repState) {
+      var store = repConfig.store;
+      store.initialValue.each(function (data) {
+        setValue$2(component, repConfig, repState, data);
+      });
+    };
+    var onUnload$1 = function (component, repConfig, repState) {
+      repState.clear();
+    };
+    var DatasetStore = [
+      option('initialValue'),
+      required$1('getFallbackEntry'),
+      required$1('getDataKey'),
+      required$1('setValue'),
+      output$1('manager', {
+        setValue: setValue$2,
+        getValue: getValue$2,
+        onLoad: onLoad$4,
+        onUnload: onUnload$1,
+        state: dataset
+      })
+    ];
+
+    var getValue$1 = function (component, repConfig, _repState) {
+      return repConfig.store.getValue(component);
+    };
+    var setValue$1 = function (component, repConfig, _repState, data) {
+      repConfig.store.setValue(component, data);
+      repConfig.onSetValue(component, data);
+    };
+    var onLoad$3 = function (component, repConfig, _repState) {
+      repConfig.store.initialValue.each(function (data) {
+        repConfig.store.setValue(component, data);
+      });
+    };
+    var ManualStore = [
+      required$1('getValue'),
+      defaulted('setValue', noop),
+      option('initialValue'),
+      output$1('manager', {
+        setValue: setValue$1,
+        getValue: getValue$1,
+        onLoad: onLoad$3,
+        onUnload: noop,
+        state: NoState.init
+      })
+    ];
+
+    var setValue = function (component, repConfig, repState, data) {
+      repState.set(data);
+      repConfig.onSetValue(component, data);
+    };
+    var getValue = function (component, repConfig, repState) {
+      return repState.get();
+    };
+    var onLoad$2 = function (component, repConfig, repState) {
+      repConfig.store.initialValue.each(function (initVal) {
+        if (repState.isNotSet()) {
+          repState.set(initVal);
+        }
+      });
+    };
+    var onUnload = function (component, repConfig, repState) {
+      repState.clear();
+    };
+    var MemoryStore = [
+      option('initialValue'),
+      output$1('manager', {
+        setValue: setValue,
+        getValue: getValue,
+        onLoad: onLoad$2,
+        onUnload: onUnload,
+        state: memory$1
+      })
+    ];
+
+    var RepresentSchema = [
+      defaultedOf('store', { mode: 'memory' }, choose$1('mode', {
+        memory: MemoryStore,
+        manual: ManualStore,
+        dataset: DatasetStore
+      })),
+      onHandler('onSetValue'),
+      defaulted('resetOnDom', false)
+    ];
+
+    var Representing = create$8({
+      fields: RepresentSchema,
+      name: 'representing',
+      active: ActiveRepresenting,
+      apis: RepresentApis,
+      extra: {
+        setValueFrom: function (component, source) {
+          var value = Representing.getValue(source);
+          Representing.setValue(component, value);
+        }
+      },
+      state: RepresentState
+    });
+
+    var field = function (name, forbidden) {
+      return defaultedObjOf(name, {}, map$2(forbidden, function (f) {
+        return forbid(f.name(), 'Cannot configure ' + f.name() + ' for ' + name);
+      }).concat([customField('dump', identity$1)]));
+    };
+    var get$2 = function (data) {
+      return data.dump;
+    };
+    var augment = function (data, original) {
+      return __assign(__assign({}, derive$1(original)), data.dump);
+    };
+    var SketchBehaviours = {
+      field: field,
+      augment: augment,
+      get: get$2
+    };
+
+    var _placeholder = 'placeholder';
+    var adt$3 = Adt.generate([
+      {
+        single: [
+          'required',
+          'valueThunk'
+        ]
+      },
+      {
+        multiple: [
+          'required',
+          'valueThunks'
+        ]
+      }
+    ]);
+    var isSubstituted = function (spec) {
+      return has$2(spec, 'uiType');
+    };
+    var subPlaceholder = function (owner, detail, compSpec, placeholders) {
+      if (owner.exists(function (o) {
+          return o !== compSpec.owner;
+        })) {
+        return adt$3.single(true, constant$1(compSpec));
+      }
+      return get$e(placeholders, compSpec.name).fold(function () {
+        throw new Error('Unknown placeholder component: ' + compSpec.name + '\nKnown: [' + keys(placeholders) + ']\nNamespace: ' + owner.getOr('none') + '\nSpec: ' + JSON.stringify(compSpec, null, 2));
+      }, function (newSpec) {
+        return newSpec.replace();
+      });
+    };
+    var scan = function (owner, detail, compSpec, placeholders) {
+      if (isSubstituted(compSpec) && compSpec.uiType === _placeholder) {
+        return subPlaceholder(owner, detail, compSpec, placeholders);
+      } else {
+        return adt$3.single(false, constant$1(compSpec));
+      }
+    };
+    var substitute = function (owner, detail, compSpec, placeholders) {
+      var base = scan(owner, detail, compSpec, placeholders);
+      return base.fold(function (req, valueThunk) {
+        var value = isSubstituted(compSpec) ? valueThunk(detail, compSpec.config, compSpec.validated) : valueThunk(detail);
+        var childSpecs = get$e(value, 'components').getOr([]);
+        var substituted = bind$3(childSpecs, function (c) {
+          return substitute(owner, detail, c, placeholders);
+        });
+        return [__assign(__assign({}, value), { components: substituted })];
+      }, function (req, valuesThunk) {
+        if (isSubstituted(compSpec)) {
+          var values = valuesThunk(detail, compSpec.config, compSpec.validated);
+          var preprocessor = compSpec.validated.preprocess.getOr(identity$1);
+          return preprocessor(values);
+        } else {
+          return valuesThunk(detail);
+        }
+      });
+    };
+    var substituteAll = function (owner, detail, components, placeholders) {
+      return bind$3(components, function (c) {
+        return substitute(owner, detail, c, placeholders);
+      });
+    };
+    var oneReplace = function (label, replacements) {
+      var called = false;
+      var used = function () {
+        return called;
+      };
+      var replace = function () {
+        if (called) {
+          throw new Error('Trying to use the same placeholder more than once: ' + label);
+        }
+        called = true;
+        return replacements;
+      };
+      var required = function () {
+        return replacements.fold(function (req, _) {
+          return req;
+        }, function (req, _) {
+          return req;
+        });
+      };
+      return {
+        name: constant$1(label),
+        required: required,
+        used: used,
+        replace: replace
+      };
+    };
+    var substitutePlaces = function (owner, detail, components, placeholders) {
+      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()) {
+          throw new Error('Placeholder: ' + p.name() + ' was not found in components list\nNamespace: ' + owner.getOr('none') + '\nComponents: ' + JSON.stringify(detail.components, null, 2));
+        }
+      });
+      return outcome;
+    };
+    var single$2 = adt$3.single;
+    var multiple = adt$3.multiple;
+    var placeholder = constant$1(_placeholder);
+
+    var adt$2 = Adt.generate([
+      { required: ['data'] },
+      { external: ['data'] },
+      { optional: ['data'] },
+      { group: ['data'] }
+    ]);
+    var fFactory = defaulted('factory', { sketch: identity$1 });
+    var fSchema = defaulted('schema', []);
+    var fName = required$1('name');
+    var fPname = field$1('pname', 'pname', defaultedThunk(function (typeSpec) {
+      return '<alloy.' + generate$6(typeSpec.name) + '>';
+    }), anyValue());
+    var fGroupSchema = customField('schema', function () {
+      return [option('preprocess')];
+    });
+    var fDefaults = defaulted('defaults', constant$1({}));
+    var fOverrides = defaulted('overrides', constant$1({}));
+    var requiredSpec = objOf([
+      fFactory,
+      fSchema,
+      fName,
+      fPname,
+      fDefaults,
+      fOverrides
+    ]);
+    var externalSpec = objOf([
+      fFactory,
+      fSchema,
+      fName,
+      fDefaults,
+      fOverrides
+    ]);
+    var optionalSpec = objOf([
+      fFactory,
+      fSchema,
+      fName,
+      fPname,
+      fDefaults,
+      fOverrides
+    ]);
+    var groupSpec = objOf([
+      fFactory,
+      fGroupSchema,
+      fName,
+      required$1('unit'),
+      fPname,
+      fDefaults,
+      fOverrides
+    ]);
+    var asNamedPart = function (part) {
+      return part.fold(Optional.some, Optional.none, Optional.some, Optional.some);
+    };
+    var name$1 = function (part) {
+      var get = function (data) {
+        return data.name;
+      };
+      return part.fold(get, get, get, get);
+    };
+    var asCommon = function (part) {
+      return part.fold(identity$1, identity$1, identity$1, identity$1);
+    };
+    var convert = function (adtConstructor, partSchema) {
+      return function (spec) {
+        var data = asRawOrDie$1('Converting part type', partSchema, spec);
+        return adtConstructor(data);
+      };
+    };
+    var required = convert(adt$2.required, requiredSpec);
+    var external$1 = convert(adt$2.external, externalSpec);
+    var optional = convert(adt$2.optional, optionalSpec);
+    var group = convert(adt$2.group, groupSpec);
+    var original = constant$1('entirety');
+
+    var PartType = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        required: required,
+        external: external$1,
+        optional: optional,
+        group: group,
+        asNamedPart: asNamedPart,
+        name: name$1,
+        asCommon: asCommon,
+        original: original
+    });
+
+    var combine = function (detail, data, partSpec, partValidated) {
+      return deepMerge(data.defaults(detail, partSpec, partValidated), partSpec, { uid: detail.partUids[data.name] }, data.overrides(detail, partSpec, partValidated));
+    };
+    var subs = function (owner, detail, parts) {
+      var internals = {};
+      var externals = {};
+      each$1(parts, function (part) {
+        part.fold(function (data) {
+          internals[data.pname] = single$2(true, function (detail, partSpec, partValidated) {
+            return data.factory.sketch(combine(detail, data, partSpec, partValidated));
+          });
+        }, function (data) {
+          var partSpec = detail.parts[data.name];
+          externals[data.name] = constant$1(data.factory.sketch(combine(detail, data, partSpec[original()]), partSpec));
+        }, function (data) {
+          internals[data.pname] = single$2(false, function (detail, partSpec, partValidated) {
+            return data.factory.sketch(combine(detail, data, partSpec, partValidated));
+          });
+        }, function (data) {
+          internals[data.pname] = multiple(true, function (detail, _partSpec, _partValidated) {
+            var units = detail[data.name];
+            return map$2(units, function (u) {
+              return data.factory.sketch(deepMerge(data.defaults(detail, u, _partValidated), u, data.overrides(detail, u)));
+            });
+          });
+        });
+      });
+      return {
+        internals: constant$1(internals),
+        externals: constant$1(externals)
+      };
+    };
+
+    var generate$3 = function (owner, parts) {
+      var r = {};
+      each$1(parts, function (part) {
+        asNamedPart(part).each(function (np) {
+          var g = doGenerateOne(owner, np.pname);
+          r[np.name] = function (config) {
+            var validated = asRawOrDie$1('Part: ' + np.name + ' in ' + owner, objOf(np.schema), config);
+            return __assign(__assign({}, g), {
+              config: config,
+              validated: validated
+            });
+          };
+        });
+      });
+      return r;
+    };
+    var doGenerateOne = function (owner, pname) {
+      return {
+        uiType: placeholder(),
+        owner: owner,
+        name: pname
+      };
+    };
+    var generateOne$1 = function (owner, pname, config) {
+      return {
+        uiType: placeholder(),
+        owner: owner,
+        name: pname,
+        config: config,
+        validated: {}
+      };
+    };
+    var schemas = function (parts) {
+      return bind$3(parts, function (part) {
+        return part.fold(Optional.none, Optional.some, Optional.none, Optional.none).map(function (data) {
+          return requiredObjOf(data.name, data.schema.concat([snapshot(original())]));
+        }).toArray();
+      });
+    };
+    var names = function (parts) {
+      return map$2(parts, name$1);
+    };
+    var substitutes = function (owner, detail, parts) {
+      return subs(owner, detail, parts);
+    };
+    var components$1 = function (owner, detail, internals) {
+      return substitutePlaces(Optional.some(owner), detail, detail.components, internals);
+    };
+    var getPart = function (component, detail, partKey) {
+      var uid = detail.partUids[partKey];
+      return component.getSystem().getByUid(uid).toOptional();
+    };
+    var getPartOrDie = function (component, detail, partKey) {
+      return getPart(component, detail, partKey).getOrDie('Could not find part: ' + partKey);
+    };
+    var getParts = function (component, detail, partKeys) {
+      var r = {};
+      var uids = detail.partUids;
+      var system = component.getSystem();
+      each$1(partKeys, function (pk) {
+        r[pk] = constant$1(system.getByUid(uids[pk]));
+      });
+      return r;
+    };
+    var getAllParts = function (component, detail) {
+      var system = component.getSystem();
+      return map$1(detail.partUids, function (pUid, _k) {
+        return constant$1(system.getByUid(pUid));
+      });
+    };
+    var getAllPartNames = function (detail) {
+      return keys(detail.partUids);
+    };
+    var getPartsOrDie = function (component, detail, partKeys) {
+      var r = {};
+      var uids = detail.partUids;
+      var system = component.getSystem();
+      each$1(partKeys, function (pk) {
+        r[pk] = constant$1(system.getByUid(uids[pk]).getOrDie());
+      });
+      return r;
+    };
+    var defaultUids = function (baseUid, partTypes) {
+      var partNames = names(partTypes);
+      return wrapAll(map$2(partNames, function (pn) {
+        return {
+          key: pn,
+          value: baseUid + '-' + pn
+        };
+      }));
+    };
+    var defaultUidsSchema = function (partTypes) {
+      return field$1('partUids', 'partUids', mergeWithThunk(function (spec) {
+        return defaultUids(spec.uid, partTypes);
+      }), anyValue());
+    };
+
+    var AlloyParts = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        generate: generate$3,
+        generateOne: generateOne$1,
+        schemas: schemas,
+        names: names,
+        substitutes: substitutes,
+        components: components$1,
+        defaultUids: defaultUids,
+        defaultUidsSchema: defaultUidsSchema,
+        getAllParts: getAllParts,
+        getAllPartNames: getAllPartNames,
+        getPart: getPart,
+        getPartOrDie: getPartOrDie,
+        getParts: getParts,
+        getPartsOrDie: getPartsOrDie
+    });
+
+    var base = function (partSchemas, partUidsSchemas) {
+      var ps = partSchemas.length > 0 ? [requiredObjOf('parts', partSchemas)] : [];
+      return ps.concat([
+        required$1('uid'),
+        defaulted('dom', {}),
+        defaulted('components', []),
+        snapshot('originalSpec'),
+        defaulted('debug.sketcher', {})
+      ]).concat(partUidsSchemas);
+    };
+    var asRawOrDie = function (label, schema, spec, partSchemas, partUidsSchemas) {
+      var baseS = base(partSchemas, partUidsSchemas);
+      return asRawOrDie$1(label + ' [SpecSchema]', objOfOnly(baseS.concat(schema)), spec);
+    };
+
+    var single$1 = function (owner, schema, factory, spec) {
+      var specWithUid = supplyUid(spec);
+      var detail = asRawOrDie(owner, schema, specWithUid, [], []);
+      return factory(detail, specWithUid);
+    };
+    var composite$1 = function (owner, schema, partTypes, factory, spec) {
+      var specWithUid = supplyUid(spec);
+      var partSchemas = schemas(partTypes);
+      var partUidsSchema = defaultUidsSchema(partTypes);
+      var detail = asRawOrDie(owner, schema, specWithUid, partSchemas, [partUidsSchema]);
+      var subs = substitutes(owner, detail, partTypes);
+      var components = components$1(owner, detail, subs.internals());
+      return factory(detail, components, specWithUid, subs.externals());
+    };
+    var hasUid = function (spec) {
+      return has$2(spec, 'uid');
+    };
+    var supplyUid = function (spec) {
+      return hasUid(spec) ? spec : __assign(__assign({}, spec), { uid: generate$5('uid') });
+    };
+
+    var isSketchSpec = function (spec) {
+      return spec.uid !== undefined;
+    };
+    var singleSchema = objOfOnly([
+      required$1('name'),
+      required$1('factory'),
+      required$1('configFields'),
+      defaulted('apis', {}),
+      defaulted('extraApis', {})
+    ]);
+    var compositeSchema = objOfOnly([
+      required$1('name'),
+      required$1('factory'),
+      required$1('configFields'),
+      required$1('partFields'),
+      defaulted('apis', {}),
+      defaulted('extraApis', {})
+    ]);
+    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$1(config.apis, makeApi);
+      var extraApis = map$1(config.extraApis, function (f, k) {
+        return markAsExtraApi(f, k);
+      });
+      return __assign(__assign({
+        name: config.name,
+        configFields: config.configFields,
+        sketch: sketch
+      }, apis), extraApis);
+    };
+    var composite = function (rawConfig) {
+      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$1(config.apis, makeApi);
+      var extraApis = map$1(config.extraApis, function (f, k) {
+        return markAsExtraApi(f, k);
+      });
+      return __assign(__assign({
+        name: config.name,
+        partFields: config.partFields,
+        configFields: config.configFields,
+        sketch: sketch,
+        parts: parts
+      }, apis), extraApis);
+    };
+
+    var inside = function (target) {
+      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 ComposeApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        getCurrent: getCurrent
+    });
+
+    var ComposeSchema = [required$1('find')];
+
+    var Composing = create$8({
+      fields: ComposeSchema,
+      name: 'composing',
+      apis: ComposeApis
+    });
+
+    var nativeDisabled = [
+      'input',
+      'button',
+      'textarea',
+      'select'
+    ];
+    var onLoad$1 = function (component, disableConfig, disableState) {
+      var f = disableConfig.disabled() ? disable$1 : enable$1;
+      f(component, disableConfig);
+    };
+    var hasNative = function (component, config) {
+      return config.useNative === true && contains$2(nativeDisabled, name$2(component.element));
+    };
+    var nativeIsDisabled = function (component) {
+      return has$1(component.element, 'disabled');
+    };
+    var nativeDisable = function (component) {
+      set$8(component.element, 'disabled', 'disabled');
+    };
+    var nativeEnable = function (component) {
+      remove$7(component.element, 'disabled');
+    };
+    var ariaIsDisabled = function (component) {
+      return get$d(component.element, 'aria-disabled') === 'true';
+    };
+    var ariaDisable = function (component) {
+      set$8(component.element, 'aria-disabled', 'true');
+    };
+    var ariaEnable = function (component) {
+      set$8(component.element, 'aria-disabled', 'false');
+    };
+    var disable$1 = function (component, disableConfig, _disableState) {
+      disableConfig.disableClass.each(function (disableClass) {
+        add$2(component.element, disableClass);
+      });
+      var f = hasNative(component, disableConfig) ? nativeDisable : ariaDisable;
+      f(component);
+      disableConfig.onDisabled(component);
+    };
+    var enable$1 = function (component, disableConfig, _disableState) {
+      disableConfig.disableClass.each(function (disableClass) {
+        remove$2(component.element, disableClass);
+      });
+      var f = hasNative(component, disableConfig) ? nativeEnable : ariaEnable;
+      f(component);
+      disableConfig.onEnabled(component);
+    };
+    var isDisabled = function (component, disableConfig) {
+      return hasNative(component, disableConfig) ? nativeIsDisabled(component) : ariaIsDisabled(component);
+    };
+    var set$3 = function (component, disableConfig, disableState, disabled) {
+      var f = disabled ? disable$1 : enable$1;
+      f(component, disableConfig);
+    };
+
+    var DisableApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        enable: enable$1,
+        disable: disable$1,
+        isDisabled: isDisabled,
+        onLoad: onLoad$1,
+        set: set$3
+    });
+
+    var exhibit$5 = function (base, disableConfig) {
+      return nu$7({ classes: disableConfig.disabled() ? disableConfig.disableClass.toArray() : [] });
+    };
+    var events$e = function (disableConfig, disableState) {
+      return derive$2([
+        abort(execute$5(), function (component, _simulatedEvent) {
+          return isDisabled(component, disableConfig);
+        }),
+        loadEvent(disableConfig, disableState, onLoad$1)
+      ]);
+    };
+
+    var ActiveDisable = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit$5,
+        events: events$e
+    });
+
+    var DisableSchema = [
+      defaultedFunction('disabled', never),
+      defaulted('useNative', true),
+      option('disableClass'),
+      onHandler('onDisabled'),
+      onHandler('onEnabled')
+    ];
+
+    var Disabling = create$8({
+      fields: DisableSchema,
+      name: 'disabling',
+      active: ActiveDisable,
+      apis: DisableApis
+    });
+
+    var dehighlightAllExcept = function (component, hConfig, hState, skip) {
+      var highlighted = descendants(component.element, '.' + hConfig.highlightClass);
+      each$1(highlighted, function (h) {
+        if (!exists(skip, function (skipComp) {
+            return skipComp.element === h;
+          })) {
+          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$2(target.element, hConfig.highlightClass);
+        hConfig.onDehighlight(component, target);
+        emit(target, dehighlight$1());
+      }
+    };
+    var highlight = function (component, hConfig, hState, target) {
+      dehighlightAllExcept(component, hConfig, hState, [target]);
+      if (!isHighlighted(component, hConfig, hState, target)) {
+        add$2(target.element, hConfig.highlightClass);
+        hConfig.onHighlight(component, target);
+        emit(target, highlight$1());
+      }
+    };
+    var highlightFirst = function (component, hConfig, hState) {
+      getFirst(component, hConfig).each(function (firstComp) {
+        highlight(component, hConfig, hState, firstComp);
+      });
+    };
+    var highlightLast = function (component, hConfig, hState) {
+      getLast(component, hConfig).each(function (lastComp) {
+        highlight(component, hConfig, hState, lastComp);
+      });
+    };
+    var highlightAt = function (component, hConfig, hState, index) {
+      getByIndex(component, hConfig, hState, index).fold(function (err) {
+        throw err;
+      }, function (firstComp) {
+        highlight(component, hConfig, hState, firstComp);
+      });
+    };
+    var highlightBy = function (component, hConfig, hState, predicate) {
+      var candidates = getCandidates(component, hConfig);
+      var targetComp = find$5(candidates, predicate);
+      targetComp.each(function (c) {
+        highlight(component, hConfig, hState, c);
+      });
+    };
+    var isHighlighted = function (component, hConfig, hState, queryTarget) {
+      return has(queryTarget.element, hConfig.highlightClass);
+    };
+    var getHighlighted = function (component, hConfig, _hState) {
+      return descendant(component.element, '.' + hConfig.highlightClass).bind(function (e) {
+        return component.getSystem().getByDom(e).toOptional();
+      });
+    };
+    var getByIndex = function (component, hConfig, hState, index) {
+      var items = descendants(component.element, '.' + hConfig.itemClass);
+      return Optional.from(items[index]).fold(function () {
+        return Result.error(new Error('No element found with index ' + index));
+      }, component.getSystem().getByDom);
+    };
+    var getFirst = function (component, hConfig, _hState) {
+      return descendant(component.element, '.' + hConfig.itemClass).bind(function (e) {
+        return component.getSystem().getByDom(e).toOptional();
+      });
+    };
+    var getLast = function (component, hConfig, _hState) {
+      var items = descendants(component.element, '.' + hConfig.itemClass);
+      var last = items.length > 0 ? Optional.some(items[items.length - 1]) : Optional.none();
+      return last.bind(function (c) {
+        return component.getSystem().getByDom(c).toOptional();
+      });
+    };
+    var getDelta$2 = function (component, hConfig, hState, delta) {
+      var items = descendants(component.element, '.' + hConfig.itemClass);
+      var current = findIndex$1(items, function (item) {
+        return has(item, hConfig.highlightClass);
+      });
+      return current.bind(function (selected) {
+        var dest = cycleBy(selected, delta, 0, items.length - 1);
+        return component.getSystem().getByDom(items[dest]).toOptional();
+      });
+    };
+    var getPrevious = function (component, hConfig, hState) {
+      return getDelta$2(component, hConfig, hState, -1);
+    };
+    var getNext = function (component, hConfig, hState) {
+      return getDelta$2(component, hConfig, hState, +1);
+    };
+    var getCandidates = function (component, hConfig, _hState) {
+      var items = descendants(component.element, '.' + hConfig.itemClass);
+      return cat(map$2(items, function (i) {
+        return component.getSystem().getByDom(i).toOptional();
+      }));
+    };
+
+    var HighlightApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        dehighlightAll: dehighlightAll,
+        dehighlight: dehighlight,
+        highlight: highlight,
+        highlightFirst: highlightFirst,
+        highlightLast: highlightLast,
+        highlightAt: highlightAt,
+        highlightBy: highlightBy,
+        isHighlighted: isHighlighted,
+        getHighlighted: getHighlighted,
+        getFirst: getFirst,
+        getLast: getLast,
+        getPrevious: getPrevious,
+        getNext: getNext,
+        getCandidates: getCandidates
+    });
+
+    var HighlightSchema = [
+      required$1('highlightClass'),
+      required$1('itemClass'),
+      onHandler('onHighlight'),
+      onHandler('onDehighlight')
+    ];
+
+    var Highlighting = create$8({
+      fields: HighlightSchema,
+      name: 'highlighting',
+      apis: HighlightApis
+    });
+
+    var BACKSPACE = [8];
+    var TAB = [9];
+    var ENTER = [13];
+    var ESCAPE = [27];
+    var SPACE = [32];
+    var LEFT = [37];
+    var UP = [38];
+    var RIGHT = [39];
+    var DOWN = [40];
+
+    var cyclePrev = function (values, index, predicate) {
+      var before = reverse(values.slice(0, index));
+      var after = reverse(values.slice(index + 1));
+      return find$5(before.concat(after), predicate);
+    };
+    var tryPrev = function (values, index, predicate) {
+      var before = reverse(values.slice(0, index));
+      return find$5(before, predicate);
+    };
+    var cycleNext = function (values, index, predicate) {
+      var before = values.slice(0, index);
+      var after = values.slice(index + 1);
+      return find$5(after.concat(before), predicate);
+    };
+    var tryNext = function (values, index, predicate) {
+      var after = values.slice(index + 1);
+      return find$5(after, predicate);
+    };
+
+    var inSet = function (keys) {
+      return function (event) {
+        var raw = event.raw;
+        return contains$2(keys, raw.which);
+      };
+    };
+    var and = function (preds) {
+      return function (event) {
+        return forall(preds, function (pred) {
+          return pred(event);
+        });
+      };
+    };
+    var isShift = function (event) {
+      var raw = event.raw;
+      return raw.shiftKey === true;
+    };
+    var isControl = function (event) {
+      var raw = event.raw;
+      return raw.ctrlKey === true;
+    };
+    var isNotShift = not(isShift);
+
+    var rule = function (matches, action) {
+      return {
+        matches: matches,
+        classification: action
+      };
+    };
+    var choose = function (transitions, event) {
+      var transition = find$5(transitions, function (t) {
+        return t.matches(event);
+      });
+      return transition.map(function (t) {
+        return t.classification;
+      });
+    };
+
+    var reportFocusShifting = function (component, prevFocus, newFocus) {
+      var noChange = prevFocus.exists(function (p) {
+        return newFocus.exists(function (n) {
+          return eq(n, p);
+        });
+      });
+      if (!noChange) {
+        emitWith(component, focusShifted(), {
+          prevFocus: prevFocus,
+          newFocus: newFocus
+        });
+      }
+    };
+    var dom$2 = function () {
+      var get = function (component) {
+        return search(component.element);
+      };
+      var set = function (component, focusee) {
+        var prevFocus = get(component);
+        component.getSystem().triggerFocus(focusee, component.element);
+        var newFocus = get(component);
+        reportFocusShifting(component, prevFocus, newFocus);
+      };
+      return {
+        get: get,
+        set: set
+      };
+    };
+    var highlights = function () {
+      var get = function (component) {
+        return Highlighting.getHighlighted(component).map(function (item) {
+          return item.element;
+        });
+      };
+      var set = function (component, element) {
+        var prevFocus = get(component);
+        component.getSystem().getByDom(element).fold(noop, function (item) {
+          Highlighting.highlight(component, item);
+        });
+        var newFocus = get(component);
+        reportFocusShifting(component, prevFocus, newFocus);
+      };
+      return {
+        get: get,
+        set: set
+      };
+    };
+
+    var FocusInsideModes;
+    (function (FocusInsideModes) {
+      FocusInsideModes['OnFocusMode'] = 'onFocus';
+      FocusInsideModes['OnEnterOrSpaceMode'] = 'onEnterOrSpace';
+      FocusInsideModes['OnApiMode'] = 'onApi';
+    }(FocusInsideModes || (FocusInsideModes = {})));
+
+    var typical = function (infoSchema, stateInit, getKeydownRules, getKeyupRules, optFocusIn) {
+      var schema = function () {
+        return infoSchema.concat([
+          defaulted('focusManager', dom$2()),
+          defaultedOf('focusInside', 'onFocus', valueOf(function (val) {
+            return contains$2([
+              'onFocus',
+              'onEnterOrSpace',
+              'onApi'
+            ], val) ? Result.value(val) : Result.error('Invalid value for focusInside');
+          })),
+          output$1('handler', me),
+          output$1('state', stateInit),
+          output$1('sendFocusIn', optFocusIn)
+        ]);
+      };
+      var processKey = function (component, simulatedEvent, getRules, keyingConfig, keyingState) {
+        var rules = getRules(component, simulatedEvent, keyingConfig, keyingState);
+        return choose(rules, simulatedEvent.event).bind(function (rule) {
+          return rule(component, simulatedEvent, keyingConfig, keyingState);
+        });
+      };
+      var toEvents = function (keyingConfig, keyingState) {
+        var onFocusHandler = keyingConfig.focusInside !== FocusInsideModes.OnFocusMode ? Optional.none() : optFocusIn(keyingConfig).map(function (focusIn) {
+          return run$1(focus$4(), function (component, simulatedEvent) {
+            focusIn(component, keyingConfig, keyingState);
+            simulatedEvent.stop();
+          });
+        });
+        var tryGoInsideComponent = function (component, simulatedEvent) {
+          var isEnterOrSpace = inSet(SPACE.concat(ENTER))(simulatedEvent.event);
+          if (keyingConfig.focusInside === FocusInsideModes.OnEnterOrSpaceMode && isEnterOrSpace && isSource(component, simulatedEvent)) {
+            optFocusIn(keyingConfig).each(function (focusIn) {
+              focusIn(component, keyingConfig, keyingState);
+              simulatedEvent.stop();
+            });
+          }
+        };
+        var keyboardEvents = [
+          run$1(keydown(), function (component, simulatedEvent) {
+            processKey(component, simulatedEvent, getKeydownRules, keyingConfig, keyingState).fold(function () {
+              tryGoInsideComponent(component, simulatedEvent);
+            }, function (_) {
+              simulatedEvent.stop();
+            });
+          }),
+          run$1(keyup(), function (component, simulatedEvent) {
+            processKey(component, simulatedEvent, getKeyupRules, keyingConfig, keyingState).each(function (_) {
+              simulatedEvent.stop();
+            });
+          })
+        ];
+        return derive$2(onFocusHandler.toArray().concat(keyboardEvents));
+      };
+      var me = {
+        schema: schema,
+        processKey: processKey,
+        toEvents: toEvents
+      };
+      return me;
+    };
+
+    var create$6 = function (cyclicField) {
+      var schema = [
+        option('onEscape'),
+        option('onEnter'),
+        defaulted('selector', '[data-alloy-tabstop="true"]:not(:disabled)'),
+        defaulted('firstTabstop', 0),
+        defaulted('useTabstopAt', always),
+        option('visibilitySelector')
+      ].concat([cyclicField]);
+      var isVisible = function (tabbingConfig, element) {
+        var target = tabbingConfig.visibilitySelector.bind(function (sel) {
+          return closest$1(element, sel);
+        }).getOr(element);
+        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.from(visibles[tabbingConfig.firstTabstop]);
+      };
+      var findCurrent = function (component, tabbingConfig) {
+        return tabbingConfig.focusManager.get(component).bind(function (elem) {
+          return closest$1(elem, tabbingConfig.selector);
+        });
+      };
+      var isTabstop = function (tabbingConfig, element) {
+        return isVisible(tabbingConfig, element) && tabbingConfig.useTabstopAt(element);
+      };
+      var focusIn = function (component, tabbingConfig, _tabbingState) {
+        findInitial(component, tabbingConfig).each(function (target) {
+          tabbingConfig.focusManager.set(component, target);
+        });
+      };
+      var goFromTabstop = function (component, tabstops, stopIndex, tabbingConfig, cycle) {
+        return cycle(tabstops, stopIndex, function (elem) {
+          return isTabstop(tabbingConfig, elem);
+        }).fold(function () {
+          return tabbingConfig.cyclic ? Optional.some(true) : Optional.none();
+        }, function (target) {
+          tabbingConfig.focusManager.set(component, target);
+          return Optional.some(true);
+        });
+      };
+      var go = function (component, _simulatedEvent, tabbingConfig, cycle) {
+        var tabstops = descendants(component.element, tabbingConfig.selector);
+        return findCurrent(component, tabbingConfig).bind(function (tabstop) {
+          var optStopIndex = findIndex$1(tabstops, curry(eq, tabstop));
+          return optStopIndex.bind(function (stopIndex) {
+            return goFromTabstop(component, tabstops, stopIndex, tabbingConfig, cycle);
+          });
+        });
+      };
+      var goBackwards = function (component, simulatedEvent, tabbingConfig) {
+        var navigate = tabbingConfig.cyclic ? cyclePrev : tryPrev;
+        return go(component, simulatedEvent, tabbingConfig, navigate);
+      };
+      var goForwards = function (component, simulatedEvent, tabbingConfig) {
+        var navigate = tabbingConfig.cyclic ? cycleNext : tryNext;
+        return go(component, simulatedEvent, tabbingConfig, navigate);
+      };
+      var execute = function (component, simulatedEvent, tabbingConfig) {
+        return tabbingConfig.onEnter.bind(function (f) {
+          return f(component, simulatedEvent);
+        });
+      };
+      var exit = function (component, simulatedEvent, tabbingConfig) {
+        return tabbingConfig.onEscape.bind(function (f) {
+          return f(component, simulatedEvent);
+        });
+      };
+      var getKeydownRules = constant$1([
+        rule(and([
+          isShift,
+          inSet(TAB)
+        ]), goBackwards),
+        rule(inSet(TAB), goForwards),
+        rule(inSet(ESCAPE), exit),
+        rule(and([
+          isNotShift,
+          inSet(ENTER)
+        ]), execute)
+      ]);
+      var getKeyupRules = constant$1([]);
+      return typical(schema, NoState.init, getKeydownRules, getKeyupRules, function () {
+        return Optional.some(focusIn);
+      });
+    };
+
+    var AcyclicType = create$6(customField('cyclic', never));
+
+    var CyclicType = create$6(customField('cyclic', always));
+
+    var doDefaultExecute = function (component, _simulatedEvent, focused) {
+      dispatch(component, focused, execute$5());
+      return Optional.some(true);
+    };
+    var defaultExecute = function (component, simulatedEvent, focused) {
+      var isComplex = inside(focused) && inSet(SPACE)(simulatedEvent.event);
+      return isComplex ? Optional.none() : doDefaultExecute(component, simulatedEvent, focused);
+    };
+    var stopEventForFirefox = function (_component, _simulatedEvent) {
+      return Optional.some(true);
+    };
+
+    var schema$v = [
+      defaulted('execute', defaultExecute),
+      defaulted('useSpace', false),
+      defaulted('useEnter', true),
+      defaulted('useControlEnter', false),
+      defaulted('useDown', false)
+    ];
+    var execute$4 = function (component, simulatedEvent, executeConfig) {
+      return executeConfig.execute(component, simulatedEvent, component.element);
+    };
+    var getKeydownRules$5 = function (component, _simulatedEvent, executeConfig, _executeState) {
+      var spaceExec = executeConfig.useSpace && !inside(component.element) ? SPACE : [];
+      var enterExec = executeConfig.useEnter ? ENTER : [];
+      var downExec = executeConfig.useDown ? DOWN : [];
+      var execKeys = spaceExec.concat(enterExec).concat(downExec);
+      return [rule(inSet(execKeys), execute$4)].concat(executeConfig.useControlEnter ? [rule(and([
+          isControl,
+          inSet(ENTER)
+        ]), execute$4)] : []);
+    };
+    var getKeyupRules$5 = function (component, _simulatedEvent, executeConfig, _executeState) {
+      return executeConfig.useSpace && !inside(component.element) ? [rule(inSet(SPACE), stopEventForFirefox)] : [];
+    };
+    var ExecutionType = typical(schema$v, NoState.init, getKeydownRules$5, getKeyupRules$5, function () {
+      return Optional.none();
+    });
+
+    var flatgrid$1 = function () {
+      var dimensions = value$1();
+      var setGridSize = function (numRows, numColumns) {
+        dimensions.set({
+          numRows: numRows,
+          numColumns: numColumns
+        });
+      };
+      var getNumRows = function () {
+        return dimensions.get().map(function (d) {
+          return d.numRows;
+        });
+      };
+      var getNumColumns = function () {
+        return dimensions.get().map(function (d) {
+          return d.numColumns;
+        });
+      };
+      return nu$8({
+        readState: function () {
+          return dimensions.get().map(function (d) {
+            return {
+              numRows: String(d.numRows),
+              numColumns: String(d.numColumns)
+            };
+          }).getOr({
+            numRows: '?',
+            numColumns: '?'
+          });
+        },
+        setGridSize: setGridSize,
+        getNumRows: getNumRows,
+        getNumColumns: getNumColumns
+      });
+    };
+    var init$d = function (spec) {
+      return spec.state(spec);
+    };
+
+    var KeyingState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        flatgrid: flatgrid$1,
+        init: init$d
+    });
+
+    var useH = function (movement) {
+      return function (component, simulatedEvent, config, state) {
+        var move = movement(component.element);
+        return use(move, component, simulatedEvent, config, state);
+      };
+    };
+    var west$1 = function (moveLeft, moveRight) {
+      var movement = onDirection(moveLeft, moveRight);
+      return useH(movement);
+    };
+    var east$1 = function (moveLeft, moveRight) {
+      var movement = onDirection(moveRight, moveLeft);
+      return useH(movement);
+    };
+    var useV = function (move) {
+      return function (component, simulatedEvent, config, state) {
+        return use(move, component, simulatedEvent, config, state);
+      };
+    };
+    var use = function (move, component, simulatedEvent, config, state) {
+      var outcome = config.focusManager.get(component).bind(function (focused) {
+        return move(component.element, focused, config, state);
+      });
+      return outcome.map(function (newFocus) {
+        config.focusManager.set(component, newFocus);
+        return true;
+      });
+    };
+    var north$1 = useV;
+    var south$1 = useV;
+    var move$1 = useV;
+
+    var isHidden$1 = function (dom) {
+      return dom.offsetWidth <= 0 && dom.offsetHeight <= 0;
+    };
+    var isVisible = function (element) {
+      return !isHidden$1(element.dom);
+    };
+
+    var locate = function (candidates, predicate) {
+      return findIndex$1(candidates, predicate).map(function (index) {
+        return {
+          index: index,
+          candidates: candidates
+        };
+      });
+    };
+
+    var locateVisible = function (container, current, selector) {
+      var predicate = function (x) {
+        return eq(x, current);
+      };
+      var candidates = descendants(container, selector);
+      var visible = filter$2(candidates, isVisible);
+      return locate(visible, predicate);
+    };
+    var findIndex = function (elements, target) {
+      return findIndex$1(elements, function (elem) {
+        return eq(target, elem);
+      });
+    };
+
+    var withGrid = function (values, index, numCols, f) {
+      var oldRow = Math.floor(index / numCols);
+      var oldColumn = index % numCols;
+      return f(oldRow, oldColumn).bind(function (address) {
+        var newIndex = address.row * numCols + address.column;
+        return newIndex >= 0 && newIndex < values.length ? Optional.some(values[newIndex]) : Optional.none();
+      });
+    };
+    var cycleHorizontal$1 = function (values, index, numRows, numCols, delta) {
+      return withGrid(values, index, numCols, function (oldRow, oldColumn) {
+        var onLastRow = oldRow === numRows - 1;
+        var colsInRow = onLastRow ? values.length - oldRow * numCols : numCols;
+        var newColumn = cycleBy(oldColumn, delta, 0, colsInRow - 1);
+        return Optional.some({
+          row: oldRow,
+          column: newColumn
+        });
+      });
+    };
+    var cycleVertical$1 = function (values, index, numRows, numCols, delta) {
+      return withGrid(values, index, numCols, function (oldRow, oldColumn) {
+        var newRow = cycleBy(oldRow, delta, 0, numRows - 1);
+        var onLastRow = newRow === numRows - 1;
+        var colsInRow = onLastRow ? values.length - newRow * numCols : numCols;
+        var newCol = clamp$1(oldColumn, 0, colsInRow - 1);
+        return Optional.some({
+          row: newRow,
+          column: newCol
+        });
+      });
+    };
+    var cycleRight$1 = function (values, index, numRows, numCols) {
+      return cycleHorizontal$1(values, index, numRows, numCols, +1);
+    };
+    var cycleLeft$1 = function (values, index, numRows, numCols) {
+      return cycleHorizontal$1(values, index, numRows, numCols, -1);
+    };
+    var cycleUp$1 = function (values, index, numRows, numCols) {
+      return cycleVertical$1(values, index, numRows, numCols, -1);
+    };
+    var cycleDown$1 = function (values, index, numRows, numCols) {
+      return cycleVertical$1(values, index, numRows, numCols, +1);
+    };
+
+    var schema$u = [
+      required$1('selector'),
+      defaulted('execute', defaultExecute),
+      onKeyboardHandler('onEscape'),
+      defaulted('captureTab', false),
+      initSize()
+    ];
+    var focusIn$3 = function (component, gridConfig, _gridState) {
+      descendant(component.element, gridConfig.selector).each(function (first) {
+        gridConfig.focusManager.set(component, first);
+      });
+    };
+    var findCurrent$1 = function (component, gridConfig) {
+      return gridConfig.focusManager.get(component).bind(function (elem) {
+        return closest$1(elem, gridConfig.selector);
+      });
+    };
+    var execute$3 = function (component, simulatedEvent, gridConfig, _gridState) {
+      return findCurrent$1(component, gridConfig).bind(function (focused) {
+        return gridConfig.execute(component, simulatedEvent, focused);
+      });
+    };
+    var doMove$2 = function (cycle) {
+      return function (element, focused, gridConfig, gridState) {
+        return locateVisible(element, focused, gridConfig.selector).bind(function (identified) {
+          return cycle(identified.candidates, identified.index, gridState.getNumRows().getOr(gridConfig.initSize.numRows), gridState.getNumColumns().getOr(gridConfig.initSize.numColumns));
+        });
+      };
+    };
+    var handleTab = function (_component, _simulatedEvent, gridConfig) {
+      return gridConfig.captureTab ? Optional.some(true) : Optional.none();
+    };
+    var doEscape$1 = function (component, simulatedEvent, gridConfig) {
+      return gridConfig.onEscape(component, simulatedEvent);
+    };
+    var moveLeft$3 = doMove$2(cycleLeft$1);
+    var moveRight$3 = doMove$2(cycleRight$1);
+    var moveNorth$1 = doMove$2(cycleUp$1);
+    var moveSouth$1 = doMove$2(cycleDown$1);
+    var getKeydownRules$4 = constant$1([
+      rule(inSet(LEFT), west$1(moveLeft$3, moveRight$3)),
+      rule(inSet(RIGHT), east$1(moveLeft$3, moveRight$3)),
+      rule(inSet(UP), north$1(moveNorth$1)),
+      rule(inSet(DOWN), south$1(moveSouth$1)),
+      rule(and([
+        isShift,
+        inSet(TAB)
+      ]), handleTab),
+      rule(and([
+        isNotShift,
+        inSet(TAB)
+      ]), handleTab),
+      rule(inSet(ESCAPE), doEscape$1),
+      rule(inSet(SPACE.concat(ENTER)), execute$3)
+    ]);
+    var getKeyupRules$4 = constant$1([rule(inSet(SPACE), stopEventForFirefox)]);
+    var FlatgridType = typical(schema$u, flatgrid$1, getKeydownRules$4, getKeyupRules$4, function () {
+      return Optional.some(focusIn$3);
+    });
+
+    var horizontal = function (container, selector, current, delta) {
+      var isDisabledButton = function (candidate) {
+        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();
+        } else {
+          return isDisabledButton(candidates[newIndex]) ? tryCycle(initial, newIndex, candidates) : Optional.from(candidates[newIndex]);
+        }
+      };
+      return locateVisible(container, current, selector).bind(function (identified) {
+        var index = identified.index;
+        var candidates = identified.candidates;
+        return tryCycle(index, index, candidates);
+      });
+    };
+
+    var schema$t = [
+      required$1('selector'),
+      defaulted('getInitial', Optional.none),
+      defaulted('execute', defaultExecute),
+      onKeyboardHandler('onEscape'),
+      defaulted('executeOnMove', false),
+      defaulted('allowVertical', true)
+    ];
+    var findCurrent = function (component, flowConfig) {
+      return flowConfig.focusManager.get(component).bind(function (elem) {
+        return closest$1(elem, flowConfig.selector);
+      });
+    };
+    var execute$2 = function (component, simulatedEvent, flowConfig) {
+      return findCurrent(component, flowConfig).bind(function (focused) {
+        return flowConfig.execute(component, simulatedEvent, focused);
+      });
+    };
+    var focusIn$2 = function (component, flowConfig, _state) {
+      flowConfig.getInitial(component).orThunk(function () {
+        return descendant(component.element, flowConfig.selector);
+      }).each(function (first) {
+        flowConfig.focusManager.set(component, first);
+      });
+    };
+    var moveLeft$2 = function (element, focused, info) {
+      return horizontal(element, info.selector, focused, -1);
+    };
+    var moveRight$2 = function (element, focused, info) {
+      return horizontal(element, info.selector, focused, +1);
+    };
+    var doMove$1 = function (movement) {
+      return function (component, simulatedEvent, flowConfig, flowState) {
+        return movement(component, simulatedEvent, flowConfig, flowState).bind(function () {
+          return flowConfig.executeOnMove ? execute$2(component, simulatedEvent, flowConfig) : Optional.some(true);
+        });
+      };
+    };
+    var doEscape = function (component, simulatedEvent, flowConfig) {
+      return flowConfig.onEscape(component, simulatedEvent);
+    };
+    var getKeydownRules$3 = function (_component, _se, flowConfig, _flowState) {
+      var westMovers = LEFT.concat(flowConfig.allowVertical ? UP : []);
+      var eastMovers = RIGHT.concat(flowConfig.allowVertical ? DOWN : []);
+      return [
+        rule(inSet(westMovers), doMove$1(west$1(moveLeft$2, moveRight$2))),
+        rule(inSet(eastMovers), doMove$1(east$1(moveLeft$2, moveRight$2))),
+        rule(inSet(ENTER), execute$2),
+        rule(inSet(SPACE), execute$2),
+        rule(inSet(ESCAPE), doEscape)
+      ];
+    };
+    var getKeyupRules$3 = constant$1([rule(inSet(SPACE), stopEventForFirefox)]);
+    var FlowType = typical(schema$t, NoState.init, getKeydownRules$3, getKeyupRules$3, function () {
+      return Optional.some(focusIn$2);
+    });
+
+    var toCell = function (matrix, rowIndex, columnIndex) {
+      return Optional.from(matrix[rowIndex]).bind(function (row) {
+        return Optional.from(row[columnIndex]).map(function (cell) {
+          return {
+            rowIndex: rowIndex,
+            columnIndex: columnIndex,
+            cell: cell
+          };
+        });
+      });
+    };
+    var cycleHorizontal = function (matrix, rowIndex, startCol, deltaCol) {
+      var row = matrix[rowIndex];
+      var colsInRow = row.length;
+      var newColIndex = cycleBy(startCol, deltaCol, 0, colsInRow - 1);
+      return toCell(matrix, rowIndex, newColIndex);
+    };
+    var cycleVertical = function (matrix, colIndex, startRow, deltaRow) {
+      var nextRowIndex = cycleBy(startRow, deltaRow, 0, matrix.length - 1);
+      var colsInNextRow = matrix[nextRowIndex].length;
+      var nextColIndex = clamp$1(colIndex, 0, colsInNextRow - 1);
+      return toCell(matrix, nextRowIndex, nextColIndex);
+    };
+    var moveHorizontal = function (matrix, rowIndex, startCol, deltaCol) {
+      var row = matrix[rowIndex];
+      var colsInRow = row.length;
+      var newColIndex = clamp$1(startCol + deltaCol, 0, colsInRow - 1);
+      return toCell(matrix, rowIndex, newColIndex);
+    };
+    var moveVertical = function (matrix, colIndex, startRow, deltaRow) {
+      var nextRowIndex = clamp$1(startRow + deltaRow, 0, matrix.length - 1);
+      var colsInNextRow = matrix[nextRowIndex].length;
+      var nextColIndex = clamp$1(colIndex, 0, colsInNextRow - 1);
+      return toCell(matrix, nextRowIndex, nextColIndex);
+    };
+    var cycleRight = function (matrix, startRow, startCol) {
+      return cycleHorizontal(matrix, startRow, startCol, +1);
+    };
+    var cycleLeft = function (matrix, startRow, startCol) {
+      return cycleHorizontal(matrix, startRow, startCol, -1);
+    };
+    var cycleUp = function (matrix, startRow, startCol) {
+      return cycleVertical(matrix, startCol, startRow, -1);
+    };
+    var cycleDown = function (matrix, startRow, startCol) {
+      return cycleVertical(matrix, startCol, startRow, +1);
+    };
+    var moveLeft$1 = function (matrix, startRow, startCol) {
+      return moveHorizontal(matrix, startRow, startCol, -1);
+    };
+    var moveRight$1 = function (matrix, startRow, startCol) {
+      return moveHorizontal(matrix, startRow, startCol, +1);
+    };
+    var moveUp$1 = function (matrix, startRow, startCol) {
+      return moveVertical(matrix, startCol, startRow, -1);
+    };
+    var moveDown$1 = function (matrix, startRow, startCol) {
+      return moveVertical(matrix, startCol, startRow, +1);
+    };
+
+    var schema$s = [
+      requiredObjOf('selectors', [
+        required$1('row'),
+        required$1('cell')
+      ]),
+      defaulted('cycles', true),
+      defaulted('previousSelector', Optional.none),
+      defaulted('execute', defaultExecute)
+    ];
+    var focusIn$1 = function (component, matrixConfig, _state) {
+      var focused = matrixConfig.previousSelector(component).orThunk(function () {
+        var selectors = matrixConfig.selectors;
+        return descendant(component.element, selectors.cell);
+      });
+      focused.each(function (cell) {
+        matrixConfig.focusManager.set(component, cell);
+      });
+    };
+    var execute$1 = function (component, simulatedEvent, matrixConfig) {
+      return search(component.element).bind(function (focused) {
+        return matrixConfig.execute(component, simulatedEvent, focused);
+      });
+    };
+    var toMatrix = function (rows, matrixConfig) {
+      return map$2(rows, function (row) {
+        return descendants(row, matrixConfig.selectors.cell);
+      });
+    };
+    var doMove = function (ifCycle, ifMove) {
+      return function (element, focused, matrixConfig) {
+        var move = matrixConfig.cycles ? ifCycle : ifMove;
+        return closest$1(focused, matrixConfig.selectors.row).bind(function (inRow) {
+          var cellsInRow = descendants(inRow, matrixConfig.selectors.cell);
+          return findIndex(cellsInRow, focused).bind(function (colIndex) {
+            var allRows = descendants(element, matrixConfig.selectors.row);
+            return findIndex(allRows, inRow).bind(function (rowIndex) {
+              var matrix = toMatrix(allRows, matrixConfig);
+              return move(matrix, rowIndex, colIndex).map(function (next) {
+                return next.cell;
+              });
+            });
+          });
+        });
+      };
+    };
+    var moveLeft = doMove(cycleLeft, moveLeft$1);
+    var moveRight = doMove(cycleRight, moveRight$1);
+    var moveNorth = doMove(cycleUp, moveUp$1);
+    var moveSouth = doMove(cycleDown, moveDown$1);
+    var getKeydownRules$2 = constant$1([
+      rule(inSet(LEFT), west$1(moveLeft, moveRight)),
+      rule(inSet(RIGHT), east$1(moveLeft, moveRight)),
+      rule(inSet(UP), north$1(moveNorth)),
+      rule(inSet(DOWN), south$1(moveSouth)),
+      rule(inSet(SPACE.concat(ENTER)), execute$1)
+    ]);
+    var getKeyupRules$2 = constant$1([rule(inSet(SPACE), stopEventForFirefox)]);
+    var MatrixType = typical(schema$s, NoState.init, getKeydownRules$2, getKeyupRules$2, function () {
+      return Optional.some(focusIn$1);
+    });
+
+    var schema$r = [
+      required$1('selector'),
+      defaulted('execute', defaultExecute),
+      defaulted('moveOnTab', false)
+    ];
+    var execute = function (component, simulatedEvent, menuConfig) {
+      return menuConfig.focusManager.get(component).bind(function (focused) {
+        return menuConfig.execute(component, simulatedEvent, focused);
+      });
+    };
+    var focusIn = function (component, menuConfig, _state) {
+      descendant(component.element, menuConfig.selector).each(function (first) {
+        menuConfig.focusManager.set(component, first);
+      });
+    };
+    var moveUp = function (element, focused, info) {
+      return horizontal(element, info.selector, focused, -1);
+    };
+    var moveDown = function (element, focused, info) {
+      return horizontal(element, info.selector, focused, +1);
+    };
+    var fireShiftTab = function (component, simulatedEvent, menuConfig, menuState) {
+      return menuConfig.moveOnTab ? move$1(moveUp)(component, simulatedEvent, menuConfig, menuState) : Optional.none();
+    };
+    var fireTab = function (component, simulatedEvent, menuConfig, menuState) {
+      return menuConfig.moveOnTab ? move$1(moveDown)(component, simulatedEvent, menuConfig, menuState) : Optional.none();
+    };
+    var getKeydownRules$1 = constant$1([
+      rule(inSet(UP), move$1(moveUp)),
+      rule(inSet(DOWN), move$1(moveDown)),
+      rule(and([
+        isShift,
+        inSet(TAB)
+      ]), fireShiftTab),
+      rule(and([
+        isNotShift,
+        inSet(TAB)
+      ]), fireTab),
+      rule(inSet(ENTER), execute),
+      rule(inSet(SPACE), execute)
+    ]);
+    var getKeyupRules$1 = constant$1([rule(inSet(SPACE), stopEventForFirefox)]);
+    var MenuType = typical(schema$r, NoState.init, getKeydownRules$1, getKeyupRules$1, function () {
+      return Optional.some(focusIn);
+    });
+
+    var schema$q = [
+      onKeyboardHandler('onSpace'),
+      onKeyboardHandler('onEnter'),
+      onKeyboardHandler('onShiftEnter'),
+      onKeyboardHandler('onLeft'),
+      onKeyboardHandler('onRight'),
+      onKeyboardHandler('onTab'),
+      onKeyboardHandler('onShiftTab'),
+      onKeyboardHandler('onUp'),
+      onKeyboardHandler('onDown'),
+      onKeyboardHandler('onEscape'),
+      defaulted('stopSpaceKeyup', false),
+      option('focusIn')
+    ];
+    var getKeydownRules = function (component, simulatedEvent, specialInfo) {
+      return [
+        rule(inSet(SPACE), specialInfo.onSpace),
+        rule(and([
+          isNotShift,
+          inSet(ENTER)
+        ]), specialInfo.onEnter),
+        rule(and([
+          isShift,
+          inSet(ENTER)
+        ]), specialInfo.onShiftEnter),
+        rule(and([
+          isShift,
+          inSet(TAB)
+        ]), specialInfo.onShiftTab),
+        rule(and([
+          isNotShift,
+          inSet(TAB)
+        ]), specialInfo.onTab),
+        rule(inSet(UP), specialInfo.onUp),
+        rule(inSet(DOWN), specialInfo.onDown),
+        rule(inSet(LEFT), specialInfo.onLeft),
+        rule(inSet(RIGHT), specialInfo.onRight),
+        rule(inSet(SPACE), specialInfo.onSpace),
+        rule(inSet(ESCAPE), specialInfo.onEscape)
+      ];
+    };
+    var getKeyupRules = function (component, simulatedEvent, specialInfo) {
+      return specialInfo.stopSpaceKeyup ? [rule(inSet(SPACE), stopEventForFirefox)] : [];
+    };
+    var SpecialType = typical(schema$q, NoState.init, getKeydownRules, getKeyupRules, function (specialInfo) {
+      return specialInfo.focusIn;
+    });
+
+    var acyclic = AcyclicType.schema();
+    var cyclic = CyclicType.schema();
+    var flow = FlowType.schema();
+    var flatgrid = FlatgridType.schema();
+    var matrix = MatrixType.schema();
+    var execution = ExecutionType.schema();
+    var menu = MenuType.schema();
+    var special = SpecialType.schema();
+
+    var KeyboardBranches = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        acyclic: acyclic,
+        cyclic: cyclic,
+        flow: flow,
+        flatgrid: flatgrid,
+        matrix: matrix,
+        execution: execution,
+        menu: menu,
+        special: special
+    });
+
+    var isFlatgridState = function (keyState) {
+      return hasNonNullableKey(keyState, 'setGridSize');
+    };
+    var Keying = createModes({
+      branchKey: 'mode',
+      branches: KeyboardBranches,
+      name: 'keying',
+      active: {
+        events: function (keyingConfig, keyingState) {
+          var handler = keyingConfig.handler;
+          return handler.toEvents(keyingConfig, keyingState);
+        }
+      },
+      apis: {
+        focusIn: function (component, keyConfig, keyState) {
+          keyConfig.sendFocusIn(keyConfig).fold(function () {
+            component.getSystem().triggerFocus(component.element, component.element);
+          }, function (sendFocusIn) {
+            sendFocusIn(component, keyConfig, keyState);
+          });
+        },
+        setGridSize: function (component, keyConfig, keyState, numRows, numColumns) {
+          if (!isFlatgridState(keyState)) {
+            console.error('Layout does not support setGridSize');
+          } else {
+            keyState.setGridSize(numRows, numColumns);
+          }
+        }
+      },
+      state: KeyingState
+    });
+
+    var set$2 = function (component, replaceConfig, replaceState, data) {
+      preserve$1(function () {
+        var newChildren = map$2(data, component.getSystem().build);
+        replaceChildren(component, newChildren);
+      }, component.element);
+    };
+    var insert = function (component, replaceConfig, insertion, childSpec) {
+      var child = component.getSystem().build(childSpec);
+      attachWith(component, child, insertion);
+    };
+    var append = function (component, replaceConfig, replaceState, appendee) {
+      insert(component, replaceConfig, append$2, appendee);
+    };
+    var prepend = function (component, replaceConfig, replaceState, prependee) {
+      insert(component, replaceConfig, prepend$1, prependee);
+    };
+    var remove = function (component, replaceConfig, replaceState, removee) {
+      var children = contents(component);
+      var foundChild = find$5(children, function (child) {
+        return eq(removee.element, child.element);
+      });
+      foundChild.each(detach);
+    };
+    var contents = function (component, _replaceConfig) {
+      return component.components();
+    };
+    var replaceAt = function (component, replaceConfig, replaceState, replaceeIndex, replacer) {
+      var children = contents(component);
+      return Optional.from(children[replaceeIndex]).map(function (replacee) {
+        remove(component, replaceConfig, replaceState, replacee);
+        replacer.each(function (r) {
+          insert(component, replaceConfig, function (p, c) {
+            appendAt(p, c, replaceeIndex);
+          }, r);
+        });
+        return replacee;
+      });
+    };
+    var replaceBy = function (component, replaceConfig, replaceState, replaceePred, replacer) {
+      var children = contents(component);
+      return findIndex$1(children, replaceePred).bind(function (replaceeIndex) {
+        return replaceAt(component, replaceConfig, replaceState, replaceeIndex, replacer);
+      });
+    };
+
+    var ReplaceApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        append: append,
+        prepend: prepend,
+        remove: remove,
+        replaceAt: replaceAt,
+        replaceBy: replaceBy,
+        set: set$2,
+        contents: contents
+    });
+
+    var Replacing = create$8({
+      fields: [],
+      name: 'replacing',
+      apis: ReplaceApis
+    });
+
+    var events$d = function (name, eventHandlers) {
+      var events = derive$2(eventHandlers);
+      return create$8({
+        fields: [required$1('enabled')],
+        name: name,
+        active: { events: constant$1(events) }
+      });
+    };
+    var config = function (name, eventHandlers) {
+      var me = events$d(name, eventHandlers);
+      return {
+        key: name,
+        value: {
+          config: {},
+          me: me,
+          configAsRaw: constant$1({}),
+          initialConfig: {},
+          state: NoState
+        }
+      };
+    };
+
+    var focus$2 = function (component, focusConfig) {
+      if (!focusConfig.ignore) {
+        focus$3(component.element);
+        focusConfig.onFocus(component);
+      }
+    };
+    var blur = function (component, focusConfig) {
+      if (!focusConfig.ignore) {
+        blur$1(component.element);
+      }
+    };
+    var isFocused = function (component) {
+      return hasFocus(component.element);
+    };
+
+    var FocusApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        focus: focus$2,
+        blur: blur,
+        isFocused: isFocused
+    });
+
+    var exhibit$4 = function (base, focusConfig) {
+      var mod = focusConfig.ignore ? {} : { attributes: { tabindex: '-1' } };
+      return nu$7(mod);
+    };
+    var events$c = function (focusConfig) {
+      return derive$2([run$1(focus$4(), function (component, simulatedEvent) {
+          focus$2(component, focusConfig);
+          simulatedEvent.stop();
+        })].concat(focusConfig.stopMousedown ? [run$1(mousedown(), function (_, simulatedEvent) {
+          simulatedEvent.event.prevent();
+        })] : []));
+    };
+
+    var ActiveFocus = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit$4,
+        events: events$c
+    });
+
+    var FocusSchema = [
+      onHandler('onFocus'),
+      defaulted('stopMousedown', false),
+      defaulted('ignore', false)
+    ];
+
+    var Focusing = create$8({
+      fields: FocusSchema,
+      name: 'focusing',
+      active: ActiveFocus,
+      apis: FocusApis
+    });
+
+    var SetupBehaviourCellState = function (initialState) {
+      var init = function () {
+        var cell = Cell(initialState);
+        var get = function () {
+          return cell.get();
+        };
+        var set = function (newState) {
+          return cell.set(newState);
+        };
+        var clear = function () {
+          return cell.set(initialState);
+        };
+        var readState = function () {
+          return cell.get();
+        };
+        return {
+          get: get,
+          set: set,
+          clear: clear,
+          readState: readState
+        };
+      };
+      return { init: init };
+    };
+
+    var updateAriaState = function (component, toggleConfig, toggleState) {
+      var ariaInfo = toggleConfig.aria;
+      ariaInfo.update(component, ariaInfo, toggleState.get());
+    };
+    var updateClass = function (component, toggleConfig, toggleState) {
+      toggleConfig.toggleClass.each(function (toggleClass) {
+        if (toggleState.get()) {
+          add$2(component.element, toggleClass);
+        } else {
+          remove$2(component.element, toggleClass);
+        }
+      });
+    };
+    var toggle$2 = function (component, toggleConfig, toggleState) {
+      set$1(component, toggleConfig, toggleState, !toggleState.get());
+    };
+    var on = function (component, toggleConfig, toggleState) {
+      toggleState.set(true);
+      updateClass(component, toggleConfig, toggleState);
+      updateAriaState(component, toggleConfig, toggleState);
+    };
+    var off = function (component, toggleConfig, toggleState) {
+      toggleState.set(false);
+      updateClass(component, toggleConfig, toggleState);
+      updateAriaState(component, toggleConfig, toggleState);
+    };
+    var set$1 = function (component, toggleConfig, toggleState, state) {
+      var action = state ? on : off;
+      action(component, toggleConfig, toggleState);
+    };
+    var isOn = function (component, toggleConfig, toggleState) {
+      return toggleState.get();
+    };
+    var onLoad = function (component, toggleConfig, toggleState) {
+      set$1(component, toggleConfig, toggleState, toggleConfig.selected);
+    };
+
+    var ToggleApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        onLoad: onLoad,
+        toggle: toggle$2,
+        isOn: isOn,
+        on: on,
+        off: off,
+        set: set$1
+    });
+
+    var exhibit$3 = function () {
+      return nu$7({});
+    };
+    var events$b = function (toggleConfig, toggleState) {
+      var execute = executeEvent(toggleConfig, toggleState, toggle$2);
+      var load = loadEvent(toggleConfig, toggleState, onLoad);
+      return derive$2(flatten([
+        toggleConfig.toggleOnExecute ? [execute] : [],
+        [load]
+      ]));
+    };
+
+    var ActiveToggle = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit$3,
+        events: events$b
+    });
+
+    var updatePressed = function (component, ariaInfo, status) {
+      set$8(component.element, 'aria-pressed', status);
+      if (ariaInfo.syncWithExpanded) {
+        updateExpanded(component, ariaInfo, status);
+      }
+    };
+    var updateSelected = function (component, ariaInfo, status) {
+      set$8(component.element, 'aria-selected', status);
+    };
+    var updateChecked = function (component, ariaInfo, status) {
+      set$8(component.element, 'aria-checked', status);
+    };
+    var updateExpanded = function (component, ariaInfo, status) {
+      set$8(component.element, 'aria-expanded', status);
+    };
+
+    var ToggleSchema = [
+      defaulted('selected', false),
+      option('toggleClass'),
+      defaulted('toggleOnExecute', true),
+      defaultedOf('aria', { mode: 'none' }, choose$1('mode', {
+        pressed: [
+          defaulted('syncWithExpanded', false),
+          output$1('update', updatePressed)
+        ],
+        checked: [output$1('update', updateChecked)],
+        expanded: [output$1('update', updateExpanded)],
+        selected: [output$1('update', updateSelected)],
+        none: [output$1('update', noop)]
+      }))
+    ];
+
+    var Toggling = create$8({
+      fields: ToggleSchema,
+      name: 'toggling',
+      active: ActiveToggle,
+      apis: ToggleApis,
+      state: SetupBehaviourCellState(false)
+    });
+
+    var pointerEvents = function () {
+      var onClick = function (component, simulatedEvent) {
+        simulatedEvent.stop();
+        emitExecute(component);
+      };
+      return [
+        run$1(click(), onClick),
+        run$1(tap(), onClick),
+        cutter(touchstart()),
+        cutter(mousedown())
+      ];
+    };
+    var events$a = function (optAction) {
+      var executeHandler = function (action) {
+        return runOnExecute$1(function (component, simulatedEvent) {
+          action(component);
+          simulatedEvent.stop();
+        });
+      };
+      return derive$2(flatten([
+        optAction.map(executeHandler).toArray(),
+        pointerEvents()
+      ]));
+    };
+
+    var hoverEvent = 'alloy.item-hover';
+    var focusEvent = 'alloy.item-focus';
+    var onHover = function (item) {
+      if (search(item.element).isNone() || Focusing.isFocused(item)) {
+        if (!Focusing.isFocused(item)) {
+          Focusing.focus(item);
+        }
+        emitWith(item, hoverEvent, { item: item });
+      }
+    };
+    var onFocus$1 = function (item) {
+      emitWith(item, focusEvent, { item: item });
+    };
+    var hover = constant$1(hoverEvent);
+    var focus$1 = constant$1(focusEvent);
+
+    var builder$2 = function (detail) {
+      return {
+        dom: detail.dom,
+        domModification: __assign(__assign({}, detail.domModification), { attributes: __assign(__assign(__assign({ 'role': detail.toggling.isSome() ? 'menuitemcheckbox' : 'menuitem' }, detail.domModification.attributes), { 'aria-haspopup': detail.hasSubmenu }), detail.hasSubmenu ? { 'aria-expanded': false } : {}) }),
+        behaviours: SketchBehaviours.augment(detail.itemBehaviours, [
+          detail.toggling.fold(Toggling.revoke, function (tConfig) {
+            return Toggling.config(__assign({ aria: { mode: 'checked' } }, tConfig));
+          }),
+          Focusing.config({
+            ignore: detail.ignoreFocus,
+            stopMousedown: detail.ignoreFocus,
+            onFocus: function (component) {
+              onFocus$1(component);
+            }
+          }),
+          Keying.config({ mode: 'execution' }),
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: detail.data
+            }
+          }),
+          config('item-type-events', __spreadArray(__spreadArray([], pointerEvents(), true), [
+            run$1(mouseover(), onHover),
+            run$1(focusItem(), Focusing.focus)
+          ], false))
+        ]),
+        components: detail.components,
+        eventOrder: detail.eventOrder
+      };
+    };
+    var schema$p = [
+      required$1('data'),
+      required$1('components'),
+      required$1('dom'),
+      defaulted('hasSubmenu', false),
+      option('toggling'),
+      SketchBehaviours.field('itemBehaviours', [
+        Toggling,
+        Focusing,
+        Keying,
+        Representing
+      ]),
+      defaulted('ignoreFocus', false),
+      defaulted('domModification', {}),
+      output$1('builder', builder$2),
+      defaulted('eventOrder', {})
+    ];
+
+    var builder$1 = function (detail) {
+      return {
+        dom: detail.dom,
+        components: detail.components,
+        events: derive$2([stopper(focusItem())])
+      };
+    };
+    var schema$o = [
+      required$1('dom'),
+      required$1('components'),
+      output$1('builder', builder$1)
+    ];
+
+    var owner$2 = constant$1('item-widget');
+    var parts$h = constant$1([required({
+        name: 'widget',
+        overrides: function (detail) {
+          return {
+            behaviours: derive$1([Representing.config({
+                store: {
+                  mode: 'manual',
+                  getValue: function (_component) {
+                    return detail.data;
+                  },
+                  setValue: noop
+                }
+              })])
+          };
+        }
+      })]);
+
+    var builder = function (detail) {
+      var subs = substitutes(owner$2(), detail, parts$h());
+      var components = components$1(owner$2(), detail, subs.internals());
+      var focusWidget = function (component) {
+        return getPart(component, detail, 'widget').map(function (widget) {
+          Keying.focusIn(widget);
+          return widget;
+        });
+      };
+      var onHorizontalArrow = function (component, simulatedEvent) {
+        return inside(simulatedEvent.event.target) ? Optional.none() : function () {
+          if (detail.autofocus) {
+            simulatedEvent.setSource(component.element);
+            return Optional.none();
+          } else {
+            return Optional.none();
+          }
+        }();
+      };
+      return {
+        dom: detail.dom,
+        components: components,
+        domModification: detail.domModification,
+        events: derive$2([
+          runOnExecute$1(function (component, simulatedEvent) {
+            focusWidget(component).each(function (_widget) {
+              simulatedEvent.stop();
+            });
+          }),
+          run$1(mouseover(), onHover),
+          run$1(focusItem(), function (component, _simulatedEvent) {
+            if (detail.autofocus) {
+              focusWidget(component);
+            } else {
+              Focusing.focus(component);
+            }
+          })
+        ]),
+        behaviours: SketchBehaviours.augment(detail.widgetBehaviours, [
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: detail.data
+            }
+          }),
+          Focusing.config({
+            ignore: detail.ignoreFocus,
+            onFocus: function (component) {
+              onFocus$1(component);
+            }
+          }),
+          Keying.config({
+            mode: 'special',
+            focusIn: detail.autofocus ? function (component) {
+              focusWidget(component);
+            } : revoke(),
+            onLeft: onHorizontalArrow,
+            onRight: onHorizontalArrow,
+            onEscape: function (component, simulatedEvent) {
+              if (!Focusing.isFocused(component) && !detail.autofocus) {
+                Focusing.focus(component);
+                return Optional.some(true);
+              } else if (detail.autofocus) {
+                simulatedEvent.setSource(component.element);
+                return Optional.none();
+              } else {
+                return Optional.none();
+              }
+            }
+          })
+        ])
+      };
+    };
+    var schema$n = [
+      required$1('uid'),
+      required$1('data'),
+      required$1('components'),
+      required$1('dom'),
+      defaulted('autofocus', false),
+      defaulted('ignoreFocus', false),
+      SketchBehaviours.field('widgetBehaviours', [
+        Representing,
+        Focusing,
+        Keying
+      ]),
+      defaulted('domModification', {}),
+      defaultUidsSchema(parts$h()),
+      output$1('builder', builder)
+    ];
+
+    var itemSchema$2 = choose$1('type', {
+      widget: schema$n,
+      item: schema$p,
+      separator: schema$o
+    });
+    var configureGrid = function (detail, movementInfo) {
+      return {
+        mode: 'flatgrid',
+        selector: '.' + detail.markers.item,
+        initSize: {
+          numColumns: movementInfo.initSize.numColumns,
+          numRows: movementInfo.initSize.numRows
+        },
+        focusManager: detail.focusManager
+      };
+    };
+    var configureMatrix = function (detail, movementInfo) {
+      return {
+        mode: 'matrix',
+        selectors: {
+          row: movementInfo.rowSelector,
+          cell: '.' + detail.markers.item
+        },
+        focusManager: detail.focusManager
+      };
+    };
+    var configureMenu = function (detail, movementInfo) {
+      return {
+        mode: 'menu',
+        selector: '.' + detail.markers.item,
+        moveOnTab: movementInfo.moveOnTab,
+        focusManager: detail.focusManager
+      };
+    };
+    var parts$g = constant$1([group({
+        factory: {
+          sketch: function (spec) {
+            var itemInfo = asRawOrDie$1('menu.spec item', itemSchema$2, spec);
+            return itemInfo.builder(itemInfo);
+          }
+        },
+        name: 'items',
+        unit: 'item',
+        defaults: function (detail, u) {
+          return has$2(u, 'uid') ? u : __assign(__assign({}, u), { uid: generate$5('item') });
+        },
+        overrides: function (detail, u) {
+          return {
+            type: u.type,
+            ignoreFocus: detail.fakeFocus,
+            domModification: { classes: [detail.markers.item] }
+          };
+        }
+      })]);
+    var schema$m = constant$1([
+      required$1('value'),
+      required$1('items'),
+      required$1('dom'),
+      required$1('components'),
+      defaulted('eventOrder', {}),
+      field('menuBehaviours', [
+        Highlighting,
+        Representing,
+        Composing,
+        Keying
+      ]),
+      defaultedOf('movement', {
+        mode: 'menu',
+        moveOnTab: true
+      }, choose$1('mode', {
+        grid: [
+          initSize(),
+          output$1('config', configureGrid)
+        ],
+        matrix: [
+          output$1('config', configureMatrix),
+          required$1('rowSelector')
+        ],
+        menu: [
+          defaulted('moveOnTab', true),
+          output$1('config', configureMenu)
+        ]
+      })),
+      itemMarkers(),
+      defaulted('fakeFocus', false),
+      defaulted('focusManager', dom$2()),
+      onHandler('onHighlight')
+    ]);
+
+    var focus = constant$1('alloy.menu-focus');
+
+    var make$7 = function (detail, components, _spec, _externals) {
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        markers: detail.markers,
+        behaviours: augment(detail.menuBehaviours, [
+          Highlighting.config({
+            highlightClass: detail.markers.selectedItem,
+            itemClass: detail.markers.item,
+            onHighlight: detail.onHighlight
+          }),
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: detail.value
+            }
+          }),
+          Composing.config({ find: Optional.some }),
+          Keying.config(detail.movement.config(detail, detail.movement))
+        ]),
+        events: derive$2([
+          run$1(focus$1(), function (menu, simulatedEvent) {
+            var event = simulatedEvent.event;
+            menu.getSystem().getByDom(event.target).each(function (item) {
+              Highlighting.highlight(menu, item);
+              simulatedEvent.stop();
+              emitWith(menu, focus(), {
+                menu: menu,
+                item: item
+              });
+            });
+          }),
+          run$1(hover(), function (menu, simulatedEvent) {
+            var item = simulatedEvent.event.item;
+            Highlighting.highlight(menu, item);
+          })
+        ]),
+        components: components,
+        eventOrder: detail.eventOrder,
+        domModification: { attributes: { role: 'menu' } }
+      };
+    };
+
+    var Menu = composite({
+      name: 'Menu',
+      configFields: schema$m(),
+      partFields: parts$g(),
+      factory: make$7
+    });
+
+    var transpose$1 = function (obj) {
+      return tupleMap(obj, function (v, k) {
+        return {
+          k: v,
+          v: k
+        };
+      });
+    };
+    var trace = function (items, byItem, byMenu, finish) {
+      return get$e(byMenu, finish).bind(function (triggerItem) {
+        return get$e(items, triggerItem).bind(function (triggerMenu) {
+          var rest = trace(items, byItem, byMenu, triggerMenu);
+          return Optional.some([triggerMenu].concat(rest));
+        });
+      }).getOr([]);
+    };
+    var generate$2 = function (menus, expansions) {
+      var items = {};
+      each(menus, function (menuItems, menu) {
+        each$1(menuItems, function (item) {
+          items[item] = menu;
+        });
+      });
+      var byItem = expansions;
+      var byMenu = transpose$1(expansions);
+      var menuPaths = map$1(byMenu, function (_triggerItem, submenu) {
+        return [submenu].concat(trace(items, byItem, byMenu, submenu));
+      });
+      return map$1(items, function (menu) {
+        return get$e(menuPaths, menu).getOr([menu]);
+      });
+    };
+
+    var init$c = function () {
+      var expansions = Cell({});
+      var menus = Cell({});
+      var paths = Cell({});
+      var primary = value$1();
+      var directory = Cell({});
+      var clear = function () {
+        expansions.set({});
+        menus.set({});
+        paths.set({});
+        primary.clear();
+      };
+      var isClear = function () {
+        return primary.get().isNone();
+      };
+      var setMenuBuilt = function (menuName, built) {
+        var _a;
+        menus.set(__assign(__assign({}, menus.get()), (_a = {}, _a[menuName] = {
+          type: 'prepared',
+          menu: built
+        }, _a)));
+      };
+      var setContents = function (sPrimary, sMenus, sExpansions, dir) {
+        primary.set(sPrimary);
+        expansions.set(sExpansions);
+        menus.set(sMenus);
+        directory.set(dir);
+        var sPaths = generate$2(dir, sExpansions);
+        paths.set(sPaths);
+      };
+      var getTriggeringItem = function (menuValue) {
+        return find$4(expansions.get(), function (v, _k) {
+          return v === menuValue;
+        });
+      };
+      var getTriggerData = function (menuValue, getItemByValue, path) {
+        return getPreparedMenu(menuValue).bind(function (menu) {
+          return getTriggeringItem(menuValue).bind(function (triggeringItemValue) {
+            return getItemByValue(triggeringItemValue).map(function (triggeredItem) {
+              return {
+                triggeredMenu: menu,
+                triggeringItem: triggeredItem,
+                triggeringPath: path
+              };
+            });
+          });
+        });
+      };
+      var getTriggeringPath = function (itemValue, getItemByValue) {
+        var extraPath = filter$2(lookupItem(itemValue).toArray(), function (menuValue) {
+          return getPreparedMenu(menuValue).isSome();
+        });
+        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$1(primary.get(), menuValue) ? [] : [Optional.none()];
+            }, function (data) {
+              return [Optional.some(data)];
+            });
+          });
+          return sequence(triggers);
+        });
+      };
+      var expand = function (itemValue) {
+        return get$e(expansions.get(), itemValue).map(function (menu) {
+          var current = get$e(paths.get(), itemValue).getOr([]);
+          return [menu].concat(current);
+        });
+      };
+      var collapse = function (itemValue) {
+        return get$e(paths.get(), itemValue).bind(function (path) {
+          return path.length > 1 ? Optional.some(path.slice(1)) : Optional.none();
+        });
+      };
+      var refresh = function (itemValue) {
+        return get$e(paths.get(), itemValue);
+      };
+      var getPreparedMenu = function (menuValue) {
+        return lookupMenu(menuValue).bind(extractPreparedMenu);
+      };
+      var lookupMenu = function (menuValue) {
+        return get$e(menus.get(), menuValue);
+      };
+      var lookupItem = function (itemValue) {
+        return get$e(expansions.get(), itemValue);
+      };
+      var otherMenus = function (path) {
+        var menuValues = directory.get();
+        return difference(keys(menuValues), path);
+      };
+      var getPrimary = function () {
+        return primary.get().bind(getPreparedMenu);
+      };
+      var getMenus = function () {
+        return menus.get();
+      };
+      return {
+        setMenuBuilt: setMenuBuilt,
+        setContents: setContents,
+        expand: expand,
+        refresh: refresh,
+        collapse: collapse,
+        lookupMenu: lookupMenu,
+        lookupItem: lookupItem,
+        otherMenus: otherMenus,
+        getPrimary: getPrimary,
+        getMenus: getMenus,
+        clear: clear,
+        isClear: isClear,
+        getTriggeringPath: getTriggeringPath
+      };
+    };
+    var extractPreparedMenu = function (prep) {
+      return prep.type === 'prepared' ? Optional.some(prep.menu) : Optional.none();
+    };
+    var LayeredState = {
+      init: init$c,
+      extractPreparedMenu: extractPreparedMenu
+    };
+
+    var make$6 = function (detail, _rawUiSpec) {
+      var submenuParentItems = value$1();
+      var buildMenus = function (container, primaryName, menus) {
+        return map$1(menus, function (spec, name) {
+          var makeSketch = function () {
+            return Menu.sketch(__assign(__assign({}, spec), {
+              value: name,
+              markers: detail.markers,
+              fakeFocus: detail.fakeFocus,
+              onHighlight: detail.onHighlight,
+              focusManager: detail.fakeFocus ? highlights() : dom$2()
+            }));
+          };
+          return name === primaryName ? {
+            type: 'prepared',
+            menu: container.getSystem().build(makeSketch())
+          } : {
+            type: 'notbuilt',
+            nbMenu: makeSketch
+          };
+        });
+      };
+      var layeredState = LayeredState.init();
+      var setup = function (container) {
+        var componentMap = buildMenus(container, detail.data.primary, detail.data.menus);
+        var directory = toDirectory();
+        layeredState.setContents(detail.data.primary, componentMap, detail.data.expansions, directory);
+        return layeredState.getPrimary();
+      };
+      var getItemValue = function (item) {
+        return Representing.getValue(item).value;
+      };
+      var getItemByValue = function (_container, menus, itemValue) {
+        return findMap(menus, function (menu) {
+          if (!menu.getSystem().isConnected()) {
+            return Optional.none();
+          }
+          var candidates = Highlighting.getCandidates(menu);
+          return find$5(candidates, function (c) {
+            return getItemValue(c) === itemValue;
+          });
+        });
+      };
+      var toDirectory = function (_container) {
+        return map$1(detail.data.menus, function (data, _menuName) {
+          return bind$3(data.items, function (item) {
+            return item.type === 'separator' ? [] : [item.data.value];
+          });
+        });
+      };
+      var setActiveMenu = function (container, menu) {
+        Highlighting.highlight(container, menu);
+        Highlighting.getHighlighted(menu).orThunk(function () {
+          return Highlighting.getFirst(menu);
+        }).each(function (item) {
+          dispatch(container, item.element, focusItem());
+        });
+      };
+      var getMenus = function (state, menuValues) {
+        return cat(map$2(menuValues, function (mv) {
+          return state.lookupMenu(mv).bind(function (prep) {
+            return prep.type === 'prepared' ? Optional.some(prep.menu) : Optional.none();
+          });
+        }));
+      };
+      var closeOthers = function (container, state, path) {
+        var others = getMenus(state, state.otherMenus(path));
+        each$1(others, function (o) {
+          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$d(i, 'aria-haspopup') === 'true';
+          });
+          each$1(parentItems, function (i) {
+            container.getSystem().getByDom(i).each(function (itemComp) {
+              var key = getItemValue(itemComp);
+              r[key] = itemComp;
+            });
+          });
+          submenuParentItems.set(r);
+          return r;
+        });
+      };
+      var updateAriaExpansions = function (container, path) {
+        var parentItems = getSubmenuParents(container);
+        each(parentItems, function (v, k) {
+          var expanded = contains$2(path, k);
+          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) {
+            if (menuPrep.type === 'notbuilt') {
+              return Optional.none();
+            } else {
+              var activeMenu = menuPrep.menu;
+              var rest = getMenus(state, path.slice(1));
+              each$1(rest, function (r) {
+                add$2(r.element, detail.markers.backgroundMenu);
+              });
+              if (!inBody(activeMenu.element)) {
+                Replacing.append(container, premade(activeMenu));
+              }
+              remove$1(activeMenu.element, [detail.markers.backgroundMenu]);
+              setActiveMenu(container, activeMenu);
+              closeOthers(container, state, path);
+              return Optional.some(activeMenu);
+            }
+          });
+        });
+      };
+      var ExpandHighlightDecision;
+      (function (ExpandHighlightDecision) {
+        ExpandHighlightDecision[ExpandHighlightDecision['HighlightSubmenu'] = 0] = 'HighlightSubmenu';
+        ExpandHighlightDecision[ExpandHighlightDecision['HighlightParent'] = 1] = 'HighlightParent';
+      }(ExpandHighlightDecision || (ExpandHighlightDecision = {})));
+      var buildIfRequired = function (container, menuName, menuPrep) {
+        if (menuPrep.type === 'notbuilt') {
+          var menu = container.getSystem().build(menuPrep.nbMenu());
+          layeredState.setMenuBuilt(menuName, menu);
+          return menu;
+        } else {
+          return menuPrep.menu;
+        }
+      };
+      var expandRight = function (container, item, decision) {
+        if (decision === void 0) {
+          decision = ExpandHighlightDecision.HighlightSubmenu;
+        }
+        if (item.hasConfigured(Disabling) && Disabling.isDisabled(item)) {
+          return Optional.some(item);
+        } else {
+          var value = getItemValue(item);
+          return layeredState.expand(value).bind(function (path) {
+            updateAriaExpansions(container, path);
+            return Optional.from(path[0]).bind(function (menuName) {
+              return layeredState.lookupMenu(menuName).bind(function (activeMenuPrep) {
+                var activeMenu = buildIfRequired(container, menuName, activeMenuPrep);
+                if (!inBody(activeMenu.element)) {
+                  Replacing.append(container, premade(activeMenu));
+                }
+                detail.onOpenSubmenu(container, item, activeMenu, reverse(path));
+                if (decision === ExpandHighlightDecision.HighlightSubmenu) {
+                  Highlighting.highlightFirst(activeMenu);
+                  return updateMenuPath(container, layeredState, path);
+                } else {
+                  Highlighting.dehighlightAll(activeMenu);
+                  return Optional.some(item);
+                }
+              });
+            });
+          });
+        }
+      };
+      var collapseLeft = function (container, item) {
+        var value = getItemValue(item);
+        return layeredState.collapse(value).bind(function (path) {
+          updateAriaExpansions(container, path);
+          return updateMenuPath(container, layeredState, path).map(function (activeMenu) {
+            detail.onCollapseMenu(container, item, activeMenu);
+            return activeMenu;
+          });
+        });
+      };
+      var updateView = function (container, item) {
+        var value = getItemValue(item);
+        return layeredState.refresh(value).bind(function (path) {
+          updateAriaExpansions(container, path);
+          return updateMenuPath(container, layeredState, path);
+        });
+      };
+      var onRight = function (container, item) {
+        return inside(item.element) ? Optional.none() : expandRight(container, item, ExpandHighlightDecision.HighlightSubmenu);
+      };
+      var onLeft = function (container, item) {
+        return inside(item.element) ? Optional.none() : collapseLeft(container, item);
+      };
+      var onEscape = function (container, item) {
+        return collapseLeft(container, item).orThunk(function () {
+          return detail.onEscape(container, item).map(function () {
+            return container;
+          });
+        });
+      };
+      var keyOnItem = function (f) {
+        return function (container, simulatedEvent) {
+          return closest$1(simulatedEvent.getSource(), '.' + detail.markers.item).bind(function (target) {
+            return container.getSystem().getByDom(target).toOptional().bind(function (item) {
+              return f(container, item).map(always);
+            });
+          });
+        };
+      };
+      var events = derive$2([
+        run$1(focus(), function (sandbox, simulatedEvent) {
+          var item = simulatedEvent.event.item;
+          layeredState.lookupItem(getItemValue(item)).each(function () {
+            var menu = simulatedEvent.event.menu;
+            Highlighting.highlight(sandbox, menu);
+            var value = getItemValue(simulatedEvent.event.item);
+            layeredState.refresh(value).each(function (path) {
+              return closeOthers(sandbox, layeredState, path);
+            });
+          });
+        }),
+        runOnExecute$1(function (component, simulatedEvent) {
+          var target = simulatedEvent.event.target;
+          component.getSystem().getByDom(target).each(function (item) {
+            var itemValue = getItemValue(item);
+            if (itemValue.indexOf('collapse-item') === 0) {
+              collapseLeft(component, item);
+            }
+            expandRight(component, item, ExpandHighlightDecision.HighlightSubmenu).fold(function () {
+              detail.onExecute(component, item);
+            }, noop);
+          });
+        }),
+        runOnAttached(function (container, _simulatedEvent) {
+          setup(container).each(function (primary) {
+            Replacing.append(container, premade(primary));
+            detail.onOpenMenu(container, primary);
+            if (detail.highlightImmediately) {
+              setActiveMenu(container, primary);
+            }
+          });
+        })
+      ].concat(detail.navigateOnHover ? [run$1(hover(), function (sandbox, simulatedEvent) {
+          var item = simulatedEvent.event.item;
+          updateView(sandbox, item);
+          expandRight(sandbox, item, ExpandHighlightDecision.HighlightParent);
+          detail.onHover(sandbox, item);
+        })] : []));
+      var getActiveItem = function (container) {
+        return Highlighting.getHighlighted(container).bind(Highlighting.getHighlighted);
+      };
+      var collapseMenuApi = function (container) {
+        getActiveItem(container).each(function (currentItem) {
+          collapseLeft(container, currentItem);
+        });
+      };
+      var highlightPrimary = function (container) {
+        layeredState.getPrimary().each(function (primary) {
+          setActiveMenu(container, primary);
+        });
+      };
+      var extractMenuFromContainer = function (container) {
+        return Optional.from(container.components()[0]).filter(function (comp) {
+          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 itemValue = getItemValue(currentItem);
+            var allMenus = values(layeredState.getMenus());
+            var preparedMenus = cat(map$2(allMenus, LayeredState.extractPreparedMenu));
+            return layeredState.getTriggeringPath(itemValue, function (v) {
+              return getItemByValue(container, preparedMenus, v);
+            });
+          }).map(function (triggeringPath) {
+            return {
+              primary: primary,
+              triggeringPath: triggeringPath
+            };
+          });
+        });
+        maybeActivePrimary.fold(function () {
+          extractMenuFromContainer(container).each(function (primaryMenu) {
+            detail.onRepositionMenu(container, primaryMenu, []);
+          });
+        }, function (_a) {
+          var primary = _a.primary, triggeringPath = _a.triggeringPath;
+          detail.onRepositionMenu(container, primary, triggeringPath);
+        });
+      };
+      var apis = {
+        collapseMenu: collapseMenuApi,
+        highlightPrimary: highlightPrimary,
+        repositionMenus: repositionMenus
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        markers: detail.markers,
+        behaviours: augment(detail.tmenuBehaviours, [
+          Keying.config({
+            mode: 'special',
+            onRight: keyOnItem(onRight),
+            onLeft: keyOnItem(onLeft),
+            onEscape: keyOnItem(onEscape),
+            focusIn: function (container, _keyInfo) {
+              layeredState.getPrimary().each(function (primary) {
+                dispatch(container, primary.element, focusItem());
+              });
+            }
+          }),
+          Highlighting.config({
+            highlightClass: detail.markers.selectedMenu,
+            itemClass: detail.markers.menu
+          }),
+          Composing.config({
+            find: function (container) {
+              return Highlighting.getHighlighted(container);
+            }
+          }),
+          Replacing.config({})
+        ]),
+        eventOrder: detail.eventOrder,
+        apis: apis,
+        events: events
+      };
+    };
+    var collapseItem$1 = constant$1('collapse-item');
+
+    var tieredData = function (primary, menus, expansions) {
+      return {
+        primary: primary,
+        menus: menus,
+        expansions: expansions
+      };
+    };
+    var singleData = function (name, menu) {
+      return {
+        primary: name,
+        menus: wrap$1(name, menu),
+        expansions: {}
+      };
+    };
+    var collapseItem = function (text) {
+      return {
+        value: generate$6(collapseItem$1()),
+        meta: { text: text }
+      };
+    };
+    var tieredMenu = single({
+      name: 'TieredMenu',
+      configFields: [
+        onStrictKeyboardHandler('onExecute'),
+        onStrictKeyboardHandler('onEscape'),
+        onStrictHandler('onOpenMenu'),
+        onStrictHandler('onOpenSubmenu'),
+        onHandler('onRepositionMenu'),
+        onHandler('onCollapseMenu'),
+        defaulted('highlightImmediately', true),
+        requiredObjOf('data', [
+          required$1('primary'),
+          required$1('menus'),
+          required$1('expansions')
+        ]),
+        defaulted('fakeFocus', false),
+        onHandler('onHighlight'),
+        onHandler('onHover'),
+        tieredMenuMarkers(),
+        required$1('dom'),
+        defaulted('navigateOnHover', true),
+        defaulted('stayInDom', false),
+        field('tmenuBehaviours', [
+          Keying,
+          Highlighting,
+          Composing,
+          Replacing
+        ]),
+        defaulted('eventOrder', {})
+      ],
+      apis: {
+        collapseMenu: function (apis, tmenu) {
+          apis.collapseMenu(tmenu);
+        },
+        highlightPrimary: function (apis, tmenu) {
+          apis.highlightPrimary(tmenu);
+        },
+        repositionMenus: function (apis, tmenu) {
+          apis.repositionMenus(tmenu);
+        }
+      },
+      factory: make$6,
+      extraApis: {
+        tieredData: tieredData,
+        singleData: singleData,
+        collapseItem: collapseItem
+      }
+    });
+
+    var makeMenu = function (detail, menuSandbox, placementSpec, menuSpec, getBounds) {
+      var lazySink = function () {
+        return detail.lazySink(menuSandbox);
+      };
+      var layouts = menuSpec.type === 'horizontal' ? {
+        layouts: {
+          onLtr: function () {
+            return belowOrAbove();
+          },
+          onRtl: function () {
+            return belowOrAboveRtl();
+          }
+        }
+      } : {};
+      var isFirstTierSubmenu = function (triggeringPaths) {
+        return triggeringPaths.length === 2;
+      };
+      var getSubmenuLayouts = function (triggeringPaths) {
+        return isFirstTierSubmenu(triggeringPaths) ? layouts : {};
+      };
+      return tieredMenu.sketch({
+        dom: { tag: 'div' },
+        data: menuSpec.data,
+        markers: menuSpec.menu.markers,
+        highlightImmediately: menuSpec.menu.highlightImmediately,
+        onEscape: function () {
+          Sandboxing.close(menuSandbox);
+          detail.onEscape.map(function (handler) {
+            return handler(menuSandbox);
+          });
+          return Optional.some(true);
+        },
+        onExecute: function () {
+          return Optional.some(true);
+        },
+        onOpenMenu: function (tmenu, menu) {
+          Positioning.positionWithinBounds(lazySink().getOrDie(), menu, placementSpec, getBounds());
+        },
+        onOpenSubmenu: function (tmenu, item, submenu, triggeringPaths) {
+          var sink = lazySink().getOrDie();
+          Positioning.position(sink, submenu, {
+            anchor: __assign({
+              type: 'submenu',
+              item: item
+            }, getSubmenuLayouts(triggeringPaths))
+          });
+        },
+        onRepositionMenu: function (tmenu, primaryMenu, submenuTriggers) {
+          var sink = lazySink().getOrDie();
+          Positioning.positionWithinBounds(sink, primaryMenu, placementSpec, getBounds());
+          each$1(submenuTriggers, function (st) {
+            var submenuLayouts = getSubmenuLayouts(st.triggeringPath);
+            Positioning.position(sink, st.triggeredMenu, {
+              anchor: __assign({
+                type: 'submenu',
+                item: st.triggeringItem
+              }, submenuLayouts)
+            });
+          });
+        }
+      });
+    };
+    var factory$m = function (detail, spec) {
+      var isPartOfRelated = function (sandbox, queryElem) {
+        var related = detail.getRelated(sandbox);
+        return related.exists(function (rel) {
+          return isPartOf$1(rel, queryElem);
+        });
+      };
+      var setContent = function (sandbox, thing) {
+        Sandboxing.setContent(sandbox, thing);
+      };
+      var showAt = function (sandbox, thing, placementSpec) {
+        showWithin(sandbox, thing, placementSpec, Optional.none());
+      };
+      var showWithin = function (sandbox, thing, placementSpec, boxElement) {
+        showWithinBounds(sandbox, thing, placementSpec, function () {
+          return boxElement.map(function (elem) {
+            return box$1(elem);
+          });
+        });
+      };
+      var showWithinBounds = function (sandbox, thing, placementSpec, getBounds) {
+        var sink = detail.lazySink(sandbox).getOrDie();
+        Sandboxing.openWhileCloaked(sandbox, thing, function () {
+          return Positioning.positionWithinBounds(sink, sandbox, placementSpec, getBounds());
+        });
+        Representing.setValue(sandbox, Optional.some({
+          mode: 'position',
+          config: placementSpec,
+          getBounds: getBounds
+        }));
+      };
+      var showMenuAt = function (sandbox, placementSpec, menuSpec) {
+        showMenuWithinBounds(sandbox, placementSpec, menuSpec, Optional.none);
+      };
+      var showMenuWithinBounds = function (sandbox, placementSpec, menuSpec, getBounds) {
+        var menu = makeMenu(detail, sandbox, placementSpec, menuSpec, getBounds);
+        Sandboxing.open(sandbox, menu);
+        Representing.setValue(sandbox, Optional.some({
+          mode: 'menu',
+          menu: menu
+        }));
+      };
+      var hide = function (sandbox) {
+        if (Sandboxing.isOpen(sandbox)) {
+          Representing.setValue(sandbox, Optional.none());
+          Sandboxing.close(sandbox);
+        }
+      };
+      var getContent = function (sandbox) {
+        return Sandboxing.getState(sandbox);
+      };
+      var reposition = function (sandbox) {
+        if (Sandboxing.isOpen(sandbox)) {
+          Representing.getValue(sandbox).each(function (state) {
+            switch (state.mode) {
+            case 'menu':
+              Sandboxing.getState(sandbox).each(tieredMenu.repositionMenus);
+              break;
+            case 'position':
+              var sink = detail.lazySink(sandbox).getOrDie();
+              Positioning.positionWithinBounds(sink, sandbox, state.config, state.getBounds());
+              break;
+            }
+          });
+        }
+      };
+      var apis = {
+        setContent: setContent,
+        showAt: showAt,
+        showWithin: showWithin,
+        showWithinBounds: showWithinBounds,
+        showMenuAt: showMenuAt,
+        showMenuWithinBounds: showMenuWithinBounds,
+        hide: hide,
+        getContent: getContent,
+        reposition: reposition,
+        isOpen: Sandboxing.isOpen
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        behaviours: augment(detail.inlineBehaviours, [
+          Sandboxing.config({
+            isPartOf: function (sandbox, data, queryElem) {
+              return isPartOf$1(data, queryElem) || isPartOfRelated(sandbox, queryElem);
+            },
+            getAttachPoint: function (sandbox) {
+              return detail.lazySink(sandbox).getOrDie();
+            },
+            onOpen: function (sandbox) {
+              detail.onShow(sandbox);
+            },
+            onClose: function (sandbox) {
+              detail.onHide(sandbox);
+            }
+          }),
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: Optional.none()
+            }
+          }),
+          Receiving.config({
+            channels: __assign(__assign({}, receivingChannel$1(__assign({ isExtraPart: spec.isExtraPart }, detail.fireDismissalEventInstead.map(function (fe) {
+              return { fireEventInstead: { event: fe.event } };
+            }).getOr({})))), receivingChannel(__assign(__assign({}, detail.fireRepositionEventInstead.map(function (fe) {
+              return { fireEventInstead: { event: fe.event } };
+            }).getOr({})), { doReposition: reposition })))
+          })
+        ]),
+        eventOrder: detail.eventOrder,
+        apis: apis
+      };
+    };
+    var InlineView = single({
+      name: 'InlineView',
+      configFields: [
+        required$1('lazySink'),
+        onHandler('onShow'),
+        onHandler('onHide'),
+        optionFunction('onEscape'),
+        field('inlineBehaviours', [
+          Sandboxing,
+          Representing,
+          Receiving
+        ]),
+        optionObjOf('fireDismissalEventInstead', [defaulted('event', dismissRequested())]),
+        optionObjOf('fireRepositionEventInstead', [defaulted('event', repositionRequested())]),
+        defaulted('getRelated', Optional.none),
+        defaulted('isExtraPart', never),
+        defaulted('eventOrder', Optional.none)
+      ],
+      factory: factory$m,
+      apis: {
+        showAt: function (apis, component, anchor, thing) {
+          apis.showAt(component, anchor, thing);
+        },
+        showWithin: function (apis, component, anchor, thing, boxElement) {
+          apis.showWithin(component, anchor, thing, boxElement);
+        },
+        showWithinBounds: function (apis, component, anchor, thing, bounds) {
+          apis.showWithinBounds(component, anchor, thing, bounds);
+        },
+        showMenuAt: function (apis, component, anchor, menuSpec) {
+          apis.showMenuAt(component, anchor, menuSpec);
+        },
+        showMenuWithinBounds: function (apis, component, anchor, menuSpec, bounds) {
+          apis.showMenuWithinBounds(component, anchor, menuSpec, bounds);
+        },
+        hide: function (apis, component) {
+          apis.hide(component);
+        },
+        isOpen: function (apis, component) {
+          return apis.isOpen(component);
+        },
+        getContent: function (apis, component) {
+          return apis.getContent(component);
+        },
+        setContent: function (apis, component, thing) {
+          apis.setContent(component, thing);
+        },
+        reposition: function (apis, component) {
+          apis.reposition(component);
+        }
+      }
+    });
+
+    var labelPrefix = 'layout-inset';
+    var westEdgeX = function (anchor) {
+      return anchor.x;
+    };
+    var middleX = function (anchor, element) {
+      return anchor.x + anchor.width / 2 - element.width / 2;
+    };
+    var eastEdgeX = function (anchor, element) {
+      return anchor.x + anchor.width - element.width;
+    };
+    var northY = function (anchor) {
+      return anchor.y;
+    };
+    var southY = function (anchor, element) {
+      return anchor.y + anchor.height - element.height;
+    };
+    var centreY = function (anchor, element) {
+      return anchor.y + anchor.height / 2 - element.height / 2;
+    };
+    var southwest = function (anchor, element, bubbles) {
+      return nu$6(eastEdgeX(anchor, element), southY(anchor, element), bubbles.insetSouthwest(), northwest$3(), 'southwest', boundsRestriction(anchor, {
+        right: 0,
+        bottom: 3
+      }), labelPrefix);
+    };
+    var southeast = function (anchor, element, bubbles) {
+      return nu$6(westEdgeX(anchor), southY(anchor, element), bubbles.insetSoutheast(), northeast$3(), 'southeast', boundsRestriction(anchor, {
+        left: 1,
+        bottom: 3
+      }), labelPrefix);
+    };
+    var northwest = function (anchor, element, bubbles) {
+      return nu$6(eastEdgeX(anchor, element), northY(anchor), bubbles.insetNorthwest(), southwest$3(), 'northwest', boundsRestriction(anchor, {
+        right: 0,
+        top: 2
+      }), labelPrefix);
+    };
+    var northeast = function (anchor, element, bubbles) {
+      return nu$6(westEdgeX(anchor), northY(anchor), bubbles.insetNortheast(), southeast$3(), 'northeast', boundsRestriction(anchor, {
+        left: 1,
+        top: 2
+      }), labelPrefix);
+    };
+    var north = function (anchor, element, bubbles) {
+      return nu$6(middleX(anchor, element), northY(anchor), bubbles.insetNorth(), south$3(), 'north', boundsRestriction(anchor, { top: 2 }), labelPrefix);
+    };
+    var south = function (anchor, element, bubbles) {
+      return nu$6(middleX(anchor, element), southY(anchor, element), bubbles.insetSouth(), north$3(), 'south', boundsRestriction(anchor, { bottom: 3 }), labelPrefix);
+    };
+    var east = function (anchor, element, bubbles) {
+      return nu$6(eastEdgeX(anchor, element), centreY(anchor, element), bubbles.insetEast(), west$3(), 'east', boundsRestriction(anchor, { right: 0 }), labelPrefix);
+    };
+    var west = function (anchor, element, bubbles) {
+      return nu$6(westEdgeX(anchor), centreY(anchor, element), bubbles.insetWest(), east$3(), 'west', boundsRestriction(anchor, { left: 1 }), labelPrefix);
+    };
+    var lookupPreserveLayout = function (lastPlacement) {
+      switch (lastPlacement) {
+      case 'north':
+        return north;
+      case 'northeast':
+        return northeast;
+      case 'northwest':
+        return northwest;
+      case 'south':
+        return south;
+      case 'southeast':
+        return southeast;
+      case 'southwest':
+        return southwest;
+      case 'east':
+        return east;
+      case 'west':
+        return west;
+      }
+    };
+    var preserve = function (anchor, element, bubbles, placee, bounds) {
+      var layout = getPlacement(placee).map(lookupPreserveLayout).getOr(north);
+      return layout(anchor, element, bubbles, placee, bounds);
+    };
+    var lookupFlippedLayout = function (lastPlacement) {
+      switch (lastPlacement) {
+      case 'north':
+        return south;
+      case 'northeast':
+        return southeast;
+      case 'northwest':
+        return southwest;
+      case 'south':
+        return north;
+      case 'southeast':
+        return northeast;
+      case 'southwest':
+        return northwest;
+      case 'east':
+        return west;
+      case 'west':
+        return east;
+      }
+    };
+    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$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) {
+        return get$e(detail.dom, 'attributes').bind(function (attrs) {
+          return get$e(attrs, attr);
+        });
+      };
+      var getModAttributes = function () {
+        if (tag === 'button') {
+          var type = lookupAttr('type').getOr('button');
+          var roleAttrs = lookupAttr('role').map(function (role) {
+            return { role: role };
+          }).getOr({});
+          return __assign({ type: type }, roleAttrs);
+        } else {
+          var role = lookupAttr('role').getOr('button');
+          return { role: role };
+        }
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: detail.components,
+        events: events,
+        behaviours: SketchBehaviours.augment(detail.buttonBehaviours, [
+          Focusing.config({}),
+          Keying.config({
+            mode: 'execution',
+            useSpace: true,
+            useEnter: true
+          })
+        ]),
+        domModification: { attributes: getModAttributes() },
+        eventOrder: detail.eventOrder
+      };
+    };
+    var Button = single({
+      name: 'Button',
+      factory: factory$l,
+      configFields: [
+        defaulted('uid', undefined),
+        required$1('dom'),
+        defaulted('components', []),
+        SketchBehaviours.field('buttonBehaviours', [
+          Focusing,
+          Keying
+        ]),
+        option('action'),
+        option('role'),
+        defaulted('eventOrder', {})
+      ]
+    });
+
+    var record = function (spec) {
+      var uid = isSketchSpec(spec) && hasNonNullableKey(spec, 'uid') ? spec.uid : generate$5('memento');
+      var get = function (anyInSystem) {
+        return anyInSystem.getSystem().getByUid(uid).getOrDie();
+      };
+      var getOpt = function (anyInSystem) {
+        return anyInSystem.getSystem().getByUid(uid).toOptional();
+      };
+      var asSpec = function () {
+        return __assign(__assign({}, spec), { uid: uid });
+      };
+      return {
+        get: get,
+        getOpt: getOpt,
+        asSpec: asSpec
+      };
+    };
+
+    var global$e = tinymce.util.Tools.resolve('tinymce.util.I18n');
+
+    var rtlTransform = {
+      'indent': true,
+      'outdent': true,
+      'table-insert-column-after': true,
+      'table-insert-column-before': true,
+      'paste-column-after': true,
+      'paste-column-before': true,
+      'unordered-list': true,
+      'list-bull-circle': true,
+      'list-bull-default': true,
+      'list-bull-square': true
+    };
+    var defaultIconName = 'temporary-placeholder';
+    var defaultIcon = function (icons) {
+      return function () {
+        return get$e(icons, defaultIconName).getOr('!not found!');
+      };
+    };
+    var getIconName = function (name, icons) {
+      var lcName = name.toLowerCase();
+      if (global$e.isRtl()) {
+        var rtlName = ensureTrailing(lcName, '-rtl');
+        return has$2(icons, rtlName) ? rtlName : lcName;
+      } else {
+        return lcName;
+      }
+    };
+    var lookupIcon = function (name, icons) {
+      return get$e(icons, getIconName(name, icons));
+    };
+    var get$1 = function (name, iconProvider) {
+      var icons = iconProvider();
+      return lookupIcon(name, icons).getOrThunk(defaultIcon(icons));
+    };
+    var getOr = function (name, iconProvider, fallbackIcon) {
+      var icons = iconProvider();
+      return lookupIcon(name, icons).or(fallbackIcon).getOrThunk(defaultIcon(icons));
+    };
+    var needsRtlTransform = function (iconName) {
+      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$8(svg, 'focusable', 'false');
+          });
+        })]);
+    };
+    var renderIcon$2 = function (spec, iconName, icons, fallbackIcon) {
+      var _a, _b;
+      var rtlIconClasses = needsRtlTransform(iconName) ? ['tox-icon--flip'] : [];
+      var iconHtml = get$e(icons, getIconName(iconName, icons)).or(fallbackIcon).getOrThunk(defaultIcon(icons));
+      return {
+        dom: {
+          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 : [], true), [addFocusableBehaviour()], false))
+      };
+    };
+    var render$3 = function (iconName, spec, iconProvider, fallbackIcon) {
+      if (fallbackIcon === void 0) {
+        fallbackIcon = Optional.none();
+      }
+      return renderIcon$2(spec, iconName, iconProvider(), fallbackIcon);
+    };
+    var renderFirst = function (iconNames, spec, iconProvider) {
+      var icons = iconProvider();
+      var iconName = find$5(iconNames, function (name) {
+        return has$2(icons, getIconName(name, icons));
+      });
+      return renderIcon$2(spec, iconName.getOr(defaultIconName), icons, Optional.none());
+    };
+
+    var notificationIconMap = {
+      success: 'checkmark',
+      error: 'warning',
+      err: 'error',
+      warning: 'warning',
+      warn: 'warning',
+      info: 'info'
+    };
+    var factory$k = function (detail) {
+      var memBannerText = record({
+        dom: {
+          tag: 'p',
+          innerHtml: detail.translationProvider(detail.text)
+        },
+        behaviours: derive$1([Replacing.config({})])
+      });
+      var renderPercentBar = function (percent) {
+        return {
+          dom: {
+            tag: 'div',
+            classes: ['tox-bar'],
+            attributes: { style: 'width: ' + percent + '%' }
+          }
+        };
+      };
+      var renderPercentText = function (percent) {
+        return {
+          dom: {
+            tag: 'div',
+            classes: ['tox-text'],
+            innerHtml: percent + '%'
+          }
+        };
+      };
+      var memBannerProgress = record({
+        dom: {
+          tag: 'div',
+          classes: detail.progress ? [
+            'tox-progress-bar',
+            'tox-progress-indicator'
+          ] : ['tox-progress-bar']
+        },
+        components: [
+          {
+            dom: {
+              tag: 'div',
+              classes: ['tox-bar-container']
+            },
+            components: [renderPercentBar(0)]
+          },
+          renderPercentText(0)
+        ],
+        behaviours: derive$1([Replacing.config({})])
+      });
+      var updateProgress = function (comp, percent) {
+        if (comp.getSystem().isConnected()) {
+          memBannerProgress.getOpt(comp).each(function (progress) {
+            Replacing.set(progress, [
+              {
+                dom: {
+                  tag: 'div',
+                  classes: ['tox-bar-container']
+                },
+                components: [renderPercentBar(percent)]
+              },
+              renderPercentText(percent)
+            ]);
+          });
+        }
+      };
+      var updateText = function (comp, text) {
+        if (comp.getSystem().isConnected()) {
+          var banner = memBannerText.get(comp);
+          Replacing.set(banner, [text$1(text)]);
+        }
+      };
+      var apis = {
+        updateProgress: updateProgress,
+        updateText: updateText
+      };
+      var iconChoices = flatten([
+        detail.icon.toArray(),
+        detail.level.toArray(),
+        detail.level.bind(function (level) {
+          return Optional.from(notificationIconMap[level]);
+        }).toArray()
+      ]);
+      var memButton = record(Button.sketch({
+        dom: {
+          tag: 'button',
+          classes: [
+            'tox-notification__dismiss',
+            'tox-button',
+            'tox-button--naked',
+            'tox-button--icon'
+          ]
+        },
+        components: [render$3('close', {
+            tag: 'div',
+            classes: ['tox-icon'],
+            attributes: { 'aria-label': detail.translationProvider('Close') }
+          }, detail.iconProvider)],
+        action: function (comp) {
+          detail.onAction(comp);
+        }
+      }));
+      var notificationIconSpec = renderFirst(iconChoices, {
+        tag: 'div',
+        classes: ['tox-notification__icon']
+      }, detail.iconProvider);
+      var notificationBodySpec = {
+        dom: {
+          tag: 'div',
+          classes: ['tox-notification__body']
+        },
+        components: [memBannerText.asSpec()],
+        behaviours: derive$1([Replacing.config({})])
+      };
+      var components = [
+        notificationIconSpec,
+        notificationBodySpec
+      ];
+      return {
+        uid: detail.uid,
+        dom: {
+          tag: 'div',
+          attributes: { role: 'alert' },
+          classes: detail.level.map(function (level) {
+            return [
+              'tox-notification',
+              'tox-notification--in',
+              'tox-notification--' + level
+            ];
+          }).getOr([
+            'tox-notification',
+            'tox-notification--in'
+          ])
+        },
+        behaviours: derive$1([
+          Focusing.config({}),
+          config('notification-events', [run$1(focusin(), function (comp) {
+              memButton.getOpt(comp).each(Focusing.focus);
+            })])
+        ]),
+        components: components.concat(detail.progress ? [memBannerProgress.asSpec()] : []).concat(!detail.closeButton ? [] : [memButton.asSpec()]),
+        apis: apis
+      };
+    };
+    var Notification = single({
+      name: 'Notification',
+      factory: factory$k,
+      configFields: [
+        option('level'),
+        required$1('progress'),
+        required$1('icon'),
+        required$1('onAction'),
+        required$1('text'),
+        required$1('iconProvider'),
+        required$1('translationProvider'),
+        defaultedBoolean('closeButton', true)
+      ],
+      apis: {
+        updateProgress: function (apis, comp, percent) {
+          apis.updateProgress(comp, percent);
+        },
+        updateText: function (apis, comp, text) {
+          apis.updateText(comp, text);
+        }
+      }
+    });
+
+    function NotificationManagerImpl (editor, extras, uiMothership) {
+      var sharedBackstage = extras.backstage.shared;
+      var getLayoutDirection = function (rel) {
+        switch (rel) {
+        case 'bc-bc':
+          return south;
+        case 'tc-tc':
+          return north;
+        case 'tc-bc':
+          return north$2;
+        case 'bc-tc':
+        default:
+          return south$2;
+        }
+      };
+      var reposition = function (notifications) {
+        if (notifications.length > 0) {
+          each$1(notifications, function (notification, index) {
+            if (index === 0) {
+              notification.moveRel(null, 'banner');
+            } else {
+              notification.moveRel(notifications[index - 1].getEl(), 'bc-tc');
+            }
+          });
+        }
+      };
+      var open = function (settings, closeCallback) {
+        var hideCloseButton = !settings.closeButton && settings.timeout && (settings.timeout > 0 || settings.timeout < 0);
+        var close = function () {
+          closeCallback();
+          InlineView.hide(notificationWrapper);
+        };
+        var notification = build$1(Notification.sketch({
+          text: settings.text,
+          level: contains$2([
+            'success',
+            'error',
+            'warning',
+            'warn',
+            'info'
+          ], settings.type) ? settings.type : undefined,
+          progress: settings.progressBar === true,
+          icon: Optional.from(settings.icon),
+          closeButton: !hideCloseButton,
+          onAction: close,
+          iconProvider: sharedBackstage.providers.icons,
+          translationProvider: sharedBackstage.providers.translate
+        }));
+        var notificationWrapper = build$1(InlineView.sketch(__assign({
+          dom: {
+            tag: 'div',
+            classes: ['tox-notifications-container']
+          },
+          lazySink: sharedBackstage.getSink,
+          fireDismissalEventInstead: {}
+        }, sharedBackstage.header.isPositionedAtTop() ? {} : { fireRepositionEventInstead: {} })));
+        uiMothership.add(notificationWrapper);
+        if (settings.timeout > 0) {
+          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: {
+                type: 'makeshift',
+                x: x,
+                y: y
+              }
+            });
+          },
+          moveRel: function (element, rel) {
+            var notificationSpec = premade(notification);
+            var anchorOverrides = { maxHeightFunction: expandable$1() };
+            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.showWithinBounds(notificationWrapper, notificationSpec, { anchor: nodeAnchor }, getBounds);
+            } else {
+              var anchor = __assign(__assign({}, sharedBackstage.anchors.banner()), { overrides: anchorOverrides });
+              InlineView.showWithinBounds(notificationWrapper, notificationSpec, { anchor: anchor }, getBounds);
+            }
+          },
+          text: function (nuText) {
+            Notification.updateText(notification, nuText);
+          },
+          settings: settings,
+          getEl: function () {
+            return notification.element.dom;
+          },
+          progressBar: {
+            value: function (percent) {
+              Notification.updateProgress(notification, percent);
+            }
+          }
+        };
+      };
+      var close = function (notification) {
+        notification.close();
+      };
+      var getArgs = function (notification) {
+        return notification.settings;
+      };
+      return {
+        open: open,
+        close: close,
+        reposition: reposition,
+        getArgs: getArgs
+      };
+    }
+
+    var first = function (fn, rate) {
+      var timer = null;
+      var cancel = function () {
+        if (!isNull(timer)) {
+          clearTimeout(timer);
+          timer = null;
+        }
+      };
+      var throttle = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        if (isNull(timer)) {
+          timer = setTimeout(function () {
+            timer = null;
+            fn.apply(null, args);
+          }, rate);
+        }
+      };
+      return {
+        cancel: cancel,
+        throttle: throttle
+      };
+    };
+    var last = function (fn, rate) {
+      var timer = null;
+      var cancel = function () {
+        if (!isNull(timer)) {
+          clearTimeout(timer);
+          timer = null;
+        }
+      };
+      var throttle = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        cancel();
+        timer = setTimeout(function () {
+          timer = null;
+          fn.apply(null, args);
+        }, rate);
+      };
+      return {
+        cancel: cancel,
+        throttle: throttle
+      };
+    };
+
+    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$d(dom, function (node) {
+        return isBoundary(dom, node);
+      });
+      return Optional.from(search.backwards(node, offset, process, rootNode));
+    };
+
+    var autocompleteSelector = '[data-mce-autocompleter]';
+    var create$5 = function (editor, range) {
+      return detect(SugarElement.fromDom(editor.selection.getNode())).getOrThunk(function () {
+        var wrapper = SugarElement.fromHtml('<span data-mce-autocompleter="1" data-mce-bogus="1"></span>', editor.getDoc());
+        append$2(wrapper, SugarElement.fromDom(range.extractContents()));
+        range.insertNode(wrapper.dom);
+        parent(wrapper).each(function (elm) {
+          return elm.dom.normalize();
+        });
+        last$1(wrapper).map(function (last) {
+          editor.selection.setCursorLocation(last.dom, getEnd(last));
+        });
+        return wrapper;
+      });
+    };
+    var detect = function (elm) {
+      return closest$1(elm, autocompleteSelector);
+    };
+
+    var isValidTextRange = function (rng) {
+      return rng.collapsed && rng.startContainer.nodeType === 3;
+    };
+    var getText = function (rng) {
+      return rng.toString().replace(/\u00A0/g, ' ').replace(/\uFEFF/g, '');
+    };
+    var isWhitespace = function (chr) {
+      return chr !== '' && ' \xA0\f\n\r\t\x0B'.indexOf(chr) !== -1;
+    };
+
+    var stripTriggerChar = function (text, triggerCh) {
+      return text.substring(triggerCh.length);
+    };
+    var findChar = function (text, index, ch) {
+      var i;
+      for (i = index - 1; i >= 0; i--) {
+        var char = text.charAt(i);
+        if (isWhitespace(char)) {
+          return Optional.none();
+        }
+        if (char === ch) {
+          break;
+        }
+      }
+      return Optional.some(i);
+    };
+    var findStart = function (dom, initRange, ch, minChars) {
+      if (minChars === void 0) {
+        minChars = 0;
+      }
+      if (!isValidTextRange(initRange)) {
+        return Optional.none();
+      }
+      var findTriggerChIndex = function (element, offset, text) {
+        return findChar(text, offset, ch).getOr(offset);
+      };
+      var root = dom.getParent(initRange.startContainer, dom.isBlock) || dom.getRoot();
+      return repeatLeft(dom, initRange.startContainer, initRange.startOffset, findTriggerChIndex, root).bind(function (spot) {
+        var range = initRange.cloneRange();
+        range.setStart(spot.container, spot.offset);
+        range.setEnd(initRange.endContainer, initRange.endOffset);
+        if (range.collapsed) {
+          return Optional.none();
+        }
+        var text = getText(range);
+        var triggerCharIndex = text.lastIndexOf(ch);
+        if (triggerCharIndex !== 0 || stripTriggerChar(text, ch).length < minChars) {
+          return Optional.none();
+        } else {
+          return Optional.some({
+            text: stripTriggerChar(text, ch),
+            range: range,
+            triggerChar: ch
+          });
+        }
+      });
+    };
+    var getContext = function (dom, initRange, ch, minChars) {
+      if (minChars === void 0) {
+        minChars = 0;
+      }
+      return detect(SugarElement.fromDom(initRange.startContainer)).fold(function () {
+        return findStart(dom, initRange, ch, minChars);
+      }, function (elm) {
+        var range = dom.createRng();
+        range.selectNode(elm.dom);
+        var text = getText(range);
+        return Optional.some({
+          range: range,
+          text: stripTriggerChar(text, ch),
+          triggerChar: ch
+        });
+      });
+    };
+
+    var setup$e = function (api, editor) {
+      editor.on('keypress compositionend', api.onKeypress.throttle);
+      editor.on('remove', api.onKeypress.cancel);
+      var redirectKeyToItem = function (item, e) {
+        emitWith(item, keydown(), { raw: e });
+      };
+      editor.on('keydown', function (e) {
+        var getItem = function () {
+          return api.getView().bind(Highlighting.getHighlighted);
+        };
+        if (e.which === 8) {
+          api.onKeypress.throttle(e);
+        }
+        if (api.isActive()) {
+          if (e.which === 27) {
+            api.cancelIfNecessary();
+          }
+          if (api.isMenuOpen()) {
+            if (e.which === 13) {
+              getItem().each(emitExecute);
+              e.preventDefault();
+            } else if (e.which === 40) {
+              getItem().fold(function () {
+                api.getView().each(Highlighting.highlightFirst);
+              }, function (item) {
+                redirectKeyToItem(item, e);
+              });
+              e.preventDefault();
+              e.stopImmediatePropagation();
+            } else if (e.which === 37 || e.which === 38 || e.which === 39) {
+              getItem().each(function (item) {
+                redirectKeyToItem(item, e);
+                e.preventDefault();
+                e.stopImmediatePropagation();
+              });
+            }
+          } else {
+            if (e.which === 13 || e.which === 38 || e.which === 40) {
+              api.cancelIfNecessary();
+            }
+          }
+        }
+      });
+      editor.on('NodeChange', function (e) {
+        if (api.isActive() && !api.isProcessingAction() && detect(SugarElement.fromDom(e.element)).isNone()) {
+          api.cancelIfNecessary();
+        }
+      });
+    };
+    var AutocompleterEditorEvents = { setup: setup$e };
+
+    var global$c = tinymce.util.Tools.resolve('tinymce.util.Promise');
+
+    var point = function (container, offset) {
+      return {
+        container: container,
+        offset: offset
+      };
+    };
+
+    var isText = function (node) {
+      return node.nodeType === TEXT;
+    };
+    var isElement$1 = function (node) {
+      return node.nodeType === ELEMENT;
+    };
+    var toLast = function (node) {
+      if (isText(node)) {
+        return point(node, node.data.length);
+      } else {
+        var children = node.childNodes;
+        return children.length > 0 ? toLast(children[children.length - 1]) : point(node, children.length);
+      }
+    };
+    var toLeaf = function (node, offset) {
+      var children = node.childNodes;
+      if (children.length > 0 && offset < children.length) {
+        return toLeaf(children[offset], 0);
+      } else if (children.length > 0 && isElement$1(node) && children.length === offset) {
+        return toLast(children[children.length - 1]);
+      } else {
+        return point(node, offset);
+      }
+    };
+
+    var isPreviousCharContent = function (dom, leaf) {
+      return repeatLeft(dom, leaf.container, leaf.offset, function (element, offset) {
+        return offset === 0 ? -1 : offset;
+      }, dom.getRoot()).filter(function (spot) {
+        var char = spot.container.data.charAt(spot.offset - 1);
+        return !isWhitespace(char);
+      }).isSome();
+    };
+    var isStartOfWord = function (dom) {
+      return function (rng) {
+        var leaf = toLeaf(rng.startContainer, rng.startOffset);
+        return !isPreviousCharContent(dom, leaf);
+      };
+    };
+    var getTriggerContext = function (dom, initRange, database) {
+      return findMap(database.triggerChars, function (ch) {
+        return getContext(dom, initRange, ch);
+      });
+    };
+    var lookup$2 = function (editor, getDatabase) {
+      var database = getDatabase();
+      var rng = editor.selection.getRng();
+      return getTriggerContext(editor.dom, rng, database).bind(function (context) {
+        return lookupWithContext(editor, getDatabase, context);
+      });
+    };
+    var lookupWithContext = function (editor, getDatabase, context, fetchOptions) {
+      if (fetchOptions === void 0) {
+        fetchOptions = {};
+      }
+      var database = getDatabase();
+      var rng = editor.selection.getRng();
+      var startText = rng.startContainer.nodeValue;
+      var autocompleters = filter$2(database.lookupByChar(context.triggerChar), function (autocompleter) {
+        return context.text.length >= autocompleter.minChars && autocompleter.matches.getOrThunk(function () {
+          return isStartOfWord(editor.dom);
+        })(context.range, startText, context.text);
+      });
+      if (autocompleters.length === 0) {
+        return Optional.none();
+      }
+      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,
+            columns: ac.columns,
+            onAction: ac.onAction,
+            highlightOn: ac.highlightOn
+          };
+        });
+      }));
+      return Optional.some({
+        lookupData: lookupData,
+        context: context
+      });
+    };
+
+    var separatorMenuItemSchema = objOf([
+      requiredString('type'),
+      optionString('text')
+    ]);
+    var createSeparatorMenuItem = function (spec) {
+      return asRaw('separatormenuitem', separatorMenuItemSchema, spec);
+    };
+
+    var autocompleterItemSchema = objOf([
+      defaulted('type', 'autocompleteitem'),
+      defaulted('active', false),
+      defaulted('disabled', false),
+      defaulted('meta', {}),
+      requiredString('value'),
+      optionString('text'),
+      optionString('icon')
+    ]);
+    var autocompleterSchema = objOf([
+      requiredString('type'),
+      requiredString('ch'),
+      defaultedNumber('minChars', 1),
+      defaulted('columns', 1),
+      defaultedNumber('maxResults', 10),
+      optionFunction('matches'),
+      requiredFunction('fetch'),
+      requiredFunction('onAction'),
+      defaultedArrayOf('highlightOn', [], string)
+    ]);
+    var createSeparatorItem = function (spec) {
+      return asRaw('Autocompleter.Separator', separatorMenuItemSchema, spec);
+    };
+    var createAutocompleterItem = function (spec) {
+      return asRaw('Autocompleter.Item', autocompleterItemSchema, spec);
+    };
+    var createAutocompleter = function (spec) {
+      return asRaw('Autocompleter', autocompleterSchema, spec);
+    };
+
+    var baseToolbarButtonFields = [
+      defaultedBoolean('disabled', false),
+      optionString('tooltip'),
+      optionString('icon'),
+      optionString('text'),
+      defaultedFunction('onSetup', function () {
+        return noop;
+      })
+    ];
+    var toolbarButtonSchema = objOf([
+      requiredString('type'),
+      requiredFunction('onAction')
+    ].concat(baseToolbarButtonFields));
+    var createToolbarButton = function (spec) {
+      return asRaw('toolbarbutton', toolbarButtonSchema, spec);
+    };
+
+    var baseToolbarToggleButtonFields = [defaultedBoolean('active', false)].concat(baseToolbarButtonFields);
+    var toggleButtonSchema = objOf(baseToolbarToggleButtonFields.concat([
+      requiredString('type'),
+      requiredFunction('onAction')
+    ]));
+    var createToggleButton = function (spec) {
+      return asRaw('ToggleButton', toggleButtonSchema, spec);
+    };
+
+    var contextBarFields = [
+      defaultedFunction('predicate', never),
+      defaultedStringEnum('scope', 'node', [
+        'node',
+        'editor'
+      ]),
+      defaultedStringEnum('position', 'selection', [
+        'node',
+        'selection',
+        'line'
+      ])
+    ];
+
+    var contextButtonFields = baseToolbarButtonFields.concat([
+      defaulted('type', 'contextformbutton'),
+      defaulted('primary', false),
+      requiredFunction('onAction'),
+      customField('original', identity$1)
+    ]);
+    var contextToggleButtonFields = baseToolbarToggleButtonFields.concat([
+      defaulted('type', 'contextformbutton'),
+      defaulted('primary', false),
+      requiredFunction('onAction'),
+      customField('original', identity$1)
+    ]);
+    var launchButtonFields = baseToolbarButtonFields.concat([defaulted('type', 'contextformbutton')]);
+    var launchToggleButtonFields = baseToolbarToggleButtonFields.concat([defaulted('type', 'contextformtogglebutton')]);
+    var toggleOrNormal = choose$1('type', {
+      contextformbutton: contextButtonFields,
+      contextformtogglebutton: contextToggleButtonFields
+    });
+    var contextFormSchema = objOf([
+      defaulted('type', 'contextform'),
+      defaultedFunction('initValue', constant$1('')),
+      optionString('label'),
+      requiredArrayOf('commands', toggleOrNormal),
+      optionOf('launch', choose$1('type', {
+        contextformbutton: launchButtonFields,
+        contextformtogglebutton: launchToggleButtonFields
+      }))
+    ].concat(contextBarFields));
+    var createContextForm = function (spec) {
+      return asRaw('ContextForm', contextFormSchema, spec);
+    };
+
+    var contextToolbarSchema = objOf([
+      defaulted('type', 'contexttoolbar'),
+      requiredString('items')
+    ].concat(contextBarFields));
+    var createContextToolbar = function (spec) {
+      return asRaw('ContextToolbar', contextToolbarSchema, spec);
+    };
+
+    var stringArray = function (a) {
+      var all = {};
+      each$1(a, function (key) {
+        all[key] = {};
+      });
+      return keys(all);
+    };
+
+    var register$b = function (editor) {
+      var popups = editor.ui.registry.getAll().popups;
+      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) {
+        return v.ch;
+      }));
+      var datasetValues = values(dataset);
+      var lookupByChar = function (ch) {
+        return filter$2(datasetValues, function (dv) {
+          return dv.ch === ch;
+        });
+      };
+      return {
+        dataset: dataset,
+        triggerChars: triggerChars,
+        lookupByChar: lookupByChar
+      };
+    };
+
+    var ItemResponse;
+    (function (ItemResponse) {
+      ItemResponse[ItemResponse['CLOSE_ON_EXECUTE'] = 0] = 'CLOSE_ON_EXECUTE';
+      ItemResponse[ItemResponse['BUBBLE_TO_SANDBOX'] = 1] = 'BUBBLE_TO_SANDBOX';
+    }(ItemResponse || (ItemResponse = {})));
+    var ItemResponse$1 = ItemResponse;
+
+    var navClass = 'tox-menu-nav__js';
+    var selectableClass = 'tox-collection__item';
+    var colorClass = 'tox-swatch';
+    var presetClasses = {
+      normal: navClass,
+      color: colorClass
+    };
+    var tickedClass = 'tox-collection__item--enabled';
+    var groupHeadingClass = 'tox-collection__group-heading';
+    var iconClass = 'tox-collection__item-icon';
+    var textClass = 'tox-collection__item-label';
+    var accessoryClass = 'tox-collection__item-accessory';
+    var caretClass = 'tox-collection__item-caret';
+    var checkmarkClass = 'tox-collection__item-checkmark';
+    var activeClass = 'tox-collection__item--active';
+    var containerClass = 'tox-collection__item-container';
+    var containerColumnClass = 'tox-collection__item-container--column';
+    var containerRowClass = 'tox-collection__item-container--row';
+    var containerAlignRightClass = 'tox-collection__item-container--align-right';
+    var containerAlignLeftClass = 'tox-collection__item-container--align-left';
+    var containerValignTopClass = 'tox-collection__item-container--valign-top';
+    var containerValignMiddleClass = 'tox-collection__item-container--valign-middle';
+    var containerValignBottomClass = 'tox-collection__item-container--valign-bottom';
+    var classForPreset = function (presets) {
+      return get$e(presetClasses, presets).getOr(navClass);
+    };
+
+    var forMenu = function (presets) {
+      if (presets === 'color') {
+        return 'tox-swatches';
+      } else {
+        return 'tox-menu';
+      }
+    };
+    var classes = function (presets) {
+      return {
+        backgroundMenu: 'tox-background-menu',
+        selectedMenu: 'tox-selected-menu',
+        selectedItem: 'tox-collection__item--active',
+        hasIcons: 'tox-menu--has-icons',
+        menu: forMenu(presets),
+        tieredMenu: 'tox-tiered-menu'
+      };
+    };
+
+    var markers = function (presets) {
+      var menuClasses = classes(presets);
+      return {
+        backgroundMenu: menuClasses.backgroundMenu,
+        selectedMenu: menuClasses.selectedMenu,
+        menu: menuClasses.menu,
+        selectedItem: menuClasses.selectedItem,
+        item: classForPreset(presets)
+      };
+    };
+    var dom$1 = function (hasIcons, columns, presets) {
+      var menuClasses = classes(presets);
+      return {
+        tag: 'div',
+        classes: flatten([
+          [
+            menuClasses.menu,
+            'tox-menu-' + columns + '-column'
+          ],
+          hasIcons ? [menuClasses.hasIcons] : []
+        ])
+      };
+    };
+    var components = [Menu.parts.items({})];
+    var part = function (hasIcons, columns, presets) {
+      var menuClasses = classes(presets);
+      var d = {
+        tag: 'div',
+        classes: flatten([[menuClasses.tieredMenu]])
+      };
+      return {
+        dom: d,
+        markers: markers(presets)
+      };
+    };
+
+    var chunk = function (rowDom, numColumns) {
+      return function (items) {
+        var chunks = chunk$1(items, numColumns);
+        return map$2(chunks, function (c) {
+          return {
+            dom: rowDom,
+            components: c
+          };
+        });
+      };
+    };
+    var forSwatch = function (columns) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: [
+            'tox-menu',
+            'tox-swatches-menu'
+          ]
+        },
+        components: [{
+            dom: {
+              tag: 'div',
+              classes: ['tox-swatches']
+            },
+            components: [Menu.parts.items({
+                preprocess: columns !== 'auto' ? chunk({
+                  tag: 'div',
+                  classes: ['tox-swatches__row']
+                }, columns) : identity$1
+              })]
+          }]
+      };
+    };
+    var forToolbar = function (columns) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: [
+            'tox-menu',
+            'tox-collection',
+            'tox-collection--toolbar',
+            'tox-collection--toolbar-lg'
+          ]
+        },
+        components: [Menu.parts.items({
+            preprocess: chunk({
+              tag: 'div',
+              classes: ['tox-collection__group']
+            }, columns)
+          })]
+      };
+    };
+    var preprocessCollection = function (items, isSeparator) {
+      var allSplits = [];
+      var currentSplit = [];
+      each$1(items, function (item, i) {
+        if (isSeparator(item, i)) {
+          if (currentSplit.length > 0) {
+            allSplits.push(currentSplit);
+          }
+          currentSplit = [];
+          if (has$2(item.dom, 'innerHtml')) {
+            currentSplit.push(item);
+          }
+        } else {
+          currentSplit.push(item);
+        }
+      });
+      if (currentSplit.length > 0) {
+        allSplits.push(currentSplit);
+      }
+      return map$2(allSplits, function (s) {
+        return {
+          dom: {
+            tag: 'div',
+            classes: ['tox-collection__group']
+          },
+          components: s
+        };
+      });
+    };
+    var forCollection = function (columns, initItems, _hasIcons) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: [
+            'tox-menu',
+            'tox-collection'
+          ].concat(columns === 1 ? ['tox-collection--list'] : ['tox-collection--grid'])
+        },
+        components: [Menu.parts.items({
+            preprocess: function (items) {
+              if (columns !== 'auto' && columns > 1) {
+                return chunk({
+                  tag: 'div',
+                  classes: ['tox-collection__group']
+                }, columns)(items);
+              } else {
+                return preprocessCollection(items, function (_item, i) {
+                  return initItems[i].type === 'separator';
+                });
+              }
+            }
+          })]
+      };
+    };
+    var forHorizontalCollection = function (initItems, _hasIcons) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: [
+            'tox-collection',
+            'tox-collection--horizontal'
+          ]
+        },
+        components: [Menu.parts.items({
+            preprocess: function (items) {
+              return preprocessCollection(items, function (_item, i) {
+                return initItems[i].type === 'separator';
+              });
+            }
+          })]
+      };
+    };
+
+    var menuHasIcons = function (xs) {
+      return exists(xs, function (item) {
+        return 'icon' in item && item.icon !== undefined;
+      });
+    };
+    var handleError = function (error) {
+      console.error(formatError(error));
+      console.log(error);
+      return Optional.none();
+    };
+    var createHorizontalPartialMenuWithAlloyItems = function (value, _hasIcons, items, _columns, _presets) {
+      var structure = forHorizontalCollection(items);
+      return {
+        value: value,
+        dom: structure.dom,
+        components: structure.components,
+        items: items
+      };
+    };
+    var createPartialMenuWithAlloyItems = function (value, hasIcons, items, columns, presets) {
+      if (presets === 'color') {
+        var structure = forSwatch(columns);
+        return {
+          value: value,
+          dom: structure.dom,
+          components: structure.components,
+          items: items
+        };
+      }
+      if (presets === 'normal' && columns === 'auto') {
+        var structure = forCollection(columns, items);
+        return {
+          value: value,
+          dom: structure.dom,
+          components: structure.components,
+          items: items
+        };
+      }
+      if (presets === 'normal' && columns === 1) {
+        var structure = forCollection(1, items);
+        return {
+          value: value,
+          dom: structure.dom,
+          components: structure.components,
+          items: items
+        };
+      }
+      if (presets === 'normal') {
+        var structure = forCollection(columns, items);
+        return {
+          value: value,
+          dom: structure.dom,
+          components: structure.components,
+          items: items
+        };
+      }
+      if (presets === 'listpreview' && columns !== 'auto') {
+        var structure = forToolbar(columns);
+        return {
+          value: value,
+          dom: structure.dom,
+          components: structure.components,
+          items: items
+        };
+      }
+      return {
+        value: value,
+        dom: dom$1(hasIcons, columns, presets),
+        components: components,
+        items: items
+      };
+    };
+
+    var cardImageFields = [
+      requiredString('type'),
+      requiredString('src'),
+      optionString('alt'),
+      defaultedArrayOf('classes', [], string)
+    ];
+    var cardImageSchema = objOf(cardImageFields);
+
+    var cardTextFields = [
+      requiredString('type'),
+      requiredString('text'),
+      optionString('name'),
+      defaultedArrayOf('classes', ['tox-collection__item-label'], string)
+    ];
+    var cardTextSchema = objOf(cardTextFields);
+
+    var itemSchema$1 = valueThunk(function () {
+      return choose$2('type', {
+        cardimage: cardImageSchema,
+        cardtext: cardTextSchema,
+        cardcontainer: cardContainerSchema
+      });
+    });
+    var cardContainerSchema = objOf([
+      requiredString('type'),
+      defaultedString('direction', 'horizontal'),
+      defaultedString('align', 'left'),
+      defaultedString('valign', 'middle'),
+      requiredArrayOf('items', itemSchema$1)
+    ]);
+
+    var commonMenuItemFields = [
+      defaultedBoolean('disabled', false),
+      optionString('text'),
+      optionString('shortcut'),
+      field$1('value', 'value', defaultedThunk(function () {
+        return generate$6('menuitem-value');
+      }), anyValue()),
+      defaulted('meta', {})
+    ];
+
+    var cardMenuItemSchema = objOf([
+      requiredString('type'),
+      optionString('label'),
+      requiredArrayOf('items', itemSchema$1),
+      defaultedFunction('onSetup', function () {
+        return noop;
+      }),
+      defaultedFunction('onAction', noop)
+    ].concat(commonMenuItemFields));
+    var createCardMenuItem = function (spec) {
+      return asRaw('cardmenuitem', cardMenuItemSchema, spec);
+    };
+
+    var choiceMenuItemSchema = objOf([
+      requiredString('type'),
+      defaultedBoolean('active', false),
+      optionString('icon')
+    ].concat(commonMenuItemFields));
+    var createChoiceMenuItem = function (spec) {
+      return asRaw('choicemenuitem', choiceMenuItemSchema, spec);
+    };
+
+    var baseFields = [
+      requiredString('type'),
+      requiredString('fancytype'),
+      defaultedFunction('onAction', noop)
+    ];
+    var insertTableFields = [defaulted('initData', {})].concat(baseFields);
+    var colorSwatchFields = [defaultedObjOf('initData', {}, [
+        defaultedBoolean('allowCustomColors', true),
+        optionArrayOf('colors', anyValue())
+      ])].concat(baseFields);
+    var fancyMenuItemSchema = choose$1('fancytype', {
+      inserttable: insertTableFields,
+      colorswatch: colorSwatchFields
+    });
+    var createFancyMenuItem = function (spec) {
+      return asRaw('fancymenuitem', fancyMenuItemSchema, spec);
+    };
+
+    var menuItemSchema = objOf([
+      requiredString('type'),
+      defaultedFunction('onSetup', function () {
+        return noop;
+      }),
+      defaultedFunction('onAction', noop),
+      optionString('icon')
+    ].concat(commonMenuItemFields));
+    var createMenuItem = function (spec) {
+      return asRaw('menuitem', menuItemSchema, spec);
+    };
+
+    var nestedMenuItemSchema = objOf([
+      requiredString('type'),
+      requiredFunction('getSubmenuItems'),
+      defaultedFunction('onSetup', function () {
+        return noop;
+      }),
+      optionString('icon')
+    ].concat(commonMenuItemFields));
+    var createNestedMenuItem = function (spec) {
+      return asRaw('nestedmenuitem', nestedMenuItemSchema, spec);
+    };
+
+    var toggleMenuItemSchema = objOf([
+      requiredString('type'),
+      optionString('icon'),
+      defaultedBoolean('active', false),
+      defaultedFunction('onSetup', function () {
+        return noop;
+      }),
+      requiredFunction('onAction')
+    ].concat(commonMenuItemFields));
+    var createToggleMenuItem = function (spec) {
+      return asRaw('togglemenuitem', toggleMenuItemSchema, spec);
+    };
+
+    var detectSize = function (comp, margin, selectorClass) {
+      var descendants$1 = descendants(comp.element, '.' + selectorClass);
+      if (descendants$1.length > 0) {
+        var columnLength = findIndex$1(descendants$1, function (c) {
+          var thisTop = c.dom.getBoundingClientRect().top;
+          var cTop = descendants$1[0].dom.getBoundingClientRect().top;
+          return Math.abs(thisTop - cTop) > margin;
+        }).getOr(descendants$1.length);
+        return Optional.some({
+          numColumns: columnLength,
+          numRows: Math.ceil(descendants$1.length / columnLength)
+        });
+      } else {
+        return Optional.none();
+      }
+    };
+
+    var namedEvents = function (name, handlers) {
+      return derive$1([config(name, handlers)]);
+    };
+    var unnamedEvents = function (handlers) {
+      return namedEvents(generate$6('unnamed-events'), handlers);
+    };
+    var SimpleBehaviours = {
+      namedEvents: namedEvents,
+      unnamedEvents: unnamedEvents
+    };
+
+    var ExclusivityChannel = generate$6('tooltip.exclusive');
+    var ShowTooltipEvent = generate$6('tooltip.show');
+    var HideTooltipEvent = generate$6('tooltip.hide');
+
+    var hideAllExclusive = function (component, _tConfig, _tState) {
+      component.getSystem().broadcastOn([ExclusivityChannel], {});
+    };
+    var setComponents = function (component, tConfig, tState, specs) {
+      tState.getTooltip().each(function (tooltip) {
+        if (tooltip.getSystem().isConnected()) {
+          Replacing.set(tooltip, specs);
+        }
+      });
+    };
+
+    var TooltippingApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        hideAllExclusive: hideAllExclusive,
+        setComponents: setComponents
+    });
+
+    var events$9 = function (tooltipConfig, state) {
+      var hide = function (comp) {
+        state.getTooltip().each(function (p) {
+          detach(p);
+          tooltipConfig.onHide(comp, p);
+          state.clearTooltip();
+        });
+        state.clearTimer();
+      };
+      var show = function (comp) {
+        if (!state.isShowing()) {
+          hideAllExclusive(comp);
+          var sink = tooltipConfig.lazySink(comp).getOrDie();
+          var popup = comp.getSystem().build({
+            dom: tooltipConfig.tooltipDom,
+            components: tooltipConfig.tooltipComponents,
+            events: derive$2(tooltipConfig.mode === 'normal' ? [
+              run$1(mouseover(), function (_) {
+                emit(comp, ShowTooltipEvent);
+              }),
+              run$1(mouseout(), function (_) {
+                emit(comp, HideTooltipEvent);
+              })
+            ] : []),
+            behaviours: derive$1([Replacing.config({})])
+          });
+          state.setTooltip(popup);
+          attach(sink, popup);
+          tooltipConfig.onShow(comp, popup);
+          Positioning.position(sink, popup, { anchor: tooltipConfig.anchor(comp) });
+        }
+      };
+      return derive$2(flatten([
+        [
+          run$1(ShowTooltipEvent, function (comp) {
+            state.resetTimer(function () {
+              show(comp);
+            }, tooltipConfig.delay);
+          }),
+          run$1(HideTooltipEvent, function (comp) {
+            state.resetTimer(function () {
+              hide(comp);
+            }, tooltipConfig.delay);
+          }),
+          run$1(receive(), function (comp, message) {
+            var receivingData = message;
+            if (!receivingData.universal) {
+              if (contains$2(receivingData.channels, ExclusivityChannel)) {
+                hide(comp);
+              }
+            }
+          }),
+          runOnDetached(function (comp) {
+            hide(comp);
+          })
+        ],
+        tooltipConfig.mode === 'normal' ? [
+          run$1(focusin(), function (comp) {
+            emit(comp, ShowTooltipEvent);
+          }),
+          run$1(postBlur(), function (comp) {
+            emit(comp, HideTooltipEvent);
+          }),
+          run$1(mouseover(), function (comp) {
+            emit(comp, ShowTooltipEvent);
+          }),
+          run$1(mouseout(), function (comp) {
+            emit(comp, HideTooltipEvent);
+          })
+        ] : [
+          run$1(highlight$1(), function (comp, _se) {
+            emit(comp, ShowTooltipEvent);
+          }),
+          run$1(dehighlight$1(), function (comp) {
+            emit(comp, HideTooltipEvent);
+          })
+        ]
+      ]));
+    };
+
+    var ActiveTooltipping = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$9
+    });
+
+    var TooltippingSchema = [
+      required$1('lazySink'),
+      required$1('tooltipDom'),
+      defaulted('exclusive', true),
+      defaulted('tooltipComponents', []),
+      defaulted('delay', 300),
+      defaultedStringEnum('mode', 'normal', [
+        'normal',
+        'follow-highlight'
+      ]),
+      defaulted('anchor', function (comp) {
+        return {
+          type: 'hotspot',
+          hotspot: comp,
+          layouts: {
+            onLtr: constant$1([
+              south$2,
+              north$2,
+              southeast$2,
+              northeast$2,
+              southwest$2,
+              northwest$2
+            ]),
+            onRtl: constant$1([
+              south$2,
+              north$2,
+              southeast$2,
+              northeast$2,
+              southwest$2,
+              northwest$2
+            ])
+          }
+        };
+      }),
+      onHandler('onHide'),
+      onHandler('onShow')
+    ];
+
+    var init$b = function () {
+      var timer = value$1();
+      var popup = value$1();
+      var clearTimer = function () {
+        timer.on(clearTimeout);
+      };
+      var resetTimer = function (f, delay) {
+        clearTimer();
+        timer.set(setTimeout(f, delay));
+      };
+      var readState = constant$1('not-implemented');
+      return nu$8({
+        getTooltip: popup.get,
+        isShowing: popup.isSet,
+        setTooltip: popup.set,
+        clearTooltip: popup.clear,
+        clearTimer: clearTimer,
+        resetTimer: resetTimer,
+        readState: readState
+      });
+    };
+
+    var TooltippingState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init$b
+    });
+
+    var Tooltipping = create$8({
+      fields: TooltippingSchema,
+      name: 'tooltipping',
+      active: ActiveTooltipping,
+      state: TooltippingState,
+      apis: TooltippingApis
+    });
+
+    var escape = function (text) {
+      return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    };
+
+    var global$b = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
+
+    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$a.baseURL + '/skins/ui/' + skinName;
+        }
+      }
+      return skinUrl;
+    };
+    var isReadOnly = function (editor) {
+      return editor.getParam('readonly', false, 'boolean');
+    };
+    var isSkinDisabled = function (editor) {
+      return editor.getParam('skin') === false;
+    };
+    var getHeightSetting = function (editor) {
+      return editor.getParam('height', Math.max(editor.getElement().offsetHeight, 200));
+    };
+    var getWidthSetting = function (editor) {
+      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 Optional.from(editor.getParam('min_height')).filter(isNumber);
+    };
+    var getMaxWidthSetting = function (editor) {
+      return Optional.from(editor.getParam('max_width')).filter(isNumber);
+    };
+    var getMaxHeightSetting = function (editor) {
+      return Optional.from(editor.getParam('max_height')).filter(isNumber);
+    };
+    var getUserStyleFormats = function (editor) {
+      return Optional.from(editor.getParam('style_formats')).filter(isArray);
+    };
+    var isMergeStyleFormats = function (editor) {
+      return editor.getParam('style_formats_merge', false, 'boolean');
+    };
+    var getLineHeightFormats = function (editor) {
+      return editor.getParam('lineheight_formats', '1 1.1 1.2 1.3 1.4 1.5 2', 'string').split(' ');
+    };
+    var getContentLanguages = function (editor) {
+      return editor.getParam('content_langs', undefined, 'array');
+    };
+    var getRemovedMenuItems = function (editor) {
+      return editor.getParam('removed_menuitems', '');
+    };
+    var isMenubarEnabled = function (editor) {
+      return editor.getParam('menubar', true, 'boolean') !== false;
+    };
+    var isToolbarEnabled = function (editor) {
+      var toolbar = editor.getParam('toolbar', true);
+      var isToolbarTrue = toolbar === true;
+      var isToolbarString = isString(toolbar);
+      var isToolbarObjectArray = isArray(toolbar) && toolbar.length > 0;
+      return !isMultipleToolbars(editor) && (isToolbarObjectArray || isToolbarString || isToolbarTrue);
+    };
+    var getMultipleToolbarsSetting = function (editor) {
+      var toolbars = range$2(9, function (num) {
+        return editor.getParam('toolbar' + (num + 1), false, 'string');
+      });
+      var toolbarArray = filter$2(toolbars, function (toolbar) {
+        return typeof toolbar === 'string';
+      });
+      return toolbarArray.length > 0 ? Optional.some(toolbarArray) : Optional.none();
+    };
+    var isMultipleToolbars = function (editor) {
+      return getMultipleToolbarsSetting(editor).fold(function () {
+        var toolbar = editor.getParam('toolbar', [], 'string[]');
+        return toolbar.length > 0;
+      }, always);
+    };
+    var ToolbarMode;
+    (function (ToolbarMode) {
+      ToolbarMode['default'] = 'wrap';
+      ToolbarMode['floating'] = 'floating';
+      ToolbarMode['sliding'] = 'sliding';
+      ToolbarMode['scrolling'] = 'scrolling';
+    }(ToolbarMode || (ToolbarMode = {})));
+    var getToolbarMode = function (editor) {
+      return editor.getParam('toolbar_mode', '', 'string');
+    };
+    var ToolbarLocation;
+    (function (ToolbarLocation) {
+      ToolbarLocation['auto'] = 'auto';
+      ToolbarLocation['top'] = 'top';
+      ToolbarLocation['bottom'] = 'bottom';
+    }(ToolbarLocation || (ToolbarLocation = {})));
+    var getToolbarGroups = function (editor) {
+      return editor.getParam('toolbar_groups', {}, 'object');
+    };
+    var getToolbarLocation = function (editor) {
+      return editor.getParam('toolbar_location', ToolbarLocation.auto, 'string');
+    };
+    var isToolbarLocationBottom = function (editor) {
+      return getToolbarLocation(editor) === ToolbarLocation.bottom;
+    };
+    var fixedContainerSelector = function (editor) {
+      return editor.getParam('fixed_toolbar_container', '', 'string');
+    };
+    var fixedToolbarContainerTarget = function (editor) {
+      return editor.getParam('fixed_toolbar_container_target');
+    };
+    var isToolbarPersist = function (editor) {
+      return editor.getParam('toolbar_persist', false, 'boolean');
+    };
+    var fixedContainerTarget = function (editor) {
+      if (!editor.inline) {
+        return Optional.none();
+      }
+      var selector = fixedContainerSelector(editor);
+      if (selector.length > 0) {
+        return descendant(body(), selector);
+      }
+      var element = fixedToolbarContainerTarget(editor);
+      if (isNonNullable(element)) {
+        return Optional.some(SugarElement.fromDom(element));
+      }
+      return Optional.none();
+    };
+    var useFixedContainer = function (editor) {
+      return editor.inline && fixedContainerTarget(editor).isSome();
+    };
+    var getUiContainer = function (editor) {
+      var fixedContainer = fixedContainerTarget(editor);
+      return fixedContainer.getOrThunk(function () {
+        return getContentContainer(getRootNode(SugarElement.fromDom(editor.getElement())));
+      });
+    };
+    var isDistractionFree = function (editor) {
+      return editor.inline && !isMenubarEnabled(editor) && !isToolbarEnabled(editor) && !isMultipleToolbars(editor);
+    };
+    var isStickyToolbar = function (editor) {
+      var isStickyToolbar = editor.getParam('toolbar_sticky', false, 'boolean');
+      return (isStickyToolbar || editor.inline) && !useFixedContainer(editor) && !isDistractionFree(editor);
+    };
+    var getStickyToolbarOffset = function (editor) {
+      return editor.getParam('toolbar_sticky_offset', 0, 'number');
+    };
+    var isDraggableModal$1 = function (editor) {
+      return editor.getParam('draggable_modal', false, 'boolean');
+    };
+    var getMenus = function (editor) {
+      var menu = editor.getParam('menu');
+      if (menu) {
+        return map$1(menu, function (menu) {
+          return __assign(__assign({}, menu), { items: menu.items });
+        });
+      } else {
+        return {};
+      }
+    };
+    var getMenubar = function (editor) {
+      return editor.getParam('menubar');
+    };
+    var getToolbar = function (editor) {
+      return editor.getParam('toolbar', true);
+    };
+    var getFilePickerCallback = function (editor) {
+      return editor.getParam('file_picker_callback');
+    };
+    var getFilePickerTypes = function (editor) {
+      return editor.getParam('file_picker_types');
+    };
+    var getFileBrowserCallbackTypes = function (editor) {
+      return editor.getParam('file_browser_callback_types');
+    };
+    var noTypeaheadUrls = function (editor) {
+      return editor.getParam('typeahead_urls') === false;
+    };
+    var getAnchorTop = function (editor) {
+      return editor.getParam('anchor_top', '#top');
+    };
+    var getAnchorBottom = function (editor) {
+      return editor.getParam('anchor_bottom', '#bottom');
+    };
+    var getFilePickerValidatorHandler = function (editor) {
+      var handler = editor.getParam('file_picker_validator_handler', undefined, 'function');
+      if (handler === undefined) {
+        return editor.getParam('filepicker_validator_handler', undefined, 'function');
+      } else {
+        return handler;
+      }
+    };
+
+    var ReadOnlyChannel = 'silver.readonly';
+    var ReadOnlyDataSchema = objOf([requiredBoolean('readonly')]);
+    var broadcastReadonly = function (uiComponents, readonly) {
+      var outerContainer = uiComponents.outerContainer;
+      var target = outerContainer.element;
+      if (readonly) {
+        uiComponents.mothership.broadcastOn([dismissPopups()], { target: target });
+        uiComponents.uiMothership.broadcastOn([dismissPopups()], { target: target });
+      }
+      uiComponents.mothership.broadcastOn([ReadOnlyChannel], { readonly: readonly });
+      uiComponents.uiMothership.broadcastOn([ReadOnlyChannel], { readonly: readonly });
+    };
+    var setupReadonlyModeSwitch = function (editor, uiComponents) {
+      editor.on('init', function () {
+        if (editor.mode.isReadOnly()) {
+          broadcastReadonly(uiComponents, true);
+        }
+      });
+      editor.on('SwitchMode', function () {
+        return broadcastReadonly(uiComponents, editor.mode.isReadOnly());
+      });
+      if (isReadOnly(editor)) {
+        editor.setMode('readonly');
+      }
+    };
+    var receivingConfig = function () {
+      var _a;
+      return Receiving.config({
+        channels: (_a = {}, _a[ReadOnlyChannel] = {
+          schema: ReadOnlyDataSchema,
+          onReceive: function (comp, data) {
+            Disabling.set(comp, data.readonly);
+          }
+        }, _a)
+      });
+    };
+
+    var item = function (disabled) {
+      return Disabling.config({
+        disabled: disabled,
+        disableClass: 'tox-collection__item--state-disabled'
+      });
+    };
+    var button = function (disabled) {
+      return Disabling.config({ disabled: disabled });
+    };
+    var splitButton = function (disabled) {
+      return Disabling.config({
+        disabled: disabled,
+        disableClass: 'tox-tbtn--disabled'
+      });
+    };
+    var toolbarButton = function (disabled) {
+      return Disabling.config({
+        disabled: disabled,
+        disableClass: 'tox-tbtn--disabled',
+        useNative: false
+      });
+    };
+    var DisablingConfigs = {
+      item: item,
+      button: button,
+      splitButton: splitButton,
+      toolbarButton: toolbarButton
+    };
+
+    var runWithApi = function (info, comp) {
+      var api = info.getApi(comp);
+      return function (f) {
+        f(api);
+      };
+    };
+    var onControlAttached = function (info, editorOffCell) {
+      return runOnAttached(function (comp) {
+        var run = runWithApi(info, comp);
+        run(function (api) {
+          var onDestroy = info.onSetup(api);
+          if (isFunction(onDestroy)) {
+            editorOffCell.set(onDestroy);
+          }
+        });
+      });
+    };
+    var onControlDetached = function (getApi, editorOffCell) {
+      return runOnDetached(function (comp) {
+        return runWithApi(getApi, comp)(editorOffCell.get());
+      });
+    };
+
+    var _a$1;
+    var onMenuItemExecute = function (info, itemResponse) {
+      return runOnExecute$1(function (comp, simulatedEvent) {
+        runWithApi(info, comp)(info.onAction);
+        if (!info.triggersSubmenu && itemResponse === ItemResponse$1.CLOSE_ON_EXECUTE) {
+          emit(comp, sandboxClose());
+          simulatedEvent.stop();
+        }
+      });
+    };
+    var menuItemEventOrder = (_a$1 = {}, _a$1[execute$5()] = [
+      'disabling',
+      'alloy.base.behaviour',
+      'toggling',
+      'item-events'
+    ], _a$1);
+
+    var componentRenderPipeline = cat;
+    var renderCommonItem = function (spec, structure, itemResponse, providersbackstage) {
+      var editorOffCell = Cell(noop);
+      return {
+        type: 'item',
+        dom: structure.dom,
+        components: componentRenderPipeline(structure.optComponents),
+        data: spec.data,
+        eventOrder: menuItemEventOrder,
+        hasSubmenu: spec.triggersSubmenu,
+        itemBehaviours: derive$1([
+          config('item-events', [
+            onMenuItemExecute(spec, itemResponse),
+            onControlAttached(spec, editorOffCell),
+            onControlDetached(spec, editorOffCell)
+          ]),
+          DisablingConfigs.item(function () {
+            return spec.disabled || providersbackstage.isDisabled();
+          }),
+          receivingConfig(),
+          Replacing.config({})
+        ].concat(spec.itemBehaviours))
+      };
+    };
+    var buildData = function (source) {
+      return {
+        value: source.value,
+        meta: __assign({ text: source.text.getOr('') }, source.meta)
+      };
+    };
+
+    var global$9 = tinymce.util.Tools.resolve('tinymce.Env');
+
+    var convertText = function (source) {
+      var mac = {
+        alt: '&#x2325;',
+        ctrl: '&#x2303;',
+        shift: '&#x21E7;',
+        meta: '&#x2318;',
+        access: '&#x2303;&#x2325;'
+      };
+      var other = {
+        meta: 'Ctrl',
+        access: 'Shift+Alt'
+      };
+      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$9.mac ? updated.join('') : updated.join('+');
+    };
+
+    var renderIcon$1 = function (name, icons, classes) {
+      if (classes === void 0) {
+        classes = [iconClass];
+      }
+      return render$3(name, {
+        tag: 'div',
+        classes: classes
+      }, icons);
+    };
+    var renderText = function (text) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: [textClass]
+        },
+        components: [text$1(global$e.translate(text))]
+      };
+    };
+    var renderHtml = function (html, classes) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: classes,
+          innerHtml: html
+        }
+      };
+    };
+    var renderStyledText = function (style, text) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: [textClass]
+        },
+        components: [{
+            dom: {
+              tag: style.tag,
+              styles: style.styles
+            },
+            components: [text$1(global$e.translate(text))]
+          }]
+      };
+    };
+    var renderShortcut = function (shortcut) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: [accessoryClass],
+          innerHtml: convertText(shortcut)
+        }
+      };
+    };
+    var renderCheckmark = function (icons) {
+      return renderIcon$1('checkmark', icons, [checkmarkClass]);
+    };
+    var renderSubmenuCaret = function (icons) {
+      return renderIcon$1('chevron-right', icons, [caretClass]);
+    };
+    var renderDownwardsCaret = function (icons) {
+      return renderIcon$1('chevron-down', icons, [caretClass]);
+    };
+    var renderContainer = function (container, components) {
+      var directionClass = container.direction === 'vertical' ? containerColumnClass : containerRowClass;
+      var alignClass = container.align === 'left' ? containerAlignLeftClass : containerAlignRightClass;
+      var getValignClass = function () {
+        switch (container.valign) {
+        case 'top':
+          return containerValignTopClass;
+        case 'middle':
+          return containerValignMiddleClass;
+        case 'bottom':
+          return containerValignBottomClass;
+        }
+      };
+      return {
+        dom: {
+          tag: 'div',
+          classes: [
+            containerClass,
+            directionClass,
+            alignClass,
+            getValignClass()
+          ]
+        },
+        components: components
+      };
+    };
+    var renderImage = function (src, classes, alt) {
+      return {
+        dom: {
+          tag: 'img',
+          classes: classes,
+          attributes: {
+            src: src,
+            alt: alt.getOr('')
+          }
+        }
+      };
+    };
+
+    var renderColorStructure = function (item, providerBackstage, fallbackIcon) {
+      var colorPickerCommand = 'custom';
+      var removeColorCommand = 'remove';
+      var itemText = item.ariaLabel;
+      var itemValue = item.value;
+      var iconSvg = item.iconContent.map(function (name) {
+        return getOr(name, providerBackstage.icons, fallbackIcon);
+      });
+      var getDom = function () {
+        var common = colorClass;
+        var icon = iconSvg.getOr('');
+        var attributes = itemText.map(function (text) {
+          return { title: providerBackstage.translate(text) };
+        }).getOr({});
+        var baseDom = {
+          tag: 'div',
+          attributes: attributes,
+          classes: [common]
+        };
+        if (itemValue === colorPickerCommand) {
+          return __assign(__assign({}, baseDom), {
+            tag: 'button',
+            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, true), ['tox-swatch--remove'], false),
+            innerHtml: icon
+          });
+        } else {
+          return __assign(__assign({}, baseDom), {
+            attributes: __assign(__assign({}, baseDom.attributes), { 'data-mce-color': itemValue }),
+            styles: { 'background-color': itemValue }
+          });
+        }
+      };
+      return {
+        dom: getDom(),
+        optComponents: []
+      };
+    };
+    var renderItemDomStructure = function (ariaLabel) {
+      var domTitle = ariaLabel.map(function (label) {
+        return { attributes: { title: global$e.translate(label) } };
+      }).getOr({});
+      return __assign({
+        tag: 'div',
+        classes: [
+          navClass,
+          selectableClass
+        ]
+      }, domTitle);
+    };
+    var renderNormalItemStructure = function (info, providersBackstage, renderIcons, fallbackIcon) {
+      var iconSpec = {
+        tag: 'div',
+        classes: [iconClass]
+      };
+      var renderIcon = function (iconName) {
+        return render$3(iconName, iconSpec, providersBackstage.icons, fallbackIcon);
+      };
+      var renderEmptyIcon = function () {
+        return Optional.some({ dom: iconSpec });
+      };
+      var leftIcon = renderIcons ? info.iconContent.map(renderIcon).orThunk(renderEmptyIcon) : Optional.none();
+      var checkmark = info.checkMark;
+      var textRender = Optional.from(info.meta).fold(function () {
+        return renderText;
+      }, function (meta) {
+        return has$2(meta, 'style') ? curry(renderStyledText, meta.style) : renderText;
+      });
+      var content = info.htmlContent.fold(function () {
+        return info.textContent.map(textRender);
+      }, function (html) {
+        return Optional.some(renderHtml(html, [textClass]));
+      });
+      var menuItem = {
+        dom: renderItemDomStructure(info.ariaLabel),
+        optComponents: [
+          leftIcon,
+          content,
+          info.shortcutContent.map(renderShortcut),
+          checkmark,
+          info.caret
+        ]
+      };
+      return menuItem;
+    };
+    var renderItemStructure = function (info, providersBackstage, renderIcons, fallbackIcon) {
+      if (fallbackIcon === void 0) {
+        fallbackIcon = Optional.none();
+      }
+      if (info.presets === 'color') {
+        return renderColorStructure(info, providersBackstage, fallbackIcon);
+      } else {
+        return renderNormalItemStructure(info, providersBackstage, renderIcons, fallbackIcon);
+      }
+    };
+
+    var tooltipBehaviour = function (meta, sharedBackstage) {
+      return get$e(meta, 'tooltipWorker').map(function (tooltipWorker) {
+        return [Tooltipping.config({
+            lazySink: sharedBackstage.getSink,
+            tooltipDom: {
+              tag: 'div',
+              classes: ['tox-tooltip-worker-container']
+            },
+            tooltipComponents: [],
+            anchor: function (comp) {
+              return {
+                type: 'submenu',
+                item: comp,
+                overrides: { maxHeightFunction: expandable$1 }
+              };
+            },
+            mode: 'follow-highlight',
+            onShow: function (component, _tooltip) {
+              tooltipWorker(function (elm) {
+                Tooltipping.setComponents(component, [external$2({ element: SugarElement.fromDom(elm) })]);
+              });
+            }
+          })];
+      }).getOr([]);
+    };
+    var encodeText = function (text) {
+      return global$b.DOM.encode(text);
+    };
+    var replaceText = function (text, matchText) {
+      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>';
+        });
+      } else {
+        return encoded;
+      }
+    };
+    var renderAutocompleteItem = function (spec, matchText, useText, presets, onItemValueHandler, itemResponse, sharedBackstage, renderIcons) {
+      if (renderIcons === void 0) {
+        renderIcons = true;
+      }
+      var structure = renderItemStructure({
+        presets: presets,
+        textContent: Optional.none(),
+        htmlContent: useText ? spec.text.map(function (text) {
+          return replaceText(text, matchText);
+        }) : Optional.none(),
+        ariaLabel: spec.text,
+        iconContent: spec.icon,
+        shortcutContent: Optional.none(),
+        checkMark: Optional.none(),
+        caret: Optional.none(),
+        value: spec.value
+      }, sharedBackstage.providers, renderIcons, spec.icon);
+      return renderCommonItem({
+        data: buildData(spec),
+        disabled: spec.disabled,
+        getApi: constant$1({}),
+        onAction: function (_api) {
+          return onItemValueHandler(spec.value, spec.meta);
+        },
+        onSetup: constant$1(noop),
+        triggersSubmenu: false,
+        itemBehaviours: tooltipBehaviour(spec.meta, sharedBackstage)
+      }, structure, itemResponse, sharedBackstage.providers);
+    };
+
+    var render$2 = function (items, extras) {
+      return map$2(items, function (item) {
+        switch (item.type) {
+        case 'cardcontainer':
+          return renderContainer(item, render$2(item.items, extras));
+        case 'cardimage':
+          return renderImage(item.src, item.classes, item.alt);
+        case 'cardtext':
+          var shouldHighlight = item.name.exists(function (name) {
+            return contains$2(extras.cardText.highlightOn, name);
+          });
+          var matchText = shouldHighlight ? Optional.from(extras.cardText.matchText).getOr('') : '';
+          return renderHtml(replaceText(item.text, matchText), item.classes);
+        }
+      });
+    };
+    var renderCardMenuItem = function (spec, itemResponse, sharedBackstage, extras) {
+      var getApi = function (component) {
+        return {
+          isDisabled: function () {
+            return Disabling.isDisabled(component);
+          },
+          setDisabled: function (state) {
+            Disabling.set(component, state);
+            each$1(descendants(component.element, '*'), function (elm) {
+              component.getSystem().getByDom(elm).each(function (comp) {
+                if (comp.hasConfigured(Disabling)) {
+                  Disabling.set(comp, state);
+                }
+              });
+            });
+          }
+        };
+      };
+      var structure = {
+        dom: renderItemDomStructure(spec.label),
+        optComponents: [Optional.some({
+            dom: {
+              tag: 'div',
+              classes: [
+                containerClass,
+                containerRowClass
+              ]
+            },
+            components: render$2(spec.items, extras)
+          })]
+      };
+      return renderCommonItem({
+        data: buildData(__assign({ text: Optional.none() }, spec)),
+        disabled: spec.disabled,
+        getApi: getApi,
+        onAction: spec.onAction,
+        onSetup: spec.onSetup,
+        triggersSubmenu: false,
+        itemBehaviours: Optional.from(extras.itemBehaviours).getOr([])
+      }, structure, itemResponse, sharedBackstage.providers);
+    };
+
+    var renderChoiceItem = function (spec, useText, presets, onItemValueHandler, isSelected, itemResponse, providersBackstage, renderIcons) {
+      if (renderIcons === void 0) {
+        renderIcons = true;
+      }
+      var getApi = function (component) {
+        return {
+          setActive: function (state) {
+            Toggling.set(component, state);
+          },
+          isActive: function () {
+            return Toggling.isOn(component);
+          },
+          isDisabled: function () {
+            return Disabling.isDisabled(component);
+          },
+          setDisabled: function (state) {
+            return Disabling.set(component, state);
+          }
+        };
+      };
+      var structure = renderItemStructure({
+        presets: presets,
+        textContent: useText ? spec.text : Optional.none(),
+        htmlContent: Optional.none(),
+        ariaLabel: spec.text,
+        iconContent: spec.icon,
+        shortcutContent: useText ? spec.shortcut : Optional.none(),
+        checkMark: useText ? Optional.some(renderCheckmark(providersBackstage.icons)) : Optional.none(),
+        caret: Optional.none(),
+        value: spec.value
+      }, providersBackstage, renderIcons);
+      return deepMerge(renderCommonItem({
+        data: buildData(spec),
+        disabled: spec.disabled,
+        getApi: getApi,
+        onAction: function (_api) {
+          return onItemValueHandler(spec.value);
+        },
+        onSetup: function (api) {
+          api.setActive(isSelected);
+          return noop;
+        },
+        triggersSubmenu: false,
+        itemBehaviours: []
+      }, structure, itemResponse, providersBackstage), {
+        toggling: {
+          toggleClass: tickedClass,
+          toggleOnExecute: false,
+          selected: spec.active
+        }
+      });
+    };
+
+    var parts$f = generate$3(owner$2(), parts$h());
+
+    var hexColour = function (value) {
+      return { value: value };
+    };
+    var shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+    var longformRegex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i;
+    var isHexString = function (hex) {
+      return shorthandRegex.test(hex) || longformRegex.test(hex);
+    };
+    var normalizeHex = function (hex) {
+      return removeLeading(hex, '#').toUpperCase();
+    };
+    var fromString$1 = function (hex) {
+      return isHexString(hex) ? Optional.some({ value: normalizeHex(hex) }) : Optional.none();
+    };
+    var getLongForm = function (hex) {
+      var hexString = hex.value.replace(shorthandRegex, function (m, r, g, b) {
+        return r + r + g + g + b + b;
+      });
+      return { value: hexString };
+    };
+    var extractValues = function (hex) {
+      var longForm = getLongForm(hex);
+      var splitForm = longformRegex.exec(longForm.value);
+      return splitForm === null ? [
+        'FFFFFF',
+        'FF',
+        'FF',
+        'FF'
+      ] : splitForm;
+    };
+    var toHex = function (component) {
+      var hex = component.toString(16);
+      return (hex.length === 1 ? '0' + hex : hex).toUpperCase();
+    };
+    var fromRgba = function (rgbaColour) {
+      var value = toHex(rgbaColour.red) + toHex(rgbaColour.green) + toHex(rgbaColour.blue);
+      return hexColour(value);
+    };
+
+    var min = Math.min;
+    var max = Math.max;
+    var round$1 = Math.round;
+    var rgbRegex = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)/;
+    var rgbaRegex = /^rgba\((\d+),\s*(\d+),\s*(\d+),\s*(\d?(?:\.\d+)?)\)/;
+    var rgbaColour = function (red, green, blue, alpha) {
+      return {
+        red: red,
+        green: green,
+        blue: blue,
+        alpha: alpha
+      };
+    };
+    var isRgbaComponent = function (value) {
+      var num = parseInt(value, 10);
+      return num.toString() === value && num >= 0 && num <= 255;
+    };
+    var fromHsv = function (hsv) {
+      var r;
+      var g;
+      var b;
+      var hue = (hsv.hue || 0) % 360;
+      var saturation = hsv.saturation / 100;
+      var brightness = hsv.value / 100;
+      saturation = max(0, min(saturation, 1));
+      brightness = max(0, min(brightness, 1));
+      if (saturation === 0) {
+        r = g = b = round$1(255 * brightness);
+        return rgbaColour(r, g, b, 1);
+      }
+      var side = hue / 60;
+      var chroma = brightness * saturation;
+      var x = chroma * (1 - Math.abs(side % 2 - 1));
+      var match = brightness - chroma;
+      switch (Math.floor(side)) {
+      case 0:
+        r = chroma;
+        g = x;
+        b = 0;
+        break;
+      case 1:
+        r = x;
+        g = chroma;
+        b = 0;
+        break;
+      case 2:
+        r = 0;
+        g = chroma;
+        b = x;
+        break;
+      case 3:
+        r = 0;
+        g = x;
+        b = chroma;
+        break;
+      case 4:
+        r = x;
+        g = 0;
+        b = chroma;
+        break;
+      case 5:
+        r = chroma;
+        g = 0;
+        b = x;
+        break;
+      default:
+        r = g = b = 0;
+      }
+      r = round$1(255 * (r + match));
+      g = round$1(255 * (g + match));
+      b = round$1(255 * (b + match));
+      return rgbaColour(r, g, b, 1);
+    };
+    var fromHex = function (hexColour) {
+      var result = extractValues(hexColour);
+      var red = parseInt(result[1], 16);
+      var green = parseInt(result[2], 16);
+      var blue = parseInt(result[3], 16);
+      return rgbaColour(red, green, blue, 1);
+    };
+    var fromStringValues = function (red, green, blue, alpha) {
+      var r = parseInt(red, 10);
+      var g = parseInt(green, 10);
+      var b = parseInt(blue, 10);
+      var a = parseFloat(alpha);
+      return rgbaColour(r, g, b, a);
+    };
+    var fromString = function (rgbaString) {
+      if (rgbaString === 'transparent') {
+        return Optional.some(rgbaColour(0, 0, 0, 0));
+      }
+      var rgbMatch = rgbRegex.exec(rgbaString);
+      if (rgbMatch !== null) {
+        return Optional.some(fromStringValues(rgbMatch[1], rgbMatch[2], rgbMatch[3], '1'));
+      }
+      var rgbaMatch = rgbaRegex.exec(rgbaString);
+      if (rgbaMatch !== null) {
+        return Optional.some(fromStringValues(rgbaMatch[1], rgbaMatch[2], rgbaMatch[3], rgbaMatch[4]));
+      }
+      return Optional.none();
+    };
+    var toString = function (rgba) {
+      return 'rgba(' + rgba.red + ',' + rgba.green + ',' + rgba.blue + ',' + rgba.alpha + ')';
+    };
+    var red = rgbaColour(255, 0, 0, 1);
+
+    var fireSkinLoaded$1 = function (editor) {
+      return editor.fire('SkinLoaded');
+    };
+    var fireSkinLoadError$1 = function (editor, error) {
+      return editor.fire('SkinLoadError', error);
+    };
+    var fireResizeEditor = function (editor) {
+      return editor.fire('ResizeEditor');
+    };
+    var fireResizeContent = function (editor, e) {
+      return editor.fire('ResizeContent', e);
+    };
+    var fireScrollContent = function (editor, e) {
+      return editor.fire('ScrollContent', e);
+    };
+    var fireTextColorChange = function (editor, data) {
+      return editor.fire('TextColorChange', data);
+    };
+
+    var hsvColour = function (hue, saturation, value) {
+      return {
+        hue: hue,
+        saturation: saturation,
+        value: value
+      };
+    };
+    var fromRgb = function (rgbaColour) {
+      var h = 0;
+      var s = 0;
+      var v = 0;
+      var r = rgbaColour.red / 255;
+      var g = rgbaColour.green / 255;
+      var b = rgbaColour.blue / 255;
+      var minRGB = Math.min(r, Math.min(g, b));
+      var maxRGB = Math.max(r, Math.max(g, b));
+      if (minRGB === maxRGB) {
+        v = minRGB;
+        return hsvColour(0, 0, v * 100);
+      }
+      var d = r === minRGB ? g - b : b === minRGB ? r - g : b - r;
+      h = r === minRGB ? 3 : b === minRGB ? 1 : 5;
+      h = 60 * (h - d / (maxRGB - minRGB));
+      s = (maxRGB - minRGB) / maxRGB;
+      v = maxRGB;
+      return hsvColour(Math.round(h), Math.round(s * 100), Math.round(v * 100));
+    };
+
+    var hexToHsv = function (hex) {
+      return fromRgb(fromHex(hex));
+    };
+    var hsvToHex = function (hsv) {
+      return fromRgba(fromHsv(hsv));
+    };
+    var anyToHex = function (color) {
+      return fromString$1(color).orThunk(function () {
+        return fromString(color).map(fromRgba);
+      }).getOrThunk(function () {
+        var canvas = document.createElement('canvas');
+        canvas.height = 1;
+        canvas.width = 1;
+        var canvasContext = canvas.getContext('2d');
+        canvasContext.clearRect(0, 0, canvas.width, canvas.height);
+        canvasContext.fillStyle = '#FFFFFF';
+        canvasContext.fillStyle = color;
+        canvasContext.fillRect(0, 0, 1, 1);
+        var rgba = canvasContext.getImageData(0, 0, 1, 1).data;
+        var r = rgba[0];
+        var g = rgba[1];
+        var b = rgba[2];
+        var a = rgba[3];
+        return fromRgba(rgbaColour(r, g, b, a));
+      });
+    };
+
+    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$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;
+      };
+      var cache = prune(localstorage);
+      var add = function (key) {
+        indexOf(cache, key).each(remove);
+        cache.unshift(key);
+        if (cache.length > max) {
+          cache.pop();
+        }
+        global$8.setItem(storageName, JSON.stringify(cache));
+      };
+      var remove = function (idx) {
+        cache.splice(idx, 1);
+      };
+      var state = function () {
+        return cache.slice(0);
+      };
+      return {
+        add: add,
+        state: state
+      };
+    }
+
+    var choiceItem = 'choiceitem';
+    var defaultColors = [
+      {
+        type: choiceItem,
+        text: 'Light Green',
+        value: '#BFEDD2'
+      },
+      {
+        type: choiceItem,
+        text: 'Light Yellow',
+        value: '#FBEEB8'
+      },
+      {
+        type: choiceItem,
+        text: 'Light Red',
+        value: '#F8CAC6'
+      },
+      {
+        type: choiceItem,
+        text: 'Light Purple',
+        value: '#ECCAFA'
+      },
+      {
+        type: choiceItem,
+        text: 'Light Blue',
+        value: '#C2E0F4'
+      },
+      {
+        type: choiceItem,
+        text: 'Green',
+        value: '#2DC26B'
+      },
+      {
+        type: choiceItem,
+        text: 'Yellow',
+        value: '#F1C40F'
+      },
+      {
+        type: choiceItem,
+        text: 'Red',
+        value: '#E03E2D'
+      },
+      {
+        type: choiceItem,
+        text: 'Purple',
+        value: '#B96AD9'
+      },
+      {
+        type: choiceItem,
+        text: 'Blue',
+        value: '#3598DB'
+      },
+      {
+        type: choiceItem,
+        text: 'Dark Turquoise',
+        value: '#169179'
+      },
+      {
+        type: choiceItem,
+        text: 'Orange',
+        value: '#E67E23'
+      },
+      {
+        type: choiceItem,
+        text: 'Dark Red',
+        value: '#BA372A'
+      },
+      {
+        type: choiceItem,
+        text: 'Dark Purple',
+        value: '#843FA1'
+      },
+      {
+        type: choiceItem,
+        text: 'Dark Blue',
+        value: '#236FA1'
+      },
+      {
+        type: choiceItem,
+        text: 'Light Gray',
+        value: '#ECF0F1'
+      },
+      {
+        type: choiceItem,
+        text: 'Medium Gray',
+        value: '#CED4D9'
+      },
+      {
+        type: choiceItem,
+        text: 'Gray',
+        value: '#95A5A6'
+      },
+      {
+        type: choiceItem,
+        text: 'Dark Gray',
+        value: '#7E8C8D'
+      },
+      {
+        type: choiceItem,
+        text: 'Navy Blue',
+        value: '#34495E'
+      },
+      {
+        type: choiceItem,
+        text: 'Black',
+        value: '#000000'
+      },
+      {
+        type: choiceItem,
+        text: 'White',
+        value: '#ffffff'
+      }
+    ];
+    var colorCache = ColorCache(10);
+    var mapColors = function (colorMap) {
+      var colors = [];
+      for (var i = 0; i < colorMap.length; i += 2) {
+        colors.push({
+          text: colorMap[i + 1],
+          value: '#' + anyToHex(colorMap[i]).value,
+          type: 'choiceitem'
+        });
+      }
+      return colors;
+    };
+    var getColorCols$2 = function (editor, defaultCols) {
+      return editor.getParam('color_cols', defaultCols, 'number');
+    };
+    var hasCustomColors$1 = function (editor) {
+      return editor.getParam('custom_colors') !== false;
+    };
+    var getColorMap = function (editor) {
+      return editor.getParam('color_map');
+    };
+    var getColors$2 = function (editor) {
+      var unmapped = getColorMap(editor);
+      return unmapped !== undefined ? mapColors(unmapped) : defaultColors;
+    };
+    var getCurrentColors = function () {
+      return map$2(colorCache.state(), function (color) {
+        return {
+          type: choiceItem,
+          text: color,
+          value: color
+        };
+      });
+    };
+    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 Optional.from(color);
+    };
+    var applyFormat = function (editor, format, value) {
+      editor.undoManager.transact(function () {
+        editor.focus();
+        editor.formatter.apply(format, { value: value });
+        editor.nodeChanged();
+      });
+    };
+    var removeFormat = function (editor, format) {
+      editor.undoManager.transact(function () {
+        editor.focus();
+        editor.formatter.remove(format, { value: null }, null, true);
+        editor.nodeChanged();
+      });
+    };
+    var registerCommands = function (editor) {
+      editor.addCommand('mceApplyTextcolor', function (format, value) {
+        applyFormat(editor, format, value);
+      });
+      editor.addCommand('mceRemoveTextcolor', function (format) {
+        removeFormat(editor, format);
+      });
+    };
+    var calcCols = function (colors) {
+      return Math.max(5, Math.ceil(Math.sqrt(colors)));
+    };
+    var getColorCols$1 = function (editor) {
+      var colors = getColors$2(editor);
+      var defaultCols = calcCols(colors.length);
+      return getColorCols$2(editor, defaultCols);
+    };
+    var getAdditionalColors = function (hasCustom) {
+      var type = 'choiceitem';
+      var remove = {
+        type: type,
+        text: 'Remove color',
+        icon: 'color-swatch-remove-color',
+        value: 'remove'
+      };
+      var custom = {
+        type: type,
+        text: 'Custom color',
+        icon: 'color-picker',
+        value: 'custom'
+      };
+      return hasCustom ? [
+        remove,
+        custom
+      ] : [remove];
+    };
+    var applyColor = function (editor, format, value, onChoice) {
+      if (value === 'custom') {
+        var dialog = colorPickerDialog(editor);
+        dialog(function (colorOpt) {
+          colorOpt.each(function (color) {
+            addColor(color);
+            editor.execCommand('mceApplyTextcolor', format, color);
+            onChoice(color);
+          });
+        }, fallbackColor);
+      } else if (value === 'remove') {
+        onChoice('');
+        editor.execCommand('mceRemoveTextcolor', format);
+      } else {
+        onChoice(value);
+        editor.execCommand('mceApplyTextcolor', format, value);
+      }
+    };
+    var getColors$1 = function (colors, hasCustom) {
+      return colors.concat(getCurrentColors().concat(getAdditionalColors(hasCustom)));
+    };
+    var getFetch$1 = function (colors, hasCustom) {
+      return function (callback) {
+        callback(getColors$1(colors, hasCustom));
+      };
+    };
+    var setIconColor = function (splitButtonApi, name, newColor) {
+      var id = name === 'forecolor' ? 'tox-icon-text-color__color' : 'tox-icon-highlight-bg-color__color';
+      splitButtonApi.setIconFill(id, newColor);
+    };
+    var registerTextColorButton = function (editor, name, format, tooltip, lastColor) {
+      editor.ui.registry.addSplitButton(name, {
+        tooltip: tooltip,
+        presets: 'color',
+        icon: name === 'forecolor' ? 'text-color' : 'highlight-bg-color',
+        select: function (value) {
+          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) {
+          applyColor(editor, format, lastColor.get(), noop);
+        },
+        onItemAction: function (_splitButtonApi, value) {
+          applyColor(editor, format, value, function (newColor) {
+            lastColor.set(newColor);
+            fireTextColorChange(editor, {
+              name: name,
+              color: newColor
+            });
+          });
+        },
+        onSetup: function (splitButtonApi) {
+          setIconColor(splitButtonApi, name, lastColor.get());
+          var handler = function (e) {
+            if (e.name === name) {
+              setIconColor(splitButtonApi, e.name, e.color);
+            }
+          };
+          editor.on('TextColorChange', handler);
+          return function () {
+            editor.off('TextColorChange', handler);
+          };
+        }
+      });
+    };
+    var registerTextColorMenuItem = function (editor, name, format, text) {
+      editor.ui.registry.addNestedMenuItem(name, {
+        text: text,
+        icon: name === 'forecolor' ? 'text-color' : 'highlight-bg-color',
+        getSubmenuItems: function () {
+          return [{
+              type: 'fancymenuitem',
+              fancytype: 'colorswatch',
+              onAction: function (data) {
+                applyColor(editor, format, data.value, noop);
+              }
+            }];
+        }
+      });
+    };
+    var colorPickerDialog = function (editor) {
+      return function (callback, value) {
+        var isValid = false;
+        var onSubmit = function (api) {
+          var data = api.getData();
+          var hex = data.colorpicker;
+          if (isValid) {
+            callback(Optional.from(hex));
+            api.close();
+          } else {
+            editor.windowManager.alert(editor.translate([
+              'Invalid hex color code: {0}',
+              hex
+            ]));
+          }
+        };
+        var onAction = function (_api, details) {
+          if (details.name === 'hex-valid') {
+            isValid = details.value;
+          }
+        };
+        var initialData = { colorpicker: value };
+        editor.windowManager.open({
+          title: 'Color Picker',
+          size: 'normal',
+          body: {
+            type: 'panel',
+            items: [{
+                type: 'colorpicker',
+                name: 'colorpicker',
+                label: 'Color'
+              }]
+          },
+          buttons: [
+            {
+              type: 'cancel',
+              name: 'cancel',
+              text: 'Cancel'
+            },
+            {
+              type: 'submit',
+              name: 'save',
+              text: 'Save',
+              primary: true
+            }
+          ],
+          initialData: initialData,
+          onAction: onAction,
+          onSubmit: onSubmit,
+          onClose: noop,
+          onCancel: function () {
+            callback(Optional.none());
+          }
+        });
+      };
+    };
+    var register$a = function (editor) {
+      registerCommands(editor);
+      var lastForeColor = Cell(fallbackColor);
+      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');
+    };
+
+    var createPartialChoiceMenu = function (value, items, onItemValueHandler, columns, presets, itemResponse, select, providersBackstage) {
+      var hasIcons = menuHasIcons(items);
+      var presetItemTypes = presets !== 'color' ? 'normal' : 'color';
+      var alloyItems = createChoiceItems(items, onItemValueHandler, columns, presetItemTypes, itemResponse, select, providersBackstage);
+      return createPartialMenuWithAlloyItems(value, hasIcons, alloyItems, columns, presets);
+    };
+    var createChoiceItems = function (items, onItemValueHandler, columns, itemPresets, itemResponse, select, providersBackstage) {
+      return cat(map$2(items, function (item) {
+        if (item.type === 'choiceitem') {
+          return createChoiceMenuItem(item).fold(handleError, function (d) {
+            return Optional.some(renderChoiceItem(d, columns === 1, itemPresets, onItemValueHandler, select(item.value), itemResponse, providersBackstage, menuHasIcons(items)));
+          });
+        } else {
+          return Optional.none();
+        }
+      }));
+    };
+
+    var deriveMenuMovement = function (columns, presets) {
+      var menuMarkers = markers(presets);
+      if (columns === 1) {
+        return {
+          mode: 'menu',
+          moveOnTab: true
+        };
+      } else if (columns === 'auto') {
+        return {
+          mode: 'grid',
+          selector: '.' + menuMarkers.item,
+          initSize: {
+            numColumns: 1,
+            numRows: 1
+          }
+        };
+      } else {
+        var rowClass = presets === 'color' ? 'tox-swatches__row' : 'tox-collection__group';
+        return {
+          mode: 'matrix',
+          rowSelector: '.' + rowClass
+        };
+      }
+    };
+    var deriveCollectionMovement = function (columns, presets) {
+      if (columns === 1) {
+        return {
+          mode: 'menu',
+          moveOnTab: false,
+          selector: '.tox-collection__item'
+        };
+      } else if (columns === 'auto') {
+        return {
+          mode: 'flatgrid',
+          selector: '.' + 'tox-collection__item',
+          initSize: {
+            numColumns: 1,
+            numRows: 1
+          }
+        };
+      } else {
+        return {
+          mode: 'matrix',
+          selectors: {
+            row: presets === 'color' ? '.tox-swatches__row' : '.tox-collection__group',
+            cell: presets === 'color' ? '.' + colorClass : '.' + selectableClass
+          }
+        };
+      }
+    };
+
+    var renderColorSwatchItem = function (spec, backstage) {
+      var items = getColorItems(spec, backstage);
+      var columns = backstage.colorinput.getColorCols();
+      var presets = 'color';
+      var menuSpec = createPartialChoiceMenu(generate$6('menu-value'), items, function (value) {
+        spec.onAction({ value: value });
+      }, columns, presets, ItemResponse$1.CLOSE_ON_EXECUTE, never, backstage.shared.providers);
+      var widgetSpec = __assign(__assign({}, menuSpec), {
+        markers: markers(presets),
+        movement: deriveMenuMovement(columns, presets)
+      });
+      return {
+        type: 'widget',
+        data: { value: generate$6('widget-id') },
+        dom: {
+          tag: 'div',
+          classes: ['tox-fancymenuitem']
+        },
+        autofocus: true,
+        components: [parts$f.widget(Menu.sketch(widgetSpec))]
+      };
+    };
+    var getColorItems = function (spec, backstage) {
+      var useCustomColors = spec.initData.allowCustomColors && backstage.colorinput.hasCustomColors();
+      return spec.initData.colors.fold(function () {
+        return getColors$1(backstage.colorinput.getColors(), useCustomColors);
+      }, function (colors) {
+        return colors.concat(getAdditionalColors(useCustomColors));
+      });
+    };
+
+    var cellOverEvent = generate$6('cell-over');
+    var cellExecuteEvent = generate$6('cell-execute');
+    var makeCell = function (row, col, labelId) {
+      var _a;
+      var emitCellOver = function (c) {
+        return emitWith(c, cellOverEvent, {
+          row: row,
+          col: col
+        });
+      };
+      var emitExecute = function (c) {
+        return emitWith(c, cellExecuteEvent, {
+          row: row,
+          col: col
+        });
+      };
+      var onClick = function (c, se) {
+        se.stop();
+        emitExecute(c);
+      };
+      return build$1({
+        dom: {
+          tag: 'div',
+          attributes: (_a = { role: 'button' }, _a['aria-labelledby'] = labelId, _a)
+        },
+        behaviours: derive$1([
+          config('insert-table-picker-cell', [
+            run$1(mouseover(), Focusing.focus),
+            run$1(execute$5(), emitExecute),
+            run$1(click(), onClick),
+            run$1(tap(), onClick)
+          ]),
+          Toggling.config({
+            toggleClass: 'tox-insert-table-picker__selected',
+            toggleOnExecute: false
+          }),
+          Focusing.config({ onFocus: emitCellOver })
+        ])
+      });
+    };
+    var makeCells = function (labelId, numRows, numCols) {
+      var cells = [];
+      for (var i = 0; i < numRows; i++) {
+        var row = [];
+        for (var j = 0; j < numCols; j++) {
+          row.push(makeCell(i, j, labelId));
+        }
+        cells.push(row);
+      }
+      return cells;
+    };
+    var selectCells = function (cells, selectedRow, selectedColumn, numRows, numColumns) {
+      for (var i = 0; i < numRows; i++) {
+        for (var j = 0; j < numColumns; j++) {
+          Toggling.set(cells[i][j], i <= selectedRow && j <= selectedColumn);
+        }
+      }
+    };
+    var makeComponents = function (cells) {
+      return bind$3(cells, function (cellRow) {
+        return map$2(cellRow, premade);
+      });
+    };
+    var makeLabelText = function (row, col) {
+      return text$1(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: [emptyLabelText],
+        behaviours: derive$1([Replacing.config({})])
+      });
+      return {
+        type: 'widget',
+        data: { value: generate$6('widget-id') },
+        dom: {
+          tag: 'div',
+          classes: ['tox-fancymenuitem']
+        },
+        autofocus: true,
+        components: [parts$f.widget({
+            dom: {
+              tag: 'div',
+              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 _a = e.event, row = _a.row, col = _a.col;
+                  selectCells(cells, row, col, numRows, numColumns);
+                  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: row + 1,
+                    numColumns: col + 1
+                  });
+                  emit(c, sandboxClose());
+                })
+              ]),
+              Keying.config({
+                initSize: {
+                  numRows: numRows,
+                  numColumns: numColumns
+                },
+                mode: 'flatgrid',
+                selector: '[role="button"]'
+              })
+            ])
+          })]
+      };
+    };
+
+    var fancyMenuItems = {
+      inserttable: renderInsertTableMenuItem,
+      colorswatch: renderColorSwatchItem
+    };
+    var renderFancyMenuItem = function (spec, backstage) {
+      return get$e(fancyMenuItems, spec.fancytype).map(function (render) {
+        return render(spec, backstage);
+      });
+    };
+
+    var renderNestedItem = function (spec, itemResponse, providersBackstage, renderIcons, downwardsCaret) {
+      if (renderIcons === void 0) {
+        renderIcons = true;
+      }
+      if (downwardsCaret === void 0) {
+        downwardsCaret = false;
+      }
+      var caret = downwardsCaret ? renderDownwardsCaret(providersBackstage.icons) : renderSubmenuCaret(providersBackstage.icons);
+      var getApi = function (component) {
+        return {
+          isDisabled: function () {
+            return Disabling.isDisabled(component);
+          },
+          setDisabled: function (state) {
+            return Disabling.set(component, state);
+          }
+        };
+      };
+      var structure = renderItemStructure({
+        presets: 'normal',
+        iconContent: spec.icon,
+        textContent: spec.text,
+        htmlContent: Optional.none(),
+        ariaLabel: spec.text,
+        caret: Optional.some(caret),
+        checkMark: Optional.none(),
+        shortcutContent: spec.shortcut
+      }, providersBackstage, renderIcons);
+      return renderCommonItem({
+        data: buildData(spec),
+        getApi: getApi,
+        disabled: spec.disabled,
+        onAction: noop,
+        onSetup: spec.onSetup,
+        triggersSubmenu: true,
+        itemBehaviours: []
+      }, structure, itemResponse, providersBackstage);
+    };
+
+    var renderNormalItem = function (spec, itemResponse, providersBackstage, renderIcons) {
+      if (renderIcons === void 0) {
+        renderIcons = true;
+      }
+      var getApi = function (component) {
+        return {
+          isDisabled: function () {
+            return Disabling.isDisabled(component);
+          },
+          setDisabled: function (state) {
+            return Disabling.set(component, state);
+          }
+        };
+      };
+      var structure = renderItemStructure({
+        presets: 'normal',
+        iconContent: spec.icon,
+        textContent: spec.text,
+        htmlContent: Optional.none(),
+        ariaLabel: spec.text,
+        caret: Optional.none(),
+        checkMark: Optional.none(),
+        shortcutContent: spec.shortcut
+      }, providersBackstage, renderIcons);
+      return renderCommonItem({
+        data: buildData(spec),
+        getApi: getApi,
+        disabled: spec.disabled,
+        onAction: spec.onAction,
+        onSetup: spec.onSetup,
+        triggersSubmenu: false,
+        itemBehaviours: []
+      }, structure, itemResponse, providersBackstage);
+    };
+
+    var renderSeparatorItem = function (spec) {
+      var innerHtml = spec.text.fold(function () {
+        return {};
+      }, function (text) {
+        return { innerHtml: text };
+      });
+      return {
+        type: 'separator',
+        dom: __assign({
+          tag: 'div',
+          classes: [
+            selectableClass,
+            groupHeadingClass
+          ]
+        }, innerHtml),
+        components: []
+      };
+    };
+
+    var renderToggleMenuItem = function (spec, itemResponse, providersBackstage, renderIcons) {
+      if (renderIcons === void 0) {
+        renderIcons = true;
+      }
+      var getApi = function (component) {
+        return {
+          setActive: function (state) {
+            Toggling.set(component, state);
+          },
+          isActive: function () {
+            return Toggling.isOn(component);
+          },
+          isDisabled: function () {
+            return Disabling.isDisabled(component);
+          },
+          setDisabled: function (state) {
+            return Disabling.set(component, state);
+          }
+        };
+      };
+      var structure = renderItemStructure({
+        iconContent: spec.icon,
+        textContent: spec.text,
+        htmlContent: Optional.none(),
+        ariaLabel: spec.text,
+        checkMark: Optional.some(renderCheckmark(providersBackstage.icons)),
+        caret: Optional.none(),
+        shortcutContent: spec.shortcut,
+        presets: 'normal',
+        meta: spec.meta
+      }, providersBackstage, renderIcons);
+      return deepMerge(renderCommonItem({
+        data: buildData(spec),
+        disabled: spec.disabled,
+        getApi: getApi,
+        onAction: spec.onAction,
+        onSetup: spec.onSetup,
+        triggersSubmenu: false,
+        itemBehaviours: []
+      }, structure, itemResponse, providersBackstage), {
+        toggling: {
+          toggleClass: tickedClass,
+          toggleOnExecute: false,
+          selected: spec.active
+        }
+      });
+    };
+
+    var autocomplete = renderAutocompleteItem;
+    var separator$3 = renderSeparatorItem;
+    var normal = renderNormalItem;
+    var nested = renderNestedItem;
+    var toggle$1 = renderToggleMenuItem;
+    var fancy = renderFancyMenuItem;
+    var card = renderCardMenuItem;
+
+    var FocusMode;
+    (function (FocusMode) {
+      FocusMode[FocusMode['ContentFocus'] = 0] = 'ContentFocus';
+      FocusMode[FocusMode['UiFocus'] = 1] = 'UiFocus';
+    }(FocusMode || (FocusMode = {})));
+    var createMenuItemFromBridge = function (item, itemResponse, backstage, menuHasIcons, isHorizontalMenu) {
+      var providersBackstage = backstage.shared.providers;
+      var parseForHorizontalMenu = function (menuitem) {
+        return !isHorizontalMenu ? menuitem : __assign(__assign({}, menuitem), {
+          shortcut: Optional.none(),
+          icon: menuitem.text.isSome() ? Optional.none() : menuitem.icon
+        });
+      };
+      switch (item.type) {
+      case 'menuitem':
+        return createMenuItem(item).fold(handleError, function (d) {
+          return Optional.some(normal(parseForHorizontalMenu(d), itemResponse, providersBackstage, menuHasIcons));
+        });
+      case 'nestedmenuitem':
+        return createNestedMenuItem(item).fold(handleError, function (d) {
+          return Optional.some(nested(parseForHorizontalMenu(d), itemResponse, providersBackstage, menuHasIcons, isHorizontalMenu));
+        });
+      case 'togglemenuitem':
+        return createToggleMenuItem(item).fold(handleError, function (d) {
+          return Optional.some(toggle$1(parseForHorizontalMenu(d), itemResponse, providersBackstage, menuHasIcons));
+        });
+      case 'separator':
+        return createSeparatorMenuItem(item).fold(handleError, function (d) {
+          return Optional.some(separator$3(d));
+        });
+      case 'fancymenuitem':
+        return createFancyMenuItem(item).fold(handleError, function (d) {
+          return fancy(parseForHorizontalMenu(d), backstage);
+        });
+      default: {
+          console.error('Unknown item in general menu', item);
+          return Optional.none();
+        }
+      }
+    };
+    var createAutocompleteItems = function (items, matchText, onItemValueHandler, columns, itemResponse, sharedBackstage, highlightOn) {
+      var renderText = columns === 1;
+      var renderIcons = !renderText || menuHasIcons(items);
+      return cat(map$2(items, function (item) {
+        switch (item.type) {
+        case 'separator':
+          return createSeparatorItem(item).fold(handleError, function (d) {
+            return Optional.some(separator$3(d));
+          });
+        case 'cardmenuitem':
+          return createCardMenuItem(item).fold(handleError, function (d) {
+            return Optional.some(card(__assign(__assign({}, d), {
+              onAction: function (api) {
+                d.onAction(api);
+                onItemValueHandler(d.value, d.meta);
+              }
+            }), itemResponse, sharedBackstage, {
+              itemBehaviours: tooltipBehaviour(d.meta, sharedBackstage),
+              cardText: {
+                matchText: matchText,
+                highlightOn: highlightOn
+              }
+            }));
+          });
+        case 'autocompleteitem':
+        default:
+          return createAutocompleterItem(item).fold(handleError, function (d) {
+            return Optional.some(autocomplete(d, matchText, renderText, 'normal', onItemValueHandler, itemResponse, sharedBackstage, renderIcons));
+          });
+        }
+      }));
+    };
+    var createPartialMenu = function (value, items, itemResponse, backstage, isHorizontalMenu) {
+      var hasIcons = menuHasIcons(items);
+      var alloyItems = cat(map$2(items, function (item) {
+        var itemHasIcon = function (i) {
+          return isHorizontalMenu ? !has$2(i, 'text') : hasIcons;
+        };
+        var createItem = function (i) {
+          return createMenuItemFromBridge(i, itemResponse, backstage, itemHasIcon(i), isHorizontalMenu);
+        };
+        if (item.type === 'nestedmenuitem' && item.getSubmenuItems().length <= 0) {
+          return createItem(__assign(__assign({}, item), { disabled: true }));
+        } else {
+          return createItem(item);
+        }
+      }));
+      var createPartial = isHorizontalMenu ? createHorizontalPartialMenuWithAlloyItems : createPartialMenuWithAlloyItems;
+      return createPartial(value, hasIcons, alloyItems, 1, 'normal');
+    };
+    var createTieredDataFrom = function (partialMenu) {
+      return tieredMenu.singleData(partialMenu.value, partialMenu);
+    };
+    var createMenuFrom = function (partialMenu, columns, focusMode, presets) {
+      var focusManager = focusMode === FocusMode.ContentFocus ? highlights() : dom$2();
+      var movement = deriveMenuMovement(columns, presets);
+      var menuMarkers = markers(presets);
+      return {
+        dom: partialMenu.dom,
+        components: partialMenu.components,
+        items: partialMenu.items,
+        value: partialMenu.value,
+        markers: {
+          selectedItem: menuMarkers.selectedItem,
+          item: menuMarkers.item
+        },
+        movement: movement,
+        fakeFocus: focusMode === FocusMode.ContentFocus,
+        focusManager: focusManager,
+        menuBehaviours: SimpleBehaviours.unnamedEvents(columns !== 'auto' ? [] : [runOnAttached(function (comp, _se) {
+            detectSize(comp, 4, menuMarkers.item).each(function (_a) {
+              var numColumns = _a.numColumns, numRows = _a.numRows;
+              Keying.setGridSize(comp, numRows, numColumns);
+            });
+          })])
+      };
+    };
+
+    var register$9 = function (editor, sharedBackstage) {
+      var activeAutocompleter = value$1();
+      var processingAction = Cell(false);
+      var autocompleter = build$1(InlineView.sketch({
+        dom: {
+          tag: 'div',
+          classes: ['tox-autocompleter']
+        },
+        components: [],
+        fireDismissalEventInstead: {},
+        inlineBehaviours: derive$1([config('dismissAutocompleter', [run$1(dismissRequested(), function () {
+              return cancelIfNecessary();
+            })])]),
+        lazySink: sharedBackstage.getSink
+      }));
+      var isMenuOpen = function () {
+        return InlineView.isOpen(autocompleter);
+      };
+      var isActive = function () {
+        return activeAutocompleter.get().isSome();
+      };
+      var hideIfNecessary = function () {
+        if (isActive()) {
+          InlineView.hide(autocompleter);
+        }
+      };
+      var cancelIfNecessary = function () {
+        if (isActive()) {
+          var lastElement = activeAutocompleter.get().map(function (ac) {
+            return ac.element;
+          });
+          detect(lastElement.getOr(SugarElement.fromDom(editor.selection.getNode()))).each(unwrap);
+          hideIfNecessary();
+          activeAutocompleter.clear();
+          processingAction.set(false);
+        }
+      };
+      var getAutocompleters = cached(function () {
+        return register$b(editor);
+      });
+      var getCombinedItems = function (triggerChar, matches) {
+        var columns = findMap(matches, function (m) {
+          return Optional.from(m.columns);
+        }).getOr(1);
+        return bind$3(matches, function (match) {
+          var choices = match.items;
+          return createAutocompleteItems(choices, match.matchText, function (itemValue, itemMeta) {
+            var nr = editor.selection.getRng();
+            getContext(editor.dom, nr, triggerChar).fold(function () {
+              return console.error('Lost context. Cursor probably moved');
+            }, function (_a) {
+              var range = _a.range;
+              var autocompleterApi = {
+                hide: function () {
+                  cancelIfNecessary();
+                },
+                reload: function (fetchOptions) {
+                  hideIfNecessary();
+                  load(fetchOptions);
+                }
+              };
+              processingAction.set(true);
+              match.onAction(autocompleterApi, range, itemValue, itemMeta);
+              processingAction.set(false);
+            });
+          }, columns, ItemResponse$1.BUBBLE_TO_SANDBOX, sharedBackstage, match.highlightOn);
+        });
+      };
+      var commenceIfNecessary = function (context) {
+        if (!isActive()) {
+          var wrapper = create$5(editor, context.range);
+          activeAutocompleter.set({
+            triggerChar: context.triggerChar,
+            element: wrapper,
+            matchLength: context.text.length
+          });
+          processingAction.set(false);
+        }
+      };
+      var display = function (ac, context, lookupData, items) {
+        ac.matchLength = context.text.length;
+        var columns = findMap(lookupData, function (ld) {
+          return Optional.from(ld.columns);
+        }).getOr(1);
+        InlineView.showAt(autocompleter, Menu.sketch(createMenuFrom(createPartialMenuWithAlloyItems('autocompleter-value', true, items, columns, 'normal'), columns, FocusMode.ContentFocus, 'normal')), {
+          anchor: {
+            type: 'node',
+            root: SugarElement.fromDom(editor.getBody()),
+            node: Optional.from(ac.element)
+          }
+        });
+        InlineView.getContent(autocompleter).each(Highlighting.highlightFirst);
+      };
+      var doLookup = function (fetchOptions) {
+        return activeAutocompleter.get().map(function (ac) {
+          return getContext(editor.dom, editor.selection.getRng(), ac.triggerChar).bind(function (newContext) {
+            return lookupWithContext(editor, getAutocompleters, newContext, fetchOptions);
+          });
+        }).getOrThunk(function () {
+          return lookup$2(editor, getAutocompleters);
+        });
+      };
+      var load = function (fetchOptions) {
+        doLookup(fetchOptions).fold(cancelIfNecessary, function (lookupInfo) {
+          commenceIfNecessary(lookupInfo.context);
+          lookupInfo.lookupData.then(function (lookupData) {
+            activeAutocompleter.get().map(function (ac) {
+              var context = lookupInfo.context;
+              if (ac.triggerChar === context.triggerChar) {
+                var combinedItems = getCombinedItems(context.triggerChar, lookupData);
+                if (combinedItems.length > 0) {
+                  display(ac, context, lookupData, combinedItems);
+                } else if (context.text.length - ac.matchLength >= 10) {
+                  cancelIfNecessary();
+                } else {
+                  hideIfNecessary();
+                }
+              }
+            });
+          });
+        });
+      };
+      var onKeypress = last(function (e) {
+        if (e.which === 27) {
+          return;
+        }
+        load();
+      }, 50);
+      var autocompleterUiApi = {
+        onKeypress: onKeypress,
+        cancelIfNecessary: cancelIfNecessary,
+        isMenuOpen: isMenuOpen,
+        isActive: isActive,
+        isProcessingAction: processingAction.get,
+        getView: function () {
+          return InlineView.getContent(autocompleter);
+        }
+      };
+      if (editor.hasPlugin('rtc') === false) {
+        AutocompleterEditorEvents.setup(autocompleterUiApi, editor);
+      }
+    };
+    var Autocompleter = { register: register$9 };
+
+    var closest = function (scope, selector, isRoot) {
+      return closest$1(scope, selector, isRoot).isSome();
+    };
+
+    var DelayedFunction = function (fun, delay) {
+      var ref = null;
+      var schedule = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        ref = setTimeout(function () {
+          fun.apply(null, args);
+          ref = null;
+        }, delay);
+      };
+      var cancel = function () {
+        if (ref !== null) {
+          clearTimeout(ref);
+          ref = null;
+        }
+      };
+      return {
+        cancel: cancel,
+        schedule: schedule
+      };
+    };
+
+    var SIGNIFICANT_MOVE = 5;
+    var LONGPRESS_DELAY = 400;
+    var getTouch = function (event) {
+      var raw = event.raw;
+      if (raw.touches === undefined || raw.touches.length !== 1) {
+        return Optional.none();
+      }
+      return Optional.some(raw.touches[0]);
+    };
+    var isFarEnough = function (touch, data) {
+      var distX = Math.abs(touch.clientX - data.x);
+      var distY = Math.abs(touch.clientY - data.y);
+      return distX > SIGNIFICANT_MOVE || distY > SIGNIFICANT_MOVE;
+    };
+    var monitor = function (settings) {
+      var startData = value$1();
+      var longpressFired = Cell(false);
+      var longpress$1 = DelayedFunction(function (event) {
+        settings.triggerEvent(longpress(), event);
+        longpressFired.set(true);
+      }, LONGPRESS_DELAY);
+      var handleTouchstart = function (event) {
+        getTouch(event).each(function (touch) {
+          longpress$1.cancel();
+          var data = {
+            x: touch.clientX,
+            y: touch.clientY,
+            target: event.target
+          };
+          longpress$1.schedule(event);
+          longpressFired.set(false);
+          startData.set(data);
+        });
+        return Optional.none();
+      };
+      var handleTouchmove = function (event) {
+        longpress$1.cancel();
+        getTouch(event).each(function (touch) {
+          startData.on(function (data) {
+            if (isFarEnough(touch, data)) {
+              startData.clear();
+            }
+          });
+        });
+        return Optional.none();
+      };
+      var handleTouchend = function (event) {
+        longpress$1.cancel();
+        var isSame = function (data) {
+          return eq(data.target, event.target);
+        };
+        return startData.get().filter(isSame).map(function (_data) {
+          if (longpressFired.get()) {
+            event.prevent();
+            return false;
+          } else {
+            return settings.triggerEvent(tap(), event);
+          }
+        });
+      };
+      var handlers = wrapAll([
+        {
+          key: touchstart(),
+          value: handleTouchstart
+        },
+        {
+          key: touchmove(),
+          value: handleTouchmove
+        },
+        {
+          key: touchend(),
+          value: handleTouchend
+        }
+      ]);
+      var fireIfReady = function (event, type) {
+        return get$e(handlers, type).bind(function (handler) {
+          return handler(event);
+        });
+      };
+      return { fireIfReady: fireIfReady };
+    };
+
+    var isDangerous = function (event) {
+      var keyEv = event.raw;
+      return keyEv.which === BACKSPACE[0] && !contains$2([
+        'input',
+        'textarea'
+      ], name$2(event.target)) && !closest(event.target, '[contenteditable="true"]');
+    };
+    var isFirefox = function () {
+      return detect$1().browser.isFirefox();
+    };
+    var bindFocus = function (container, handler) {
+      if (isFirefox()) {
+        return capture(container, 'focus', handler);
+      } else {
+        return bind(container, 'focusin', handler);
+      }
+    };
+    var bindBlur = function (container, handler) {
+      if (isFirefox()) {
+        return capture(container, 'blur', handler);
+      } else {
+        return bind(container, 'focusout', handler);
+      }
+    };
+    var setup$d = function (container, rawSettings) {
+      var settings = __assign({ stopBackspace: true }, rawSettings);
+      var pointerEvents = [
+        'touchstart',
+        'touchmove',
+        'touchend',
+        'touchcancel',
+        'gesturestart',
+        'mousedown',
+        'mouseup',
+        'mouseover',
+        'mousemove',
+        'mouseout',
+        'click'
+      ];
+      var tapEvent = monitor(settings);
+      var simpleEvents = map$2(pointerEvents.concat([
+        'selectstart',
+        'input',
+        'contextmenu',
+        'change',
+        'transitionend',
+        'transitioncancel',
+        'drag',
+        'dragstart',
+        'dragend',
+        'dragenter',
+        'dragleave',
+        'dragover',
+        'drop',
+        'keyup'
+      ]), function (type) {
+        return bind(container, type, function (event) {
+          tapEvent.fireIfReady(event, type).each(function (tapStopped) {
+            if (tapStopped) {
+              event.kill();
+            }
+          });
+          var stopped = settings.triggerEvent(type, event);
+          if (stopped) {
+            event.kill();
+          }
+        });
+      });
+      var pasteTimeout = value$1();
+      var onPaste = bind(container, 'paste', function (event) {
+        tapEvent.fireIfReady(event, 'paste').each(function (tapStopped) {
+          if (tapStopped) {
+            event.kill();
+          }
+        });
+        var stopped = settings.triggerEvent('paste', event);
+        if (stopped) {
+          event.kill();
+        }
+        pasteTimeout.set(setTimeout(function () {
+          settings.triggerEvent(postPaste(), event);
+        }, 0));
+      });
+      var onKeydown = bind(container, 'keydown', function (event) {
+        var stopped = settings.triggerEvent('keydown', event);
+        if (stopped) {
+          event.kill();
+        } else if (settings.stopBackspace && isDangerous(event)) {
+          event.prevent();
+        }
+      });
+      var onFocusIn = bindFocus(container, function (event) {
+        var stopped = settings.triggerEvent('focusin', event);
+        if (stopped) {
+          event.kill();
+        }
+      });
+      var focusoutTimeout = value$1();
+      var onFocusOut = bindBlur(container, function (event) {
+        var stopped = settings.triggerEvent('focusout', event);
+        if (stopped) {
+          event.kill();
+        }
+        focusoutTimeout.set(setTimeout(function () {
+          settings.triggerEvent(postBlur(), event);
+        }, 0));
+      });
+      var unbind = function () {
+        each$1(simpleEvents, function (e) {
+          e.unbind();
+        });
+        onKeydown.unbind();
+        onFocusIn.unbind();
+        onFocusOut.unbind();
+        onPaste.unbind();
+        pasteTimeout.on(clearTimeout);
+        focusoutTimeout.on(clearTimeout);
+      };
+      return { unbind: unbind };
+    };
+
+    var derive = function (rawEvent, rawTarget) {
+      var source = get$e(rawEvent, 'target').getOr(rawTarget);
+      return Cell(source);
+    };
+
+    var fromSource = function (event, source) {
+      var stopper = Cell(false);
+      var cutter = Cell(false);
+      var stop = function () {
+        stopper.set(true);
+      };
+      var cut = function () {
+        cutter.set(true);
+      };
+      return {
+        stop: stop,
+        cut: cut,
+        isStopped: stopper.get,
+        isCut: cutter.get,
+        event: event,
+        setSource: source.set,
+        getSource: source.get
+      };
+    };
+    var fromExternal = function (event) {
+      var stopper = Cell(false);
+      var stop = function () {
+        stopper.set(true);
+      };
+      return {
+        stop: stop,
+        cut: noop,
+        isStopped: stopper.get,
+        isCut: never,
+        event: event,
+        setSource: die('Cannot set source of a broadcasted event'),
+        getSource: die('Cannot get source of a broadcasted event')
+      };
+    };
+
+    var adt$1 = Adt.generate([
+      { stopped: [] },
+      { resume: ['element'] },
+      { complete: [] }
+    ]);
+    var doTriggerHandler = function (lookup, eventType, rawEvent, target, source, logger) {
+      var handler = lookup(eventType, target);
+      var simulatedEvent = fromSource(rawEvent, source);
+      return handler.fold(function () {
+        logger.logEventNoHandlers(eventType, target);
+        return adt$1.complete();
+      }, function (handlerInfo) {
+        var descHandler = handlerInfo.descHandler;
+        var eventHandler = getCurried(descHandler);
+        eventHandler(simulatedEvent);
+        if (simulatedEvent.isStopped()) {
+          logger.logEventStopped(eventType, handlerInfo.element, descHandler.purpose);
+          return adt$1.stopped();
+        } else if (simulatedEvent.isCut()) {
+          logger.logEventCut(eventType, handlerInfo.element, descHandler.purpose);
+          return adt$1.complete();
+        } else {
+          return parent(handlerInfo.element).fold(function () {
+            logger.logNoParent(eventType, handlerInfo.element, descHandler.purpose);
+            return adt$1.complete();
+          }, function (parent) {
+            logger.logEventResponse(eventType, handlerInfo.element, descHandler.purpose);
+            return adt$1.resume(parent);
+          });
+        }
+      });
+    };
+    var doTriggerOnUntilStopped = function (lookup, eventType, rawEvent, rawTarget, source, logger) {
+      return doTriggerHandler(lookup, eventType, rawEvent, rawTarget, source, logger).fold(always, function (parent) {
+        return doTriggerOnUntilStopped(lookup, eventType, rawEvent, parent, source, logger);
+      }, never);
+    };
+    var triggerHandler = function (lookup, eventType, rawEvent, target, logger) {
+      var source = derive(rawEvent, target);
+      return doTriggerHandler(lookup, eventType, rawEvent, target, source, logger);
+    };
+    var broadcast = function (listeners, rawEvent, _logger) {
+      var simulatedEvent = fromExternal(rawEvent);
+      each$1(listeners, function (listener) {
+        var descHandler = listener.descHandler;
+        var handler = getCurried(descHandler);
+        handler(simulatedEvent);
+      });
+      return simulatedEvent.isStopped();
+    };
+    var triggerUntilStopped = function (lookup, eventType, rawEvent, logger) {
+      return triggerOnUntilStopped(lookup, eventType, rawEvent, rawEvent.target, logger);
+    };
+    var triggerOnUntilStopped = function (lookup, eventType, rawEvent, rawTarget, logger) {
+      var source = derive(rawEvent, rawTarget);
+      return doTriggerOnUntilStopped(lookup, eventType, rawEvent, rawTarget, source, logger);
+    };
+
+    var eventHandler = function (element, descHandler) {
+      return {
+        element: element,
+        descHandler: descHandler
+      };
+    };
+    var broadcastHandler = function (id, handler) {
+      return {
+        id: id,
+        descHandler: handler
+      };
+    };
+    var EventRegistry = function () {
+      var registry = {};
+      var registerId = function (extraArgs, id, events) {
+        each(events, function (v, k) {
+          var handlers = registry[k] !== undefined ? registry[k] : {};
+          handlers[id] = curryArgs(v, extraArgs);
+          registry[k] = handlers;
+        });
+      };
+      var findHandler = function (handlers, elem) {
+        return read$1(elem).bind(function (id) {
+          return get$e(handlers, id);
+        }).map(function (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) {
+        return get$e(registry, type).bind(function (handlers) {
+          return closest$4(target, function (elem) {
+            return findHandler(handlers, elem);
+          }, isAboveRoot);
+        });
+      };
+      var unregisterId = function (id) {
+        each(registry, function (handlersById, _eventName) {
+          if (has$2(handlersById, id)) {
+            delete handlersById[id];
+          }
+        });
+      };
+      return {
+        registerId: registerId,
+        unregisterId: unregisterId,
+        filterByType: filterByType,
+        find: find
+      };
+    };
+
+    var Registry = function () {
+      var events = EventRegistry();
+      var components = {};
+      var readOrTag = function (component) {
+        var elem = component.element;
+        return read$1(elem).getOrThunk(function () {
+          return write('uid-', component.element);
+        });
+      };
+      var failOnDuplicate = function (component, tagId) {
+        var conflict = components[tagId];
+        if (conflict === component) {
+          unregister(component);
+        } else {
+          throw new Error('The tagId "' + tagId + '" is already used by: ' + element(conflict.element) + '\nCannot use it for: ' + element(component.element) + '\n' + 'The conflicting element is' + (inBody(conflict.element) ? ' ' : ' not ') + 'already in the DOM');
+        }
+      };
+      var register = function (component) {
+        var tagId = readOrTag(component);
+        if (hasNonNullableKey(components, tagId)) {
+          failOnDuplicate(component, tagId);
+        }
+        var extraArgs = [component];
+        events.registerId(extraArgs, tagId, component.events);
+        components[tagId] = component;
+      };
+      var unregister = function (component) {
+        read$1(component.element).each(function (tagId) {
+          delete components[tagId];
+          events.unregisterId(tagId);
+        });
+      };
+      var filter = function (type) {
+        return events.filterByType(type);
+      };
+      var find = function (isAboveRoot, type, target) {
+        return events.find(isAboveRoot, type, target);
+      };
+      var getById = function (id) {
+        return get$e(components, id);
+      };
+      return {
+        find: find,
+        filter: filter,
+        register: register,
+        unregister: unregister,
+        getById: getById
+      };
+    };
+
+    var factory$j = function (detail) {
+      var _a = detail.dom, attributes = _a.attributes, domWithoutAttributes = __rest(_a, ['attributes']);
+      return {
+        uid: detail.uid,
+        dom: __assign({
+          tag: 'div',
+          attributes: __assign({ role: 'presentation' }, attributes)
+        }, domWithoutAttributes),
+        components: detail.components,
+        behaviours: get$2(detail.containerBehaviours),
+        events: detail.events,
+        domModification: detail.domModification,
+        eventOrder: detail.eventOrder
+      };
+    };
+    var Container = single({
+      name: 'Container',
+      factory: factory$j,
+      configFields: [
+        defaulted('components', []),
+        field('containerBehaviours', []),
+        defaulted('events', {}),
+        defaulted('domModification', {}),
+        defaulted('eventOrder', {})
+      ]
+    });
+
+    var takeover = function (root) {
+      var isAboveRoot = function (el) {
+        return parent(root.element).fold(always, function (parent) {
+          return eq(el, parent);
+        });
+      };
+      var registry = Registry();
+      var lookup = function (eventName, target) {
+        return registry.find(isAboveRoot, eventName, target);
+      };
+      var domEvents = setup$d(root.element, {
+        triggerEvent: function (eventName, event) {
+          return monitorEvent(eventName, event.target, function (logger) {
+            return triggerUntilStopped(lookup, eventName, event, logger);
+          });
+        }
+      });
+      var systemApi = {
+        debugInfo: constant$1('real'),
+        triggerEvent: function (eventName, target, data) {
+          monitorEvent(eventName, target, function (logger) {
+            return triggerOnUntilStopped(lookup, eventName, data, target, logger);
+          });
+        },
+        triggerFocus: function (target, originator) {
+          read$1(target).fold(function () {
+            focus$3(target);
+          }, function (_alloyId) {
+            monitorEvent(focus$4(), target, function (logger) {
+              triggerHandler(lookup, focus$4(), {
+                originator: originator,
+                kill: noop,
+                prevent: noop,
+                target: target
+              }, target, logger);
+              return false;
+            });
+          });
+        },
+        triggerEscape: function (comp, simulatedEvent) {
+          systemApi.triggerEvent('keydown', comp.element, simulatedEvent.event);
+        },
+        getByUid: function (uid) {
+          return getByUid(uid);
+        },
+        getByDom: function (elem) {
+          return getByDom(elem);
+        },
+        build: build$1,
+        addToGui: function (c) {
+          add(c);
+        },
+        removeFromGui: function (c) {
+          remove(c);
+        },
+        addToWorld: function (c) {
+          addToWorld(c);
+        },
+        removeFromWorld: function (c) {
+          removeFromWorld(c);
+        },
+        broadcast: function (message) {
+          broadcast$1(message);
+        },
+        broadcastOn: function (channels, message) {
+          broadcastOn(channels, message);
+        },
+        broadcastEvent: function (eventName, event) {
+          broadcastEvent(eventName, event);
+        },
+        isConnected: always
+      };
+      var addToWorld = function (component) {
+        component.connect(systemApi);
+        if (!isText$1(component.element)) {
+          registry.register(component);
+          each$1(component.components(), addToWorld);
+          systemApi.triggerEvent(systemInit(), component.element, { target: component.element });
+        }
+      };
+      var removeFromWorld = function (component) {
+        if (!isText$1(component.element)) {
+          each$1(component.components(), removeFromWorld);
+          registry.unregister(component);
+        }
+        component.disconnect();
+      };
+      var add = function (component) {
+        attach(root, component);
+      };
+      var remove = function (component) {
+        detach(component);
+      };
+      var destroy = function () {
+        domEvents.unbind();
+        remove$5(root.element);
+      };
+      var broadcastData = function (data) {
+        var receivers = registry.filter(receive());
+        each$1(receivers, function (receiver) {
+          var descHandler = receiver.descHandler;
+          var handler = getCurried(descHandler);
+          handler(data);
+        });
+      };
+      var broadcast$1 = function (message) {
+        broadcastData({
+          universal: true,
+          data: message
+        });
+      };
+      var broadcastOn = function (channels, message) {
+        broadcastData({
+          universal: false,
+          channels: channels,
+          data: message
+        });
+      };
+      var broadcastEvent = function (eventName, event) {
+        var listeners = registry.filter(eventName);
+        return broadcast(listeners, event);
+      };
+      var getByUid = function (uid) {
+        return registry.getById(uid).fold(function () {
+          return Result.error(new Error('Could not find component with uid: "' + uid + '" in system.'));
+        }, Result.value);
+      };
+      var getByDom = function (elem) {
+        var uid = read$1(elem).getOr('not found');
+        return getByUid(uid);
+      };
+      addToWorld(root);
+      return {
+        root: root,
+        element: root.element,
+        destroy: destroy,
+        add: add,
+        remove: remove,
+        getByUid: getByUid,
+        getByDom: getByDom,
+        addToWorld: addToWorld,
+        removeFromWorld: removeFromWorld,
+        broadcast: broadcast$1,
+        broadcastOn: broadcastOn,
+        broadcastEvent: broadcastEvent
+      };
+    };
+
+    var renderBar = function (spec, backstage) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: [
+            'tox-bar',
+            'tox-form__controls-h-stack'
+          ]
+        },
+        components: map$2(spec.items, backstage.interpreter)
+      };
+    };
+
+    var schema$l = constant$1([
+      defaulted('prefix', 'form-field'),
+      field('fieldBehaviours', [
+        Composing,
+        Representing
+      ])
+    ]);
+    var parts$e = constant$1([
+      optional({
+        schema: [required$1('dom')],
+        name: 'label'
+      }),
+      optional({
+        factory: {
+          sketch: function (spec) {
+            return {
+              uid: spec.uid,
+              dom: {
+                tag: 'span',
+                styles: { display: 'none' },
+                attributes: { 'aria-hidden': 'true' },
+                innerHtml: spec.text
+              }
+            };
+          }
+        },
+        schema: [required$1('text')],
+        name: 'aria-descriptor'
+      }),
+      required({
+        factory: {
+          sketch: function (spec) {
+            var excludeFactory = exclude(spec, ['factory']);
+            return spec.factory.sketch(excludeFactory);
+          }
+        },
+        schema: [required$1('factory')],
+        name: 'field'
+      })
+    ]);
+
+    var factory$i = function (detail, components, _spec, _externals) {
+      var behaviours = augment(detail.fieldBehaviours, [
+        Composing.config({
+          find: function (container) {
+            return getPart(container, detail, 'field');
+          }
+        }),
+        Representing.config({
+          store: {
+            mode: 'manual',
+            getValue: function (field) {
+              return Composing.getCurrent(field).bind(Representing.getValue);
+            },
+            setValue: function (field, value) {
+              Composing.getCurrent(field).each(function (current) {
+                Representing.setValue(current, value);
+              });
+            }
+          }
+        })
+      ]);
+      var events = derive$2([runOnAttached(function (component, _simulatedEvent) {
+          var ps = getParts(component, detail, [
+            'label',
+            'field',
+            'aria-descriptor'
+          ]);
+          ps.field().each(function (field) {
+            var id = generate$6(detail.prefix);
+            ps.label().each(function (label) {
+              set$8(label.element, 'for', id);
+              set$8(field.element, 'id', id);
+            });
+            ps['aria-descriptor']().each(function (descriptor) {
+              var descriptorId = generate$6(detail.prefix);
+              set$8(descriptor.element, 'id', descriptorId);
+              set$8(field.element, 'aria-describedby', descriptorId);
+            });
+          });
+        })]);
+      var apis = {
+        getField: function (container) {
+          return getPart(container, detail, 'field');
+        },
+        getLabel: function (container) {
+          return getPart(container, detail, 'label');
+        }
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: behaviours,
+        events: events,
+        apis: apis
+      };
+    };
+    var FormField = composite({
+      name: 'FormField',
+      configFields: schema$l(),
+      partFields: parts$e(),
+      factory: factory$i,
+      apis: {
+        getField: function (apis, comp) {
+          return apis.getField(comp);
+        },
+        getLabel: function (apis, comp) {
+          return apis.getLabel(comp);
+        }
+      }
+    });
+
+    var exhibit$2 = function (base, tabConfig) {
+      return nu$7({
+        attributes: wrapAll([{
+            key: tabConfig.tabAttr,
+            value: 'true'
+          }])
+      });
+    };
+
+    var ActiveTabstopping = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit$2
+    });
+
+    var TabstopSchema = [defaulted('tabAttr', 'data-alloy-tabstop')];
+
+    var Tabstopping = create$8({
+      fields: TabstopSchema,
+      name: 'tabstopping',
+      active: ActiveTabstopping
+    });
+
+    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);
+    };
+    var renderFormField = function (pLabel, pField) {
+      return renderFormFieldWith(pLabel, pField, [], []);
+    };
+    var renderFormFieldSpecWith = function (pLabel, pField, extraClasses, extraBehaviours) {
+      return {
+        dom: renderFormFieldDomWith(extraClasses),
+        components: pLabel.toArray().concat([pField]),
+        fieldBehaviours: derive$1(extraBehaviours)
+      };
+    };
+    var renderFormFieldDom = function () {
+      return renderFormFieldDomWith([]);
+    };
+    var renderFormFieldDomWith = function (extraClasses) {
+      return {
+        tag: 'div',
+        classes: ['tox-form__group'].concat(extraClasses)
+      };
+    };
+    var renderLabel$2 = function (label, providersBackstage) {
+      return FormField.parts.label({
+        dom: {
+          tag: 'label',
+          classes: ['tox-label'],
+          innerHtml: providersBackstage.translate(label)
+        }
+      });
+    };
+
+    var formChangeEvent = generate$6('form-component-change');
+    var formCloseEvent = generate$6('form-close');
+    var formCancelEvent = generate$6('form-cancel');
+    var formActionEvent = generate$6('form-action');
+    var formSubmitEvent = generate$6('form-submit');
+    var formBlockEvent = generate$6('form-block');
+    var formUnblockEvent = generate$6('form-unblock');
+    var formTabChangeEvent = generate$6('form-tabchange');
+    var formResizeEvent = generate$6('form-resize');
+
+    var renderCollection = function (spec, providersBackstage) {
+      var _a;
+      var pLabel = spec.label.map(function (label) {
+        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$d(target, 'data-collection-item-value'));
+          });
+        };
+      };
+      var setContents = function (comp, items) {
+        var htmlLines = map$2(items, function (item) {
+          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$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$5(comp.element, html.join(''));
+      };
+      var onClick = runOnItem(function (comp, se, tgt, itemValue) {
+        se.stop();
+        if (!providersBackstage.isDisabled()) {
+          emitWith(comp, formActionEvent, {
+            name: spec.name,
+            value: itemValue
+          });
+        }
+      });
+      var collectionEvents = [
+        run$1(mouseover(), runOnItem(function (comp, se, tgt) {
+          focus$3(tgt);
+        })),
+        run$1(click(), onClick),
+        run$1(tap(), onClick),
+        run$1(focusin(), runOnItem(function (comp, se, tgt) {
+          descendant(comp.element, '.' + activeClass).each(function (currentActive) {
+            remove$2(currentActive, activeClass);
+          });
+          add$2(tgt, activeClass);
+        })),
+        run$1(focusout(), runOnItem(function (comp) {
+          descendant(comp.element, '.' + activeClass).each(function (currentActive) {
+            remove$2(currentActive, activeClass);
+          });
+        })),
+        runOnExecute$1(runOnItem(function (comp, se, tgt, itemValue) {
+          emitWith(comp, formActionEvent, {
+            name: spec.name,
+            value: itemValue
+          });
+        }))
+      ];
+      var iterCollectionItems = function (comp, applyAttributes) {
+        return map$2(descendants(comp.element, '.tox-collection__item'), applyAttributes);
+      };
+      var pField = FormField.parts.field({
+        dom: {
+          tag: 'div',
+          classes: ['tox-collection'].concat(spec.columns !== 1 ? ['tox-collection--grid'] : ['tox-collection--list'])
+        },
+        components: [],
+        factory: { sketch: identity$1 },
+        behaviours: derive$1([
+          Disabling.config({
+            disabled: providersBackstage.isDisabled,
+            onDisabled: function (comp) {
+              iterCollectionItems(comp, function (childElm) {
+                add$2(childElm, 'tox-collection__item--state-disabled');
+                set$8(childElm, 'aria-disabled', true);
+              });
+            },
+            onEnabled: function (comp) {
+              iterCollectionItems(comp, function (childElm) {
+                remove$2(childElm, 'tox-collection__item--state-disabled');
+                remove$7(childElm, 'aria-disabled');
+              });
+            }
+          }),
+          receivingConfig(),
+          Replacing.config({}),
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: []
+            },
+            onSetValue: function (comp, items) {
+              setContents(comp, items);
+              if (spec.columns === 'auto') {
+                detectSize(comp, 5, 'tox-collection__item').each(function (_a) {
+                  var numRows = _a.numRows, numColumns = _a.numColumns;
+                  Keying.setGridSize(comp, numRows, numColumns);
+                });
+              }
+              emit(comp, formResizeEvent);
+            }
+          }),
+          Tabstopping.config({}),
+          Keying.config(deriveCollectionMovement(spec.columns, 'normal')),
+          config('collection-events', collectionEvents)
+        ]),
+        eventOrder: (_a = {}, _a[execute$5()] = [
+          'disabling',
+          'alloy.base.behaviour',
+          'collection-events'
+        ], _a)
+      });
+      var extraClasses = ['tox-form__group--collection'];
+      return renderFormFieldWith(pLabel, pField, extraClasses, []);
+    };
+
+    var schema$k = constant$1([
+      option('data'),
+      defaulted('inputAttributes', {}),
+      defaulted('inputStyles', {}),
+      defaulted('tag', 'input'),
+      defaulted('inputClasses', []),
+      onHandler('onSetValue'),
+      defaulted('styles', {}),
+      defaulted('eventOrder', {}),
+      field('inputBehaviours', [
+        Representing,
+        Focusing
+      ]),
+      defaulted('selectOnFocus', true)
+    ]);
+    var focusBehaviours = function (detail) {
+      return derive$1([Focusing.config({
+          onFocus: !detail.selectOnFocus ? noop : function (component) {
+            var input = component.element;
+            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$5(input.element);
+            },
+            setValue: function (input, data) {
+              var current = get$5(input.element);
+              if (current !== data) {
+                set$4(input.element, data);
+              }
+            }
+          }),
+          onSetValue: detail.onSetValue
+        })]));
+    };
+    var dom = function (detail) {
+      return {
+        tag: detail.tag,
+        attributes: __assign({ type: 'text' }, detail.inputAttributes),
+        styles: detail.inputStyles,
+        classes: detail.inputClasses
+      };
+    };
+
+    var factory$h = function (detail, _spec) {
+      return {
+        uid: detail.uid,
+        dom: dom(detail),
+        components: [],
+        behaviours: behaviours(detail),
+        eventOrder: detail.eventOrder
+      };
+    };
+    var Input = single({
+      name: 'Input',
+      configFields: schema$k(),
+      factory: factory$h
+    });
+
+    var exports$1 = {}, module = { exports: exports$1 };
+    (function (define, exports, module, require) {
+      (function (global, factory) {
+        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());
+      }(this, function () {
+        var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+        var promise = { exports: {} };
+        (function (module) {
+          (function (root) {
+            var setTimeoutFunc = setTimeout;
+            function noop() {
+            }
+            function bind(fn, thisArg) {
+              return function () {
+                fn.apply(thisArg, arguments);
+              };
+            }
+            function Promise(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 = 0;
+              this._handled = false;
+              this._value = undefined;
+              this._deferreds = [];
+              doResolve(fn, this);
+            }
+            function handle(self, deferred) {
+              while (self._state === 3) {
+                self = self._value;
+              }
+              if (self._state === 0) {
+                self._deferreds.push(deferred);
+                return;
+              }
+              self._handled = true;
+              Promise._immediateFn(function () {
+                var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
+                if (cb === null) {
+                  (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
+                  return;
+                }
+                var ret;
+                try {
+                  ret = cb(self._value);
+                } catch (e) {
+                  reject(deferred.promise, e);
+                  return;
+                }
+                resolve(deferred.promise, ret);
+              });
+            }
+            function resolve(self, newValue) {
+              try {
+                if (newValue === self)
+                  throw new TypeError('A promise cannot be resolved with itself.');
+                if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+                  var then = newValue.then;
+                  if (newValue instanceof Promise) {
+                    self._state = 3;
+                    self._value = newValue;
+                    finale(self);
+                    return;
+                  } else if (typeof then === 'function') {
+                    doResolve(bind(then, newValue), self);
+                    return;
+                  }
+                }
+                self._state = 1;
+                self._value = newValue;
+                finale(self);
+              } catch (e) {
+                reject(self, e);
+              }
+            }
+            function reject(self, newValue) {
+              self._state = 2;
+              self._value = newValue;
+              finale(self);
+            }
+            function finale(self) {
+              if (self._state === 2 && self._deferreds.length === 0) {
+                Promise._immediateFn(function () {
+                  if (!self._handled) {
+                    Promise._unhandledRejectionFn(self._value);
+                  }
+                });
+              }
+              for (var i = 0, len = self._deferreds.length; i < len; i++) {
+                handle(self, self._deferreds[i]);
+              }
+              self._deferreds = null;
+            }
+            function Handler(onFulfilled, onRejected, promise) {
+              this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+              this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+              this.promise = promise;
+            }
+            function doResolve(fn, self) {
+              var done = false;
+              try {
+                fn(function (value) {
+                  if (done)
+                    return;
+                  done = true;
+                  resolve(self, value);
+                }, function (reason) {
+                  if (done)
+                    return;
+                  done = true;
+                  reject(self, reason);
+                });
+              } catch (ex) {
+                if (done)
+                  return;
+                done = true;
+                reject(self, ex);
+              }
+            }
+            Promise.prototype['catch'] = function (onRejected) {
+              return this.then(null, onRejected);
+            };
+            Promise.prototype.then = function (onFulfilled, onRejected) {
+              var prom = new this.constructor(noop);
+              handle(this, new Handler(onFulfilled, onRejected, prom));
+              return prom;
+            };
+            Promise.all = function (arr) {
+              var args = Array.prototype.slice.call(arr);
+              return new Promise(function (resolve, reject) {
+                if (args.length === 0)
+                  return resolve([]);
+                var remaining = args.length;
+                function res(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 (value) {
+              return new Promise(function (resolve, reject) {
+                reject(value);
+              });
+            };
+            Promise.race = function (values) {
+              return new Promise(function (resolve, reject) {
+                for (var i = 0, len = values.length; i < len; i++) {
+                  values[i].then(resolve, reject);
+                }
+              });
+            };
+            Promise._immediateFn = typeof setImmediate === 'function' ? function (fn) {
+              setImmediate(fn);
+            } : function (fn) {
+              setTimeoutFunc(fn, 0);
+            };
+            Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
+              if (typeof console !== 'undefined' && console) {
+                console.warn('Possible Unhandled Promise Rejection:', err);
+              }
+            };
+            Promise._setImmediateFn = function _setImmediateFn(fn) {
+              Promise._immediateFn = fn;
+            };
+            Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
+              Promise._unhandledRejectionFn = fn;
+            };
+            if (module.exports) {
+              module.exports = Promise;
+            } else if (!root.Promise) {
+              root.Promise = Promise;
+            }
+          }(commonjsGlobal));
+        }(promise));
+        var promisePolyfill = promise.exports;
+        var Global = function () {
+          if (typeof window !== 'undefined') {
+            return window;
+          } else {
+            return Function('return this;')();
+          }
+        }();
+        var promisePolyfill_1 = { boltExport: Global.Promise || promisePolyfill };
+        return promisePolyfill_1;
+      }));
+    }(undefined, exports$1, module));
+    var Promise$1 = module.exports.boltExport;
+
+    var nu$3 = function (baseFn) {
+      var data = Optional.none();
+      var callbacks = [];
+      var map = function (f) {
+        return nu$3(function (nCallback) {
+          get(function (data) {
+            nCallback(f(data));
+          });
+        });
+      };
+      var get = function (nCallback) {
+        if (isReady()) {
+          call(nCallback);
+        } else {
+          callbacks.push(nCallback);
+        }
+      };
+      var set = function (x) {
+        if (!isReady()) {
+          data = Optional.some(x);
+          run(callbacks);
+          callbacks = [];
+        }
+      };
+      var isReady = function () {
+        return data.isSome();
+      };
+      var run = function (cbs) {
+        each$1(cbs, call);
+      };
+      var call = function (cb) {
+        data.each(function (x) {
+          setTimeout(function () {
+            cb(x);
+          }, 0);
+        });
+      };
+      baseFn(set);
+      return {
+        get: get,
+        map: map,
+        isReady: isReady
+      };
+    };
+    var pure$1 = function (a) {
+      return nu$3(function (callback) {
+        callback(a);
+      });
+    };
+    var LazyValue = {
+      nu: nu$3,
+      pure: pure$1
+    };
+
+    var errorReporter = function (err) {
+      setTimeout(function () {
+        throw err;
+      }, 0);
+    };
+    var make$5 = function (run) {
+      var get = function (callback) {
+        run().then(callback, errorReporter);
+      };
+      var map = function (fab) {
+        return make$5(function () {
+          return run().then(fab);
+        });
+      };
+      var bind = function (aFutureB) {
+        return make$5(function () {
+          return run().then(function (v) {
+            return aFutureB(v).toPromise();
+          });
+        });
+      };
+      var anonBind = function (futureB) {
+        return make$5(function () {
+          return run().then(function () {
+            return futureB.toPromise();
+          });
+        });
+      };
+      var toLazy = function () {
+        return LazyValue.nu(get);
+      };
+      var toCached = function () {
+        var cache = null;
+        return make$5(function () {
+          if (cache === null) {
+            cache = run();
+          }
+          return cache;
+        });
+      };
+      var toPromise = run;
+      return {
+        map: map,
+        bind: bind,
+        anonBind: anonBind,
+        toLazy: toLazy,
+        toCached: toCached,
+        toPromise: toPromise,
+        get: get
+      };
+    };
+    var nu$2 = function (baseFn) {
+      return make$5(function () {
+        return new Promise$1(baseFn);
+      });
+    };
+    var pure = function (a) {
+      return make$5(function () {
+        return Promise$1.resolve(a);
+      });
+    };
+    var Future = {
+      nu: nu$2,
+      pure: pure
+    };
+
+    var ariaElements = [
+      'input',
+      'textarea'
+    ];
+    var isAriaElement = function (elem) {
+      var name = name$2(elem);
+      return contains$2(ariaElements, name);
+    };
+    var markValid = function (component, invalidConfig) {
+      var elem = invalidConfig.getRoot(component).getOr(component.element);
+      remove$2(elem, invalidConfig.invalidClass);
+      invalidConfig.notify.each(function (notifyInfo) {
+        if (isAriaElement(component.element)) {
+          set$8(component.element, 'aria-invalid', false);
+        }
+        notifyInfo.getContainer(component).each(function (container) {
+          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$8(component.element, 'aria-invalid', true);
+        }
+        notifyInfo.getContainer(component).each(function (container) {
+          set$5(container, text);
+        });
+        notifyInfo.onInvalid(component, text);
+      });
+    };
+    var query = function (component, invalidConfig, _invalidState) {
+      return invalidConfig.validator.fold(function () {
+        return Future.pure(Result.value(true));
+      }, function (validatorInfo) {
+        return validatorInfo.validate(component);
+      });
+    };
+    var run = function (component, invalidConfig, invalidState) {
+      invalidConfig.notify.each(function (notifyInfo) {
+        notifyInfo.onValidate(component);
+      });
+      return query(component, invalidConfig).map(function (valid) {
+        if (component.getSystem().isConnected()) {
+          return valid.fold(function (err) {
+            markInvalid(component, invalidConfig, invalidState, err);
+            return Result.error(err);
+          }, function (v) {
+            markValid(component, invalidConfig);
+            return Result.value(v);
+          });
+        } else {
+          return Result.error('No longer in system');
+        }
+      });
+    };
+    var isInvalid = function (component, invalidConfig) {
+      var elem = invalidConfig.getRoot(component).getOr(component.element);
+      return has(elem, invalidConfig.invalidClass);
+    };
+
+    var InvalidateApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        markValid: markValid,
+        markInvalid: markInvalid,
+        query: query,
+        run: run,
+        isInvalid: isInvalid
+    });
+
+    var events$8 = function (invalidConfig, invalidState) {
+      return invalidConfig.validator.map(function (validatorInfo) {
+        return derive$2([run$1(validatorInfo.onEvent, function (component) {
+            run(component, invalidConfig, invalidState).get(identity$1);
+          })].concat(validatorInfo.validateOnLoad ? [runOnAttached(function (component) {
+            run(component, invalidConfig, invalidState).get(noop);
+          })] : []));
+      }).getOr({});
+    };
+
+    var ActiveInvalidate = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$8
+    });
+
+    var InvalidateSchema = [
+      required$1('invalidClass'),
+      defaulted('getRoot', Optional.none),
+      optionObjOf('notify', [
+        defaulted('aria', 'alert'),
+        defaulted('getContainer', Optional.none),
+        defaulted('validHtml', ''),
+        onHandler('onValid'),
+        onHandler('onInvalid'),
+        onHandler('onValidate')
+      ]),
+      optionObjOf('validator', [
+        required$1('validate'),
+        defaulted('onEvent', 'input'),
+        defaulted('validateOnLoad', true)
+      ])
+    ];
+
+    var Invalidating = create$8({
+      fields: InvalidateSchema,
+      name: 'invalidating',
+      active: ActiveInvalidate,
+      apis: InvalidateApis,
+      extra: {
+        validation: function (validator) {
+          return function (component) {
+            var v = Representing.getValue(component);
+            return Future.pure(validator(v));
+          };
+        }
+      }
+    });
+
+    var getCoupled = function (component, coupleConfig, coupleState, name) {
+      return coupleState.getOrCreate(component, coupleConfig, name);
+    };
+
+    var CouplingApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        getCoupled: getCoupled
+    });
+
+    var CouplingSchema = [requiredOf('others', setOf(Result.value, anyValue()))];
+
+    var init$a = function () {
+      var coupled = {};
+      var getOrCreate = function (component, coupleConfig, name) {
+        var available = keys(coupleConfig.others);
+        if (!available) {
+          throw new Error('Cannot find coupled component: ' + name + '. Known coupled components: ' + JSON.stringify(available, null, 2));
+        } else {
+          return get$e(coupled, name).getOrThunk(function () {
+            var builder = get$e(coupleConfig.others, name).getOrDie('No information found for coupled component: ' + name);
+            var spec = builder(component);
+            var built = component.getSystem().build(spec);
+            coupled[name] = built;
+            return built;
+          });
+        }
+      };
+      var readState = constant$1({});
+      return nu$8({
+        readState: readState,
+        getOrCreate: getOrCreate
+      });
+    };
+
+    var CouplingState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init$a
+    });
+
+    var Coupling = create$8({
+      fields: CouplingSchema,
+      name: 'coupling',
+      apis: CouplingApis,
+      state: CouplingState
+    });
+
+    var suffix = constant$1('sink');
+    var partType$1 = constant$1(optional({
+      name: suffix(),
+      overrides: constant$1({
+        dom: { tag: 'div' },
+        behaviours: derive$1([Positioning.config({ useFixed: always })]),
+        events: derive$2([
+          cutter(keydown()),
+          cutter(mousedown()),
+          cutter(click())
+        ])
+      })
+    }));
+
+    var HighlightOnOpen;
+    (function (HighlightOnOpen) {
+      HighlightOnOpen[HighlightOnOpen['HighlightFirst'] = 0] = 'HighlightFirst';
+      HighlightOnOpen[HighlightOnOpen['HighlightNone'] = 1] = 'HighlightNone';
+    }(HighlightOnOpen || (HighlightOnOpen = {})));
+    var getAnchor = function (detail, component) {
+      var hotspot = detail.getHotspot(component).getOr(component);
+      var type = 'hotspot';
+      var overrides = detail.getAnchorOverrides();
+      return detail.layouts.fold(function () {
+        return {
+          type: type,
+          hotspot: hotspot,
+          overrides: overrides
+        };
+      }, function (layouts) {
+        return {
+          type: type,
+          hotspot: hotspot,
+          overrides: overrides,
+          layouts: layouts
+        };
+      });
+    };
+    var fetch = function (detail, mapFetch, component) {
+      var fetcher = detail.fetch;
+      return fetcher(component).map(mapFetch);
+    };
+    var openF = function (detail, mapFetch, anchor, component, sandbox, externals, highlightOnOpen) {
+      var futureData = fetch(detail, mapFetch, component);
+      var getLazySink = getSink(component, detail);
+      return futureData.map(function (tdata) {
+        return tdata.bind(function (data) {
+          return Optional.from(tieredMenu.sketch(__assign(__assign({}, externals.menu()), {
+            uid: generate$5(''),
+            data: data,
+            highlightImmediately: highlightOnOpen === HighlightOnOpen.HighlightFirst,
+            onOpenMenu: function (tmenu, menu) {
+              var sink = getLazySink().getOrDie();
+              Positioning.position(sink, menu, { anchor: anchor });
+              Sandboxing.decloak(sandbox);
+            },
+            onOpenSubmenu: function (tmenu, item, submenu) {
+              var sink = getLazySink().getOrDie();
+              Positioning.position(sink, submenu, {
+                anchor: {
+                  type: 'submenu',
+                  item: item
+                }
+              });
+              Sandboxing.decloak(sandbox);
+            },
+            onRepositionMenu: function (tmenu, primaryMenu, submenuTriggers) {
+              var sink = getLazySink().getOrDie();
+              Positioning.position(sink, primaryMenu, { anchor: anchor });
+              each$1(submenuTriggers, function (st) {
+                Positioning.position(sink, st.triggeredMenu, {
+                  anchor: {
+                    type: 'submenu',
+                    item: st.triggeringItem
+                  }
+                });
+              });
+            },
+            onEscape: function () {
+              Focusing.focus(component);
+              Sandboxing.close(sandbox);
+              return Optional.some(true);
+            }
+          })));
+        });
+      });
+    };
+    var open = function (detail, mapFetch, hotspot, sandbox, externals, onOpenSync, highlightOnOpen) {
+      var anchor = getAnchor(detail, hotspot);
+      var processed = openF(detail, mapFetch, anchor, hotspot, sandbox, externals, highlightOnOpen);
+      return processed.map(function (tdata) {
+        tdata.fold(function () {
+          if (Sandboxing.isOpen(sandbox)) {
+            Sandboxing.close(sandbox);
+          }
+        }, function (data) {
+          Sandboxing.cloak(sandbox);
+          Sandboxing.open(sandbox, data);
+          onOpenSync(sandbox);
+        });
+        return sandbox;
+      });
+    };
+    var close = function (detail, mapFetch, component, sandbox, _externals, _onOpenSync, _highlightOnOpen) {
+      Sandboxing.close(sandbox);
+      return Future.pure(sandbox);
+    };
+    var togglePopup = function (detail, mapFetch, hotspot, externals, onOpenSync, highlightOnOpen) {
+      var sandbox = Coupling.getCoupled(hotspot, 'sandbox');
+      var showing = Sandboxing.isOpen(sandbox);
+      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$a(hotspot.element);
+      if (useMinWidth) {
+        set$7(menu.element, 'min-width', buttonWidth + 'px');
+      } else {
+        set$6(menu.element, buttonWidth);
+      }
+    };
+    var getSink = function (anyInSystem, sinkDetail) {
+      return anyInSystem.getSystem().getByUid(sinkDetail.uid + '-' + suffix()).map(function (internalSink) {
+        return function () {
+          return Result.value(internalSink);
+        };
+      }).getOrThunk(function () {
+        return sinkDetail.lazySink.fold(function () {
+          return function () {
+            return Result.error(new Error('No internal sink is specified, nor could an external sink be found'));
+          };
+        }, function (lazySinkFn) {
+          return function () {
+            return lazySinkFn(anyInSystem);
+          };
+        });
+      });
+    };
+    var doRepositionMenus = function (sandbox) {
+      Sandboxing.getState(sandbox).each(function (tmenu) {
+        tieredMenu.repositionMenus(tmenu);
+      });
+    };
+    var makeSandbox$1 = function (detail, hotspot, extras) {
+      var ariaOwner = manager();
+      var onOpen = function (component, menu) {
+        var anchor = getAnchor(detail, hotspot);
+        ariaOwner.link(hotspot.element);
+        if (detail.matchWidth) {
+          matchWidth(anchor.hotspot, menu, detail.useMinWidth);
+        }
+        detail.onOpen(anchor, component, menu);
+        if (extras !== undefined && extras.onOpen !== undefined) {
+          extras.onOpen(component, menu);
+        }
+      };
+      var onClose = function (component, menu) {
+        ariaOwner.unlink(hotspot.element);
+        if (extras !== undefined && extras.onClose !== undefined) {
+          extras.onClose(component, menu);
+        }
+      };
+      var lazySink = getSink(hotspot, detail);
+      return {
+        dom: {
+          tag: 'div',
+          classes: detail.sandboxClasses,
+          attributes: {
+            id: ariaOwner.id,
+            role: 'listbox'
+          }
+        },
+        behaviours: SketchBehaviours.augment(detail.sandboxBehaviours, [
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: hotspot
+            }
+          }),
+          Sandboxing.config({
+            onOpen: onOpen,
+            onClose: onClose,
+            isPartOf: function (container, data, queryElem) {
+              return isPartOf$1(data, queryElem) || isPartOf$1(hotspot, queryElem);
+            },
+            getAttachPoint: function () {
+              return lazySink().getOrDie();
+            }
+          }),
+          Composing.config({
+            find: function (sandbox) {
+              return Sandboxing.getState(sandbox).bind(function (menu) {
+                return Composing.getCurrent(menu);
+              });
+            }
+          }),
+          Receiving.config({ channels: __assign(__assign({}, receivingChannel$1({ isExtraPart: never })), receivingChannel({ doReposition: doRepositionMenus })) })
+        ])
+      };
+    };
+    var repositionMenus = function (comp) {
+      var sandbox = Coupling.getCoupled(comp, 'sandbox');
+      doRepositionMenus(sandbox);
+    };
+
+    var sandboxFields = function () {
+      return [
+        defaulted('sandboxClasses', []),
+        SketchBehaviours.field('sandboxBehaviours', [
+          Composing,
+          Receiving,
+          Sandboxing,
+          Representing
+        ])
+      ];
+    };
+
+    var schema$j = constant$1([
+      required$1('dom'),
+      required$1('fetch'),
+      onHandler('onOpen'),
+      onKeyboardHandler('onExecute'),
+      defaulted('getHotspot', Optional.some),
+      defaulted('getAnchorOverrides', constant$1({})),
+      schema$y(),
+      field('dropdownBehaviours', [
+        Toggling,
+        Coupling,
+        Keying,
+        Focusing
+      ]),
+      required$1('toggleClass'),
+      defaulted('eventOrder', {}),
+      option('lazySink'),
+      defaulted('matchWidth', false),
+      defaulted('useMinWidth', false),
+      option('role')
+    ].concat(sandboxFields()));
+    var parts$d = constant$1([
+      external$1({
+        schema: [tieredMenuMarkers()],
+        name: 'menu',
+        defaults: function (detail) {
+          return { onExecute: detail.onExecute };
+        }
+      }),
+      partType$1()
+    ]);
+
+    var factory$g = function (detail, components, _spec, externals) {
+      var _a;
+      var lookupAttr = function (attr) {
+        return get$e(detail.dom, 'attributes').bind(function (attrs) {
+          return get$e(attrs, attr);
+        });
+      };
+      var switchToMenu = function (sandbox) {
+        Sandboxing.getState(sandbox).each(function (tmenu) {
+          tieredMenu.highlightPrimary(tmenu);
+        });
+      };
+      var action = function (component) {
+        var onOpenSync = switchToMenu;
+        togglePopup(detail, identity$1, component, externals, onOpenSync, HighlightOnOpen.HighlightFirst).get(noop);
+      };
+      var apis = {
+        expand: function (comp) {
+          if (!Toggling.isOn(comp)) {
+            togglePopup(detail, identity$1, comp, externals, noop, HighlightOnOpen.HighlightNone).get(noop);
+          }
+        },
+        open: function (comp) {
+          if (!Toggling.isOn(comp)) {
+            togglePopup(detail, identity$1, comp, externals, noop, HighlightOnOpen.HighlightFirst).get(noop);
+          }
+        },
+        isOpen: Toggling.isOn,
+        close: function (comp) {
+          if (Toggling.isOn(comp)) {
+            togglePopup(detail, identity$1, comp, externals, noop, HighlightOnOpen.HighlightFirst).get(noop);
+          }
+        },
+        repositionMenus: function (comp) {
+          if (Toggling.isOn(comp)) {
+            repositionMenus(comp);
+          }
+        }
+      };
+      var triggerExecute = function (comp, _se) {
+        emitExecute(comp);
+        return Optional.some(true);
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: augment(detail.dropdownBehaviours, [
+          Toggling.config({
+            toggleClass: detail.toggleClass,
+            aria: { mode: 'expanded' }
+          }),
+          Coupling.config({
+            others: {
+              sandbox: function (hotspot) {
+                return makeSandbox$1(detail, hotspot, {
+                  onOpen: function () {
+                    return Toggling.on(hotspot);
+                  },
+                  onClose: function () {
+                    return Toggling.off(hotspot);
+                  }
+                });
+              }
+            }
+          }),
+          Keying.config({
+            mode: 'special',
+            onSpace: triggerExecute,
+            onEnter: triggerExecute,
+            onDown: function (comp, _se) {
+              if (Dropdown.isOpen(comp)) {
+                var sandbox = Coupling.getCoupled(comp, 'sandbox');
+                switchToMenu(sandbox);
+              } else {
+                Dropdown.open(comp);
+              }
+              return Optional.some(true);
+            },
+            onEscape: function (comp, _se) {
+              if (Dropdown.isOpen(comp)) {
+                Dropdown.close(comp);
+                return Optional.some(true);
+              } else {
+                return Optional.none();
+              }
+            }
+          }),
+          Focusing.config({})
+        ]),
+        events: events$a(Optional.some(action)),
+        eventOrder: __assign(__assign({}, detail.eventOrder), (_a = {}, _a[execute$5()] = [
+          'disabling',
+          'toggling',
+          'alloy.base.behaviour'
+        ], _a)),
+        apis: apis,
+        domModification: {
+          attributes: __assign(__assign({ 'aria-haspopup': 'true' }, detail.role.fold(function () {
+            return {};
+          }, function (role) {
+            return { role: role };
+          })), detail.dom.tag === 'button' ? { type: lookupAttr('type').getOr('button') } : {})
+        }
+      };
+    };
+    var Dropdown = composite({
+      name: 'Dropdown',
+      configFields: schema$j(),
+      partFields: parts$d(),
+      factory: factory$g,
+      apis: {
+        open: function (apis, comp) {
+          return apis.open(comp);
+        },
+        expand: function (apis, comp) {
+          return apis.expand(comp);
+        },
+        close: function (apis, comp) {
+          return apis.close(comp);
+        },
+        isOpen: function (apis, comp) {
+          return apis.isOpen(comp);
+        },
+        repositionMenus: function (apis, comp) {
+          return apis.repositionMenus(comp);
+        }
+      }
+    });
+
+    var exhibit$1 = function () {
+      return nu$7({
+        styles: {
+          '-webkit-user-select': 'none',
+          'user-select': 'none',
+          '-ms-user-select': 'none',
+          '-moz-user-select': '-moz-none'
+        },
+        attributes: { unselectable: 'on' }
+      });
+    };
+    var events$7 = function () {
+      return derive$2([abort(selectstart(), always)]);
+    };
+
+    var ActiveUnselecting = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$7,
+        exhibit: exhibit$1
+    });
+
+    var Unselecting = create$8({
+      fields: [],
+      name: 'unselecting',
+      active: ActiveUnselecting
+    });
+
+    var renderPanelButton = function (spec, sharedBackstage) {
+      return Dropdown.sketch({
+        dom: spec.dom,
+        components: spec.components,
+        toggleClass: 'mce-active',
+        dropdownBehaviours: derive$1([
+          DisablingConfigs.button(sharedBackstage.providers.isDisabled),
+          receivingConfig(),
+          Unselecting.config({}),
+          Tabstopping.config({})
+        ]),
+        layouts: spec.layouts,
+        sandboxClasses: ['tox-dialog__popups'],
+        lazySink: sharedBackstage.getSink,
+        fetch: function (comp) {
+          return Future.nu(function (callback) {
+            return spec.fetch(callback);
+          }).map(function (items) {
+            return Optional.from(createTieredDataFrom(deepMerge(createPartialChoiceMenu(generate$6('menu-value'), items, function (value) {
+              spec.onItemAction(comp, value);
+            }, spec.columns, spec.presets, ItemResponse$1.CLOSE_ON_EXECUTE, never, sharedBackstage.providers), { movement: deriveMenuMovement(spec.columns, spec.presets) })));
+          });
+        },
+        parts: { menu: part(false, 1, spec.presets) }
+      });
+    };
+
+    var colorInputChangeEvent = generate$6('color-input-change');
+    var colorSwatchChangeEvent = generate$6('color-swatch-change');
+    var colorPickerCancelEvent = generate$6('color-picker-cancel');
+    var renderColorInput = function (spec, sharedBackstage, colorInputBackstage) {
+      var pField = FormField.parts.field({
+        factory: Input,
+        inputClasses: ['tox-textfield'],
+        onSetValue: function (c) {
+          return Invalidating.run(c).get(noop);
+        },
+        inputBehaviours: derive$1([
+          Disabling.config({ disabled: sharedBackstage.providers.isDisabled }),
+          receivingConfig(),
+          Tabstopping.config({}),
+          Invalidating.config({
+            invalidClass: 'tox-textbox-field-invalid',
+            getRoot: function (comp) {
+              return parent(comp.element);
+            },
+            notify: {
+              onValid: function (comp) {
+                var val = Representing.getValue(comp);
+                emitWith(comp, colorInputChangeEvent, { color: val });
+              }
+            },
+            validator: {
+              validateOnLoad: false,
+              validate: function (input) {
+                var inputValue = Representing.getValue(input);
+                if (inputValue.length === 0) {
+                  return Future.pure(Result.value(true));
+                } else {
+                  var span = SugarElement.fromTag('span');
+                  set$7(span, 'background-color', inputValue);
+                  var res = getRaw(span, 'background-color').fold(function () {
+                    return Result.error('blah');
+                  }, function (_) {
+                    return Result.value(inputValue);
+                  });
+                  return Future.pure(res);
+                }
+              }
+            }
+          })
+        ]),
+        selectOnFocus: false
+      });
+      var pLabel = spec.label.map(function (label) {
+        return renderLabel$2(label, sharedBackstage.providers);
+      });
+      var emitSwatchChange = function (colorBit, value) {
+        emitWith(colorBit, colorSwatchChangeEvent, { value: value });
+      };
+      var onItemAction = function (comp, value) {
+        memColorButton.getOpt(comp).each(function (colorBit) {
+          if (value === 'custom') {
+            colorInputBackstage.colorPicker(function (valueOpt) {
+              valueOpt.fold(function () {
+                return emit(colorBit, colorPickerCancelEvent);
+              }, function (value) {
+                emitSwatchChange(colorBit, value);
+                addColor(value);
+              });
+            }, '#ffffff');
+          } else if (value === 'remove') {
+            emitSwatchChange(colorBit, '');
+          } else {
+            emitSwatchChange(colorBit, value);
+          }
+        });
+      };
+      var memColorButton = record(renderPanelButton({
+        dom: {
+          tag: 'span',
+          attributes: { 'aria-label': sharedBackstage.providers.translate('Color swatch') }
+        },
+        layouts: {
+          onRtl: function () {
+            return [
+              southwest$2,
+              southeast$2,
+              south$2
+            ];
+          },
+          onLtr: function () {
+            return [
+              southeast$2,
+              southwest$2,
+              south$2
+            ];
+          }
+        },
+        components: [],
+        fetch: getFetch$1(colorInputBackstage.getColors(), colorInputBackstage.hasCustomColors()),
+        columns: colorInputBackstage.getColorCols(),
+        presets: 'color',
+        onItemAction: onItemAction
+      }, sharedBackstage));
+      return FormField.sketch({
+        dom: {
+          tag: 'div',
+          classes: ['tox-form__group']
+        },
+        components: pLabel.toArray().concat([{
+            dom: {
+              tag: 'div',
+              classes: ['tox-color-input']
+            },
+            components: [
+              pField,
+              memColorButton.asSpec()
+            ]
+          }]),
+        fieldBehaviours: derive$1([config('form-field-events', [
+            run$1(colorInputChangeEvent, function (comp, se) {
+              memColorButton.getOpt(comp).each(function (colorButton) {
+                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) {
+                Representing.setValue(field, se.event.value);
+                Composing.getCurrent(comp).each(Focusing.focus);
+              });
+            }),
+            run$1(colorPickerCancelEvent, function (comp, _se) {
+              FormField.getField(comp).each(function (_field) {
+                Composing.getCurrent(comp).each(Focusing.focus);
+              });
+            })
+          ])])
+      });
+    };
+
+    var labelPart = optional({
+      schema: [required$1('dom')],
+      name: 'label'
+    });
+    var edgePart = function (name) {
+      return optional({
+        name: '' + name + '-edge',
+        overrides: function (detail) {
+          var action = detail.model.manager.edgeActions[name];
+          return action.fold(function () {
+            return {};
+          }, function (a) {
+            return {
+              events: derive$2([
+                runActionExtra(touchstart(), function (comp, se, d) {
+                  return a(comp, d);
+                }, [detail]),
+                runActionExtra(mousedown(), function (comp, se, d) {
+                  return a(comp, d);
+                }, [detail]),
+                runActionExtra(mousemove(), function (comp, se, det) {
+                  if (det.mouseIsDown.get()) {
+                    a(comp, det);
+                  }
+                }, [detail])
+              ])
+            };
+          });
+        }
+      });
+    };
+    var tlEdgePart = edgePart('top-left');
+    var tedgePart = edgePart('top');
+    var trEdgePart = edgePart('top-right');
+    var redgePart = edgePart('right');
+    var brEdgePart = edgePart('bottom-right');
+    var bedgePart = edgePart('bottom');
+    var blEdgePart = edgePart('bottom-left');
+    var ledgePart = edgePart('left');
+    var thumbPart = required({
+      name: 'thumb',
+      defaults: constant$1({ dom: { styles: { position: 'absolute' } } }),
+      overrides: function (detail) {
+        return {
+          events: derive$2([
+            redirectToPart(touchstart(), detail, 'spectrum'),
+            redirectToPart(touchmove(), detail, 'spectrum'),
+            redirectToPart(touchend(), detail, 'spectrum'),
+            redirectToPart(mousedown(), detail, 'spectrum'),
+            redirectToPart(mousemove(), detail, 'spectrum'),
+            redirectToPart(mouseup(), detail, 'spectrum')
+          ])
+        };
+      }
+    });
+    var spectrumPart = required({
+      schema: [customField('mouseIsDown', function () {
+          return Cell(false);
+        })],
+      name: 'spectrum',
+      overrides: function (detail) {
+        var modelDetail = detail.model;
+        var model = modelDetail.manager;
+        var setValueFrom = function (component, simulatedEvent) {
+          return model.getValueFromEvent(simulatedEvent).map(function (value) {
+            return model.setValueFrom(component, detail, value);
+          });
+        };
+        return {
+          behaviours: derive$1([
+            Keying.config({
+              mode: 'special',
+              onLeft: function (spectrum) {
+                return model.onLeft(spectrum, detail);
+              },
+              onRight: function (spectrum) {
+                return model.onRight(spectrum, detail);
+              },
+              onUp: function (spectrum) {
+                return model.onUp(spectrum, detail);
+              },
+              onDown: function (spectrum) {
+                return model.onDown(spectrum, detail);
+              }
+            }),
+            Focusing.config({})
+          ]),
+          events: derive$2([
+            run$1(touchstart(), setValueFrom),
+            run$1(touchmove(), setValueFrom),
+            run$1(mousedown(), setValueFrom),
+            run$1(mousemove(), function (spectrum, se) {
+              if (detail.mouseIsDown.get()) {
+                setValueFrom(spectrum, se);
+              }
+            })
+          ])
+        };
+      }
+    });
+    var SliderParts = [
+      labelPart,
+      ledgePart,
+      redgePart,
+      tedgePart,
+      bedgePart,
+      tlEdgePart,
+      trEdgePart,
+      blEdgePart,
+      brEdgePart,
+      thumbPart,
+      spectrumPart
+    ];
+
+    var _sliderChangeEvent = 'slider.change.value';
+    var sliderChangeEvent = constant$1(_sliderChangeEvent);
+    var isTouchEvent$2 = function (evt) {
+      return evt.type.indexOf('touch') !== -1;
+    };
+    var getEventSource = function (simulatedEvent) {
+      var evt = simulatedEvent.event.raw;
+      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 {
+        var mouseEvent = evt;
+        return mouseEvent.clientX !== undefined ? Optional.some(mouseEvent).map(function (me) {
+          return SugarPosition(me.clientX, me.clientY);
+        }) : Optional.none();
+      }
+    };
+
+    var t = 'top', r = 'right', b = 'bottom', l = 'left';
+    var minX = function (detail) {
+      return detail.model.minX;
+    };
+    var minY = function (detail) {
+      return detail.model.minY;
+    };
+    var min1X = function (detail) {
+      return detail.model.minX - 1;
+    };
+    var min1Y = function (detail) {
+      return detail.model.minY - 1;
+    };
+    var maxX = function (detail) {
+      return detail.model.maxX;
+    };
+    var maxY = function (detail) {
+      return detail.model.maxY;
+    };
+    var max1X = function (detail) {
+      return detail.model.maxX + 1;
+    };
+    var max1Y = function (detail) {
+      return detail.model.maxY + 1;
+    };
+    var range = function (detail, max, min) {
+      return max(detail) - min(detail);
+    };
+    var xRange = function (detail) {
+      return range(detail, maxX, minX);
+    };
+    var yRange = function (detail) {
+      return range(detail, maxY, minY);
+    };
+    var halfX = function (detail) {
+      return xRange(detail) / 2;
+    };
+    var halfY = function (detail) {
+      return yRange(detail) / 2;
+    };
+    var step = function (detail) {
+      return detail.stepSize;
+    };
+    var snap = function (detail) {
+      return detail.snapToGrid;
+    };
+    var snapStart = function (detail) {
+      return detail.snapStart;
+    };
+    var rounded = function (detail) {
+      return detail.rounded;
+    };
+    var hasEdge = function (detail, edgeName) {
+      return detail[edgeName + '-edge'] !== undefined;
+    };
+    var hasLEdge = function (detail) {
+      return hasEdge(detail, l);
+    };
+    var hasREdge = function (detail) {
+      return hasEdge(detail, r);
+    };
+    var hasTEdge = function (detail) {
+      return hasEdge(detail, t);
+    };
+    var hasBEdge = function (detail) {
+      return hasEdge(detail, b);
+    };
+    var currentValue = function (detail) {
+      return detail.model.value.get();
+    };
+
+    var xValue = function (x) {
+      return { x: x };
+    };
+    var yValue = function (y) {
+      return { y: y };
+    };
+    var xyValue = function (x, y) {
+      return {
+        x: x,
+        y: y
+      };
+    };
+    var fireSliderChange$3 = function (component, value) {
+      emitWith(component, sliderChangeEvent(), { value: value });
+    };
+    var setToTLEdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(min1X(detail), min1Y(detail)));
+    };
+    var setToTEdge = function (edge, detail) {
+      fireSliderChange$3(edge, yValue(min1Y(detail)));
+    };
+    var setToTEdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(halfX(detail), min1Y(detail)));
+    };
+    var setToTREdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(max1X(detail), min1Y(detail)));
+    };
+    var setToREdge = function (edge, detail) {
+      fireSliderChange$3(edge, xValue(max1X(detail)));
+    };
+    var setToREdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(max1X(detail), halfY(detail)));
+    };
+    var setToBREdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(max1X(detail), max1Y(detail)));
+    };
+    var setToBEdge = function (edge, detail) {
+      fireSliderChange$3(edge, yValue(max1Y(detail)));
+    };
+    var setToBEdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(halfX(detail), max1Y(detail)));
+    };
+    var setToBLEdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(min1X(detail), max1Y(detail)));
+    };
+    var setToLEdge = function (edge, detail) {
+      fireSliderChange$3(edge, xValue(min1X(detail)));
+    };
+    var setToLEdgeXY = function (edge, detail) {
+      fireSliderChange$3(edge, xyValue(min1X(detail), halfY(detail)));
+    };
+
+    var reduceBy = function (value, min, max, step) {
+      if (value < min) {
+        return value;
+      } else if (value > max) {
+        return max;
+      } else if (value === min) {
+        return min - 1;
+      } else {
+        return Math.max(min, value - step);
+      }
+    };
+    var increaseBy = function (value, min, max, step) {
+      if (value > max) {
+        return value;
+      } else if (value < min) {
+        return min;
+      } else if (value === max) {
+        return max + 1;
+      } else {
+        return Math.min(max, value + step);
+      }
+    };
+    var capValue = function (value, min, max) {
+      return Math.max(min, Math.min(max, value));
+    };
+    var snapValueOf = function (value, min, max, step, snapStart) {
+      return snapStart.fold(function () {
+        var initValue = value - min;
+        var extraValue = Math.round(initValue / step) * step;
+        return capValue(min + extraValue, min - 1, max + 1);
+      }, function (start) {
+        var remainder = (value - start) % step;
+        var adjustment = Math.round(remainder / step);
+        var rawSteps = Math.floor((value - start) / step);
+        var maxSteps = Math.floor((max - start) / step);
+        var numSteps = Math.min(maxSteps, rawSteps + adjustment);
+        var r = start + numSteps * step;
+        return Math.max(start, r);
+      });
+    };
+    var findOffsetOf = function (value, min, max) {
+      return Math.min(max, Math.max(value, min)) - min;
+    };
+    var findValueOf = function (args) {
+      var min = args.min, max = args.max, range = args.range, value = args.value, step = args.step, snap = args.snap, snapStart = args.snapStart, rounded = args.rounded, hasMinEdge = args.hasMinEdge, hasMaxEdge = args.hasMaxEdge, minBound = args.minBound, maxBound = args.maxBound, screenRange = args.screenRange;
+      var capMin = hasMinEdge ? min - 1 : min;
+      var capMax = hasMaxEdge ? max + 1 : max;
+      if (value < minBound) {
+        return capMin;
+      } else if (value > maxBound) {
+        return capMax;
+      } else {
+        var offset = findOffsetOf(value, minBound, maxBound);
+        var newValue = capValue(offset / screenRange * range + min, capMin, capMax);
+        if (snap && newValue >= min && newValue <= max) {
+          return snapValueOf(newValue, min, max, step, snapStart);
+        } else if (rounded) {
+          return Math.round(newValue);
+        } else {
+          return newValue;
+        }
+      }
+    };
+    var findOffsetOfValue$2 = function (args) {
+      var min = args.min, max = args.max, range = args.range, value = args.value, hasMinEdge = args.hasMinEdge, hasMaxEdge = args.hasMaxEdge, maxBound = args.maxBound, maxOffset = args.maxOffset, centerMinEdge = args.centerMinEdge, centerMaxEdge = args.centerMaxEdge;
+      if (value < min) {
+        return hasMinEdge ? 0 : centerMinEdge;
+      } else if (value > max) {
+        return hasMaxEdge ? maxBound : centerMaxEdge;
+      } else {
+        return (value - min) / range * maxOffset;
+      }
+    };
+
+    var top = 'top', right = 'right', bottom = 'bottom', left = 'left', width = 'width', height = 'height';
+    var getBounds = function (component) {
+      return component.element.dom.getBoundingClientRect();
+    };
+    var getBoundsProperty = function (bounds, property) {
+      return bounds[property];
+    };
+    var getMinXBounds = function (component) {
+      var bounds = getBounds(component);
+      return getBoundsProperty(bounds, left);
+    };
+    var getMaxXBounds = function (component) {
+      var bounds = getBounds(component);
+      return getBoundsProperty(bounds, right);
+    };
+    var getMinYBounds = function (component) {
+      var bounds = getBounds(component);
+      return getBoundsProperty(bounds, top);
+    };
+    var getMaxYBounds = function (component) {
+      var bounds = getBounds(component);
+      return getBoundsProperty(bounds, bottom);
+    };
+    var getXScreenRange = function (component) {
+      var bounds = getBounds(component);
+      return getBoundsProperty(bounds, width);
+    };
+    var getYScreenRange = function (component) {
+      var bounds = getBounds(component);
+      return getBoundsProperty(bounds, height);
+    };
+    var getCenterOffsetOf = function (componentMinEdge, componentMaxEdge, spectrumMinEdge) {
+      return (componentMinEdge + componentMaxEdge) / 2 - spectrumMinEdge;
+    };
+    var getXCenterOffSetOf = function (component, spectrum) {
+      var componentBounds = getBounds(component);
+      var spectrumBounds = getBounds(spectrum);
+      var componentMinEdge = getBoundsProperty(componentBounds, left);
+      var componentMaxEdge = getBoundsProperty(componentBounds, right);
+      var spectrumMinEdge = getBoundsProperty(spectrumBounds, left);
+      return getCenterOffsetOf(componentMinEdge, componentMaxEdge, spectrumMinEdge);
+    };
+    var getYCenterOffSetOf = function (component, spectrum) {
+      var componentBounds = getBounds(component);
+      var spectrumBounds = getBounds(spectrum);
+      var componentMinEdge = getBoundsProperty(componentBounds, top);
+      var componentMaxEdge = getBoundsProperty(componentBounds, bottom);
+      var spectrumMinEdge = getBoundsProperty(spectrumBounds, top);
+      return getCenterOffsetOf(componentMinEdge, componentMaxEdge, spectrumMinEdge);
+    };
+
+    var fireSliderChange$2 = function (spectrum, value) {
+      emitWith(spectrum, sliderChangeEvent(), { value: value });
+    };
+    var sliderValue$2 = function (x) {
+      return { x: x };
+    };
+    var findValueOfOffset$1 = function (spectrum, detail, left) {
+      var args = {
+        min: minX(detail),
+        max: maxX(detail),
+        range: xRange(detail),
+        value: left,
+        step: step(detail),
+        snap: snap(detail),
+        snapStart: snapStart(detail),
+        rounded: rounded(detail),
+        hasMinEdge: hasLEdge(detail),
+        hasMaxEdge: hasREdge(detail),
+        minBound: getMinXBounds(spectrum),
+        maxBound: getMaxXBounds(spectrum),
+        screenRange: getXScreenRange(spectrum)
+      };
+      return findValueOf(args);
+    };
+    var setValueFrom$2 = function (spectrum, detail, value) {
+      var xValue = findValueOfOffset$1(spectrum, detail, value);
+      var sliderVal = sliderValue$2(xValue);
+      fireSliderChange$2(spectrum, sliderVal);
+      return xValue;
+    };
+    var setToMin$2 = function (spectrum, detail) {
+      var min = minX(detail);
+      fireSliderChange$2(spectrum, sliderValue$2(min));
+    };
+    var setToMax$2 = function (spectrum, detail) {
+      var max = maxX(detail);
+      fireSliderChange$2(spectrum, sliderValue$2(max));
+    };
+    var moveBy$2 = function (direction, spectrum, detail) {
+      var f = direction > 0 ? increaseBy : reduceBy;
+      var xValue = f(currentValue(detail).x, minX(detail), maxX(detail), step(detail));
+      fireSliderChange$2(spectrum, sliderValue$2(xValue));
+      return Optional.some(xValue);
+    };
+    var handleMovement$2 = function (direction) {
+      return function (spectrum, detail) {
+        return moveBy$2(direction, spectrum, detail).map(always);
+      };
+    };
+    var getValueFromEvent$2 = function (simulatedEvent) {
+      var pos = getEventSource(simulatedEvent);
+      return pos.map(function (p) {
+        return p.left;
+      });
+    };
+    var findOffsetOfValue$1 = function (spectrum, detail, value, minEdge, maxEdge) {
+      var minOffset = 0;
+      var maxOffset = getXScreenRange(spectrum);
+      var centerMinEdge = minEdge.bind(function (edge) {
+        return Optional.some(getXCenterOffSetOf(edge, spectrum));
+      }).getOr(minOffset);
+      var centerMaxEdge = maxEdge.bind(function (edge) {
+        return Optional.some(getXCenterOffSetOf(edge, spectrum));
+      }).getOr(maxOffset);
+      var args = {
+        min: minX(detail),
+        max: maxX(detail),
+        range: xRange(detail),
+        value: value,
+        hasMinEdge: hasLEdge(detail),
+        hasMaxEdge: hasREdge(detail),
+        minBound: getMinXBounds(spectrum),
+        minOffset: minOffset,
+        maxBound: getMaxXBounds(spectrum),
+        maxOffset: maxOffset,
+        centerMinEdge: centerMinEdge,
+        centerMaxEdge: centerMaxEdge
+      };
+      return findOffsetOfValue$2(args);
+    };
+    var findPositionOfValue$1 = function (slider, spectrum, value, minEdge, maxEdge, detail) {
+      var offset = findOffsetOfValue$1(spectrum, detail, value, minEdge, maxEdge);
+      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$a(thumb.element) / 2;
+      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;
+    var edgeActions$2 = {
+      'top-left': Optional.none(),
+      'top': Optional.none(),
+      'top-right': Optional.none(),
+      'right': Optional.some(setToREdge),
+      'bottom-right': Optional.none(),
+      'bottom': Optional.none(),
+      'bottom-left': Optional.none(),
+      'left': Optional.some(setToLEdge)
+    };
+
+    var HorizontalModel = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        setValueFrom: setValueFrom$2,
+        setToMin: setToMin$2,
+        setToMax: setToMax$2,
+        findValueOfOffset: findValueOfOffset$1,
+        getValueFromEvent: getValueFromEvent$2,
+        findPositionOfValue: findPositionOfValue$1,
+        setPositionFromValue: setPositionFromValue$2,
+        onLeft: onLeft$2,
+        onRight: onRight$2,
+        onUp: onUp$2,
+        onDown: onDown$2,
+        edgeActions: edgeActions$2
+    });
+
+    var fireSliderChange$1 = function (spectrum, value) {
+      emitWith(spectrum, sliderChangeEvent(), { value: value });
+    };
+    var sliderValue$1 = function (y) {
+      return { y: y };
+    };
+    var findValueOfOffset = function (spectrum, detail, top) {
+      var args = {
+        min: minY(detail),
+        max: maxY(detail),
+        range: yRange(detail),
+        value: top,
+        step: step(detail),
+        snap: snap(detail),
+        snapStart: snapStart(detail),
+        rounded: rounded(detail),
+        hasMinEdge: hasTEdge(detail),
+        hasMaxEdge: hasBEdge(detail),
+        minBound: getMinYBounds(spectrum),
+        maxBound: getMaxYBounds(spectrum),
+        screenRange: getYScreenRange(spectrum)
+      };
+      return findValueOf(args);
+    };
+    var setValueFrom$1 = function (spectrum, detail, value) {
+      var yValue = findValueOfOffset(spectrum, detail, value);
+      var sliderVal = sliderValue$1(yValue);
+      fireSliderChange$1(spectrum, sliderVal);
+      return yValue;
+    };
+    var setToMin$1 = function (spectrum, detail) {
+      var min = minY(detail);
+      fireSliderChange$1(spectrum, sliderValue$1(min));
+    };
+    var setToMax$1 = function (spectrum, detail) {
+      var max = maxY(detail);
+      fireSliderChange$1(spectrum, sliderValue$1(max));
+    };
+    var moveBy$1 = function (direction, spectrum, detail) {
+      var f = direction > 0 ? increaseBy : reduceBy;
+      var yValue = f(currentValue(detail).y, minY(detail), maxY(detail), step(detail));
+      fireSliderChange$1(spectrum, sliderValue$1(yValue));
+      return Optional.some(yValue);
+    };
+    var handleMovement$1 = function (direction) {
+      return function (spectrum, detail) {
+        return moveBy$1(direction, spectrum, detail).map(always);
+      };
+    };
+    var getValueFromEvent$1 = function (simulatedEvent) {
+      var pos = getEventSource(simulatedEvent);
+      return pos.map(function (p) {
+        return p.top;
+      });
+    };
+    var findOffsetOfValue = function (spectrum, detail, value, minEdge, maxEdge) {
+      var minOffset = 0;
+      var maxOffset = getYScreenRange(spectrum);
+      var centerMinEdge = minEdge.bind(function (edge) {
+        return Optional.some(getYCenterOffSetOf(edge, spectrum));
+      }).getOr(minOffset);
+      var centerMaxEdge = maxEdge.bind(function (edge) {
+        return Optional.some(getYCenterOffSetOf(edge, spectrum));
+      }).getOr(maxOffset);
+      var args = {
+        min: minY(detail),
+        max: maxY(detail),
+        range: yRange(detail),
+        value: value,
+        hasMinEdge: hasTEdge(detail),
+        hasMaxEdge: hasBEdge(detail),
+        minBound: getMinYBounds(spectrum),
+        minOffset: minOffset,
+        maxBound: getMaxYBounds(spectrum),
+        maxOffset: maxOffset,
+        centerMinEdge: centerMinEdge,
+        centerMaxEdge: centerMaxEdge
+      };
+      return findOffsetOfValue$2(args);
+    };
+    var findPositionOfValue = function (slider, spectrum, value, minEdge, maxEdge, detail) {
+      var offset = findOffsetOfValue(spectrum, detail, value, minEdge, maxEdge);
+      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$b(thumb.element) / 2;
+      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 edgeActions$1 = {
+      'top-left': Optional.none(),
+      'top': Optional.some(setToTEdge),
+      'top-right': Optional.none(),
+      'right': Optional.none(),
+      'bottom-right': Optional.none(),
+      'bottom': Optional.some(setToBEdge),
+      'bottom-left': Optional.none(),
+      'left': Optional.none()
+    };
+
+    var VerticalModel = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        setValueFrom: setValueFrom$1,
+        setToMin: setToMin$1,
+        setToMax: setToMax$1,
+        findValueOfOffset: findValueOfOffset,
+        getValueFromEvent: getValueFromEvent$1,
+        findPositionOfValue: findPositionOfValue,
+        setPositionFromValue: setPositionFromValue$1,
+        onLeft: onLeft$1,
+        onRight: onRight$1,
+        onUp: onUp$1,
+        onDown: onDown$1,
+        edgeActions: edgeActions$1
+    });
+
+    var fireSliderChange = function (spectrum, value) {
+      emitWith(spectrum, sliderChangeEvent(), { value: value });
+    };
+    var sliderValue = function (x, y) {
+      return {
+        x: x,
+        y: y
+      };
+    };
+    var setValueFrom = function (spectrum, detail, value) {
+      var xValue = findValueOfOffset$1(spectrum, detail, value.left);
+      var yValue = findValueOfOffset(spectrum, detail, value.top);
+      var val = sliderValue(xValue, yValue);
+      fireSliderChange(spectrum, val);
+      return val;
+    };
+    var moveBy = function (direction, isVerticalMovement, spectrum, detail) {
+      var f = direction > 0 ? increaseBy : reduceBy;
+      var xValue = isVerticalMovement ? currentValue(detail).x : f(currentValue(detail).x, minX(detail), maxX(detail), step(detail));
+      var yValue = !isVerticalMovement ? currentValue(detail).y : f(currentValue(detail).y, minY(detail), maxY(detail), step(detail));
+      fireSliderChange(spectrum, sliderValue(xValue, yValue));
+      return Optional.some(xValue);
+    };
+    var handleMovement = function (direction, isVerticalMovement) {
+      return function (spectrum, detail) {
+        return moveBy(direction, isVerticalMovement, spectrum, detail).map(always);
+      };
+    };
+    var setToMin = function (spectrum, detail) {
+      var mX = minX(detail);
+      var mY = minY(detail);
+      fireSliderChange(spectrum, sliderValue(mX, mY));
+    };
+    var setToMax = function (spectrum, detail) {
+      var mX = maxX(detail);
+      var mY = maxY(detail);
+      fireSliderChange(spectrum, sliderValue(mX, mY));
+    };
+    var getValueFromEvent = function (simulatedEvent) {
+      return getEventSource(simulatedEvent);
+    };
+    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$a(thumb.element) / 2;
+      var thumbYRadius = get$b(thumb.element) / 2;
+      set$7(thumb.element, 'left', xPos - thumbXRadius + '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);
+    var edgeActions = {
+      'top-left': Optional.some(setToTLEdgeXY),
+      'top': Optional.some(setToTEdgeXY),
+      'top-right': Optional.some(setToTREdgeXY),
+      'right': Optional.some(setToREdgeXY),
+      'bottom-right': Optional.some(setToBREdgeXY),
+      'bottom': Optional.some(setToBEdgeXY),
+      'bottom-left': Optional.some(setToBLEdgeXY),
+      'left': Optional.some(setToLEdgeXY)
+    };
+
+    var TwoDModel = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        setValueFrom: setValueFrom,
+        setToMin: setToMin,
+        setToMax: setToMax,
+        getValueFromEvent: getValueFromEvent,
+        setPositionFromValue: setPositionFromValue,
+        onLeft: onLeft,
+        onRight: onRight,
+        onUp: onUp,
+        onDown: onDown,
+        edgeActions: edgeActions
+    });
+
+    var SliderSchema = [
+      defaulted('stepSize', 1),
+      defaulted('onChange', noop),
+      defaulted('onChoose', noop),
+      defaulted('onInit', noop),
+      defaulted('onDragStart', noop),
+      defaulted('onDragEnd', noop),
+      defaulted('snapToGrid', false),
+      defaulted('rounded', true),
+      option('snapStart'),
+      requiredOf('model', choose$1('mode', {
+        x: [
+          defaulted('minX', 0),
+          defaulted('maxX', 100),
+          customField('value', function (spec) {
+            return Cell(spec.mode.minX);
+          }),
+          required$1('getInitialValue'),
+          output$1('manager', HorizontalModel)
+        ],
+        y: [
+          defaulted('minY', 0),
+          defaulted('maxY', 100),
+          customField('value', function (spec) {
+            return Cell(spec.mode.minY);
+          }),
+          required$1('getInitialValue'),
+          output$1('manager', VerticalModel)
+        ],
+        xy: [
+          defaulted('minX', 0),
+          defaulted('maxX', 100),
+          defaulted('minY', 0),
+          defaulted('maxY', 100),
+          customField('value', function (spec) {
+            return Cell({
+              x: spec.mode.minX,
+              y: spec.mode.minY
+            });
+          }),
+          required$1('getInitialValue'),
+          output$1('manager', TwoDModel)
+        ]
+      })),
+      field('sliderBehaviours', [
+        Keying,
+        Representing
+      ]),
+      customField('mouseIsDown', function () {
+        return Cell(false);
+      })
+    ];
+
+    var sketch$2 = function (detail, components, _spec, _externals) {
+      var _a;
+      var getThumb = function (component) {
+        return getPartOrDie(component, detail, 'thumb');
+      };
+      var getSpectrum = function (component) {
+        return getPartOrDie(component, detail, 'spectrum');
+      };
+      var getLeftEdge = function (component) {
+        return getPart(component, detail, 'left-edge');
+      };
+      var getRightEdge = function (component) {
+        return getPart(component, detail, 'right-edge');
+      };
+      var getTopEdge = function (component) {
+        return getPart(component, detail, 'top-edge');
+      };
+      var getBottomEdge = function (component) {
+        return getPart(component, detail, 'bottom-edge');
+      };
+      var modelDetail = detail.model;
+      var model = modelDetail.manager;
+      var refresh = function (slider, thumb) {
+        model.setPositionFromValue(slider, thumb, detail, {
+          getLeftEdge: getLeftEdge,
+          getRightEdge: getRightEdge,
+          getTopEdge: getTopEdge,
+          getBottomEdge: getBottomEdge,
+          getSpectrum: getSpectrum
+        });
+      };
+      var setValue = function (slider, newValue) {
+        modelDetail.value.set(newValue);
+        var thumb = getThumb(slider);
+        refresh(slider, thumb);
+      };
+      var changeValue = function (slider, newValue) {
+        setValue(slider, newValue);
+        var thumb = getThumb(slider);
+        detail.onChange(slider, thumb, newValue);
+        return Optional.some(true);
+      };
+      var resetToMin = function (slider) {
+        model.setToMin(slider, detail);
+      };
+      var resetToMax = function (slider) {
+        model.setToMax(slider, detail);
+      };
+      var choose = function (slider) {
+        var fireOnChoose = function () {
+          getPart(slider, detail, 'thumb').each(function (thumb) {
+            var value = modelDetail.value.get();
+            detail.onChoose(slider, thumb, value);
+          });
+        };
+        var wasDown = detail.mouseIsDown.get();
+        detail.mouseIsDown.set(false);
+        if (wasDown) {
+          fireOnChoose();
+        }
+      };
+      var onDragStart = function (slider, simulatedEvent) {
+        simulatedEvent.stop();
+        detail.mouseIsDown.set(true);
+        detail.onDragStart(slider, getThumb(slider));
+      };
+      var onDragEnd = function (slider, simulatedEvent) {
+        simulatedEvent.stop();
+        detail.onDragEnd(slider, getThumb(slider));
+        choose(slider);
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: augment(detail.sliderBehaviours, [
+          Keying.config({
+            mode: 'special',
+            focusIn: function (slider) {
+              return getPart(slider, detail, 'spectrum').map(Keying.focusIn).map(always);
+            }
+          }),
+          Representing.config({
+            store: {
+              mode: 'manual',
+              getValue: function (_) {
+                return modelDetail.value.get();
+              }
+            }
+          }),
+          Receiving.config({ channels: (_a = {}, _a[mouseReleased()] = { onReceive: choose }, _a) })
+        ]),
+        events: derive$2([
+          run$1(sliderChangeEvent(), function (slider, simulatedEvent) {
+            changeValue(slider, simulatedEvent.event.value);
+          }),
+          runOnAttached(function (slider, _simulatedEvent) {
+            var getInitial = modelDetail.getInitialValue();
+            modelDetail.value.set(getInitial);
+            var thumb = getThumb(slider);
+            refresh(slider, thumb);
+            var spectrum = getSpectrum(slider);
+            detail.onInit(slider, thumb, spectrum, modelDetail.value.get());
+          }),
+          run$1(touchstart(), onDragStart),
+          run$1(touchend(), onDragEnd),
+          run$1(mousedown(), onDragStart),
+          run$1(mouseup(), onDragEnd)
+        ]),
+        apis: {
+          resetToMin: resetToMin,
+          resetToMax: resetToMax,
+          setValue: setValue,
+          refresh: refresh
+        },
+        domModification: { styles: { position: 'relative' } }
+      };
+    };
+
+    var Slider = composite({
+      name: 'Slider',
+      configFields: SliderSchema,
+      partFields: SliderParts,
+      factory: sketch$2,
+      apis: {
+        setValue: function (apis, slider, value) {
+          apis.setValue(slider, value);
+        },
+        resetToMin: function (apis, slider) {
+          apis.resetToMin(slider);
+        },
+        resetToMax: function (apis, slider) {
+          apis.resetToMax(slider);
+        },
+        refresh: function (apis, slider) {
+          apis.refresh(slider);
+        }
+      }
+    });
+
+    var fieldsUpdate = generate$6('rgb-hex-update');
+    var sliderUpdate = generate$6('slider-update');
+    var paletteUpdate = generate$6('palette-update');
+
+    var sliderFactory = function (translate, getClass) {
+      var spectrum = Slider.parts.spectrum({
+        dom: {
+          tag: 'div',
+          classes: [getClass('hue-slider-spectrum')],
+          attributes: { role: 'presentation' }
+        }
+      });
+      var thumb = Slider.parts.thumb({
+        dom: {
+          tag: 'div',
+          classes: [getClass('hue-slider-thumb')],
+          attributes: { role: 'presentation' }
+        }
+      });
+      return Slider.sketch({
+        dom: {
+          tag: 'div',
+          classes: [getClass('hue-slider')],
+          attributes: { role: 'presentation' }
+        },
+        rounded: false,
+        model: {
+          mode: 'y',
+          getInitialValue: constant$1({ y: 0 })
+        },
+        components: [
+          spectrum,
+          thumb
+        ],
+        sliderBehaviours: derive$1([Focusing.config({})]),
+        onChange: function (slider, _thumb, value) {
+          emitWith(slider, sliderUpdate, { value: value });
+        }
+      });
+    };
+
+    var owner$1 = 'form';
+    var schema$i = [field('formBehaviours', [Representing])];
+    var getPartName$1 = function (name) {
+      return '<alloy.field.' + name + '>';
+    };
+    var sketch$1 = function (fSpec) {
+      var parts = function () {
+        var record = [];
+        var field = function (name, config) {
+          record.push(name);
+          return generateOne$1(owner$1, getPartName$1(name), config);
+        };
+        return {
+          field: field,
+          record: constant$1(record)
+        };
+      }();
+      var spec = fSpec(parts);
+      var partNames = parts.record();
+      var fieldParts = map$2(partNames, function (n) {
+        return required({
+          name: n,
+          pname: getPartName$1(n)
+        });
+      });
+      return composite$1(owner$1, schema$i, fieldParts, make$4, spec);
+    };
+    var toResult = function (o, e) {
+      return o.fold(function () {
+        return Result.error(e);
+      }, Result.value);
+    };
+    var make$4 = function (detail, components) {
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: augment(detail.formBehaviours, [Representing.config({
+            store: {
+              mode: 'manual',
+              getValue: function (form) {
+                var resPs = getAllParts(form, detail);
+                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);
+                });
+              },
+              setValue: function (form, values) {
+                each(values, function (newValue, key) {
+                  getPart(form, detail, key).each(function (wrapper) {
+                    Composing.getCurrent(wrapper).each(function (field) {
+                      Representing.setValue(field, newValue);
+                    });
+                  });
+                });
+              }
+            }
+          })]),
+        apis: {
+          getField: function (form, key) {
+            return getPart(form, detail, key).bind(Composing.getCurrent);
+          }
+        }
+      };
+    };
+    var Form = {
+      getField: makeApi(function (apis, component, key) {
+        return apis.getField(component, key);
+      }),
+      sketch: sketch$1
+    };
+
+    var validInput = generate$6('valid-input');
+    var invalidInput = generate$6('invalid-input');
+    var validatingInput = generate$6('validating-input');
+    var translatePrefix = 'colorcustom.rgb.';
+    var rgbFormFactory = function (translate, getClass, onValidHexx, onInvalidHexx) {
+      var invalidation = function (label, isValid) {
+        return Invalidating.config({
+          invalidClass: getClass('invalid'),
+          notify: {
+            onValidate: function (comp) {
+              emitWith(comp, validatingInput, { type: label });
+            },
+            onValid: function (comp) {
+              emitWith(comp, validInput, {
+                type: label,
+                value: Representing.getValue(comp)
+              });
+            },
+            onInvalid: function (comp) {
+              emitWith(comp, invalidInput, {
+                type: label,
+                value: Representing.getValue(comp)
+              });
+            }
+          },
+          validator: {
+            validate: function (comp) {
+              var value = Representing.getValue(comp);
+              var res = isValid(value) ? Result.value(true) : Result.error(translate('aria.input.invalid'));
+              return Future.pure(res);
+            },
+            validateOnLoad: false
+          }
+        });
+      };
+      var renderTextField = function (isValid, name, label, description, data) {
+        var helptext = translate(translatePrefix + 'range');
+        var pLabel = FormField.parts.label({
+          dom: {
+            tag: 'label',
+            innerHtml: label,
+            attributes: { 'aria-label': description }
+          }
+        });
+        var pField = FormField.parts.field({
+          data: data,
+          factory: Input,
+          inputAttributes: __assign({ type: 'text' }, name === 'hex' ? { 'aria-live': 'polite' } : {}),
+          inputClasses: [getClass('textfield')],
+          inputBehaviours: derive$1([
+            invalidation(name, isValid),
+            Tabstopping.config({})
+          ]),
+          onSetValue: function (input) {
+            if (Invalidating.isInvalid(input)) {
+              var run = Invalidating.run(input);
+              run.get(noop);
+            }
+          }
+        });
+        var comps = [
+          pLabel,
+          pField
+        ];
+        var concats = name !== 'hex' ? [FormField.parts['aria-descriptor']({ text: helptext })] : [];
+        var components = comps.concat(concats);
+        return {
+          dom: {
+            tag: 'div',
+            attributes: { role: 'presentation' }
+          },
+          components: components
+        };
+      };
+      var copyRgbToHex = function (form, rgba) {
+        var hex = fromRgba(rgba);
+        Form.getField(form, 'hex').each(function (hexField) {
+          if (!Focusing.isFocused(hexField)) {
+            Representing.setValue(form, { hex: hex.value });
+          }
+        });
+        return hex;
+      };
+      var copyRgbToForm = function (form, rgb) {
+        var red = rgb.red;
+        var green = rgb.green;
+        var blue = rgb.blue;
+        Representing.setValue(form, {
+          red: red,
+          green: green,
+          blue: blue
+        });
+      };
+      var memPreview = record({
+        dom: {
+          tag: 'div',
+          classes: [getClass('rgba-preview')],
+          styles: { 'background-color': 'white' },
+          attributes: { role: 'presentation' }
+        }
+      });
+      var updatePreview = function (anyInSystem, hex) {
+        memPreview.getOpt(anyInSystem).each(function (preview) {
+          set$7(preview.element, 'background-color', '#' + hex.value);
+        });
+      };
+      var factory = function () {
+        var state = {
+          red: Cell(Optional.some(255)),
+          green: Cell(Optional.some(255)),
+          blue: Cell(Optional.some(255)),
+          hex: Cell(Optional.some('ffffff'))
+        };
+        var copyHexToRgb = function (form, hex) {
+          var rgb = fromHex(hex);
+          copyRgbToForm(form, rgb);
+          setValueRgb(rgb);
+        };
+        var get = function (prop) {
+          return state[prop].get();
+        };
+        var set = function (prop, value) {
+          state[prop].set(value);
+        };
+        var getValueRgb = function () {
+          return get('red').bind(function (red) {
+            return get('green').bind(function (green) {
+              return get('blue').map(function (blue) {
+                return rgbaColour(red, green, blue, 1);
+              });
+            });
+          });
+        };
+        var setValueRgb = function (rgb) {
+          var red = rgb.red;
+          var green = rgb.green;
+          var blue = rgb.blue;
+          set('red', Optional.some(red));
+          set('green', Optional.some(green));
+          set('blue', Optional.some(blue));
+        };
+        var onInvalidInput = function (form, simulatedEvent) {
+          var data = simulatedEvent.event;
+          if (data.type !== 'hex') {
+            set(data.type, Optional.none());
+          } else {
+            onInvalidHexx(form);
+          }
+        };
+        var onValidHex = function (form, value) {
+          onValidHexx(form);
+          var hex = hexColour(value);
+          set('hex', Optional.some(value));
+          var rgb = fromHex(hex);
+          copyRgbToForm(form, rgb);
+          setValueRgb(rgb);
+          emitWith(form, fieldsUpdate, { hex: hex });
+          updatePreview(form, hex);
+        };
+        var onValidRgb = function (form, prop, value) {
+          var val = parseInt(value, 10);
+          set(prop, Optional.some(val));
+          getValueRgb().each(function (rgb) {
+            var hex = copyRgbToHex(form, rgb);
+            emitWith(form, fieldsUpdate, { hex: hex });
+            updatePreview(form, hex);
+          });
+        };
+        var isHexInputEvent = function (data) {
+          return data.type === 'hex';
+        };
+        var onValidInput = function (form, simulatedEvent) {
+          var data = simulatedEvent.event;
+          if (isHexInputEvent(data)) {
+            onValidHex(form, data.value);
+          } else {
+            onValidRgb(form, data.type, data.value);
+          }
+        };
+        var formPartStrings = function (key) {
+          return {
+            label: translate(translatePrefix + key + '.label'),
+            description: translate(translatePrefix + key + '.description')
+          };
+        };
+        var redStrings = formPartStrings('red');
+        var greenStrings = formPartStrings('green');
+        var blueStrings = formPartStrings('blue');
+        var hexStrings = formPartStrings('hex');
+        return deepMerge(Form.sketch(function (parts) {
+          return {
+            dom: {
+              tag: 'form',
+              classes: [getClass('rgb-form')],
+              attributes: { 'aria-label': translate('aria.color.picker') }
+            },
+            components: [
+              parts.field('red', FormField.sketch(renderTextField(isRgbaComponent, 'red', redStrings.label, redStrings.description, 255))),
+              parts.field('green', FormField.sketch(renderTextField(isRgbaComponent, 'green', greenStrings.label, greenStrings.description, 255))),
+              parts.field('blue', FormField.sketch(renderTextField(isRgbaComponent, 'blue', blueStrings.label, blueStrings.description, 255))),
+              parts.field('hex', FormField.sketch(renderTextField(isHexString, 'hex', hexStrings.label, hexStrings.description, 'ffffff'))),
+              memPreview.asSpec()
+            ],
+            formBehaviours: derive$1([
+              Invalidating.config({ invalidClass: getClass('form-invalid') }),
+              config('rgb-form-events', [
+                run$1(validInput, onValidInput),
+                run$1(invalidInput, onInvalidInput),
+                run$1(validatingInput, onInvalidInput)
+              ])
+            ])
+          };
+        }), {
+          apis: {
+            updateHex: function (form, hex) {
+              Representing.setValue(form, { hex: hex.value });
+              copyHexToRgb(form, hex);
+              updatePreview(form, hex);
+            }
+          }
+        });
+      };
+      var rgbFormSketcher = single({
+        factory: factory,
+        name: 'RgbForm',
+        configFields: [],
+        apis: {
+          updateHex: function (apis, form, hex) {
+            apis.updateHex(form, hex);
+          }
+        },
+        extraApis: {}
+      });
+      return rgbFormSketcher;
+    };
+
+    var paletteFactory = function (_translate, getClass) {
+      var spectrumPart = Slider.parts.spectrum({
+        dom: {
+          tag: 'canvas',
+          attributes: { role: 'presentation' },
+          classes: [getClass('sv-palette-spectrum')]
+        }
+      });
+      var thumbPart = Slider.parts.thumb({
+        dom: {
+          tag: 'div',
+          attributes: { role: 'presentation' },
+          classes: [getClass('sv-palette-thumb')],
+          innerHtml: '<div class=' + getClass('sv-palette-inner-thumb') + ' role="presentation"></div>'
+        }
+      });
+      var setColour = function (canvas, rgba) {
+        var width = canvas.width, height = canvas.height;
+        var ctx = canvas.getContext('2d');
+        if (ctx === null) {
+          return;
+        }
+        ctx.fillStyle = rgba;
+        ctx.fillRect(0, 0, width, height);
+        var grdWhite = ctx.createLinearGradient(0, 0, width, 0);
+        grdWhite.addColorStop(0, 'rgba(255,255,255,1)');
+        grdWhite.addColorStop(1, 'rgba(255,255,255,0)');
+        ctx.fillStyle = grdWhite;
+        ctx.fillRect(0, 0, width, height);
+        var grdBlack = ctx.createLinearGradient(0, 0, 0, height);
+        grdBlack.addColorStop(0, 'rgba(0,0,0,0)');
+        grdBlack.addColorStop(1, 'rgba(0,0,0,1)');
+        ctx.fillStyle = grdBlack;
+        ctx.fillRect(0, 0, width, height);
+      };
+      var setPaletteHue = function (slider, hue) {
+        var canvas = slider.components()[0].element.dom;
+        var hsv = hsvColour(hue, 100, 100);
+        var rgba = fromHsv(hsv);
+        setColour(canvas, toString(rgba));
+      };
+      var setPaletteThumb = function (slider, hex) {
+        var hsv = fromRgb(fromHex(hex));
+        Slider.setValue(slider, {
+          x: hsv.saturation,
+          y: 100 - hsv.value
+        });
+      };
+      var factory = function (_detail) {
+        var getInitialValue = constant$1({
+          x: 0,
+          y: 0
+        });
+        var onChange = function (slider, _thumb, value) {
+          emitWith(slider, paletteUpdate, { value: value });
+        };
+        var onInit = function (_slider, _thumb, spectrum, _value) {
+          setColour(spectrum.element.dom, toString(red));
+        };
+        var sliderBehaviours = derive$1([
+          Composing.config({ find: Optional.some }),
+          Focusing.config({})
+        ]);
+        return Slider.sketch({
+          dom: {
+            tag: 'div',
+            attributes: { role: 'presentation' },
+            classes: [getClass('sv-palette')]
+          },
+          model: {
+            mode: 'xy',
+            getInitialValue: getInitialValue
+          },
+          rounded: false,
+          components: [
+            spectrumPart,
+            thumbPart
+          ],
+          onChange: onChange,
+          onInit: onInit,
+          sliderBehaviours: sliderBehaviours
+        });
+      };
+      var saturationBrightnessPaletteSketcher = single({
+        factory: factory,
+        name: 'SaturationBrightnessPalette',
+        configFields: [],
+        apis: {
+          setHue: function (_apis, slider, hue) {
+            setPaletteHue(slider, hue);
+          },
+          setThumb: function (_apis, slider, hex) {
+            setPaletteThumb(slider, hex);
+          }
+        },
+        extraApis: {}
+      });
+      return saturationBrightnessPaletteSketcher;
+    };
+
+    var makeFactory = function (translate, getClass) {
+      var factory = function (detail) {
+        var rgbForm = rgbFormFactory(translate, getClass, detail.onValidHex, detail.onInvalidHex);
+        var sbPalette = paletteFactory(translate, getClass);
+        var hueSliderToDegrees = function (hue) {
+          return (100 - hue) / 100 * 360;
+        };
+        var hueDegreesToSlider = function (hue) {
+          return 100 - hue / 360 * 100;
+        };
+        var state = {
+          paletteRgba: Cell(red),
+          paletteHue: Cell(0)
+        };
+        var memSlider = record(sliderFactory(translate, getClass));
+        var memPalette = record(sbPalette.sketch({}));
+        var memRgb = record(rgbForm.sketch({}));
+        var updatePalette = function (anyInSystem, _hex, hue) {
+          memPalette.getOpt(anyInSystem).each(function (palette) {
+            sbPalette.setHue(palette, hue);
+          });
+        };
+        var updateFields = function (anyInSystem, hex) {
+          memRgb.getOpt(anyInSystem).each(function (form) {
+            rgbForm.updateHex(form, hex);
+          });
+        };
+        var updateSlider = function (anyInSystem, _hex, hue) {
+          memSlider.getOpt(anyInSystem).each(function (slider) {
+            Slider.setValue(slider, { y: hueDegreesToSlider(hue) });
+          });
+        };
+        var updatePaletteThumb = function (anyInSystem, hex) {
+          memPalette.getOpt(anyInSystem).each(function (palette) {
+            sbPalette.setThumb(palette, hex);
+          });
+        };
+        var updateState = function (hex, hue) {
+          var rgba = fromHex(hex);
+          state.paletteRgba.set(rgba);
+          state.paletteHue.set(hue);
+        };
+        var runUpdates = function (anyInSystem, hex, hue, updates) {
+          updateState(hex, hue);
+          each$1(updates, function (update) {
+            update(anyInSystem, hex, hue);
+          });
+        };
+        var onPaletteUpdate = function () {
+          var updates = [updateFields];
+          return function (form, simulatedEvent) {
+            var value = simulatedEvent.event.value;
+            var oldHue = state.paletteHue.get();
+            var newHsv = hsvColour(oldHue, value.x, 100 - value.y);
+            var newHex = hsvToHex(newHsv);
+            runUpdates(form, newHex, oldHue, updates);
+          };
+        };
+        var onSliderUpdate = function () {
+          var updates = [
+            updatePalette,
+            updateFields
+          ];
+          return function (form, simulatedEvent) {
+            var hue = hueSliderToDegrees(simulatedEvent.event.value.y);
+            var oldRgb = state.paletteRgba.get();
+            var oldHsv = fromRgb(oldRgb);
+            var newHsv = hsvColour(hue, oldHsv.saturation, oldHsv.value);
+            var newHex = hsvToHex(newHsv);
+            runUpdates(form, newHex, hue, updates);
+          };
+        };
+        var onFieldsUpdate = function () {
+          var updates = [
+            updatePalette,
+            updateSlider,
+            updatePaletteThumb
+          ];
+          return function (form, simulatedEvent) {
+            var hex = simulatedEvent.event.hex;
+            var hsv = hexToHsv(hex);
+            runUpdates(form, hex, hsv.hue, updates);
+          };
+        };
+        return {
+          uid: detail.uid,
+          dom: detail.dom,
+          components: [
+            memPalette.asSpec(),
+            memSlider.asSpec(),
+            memRgb.asSpec()
+          ],
+          behaviours: derive$1([
+            config('colour-picker-events', [
+              run$1(fieldsUpdate, onFieldsUpdate()),
+              run$1(paletteUpdate, onPaletteUpdate()),
+              run$1(sliderUpdate, onSliderUpdate())
+            ]),
+            Composing.config({
+              find: function (comp) {
+                return memRgb.getOpt(comp);
+              }
+            }),
+            Keying.config({ mode: 'acyclic' })
+          ])
+        };
+      };
+      var colourPickerSketcher = single({
+        name: 'ColourPicker',
+        configFields: [
+          required$1('dom'),
+          defaulted('onValidHex', noop),
+          defaulted('onInvalidHex', noop)
+        ],
+        factory: factory
+      });
+      return colourPickerSketcher;
+    };
+
+    var self$1 = function () {
+      return Composing.config({ find: Optional.some });
+    };
+    var memento$1 = function (mem) {
+      return Composing.config({ find: mem.getOpt });
+    };
+    var childAt = function (index) {
+      return Composing.config({
+        find: function (comp) {
+          return child$2(comp.element, index).bind(function (element) {
+            return comp.getSystem().getByDom(element).toOptional();
+          });
+        }
+      });
+    };
+    var ComposingConfigs = {
+      self: self$1,
+      memento: memento$1,
+      childAt: childAt
+    };
+
+    var english = {
+      'colorcustom.rgb.red.label': 'R',
+      'colorcustom.rgb.red.description': 'Red component',
+      'colorcustom.rgb.green.label': 'G',
+      'colorcustom.rgb.green.description': 'Green component',
+      'colorcustom.rgb.blue.label': 'B',
+      'colorcustom.rgb.blue.description': 'Blue component',
+      'colorcustom.rgb.hex.label': '#',
+      'colorcustom.rgb.hex.description': 'Hex color code',
+      'colorcustom.rgb.range': 'Range 0 to 255',
+      'colorcustom.sb.saturation': 'Saturation',
+      'colorcustom.sb.brightness': 'Brightness',
+      'colorcustom.sb.picker': 'Saturation and Brightness Picker',
+      'colorcustom.sb.palette': 'Saturation and Brightness Palette',
+      'colorcustom.sb.instructions': 'Use arrow keys to select saturation and brightness, on x and y axes',
+      'colorcustom.hue.hue': 'Hue',
+      'colorcustom.hue.slider': 'Hue Slider',
+      'colorcustom.hue.palette': 'Hue Palette',
+      'colorcustom.hue.instructions': 'Use arrow keys to select a hue',
+      'aria.color.picker': 'Color Picker',
+      'aria.input.invalid': 'Invalid input'
+    };
+    var getEnglishText = function (key) {
+      return english[key];
+    };
+    var translate$1 = function (key) {
+      return getEnglishText(key);
+    };
+    var renderColorPicker = function (_spec) {
+      var getClass = function (key) {
+        return 'tox-' + key;
+      };
+      var colourPickerFactory = makeFactory(translate$1, getClass);
+      var onValidHex = function (form) {
+        emitWith(form, formActionEvent, {
+          name: 'hex-valid',
+          value: true
+        });
+      };
+      var onInvalidHex = function (form) {
+        emitWith(form, formActionEvent, {
+          name: 'hex-valid',
+          value: false
+        });
+      };
+      var memPicker = record(colourPickerFactory.sketch({
+        dom: {
+          tag: 'div',
+          classes: [getClass('color-picker-container')],
+          attributes: { role: 'presentation' }
+        },
+        onValidHex: onValidHex,
+        onInvalidHex: onInvalidHex
+      }));
+      return {
+        dom: { tag: 'div' },
+        components: [memPicker.asSpec()],
+        behaviours: derive$1([
+          Representing.config({
+            store: {
+              mode: 'manual',
+              getValue: function (comp) {
+                var picker = memPicker.get(comp);
+                var optRgbForm = Composing.getCurrent(picker);
+                var optHex = optRgbForm.bind(function (rgbForm) {
+                  var formValues = Representing.getValue(rgbForm);
+                  return formValues.hex;
+                });
+                return optHex.map(function (hex) {
+                  return '#' + hex;
+                }).getOr('');
+              },
+              setValue: function (comp, newValue) {
+                var pattern = /^#([a-fA-F0-9]{3}(?:[a-fA-F0-9]{3})?)/;
+                var m = pattern.exec(newValue);
+                var picker = memPicker.get(comp);
+                var optRgbForm = Composing.getCurrent(picker);
+                optRgbForm.fold(function () {
+                  console.log('Can not find form');
+                }, function (rgbForm) {
+                  Representing.setValue(rgbForm, { hex: Optional.from(m[1]).getOr('') });
+                  Form.getField(rgbForm, 'hex').each(function (hexField) {
+                    emit(hexField, input());
+                  });
+                });
+              }
+            }
+          }),
+          ComposingConfigs.self()
+        ])
+      };
+    };
+
+    var global$6 = tinymce.util.Tools.resolve('tinymce.Resource');
+
+    var isOldCustomEditor = function (spec) {
+      return has$2(spec, 'init');
+    };
+    var renderCustomEditor = function (spec) {
+      var editorApi = value$1();
+      var memReplaced = record({ dom: { tag: spec.tag } });
+      var initialValue = value$1();
+      return {
+        dom: {
+          tag: 'div',
+          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$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);
+                  });
+                  initialValue.clear();
+                  editorApi.set(ea);
+                });
+              });
+            })]),
+          Representing.config({
+            store: {
+              mode: 'manual',
+              getValue: function () {
+                return editorApi.get().fold(function () {
+                  return initialValue.get().getOr('');
+                }, function (ed) {
+                  return ed.getValue();
+                });
+              },
+              setValue: function (component, value) {
+                editorApi.get().fold(function () {
+                  initialValue.set(value);
+                }, function (ed) {
+                  return ed.setValue(value);
+                });
+              }
+            }
+          }),
+          ComposingConfigs.self()
+        ]),
+        components: [memReplaced.asSpec()]
+      };
+    };
+
+    var global$5 = tinymce.util.Tools.resolve('tinymce.util.Tools');
+
+    var processors = objOf([
+      defaulted('preprocess', identity$1),
+      defaulted('postprocess', identity$1)
+    ]);
+    var memento = function (mem, rawProcessors) {
+      var ps = asRawOrDie$1('RepresentingConfigs.memento processors', processors, rawProcessors);
+      return Representing.config({
+        store: {
+          mode: 'manual',
+          getValue: function (comp) {
+            var other = mem.get(comp);
+            var rawValue = Representing.getValue(other);
+            return ps.postprocess(rawValue);
+          },
+          setValue: function (comp, rawValue) {
+            var newValue = ps.preprocess(rawValue);
+            var other = mem.get(comp);
+            Representing.setValue(other, newValue);
+          }
+        }
+      });
+    };
+    var withComp = function (optInitialValue, getter, setter) {
+      return Representing.config(deepMerge({
+        store: {
+          mode: 'manual',
+          getValue: getter,
+          setValue: setter
+        }
+      }, optInitialValue.map(function (initialValue) {
+        return { store: { initialValue: initialValue } };
+      }).getOr({})));
+    };
+    var withElement = function (initialValue, getter, setter) {
+      return withComp(initialValue, function (c) {
+        return getter(c.element);
+      }, function (c, v) {
+        return setter(c.element, v);
+      });
+    };
+    var domValue = function (optInitialValue) {
+      return withElement(optInitialValue, get$5, set$4);
+    };
+    var domHtml = function (optInitialValue) {
+      return withElement(optInitialValue, get$7, set$5);
+    };
+    var memory = function (initialValue) {
+      return Representing.config({
+        store: {
+          mode: 'memory',
+          initialValue: initialValue
+        }
+      });
+    };
+    var RepresentingConfigs = {
+      memento: memento,
+      withElement: withElement,
+      withComp: withComp,
+      domValue: domValue,
+      domHtml: domHtml,
+      memory: memory
+    };
+
+    var defaultImageFileTypes = 'jpeg,jpg,jpe,jfi,jif,jfif,png,gif,bmp,webp';
+    var filterByExtension = function (files, providersBackstage) {
+      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());
+        });
+      };
+      return filter$2(from(files), isFileInAllowedTypes);
+    };
+    var renderDropZone = function (spec, providersBackstage) {
+      var stopper = function (_, se) {
+        se.stop();
+      };
+      var sequence = function (actions) {
+        return function (comp, se) {
+          each$1(actions, function (a) {
+            a(comp, se);
+          });
+        };
+      };
+      var onDrop = function (comp, se) {
+        if (!Disabling.isDisabled(comp)) {
+          var transferEvent = se.event.raw;
+          handleFiles(comp, transferEvent.dataTransfer.files);
+        }
+      };
+      var onSelect = function (component, simulatedEvent) {
+        var input = simulatedEvent.event.raw.target;
+        handleFiles(component, input.files);
+      };
+      var handleFiles = function (component, files) {
+        Representing.setValue(component, filterByExtension(files, providersBackstage));
+        emitWith(component, formChangeEvent, { name: spec.name });
+      };
+      var memInput = record({
+        dom: {
+          tag: 'input',
+          attributes: {
+            type: 'file',
+            accept: 'image/*'
+          },
+          styles: { display: 'none' }
+        },
+        behaviours: derive$1([config('input-file-events', [
+            cutter(click()),
+            cutter(tap())
+          ])])
+      });
+      var renderField = function (s) {
+        return {
+          uid: s.uid,
+          dom: {
+            tag: 'div',
+            classes: ['tox-dropzone-container']
+          },
+          behaviours: derive$1([
+            RepresentingConfigs.memory([]),
+            ComposingConfigs.self(),
+            Disabling.config({}),
+            Toggling.config({
+              toggleClass: 'dragenter',
+              toggleOnExecute: false
+            }),
+            config('dropzone-events', [
+              run$1('dragenter', sequence([
+                stopper,
+                Toggling.toggle
+              ])),
+              run$1('dragleave', sequence([
+                stopper,
+                Toggling.toggle
+              ])),
+              run$1('dragover', stopper),
+              run$1('drop', sequence([
+                stopper,
+                onDrop
+              ])),
+              run$1(change(), onSelect)
+            ])
+          ]),
+          components: [{
+              dom: {
+                tag: 'div',
+                classes: ['tox-dropzone'],
+                styles: {}
+              },
+              components: [
+                {
+                  dom: {
+                    tag: 'p',
+                    innerHtml: providersBackstage.translate('Drop an image here')
+                  }
+                },
+                Button.sketch({
+                  dom: {
+                    tag: 'button',
+                    innerHtml: providersBackstage.translate('Browse for an image'),
+                    styles: { position: 'relative' },
+                    classes: [
+                      'tox-button',
+                      'tox-button--secondary'
+                    ]
+                  },
+                  components: [memInput.asSpec()],
+                  action: function (comp) {
+                    var inputComp = memInput.get(comp);
+                    inputComp.element.dom.click();
+                  },
+                  buttonBehaviours: derive$1([
+                    Tabstopping.config({}),
+                    DisablingConfigs.button(providersBackstage.isDisabled),
+                    receivingConfig()
+                  ])
+                })
+              ]
+            }]
+        };
+      };
+      var pLabel = spec.label.map(function (label) {
+        return renderLabel$2(label, providersBackstage);
+      });
+      var pField = FormField.parts.field({ factory: { sketch: renderField } });
+      return renderFormFieldWith(pLabel, pField, ['tox-form__group--stretched'], []);
+    };
+
+    var renderGrid = function (spec, backstage) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: [
+            'tox-form__grid',
+            'tox-form__grid--' + spec.columns + 'col'
+          ]
+        },
+        components: map$2(spec.items, backstage.interpreter)
+      };
+    };
+
+    var beforeObject = generate$6('alloy-fake-before-tabstop');
+    var afterObject = generate$6('alloy-fake-after-tabstop');
+    var craftWithClasses = function (classes) {
+      return {
+        dom: {
+          tag: 'div',
+          styles: {
+            width: '1px',
+            height: '1px',
+            outline: 'none'
+          },
+          attributes: { tabindex: '0' },
+          classes: classes
+        },
+        behaviours: derive$1([
+          Focusing.config({ ignore: true }),
+          Tabstopping.config({})
+        ])
+      };
+    };
+    var craft = function (spec) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: ['tox-navobj']
+        },
+        components: [
+          craftWithClasses([beforeObject]),
+          spec,
+          craftWithClasses([afterObject])
+        ],
+        behaviours: derive$1([ComposingConfigs.childAt(1)])
+      };
+    };
+    var triggerTab = function (placeholder, shiftKey) {
+      emitWith(placeholder, keydown(), {
+        raw: {
+          which: 9,
+          shiftKey: shiftKey
+        }
+      });
+    };
+    var onFocus = function (container, targetComp) {
+      var target = targetComp.element;
+      if (has(target, beforeObject)) {
+        triggerTab(container, true);
+      } else if (has(target, afterObject)) {
+        triggerTab(container, false);
+      }
+    };
+    var isPseudoStop = function (element) {
+      return closest(element, [
+        '.' + beforeObject,
+        '.' + afterObject
+      ].join(','), never);
+    };
+
+    var platformNeedsSandboxing = !(detect$1().browser.isIE() || detect$1().browser.isEdge());
+    var getDynamicSource = function (isSandbox) {
+      var cachedValue = Cell('');
+      return {
+        getValue: function (_frameComponent) {
+          return cachedValue.get();
+        },
+        setValue: function (frameComponent, html) {
+          if (!isSandbox) {
+            set$8(frameComponent.element, 'src', 'javascript:\'\'');
+            var doc = frameComponent.element.dom.contentWindow.document;
+            doc.open();
+            doc.write(html);
+            doc.close();
+          } else {
+            set$8(frameComponent.element, 'srcdoc', html);
+          }
+          cachedValue.set(html);
+        }
+      };
+    };
+    var renderIFrame = function (spec, providersBackstage) {
+      var isSandbox = platformNeedsSandboxing && spec.sandboxed;
+      var attributes = __assign(__assign({}, spec.label.map(function (title) {
+        return { title: title };
+      }).getOr({})), isSandbox ? { sandbox: 'allow-scripts allow-same-origin' } : {});
+      var sourcing = getDynamicSource(isSandbox);
+      var pLabel = spec.label.map(function (label) {
+        return renderLabel$2(label, providersBackstage);
+      });
+      var factory = function (newSpec) {
+        return craft({
+          uid: newSpec.uid,
+          dom: {
+            tag: 'iframe',
+            attributes: attributes
+          },
+          behaviours: derive$1([
+            Tabstopping.config({}),
+            Focusing.config({}),
+            RepresentingConfigs.withComp(Optional.none(), sourcing.getValue, sourcing.setValue)
+          ])
+        });
+      };
+      var pField = FormField.parts.field({ factory: { sketch: factory } });
+      return renderFormFieldWith(pLabel, pField, ['tox-form__group--stretched'], []);
+    };
+
+    var create$4 = function (width, height) {
+      return resize$3(document.createElement('canvas'), width, height);
+    };
+    var clone$1 = function (canvas) {
+      var tCanvas = create$4(canvas.width, canvas.height);
+      var ctx = get2dContext(tCanvas);
+      ctx.drawImage(canvas, 0, 0);
+      return tCanvas;
+    };
+    var get2dContext = function (canvas) {
+      return canvas.getContext('2d');
+    };
+    var resize$3 = function (canvas, width, height) {
+      canvas.width = width;
+      canvas.height = height;
+      return canvas;
+    };
+
+    var getWidth$1 = function (image) {
+      return image.naturalWidth || image.width;
+    };
+    var getHeight$1 = function (image) {
+      return image.naturalHeight || image.height;
+    };
+
+    var blobToImage = function (blob) {
+      return new Promise$1(function (resolve, reject) {
+        var blobUrl = URL.createObjectURL(blob);
+        var image = new Image();
+        var removeListeners = function () {
+          image.removeEventListener('load', loaded);
+          image.removeEventListener('error', error);
+        };
+        var loaded = function () {
+          removeListeners();
+          resolve(image);
+        };
+        var error = function () {
+          removeListeners();
+          reject('Unable to load data of type ' + blob.type + ': ' + blobUrl);
+        };
+        image.addEventListener('load', loaded);
+        image.addEventListener('error', error);
+        image.src = blobUrl;
+        if (image.complete) {
+          setTimeout(loaded, 0);
+        }
+      });
+    };
+    var dataUriToBlobSync = function (uri) {
+      var data = uri.split(',');
+      var matches = /data:([^;]+)/.exec(data[0]);
+      if (!matches) {
+        return Optional.none();
+      }
+      var mimetype = matches[1];
+      var base64 = data[1];
+      var sliceSize = 1024;
+      var byteCharacters = atob(base64);
+      var bytesLength = byteCharacters.length;
+      var slicesCount = Math.ceil(bytesLength / sliceSize);
+      var byteArrays = new Array(slicesCount);
+      for (var sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
+        var begin = sliceIndex * sliceSize;
+        var end = Math.min(begin + sliceSize, bytesLength);
+        var bytes = new Array(end - begin);
+        for (var offset = begin, i = 0; offset < end; ++i, ++offset) {
+          bytes[i] = byteCharacters[offset].charCodeAt(0);
+        }
+        byteArrays[sliceIndex] = new Uint8Array(bytes);
+      }
+      return Optional.some(new Blob(byteArrays, { type: mimetype }));
+    };
+    var dataUriToBlob = function (uri) {
+      return new Promise$1(function (resolve, reject) {
+        dataUriToBlobSync(uri).fold(function () {
+          reject('uri is not base64: ' + uri);
+        }, resolve);
+      });
+    };
+    var canvasToBlob = function (canvas, type, quality) {
+      type = type || 'image/png';
+      if (isFunction(HTMLCanvasElement.prototype.toBlob)) {
+        return new Promise$1(function (resolve, reject) {
+          canvas.toBlob(function (blob) {
+            if (blob) {
+              resolve(blob);
+            } else {
+              reject();
+            }
+          }, type, quality);
+        });
+      } else {
+        return dataUriToBlob(canvas.toDataURL(type, quality));
+      }
+    };
+    var canvasToDataURL = function (canvas, type, quality) {
+      type = type || 'image/png';
+      return canvas.toDataURL(type, quality);
+    };
+    var blobToCanvas = function (blob) {
+      return blobToImage(blob).then(function (image) {
+        revokeImageUrl(image);
+        var canvas = create$4(getWidth$1(image), getHeight$1(image));
+        var context = get2dContext(canvas);
+        context.drawImage(image, 0, 0);
+        return canvas;
+      });
+    };
+    var blobToDataUri = function (blob) {
+      return new Promise$1(function (resolve) {
+        var reader = new FileReader();
+        reader.onloadend = function () {
+          resolve(reader.result);
+        };
+        reader.readAsDataURL(blob);
+      });
+    };
+    var revokeImageUrl = function (image) {
+      URL.revokeObjectURL(image.src);
+    };
+
+    var create$3 = function (getCanvas, blob, uri) {
+      var initialType = blob.type;
+      var getType = constant$1(initialType);
+      var toBlob = function () {
+        return Promise$1.resolve(blob);
+      };
+      var toDataURL = constant$1(uri);
+      var toBase64 = function () {
+        return uri.split(',')[1];
+      };
+      var toAdjustedBlob = function (type, quality) {
+        return getCanvas.then(function (canvas) {
+          return canvasToBlob(canvas, type, quality);
+        });
+      };
+      var toAdjustedDataURL = function (type, quality) {
+        return getCanvas.then(function (canvas) {
+          return canvasToDataURL(canvas, type, quality);
+        });
+      };
+      var toAdjustedBase64 = function (type, quality) {
+        return toAdjustedDataURL(type, quality).then(function (dataurl) {
+          return dataurl.split(',')[1];
+        });
+      };
+      var toCanvas = function () {
+        return getCanvas.then(clone$1);
+      };
+      return {
+        getType: getType,
+        toBlob: toBlob,
+        toDataURL: toDataURL,
+        toBase64: toBase64,
+        toAdjustedBlob: toAdjustedBlob,
+        toAdjustedDataURL: toAdjustedDataURL,
+        toAdjustedBase64: toAdjustedBase64,
+        toCanvas: toCanvas
+      };
+    };
+    var fromBlob = function (blob) {
+      return blobToDataUri(blob).then(function (uri) {
+        return create$3(blobToCanvas(blob), blob, uri);
+      });
+    };
+    var fromCanvas = function (canvas, type) {
+      return canvasToBlob(canvas, type).then(function (blob) {
+        return create$3(Promise$1.resolve(canvas), blob, canvas.toDataURL());
+      });
+    };
+
+    var blobToImageResult = function (blob) {
+      return fromBlob(blob);
+    };
+
+    var clamp = function (value, min, max) {
+      var parsedValue = typeof value === 'string' ? parseFloat(value) : value;
+      if (parsedValue > max) {
+        parsedValue = max;
+      } else if (parsedValue < min) {
+        parsedValue = min;
+      }
+      return parsedValue;
+    };
+    var identity = function () {
+      return [
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1
+      ];
+    };
+    var DELTA_INDEX = [
+      0,
+      0.01,
+      0.02,
+      0.04,
+      0.05,
+      0.06,
+      0.07,
+      0.08,
+      0.1,
+      0.11,
+      0.12,
+      0.14,
+      0.15,
+      0.16,
+      0.17,
+      0.18,
+      0.2,
+      0.21,
+      0.22,
+      0.24,
+      0.25,
+      0.27,
+      0.28,
+      0.3,
+      0.32,
+      0.34,
+      0.36,
+      0.38,
+      0.4,
+      0.42,
+      0.44,
+      0.46,
+      0.48,
+      0.5,
+      0.53,
+      0.56,
+      0.59,
+      0.62,
+      0.65,
+      0.68,
+      0.71,
+      0.74,
+      0.77,
+      0.8,
+      0.83,
+      0.86,
+      0.89,
+      0.92,
+      0.95,
+      0.98,
+      1,
+      1.06,
+      1.12,
+      1.18,
+      1.24,
+      1.3,
+      1.36,
+      1.42,
+      1.48,
+      1.54,
+      1.6,
+      1.66,
+      1.72,
+      1.78,
+      1.84,
+      1.9,
+      1.96,
+      2,
+      2.12,
+      2.25,
+      2.37,
+      2.5,
+      2.62,
+      2.75,
+      2.87,
+      3,
+      3.2,
+      3.4,
+      3.6,
+      3.8,
+      4,
+      4.3,
+      4.7,
+      4.9,
+      5,
+      5.5,
+      6,
+      6.5,
+      6.8,
+      7,
+      7.3,
+      7.5,
+      7.8,
+      8,
+      8.4,
+      8.7,
+      9,
+      9.4,
+      9.6,
+      9.8,
+      10
+    ];
+    var multiply = function (matrix1, matrix2) {
+      var col = [];
+      var out = new Array(25);
+      var val;
+      for (var i = 0; i < 5; i++) {
+        for (var j = 0; j < 5; j++) {
+          col[j] = matrix2[j + i * 5];
+        }
+        for (var j = 0; j < 5; j++) {
+          val = 0;
+          for (var k = 0; k < 5; k++) {
+            val += matrix1[j + k * 5] * col[k];
+          }
+          out[j + i * 5] = val;
+        }
+      }
+      return out;
+    };
+    var adjustContrast = function (matrix, value) {
+      var x;
+      value = clamp(value, -1, 1);
+      value *= 100;
+      if (value < 0) {
+        x = 127 + value / 100 * 127;
+      } else {
+        x = value % 1;
+        if (x === 0) {
+          x = DELTA_INDEX[value];
+        } else {
+          x = DELTA_INDEX[Math.floor(value)] * (1 - x) + DELTA_INDEX[Math.floor(value) + 1] * x;
+        }
+        x = x * 127 + 127;
+      }
+      return multiply(matrix, [
+        x / 127,
+        0,
+        0,
+        0,
+        0.5 * (127 - x),
+        0,
+        x / 127,
+        0,
+        0,
+        0.5 * (127 - x),
+        0,
+        0,
+        x / 127,
+        0,
+        0.5 * (127 - x),
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1
+      ]);
+    };
+    var adjustBrightness = function (matrix, value) {
+      value = clamp(255 * value, -255, 255);
+      return multiply(matrix, [
+        1,
+        0,
+        0,
+        0,
+        value,
+        0,
+        1,
+        0,
+        0,
+        value,
+        0,
+        0,
+        1,
+        0,
+        value,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1
+      ]);
+    };
+    var adjustColors = function (matrix, adjustR, adjustG, adjustB) {
+      adjustR = clamp(adjustR, 0, 2);
+      adjustG = clamp(adjustG, 0, 2);
+      adjustB = clamp(adjustB, 0, 2);
+      return multiply(matrix, [
+        adjustR,
+        0,
+        0,
+        0,
+        0,
+        0,
+        adjustG,
+        0,
+        0,
+        0,
+        0,
+        0,
+        adjustB,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1
+      ]);
+    };
+
+    var colorFilter = function (ir, matrix) {
+      return ir.toCanvas().then(function (canvas) {
+        return applyColorFilter(canvas, ir.getType(), matrix);
+      });
+    };
+    var applyColorFilter = function (canvas, type, matrix) {
+      var context = get2dContext(canvas);
+      var applyMatrix = function (pixelsData, m) {
+        var r, g, b, a;
+        var data = pixelsData.data, m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3], m4 = m[4], m5 = m[5], m6 = m[6], m7 = m[7], m8 = m[8], m9 = m[9], m10 = m[10], m11 = m[11], m12 = m[12], m13 = m[13], m14 = m[14], m15 = m[15], m16 = m[16], m17 = m[17], m18 = m[18], m19 = m[19];
+        for (var i = 0; i < data.length; i += 4) {
+          r = data[i];
+          g = data[i + 1];
+          b = data[i + 2];
+          a = data[i + 3];
+          data[i] = r * m0 + g * m1 + b * m2 + a * m3 + m4;
+          data[i + 1] = r * m5 + g * m6 + b * m7 + a * m8 + m9;
+          data[i + 2] = r * m10 + g * m11 + b * m12 + a * m13 + m14;
+          data[i + 3] = r * m15 + g * m16 + b * m17 + a * m18 + m19;
+        }
+        return pixelsData;
+      };
+      var pixels = applyMatrix(context.getImageData(0, 0, canvas.width, canvas.height), matrix);
+      context.putImageData(pixels, 0, 0);
+      return fromCanvas(canvas, type);
+    };
+    var convoluteFilter = function (ir, matrix) {
+      return ir.toCanvas().then(function (canvas) {
+        return applyConvoluteFilter(canvas, ir.getType(), matrix);
+      });
+    };
+    var applyConvoluteFilter = function (canvas, type, matrix) {
+      var context = get2dContext(canvas);
+      var applyMatrix = function (pIn, pOut, aMatrix) {
+        var clamp = function (value, min, max) {
+          if (value > max) {
+            value = max;
+          } else if (value < min) {
+            value = min;
+          }
+          return value;
+        };
+        var side = Math.round(Math.sqrt(aMatrix.length));
+        var halfSide = Math.floor(side / 2);
+        var rgba = pIn.data;
+        var drgba = pOut.data;
+        var w = pIn.width;
+        var h = pIn.height;
+        for (var y = 0; y < h; y++) {
+          for (var x = 0; x < w; x++) {
+            var r = 0;
+            var g = 0;
+            var b = 0;
+            for (var cy = 0; cy < side; cy++) {
+              for (var cx = 0; cx < side; cx++) {
+                var scx = clamp(x + cx - halfSide, 0, w - 1);
+                var scy = clamp(y + cy - halfSide, 0, h - 1);
+                var innerOffset = (scy * w + scx) * 4;
+                var wt = aMatrix[cy * side + cx];
+                r += rgba[innerOffset] * wt;
+                g += rgba[innerOffset + 1] * wt;
+                b += rgba[innerOffset + 2] * wt;
+              }
+            }
+            var offset = (y * w + x) * 4;
+            drgba[offset] = clamp(r, 0, 255);
+            drgba[offset + 1] = clamp(g, 0, 255);
+            drgba[offset + 2] = clamp(b, 0, 255);
+          }
+        }
+        return pOut;
+      };
+      var pixelsIn = context.getImageData(0, 0, canvas.width, canvas.height);
+      var pixelsOut = context.getImageData(0, 0, canvas.width, canvas.height);
+      pixelsOut = applyMatrix(pixelsIn, pixelsOut, matrix);
+      context.putImageData(pixelsOut, 0, 0);
+      return fromCanvas(canvas, type);
+    };
+    var functionColorFilter = function (colorFn) {
+      var filterImpl = function (canvas, type, value) {
+        var context = get2dContext(canvas);
+        var lookup = new Array(256);
+        var applyLookup = function (pixelsData, lookupData) {
+          var data = pixelsData.data;
+          for (var i = 0; i < data.length; i += 4) {
+            data[i] = lookupData[data[i]];
+            data[i + 1] = lookupData[data[i + 1]];
+            data[i + 2] = lookupData[data[i + 2]];
+          }
+          return pixelsData;
+        };
+        for (var i = 0; i < lookup.length; i++) {
+          lookup[i] = colorFn(i, value);
+        }
+        var pixels = applyLookup(context.getImageData(0, 0, canvas.width, canvas.height), lookup);
+        context.putImageData(pixels, 0, 0);
+        return fromCanvas(canvas, type);
+      };
+      return function (ir, value) {
+        return ir.toCanvas().then(function (canvas) {
+          return filterImpl(canvas, ir.getType(), value);
+        });
+      };
+    };
+    var complexAdjustableColorFilter = function (matrixAdjustFn) {
+      return function (ir, adjust) {
+        return colorFilter(ir, matrixAdjustFn(identity(), adjust));
+      };
+    };
+    var basicColorFilter = function (matrix) {
+      return function (ir) {
+        return colorFilter(ir, matrix);
+      };
+    };
+    var basicConvolutionFilter = function (kernel) {
+      return function (ir) {
+        return convoluteFilter(ir, kernel);
+      };
+    };
+    var invert$1 = basicColorFilter([
+      -1,
+      0,
+      0,
+      0,
+      255,
+      0,
+      -1,
+      0,
+      0,
+      255,
+      0,
+      0,
+      -1,
+      0,
+      255,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1
+    ]);
+    var brightness$1 = complexAdjustableColorFilter(adjustBrightness);
+    var contrast$1 = complexAdjustableColorFilter(adjustContrast);
+    var colorize$1 = function (ir, adjustR, adjustG, adjustB) {
+      return colorFilter(ir, adjustColors(identity(), adjustR, adjustG, adjustB));
+    };
+    var sharpen$1 = basicConvolutionFilter([
+      0,
+      -1,
+      0,
+      -1,
+      5,
+      -1,
+      0,
+      -1,
+      0
+    ]);
+    var gamma$1 = functionColorFilter(function (color, value) {
+      return Math.pow(color / 255, 1 - value) * 255;
+    });
+
+    var scale = function (image, dW, dH) {
+      var sW = getWidth$1(image);
+      var sH = getHeight$1(image);
+      var wRatio = dW / sW;
+      var hRatio = dH / sH;
+      var scaleCapped = false;
+      if (wRatio < 0.5 || wRatio > 2) {
+        wRatio = wRatio < 0.5 ? 0.5 : 2;
+        scaleCapped = true;
+      }
+      if (hRatio < 0.5 || hRatio > 2) {
+        hRatio = hRatio < 0.5 ? 0.5 : 2;
+        scaleCapped = true;
+      }
+      var scaled = _scale(image, wRatio, hRatio);
+      return !scaleCapped ? scaled : scaled.then(function (tCanvas) {
+        return scale(tCanvas, dW, dH);
+      });
+    };
+    var _scale = function (image, wRatio, hRatio) {
+      return new Promise$1(function (resolve) {
+        var sW = getWidth$1(image);
+        var sH = getHeight$1(image);
+        var dW = Math.floor(sW * wRatio);
+        var dH = Math.floor(sH * hRatio);
+        var canvas = create$4(dW, dH);
+        var context = get2dContext(canvas);
+        context.drawImage(image, 0, 0, sW, sH, 0, 0, dW, dH);
+        resolve(canvas);
+      });
+    };
+
+    var ceilWithPrecision = function (num, precision) {
+      if (precision === void 0) {
+        precision = 2;
+      }
+      var mul = Math.pow(10, precision);
+      var upper = Math.round(num * mul);
+      return Math.ceil(upper / mul);
+    };
+    var rotate$1 = function (ir, angle) {
+      return ir.toCanvas().then(function (canvas) {
+        return applyRotate(canvas, ir.getType(), angle);
+      });
+    };
+    var applyRotate = function (image, type, angle) {
+      var degrees = angle < 0 ? 360 + angle : angle;
+      var rad = degrees * Math.PI / 180;
+      var width = image.width;
+      var height = image.height;
+      var sin = Math.sin(rad);
+      var cos = Math.cos(rad);
+      var newWidth = ceilWithPrecision(Math.abs(width * cos) + Math.abs(height * sin));
+      var newHeight = ceilWithPrecision(Math.abs(width * sin) + Math.abs(height * cos));
+      var canvas = create$4(newWidth, newHeight);
+      var context = get2dContext(canvas);
+      context.translate(newWidth / 2, newHeight / 2);
+      context.rotate(rad);
+      context.drawImage(image, -width / 2, -height / 2);
+      return fromCanvas(canvas, type);
+    };
+    var flip$1 = function (ir, axis) {
+      return ir.toCanvas().then(function (canvas) {
+        return applyFlip(canvas, ir.getType(), axis);
+      });
+    };
+    var applyFlip = function (image, type, axis) {
+      var canvas = create$4(image.width, image.height);
+      var context = get2dContext(canvas);
+      if (axis === 'v') {
+        context.scale(1, -1);
+        context.drawImage(image, 0, -canvas.height);
+      } else {
+        context.scale(-1, 1);
+        context.drawImage(image, -canvas.width, 0);
+      }
+      return fromCanvas(canvas, type);
+    };
+    var crop$1 = function (ir, x, y, w, h) {
+      return ir.toCanvas().then(function (canvas) {
+        return applyCrop(canvas, ir.getType(), x, y, w, h);
+      });
+    };
+    var applyCrop = function (image, type, x, y, w, h) {
+      var canvas = create$4(w, h);
+      var context = get2dContext(canvas);
+      context.drawImage(image, -x, -y);
+      return fromCanvas(canvas, type);
+    };
+    var resize$2 = function (ir, w, h) {
+      return ir.toCanvas().then(function (canvas) {
+        return scale(canvas, w, h).then(function (newCanvas) {
+          return fromCanvas(newCanvas, ir.getType());
+        });
+      });
+    };
+
+    var invert = function (ir) {
+      return invert$1(ir);
+    };
+    var sharpen = function (ir) {
+      return sharpen$1(ir);
+    };
+    var gamma = function (ir, value) {
+      return gamma$1(ir, value);
+    };
+    var colorize = function (ir, adjustR, adjustG, adjustB) {
+      return colorize$1(ir, adjustR, adjustG, adjustB);
+    };
+    var brightness = function (ir, adjust) {
+      return brightness$1(ir, adjust);
+    };
+    var contrast = function (ir, adjust) {
+      return contrast$1(ir, adjust);
+    };
+    var flip = function (ir, axis) {
+      return flip$1(ir, axis);
+    };
+    var crop = function (ir, x, y, w, h) {
+      return crop$1(ir, x, y, w, h);
+    };
+    var resize$1 = function (ir, w, h) {
+      return resize$2(ir, w, h);
+    };
+    var rotate = function (ir, angle) {
+      return rotate$1(ir, angle);
+    };
+
+    var renderIcon = function (iconName, iconsProvider, behaviours) {
+      return render$3(iconName, {
+        tag: 'span',
+        classes: [
+          'tox-icon',
+          'tox-tbtn__icon-wrap'
+        ],
+        behaviours: behaviours
+      }, iconsProvider);
+    };
+    var renderIconFromPack = function (iconName, iconsProvider) {
+      return renderIcon(iconName, iconsProvider, []);
+    };
+    var renderReplacableIconFromPack = function (iconName, iconsProvider) {
+      return renderIcon(iconName, iconsProvider, [Replacing.config({})]);
+    };
+    var renderLabel$1 = function (text, prefix, providersBackstage) {
+      return {
+        dom: {
+          tag: 'span',
+          innerHtml: providersBackstage.translate(text),
+          classes: [prefix + '__select-label']
+        },
+        behaviours: derive$1([Replacing.config({})])
+      };
+    };
+
+    var _a;
+    var internalToolbarButtonExecute = generate$6('toolbar.button.execute');
+    var onToolbarButtonExecute = function (info) {
+      return runOnExecute$1(function (comp, _simulatedEvent) {
+        runWithApi(info, comp)(function (itemApi) {
+          emitWith(comp, internalToolbarButtonExecute, { buttonApi: itemApi });
+          info.onAction(itemApi);
+        });
+      });
+    };
+    var toolbarButtonEventOrder = (_a = {}, _a[execute$5()] = [
+      'disabling',
+      'alloy.base.behaviour',
+      'toggling',
+      'toolbar-button-events'
+    ], _a);
+
+    var updateMenuText = generate$6('update-menu-text');
+    var updateMenuIcon = generate$6('update-menu-icon');
+    var renderCommonDropdown = function (spec, prefix, sharedBackstage) {
+      var editorOffCell = Cell(noop);
+      var optMemDisplayText = spec.text.map(function (text) {
+        return record(renderLabel$1(text, prefix, sharedBackstage.providers));
+      });
+      var optMemDisplayIcon = spec.icon.map(function (iconName) {
+        return record(renderReplacableIconFromPack(iconName, sharedBackstage.providers.icons));
+      });
+      var onLeftOrRightInMenu = function (comp, se) {
+        var dropdown = Representing.getValue(comp);
+        Focusing.focus(dropdown);
+        emitWith(dropdown, 'keydown', { raw: se.event.raw });
+        Dropdown.close(dropdown);
+        return Optional.some(true);
+      };
+      var role = spec.role.fold(function () {
+        return {};
+      }, function (role) {
+        return { role: role };
+      });
+      var tooltipAttributes = spec.tooltip.fold(function () {
+        return {};
+      }, function (tooltip) {
+        var translatedTooltip = sharedBackstage.providers.translate(tooltip);
+        return {
+          'title': translatedTooltip,
+          'aria-label': translatedTooltip
+        };
+      });
+      var iconSpec = render$3('chevron-down', {
+        tag: 'div',
+        classes: [prefix + '__select-chevron']
+      }, sharedBackstage.providers.icons);
+      var memDropdown = record(Dropdown.sketch(__assign(__assign(__assign({}, spec.uid ? { uid: spec.uid } : {}), role), {
+        dom: {
+          tag: 'button',
+          classes: [
+            prefix,
+            prefix + '--select'
+          ].concat(map$2(spec.classes, function (c) {
+            return prefix + '--' + c;
+          })),
+          attributes: __assign({}, tooltipAttributes)
+        },
+        components: componentRenderPipeline([
+          optMemDisplayIcon.map(function (mem) {
+            return mem.asSpec();
+          }),
+          optMemDisplayText.map(function (mem) {
+            return mem.asSpec();
+          }),
+          Optional.some(iconSpec)
+        ]),
+        matchWidth: true,
+        useMinWidth: true,
+        dropdownBehaviours: derive$1(__spreadArray(__spreadArray([], spec.dropdownBehaviours, true), [
+          DisablingConfigs.button(function () {
+            return spec.disabled || sharedBackstage.providers.isDisabled();
+          }),
+          receivingConfig(),
+          Unselecting.config({}),
+          Replacing.config({}),
+          config('dropdown-events', [
+            onControlAttached(spec, editorOffCell),
+            onControlDetached(spec, editorOffCell)
+          ]),
+          config('menubutton-update-display-text', [
+            run$1(updateMenuText, function (comp, se) {
+              optMemDisplayText.bind(function (mem) {
+                return mem.getOpt(comp);
+              }).each(function (displayText) {
+                Replacing.set(displayText, [text$1(sharedBackstage.providers.translate(se.event.text))]);
+              });
+            }),
+            run$1(updateMenuIcon, function (comp, se) {
+              optMemDisplayIcon.bind(function (mem) {
+                return mem.getOpt(comp);
+              }).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',
+            'normal-dropdown-events'
+          ]
+        }),
+        sandboxBehaviours: derive$1([Keying.config({
+            mode: 'special',
+            onLeft: onLeftOrRightInMenu,
+            onRight: onLeftOrRightInMenu
+          })]),
+        lazySink: sharedBackstage.getSink,
+        toggleClass: prefix + '--active',
+        parts: { menu: part(false, spec.columns, spec.presets) },
+        fetch: function (comp) {
+          return Future.nu(curry(spec.fetch, comp));
+        }
+      })));
+      return memDropdown.asSpec();
+    };
+
+    var isMenuItemReference = function (item) {
+      return isString(item);
+    };
+    var isSeparator$1 = function (item) {
+      return item.type === 'separator';
+    };
+    var isExpandingMenuItem = function (item) {
+      return has$2(item, 'getSubmenuItems');
+    };
+    var separator$2 = { type: 'separator' };
+    var unwrapReferences = function (items, menuItems) {
+      var realItems = foldl(items, function (acc, item) {
+        if (isMenuItemReference(item)) {
+          if (item === '') {
+            return acc;
+          } else if (item === '|') {
+            return acc.length > 0 && !isSeparator$1(acc[acc.length - 1]) ? acc.concat([separator$2]) : acc;
+          } else if (has$2(menuItems, item.toLowerCase())) {
+            return acc.concat([menuItems[item.toLowerCase()]]);
+          } else {
+            return acc;
+          }
+        } else {
+          return acc.concat([item]);
+        }
+      }, []);
+      if (realItems.length > 0 && isSeparator$1(realItems[realItems.length - 1])) {
+        realItems.pop();
+      }
+      return realItems;
+    };
+    var getFromExpandingItem = function (item, menuItems) {
+      var submenuItems = item.getSubmenuItems();
+      var rest = expand(submenuItems, menuItems);
+      var newMenus = deepMerge(rest.menus, wrap$1(item.value, rest.items));
+      var newExpansions = deepMerge(rest.expansions, wrap$1(item.value, item.value));
+      return {
+        item: item,
+        menus: newMenus,
+        expansions: newExpansions
+      };
+    };
+    var getFromItem = function (item, menuItems) {
+      return isExpandingMenuItem(item) ? getFromExpandingItem(item, menuItems) : {
+        item: item,
+        menus: {},
+        expansions: {}
+      };
+    };
+    var generateValueIfRequired = function (item) {
+      if (isSeparator$1(item)) {
+        return item;
+      } else {
+        var itemValue = get$e(item, 'value').getOrThunk(function () {
+          return generate$6('generated-menu-item');
+        });
+        return deepMerge({ value: itemValue }, item);
+      }
+    };
+    var expand = function (items, menuItems) {
+      var realItems = unwrapReferences(isString(items) ? items.split(' ') : items, menuItems);
+      return foldr(realItems, function (acc, item) {
+        var itemWithValue = generateValueIfRequired(item);
+        var newData = getFromItem(itemWithValue, menuItems);
+        return {
+          menus: deepMerge(acc.menus, newData.menus),
+          items: [newData.item].concat(acc.items),
+          expansions: deepMerge(acc.expansions, newData.expansions)
+        };
+      }, {
+        menus: {},
+        expansions: {},
+        items: []
+      });
+    };
+
+    var build = function (items, itemResponse, backstage, isHorizontalMenu) {
+      var primary = generate$6('primary-menu');
+      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$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));
+    };
+
+    var getMenuButtonApi = function (component) {
+      return {
+        isDisabled: function () {
+          return Disabling.isDisabled(component);
+        },
+        setDisabled: function (state) {
+          return Disabling.set(component, state);
+        },
+        setActive: function (state) {
+          var elm = component.element;
+          if (state) {
+            add$2(elm, 'tox-tbtn--enabled');
+            set$8(elm, 'aria-pressed', true);
+          } else {
+            remove$2(elm, 'tox-tbtn--enabled');
+            remove$7(elm, 'aria-pressed');
+          }
+        },
+        isActive: function () {
+          return has(component.element, 'tox-tbtn--enabled');
+        }
+      };
+    };
+    var renderMenuButton = function (spec, prefix, backstage, role) {
+      return renderCommonDropdown({
+        text: spec.text,
+        icon: spec.icon,
+        tooltip: spec.tooltip,
+        role: role,
+        fetch: function (_comp, callback) {
+          spec.fetch(function (items) {
+            callback(build(items, ItemResponse$1.CLOSE_ON_EXECUTE, backstage, false));
+          });
+        },
+        onSetup: spec.onSetup,
+        getApi: getMenuButtonApi,
+        columns: 1,
+        presets: 'normal',
+        classes: [],
+        dropdownBehaviours: [Tabstopping.config({})]
+      }, prefix, backstage.shared);
+    };
+    var getFetch = function (items, getButton, backstage) {
+      var getMenuItemAction = function (item) {
+        return function (api) {
+          var newValue = !api.isActive();
+          api.setActive(newValue);
+          item.storage.set(newValue);
+          backstage.shared.getSink().each(function (sink) {
+            getButton().getOpt(sink).each(function (orig) {
+              focus$3(orig.element);
+              emitWith(orig, formActionEvent, {
+                name: item.name,
+                value: item.storage.get()
+              });
+            });
+          });
+        };
+      };
+      var getMenuItemSetup = function (item) {
+        return function (api) {
+          api.setActive(item.storage.get());
+        };
+      };
+      return function (success) {
+        success(map$2(items, function (item) {
+          var text = item.text.fold(function () {
+            return {};
+          }, function (text) {
+            return { text: text };
+          });
+          return __assign(__assign({
+            type: item.type,
+            active: false
+          }, text), {
+            onAction: getMenuItemAction(item),
+            onSetup: getMenuItemSetup(item)
+          });
+        }));
+      };
+    };
+
+    var renderCommonSpec = function (spec, actionOpt, extraBehaviours, dom, components, providersBackstage) {
+      if (extraBehaviours === void 0) {
+        extraBehaviours = [];
+      }
+      var action = actionOpt.fold(function () {
+        return {};
+      }, function (action) {
+        return { action: action };
+      });
+      var common = __assign({
+        buttonBehaviours: derive$1([
+          DisablingConfigs.button(function () {
+            return spec.disabled || providersBackstage.isDisabled();
+          }),
+          receivingConfig(),
+          Tabstopping.config({}),
+          config('button press', [
+            preventDefault('click'),
+            preventDefault('mousedown')
+          ])
+        ].concat(extraBehaviours)),
+        eventOrder: {
+          click: [
+            'button press',
+            'alloy.base.behaviour'
+          ],
+          mousedown: [
+            'button press',
+            'alloy.base.behaviour'
+          ]
+        }
+      }, action);
+      var domFinal = deepMerge(common, { dom: dom });
+      return deepMerge(domFinal, { components: components });
+    };
+    var renderIconButtonSpec = function (spec, action, providersBackstage, extraBehaviours) {
+      if (extraBehaviours === void 0) {
+        extraBehaviours = [];
+      }
+      var tooltipAttributes = spec.tooltip.map(function (tooltip) {
+        return {
+          'aria-label': providersBackstage.translate(tooltip),
+          'title': providersBackstage.translate(tooltip)
+        };
+      }).getOr({});
+      var dom = {
+        tag: 'button',
+        classes: ['tox-tbtn'],
+        attributes: tooltipAttributes
+      };
+      var icon = spec.icon.map(function (iconName) {
+        return renderIconFromPack(iconName, providersBackstage.icons);
+      });
+      var components = componentRenderPipeline([icon]);
+      return renderCommonSpec(spec, action, extraBehaviours, dom, components, providersBackstage);
+    };
+    var renderIconButton = function (spec, action, providersBackstage, extraBehaviours) {
+      if (extraBehaviours === void 0) {
+        extraBehaviours = [];
+      }
+      var iconButtonSpec = renderIconButtonSpec(spec, Optional.some(action), providersBackstage, extraBehaviours);
+      return Button.sketch(iconButtonSpec);
+    };
+    var renderButtonSpec = function (spec, action, providersBackstage, extraBehaviours, extraClasses) {
+      if (extraBehaviours === void 0) {
+        extraBehaviours = [];
+      }
+      if (extraClasses === void 0) {
+        extraClasses = [];
+      }
+      var translatedText = providersBackstage.translate(spec.text);
+      var icon = spec.icon ? spec.icon.map(function (iconName) {
+        return renderIconFromPack(iconName, providersBackstage.icons);
+      }) : Optional.none();
+      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'], 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);
+    };
+    var renderButton = function (spec, action, providersBackstage, extraBehaviours, extraClasses) {
+      if (extraBehaviours === void 0) {
+        extraBehaviours = [];
+      }
+      if (extraClasses === void 0) {
+        extraClasses = [];
+      }
+      var buttonSpec = renderButtonSpec(spec, Optional.some(action), providersBackstage, extraBehaviours, extraClasses);
+      return Button.sketch(buttonSpec);
+    };
+    var getAction = function (name, buttonType) {
+      return function (comp) {
+        if (buttonType === 'custom') {
+          emitWith(comp, formActionEvent, {
+            name: name,
+            value: {}
+          });
+        } else if (buttonType === 'submit') {
+          emit(comp, formSubmitEvent);
+        } else if (buttonType === 'cancel') {
+          emit(comp, formCancelEvent);
+        } else {
+          console.error('Unknown button type: ', buttonType);
+        }
+      };
+    };
+    var isMenuFooterButtonSpec = function (spec, buttonType) {
+      return buttonType === 'menu';
+    };
+    var isNormalFooterButtonSpec = function (spec, buttonType) {
+      return buttonType === 'custom' || buttonType === 'cancel' || buttonType === 'submit';
+    };
+    var renderFooterButton = function (spec, buttonType, backstage) {
+      if (isMenuFooterButtonSpec(spec, buttonType)) {
+        var getButton = function () {
+          return memButton_1;
+        };
+        var menuButtonSpec = spec;
+        var fixedSpec = __assign(__assign({}, spec), {
+          onSetup: function (api) {
+            api.setDisabled(spec.disabled);
+            return noop;
+          },
+          fetch: getFetch(menuButtonSpec.items, getButton, backstage)
+        });
+        var memButton_1 = record(renderMenuButton(fixedSpec, 'tox-tbtn', backstage, Optional.none()));
+        return memButton_1.asSpec();
+      } else if (isNormalFooterButtonSpec(spec, buttonType)) {
+        var action = getAction(spec.name, buttonType);
+        var buttonSpec = __assign(__assign({}, spec), { borderless: false });
+        return renderButton(buttonSpec, action, backstage.shared.providers, []);
+      } else {
+        console.error('Unknown footer button type: ', buttonType);
+      }
+    };
+    var renderDialogButton = function (spec, providersBackstage) {
+      var action = getAction(spec.name, 'custom');
+      return renderFormField(Optional.none(), FormField.parts.field(__assign({ factory: Button }, renderButtonSpec(spec, Optional.some(action), providersBackstage, [
+        RepresentingConfigs.memory(''),
+        ComposingConfigs.self()
+      ]))));
+    };
+
+    var schema$h = constant$1([
+      defaulted('field1Name', 'field1'),
+      defaulted('field2Name', 'field2'),
+      onStrictHandler('onLockedChange'),
+      markers$1(['lockClass']),
+      defaulted('locked', false),
+      SketchBehaviours.field('coupledFieldBehaviours', [
+        Composing,
+        Representing
+      ])
+    ]);
+    var getField = function (comp, detail, partName) {
+      return getPart(comp, detail, partName).bind(Composing.getCurrent);
+    };
+    var coupledPart = function (selfName, otherName) {
+      return required({
+        factory: FormField,
+        name: selfName,
+        overrides: function (detail) {
+          return {
+            fieldBehaviours: derive$1([config('coupled-input-behaviour', [run$1(input(), function (me) {
+                  getField(me, detail, otherName).each(function (other) {
+                    getPart(me, detail, 'lock').each(function (lock) {
+                      if (Toggling.isOn(lock)) {
+                        detail.onLockedChange(me, other, lock);
+                      }
+                    });
+                  });
+                })])])
+          };
+        }
+      });
+    };
+    var parts$c = constant$1([
+      coupledPart('field1', 'field2'),
+      coupledPart('field2', 'field1'),
+      required({
+        factory: Button,
+        schema: [required$1('dom')],
+        name: 'lock',
+        overrides: function (detail) {
+          return {
+            buttonBehaviours: derive$1([Toggling.config({
+                selected: detail.locked,
+                toggleClass: detail.markers.lockClass,
+                aria: { mode: 'pressed' }
+              })])
+          };
+        }
+      })
+    ]);
+
+    var factory$f = function (detail, components, _spec, _externals) {
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: SketchBehaviours.augment(detail.coupledFieldBehaviours, [
+          Composing.config({ find: Optional.some }),
+          Representing.config({
+            store: {
+              mode: 'manual',
+              getValue: function (comp) {
+                var _a;
+                var parts = getPartsOrDie(comp, detail, [
+                  'field1',
+                  'field2'
+                ]);
+                return _a = {}, _a[detail.field1Name] = Representing.getValue(parts.field1()), _a[detail.field2Name] = Representing.getValue(parts.field2()), _a;
+              },
+              setValue: function (comp, value) {
+                var parts = getPartsOrDie(comp, detail, [
+                  'field1',
+                  'field2'
+                ]);
+                if (hasNonNullableKey(value, detail.field1Name)) {
+                  Representing.setValue(parts.field1(), value[detail.field1Name]);
+                }
+                if (hasNonNullableKey(value, detail.field2Name)) {
+                  Representing.setValue(parts.field2(), value[detail.field2Name]);
+                }
+              }
+            }
+          })
+        ]),
+        apis: {
+          getField1: function (component) {
+            return getPart(component, detail, 'field1');
+          },
+          getField2: function (component) {
+            return getPart(component, detail, 'field2');
+          },
+          getLock: function (component) {
+            return getPart(component, detail, 'lock');
+          }
+        }
+      };
+    };
+    var FormCoupledInputs = composite({
+      name: 'FormCoupledInputs',
+      configFields: schema$h(),
+      partFields: parts$c(),
+      factory: factory$f,
+      apis: {
+        getField1: function (apis, component) {
+          return apis.getField1(component);
+        },
+        getField2: function (apis, component) {
+          return apis.getField2(component);
+        },
+        getLock: function (apis, component) {
+          return apis.getLock(component);
+        }
+      }
+    });
+
+    var formatSize = function (size) {
+      var unitDec = {
+        '': 0,
+        'px': 0,
+        'pt': 1,
+        'mm': 1,
+        'pc': 2,
+        'ex': 2,
+        'em': 2,
+        'ch': 2,
+        'rem': 2,
+        'cm': 3,
+        'in': 4,
+        '%': 4
+      };
+      var maxDecimal = function (unit) {
+        return unit in unitDec ? unitDec[unit] : 1;
+      };
+      var numText = size.value.toFixed(maxDecimal(size.unit));
+      if (numText.indexOf('.') !== -1) {
+        numText = numText.replace(/\.?0*$/, '');
+      }
+      return numText + size.unit;
+    };
+    var parseSize = function (sizeText) {
+      var numPattern = /^\s*(\d+(?:\.\d+)?)\s*(|cm|mm|in|px|pt|pc|em|ex|ch|rem|vw|vh|vmin|vmax|%)\s*$/;
+      var match = numPattern.exec(sizeText);
+      if (match !== null) {
+        var value = parseFloat(match[1]);
+        var unit = match[2];
+        return Result.value({
+          value: value,
+          unit: unit
+        });
+      } else {
+        return Result.error(sizeText);
+      }
+    };
+    var convertUnit = function (size, unit) {
+      var inInch = {
+        '': 96,
+        'px': 96,
+        'pt': 72,
+        'cm': 2.54,
+        'pc': 12,
+        'mm': 25.4,
+        'in': 1
+      };
+      var supported = function (u) {
+        return has$2(inInch, u);
+      };
+      if (size.unit === unit) {
+        return Optional.some(size.value);
+      } else if (supported(size.unit) && supported(unit)) {
+        if (inInch[size.unit] === inInch[unit]) {
+          return Optional.some(size.value);
+        } else {
+          return Optional.some(size.value / inInch[size.unit] * inInch[unit]);
+        }
+      } else {
+        return Optional.none();
+      }
+    };
+    var noSizeConversion = function (_input) {
+      return Optional.none();
+    };
+    var ratioSizeConversion = function (scale, unit) {
+      return function (size) {
+        return convertUnit(size, unit).map(function (value) {
+          return {
+            value: value * scale,
+            unit: unit
+          };
+        });
+      };
+    };
+    var makeRatioConverter = function (currentFieldText, otherFieldText) {
+      var cValue = parseSize(currentFieldText).toOptional();
+      var oValue = parseSize(otherFieldText).toOptional();
+      return lift2(cValue, oValue, function (cSize, oSize) {
+        return convertUnit(cSize, oSize.unit).map(function (val) {
+          return oSize.value / val;
+        }).map(function (r) {
+          return ratioSizeConversion(r, oSize.unit);
+        }).getOr(noSizeConversion);
+      }).getOr(noSizeConversion);
+    };
+
+    var renderSizeInput = function (spec, providersBackstage) {
+      var converter = noSizeConversion;
+      var ratioEvent = generate$6('ratio-event');
+      var makeIcon = function (iconName) {
+        return render$3(iconName, {
+          tag: 'span',
+          classes: [
+            'tox-icon',
+            'tox-lock-icon__' + iconName
+          ]
+        }, providersBackstage.icons);
+      };
+      var pLock = FormCoupledInputs.parts.lock({
+        dom: {
+          tag: 'button',
+          classes: [
+            'tox-lock',
+            'tox-button',
+            'tox-button--naked',
+            'tox-button--icon'
+          ],
+          attributes: { title: providersBackstage.translate(spec.label.getOr('Constrain proportions')) }
+        },
+        components: [
+          makeIcon('lock'),
+          makeIcon('unlock')
+        ],
+        buttonBehaviours: derive$1([
+          Disabling.config({
+            disabled: function () {
+              return spec.disabled || providersBackstage.isDisabled();
+            }
+          }),
+          receivingConfig(),
+          Tabstopping.config({})
+        ])
+      });
+      var formGroup = function (components) {
+        return {
+          dom: {
+            tag: 'div',
+            classes: ['tox-form__group']
+          },
+          components: components
+        };
+      };
+      var getFieldPart = function (isField1) {
+        return FormField.parts.field({
+          factory: Input,
+          inputClasses: ['tox-textfield'],
+          inputBehaviours: derive$1([
+            Disabling.config({
+              disabled: function () {
+                return spec.disabled || providersBackstage.isDisabled();
+              }
+            }),
+            receivingConfig(),
+            Tabstopping.config({}),
+            config('size-input-events', [
+              run$1(focusin(), function (component, _simulatedEvent) {
+                emitWith(component, ratioEvent, { isField1: isField1 });
+              }),
+              run$1(change(), function (component, _simulatedEvent) {
+                emitWith(component, formChangeEvent, { name: spec.name });
+              })
+            ])
+          ]),
+          selectOnFocus: false
+        });
+      };
+      var getLabel = function (label) {
+        return {
+          dom: {
+            tag: 'label',
+            classes: ['tox-label'],
+            innerHtml: providersBackstage.translate(label)
+          }
+        };
+      };
+      var widthField = FormCoupledInputs.parts.field1(formGroup([
+        FormField.parts.label(getLabel('Width')),
+        getFieldPart(true)
+      ]));
+      var heightField = FormCoupledInputs.parts.field2(formGroup([
+        FormField.parts.label(getLabel('Height')),
+        getFieldPart(false)
+      ]));
+      return FormCoupledInputs.sketch({
+        dom: {
+          tag: 'div',
+          classes: ['tox-form__group']
+        },
+        components: [{
+            dom: {
+              tag: 'div',
+              classes: ['tox-form__controls-h-stack']
+            },
+            components: [
+              widthField,
+              heightField,
+              formGroup([
+                getLabel('&nbsp;'),
+                pLock
+              ])
+            ]
+          }],
+        field1Name: 'width',
+        field2Name: 'height',
+        locked: true,
+        markers: { lockClass: 'tox-locked' },
+        onLockedChange: function (current, other, _lock) {
+          parseSize(Representing.getValue(current)).each(function (size) {
+            converter(size).each(function (newSize) {
+              Representing.setValue(other, formatSize(newSize));
+            });
+          });
+        },
+        coupledFieldBehaviours: derive$1([
+          Disabling.config({
+            disabled: function () {
+              return spec.disabled || providersBackstage.isDisabled();
+            },
+            onDisabled: function (comp) {
+              FormCoupledInputs.getField1(comp).bind(FormField.getField).each(Disabling.disable);
+              FormCoupledInputs.getField2(comp).bind(FormField.getField).each(Disabling.disable);
+              FormCoupledInputs.getLock(comp).each(Disabling.disable);
+            },
+            onEnabled: function (comp) {
+              FormCoupledInputs.getField1(comp).bind(FormField.getField).each(Disabling.enable);
+              FormCoupledInputs.getField2(comp).bind(FormField.getField).each(Disabling.enable);
+              FormCoupledInputs.getLock(comp).each(Disabling.enable);
+            }
+          }),
+          receivingConfig(),
+          config('size-input-events2', [run$1(ratioEvent, function (component, simulatedEvent) {
+              var isField1 = simulatedEvent.event.isField1;
+              var optCurrent = isField1 ? FormCoupledInputs.getField1(component) : FormCoupledInputs.getField2(component);
+              var optOther = isField1 ? FormCoupledInputs.getField2(component) : FormCoupledInputs.getField1(component);
+              var value1 = optCurrent.map(Representing.getValue).getOr('');
+              var value2 = optOther.map(Representing.getValue).getOr('');
+              converter = makeRatioConverter(value1, value2);
+            })])
+        ])
+      });
+    };
+
+    var undo = constant$1(generate$6('undo'));
+    var redo = constant$1(generate$6('redo'));
+    var zoom = constant$1(generate$6('zoom'));
+    var back = constant$1(generate$6('back'));
+    var apply$1 = constant$1(generate$6('apply'));
+    var swap = constant$1(generate$6('swap'));
+    var transform$1 = constant$1(generate$6('transform'));
+    var tempTransform = constant$1(generate$6('temp-transform'));
+    var transformApply = constant$1(generate$6('transform-apply'));
+    var internal = {
+      undo: undo,
+      redo: redo,
+      zoom: zoom,
+      back: back,
+      apply: apply$1,
+      swap: swap,
+      transform: transform$1,
+      tempTransform: tempTransform,
+      transformApply: transformApply
+    };
+    var saveState = constant$1('save-state');
+    var disable = constant$1('disable');
+    var enable = constant$1('enable');
+    var external = {
+      formActionEvent: formActionEvent,
+      saveState: saveState,
+      disable: disable,
+      enable: enable
+    };
+
+    var renderEditPanel = function (imagePanel, providersBackstage) {
+      var createButton = function (text, action, disabled, primary) {
+        return record(renderButton({
+          name: text,
+          text: text,
+          disabled: disabled,
+          primary: primary,
+          icon: Optional.none(),
+          borderless: false
+        }, action, providersBackstage));
+      };
+      var createIconButton = function (icon, tooltip, action, disabled) {
+        return record(renderIconButton({
+          name: icon,
+          icon: Optional.some(icon),
+          tooltip: Optional.some(tooltip),
+          disabled: disabled,
+          primary: false,
+          borderless: false
+        }, action, providersBackstage));
+      };
+      var disableAllComponents = function (comps, eventcomp) {
+        comps.map(function (mem) {
+          var component = mem.get(eventcomp);
+          if (component.hasConfigured(Disabling)) {
+            Disabling.disable(component);
+          }
+        });
+      };
+      var enableAllComponents = function (comps, eventcomp) {
+        comps.map(function (mem) {
+          var component = mem.get(eventcomp);
+          if (component.hasConfigured(Disabling)) {
+            Disabling.enable(component);
+          }
+        });
+      };
+      var panelDom = {
+        tag: 'div',
+        classes: [
+          'tox-image-tools__toolbar',
+          'tox-image-tools-edit-panel'
+        ]
+      };
+      var noop$1 = noop;
+      var emit$1 = function (comp, event, data) {
+        emitWith(comp, event, data);
+      };
+      var emitDisable = function (component) {
+        return emit(component, external.disable());
+      };
+      var emitEnable = function (component) {
+        return emit(component, external.enable());
+      };
+      var emitTransform = function (comp, transform) {
+        emitDisable(comp);
+        emit$1(comp, internal.transform(), { transform: transform });
+        emitEnable(comp);
+      };
+      var emitTempTransform = function (comp, transform) {
+        emitDisable(comp);
+        emit$1(comp, internal.tempTransform(), { transform: transform });
+        emitEnable(comp);
+      };
+      var getBackSwap = function (anyInSystem) {
+        return function () {
+          memContainer.getOpt(anyInSystem).each(function (container) {
+            Replacing.set(container, [ButtonPanel]);
+          });
+        };
+      };
+      var emitTransformApply = function (comp, transform) {
+        emitDisable(comp);
+        emit$1(comp, internal.transformApply(), {
+          transform: transform,
+          swap: getBackSwap(comp)
+        });
+        emitEnable(comp);
+      };
+      var createBackButton = function () {
+        return createButton('Back', function (button) {
+          return emit$1(button, internal.back(), { swap: getBackSwap(button) });
+        }, false, false);
+      };
+      var createSpacer = function () {
+        return record({
+          dom: {
+            tag: 'div',
+            classes: ['tox-spacer']
+          },
+          behaviours: derive$1([Disabling.config({})])
+        });
+      };
+      var createApplyButton = function () {
+        return createButton('Apply', function (button) {
+          return emit$1(button, internal.apply(), { swap: getBackSwap(button) });
+        }, true, true);
+      };
+      var makeCropTransform = function () {
+        return function (ir) {
+          var rect = imagePanel.getRect();
+          return crop(ir, rect.x, rect.y, rect.w, rect.h);
+        };
+      };
+      var cropPanelComponents = [
+        createBackButton(),
+        createSpacer(),
+        createButton('Apply', function (button) {
+          var transform = makeCropTransform();
+          emitTransformApply(button, transform);
+          imagePanel.hideCrop();
+        }, false, true)
+      ];
+      var CropPanel = Container.sketch({
+        dom: panelDom,
+        components: cropPanelComponents.map(function (mem) {
+          return mem.asSpec();
+        }),
+        containerBehaviours: derive$1([config('image-tools-crop-buttons-events', [
+            run$1(external.disable(), function (comp, _se) {
+              disableAllComponents(cropPanelComponents, comp);
+            }),
+            run$1(external.enable(), function (comp, _se) {
+              enableAllComponents(cropPanelComponents, comp);
+            })
+          ])])
+      });
+      var memSize = record(renderSizeInput({
+        name: 'size',
+        label: Optional.none(),
+        constrain: true,
+        disabled: false
+      }, providersBackstage));
+      var makeResizeTransform = function (width, height) {
+        return function (ir) {
+          return resize$1(ir, width, height);
+        };
+      };
+      var resizePanelComponents = [
+        createBackButton(),
+        createSpacer(),
+        memSize,
+        createSpacer(),
+        createButton('Apply', function (button) {
+          memSize.getOpt(button).each(function (sizeInput) {
+            var value = Representing.getValue(sizeInput);
+            var width = parseInt(value.width, 10);
+            var height = parseInt(value.height, 10);
+            var transform = makeResizeTransform(width, height);
+            emitTransformApply(button, transform);
+          });
+        }, false, true)
+      ];
+      var ResizePanel = Container.sketch({
+        dom: panelDom,
+        components: resizePanelComponents.map(function (mem) {
+          return mem.asSpec();
+        }),
+        containerBehaviours: derive$1([config('image-tools-resize-buttons-events', [
+            run$1(external.disable(), function (comp, _se) {
+              disableAllComponents(resizePanelComponents, comp);
+            }),
+            run$1(external.enable(), function (comp, _se) {
+              enableAllComponents(resizePanelComponents, comp);
+            })
+          ])])
+      });
+      var makeValueTransform = function (transform, value) {
+        return function (ir) {
+          return transform(ir, value);
+        };
+      };
+      var horizontalFlip = makeValueTransform(flip, 'h');
+      var verticalFlip = makeValueTransform(flip, 'v');
+      var counterclockwiseRotate = makeValueTransform(rotate, -90);
+      var clockwiseRotate = makeValueTransform(rotate, 90);
+      var flipRotateOnAction = function (comp, operation) {
+        emitTempTransform(comp, operation);
+      };
+      var flipRotateComponents = [
+        createBackButton(),
+        createSpacer(),
+        createIconButton('flip-horizontally', 'Flip horizontally', function (button) {
+          flipRotateOnAction(button, horizontalFlip);
+        }, false),
+        createIconButton('flip-vertically', 'Flip vertically', function (button) {
+          flipRotateOnAction(button, verticalFlip);
+        }, false),
+        createIconButton('rotate-left', 'Rotate counterclockwise', function (button) {
+          flipRotateOnAction(button, counterclockwiseRotate);
+        }, false),
+        createIconButton('rotate-right', 'Rotate clockwise', function (button) {
+          flipRotateOnAction(button, clockwiseRotate);
+        }, false),
+        createSpacer(),
+        createApplyButton()
+      ];
+      var FlipRotatePanel = Container.sketch({
+        dom: panelDom,
+        components: flipRotateComponents.map(function (mem) {
+          return mem.asSpec();
+        }),
+        containerBehaviours: derive$1([config('image-tools-fliprotate-buttons-events', [
+            run$1(external.disable(), function (comp, _se) {
+              disableAllComponents(flipRotateComponents, comp);
+            }),
+            run$1(external.enable(), function (comp, _se) {
+              enableAllComponents(flipRotateComponents, comp);
+            })
+          ])])
+      });
+      var makeSlider = function (label, onChoose, min, value, max) {
+        var labelPart = Slider.parts.label({
+          dom: {
+            tag: 'label',
+            classes: ['tox-label'],
+            innerHtml: providersBackstage.translate(label)
+          }
+        });
+        var spectrum = Slider.parts.spectrum({
+          dom: {
+            tag: 'div',
+            classes: ['tox-slider__rail'],
+            attributes: { role: 'presentation' }
+          }
+        });
+        var thumb = Slider.parts.thumb({
+          dom: {
+            tag: 'div',
+            classes: ['tox-slider__handle'],
+            attributes: { role: 'presentation' }
+          }
+        });
+        return record(Slider.sketch({
+          dom: {
+            tag: 'div',
+            classes: ['tox-slider'],
+            attributes: { role: 'presentation' }
+          },
+          model: {
+            mode: 'x',
+            minX: min,
+            maxX: max,
+            getInitialValue: constant$1({ x: value })
+          },
+          components: [
+            labelPart,
+            spectrum,
+            thumb
+          ],
+          sliderBehaviours: derive$1([Focusing.config({})]),
+          onChoose: onChoose
+        }));
+      };
+      var makeVariableSlider = function (label, transform, min, value, max) {
+        var onChoose = function (slider, _thumb, value) {
+          var valTransform = makeValueTransform(transform, value.x / 100);
+          emitTransform(slider, valTransform);
+        };
+        return makeSlider(label, onChoose, min, value, max);
+      };
+      var variableFilterPanelComponents = function (label, transform, min, value, max) {
+        return [
+          createBackButton(),
+          makeVariableSlider(label, transform, min, value, max),
+          createApplyButton()
+        ];
+      };
+      var createVariableFilterPanel = function (label, transform, min, value, max) {
+        var filterPanelComponents = variableFilterPanelComponents(label, transform, min, value, max);
+        return Container.sketch({
+          dom: panelDom,
+          components: filterPanelComponents.map(function (mem) {
+            return mem.asSpec();
+          }),
+          containerBehaviours: derive$1([config('image-tools-filter-panel-buttons-events', [
+              run$1(external.disable(), function (comp, _se) {
+                disableAllComponents(filterPanelComponents, comp);
+              }),
+              run$1(external.enable(), function (comp, _se) {
+                enableAllComponents(filterPanelComponents, comp);
+              })
+            ])])
+        });
+      };
+      var filterPanelComponents = [
+        createBackButton(),
+        createSpacer(),
+        createApplyButton()
+      ];
+      var FilterPanel = Container.sketch({
+        dom: panelDom,
+        components: filterPanelComponents.map(function (mem) {
+          return mem.asSpec();
+        })
+      });
+      var BrightnessPanel = createVariableFilterPanel('Brightness', brightness, -100, 0, 100);
+      var ContrastPanel = createVariableFilterPanel('Contrast', contrast, -100, 0, 100);
+      var GammaPanel = createVariableFilterPanel('Gamma', gamma, -100, 0, 100);
+      var makeColorTransform = function (red, green, blue) {
+        return function (ir) {
+          return colorize(ir, red, green, blue);
+        };
+      };
+      var makeColorSlider = function (label) {
+        var onChoose = function (slider, _thumb, _value) {
+          var redOpt = memRed.getOpt(slider);
+          var blueOpt = memBlue.getOpt(slider);
+          var greenOpt = memGreen.getOpt(slider);
+          redOpt.each(function (red) {
+            blueOpt.each(function (blue) {
+              greenOpt.each(function (green) {
+                var r = Representing.getValue(red).x / 100;
+                var g = Representing.getValue(green).x / 100;
+                var b = Representing.getValue(blue).x / 100;
+                var transform = makeColorTransform(r, g, b);
+                emitTransform(slider, transform);
+              });
+            });
+          });
+        };
+        return makeSlider(label, onChoose, 0, 100, 200);
+      };
+      var memRed = makeColorSlider('R');
+      var memGreen = makeColorSlider('G');
+      var memBlue = makeColorSlider('B');
+      var colorizePanelComponents = [
+        createBackButton(),
+        memRed,
+        memGreen,
+        memBlue,
+        createApplyButton()
+      ];
+      var ColorizePanel = Container.sketch({
+        dom: panelDom,
+        components: colorizePanelComponents.map(function (mem) {
+          return mem.asSpec();
+        })
+      });
+      var getTransformPanelEvent = function (panel, transform, update) {
+        return function (button) {
+          var swap = function () {
+            memContainer.getOpt(button).each(function (container) {
+              Replacing.set(container, [panel]);
+              update(container);
+            });
+          };
+          emit$1(button, internal.swap(), {
+            transform: transform,
+            swap: swap
+          });
+        };
+      };
+      var cropPanelUpdate = function (_anyInSystem) {
+        imagePanel.showCrop();
+      };
+      var resizePanelUpdate = function (anyInSystem) {
+        memSize.getOpt(anyInSystem).each(function (sizeInput) {
+          var measurements = imagePanel.getMeasurements();
+          var width = measurements.width;
+          var height = measurements.height;
+          Representing.setValue(sizeInput, {
+            width: width,
+            height: height
+          });
+        });
+      };
+      var sharpenTransform = Optional.some(sharpen);
+      var invertTransform = Optional.some(invert);
+      var buttonPanelComponents = [
+        createIconButton('crop', 'Crop', getTransformPanelEvent(CropPanel, Optional.none(), cropPanelUpdate), false),
+        createIconButton('resize', 'Resize', getTransformPanelEvent(ResizePanel, Optional.none(), resizePanelUpdate), false),
+        createIconButton('orientation', 'Orientation', getTransformPanelEvent(FlipRotatePanel, Optional.none(), noop$1), false),
+        createIconButton('brightness', 'Brightness', getTransformPanelEvent(BrightnessPanel, Optional.none(), noop$1), false),
+        createIconButton('sharpen', 'Sharpen', getTransformPanelEvent(FilterPanel, sharpenTransform, noop$1), false),
+        createIconButton('contrast', 'Contrast', getTransformPanelEvent(ContrastPanel, Optional.none(), noop$1), false),
+        createIconButton('color-levels', 'Color levels', getTransformPanelEvent(ColorizePanel, Optional.none(), noop$1), false),
+        createIconButton('gamma', 'Gamma', getTransformPanelEvent(GammaPanel, Optional.none(), noop$1), false),
+        createIconButton('invert', 'Invert', getTransformPanelEvent(FilterPanel, invertTransform, noop$1), false)
+      ];
+      var ButtonPanel = Container.sketch({
+        dom: panelDom,
+        components: buttonPanelComponents.map(function (mem) {
+          return mem.asSpec();
+        })
+      });
+      var container = Container.sketch({
+        dom: { tag: 'div' },
+        components: [ButtonPanel],
+        containerBehaviours: derive$1([Replacing.config({})])
+      });
+      var memContainer = record(container);
+      var getApplyButton = function (anyInSystem) {
+        return memContainer.getOpt(anyInSystem).map(function (container) {
+          var panel = container.components()[0];
+          return panel.components()[panel.components().length - 1];
+        });
+      };
+      return {
+        memContainer: memContainer,
+        getApplyButton: getApplyButton
+      };
+    };
+
+    var global$4 = tinymce.util.Tools.resolve('tinymce.geom.Rect');
+
+    var global$3 = tinymce.util.Tools.resolve('tinymce.util.Observable');
+
+    var global$2 = tinymce.util.Tools.resolve('tinymce.util.VK');
+
+    var getDocumentSize = function (doc) {
+      var max = Math.max;
+      var documentElement = doc.documentElement;
+      var body = doc.body;
+      var scrollWidth = max(documentElement.scrollWidth, body.scrollWidth);
+      var clientWidth = max(documentElement.clientWidth, body.clientWidth);
+      var offsetWidth = max(documentElement.offsetWidth, body.offsetWidth);
+      var scrollHeight = max(documentElement.scrollHeight, body.scrollHeight);
+      var clientHeight = max(documentElement.clientHeight, body.clientHeight);
+      var offsetHeight = max(documentElement.offsetHeight, body.offsetHeight);
+      return {
+        width: scrollWidth < offsetWidth ? clientWidth : scrollWidth,
+        height: scrollHeight < offsetHeight ? clientHeight : scrollHeight
+      };
+    };
+    var isTouchEvent$1 = function (e) {
+      return isNonNullable(e.changedTouches);
+    };
+    var updateWithTouchData = function (e) {
+      if (isTouchEvent$1(e)) {
+        var keys = 'screenX screenY pageX pageY clientX clientY'.split(' ');
+        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 handleEvents = [];
+      var overlayEvents = [];
+      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 startY;
+      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);
+        updateWithTouchData(rawEvent);
+        e.prevent();
+        downButton = rawEvent.button;
+        startX = rawEvent.screenX;
+        startY = rawEvent.screenY;
+        var cursor = get$c(handleElement, 'cursor');
+        eventOverlay = SugarElement.fromTag('div', doc);
+        setAll(eventOverlay, {
+          'position': 'absolute',
+          'top': '0',
+          'left': '0',
+          'width': docSize.width + 'px',
+          'height': docSize.height + 'px',
+          'z-index': 2147483647 + '',
+          'opacity': '0.0001',
+          cursor: cursor
+        });
+        append$2(getBody(sugarDoc), eventOverlay);
+        overlayEvents.push(bind(sugarDoc, 'mousemove', drag), bind(sugarDoc, 'touchmove', drag), bind(sugarDoc, 'mouseup', stop), bind(sugarDoc, 'touchend', stop));
+        settings.start(rawEvent);
+      };
+      var drag = function (e) {
+        var rawEvent = e.raw;
+        updateWithTouchData(rawEvent);
+        if (rawEvent.button !== downButton) {
+          return stop(e);
+        }
+        rawEvent.deltaX = rawEvent.screenX - startX;
+        rawEvent.deltaY = rawEvent.screenY - startY;
+        e.prevent();
+        settings.drag(rawEvent);
+      };
+      var stop = function (e) {
+        updateWithTouchData(e.raw);
+        each$1(overlayEvents, function (e) {
+          return e.unbind();
+        });
+        overlayEvents = [];
+        remove$5(eventOverlay);
+        if (settings.stop) {
+          settings.stop(e.raw);
+        }
+      };
+      var destroy = function () {
+        each$1(overlayEvents.concat(handleEvents), function (e) {
+          return e.unbind();
+        });
+        overlayEvents = [];
+        handleEvents = [];
+        if (isNonNullable(eventOverlay)) {
+          remove$5(eventOverlay);
+        }
+      };
+      handleEvents.push(bind(handleElement, 'mousedown', start), bind(handleElement, 'touchstart', start));
+      return { destroy: destroy };
+    }
+
+    var count = 0;
+    var create$2 = 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,
+          deltaX: 1,
+          deltaY: 1,
+          deltaW: 0,
+          deltaH: 0,
+          label: 'Crop Mask'
+        },
+        {
+          name: 'nw',
+          xMul: 0,
+          yMul: 0,
+          deltaX: 1,
+          deltaY: 1,
+          deltaW: -1,
+          deltaH: -1,
+          label: 'Top Left Crop Handle'
+        },
+        {
+          name: 'ne',
+          xMul: 1,
+          yMul: 0,
+          deltaX: 0,
+          deltaY: 1,
+          deltaW: 1,
+          deltaH: -1,
+          label: 'Top Right Crop Handle'
+        },
+        {
+          name: 'sw',
+          xMul: 0,
+          yMul: 1,
+          deltaX: 1,
+          deltaY: 0,
+          deltaW: -1,
+          deltaH: 1,
+          label: 'Bottom Left Crop Handle'
+        },
+        {
+          name: 'se',
+          xMul: 1,
+          yMul: 1,
+          deltaX: 0,
+          deltaY: 0,
+          deltaW: 1,
+          deltaH: 1,
+          label: 'Bottom Right Crop Handle'
+        }
+      ];
+      var blockers = [
+        'top',
+        'right',
+        'bottom',
+        'left'
+      ];
+      var getAbsoluteRect = function (outerRect, relativeRect) {
+        return {
+          x: relativeRect.x + outerRect.x,
+          y: relativeRect.y + outerRect.y,
+          w: relativeRect.w,
+          h: relativeRect.h
+        };
+      };
+      var getRelativeRect = function (outerRect, innerRect) {
+        return {
+          x: innerRect.x - outerRect.x,
+          y: innerRect.y - outerRect.y,
+          w: innerRect.w,
+          h: innerRect.h
+        };
+      };
+      var getInnerRect = function () {
+        return getRelativeRect(clampRect, currentRect);
+      };
+      var moveRect = function (handle, startRect, deltaX, deltaY) {
+        var x = startRect.x + deltaX * handle.deltaX;
+        var y = startRect.y + deltaY * handle.deltaY;
+        var w = Math.max(20, startRect.w + deltaX * handle.deltaW);
+        var h = Math.max(20, startRect.h + deltaY * handle.deltaH);
+        var rect = currentRect = global$4.clamp({
+          x: x,
+          y: y,
+          w: w,
+          h: h
+        }, clampRect, handle.name === 'move');
+        rect = getRelativeRect(clampRect, rect);
+        instance.fire('updateRect', { rect: rect });
+        setInnerRect(rect);
+      };
+      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,
+          'class': prefix + 'croprect-container',
+          'role': 'grid',
+          'aria-dropeffect': 'execute'
+        });
+        append$2(container, cropContainer);
+        each$1(blockers, function (blocker) {
+          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);
+          });
+        });
+        dragHelpers = map$2(handles, createDragHelper);
+        repaint(currentRect);
+        var handleFocus = function (e) {
+          set$8(e.target, 'aria-grabbed', e.raw.type === 'focus' ? 'true' : 'false');
+        };
+        var handleKeydown = function (e) {
+          var activeHandle;
+          each$1(handles, function (handle) {
+            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.raw.keyCode) {
+          case global$2.LEFT:
+            moveAndBlock(e, activeHandle, currentRect, -10, 0);
+            break;
+          case global$2.RIGHT:
+            moveAndBlock(e, activeHandle, currentRect, 10, 0);
+            break;
+          case global$2.UP:
+            moveAndBlock(e, activeHandle, currentRect, 0, -10);
+            break;
+          case global$2.DOWN:
+            moveAndBlock(e, activeHandle, currentRect, 0, 10);
+            break;
+          case global$2.ENTER:
+          case global$2.SPACEBAR:
+            e.prevent();
+            action();
+            break;
+          }
+        };
+        events.push(bind(container, 'focusin', handleFocus), bind(container, 'focusout', handleFocus), bind(container, 'keydown', handleKeydown));
+      };
+      var toggleVisibility = function (state) {
+        var selectors = __spreadArray(__spreadArray([], map$2(handles, function (handle) {
+          return '#' + id + '-' + handle.name;
+        }), true), map$2(blockers, function (blocker) {
+          return '#' + id + '-' + blocker;
+        }), true).join(',');
+        var elems = descendants(container, selectors);
+        if (state) {
+          each$1(elems, function (elm) {
+            return remove$6(elm, 'display');
+          });
+        } else {
+          each$1(elems, function (elm) {
+            return set$7(elm, 'display', 'none');
+          });
+        }
+      };
+      var repaint = function (rect) {
+        var updateElementRect = function (name, newRect) {
+          descendant(container, '#' + id + '-' + name).each(function (elm) {
+            setAll(elm, {
+              left: newRect.x + 'px',
+              top: newRect.y + 'px',
+              width: Math.max(0, newRect.w) + 'px',
+              height: Math.max(0, newRect.h) + 'px'
+            });
+          });
+        };
+        each$1(handles, function (handle) {
+          descendant(container, '#' + id + '-' + handle.name).each(function (elm) {
+            setAll(elm, {
+              left: rect.w * handle.xMul + rect.x + 'px',
+              top: rect.h * handle.yMul + rect.y + 'px'
+            });
+          });
+        });
+        updateElementRect('top', {
+          x: viewPortRect.x,
+          y: viewPortRect.y,
+          w: viewPortRect.w,
+          h: rect.y - viewPortRect.y
+        });
+        updateElementRect('right', {
+          x: rect.x + rect.w,
+          y: rect.y,
+          w: viewPortRect.w - rect.x - rect.w + viewPortRect.x,
+          h: rect.h
+        });
+        updateElementRect('bottom', {
+          x: viewPortRect.x,
+          y: rect.y + rect.h,
+          w: viewPortRect.w,
+          h: viewPortRect.h - rect.y - rect.h + viewPortRect.y
+        });
+        updateElementRect('left', {
+          x: viewPortRect.x,
+          y: rect.y,
+          w: rect.x - viewPortRect.x,
+          h: rect.h
+        });
+        updateElementRect('move', rect);
+      };
+      var setRect = function (rect) {
+        currentRect = rect;
+        repaint(currentRect);
+      };
+      var setViewPortRect = function (rect) {
+        viewPortRect = rect;
+        repaint(currentRect);
+      };
+      var setInnerRect = function (rect) {
+        setRect(getAbsoluteRect(clampRect, rect));
+      };
+      var setClampRect = function (rect) {
+        clampRect = rect;
+        repaint(currentRect);
+      };
+      var destroy = function () {
+        each$1(dragHelpers, function (helper) {
+          return helper.destroy();
+        });
+        dragHelpers = [];
+        each$1(events, function (e) {
+          return e.unbind();
+        });
+        events = [];
+      };
+      render();
+      var instance = __assign(__assign({}, global$3), {
+        toggleVisibility: toggleVisibility,
+        setClampRect: setClampRect,
+        setRect: setRect,
+        getInnerRect: getInnerRect,
+        setInnerRect: setInnerRect,
+        setViewPortRect: setViewPortRect,
+        destroy: destroy
+      });
+      return instance;
+    };
+    var CropRect = { create: create$2 };
+
+    var loadImage = function (image) {
+      return new global$c(function (resolve) {
+        var loaded = function () {
+          image.removeEventListener('load', loaded);
+          resolve(image);
+        };
+        if (image.complete) {
+          resolve(image);
+        } else {
+          image.addEventListener('load', loaded);
+        }
+      });
+    };
+    var renderImagePanel = function (initialUrl) {
+      var memBg = record({
+        dom: {
+          tag: 'div',
+          classes: ['tox-image-tools__image-bg'],
+          attributes: { role: 'presentation' }
+        }
+      });
+      var zoomState = Cell(1);
+      var cropRect = api$1();
+      var rectState = Cell({
+        x: 0,
+        y: 0,
+        w: 1,
+        h: 1
+      });
+      var viewRectState = Cell({
+        x: 0,
+        y: 0,
+        w: 1,
+        h: 1
+      });
+      var repaintImg = function (anyInSystem, img) {
+        memContainer.getOpt(anyInSystem).each(function (panel) {
+          var zoom = zoomState.get();
+          var panelW = get$a(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 = {
+            left: left.toString() + 'px',
+            top: top.toString() + 'px',
+            width: width.toString() + 'px',
+            height: height.toString() + 'px',
+            position: 'absolute'
+          };
+          setAll(img, css);
+          memBg.getOpt(panel).each(function (bg) {
+            setAll(bg.element, css);
+          });
+          cropRect.run(function (cRect) {
+            var rect = rectState.get();
+            cRect.setRect({
+              x: rect.x * zoom + left,
+              y: rect.y * zoom + top,
+              w: rect.w * zoom,
+              h: rect.h * zoom
+            });
+            cRect.setClampRect({
+              x: left,
+              y: top,
+              w: width,
+              h: height
+            });
+            cRect.setViewPortRect({
+              x: 0,
+              y: 0,
+              w: panelW,
+              h: panelH
+            });
+          });
+        });
+      };
+      var zoomFit = function (anyInSystem, img) {
+        memContainer.getOpt(anyInSystem).each(function (panel) {
+          var panelW = get$a(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);
+          } else {
+            zoomState.set(zoom);
+          }
+        });
+      };
+      var updateSrc = function (anyInSystem, url) {
+        var img = SugarElement.fromTag('img');
+        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));
+              var lastViewRect = viewRectState.get();
+              var viewRect = {
+                x: 0,
+                y: 0,
+                w: img.dom.naturalWidth,
+                h: img.dom.naturalHeight
+              };
+              viewRectState.set(viewRect);
+              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 zoom = function (anyInSystem, direction) {
+        var currentZoom = zoomState.get();
+        var newZoom = direction > 0 ? Math.min(2, currentZoom + 0.1) : Math.max(0.1, currentZoom - 0.1);
+        zoomState.set(newZoom);
+        memContainer.getOpt(anyInSystem).each(function (panel) {
+          var img = panel.components()[1].element;
+          repaintImg(panel, img);
+        });
+      };
+      var showCrop = function () {
+        cropRect.run(function (cRect) {
+          cRect.toggleVisibility(true);
+        });
+      };
+      var hideCrop = function () {
+        cropRect.run(function (cRect) {
+          cRect.toggleVisibility(false);
+        });
+      };
+      var getRect = function () {
+        return rectState.get();
+      };
+      var container = Container.sketch({
+        dom: {
+          tag: 'div',
+          classes: ['tox-image-tools__image']
+        },
+        components: [
+          memBg.asSpec(),
+          {
+            dom: {
+              tag: 'img',
+              attributes: { src: initialUrl }
+            }
+          },
+          {
+            dom: { tag: 'div' },
+            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,
+                      w: 100,
+                      h: 100
+                    }, {
+                      x: 0,
+                      y: 0,
+                      w: 200,
+                      h: 200
+                    }, {
+                      x: 0,
+                      y: 0,
+                      w: 200,
+                      h: 200
+                    }, el, noop);
+                    cRect.toggleVisibility(false);
+                    cRect.on('updateRect', function (e) {
+                      var rect = e.rect;
+                      var zoom = zoomState.get();
+                      var newRect = {
+                        x: Math.round(rect.x / zoom),
+                        y: Math.round(rect.y / zoom),
+                        w: Math.round(rect.w / zoom),
+                        h: Math.round(rect.h / zoom)
+                      };
+                      rectState.set(newRect);
+                    });
+                    cropRect.set(cRect);
+                  });
+                }),
+                runOnDetached(function () {
+                  cropRect.clear();
+                })
+              ])])
+          }
+        ],
+        containerBehaviours: derive$1([
+          Replacing.config({}),
+          config('image-panel-events', [runOnAttached(function (comp) {
+              updateSrc(comp, initialUrl);
+            })])
+        ])
+      });
+      var memContainer = record(container);
+      var getMeasurements = function () {
+        var viewRect = viewRectState.get();
+        return {
+          width: viewRect.w,
+          height: viewRect.h
+        };
+      };
+      return {
+        memContainer: memContainer,
+        updateSrc: updateSrc,
+        zoom: zoom,
+        showCrop: showCrop,
+        hideCrop: hideCrop,
+        getRect: getRect,
+        getMeasurements: getMeasurements
+      };
+    };
+
+    var createButton = function (innerHtml, icon, disabled, action, providersBackstage) {
+      return renderIconButton({
+        name: innerHtml,
+        icon: Optional.some(icon),
+        disabled: disabled,
+        tooltip: Optional.some(innerHtml),
+        primary: false,
+        borderless: false
+      }, action, providersBackstage);
+    };
+    var setButtonEnabled = function (button, enabled) {
+      if (enabled) {
+        Disabling.enable(button);
+      } else {
+        Disabling.disable(button);
+      }
+    };
+    var renderSideBar = function (providersBackstage) {
+      var updateButtonUndoStates = function (anyInSystem, undoEnabled, redoEnabled) {
+        memUndo.getOpt(anyInSystem).each(function (undo) {
+          setButtonEnabled(undo, undoEnabled);
+        });
+        memRedo.getOpt(anyInSystem).each(function (redo) {
+          setButtonEnabled(redo, redoEnabled);
+        });
+      };
+      var memUndo = record(createButton('Undo', 'undo', true, function (button) {
+        emitWith(button, internal.undo(), { direction: 1 });
+      }, providersBackstage));
+      var memRedo = record(createButton('Redo', 'redo', true, function (button) {
+        emitWith(button, internal.redo(), { direction: 1 });
+      }, providersBackstage));
+      var container = Container.sketch({
+        dom: {
+          tag: 'div',
+          classes: [
+            'tox-image-tools__toolbar',
+            'tox-image-tools__sidebar'
+          ]
+        },
+        components: [
+          memUndo.asSpec(),
+          memRedo.asSpec(),
+          createButton('Zoom in', 'zoom-in', false, function (button) {
+            emitWith(button, internal.zoom(), { direction: 1 });
+          }, providersBackstage),
+          createButton('Zoom out', 'zoom-out', false, function (button) {
+            emitWith(button, internal.zoom(), { direction: -1 });
+          }, providersBackstage)
+        ]
+      });
+      return {
+        container: container,
+        updateButtonUndoStates: updateButtonUndoStates
+      };
+    };
+
+    function UndoStack () {
+      var data = [];
+      var index = -1;
+      var add = function (state) {
+        var removed = data.splice(++index);
+        data.push(state);
+        return {
+          state: state,
+          removed: removed
+        };
+      };
+      var undo = function () {
+        if (canUndo()) {
+          return data[--index];
+        }
+      };
+      var redo = function () {
+        if (canRedo()) {
+          return data[++index];
+        }
+      };
+      var canUndo = function () {
+        return index > 0;
+      };
+      var canRedo = function () {
+        return index !== -1 && index < data.length - 1;
+      };
+      return {
+        data: data,
+        add: add,
+        undo: undo,
+        redo: redo,
+        canUndo: canUndo,
+        canRedo: canRedo
+      };
+    }
+
+    var makeState = function (initialState) {
+      var blobState = Cell(initialState);
+      var tempState = value$1();
+      var undoStack = UndoStack();
+      undoStack.add(initialState);
+      var getBlobState = function () {
+        return blobState.get();
+      };
+      var setBlobState = function (state) {
+        blobState.set(state);
+      };
+      var getTempState = function () {
+        return tempState.get().getOrThunk(blobState.get);
+      };
+      var updateTempState = function (blob) {
+        var newTempState = createState(blob);
+        destroyTempState();
+        tempState.set(newTempState);
+        return newTempState.url;
+      };
+      var createState = function (blob) {
+        return {
+          blob: blob,
+          url: URL.createObjectURL(blob)
+        };
+      };
+      var destroyState = function (state) {
+        URL.revokeObjectURL(state.url);
+      };
+      var destroyStates = function (states) {
+        global$5.each(states, destroyState);
+      };
+      var destroyTempState = function () {
+        tempState.on(destroyState);
+        tempState.clear();
+      };
+      var addBlobState = function (blob) {
+        var newState = createState(blob);
+        setBlobState(newState);
+        var removed = undoStack.add(newState).removed;
+        destroyStates(removed);
+        return newState.url;
+      };
+      var addTempState = function (blob) {
+        var newState = createState(blob);
+        tempState.set(newState);
+        return newState.url;
+      };
+      var applyTempState = function (postApply) {
+        return tempState.get().fold(noop, function (temp) {
+          addBlobState(temp.blob);
+          postApply();
+        });
+      };
+      var undo = function () {
+        var currentState = undoStack.undo();
+        setBlobState(currentState);
+        return currentState.url;
+      };
+      var redo = function () {
+        var currentState = undoStack.redo();
+        setBlobState(currentState);
+        return currentState.url;
+      };
+      var getHistoryStates = function () {
+        var undoEnabled = undoStack.canUndo();
+        var redoEnabled = undoStack.canRedo();
+        return {
+          undoEnabled: undoEnabled,
+          redoEnabled: redoEnabled
+        };
+      };
+      return {
+        getBlobState: getBlobState,
+        setBlobState: setBlobState,
+        addBlobState: addBlobState,
+        getTempState: getTempState,
+        updateTempState: updateTempState,
+        addTempState: addTempState,
+        applyTempState: applyTempState,
+        destroyTempState: destroyTempState,
+        undo: undo,
+        redo: redo,
+        getHistoryStates: getHistoryStates
+      };
+    };
+
+    var renderImageTools = function (detail, providersBackstage) {
+      var state = makeState(detail.currentState);
+      var zoom = function (anyInSystem, simulatedEvent) {
+        var direction = simulatedEvent.event.direction;
+        imagePanel.zoom(anyInSystem, direction);
+      };
+      var updateButtonUndoStates = function (anyInSystem) {
+        var historyStates = state.getHistoryStates();
+        sideBar.updateButtonUndoStates(anyInSystem, historyStates.undoEnabled, historyStates.redoEnabled);
+        emitWith(anyInSystem, external.formActionEvent, {
+          name: external.saveState(),
+          value: historyStates.undoEnabled
+        });
+      };
+      var disableUndoRedo = function (anyInSystem) {
+        sideBar.updateButtonUndoStates(anyInSystem, false, false);
+      };
+      var undo = function (anyInSystem, _simulatedEvent) {
+        var url = state.undo();
+        updateSrc(anyInSystem, url).then(function (_oImg) {
+          unblock(anyInSystem);
+          updateButtonUndoStates(anyInSystem);
+        });
+      };
+      var redo = function (anyInSystem, _simulatedEvent) {
+        var url = state.redo();
+        updateSrc(anyInSystem, url).then(function (_oImg) {
+          unblock(anyInSystem);
+          updateButtonUndoStates(anyInSystem);
+        });
+      };
+      var imageResultToBlob = function (ir) {
+        return ir.toBlob();
+      };
+      var block = function (anyInSystem) {
+        emitWith(anyInSystem, external.formActionEvent, {
+          name: external.disable(),
+          value: {}
+        });
+      };
+      var unblock = function (anyInSystem) {
+        editPanel.getApplyButton(anyInSystem).each(function (applyButton) {
+          Disabling.enable(applyButton);
+        });
+        emitWith(anyInSystem, external.formActionEvent, {
+          name: external.enable(),
+          value: {}
+        });
+      };
+      var updateSrc = function (anyInSystem, src) {
+        block(anyInSystem);
+        return imagePanel.updateSrc(anyInSystem, src);
+      };
+      var blobManipulate = function (anyInSystem, blob, filter, action, swap) {
+        block(anyInSystem);
+        blobToImageResult(blob).then(filter).then(imageResultToBlob).then(action).then(function (url) {
+          return updateSrc(anyInSystem, url);
+        }).then(function () {
+          updateButtonUndoStates(anyInSystem);
+          swap();
+          unblock(anyInSystem);
+        }).catch(function (err) {
+          console.log(err);
+          if (anyInSystem.getSystem().isConnected()) {
+            unblock(anyInSystem);
+          }
+        });
+      };
+      var manipulate = function (anyInSystem, filter, swap) {
+        var blob = state.getBlobState().blob;
+        var action = function (blob) {
+          return state.updateTempState(blob);
+        };
+        blobManipulate(anyInSystem, blob, filter, action, swap);
+      };
+      var tempManipulate = function (anyInSystem, filter) {
+        var blob = state.getTempState().blob;
+        var action = function (blob) {
+          return state.addTempState(blob);
+        };
+        blobManipulate(anyInSystem, blob, filter, action, noop);
+      };
+      var manipulateApply = function (anyInSystem, filter, swap) {
+        var blob = state.getBlobState().blob;
+        var action = function (blob) {
+          var url = state.addBlobState(blob);
+          destroyTempState(anyInSystem);
+          return url;
+        };
+        blobManipulate(anyInSystem, blob, filter, action, swap);
+      };
+      var apply = function (anyInSystem, simulatedEvent) {
+        var postApply = function () {
+          destroyTempState(anyInSystem);
+          var swap = simulatedEvent.event.swap;
+          swap();
+        };
+        state.applyTempState(postApply);
+      };
+      var destroyTempState = function (anyInSystem) {
+        var currentUrl = state.getBlobState().url;
+        state.destroyTempState();
+        updateButtonUndoStates(anyInSystem);
+        return currentUrl;
+      };
+      var cancel = function (anyInSystem) {
+        var currentUrl = destroyTempState(anyInSystem);
+        updateSrc(anyInSystem, currentUrl).then(function (_oImg) {
+          unblock(anyInSystem);
+        });
+      };
+      var back = function (anyInSystem, simulatedEvent) {
+        cancel(anyInSystem);
+        var swap = simulatedEvent.event.swap;
+        swap();
+        imagePanel.hideCrop();
+      };
+      var transform = function (anyInSystem, simulatedEvent) {
+        return manipulate(anyInSystem, simulatedEvent.event.transform, noop);
+      };
+      var tempTransform = function (anyInSystem, simulatedEvent) {
+        return tempManipulate(anyInSystem, simulatedEvent.event.transform);
+      };
+      var transformApply = function (anyInSystem, simulatedEvent) {
+        return manipulateApply(anyInSystem, simulatedEvent.event.transform, simulatedEvent.event.swap);
+      };
+      var imagePanel = renderImagePanel(detail.currentState.url);
+      var sideBar = renderSideBar(providersBackstage);
+      var editPanel = renderEditPanel(imagePanel, providersBackstage);
+      var swap = function (anyInSystem, simulatedEvent) {
+        disableUndoRedo(anyInSystem);
+        var transform = simulatedEvent.event.transform;
+        var swap = simulatedEvent.event.swap;
+        transform.fold(function () {
+          swap();
+        }, function (transform) {
+          manipulate(anyInSystem, transform, swap);
+        });
+      };
+      return {
+        dom: {
+          tag: 'div',
+          attributes: { role: 'presentation' }
+        },
+        components: [
+          editPanel.memContainer.asSpec(),
+          imagePanel.memContainer.asSpec(),
+          sideBar.container
+        ],
+        behaviours: derive$1([
+          Representing.config({
+            store: {
+              mode: 'manual',
+              getValue: function () {
+                return state.getBlobState();
+              }
+            }
+          }),
+          config('image-tools-events', [
+            run$1(internal.undo(), undo),
+            run$1(internal.redo(), redo),
+            run$1(internal.zoom(), zoom),
+            run$1(internal.back(), back),
+            run$1(internal.apply(), apply),
+            run$1(internal.transform(), transform),
+            run$1(internal.tempTransform(), tempTransform),
+            run$1(internal.transformApply(), transformApply),
+            run$1(internal.swap(), swap)
+          ]),
+          ComposingConfigs.self()
+        ])
+      };
+    };
+
+    var renderLabel = function (spec, backstageShared) {
+      var label = {
+        dom: {
+          tag: 'label',
+          innerHtml: backstageShared.providers.translate(spec.label),
+          classes: ['tox-label']
+        }
+      };
+      var comps = map$2(spec.items, backstageShared.interpreter);
+      return {
+        dom: {
+          tag: 'div',
+          classes: ['tox-form__group']
+        },
+        components: [label].concat(comps),
+        behaviours: derive$1([
+          ComposingConfigs.self(),
+          Replacing.config({}),
+          RepresentingConfigs.domHtml(Optional.none()),
+          Keying.config({ mode: 'acyclic' })
+        ])
+      };
+    };
+
+    var isSingleListItem = function (item) {
+      return !has$2(item, 'items');
+    };
+    var dataAttribute = 'data-value';
+    var fetchItems = function (dropdownComp, name, items, selectedValue) {
+      return map$2(items, function (item) {
+        if (!isSingleListItem(item)) {
+          return {
+            type: 'nestedmenuitem',
+            text: item.text,
+            getSubmenuItems: function () {
+              return fetchItems(dropdownComp, name, item.items, selectedValue);
+            }
+          };
+        } else {
+          return {
+            type: 'togglemenuitem',
+            text: item.text,
+            value: item.value,
+            active: item.value === selectedValue,
+            onAction: function () {
+              Representing.setValue(dropdownComp, item.value);
+              emitWith(dropdownComp, formChangeEvent, { name: name });
+              Focusing.focus(dropdownComp);
+            }
+          };
+        }
+      });
+    };
+    var findItemByValue = function (items, value) {
+      return findMap(items, function (item) {
+        if (!isSingleListItem(item)) {
+          return findItemByValue(item.items, value);
+        } else {
+          return someIf(item.value === value, item);
+        }
+      });
+    };
+    var renderListBox = function (spec, backstage) {
+      var providersBackstage = backstage.shared.providers;
+      var initialItem = head(spec.items).filter(isSingleListItem);
+      var pLabel = spec.label.map(function (label) {
+        return renderLabel$2(label, providersBackstage);
+      });
+      var pField = FormField.parts.field({
+        dom: {},
+        factory: {
+          sketch: function (sketchSpec) {
+            return renderCommonDropdown({
+              uid: sketchSpec.uid,
+              text: initialItem.map(function (item) {
+                return item.text;
+              }),
+              icon: Optional.none(),
+              tooltip: spec.label,
+              role: Optional.none(),
+              fetch: function (comp, callback) {
+                var items = fetchItems(comp, spec.name, spec.items, Representing.getValue(comp));
+                callback(build(items, ItemResponse$1.CLOSE_ON_EXECUTE, backstage, false));
+              },
+              onSetup: constant$1(noop),
+              getApi: constant$1({}),
+              columns: 1,
+              presets: 'normal',
+              classes: [],
+              dropdownBehaviours: [
+                Tabstopping.config({}),
+                Representing.config({
+                  store: {
+                    mode: 'manual',
+                    initialValue: initialItem.map(function (item) {
+                      return item.value;
+                    }).getOr(''),
+                    getValue: function (comp) {
+                      return get$d(comp.element, dataAttribute);
+                    },
+                    setValue: function (comp, data) {
+                      findItemByValue(spec.items, data).each(function (item) {
+                        set$8(comp.element, dataAttribute, item.value);
+                        emitWith(comp, updateMenuText, { text: item.text });
+                      });
+                    }
+                  }
+                })
+              ]
+            }, 'tox-listbox', backstage.shared);
+          }
+        }
+      });
+      var listBoxWrap = {
+        dom: {
+          tag: 'div',
+          classes: ['tox-listboxfield']
+        },
+        components: [pField]
+      };
+      return FormField.sketch({
+        dom: {
+          tag: 'div',
+          classes: ['tox-form__group']
+        },
+        components: flatten([
+          pLabel.toArray(),
+          [listBoxWrap]
+        ]),
+        fieldBehaviours: derive$1([Disabling.config({
+            disabled: constant$1(spec.disabled),
+            onDisabled: function (comp) {
+              FormField.getField(comp).each(Disabling.disable);
+            },
+            onEnabled: function (comp) {
+              FormField.getField(comp).each(Disabling.enable);
+            }
+          })])
+      });
+    };
+
+    var renderPanel = function (spec, backstage) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: spec.classes
+        },
+        components: map$2(spec.items, backstage.shared.interpreter)
+      };
+    };
+
+    var factory$e = function (detail, _spec) {
+      var options = map$2(detail.options, function (option) {
+        return {
+          dom: {
+            tag: 'option',
+            value: option.value,
+            innerHtml: option.text
+          }
+        };
+      });
+      var initialValues = detail.data.map(function (v) {
+        return wrap$1('initialValue', v);
+      }).getOr({});
+      return {
+        uid: detail.uid,
+        dom: {
+          tag: 'select',
+          classes: detail.selectClasses,
+          attributes: detail.selectAttributes
+        },
+        components: options,
+        behaviours: augment(detail.selectBehaviours, [
+          Focusing.config({}),
+          Representing.config({
+            store: __assign({
+              mode: 'manual',
+              getValue: function (select) {
+                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$4(select.element, newValue);
+                }
+              }
+            }, initialValues)
+          })
+        ])
+      };
+    };
+    var HtmlSelect = single({
+      name: 'HtmlSelect',
+      configFields: [
+        required$1('options'),
+        field('selectBehaviours', [
+          Focusing,
+          Representing
+        ]),
+        defaulted('selectClasses', []),
+        defaulted('selectAttributes', {}),
+        option('data')
+      ],
+      factory: factory$e
+    });
+
+    var renderSelectBox = function (spec, providersBackstage) {
+      var translatedOptions = map$2(spec.items, function (item) {
+        return {
+          text: providersBackstage.translate(item.text),
+          value: item.value
+        };
+      });
+      var pLabel = spec.label.map(function (label) {
+        return renderLabel$2(label, providersBackstage);
+      });
+      var pField = FormField.parts.field({
+        dom: {},
+        selectAttributes: { size: spec.size },
+        options: translatedOptions,
+        factory: HtmlSelect,
+        selectBehaviours: derive$1([
+          Disabling.config({
+            disabled: function () {
+              return spec.disabled || providersBackstage.isDisabled();
+            }
+          }),
+          Tabstopping.config({}),
+          config('selectbox-change', [run$1(change(), function (component, _) {
+              emitWith(component, formChangeEvent, { name: spec.name });
+            })])
+        ])
+      });
+      var chevron = spec.size > 1 ? Optional.none() : Optional.some(render$3('chevron-down', {
+        tag: 'div',
+        classes: ['tox-selectfield__icon-js']
+      }, providersBackstage.icons));
+      var selectWrap = {
+        dom: {
+          tag: 'div',
+          classes: ['tox-selectfield']
+        },
+        components: flatten([
+          [pField],
+          chevron.toArray()
+        ])
+      };
+      return FormField.sketch({
+        dom: {
+          tag: 'div',
+          classes: ['tox-form__group']
+        },
+        components: flatten([
+          pLabel.toArray(),
+          [selectWrap]
+        ]),
+        fieldBehaviours: derive$1([
+          Disabling.config({
+            disabled: function () {
+              return spec.disabled || providersBackstage.isDisabled();
+            },
+            onDisabled: function (comp) {
+              FormField.getField(comp).each(Disabling.disable);
+            },
+            onEnabled: function (comp) {
+              FormField.getField(comp).each(Disabling.enable);
+            }
+          }),
+          receivingConfig()
+        ])
+      });
+    };
+
+    var renderTable = function (spec, providersBackstage) {
+      var renderTh = function (text) {
+        return {
+          dom: {
+            tag: 'th',
+            innerHtml: providersBackstage.translate(text)
+          }
+        };
+      };
+      var renderHeader = function (header) {
+        return {
+          dom: { tag: 'thead' },
+          components: [{
+              dom: { tag: 'tr' },
+              components: map$2(header, renderTh)
+            }]
+        };
+      };
+      var renderTd = function (text) {
+        return {
+          dom: {
+            tag: 'td',
+            innerHtml: providersBackstage.translate(text)
+          }
+        };
+      };
+      var renderTr = function (row) {
+        return {
+          dom: { tag: 'tr' },
+          components: map$2(row, renderTd)
+        };
+      };
+      var renderRows = function (rows) {
+        return {
+          dom: { tag: 'tbody' },
+          components: map$2(rows, renderTr)
+        };
+      };
+      return {
+        dom: {
+          tag: 'table',
+          classes: ['tox-dialog__table']
+        },
+        components: [
+          renderHeader(spec.header),
+          renderRows(spec.cells)
+        ],
+        behaviours: derive$1([
+          Tabstopping.config({}),
+          Focusing.config({})
+        ])
+      };
+    };
+
+    var renderTextField = function (spec, providersBackstage) {
+      var pLabel = spec.label.map(function (label) {
+        return renderLabel$2(label, providersBackstage);
+      });
+      var baseInputBehaviours = [
+        Disabling.config({
+          disabled: function () {
+            return spec.disabled || providersBackstage.isDisabled();
+          }
+        }),
+        receivingConfig(),
+        Keying.config({
+          mode: 'execution',
+          useEnter: spec.multiline !== true,
+          useControlEnter: spec.multiline === true,
+          execute: function (comp) {
+            emit(comp, formSubmitEvent);
+            return Optional.some(true);
+          }
+        }),
+        config('textfield-change', [
+          run$1(input(), function (component, _) {
+            emitWith(component, formChangeEvent, { name: spec.name });
+          }),
+          run$1(postPaste(), function (component, _) {
+            emitWith(component, formChangeEvent, { name: spec.name });
+          })
+        ]),
+        Tabstopping.config({})
+      ];
+      var validatingBehaviours = spec.validation.map(function (vl) {
+        return Invalidating.config({
+          getRoot: function (input) {
+            return parent(input.element);
+          },
+          invalidClass: 'tox-invalid',
+          validator: {
+            validate: function (input) {
+              var v = Representing.getValue(input);
+              var result = vl.validator(v);
+              return Future.pure(result === true ? Result.value(v) : Result.error(result));
+            },
+            validateOnLoad: vl.validateOnLoad
+          }
+        });
+      }).toArray();
+      var placeholder = spec.placeholder.fold(constant$1({}), function (p) {
+        return { placeholder: providersBackstage.translate(p) };
+      });
+      var inputMode = spec.inputMode.fold(constant$1({}), function (mode) {
+        return { inputmode: mode };
+      });
+      var inputAttributes = __assign(__assign({}, placeholder), inputMode);
+      var pField = FormField.parts.field({
+        tag: spec.multiline === true ? 'textarea' : 'input',
+        inputAttributes: inputAttributes,
+        inputClasses: [spec.classname],
+        inputBehaviours: derive$1(flatten([
+          baseInputBehaviours,
+          validatingBehaviours
+        ])),
+        selectOnFocus: false,
+        factory: Input
+      });
+      var extraClasses = spec.flex ? ['tox-form__group--stretched'] : [];
+      var extraClasses2 = extraClasses.concat(spec.maximized ? ['tox-form-group--maximize'] : []);
+      var extraBehaviours = [
+        Disabling.config({
+          disabled: function () {
+            return spec.disabled || providersBackstage.isDisabled();
+          },
+          onDisabled: function (comp) {
+            FormField.getField(comp).each(Disabling.disable);
+          },
+          onEnabled: function (comp) {
+            FormField.getField(comp).each(Disabling.enable);
+          }
+        }),
+        receivingConfig()
+      ];
+      return renderFormFieldWith(pLabel, pField, extraClasses2, extraBehaviours);
+    };
+    var renderInput = function (spec, providersBackstage) {
+      return renderTextField({
+        name: spec.name,
+        multiline: false,
+        label: spec.label,
+        inputMode: spec.inputMode,
+        placeholder: spec.placeholder,
+        flex: false,
+        disabled: spec.disabled,
+        classname: 'tox-textfield',
+        validation: Optional.none(),
+        maximized: spec.maximized
+      }, providersBackstage);
+    };
+    var renderTextarea = function (spec, providersBackstage) {
+      return renderTextField({
+        name: spec.name,
+        multiline: true,
+        label: spec.label,
+        inputMode: Optional.none(),
+        placeholder: spec.placeholder,
+        flex: true,
+        disabled: spec.disabled,
+        classname: 'tox-textarea',
+        validation: Optional.none(),
+        maximized: spec.maximized
+      }, providersBackstage);
+    };
+
+    var events$6 = function (streamConfig, streamState) {
+      var streams = streamConfig.stream.streams;
+      var processor = streams.setup(streamConfig, streamState);
+      return derive$2([
+        run$1(streamConfig.event, processor),
+        runOnDetached(function () {
+          return streamState.cancel();
+        })
+      ].concat(streamConfig.cancelEvent.map(function (e) {
+        return [run$1(e, function () {
+            return streamState.cancel();
+          })];
+      }).getOr([])));
+    };
+
+    var ActiveStreaming = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$6
+    });
+
+    var throttle = function (_config) {
+      var state = Cell(null);
+      var readState = function () {
+        return { timer: state.get() !== null ? 'set' : 'unset' };
+      };
+      var setTimer = function (t) {
+        state.set(t);
+      };
+      var cancel = function () {
+        var t = state.get();
+        if (t !== null) {
+          t.cancel();
+        }
+      };
+      return nu$8({
+        readState: readState,
+        setTimer: setTimer,
+        cancel: cancel
+      });
+    };
+    var init$9 = function (spec) {
+      return spec.stream.streams.state(spec);
+    };
+
+    var StreamingState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        throttle: throttle,
+        init: init$9
+    });
+
+    var setup$c = function (streamInfo, streamState) {
+      var sInfo = streamInfo.stream;
+      var throttler = last(streamInfo.onStream, sInfo.delay);
+      streamState.setTimer(throttler);
+      return function (component, simulatedEvent) {
+        throttler.throttle(component, simulatedEvent);
+        if (sInfo.stopEvent) {
+          simulatedEvent.stop();
+        }
+      };
+    };
+    var StreamingSchema = [
+      requiredOf('stream', choose$1('mode', {
+        throttle: [
+          required$1('delay'),
+          defaulted('stopEvent', true),
+          output$1('streams', {
+            setup: setup$c,
+            state: throttle
+          })
+        ]
+      })),
+      defaulted('event', 'input'),
+      option('cancelEvent'),
+      onStrictHandler('onStream')
+    ];
+
+    var Streaming = create$8({
+      fields: StreamingSchema,
+      name: 'streaming',
+      active: ActiveStreaming,
+      state: StreamingState
+    });
+
+    var setValueFromItem = function (model, input, item) {
+      var itemData = Representing.getValue(item);
+      Representing.setValue(input, itemData);
+      setCursorAtEnd(input);
+    };
+    var setSelectionOn = function (input, f) {
+      var el = input.element;
+      var value = get$5(el);
+      var node = el.dom;
+      if (get$d(el, 'type') !== 'number') {
+        f(node, value);
+      }
+    };
+    var setCursorAtEnd = function (input) {
+      setSelectionOn(input, function (node, value) {
+        return node.setSelectionRange(value.length, value.length);
+      });
+    };
+    var setSelectionToEnd = function (input, startOffset) {
+      setSelectionOn(input, function (node, value) {
+        return node.setSelectionRange(startOffset, value.length);
+      });
+    };
+    var attemptSelectOver = function (model, input, item) {
+      if (!model.selectsOver) {
+        return Optional.none();
+      } else {
+        var currentValue = Representing.getValue(input);
+        var inputDisplay_1 = model.getDisplayText(currentValue);
+        var itemValue = Representing.getValue(item);
+        var itemDisplay = model.getDisplayText(itemValue);
+        return itemDisplay.indexOf(inputDisplay_1) === 0 ? Optional.some(function () {
+          setValueFromItem(model, input, item);
+          setSelectionToEnd(input, inputDisplay_1.length);
+        }) : Optional.none();
+      }
+    };
+
+    var itemExecute = constant$1('alloy.typeahead.itemexecute');
+
+    var make$3 = function (detail, components, spec, externals) {
+      var navigateList = function (comp, simulatedEvent, highlighter) {
+        detail.previewing.set(false);
+        var sandbox = Coupling.getCoupled(comp, 'sandbox');
+        if (Sandboxing.isOpen(sandbox)) {
+          Composing.getCurrent(sandbox).each(function (menu) {
+            Highlighting.getHighlighted(menu).fold(function () {
+              highlighter(menu);
+            }, function () {
+              dispatchEvent(sandbox, menu.element, 'keydown', simulatedEvent);
+            });
+          });
+        } else {
+          var onOpenSync = function (sandbox) {
+            Composing.getCurrent(sandbox).each(highlighter);
+          };
+          open(detail, mapFetch(comp), comp, sandbox, externals, onOpenSync, HighlightOnOpen.HighlightFirst).get(noop);
+        }
+      };
+      var focusBehaviours$1 = focusBehaviours(detail);
+      var mapFetch = function (comp) {
+        return function (tdata) {
+          return tdata.map(function (data) {
+            var menus = values(data.menus);
+            var items = bind$3(menus, function (menu) {
+              return filter$2(menu.items, function (item) {
+                return item.type === 'item';
+              });
+            });
+            var repState = Representing.getState(comp);
+            repState.update(map$2(items, function (item) {
+              return item.data;
+            }));
+            return data;
+          });
+        };
+      };
+      var behaviours = [
+        Focusing.config({}),
+        Representing.config({
+          onSetValue: detail.onSetValue,
+          store: __assign({
+            mode: 'dataset',
+            getDataKey: function (comp) {
+              return get$5(comp.element);
+            },
+            getFallbackEntry: function (itemString) {
+              return {
+                value: itemString,
+                meta: {}
+              };
+            },
+            setValue: function (comp, data) {
+              set$4(comp.element, detail.model.getDisplayText(data));
+            }
+          }, detail.initialData.map(function (d) {
+            return wrap$1('initialValue', d);
+          }).getOr({}))
+        }),
+        Streaming.config({
+          stream: {
+            mode: 'throttle',
+            delay: detail.responseTime,
+            stopEvent: false
+          },
+          onStream: function (component, _simulatedEvent) {
+            var sandbox = Coupling.getCoupled(component, 'sandbox');
+            var focusInInput = Focusing.isFocused(component);
+            if (focusInInput) {
+              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) {
+                  Composing.getCurrent(sandbox).each(function (menu) {
+                    previousValue_1.fold(function () {
+                      if (detail.model.selectsOver) {
+                        Highlighting.highlightFirst(menu);
+                      }
+                    }, function (pv) {
+                      Highlighting.highlightBy(menu, function (item) {
+                        var itemData = Representing.getValue(item);
+                        return itemData.value === pv.value;
+                      });
+                      Highlighting.getHighlighted(menu).orThunk(function () {
+                        Highlighting.highlightFirst(menu);
+                        return Optional.none();
+                      });
+                    });
+                  });
+                };
+                open(detail, mapFetch(component), component, sandbox, externals, onOpenSync, HighlightOnOpen.HighlightFirst).get(noop);
+              }
+            }
+          },
+          cancelEvent: typeaheadCancel()
+        }),
+        Keying.config({
+          mode: 'special',
+          onDown: function (comp, simulatedEvent) {
+            navigateList(comp, simulatedEvent, Highlighting.highlightFirst);
+            return Optional.some(true);
+          },
+          onEscape: function (comp) {
+            var sandbox = Coupling.getCoupled(comp, 'sandbox');
+            if (Sandboxing.isOpen(sandbox)) {
+              Sandboxing.close(sandbox);
+              return Optional.some(true);
+            }
+            return Optional.none();
+          },
+          onUp: function (comp, simulatedEvent) {
+            navigateList(comp, simulatedEvent, Highlighting.highlightLast);
+            return Optional.some(true);
+          },
+          onEnter: function (comp) {
+            var sandbox = Coupling.getCoupled(comp, 'sandbox');
+            var sandboxIsOpen = Sandboxing.isOpen(sandbox);
+            if (sandboxIsOpen && !detail.previewing.get()) {
+              return Composing.getCurrent(sandbox).bind(function (menu) {
+                return Highlighting.getHighlighted(menu);
+              }).map(function (item) {
+                emitWith(comp, itemExecute(), { item: item });
+                return true;
+              });
+            } else {
+              var currentValue = Representing.getValue(comp);
+              emit(comp, typeaheadCancel());
+              detail.onExecute(sandbox, comp, currentValue);
+              if (sandboxIsOpen) {
+                Sandboxing.close(sandbox);
+              }
+              return Optional.some(true);
+            }
+          }
+        }),
+        Toggling.config({
+          toggleClass: detail.markers.openClass,
+          aria: { mode: 'expanded' }
+        }),
+        Coupling.config({
+          others: {
+            sandbox: function (hotspot) {
+              return makeSandbox$1(detail, hotspot, {
+                onOpen: function () {
+                  return Toggling.on(hotspot);
+                },
+                onClose: function () {
+                  return Toggling.off(hotspot);
+                }
+              });
+            }
+          }
+        }),
+        config('typeaheadevents', [
+          runOnExecute$1(function (comp) {
+            var onOpenSync = noop;
+            togglePopup(detail, mapFetch(comp), comp, externals, onOpenSync, HighlightOnOpen.HighlightFirst).get(noop);
+          }),
+          run$1(itemExecute(), function (comp, se) {
+            var sandbox = Coupling.getCoupled(comp, 'sandbox');
+            setValueFromItem(detail.model, comp, se.event.item);
+            emit(comp, typeaheadCancel());
+            detail.onItemExecute(comp, sandbox, se.event.item, Representing.getValue(comp));
+            Sandboxing.close(sandbox);
+            setCursorAtEnd(comp);
+          })
+        ].concat(detail.dismissOnBlur ? [run$1(postBlur(), function (typeahead) {
+            var sandbox = Coupling.getCoupled(typeahead, 'sandbox');
+            if (search(sandbox.element).isNone()) {
+              Sandboxing.close(sandbox);
+            }
+          })] : []))
+      ];
+      return {
+        uid: detail.uid,
+        dom: dom(deepMerge(detail, {
+          inputAttributes: {
+            'role': 'combobox',
+            'aria-autocomplete': 'list',
+            'aria-haspopup': 'true'
+          }
+        })),
+        behaviours: __assign(__assign({}, focusBehaviours$1), augment(detail.typeaheadBehaviours, behaviours)),
+        eventOrder: detail.eventOrder
+      };
+    };
+
+    var schema$g = constant$1([
+      option('lazySink'),
+      required$1('fetch'),
+      defaulted('minChars', 5),
+      defaulted('responseTime', 1000),
+      onHandler('onOpen'),
+      defaulted('getHotspot', Optional.some),
+      defaulted('getAnchorOverrides', constant$1({})),
+      defaulted('layouts', Optional.none()),
+      defaulted('eventOrder', {}),
+      defaultedObjOf('model', {}, [
+        defaulted('getDisplayText', function (itemData) {
+          return itemData.meta !== undefined && itemData.meta.text !== undefined ? itemData.meta.text : itemData.value;
+        }),
+        defaulted('selectsOver', true),
+        defaulted('populateFromBrowse', true)
+      ]),
+      onHandler('onSetValue'),
+      onKeyboardHandler('onExecute'),
+      onHandler('onItemExecute'),
+      defaulted('inputClasses', []),
+      defaulted('inputAttributes', {}),
+      defaulted('inputStyles', {}),
+      defaulted('matchWidth', true),
+      defaulted('useMinWidth', false),
+      defaulted('dismissOnBlur', true),
+      markers$1(['openClass']),
+      option('initialData'),
+      field('typeaheadBehaviours', [
+        Focusing,
+        Representing,
+        Streaming,
+        Keying,
+        Toggling,
+        Coupling
+      ]),
+      customField('previewing', function () {
+        return Cell(true);
+      })
+    ].concat(schema$k()).concat(sandboxFields()));
+    var parts$b = constant$1([external$1({
+        schema: [tieredMenuMarkers()],
+        name: 'menu',
+        overrides: function (detail) {
+          return {
+            fakeFocus: true,
+            onHighlight: function (menu, item) {
+              if (!detail.previewing.get()) {
+                menu.getSystem().getByUid(detail.uid).each(function (input) {
+                  if (detail.model.populateFromBrowse) {
+                    setValueFromItem(detail.model, input, item);
+                  }
+                });
+              } else {
+                menu.getSystem().getByUid(detail.uid).each(function (input) {
+                  attemptSelectOver(detail.model, input, item).fold(function () {
+                    return Highlighting.dehighlight(menu, item);
+                  }, function (fn) {
+                    return fn();
+                  });
+                });
+              }
+              detail.previewing.set(false);
+            },
+            onExecute: function (menu, item) {
+              return menu.getSystem().getByUid(detail.uid).toOptional().map(function (typeahead) {
+                emitWith(typeahead, itemExecute(), { item: item });
+                return true;
+              });
+            },
+            onHover: function (menu, item) {
+              detail.previewing.set(false);
+              menu.getSystem().getByUid(detail.uid).each(function (input) {
+                if (detail.model.populateFromBrowse) {
+                  setValueFromItem(detail.model, input, item);
+                }
+              });
+            }
+          };
+        }
+      })]);
+
+    var Typeahead = composite({
+      name: 'Typeahead',
+      configFields: schema$g(),
+      partFields: parts$b(),
+      factory: make$3
+    });
+
+    var wrap = function (delegate) {
+      var toCached = function () {
+        return wrap(delegate.toCached());
+      };
+      var bindFuture = function (f) {
+        return wrap(delegate.bind(function (resA) {
+          return resA.fold(function (err) {
+            return Future.pure(Result.error(err));
+          }, function (a) {
+            return f(a);
+          });
+        }));
+      };
+      var bindResult = function (f) {
+        return wrap(delegate.map(function (resA) {
+          return resA.bind(f);
+        }));
+      };
+      var mapResult = function (f) {
+        return wrap(delegate.map(function (resA) {
+          return resA.map(f);
+        }));
+      };
+      var mapError = function (f) {
+        return wrap(delegate.map(function (resA) {
+          return resA.mapError(f);
+        }));
+      };
+      var foldResult = function (whenError, whenValue) {
+        return delegate.map(function (res) {
+          return res.fold(whenError, whenValue);
+        });
+      };
+      var withTimeout = function (timeout, errorThunk) {
+        return wrap(Future.nu(function (callback) {
+          var timedOut = false;
+          var timer = setTimeout(function () {
+            timedOut = true;
+            callback(Result.error(errorThunk()));
+          }, timeout);
+          delegate.get(function (result) {
+            if (!timedOut) {
+              clearTimeout(timer);
+              callback(result);
+            }
+          });
+        }));
+      };
+      return __assign(__assign({}, delegate), {
+        toCached: toCached,
+        bindFuture: bindFuture,
+        bindResult: bindResult,
+        mapResult: mapResult,
+        mapError: mapError,
+        foldResult: foldResult,
+        withTimeout: withTimeout
+      });
+    };
+    var nu$1 = function (worker) {
+      return wrap(Future.nu(worker));
+    };
+    var value = function (value) {
+      return wrap(Future.pure(Result.value(value)));
+    };
+    var error = function (error) {
+      return wrap(Future.pure(Result.error(error)));
+    };
+    var fromResult = function (result) {
+      return wrap(Future.pure(result));
+    };
+    var fromFuture = function (future) {
+      return wrap(future.map(Result.value));
+    };
+    var fromPromise = function (promise) {
+      return nu$1(function (completer) {
+        promise.then(function (value) {
+          completer(Result.value(value));
+        }, function (error) {
+          completer(Result.error(error));
+        });
+      });
+    };
+    var FutureResult = {
+      nu: nu$1,
+      wrap: wrap,
+      pure: value,
+      value: value,
+      error: error,
+      fromResult: fromResult,
+      fromFuture: fromFuture,
+      fromPromise: fromPromise
+    };
+
+    var separator$1 = { type: 'separator' };
+    var toMenuItem = function (target) {
+      return {
+        type: 'menuitem',
+        value: target.url,
+        text: target.title,
+        meta: { attach: target.attach },
+        onAction: noop
+      };
+    };
+    var staticMenuItem = function (title, url) {
+      return {
+        type: 'menuitem',
+        value: url,
+        text: title,
+        meta: { attach: undefined },
+        onAction: noop
+      };
+    };
+    var toMenuItems = function (targets) {
+      return map$2(targets, toMenuItem);
+    };
+    var filterLinkTargets = function (type, targets) {
+      return filter$2(targets, function (target) {
+        return target.type === type;
+      });
+    };
+    var filteredTargets = function (type, targets) {
+      return toMenuItems(filterLinkTargets(type, targets));
+    };
+    var headerTargets = function (linkInfo) {
+      return filteredTargets('header', linkInfo.targets);
+    };
+    var anchorTargets = function (linkInfo) {
+      return filteredTargets('anchor', linkInfo.targets);
+    };
+    var anchorTargetTop = function (linkInfo) {
+      return Optional.from(linkInfo.anchorTop).map(function (url) {
+        return staticMenuItem('<top>', url);
+      }).toArray();
+    };
+    var anchorTargetBottom = function (linkInfo) {
+      return Optional.from(linkInfo.anchorBottom).map(function (url) {
+        return staticMenuItem('<bottom>', url);
+      }).toArray();
+    };
+    var historyTargets = function (history) {
+      return map$2(history, function (url) {
+        return staticMenuItem(url, url);
+      });
+    };
+    var joinMenuLists = function (items) {
+      return foldl(items, function (a, b) {
+        var bothEmpty = a.length === 0 || b.length === 0;
+        return bothEmpty ? a.concat(b) : a.concat(separator$1, b);
+      }, []);
+    };
+    var filterByQuery = function (term, menuItems) {
+      var lowerCaseTerm = term.toLowerCase();
+      return filter$2(menuItems, function (item) {
+        var text = item.meta !== undefined && item.meta.text !== undefined ? item.meta.text : item.text;
+        return contains$1(text.toLowerCase(), lowerCaseTerm) || contains$1(item.value.toLowerCase(), lowerCaseTerm);
+      });
+    };
+
+    var getItems = function (fileType, input, urlBackstage) {
+      var urlInputValue = Representing.getValue(input);
+      var term = urlInputValue.meta.text !== undefined ? urlInputValue.meta.text : urlInputValue.value;
+      var info = urlBackstage.getLinkInformation();
+      return info.fold(function () {
+        return [];
+      }, function (linkInfo) {
+        var history = filterByQuery(term, historyTargets(urlBackstage.getHistory(fileType)));
+        return fileType === 'file' ? joinMenuLists([
+          history,
+          filterByQuery(term, headerTargets(linkInfo)),
+          filterByQuery(term, flatten([
+            anchorTargetTop(linkInfo),
+            anchorTargets(linkInfo),
+            anchorTargetBottom(linkInfo)
+          ]))
+        ]) : history;
+      });
+    };
+    var errorId = generate$6('aria-invalid');
+    var renderUrlInput = function (spec, backstage, urlBackstage) {
+      var _a;
+      var providersBackstage = backstage.shared.providers;
+      var updateHistory = function (component) {
+        var urlEntry = Representing.getValue(component);
+        urlBackstage.addToHistory(urlEntry.value, spec.filetype);
+      };
+      var pField = FormField.parts.field({
+        factory: Typeahead,
+        dismissOnBlur: true,
+        inputClasses: ['tox-textfield'],
+        sandboxClasses: ['tox-dialog__popups'],
+        inputAttributes: {
+          'aria-errormessage': errorId,
+          'type': 'url'
+        },
+        minChars: 0,
+        responseTime: 0,
+        fetch: function (input) {
+          var items = getItems(spec.filetype, input, urlBackstage);
+          var tdata = build(items, ItemResponse$1.BUBBLE_TO_SANDBOX, backstage, false);
+          return Future.pure(tdata);
+        },
+        getHotspot: function (comp) {
+          return memUrlBox.getOpt(comp);
+        },
+        onSetValue: function (comp, _newValue) {
+          if (comp.hasConfigured(Invalidating)) {
+            Invalidating.run(comp).get(noop);
+          }
+        },
+        typeaheadBehaviours: derive$1(flatten([
+          urlBackstage.getValidationHandler().map(function (handler) {
+            return Invalidating.config({
+              getRoot: function (comp) {
+                return parent(comp.element);
+              },
+              invalidClass: 'tox-control-wrap--status-invalid',
+              notify: {
+                onInvalid: function (comp, err) {
+                  memInvalidIcon.getOpt(comp).each(function (invalidComp) {
+                    set$8(invalidComp.element, 'title', providersBackstage.translate(err));
+                  });
+                }
+              },
+              validator: {
+                validate: function (input) {
+                  var urlEntry = Representing.getValue(input);
+                  return FutureResult.nu(function (completer) {
+                    handler({
+                      type: spec.filetype,
+                      url: urlEntry.value
+                    }, function (validation) {
+                      if (validation.status === 'invalid') {
+                        var err = Result.error(validation.message);
+                        completer(err);
+                      } else {
+                        var val = Result.value(validation.message);
+                        completer(val);
+                      }
+                    });
+                  });
+                },
+                validateOnLoad: false
+              }
+            });
+          }).toArray(),
+          [
+            Disabling.config({
+              disabled: function () {
+                return spec.disabled || providersBackstage.isDisabled();
+              }
+            }),
+            Tabstopping.config({}),
+            config('urlinput-events', flatten([
+              spec.filetype === 'file' ? [run$1(input(), function (comp) {
+                  emitWith(comp, formChangeEvent, { name: spec.name });
+                })] : [],
+              [
+                run$1(change(), function (comp) {
+                  emitWith(comp, formChangeEvent, { name: spec.name });
+                  updateHistory(comp);
+                }),
+                run$1(postPaste(), function (comp) {
+                  emitWith(comp, formChangeEvent, { name: spec.name });
+                  updateHistory(comp);
+                })
+              ]
+            ]))
+          ]
+        ])),
+        eventOrder: (_a = {}, _a[input()] = [
+          'streaming',
+          'urlinput-events',
+          'invalidating'
+        ], _a),
+        model: {
+          getDisplayText: function (itemData) {
+            return itemData.value;
+          },
+          selectsOver: false,
+          populateFromBrowse: false
+        },
+        markers: { openClass: 'tox-textfield--popup-open' },
+        lazySink: backstage.shared.getSink,
+        parts: { menu: part(false, 1, 'normal') },
+        onExecute: function (_menu, component, _entry) {
+          emitWith(component, formSubmitEvent, {});
+        },
+        onItemExecute: function (typeahead, _sandbox, _item, _value) {
+          updateHistory(typeahead);
+          emitWith(typeahead, formChangeEvent, { name: spec.name });
+        }
+      });
+      var pLabel = spec.label.map(function (label) {
+        return renderLabel$2(label, providersBackstage);
+      });
+      var makeIcon = function (name, errId, icon, label) {
+        if (icon === void 0) {
+          icon = name;
+        }
+        if (label === void 0) {
+          label = name;
+        }
+        return render$3(icon, {
+          tag: 'div',
+          classes: [
+            'tox-icon',
+            'tox-control-wrap__status-icon-' + name
+          ],
+          attributes: __assign({
+            'title': providersBackstage.translate(label),
+            'aria-live': 'polite'
+          }, errId.fold(function () {
+            return {};
+          }, function (id) {
+            return { id: id };
+          }))
+        }, providersBackstage.icons);
+      };
+      var memInvalidIcon = record(makeIcon('invalid', Optional.some(errorId), 'warning'));
+      var memStatus = record({
+        dom: {
+          tag: 'div',
+          classes: ['tox-control-wrap__status-icon-wrap']
+        },
+        components: [memInvalidIcon.asSpec()]
+      });
+      var optUrlPicker = urlBackstage.getUrlPicker(spec.filetype);
+      var browseUrlEvent = generate$6('browser.url.event');
+      var memUrlBox = record({
+        dom: {
+          tag: 'div',
+          classes: ['tox-control-wrap']
+        },
+        components: [
+          pField,
+          memStatus.asSpec()
+        ],
+        behaviours: derive$1([Disabling.config({
+            disabled: function () {
+              return spec.disabled || providersBackstage.isDisabled();
+            }
+          })])
+      });
+      var memUrlPickerButton = record(renderButton({
+        name: spec.name,
+        icon: Optional.some('browse'),
+        text: spec.label.getOr(''),
+        disabled: spec.disabled,
+        primary: false,
+        borderless: true
+      }, function (component) {
+        return emit(component, browseUrlEvent);
+      }, providersBackstage, [], ['tox-browse-url']));
+      var controlHWrapper = function () {
+        return {
+          dom: {
+            tag: 'div',
+            classes: ['tox-form__controls-h-stack']
+          },
+          components: flatten([
+            [memUrlBox.asSpec()],
+            optUrlPicker.map(function () {
+              return memUrlPickerButton.asSpec();
+            }).toArray()
+          ])
+        };
+      };
+      var openUrlPicker = function (comp) {
+        Composing.getCurrent(comp).each(function (field) {
+          var componentData = Representing.getValue(field);
+          var urlData = __assign({ fieldname: spec.name }, componentData);
+          optUrlPicker.each(function (picker) {
+            picker(urlData).get(function (chosenData) {
+              Representing.setValue(field, chosenData);
+              emitWith(comp, formChangeEvent, { name: spec.name });
+            });
+          });
+        });
+      };
+      return FormField.sketch({
+        dom: renderFormFieldDom(),
+        components: pLabel.toArray().concat([controlHWrapper()]),
+        fieldBehaviours: derive$1([
+          Disabling.config({
+            disabled: function () {
+              return spec.disabled || providersBackstage.isDisabled();
+            },
+            onDisabled: function (comp) {
+              FormField.getField(comp).each(Disabling.disable);
+              memUrlPickerButton.getOpt(comp).each(Disabling.disable);
+            },
+            onEnabled: function (comp) {
+              FormField.getField(comp).each(Disabling.enable);
+              memUrlPickerButton.getOpt(comp).each(Disabling.enable);
+            }
+          }),
+          receivingConfig(),
+          config('url-input-events', [run$1(browseUrlEvent, openUrlPicker)])
+        ])
+      });
+    };
+
+    var renderAlertBanner = function (spec, providersBackstage) {
+      return Container.sketch({
+        dom: {
+          tag: 'div',
+          attributes: { role: 'alert' },
+          classes: [
+            'tox-notification',
+            'tox-notification--in',
+            'tox-notification--' + spec.level
+          ]
+        },
+        components: [
+          {
+            dom: {
+              tag: 'div',
+              classes: ['tox-notification__icon']
+            },
+            components: [Button.sketch({
+                dom: {
+                  tag: 'button',
+                  classes: [
+                    'tox-button',
+                    'tox-button--naked',
+                    'tox-button--icon'
+                  ],
+                  innerHtml: get$1(spec.icon, providersBackstage.icons),
+                  attributes: { title: providersBackstage.translate(spec.iconTooltip) }
+                },
+                action: function (comp) {
+                  emitWith(comp, formActionEvent, {
+                    name: 'alert-banner',
+                    value: spec.url
+                  });
+                },
+                buttonBehaviours: derive$1([addFocusableBehaviour()])
+              })]
+          },
+          {
+            dom: {
+              tag: 'div',
+              classes: ['tox-notification__body'],
+              innerHtml: providersBackstage.translate(spec.text)
+            }
+          }
+        ]
+      });
+    };
+
+    var renderCheckbox = function (spec, providerBackstage) {
+      var repBehaviour = Representing.config({
+        store: {
+          mode: 'manual',
+          getValue: function (comp) {
+            var el = comp.element.dom;
+            return el.checked;
+          },
+          setValue: function (comp, value) {
+            var el = comp.element.dom;
+            el.checked = value;
+          }
+        }
+      });
+      var toggleCheckboxHandler = function (comp) {
+        comp.element.dom.click();
+        return Optional.some(true);
+      };
+      var pField = FormField.parts.field({
+        factory: { sketch: identity$1 },
+        dom: {
+          tag: 'input',
+          classes: ['tox-checkbox__input'],
+          attributes: { type: 'checkbox' }
+        },
+        behaviours: derive$1([
+          ComposingConfigs.self(),
+          Disabling.config({
+            disabled: function () {
+              return spec.disabled || providerBackstage.isDisabled();
+            }
+          }),
+          Tabstopping.config({}),
+          Focusing.config({}),
+          repBehaviour,
+          Keying.config({
+            mode: 'special',
+            onEnter: toggleCheckboxHandler,
+            onSpace: toggleCheckboxHandler,
+            stopSpaceKeyup: true
+          }),
+          config('checkbox-events', [run$1(change(), function (component, _) {
+              emitWith(component, formChangeEvent, { name: spec.name });
+            })])
+        ])
+      });
+      var pLabel = FormField.parts.label({
+        dom: {
+          tag: 'span',
+          classes: ['tox-checkbox__label'],
+          innerHtml: providerBackstage.translate(spec.label)
+        },
+        behaviours: derive$1([Unselecting.config({})])
+      });
+      var makeIcon = function (className) {
+        var iconName = className === 'checked' ? 'selected' : 'unselected';
+        return render$3(iconName, {
+          tag: 'span',
+          classes: [
+            'tox-icon',
+            'tox-checkbox-icon__' + className
+          ]
+        }, providerBackstage.icons);
+      };
+      var memIcons = record({
+        dom: {
+          tag: 'div',
+          classes: ['tox-checkbox__icons']
+        },
+        components: [
+          makeIcon('checked'),
+          makeIcon('unchecked')
+        ]
+      });
+      return FormField.sketch({
+        dom: {
+          tag: 'label',
+          classes: ['tox-checkbox']
+        },
+        components: [
+          pField,
+          memIcons.asSpec(),
+          pLabel
+        ],
+        fieldBehaviours: derive$1([
+          Disabling.config({
+            disabled: function () {
+              return spec.disabled || providerBackstage.isDisabled();
+            },
+            disableClass: 'tox-checkbox--disabled',
+            onDisabled: function (comp) {
+              FormField.getField(comp).each(Disabling.disable);
+            },
+            onEnabled: function (comp) {
+              FormField.getField(comp).each(Disabling.enable);
+            }
+          }),
+          receivingConfig()
+        ])
+      });
+    };
+
+    var renderHtmlPanel = function (spec) {
+      if (spec.presets === 'presentation') {
+        return Container.sketch({
+          dom: {
+            tag: 'div',
+            classes: ['tox-form__group'],
+            innerHtml: spec.html
+          }
+        });
+      } else {
+        return Container.sketch({
+          dom: {
+            tag: 'div',
+            classes: ['tox-form__group'],
+            innerHtml: spec.html,
+            attributes: { role: 'document' }
+          },
+          containerBehaviours: derive$1([
+            Tabstopping.config({}),
+            Focusing.config({})
+          ])
+        });
+      }
+    };
+
+    var make$2 = function (render) {
+      return function (parts, spec, backstage) {
+        return get$e(spec, 'name').fold(function () {
+          return render(spec, backstage);
+        }, function (fieldName) {
+          return parts.field(fieldName, render(spec, backstage));
+        });
+      };
+    };
+    var makeIframe = function (render) {
+      return function (parts, spec, backstage) {
+        var iframeSpec = deepMerge(spec, { source: 'dynamic' });
+        return make$2(render)(parts, iframeSpec, backstage);
+      };
+    };
+    var factories = {
+      bar: make$2(function (spec, backstage) {
+        return renderBar(spec, backstage.shared);
+      }),
+      collection: make$2(function (spec, backstage) {
+        return renderCollection(spec, backstage.shared.providers);
+      }),
+      alertbanner: make$2(function (spec, backstage) {
+        return renderAlertBanner(spec, backstage.shared.providers);
+      }),
+      input: make$2(function (spec, backstage) {
+        return renderInput(spec, backstage.shared.providers);
+      }),
+      textarea: make$2(function (spec, backstage) {
+        return renderTextarea(spec, backstage.shared.providers);
+      }),
+      label: make$2(function (spec, backstage) {
+        return renderLabel(spec, backstage.shared);
+      }),
+      iframe: makeIframe(function (spec, backstage) {
+        return renderIFrame(spec, backstage.shared.providers);
+      }),
+      button: make$2(function (spec, backstage) {
+        return renderDialogButton(spec, backstage.shared.providers);
+      }),
+      checkbox: make$2(function (spec, backstage) {
+        return renderCheckbox(spec, backstage.shared.providers);
+      }),
+      colorinput: make$2(function (spec, backstage) {
+        return renderColorInput(spec, backstage.shared, backstage.colorinput);
+      }),
+      colorpicker: make$2(renderColorPicker),
+      dropzone: make$2(function (spec, backstage) {
+        return renderDropZone(spec, backstage.shared.providers);
+      }),
+      grid: make$2(function (spec, backstage) {
+        return renderGrid(spec, backstage.shared);
+      }),
+      listbox: make$2(function (spec, backstage) {
+        return renderListBox(spec, backstage);
+      }),
+      selectbox: make$2(function (spec, backstage) {
+        return renderSelectBox(spec, backstage.shared.providers);
+      }),
+      sizeinput: make$2(function (spec, backstage) {
+        return renderSizeInput(spec, backstage.shared.providers);
+      }),
+      urlinput: make$2(function (spec, backstage) {
+        return renderUrlInput(spec, backstage, backstage.urlinput);
+      }),
+      customeditor: make$2(renderCustomEditor),
+      htmlpanel: make$2(renderHtmlPanel),
+      imagetools: make$2(function (spec, backstage) {
+        return renderImageTools(spec, backstage.shared.providers);
+      }),
+      table: make$2(function (spec, backstage) {
+        return renderTable(spec, backstage.shared.providers);
+      }),
+      panel: make$2(function (spec, backstage) {
+        return renderPanel(spec, backstage);
+      })
+    };
+    var noFormParts = {
+      field: function (_name, spec) {
+        return spec;
+      }
+    };
+    var interpretInForm = function (parts, spec, oldBackstage) {
+      var newBackstage = deepMerge(oldBackstage, {
+        shared: {
+          interpreter: function (childSpec) {
+            return interpretParts(parts, childSpec, newBackstage);
+          }
+        }
+      });
+      return interpretParts(parts, spec, newBackstage);
+    };
+    var interpretParts = function (parts, spec, backstage) {
+      return get$e(factories, spec.type).fold(function () {
+        console.error('Unknown factory type "' + spec.type + '", defaulting to container: ', spec);
+        return spec;
+      }, function (factory) {
+        return factory(parts, spec, backstage);
+      });
+    };
+    var interpretWithoutForm = function (spec, backstage) {
+      var parts = noFormParts;
+      return interpretParts(parts, spec, backstage);
+    };
+
+    var bubbleAlignments$2 = {
+      valignCentre: [],
+      alignCentre: [],
+      alignLeft: [],
+      alignRight: [],
+      right: [],
+      left: [],
+      bottom: [],
+      top: []
+    };
+    var getInlineDialogAnchor = function (contentAreaElement, lazyAnchorbar, lazyUseEditableAreaAnchor) {
+      var bubbleSize = 12;
+      var overrides = { maxHeightFunction: expandable$1() };
+      var editableAreaAnchor = function () {
+        return {
+          type: 'node',
+          root: getContentContainer(contentAreaElement()),
+          node: Optional.from(contentAreaElement()),
+          bubble: nu$5(bubbleSize, bubbleSize, bubbleAlignments$2),
+          layouts: {
+            onRtl: function () {
+              return [northeast];
+            },
+            onLtr: function () {
+              return [northwest];
+            }
+          },
+          overrides: overrides
+        };
+      };
+      var standardAnchor = function () {
+        return {
+          type: 'hotspot',
+          hotspot: lazyAnchorbar(),
+          bubble: nu$5(-bubbleSize, bubbleSize, bubbleAlignments$2),
+          layouts: {
+            onRtl: function () {
+              return [southeast$2];
+            },
+            onLtr: function () {
+              return [southwest$2];
+            }
+          },
+          overrides: overrides
+        };
+      };
+      return function () {
+        return lazyUseEditableAreaAnchor() ? editableAreaAnchor() : standardAnchor();
+      };
+    };
+    var getBannerAnchor = function (contentAreaElement, lazyAnchorbar, lazyUseEditableAreaAnchor) {
+      var editableAreaAnchor = function () {
+        return {
+          type: 'node',
+          root: getContentContainer(contentAreaElement()),
+          node: Optional.from(contentAreaElement()),
+          layouts: {
+            onRtl: function () {
+              return [north];
+            },
+            onLtr: function () {
+              return [north];
+            }
+          }
+        };
+      };
+      var standardAnchor = function () {
+        return {
+          type: 'hotspot',
+          hotspot: lazyAnchorbar(),
+          layouts: {
+            onRtl: function () {
+              return [south$2];
+            },
+            onLtr: function () {
+              return [south$2];
+            }
+          }
+        };
+      };
+      return function () {
+        return lazyUseEditableAreaAnchor() ? editableAreaAnchor() : standardAnchor();
+      };
+    };
+    var getCursorAnchor = function (editor, bodyElement) {
+      return function () {
+        return {
+          type: 'selection',
+          root: bodyElement(),
+          getSelection: function () {
+            var rng = editor.selection.getRng();
+            return Optional.some(SimSelection.range(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset));
+          }
+        };
+      };
+    };
+    var getNodeAnchor$1 = function (bodyElement) {
+      return function (element) {
+        return {
+          type: 'node',
+          root: bodyElement(),
+          node: element
+        };
+      };
+    };
+    var getAnchors = function (editor, lazyAnchorbar, isToolbarTop) {
+      var useFixedToolbarContainer = useFixedContainer(editor);
+      var bodyElement = function () {
+        return SugarElement.fromDom(editor.getBody());
+      };
+      var contentAreaElement = function () {
+        return SugarElement.fromDom(editor.getContentAreaContainer());
+      };
+      var lazyUseEditableAreaAnchor = function () {
+        return useFixedToolbarContainer || !isToolbarTop();
+      };
+      return {
+        inlineDialog: getInlineDialogAnchor(contentAreaElement, lazyAnchorbar, lazyUseEditableAreaAnchor),
+        banner: getBannerAnchor(contentAreaElement, lazyAnchorbar, lazyUseEditableAreaAnchor),
+        cursor: getCursorAnchor(editor, bodyElement),
+        node: getNodeAnchor$1(bodyElement)
+      };
+    };
+
+    var colorPicker = function (editor) {
+      return function (callback, value) {
+        var dialog = colorPickerDialog(editor);
+        dialog(callback, value);
+      };
+    };
+    var hasCustomColors = function (editor) {
+      return function () {
+        return hasCustomColors$1(editor);
+      };
+    };
+    var getColors = function (editor) {
+      return function () {
+        return getColors$2(editor);
+      };
+    };
+    var getColorCols = function (editor) {
+      return function () {
+        return getColorCols$1(editor);
+      };
+    };
+    var ColorInputBackstage = function (editor) {
+      return {
+        colorPicker: colorPicker(editor),
+        hasCustomColors: hasCustomColors(editor),
+        getColors: getColors(editor),
+        getColorCols: getColorCols(editor)
+      };
+    };
+
+    var isDraggableModal = function (editor) {
+      return function () {
+        return isDraggableModal$1(editor);
+      };
+    };
+    var DialogBackstage = function (editor) {
+      return { isDraggableModal: isDraggableModal(editor) };
+    };
+
+    var HeaderBackstage = function (editor) {
+      var mode = Cell(isToolbarLocationBottom(editor) ? 'bottom' : 'top');
+      return {
+        isPositionedAtTop: function () {
+          return mode.get() === 'top';
+        },
+        getDockingMode: mode.get,
+        setDockingMode: mode.set
+      };
+    };
+
+    var defaultStyleFormats = [
+      {
+        title: 'Headings',
+        items: [
+          {
+            title: 'Heading 1',
+            format: 'h1'
+          },
+          {
+            title: 'Heading 2',
+            format: 'h2'
+          },
+          {
+            title: 'Heading 3',
+            format: 'h3'
+          },
+          {
+            title: 'Heading 4',
+            format: 'h4'
+          },
+          {
+            title: 'Heading 5',
+            format: 'h5'
+          },
+          {
+            title: 'Heading 6',
+            format: 'h6'
+          }
+        ]
+      },
+      {
+        title: 'Inline',
+        items: [
+          {
+            title: 'Bold',
+            format: 'bold'
+          },
+          {
+            title: 'Italic',
+            format: 'italic'
+          },
+          {
+            title: 'Underline',
+            format: 'underline'
+          },
+          {
+            title: 'Strikethrough',
+            format: 'strikethrough'
+          },
+          {
+            title: 'Superscript',
+            format: 'superscript'
+          },
+          {
+            title: 'Subscript',
+            format: 'subscript'
+          },
+          {
+            title: 'Code',
+            format: 'code'
+          }
+        ]
+      },
+      {
+        title: 'Blocks',
+        items: [
+          {
+            title: 'Paragraph',
+            format: 'p'
+          },
+          {
+            title: 'Blockquote',
+            format: 'blockquote'
+          },
+          {
+            title: 'Div',
+            format: 'div'
+          },
+          {
+            title: 'Pre',
+            format: 'pre'
+          }
+        ]
+      },
+      {
+        title: 'Align',
+        items: [
+          {
+            title: 'Left',
+            format: 'alignleft'
+          },
+          {
+            title: 'Center',
+            format: 'aligncenter'
+          },
+          {
+            title: 'Right',
+            format: 'alignright'
+          },
+          {
+            title: 'Justify',
+            format: 'alignjustify'
+          }
+        ]
+      }
+    ];
+    var isNestedFormat = function (format) {
+      return has$2(format, 'items');
+    };
+    var isBlockFormat = function (format) {
+      return has$2(format, 'block');
+    };
+    var isInlineFormat = function (format) {
+      return has$2(format, 'inline');
+    };
+    var isSelectorFormat = function (format) {
+      return has$2(format, 'selector');
+    };
+    var mapFormats = function (userFormats) {
+      return foldl(userFormats, function (acc, fmt) {
+        if (isNestedFormat(fmt)) {
+          var result = mapFormats(fmt.items);
+          return {
+            customFormats: acc.customFormats.concat(result.customFormats),
+            formats: acc.formats.concat([{
+                title: fmt.title,
+                items: result.formats
+              }])
+          };
+        } else if (isInlineFormat(fmt) || isBlockFormat(fmt) || isSelectorFormat(fmt)) {
+          var formatName = isString(fmt.name) ? fmt.name : fmt.title.toLowerCase();
+          var formatNameWithPrefix = 'custom-' + formatName;
+          return {
+            customFormats: acc.customFormats.concat([{
+                name: formatNameWithPrefix,
+                format: fmt
+              }]),
+            formats: acc.formats.concat([{
+                title: fmt.title,
+                format: formatNameWithPrefix,
+                icon: fmt.icon
+              }])
+          };
+        } else {
+          return __assign(__assign({}, acc), { formats: acc.formats.concat(fmt) });
+        }
+      }, {
+        customFormats: [],
+        formats: []
+      });
+    };
+    var registerCustomFormats = function (editor, userFormats) {
+      var result = mapFormats(userFormats);
+      var registerFormats = function (customFormats) {
+        each$1(customFormats, function (fmt) {
+          if (!editor.formatter.has(fmt.name)) {
+            editor.formatter.register(fmt.name, fmt.format);
+          }
+        });
+      };
+      if (editor.formatter) {
+        registerFormats(result.customFormats);
+      } else {
+        editor.on('init', function () {
+          registerFormats(result.customFormats);
+        });
+      }
+      return result.formats;
+    };
+    var getStyleFormats = function (editor) {
+      return getUserStyleFormats(editor).map(function (userFormats) {
+        var registeredUserFormats = registerCustomFormats(editor, userFormats);
+        return isMergeStyleFormats(editor) ? defaultStyleFormats.concat(registeredUserFormats) : registeredUserFormats;
+      }).getOr(defaultStyleFormats);
+    };
+
+    var processBasic = function (item, isSelectedFor, getPreviewFor) {
+      var formatterSpec = {
+        type: 'formatter',
+        isSelected: isSelectedFor(item.format),
+        getStylePreview: getPreviewFor(item.format)
+      };
+      return deepMerge(item, formatterSpec);
+    };
+    var register$8 = function (editor, formats, isSelectedFor, getPreviewFor) {
+      var enrichSupported = function (item) {
+        return processBasic(item, isSelectedFor, getPreviewFor);
+      };
+      var enrichMenu = function (item) {
+        var submenuSpec = { type: 'submenu' };
+        return deepMerge(item, submenuSpec);
+      };
+      var enrichCustom = function (item) {
+        var formatName = isString(item.name) ? item.name : generate$6(item.title);
+        var formatNameWithPrefix = 'custom-' + formatName;
+        var customSpec = {
+          type: 'formatter',
+          format: formatNameWithPrefix,
+          isSelected: isSelectedFor(formatNameWithPrefix),
+          getStylePreview: getPreviewFor(formatNameWithPrefix)
+        };
+        var newItem = deepMerge(item, customSpec);
+        editor.formatter.register(formatName, newItem);
+        return newItem;
+      };
+      var doEnrich = function (items) {
+        return map$2(items, function (item) {
+          var keys$1 = keys(item);
+          if (hasNonNullableKey(item, 'items')) {
+            var newItems = doEnrich(item.items);
+            return deepMerge(enrichMenu(item), { getStyleItems: constant$1(newItems) });
+          } else if (hasNonNullableKey(item, 'format')) {
+            return enrichSupported(item);
+          } else if (keys$1.length === 1 && contains$2(keys$1, 'title')) {
+            return deepMerge(item, { type: 'separator' });
+          } else {
+            return enrichCustom(item);
+          }
+        });
+      };
+      return doEnrich(formats);
+    };
+
+    var init$8 = function (editor) {
+      var isSelectedFor = function (format) {
+        return function () {
+          return editor.formatter.match(format);
+        };
+      };
+      var getPreviewFor = function (format) {
+        return function () {
+          var fmt = editor.formatter.get(format);
+          return fmt !== undefined ? Optional.some({
+            tag: fmt.length > 0 ? fmt[0].inline || fmt[0].block || 'div' : 'div',
+            styles: editor.dom.parseStyle(editor.formatter.getCssText(format))
+          }) : Optional.none();
+        };
+      };
+      var flatten = function (fmt) {
+        var subs = fmt.items;
+        return subs !== undefined && subs.length > 0 ? bind$3(subs, flatten) : [fmt.format];
+      };
+      var settingsFormats = Cell([]);
+      var settingsFlattenedFormats = Cell([]);
+      var eventsFormats = Cell([]);
+      var eventsFlattenedFormats = Cell([]);
+      var replaceSettings = Cell(false);
+      editor.on('PreInit', function (_e) {
+        var formats = getStyleFormats(editor);
+        var enriched = register$8(editor, formats, isSelectedFor, getPreviewFor);
+        settingsFormats.set(enriched);
+        settingsFlattenedFormats.set(bind$3(enriched, flatten));
+      });
+      editor.on('addStyleModifications', function (e) {
+        var modifications = register$8(editor, e.items, isSelectedFor, getPreviewFor);
+        eventsFormats.set(modifications);
+        replaceSettings.set(e.replace);
+        eventsFlattenedFormats.set(bind$3(modifications, flatten));
+      });
+      var getData = function () {
+        var fromSettings = replaceSettings.get() ? [] : settingsFormats.get();
+        var fromEvents = eventsFormats.get();
+        return fromSettings.concat(fromEvents);
+      };
+      var getFlattenedKeys = function () {
+        var fromSettings = replaceSettings.get() ? [] : settingsFlattenedFormats.get();
+        var fromEvents = eventsFlattenedFormats.get();
+        return fromSettings.concat(fromEvents);
+      };
+      return {
+        getData: getData,
+        getFlattenedKeys: getFlattenedKeys
+      };
+    };
+
+    var isElement = function (node) {
+      return isNonNullable(node) && node.nodeType === 1;
+    };
+    var trim = global$5.trim;
+    var hasContentEditableState = function (value) {
+      return function (node) {
+        if (isElement(node)) {
+          if (node.contentEditable === value) {
+            return true;
+          }
+          if (node.getAttribute('data-mce-contenteditable') === value) {
+            return true;
+          }
+        }
+        return false;
+      };
+    };
+    var isContentEditableTrue = hasContentEditableState('true');
+    var isContentEditableFalse = hasContentEditableState('false');
+    var create$1 = function (type, title, url, level, attach) {
+      return {
+        type: type,
+        title: title,
+        url: url,
+        level: level,
+        attach: attach
+      };
+    };
+    var isChildOfContentEditableTrue = function (node) {
+      while (node = node.parentNode) {
+        var value = node.contentEditable;
+        if (value && value !== 'inherit') {
+          return isContentEditableTrue(node);
+        }
+      }
+      return false;
+    };
+    var select = function (selector, root) {
+      return map$2(descendants(SugarElement.fromDom(root), selector), function (element) {
+        return element.dom;
+      });
+    };
+    var getElementText = function (elm) {
+      return elm.innerText || elm.textContent;
+    };
+    var getOrGenerateId = function (elm) {
+      return elm.id ? elm.id : generate$6('h');
+    };
+    var isAnchor = function (elm) {
+      return elm && elm.nodeName === 'A' && (elm.id || elm.name) !== undefined;
+    };
+    var isValidAnchor = function (elm) {
+      return isAnchor(elm) && isEditable(elm);
+    };
+    var isHeader = function (elm) {
+      return elm && /^(H[1-6])$/.test(elm.nodeName);
+    };
+    var isEditable = function (elm) {
+      return isChildOfContentEditableTrue(elm) && !isContentEditableFalse(elm);
+    };
+    var isValidHeader = function (elm) {
+      return isHeader(elm) && isEditable(elm);
+    };
+    var getLevel = function (elm) {
+      return isHeader(elm) ? parseInt(elm.nodeName.substr(1), 10) : 0;
+    };
+    var headerTarget = function (elm) {
+      var headerId = getOrGenerateId(elm);
+      var attach = function () {
+        elm.id = headerId;
+      };
+      return create$1('header', getElementText(elm), '#' + headerId, getLevel(elm), attach);
+    };
+    var anchorTarget = function (elm) {
+      var anchorId = elm.id || elm.name;
+      var anchorText = getElementText(elm);
+      return create$1('anchor', anchorText ? anchorText : '#' + anchorId, '#' + anchorId, 0, noop);
+    };
+    var getHeaderTargets = function (elms) {
+      return map$2(filter$2(elms, isValidHeader), headerTarget);
+    };
+    var getAnchorTargets = function (elms) {
+      return map$2(filter$2(elms, isValidAnchor), anchorTarget);
+    };
+    var getTargetElements = function (elm) {
+      var elms = select('h1,h2,h3,h4,h5,h6,a:not([href])', elm);
+      return elms;
+    };
+    var hasTitle = function (target) {
+      return trim(target.title).length > 0;
+    };
+    var find = function (elm) {
+      var elms = getTargetElements(elm);
+      return filter$2(getHeaderTargets(elms).concat(getAnchorTargets(elms)), hasTitle);
+    };
+    var LinkTargets = { find: find };
+
+    var STORAGE_KEY = 'tinymce-url-history';
+    var HISTORY_LENGTH = 5;
+    var isHttpUrl = function (url) {
+      return isString(url) && /^https?/.test(url);
+    };
+    var isArrayOfUrl = function (a) {
+      return isArray(a) && a.length <= HISTORY_LENGTH && forall(a, isHttpUrl);
+    };
+    var isRecordOfUrlArray = function (r) {
+      return isObject(r) && find$4(r, function (value) {
+        return !isArrayOfUrl(value);
+      }).isNone();
+    };
+    var getAllHistory = function () {
+      var unparsedHistory = global$8.getItem(STORAGE_KEY);
+      if (unparsedHistory === null) {
+        return {};
+      }
+      var history;
+      try {
+        history = JSON.parse(unparsedHistory);
+      } catch (e) {
+        if (e instanceof SyntaxError) {
+          console.log('Local storage ' + STORAGE_KEY + ' was not valid JSON', e);
+          return {};
+        }
+        throw e;
+      }
+      if (!isRecordOfUrlArray(history)) {
+        console.log('Local storage ' + STORAGE_KEY + ' was not valid format', history);
+        return {};
+      }
+      return history;
+    };
+    var setAllHistory = function (history) {
+      if (!isRecordOfUrlArray(history)) {
+        throw new Error('Bad format for history:\n' + 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 addToHistory = function (url, fileType) {
+      if (!isHttpUrl(url)) {
+        return;
+      }
+      var history = getAllHistory();
+      var items = get$e(history, fileType).getOr([]);
+      var itemsWithoutUrl = filter$2(items, function (item) {
+        return item !== url;
+      });
+      history[fileType] = [url].concat(itemsWithoutUrl).slice(0, HISTORY_LENGTH);
+      setAllHistory(history);
+    };
+
+    var isTruthy = function (value) {
+      return !!value;
+    };
+    var makeMap = function (value) {
+      return map$1(global$5.makeMap(value, /[, ]/), isTruthy);
+    };
+    var getPicker = function (editor) {
+      return Optional.from(getFilePickerCallback(editor)).filter(isFunction);
+    };
+    var getPickerTypes = function (editor) {
+      var optFileTypes = Optional.some(getFilePickerTypes(editor)).filter(isTruthy);
+      var optLegacyTypes = Optional.some(getFileBrowserCallbackTypes(editor)).filter(isTruthy);
+      var optTypes = optFileTypes.or(optLegacyTypes).map(makeMap);
+      return getPicker(editor).fold(never, function (_picker) {
+        return optTypes.fold(always, function (types) {
+          return keys(types).length > 0 ? types : false;
+        });
+      });
+    };
+    var getPickerSetting = function (editor, filetype) {
+      var pickerTypes = getPickerTypes(editor);
+      if (isBoolean(pickerTypes)) {
+        return pickerTypes ? getPicker(editor) : Optional.none();
+      } else {
+        return pickerTypes[filetype] ? getPicker(editor) : Optional.none();
+      }
+    };
+    var getUrlPicker = function (editor, filetype) {
+      return getPickerSetting(editor, filetype).map(function (picker) {
+        return function (entry) {
+          return Future.nu(function (completer) {
+            var handler = function (value, meta) {
+              if (!isString(value)) {
+                throw new Error('Expected value to be string');
+              }
+              if (meta !== undefined && !isObject(meta)) {
+                throw new Error('Expected meta to be a object');
+              }
+              var r = {
+                value: value,
+                meta: meta
+              };
+              completer(r);
+            };
+            var meta = __assign({
+              filetype: filetype,
+              fieldname: entry.fieldname
+            }, Optional.from(entry.meta).getOr({}));
+            picker.call(editor, handler, entry.value, meta);
+          });
+        };
+      });
+    };
+    var getTextSetting = function (value) {
+      return Optional.from(value).filter(isString).getOrUndefined();
+    };
+    var getLinkInformation = function (editor) {
+      if (noTypeaheadUrls(editor)) {
+        return Optional.none();
+      }
+      return Optional.some({
+        targets: LinkTargets.find(editor.getBody()),
+        anchorTop: getTextSetting(getAnchorTop(editor)),
+        anchorBottom: getTextSetting(getAnchorBottom(editor))
+      });
+    };
+    var getValidationHandler = function (editor) {
+      return Optional.from(getFilePickerValidatorHandler(editor));
+    };
+    var UrlInputBackstage = function (editor) {
+      return {
+        getHistory: getHistory,
+        addToHistory: addToHistory,
+        getLinkInformation: function () {
+          return getLinkInformation(editor);
+        },
+        getValidationHandler: function () {
+          return getValidationHandler(editor);
+        },
+        getUrlPicker: function (filetype) {
+          return getUrlPicker(editor, filetype);
+        }
+      };
+    };
+
+    var init$7 = function (sink, editor, lazyAnchorbar) {
+      var contextMenuState = Cell(false);
+      var toolbar = HeaderBackstage(editor);
+      var backstage = {
+        shared: {
+          providers: {
+            icons: function () {
+              return editor.ui.registry.getAll().icons;
+            },
+            menuItems: function () {
+              return editor.ui.registry.getAll().menuItems;
+            },
+            translate: global$e.translate,
+            isDisabled: function () {
+              return editor.mode.isReadOnly() || editor.ui.isDisabled();
+            },
+            getSetting: editor.getParam.bind(editor)
+          },
+          interpreter: function (s) {
+            return interpretWithoutForm(s, backstage);
+          },
+          anchors: getAnchors(editor, lazyAnchorbar, toolbar.isPositionedAtTop),
+          header: toolbar,
+          getSink: function () {
+            return Result.value(sink);
+          }
+        },
+        urlinput: UrlInputBackstage(editor),
+        styleselect: init$8(editor),
+        colorinput: ColorInputBackstage(editor),
+        dialog: DialogBackstage(editor),
+        isContextMenuOpen: function () {
+          return contextMenuState.get();
+        },
+        setContextMenuState: function (state) {
+          return contextMenuState.set(state);
+        }
+      };
+      return backstage;
+    };
+
+    var setup$b = function (editor, mothership, uiMothership) {
+      var broadcastEvent = function (name, evt) {
+        each$1([
+          mothership,
+          uiMothership
+        ], function (ship) {
+          ship.broadcastEvent(name, evt);
+        });
+      };
+      var broadcastOn = function (channel, message) {
+        each$1([
+          mothership,
+          uiMothership
+        ], function (ship) {
+          ship.broadcastOn([channel], message);
+        });
+      };
+      var fireDismissPopups = function (evt) {
+        return broadcastOn(dismissPopups(), { target: evt.target });
+      };
+      var doc = getDocument();
+      var onTouchstart = bind(doc, 'touchstart', fireDismissPopups);
+      var onTouchmove = bind(doc, 'touchmove', function (evt) {
+        return broadcastEvent(documentTouchmove(), evt);
+      });
+      var onTouchend = bind(doc, 'touchend', function (evt) {
+        return broadcastEvent(documentTouchend(), evt);
+      });
+      var onMousedown = bind(doc, 'mousedown', fireDismissPopups);
+      var onMouseup = bind(doc, 'mouseup', function (evt) {
+        if (evt.raw.button === 0) {
+          broadcastOn(mouseReleased(), { target: evt.target });
+        }
+      });
+      var onContentClick = function (raw) {
+        return broadcastOn(dismissPopups(), { target: SugarElement.fromDom(raw.target) });
+      };
+      var onContentMouseup = function (raw) {
+        if (raw.button === 0) {
+          broadcastOn(mouseReleased(), { target: SugarElement.fromDom(raw.target) });
+        }
+      };
+      var onContentMousedown = function () {
+        each$1(editor.editorManager.get(), function (loopEditor) {
+          if (editor !== loopEditor) {
+            loopEditor.fire('DismissPopups', { relatedTarget: editor });
+          }
+        });
+      };
+      var onWindowScroll = function (evt) {
+        return broadcastEvent(windowScroll(), fromRawEvent(evt));
+      };
+      var onWindowResize = function (evt) {
+        broadcastOn(repositionPopups(), {});
+        broadcastEvent(windowResize(), fromRawEvent(evt));
+      };
+      var onEditorResize = function () {
+        return broadcastOn(repositionPopups(), {});
+      };
+      var onEditorProgress = function (evt) {
+        if (evt.state) {
+          broadcastOn(dismissPopups(), { target: SugarElement.fromDom(editor.getContainer()) });
+        }
+      };
+      var onDismissPopups = function (event) {
+        broadcastOn(dismissPopups(), { target: SugarElement.fromDom(event.relatedTarget.getContainer()) });
+      };
+      editor.on('PostRender', function () {
+        editor.on('click', onContentClick);
+        editor.on('tap', onContentClick);
+        editor.on('mouseup', onContentMouseup);
+        editor.on('mousedown', onContentMousedown);
+        editor.on('ScrollWindow', onWindowScroll);
+        editor.on('ResizeWindow', onWindowResize);
+        editor.on('ResizeEditor', onEditorResize);
+        editor.on('AfterProgressState', onEditorProgress);
+        editor.on('DismissPopups', onDismissPopups);
+      });
+      editor.on('remove', function () {
+        editor.off('click', onContentClick);
+        editor.off('tap', onContentClick);
+        editor.off('mouseup', onContentMouseup);
+        editor.off('mousedown', onContentMousedown);
+        editor.off('ScrollWindow', onWindowScroll);
+        editor.off('ResizeWindow', onWindowResize);
+        editor.off('ResizeEditor', onEditorResize);
+        editor.off('AfterProgressState', onEditorProgress);
+        editor.off('DismissPopups', onDismissPopups);
+        onMousedown.unbind();
+        onTouchstart.unbind();
+        onTouchmove.unbind();
+        onTouchend.unbind();
+        onMouseup.unbind();
+      });
+      editor.on('detach', function () {
+        detachSystem(mothership);
+        detachSystem(uiMothership);
+        mothership.destroy();
+        uiMothership.destroy();
+      });
+    };
+
+    var parts$a = AlloyParts;
+    var partType = PartType;
+
+    var schema$f = constant$1([
+      defaulted('shell', false),
+      required$1('makeItem'),
+      defaulted('setupItem', noop),
+      SketchBehaviours.field('listBehaviours', [Replacing])
+    ]);
+    var customListDetail = function () {
+      return { behaviours: derive$1([Replacing.config({})]) };
+    };
+    var itemsPart = optional({
+      name: 'items',
+      overrides: customListDetail
+    });
+    var parts$9 = constant$1([itemsPart]);
+    var name = constant$1('CustomList');
+
+    var factory$d = function (detail, components, _spec, _external) {
+      var setItems = function (list, items) {
+        getListContainer(list).fold(function () {
+          console.error('Custom List was defined to not be a shell, but no item container was specified in components');
+          throw new Error('Custom List was defined to not be a shell, but no item container was specified in components');
+        }, function (container) {
+          var itemComps = Replacing.contents(container);
+          var numListsRequired = items.length;
+          var numListsToAdd = numListsRequired - itemComps.length;
+          var itemsToAdd = numListsToAdd > 0 ? range$2(numListsToAdd, function () {
+            return detail.makeItem();
+          }) : [];
+          var itemsToRemove = itemComps.slice(numListsRequired);
+          each$1(itemsToRemove, function (item) {
+            return Replacing.remove(container, item);
+          });
+          each$1(itemsToAdd, function (item) {
+            return Replacing.append(container, item);
+          });
+          var builtLists = Replacing.contents(container);
+          each$1(builtLists, function (item, i) {
+            detail.setupItem(list, item, items[i], i);
+          });
+        });
+      };
+      var extra = detail.shell ? {
+        behaviours: [Replacing.config({})],
+        components: []
+      } : {
+        behaviours: [],
+        components: components
+      };
+      var getListContainer = function (component) {
+        return detail.shell ? Optional.some(component) : getPart(component, detail, 'items');
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: extra.components,
+        behaviours: augment(detail.listBehaviours, extra.behaviours),
+        apis: { setItems: setItems }
+      };
+    };
+    var CustomList = composite({
+      name: name(),
+      configFields: schema$f(),
+      partFields: parts$9(),
+      factory: factory$d,
+      apis: {
+        setItems: function (apis, list, items) {
+          apis.setItems(list, items);
+        }
+      }
+    });
+
+    var schema$e = constant$1([
+      required$1('dom'),
+      defaulted('shell', true),
+      field('toolbarBehaviours', [Replacing])
+    ]);
+    var enhanceGroups = function () {
+      return { behaviours: derive$1([Replacing.config({})]) };
+    };
+    var parts$8 = constant$1([optional({
+        name: 'groups',
+        overrides: enhanceGroups
+      })]);
+
+    var factory$c = function (detail, components, _spec, _externals) {
+      var setGroups = function (toolbar, groups) {
+        getGroupContainer(toolbar).fold(function () {
+          console.error('Toolbar was defined to not be a shell, but no groups container was specified in components');
+          throw new Error('Toolbar was defined to not be a shell, but no groups container was specified in components');
+        }, function (container) {
+          Replacing.set(container, groups);
+        });
+      };
+      var getGroupContainer = function (component) {
+        return detail.shell ? Optional.some(component) : getPart(component, detail, 'groups');
+      };
+      var extra = detail.shell ? {
+        behaviours: [Replacing.config({})],
+        components: []
+      } : {
+        behaviours: [],
+        components: components
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: extra.components,
+        behaviours: augment(detail.toolbarBehaviours, extra.behaviours),
+        apis: { setGroups: setGroups },
+        domModification: { attributes: { role: 'group' } }
+      };
+    };
+    var Toolbar = composite({
+      name: 'Toolbar',
+      configFields: schema$e(),
+      partFields: parts$8(),
+      factory: factory$c,
+      apis: {
+        setGroups: function (apis, toolbar, groups) {
+          apis.setGroups(toolbar, groups);
+        }
+      }
+    });
+
+    var setup$a = noop;
+    var isDocked$2 = never;
+    var getBehaviours$1 = constant$1([]);
+
+    var StaticHeader = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        setup: setup$a,
+        isDocked: isDocked$2,
+        getBehaviours: getBehaviours$1
+    });
+
+    var getOffsetParent = function (element) {
+      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$5(marker);
+          return offsetParent$1;
+        });
+      });
+    };
+    var getOrigin = function (element) {
+      return getOffsetParent(element).map(absolute$3).getOrThunk(function () {
+        return SugarPosition(0, 0);
+      });
+    };
+
+    var morphAdt = Adt.generate([
+      { static: [] },
+      { absolute: ['positionCss'] },
+      { fixed: ['positionCss'] }
+    ]);
+    var appear = function (component, contextualInfo) {
+      var elem = component.element;
+      add$2(elem, contextualInfo.transitionClass);
+      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$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 isTopCompletelyVisible = function (box, viewport) {
+      return box.y >= viewport.y;
+    };
+    var isBottomCompletelyVisible = function (box, viewport) {
+      return box.bottom <= viewport.bottom;
+    };
+    var isVisibleForModes = function (modes, box, viewport) {
+      return forall(modes, function (mode) {
+        switch (mode) {
+        case 'bottom':
+          return isBottomCompletelyVisible(box, viewport);
+        case 'top':
+          return isTopCompletelyVisible(box, viewport);
+        }
+      });
+    };
+    var getPrior = function (elem, state) {
+      return state.getInitialPos().map(function (pos) {
+        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$c(elem, 'position') || 'static',
+        bounds: box
+      });
+    };
+    var revertToOriginal = function (elem, box, state) {
+      return state.getInitialPos().bind(function (position) {
+        state.clearInitialPos();
+        switch (position.position) {
+        case 'static':
+          return Optional.some(morphAdt.static());
+        case 'absolute':
+          var offsetBox_1 = getOffsetParent(elem).map(box$1).getOrThunk(function () {
+            return box$1(body());
+          });
+          return Optional.some(morphAdt.absolute(NuPositionCss('absolute', get$e(position.style, 'left').map(function (_left) {
+            return box.x - offsetBox_1.x;
+          }), get$e(position.style, 'top').map(function (_top) {
+            return box.y - offsetBox_1.y;
+          }), get$e(position.style, 'right').map(function (_right) {
+            return offsetBox_1.right - box.right;
+          }), get$e(position.style, 'bottom').map(function (_bottom) {
+            return offsetBox_1.bottom - box.bottom;
+          }))));
+        default:
+          return Optional.none();
+        }
+      });
+    };
+    var morphToOriginal = function (elem, viewport, state) {
+      return getPrior(elem, state).filter(function (box) {
+        return isVisibleForModes(state.getModes(), box, viewport);
+      }).bind(function (box) {
+        return revertToOriginal(elem, box, state);
+      });
+    };
+    var morphToFixed = function (elem, viewport, state) {
+      var box = box$1(elem);
+      if (!isVisibleForModes(state.getModes(), box, viewport)) {
+        storePrior(elem, box, state);
+        var winBox = win();
+        var left = box.x - winBox.x;
+        var top_1 = viewport.y - winBox.y;
+        var bottom = winBox.bottom - viewport.bottom;
+        var isTop = box.y <= viewport.y;
+        return Optional.some(morphAdt.fixed(NuPositionCss('fixed', Optional.some(left), isTop ? Optional.some(top_1) : Optional.none(), Optional.none(), !isTop ? Optional.some(bottom) : Optional.none())));
+      } else {
+        return Optional.none();
+      }
+    };
+    var getMorph = function (component, viewport, state) {
+      var elem = component.element;
+      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, state) {
+      state.setDocked(false);
+      each$1([
+        'left',
+        'right',
+        'top',
+        'bottom',
+        'position'
+      ], function (prop) {
+        return remove$6(component.element, prop);
+      });
+      config.onUndocked(component);
+    };
+    var morphToCoord = function (component, config, state, position) {
+      var isDocked = position.position === 'fixed';
+      state.setDocked(isDocked);
+      applyPositionCss(component.element, position);
+      var method = isDocked ? config.onDocked : config.onUndocked;
+      method(component);
+    };
+    var updateVisibility = function (component, config, state, viewport, morphToDocked) {
+      if (morphToDocked === void 0) {
+        morphToDocked = false;
+      }
+      config.contextual.each(function (contextInfo) {
+        contextInfo.lazyContext(component).each(function (box) {
+          var isVisible = isPartiallyVisible(box, viewport);
+          if (isVisible !== state.isVisible()) {
+            state.setVisible(isVisible);
+            if (morphToDocked && !isVisible) {
+              add$1(component.element, [contextInfo.fadeOutClass]);
+              contextInfo.onHide(component);
+            } else {
+              var method = isVisible ? appear : disappear;
+              method(component, contextInfo);
+            }
+          }
+        });
+      });
+    };
+    var refreshInternal = function (component, config, state) {
+      var viewport = config.lazyViewport(component);
+      var isDocked = state.isDocked();
+      if (isDocked) {
+        updateVisibility(component, config, state, viewport);
+      }
+      getMorph(component, viewport, state).each(function (morph) {
+        morph.fold(function () {
+          return morphToStatic(component, config, state);
+        }, function (position) {
+          return morphToCoord(component, config, state, position);
+        }, function (position) {
+          updateVisibility(component, config, state, viewport, true);
+          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, state);
+        }, function (position) {
+          return morphToCoord(component, config, state, position);
+        }, noop);
+      });
+      state.setVisible(true);
+      config.contextual.each(function (contextInfo) {
+        remove$1(elem, [
+          contextInfo.fadeInClass,
+          contextInfo.fadeOutClass,
+          contextInfo.transitionClass
+        ]);
+        contextInfo.onShow(component);
+      });
+      refresh$4(component, config, state);
+    };
+    var refresh$4 = function (component, config, state) {
+      if (component.getSystem().isConnected()) {
+        refreshInternal(component, config, state);
+      }
+    };
+    var reset = function (component, config, state) {
+      if (state.isDocked()) {
+        resetInternal(component, config, state);
+      }
+    };
+    var isDocked$1 = function (component, config, state) {
+      return state.isDocked();
+    };
+    var setModes = function (component, config, state, modes) {
+      return state.setModes(modes);
+    };
+    var getModes = function (component, config, state) {
+      return state.getModes();
+    };
+
+    var DockingApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        refresh: refresh$4,
+        reset: reset,
+        isDocked: isDocked$1,
+        getModes: getModes,
+        setModes: setModes
+    });
+
+    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$1(component.element, [
+                contextInfo.transitionClass,
+                contextInfo.fadeInClass
+              ]);
+              var notify = dockState.isVisible() ? contextInfo.onShown : contextInfo.onHidden;
+              notify(component);
+            }
+            simulatedEvent.stop();
+          });
+        }),
+        run$1(windowScroll(), function (component, _) {
+          refresh$4(component, dockInfo, dockState);
+        }),
+        run$1(windowResize(), function (component, _) {
+          reset(component, dockInfo, dockState);
+        })
+      ]);
+    };
+
+    var ActiveDocking = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$5
+    });
+
+    var DockingSchema = [
+      optionObjOf('contextual', [
+        requiredString('fadeInClass'),
+        requiredString('fadeOutClass'),
+        requiredString('transitionClass'),
+        requiredFunction('lazyContext'),
+        onHandler('onShow'),
+        onHandler('onShown'),
+        onHandler('onHide'),
+        onHandler('onHidden')
+      ]),
+      defaultedFunction('lazyViewport', win),
+      defaultedArrayOf('modes', [
+        'top',
+        'bottom'
+      ], string),
+      onHandler('onDocked'),
+      onHandler('onUndocked')
+    ];
+
+    var init$6 = function (spec) {
+      var docked = Cell(false);
+      var visible = Cell(true);
+      var initialBounds = value$1();
+      var modes = Cell(spec.modes);
+      var readState = function () {
+        return 'docked:  ' + docked.get() + ', visible: ' + visible.get() + ', modes: ' + modes.get().join(',');
+      };
+      return nu$8({
+        isDocked: docked.get,
+        setDocked: docked.set,
+        getInitialPos: initialBounds.get,
+        setInitialPos: initialBounds.set,
+        clearInitialPos: initialBounds.clear,
+        isVisible: visible.get,
+        setVisible: visible.set,
+        getModes: modes.get,
+        setModes: modes.set,
+        readState: readState
+      });
+    };
+
+    var DockingState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init$6
+    });
+
+    var Docking = create$8({
+      fields: DockingSchema,
+      name: 'docking',
+      active: ActiveDocking,
+      apis: DockingApis,
+      state: DockingState
+    });
+
+    var toolbarHeightChange = constant$1(generate$6('toolbar-height-change'));
+
+    var visibility = {
+      fadeInClass: 'tox-editor-dock-fadein',
+      fadeOutClass: 'tox-editor-dock-fadeout',
+      transitionClass: 'tox-editor-dock-transition'
+    };
+    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$9(doc);
+      var markerElement = SugarElement.fromDom(e.elm);
+      var markerPos = absolute$2(markerElement);
+      var markerHeight = get$b(markerElement);
+      var markerTop = markerPos.y;
+      var markerBottom = markerTop + markerHeight;
+      var editorHeaderPos = absolute$3(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) {
+        to(scrollPos.left, markerTop - editorHeaderHeight, doc);
+      } else if (editorHeaderDockedAtBottom && markerBottom > editorHeaderTop) {
+        var y = markerTop - viewHeight + markerHeight + editorHeaderHeight;
+        to(scrollPos.left, y, doc);
+      }
+    };
+    var isDockedMode = function (header, mode) {
+      return contains$2(Docking.getModes(header), mode);
+    };
+    var updateIframeContentFlow = function (header) {
+      var getOccupiedHeight = function (elm) {
+        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$a(parentElem);
+          set$7(elm, 'width', parentWidth + 'px');
+          set$7(parentElem, padding, getOccupiedHeight(elm) + 'px');
+        } else {
+          remove$6(elm, 'width');
+          remove$6(parentElem, padding);
+        }
+      });
+    };
+    var updateSinkVisibility = function (sinkElem, visible) {
+      if (visible) {
+        remove$2(sinkElem, visibility.fadeOutClass);
+        add$1(sinkElem, [
+          visibility.transitionClass,
+          visibility.fadeInClass
+        ]);
+      } else {
+        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$2(editorContainer, editorStickyOffClass);
+      } else {
+        add$2(editorContainer, editorStickyOffClass);
+        remove$2(editorContainer, editorStickyOnClass);
+      }
+    };
+    var restoreFocus = function (headerElem, focusedElem) {
+      var ownerDoc = owner$4(focusedElem);
+      active(ownerDoc).filter(function (activeElm) {
+        return !eq(focusedElem, activeElm);
+      }).filter(function (activeElm) {
+        return eq(activeElm, SugarElement.fromDom(ownerDoc.dom.body)) || contains(headerElem, activeElm);
+      }).each(function () {
+        return focus$3(focusedElem);
+      });
+    };
+    var findFocusedElem = function (rootElm, lazySink) {
+      return search(rootElm).orThunk(function () {
+        return lazySink().toOptional().bind(function (sink) {
+          return search(sink.element);
+        });
+      });
+    };
+    var setup$9 = function (editor, sharedBackstage, lazyHeader) {
+      if (!editor.inline) {
+        if (!sharedBackstage.header.isPositionedAtTop()) {
+          editor.on('ResizeEditor', function () {
+            lazyHeader().each(Docking.reset);
+          });
+        }
+        editor.on('ResizeWindow ResizeEditor', function () {
+          lazyHeader().each(updateIframeContentFlow);
+        });
+        editor.on('SkinLoaded', function () {
+          lazyHeader().each(function (comp) {
+            Docking.isDocked(comp) ? Docking.reset(comp) : Docking.refresh(comp);
+          });
+        });
+        editor.on('FullscreenStateChanged', function () {
+          lazyHeader().each(Docking.reset);
+        });
+      }
+      editor.on('AfterScrollIntoView', function (e) {
+        lazyHeader().each(function (header) {
+          Docking.refresh(header);
+          var headerElem = header.element;
+          if (isVisible(headerElem)) {
+            scrollFromBehindHeader(e, headerElem);
+          }
+        });
+      });
+      editor.on('PostRender', function () {
+        updateEditorClasses(editor, false);
+      });
+    };
+    var isDocked = function (lazyHeader) {
+      return lazyHeader().map(Docking.isDocked).getOr(false);
+    };
+    var getIframeBehaviours = function () {
+      var _a;
+      return [Receiving.config({ channels: (_a = {}, _a[toolbarHeightChange()] = { onReceive: updateIframeContentFlow }, _a) })];
+    };
+    var getBehaviours = function (editor, sharedBackstage) {
+      var focusedElm = value$1();
+      var lazySink = sharedBackstage.getSink;
+      var runOnSinkElement = function (f) {
+        lazySink().each(function (sink) {
+          return f(sink.element);
+        });
+      };
+      var onDockingSwitch = function (comp) {
+        if (!editor.inline) {
+          updateIframeContentFlow(comp);
+        }
+        updateEditorClasses(editor, Docking.isDocked(comp));
+        comp.getSystem().broadcastOn([repositionPopups()], {});
+        lazySink().each(function (sink) {
+          return sink.getSystem().broadcastOn([repositionPopups()], {});
+        });
+      };
+      var additionalBehaviours = editor.inline ? [] : getIframeBehaviours();
+      return __spreadArray([
+        Focusing.config({}),
+        Docking.config({
+          contextual: __assign({
+            lazyContext: function (comp) {
+              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));
+            },
+            onShow: function () {
+              runOnSinkElement(function (elem) {
+                return updateSinkVisibility(elem, true);
+              });
+            },
+            onShown: function (comp) {
+              runOnSinkElement(function (elem) {
+                return remove$1(elem, [
+                  visibility.transitionClass,
+                  visibility.fadeInClass
+                ]);
+              });
+              focusedElm.get().each(function (elem) {
+                restoreFocus(comp.element, elem);
+                focusedElm.clear();
+              });
+            },
+            onHide: function (comp) {
+              findFocusedElem(comp.element, lazySink).fold(focusedElm.clear, focusedElm.set);
+              runOnSinkElement(function (elem) {
+                return updateSinkVisibility(elem, false);
+              });
+            },
+            onHidden: function () {
+              runOnSinkElement(function (elem) {
+                return remove$1(elem, [visibility.transitionClass]);
+              });
+            }
+          }, visibility),
+          lazyViewport: function (comp) {
+            var win$1 = win();
+            var offset = getStickyToolbarOffset(editor);
+            var top = win$1.y + (isDockedMode(comp, 'top') ? offset : 0);
+            var height = win$1.height - (isDockedMode(comp, 'bottom') ? offset : 0);
+            return bounds(win$1.x, top, win$1.width, height);
+          },
+          modes: [sharedBackstage.header.getDockingMode()],
+          onDocked: onDockingSwitch,
+          onUndocked: onDockingSwitch
+        })
+      ], additionalBehaviours, true);
+    };
+
+    var StickyHeader = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        setup: setup$9,
+        isDocked: isDocked,
+        getBehaviours: getBehaviours
+    });
+
+    var renderHeader = function (spec) {
+      var editor = spec.editor;
+      var getBehaviours$2 = spec.sticky ? getBehaviours : getBehaviours$1;
+      return {
+        uid: spec.uid,
+        dom: spec.dom,
+        components: spec.components,
+        behaviours: derive$1(getBehaviours$2(editor, spec.sharedBackstage))
+      };
+    };
+
+    var groupToolbarButtonSchema = objOf([
+      requiredString('type'),
+      requiredOf('items', oneOf([
+        arrOfObj([
+          requiredString('name'),
+          requiredArrayOf('items', string)
+        ]),
+        string
+      ]))
+    ].concat(baseToolbarButtonFields));
+    var createGroupToolbarButton = function (spec) {
+      return asRaw('GroupToolbarButton', groupToolbarButtonSchema, spec);
+    };
+
+    var baseMenuButtonFields = [
+      optionString('text'),
+      optionString('tooltip'),
+      optionString('icon'),
+      requiredFunction('fetch'),
+      defaultedFunction('onSetup', function () {
+        return noop;
+      })
+    ];
+
+    var MenuButtonSchema = objOf(__spreadArray([requiredString('type')], baseMenuButtonFields, true));
+    var createMenuButton = function (spec) {
+      return asRaw('menubutton', MenuButtonSchema, spec);
+    };
+
+    var splitButtonSchema = objOf([
+      requiredString('type'),
+      optionString('tooltip'),
+      optionString('icon'),
+      optionString('text'),
+      optionFunction('select'),
+      requiredFunction('fetch'),
+      defaultedFunction('onSetup', function () {
+        return noop;
+      }),
+      defaultedStringEnum('presets', 'normal', [
+        'normal',
+        'color',
+        'listpreview'
+      ]),
+      defaulted('columns', 1),
+      requiredFunction('onAction'),
+      requiredFunction('onItemAction')
+    ]);
+    var createSplitButton = function (spec) {
+      return asRaw('SplitButton', splitButtonSchema, spec);
+    };
+
+    var factory$b = function (detail, spec) {
+      var setMenus = function (comp, menus) {
+        var newMenus = map$2(menus, function (m) {
+          var buttonSpec = {
+            type: 'menubutton',
+            text: m.text,
+            fetch: function (callback) {
+              callback(m.getItems());
+            }
+          };
+          var internal = createMenuButton(buttonSpec).mapError(function (errInfo) {
+            return formatError(errInfo);
+          }).getOrDie();
+          return renderMenuButton(internal, 'tox-mbtn', spec.backstage, Optional.some('menuitem'));
+        });
+        Replacing.set(comp, newMenus);
+      };
+      var apis = {
+        focus: Keying.focusIn,
+        setMenus: setMenus
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: [],
+        behaviours: derive$1([
+          Replacing.config({}),
+          config('menubar-events', [
+            runOnAttached(function (component) {
+              detail.onSetup(component);
+            }),
+            run$1(mouseover(), function (comp, se) {
+              descendant(comp.element, '.' + 'tox-mbtn--active').each(function (activeButton) {
+                closest$1(se.event.target, '.' + 'tox-mbtn').each(function (hoveredButton) {
+                  if (!eq(activeButton, hoveredButton)) {
+                    comp.getSystem().getByDom(activeButton).each(function (activeComp) {
+                      comp.getSystem().getByDom(hoveredButton).each(function (hoveredComp) {
+                        Dropdown.expand(hoveredComp);
+                        Dropdown.close(activeComp);
+                        Focusing.focus(hoveredComp);
+                      });
+                    });
+                  }
+                });
+              });
+            }),
+            run$1(focusShifted(), function (comp, se) {
+              se.event.prevFocus.bind(function (prev) {
+                return comp.getSystem().getByDom(prev).toOptional();
+              }).each(function (prev) {
+                se.event.newFocus.bind(function (nu) {
+                  return comp.getSystem().getByDom(nu).toOptional();
+                }).each(function (nu) {
+                  if (Dropdown.isOpen(prev)) {
+                    Dropdown.expand(nu);
+                    Dropdown.close(prev);
+                  }
+                });
+              });
+            })
+          ]),
+          Keying.config({
+            mode: 'flow',
+            selector: '.' + 'tox-mbtn',
+            onEscape: function (comp) {
+              detail.onEscape(comp);
+              return Optional.some(true);
+            }
+          }),
+          Tabstopping.config({})
+        ]),
+        apis: apis,
+        domModification: { attributes: { role: 'menubar' } }
+      };
+    };
+    var SilverMenubar = single({
+      factory: factory$b,
+      name: 'silver.Menubar',
+      configFields: [
+        required$1('dom'),
+        required$1('uid'),
+        required$1('onEscape'),
+        required$1('backstage'),
+        defaulted('onSetup', noop)
+      ],
+      apis: {
+        focus: function (apis, comp) {
+          apis.focus(comp);
+        },
+        setMenus: function (apis, comp, menus) {
+          apis.setMenus(comp, menus);
+        }
+      }
+    });
+
+    var getAnimationRoot = function (component, slideConfig) {
+      return slideConfig.getAnimationRoot.fold(function () {
+        return component.element;
+      }, function (get) {
+        return get(component);
+      });
+    };
+
+    var getDimensionProperty = function (slideConfig) {
+      return slideConfig.dimension.property;
+    };
+    var getDimension = function (slideConfig, elem) {
+      return slideConfig.dimension.getDimension(elem);
+    };
+    var disableTransitions = function (component, slideConfig) {
+      var root = getAnimationRoot(component, slideConfig);
+      remove$1(root, [
+        slideConfig.shrinkingClass,
+        slideConfig.growingClass
+      ]);
+    };
+    var setShrunk = function (component, slideConfig) {
+      remove$2(component.element, slideConfig.openClass);
+      add$2(component.element, slideConfig.closedClass);
+      set$7(component.element, getDimensionProperty(slideConfig), '0px');
+      reflow(component.element);
+    };
+    var setGrown = function (component, slideConfig) {
+      remove$2(component.element, slideConfig.closedClass);
+      add$2(component.element, slideConfig.openClass);
+      remove$6(component.element, getDimensionProperty(slideConfig));
+    };
+    var doImmediateShrink = function (component, slideConfig, slideState, _calculatedSize) {
+      slideState.setCollapsed();
+      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$7(component.element, getDimensionProperty(slideConfig), size);
+      reflow(component.element);
+      var root = getAnimationRoot(component, slideConfig);
+      remove$2(root, slideConfig.growingClass);
+      add$2(root, slideConfig.shrinkingClass);
+      setShrunk(component, slideConfig);
+      slideConfig.onStartShrink(component);
+    };
+    var doStartSmartShrink = function (component, slideConfig, slideState) {
+      var size = getDimension(slideConfig, component.element);
+      var shrinker = size === '0px' ? doImmediateShrink : doStartShrink;
+      shrinker(component, slideConfig, slideState, Optional.some(size));
+    };
+    var doStartGrow = function (component, slideConfig, slideState) {
+      var root = getAnimationRoot(component, slideConfig);
+      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$7(component.element, getDimensionProperty(slideConfig), beforeSize);
+        reflow(component.element);
+      };
+      var startCompleteGrow = function () {
+        setShrunk(component, slideConfig);
+      };
+      var setStartSize = wasShrinking ? startPartialGrow : startCompleteGrow;
+      setStartSize();
+      remove$2(root, slideConfig.shrinkingClass);
+      add$2(root, slideConfig.growingClass);
+      setGrown(component, slideConfig);
+      set$7(component.element, getDimensionProperty(slideConfig), fullSize);
+      slideState.setExpanded();
+      slideConfig.onStartGrow(component);
+    };
+    var refresh$3 = function (component, slideConfig, slideState) {
+      if (slideState.isExpanded()) {
+        remove$6(component.element, getDimensionProperty(slideConfig));
+        var fullSize = getDimension(slideConfig, component.element);
+        set$7(component.element, getDimensionProperty(slideConfig), fullSize);
+      }
+    };
+    var grow = function (component, slideConfig, slideState) {
+      if (!slideState.isExpanded()) {
+        doStartGrow(component, slideConfig, slideState);
+      }
+    };
+    var shrink = function (component, slideConfig, slideState) {
+      if (slideState.isExpanded()) {
+        doStartSmartShrink(component, slideConfig, slideState);
+      }
+    };
+    var immediateShrink = function (component, slideConfig, slideState) {
+      if (slideState.isExpanded()) {
+        doImmediateShrink(component, slideConfig, slideState);
+      }
+    };
+    var hasGrown = function (component, slideConfig, slideState) {
+      return slideState.isExpanded();
+    };
+    var hasShrunk = function (component, slideConfig, slideState) {
+      return slideState.isCollapsed();
+    };
+    var isGrowing = function (component, slideConfig, _slideState) {
+      var root = getAnimationRoot(component, slideConfig);
+      return has(root, slideConfig.growingClass) === true;
+    };
+    var isShrinking = function (component, slideConfig, _slideState) {
+      var root = getAnimationRoot(component, slideConfig);
+      return has(root, slideConfig.shrinkingClass) === true;
+    };
+    var isTransitioning = function (component, slideConfig, slideState) {
+      return isGrowing(component, slideConfig) || isShrinking(component, slideConfig);
+    };
+    var toggleGrow = function (component, slideConfig, slideState) {
+      var f = slideState.isExpanded() ? doStartSmartShrink : doStartGrow;
+      f(component, slideConfig, slideState);
+    };
+
+    var SlidingApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        refresh: refresh$3,
+        grow: grow,
+        shrink: shrink,
+        immediateShrink: immediateShrink,
+        hasGrown: hasGrown,
+        hasShrunk: hasShrunk,
+        isGrowing: isGrowing,
+        isShrinking: isShrinking,
+        isTransitioning: isTransitioning,
+        toggleGrow: toggleGrow,
+        disableTransitions: disableTransitions
+    });
+
+    var exhibit = function (base, slideConfig, _slideState) {
+      var expanded = slideConfig.expanded;
+      return expanded ? nu$7({
+        classes: [slideConfig.openClass],
+        styles: {}
+      }) : nu$7({
+        classes: [slideConfig.closedClass],
+        styles: wrap$1(slideConfig.dimension.property, '0px')
+      });
+    };
+    var events$4 = function (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$6(component.element, slideConfig.dimension.property);
+            }
+            var notify = slideState.isExpanded() ? slideConfig.onGrown : slideConfig.onShrunk;
+            notify(component);
+          }
+        })]);
+    };
+
+    var ActiveSliding = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exhibit: exhibit,
+        events: events$4
+    });
+
+    var SlidingSchema = [
+      required$1('closedClass'),
+      required$1('openClass'),
+      required$1('shrinkingClass'),
+      required$1('growingClass'),
+      option('getAnimationRoot'),
+      onHandler('onShrunk'),
+      onHandler('onStartShrink'),
+      onHandler('onGrown'),
+      onHandler('onStartGrow'),
+      defaulted('expanded', false),
+      requiredOf('dimension', choose$1('property', {
+        width: [
+          output$1('property', 'width'),
+          output$1('getDimension', function (elem) {
+            return get$a(elem) + 'px';
+          })
+        ],
+        height: [
+          output$1('property', 'height'),
+          output$1('getDimension', function (elem) {
+            return get$b(elem) + 'px';
+          })
+        ]
+      }))
+    ];
+
+    var init$5 = function (spec) {
+      var state = Cell(spec.expanded);
+      var readState = function () {
+        return 'expanded: ' + state.get();
+      };
+      return nu$8({
+        isExpanded: function () {
+          return state.get() === true;
+        },
+        isCollapsed: function () {
+          return state.get() === false;
+        },
+        setCollapsed: curry(state.set, false),
+        setExpanded: curry(state.set, true),
+        readState: readState
+      });
+    };
+
+    var SlidingState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init$5
+    });
+
+    var Sliding = create$8({
+      fields: SlidingSchema,
+      name: 'sliding',
+      active: ActiveSliding,
+      apis: SlidingApis,
+      state: SlidingState
+    });
+
+    var owner = 'container';
+    var schema$d = [field('slotBehaviours', [])];
+    var getPartName = function (name) {
+      return '<alloy.field.' + name + '>';
+    };
+    var sketch = function (sSpec) {
+      var parts = function () {
+        var record = [];
+        var slot = function (name, config) {
+          record.push(name);
+          return generateOne$1(owner, getPartName(name), config);
+        };
+        return {
+          slot: slot,
+          record: constant$1(record)
+        };
+      }();
+      var spec = sSpec(parts);
+      var partNames = parts.record();
+      var fieldParts = map$2(partNames, function (n) {
+        return required({
+          name: n,
+          pname: getPartName(n)
+        });
+      });
+      return composite$1(owner, schema$d, fieldParts, make$1, spec);
+    };
+    var make$1 = function (detail, components) {
+      var getSlotNames = function (_) {
+        return getAllPartNames(detail);
+      };
+      var getSlot = function (container, key) {
+        return getPart(container, detail, key);
+      };
+      var onSlot = function (f, def) {
+        return function (container, key) {
+          return getPart(container, detail, key).map(function (slot) {
+            return f(slot, key);
+          }).getOr(def);
+        };
+      };
+      var onSlots = function (f) {
+        return function (container, keys) {
+          each$1(keys, function (key) {
+            return f(container, key);
+          });
+        };
+      };
+      var doShowing = function (comp, _key) {
+        return get$d(comp.element, 'aria-hidden') !== 'true';
+      };
+      var doShow = function (comp, key) {
+        if (!doShowing(comp)) {
+          var element = comp.element;
+          remove$6(element, 'display');
+          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$7(element, 'display', 'none');
+          set$8(element, 'aria-hidden', 'true');
+          emitWith(comp, slotVisibility(), {
+            name: key,
+            visible: false
+          });
+        }
+      };
+      var isShowing = onSlot(doShowing, false);
+      var hideSlot = onSlot(doHide);
+      var hideSlots = onSlots(hideSlot);
+      var hideAllSlots = function (container) {
+        return hideSlots(container, getSlotNames());
+      };
+      var showSlot = onSlot(doShow);
+      var apis = {
+        getSlotNames: getSlotNames,
+        getSlot: getSlot,
+        isShowing: isShowing,
+        hideSlot: hideSlot,
+        hideAllSlots: hideAllSlots,
+        showSlot: showSlot
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: get$2(detail.slotBehaviours),
+        apis: apis
+      };
+    };
+    var slotApis = map$1({
+      getSlotNames: function (apis, c) {
+        return apis.getSlotNames(c);
+      },
+      getSlot: function (apis, c, key) {
+        return apis.getSlot(c, key);
+      },
+      isShowing: function (apis, c, key) {
+        return apis.isShowing(c, key);
+      },
+      hideSlot: function (apis, c, key) {
+        return apis.hideSlot(c, key);
+      },
+      hideAllSlots: function (apis, c) {
+        return apis.hideAllSlots(c);
+      },
+      showSlot: function (apis, c, key) {
+        return apis.showSlot(c, key);
+      }
+    }, function (value) {
+      return makeApi(value);
+    });
+    var SlotContainer = __assign(__assign({}, slotApis), { sketch: sketch });
+
+    var sidebarSchema = objOf([
+      optionString('icon'),
+      optionString('tooltip'),
+      defaultedFunction('onShow', noop),
+      defaultedFunction('onHide', noop),
+      defaultedFunction('onSetup', function () {
+        return noop;
+      })
+    ]);
+    var createSidebar = function (spec) {
+      return asRaw('sidebar', sidebarSchema, spec);
+    };
+
+    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$1(Optional.from(editor.queryCommandValue('ToggleSidebar')), name);
+        };
+        editor.ui.registry.addToggleButton(name, {
+          icon: spec.icon,
+          tooltip: spec.tooltip,
+          onAction: function (buttonApi) {
+            editor.execCommand('ToggleSidebar', false, name);
+            buttonApi.setActive(isActive());
+          },
+          onSetup: function (buttonApi) {
+            var handleToggle = function () {
+              return buttonApi.setActive(isActive());
+            };
+            editor.on('ToggleSidebar', handleToggle);
+            return function () {
+              editor.off('ToggleSidebar', handleToggle);
+            };
+          }
+        });
+      });
+    };
+    var getApi = function (comp) {
+      return {
+        element: function () {
+          return comp.element.dom;
+        }
+      };
+    };
+    var makePanels = function (parts, panelConfigs) {
+      var specs = map$2(keys(panelConfigs), function (name) {
+        var spec = panelConfigs[name];
+        var bridged = getOrDie(createSidebar(spec));
+        return {
+          name: name,
+          getApi: getApi,
+          onSetup: bridged.onSetup,
+          onShow: bridged.onShow,
+          onHide: bridged.onHide
+        };
+      });
+      return map$2(specs, function (spec) {
+        var editorOffCell = Cell(noop);
+        return parts.slot(spec.name, {
+          dom: {
+            tag: 'div',
+            classes: ['tox-sidebar__pane']
+          },
+          behaviours: SimpleBehaviours.unnamedEvents([
+            onControlAttached(spec, editorOffCell),
+            onControlDetached(spec, editorOffCell),
+            run$1(slotVisibility(), function (sidepanel, se) {
+              var data = se.event;
+              var optSidePanelSpec = find$5(specs, function (config) {
+                return config.name === data.name;
+              });
+              optSidePanelSpec.each(function (sidePanelSpec) {
+                var handler = data.visible ? sidePanelSpec.onShow : sidePanelSpec.onHide;
+                handler(sidePanelSpec.getApi(sidepanel));
+              });
+            })
+          ])
+        });
+      });
+    };
+    var makeSidebar = function (panelConfigs) {
+      return SlotContainer.sketch(function (parts) {
+        return {
+          dom: {
+            tag: 'div',
+            classes: ['tox-sidebar__pane-container']
+          },
+          components: makePanels(parts, panelConfigs),
+          slotBehaviours: SimpleBehaviours.unnamedEvents([runOnAttached(function (slotContainer) {
+              return SlotContainer.hideAllSlots(slotContainer);
+            })])
+        };
+      });
+    };
+    var setSidebar = function (sidebar, panelConfigs) {
+      var optSlider = Composing.getCurrent(sidebar);
+      optSlider.each(function (slider) {
+        return Replacing.set(slider, [makeSidebar(panelConfigs)]);
+      });
+    };
+    var toggleSidebar = function (sidebar, name) {
+      var optSlider = Composing.getCurrent(sidebar);
+      optSlider.each(function (slider) {
+        var optSlotContainer = Composing.getCurrent(slider);
+        optSlotContainer.each(function (slotContainer) {
+          if (Sliding.hasGrown(slider)) {
+            if (SlotContainer.isShowing(slotContainer, name)) {
+              Sliding.shrink(slider);
+            } else {
+              SlotContainer.hideAllSlots(slotContainer);
+              SlotContainer.showSlot(slotContainer, name);
+            }
+          } else {
+            SlotContainer.hideAllSlots(slotContainer);
+            SlotContainer.showSlot(slotContainer, name);
+            Sliding.grow(slider);
+          }
+        });
+      });
+    };
+    var whichSidebar = function (sidebar) {
+      var optSlider = Composing.getCurrent(sidebar);
+      return optSlider.bind(function (slider) {
+        var sidebarOpen = Sliding.isGrowing(slider) || Sliding.hasGrown(slider);
+        if (sidebarOpen) {
+          var optSlotContainer = Composing.getCurrent(slider);
+          return optSlotContainer.bind(function (slotContainer) {
+            return find$5(SlotContainer.getSlotNames(slotContainer), function (name) {
+              return SlotContainer.isShowing(slotContainer, name);
+            });
+          });
+        } else {
+          return Optional.none();
+        }
+      });
+    };
+    var fixSize = generate$6('FixSizeEvent');
+    var autoSize = generate$6('AutoSizeEvent');
+    var renderSidebar = function (spec) {
+      return {
+        uid: spec.uid,
+        dom: {
+          tag: 'div',
+          classes: ['tox-sidebar'],
+          attributes: { role: 'complementary' }
+        },
+        components: [{
+            dom: {
+              tag: 'div',
+              classes: ['tox-sidebar__slider']
+            },
+            components: [],
+            behaviours: derive$1([
+              Tabstopping.config({}),
+              Focusing.config({}),
+              Sliding.config({
+                dimension: { property: 'width' },
+                closedClass: 'tox-sidebar--sliding-closed',
+                openClass: 'tox-sidebar--sliding-open',
+                shrinkingClass: 'tox-sidebar--sliding-shrinking',
+                growingClass: 'tox-sidebar--sliding-growing',
+                onShrunk: function (slider) {
+                  var optSlotContainer = Composing.getCurrent(slider);
+                  optSlotContainer.each(SlotContainer.hideAllSlots);
+                  emit(slider, autoSize);
+                },
+                onGrown: function (slider) {
+                  emit(slider, autoSize);
+                },
+                onStartGrow: function (slider) {
+                  emitWith(slider, fixSize, { width: getRaw(slider.element, 'width').getOr('') });
+                },
+                onStartShrink: function (slider) {
+                  emitWith(slider, fixSize, { width: get$a(slider.element) + 'px' });
+                }
+              }),
+              Replacing.config({}),
+              Composing.config({
+                find: function (comp) {
+                  var children = Replacing.contents(comp);
+                  return head(children);
+                }
+              })
+            ])
+          }],
+        behaviours: derive$1([
+          ComposingConfigs.childAt(0),
+          config('sidebar-sliding-events', [
+            run$1(fixSize, function (comp, se) {
+              set$7(comp.element, 'width', se.event.width);
+            }),
+            run$1(autoSize, function (comp, _se) {
+              remove$6(comp.element, 'width');
+            })
+          ])
+        ])
+      };
+    };
+
+    var block = function (component, config, state, getBusySpec) {
+      set$8(component.element, 'aria-busy', true);
+      var root = config.getRoot(component).getOr(component);
+      var blockerBehaviours = derive$1([
+        Keying.config({
+          mode: 'special',
+          onTab: function () {
+            return Optional.some(true);
+          },
+          onShiftTab: function () {
+            return Optional.some(true);
+          }
+        }),
+        Focusing.config({})
+      ]);
+      var blockSpec = getBusySpec(root, blockerBehaviours);
+      var blocker = root.getSystem().build(blockSpec);
+      Replacing.append(root, premade(blocker));
+      if (blocker.hasConfigured(Keying) && config.focus) {
+        Keying.focusIn(blocker);
+      }
+      if (!state.isBlocked()) {
+        config.onBlock(component);
+      }
+      state.blockWith(function () {
+        return Replacing.remove(root, blocker);
+      });
+    };
+    var unblock = function (component, config, state) {
+      remove$7(component.element, 'aria-busy');
+      if (state.isBlocked()) {
+        config.onUnblock(component);
+      }
+      state.clear();
+    };
+
+    var BlockingApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        block: block,
+        unblock: unblock
+    });
+
+    var BlockingSchema = [
+      defaultedFunction('getRoot', Optional.none),
+      defaultedBoolean('focus', true),
+      onHandler('onBlock'),
+      onHandler('onUnblock')
+    ];
+
+    var init$4 = function () {
+      var blocker = destroyable();
+      var blockWith = function (destroy) {
+        blocker.set({ destroy: destroy });
+      };
+      return nu$8({
+        readState: blocker.isSet,
+        blockWith: blockWith,
+        clear: blocker.clear,
+        isBlocked: blocker.isSet
+      });
+    };
+
+    var BlockingState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init$4
+    });
+
+    var Blocking = create$8({
+      fields: BlockingSchema,
+      name: 'blocking',
+      apis: BlockingApis,
+      state: BlockingState
+    });
+
+    var getAttrs = function (elem) {
+      var attributes = elem.dom.attributes !== undefined ? elem.dom.attributes : [];
+      return foldl(attributes, function (b, attr) {
+        var _a;
+        if (attr.name === 'class') {
+          return b;
+        } else {
+          return __assign(__assign({}, b), (_a = {}, _a[attr.name] = attr.value, _a));
+        }
+      }, {});
+    };
+    var getClasses = function (elem) {
+      return Array.prototype.slice.call(elem.dom.classList, 0);
+    };
+    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$7(elem) };
+      return __assign({
+        tag: name$2(elem),
+        classes: classes,
+        attributes: attrs
+      }, contents);
+    };
+
+    var getBusySpec$1 = function (providerBackstage) {
+      return function (_root, _behaviours) {
+        return {
+          dom: {
+            tag: 'div',
+            attributes: {
+              'aria-label': providerBackstage.translate('Loading...'),
+              'tabindex': '0'
+            },
+            classes: ['tox-throbber__busy-spinner']
+          },
+          components: [{ dom: fromHtml('<div class="tox-spinner"><div></div><div></div><div></div></div>') }]
+        };
+      };
+    };
+    var focusBusyComponent = function (throbber) {
+      return Composing.getCurrent(throbber).each(function (comp) {
+        return focus$3(comp.element);
+      });
+    };
+    var toggleEditorTabIndex = function (editor, state) {
+      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$8(iframe, dataTabIndexAttr, tabIndex);
+          });
+          set$8(iframe, tabIndexAttr, -1);
+        } else {
+          remove$7(iframe, tabIndexAttr);
+          getOpt(iframe, dataTabIndexAttr).each(function (tabIndex) {
+            set$8(iframe, tabIndexAttr, tabIndex);
+            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$6(element, 'display');
+        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$7(element, 'display', 'none');
+        set$8(element, 'aria-hidden', 'true');
+        if (throbberFocus) {
+          editor.focus();
+        }
+      }
+    };
+    var renderThrobber = function (spec) {
+      return {
+        uid: spec.uid,
+        dom: {
+          tag: 'div',
+          attributes: { 'aria-hidden': 'true' },
+          classes: ['tox-throbber'],
+          styles: { display: 'none' }
+        },
+        behaviours: derive$1([
+          Replacing.config({}),
+          Blocking.config({ focus: false }),
+          Composing.config({
+            find: function (comp) {
+              return head(comp.components());
+            }
+          })
+        ]),
+        components: []
+      };
+    };
+    var isFocusEvent = function (event) {
+      return event.type === 'focusin';
+    };
+    var isPasteBinTarget = function (event) {
+      if (isFocusEvent(event)) {
+        var node = event.composed ? head(event.composedPath()) : Optional.from(event.target);
+        return node.map(SugarElement.fromDom).filter(isElement$2).exists(function (targetElm) {
+          return has(targetElm, 'mce-pastebin');
+        });
+      } else {
+        return false;
+      }
+    };
+    var setup$7 = function (editor, lazyThrobber, sharedBackstage) {
+      var throbberState = Cell(false);
+      var timer = value$1();
+      var stealFocus = function (e) {
+        if (throbberState.get() && !isPasteBinTarget(e)) {
+          e.preventDefault();
+          focusBusyComponent(lazyThrobber());
+          editor.editorManager.setActive(editor);
+        }
+      };
+      if (!editor.inline) {
+        editor.on('PreInit', function () {
+          editor.dom.bind(editor.getWin(), 'focusin', stealFocus);
+          editor.on('BeforeExecCommand', function (e) {
+            if (e.command.toLowerCase() === 'mcefocus' && e.value !== true) {
+              stealFocus(e);
+            }
+          });
+        });
+      }
+      var toggle = function (state) {
+        if (state !== throbberState.get()) {
+          throbberState.set(state);
+          toggleThrobber(editor, lazyThrobber(), state, sharedBackstage.providers);
+          editor.fire('AfterProgressState', { state: state });
+        }
+      };
+      editor.on('ProgressState', function (e) {
+        timer.on(global$f.clearTimeout);
+        if (isNumber(e.time)) {
+          var timerId = global$f.setEditorTimeout(editor, function () {
+            return toggle(e.state);
+          }, e.time);
+          timer.set(timerId);
+        } else {
+          toggle(e.state);
+          timer.clear();
+        }
+      });
+    };
+
+    var generate$1 = function (xs, f) {
+      var init = {
+        len: 0,
+        list: []
+      };
+      var r = foldl(xs, function (b, a) {
+        var value = f(a, b.len);
+        return value.fold(constant$1(b), function (v) {
+          return {
+            len: v.finish,
+            list: b.list.concat([v])
+          };
+        });
+      }, init);
+      return r.list;
+    };
+
+    var output = function (within, extra, withinWidth) {
+      return {
+        within: within,
+        extra: extra,
+        withinWidth: withinWidth
+      };
+    };
+    var apportion = function (units, total, len) {
+      var parray = generate$1(units, function (unit, current) {
+        var width = len(unit);
+        return Optional.some({
+          element: unit,
+          start: current,
+          finish: current + width,
+          width: width
+        });
+      });
+      var within = filter$2(parray, function (unit) {
+        return unit.finish <= total;
+      });
+      var withinWidth = foldr(within, function (acc, el) {
+        return acc + el.width;
+      }, 0);
+      var extra = parray.slice(within.length);
+      return {
+        within: within,
+        extra: extra,
+        withinWidth: withinWidth
+      };
+    };
+    var toUnit = function (parray) {
+      return map$2(parray, function (unit) {
+        return unit.element;
+      });
+    };
+    var fitLast = function (within, extra, withinWidth) {
+      var fits = toUnit(within.concat(extra));
+      return output(fits, [], withinWidth);
+    };
+    var overflow = function (within, extra, overflower, withinWidth) {
+      var fits = toUnit(within).concat([overflower]);
+      return output(fits, toUnit(extra), withinWidth);
+    };
+    var fitAll = function (within, extra, withinWidth) {
+      return output(toUnit(within), [], withinWidth);
+    };
+    var tryFit = function (total, units, len) {
+      var divide = apportion(units, total, len);
+      return divide.extra.length === 0 ? Optional.some(divide) : Optional.none();
+    };
+    var partition = function (total, units, len, overflower) {
+      var divide = tryFit(total, units, len).getOrThunk(function () {
+        return apportion(units, total - len(overflower), len);
+      });
+      var within = divide.within;
+      var extra = divide.extra;
+      var withinWidth = divide.withinWidth;
+      if (extra.length === 1 && extra[0].width <= len(overflower)) {
+        return fitLast(within, extra, withinWidth);
+      } else if (extra.length >= 1) {
+        return overflow(within, extra, overflower, withinWidth);
+      } else {
+        return fitAll(within, extra, withinWidth);
+      }
+    };
+
+    var setGroups$1 = function (toolbar, storedGroups) {
+      var bGroups = map$2(storedGroups, function (g) {
+        return premade(g);
+      });
+      Toolbar.setGroups(toolbar, bGroups);
+    };
+    var findFocusedComp = function (comps) {
+      return findMap(comps, function (comp) {
+        return search(comp.element).bind(function (focusedElm) {
+          return comp.getSystem().getByDom(focusedElm).toOptional();
+        });
+      });
+    };
+    var refresh$2 = function (toolbar, detail, setOverflow) {
+      var builtGroups = detail.builtGroups.get();
+      if (builtGroups.length === 0) {
+        return;
+      }
+      var primary = getPartOrDie(toolbar, detail, 'primary');
+      var overflowGroup = Coupling.getCoupled(toolbar, 'overflowGroup');
+      set$7(primary.element, 'visibility', 'hidden');
+      var groups = builtGroups.concat([overflowGroup]);
+      var focusedComp = findFocusedComp(groups);
+      setOverflow([]);
+      setGroups$1(primary, groups);
+      var availableWidth = get$a(primary.element);
+      var overflows = partition(availableWidth, detail.builtGroups.get(), function (comp) {
+        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$6(primary.element, 'visibility');
+      reflow(primary.element);
+      focusedComp.each(Focusing.focus);
+    };
+
+    var schema$c = constant$1([
+      field('splitToolbarBehaviours', [Coupling]),
+      customField('builtGroups', function () {
+        return Cell([]);
+      })
+    ]);
+
+    var schema$b = constant$1([
+      markers$1(['overflowToggledClass']),
+      optionFunction('getOverflowBounds'),
+      required$1('lazySink'),
+      customField('overflowGroups', function () {
+        return Cell([]);
+      })
+    ].concat(schema$c()));
+    var parts$7 = constant$1([
+      required({
+        factory: Toolbar,
+        schema: schema$e(),
+        name: 'primary'
+      }),
+      external$1({
+        schema: schema$e(),
+        name: 'overflow'
+      }),
+      external$1({ name: 'overflow-button' }),
+      external$1({ name: 'overflow-group' })
+    ]);
+
+    var expandable = constant$1(function (element, available) {
+      setMax(element, Math.floor(available));
+    });
+
+    var schema$a = constant$1([
+      markers$1(['toggledClass']),
+      required$1('lazySink'),
+      requiredFunction('fetch'),
+      optionFunction('getBounds'),
+      optionObjOf('fireDismissalEventInstead', [defaulted('event', dismissRequested())]),
+      schema$y()
+    ]);
+    var parts$6 = constant$1([
+      external$1({
+        name: 'button',
+        overrides: function (detail) {
+          return {
+            dom: { attributes: { 'aria-haspopup': 'true' } },
+            buttonBehaviours: derive$1([Toggling.config({
+                toggleClass: detail.markers.toggledClass,
+                aria: { mode: 'expanded' },
+                toggleOnExecute: false
+              })])
+          };
+        }
+      }),
+      external$1({
+        factory: Toolbar,
+        schema: schema$e(),
+        name: 'toolbar',
+        overrides: function (detail) {
+          return {
+            toolbarBehaviours: derive$1([Keying.config({
+                mode: 'cyclic',
+                onEscape: function (comp) {
+                  getPart(comp, detail, 'button').each(Focusing.focus);
+                  return Optional.none();
+                }
+              })])
+          };
+        }
+      })
+    ]);
+
+    var toggle = function (button, externals) {
+      var toolbarSandbox = Coupling.getCoupled(button, 'toolbarSandbox');
+      if (Sandboxing.isOpen(toolbarSandbox)) {
+        Sandboxing.close(toolbarSandbox);
+      } else {
+        Sandboxing.open(toolbarSandbox, externals.toolbar());
+      }
+    };
+    var position = function (button, toolbar, detail, layouts) {
+      var bounds = detail.getBounds.map(function (bounder) {
+        return bounder();
+      });
+      var sink = detail.lazySink(button).getOrDie();
+      Positioning.positionWithinBounds(sink, toolbar, {
+        anchor: {
+          type: 'hotspot',
+          hotspot: button,
+          layouts: layouts,
+          overrides: { maxWidthFunction: expandable() }
+        }
+      }, bounds);
+    };
+    var setGroups = function (button, toolbar, detail, layouts, groups) {
+      Toolbar.setGroups(toolbar, groups);
+      position(button, toolbar, detail, layouts);
+      Toggling.on(button);
+    };
+    var makeSandbox = function (button, spec, detail) {
+      var ariaOwner = manager();
+      var onOpen = function (sandbox, toolbar) {
+        detail.fetch().get(function (groups) {
+          setGroups(button, toolbar, detail, spec.layouts, groups);
+          ariaOwner.link(button.element);
+          Keying.focusIn(toolbar);
+        });
+      };
+      var onClose = function () {
+        Toggling.off(button);
+        Focusing.focus(button);
+        ariaOwner.unlink(button.element);
+      };
+      return {
+        dom: {
+          tag: 'div',
+          attributes: { id: ariaOwner.id }
+        },
+        behaviours: derive$1([
+          Keying.config({
+            mode: 'special',
+            onEscape: function (comp) {
+              Sandboxing.close(comp);
+              return Optional.some(true);
+            }
+          }),
+          Sandboxing.config({
+            onOpen: onOpen,
+            onClose: onClose,
+            isPartOf: function (container, data, queryElem) {
+              return isPartOf$1(data, queryElem) || isPartOf$1(button, queryElem);
+            },
+            getAttachPoint: function () {
+              return detail.lazySink(button).getOrDie();
+            }
+          }),
+          Receiving.config({
+            channels: __assign(__assign({}, receivingChannel$1(__assign({ isExtraPart: never }, detail.fireDismissalEventInstead.map(function (fe) {
+              return { fireEventInstead: { event: fe.event } };
+            }).getOr({})))), receivingChannel({
+              doReposition: function () {
+                Sandboxing.getState(Coupling.getCoupled(button, 'toolbarSandbox')).each(function (toolbar) {
+                  position(button, toolbar, detail, spec.layouts);
+                });
+              }
+            }))
+          })
+        ])
+      };
+    };
+    var factory$a = function (detail, components, spec, externals) {
+      return __assign(__assign({}, Button.sketch(__assign(__assign({}, externals.button()), {
+        action: function (button) {
+          toggle(button, externals);
+        },
+        buttonBehaviours: SketchBehaviours.augment({ dump: externals.button().buttonBehaviours }, [Coupling.config({
+            others: {
+              toolbarSandbox: function (button) {
+                return makeSandbox(button, spec, detail);
+              }
+            }
+          })])
+      }))), {
+        apis: {
+          setGroups: function (button, groups) {
+            Sandboxing.getState(Coupling.getCoupled(button, 'toolbarSandbox')).each(function (toolbar) {
+              setGroups(button, toolbar, detail, spec.layouts, groups);
+            });
+          },
+          reposition: function (button) {
+            Sandboxing.getState(Coupling.getCoupled(button, 'toolbarSandbox')).each(function (toolbar) {
+              position(button, toolbar, detail, spec.layouts);
+            });
+          },
+          toggle: function (button) {
+            toggle(button, externals);
+          },
+          getToolbar: function (button) {
+            return Sandboxing.getState(Coupling.getCoupled(button, 'toolbarSandbox'));
+          },
+          isOpen: function (button) {
+            return Sandboxing.isOpen(Coupling.getCoupled(button, 'toolbarSandbox'));
+          }
+        }
+      });
+    };
+    var FloatingToolbarButton = composite({
+      name: 'FloatingToolbarButton',
+      factory: factory$a,
+      configFields: schema$a(),
+      partFields: parts$6(),
+      apis: {
+        setGroups: function (apis, button, groups) {
+          apis.setGroups(button, groups);
+        },
+        reposition: function (apis, button) {
+          apis.reposition(button);
+        },
+        toggle: function (apis, button) {
+          apis.toggle(button);
+        },
+        getToolbar: function (apis, button) {
+          return apis.getToolbar(button);
+        },
+        isOpen: function (apis, button) {
+          return apis.isOpen(button);
+        }
+      }
+    });
+
+    var schema$9 = constant$1([
+      required$1('items'),
+      markers$1(['itemSelector']),
+      field('tgroupBehaviours', [Keying])
+    ]);
+    var parts$5 = constant$1([group({
+        name: 'items',
+        unit: 'item'
+      })]);
+
+    var factory$9 = function (detail, components, _spec, _externals) {
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: augment(detail.tgroupBehaviours, [Keying.config({
+            mode: 'flow',
+            selector: detail.markers.itemSelector
+          })]),
+        domModification: { attributes: { role: 'toolbar' } }
+      };
+    };
+    var ToolbarGroup = composite({
+      name: 'ToolbarGroup',
+      configFields: schema$9(),
+      partFields: parts$5(),
+      factory: factory$9
+    });
+
+    var buildGroups = function (comps) {
+      return map$2(comps, function (g) {
+        return premade(g);
+      });
+    };
+    var refresh$1 = function (toolbar, memFloatingToolbarButton, detail) {
+      refresh$2(toolbar, detail, function (overflowGroups) {
+        detail.overflowGroups.set(overflowGroups);
+        memFloatingToolbarButton.getOpt(toolbar).each(function (floatingToolbarButton) {
+          FloatingToolbarButton.setGroups(floatingToolbarButton, buildGroups(overflowGroups));
+        });
+      });
+    };
+    var factory$8 = function (detail, components, spec, externals) {
+      var memFloatingToolbarButton = record(FloatingToolbarButton.sketch({
+        fetch: function () {
+          return Future.nu(function (resolve) {
+            resolve(buildGroups(detail.overflowGroups.get()));
+          });
+        },
+        layouts: {
+          onLtr: function () {
+            return [
+              southwest$2,
+              southeast$2
+            ];
+          },
+          onRtl: function () {
+            return [
+              southeast$2,
+              southwest$2
+            ];
+          },
+          onBottomLtr: function () {
+            return [
+              northwest$2,
+              northeast$2
+            ];
+          },
+          onBottomRtl: function () {
+            return [
+              northeast$2,
+              northwest$2
+            ];
+          }
+        },
+        getBounds: spec.getOverflowBounds,
+        lazySink: detail.lazySink,
+        fireDismissalEventInstead: {},
+        markers: { toggledClass: detail.markers.overflowToggledClass },
+        parts: {
+          button: externals['overflow-button'](),
+          toolbar: externals.overflow()
+        }
+      }));
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: augment(detail.splitToolbarBehaviours, [Coupling.config({
+            others: {
+              overflowGroup: function () {
+                return ToolbarGroup.sketch(__assign(__assign({}, externals['overflow-group']()), { items: [memFloatingToolbarButton.asSpec()] }));
+              }
+            }
+          })]),
+        apis: {
+          setGroups: function (toolbar, groups) {
+            detail.builtGroups.set(map$2(groups, toolbar.getSystem().build));
+            refresh$1(toolbar, memFloatingToolbarButton, detail);
+          },
+          refresh: function (toolbar) {
+            return refresh$1(toolbar, memFloatingToolbarButton, detail);
+          },
+          toggle: function (toolbar) {
+            memFloatingToolbarButton.getOpt(toolbar).each(function (floatingToolbarButton) {
+              FloatingToolbarButton.toggle(floatingToolbarButton);
+            });
+          },
+          isOpen: function (toolbar) {
+            return memFloatingToolbarButton.getOpt(toolbar).map(FloatingToolbarButton.isOpen).getOr(false);
+          },
+          reposition: function (toolbar) {
+            memFloatingToolbarButton.getOpt(toolbar).each(function (floatingToolbarButton) {
+              FloatingToolbarButton.reposition(floatingToolbarButton);
+            });
+          },
+          getOverflow: function (toolbar) {
+            return memFloatingToolbarButton.getOpt(toolbar).bind(FloatingToolbarButton.getToolbar);
+          }
+        },
+        domModification: { attributes: { role: 'group' } }
+      };
+    };
+    var SplitFloatingToolbar = composite({
+      name: 'SplitFloatingToolbar',
+      configFields: schema$b(),
+      partFields: parts$7(),
+      factory: factory$8,
+      apis: {
+        setGroups: function (apis, toolbar, groups) {
+          apis.setGroups(toolbar, groups);
+        },
+        refresh: function (apis, toolbar) {
+          apis.refresh(toolbar);
+        },
+        reposition: function (apis, toolbar) {
+          apis.reposition(toolbar);
+        },
+        toggle: function (apis, toolbar) {
+          apis.toggle(toolbar);
+        },
+        isOpen: function (apis, toolbar) {
+          return apis.isOpen(toolbar);
+        },
+        getOverflow: function (apis, toolbar) {
+          return apis.getOverflow(toolbar);
+        }
+      }
+    });
+
+    var schema$8 = constant$1([
+      markers$1([
+        'closedClass',
+        'openClass',
+        'shrinkingClass',
+        'growingClass',
+        'overflowToggledClass'
+      ]),
+      onHandler('onOpened'),
+      onHandler('onClosed')
+    ].concat(schema$c()));
+    var parts$4 = constant$1([
+      required({
+        factory: Toolbar,
+        schema: schema$e(),
+        name: 'primary'
+      }),
+      required({
+        factory: Toolbar,
+        schema: schema$e(),
+        name: 'overflow',
+        overrides: function (detail) {
+          return {
+            toolbarBehaviours: derive$1([
+              Sliding.config({
+                dimension: { property: 'height' },
+                closedClass: detail.markers.closedClass,
+                openClass: detail.markers.openClass,
+                shrinkingClass: detail.markers.shrinkingClass,
+                growingClass: detail.markers.growingClass,
+                onShrunk: function (comp) {
+                  getPart(comp, detail, 'overflow-button').each(function (button) {
+                    Toggling.off(button);
+                    Focusing.focus(button);
+                  });
+                  detail.onClosed(comp);
+                },
+                onGrown: function (comp) {
+                  Keying.focusIn(comp);
+                  detail.onOpened(comp);
+                },
+                onStartGrow: function (comp) {
+                  getPart(comp, detail, 'overflow-button').each(Toggling.on);
+                }
+              }),
+              Keying.config({
+                mode: 'acyclic',
+                onEscape: function (comp) {
+                  getPart(comp, detail, 'overflow-button').each(Focusing.focus);
+                  return Optional.some(true);
+                }
+              })
+            ])
+          };
+        }
+      }),
+      external$1({
+        name: 'overflow-button',
+        overrides: function (detail) {
+          return {
+            buttonBehaviours: derive$1([Toggling.config({
+                toggleClass: detail.markers.overflowToggledClass,
+                aria: { mode: 'pressed' },
+                toggleOnExecute: false
+              })])
+          };
+        }
+      }),
+      external$1({ name: 'overflow-group' })
+    ]);
+
+    var isOpen = function (toolbar, detail) {
+      return getPart(toolbar, detail, 'overflow').map(Sliding.hasGrown).getOr(false);
+    };
+    var toggleToolbar = function (toolbar, detail) {
+      getPart(toolbar, detail, 'overflow-button').bind(function () {
+        return getPart(toolbar, detail, 'overflow');
+      }).each(function (overf) {
+        refresh(toolbar, detail);
+        Sliding.toggleGrow(overf);
+      });
+    };
+    var refresh = function (toolbar, detail) {
+      getPart(toolbar, detail, 'overflow').each(function (overflow) {
+        refresh$2(toolbar, detail, function (groups) {
+          var builtGroups = map$2(groups, function (g) {
+            return premade(g);
+          });
+          Toolbar.setGroups(overflow, builtGroups);
+        });
+        getPart(toolbar, detail, 'overflow-button').each(function (button) {
+          if (Sliding.hasGrown(overflow)) {
+            Toggling.on(button);
+          }
+        });
+        Sliding.refresh(overflow);
+      });
+    };
+    var factory$7 = function (detail, components, spec, externals) {
+      var toolbarToggleEvent = 'alloy.toolbar.toggle';
+      var doSetGroups = function (toolbar, groups) {
+        var built = map$2(groups, toolbar.getSystem().build);
+        detail.builtGroups.set(built);
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: augment(detail.splitToolbarBehaviours, [
+          Coupling.config({
+            others: {
+              overflowGroup: function (toolbar) {
+                return ToolbarGroup.sketch(__assign(__assign({}, externals['overflow-group']()), {
+                  items: [Button.sketch(__assign(__assign({}, externals['overflow-button']()), {
+                      action: function (_button) {
+                        emit(toolbar, toolbarToggleEvent);
+                      }
+                    }))]
+                }));
+              }
+            }
+          }),
+          config('toolbar-toggle-events', [run$1(toolbarToggleEvent, function (toolbar) {
+              toggleToolbar(toolbar, detail);
+            })])
+        ]),
+        apis: {
+          setGroups: function (toolbar, groups) {
+            doSetGroups(toolbar, groups);
+            refresh(toolbar, detail);
+          },
+          refresh: function (toolbar) {
+            return refresh(toolbar, detail);
+          },
+          toggle: function (toolbar) {
+            return toggleToolbar(toolbar, detail);
+          },
+          isOpen: function (toolbar) {
+            return isOpen(toolbar, detail);
+          }
+        },
+        domModification: { attributes: { role: 'group' } }
+      };
+    };
+    var SplitSlidingToolbar = composite({
+      name: 'SplitSlidingToolbar',
+      configFields: schema$8(),
+      partFields: parts$4(),
+      factory: factory$7,
+      apis: {
+        setGroups: function (apis, toolbar, groups) {
+          apis.setGroups(toolbar, groups);
+        },
+        refresh: function (apis, toolbar) {
+          apis.refresh(toolbar);
+        },
+        toggle: function (apis, toolbar) {
+          apis.toggle(toolbar);
+        },
+        isOpen: function (apis, toolbar) {
+          return apis.isOpen(toolbar);
+        }
+      }
+    });
+
+    var renderToolbarGroupCommon = function (toolbarGroup) {
+      var attributes = toolbarGroup.title.fold(function () {
+        return {};
+      }, function (title) {
+        return { attributes: { title: title } };
+      });
+      return {
+        dom: __assign({
+          tag: 'div',
+          classes: ['tox-toolbar__group']
+        }, attributes),
+        components: [ToolbarGroup.parts.items({})],
+        items: toolbarGroup.items,
+        markers: { itemSelector: '*:not(.tox-split-button) > .tox-tbtn:not([disabled]), ' + '.tox-split-button:not([disabled]), ' + '.tox-toolbar-nav-js:not([disabled])' },
+        tgroupBehaviours: derive$1([
+          Tabstopping.config({}),
+          Focusing.config({})
+        ])
+      };
+    };
+    var renderToolbarGroup = function (toolbarGroup) {
+      return ToolbarGroup.sketch(renderToolbarGroupCommon(toolbarGroup));
+    };
+    var getToolbarbehaviours = function (toolbarSpec, modeName) {
+      var onAttached = runOnAttached(function (component) {
+        var groups = map$2(toolbarSpec.initGroups, renderToolbarGroup);
+        Toolbar.setGroups(component, groups);
+      });
+      return derive$1([
+        DisablingConfigs.toolbarButton(toolbarSpec.providers.isDisabled),
+        receivingConfig(),
+        Keying.config({
+          mode: modeName,
+          onEscape: toolbarSpec.onEscape,
+          selector: '.tox-toolbar__group'
+        }),
+        config('toolbar-events', [onAttached])
+      ]);
+    };
+    var renderMoreToolbarCommon = function (toolbarSpec) {
+      var modeName = toolbarSpec.cyclicKeying ? 'cyclic' : 'acyclic';
+      return {
+        uid: toolbarSpec.uid,
+        dom: {
+          tag: 'div',
+          classes: ['tox-toolbar-overlord']
+        },
+        parts: {
+          'overflow-group': renderToolbarGroupCommon({
+            title: Optional.none(),
+            items: []
+          }),
+          'overflow-button': renderIconButtonSpec({
+            name: 'more',
+            icon: Optional.some('more-drawer'),
+            disabled: false,
+            tooltip: Optional.some('More...'),
+            primary: false,
+            borderless: false
+          }, Optional.none(), toolbarSpec.providers)
+        },
+        splitToolbarBehaviours: getToolbarbehaviours(toolbarSpec, modeName)
+      };
+    };
+    var renderFloatingMoreToolbar = function (toolbarSpec) {
+      var baseSpec = renderMoreToolbarCommon(toolbarSpec);
+      var overflowXOffset = 4;
+      var primary = SplitFloatingToolbar.parts.primary({
+        dom: {
+          tag: 'div',
+          classes: ['tox-toolbar__primary']
+        }
+      });
+      return SplitFloatingToolbar.sketch(__assign(__assign({}, baseSpec), {
+        lazySink: toolbarSpec.getSink,
+        getOverflowBounds: function () {
+          var headerElem = toolbarSpec.moreDrawerData.lazyHeader().element;
+          var headerBounds = absolute$2(headerElem);
+          var docElem = documentElement(headerElem);
+          var docBounds = absolute$2(docElem);
+          var height = Math.max(docElem.dom.scrollHeight, docBounds.height);
+          return bounds(headerBounds.x + overflowXOffset, docBounds.y, headerBounds.width - overflowXOffset * 2, height);
+        },
+        parts: __assign(__assign({}, baseSpec.parts), {
+          overflow: {
+            dom: {
+              tag: 'div',
+              classes: ['tox-toolbar__overflow'],
+              attributes: toolbarSpec.attributes
+            }
+          }
+        }),
+        components: [primary],
+        markers: { overflowToggledClass: 'tox-tbtn--enabled' }
+      }));
+    };
+    var renderSlidingMoreToolbar = function (toolbarSpec) {
+      var primary = SplitSlidingToolbar.parts.primary({
+        dom: {
+          tag: 'div',
+          classes: ['tox-toolbar__primary']
+        }
+      });
+      var overflow = SplitSlidingToolbar.parts.overflow({
+        dom: {
+          tag: 'div',
+          classes: ['tox-toolbar__overflow']
+        }
+      });
+      var baseSpec = renderMoreToolbarCommon(toolbarSpec);
+      return SplitSlidingToolbar.sketch(__assign(__assign({}, baseSpec), {
+        components: [
+          primary,
+          overflow
+        ],
+        markers: {
+          openClass: 'tox-toolbar__overflow--open',
+          closedClass: 'tox-toolbar__overflow--closed',
+          growingClass: 'tox-toolbar__overflow--growing',
+          shrinkingClass: 'tox-toolbar__overflow--shrinking',
+          overflowToggledClass: 'tox-tbtn--enabled'
+        },
+        onOpened: function (comp) {
+          comp.getSystem().broadcastOn([toolbarHeightChange()], { type: 'opened' });
+        },
+        onClosed: function (comp) {
+          comp.getSystem().broadcastOn([toolbarHeightChange()], { type: 'closed' });
+        }
+      }));
+    };
+    var renderToolbar = function (toolbarSpec) {
+      var modeName = toolbarSpec.cyclicKeying ? 'cyclic' : 'acyclic';
+      return Toolbar.sketch({
+        uid: toolbarSpec.uid,
+        dom: {
+          tag: 'div',
+          classes: ['tox-toolbar'].concat(toolbarSpec.type === ToolbarMode.scrolling ? ['tox-toolbar--scrolling'] : [])
+        },
+        components: [Toolbar.parts.groups({})],
+        toolbarBehaviours: getToolbarbehaviours(toolbarSpec, modeName)
+      });
+    };
+
+    var factory$6 = function (detail, components, _spec) {
+      var apis = {
+        getSocket: function (comp) {
+          return parts$a.getPart(comp, detail, 'socket');
+        },
+        setSidebar: function (comp, panelConfigs) {
+          parts$a.getPart(comp, detail, 'sidebar').each(function (sidebar) {
+            return setSidebar(sidebar, panelConfigs);
+          });
+        },
+        toggleSidebar: function (comp, name) {
+          parts$a.getPart(comp, detail, 'sidebar').each(function (sidebar) {
+            return toggleSidebar(sidebar, name);
+          });
+        },
+        whichSidebar: function (comp) {
+          return parts$a.getPart(comp, detail, 'sidebar').bind(whichSidebar).getOrNull();
+        },
+        getHeader: function (comp) {
+          return parts$a.getPart(comp, detail, 'header');
+        },
+        getToolbar: function (comp) {
+          return parts$a.getPart(comp, detail, 'toolbar');
+        },
+        setToolbar: function (comp, groups) {
+          parts$a.getPart(comp, detail, 'toolbar').each(function (toolbar) {
+            toolbar.getApis().setGroups(toolbar, groups);
+          });
+        },
+        setToolbars: function (comp, toolbars) {
+          parts$a.getPart(comp, detail, 'multiple-toolbar').each(function (mToolbar) {
+            CustomList.setItems(mToolbar, toolbars);
+          });
+        },
+        refreshToolbar: function (comp) {
+          var toolbar = parts$a.getPart(comp, detail, 'toolbar');
+          toolbar.each(function (toolbar) {
+            return toolbar.getApis().refresh(toolbar);
+          });
+        },
+        toggleToolbarDrawer: function (comp) {
+          parts$a.getPart(comp, detail, 'toolbar').each(function (toolbar) {
+            mapFrom(toolbar.getApis().toggle, function (toggle) {
+              return toggle(toolbar);
+            });
+          });
+        },
+        isToolbarDrawerToggled: function (comp) {
+          return parts$a.getPart(comp, detail, 'toolbar').bind(function (toolbar) {
+            return Optional.from(toolbar.getApis().isOpen).map(function (isOpen) {
+              return isOpen(toolbar);
+            });
+          }).getOr(false);
+        },
+        getThrobber: function (comp) {
+          return parts$a.getPart(comp, detail, 'throbber');
+        },
+        focusToolbar: function (comp) {
+          var optToolbar = parts$a.getPart(comp, detail, 'toolbar').orThunk(function () {
+            return parts$a.getPart(comp, detail, 'multiple-toolbar');
+          });
+          optToolbar.each(function (toolbar) {
+            Keying.focusIn(toolbar);
+          });
+        },
+        setMenubar: function (comp, menus) {
+          parts$a.getPart(comp, detail, 'menubar').each(function (menubar) {
+            SilverMenubar.setMenus(menubar, menus);
+          });
+        },
+        focusMenubar: function (comp) {
+          parts$a.getPart(comp, detail, 'menubar').each(function (menubar) {
+            SilverMenubar.focus(menubar);
+          });
+        }
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        apis: apis,
+        behaviours: detail.behaviours
+      };
+    };
+    var partMenubar = partType.optional({
+      factory: SilverMenubar,
+      name: 'menubar',
+      schema: [required$1('backstage')]
+    });
+    var toolbarFactory = function (spec) {
+      if (spec.type === ToolbarMode.sliding) {
+        return renderSlidingMoreToolbar;
+      } else if (spec.type === ToolbarMode.floating) {
+        return renderFloatingMoreToolbar;
+      } else {
+        return renderToolbar;
+      }
+    };
+    var partMultipleToolbar = partType.optional({
+      factory: {
+        sketch: function (spec) {
+          return CustomList.sketch({
+            uid: spec.uid,
+            dom: spec.dom,
+            listBehaviours: derive$1([Keying.config({
+                mode: 'acyclic',
+                selector: '.tox-toolbar'
+              })]),
+            makeItem: function () {
+              return renderToolbar({
+                type: spec.type,
+                uid: generate$6('multiple-toolbar-item'),
+                cyclicKeying: false,
+                initGroups: [],
+                providers: spec.providers,
+                onEscape: function () {
+                  spec.onEscape();
+                  return Optional.some(true);
+                }
+              });
+            },
+            setupItem: function (_mToolbar, tc, data, _index) {
+              Toolbar.setGroups(tc, data);
+            },
+            shell: true
+          });
+        }
+      },
+      name: 'multiple-toolbar',
+      schema: [
+        required$1('dom'),
+        required$1('onEscape')
+      ]
+    });
+    var partToolbar = partType.optional({
+      factory: {
+        sketch: function (spec) {
+          var renderer = toolbarFactory(spec);
+          var toolbarSpec = {
+            type: spec.type,
+            uid: spec.uid,
+            onEscape: function () {
+              spec.onEscape();
+              return Optional.some(true);
+            },
+            cyclicKeying: false,
+            initGroups: [],
+            getSink: spec.getSink,
+            providers: spec.providers,
+            moreDrawerData: {
+              lazyToolbar: spec.lazyToolbar,
+              lazyMoreButton: spec.lazyMoreButton,
+              lazyHeader: spec.lazyHeader
+            },
+            attributes: spec.attributes
+          };
+          return renderer(toolbarSpec);
+        }
+      },
+      name: 'toolbar',
+      schema: [
+        required$1('dom'),
+        required$1('onEscape'),
+        required$1('getSink')
+      ]
+    });
+    var partHeader = partType.optional({
+      factory: { sketch: renderHeader },
+      name: 'header',
+      schema: [required$1('dom')]
+    });
+    var partSocket = partType.optional({
+      name: 'socket',
+      schema: [required$1('dom')]
+    });
+    var partSidebar = partType.optional({
+      factory: { sketch: renderSidebar },
+      name: 'sidebar',
+      schema: [required$1('dom')]
+    });
+    var partThrobber = partType.optional({
+      factory: { sketch: renderThrobber },
+      name: 'throbber',
+      schema: [required$1('dom')]
+    });
+    var OuterContainer = composite({
+      name: 'OuterContainer',
+      factory: factory$6,
+      configFields: [
+        required$1('dom'),
+        required$1('behaviours')
+      ],
+      partFields: [
+        partHeader,
+        partMenubar,
+        partToolbar,
+        partMultipleToolbar,
+        partSocket,
+        partSidebar,
+        partThrobber
+      ],
+      apis: {
+        getSocket: function (apis, comp) {
+          return apis.getSocket(comp);
+        },
+        setSidebar: function (apis, comp, panelConfigs) {
+          apis.setSidebar(comp, panelConfigs);
+        },
+        toggleSidebar: function (apis, comp, name) {
+          apis.toggleSidebar(comp, name);
+        },
+        whichSidebar: function (apis, comp) {
+          return apis.whichSidebar(comp);
+        },
+        getHeader: function (apis, comp) {
+          return apis.getHeader(comp);
+        },
+        getToolbar: function (apis, comp) {
+          return apis.getToolbar(comp);
+        },
+        setToolbar: function (apis, comp, grps) {
+          var groups = map$2(grps, function (grp) {
+            return renderToolbarGroup(grp);
+          });
+          apis.setToolbar(comp, groups);
+        },
+        setToolbars: function (apis, comp, ts) {
+          var renderedToolbars = map$2(ts, function (g) {
+            return map$2(g, renderToolbarGroup);
+          });
+          apis.setToolbars(comp, renderedToolbars);
+        },
+        refreshToolbar: function (apis, comp) {
+          return apis.refreshToolbar(comp);
+        },
+        toggleToolbarDrawer: function (apis, comp) {
+          apis.toggleToolbarDrawer(comp);
+        },
+        isToolbarDrawerToggled: function (apis, comp) {
+          return apis.isToolbarDrawerToggled(comp);
+        },
+        getThrobber: function (apis, comp) {
+          return apis.getThrobber(comp);
+        },
+        setMenubar: function (apis, comp, menus) {
+          apis.setMenubar(comp, menus);
+        },
+        focusMenubar: function (apis, comp) {
+          apis.focusMenubar(comp);
+        },
+        focusToolbar: function (apis, comp) {
+          apis.focusToolbar(comp);
+        }
+      }
+    });
+
+    var defaultMenubar = 'file edit view insert format tools table help';
+    var defaultMenus = {
+      file: {
+        title: 'File',
+        items: 'newdocument restoredraft | preview | export print | deleteallconversations'
+      },
+      edit: {
+        title: 'Edit',
+        items: 'undo redo | cut copy paste pastetext | selectall | searchreplace'
+      },
+      view: {
+        title: 'View',
+        items: 'code | visualaid visualchars visualblocks | spellchecker | preview fullscreen | showcomments'
+      },
+      insert: {
+        title: 'Insert',
+        items: 'image link media addcomment pageembed template codesample inserttable | charmap emoticons hr | pagebreak nonbreaking anchor toc | insertdatetime'
+      },
+      format: {
+        title: 'Format',
+        items: 'bold italic underline strikethrough superscript subscript codeformat | formats blockformats fontformats fontsizes align lineheight | forecolor backcolor | language | removeformat'
+      },
+      tools: {
+        title: 'Tools',
+        items: 'spellchecker spellcheckerlanguage | a11ycheck code wordcount'
+      },
+      table: {
+        title: 'Table',
+        items: 'inserttable | cell row column | advtablesort | tableprops deletetable'
+      },
+      help: {
+        title: 'Help',
+        items: 'help'
+      }
+    };
+    var make = function (menu, registry, editor) {
+      var removedMenuItems = getRemovedMenuItems(editor).split(/[ ,]/);
+      return {
+        text: menu.title,
+        getItems: function () {
+          return bind$3(menu.items, function (i) {
+            var itemName = i.toLowerCase();
+            if (itemName.trim().length === 0) {
+              return [];
+            } else if (exists(removedMenuItems, function (removedMenuItem) {
+                return removedMenuItem === itemName;
+              })) {
+              return [];
+            } else if (itemName === 'separator' || itemName === '|') {
+              return [{ type: 'separator' }];
+            } else if (registry.menuItems[itemName]) {
+              return [registry.menuItems[itemName]];
+            } else {
+              return [];
+            }
+          });
+        }
+      };
+    };
+    var parseItemsString = function (items) {
+      if (typeof items === 'string') {
+        return items.split(' ');
+      }
+      return items;
+    };
+    var identifyMenus = function (editor, registry) {
+      var rawMenuData = __assign(__assign({}, defaultMenus), registry.menus);
+      var userDefinedMenus = keys(registry.menus).length > 0;
+      var menubar = registry.menubar === undefined || registry.menubar === true ? parseItemsString(defaultMenubar) : parseItemsString(registry.menubar === false ? '' : registry.menubar);
+      var validMenus = filter$2(menubar, function (menuName) {
+        var isDefaultMenu = has$2(defaultMenus, menuName);
+        if (userDefinedMenus) {
+          return isDefaultMenu || get$e(registry.menus, menuName).exists(function (menu) {
+            return has$2(menu, 'items');
+          });
+        } else {
+          return isDefaultMenu;
+        }
+      });
+      var menus = map$2(validMenus, function (menuName) {
+        var menuData = rawMenuData[menuName];
+        return make({
+          title: menuData.title,
+          items: parseItemsString(menuData.items)
+        }, registry, editor);
+      });
+      return filter$2(menus, function (menu) {
+        var isNotSeparator = function (item) {
+          return item.type !== 'separator';
+        };
+        return menu.getItems().length > 0 && exists(menu.getItems(), isNotSeparator);
+      });
+    };
+
+    var fireSkinLoaded = function (editor) {
+      var done = function () {
+        editor._skinLoaded = true;
+        fireSkinLoaded$1(editor);
+      };
+      return function () {
+        if (editor.initialized) {
+          done();
+        } else {
+          editor.on('init', done);
+        }
+      };
+    };
+    var fireSkinLoadError = function (editor, err) {
+      return function () {
+        return fireSkinLoadError$1(editor, { message: err });
+      };
+    };
+
+    var loadStylesheet = function (editor, stylesheetUrl, styleSheetLoader) {
+      return new global$c(function (resolve, reject) {
+        styleSheetLoader.load(stylesheetUrl, resolve, reject);
+        editor.on('remove', function () {
+          return styleSheetLoader.unload(stylesheetUrl);
+        });
+      });
+    };
+    var loadUiSkins = function (editor, skinUrl) {
+      var skinUiCss = skinUrl + '/skin.min.css';
+      return loadStylesheet(editor, skinUiCss, editor.ui.styleSheetLoader);
+    };
+    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$b.DOM.styleSheetLoader);
+      } else {
+        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$c.all([
+          loadUiSkins(editor, skinUrl),
+          loadShadowDomUiSkins(editor, skinUrl)
+        ]).then(fireSkinLoaded(editor), fireSkinLoadError(editor, 'Skin could not be loaded'));
+      } else {
+        fireSkinLoaded(editor)();
+      }
+    };
+    var iframe = curry(loadSkin, false);
+    var inline = curry(loadSkin, true);
+
+    var onSetupFormatToggle = function (editor, name) {
+      return function (api) {
+        var boundCallback = unbindable();
+        var init = function () {
+          api.setActive(editor.formatter.match(name));
+          var binding = editor.formatter.formatChanged(name, api.setActive);
+          boundCallback.set(binding);
+        };
+        editor.initialized ? init() : editor.once('init', init);
+        return function () {
+          editor.off('init', init);
+          boundCallback.clear();
+        };
+      };
+    };
+    var onSetupEvent = function (editor, event, f) {
+      return function (api) {
+        var handleEvent = function () {
+          return f(api);
+        };
+        var init = function () {
+          f(api);
+          editor.on(event, handleEvent);
+        };
+        editor.initialized ? init() : editor.once('init', init);
+        return function () {
+          editor.off('init', init);
+          editor.off(event, handleEvent);
+        };
+      };
+    };
+    var onActionToggleFormat$1 = function (editor) {
+      return function (rawItem) {
+        return function () {
+          editor.undoManager.transact(function () {
+            editor.focus();
+            editor.execCommand('mceToggleFormat', false, rawItem.format);
+          });
+        };
+      };
+    };
+    var onActionExecCommand = function (editor, command) {
+      return function () {
+        return editor.execCommand(command);
+      };
+    };
+
+    var generateSelectItems = function (_editor, backstage, spec) {
+      var generateItem = function (rawItem, response, disabled, value) {
+        var translatedText = backstage.shared.providers.translate(rawItem.title);
+        if (rawItem.type === 'separator') {
+          return Optional.some({
+            type: 'separator',
+            text: translatedText
+          });
+        } else if (rawItem.type === 'submenu') {
+          var items = bind$3(rawItem.getStyleItems(), function (si) {
+            return validate(si, response, value);
+          });
+          if (response === 0 && items.length <= 0) {
+            return Optional.none();
+          } else {
+            return Optional.some({
+              type: 'nestedmenuitem',
+              text: translatedText,
+              disabled: items.length <= 0,
+              getSubmenuItems: function () {
+                return bind$3(rawItem.getStyleItems(), function (si) {
+                  return validate(si, response, value);
+                });
+              }
+            });
+          }
+        } else {
+          return Optional.some(__assign({
+            type: 'togglemenuitem',
+            text: translatedText,
+            icon: rawItem.icon,
+            active: rawItem.isSelected(value),
+            disabled: disabled,
+            onAction: spec.onAction(rawItem)
+          }, rawItem.getStylePreview().fold(function () {
+            return {};
+          }, function (preview) {
+            return { meta: { style: preview } };
+          })));
+        }
+      };
+      var validate = function (item, response, value) {
+        var invalid = item.type === 'formatter' && spec.isInvalid(item);
+        if (response === 0) {
+          return invalid ? [] : generateItem(item, response, false, value).toArray();
+        } else {
+          return generateItem(item, response, invalid, value).toArray();
+        }
+      };
+      var validateItems = function (preItems) {
+        var value = spec.getCurrentValue();
+        var response = spec.shouldHide ? 0 : 1;
+        return bind$3(preItems, function (item) {
+          return validate(item, response, value);
+        });
+      };
+      var getFetch = function (backstage, getStyleItems) {
+        return function (comp, callback) {
+          var preItems = getStyleItems();
+          var items = validateItems(preItems);
+          var menu = build(items, ItemResponse$1.CLOSE_ON_EXECUTE, backstage, false);
+          callback(menu);
+        };
+      };
+      return {
+        validateItems: validateItems,
+        getFetch: getFetch
+      };
+    };
+    var createMenuItems = function (editor, backstage, spec) {
+      var dataset = spec.dataset;
+      var getStyleItems = dataset.type === 'basic' ? function () {
+        return map$2(dataset.data, function (d) {
+          return processBasic(d, spec.isSelectedFor, spec.getPreviewFor);
+        });
+      } : dataset.getData;
+      return {
+        items: generateSelectItems(editor, backstage, spec),
+        getStyleItems: getStyleItems
+      };
+    };
+    var createSelectButton = function (editor, backstage, spec) {
+      var _a = createMenuItems(editor, backstage, spec), items = _a.items, getStyleItems = _a.getStyleItems;
+      var getApi = function (comp) {
+        return { getComponent: constant$1(comp) };
+      };
+      var onSetup = onSetupEvent(editor, 'NodeChange', function (api) {
+        var comp = api.getComponent();
+        spec.updateText(comp);
+      });
+      return renderCommonDropdown({
+        text: spec.icon.isSome() ? Optional.none() : spec.text,
+        icon: spec.icon,
+        tooltip: Optional.from(spec.tooltip),
+        role: Optional.none(),
+        fetch: items.getFetch(backstage, getStyleItems),
+        onSetup: onSetup,
+        getApi: getApi,
+        columns: 1,
+        presets: 'normal',
+        classes: spec.icon.isSome() ? [] : ['bespoke'],
+        dropdownBehaviours: []
+      }, 'tox-tbtn', backstage.shared);
+    };
+
+    var process = function (rawFormats) {
+      return map$2(rawFormats, function (item) {
+        var title = item, format = item;
+        var values = item.split('=');
+        if (values.length > 1) {
+          title = values[0];
+          format = values[1];
+        }
+        return {
+          title: title,
+          format: format
+        };
+      });
+    };
+    var buildBasicStaticDataset = function (data) {
+      return {
+        type: 'basic',
+        data: data
+      };
+    };
+    var Delimiter;
+    (function (Delimiter) {
+      Delimiter[Delimiter['SemiColon'] = 0] = 'SemiColon';
+      Delimiter[Delimiter['Space'] = 1] = 'Space';
+    }(Delimiter || (Delimiter = {})));
+    var split = function (rawFormats, delimiter) {
+      if (delimiter === Delimiter.SemiColon) {
+        return rawFormats.replace(/;$/, '').split(';');
+      } else {
+        return rawFormats.split(' ');
+      }
+    };
+    var buildBasicSettingsDataset = function (editor, settingName, defaults, delimiter) {
+      var rawFormats = editor.getParam(settingName, defaults, 'string');
+      var data = process(split(rawFormats, delimiter));
+      return {
+        type: 'basic',
+        data: data
+      };
+    };
+
+    var alignMenuItems = [
+      {
+        title: 'Left',
+        icon: 'align-left',
+        format: 'alignleft',
+        command: 'JustifyLeft'
+      },
+      {
+        title: 'Center',
+        icon: 'align-center',
+        format: 'aligncenter',
+        command: 'JustifyCenter'
+      },
+      {
+        title: 'Right',
+        icon: 'align-right',
+        format: 'alignright',
+        command: 'JustifyRight'
+      },
+      {
+        title: 'Justify',
+        icon: 'align-justify',
+        format: 'alignjustify',
+        command: 'JustifyFull'
+      }
+    ];
+    var getSpec$4 = function (editor) {
+      var getMatchingValue = function () {
+        return find$5(alignMenuItems, function (item) {
+          return editor.formatter.match(item.format);
+        });
+      };
+      var isSelectedFor = function (format) {
+        return function () {
+          return editor.formatter.match(format);
+        };
+      };
+      var getPreviewFor = function (_format) {
+        return Optional.none;
+      };
+      var updateSelectMenuIcon = function (comp) {
+        var match = getMatchingValue();
+        var alignment = match.fold(constant$1('left'), function (item) {
+          return item.title.toLowerCase();
+        });
+        emitWith(comp, updateMenuIcon, { icon: 'align-' + alignment });
+      };
+      var dataset = buildBasicStaticDataset(alignMenuItems);
+      var onAction = function (rawItem) {
+        return function () {
+          return find$5(alignMenuItems, function (item) {
+            return item.format === rawItem.format;
+          }).each(function (item) {
+            return editor.execCommand(item.command);
+          });
+        };
+      };
+      return {
+        tooltip: 'Align',
+        text: Optional.none(),
+        icon: Optional.some('align-left'),
+        isSelectedFor: isSelectedFor,
+        getCurrentValue: Optional.none,
+        getPreviewFor: getPreviewFor,
+        onAction: onAction,
+        updateText: updateSelectMenuIcon,
+        dataset: dataset,
+        shouldHide: false,
+        isInvalid: function (item) {
+          return !editor.formatter.canApply(item.format);
+        }
+      };
+    };
+    var createAlignSelect = function (editor, backstage) {
+      return createSelectButton(editor, backstage, getSpec$4(editor));
+    };
+    var alignSelectMenu = function (editor, backstage) {
+      var menuItems = createMenuItems(editor, backstage, getSpec$4(editor));
+      editor.ui.registry.addNestedMenuItem('align', {
+        text: backstage.shared.providers.translate('Align'),
+        getSubmenuItems: function () {
+          return menuItems.items.validateItems(menuItems.getStyleItems());
+        }
+      });
+    };
+
+    var defaultFontsFormats = 'Andale Mono=andale mono,monospace;' + 'Arial=arial,helvetica,sans-serif;' + 'Arial Black=arial black,sans-serif;' + 'Book Antiqua=book antiqua,palatino,serif;' + 'Comic Sans MS=comic sans ms,sans-serif;' + 'Courier New=courier new,courier,monospace;' + 'Georgia=georgia,palatino,serif;' + 'Helvetica=helvetica,arial,sans-serif;' + 'Impact=impact,sans-serif;' + 'Symbol=symbol;' + 'Tahoma=tahoma,arial,helvetica,sans-serif;' + 'Terminal=terminal,monaco,monospace;' + 'Times New Roman=times new roman,times,serif;' + 'Trebuchet MS=trebuchet ms,geneva,sans-serif;' + 'Verdana=verdana,geneva,sans-serif;' + 'Webdings=webdings;' + 'Wingdings=wingdings,zapf dingbats';
+    var systemStackFonts = [
+      '-apple-system',
+      'Segoe UI',
+      'Roboto',
+      'Helvetica Neue',
+      'sans-serif'
+    ];
+    var splitFonts = function (fontFamily) {
+      var fonts = fontFamily.split(/\s*,\s*/);
+      return map$2(fonts, function (font) {
+        return font.replace(/^['"]+|['"]+$/g, '');
+      });
+    };
+    var isSystemFontStack = function (fontFamily) {
+      var matchesSystemStack = function () {
+        var fonts = splitFonts(fontFamily.toLowerCase());
+        return forall(systemStackFonts, function (font) {
+          return fonts.indexOf(font.toLowerCase()) > -1;
+        });
+      };
+      return fontFamily.indexOf('-apple-system') === 0 && matchesSystemStack();
+    };
+    var getSpec$3 = function (editor) {
+      var systemFont = 'System Font';
+      var getMatchingValue = function () {
+        var getFirstFont = function (fontFamily) {
+          return fontFamily ? splitFonts(fontFamily)[0] : '';
+        };
+        var fontFamily = editor.queryCommandValue('FontName');
+        var items = dataset.data;
+        var font = fontFamily ? fontFamily.toLowerCase() : '';
+        var matchOpt = find$5(items, function (item) {
+          var format = item.format;
+          return format.toLowerCase() === font || getFirstFont(format).toLowerCase() === getFirstFont(font).toLowerCase();
+        }).orThunk(function () {
+          return someIf(isSystemFontStack(font), {
+            title: systemFont,
+            format: font
+          });
+        });
+        return {
+          matchOpt: matchOpt,
+          font: fontFamily
+        };
+      };
+      var isSelectedFor = function (item) {
+        return function (valueOpt) {
+          return valueOpt.exists(function (value) {
+            return value.format === item;
+          });
+        };
+      };
+      var getCurrentValue = function () {
+        var matchOpt = getMatchingValue().matchOpt;
+        return matchOpt;
+      };
+      var getPreviewFor = function (item) {
+        return function () {
+          return Optional.some({
+            tag: 'div',
+            styles: item.indexOf('dings') === -1 ? { 'font-family': item } : {}
+          });
+        };
+      };
+      var onAction = function (rawItem) {
+        return function () {
+          editor.undoManager.transact(function () {
+            editor.focus();
+            editor.execCommand('FontName', false, rawItem.format);
+          });
+        };
+      };
+      var updateSelectMenuText = function (comp) {
+        var _a = getMatchingValue(), matchOpt = _a.matchOpt, font = _a.font;
+        var text = matchOpt.fold(constant$1(font), function (item) {
+          return item.title;
+        });
+        emitWith(comp, updateMenuText, { text: text });
+      };
+      var dataset = buildBasicSettingsDataset(editor, 'font_formats', defaultFontsFormats, Delimiter.SemiColon);
+      return {
+        tooltip: 'Fonts',
+        text: Optional.some(systemFont),
+        icon: Optional.none(),
+        isSelectedFor: isSelectedFor,
+        getCurrentValue: getCurrentValue,
+        getPreviewFor: getPreviewFor,
+        onAction: onAction,
+        updateText: updateSelectMenuText,
+        dataset: dataset,
+        shouldHide: false,
+        isInvalid: never
+      };
+    };
+    var createFontSelect = function (editor, backstage) {
+      return createSelectButton(editor, backstage, getSpec$3(editor));
+    };
+    var fontSelectMenu = function (editor, backstage) {
+      var menuItems = createMenuItems(editor, backstage, getSpec$3(editor));
+      editor.ui.registry.addNestedMenuItem('fontformats', {
+        text: backstage.shared.providers.translate('Fonts'),
+        getSubmenuItems: function () {
+          return menuItems.items.validateItems(menuItems.getStyleItems());
+        }
+      });
+    };
+
+    var defaultFontsizeFormats = '8pt 10pt 12pt 14pt 18pt 24pt 36pt';
+    var legacyFontSizes = {
+      '8pt': '1',
+      '10pt': '2',
+      '12pt': '3',
+      '14pt': '4',
+      '18pt': '5',
+      '24pt': '6',
+      '36pt': '7'
+    };
+    var keywordFontSizes = {
+      'xx-small': '7pt',
+      'x-small': '8pt',
+      'small': '10pt',
+      'medium': '12pt',
+      'large': '14pt',
+      'x-large': '18pt',
+      'xx-large': '24pt'
+    };
+    var round = function (number, precision) {
+      var factor = Math.pow(10, precision);
+      return Math.round(number * factor) / factor;
+    };
+    var toPt = function (fontSize, precision) {
+      if (/[0-9.]+px$/.test(fontSize)) {
+        return round(parseInt(fontSize, 10) * 72 / 96, precision || 0) + 'pt';
+      } else {
+        return get$e(keywordFontSizes, fontSize).getOr(fontSize);
+      }
+    };
+    var toLegacy = function (fontSize) {
+      return get$e(legacyFontSizes, fontSize).getOr('');
+    };
+    var getSpec$2 = function (editor) {
+      var getMatchingValue = function () {
+        var matchOpt = Optional.none();
+        var items = dataset.data;
+        var fontSize = editor.queryCommandValue('FontSize');
+        if (fontSize) {
+          var _loop_1 = function (precision) {
+            var pt = toPt(fontSize, precision);
+            var legacy = toLegacy(pt);
+            matchOpt = find$5(items, function (item) {
+              return item.format === fontSize || item.format === pt || item.format === legacy;
+            });
+          };
+          for (var precision = 3; matchOpt.isNone() && precision >= 0; precision--) {
+            _loop_1(precision);
+          }
+        }
+        return {
+          matchOpt: matchOpt,
+          size: fontSize
+        };
+      };
+      var isSelectedFor = function (item) {
+        return function (valueOpt) {
+          return valueOpt.exists(function (value) {
+            return value.format === item;
+          });
+        };
+      };
+      var getCurrentValue = function () {
+        var matchOpt = getMatchingValue().matchOpt;
+        return matchOpt;
+      };
+      var getPreviewFor = constant$1(Optional.none);
+      var onAction = function (rawItem) {
+        return function () {
+          editor.undoManager.transact(function () {
+            editor.focus();
+            editor.execCommand('FontSize', false, rawItem.format);
+          });
+        };
+      };
+      var updateSelectMenuText = function (comp) {
+        var _a = getMatchingValue(), matchOpt = _a.matchOpt, size = _a.size;
+        var text = matchOpt.fold(constant$1(size), function (match) {
+          return match.title;
+        });
+        emitWith(comp, updateMenuText, { text: text });
+      };
+      var dataset = buildBasicSettingsDataset(editor, 'fontsize_formats', defaultFontsizeFormats, Delimiter.Space);
+      return {
+        tooltip: 'Font sizes',
+        text: Optional.some('12pt'),
+        icon: Optional.none(),
+        isSelectedFor: isSelectedFor,
+        getPreviewFor: getPreviewFor,
+        getCurrentValue: getCurrentValue,
+        onAction: onAction,
+        updateText: updateSelectMenuText,
+        dataset: dataset,
+        shouldHide: false,
+        isInvalid: never
+      };
+    };
+    var createFontsizeSelect = function (editor, backstage) {
+      return createSelectButton(editor, backstage, getSpec$2(editor));
+    };
+    var fontsizeSelectMenu = function (editor, backstage) {
+      var menuItems = createMenuItems(editor, backstage, getSpec$2(editor));
+      editor.ui.registry.addNestedMenuItem('fontsizes', {
+        text: 'Font sizes',
+        getSubmenuItems: function () {
+          return menuItems.items.validateItems(menuItems.getStyleItems());
+        }
+      });
+    };
+
+    var findNearest = function (editor, getStyles) {
+      var styles = getStyles();
+      var formats = map$2(styles, function (style) {
+        return style.format;
+      });
+      return Optional.from(editor.formatter.closest(formats)).bind(function (fmt) {
+        return find$5(styles, function (data) {
+          return data.format === fmt;
+        });
+      }).orThunk(function () {
+        return someIf(editor.formatter.match('p'), {
+          title: 'Paragraph',
+          format: 'p'
+        });
+      });
+    };
+
+    var defaultBlocks = 'Paragraph=p;' + 'Heading 1=h1;' + 'Heading 2=h2;' + 'Heading 3=h3;' + 'Heading 4=h4;' + 'Heading 5=h5;' + 'Heading 6=h6;' + 'Preformatted=pre';
+    var getSpec$1 = function (editor) {
+      var fallbackFormat = 'Paragraph';
+      var isSelectedFor = function (format) {
+        return function () {
+          return editor.formatter.match(format);
+        };
+      };
+      var getPreviewFor = function (format) {
+        return function () {
+          var fmt = editor.formatter.get(format);
+          return Optional.some({
+            tag: fmt.length > 0 ? fmt[0].inline || fmt[0].block || 'div' : 'div',
+            styles: editor.dom.parseStyle(editor.formatter.getCssText(format))
+          });
+        };
+      };
+      var updateSelectMenuText = function (comp) {
+        var detectedFormat = findNearest(editor, function () {
+          return dataset.data;
+        });
+        var text = detectedFormat.fold(constant$1(fallbackFormat), function (fmt) {
+          return fmt.title;
+        });
+        emitWith(comp, updateMenuText, { text: text });
+      };
+      var dataset = buildBasicSettingsDataset(editor, 'block_formats', defaultBlocks, Delimiter.SemiColon);
+      return {
+        tooltip: 'Blocks',
+        text: Optional.some(fallbackFormat),
+        icon: Optional.none(),
+        isSelectedFor: isSelectedFor,
+        getCurrentValue: Optional.none,
+        getPreviewFor: getPreviewFor,
+        onAction: onActionToggleFormat$1(editor),
+        updateText: updateSelectMenuText,
+        dataset: dataset,
+        shouldHide: false,
+        isInvalid: function (item) {
+          return !editor.formatter.canApply(item.format);
+        }
+      };
+    };
+    var createFormatSelect = function (editor, backstage) {
+      return createSelectButton(editor, backstage, getSpec$1(editor));
+    };
+    var formatSelectMenu = function (editor, backstage) {
+      var menuItems = createMenuItems(editor, backstage, getSpec$1(editor));
+      editor.ui.registry.addNestedMenuItem('blockformats', {
+        text: 'Blocks',
+        getSubmenuItems: function () {
+          return menuItems.items.validateItems(menuItems.getStyleItems());
+        }
+      });
+    };
+
+    var getSpec = function (editor, dataset) {
+      var fallbackFormat = 'Paragraph';
+      var isSelectedFor = function (format) {
+        return function () {
+          return editor.formatter.match(format);
+        };
+      };
+      var getPreviewFor = function (format) {
+        return function () {
+          var fmt = editor.formatter.get(format);
+          return fmt !== undefined ? Optional.some({
+            tag: fmt.length > 0 ? fmt[0].inline || fmt[0].block || 'div' : 'div',
+            styles: editor.dom.parseStyle(editor.formatter.getCssText(format))
+          }) : Optional.none();
+        };
+      };
+      var updateSelectMenuText = function (comp) {
+        var getFormatItems = function (fmt) {
+          var subs = fmt.items;
+          return subs !== undefined && subs.length > 0 ? bind$3(subs, getFormatItems) : [{
+              title: fmt.title,
+              format: fmt.format
+            }];
+        };
+        var flattenedItems = bind$3(getStyleFormats(editor), getFormatItems);
+        var detectedFormat = findNearest(editor, constant$1(flattenedItems));
+        var text = detectedFormat.fold(constant$1(fallbackFormat), function (fmt) {
+          return fmt.title;
+        });
+        emitWith(comp, updateMenuText, { text: text });
+      };
+      return {
+        tooltip: 'Formats',
+        text: Optional.some(fallbackFormat),
+        icon: Optional.none(),
+        isSelectedFor: isSelectedFor,
+        getCurrentValue: Optional.none,
+        getPreviewFor: getPreviewFor,
+        onAction: onActionToggleFormat$1(editor),
+        updateText: updateSelectMenuText,
+        shouldHide: editor.getParam('style_formats_autohide', false, 'boolean'),
+        isInvalid: function (item) {
+          return !editor.formatter.canApply(item.format);
+        },
+        dataset: dataset
+      };
+    };
+    var createStyleSelect = function (editor, backstage) {
+      var dataset = __assign({ type: 'advanced' }, backstage.styleselect);
+      return createSelectButton(editor, backstage, getSpec(editor, dataset));
+    };
+    var styleSelectMenu = function (editor, backstage) {
+      var dataset = __assign({ type: 'advanced' }, backstage.styleselect);
+      var menuItems = createMenuItems(editor, backstage, getSpec(editor, dataset));
+      editor.ui.registry.addNestedMenuItem('formats', {
+        text: 'Formats',
+        getSubmenuItems: function () {
+          return menuItems.items.validateItems(menuItems.getStyleItems());
+        }
+      });
+    };
+
+    var events$3 = function (reflectingConfig, reflectingState) {
+      var update = function (component, data) {
+        reflectingConfig.updateState.each(function (updateState) {
+          var newState = updateState(component, data);
+          reflectingState.set(newState);
+        });
+        reflectingConfig.renderComponents.each(function (renderComponents) {
+          var newComponents = renderComponents(data, reflectingState.get());
+          var newChildren = map$2(newComponents, component.getSystem().build);
+          replaceChildren(component, newChildren);
+        });
+      };
+      return derive$2([
+        run$1(receive(), function (component, message) {
+          var receivingData = message;
+          if (!receivingData.universal) {
+            var channel = reflectingConfig.channel;
+            if (contains$2(receivingData.channels, channel)) {
+              update(component, receivingData.data);
+            }
+          }
+        }),
+        runOnAttached(function (comp, _se) {
+          reflectingConfig.initialData.each(function (rawData) {
+            update(comp, rawData);
+          });
+        })
+      ]);
+    };
+
+    var ActiveReflecting = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        events: events$3
+    });
+
+    var getState = function (component, replaceConfig, reflectState) {
+      return reflectState;
+    };
+
+    var ReflectingApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        getState: getState
+    });
+
+    var ReflectingSchema = [
+      required$1('channel'),
+      option('renderComponents'),
+      option('updateState'),
+      option('initialData')
+    ];
+
+    var init$3 = function () {
+      var cell = Cell(Optional.none());
+      var clear = function () {
+        return cell.set(Optional.none());
+      };
+      var readState = function () {
+        return cell.get().getOr('none');
+      };
+      return {
+        readState: readState,
+        get: cell.get,
+        set: cell.set,
+        clear: clear
+      };
+    };
+
+    var ReflectingState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init$3
+    });
+
+    var Reflecting = create$8({
+      fields: ReflectingSchema,
+      name: 'reflecting',
+      active: ActiveReflecting,
+      apis: ReflectingApis,
+      state: ReflectingState
+    });
+
+    var schema$7 = constant$1([
+      required$1('toggleClass'),
+      required$1('fetch'),
+      onStrictHandler('onExecute'),
+      defaulted('getHotspot', Optional.some),
+      defaulted('getAnchorOverrides', constant$1({})),
+      schema$y(),
+      onStrictHandler('onItemExecute'),
+      option('lazySink'),
+      required$1('dom'),
+      onHandler('onOpen'),
+      field('splitDropdownBehaviours', [
+        Coupling,
+        Keying,
+        Focusing
+      ]),
+      defaulted('matchWidth', false),
+      defaulted('useMinWidth', false),
+      defaulted('eventOrder', {}),
+      option('role')
+    ].concat(sandboxFields()));
+    var arrowPart = required({
+      factory: Button,
+      schema: [required$1('dom')],
+      name: 'arrow',
+      defaults: function () {
+        return { buttonBehaviours: derive$1([Focusing.revoke()]) };
+      },
+      overrides: function (detail) {
+        return {
+          dom: {
+            tag: 'span',
+            attributes: { role: 'presentation' }
+          },
+          action: function (arrow) {
+            arrow.getSystem().getByUid(detail.uid).each(emitExecute);
+          },
+          buttonBehaviours: derive$1([Toggling.config({
+              toggleOnExecute: false,
+              toggleClass: detail.toggleClass
+            })])
+        };
+      }
+    });
+    var buttonPart = required({
+      factory: Button,
+      schema: [required$1('dom')],
+      name: 'button',
+      defaults: function () {
+        return { buttonBehaviours: derive$1([Focusing.revoke()]) };
+      },
+      overrides: function (detail) {
+        return {
+          dom: {
+            tag: 'span',
+            attributes: { role: 'presentation' }
+          },
+          action: function (btn) {
+            btn.getSystem().getByUid(detail.uid).each(function (splitDropdown) {
+              detail.onExecute(splitDropdown, btn);
+            });
+          }
+        };
+      }
+    });
+    var parts$3 = constant$1([
+      arrowPart,
+      buttonPart,
+      optional({
+        factory: {
+          sketch: function (spec) {
+            return {
+              uid: spec.uid,
+              dom: {
+                tag: 'span',
+                styles: { display: 'none' },
+                attributes: { 'aria-hidden': 'true' },
+                innerHtml: spec.text
+              }
+            };
+          }
+        },
+        schema: [required$1('text')],
+        name: 'aria-descriptor'
+      }),
+      external$1({
+        schema: [tieredMenuMarkers()],
+        name: 'menu',
+        defaults: function (detail) {
+          return {
+            onExecute: function (tmenu, item) {
+              tmenu.getSystem().getByUid(detail.uid).each(function (splitDropdown) {
+                detail.onItemExecute(splitDropdown, tmenu, item);
+              });
+            }
+          };
+        }
+      }),
+      partType$1()
+    ]);
+
+    var factory$5 = function (detail, components, spec, externals) {
+      var _a;
+      var switchToMenu = function (sandbox) {
+        Composing.getCurrent(sandbox).each(function (current) {
+          Highlighting.highlightFirst(current);
+          Keying.focusIn(current);
+        });
+      };
+      var action = function (component) {
+        var onOpenSync = switchToMenu;
+        togglePopup(detail, identity$1, component, externals, onOpenSync, HighlightOnOpen.HighlightFirst).get(noop);
+      };
+      var openMenu = function (comp) {
+        action(comp);
+        return Optional.some(true);
+      };
+      var executeOnButton = function (comp) {
+        var button = getPartOrDie(comp, detail, 'button');
+        emitExecute(button);
+        return Optional.some(true);
+      };
+      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$8(descriptor.element, 'id', descriptorId);
+            set$8(component.element, 'aria-describedby', descriptorId);
+          });
+        })])), events$a(Optional.some(action)));
+      var apis = {
+        repositionMenus: function (comp) {
+          if (Toggling.isOn(comp)) {
+            repositionMenus(comp);
+          }
+        }
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        apis: apis,
+        eventOrder: __assign(__assign({}, detail.eventOrder), (_a = {}, _a[execute$5()] = [
+          'disabling',
+          'toggling',
+          'alloy.base.behaviour'
+        ], _a)),
+        events: buttonEvents,
+        behaviours: augment(detail.splitDropdownBehaviours, [
+          Coupling.config({
+            others: {
+              sandbox: function (hotspot) {
+                var arrow = getPartOrDie(hotspot, detail, 'arrow');
+                var extras = {
+                  onOpen: function () {
+                    Toggling.on(arrow);
+                    Toggling.on(hotspot);
+                  },
+                  onClose: function () {
+                    Toggling.off(arrow);
+                    Toggling.off(hotspot);
+                  }
+                };
+                return makeSandbox$1(detail, hotspot, extras);
+              }
+            }
+          }),
+          Keying.config({
+            mode: 'special',
+            onSpace: executeOnButton,
+            onEnter: executeOnButton,
+            onDown: openMenu
+          }),
+          Focusing.config({}),
+          Toggling.config({
+            toggleOnExecute: false,
+            aria: { mode: 'expanded' }
+          })
+        ]),
+        domModification: {
+          attributes: {
+            'role': detail.role.getOr('button'),
+            'aria-haspopup': true
+          }
+        }
+      };
+    };
+    var SplitDropdown = composite({
+      name: 'SplitDropdown',
+      configFields: schema$7(),
+      partFields: parts$3(),
+      factory: factory$5,
+      apis: {
+        repositionMenus: function (apis, comp) {
+          return apis.repositionMenus(comp);
+        }
+      }
+    });
+
+    var getButtonApi = function (component) {
+      return {
+        isDisabled: function () {
+          return Disabling.isDisabled(component);
+        },
+        setDisabled: function (state) {
+          return Disabling.set(component, state);
+        }
+      };
+    };
+    var getToggleApi = function (component) {
+      return {
+        setActive: function (state) {
+          Toggling.set(component, state);
+        },
+        isActive: function () {
+          return Toggling.isOn(component);
+        },
+        isDisabled: function () {
+          return Disabling.isDisabled(component);
+        },
+        setDisabled: function (state) {
+          return Disabling.set(component, state);
+        }
+      };
+    };
+    var getTooltipAttributes = function (tooltip, providersBackstage) {
+      return tooltip.map(function (tooltip) {
+        return {
+          'aria-label': providersBackstage.translate(tooltip),
+          'title': providersBackstage.translate(tooltip)
+        };
+      }).getOr({});
+    };
+    var focusButtonEvent = generate$6('focus-button');
+    var renderCommonStructure = function (icon, text, tooltip, receiver, behaviours, providersBackstage) {
+      var _d;
+      return {
+        dom: {
+          tag: 'button',
+          classes: ['tox-tbtn'].concat(text.isSome() ? ['tox-tbtn--select'] : []),
+          attributes: getTooltipAttributes(tooltip, providersBackstage)
+        },
+        components: componentRenderPipeline([
+          icon.map(function (iconName) {
+            return renderIconFromPack(iconName, providersBackstage.icons);
+          }),
+          text.map(function (text) {
+            return renderLabel$1(text, 'tox-tbtn', providersBackstage);
+          })
+        ]),
+        eventOrder: (_d = {}, _d[mousedown()] = [
+          'focusing',
+          'alloy.base.behaviour',
+          'common-button-display-events'
+        ], _d),
+        buttonBehaviours: derive$1([
+          DisablingConfigs.toolbarButton(providersBackstage.isDisabled),
+          receivingConfig(),
+          config('common-button-display-events', [run$1(mousedown(), function (button, se) {
+              se.event.prevent();
+              emit(button, focusButtonEvent);
+            })])
+        ].concat(receiver.map(function (r) {
+          return Reflecting.config({
+            channel: r,
+            initialData: {
+              icon: icon,
+              text: text
+            },
+            renderComponents: function (data, _state) {
+              return componentRenderPipeline([
+                data.icon.map(function (iconName) {
+                  return renderIconFromPack(iconName, providersBackstage.icons);
+                }),
+                data.text.map(function (text) {
+                  return renderLabel$1(text, 'tox-tbtn', providersBackstage);
+                })
+              ]);
+            }
+          });
+        }).toArray()).concat(behaviours.getOr([])))
+      };
+    };
+    var renderFloatingToolbarButton = function (spec, backstage, identifyButtons, attributes) {
+      var sharedBackstage = backstage.shared;
+      return FloatingToolbarButton.sketch({
+        lazySink: sharedBackstage.getSink,
+        fetch: function () {
+          return Future.nu(function (resolve) {
+            resolve(map$2(identifyButtons(spec.items), renderToolbarGroup));
+          });
+        },
+        markers: { toggledClass: 'tox-tbtn--enabled' },
+        parts: {
+          button: renderCommonStructure(spec.icon, spec.text, spec.tooltip, Optional.none(), Optional.none(), sharedBackstage.providers),
+          toolbar: {
+            dom: {
+              tag: 'div',
+              classes: ['tox-toolbar__overflow'],
+              attributes: attributes
+            }
+          }
+        }
+      });
+    };
+    var renderCommonToolbarButton = function (spec, specialisation, providersBackstage) {
+      var editorOffCell = Cell(noop);
+      var structure = renderCommonStructure(spec.icon, spec.text, spec.tooltip, Optional.none(), Optional.none(), providersBackstage);
+      return Button.sketch({
+        dom: structure.dom,
+        components: structure.components,
+        eventOrder: toolbarButtonEventOrder,
+        buttonBehaviours: derive$1([
+          config('toolbar-button-events', [
+            onToolbarButtonExecute({
+              onAction: spec.onAction,
+              getApi: specialisation.getApi
+            }),
+            onControlAttached(specialisation, editorOffCell),
+            onControlDetached(specialisation, editorOffCell)
+          ]),
+          DisablingConfigs.toolbarButton(function () {
+            return spec.disabled || providersBackstage.isDisabled();
+          }),
+          receivingConfig()
+        ].concat(specialisation.toolbarButtonBehaviours))
+      });
+    };
+    var renderToolbarButton = function (spec, providersBackstage) {
+      return renderToolbarButtonWith(spec, providersBackstage, []);
+    };
+    var renderToolbarButtonWith = function (spec, providersBackstage, bonusEvents) {
+      return renderCommonToolbarButton(spec, {
+        toolbarButtonBehaviours: [].concat(bonusEvents.length > 0 ? [config('toolbarButtonWith', bonusEvents)] : []),
+        getApi: getButtonApi,
+        onSetup: spec.onSetup
+      }, providersBackstage);
+    };
+    var renderToolbarToggleButton = function (spec, providersBackstage) {
+      return renderToolbarToggleButtonWith(spec, providersBackstage, []);
+    };
+    var renderToolbarToggleButtonWith = function (spec, providersBackstage, bonusEvents) {
+      return deepMerge(renderCommonToolbarButton(spec, {
+        toolbarButtonBehaviours: [
+          Replacing.config({}),
+          Toggling.config({
+            toggleClass: 'tox-tbtn--enabled',
+            aria: { mode: 'pressed' },
+            toggleOnExecute: false
+          })
+        ].concat(bonusEvents.length > 0 ? [config('toolbarToggleButtonWith', bonusEvents)] : []),
+        getApi: getToggleApi,
+        onSetup: spec.onSetup
+      }, providersBackstage));
+    };
+    var fetchChoices = function (getApi, spec, providersBackstage) {
+      return function (comp) {
+        return Future.nu(function (callback) {
+          return spec.fetch(callback);
+        }).map(function (items) {
+          return Optional.from(createTieredDataFrom(deepMerge(createPartialChoiceMenu(generate$6('menu-value'), items, function (value) {
+            spec.onItemAction(getApi(comp), value);
+          }, spec.columns, spec.presets, ItemResponse$1.CLOSE_ON_EXECUTE, spec.select.getOr(never), providersBackstage), {
+            movement: deriveMenuMovement(spec.columns, spec.presets),
+            menuBehaviours: SimpleBehaviours.unnamedEvents(spec.columns !== 'auto' ? [] : [runOnAttached(function (comp, _se) {
+                detectSize(comp, 4, classForPreset(spec.presets)).each(function (_d) {
+                  var numRows = _d.numRows, numColumns = _d.numColumns;
+                  Keying.setGridSize(comp, numRows, numColumns);
+                });
+              })])
+          })));
+        });
+      };
+    };
+    var renderSplitButton = function (spec, sharedBackstage) {
+      var _d;
+      var displayChannel = generate$6('channel-update-split-dropdown-display');
+      var getApi = function (comp) {
+        return {
+          isDisabled: function () {
+            return Disabling.isDisabled(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$8(underlinePath, 'fill', value);
+            });
+          },
+          setIconStroke: function (id, value) {
+            descendant(comp.element, 'svg path[id="' + id + '"], rect[id="' + id + '"]').each(function (underlinePath) {
+              set$8(underlinePath, 'stroke', value);
+            });
+          },
+          setActive: function (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);
+              });
+            });
+          },
+          isActive: function () {
+            return descendant(comp.element, 'span').exists(function (button) {
+              return comp.getSystem().getByDom(button).exists(Toggling.isOn);
+            });
+          }
+        };
+      };
+      var editorOffCell = Cell(noop);
+      var specialisation = {
+        getApi: getApi,
+        onSetup: spec.onSetup
+      };
+      return SplitDropdown.sketch({
+        dom: {
+          tag: 'div',
+          classes: ['tox-split-button'],
+          attributes: __assign({ 'aria-pressed': false }, getTooltipAttributes(spec.tooltip, sharedBackstage.providers))
+        },
+        onExecute: function (button) {
+          spec.onAction(getApi(button));
+        },
+        onItemExecute: function (_a, _b, _c) {
+        },
+        splitDropdownBehaviours: derive$1([
+          DisablingConfigs.splitButton(sharedBackstage.providers.isDisabled),
+          receivingConfig(),
+          config('split-dropdown-events', [
+            run$1(focusButtonEvent, Focusing.focus),
+            onControlAttached(specialisation, editorOffCell),
+            onControlDetached(specialisation, editorOffCell)
+          ]),
+          Unselecting.config({})
+        ]),
+        eventOrder: (_d = {}, _d[attachedToDom()] = [
+          'alloy.base.behaviour',
+          'split-dropdown-events'
+        ], _d),
+        toggleClass: 'tox-tbtn--enabled',
+        lazySink: sharedBackstage.getSink,
+        fetch: fetchChoices(getApi, spec, sharedBackstage.providers),
+        parts: { menu: part(false, spec.columns, spec.presets) },
+        components: [
+          SplitDropdown.parts.button(renderCommonStructure(spec.icon, spec.text, Optional.none(), Optional.some(displayChannel), Optional.some([Toggling.config({
+              toggleClass: 'tox-tbtn--enabled',
+              toggleOnExecute: false
+            })]), sharedBackstage.providers)),
+          SplitDropdown.parts.arrow({
+            dom: {
+              tag: 'button',
+              classes: [
+                'tox-tbtn',
+                'tox-split-button__chevron'
+              ],
+              innerHtml: get$1('chevron-down', sharedBackstage.providers.icons)
+            },
+            buttonBehaviours: derive$1([
+              DisablingConfigs.splitButton(sharedBackstage.providers.isDisabled),
+              receivingConfig(),
+              addFocusableBehaviour()
+            ])
+          }),
+          SplitDropdown.parts['aria-descriptor']({ text: sharedBackstage.providers.translate('To open the popup, press Shift+Enter') })
+        ]
+      });
+    };
+
+    var defaultToolbar = [
+      {
+        name: 'history',
+        items: [
+          'undo',
+          'redo'
+        ]
+      },
+      {
+        name: 'styles',
+        items: ['styleselect']
+      },
+      {
+        name: 'formatting',
+        items: [
+          'bold',
+          'italic'
+        ]
+      },
+      {
+        name: 'alignment',
+        items: [
+          'alignleft',
+          'aligncenter',
+          'alignright',
+          'alignjustify'
+        ]
+      },
+      {
+        name: 'indentation',
+        items: [
+          'outdent',
+          'indent'
+        ]
+      },
+      {
+        name: 'permanent pen',
+        items: ['permanentpen']
+      },
+      {
+        name: 'comments',
+        items: ['addcomment']
+      }
+    ];
+    var renderFromBridge = function (bridgeBuilder, render) {
+      return function (spec, extras, editor) {
+        var internal = bridgeBuilder(spec).mapError(function (errInfo) {
+          return formatError(errInfo);
+        }).getOrDie();
+        return render(internal, extras, editor);
+      };
+    };
+    var types = {
+      button: renderFromBridge(createToolbarButton, function (s, extras) {
+        return renderToolbarButton(s, extras.backstage.shared.providers);
+      }),
+      togglebutton: renderFromBridge(createToggleButton, function (s, extras) {
+        return renderToolbarToggleButton(s, extras.backstage.shared.providers);
+      }),
+      menubutton: renderFromBridge(createMenuButton, function (s, extras) {
+        return renderMenuButton(s, 'tox-tbtn', extras.backstage, Optional.none());
+      }),
+      splitbutton: renderFromBridge(createSplitButton, function (s, extras) {
+        return renderSplitButton(s, extras.backstage.shared);
+      }),
+      grouptoolbarbutton: renderFromBridge(createGroupToolbarButton, function (s, extras, editor) {
+        var _a;
+        var buttons = editor.ui.registry.getAll().buttons;
+        var identify = function (toolbar) {
+          return identifyButtons(editor, {
+            buttons: buttons,
+            toolbar: toolbar,
+            allowToolbarGroups: false
+          }, extras, Optional.none());
+        };
+        var attributes = (_a = {}, _a[Attribute] = extras.backstage.shared.header.isPositionedAtTop() ? AttributeValue.TopToBottom : AttributeValue.BottomToTop, _a);
+        switch (getToolbarMode(editor)) {
+        case ToolbarMode.floating:
+          return renderFloatingToolbarButton(s, extras.backstage, identify, attributes);
+        default:
+          throw new Error('Toolbar groups are only supported when using floating toolbar mode');
+        }
+      }),
+      styleSelectButton: function (editor, extras) {
+        return createStyleSelect(editor, extras.backstage);
+      },
+      fontsizeSelectButton: function (editor, extras) {
+        return createFontsizeSelect(editor, extras.backstage);
+      },
+      fontSelectButton: function (editor, extras) {
+        return createFontSelect(editor, extras.backstage);
+      },
+      formatButton: function (editor, extras) {
+        return createFormatSelect(editor, extras.backstage);
+      },
+      alignMenuButton: function (editor, extras) {
+        return createAlignSelect(editor, extras.backstage);
+      }
+    };
+    var extractFrom = function (spec, extras, editor) {
+      return get$e(types, spec.type).fold(function () {
+        console.error('skipping button defined by', spec);
+        return Optional.none();
+      }, function (render) {
+        return Optional.some(render(spec, extras, editor));
+      });
+    };
+    var bespokeButtons = {
+      styleselect: types.styleSelectButton,
+      fontsizeselect: types.fontsizeSelectButton,
+      fontselect: types.fontSelectButton,
+      formatselect: types.formatButton,
+      align: types.alignMenuButton
+    };
+    var removeUnusedDefaults = function (buttons) {
+      var filteredItemGroups = map$2(defaultToolbar, function (group) {
+        var items = filter$2(group.items, function (subItem) {
+          return has$2(buttons, subItem) || has$2(bespokeButtons, subItem);
+        });
+        return {
+          name: group.name,
+          items: items
+        };
+      });
+      return filter$2(filteredItemGroups, function (group) {
+        return group.items.length > 0;
+      });
+    };
+    var convertStringToolbar = function (strToolbar) {
+      var groupsStrings = strToolbar.split('|');
+      return map$2(groupsStrings, function (g) {
+        return { items: g.trim().split(' ') };
+      });
+    };
+    var isToolbarGroupSettingArray = function (toolbar) {
+      return isArrayOf(toolbar, function (t) {
+        return has$2(t, 'name') && has$2(t, 'items');
+      });
+    };
+    var createToolbar = function (toolbarConfig) {
+      var toolbar = toolbarConfig.toolbar;
+      var buttons = toolbarConfig.buttons;
+      if (toolbar === false) {
+        return [];
+      } else if (toolbar === undefined || toolbar === true) {
+        return removeUnusedDefaults(buttons);
+      } else if (isString(toolbar)) {
+        return convertStringToolbar(toolbar);
+      } else if (isToolbarGroupSettingArray(toolbar)) {
+        return toolbar;
+      } else {
+        console.error('Toolbar type should be string, string[], boolean or ToolbarGroup[]');
+        return [];
+      }
+    };
+    var lookupButton = function (editor, buttons, toolbarItem, allowToolbarGroups, extras, prefixes) {
+      return get$e(buttons, toolbarItem.toLowerCase()).orThunk(function () {
+        return prefixes.bind(function (ps) {
+          return findMap(ps, function (prefix) {
+            return get$e(buttons, prefix + toolbarItem.toLowerCase());
+          });
+        });
+      }).fold(function () {
+        return get$e(bespokeButtons, toolbarItem.toLowerCase()).map(function (r) {
+          return r(editor, extras);
+        }).orThunk(function () {
+          return Optional.none();
+        });
+      }, function (spec) {
+        if (spec.type === 'grouptoolbarbutton' && !allowToolbarGroups) {
+          console.warn('Ignoring the \'' + toolbarItem + '\' toolbar button. Group toolbar buttons are only supported when using floating toolbar mode and cannot be nested.');
+          return Optional.none();
+        } else {
+          return extractFrom(spec, extras, editor);
+        }
+      });
+    };
+    var identifyButtons = function (editor, toolbarConfig, extras, prefixes) {
+      var toolbarGroups = createToolbar(toolbarConfig);
+      var groups = map$2(toolbarGroups, function (group) {
+        var items = bind$3(group.items, function (toolbarItem) {
+          return toolbarItem.trim().length === 0 ? [] : lookupButton(editor, toolbarConfig.buttons, toolbarItem, toolbarConfig.allowToolbarGroups, extras, prefixes).toArray();
+        });
+        return {
+          title: Optional.from(editor.translate(group.name)),
+          items: items
+        };
+      });
+      return filter$2(groups, function (group) {
+        return group.items.length > 0;
+      });
+    };
+
+    var setToolbar = function (editor, uiComponents, rawUiConfig, backstage) {
+      var comp = uiComponents.outerContainer;
+      var toolbarConfig = rawUiConfig.toolbar;
+      var toolbarButtonsConfig = rawUiConfig.buttons;
+      if (isArrayOf(toolbarConfig, isString)) {
+        var toolbars = toolbarConfig.map(function (t) {
+          var config = {
+            toolbar: t,
+            buttons: toolbarButtonsConfig,
+            allowToolbarGroups: rawUiConfig.allowToolbarGroups
+          };
+          return identifyButtons(editor, config, { backstage: backstage }, Optional.none());
+        });
+        OuterContainer.setToolbars(comp, toolbars);
+      } else {
+        OuterContainer.setToolbar(comp, identifyButtons(editor, rawUiConfig, { backstage: backstage }, Optional.none()));
+      }
+    };
+
+    var detection = detect$1();
+    var isiOS12 = detection.os.isiOS() && detection.os.version.major <= 12;
+    var setupEvents$1 = function (editor, uiComponents) {
+      var dom = editor.dom;
+      var contentWindow = editor.getWin();
+      var initialDocEle = editor.getDoc().documentElement;
+      var lastWindowDimensions = Cell(SugarPosition(contentWindow.innerWidth, contentWindow.innerHeight));
+      var lastDocumentDimensions = Cell(SugarPosition(initialDocEle.offsetWidth, initialDocEle.offsetHeight));
+      var resizeWindow = function () {
+        var outer = lastWindowDimensions.get();
+        if (outer.left !== contentWindow.innerWidth || outer.top !== contentWindow.innerHeight) {
+          lastWindowDimensions.set(SugarPosition(contentWindow.innerWidth, contentWindow.innerHeight));
+          fireResizeContent(editor);
+        }
+      };
+      var resizeDocument = function () {
+        var docEle = editor.getDoc().documentElement;
+        var inner = lastDocumentDimensions.get();
+        if (inner.left !== docEle.offsetWidth || inner.top !== docEle.offsetHeight) {
+          lastDocumentDimensions.set(SugarPosition(docEle.offsetWidth, docEle.offsetHeight));
+          fireResizeContent(editor);
+        }
+      };
+      var scroll = function (e) {
+        return fireScrollContent(editor, e);
+      };
+      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$7(mothership, 'display', 'none');
+      });
+      editor.on('show', function () {
+        remove$6(mothership, 'display');
+      });
+      editor.on('NodeChange', resizeDocument);
+      editor.on('remove', function () {
+        elementLoad.unbind();
+        dom.unbind(contentWindow, 'resize', resizeWindow);
+        dom.unbind(contentWindow, 'scroll', scroll);
+        contentWindow = null;
+      });
+    };
+    var render$1 = function (editor, uiComponents, rawUiConfig, backstage, args) {
+      var lastToolbarWidth = Cell(0);
+      var outerContainer = uiComponents.outerContainer;
+      iframe(editor);
+      var eTargetNode = SugarElement.fromDom(args.targetNode);
+      var uiRoot = getContentContainer(getRootNode(eTargetNode));
+      attachSystemAfter(eTargetNode, uiComponents.mothership);
+      attachSystem(uiRoot, uiComponents.uiMothership);
+      editor.on('PostRender', function () {
+        setToolbar(editor, uiComponents, rawUiConfig, backstage);
+        lastToolbarWidth.set(editor.getWin().innerWidth);
+        OuterContainer.setMenubar(outerContainer, identifyMenus(editor, rawUiConfig));
+        OuterContainer.setSidebar(outerContainer, rawUiConfig.sidebar);
+        setupEvents$1(editor, uiComponents);
+      });
+      var socket = OuterContainer.getSocket(outerContainer).getOrDie('Could not find expected socket element');
+      if (isiOS12) {
+        setAll(socket.element, {
+          'overflow': 'scroll',
+          '-webkit-overflow-scrolling': 'touch'
+        });
+        var limit = first(function () {
+          editor.fire('ScrollContent');
+        }, 20);
+        var unbinder = bind(socket.element, 'scroll', limit.throttle);
+        editor.on('remove', unbinder.unbind);
+      }
+      setupReadonlyModeSwitch(editor, uiComponents);
+      editor.addCommand('ToggleSidebar', function (_ui, value) {
+        OuterContainer.toggleSidebar(outerContainer, value);
+        editor.fire('ToggleSidebar');
+      });
+      editor.addQueryValueHandler('ToggleSidebar', function () {
+        return OuterContainer.whichSidebar(outerContainer);
+      });
+      var toolbarMode = getToolbarMode(editor);
+      var refreshDrawer = function () {
+        OuterContainer.refreshToolbar(uiComponents.outerContainer);
+      };
+      if (toolbarMode === ToolbarMode.sliding || toolbarMode === ToolbarMode.floating) {
+        editor.on('ResizeWindow ResizeEditor ResizeContent', function () {
+          var width = editor.getWin().innerWidth;
+          if (width !== lastToolbarWidth.get()) {
+            refreshDrawer();
+            lastToolbarWidth.set(width);
+          }
+        });
+      }
+      var api = {
+        enable: function () {
+          broadcastReadonly(uiComponents, false);
+        },
+        disable: function () {
+          broadcastReadonly(uiComponents, true);
+        },
+        isDisabled: function () {
+          return Disabling.isDisabled(outerContainer);
+        }
+      };
+      return {
+        iframeContainer: socket.element.dom,
+        editorContainer: outerContainer.element.dom,
+        api: api
+      };
+    };
+
+    var Iframe = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        render: render$1
+    });
+
+    var parseToInt = function (val) {
+      var re = /^[0-9\.]+(|px)$/i;
+      if (re.test('' + val)) {
+        return Optional.some(parseInt('' + val, 10));
+      }
+      return Optional.none();
+    };
+    var numToPx = function (val) {
+      return isNumber(val) ? val + 'px' : val;
+    };
+    var calcCappedSize = function (size, minSize, maxSize) {
+      var minOverride = minSize.filter(function (min) {
+        return size < min;
+      });
+      var maxOverride = maxSize.filter(function (max) {
+        return size > max;
+      });
+      return minOverride.or(maxOverride).getOr(size);
+    };
+
+    var getHeight = function (editor) {
+      var baseHeight = getHeightSetting(editor);
+      var minHeight = getMinHeightSetting(editor);
+      var maxHeight = getMaxHeightSetting(editor);
+      return parseToInt(baseHeight).map(function (height) {
+        return calcCappedSize(height, minHeight, maxHeight);
+      });
+    };
+    var getHeightWithFallback = function (editor) {
+      var height = getHeight(editor);
+      return height.getOr(getHeightSetting(editor));
+    };
+    var getWidth = function (editor) {
+      var baseWidth = getWidthSetting(editor);
+      var minWidth = getMinWidthSetting(editor);
+      var maxWidth = getMaxWidthSetting(editor);
+      return parseToInt(baseWidth).map(function (width) {
+        return calcCappedSize(width, minWidth, maxWidth);
+      });
+    };
+    var getWidthWithFallback = function (editor) {
+      var width = getWidth(editor);
+      return width.getOr(getWidthSetting(editor));
+    };
+
+    var InlineHeader = function (editor, targetElm, uiComponents, backstage, floatContainer) {
+      var uiMothership = uiComponents.uiMothership, outerContainer = uiComponents.outerContainer;
+      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 toolbarMode = getToolbarMode(editor);
+      var isSplitToolbar = toolbarMode === ToolbarMode.sliding || toolbarMode === ToolbarMode.floating;
+      var visible = Cell(false);
+      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$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$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$b(doc));
+            var roomAtBottom = targetBounds.bottom < docHeight - toolbarHeight;
+            if (roomAtBottom) {
+              return 'bottom';
+            } else {
+              var winBounds = win();
+              var isRoomAtBottomViewport = winBounds.bottom < targetBounds.bottom - toolbarHeight;
+              return isRoomAtBottomViewport ? 'bottom' : 'top';
+            }
+          }
+        case ToolbarLocation.bottom:
+          return 'bottom';
+        case ToolbarLocation.top:
+        default:
+          return 'top';
+        }
+      };
+      var setupMode = function (mode) {
+        var container = floatContainer.get();
+        Docking.setModes(container, [mode]);
+        headerBackstage.setDockingMode(mode);
+        var verticalDir = isPositionedAtTop() ? AttributeValue.TopToBottom : AttributeValue.BottomToTop;
+        set$8(container.element, Attribute, verticalDir);
+      };
+      var updateChromeWidth = function () {
+        var maxWidth = editorMaxWidthOpt.getOrThunk(function () {
+          var bodyMargin = parseToInt(get$c(body(), 'margin-left')).getOr(0);
+          return get$a(body()) - absolute$3(targetElm).left + bodyMargin;
+        });
+        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$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 repositionPopups$1 = function () {
+        uiMothership.broadcastOn([repositionPopups()], {});
+      };
+      var updateChromeUi = function (resetDocking) {
+        if (resetDocking === void 0) {
+          resetDocking = false;
+        }
+        if (!isVisible()) {
+          return;
+        }
+        if (!useFixedToolbarContainer) {
+          updateChromeWidth();
+        }
+        if (isSplitToolbar) {
+          OuterContainer.refreshToolbar(outerContainer);
+        }
+        if (!useFixedToolbarContainer) {
+          updateChromePosition();
+        }
+        if (isSticky) {
+          var floatContainerComp = floatContainer.get();
+          resetDocking ? Docking.reset(floatContainerComp) : Docking.refresh(floatContainerComp);
+        }
+        repositionPopups$1();
+      };
+      var updateMode = function (updateUi) {
+        if (updateUi === void 0) {
+          updateUi = true;
+        }
+        if (useFixedToolbarContainer || !isSticky || !isVisible()) {
+          return;
+        }
+        var currentMode = headerBackstage.getDockingMode();
+        var newMode = calcMode(floatContainer.get());
+        if (newMode !== currentMode) {
+          setupMode(newMode);
+          if (updateUi) {
+            updateChromeUi(true);
+          }
+        }
+      };
+      var show = function () {
+        visible.set(true);
+        set$7(outerContainer.element, 'display', 'flex');
+        DOM.addClass(editor.getBody(), 'mce-edit-focus');
+        remove$6(uiMothership.element, 'display');
+        updateMode(false);
+        updateChromeUi();
+      };
+      var hide = function () {
+        visible.set(false);
+        if (uiComponents.outerContainer) {
+          set$7(outerContainer.element, 'display', 'none');
+          DOM.removeClass(editor.getBody(), 'mce-edit-focus');
+        }
+        set$7(uiMothership.element, 'display', 'none');
+      };
+      return {
+        isVisible: isVisible,
+        isPositionedAtTop: isPositionedAtTop,
+        show: show,
+        hide: hide,
+        update: updateChromeUi,
+        updateMode: updateMode,
+        repositionPopups: repositionPopups$1
+      };
+    };
+
+    var getTargetPosAndBounds = function (targetElm, isToolbarTop) {
+      var bounds = box$1(targetElm);
+      return {
+        pos: isToolbarTop ? bounds.y : bounds.bottom,
+        bounds: bounds
+      };
+    };
+    var setupEvents = function (editor, targetElm, ui, toolbarPersist) {
+      var prevPosAndBounds = Cell(getTargetPosAndBounds(targetElm, ui.isPositionedAtTop()));
+      var resizeContent = function (e) {
+        var _a = getTargetPosAndBounds(targetElm, ui.isPositionedAtTop()), pos = _a.pos, bounds = _a.bounds;
+        var _b = prevPosAndBounds.get(), prevPos = _b.pos, prevBounds = _b.bounds;
+        var hasResized = bounds.height !== prevBounds.height || bounds.width !== prevBounds.width;
+        prevPosAndBounds.set({
+          pos: pos,
+          bounds: bounds
+        });
+        if (hasResized) {
+          fireResizeContent(editor, e);
+        }
+        if (ui.isVisible()) {
+          if (prevPos !== pos) {
+            ui.update(true);
+          } else if (hasResized) {
+            ui.updateMode();
+            ui.repositionPopups();
+          }
+        }
+      };
+      if (!toolbarPersist) {
+        editor.on('activate', ui.show);
+        editor.on('deactivate', ui.hide);
+      }
+      editor.on('SkinLoaded ResizeWindow', function () {
+        return ui.update(true);
+      });
+      editor.on('NodeChange keydown', function (e) {
+        global$f.requestAnimationFrame(function () {
+          return resizeContent(e);
+        });
+      });
+      editor.on('ScrollWindow', function () {
+        return ui.updateMode();
+      });
+      var elementLoad = unbindable();
+      elementLoad.set(capture(SugarElement.fromDom(editor.getBody()), 'load', resizeContent));
+      editor.on('remove', function () {
+        elementLoad.clear();
+      });
+    };
+    var render = function (editor, uiComponents, rawUiConfig, backstage, args) {
+      var mothership = uiComponents.mothership, uiMothership = uiComponents.uiMothership, outerContainer = uiComponents.outerContainer;
+      var floatContainer = Cell(null);
+      var targetElm = SugarElement.fromDom(args.targetNode);
+      var ui = InlineHeader(editor, targetElm, uiComponents, backstage, floatContainer);
+      var toolbarPersist = isToolbarPersist(editor);
+      inline(editor);
+      var render = function () {
+        if (floatContainer.get()) {
+          ui.show();
+          return;
+        }
+        floatContainer.set(OuterContainer.getHeader(outerContainer).getOrDie());
+        var uiContainer = getUiContainer(editor);
+        attachSystem(uiContainer, mothership);
+        attachSystem(uiContainer, uiMothership);
+        setToolbar(editor, uiComponents, rawUiConfig, backstage);
+        OuterContainer.setMenubar(outerContainer, identifyMenus(editor, rawUiConfig));
+        ui.show();
+        setupEvents(editor, targetElm, ui, toolbarPersist);
+        editor.nodeChanged();
+      };
+      editor.on('show', render);
+      editor.on('hide', ui.hide);
+      if (!toolbarPersist) {
+        editor.on('focus', render);
+        editor.on('blur', ui.hide);
+      }
+      editor.on('init', function () {
+        if (editor.hasFocus() || toolbarPersist) {
+          render();
+        }
+      });
+      setupReadonlyModeSwitch(editor, uiComponents);
+      var api = {
+        show: function () {
+          ui.show();
+        },
+        hide: function () {
+          ui.hide();
+        },
+        enable: function () {
+          broadcastReadonly(uiComponents, false);
+        },
+        disable: function () {
+          broadcastReadonly(uiComponents, true);
+        },
+        isDisabled: function () {
+          return Disabling.isDisabled(outerContainer);
+        }
+      };
+      return {
+        editorContainer: outerContainer.element.dom,
+        api: api
+      };
+    };
+
+    var Inline = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        render: render
+    });
+
+    var showContextToolbarEvent = 'contexttoolbar-show';
+    var hideContextToolbarEvent = 'contexttoolbar-hide';
+
+    var getFormApi = function (input) {
+      return {
+        hide: function () {
+          return emit(input, sandboxClose());
+        },
+        getValue: function () {
+          return Representing.getValue(input);
+        }
+      };
+    };
+    var runOnExecute = function (memInput, original) {
+      return run$1(internalToolbarButtonExecute, function (comp, se) {
+        var input = memInput.get(comp);
+        var formApi = getFormApi(input);
+        original.onAction(formApi, se.event.buttonApi);
+      });
+    };
+    var renderContextButton = function (memInput, button, extras) {
+      var _a = button.original; _a.primary; var rest = __rest(_a, ['primary']);
+      var bridged = getOrDie(createToolbarButton(__assign(__assign({}, rest), {
+        type: 'button',
+        onAction: noop
+      })));
+      return renderToolbarButtonWith(bridged, extras.backstage.shared.providers, [runOnExecute(memInput, button)]);
+    };
+    var renderContextToggleButton = function (memInput, button, extras) {
+      var _a = button.original; _a.primary; var rest = __rest(_a, ['primary']);
+      var bridged = getOrDie(createToggleButton(__assign(__assign({}, rest), {
+        type: 'togglebutton',
+        onAction: noop
+      })));
+      return renderToolbarToggleButtonWith(bridged, extras.backstage.shared.providers, [runOnExecute(memInput, button)]);
+    };
+    var generateOne = function (memInput, button, providersBackstage) {
+      var extras = { backstage: { shared: { providers: providersBackstage } } };
+      if (button.type === 'contextformtogglebutton') {
+        return renderContextToggleButton(memInput, button, extras);
+      } else {
+        return renderContextButton(memInput, button, extras);
+      }
+    };
+    var generate = function (memInput, buttons, providersBackstage) {
+      var mementos = map$2(buttons, function (button) {
+        return record(generateOne(memInput, button, providersBackstage));
+      });
+      var asSpecs = function () {
+        return map$2(mementos, function (mem) {
+          return mem.asSpec();
+        });
+      };
+      var findPrimary = function (compInSystem) {
+        return findMap(buttons, function (button, i) {
+          if (button.primary) {
+            return Optional.from(mementos[i]).bind(function (mem) {
+              return mem.getOpt(compInSystem);
+            }).filter(not(Disabling.isDisabled));
+          } else {
+            return Optional.none();
+          }
+        });
+      };
+      return {
+        asSpecs: asSpecs,
+        findPrimary: findPrimary
+      };
+    };
+
+    var buildInitGroups = function (ctx, providers) {
+      var inputAttributes = ctx.label.fold(function () {
+        return {};
+      }, function (label) {
+        return { 'aria-label': label };
+      });
+      var memInput = record(Input.sketch({
+        inputClasses: [
+          'tox-toolbar-textfield',
+          'tox-toolbar-nav-js'
+        ],
+        data: ctx.initValue(),
+        inputAttributes: inputAttributes,
+        selectOnFocus: true,
+        inputBehaviours: derive$1([Keying.config({
+            mode: 'special',
+            onEnter: function (input) {
+              return commands.findPrimary(input).map(function (primary) {
+                emitExecute(primary);
+                return true;
+              });
+            },
+            onLeft: function (comp, se) {
+              se.cut();
+              return Optional.none();
+            },
+            onRight: function (comp, se) {
+              se.cut();
+              return Optional.none();
+            }
+          })])
+      }));
+      var commands = generate(memInput, ctx.commands, providers);
+      return [
+        {
+          title: Optional.none(),
+          items: [memInput.asSpec()]
+        },
+        {
+          title: Optional.none(),
+          items: commands.asSpecs()
+        }
+      ];
+    };
+    var renderContextForm = function (toolbarType, ctx, providers) {
+      return renderToolbar({
+        type: toolbarType,
+        uid: generate$6('context-toolbar'),
+        initGroups: buildInitGroups(ctx, providers),
+        onEscape: Optional.none,
+        cyclicKeying: true,
+        providers: providers
+      });
+    };
+    var ContextForm = {
+      renderContextForm: renderContextForm,
+      buildInitGroups: buildInitGroups
+    };
+
+    var isVerticalOverlap = function (a, b, threshold) {
+      if (threshold === void 0) {
+        threshold = 0.01;
+      }
+      return b.bottom - a.y >= threshold && a.bottom - b.y >= threshold;
+    };
+    var getRangeRect = function (rng) {
+      var rect = rng.getBoundingClientRect();
+      if (rect.height <= 0 && rect.width <= 0) {
+        var leaf$1 = leaf(SugarElement.fromDom(rng.startContainer), rng.startOffset).element;
+        var elm = isText$1(leaf$1) ? parent(leaf$1) : Optional.some(leaf$1);
+        return elm.filter(isElement$2).map(function (e) {
+          return e.dom.getBoundingClientRect();
+        }).getOr(rect);
+      } else {
+        return rect;
+      }
+    };
+    var getSelectionBounds = function (editor) {
+      var rng = editor.selection.getRng();
+      var rect = getRangeRect(rng);
+      if (editor.inline) {
+        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 getAnchorElementBounds = function (editor, lastElement) {
+      return lastElement.filter(inBody).map(absolute$2).getOrThunk(function () {
+        return getSelectionBounds(editor);
+      });
+    };
+    var getHorizontalBounds = function (contentAreaBox, viewportBounds, margin) {
+      var x = Math.max(contentAreaBox.x + margin, viewportBounds.x);
+      var right = Math.min(contentAreaBox.right - margin, viewportBounds.right);
+      return {
+        x: x,
+        width: right - x
+      };
+    };
+    var getVerticalBounds = function (editor, contentAreaBox, viewportBounds, isToolbarLocationTop, toolbarType, margin) {
+      var container = SugarElement.fromDom(editor.getContainer());
+      var header = descendant(container, '.tox-editor-header').getOr(container);
+      var headerBox = box$1(header);
+      var isToolbarBelowContentArea = headerBox.y >= contentAreaBox.bottom;
+      var isToolbarAbove = isToolbarLocationTop && !isToolbarBelowContentArea;
+      if (editor.inline && isToolbarAbove) {
+        return {
+          y: Math.max(headerBox.bottom + margin, viewportBounds.y),
+          bottom: viewportBounds.bottom
+        };
+      }
+      if (editor.inline && !isToolbarAbove) {
+        return {
+          y: viewportBounds.y,
+          bottom: Math.min(headerBox.y - margin, viewportBounds.bottom)
+        };
+      }
+      var containerBounds = toolbarType === 'line' ? box$1(container) : contentAreaBox;
+      if (isToolbarAbove) {
+        return {
+          y: Math.max(headerBox.bottom + margin, viewportBounds.y),
+          bottom: Math.min(containerBounds.bottom - margin, viewportBounds.bottom)
+        };
+      }
+      return {
+        y: Math.max(containerBounds.y + margin, viewportBounds.y),
+        bottom: Math.min(headerBox.y - margin, viewportBounds.bottom)
+      };
+    };
+    var getContextToolbarBounds = function (editor, sharedBackstage, toolbarType, margin) {
+      if (margin === void 0) {
+        margin = 0;
+      }
+      var viewportBounds = getBounds$3(window);
+      var contentAreaBox = box$1(SugarElement.fromDom(editor.getContentAreaContainer()));
+      var toolbarOrMenubarEnabled = isMenubarEnabled(editor) || isToolbarEnabled(editor) || isMultipleToolbars(editor);
+      var _a = getHorizontalBounds(contentAreaBox, viewportBounds, margin), x = _a.x, width = _a.width;
+      if (editor.inline && !toolbarOrMenubarEnabled) {
+        return bounds(x, viewportBounds.y, width, viewportBounds.height);
+      } else {
+        var isToolbarTop = sharedBackstage.header.isPositionedAtTop();
+        var _b = getVerticalBounds(editor, contentAreaBox, viewportBounds, isToolbarTop, toolbarType, margin), y = _b.y, bottom = _b.bottom;
+        return bounds(x, y, width, bottom - y);
+      }
+    };
+
+    var bubbleSize$1 = 12;
+    var bubbleAlignments$1 = {
+      valignCentre: [],
+      alignCentre: [],
+      alignLeft: ['tox-pop--align-left'],
+      alignRight: ['tox-pop--align-right'],
+      right: ['tox-pop--right'],
+      left: ['tox-pop--left'],
+      bottom: ['tox-pop--bottom'],
+      top: ['tox-pop--top'],
+      inset: ['tox-pop--inset']
+    };
+    var anchorOverrides = {
+      maxHeightFunction: expandable$1(),
+      maxWidthFunction: expandable()
+    };
+    var isEntireElementSelected = function (editor, elem) {
+      var rng = editor.selection.getRng();
+      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$7(elem, 'position', position);
+      var result = f(elem);
+      currentPosition.each(function (pos) {
+        return set$7(elem, 'position', pos);
+      });
+      return result;
+    };
+    var shouldUseInsetLayouts = function (position) {
+      return position === 'node';
+    };
+    var determineInsetLayout = function (editor, contextbar, elem, data, bounds) {
+      var selectionBounds = getSelectionBounds(editor);
+      var isSameAnchorElement = data.lastElement().exists(function (prev) {
+        return eq(elem, prev);
+      });
+      if (isEntireElementSelected(editor, elem)) {
+        return isSameAnchorElement ? preserve : north;
+      } else if (isSameAnchorElement) {
+        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$9().top : bounds.y;
+        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) {
+        return function (anchor, element, bubbles, placee, bounds) {
+          var layout = determineInsetLayout(editor, placee, elem, data, bounds);
+          var newAnchor = __assign(__assign({}, anchor), {
+            y: bounds.y,
+            height: bounds.height
+          });
+          return __assign(__assign({}, layout(newAnchor, element, bubbles, placee, bounds)), { alwaysFit: true });
+        };
+      };
+      var getInsetLayouts = function (elem) {
+        return shouldUseInsetLayouts(position) ? [smartInsetLayout(elem)] : [];
+      };
+      var desktopAnchorSpecLayouts = {
+        onLtr: function (elem) {
+          return [
+            north$2,
+            south$2,
+            northeast$2,
+            southeast$2,
+            northwest$2,
+            southwest$2
+          ].concat(getInsetLayouts(elem));
+        },
+        onRtl: function (elem) {
+          return [
+            north$2,
+            south$2,
+            northwest$2,
+            southwest$2,
+            northeast$2,
+            southeast$2
+          ].concat(getInsetLayouts(elem));
+        }
+      };
+      var mobileAnchorSpecLayouts = {
+        onLtr: function (elem) {
+          return [
+            south$2,
+            southeast$2,
+            southwest$2,
+            northeast$2,
+            northwest$2,
+            north$2
+          ].concat(getInsetLayouts(elem));
+        },
+        onRtl: function (elem) {
+          return [
+            south$2,
+            southwest$2,
+            southeast$2,
+            northwest$2,
+            northeast$2,
+            north$2
+          ].concat(getInsetLayouts(elem));
+        }
+      };
+      return mobile ? mobileAnchorSpecLayouts : desktopAnchorSpecLayouts;
+    };
+    var getAnchorLayout = function (editor, position, isTouch, data) {
+      if (position === 'line') {
+        return {
+          bubble: nu$5(bubbleSize$1, 0, bubbleAlignments$1),
+          layouts: {
+            onLtr: function () {
+              return [east$2];
+            },
+            onRtl: function () {
+              return [west$2];
+            }
+          },
+          overrides: anchorOverrides
+        };
+      } else {
+        return {
+          bubble: nu$5(0, bubbleSize$1, bubbleAlignments$1, 1 / bubbleSize$1),
+          layouts: getAnchorSpec$2(editor, isTouch, data, position),
+          overrides: anchorOverrides
+        };
+      }
+    };
+
+    var matchTargetWith = function (elem, candidates) {
+      var ctxs = filter$2(candidates, function (toolbarApi) {
+        return toolbarApi.predicate(elem.dom);
+      });
+      var _a = partition$3(ctxs, function (t) {
+          return t.type === 'contexttoolbar';
+        }), pass = _a.pass, fail = _a.fail;
+      return {
+        contextToolbars: pass,
+        contextForms: fail
+      };
+    };
+    var filterByPositionForStartNode = function (toolbars) {
+      if (toolbars.length <= 1) {
+        return toolbars;
+      } else {
+        var doesPositionExist = function (value) {
+          return exists(toolbars, function (t) {
+            return t.position === value;
+          });
+        };
+        var filterToolbarsByPosition = function (value) {
+          return filter$2(toolbars, function (t) {
+            return t.position === value;
+          });
+        };
+        var hasSelectionToolbars = doesPositionExist('selection');
+        var hasNodeToolbars = doesPositionExist('node');
+        if (hasSelectionToolbars || hasNodeToolbars) {
+          if (hasNodeToolbars && hasSelectionToolbars) {
+            var nodeToolbars = filterToolbarsByPosition('node');
+            var selectionToolbars = map$2(filterToolbarsByPosition('selection'), function (t) {
+              return __assign(__assign({}, t), { position: 'node' });
+            });
+            return nodeToolbars.concat(selectionToolbars);
+          } else {
+            return hasSelectionToolbars ? filterToolbarsByPosition('selection') : filterToolbarsByPosition('node');
+          }
+        } else {
+          return filterToolbarsByPosition('line');
+        }
+      }
+    };
+    var filterByPositionForAncestorNode = function (toolbars) {
+      if (toolbars.length <= 1) {
+        return toolbars;
+      } else {
+        var findPosition_1 = function (value) {
+          return find$5(toolbars, function (t) {
+            return t.position === value;
+          });
+        };
+        var basePosition = findPosition_1('selection').orThunk(function () {
+          return findPosition_1('node');
+        }).orThunk(function () {
+          return findPosition_1('line');
+        }).map(function (t) {
+          return t.position;
+        });
+        return basePosition.fold(function () {
+          return [];
+        }, function (pos) {
+          return filter$2(toolbars, function (t) {
+            return t.position === pos;
+          });
+        });
+      }
+    };
+    var matchStartNode = function (elem, nodeCandidates, editorCandidates) {
+      var nodeMatches = matchTargetWith(elem, nodeCandidates);
+      if (nodeMatches.contextForms.length > 0) {
+        return Optional.some({
+          elem: elem,
+          toolbars: [nodeMatches.contextForms[0]]
+        });
+      } else {
+        var editorMatches = matchTargetWith(elem, editorCandidates);
+        if (editorMatches.contextForms.length > 0) {
+          return Optional.some({
+            elem: elem,
+            toolbars: [editorMatches.contextForms[0]]
+          });
+        } else if (nodeMatches.contextToolbars.length > 0 || editorMatches.contextToolbars.length > 0) {
+          var toolbars = filterByPositionForStartNode(nodeMatches.contextToolbars.concat(editorMatches.contextToolbars));
+          return Optional.some({
+            elem: elem,
+            toolbars: toolbars
+          });
+        } else {
+          return Optional.none();
+        }
+      }
+    };
+    var matchAncestor = function (isRoot, startNode, scopes) {
+      if (isRoot(startNode)) {
+        return Optional.none();
+      } else {
+        return ancestor$2(startNode, function (ancestorElem) {
+          if (isElement$2(ancestorElem)) {
+            var _a = matchTargetWith(ancestorElem, scopes.inNodeScope), contextToolbars = _a.contextToolbars, contextForms = _a.contextForms;
+            var toolbars = contextForms.length > 0 ? contextForms : filterByPositionForAncestorNode(contextToolbars);
+            return toolbars.length > 0 ? Optional.some({
+              elem: ancestorElem,
+              toolbars: toolbars
+            }) : Optional.none();
+          } else {
+            return Optional.none();
+          }
+        }, isRoot);
+      }
+    };
+    var lookup$1 = function (scopes, editor) {
+      var rootElem = SugarElement.fromDom(editor.getBody());
+      var isRoot = function (elem) {
+        return eq(elem, rootElem);
+      };
+      var isOutsideRoot = function (startNode) {
+        return !isRoot(startNode) && !contains(rootElem, startNode);
+      };
+      var startNode = SugarElement.fromDom(editor.selection.getNode());
+      if (isOutsideRoot(startNode)) {
+        return Optional.none();
+      }
+      return matchStartNode(startNode, scopes.inNodeScope, scopes.inEditorScope).orThunk(function () {
+        return matchAncestor(isRoot, startNode, scopes);
+      });
+    };
+
+    var categorise = function (contextToolbars, navigate) {
+      var forms = {};
+      var inNodeScope = [];
+      var inEditorScope = [];
+      var formNavigators = {};
+      var lookupTable = {};
+      var registerForm = function (key, toolbarSpec) {
+        var contextForm = getOrDie(createContextForm(toolbarSpec));
+        forms[key] = contextForm;
+        contextForm.launch.map(function (launch) {
+          formNavigators['form:' + key + ''] = __assign(__assign({}, toolbarSpec.launch), {
+            type: launch.type === 'contextformtogglebutton' ? 'togglebutton' : 'button',
+            onAction: function () {
+              navigate(contextForm);
+            }
+          });
+        });
+        if (contextForm.scope === 'editor') {
+          inEditorScope.push(contextForm);
+        } else {
+          inNodeScope.push(contextForm);
+        }
+        lookupTable[key] = contextForm;
+      };
+      var registerToolbar = function (key, toolbarSpec) {
+        createContextToolbar(toolbarSpec).each(function (contextToolbar) {
+          if (toolbarSpec.scope === 'editor') {
+            inEditorScope.push(contextToolbar);
+          } else {
+            inNodeScope.push(contextToolbar);
+          }
+          lookupTable[key] = contextToolbar;
+        });
+      };
+      var keys$1 = keys(contextToolbars);
+      each$1(keys$1, function (key) {
+        var toolbarApi = contextToolbars[key];
+        if (toolbarApi.type === 'contextform') {
+          registerForm(key, toolbarApi);
+        } else if (toolbarApi.type === 'contexttoolbar') {
+          registerToolbar(key, toolbarApi);
+        }
+      });
+      return {
+        forms: forms,
+        inNodeScope: inNodeScope,
+        inEditorScope: inEditorScope,
+        lookupTable: lookupTable,
+        formNavigators: formNavigators
+      };
+    };
+
+    var forwardSlideEvent = generate$6('forward-slide');
+    var backSlideEvent = generate$6('backward-slide');
+    var changeSlideEvent = generate$6('change-slide-event');
+    var resizingClass = 'tox-pop--resizing';
+    var renderContextToolbar = function (spec) {
+      var stack = Cell([]);
+      return InlineView.sketch({
+        dom: {
+          tag: 'div',
+          classes: ['tox-pop']
+        },
+        fireDismissalEventInstead: { event: 'doNotDismissYet' },
+        onShow: function (comp) {
+          stack.set([]);
+          InlineView.getContent(comp).each(function (c) {
+            remove$6(c.element, 'visibility');
+          });
+          remove$2(comp.element, resizingClass);
+          remove$6(comp.element, 'width');
+        },
+        inlineBehaviours: derive$1([
+          config('context-toolbar-events', [
+            runOnSource(transitionend(), function (comp, se) {
+              if (se.event.raw.propertyName === 'width') {
+                remove$2(comp.element, resizingClass);
+                remove$6(comp.element, 'width');
+              }
+            }),
+            run$1(changeSlideEvent, function (comp, se) {
+              var elem = comp.element;
+              remove$6(elem, 'width');
+              var currentWidth = get$a(elem);
+              InlineView.setContent(comp, se.event.contents);
+              add$2(elem, resizingClass);
+              var newWidth = get$a(elem);
+              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$f.setTimeout(function () {
+                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([{
+                    bar: oldContents,
+                    focus: active(getRootNode(comp.element))
+                  }]));
+              });
+              emitWith(comp, changeSlideEvent, {
+                contents: se.event.forwardContents,
+                focus: Optional.none()
+              });
+            }),
+            run$1(backSlideEvent, function (comp, _se) {
+              last$2(stack.get()).each(function (last) {
+                stack.set(stack.get().slice(0, stack.get().length - 1));
+                emitWith(comp, changeSlideEvent, {
+                  contents: premade(last.bar),
+                  focus: last.focus
+                });
+              });
+            })
+          ]),
+          Keying.config({
+            mode: 'special',
+            onEscape: function (comp) {
+              return last$2(stack.get()).fold(function () {
+                return spec.onEscape();
+              }, function (_) {
+                emit(comp, backSlideEvent);
+                return Optional.some(true);
+              });
+            }
+          })
+        ]),
+        lazySink: function () {
+          return Result.value(spec.sink);
+        }
+      });
+    };
+
+    var transitionClass = 'tox-pop--transition';
+    var register$7 = function (editor, registryContextToolbars, sink, extras) {
+      var backstage = extras.backstage;
+      var sharedBackstage = backstage.shared;
+      var isTouch = detect$1().deviceType.isTouch;
+      var lastElement = value$1();
+      var lastTrigger = value$1();
+      var lastContextPosition = value$1();
+      var contextbar = build$1(renderContextToolbar({
+        sink: sink,
+        onEscape: function () {
+          editor.focus();
+          return Optional.some(true);
+        }
+      }));
+      var getBounds = function () {
+        var position = lastContextPosition.get().getOr('node');
+        var margin = shouldUseInsetLayouts(position) ? 1 : 0;
+        return getContextToolbarBounds(editor, sharedBackstage, position, margin);
+      };
+      var canLaunchToolbar = function () {
+        return !editor.removed && !(isTouch() && backstage.isContextMenuOpen());
+      };
+      var isSameLaunchElement = function (elem) {
+        return is$1(lift2(elem, lastElement.get(), eq), true);
+      };
+      var shouldContextToolbarHide = function () {
+        if (!canLaunchToolbar()) {
+          return true;
+        } else {
+          var contextToolbarBounds = getBounds();
+          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();
+        lastTrigger.clear();
+        lastContextPosition.clear();
+        InlineView.hide(contextbar);
+      };
+      var hideOrRepositionIfNecessary = function () {
+        if (InlineView.isOpen(contextbar)) {
+          var contextBarEle = contextbar.element;
+          remove$6(contextBarEle, 'display');
+          if (shouldContextToolbarHide()) {
+            set$7(contextBarEle, 'display', 'none');
+          } else {
+            lastTrigger.set(0);
+            InlineView.reposition(contextbar);
+          }
+        }
+      };
+      var wrapInPopDialog = function (toolbarSpec) {
+        return {
+          dom: {
+            tag: 'div',
+            classes: ['tox-pop__dialog']
+          },
+          components: [toolbarSpec],
+          behaviours: derive$1([
+            Keying.config({ mode: 'acyclic' }),
+            config('pop-dialog-wrap-events', [
+              runOnAttached(function (comp) {
+                editor.shortcuts.add('ctrl+F9', 'focus statusbar', function () {
+                  return Keying.focusIn(comp);
+                });
+              }),
+              runOnDetached(function (_comp) {
+                editor.shortcuts.remove('ctrl+F9');
+              })
+            ])
+          ])
+        };
+      };
+      var getScopes = cached(function () {
+        return categorise(registryContextToolbars, function (toolbarApi) {
+          var alloySpec = buildToolbar([toolbarApi]);
+          emitWith(contextbar, forwardSlideEvent, { forwardContents: wrapInPopDialog(alloySpec) });
+        });
+      });
+      var buildContextToolbarGroups = function (allButtons, ctx) {
+        return identifyButtons(editor, {
+          buttons: allButtons,
+          toolbar: ctx.items,
+          allowToolbarGroups: false
+        }, extras, Optional.some(['form:']));
+      };
+      var buildContextFormGroups = function (ctx, providers) {
+        return ContextForm.buildInitGroups(ctx, providers);
+      };
+      var buildToolbar = function (toolbars) {
+        var buttons = editor.ui.registry.getAll().buttons;
+        var scopes = getScopes();
+        var allButtons = __assign(__assign({}, buttons), scopes.formNavigators);
+        var toolbarType = getToolbarMode(editor) === ToolbarMode.scrolling ? ToolbarMode.scrolling : ToolbarMode.default;
+        var initGroups = flatten(map$2(toolbars, function (ctx) {
+          return ctx.type === 'contexttoolbar' ? buildContextToolbarGroups(allButtons, ctx) : buildContextFormGroups(ctx, sharedBackstage.providers);
+        }));
+        return renderToolbar({
+          type: toolbarType,
+          uid: generate$6('context-toolbar'),
+          initGroups: initGroups,
+          onEscape: Optional.none,
+          cyclicKeying: true,
+          providers: sharedBackstage.providers
+        });
+      };
+      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$1(lastTrigger.get(), 0);
+          },
+          getMode: function () {
+            return Positioning.getMode(sink);
+          }
+        });
+        return deepMerge(anchorage, anchorLayout);
+      };
+      var launchContext = function (toolbarApi, elem) {
+        launchContextToolbar.cancel();
+        if (!canLaunchToolbar()) {
+          return;
+        }
+        var toolbarSpec = buildToolbar(toolbarApi);
+        var position = toolbarApi[0].position;
+        var anchor = getAnchor(position, elem);
+        lastContextPosition.set(position);
+        lastTrigger.set(1);
+        var contextBarEle = contextbar.element;
+        remove$6(contextBarEle, 'display');
+        if (!isSameLaunchElement(elem)) {
+          remove$2(contextBarEle, transitionClass);
+          Positioning.reset(sink, contextbar);
+        }
+        InlineView.showWithinBounds(contextbar, wrapInPopDialog(toolbarSpec), {
+          anchor: anchor,
+          transition: {
+            classes: [transitionClass],
+            mode: 'placement'
+          }
+        }, function () {
+          return Optional.some(getBounds());
+        });
+        elem.fold(lastElement.clear, lastElement.set);
+        if (shouldContextToolbarHide()) {
+          set$7(contextBarEle, 'display', 'none');
+        }
+      };
+      var launchContextToolbar = last(function () {
+        if (!editor.hasFocus() || editor.removed) {
+          return;
+        }
+        if (has(contextbar.element, transitionClass)) {
+          launchContextToolbar.throttle();
+        } else {
+          var scopes = getScopes();
+          lookup$1(scopes, editor).fold(close, function (info) {
+            launchContext(info.toolbars, Optional.some(info.elem));
+          });
+        }
+      }, 17);
+      editor.on('init', function () {
+        editor.on('remove', close);
+        editor.on('ScrollContent ScrollWindow ObjectResized ResizeEditor longpress', hideOrRepositionIfNecessary);
+        editor.on('click keyup focus SetContent', launchContextToolbar.throttle);
+        editor.on(hideContextToolbarEvent, close);
+        editor.on(showContextToolbarEvent, function (e) {
+          var scopes = getScopes();
+          get$e(scopes.lookupTable, e.toolbarKey).each(function (ctx) {
+            launchContext([ctx], someIf(e.target !== editor, e.target));
+            InlineView.getContent(contextbar).each(Keying.focusIn);
+          });
+        });
+        editor.on('focusout', function (_e) {
+          global$f.setEditorTimeout(editor, function () {
+            if (search(sink.element).isNone() && search(contextbar.element).isNone()) {
+              close();
+            }
+          }, 0);
+        });
+        editor.on('SwitchMode', function () {
+          if (editor.mode.isReadOnly()) {
+            close();
+          }
+        });
+        editor.on('AfterProgressState', function (event) {
+          if (event.state) {
+            close();
+          } else if (editor.hasFocus()) {
+            launchContextToolbar.throttle();
+          }
+        });
+        editor.on('NodeChange', function (_e) {
+          search(contextbar.element).fold(launchContextToolbar.throttle, noop);
+        });
+      });
+    };
+
+    var register$6 = function (editor) {
+      var alignToolbarButtons = [
+        {
+          name: 'alignleft',
+          text: 'Align left',
+          cmd: 'JustifyLeft',
+          icon: 'align-left'
+        },
+        {
+          name: 'aligncenter',
+          text: 'Align center',
+          cmd: 'JustifyCenter',
+          icon: 'align-center'
+        },
+        {
+          name: 'alignright',
+          text: 'Align right',
+          cmd: 'JustifyRight',
+          icon: 'align-right'
+        },
+        {
+          name: 'alignjustify',
+          text: 'Justify',
+          cmd: 'JustifyFull',
+          icon: 'align-justify'
+        }
+      ];
+      each$1(alignToolbarButtons, function (item) {
+        editor.ui.registry.addToggleButton(item.name, {
+          tooltip: item.text,
+          icon: item.icon,
+          onAction: onActionExecCommand(editor, item.cmd),
+          onSetup: onSetupFormatToggle(editor, item.name)
+        });
+      });
+      editor.ui.registry.addButton('alignnone', {
+        tooltip: 'No alignment',
+        icon: 'align-none',
+        onAction: onActionExecCommand(editor, 'JustifyNone')
+      });
+    };
+
+    var units = {
+      unsupportedLength: [
+        'em',
+        'ex',
+        'cap',
+        'ch',
+        'ic',
+        'rem',
+        'lh',
+        'rlh',
+        'vw',
+        'vh',
+        'vi',
+        'vb',
+        'vmin',
+        'vmax',
+        'cm',
+        'mm',
+        'Q',
+        'in',
+        'pc',
+        'pt',
+        'px'
+      ],
+      fixed: [
+        'px',
+        'pt'
+      ],
+      relative: ['%'],
+      empty: ['']
+    };
+    var pattern = function () {
+      var decimalDigits = '[0-9]+';
+      var signedInteger = '[+-]?' + decimalDigits;
+      var exponentPart = '[eE]' + signedInteger;
+      var dot = '\\.';
+      var opt = function (input) {
+        return '(?:' + input + ')?';
+      };
+      var unsignedDecimalLiteral = [
+        'Infinity',
+        decimalDigits + dot + opt(decimalDigits) + opt(exponentPart),
+        dot + decimalDigits + opt(exponentPart),
+        decimalDigits + opt(exponentPart)
+      ].join('|');
+      var float = '[+-]?(?:' + unsignedDecimalLiteral + ')';
+      return new RegExp('^(' + float + ')(.*)$');
+    }();
+    var isUnit = function (unit, accepted) {
+      return exists(accepted, function (acc) {
+        return exists(units[acc], function (check) {
+          return unit === check;
+        });
+      });
+    };
+    var parse = function (input, accepted) {
+      var match = Optional.from(pattern.exec(input));
+      return match.bind(function (array) {
+        var value = Number(array[1]);
+        var unitRaw = array[2];
+        if (isUnit(unitRaw, accepted)) {
+          return Optional.some({
+            value: value,
+            unit: unitRaw
+          });
+        } else {
+          return Optional.none();
+        }
+      });
+    };
+    var normalise = function (input, accepted) {
+      return parse(input, accepted).map(function (_a) {
+        var value = _a.value, unit = _a.unit;
+        return value + unit;
+      });
+    };
+
+    var registerController = function (editor, spec) {
+      var getMenuItems = function () {
+        var options = spec.getOptions(editor);
+        var initial = spec.getCurrent(editor).map(spec.hash);
+        var current = value$1();
+        return map$2(options, function (value) {
+          return {
+            type: 'togglemenuitem',
+            text: spec.display(value),
+            onSetup: function (api) {
+              var setActive = function (active) {
+                if (active) {
+                  current.on(function (oldApi) {
+                    return oldApi.setActive(false);
+                  });
+                  current.set(api);
+                }
+                api.setActive(active);
+              };
+              setActive(is$1(initial, spec.hash(value)));
+              var unbindWatcher = spec.watcher(editor, value, setActive);
+              return function () {
+                current.clear();
+                unbindWatcher();
+              };
+            },
+            onAction: function () {
+              return spec.setCurrent(editor, value);
+            }
+          };
+        });
+      };
+      editor.ui.registry.addMenuButton(spec.name, {
+        tooltip: spec.text,
+        icon: spec.icon,
+        fetch: function (callback) {
+          return callback(getMenuItems());
+        },
+        onSetup: spec.onToolbarSetup
+      });
+      editor.ui.registry.addNestedMenuItem(spec.name, {
+        type: 'nestedmenuitem',
+        text: spec.text,
+        getSubmenuItems: getMenuItems,
+        onSetup: spec.onMenuSetup
+      });
+    };
+    var lineHeightSpec = {
+      name: 'lineheight',
+      text: 'Line height',
+      icon: 'line-height',
+      getOptions: getLineHeightFormats,
+      hash: function (input) {
+        return normalise(input, [
+          'fixed',
+          'relative',
+          'empty'
+        ]).getOr(input);
+      },
+      display: identity$1,
+      watcher: function (editor, value, callback) {
+        return editor.formatter.formatChanged('lineheight', callback, false, { value: value }).unbind;
+      },
+      getCurrent: function (editor) {
+        return Optional.from(editor.queryCommandValue('LineHeight'));
+      },
+      setCurrent: function (editor, value) {
+        return editor.execCommand('LineHeight', false, value);
+      }
+    };
+    var languageSpec = function (editor) {
+      var settingsOpt = Optional.from(getContentLanguages(editor));
+      return settingsOpt.map(function (settings) {
+        return {
+          name: 'language',
+          text: 'Language',
+          icon: 'language',
+          getOptions: constant$1(settings),
+          hash: function (input) {
+            return isUndefined(input.customCode) ? input.code : input.code + '/' + input.customCode;
+          },
+          display: function (input) {
+            return input.title;
+          },
+          watcher: function (editor, value, callback) {
+            return editor.formatter.formatChanged('lang', callback, false, {
+              value: value.code,
+              customValue: value.customCode
+            }).unbind;
+          },
+          getCurrent: function (editor) {
+            var node = SugarElement.fromDom(editor.selection.getNode());
+            return closest$4(node, function (n) {
+              return Optional.some(n).filter(isElement$2).bind(function (ele) {
+                var codeOpt = getOpt(ele, 'lang');
+                return codeOpt.map(function (code) {
+                  var customCode = getOpt(ele, 'data-mce-lang').getOrUndefined();
+                  return {
+                    code: code,
+                    customCode: customCode,
+                    title: ''
+                  };
+                });
+              });
+            });
+          },
+          setCurrent: function (editor, lang) {
+            return editor.execCommand('Lang', false, lang);
+          },
+          onToolbarSetup: function (api) {
+            var unbinder = unbindable();
+            api.setActive(editor.formatter.match('lang', {}, undefined, true));
+            unbinder.set(editor.formatter.formatChanged('lang', api.setActive, true));
+            return unbinder.clear;
+          }
+        };
+      });
+    };
+    var register$5 = function (editor) {
+      registerController(editor, lineHeightSpec);
+      languageSpec(editor).each(function (spec) {
+        return registerController(editor, spec);
+      });
+    };
+
+    var register$4 = function (editor, backstage) {
+      alignSelectMenu(editor, backstage);
+      fontSelectMenu(editor, backstage);
+      styleSelectMenu(editor, backstage);
+      formatSelectMenu(editor, backstage);
+      fontsizeSelectMenu(editor, backstage);
+    };
+
+    var onSetupOutdentState = function (editor) {
+      return onSetupEvent(editor, 'NodeChange', function (api) {
+        api.setDisabled(!editor.queryCommandState('outdent'));
+      });
+    };
+    var registerButtons$2 = function (editor) {
+      editor.ui.registry.addButton('outdent', {
+        tooltip: 'Decrease indent',
+        icon: 'outdent',
+        onSetup: onSetupOutdentState(editor),
+        onAction: onActionExecCommand(editor, 'outdent')
+      });
+      editor.ui.registry.addButton('indent', {
+        tooltip: 'Increase indent',
+        icon: 'indent',
+        onAction: onActionExecCommand(editor, 'indent')
+      });
+    };
+    var register$3 = function (editor) {
+      registerButtons$2(editor);
+    };
+
+    var onActionToggleFormat = function (editor, fmt) {
+      return function () {
+        editor.execCommand('mceToggleFormat', false, fmt);
+      };
+    };
+    var registerFormatButtons = function (editor) {
+      global$5.each([
+        {
+          name: 'bold',
+          text: 'Bold',
+          icon: 'bold'
+        },
+        {
+          name: 'italic',
+          text: 'Italic',
+          icon: 'italic'
+        },
+        {
+          name: 'underline',
+          text: 'Underline',
+          icon: 'underline'
+        },
+        {
+          name: 'strikethrough',
+          text: 'Strikethrough',
+          icon: 'strike-through'
+        },
+        {
+          name: 'subscript',
+          text: 'Subscript',
+          icon: 'subscript'
+        },
+        {
+          name: 'superscript',
+          text: 'Superscript',
+          icon: 'superscript'
+        }
+      ], function (btn, _idx) {
+        editor.ui.registry.addToggleButton(btn.name, {
+          tooltip: btn.text,
+          icon: btn.icon,
+          onSetup: onSetupFormatToggle(editor, btn.name),
+          onAction: onActionToggleFormat(editor, btn.name)
+        });
+      });
+      for (var i = 1; i <= 6; i++) {
+        var name_1 = 'h' + i;
+        editor.ui.registry.addToggleButton(name_1, {
+          text: name_1.toUpperCase(),
+          tooltip: 'Heading ' + i,
+          onSetup: onSetupFormatToggle(editor, name_1),
+          onAction: onActionToggleFormat(editor, name_1)
+        });
+      }
+    };
+    var registerCommandButtons = function (editor) {
+      global$5.each([
+        {
+          name: 'cut',
+          text: 'Cut',
+          action: 'Cut',
+          icon: 'cut'
+        },
+        {
+          name: 'copy',
+          text: 'Copy',
+          action: 'Copy',
+          icon: 'copy'
+        },
+        {
+          name: 'paste',
+          text: 'Paste',
+          action: 'Paste',
+          icon: 'paste'
+        },
+        {
+          name: 'help',
+          text: 'Help',
+          action: 'mceHelp',
+          icon: 'help'
+        },
+        {
+          name: 'selectall',
+          text: 'Select all',
+          action: 'SelectAll',
+          icon: 'select-all'
+        },
+        {
+          name: 'newdocument',
+          text: 'New document',
+          action: 'mceNewDocument',
+          icon: 'new-document'
+        },
+        {
+          name: 'removeformat',
+          text: 'Clear formatting',
+          action: 'RemoveFormat',
+          icon: 'remove-formatting'
+        },
+        {
+          name: 'remove',
+          text: 'Remove',
+          action: 'Delete',
+          icon: 'remove'
+        }
+      ], function (btn) {
+        editor.ui.registry.addButton(btn.name, {
+          tooltip: btn.text,
+          icon: btn.icon,
+          onAction: onActionExecCommand(editor, btn.action)
+        });
+      });
+    };
+    var registerCommandToggleButtons = function (editor) {
+      global$5.each([{
+          name: 'blockquote',
+          text: 'Blockquote',
+          action: 'mceBlockQuote',
+          icon: 'quote'
+        }], function (btn) {
+        editor.ui.registry.addToggleButton(btn.name, {
+          tooltip: btn.text,
+          icon: btn.icon,
+          onAction: onActionExecCommand(editor, btn.action),
+          onSetup: onSetupFormatToggle(editor, btn.name)
+        });
+      });
+    };
+    var registerButtons$1 = function (editor) {
+      registerFormatButtons(editor);
+      registerCommandButtons(editor);
+      registerCommandToggleButtons(editor);
+    };
+    var registerMenuItems$2 = function (editor) {
+      global$5.each([
+        {
+          name: 'bold',
+          text: 'Bold',
+          action: 'Bold',
+          icon: 'bold',
+          shortcut: 'Meta+B'
+        },
+        {
+          name: 'italic',
+          text: 'Italic',
+          action: 'Italic',
+          icon: 'italic',
+          shortcut: 'Meta+I'
+        },
+        {
+          name: 'underline',
+          text: 'Underline',
+          action: 'Underline',
+          icon: 'underline',
+          shortcut: 'Meta+U'
+        },
+        {
+          name: 'strikethrough',
+          text: 'Strikethrough',
+          action: 'Strikethrough',
+          icon: 'strike-through',
+          shortcut: ''
+        },
+        {
+          name: 'subscript',
+          text: 'Subscript',
+          action: 'Subscript',
+          icon: 'subscript',
+          shortcut: ''
+        },
+        {
+          name: 'superscript',
+          text: 'Superscript',
+          action: 'Superscript',
+          icon: 'superscript',
+          shortcut: ''
+        },
+        {
+          name: 'removeformat',
+          text: 'Clear formatting',
+          action: 'RemoveFormat',
+          icon: 'remove-formatting',
+          shortcut: ''
+        },
+        {
+          name: 'newdocument',
+          text: 'New document',
+          action: 'mceNewDocument',
+          icon: 'new-document',
+          shortcut: ''
+        },
+        {
+          name: 'cut',
+          text: 'Cut',
+          action: 'Cut',
+          icon: 'cut',
+          shortcut: 'Meta+X'
+        },
+        {
+          name: 'copy',
+          text: 'Copy',
+          action: 'Copy',
+          icon: 'copy',
+          shortcut: 'Meta+C'
+        },
+        {
+          name: 'paste',
+          text: 'Paste',
+          action: 'Paste',
+          icon: 'paste',
+          shortcut: 'Meta+V'
+        },
+        {
+          name: 'selectall',
+          text: 'Select all',
+          action: 'SelectAll',
+          icon: 'select-all',
+          shortcut: 'Meta+A'
+        }
+      ], function (btn) {
+        editor.ui.registry.addMenuItem(btn.name, {
+          text: btn.text,
+          icon: btn.icon,
+          shortcut: btn.shortcut,
+          onAction: onActionExecCommand(editor, btn.action)
+        });
+      });
+      editor.ui.registry.addMenuItem('codeformat', {
+        text: 'Code',
+        icon: 'sourcecode',
+        onAction: onActionToggleFormat(editor, 'code')
+      });
+    };
+    var register$2 = function (editor) {
+      registerButtons$1(editor);
+      registerMenuItems$2(editor);
+    };
+
+    var onSetupUndoRedoState = function (editor, type) {
+      return onSetupEvent(editor, 'Undo Redo AddUndo TypingUndo ClearUndos SwitchMode', function (api) {
+        api.setDisabled(editor.mode.isReadOnly() || !editor.undoManager[type]());
+      });
+    };
+    var registerMenuItems$1 = function (editor) {
+      editor.ui.registry.addMenuItem('undo', {
+        text: 'Undo',
+        icon: 'undo',
+        shortcut: 'Meta+Z',
+        onSetup: onSetupUndoRedoState(editor, 'hasUndo'),
+        onAction: onActionExecCommand(editor, 'undo')
+      });
+      editor.ui.registry.addMenuItem('redo', {
+        text: 'Redo',
+        icon: 'redo',
+        shortcut: 'Meta+Y',
+        onSetup: onSetupUndoRedoState(editor, 'hasRedo'),
+        onAction: onActionExecCommand(editor, 'redo')
+      });
+    };
+    var registerButtons = function (editor) {
+      editor.ui.registry.addButton('undo', {
+        tooltip: 'Undo',
+        icon: 'undo',
+        disabled: true,
+        onSetup: onSetupUndoRedoState(editor, 'hasUndo'),
+        onAction: onActionExecCommand(editor, 'undo')
+      });
+      editor.ui.registry.addButton('redo', {
+        tooltip: 'Redo',
+        icon: 'redo',
+        disabled: true,
+        onSetup: onSetupUndoRedoState(editor, 'hasRedo'),
+        onAction: onActionExecCommand(editor, 'redo')
+      });
+    };
+    var register$1 = function (editor) {
+      registerMenuItems$1(editor);
+      registerButtons(editor);
+    };
+
+    var onSetupVisualAidState = function (editor) {
+      return onSetupEvent(editor, 'VisualAid', function (api) {
+        api.setActive(editor.hasVisual);
+      });
+    };
+    var registerMenuItems = function (editor) {
+      editor.ui.registry.addToggleMenuItem('visualaid', {
+        text: 'Visual aids',
+        onSetup: onSetupVisualAidState(editor),
+        onAction: onActionExecCommand(editor, 'mceToggleVisualAid')
+      });
+    };
+    var registerToolbarButton = function (editor) {
+      editor.ui.registry.addButton('visualaid', {
+        tooltip: 'Visual aids',
+        text: 'Visual aids',
+        onAction: onActionExecCommand(editor, 'mceToggleVisualAid')
+      });
+    };
+    var register = function (editor) {
+      registerToolbarButton(editor);
+      registerMenuItems(editor);
+    };
+
+    var setup$6 = function (editor, backstage) {
+      register$6(editor);
+      register$2(editor);
+      register$4(editor, backstage);
+      register$1(editor);
+      register$a(editor);
+      register(editor);
+      register$3(editor);
+      register$5(editor);
+    };
+
+    var nu = function (x, y) {
+      return {
+        type: 'makeshift',
+        x: x,
+        y: y
+      };
+    };
+    var transpose = function (pos, dx, dy) {
+      return nu(pos.x + dx, pos.y + dy);
+    };
+    var isTouchEvent = function (e) {
+      return e.type === 'longpress' || e.type.indexOf('touch') === 0;
+    };
+    var fromPageXY = function (e) {
+      if (isTouchEvent(e)) {
+        var touch = e.touches[0];
+        return nu(touch.pageX, touch.pageY);
+      } else {
+        return nu(e.pageX, e.pageY);
+      }
+    };
+    var fromClientXY = function (e) {
+      if (isTouchEvent(e)) {
+        var touch = e.touches[0];
+        return nu(touch.clientX, touch.clientY);
+      } else {
+        return nu(e.clientX, e.clientY);
+      }
+    };
+    var transposeContentAreaContainer = function (element, pos) {
+      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) {
+          return fromPageXY(e);
+        } else {
+          return transposeContentAreaContainer(editor.getContentAreaContainer(), fromClientXY(e));
+        }
+      } else {
+        return getSelectionAnchor(editor);
+      }
+    };
+    var getSelectionAnchor = function (editor) {
+      return {
+        type: 'selection',
+        root: SugarElement.fromDom(editor.selection.getNode())
+      };
+    };
+    var getNodeAnchor = function (editor) {
+      return {
+        type: 'node',
+        node: Optional.some(SugarElement.fromDom(editor.selection.getNode())),
+        root: SugarElement.fromDom(editor.getBody())
+      };
+    };
+    var getAnchorSpec$1 = function (editor, e, anchorType) {
+      switch (anchorType) {
+      case 'node':
+        return getNodeAnchor(editor);
+      case 'point':
+        return getPointAnchor(editor, e);
+      case 'selection':
+        return getSelectionAnchor(editor);
+      }
+    };
+
+    var initAndShow$1 = function (editor, e, buildMenu, backstage, contextmenu, anchorType) {
+      var items = buildMenu();
+      var anchorSpec = getAnchorSpec$1(editor, e, anchorType);
+      build(items, ItemResponse$1.CLOSE_ON_EXECUTE, backstage, false).map(function (menuData) {
+        e.preventDefault();
+        InlineView.showMenuAt(contextmenu, { anchor: anchorSpec }, {
+          menu: { markers: markers('normal') },
+          data: menuData
+        });
+      });
+    };
+
+    var layouts = {
+      onLtr: function () {
+        return [
+          south$2,
+          southeast$2,
+          southwest$2,
+          northeast$2,
+          northwest$2,
+          north$2,
+          north,
+          south,
+          northeast,
+          southeast,
+          northwest,
+          southwest
+        ];
+      },
+      onRtl: function () {
+        return [
+          south$2,
+          southwest$2,
+          southeast$2,
+          northwest$2,
+          northeast$2,
+          north$2,
+          north,
+          south,
+          northwest,
+          southwest,
+          northeast,
+          southeast
+        ];
+      }
+    };
+    var bubbleSize = 12;
+    var bubbleAlignments = {
+      valignCentre: [],
+      alignCentre: [],
+      alignLeft: ['tox-pop--align-left'],
+      alignRight: ['tox-pop--align-right'],
+      right: ['tox-pop--right'],
+      left: ['tox-pop--left'],
+      bottom: ['tox-pop--bottom'],
+      top: ['tox-pop--top']
+    };
+    var isTouchWithinSelection = function (editor, e) {
+      var selection = editor.selection;
+      if (selection.isCollapsed() || e.touches.length < 1) {
+        return false;
+      } else {
+        var touch_1 = e.touches[0];
+        var rng = selection.getRng();
+        var rngRectOpt = getFirstRect(editor.getWin(), SimSelection.domRange(rng));
+        return rngRectOpt.exists(function (rngRect) {
+          return rngRect.left <= touch_1.clientX && rngRect.right >= touch_1.clientX && rngRect.top <= touch_1.clientY && rngRect.bottom >= touch_1.clientY;
+        });
+      }
+    };
+    var setupiOSOverrides = function (editor) {
+      var originalSelection = editor.selection.getRng();
+      var selectionReset = function () {
+        global$f.setEditorTimeout(editor, function () {
+          editor.selection.setRng(originalSelection);
+        }, 10);
+        unbindEventListeners();
+      };
+      editor.once('touchend', selectionReset);
+      var preventMousedown = function (e) {
+        e.preventDefault();
+        e.stopImmediatePropagation();
+      };
+      editor.on('mousedown', preventMousedown, true);
+      var clearSelectionReset = function () {
+        return unbindEventListeners();
+      };
+      editor.once('longpresscancel', clearSelectionReset);
+      var unbindEventListeners = function () {
+        editor.off('touchend', selectionReset);
+        editor.off('longpresscancel', clearSelectionReset);
+        editor.off('mousedown', preventMousedown);
+      };
+    };
+    var getAnchorSpec = function (editor, e, anchorType) {
+      var anchorSpec = getAnchorSpec$1(editor, e, anchorType);
+      var bubbleYOffset = anchorType === 'point' ? bubbleSize : 0;
+      return __assign({
+        bubble: nu$5(0, bubbleYOffset, bubbleAlignments),
+        layouts: layouts,
+        overrides: {
+          maxWidthFunction: expandable(),
+          maxHeightFunction: expandable$1()
+        }
+      }, anchorSpec);
+    };
+    var show = function (editor, e, items, backstage, contextmenu, anchorType, highlightImmediately) {
+      var anchorSpec = getAnchorSpec(editor, e, anchorType);
+      build(items, ItemResponse$1.CLOSE_ON_EXECUTE, backstage, true).map(function (menuData) {
+        e.preventDefault();
+        InlineView.showMenuWithinBounds(contextmenu, { anchor: anchorSpec }, {
+          menu: {
+            markers: markers('normal'),
+            highlightImmediately: highlightImmediately
+          },
+          data: menuData,
+          type: 'horizontal'
+        }, function () {
+          return Optional.some(getContextToolbarBounds(editor, backstage.shared, anchorType === 'node' ? 'node' : 'selection'));
+        });
+        editor.fire(hideContextToolbarEvent);
+      });
+    };
+    var initAndShow = function (editor, e, buildMenu, backstage, contextmenu, anchorType) {
+      var detection = detect$1();
+      var isiOS = detection.os.isiOS();
+      var isOSX = detection.os.isOSX();
+      var isAndroid = detection.os.isAndroid();
+      var isTouch = detection.deviceType.isTouch();
+      var shouldHighlightImmediately = function () {
+        return !(isAndroid || isiOS || isOSX && isTouch);
+      };
+      var open = function () {
+        var items = buildMenu();
+        show(editor, e, items, backstage, contextmenu, anchorType, shouldHighlightImmediately());
+      };
+      if ((isOSX || isiOS) && anchorType !== 'node') {
+        var openiOS_1 = function () {
+          setupiOSOverrides(editor);
+          open();
+        };
+        if (isTouchWithinSelection(editor, e)) {
+          openiOS_1();
+        } else {
+          editor.once('selectionchange', openiOS_1);
+          editor.once('touchend', function () {
+            return editor.off('selectionchange', openiOS_1);
+          });
+        }
+      } else {
+        open();
+      }
+    };
+
+    var patchPipeConfig = function (config) {
+      return typeof config === 'string' ? config.split(/[ ,]/) : config;
+    };
+    var shouldNeverUseNative = function (editor) {
+      return editor.getParam('contextmenu_never_use_native', false, 'boolean');
+    };
+    var getMenuItems = function (editor, name, defaultItems) {
+      var contextMenus = editor.ui.registry.getAll().contextMenus;
+      return Optional.from(editor.getParam(name)).map(patchPipeConfig).getOrThunk(function () {
+        return filter$2(patchPipeConfig(defaultItems), function (item) {
+          return has$2(contextMenus, item);
+        });
+      });
+    };
+    var isContextMenuDisabled = function (editor) {
+      return editor.getParam('contextmenu') === false;
+    };
+    var getContextMenu = function (editor) {
+      return getMenuItems(editor, 'contextmenu', 'link linkchecker image imagetools table spellchecker configurepermanentpen');
+    };
+    var getAvoidOverlapSelector = function (editor) {
+      return editor.getParam('contextmenu_avoid_overlap', '', 'string');
+    };
+
+    var isSeparator = function (item) {
+      return isString(item) ? item === '|' : item.type === 'separator';
+    };
+    var separator = { type: 'separator' };
+    var makeContextItem = function (item) {
+      var commonMenuItem = function (item) {
+        return {
+          text: item.text,
+          icon: item.icon,
+          disabled: item.disabled,
+          shortcut: item.shortcut
+        };
+      };
+      if (isString(item)) {
+        return item;
+      } else {
+        switch (item.type) {
+        case 'separator':
+          return separator;
+        case 'submenu':
+          return __assign(__assign({ type: 'nestedmenuitem' }, commonMenuItem(item)), {
+            getSubmenuItems: function () {
+              var items = item.getSubmenuItems();
+              if (isString(items)) {
+                return items;
+              } else {
+                return map$2(items, makeContextItem);
+              }
+            }
+          });
+        default:
+          return __assign(__assign({ type: 'menuitem' }, commonMenuItem(item)), { onAction: noarg(item.onAction) });
+        }
+      }
+    };
+    var addContextMenuGroup = function (xs, groupItems) {
+      if (groupItems.length === 0) {
+        return xs;
+      }
+      var lastMenuItem = last$2(xs).filter(function (item) {
+        return !isSeparator(item);
+      });
+      var before = lastMenuItem.fold(function () {
+        return [];
+      }, function (_) {
+        return [separator];
+      });
+      return xs.concat(before).concat(groupItems).concat([separator]);
+    };
+    var generateContextMenu = function (contextMenus, menuConfig, selectedElement) {
+      var sections = foldl(menuConfig, function (acc, name) {
+        return get$e(contextMenus, name.toLowerCase()).map(function (menu) {
+          var items = menu.update(selectedElement);
+          if (isString(items)) {
+            return addContextMenuGroup(acc, items.split(' '));
+          } else if (items.length > 0) {
+            var allItems = map$2(items, makeContextItem);
+            return addContextMenuGroup(acc, allItems);
+          } else {
+            return acc;
+          }
+        }).getOrThunk(function () {
+          return acc.concat([name]);
+        });
+      }, []);
+      if (sections.length > 0 && isSeparator(sections[sections.length - 1])) {
+        sections.pop();
+      }
+      return sections;
+    };
+    var isNativeOverrideKeyEvent = function (editor, e) {
+      return e.ctrlKey && !shouldNeverUseNative(editor);
+    };
+    var isTriggeredByKeyboard = function (editor, e) {
+      return e.type !== 'longpress' && (e.button !== 2 || e.target === editor.getBody() && e.pointerType === '');
+    };
+    var getSelectedElement = function (editor, e) {
+      return isTriggeredByKeyboard(editor, e) ? editor.selection.getStart(true) : e.target;
+    };
+    var getAnchorType = function (editor, e) {
+      var selector = getAvoidOverlapSelector(editor);
+      var anchorType = isTriggeredByKeyboard(editor, e) ? 'selection' : 'point';
+      if (isNotEmpty(selector)) {
+        var target = getSelectedElement(editor, e);
+        var selectorExists = closest(SugarElement.fromDom(target), selector);
+        return selectorExists ? 'node' : anchorType;
+      } else {
+        return anchorType;
+      }
+    };
+    var setup$5 = function (editor, lazySink, backstage) {
+      var detection = detect$1();
+      var isTouch = detection.deviceType.isTouch;
+      var contextmenu = build$1(InlineView.sketch({
+        dom: { tag: 'div' },
+        lazySink: lazySink,
+        onEscape: function () {
+          return editor.focus();
+        },
+        onShow: function () {
+          return backstage.setContextMenuState(true);
+        },
+        onHide: function () {
+          return backstage.setContextMenuState(false);
+        },
+        fireDismissalEventInstead: {},
+        inlineBehaviours: derive$1([config('dismissContextMenu', [run$1(dismissRequested(), function (comp, _se) {
+              Sandboxing.close(comp);
+              editor.focus();
+            })])])
+      }));
+      var hideContextMenu = function (_e) {
+        return InlineView.hide(contextmenu);
+      };
+      var showContextMenu = function (e) {
+        if (shouldNeverUseNative(editor)) {
+          e.preventDefault();
+        }
+        if (isNativeOverrideKeyEvent(editor, e) || isContextMenuDisabled(editor)) {
+          return;
+        }
+        var anchorType = getAnchorType(editor, e);
+        var buildMenu = function () {
+          var selectedElement = getSelectedElement(editor, e);
+          var registry = editor.ui.registry.getAll();
+          var menuConfig = getContextMenu(editor);
+          return generateContextMenu(registry.contextMenus, menuConfig, selectedElement);
+        };
+        var initAndShow$2 = isTouch() ? initAndShow : initAndShow$1;
+        initAndShow$2(editor, e, buildMenu, backstage, contextmenu, anchorType);
+      };
+      editor.on('init', function () {
+        var hideEvents = 'ResizeEditor ScrollContent ScrollWindow longpresscancel' + (isTouch() ? '' : ' ResizeWindow');
+        editor.on(hideEvents, hideContextMenu);
+        editor.on('longpress contextmenu', showContextMenu);
+      });
+    };
+
+    var adt = Adt.generate([
+      {
+        offset: [
+          'x',
+          'y'
+        ]
+      },
+      {
+        absolute: [
+          'x',
+          'y'
+        ]
+      },
+      {
+        fixed: [
+          'x',
+          'y'
+        ]
+      }
+    ]);
+    var subtract = function (change) {
+      return function (point) {
+        return point.translate(-change.left, -change.top);
+      };
+    };
+    var add = function (change) {
+      return function (point) {
+        return point.translate(change.left, change.top);
+      };
+    };
+    var transform = function (changes) {
+      return function (x, y) {
+        return foldl(changes, function (rest, f) {
+          return f(rest);
+        }, SugarPosition(x, y));
+      };
+    };
+    var asFixed = function (coord, scroll, origin) {
+      return coord.fold(transform([
+        add(origin),
+        subtract(scroll)
+      ]), transform([subtract(scroll)]), transform([]));
+    };
+    var asAbsolute = function (coord, scroll, origin) {
+      return coord.fold(transform([add(origin)]), transform([]), transform([add(scroll)]));
+    };
+    var asOffset = function (coord, scroll, origin) {
+      return coord.fold(transform([]), transform([subtract(origin)]), transform([
+        add(scroll),
+        subtract(origin)
+      ]));
+    };
+    var withinRange = function (coord1, coord2, xRange, yRange, scroll, origin) {
+      var a1 = asAbsolute(coord1, scroll, origin);
+      var a2 = asAbsolute(coord2, scroll, origin);
+      return Math.abs(a1.left - a2.left) <= xRange && Math.abs(a1.top - a2.top) <= yRange;
+    };
+    var getDeltas = function (coord1, coord2, xRange, yRange, scroll, origin) {
+      var a1 = asAbsolute(coord1, scroll, origin);
+      var a2 = asAbsolute(coord2, scroll, origin);
+      var left = Math.abs(a1.left - a2.left);
+      var top = Math.abs(a1.top - a2.top);
+      return SugarPosition(left, top);
+    };
+    var toStyles = function (coord, scroll, origin) {
+      var stylesOpt = coord.fold(function (x, y) {
+        return {
+          position: Optional.some('absolute'),
+          left: Optional.some(x + 'px'),
+          top: Optional.some(y + 'px')
+        };
+      }, function (x, y) {
+        return {
+          position: Optional.some('absolute'),
+          left: Optional.some(x - origin.left + 'px'),
+          top: Optional.some(y - origin.top + 'px')
+        };
+      }, function (x, y) {
+        return {
+          position: Optional.some('fixed'),
+          left: Optional.some(x + 'px'),
+          top: Optional.some(y + 'px')
+        };
+      });
+      return __assign({
+        right: Optional.none(),
+        bottom: Optional.none()
+      }, stylesOpt);
+    };
+    var translate = function (coord, deltaX, deltaY) {
+      return coord.fold(function (x, y) {
+        return offset(x + deltaX, y + deltaY);
+      }, function (x, y) {
+        return absolute(x + deltaX, y + deltaY);
+      }, function (x, y) {
+        return fixed(x + deltaX, y + deltaY);
+      });
+    };
+    var absorb = function (partialCoord, originalCoord, scroll, origin) {
+      var absorbOne = function (stencil, nu) {
+        return function (optX, optY) {
+          var original = stencil(originalCoord, scroll, origin);
+          return nu(optX.getOr(original.left), optY.getOr(original.top));
+        };
+      };
+      return partialCoord.fold(absorbOne(asOffset, offset), absorbOne(asAbsolute, absolute), absorbOne(asFixed, fixed));
+    };
+    var offset = adt.offset;
+    var absolute = adt.absolute;
+    var fixed = adt.fixed;
+
+    var parseAttrToInt = function (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$8(element, snapsInfo.leftAttr, pt.left + 'px');
+      set$8(element, snapsInfo.topAttr, pt.top + 'px');
+    };
+    var clear = function (component, snapsInfo) {
+      var element = component.element;
+      remove$7(element, snapsInfo.leftAttr);
+      remove$7(element, snapsInfo.topAttr);
+    };
+
+    var getCoords = function (component, snapInfo, coord, delta) {
+      return get(component, snapInfo).fold(function () {
+        return coord;
+      }, function (fixed$1) {
+        return fixed(fixed$1.left + delta.left, fixed$1.top + delta.top);
+      });
+    };
+    var moveOrSnap = function (component, snapInfo, coord, delta, scroll, origin) {
+      var newCoord = getCoords(component, snapInfo, coord, delta);
+      var snap = snapInfo.mustSnap ? findClosestSnap(component, snapInfo, newCoord, scroll, origin) : findSnap(component, snapInfo, newCoord, scroll, origin);
+      var fixedCoord = asFixed(newCoord, scroll, origin);
+      set(component, snapInfo, fixedCoord);
+      return snap.fold(function () {
+        return {
+          coord: fixed(fixedCoord.left, fixedCoord.top),
+          extra: Optional.none()
+        };
+      }, function (spanned) {
+        return {
+          coord: spanned.output,
+          extra: spanned.extra
+        };
+      });
+    };
+    var stopDrag = function (component, snapInfo) {
+      clear(component, snapInfo);
+    };
+    var findMatchingSnap = function (snaps, newCoord, scroll, origin) {
+      return findMap(snaps, function (snap) {
+        var sensor = snap.sensor;
+        var inRange = withinRange(newCoord, sensor, snap.range.left, snap.range.top, scroll, origin);
+        return inRange ? Optional.some({
+          output: absorb(snap.output, newCoord, scroll, origin),
+          extra: snap.extra
+        }) : Optional.none();
+      });
+    };
+    var findClosestSnap = function (component, snapInfo, newCoord, scroll, origin) {
+      var snaps = snapInfo.getSnapPoints(component);
+      var matchSnap = findMatchingSnap(snaps, newCoord, scroll, origin);
+      return matchSnap.orThunk(function () {
+        var bestSnap = foldl(snaps, function (acc, snap) {
+          var sensor = snap.sensor;
+          var deltas = getDeltas(newCoord, sensor, snap.range.left, snap.range.top, scroll, origin);
+          return acc.deltas.fold(function () {
+            return {
+              deltas: Optional.some(deltas),
+              snap: Optional.some(snap)
+            };
+          }, function (bestDeltas) {
+            var currAvg = (deltas.left + deltas.top) / 2;
+            var bestAvg = (bestDeltas.left + bestDeltas.top) / 2;
+            if (currAvg <= bestAvg) {
+              return {
+                deltas: Optional.some(deltas),
+                snap: Optional.some(snap)
+              };
+            } else {
+              return acc;
+            }
+          });
+        }, {
+          deltas: Optional.none(),
+          snap: Optional.none()
+        });
+        return bestSnap.snap.map(function (snap) {
+          return {
+            output: absorb(snap.output, newCoord, scroll, origin),
+            extra: snap.extra
+          };
+        });
+      });
+    };
+    var findSnap = function (component, snapInfo, newCoord, scroll, origin) {
+      var snaps = snapInfo.getSnapPoints(component);
+      return findMatchingSnap(snaps, newCoord, scroll, origin);
+    };
+    var snapTo$1 = function (snap, scroll, origin) {
+      return {
+        coord: absorb(snap.output, snap.output, scroll, origin),
+        extra: snap.extra
+      };
+    };
+
+    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$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 DraggingApis = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        snapTo: snapTo
+    });
+
+    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$6(root, 'z-index');
+        }, function (zIndex) {
+          return set$7(root, 'z-index', zIndex);
+        });
+        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$8(root, initialAttribute, zindex);
+        });
+        set$7(root, 'z-index', get$c(blocker.element, 'z-index'));
+      });
+    };
+    var instigate = function (anyComponent, blocker) {
+      anyComponent.getSystem().addToGui(blocker);
+      changeZIndex(blocker);
+    };
+    var discard = function (blocker) {
+      resetZIndex(blocker);
+      blocker.getSystem().removeFromGui(blocker);
+    };
+    var createComponent = function (component, blockerClass, blockerEvents) {
+      return component.getSystem().build(Container.sketch({
+        dom: {
+          styles: {
+            'left': '0px',
+            'top': '0px',
+            'width': '100%',
+            'height': '100%',
+            'position': 'fixed',
+            'z-index': '1000000000000000'
+          },
+          classes: [blockerClass]
+        },
+        events: blockerEvents
+      }));
+    };
+
+    var SnapSchema = optionObjOf('snaps', [
+      required$1('getSnapPoints'),
+      onHandler('onSensor'),
+      required$1('leftAttr'),
+      required$1('topAttr'),
+      defaulted('lazyViewport', win),
+      defaulted('mustSnap', false)
+    ]);
+
+    var schema$6 = [
+      defaulted('useFixed', never),
+      required$1('blockerClass'),
+      defaulted('getTarget', identity$1),
+      defaulted('onDrag', noop),
+      defaulted('repositionTarget', true),
+      defaulted('onDrop', noop),
+      defaultedFunction('getBounds', win),
+      SnapSchema
+    ];
+
+    var getCurrentCoord = function (target) {
+      return lift3(getRaw(target, 'left'), getRaw(target, 'top'), getRaw(target, 'position'), function (left, top, position) {
+        var nu = position === 'fixed' ? fixed : offset;
+        return nu(parseInt(left, 10), parseInt(top, 10));
+      }).getOrThunk(function () {
+        var location = absolute$3(target);
+        return absolute(location.left, location.top);
+      });
+    };
+    var clampCoords = function (component, coords, scroll, origin, startData) {
+      var bounds = startData.bounds;
+      var absoluteCoord = asAbsolute(coords, scroll, origin);
+      var newX = clamp$1(absoluteCoord.left, bounds.x, bounds.x + bounds.width - startData.width);
+      var newY = clamp$1(absoluteCoord.top, bounds.y, bounds.y + bounds.height - startData.height);
+      var newCoords = absolute(newX, newY);
+      return coords.fold(function () {
+        var offset$1 = asOffset(newCoords, scroll, origin);
+        return offset(offset$1.left, offset$1.top);
+      }, constant$1(newCoords), function () {
+        var fixed$1 = asFixed(newCoords, scroll, origin);
+        return fixed(fixed$1.left, fixed$1.top);
+      });
+    };
+    var calcNewCoord = function (component, optSnaps, currentCoord, scroll, origin, delta, startData) {
+      var newCoord = optSnaps.fold(function () {
+        var translated = translate(currentCoord, delta.left, delta.top);
+        var fixedCoord = asFixed(translated, scroll, origin);
+        return fixed(fixedCoord.left, fixedCoord.top);
+      }, function (snapInfo) {
+        var snapping = moveOrSnap(component, snapInfo, currentCoord, delta, scroll, origin);
+        snapping.extra.each(function (extra) {
+          snapInfo.onSensor(component, extra);
+        });
+        return snapping.coord;
+      });
+      return clampCoords(component, newCoord, scroll, origin, startData);
+    };
+    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$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);
+      }
+      dragConfig.onDrag(component, target, delta);
+    };
+
+    var calcStartData = function (dragConfig, comp) {
+      return {
+        bounds: dragConfig.getBounds(),
+        height: getOuter$2(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 calcStartData(dragConfig, component);
+      });
+      delta.each(function (dlt) {
+        dragBy(component, dragConfig, dragStartData, dlt);
+      });
+    };
+    var stop = function (component, blocker, dragConfig, dragState) {
+      blocker.each(discard);
+      dragConfig.snaps.each(function (snapInfo) {
+        stopDrag(component, snapInfo);
+      });
+      var target = dragConfig.getTarget(component.element);
+      dragState.reset();
+      dragConfig.onDrop(component, target);
+    };
+    var handlers = function (events) {
+      return function (dragConfig, dragState) {
+        var updateStartState = function (comp) {
+          dragState.setStartData(calcStartData(dragConfig, comp));
+        };
+        return derive$2(__spreadArray([run$1(windowScroll(), function (comp) {
+            dragState.getStartData().each(function () {
+              return updateStartState(comp);
+            });
+          })], events(dragConfig, dragState, updateStartState), true));
+      };
+    };
+
+    var init$2 = function (dragApi) {
+      return derive$2([
+        run$1(mousedown(), dragApi.forceDrop),
+        run$1(mouseup(), dragApi.drop),
+        run$1(mousemove(), function (comp, simulatedEvent) {
+          dragApi.move(simulatedEvent.event);
+        }),
+        run$1(mouseout(), dragApi.delayDrop)
+      ]);
+    };
+
+    var getData$1 = function (event) {
+      return Optional.from(SugarPosition(event.x, event.y));
+    };
+    var getDelta$1 = function (old, nu) {
+      return SugarPosition(nu.left - old.left, nu.top - old.top);
+    };
+
+    var MouseData = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        getData: getData$1,
+        getDelta: getDelta$1
+    });
+
+    var events$2 = function (dragConfig, dragState, updateStartState) {
+      return [run$1(mousedown(), function (component, simulatedEvent) {
+          var raw = simulatedEvent.event.raw;
+          if (raw.button !== 0) {
+            return;
+          }
+          simulatedEvent.stop();
+          var stop$1 = function () {
+            return stop(component, Optional.some(blocker), dragConfig, dragState);
+          };
+          var delayDrop = DelayedFunction(stop$1, 200);
+          var dragApi = {
+            drop: stop$1,
+            delayDrop: delayDrop.schedule,
+            forceDrop: stop$1,
+            move: function (event) {
+              delayDrop.cancel();
+              move(component, dragConfig, dragState, MouseData, event);
+            }
+          };
+          var blocker = createComponent(component, dragConfig.blockerClass, init$2(dragApi));
+          var start = function () {
+            updateStartState(component);
+            instigate(component, blocker);
+          };
+          start();
+        })];
+    };
+    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),
+        run$1(touchcancel(), dragApi.drop),
+        run$1(touchmove(), function (comp, simulatedEvent) {
+          dragApi.move(simulatedEvent.event);
+        })
+      ]);
+    };
+
+    var getDataFrom = function (touches) {
+      var touch = touches[0];
+      return Optional.some(SugarPosition(touch.clientX, touch.clientY));
+    };
+    var getData = function (event) {
+      var raw = event.raw;
+      var touches = raw.touches;
+      return touches.length === 1 ? getDataFrom(touches) : Optional.none();
+    };
+    var getDelta = function (old, nu) {
+      return SugarPosition(nu.left - old.left, nu.top - old.top);
+    };
+
+    var TouchData = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        getData: getData,
+        getDelta: getDelta
+    });
+
+    var events$1 = function (dragConfig, dragState, updateStartState) {
+      var blockerSingleton = value$1();
+      var stopBlocking = function (component) {
+        stop(component, blockerSingleton.get(), dragConfig, dragState);
+        blockerSingleton.clear();
+      };
+      return [
+        run$1(touchstart(), function (component, simulatedEvent) {
+          simulatedEvent.stop();
+          var stop = function () {
+            return stopBlocking(component);
+          };
+          var dragApi = {
+            drop: stop,
+            delayDrop: noop,
+            forceDrop: stop,
+            move: function (event) {
+              move(component, dragConfig, dragState, TouchData, event);
+            }
+          };
+          var blocker = createComponent(component, dragConfig.blockerClass, init$1(dragApi));
+          blockerSingleton.set(blocker);
+          var start = function () {
+            updateStartState(component);
+            instigate(component, blocker);
+          };
+          start();
+        }),
+        run$1(touchmove(), function (component, simulatedEvent) {
+          simulatedEvent.stop();
+          move(component, dragConfig, dragState, TouchData, simulatedEvent.event);
+        }),
+        run$1(touchend(), function (component, simulatedEvent) {
+          simulatedEvent.stop();
+          stopBlocking(component);
+        }),
+        run$1(touchcancel(), stopBlocking)
+      ];
+    };
+    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), true), events$1(dragConfig, dragState, updateStartState), true);
+    };
+    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 DraggingBranches = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        mouse: mouse,
+        touch: touch,
+        mouseOrTouch: mouseOrTouch
+    });
+
+    var init = function () {
+      var previous = Optional.none();
+      var startData = Optional.none();
+      var reset = function () {
+        previous = Optional.none();
+        startData = Optional.none();
+      };
+      var calculateDelta = function (mode, nu) {
+        var result = previous.map(function (old) {
+          return mode.getDelta(old, nu);
+        });
+        previous = Optional.some(nu);
+        return result;
+      };
+      var update = function (mode, dragEvent) {
+        return mode.getData(dragEvent).bind(function (nuData) {
+          return calculateDelta(mode, nuData);
+        });
+      };
+      var setStartData = function (data) {
+        startData = Optional.some(data);
+      };
+      var getStartData = function () {
+        return startData;
+      };
+      var readState = constant$1({});
+      return nu$8({
+        readState: readState,
+        reset: reset,
+        update: update,
+        getStartData: getStartData,
+        setStartData: setStartData
+      });
+    };
+
+    var DragState = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        init: init
+    });
+
+    var Dragging = createModes({
+      branchKey: 'mode',
+      branches: DraggingBranches,
+      name: 'dragging',
+      active: {
+        events: function (dragConfig, dragState) {
+          var dragger = dragConfig.dragger;
+          return dragger.handlers(dragConfig, dragState);
+        }
+      },
+      extra: {
+        snap: function (sConfig) {
+          return {
+            sensor: sConfig.sensor,
+            range: sConfig.range,
+            output: sConfig.output,
+            extra: Optional.from(sConfig.extra)
+          };
+        }
+      },
+      state: DragState,
+      apis: DraggingApis
+    });
+
+    var snapWidth = 40;
+    var snapOffset = snapWidth / 2;
+    var calcSnap = function (selectorOpt, td, x, y, width, height) {
+      return selectorOpt.fold(function () {
+        return Dragging.snap({
+          sensor: absolute(x - snapOffset, y - snapOffset),
+          range: SugarPosition(width, height),
+          output: absolute(Optional.some(x), Optional.some(y)),
+          extra: { td: td }
+        });
+      }, function (selectorHandle) {
+        var sensorLeft = x - snapOffset;
+        var sensorTop = y - snapOffset;
+        var sensorWidth = snapWidth;
+        var sensorHeight = snapWidth;
+        var rect = selectorHandle.element.dom.getBoundingClientRect();
+        return Dragging.snap({
+          sensor: absolute(sensorLeft, sensorTop),
+          range: SugarPosition(sensorWidth, sensorHeight),
+          output: absolute(Optional.some(x - rect.width / 2), Optional.some(y - rect.height / 2)),
+          extra: { td: td }
+        });
+      });
+    };
+    var getSnapsConfig = function (getSnapPoints, cell, onChange) {
+      var isSameCell = function (cellOpt, td) {
+        return cellOpt.exists(function (currentTd) {
+          return eq(currentTd, td);
+        });
+      };
+      return {
+        getSnapPoints: getSnapPoints,
+        leftAttr: 'data-drag-left',
+        topAttr: 'data-drag-top',
+        onSensor: function (component, extra) {
+          var td = extra.td;
+          if (!isSameCell(cell.get(), td)) {
+            cell.set(td);
+            onChange(td);
+          }
+        },
+        mustSnap: true
+      };
+    };
+    var createSelector = function (snaps) {
+      return record(Button.sketch({
+        dom: {
+          tag: 'div',
+          classes: ['tox-selector']
+        },
+        buttonBehaviours: derive$1([
+          Dragging.config({
+            mode: 'mouseOrTouch',
+            blockerClass: 'blocker',
+            snaps: snaps
+          }),
+          Unselecting.config({})
+        ]),
+        eventOrder: {
+          mousedown: [
+            'dragging',
+            'alloy.base.behaviour'
+          ],
+          touchstart: [
+            'dragging',
+            'alloy.base.behaviour'
+          ]
+        }
+      }));
+    };
+    var setup$4 = function (editor, sink) {
+      var tlTds = Cell([]);
+      var brTds = Cell([]);
+      var isVisible = Cell(false);
+      var startCell = value$1();
+      var finishCell = value$1();
+      var getTopLeftSnap = function (td) {
+        var box = absolute$2(td);
+        return calcSnap(memTopLeft.getOpt(sink), td, box.x, box.y, box.width, box.height);
+      };
+      var getTopLeftSnaps = function () {
+        return map$2(tlTds.get(), function (td) {
+          return getTopLeftSnap(td);
+        });
+      };
+      var getBottomRightSnap = function (td) {
+        var box = absolute$2(td);
+        return calcSnap(memBottomRight.getOpt(sink), td, box.right, box.bottom, box.width, box.height);
+      };
+      var getBottomRightSnaps = function () {
+        return map$2(brTds.get(), function (td) {
+          return getBottomRightSnap(td);
+        });
+      };
+      var topLeftSnaps = getSnapsConfig(getTopLeftSnaps, startCell, function (start) {
+        finishCell.get().each(function (finish) {
+          editor.fire('TableSelectorChange', {
+            start: start,
+            finish: finish
+          });
+        });
+      });
+      var bottomRightSnaps = getSnapsConfig(getBottomRightSnaps, finishCell, function (finish) {
+        startCell.get().each(function (start) {
+          editor.fire('TableSelectorChange', {
+            start: start,
+            finish: finish
+          });
+        });
+      });
+      var memTopLeft = createSelector(topLeftSnaps);
+      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$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$7(selector.element, 'display', 'none');
+        }
+      };
+      var snapTo = function (selector, cell, getSnapConfig, pos) {
+        var snap = getSnapConfig(cell);
+        Dragging.snapTo(selector, snap);
+        var isAbove = function (rect) {
+          return rect[pos] < 0;
+        };
+        var isBelow = function (rect, viewportHeight) {
+          return rect[pos] > viewportHeight;
+        };
+        showOrHideHandle(selector, cell, isAbove, isBelow);
+      };
+      var snapTopLeft = function (cell) {
+        return snapTo(topLeft, cell, getTopLeftSnap, 'top');
+      };
+      var snapLastTopLeft = function () {
+        return startCell.get().each(snapTopLeft);
+      };
+      var snapBottomRight = function (cell) {
+        return snapTo(bottomRight, cell, getBottomRightSnap, 'bottom');
+      };
+      var snapLastBottomRight = function () {
+        return finishCell.get().each(snapBottomRight);
+      };
+      if (detect$1().deviceType.isTouch()) {
+        editor.on('TableSelectionChange', function (e) {
+          if (!isVisible.get()) {
+            attach(sink, topLeft);
+            attach(sink, bottomRight);
+            isVisible.set(true);
+          }
+          startCell.set(e.start);
+          finishCell.set(e.finish);
+          e.otherCells.each(function (otherCells) {
+            tlTds.set(otherCells.upOrLeftCells);
+            brTds.set(otherCells.downOrRightCells);
+            snapTopLeft(e.start);
+            snapBottomRight(e.finish);
+          });
+        });
+        editor.on('ResizeEditor ResizeWindow ScrollContent', function () {
+          snapLastTopLeft();
+          snapLastBottomRight();
+        });
+        editor.on('TableSelectionClear', function () {
+          if (isVisible.get()) {
+            detach(topLeft);
+            detach(bottomRight);
+            isVisible.set(false);
+          }
+          startCell.clear();
+          finishCell.clear();
+        });
+      }
+    };
+
+    var isHidden = function (elm) {
+      if (elm.nodeType === 1) {
+        if (elm.nodeName === 'BR' || !!elm.getAttribute('data-mce-bogus')) {
+          return true;
+        }
+        if (elm.getAttribute('data-mce-type') === 'bookmark') {
+          return true;
+        }
+      }
+      return false;
+    };
+    var renderElementPath = function (editor, settings, providersBackstage) {
+      if (!settings.delimiter) {
+        settings.delimiter = '\xBB';
+      }
+      var getDataPath = function (data) {
+        var parts = data || [];
+        var newPathElements = map$2(parts, function (part, index) {
+          return Button.sketch({
+            dom: {
+              tag: 'div',
+              classes: ['tox-statusbar__path-item'],
+              attributes: {
+                'role': 'button',
+                'data-index': index,
+                'tab-index': -1,
+                'aria-level': index + 1
+              },
+              innerHtml: part.name
+            },
+            action: function (_btn) {
+              editor.focus();
+              editor.selection.select(part.element);
+              editor.nodeChanged();
+            },
+            buttonBehaviours: derive$1([
+              DisablingConfigs.button(providersBackstage.isDisabled),
+              receivingConfig()
+            ])
+          });
+        });
+        var divider = {
+          dom: {
+            tag: 'div',
+            classes: ['tox-statusbar__path-divider'],
+            attributes: { 'aria-hidden': true },
+            innerHtml: ' ' + settings.delimiter + ' '
+          }
+        };
+        return foldl(newPathElements.slice(1), function (acc, element) {
+          var newAcc = acc;
+          newAcc.push(divider);
+          newAcc.push(element);
+          return newAcc;
+        }, [newPathElements[0]]);
+      };
+      var updatePath = function (parents) {
+        var newPath = [];
+        var i = parents.length;
+        while (i-- > 0) {
+          var parent_1 = parents[i];
+          if (parent_1.nodeType === 1 && !isHidden(parent_1)) {
+            var args = editor.fire('ResolveName', {
+              name: parent_1.nodeName.toLowerCase(),
+              target: parent_1
+            });
+            if (!args.isDefaultPrevented()) {
+              newPath.push({
+                name: args.name,
+                element: parent_1
+              });
+            }
+            if (args.isPropagationStopped()) {
+              break;
+            }
+          }
+        }
+        return newPath;
+      };
+      return {
+        dom: {
+          tag: 'div',
+          classes: ['tox-statusbar__path'],
+          attributes: { role: 'navigation' }
+        },
+        behaviours: derive$1([
+          Keying.config({
+            mode: 'flow',
+            selector: 'div[role=button]'
+          }),
+          Disabling.config({ disabled: providersBackstage.isDisabled }),
+          receivingConfig(),
+          Tabstopping.config({}),
+          Replacing.config({}),
+          config('elementPathEvents', [runOnAttached(function (comp, _e) {
+              editor.shortcuts.add('alt+F11', 'focus statusbar elementpath', function () {
+                return Keying.focusIn(comp);
+              });
+              editor.on('NodeChange', function (e) {
+                var newPath = updatePath(e.parents);
+                if (newPath.length > 0) {
+                  Replacing.set(comp, getDataPath(newPath));
+                } else {
+                  Replacing.set(comp, []);
+                }
+              });
+            })])
+        ]),
+        components: []
+      };
+    };
+
+    var ResizeTypes;
+    (function (ResizeTypes) {
+      ResizeTypes[ResizeTypes['None'] = 0] = 'None';
+      ResizeTypes[ResizeTypes['Both'] = 1] = 'Both';
+      ResizeTypes[ResizeTypes['Vertical'] = 2] = 'Vertical';
+    }(ResizeTypes || (ResizeTypes = {})));
+    var getDimensions = function (editor, deltas, resizeType, originalHeight, originalWidth) {
+      var dimensions = {};
+      dimensions.height = calcCappedSize(originalHeight + deltas.top, getMinHeightSetting(editor), getMaxHeightSetting(editor));
+      if (resizeType === ResizeTypes.Both) {
+        dimensions.width = calcCappedSize(originalWidth + deltas.left, getMinWidthSetting(editor), getMaxWidthSetting(editor));
+      }
+      return dimensions;
+    };
+    var resize = function (editor, deltas, resizeType) {
+      var container = SugarElement.fromDom(editor.getContainer());
+      var dimensions = getDimensions(editor, deltas, resizeType, get$b(container), get$a(container));
+      each(dimensions, function (val, dim) {
+        return set$7(container, dim, numToPx(val));
+      });
+      fireResizeEditor(editor);
+    };
+
+    var getResizeType = function (editor) {
+      var fallback = !editor.hasPlugin('autoresize');
+      var resize = editor.getParam('resize', fallback);
+      if (resize === false) {
+        return ResizeTypes.None;
+      } else if (resize === 'both') {
+        return ResizeTypes.Both;
+      } else {
+        return ResizeTypes.Vertical;
+      }
+    };
+    var keyboardHandler = function (editor, resizeType, x, y) {
+      var scale = 20;
+      var delta = SugarPosition(x * scale, y * scale);
+      resize(editor, delta, resizeType);
+      return Optional.some(true);
+    };
+    var renderResizeHandler = function (editor, providersBackstage) {
+      var resizeType = getResizeType(editor);
+      if (resizeType === ResizeTypes.None) {
+        return Optional.none();
+      }
+      return Optional.some(render$3('resize-handle', {
+        tag: 'div',
+        classes: ['tox-statusbar__resize-handle'],
+        attributes: { title: providersBackstage.translate('Resize') },
+        behaviours: [
+          Dragging.config({
+            mode: 'mouse',
+            repositionTarget: false,
+            onDrag: function (_comp, _target, delta) {
+              return resize(editor, delta, resizeType);
+            },
+            blockerClass: 'tox-blocker'
+          }),
+          Keying.config({
+            mode: 'special',
+            onLeft: function () {
+              return keyboardHandler(editor, resizeType, -1, 0);
+            },
+            onRight: function () {
+              return keyboardHandler(editor, resizeType, 1, 0);
+            },
+            onUp: function () {
+              return keyboardHandler(editor, resizeType, 0, -1);
+            },
+            onDown: function () {
+              return keyboardHandler(editor, resizeType, 0, 1);
+            }
+          }),
+          Tabstopping.config({}),
+          Focusing.config({})
+        ]
+      }, providersBackstage.icons));
+    };
+
+    var renderWordCount = function (editor, providersBackstage) {
+      var _a;
+      var replaceCountText = function (comp, count, mode) {
+        return Replacing.set(comp, [text$1(providersBackstage.translate([
+            '{0} ' + mode,
+            count[mode]
+          ]))]);
+      };
+      return Button.sketch({
+        dom: {
+          tag: 'button',
+          classes: ['tox-statusbar__wordcount']
+        },
+        components: [],
+        buttonBehaviours: derive$1([
+          DisablingConfigs.button(providersBackstage.isDisabled),
+          receivingConfig(),
+          Tabstopping.config({}),
+          Replacing.config({}),
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: {
+                mode: 'words',
+                count: {
+                  words: 0,
+                  characters: 0
+                }
+              }
+            }
+          }),
+          config('wordcount-events', [
+            runOnExecute$1(function (comp) {
+              var currentVal = Representing.getValue(comp);
+              var newMode = currentVal.mode === 'words' ? 'characters' : 'words';
+              Representing.setValue(comp, {
+                mode: newMode,
+                count: currentVal.count
+              });
+              replaceCountText(comp, currentVal.count, newMode);
+            }),
+            runOnAttached(function (comp) {
+              editor.on('wordCountUpdate', function (e) {
+                var mode = Representing.getValue(comp).mode;
+                Representing.setValue(comp, {
+                  mode: mode,
+                  count: e.wordCount
+                });
+                replaceCountText(comp, e.wordCount, mode);
+              });
+            })
+          ])
+        ]),
+        eventOrder: (_a = {}, _a[execute$5()] = [
+          'disabling',
+          'alloy.base.behaviour',
+          'wordcount-events'
+        ], _a)
+      });
+    };
+
+    var renderStatusbar = function (editor, providersBackstage) {
+      var renderBranding = function () {
+        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 {
+          dom: {
+            tag: 'span',
+            classes: ['tox-statusbar__branding'],
+            innerHtml: linkHtml
+          }
+        };
+      };
+      var getTextComponents = function () {
+        var components = [];
+        if (editor.getParam('elementpath', true, 'boolean')) {
+          components.push(renderElementPath(editor, {}, providersBackstage));
+        }
+        if (editor.hasPlugin('wordcount')) {
+          components.push(renderWordCount(editor, providersBackstage));
+        }
+        if (editor.getParam('branding', true, 'boolean')) {
+          components.push(renderBranding());
+        }
+        if (components.length > 0) {
+          return [{
+              dom: {
+                tag: 'div',
+                classes: ['tox-statusbar__text-container']
+              },
+              components: components
+            }];
+        }
+        return [];
+      };
+      var getComponents = function () {
+        var components = getTextComponents();
+        var resizeHandler = renderResizeHandler(editor, providersBackstage);
+        return components.concat(resizeHandler.toArray());
+      };
+      return {
+        dom: {
+          tag: 'div',
+          classes: ['tox-statusbar']
+        },
+        components: getComponents()
+      };
+    };
+
+    var setup$3 = function (editor) {
+      var _a;
+      var isInline = editor.inline;
+      var mode = isInline ? Inline : Iframe;
+      var header = isStickyToolbar(editor) ? StickyHeader : StaticHeader;
+      var lazyOuterContainer = Optional.none();
+      var platform = detect$1();
+      var isIE = platform.browser.isIE();
+      var platformClasses = isIE ? ['tox-platform-ie'] : [];
+      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$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$7(uiMothership.element, 'width', document.body.clientWidth + 'px');
+      };
+      var makeSinkDefinition = function () {
+        var isGridUiContainer = eq(body(), uiContainer) && get$c(uiContainer, 'display') === 'grid';
+        var sinkSpec = {
+          dom: __assign({
+            tag: 'div',
+            classes: [
+              'tox',
+              'tox-silver-sink',
+              'tox-tinymce-aux'
+            ].concat(platformClasses).concat(deviceClasses)
+          }, dirAttributes),
+          behaviours: derive$1([Positioning.config({
+              useFixed: function () {
+                return isHeaderDocked();
+              }
+            })])
+        };
+        var reactiveWidthSpec = {
+          dom: { styles: { width: document.body.clientWidth + 'px' } },
+          events: derive$2([run$1(windowResize(), resizeUiMothership)])
+        };
+        return deepMerge(sinkSpec, isGridUiContainer ? reactiveWidthSpec : {});
+      };
+      var sink = build$1(makeSinkDefinition());
+      var lazySink = function () {
+        return Result.value(sink);
+      };
+      var memAnchorBar = record({
+        dom: {
+          tag: 'div',
+          classes: ['tox-anchorbar']
+        }
+      });
+      var lazyAnchorBar = function () {
+        return lazyOuterContainer.bind(function (container) {
+          return memAnchorBar.getOpt(container);
+        }).getOrDie('Could not find a anchor bar element');
+      };
+      var lazyToolbar = function () {
+        return lazyOuterContainer.bind(function (container) {
+          return OuterContainer.getToolbar(container);
+        }).getOrDie('Could not find more toolbar element');
+      };
+      var lazyThrobber = function () {
+        return lazyOuterContainer.bind(function (container) {
+          return OuterContainer.getThrobber(container);
+        }).getOrDie('Could not find throbber element');
+      };
+      var backstage = init$7(sink, editor, lazyAnchorBar);
+      var partMenubar = OuterContainer.parts.menubar({
+        dom: {
+          tag: 'div',
+          classes: ['tox-menubar']
+        },
+        backstage: backstage,
+        onEscape: function () {
+          editor.focus();
+        }
+      });
+      var toolbarMode = getToolbarMode(editor);
+      var partToolbar = OuterContainer.parts.toolbar(__assign({
+        dom: {
+          tag: 'div',
+          classes: ['tox-toolbar']
+        },
+        getSink: lazySink,
+        providers: backstage.shared.providers,
+        onEscape: function () {
+          editor.focus();
+        },
+        type: toolbarMode,
+        lazyToolbar: lazyToolbar,
+        lazyHeader: function () {
+          return lazyHeader().getOrDie('Could not find header element');
+        }
+      }, verticalDirAttributes));
+      var partMultipleToolbar = OuterContainer.parts['multiple-toolbar']({
+        dom: {
+          tag: 'div',
+          classes: ['tox-toolbar-overlord']
+        },
+        providers: backstage.shared.providers,
+        onEscape: function () {
+          editor.focus();
+        },
+        type: toolbarMode
+      });
+      var partSocket = OuterContainer.parts.socket({
+        dom: {
+          tag: 'div',
+          classes: ['tox-edit-area']
+        }
+      });
+      var partSidebar = OuterContainer.parts.sidebar({
+        dom: {
+          tag: 'div',
+          classes: ['tox-sidebar']
+        }
+      });
+      var partThrobber = OuterContainer.parts.throbber({
+        dom: {
+          tag: 'div',
+          classes: ['tox-throbber']
+        },
+        backstage: backstage
+      });
+      var sb = editor.getParam('statusbar', true, 'boolean');
+      var statusbar = sb && !isInline ? Optional.some(renderStatusbar(editor, backstage.shared.providers)) : Optional.none();
+      var socketSidebarContainer = {
+        dom: {
+          tag: 'div',
+          classes: ['tox-sidebar-wrap']
+        },
+        components: [
+          partSocket,
+          partSidebar
+        ]
+      };
+      var hasMultipleToolbar = isMultipleToolbars(editor);
+      var hasToolbar = isToolbarEnabled(editor);
+      var hasMenubar = isMenubarEnabled(editor);
+      var getPartToolbar = function () {
+        if (hasMultipleToolbar) {
+          return [partMultipleToolbar];
+        } else if (hasToolbar) {
+          return [partToolbar];
+        } else {
+          return [];
+        }
+      };
+      var partHeader = OuterContainer.parts.header({
+        dom: __assign({
+          tag: 'div',
+          classes: ['tox-editor-header']
+        }, verticalDirAttributes),
+        components: flatten([
+          hasMenubar ? [partMenubar] : [],
+          getPartToolbar(),
+          useFixedContainer(editor) ? [] : [memAnchorBar.asSpec()]
+        ]),
+        sticky: isStickyToolbar(editor),
+        editor: editor,
+        sharedBackstage: backstage.shared
+      });
+      var editorComponents = flatten([
+        isToolbarBottom ? [] : [partHeader],
+        isInline ? [] : [socketSidebarContainer],
+        isToolbarBottom ? [partHeader] : []
+      ]);
+      var editorContainer = {
+        dom: {
+          tag: 'div',
+          classes: ['tox-editor-container']
+        },
+        components: editorComponents
+      };
+      var containerComponents = flatten([
+        [editorContainer],
+        isInline ? [] : statusbar.toArray(),
+        [partThrobber]
+      ]);
+      var isHidden = isDistractionFree(editor);
+      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',
+            'tox-tinymce'
+          ].concat(isInline ? ['tox-tinymce-inline'] : []).concat(isToolbarBottom ? ['tox-tinymce--toolbar-bottom'] : []).concat(deviceClasses).concat(platformClasses),
+          styles: __assign({ visibility: 'hidden' }, isHidden ? {
+            opacity: '0',
+            border: '0'
+          } : {}),
+          attributes: attributes
+        },
+        components: containerComponents,
+        behaviours: derive$1([
+          receivingConfig(),
+          Disabling.config({ disableClass: 'tox-tinymce--disabled' }),
+          Keying.config({
+            mode: 'cyclic',
+            selector: '.tox-menubar, .tox-toolbar, .tox-toolbar__primary, .tox-toolbar__overflow--open, .tox-sidebar__overflow--open, .tox-statusbar__path, .tox-statusbar__wordcount, .tox-statusbar__branding a, .tox-statusbar__resize-handle'
+          })
+        ])
+      }));
+      lazyOuterContainer = Optional.some(outerContainer);
+      editor.shortcuts.add('alt+F9', 'focus menubar', function () {
+        OuterContainer.focusMenubar(outerContainer);
+      });
+      editor.shortcuts.add('alt+F10', 'focus toolbar', function () {
+        OuterContainer.focusToolbar(outerContainer);
+      });
+      editor.addCommand('ToggleToolbarDrawer', function () {
+        OuterContainer.toggleToolbarDrawer(outerContainer);
+      });
+      editor.addQueryStateHandler('ToggleToolbarDrawer', function () {
+        return OuterContainer.isToolbarDrawerToggled(outerContainer);
+      });
+      var mothership = takeover(outerContainer);
+      var uiMothership = takeover(sink);
+      setup$b(editor, mothership, uiMothership);
+      var getUi = function () {
+        var channels = {
+          broadcastAll: uiMothership.broadcast,
+          broadcastOn: uiMothership.broadcastOn,
+          register: noop
+        };
+        return { channels: channels };
+      };
+      var setEditorSize = function () {
+        var parsedHeight = numToPx(getHeightWithFallback(editor));
+        var parsedWidth = numToPx(getWidthWithFallback(editor));
+        if (!editor.inline) {
+          if (isValidValue('div', 'width', parsedWidth)) {
+            set$7(outerContainer.element, 'width', parsedWidth);
+          }
+          if (isValidValue('div', 'height', parsedHeight)) {
+            set$7(outerContainer.element, 'height', parsedHeight);
+          } else {
+            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$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 = {
+          menuItems: menuItems,
+          menus: getMenus(editor),
+          menubar: getMenubar(editor),
+          toolbar: toolbarOpt.getOrThunk(function () {
+            return getToolbar(editor);
+          }),
+          allowToolbarGroups: toolbarMode === ToolbarMode.floating,
+          buttons: buttons,
+          sidebar: sidebars
+        };
+        register$7(editor, contextToolbars, sink, { backstage: backstage });
+        setup$4(editor, sink);
+        var elm = editor.getElement();
+        var height = setEditorSize();
+        var uiComponents = {
+          mothership: mothership,
+          uiMothership: uiMothership,
+          outerContainer: outerContainer
+        };
+        var args = {
+          targetNode: elm,
+          height: height
+        };
+        return mode.render(editor, uiComponents, rawUiConfig, backstage, args);
+      };
+      return {
+        mothership: mothership,
+        uiMothership: uiMothership,
+        backstage: backstage,
+        renderUI: renderUI,
+        getUi: getUi
+      };
+    };
+
+    var describedBy = function (describedElement, describeElement) {
+      var describeId = Optional.from(get$d(describedElement, 'id')).fold(function () {
+        var id = generate$6('dialog-describe');
+        set$8(describeElement, 'id', id);
+        return id;
+      }, identity$1);
+      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$8(labelElement, 'id', id);
+        return id;
+      }, identity$1);
+      set$8(labelledElement, 'aria-labelledby', labelId);
+    };
+
+    var schema$2 = constant$1([
+      required$1('lazySink'),
+      option('dragBlockClass'),
+      defaultedFunction('getBounds', win),
+      defaulted('useTabstopAt', always),
+      defaulted('eventOrder', {}),
+      field('modalBehaviours', [Keying]),
+      onKeyboardHandler('onExecute'),
+      onStrictKeyboardHandler('onEscape')
+    ]);
+    var basic = { sketch: identity$1 };
+    var parts$2 = constant$1([
+      optional({
+        name: 'draghandle',
+        overrides: function (detail, spec) {
+          return {
+            behaviours: derive$1([Dragging.config({
+                mode: 'mouse',
+                getTarget: function (handle) {
+                  return ancestor(handle, '[role="dialog"]').getOr(handle);
+                },
+                blockerClass: detail.dragBlockClass.getOrDie(new Error('The drag blocker class was not specified for a dialog with a drag handle: \n' + JSON.stringify(spec, null, 2)).message),
+                getBounds: detail.getDragBounds
+              })])
+          };
+        }
+      }),
+      required({
+        schema: [required$1('dom')],
+        name: 'title'
+      }),
+      required({
+        factory: basic,
+        schema: [required$1('dom')],
+        name: 'close'
+      }),
+      required({
+        factory: basic,
+        schema: [required$1('dom')],
+        name: 'body'
+      }),
+      optional({
+        factory: basic,
+        schema: [required$1('dom')],
+        name: 'footer'
+      }),
+      external$1({
+        factory: {
+          sketch: function (spec, detail) {
+            return __assign(__assign({}, spec), {
+              dom: detail.dom,
+              components: detail.components
+            });
+          }
+        },
+        schema: [
+          defaulted('dom', {
+            tag: 'div',
+            styles: {
+              position: 'fixed',
+              left: '0px',
+              top: '0px',
+              right: '0px',
+              bottom: '0px'
+            }
+          }),
+          defaulted('components', [])
+        ],
+        name: 'blocker'
+      })
+    ]);
+
+    var factory$4 = function (detail, components, spec, externals) {
+      var _a;
+      var dialogComp = value$1();
+      var showDialog = function (dialog) {
+        dialogComp.set(dialog);
+        var sink = detail.lazySink(dialog).getOrDie();
+        var externalBlocker = externals.blocker();
+        var blocker = sink.getSystem().build(__assign(__assign({}, externalBlocker), {
+          components: externalBlocker.components.concat([premade(dialog)]),
+          behaviours: derive$1([
+            Focusing.config({}),
+            config('dialog-blocker-events', [runOnSource(focusin(), function () {
+                Keying.focusIn(dialog);
+              })])
+          ])
+        }));
+        attach(sink, blocker);
+        Keying.focusIn(dialog);
+      };
+      var hideDialog = function (dialog) {
+        dialogComp.clear();
+        parent(dialog.element).each(function (blockerDom) {
+          dialog.getSystem().getByDom(blockerDom).each(function (blocker) {
+            detach(blocker);
+          });
+        });
+      };
+      var getDialogBody = function (dialog) {
+        return getPartOrDie(dialog, detail, 'body');
+      };
+      var getDialogFooter = function (dialog) {
+        return getPartOrDie(dialog, detail, 'footer');
+      };
+      var setBusy = function (dialog, getBusySpec) {
+        Blocking.block(dialog, getBusySpec);
+      };
+      var setIdle = function (dialog) {
+        Blocking.unblock(dialog);
+      };
+      var modalEventsId = generate$6('modal-events');
+      var eventOrder = __assign(__assign({}, detail.eventOrder), (_a = {}, _a[attachedToDom()] = [modalEventsId].concat(detail.eventOrder['alloy.system.attached'] || []), _a));
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        apis: {
+          show: showDialog,
+          hide: hideDialog,
+          getBody: getDialogBody,
+          getFooter: getDialogFooter,
+          setIdle: setIdle,
+          setBusy: setBusy
+        },
+        eventOrder: eventOrder,
+        domModification: {
+          attributes: {
+            'role': 'dialog',
+            'aria-modal': 'true'
+          }
+        },
+        behaviours: augment(detail.modalBehaviours, [
+          Replacing.config({}),
+          Keying.config({
+            mode: 'cyclic',
+            onEnter: detail.onExecute,
+            onEscape: detail.onEscape,
+            useTabstopAt: detail.useTabstopAt
+          }),
+          Blocking.config({ getRoot: dialogComp.get }),
+          config(modalEventsId, [runOnAttached(function (c) {
+              labelledBy(c.element, getPartOrDie(c, detail, 'title').element);
+              describedBy(c.element, getPartOrDie(c, detail, 'body').element);
+            })])
+        ])
+      };
+    };
+    var ModalDialog = composite({
+      name: 'ModalDialog',
+      configFields: schema$2(),
+      partFields: parts$2(),
+      factory: factory$4,
+      apis: {
+        show: function (apis, dialog) {
+          apis.show(dialog);
+        },
+        hide: function (apis, dialog) {
+          apis.hide(dialog);
+        },
+        getBody: function (apis, dialog) {
+          return apis.getBody(dialog);
+        },
+        getFooter: function (apis, dialog) {
+          return apis.getFooter(dialog);
+        },
+        setBusy: function (apis, dialog, getBusySpec) {
+          apis.setBusy(dialog, getBusySpec);
+        },
+        setIdle: function (apis, dialog) {
+          apis.setIdle(dialog);
+        }
+      }
+    });
+
+    var dialogToggleMenuItemSchema = objOf([
+      requiredString('type'),
+      requiredString('name')
+    ].concat(commonMenuItemFields));
+    var dialogToggleMenuItemDataProcessor = boolean;
+
+    var baseFooterButtonFields = [
+      field$1('name', 'name', defaultedThunk(function () {
+        return generate$6('button-name');
+      }), string),
+      optionString('icon'),
+      defaultedStringEnum('align', 'end', [
+        'start',
+        'end'
+      ]),
+      defaultedBoolean('primary', false),
+      defaultedBoolean('disabled', false)
+    ];
+    var dialogFooterButtonFields = __spreadArray(__spreadArray([], baseFooterButtonFields, true), [requiredString('text')], false);
+    var normalFooterButtonFields = __spreadArray([requiredStringEnum('type', [
+        'submit',
+        'cancel',
+        'custom'
+      ])], dialogFooterButtonFields, true);
+    var menuFooterButtonFields = __spreadArray([
+      requiredStringEnum('type', ['menu']),
+      optionString('text'),
+      optionString('tooltip'),
+      optionString('icon'),
+      requiredArrayOf('items', dialogToggleMenuItemSchema)
+    ], baseFooterButtonFields, true);
+    var dialogFooterButtonSchema = choose$1('type', {
+      submit: normalFooterButtonFields,
+      cancel: normalFooterButtonFields,
+      custom: normalFooterButtonFields,
+      menu: menuFooterButtonFields
+    });
+
+    var alertBannerFields = [
+      requiredString('type'),
+      requiredString('text'),
+      requiredStringEnum('level', [
+        'info',
+        'warn',
+        'error',
+        'success'
+      ]),
+      requiredString('icon'),
+      defaulted('url', '')
+    ];
+    var alertBannerSchema = objOf(alertBannerFields);
+
+    var createBarFields = function (itemsField) {
+      return [
+        requiredString('type'),
+        itemsField
+      ];
+    };
+
+    var buttonFields = [
+      requiredString('type'),
+      requiredString('text'),
+      defaultedBoolean('disabled', false),
+      defaultedBoolean('primary', false),
+      field$1('name', 'name', defaultedThunk(function () {
+        return generate$6('button-name');
+      }), string),
+      optionString('icon'),
+      defaultedBoolean('borderless', false)
+    ];
+    var buttonSchema = objOf(buttonFields);
+
+    var checkboxFields = [
+      requiredString('type'),
+      requiredString('name'),
+      requiredString('label'),
+      defaultedBoolean('disabled', false)
+    ];
+    var checkboxSchema = objOf(checkboxFields);
+    var checkboxDataProcessor = boolean;
+
+    var formComponentFields = [
+      requiredString('type'),
+      requiredString('name')
+    ];
+    var formComponentWithLabelFields = formComponentFields.concat([optionString('label')]);
+
+    var collectionFields = formComponentWithLabelFields.concat([defaulted('columns', 'auto')]);
+    var collectionSchema = objOf(collectionFields);
+    var collectionDataProcessor = arrOfObj([
+      requiredString('value'),
+      requiredString('text'),
+      requiredString('icon')
+    ]);
+
+    var colorInputFields = formComponentWithLabelFields;
+    var colorInputSchema = objOf(colorInputFields);
+    var colorInputDataProcessor = string;
+
+    var colorPickerFields = formComponentWithLabelFields;
+    var colorPickerSchema = objOf(colorPickerFields);
+    var colorPickerDataProcessor = string;
+
+    var customEditorFields = formComponentFields.concat([
+      defaultedString('tag', 'textarea'),
+      requiredString('scriptId'),
+      requiredString('scriptUrl'),
+      defaultedPostMsg('settings', undefined)
+    ]);
+    var customEditorFieldsOld = formComponentFields.concat([
+      defaultedString('tag', 'textarea'),
+      requiredFunction('init')
+    ]);
+    var customEditorSchema = valueOf(function (v) {
+      return asRaw('customeditor.old', objOfOnly(customEditorFieldsOld), v).orThunk(function () {
+        return asRaw('customeditor.new', objOfOnly(customEditorFields), v);
+      });
+    });
+    var customEditorDataProcessor = string;
+
+    var dropZoneFields = formComponentWithLabelFields;
+    var dropZoneSchema = objOf(dropZoneFields);
+    var dropZoneDataProcessor = arrOfVal();
+
+    var createGridFields = function (itemsField) {
+      return [
+        requiredString('type'),
+        requiredNumber('columns'),
+        itemsField
+      ];
+    };
+
+    var htmlPanelFields = [
+      requiredString('type'),
+      requiredString('html'),
+      defaultedStringEnum('presets', 'presentation', [
+        'presentation',
+        'document'
+      ])
+    ];
+    var htmlPanelSchema = objOf(htmlPanelFields);
+
+    var iframeFields = formComponentWithLabelFields.concat([defaultedBoolean('sandboxed', true)]);
+    var iframeSchema = objOf(iframeFields);
+    var iframeDataProcessor = string;
+
+    var imageToolsFields = formComponentWithLabelFields.concat([requiredOf('currentState', objOf([
+        required$1('blob'),
+        requiredString('url')
+      ]))]);
+    var imageToolsSchema = objOf(imageToolsFields);
+
+    var inputFields = formComponentWithLabelFields.concat([
+      optionString('inputMode'),
+      optionString('placeholder'),
+      defaultedBoolean('maximized', false),
+      defaultedBoolean('disabled', false)
+    ]);
+    var inputSchema = objOf(inputFields);
+    var inputDataProcessor = string;
+
+    var createLabelFields = function (itemsField) {
+      return [
+        requiredString('type'),
+        requiredString('label'),
+        itemsField
+      ];
+    };
+
+    var listBoxSingleItemFields = [
+      requiredString('text'),
+      requiredString('value')
+    ];
+    var listBoxNestedItemFields = [
+      requiredString('text'),
+      requiredArrayOf('items', thunkOf('items', function () {
+        return listBoxItemSchema;
+      }))
+    ];
+    var listBoxItemSchema = oneOf([
+      objOf(listBoxSingleItemFields),
+      objOf(listBoxNestedItemFields)
+    ]);
+    var listBoxFields = formComponentWithLabelFields.concat([
+      requiredArrayOf('items', listBoxItemSchema),
+      defaultedBoolean('disabled', false)
+    ]);
+    var listBoxSchema = objOf(listBoxFields);
+    var listBoxDataProcessor = string;
+
+    var selectBoxFields = formComponentWithLabelFields.concat([
+      requiredArrayOfObj('items', [
+        requiredString('text'),
+        requiredString('value')
+      ]),
+      defaultedNumber('size', 1),
+      defaultedBoolean('disabled', false)
+    ]);
+    var selectBoxSchema = objOf(selectBoxFields);
+    var selectBoxDataProcessor = string;
+
+    var sizeInputFields = formComponentWithLabelFields.concat([
+      defaultedBoolean('constrain', true),
+      defaultedBoolean('disabled', false)
+    ]);
+    var sizeInputSchema = objOf(sizeInputFields);
+    var sizeInputDataProcessor = objOf([
+      requiredString('width'),
+      requiredString('height')
+    ]);
+
+    var tableFields = [
+      requiredString('type'),
+      requiredArrayOf('header', string),
+      requiredArrayOf('cells', arrOf(string))
+    ];
+    var tableSchema = objOf(tableFields);
+
+    var textAreaFields = formComponentWithLabelFields.concat([
+      optionString('placeholder'),
+      defaultedBoolean('maximized', false),
+      defaultedBoolean('disabled', false)
+    ]);
+    var textAreaSchema = objOf(textAreaFields);
+    var textAreaDataProcessor = string;
+
+    var urlInputFields = formComponentWithLabelFields.concat([
+      defaultedStringEnum('filetype', 'file', [
+        'image',
+        'media',
+        'file'
+      ]),
+      defaulted('disabled', false)
+    ]);
+    var urlInputSchema = objOf(urlInputFields);
+    var urlInputDataProcessor = objOf([
+      requiredString('value'),
+      defaulted('meta', {})
+    ]);
+
+    var createItemsField = function (name) {
+      return field$1('items', 'items', required$2(), arrOf(valueOf(function (v) {
+        return asRaw('Checking item of ' + name, itemSchema, v).fold(function (sErr) {
+          return Result.error(formatError(sErr));
+        }, function (passValue) {
+          return Result.value(passValue);
+        });
+      })));
+    };
+    var itemSchema = valueThunk(function () {
+      return choose$2('type', {
+        alertbanner: alertBannerSchema,
+        bar: objOf(createBarFields(createItemsField('bar'))),
+        button: buttonSchema,
+        checkbox: checkboxSchema,
+        colorinput: colorInputSchema,
+        colorpicker: colorPickerSchema,
+        dropzone: dropZoneSchema,
+        grid: objOf(createGridFields(createItemsField('grid'))),
+        iframe: iframeSchema,
+        input: inputSchema,
+        listbox: listBoxSchema,
+        selectbox: selectBoxSchema,
+        sizeinput: sizeInputSchema,
+        textarea: textAreaSchema,
+        urlinput: urlInputSchema,
+        customeditor: customEditorSchema,
+        htmlpanel: htmlPanelSchema,
+        imagetools: imageToolsSchema,
+        collection: collectionSchema,
+        label: objOf(createLabelFields(createItemsField('label'))),
+        table: tableSchema,
+        panel: panelSchema
+      });
+    });
+    var panelFields = [
+      requiredString('type'),
+      defaulted('classes', []),
+      requiredArrayOf('items', itemSchema)
+    ];
+    var panelSchema = objOf(panelFields);
+
+    var tabFields = [
+      field$1('name', 'name', defaultedThunk(function () {
+        return generate$6('tab-name');
+      }), string),
+      requiredString('title'),
+      requiredArrayOf('items', itemSchema)
+    ];
+    var tabPanelFields = [
+      requiredString('type'),
+      requiredArrayOfObj('tabs', tabFields)
+    ];
+    var tabPanelSchema = objOf(tabPanelFields);
+
+    var dialogButtonFields = dialogFooterButtonFields;
+    var dialogButtonSchema = dialogFooterButtonSchema;
+    var dialogSchema = objOf([
+      requiredString('title'),
+      requiredOf('body', choose$2('type', {
+        panel: panelSchema,
+        tabpanel: tabPanelSchema
+      })),
+      defaultedString('size', 'normal'),
+      requiredArrayOf('buttons', dialogButtonSchema),
+      defaulted('initialData', {}),
+      defaultedFunction('onAction', noop),
+      defaultedFunction('onChange', noop),
+      defaultedFunction('onSubmit', noop),
+      defaultedFunction('onClose', noop),
+      defaultedFunction('onCancel', noop),
+      defaulted('onTabChange', noop)
+    ]);
+    var createDialog = function (spec) {
+      return asRaw('dialog', dialogSchema, spec);
+    };
+
+    var urlDialogButtonSchema = objOf(__spreadArray([requiredStringEnum('type', [
+        'cancel',
+        'custom'
+      ])], dialogButtonFields, true));
+    var urlDialogSchema = objOf([
+      requiredString('title'),
+      requiredString('url'),
+      optionNumber('height'),
+      optionNumber('width'),
+      optionArrayOf('buttons', urlDialogButtonSchema),
+      defaultedFunction('onAction', noop),
+      defaultedFunction('onCancel', noop),
+      defaultedFunction('onClose', noop),
+      defaultedFunction('onMessage', noop)
+    ]);
+    var createUrlDialog = function (spec) {
+      return asRaw('dialog', urlDialogSchema, spec);
+    };
+
+    var getAllObjects = function (obj) {
+      if (isObject(obj)) {
+        return [obj].concat(bind$3(values(obj), getAllObjects));
+      } else if (isArray(obj)) {
+        return bind$3(obj, getAllObjects);
+      } else {
+        return [];
+      }
+    };
+
+    var isNamedItem = function (obj) {
+      return isString(obj.type) && isString(obj.name);
+    };
+    var dataProcessors = {
+      checkbox: checkboxDataProcessor,
+      colorinput: colorInputDataProcessor,
+      colorpicker: colorPickerDataProcessor,
+      dropzone: dropZoneDataProcessor,
+      input: inputDataProcessor,
+      iframe: iframeDataProcessor,
+      sizeinput: sizeInputDataProcessor,
+      selectbox: selectBoxDataProcessor,
+      listbox: listBoxDataProcessor,
+      size: sizeInputDataProcessor,
+      textarea: textAreaDataProcessor,
+      urlinput: urlInputDataProcessor,
+      customeditor: customEditorDataProcessor,
+      collection: collectionDataProcessor,
+      togglemenuitem: dialogToggleMenuItemDataProcessor
+    };
+    var getDataProcessor = function (item) {
+      return Optional.from(dataProcessors[item.type]);
+    };
+    var getNamedItems = function (structure) {
+      return filter$2(getAllObjects(structure), isNamedItem);
+    };
+
+    var createDataValidator = function (structure) {
+      var namedItems = getNamedItems(structure);
+      var fields = bind$3(namedItems, function (item) {
+        return getDataProcessor(item).fold(function () {
+          return [];
+        }, function (schema) {
+          return [requiredOf(item.name, schema)];
+        });
+      });
+      return objOf(fields);
+    };
+
+    var extract = function (structure) {
+      var internalDialog = getOrDie(createDialog(structure));
+      var dataValidator = createDataValidator(structure);
+      var initialData = structure.initialData;
+      return {
+        internalDialog: internalDialog,
+        dataValidator: dataValidator,
+        initialData: initialData
+      };
+    };
+    var DialogManager = {
+      open: function (factory, structure) {
+        var extraction = extract(structure);
+        return factory(extraction.internalDialog, extraction.initialData, extraction.dataValidator);
+      },
+      openUrl: function (factory, structure) {
+        var internalDialog = getOrDie(createUrlDialog(structure));
+        return factory(internalDialog);
+      },
+      redial: function (structure) {
+        return extract(structure);
+      }
+    };
+
+    var toValidValues = function (values) {
+      var errors = [];
+      var result = {};
+      each(values, function (value, name) {
+        value.fold(function () {
+          errors.push(name);
+        }, function (v) {
+          result[name] = v;
+        });
+      });
+      return errors.length > 0 ? Result.error(errors) : Result.value(result);
+    };
+
+    var renderBodyPanel = function (spec, backstage) {
+      var memForm = record(Form.sketch(function (parts) {
+        return {
+          dom: {
+            tag: 'div',
+            classes: ['tox-form'].concat(spec.classes)
+          },
+          components: map$2(spec.items, function (item) {
+            return interpretInForm(parts, item, backstage);
+          })
+        };
+      }));
+      return {
+        dom: {
+          tag: 'div',
+          classes: ['tox-dialog__body']
+        },
+        components: [{
+            dom: {
+              tag: 'div',
+              classes: ['tox-dialog__body-content']
+            },
+            components: [memForm.asSpec()]
+          }],
+        behaviours: derive$1([
+          Keying.config({
+            mode: 'acyclic',
+            useTabstopAt: not(isPseudoStop)
+          }),
+          ComposingConfigs.memento(memForm),
+          RepresentingConfigs.memento(memForm, {
+            postprocess: function (formValue) {
+              return toValidValues(formValue).fold(function (err) {
+                console.error(err);
+                return {};
+              }, identity$1);
+            }
+          })
+        ])
+      };
+    };
+
+    var factory$3 = function (detail, _spec) {
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: detail.components,
+        events: events$a(detail.action),
+        behaviours: augment(detail.tabButtonBehaviours, [
+          Focusing.config({}),
+          Keying.config({
+            mode: 'execution',
+            useSpace: true,
+            useEnter: true
+          }),
+          Representing.config({
+            store: {
+              mode: 'memory',
+              initialValue: detail.value
+            }
+          })
+        ]),
+        domModification: detail.domModification
+      };
+    };
+    var TabButton = single({
+      name: 'TabButton',
+      configFields: [
+        defaulted('uid', undefined),
+        required$1('value'),
+        field$1('dom', 'dom', mergeWithThunk(function () {
+          return {
+            attributes: {
+              'role': 'tab',
+              'id': generate$6('aria'),
+              'aria-selected': 'false'
+            }
+          };
+        }), anyValue()),
+        option('action'),
+        defaulted('domModification', {}),
+        field('tabButtonBehaviours', [
+          Focusing,
+          Keying,
+          Representing
+        ]),
+        required$1('view')
+      ],
+      factory: factory$3
+    });
+
+    var schema$1 = constant$1([
+      required$1('tabs'),
+      required$1('dom'),
+      defaulted('clickToDismiss', false),
+      field('tabbarBehaviours', [
+        Highlighting,
+        Keying
+      ]),
+      markers$1([
+        'tabClass',
+        'selectedClass'
+      ])
+    ]);
+    var tabsPart = group({
+      factory: TabButton,
+      name: 'tabs',
+      unit: 'tab',
+      overrides: function (barDetail) {
+        var dismissTab$1 = function (tabbar, button) {
+          Highlighting.dehighlight(tabbar, button);
+          emitWith(tabbar, dismissTab(), {
+            tabbar: tabbar,
+            button: button
+          });
+        };
+        var changeTab$1 = function (tabbar, button) {
+          Highlighting.highlight(tabbar, button);
+          emitWith(tabbar, changeTab(), {
+            tabbar: tabbar,
+            button: button
+          });
+        };
+        return {
+          action: function (button) {
+            var tabbar = button.getSystem().getByUid(barDetail.uid).getOrDie();
+            var activeButton = Highlighting.isHighlighted(tabbar, button);
+            var response = function () {
+              if (activeButton && barDetail.clickToDismiss) {
+                return dismissTab$1;
+              } else if (!activeButton) {
+                return changeTab$1;
+              } else {
+                return noop;
+              }
+            }();
+            response(tabbar, button);
+          },
+          domModification: { classes: [barDetail.markers.tabClass] }
+        };
+      }
+    });
+    var parts$1 = constant$1([tabsPart]);
+
+    var factory$2 = function (detail, components, _spec, _externals) {
+      return {
+        'uid': detail.uid,
+        'dom': detail.dom,
+        components: components,
+        'debug.sketcher': 'Tabbar',
+        'domModification': { attributes: { role: 'tablist' } },
+        'behaviours': augment(detail.tabbarBehaviours, [
+          Highlighting.config({
+            highlightClass: detail.markers.selectedClass,
+            itemClass: detail.markers.tabClass,
+            onHighlight: function (tabbar, tab) {
+              set$8(tab.element, 'aria-selected', 'true');
+            },
+            onDehighlight: function (tabbar, tab) {
+              set$8(tab.element, 'aria-selected', 'false');
+            }
+          }),
+          Keying.config({
+            mode: 'flow',
+            getInitial: function (tabbar) {
+              return Highlighting.getHighlighted(tabbar).map(function (tab) {
+                return tab.element;
+              });
+            },
+            selector: '.' + detail.markers.tabClass,
+            executeOnMove: true
+          })
+        ])
+      };
+    };
+    var Tabbar = composite({
+      name: 'Tabbar',
+      configFields: schema$1(),
+      partFields: parts$1(),
+      factory: factory$2
+    });
+
+    var factory$1 = function (detail, _spec) {
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        behaviours: augment(detail.tabviewBehaviours, [Replacing.config({})]),
+        domModification: { attributes: { role: 'tabpanel' } }
+      };
+    };
+    var Tabview = single({
+      name: 'Tabview',
+      configFields: [field('tabviewBehaviours', [Replacing])],
+      factory: factory$1
+    });
+
+    var schema = constant$1([
+      defaulted('selectFirst', true),
+      onHandler('onChangeTab'),
+      onHandler('onDismissTab'),
+      defaulted('tabs', []),
+      field('tabSectionBehaviours', [])
+    ]);
+    var barPart = required({
+      factory: Tabbar,
+      schema: [
+        required$1('dom'),
+        requiredObjOf('markers', [
+          required$1('tabClass'),
+          required$1('selectedClass')
+        ])
+      ],
+      name: 'tabbar',
+      defaults: function (detail) {
+        return { tabs: detail.tabs };
+      }
+    });
+    var viewPart = required({
+      factory: Tabview,
+      name: 'tabview'
+    });
+    var parts = constant$1([
+      barPart,
+      viewPart
+    ]);
+
+    var factory = function (detail, components, _spec, _externals) {
+      var changeTab$1 = function (button) {
+        var tabValue = Representing.getValue(button);
+        getPart(button, detail, 'tabview').each(function (tabview) {
+          var tabWithValue = find$5(detail.tabs, function (t) {
+            return t.value === tabValue;
+          });
+          tabWithValue.each(function (tabData) {
+            var panel = tabData.view();
+            getOpt(button.element, 'id').each(function (id) {
+              set$8(tabview.element, 'aria-labelledby', id);
+            });
+            Replacing.set(tabview, panel);
+            detail.onChangeTab(tabview, button, panel);
+          });
+        });
+      };
+      var changeTabBy = function (section, byPred) {
+        getPart(section, detail, 'tabbar').each(function (tabbar) {
+          byPred(tabbar).each(emitExecute);
+        });
+      };
+      return {
+        uid: detail.uid,
+        dom: detail.dom,
+        components: components,
+        behaviours: get$2(detail.tabSectionBehaviours),
+        events: derive$2(flatten([
+          detail.selectFirst ? [runOnAttached(function (section, _simulatedEvent) {
+              changeTabBy(section, Highlighting.getFirst);
+            })] : [],
+          [
+            run$1(changeTab(), function (section, simulatedEvent) {
+              var button = simulatedEvent.event.button;
+              changeTab$1(button);
+            }),
+            run$1(dismissTab(), function (section, simulatedEvent) {
+              var button = simulatedEvent.event.button;
+              detail.onDismissTab(section, button);
+            })
+          ]
+        ])),
+        apis: {
+          getViewItems: function (section) {
+            return getPart(section, detail, 'tabview').map(function (tabview) {
+              return Replacing.contents(tabview);
+            }).getOr([]);
+          },
+          showTab: function (section, tabKey) {
+            var getTabIfNotActive = function (tabbar) {
+              var candidates = Highlighting.getCandidates(tabbar);
+              var optTab = find$5(candidates, function (c) {
+                return Representing.getValue(c) === tabKey;
+              });
+              return optTab.filter(function (tab) {
+                return !Highlighting.isHighlighted(tabbar, tab);
+              });
+            };
+            changeTabBy(section, getTabIfNotActive);
+          }
+        }
+      };
+    };
+    var TabSection = composite({
+      name: 'TabSection',
+      configFields: schema(),
+      partFields: parts(),
+      factory: factory,
+      apis: {
+        getViewItems: function (apis, component) {
+          return apis.getViewItems(component);
+        },
+        showTab: function (apis, component, tabKey) {
+          apis.showTab(component, tabKey);
+        }
+      }
+    });
+
+    var measureHeights = function (allTabs, tabview, tabviewComp) {
+      return map$2(allTabs, function (_tab, i) {
+        Replacing.set(tabviewComp, allTabs[i].view());
+        var rect = tabview.dom.getBoundingClientRect();
+        Replacing.set(tabviewComp, []);
+        return rect.height;
+      });
+    };
+    var getMaxHeight = function (heights) {
+      return head(sort(heights, function (a, b) {
+        if (a > b) {
+          return -1;
+        } else if (a < b) {
+          return +1;
+        } else {
+          return 0;
+        }
+      }));
+    };
+    var getMaxTabviewHeight = function (dialog, tabview, tablist) {
+      var documentElement$1 = documentElement(dialog).dom;
+      var rootElm = ancestor(dialog, '.tox-dialog-wrap').getOr(dialog);
+      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$b(tabview);
+      var isTabListBeside = tabview.dom.offsetLeft >= tablist.dom.offsetLeft + get$a(tablist);
+      var currentTabHeight = isTabListBeside ? Math.max(get$b(tablist), tabviewHeight) : tabviewHeight;
+      var dialogTopMargin = parseInt(get$c(dialog, 'margin-top'), 10) || 0;
+      var dialogBottomMargin = parseInt(get$c(dialog, 'margin-bottom'), 10) || 0;
+      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$7(tabview, 'height', height + 'px');
+      if (!detect$1().browser.isIE()) {
+        set$7(tabview, 'flex-basis', height + 'px');
+      } else {
+        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$7(tabview, 'height', '0');
+            set$7(tabview, 'flex-basis', '0');
+            return Math.min(height, getMaxTabviewHeight(dialog, tabview, tablist));
+          }).each(function (height) {
+            setTabviewHeight(tabview, height);
+          });
+        });
+      });
+    };
+    var getTabview = function (dialog) {
+      return descendant(dialog, '[role="tabpanel"]');
+    };
+    var setMode = function (allTabs) {
+      var smartTabHeight = function () {
+        var maxTabHeight = value$1();
+        var extraEvents = [
+          runOnAttached(function (comp) {
+            var dialog = comp.element;
+            getTabview(dialog).each(function (tabview) {
+              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$6(tabview, 'visibility');
+              showTab(allTabs, comp);
+              global$f.requestAnimationFrame(function () {
+                updateTabviewHeight(dialog, tabview, maxTabHeight);
+              });
+            });
+          }),
+          run$1(windowResize(), function (comp) {
+            var dialog = comp.element;
+            getTabview(dialog).each(function (tabview) {
+              updateTabviewHeight(dialog, tabview, maxTabHeight);
+            });
+          }),
+          run$1(formResizeEvent, function (comp, _se) {
+            var dialog = comp.element;
+            getTabview(dialog).each(function (tabview) {
+              var oldFocus = active(getRootNode(tabview));
+              set$7(tabview, 'visibility', 'hidden');
+              var oldHeight = getRaw(tabview, 'height').map(function (h) {
+                return parseInt(h, 10);
+              });
+              remove$6(tabview, 'height');
+              remove$6(tabview, 'flex-basis');
+              var newHeight = tabview.dom.getBoundingClientRect().height;
+              var hasGrown = oldHeight.forall(function (h) {
+                return newHeight > h;
+              });
+              if (hasGrown) {
+                maxTabHeight.set(newHeight);
+                updateTabviewHeight(dialog, tabview, maxTabHeight);
+              } else {
+                oldHeight.each(function (h) {
+                  setTabviewHeight(tabview, h);
+                });
+              }
+              remove$6(tabview, 'visibility');
+              oldFocus.each(focus$3);
+            });
+          })
+        ];
+        var selectFirst = false;
+        return {
+          extraEvents: extraEvents,
+          selectFirst: selectFirst
+        };
+      }();
+      var naiveTabHeight = function () {
+        var extraEvents = [];
+        var selectFirst = true;
+        return {
+          extraEvents: extraEvents,
+          selectFirst: selectFirst
+        };
+      }();
+      return {
+        smartTabHeight: smartTabHeight,
+        naiveTabHeight: naiveTabHeight
+      };
+    };
+
+    var SendDataToSectionChannel = 'send-data-to-section';
+    var SendDataToViewChannel = 'send-data-to-view';
+    var renderTabPanel = function (spec, backstage) {
+      var storedValue = Cell({});
+      var updateDataWithForm = function (form) {
+        var formData = Representing.getValue(form);
+        var validData = toValidValues(formData).getOr({});
+        var currentData = storedValue.get();
+        var newData = deepMerge(currentData, validData);
+        storedValue.set(newData);
+      };
+      var setDataOnForm = function (form) {
+        var tabData = storedValue.get();
+        Representing.setValue(form, tabData);
+      };
+      var oldTab = Cell(null);
+      var allTabs = map$2(spec.tabs, function (tab) {
+        return {
+          value: tab.name,
+          dom: {
+            tag: 'div',
+            classes: ['tox-dialog__body-nav-item'],
+            innerHtml: backstage.shared.providers.translate(tab.title)
+          },
+          view: function () {
+            return [Form.sketch(function (parts) {
+                return {
+                  dom: {
+                    tag: 'div',
+                    classes: ['tox-form']
+                  },
+                  components: map$2(tab.items, function (item) {
+                    return interpretInForm(parts, item, backstage);
+                  }),
+                  formBehaviours: derive$1([
+                    Keying.config({
+                      mode: 'acyclic',
+                      useTabstopAt: not(isPseudoStop)
+                    }),
+                    config('TabView.form.events', [
+                      runOnAttached(setDataOnForm),
+                      runOnDetached(updateDataWithForm)
+                    ]),
+                    Receiving.config({
+                      channels: wrapAll([
+                        {
+                          key: SendDataToSectionChannel,
+                          value: { onReceive: updateDataWithForm }
+                        },
+                        {
+                          key: SendDataToViewChannel,
+                          value: { onReceive: setDataOnForm }
+                        }
+                      ])
+                    })
+                  ])
+                };
+              })];
+          }
+        };
+      });
+      var tabMode = setMode(allTabs).smartTabHeight;
+      return TabSection.sketch({
+        dom: {
+          tag: 'div',
+          classes: ['tox-dialog__body']
+        },
+        onChangeTab: function (section, button, _viewItems) {
+          var name = Representing.getValue(button);
+          emitWith(section, formTabChangeEvent, {
+            name: name,
+            oldName: oldTab.get()
+          });
+          oldTab.set(name);
+        },
+        tabs: allTabs,
+        components: [
+          TabSection.parts.tabbar({
+            dom: {
+              tag: 'div',
+              classes: ['tox-dialog__body-nav']
+            },
+            components: [Tabbar.parts.tabs({})],
+            markers: {
+              tabClass: 'tox-tab',
+              selectedClass: 'tox-dialog__body-nav-item--active'
+            },
+            tabbarBehaviours: derive$1([Tabstopping.config({})])
+          }),
+          TabSection.parts.tabview({
+            dom: {
+              tag: 'div',
+              classes: ['tox-dialog__body-content']
+            }
+          })
+        ],
+        selectFirst: tabMode.selectFirst,
+        tabSectionBehaviours: derive$1([
+          config('tabpanel', tabMode.extraEvents),
+          Keying.config({ mode: 'acyclic' }),
+          Composing.config({
+            find: function (comp) {
+              return head(TabSection.getViewItems(comp));
+            }
+          }),
+          Representing.config({
+            store: {
+              mode: 'manual',
+              getValue: function (tsection) {
+                tsection.getSystem().broadcastOn([SendDataToSectionChannel], {});
+                return storedValue.get();
+              },
+              setValue: function (tsection, value) {
+                storedValue.set(value);
+                tsection.getSystem().broadcastOn([SendDataToViewChannel], {});
+              }
+            }
+          })
+        ])
+      });
+    };
+
+    var dialogChannel = generate$6('update-dialog');
+    var titleChannel = generate$6('update-title');
+    var bodyChannel = generate$6('update-body');
+    var footerChannel = generate$6('update-footer');
+    var bodySendMessageChannel = generate$6('body-send-message');
+
+    var renderBody = function (spec, id, backstage, ariaAttrs) {
+      var renderComponents = function (incoming) {
+        switch (incoming.body.type) {
+        case 'tabpanel': {
+            return [renderTabPanel(incoming.body, backstage)];
+          }
+        default: {
+            return [renderBodyPanel(incoming.body, backstage)];
+          }
+        }
+      };
+      var updateState = function (_comp, incoming) {
+        return Optional.some({
+          isTabPanel: function () {
+            return incoming.body.type === 'tabpanel';
+          }
+        });
+      };
+      var ariaAttributes = { 'aria-live': 'polite' };
+      return {
+        dom: {
+          tag: 'div',
+          classes: ['tox-dialog__content-js'],
+          attributes: __assign(__assign({}, id.map(function (x) {
+            return { id: x };
+          }).getOr({})), ariaAttrs ? ariaAttributes : {})
+        },
+        components: [],
+        behaviours: derive$1([
+          ComposingConfigs.childAt(0),
+          Reflecting.config({
+            channel: bodyChannel,
+            updateState: updateState,
+            renderComponents: renderComponents,
+            initialData: spec
+          })
+        ])
+      };
+    };
+    var renderInlineBody = function (spec, contentId, backstage, ariaAttrs) {
+      return renderBody(spec, Optional.some(contentId), backstage, ariaAttrs);
+    };
+    var renderModalBody = function (spec, backstage) {
+      var bodySpec = renderBody(spec, Optional.none(), backstage, false);
+      return ModalDialog.parts.body(bodySpec);
+    };
+    var renderIframeBody = function (spec) {
+      var bodySpec = {
+        dom: {
+          tag: 'div',
+          classes: ['tox-dialog__content-js']
+        },
+        components: [{
+            dom: {
+              tag: 'div',
+              classes: ['tox-dialog__body-iframe']
+            },
+            components: [craft({
+                dom: {
+                  tag: 'iframe',
+                  attributes: { src: spec.url }
+                },
+                behaviours: derive$1([
+                  Tabstopping.config({}),
+                  Focusing.config({})
+                ])
+              })]
+          }],
+        behaviours: derive$1([Keying.config({
+            mode: 'acyclic',
+            useTabstopAt: not(isPseudoStop)
+          })])
+      };
+      return ModalDialog.parts.body(bodySpec);
+    };
+
+    function _typeof(obj) {
+      '@babel/helpers - typeof';
+      return _typeof = 'function' == typeof Symbol && 'symbol' == typeof Symbol.iterator ? function (obj) {
+        return typeof obj;
+      } : function (obj) {
+        return obj && 'function' == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj;
+      }, _typeof(obj);
+    }
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+      };
+      return _setPrototypeOf(o, p);
+    }
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === 'undefined' || !Reflect.construct)
+        return false;
+      if (Reflect.construct.sham)
+        return false;
+      if (typeof Proxy === 'function')
+        return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    function _construct(Parent, args, Class) {
+      if (_isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+      } else {
+        _construct = function _construct(Parent, args, Class) {
+          var a = [null];
+          a.push.apply(a, args);
+          var Constructor = Function.bind.apply(Parent, a);
+          var instance = new Constructor();
+          if (Class)
+            _setPrototypeOf(instance, Class.prototype);
+          return instance;
+        };
+      }
+      return _construct.apply(null, arguments);
+    }
+    function _toConsumableArray(arr) {
+      return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+    }
+    function _arrayWithoutHoles(arr) {
+      if (Array.isArray(arr))
+        return _arrayLikeToArray(arr);
+    }
+    function _iterableToArray(iter) {
+      if (typeof Symbol !== 'undefined' && iter[Symbol.iterator] != null || iter['@@iterator'] != null)
+        return Array.from(iter);
+    }
+    function _unsupportedIterableToArray(o, minLen) {
+      if (!o)
+        return;
+      if (typeof o === 'string')
+        return _arrayLikeToArray(o, minLen);
+      var n = Object.prototype.toString.call(o).slice(8, -1);
+      if (n === 'Object' && o.constructor)
+        n = o.constructor.name;
+      if (n === 'Map' || n === 'Set')
+        return Array.from(o);
+      if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _arrayLikeToArray(o, minLen);
+    }
+    function _arrayLikeToArray(arr, len) {
+      if (len == null || len > arr.length)
+        len = arr.length;
+      for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+      return arr2;
+    }
+    function _nonIterableSpread() {
+      throw new TypeError('Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.');
+    }
+    var hasOwnProperty = Object.hasOwnProperty, setPrototypeOf = Object.setPrototypeOf, isFrozen = Object.isFrozen, getPrototypeOf = Object.getPrototypeOf, getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    var freeze = Object.freeze, seal = Object.seal, create = Object.create;
+    var _ref = typeof Reflect !== 'undefined' && Reflect, apply = _ref.apply, construct = _ref.construct;
+    if (!apply) {
+      apply = function apply(fun, thisValue, args) {
+        return fun.apply(thisValue, args);
+      };
+    }
+    if (!freeze) {
+      freeze = function freeze(x) {
+        return x;
+      };
+    }
+    if (!seal) {
+      seal = function seal(x) {
+        return x;
+      };
+    }
+    if (!construct) {
+      construct = function construct(Func, args) {
+        return _construct(Func, _toConsumableArray(args));
+      };
+    }
+    var arrayForEach = unapply(Array.prototype.forEach);
+    var arrayPop = unapply(Array.prototype.pop);
+    var arrayPush = unapply(Array.prototype.push);
+    var stringToLowerCase = unapply(String.prototype.toLowerCase);
+    var stringMatch = unapply(String.prototype.match);
+    var stringReplace = unapply(String.prototype.replace);
+    var stringIndexOf = unapply(String.prototype.indexOf);
+    var stringTrim = unapply(String.prototype.trim);
+    var regExpTest = unapply(RegExp.prototype.test);
+    var typeErrorCreate = unconstruct(TypeError);
+    function unapply(func) {
+      return function (thisArg) {
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        return apply(func, thisArg, args);
+      };
+    }
+    function unconstruct(func) {
+      return function () {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        return construct(func, args);
+      };
+    }
+    function addToSet(set, array) {
+      if (setPrototypeOf) {
+        setPrototypeOf(set, null);
+      }
+      var l = array.length;
+      while (l--) {
+        var element = array[l];
+        if (typeof element === 'string') {
+          var lcElement = stringToLowerCase(element);
+          if (lcElement !== element) {
+            if (!isFrozen(array)) {
+              array[l] = lcElement;
+            }
+            element = lcElement;
+          }
+        }
+        set[element] = true;
+      }
+      return set;
+    }
+    function clone(object) {
+      var newObject = create(null);
+      var property;
+      for (property in object) {
+        if (apply(hasOwnProperty, object, [property])) {
+          newObject[property] = object[property];
+        }
+      }
+      return newObject;
+    }
+    function lookupGetter(object, prop) {
+      while (object !== null) {
+        var desc = getOwnPropertyDescriptor(object, prop);
+        if (desc) {
+          if (desc.get) {
+            return unapply(desc.get);
+          }
+          if (typeof desc.value === 'function') {
+            return unapply(desc.value);
+          }
+        }
+        object = getPrototypeOf(object);
+      }
+      function fallbackValue(element) {
+        console.warn('fallback value for', element);
+        return null;
+      }
+      return fallbackValue;
+    }
+    var html$1 = freeze([
+      'a',
+      'abbr',
+      'acronym',
+      'address',
+      'area',
+      'article',
+      'aside',
+      'audio',
+      'b',
+      'bdi',
+      'bdo',
+      'big',
+      'blink',
+      'blockquote',
+      'body',
+      'br',
+      'button',
+      'canvas',
+      'caption',
+      'center',
+      'cite',
+      'code',
+      'col',
+      'colgroup',
+      'content',
+      'data',
+      'datalist',
+      'dd',
+      'decorator',
+      'del',
+      'details',
+      'dfn',
+      'dialog',
+      'dir',
+      'div',
+      'dl',
+      'dt',
+      'element',
+      'em',
+      'fieldset',
+      'figcaption',
+      'figure',
+      'font',
+      'footer',
+      'form',
+      'h1',
+      'h2',
+      'h3',
+      'h4',
+      'h5',
+      'h6',
+      'head',
+      'header',
+      'hgroup',
+      'hr',
+      'html',
+      'i',
+      'img',
+      'input',
+      'ins',
+      'kbd',
+      'label',
+      'legend',
+      'li',
+      'main',
+      'map',
+      'mark',
+      'marquee',
+      'menu',
+      'menuitem',
+      'meter',
+      'nav',
+      'nobr',
+      'ol',
+      'optgroup',
+      'option',
+      'output',
+      'p',
+      'picture',
+      'pre',
+      'progress',
+      'q',
+      'rp',
+      'rt',
+      'ruby',
+      's',
+      'samp',
+      'section',
+      'select',
+      'shadow',
+      'small',
+      'source',
+      'spacer',
+      'span',
+      'strike',
+      'strong',
+      'style',
+      'sub',
+      'summary',
+      'sup',
+      'table',
+      'tbody',
+      'td',
+      'template',
+      'textarea',
+      'tfoot',
+      'th',
+      'thead',
+      'time',
+      'tr',
+      'track',
+      'tt',
+      'u',
+      'ul',
+      'var',
+      'video',
+      'wbr'
+    ]);
+    var svg$1 = freeze([
+      'svg',
+      'a',
+      'altglyph',
+      'altglyphdef',
+      'altglyphitem',
+      'animatecolor',
+      'animatemotion',
+      'animatetransform',
+      'circle',
+      'clippath',
+      'defs',
+      'desc',
+      'ellipse',
+      'filter',
+      'font',
+      'g',
+      'glyph',
+      'glyphref',
+      'hkern',
+      'image',
+      'line',
+      'lineargradient',
+      'marker',
+      'mask',
+      'metadata',
+      'mpath',
+      'path',
+      'pattern',
+      'polygon',
+      'polyline',
+      'radialgradient',
+      'rect',
+      'stop',
+      'style',
+      'switch',
+      'symbol',
+      'text',
+      'textpath',
+      'title',
+      'tref',
+      'tspan',
+      'view',
+      'vkern'
+    ]);
+    var svgFilters = freeze([
+      'feBlend',
+      'feColorMatrix',
+      'feComponentTransfer',
+      'feComposite',
+      'feConvolveMatrix',
+      'feDiffuseLighting',
+      'feDisplacementMap',
+      'feDistantLight',
+      'feFlood',
+      'feFuncA',
+      'feFuncB',
+      'feFuncG',
+      'feFuncR',
+      'feGaussianBlur',
+      'feImage',
+      'feMerge',
+      'feMergeNode',
+      'feMorphology',
+      'feOffset',
+      'fePointLight',
+      'feSpecularLighting',
+      'feSpotLight',
+      'feTile',
+      'feTurbulence'
+    ]);
+    var svgDisallowed = freeze([
+      'animate',
+      'color-profile',
+      'cursor',
+      'discard',
+      'fedropshadow',
+      'font-face',
+      'font-face-format',
+      'font-face-name',
+      'font-face-src',
+      'font-face-uri',
+      'foreignobject',
+      'hatch',
+      'hatchpath',
+      'mesh',
+      'meshgradient',
+      'meshpatch',
+      'meshrow',
+      'missing-glyph',
+      'script',
+      'set',
+      'solidcolor',
+      'unknown',
+      'use'
+    ]);
+    var mathMl$1 = freeze([
+      'math',
+      'menclose',
+      'merror',
+      'mfenced',
+      'mfrac',
+      'mglyph',
+      'mi',
+      'mlabeledtr',
+      'mmultiscripts',
+      'mn',
+      'mo',
+      'mover',
+      'mpadded',
+      'mphantom',
+      'mroot',
+      'mrow',
+      'ms',
+      'mspace',
+      'msqrt',
+      'mstyle',
+      'msub',
+      'msup',
+      'msubsup',
+      'mtable',
+      'mtd',
+      'mtext',
+      'mtr',
+      'munder',
+      'munderover'
+    ]);
+    var mathMlDisallowed = freeze([
+      'maction',
+      'maligngroup',
+      'malignmark',
+      'mlongdiv',
+      'mscarries',
+      'mscarry',
+      'msgroup',
+      'mstack',
+      'msline',
+      'msrow',
+      'semantics',
+      'annotation',
+      'annotation-xml',
+      'mprescripts',
+      'none'
+    ]);
+    var text = freeze(['#text']);
+    var html = freeze([
+      'accept',
+      'action',
+      'align',
+      'alt',
+      'autocapitalize',
+      'autocomplete',
+      'autopictureinpicture',
+      'autoplay',
+      'background',
+      'bgcolor',
+      'border',
+      'capture',
+      'cellpadding',
+      'cellspacing',
+      'checked',
+      'cite',
+      'class',
+      'clear',
+      'color',
+      'cols',
+      'colspan',
+      'controls',
+      'controlslist',
+      'coords',
+      'crossorigin',
+      'datetime',
+      'decoding',
+      'default',
+      'dir',
+      'disabled',
+      'disablepictureinpicture',
+      'disableremoteplayback',
+      'download',
+      'draggable',
+      'enctype',
+      'enterkeyhint',
+      'face',
+      'for',
+      'headers',
+      'height',
+      'hidden',
+      'high',
+      'href',
+      'hreflang',
+      'id',
+      'inputmode',
+      'integrity',
+      'ismap',
+      'kind',
+      'label',
+      'lang',
+      'list',
+      'loading',
+      'loop',
+      'low',
+      'max',
+      'maxlength',
+      'media',
+      'method',
+      'min',
+      'minlength',
+      'multiple',
+      'muted',
+      'name',
+      'nonce',
+      'noshade',
+      'novalidate',
+      'nowrap',
+      'open',
+      'optimum',
+      'pattern',
+      'placeholder',
+      'playsinline',
+      'poster',
+      'preload',
+      'pubdate',
+      'radiogroup',
+      'readonly',
+      'rel',
+      'required',
+      'rev',
+      'reversed',
+      'role',
+      'rows',
+      'rowspan',
+      'spellcheck',
+      'scope',
+      'selected',
+      'shape',
+      'size',
+      'sizes',
+      'span',
+      'srclang',
+      'start',
+      'src',
+      'srcset',
+      'step',
+      'style',
+      'summary',
+      'tabindex',
+      'title',
+      'translate',
+      'type',
+      'usemap',
+      'valign',
+      'value',
+      'width',
+      'xmlns',
+      'slot'
+    ]);
+    var svg = freeze([
+      'accent-height',
+      'accumulate',
+      'additive',
+      'alignment-baseline',
+      'ascent',
+      'attributename',
+      'attributetype',
+      'azimuth',
+      'basefrequency',
+      'baseline-shift',
+      'begin',
+      'bias',
+      'by',
+      'class',
+      'clip',
+      'clippathunits',
+      'clip-path',
+      'clip-rule',
+      'color',
+      'color-interpolation',
+      'color-interpolation-filters',
+      'color-profile',
+      'color-rendering',
+      'cx',
+      'cy',
+      'd',
+      'dx',
+      'dy',
+      'diffuseconstant',
+      'direction',
+      'display',
+      'divisor',
+      'dur',
+      'edgemode',
+      'elevation',
+      'end',
+      'fill',
+      'fill-opacity',
+      'fill-rule',
+      'filter',
+      'filterunits',
+      'flood-color',
+      'flood-opacity',
+      'font-family',
+      'font-size',
+      'font-size-adjust',
+      'font-stretch',
+      'font-style',
+      'font-variant',
+      'font-weight',
+      'fx',
+      'fy',
+      'g1',
+      'g2',
+      'glyph-name',
+      'glyphref',
+      'gradientunits',
+      'gradienttransform',
+      'height',
+      'href',
+      'id',
+      'image-rendering',
+      'in',
+      'in2',
+      'k',
+      'k1',
+      'k2',
+      'k3',
+      'k4',
+      'kerning',
+      'keypoints',
+      'keysplines',
+      'keytimes',
+      'lang',
+      'lengthadjust',
+      'letter-spacing',
+      'kernelmatrix',
+      'kernelunitlength',
+      'lighting-color',
+      'local',
+      'marker-end',
+      'marker-mid',
+      'marker-start',
+      'markerheight',
+      'markerunits',
+      'markerwidth',
+      'maskcontentunits',
+      'maskunits',
+      'max',
+      'mask',
+      'media',
+      'method',
+      'mode',
+      'min',
+      'name',
+      'numoctaves',
+      'offset',
+      'operator',
+      'opacity',
+      'order',
+      'orient',
+      'orientation',
+      'origin',
+      'overflow',
+      'paint-order',
+      'path',
+      'pathlength',
+      'patterncontentunits',
+      'patterntransform',
+      'patternunits',
+      'points',
+      'preservealpha',
+      'preserveaspectratio',
+      'primitiveunits',
+      'r',
+      'rx',
+      'ry',
+      'radius',
+      'refx',
+      'refy',
+      'repeatcount',
+      'repeatdur',
+      'restart',
+      'result',
+      'rotate',
+      'scale',
+      'seed',
+      'shape-rendering',
+      'specularconstant',
+      'specularexponent',
+      'spreadmethod',
+      'startoffset',
+      'stddeviation',
+      'stitchtiles',
+      'stop-color',
+      'stop-opacity',
+      'stroke-dasharray',
+      'stroke-dashoffset',
+      'stroke-linecap',
+      'stroke-linejoin',
+      'stroke-miterlimit',
+      'stroke-opacity',
+      'stroke',
+      'stroke-width',
+      'style',
+      'surfacescale',
+      'systemlanguage',
+      'tabindex',
+      'targetx',
+      'targety',
+      'transform',
+      'transform-origin',
+      'text-anchor',
+      'text-decoration',
+      'text-rendering',
+      'textlength',
+      'type',
+      'u1',
+      'u2',
+      'unicode',
+      'values',
+      'viewbox',
+      'visibility',
+      'version',
+      'vert-adv-y',
+      'vert-origin-x',
+      'vert-origin-y',
+      'width',
+      'word-spacing',
+      'wrap',
+      'writing-mode',
+      'xchannelselector',
+      'ychannelselector',
+      'x',
+      'x1',
+      'x2',
+      'xmlns',
+      'y',
+      'y1',
+      'y2',
+      'z',
+      'zoomandpan'
+    ]);
+    var mathMl = freeze([
+      'accent',
+      'accentunder',
+      'align',
+      'bevelled',
+      'close',
+      'columnsalign',
+      'columnlines',
+      'columnspan',
+      'denomalign',
+      'depth',
+      'dir',
+      'display',
+      'displaystyle',
+      'encoding',
+      'fence',
+      'frame',
+      'height',
+      'href',
+      'id',
+      'largeop',
+      'length',
+      'linethickness',
+      'lspace',
+      'lquote',
+      'mathbackground',
+      'mathcolor',
+      'mathsize',
+      'mathvariant',
+      'maxsize',
+      'minsize',
+      'movablelimits',
+      'notation',
+      'numalign',
+      'open',
+      'rowalign',
+      'rowlines',
+      'rowspacing',
+      'rowspan',
+      'rspace',
+      'rquote',
+      'scriptlevel',
+      'scriptminsize',
+      'scriptsizemultiplier',
+      'selection',
+      'separator',
+      'separators',
+      'stretchy',
+      'subscriptshift',
+      'supscriptshift',
+      'symmetric',
+      'voffset',
+      'width',
+      'xmlns'
+    ]);
+    var xml = freeze([
+      'xlink:href',
+      'xml:id',
+      'xlink:title',
+      'xml:space',
+      'xmlns:xlink'
+    ]);
+    var MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm);
+    var ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
+    var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]/);
+    var ARIA_ATTR = seal(/^aria-[\-\w]+$/);
+    var IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i);
+    var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+    var ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g);
+    var DOCTYPE_NAME = seal(/^html$/i);
+    var getGlobal = function getGlobal() {
+      return typeof window === 'undefined' ? null : window;
+    };
+    var _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, document) {
+      if (_typeof(trustedTypes) !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
+        return null;
+      }
+      var suffix = null;
+      var ATTR_NAME = 'data-tt-policy-suffix';
+      if (document.currentScript && document.currentScript.hasAttribute(ATTR_NAME)) {
+        suffix = document.currentScript.getAttribute(ATTR_NAME);
+      }
+      var policyName = 'dompurify' + (suffix ? '#' + suffix : '');
+      try {
+        return trustedTypes.createPolicy(policyName, {
+          createHTML: function createHTML(html) {
+            return html;
+          }
+        });
+      } catch (_) {
+        console.warn('TrustedTypes policy ' + policyName + ' could not be created.');
+        return null;
+      }
+    };
+    function createDOMPurify() {
+      var window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
+      var DOMPurify = function DOMPurify(root) {
+        return createDOMPurify(root);
+      };
+      DOMPurify.version = '2.3.8';
+      DOMPurify.removed = [];
+      if (!window || !window.document || window.document.nodeType !== 9) {
+        DOMPurify.isSupported = false;
+        return DOMPurify;
+      }
+      var originalDocument = window.document;
+      var document = window.document;
+      var DocumentFragment = window.DocumentFragment, HTMLTemplateElement = window.HTMLTemplateElement, Node = window.Node, Element = window.Element, NodeFilter = window.NodeFilter, _window$NamedNodeMap = window.NamedNodeMap, NamedNodeMap = _window$NamedNodeMap === void 0 ? window.NamedNodeMap || window.MozNamedAttrMap : _window$NamedNodeMap, HTMLFormElement = window.HTMLFormElement, DOMParser = window.DOMParser, trustedTypes = window.trustedTypes;
+      var ElementPrototype = Element.prototype;
+      var cloneNode = lookupGetter(ElementPrototype, 'cloneNode');
+      var getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
+      var getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
+      var getParentNode = lookupGetter(ElementPrototype, 'parentNode');
+      if (typeof HTMLTemplateElement === 'function') {
+        var template = document.createElement('template');
+        if (template.content && template.content.ownerDocument) {
+          document = template.content.ownerDocument;
+        }
+      }
+      var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument);
+      var emptyHTML = trustedTypesPolicy ? trustedTypesPolicy.createHTML('') : '';
+      var _document = document, implementation = _document.implementation, createNodeIterator = _document.createNodeIterator, createDocumentFragment = _document.createDocumentFragment, getElementsByTagName = _document.getElementsByTagName;
+      var importNode = originalDocument.importNode;
+      var documentMode = {};
+      try {
+        documentMode = clone(document).documentMode ? document.documentMode : {};
+      } catch (_) {
+      }
+      var hooks = {};
+      DOMPurify.isSupported = typeof getParentNode === 'function' && implementation && typeof implementation.createHTMLDocument !== 'undefined' && documentMode !== 9;
+      var MUSTACHE_EXPR$1 = MUSTACHE_EXPR, ERB_EXPR$1 = ERB_EXPR, DATA_ATTR$1 = DATA_ATTR, ARIA_ATTR$1 = ARIA_ATTR, IS_SCRIPT_OR_DATA$1 = IS_SCRIPT_OR_DATA, ATTR_WHITESPACE$1 = ATTR_WHITESPACE;
+      var IS_ALLOWED_URI$1 = IS_ALLOWED_URI;
+      var ALLOWED_TAGS = null;
+      var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray(html$1), _toConsumableArray(svg$1), _toConsumableArray(svgFilters), _toConsumableArray(mathMl$1), _toConsumableArray(text)));
+      var ALLOWED_ATTR = null;
+      var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray(html), _toConsumableArray(svg), _toConsumableArray(mathMl), _toConsumableArray(xml)));
+      var CUSTOM_ELEMENT_HANDLING = Object.seal(Object.create(null, {
+        tagNameCheck: {
+          writable: true,
+          configurable: false,
+          enumerable: true,
+          value: null
+        },
+        attributeNameCheck: {
+          writable: true,
+          configurable: false,
+          enumerable: true,
+          value: null
+        },
+        allowCustomizedBuiltInElements: {
+          writable: true,
+          configurable: false,
+          enumerable: true,
+          value: false
+        }
+      }));
+      var FORBID_TAGS = null;
+      var FORBID_ATTR = null;
+      var ALLOW_ARIA_ATTR = true;
+      var ALLOW_DATA_ATTR = true;
+      var ALLOW_UNKNOWN_PROTOCOLS = false;
+      var SAFE_FOR_TEMPLATES = false;
+      var WHOLE_DOCUMENT = false;
+      var SET_CONFIG = false;
+      var FORCE_BODY = false;
+      var RETURN_DOM = false;
+      var RETURN_DOM_FRAGMENT = false;
+      var RETURN_TRUSTED_TYPE = false;
+      var SANITIZE_DOM = true;
+      var KEEP_CONTENT = true;
+      var IN_PLACE = false;
+      var USE_PROFILES = {};
+      var FORBID_CONTENTS = null;
+      var DEFAULT_FORBID_CONTENTS = addToSet({}, [
+        'annotation-xml',
+        'audio',
+        'colgroup',
+        'desc',
+        'foreignobject',
+        'head',
+        'iframe',
+        'math',
+        'mi',
+        'mn',
+        'mo',
+        'ms',
+        'mtext',
+        'noembed',
+        'noframes',
+        'noscript',
+        'plaintext',
+        'script',
+        'style',
+        'svg',
+        'template',
+        'thead',
+        'title',
+        'video',
+        'xmp'
+      ]);
+      var DATA_URI_TAGS = null;
+      var DEFAULT_DATA_URI_TAGS = addToSet({}, [
+        'audio',
+        'video',
+        'img',
+        'source',
+        'image',
+        'track'
+      ]);
+      var URI_SAFE_ATTRIBUTES = null;
+      var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, [
+        'alt',
+        'class',
+        'for',
+        'id',
+        'label',
+        'name',
+        'pattern',
+        'placeholder',
+        'role',
+        'summary',
+        'title',
+        'value',
+        'style',
+        'xmlns'
+      ]);
+      var MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+      var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+      var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+      var NAMESPACE = HTML_NAMESPACE;
+      var IS_EMPTY_INPUT = false;
+      var PARSER_MEDIA_TYPE;
+      var SUPPORTED_PARSER_MEDIA_TYPES = [
+        'application/xhtml+xml',
+        'text/html'
+      ];
+      var DEFAULT_PARSER_MEDIA_TYPE = 'text/html';
+      var transformCaseFunc;
+      var CONFIG = null;
+      var formElement = document.createElement('form');
+      var isRegexOrFunction = function isRegexOrFunction(testValue) {
+        return testValue instanceof RegExp || testValue instanceof Function;
+      };
+      var _parseConfig = function _parseConfig(cfg) {
+        if (CONFIG && CONFIG === cfg) {
+          return;
+        }
+        if (!cfg || _typeof(cfg) !== 'object') {
+          cfg = {};
+        }
+        cfg = clone(cfg);
+        ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS) : DEFAULT_ALLOWED_TAGS;
+        ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR) : DEFAULT_ALLOWED_ATTR;
+        URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR) : DEFAULT_URI_SAFE_ATTRIBUTES;
+        DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS) : DEFAULT_DATA_URI_TAGS;
+        FORBID_CONTENTS = 'FORBID_CONTENTS' in cfg ? addToSet({}, cfg.FORBID_CONTENTS) : DEFAULT_FORBID_CONTENTS;
+        FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS) : {};
+        FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR) : {};
+        USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false;
+        ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
+        ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
+        ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false;
+        SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false;
+        WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false;
+        RETURN_DOM = cfg.RETURN_DOM || false;
+        RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false;
+        RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false;
+        FORCE_BODY = cfg.FORCE_BODY || false;
+        SANITIZE_DOM = cfg.SANITIZE_DOM !== false;
+        KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
+        IN_PLACE = cfg.IN_PLACE || false;
+        IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$1;
+        NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+        if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
+          CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+        }
+        if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
+          CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
+        }
+        if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === 'boolean') {
+          CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
+        }
+        PARSER_MEDIA_TYPE = SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? PARSER_MEDIA_TYPE = DEFAULT_PARSER_MEDIA_TYPE : PARSER_MEDIA_TYPE = cfg.PARSER_MEDIA_TYPE;
+        transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? function (x) {
+          return x;
+        } : stringToLowerCase;
+        if (SAFE_FOR_TEMPLATES) {
+          ALLOW_DATA_ATTR = false;
+        }
+        if (RETURN_DOM_FRAGMENT) {
+          RETURN_DOM = true;
+        }
+        if (USE_PROFILES) {
+          ALLOWED_TAGS = addToSet({}, _toConsumableArray(text));
+          ALLOWED_ATTR = [];
+          if (USE_PROFILES.html === true) {
+            addToSet(ALLOWED_TAGS, html$1);
+            addToSet(ALLOWED_ATTR, html);
+          }
+          if (USE_PROFILES.svg === true) {
+            addToSet(ALLOWED_TAGS, svg$1);
+            addToSet(ALLOWED_ATTR, svg);
+            addToSet(ALLOWED_ATTR, xml);
+          }
+          if (USE_PROFILES.svgFilters === true) {
+            addToSet(ALLOWED_TAGS, svgFilters);
+            addToSet(ALLOWED_ATTR, svg);
+            addToSet(ALLOWED_ATTR, xml);
+          }
+          if (USE_PROFILES.mathMl === true) {
+            addToSet(ALLOWED_TAGS, mathMl$1);
+            addToSet(ALLOWED_ATTR, mathMl);
+            addToSet(ALLOWED_ATTR, xml);
+          }
+        }
+        if (cfg.ADD_TAGS) {
+          if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+            ALLOWED_TAGS = clone(ALLOWED_TAGS);
+          }
+          addToSet(ALLOWED_TAGS, cfg.ADD_TAGS);
+        }
+        if (cfg.ADD_ATTR) {
+          if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+            ALLOWED_ATTR = clone(ALLOWED_ATTR);
+          }
+          addToSet(ALLOWED_ATTR, cfg.ADD_ATTR);
+        }
+        if (cfg.ADD_URI_SAFE_ATTR) {
+          addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR);
+        }
+        if (cfg.FORBID_CONTENTS) {
+          if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+            FORBID_CONTENTS = clone(FORBID_CONTENTS);
+          }
+          addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS);
+        }
+        if (KEEP_CONTENT) {
+          ALLOWED_TAGS['#text'] = true;
+        }
+        if (WHOLE_DOCUMENT) {
+          addToSet(ALLOWED_TAGS, [
+            'html',
+            'head',
+            'body'
+          ]);
+        }
+        if (ALLOWED_TAGS.table) {
+          addToSet(ALLOWED_TAGS, ['tbody']);
+          delete FORBID_TAGS.tbody;
+        }
+        if (freeze) {
+          freeze(cfg);
+        }
+        CONFIG = cfg;
+      };
+      var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, [
+        'mi',
+        'mo',
+        'mn',
+        'ms',
+        'mtext'
+      ]);
+      var HTML_INTEGRATION_POINTS = addToSet({}, [
+        'foreignobject',
+        'desc',
+        'title',
+        'annotation-xml'
+      ]);
+      var COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, [
+        'title',
+        'style',
+        'font',
+        'a',
+        'script'
+      ]);
+      var ALL_SVG_TAGS = addToSet({}, svg$1);
+      addToSet(ALL_SVG_TAGS, svgFilters);
+      addToSet(ALL_SVG_TAGS, svgDisallowed);
+      var ALL_MATHML_TAGS = addToSet({}, mathMl$1);
+      addToSet(ALL_MATHML_TAGS, mathMlDisallowed);
+      var _checkValidNamespace = function _checkValidNamespace(element) {
+        var parent = getParentNode(element);
+        if (!parent || !parent.tagName) {
+          parent = {
+            namespaceURI: HTML_NAMESPACE,
+            tagName: 'template'
+          };
+        }
+        var tagName = stringToLowerCase(element.tagName);
+        var parentTagName = stringToLowerCase(parent.tagName);
+        if (element.namespaceURI === SVG_NAMESPACE) {
+          if (parent.namespaceURI === HTML_NAMESPACE) {
+            return tagName === 'svg';
+          }
+          if (parent.namespaceURI === MATHML_NAMESPACE) {
+            return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+          }
+          return Boolean(ALL_SVG_TAGS[tagName]);
+        }
+        if (element.namespaceURI === MATHML_NAMESPACE) {
+          if (parent.namespaceURI === HTML_NAMESPACE) {
+            return tagName === 'math';
+          }
+          if (parent.namespaceURI === SVG_NAMESPACE) {
+            return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];
+          }
+          return Boolean(ALL_MATHML_TAGS[tagName]);
+        }
+        if (element.namespaceURI === HTML_NAMESPACE) {
+          if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+            return false;
+          }
+          if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+            return false;
+          }
+          return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+        }
+        return false;
+      };
+      var _forceRemove = function _forceRemove(node) {
+        arrayPush(DOMPurify.removed, { element: node });
+        try {
+          node.parentNode.removeChild(node);
+        } catch (_) {
+          try {
+            node.outerHTML = emptyHTML;
+          } catch (_) {
+            node.remove();
+          }
+        }
+      };
+      var _removeAttribute = function _removeAttribute(name, node) {
+        try {
+          arrayPush(DOMPurify.removed, {
+            attribute: node.getAttributeNode(name),
+            from: node
+          });
+        } catch (_) {
+          arrayPush(DOMPurify.removed, {
+            attribute: null,
+            from: node
+          });
+        }
+        node.removeAttribute(name);
+        if (name === 'is' && !ALLOWED_ATTR[name]) {
+          if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+            try {
+              _forceRemove(node);
+            } catch (_) {
+            }
+          } else {
+            try {
+              node.setAttribute(name, '');
+            } catch (_) {
+            }
+          }
+        }
+      };
+      var _initDocument = function _initDocument(dirty) {
+        var doc;
+        var leadingWhitespace;
+        if (FORCE_BODY) {
+          dirty = '<remove></remove>' + dirty;
+        } else {
+          var matches = stringMatch(dirty, /^[\r\n\t ]+/);
+          leadingWhitespace = matches && matches[0];
+        }
+        if (PARSER_MEDIA_TYPE === 'application/xhtml+xml') {
+          dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + '</body></html>';
+        }
+        var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+        if (NAMESPACE === HTML_NAMESPACE) {
+          try {
+            doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
+          } catch (_) {
+          }
+        }
+        if (!doc || !doc.documentElement) {
+          doc = implementation.createDocument(NAMESPACE, 'template', null);
+          try {
+            doc.documentElement.innerHTML = IS_EMPTY_INPUT ? '' : dirtyPayload;
+          } catch (_) {
+          }
+        }
+        var body = doc.body || doc.documentElement;
+        if (dirty && leadingWhitespace) {
+          body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+        }
+        if (NAMESPACE === HTML_NAMESPACE) {
+          return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
+        }
+        return WHOLE_DOCUMENT ? doc.documentElement : body;
+      };
+      var _createIterator = function _createIterator(root) {
+        return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, null, false);
+      };
+      var _isClobbered = function _isClobbered(elm) {
+        return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function');
+      };
+      var _isNode = function _isNode(object) {
+        return _typeof(Node) === 'object' ? object instanceof Node : object && _typeof(object) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string';
+      };
+      var _executeHook = function _executeHook(entryPoint, currentNode, data) {
+        if (!hooks[entryPoint]) {
+          return;
+        }
+        arrayForEach(hooks[entryPoint], function (hook) {
+          hook.call(DOMPurify, currentNode, data, CONFIG);
+        });
+      };
+      var _sanitizeElements = function _sanitizeElements(currentNode) {
+        var content;
+        _executeHook('beforeSanitizeElements', currentNode, null);
+        if (_isClobbered(currentNode)) {
+          _forceRemove(currentNode);
+          return true;
+        }
+        if (regExpTest(/[\u0080-\uFFFF]/, currentNode.nodeName)) {
+          _forceRemove(currentNode);
+          return true;
+        }
+        var tagName = transformCaseFunc(currentNode.nodeName);
+        _executeHook('uponSanitizeElement', currentNode, {
+          tagName: tagName,
+          allowedTags: ALLOWED_TAGS
+        });
+        if (currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
+          _forceRemove(currentNode);
+          return true;
+        }
+        if (tagName === 'select' && regExpTest(/<template/i, currentNode.innerHTML)) {
+          _forceRemove(currentNode);
+          return true;
+        }
+        if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+          if (!FORBID_TAGS[tagName] && _basicCustomElementTest(tagName)) {
+            if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName))
+              return false;
+            if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName))
+              return false;
+          }
+          if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+            var parentNode = getParentNode(currentNode) || currentNode.parentNode;
+            var childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+            if (childNodes && parentNode) {
+              var childCount = childNodes.length;
+              for (var i = childCount - 1; i >= 0; --i) {
+                parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode));
+              }
+            }
+          }
+          _forceRemove(currentNode);
+          return true;
+        }
+        if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
+          _forceRemove(currentNode);
+          return true;
+        }
+        if ((tagName === 'noscript' || tagName === 'noembed') && regExpTest(/<\/no(script|embed)/i, currentNode.innerHTML)) {
+          _forceRemove(currentNode);
+          return true;
+        }
+        if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {
+          content = currentNode.textContent;
+          content = stringReplace(content, MUSTACHE_EXPR$1, ' ');
+          content = stringReplace(content, ERB_EXPR$1, ' ');
+          if (currentNode.textContent !== content) {
+            arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });
+            currentNode.textContent = content;
+          }
+        }
+        _executeHook('afterSanitizeElements', currentNode, null);
+        return false;
+      };
+      var _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
+        if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
+          return false;
+        }
+        if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR$1, lcName));
+        else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$1, lcName));
+        else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+          if (_basicCustomElementTest(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) || lcName === 'is' && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value)));
+          else {
+            return false;
+          }
+        } else if (URI_SAFE_ATTRIBUTES[lcName]);
+        else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE$1, '')));
+        else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]);
+        else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$1, stringReplace(value, ATTR_WHITESPACE$1, '')));
+        else if (!value);
+        else {
+          return false;
+        }
+        return true;
+      };
+      var _basicCustomElementTest = function _basicCustomElementTest(tagName) {
+        return tagName.indexOf('-') > 0;
+      };
+      var _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
+        var attr;
+        var value;
+        var lcName;
+        var l;
+        _executeHook('beforeSanitizeAttributes', currentNode, null);
+        var attributes = currentNode.attributes;
+        if (!attributes) {
+          return;
+        }
+        var hookEvent = {
+          attrName: '',
+          attrValue: '',
+          keepAttr: true,
+          allowedAttributes: ALLOWED_ATTR
+        };
+        l = attributes.length;
+        while (l--) {
+          attr = attributes[l];
+          var _attr = attr, name = _attr.name, namespaceURI = _attr.namespaceURI;
+          value = name === 'value' ? attr.value : stringTrim(attr.value);
+          lcName = transformCaseFunc(name);
+          hookEvent.attrName = lcName;
+          hookEvent.attrValue = value;
+          hookEvent.keepAttr = true;
+          hookEvent.forceKeepAttr = undefined;
+          _executeHook('uponSanitizeAttribute', currentNode, hookEvent);
+          value = hookEvent.attrValue;
+          if (hookEvent.forceKeepAttr) {
+            continue;
+          }
+          _removeAttribute(name, currentNode);
+          if (!hookEvent.keepAttr) {
+            continue;
+          }
+          if (regExpTest(/\/>/i, value)) {
+            _removeAttribute(name, currentNode);
+            continue;
+          }
+          if (SAFE_FOR_TEMPLATES) {
+            value = stringReplace(value, MUSTACHE_EXPR$1, ' ');
+            value = stringReplace(value, ERB_EXPR$1, ' ');
+          }
+          var lcTag = transformCaseFunc(currentNode.nodeName);
+          if (!_isValidAttribute(lcTag, lcName, value)) {
+            continue;
+          }
+          try {
+            if (namespaceURI) {
+              currentNode.setAttributeNS(namespaceURI, name, value);
+            } else {
+              currentNode.setAttribute(name, value);
+            }
+            arrayPop(DOMPurify.removed);
+          } catch (_) {
+          }
+        }
+        _executeHook('afterSanitizeAttributes', currentNode, null);
+      };
+      var _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
+        var shadowNode;
+        var shadowIterator = _createIterator(fragment);
+        _executeHook('beforeSanitizeShadowDOM', fragment, null);
+        while (shadowNode = shadowIterator.nextNode()) {
+          _executeHook('uponSanitizeShadowNode', shadowNode, null);
+          if (_sanitizeElements(shadowNode)) {
+            continue;
+          }
+          if (shadowNode.content instanceof DocumentFragment) {
+            _sanitizeShadowDOM(shadowNode.content);
+          }
+          _sanitizeAttributes(shadowNode);
+        }
+        _executeHook('afterSanitizeShadowDOM', fragment, null);
+      };
+      DOMPurify.sanitize = function (dirty, cfg) {
+        var body;
+        var importedNode;
+        var currentNode;
+        var oldNode;
+        var returnNode;
+        IS_EMPTY_INPUT = !dirty;
+        if (IS_EMPTY_INPUT) {
+          dirty = '<!-->';
+        }
+        if (typeof dirty !== 'string' && !_isNode(dirty)) {
+          if (typeof dirty.toString !== 'function') {
+            throw typeErrorCreate('toString is not a function');
+          } else {
+            dirty = dirty.toString();
+            if (typeof dirty !== 'string') {
+              throw typeErrorCreate('dirty is not a string, aborting');
+            }
+          }
+        }
+        if (!DOMPurify.isSupported) {
+          if (_typeof(window.toStaticHTML) === 'object' || typeof window.toStaticHTML === 'function') {
+            if (typeof dirty === 'string') {
+              return window.toStaticHTML(dirty);
+            }
+            if (_isNode(dirty)) {
+              return window.toStaticHTML(dirty.outerHTML);
+            }
+          }
+          return dirty;
+        }
+        if (!SET_CONFIG) {
+          _parseConfig(cfg);
+        }
+        DOMPurify.removed = [];
+        if (typeof dirty === 'string') {
+          IN_PLACE = false;
+        }
+        if (IN_PLACE) {
+          if (dirty.nodeName) {
+            var tagName = transformCaseFunc(dirty.nodeName);
+            if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+              throw typeErrorCreate('root node is forbidden and cannot be sanitized in-place');
+            }
+          }
+        } else if (dirty instanceof Node) {
+          body = _initDocument('<!---->');
+          importedNode = body.ownerDocument.importNode(dirty, true);
+          if (importedNode.nodeType === 1 && importedNode.nodeName === 'BODY') {
+            body = importedNode;
+          } else if (importedNode.nodeName === 'HTML') {
+            body = importedNode;
+          } else {
+            body.appendChild(importedNode);
+          }
+        } else {
+          if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && dirty.indexOf('<') === -1) {
+            return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+          }
+          body = _initDocument(dirty);
+          if (!body) {
+            return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : '';
+          }
+        }
+        if (body && FORCE_BODY) {
+          _forceRemove(body.firstChild);
+        }
+        var nodeIterator = _createIterator(IN_PLACE ? dirty : body);
+        while (currentNode = nodeIterator.nextNode()) {
+          if (currentNode.nodeType === 3 && currentNode === oldNode) {
+            continue;
+          }
+          if (_sanitizeElements(currentNode)) {
+            continue;
+          }
+          if (currentNode.content instanceof DocumentFragment) {
+            _sanitizeShadowDOM(currentNode.content);
+          }
+          _sanitizeAttributes(currentNode);
+          oldNode = currentNode;
+        }
+        oldNode = null;
+        if (IN_PLACE) {
+          return dirty;
+        }
+        if (RETURN_DOM) {
+          if (RETURN_DOM_FRAGMENT) {
+            returnNode = createDocumentFragment.call(body.ownerDocument);
+            while (body.firstChild) {
+              returnNode.appendChild(body.firstChild);
+            }
+          } else {
+            returnNode = body;
+          }
+          if (ALLOWED_ATTR.shadowroot) {
+            returnNode = importNode.call(originalDocument, returnNode, true);
+          }
+          return returnNode;
+        }
+        var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+        if (WHOLE_DOCUMENT && ALLOWED_TAGS['!doctype'] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
+          serializedHTML = '<!DOCTYPE ' + body.ownerDocument.doctype.name + '>\n' + serializedHTML;
+        }
+        if (SAFE_FOR_TEMPLATES) {
+          serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$1, ' ');
+          serializedHTML = stringReplace(serializedHTML, ERB_EXPR$1, ' ');
+        }
+        return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+      };
+      DOMPurify.setConfig = function (cfg) {
+        _parseConfig(cfg);
+        SET_CONFIG = true;
+      };
+      DOMPurify.clearConfig = function () {
+        CONFIG = null;
+        SET_CONFIG = false;
+      };
+      DOMPurify.isValidAttribute = function (tag, attr, value) {
+        if (!CONFIG) {
+          _parseConfig({});
+        }
+        var lcTag = transformCaseFunc(tag);
+        var lcName = transformCaseFunc(attr);
+        return _isValidAttribute(lcTag, lcName, value);
+      };
+      DOMPurify.addHook = function (entryPoint, hookFunction) {
+        if (typeof hookFunction !== 'function') {
+          return;
+        }
+        hooks[entryPoint] = hooks[entryPoint] || [];
+        arrayPush(hooks[entryPoint], hookFunction);
+      };
+      DOMPurify.removeHook = function (entryPoint) {
+        if (hooks[entryPoint]) {
+          return arrayPop(hooks[entryPoint]);
+        }
+      };
+      DOMPurify.removeHooks = function (entryPoint) {
+        if (hooks[entryPoint]) {
+          hooks[entryPoint] = [];
+        }
+      };
+      DOMPurify.removeAllHooks = function () {
+        hooks = {};
+      };
+      return DOMPurify;
+    }
+    var purify = createDOMPurify();
+
+    var sanitizeHtmlString = function (html) {
+      return purify().sanitize(html);
+    };
+
+    var isTouch = global$9.deviceType.isTouch();
+    var hiddenHeader = function (title, close) {
+      return {
+        dom: {
+          tag: 'div',
+          styles: { display: 'none' },
+          classes: ['tox-dialog__header']
+        },
+        components: [
+          title,
+          close
+        ]
+      };
+    };
+    var pClose = function (onClose, providersBackstage) {
+      return ModalDialog.parts.close(Button.sketch({
+        dom: {
+          tag: 'button',
+          classes: [
+            'tox-button',
+            'tox-button--icon',
+            'tox-button--naked'
+          ],
+          attributes: {
+            'type': 'button',
+            'aria-label': providersBackstage.translate('Close')
+          }
+        },
+        action: onClose,
+        buttonBehaviours: derive$1([Tabstopping.config({})])
+      }));
+    };
+    var pUntitled = function () {
+      return ModalDialog.parts.title({
+        dom: {
+          tag: 'div',
+          classes: ['tox-dialog__title'],
+          innerHtml: '',
+          styles: { display: 'none' }
+        }
+      });
+    };
+    var pBodyMessage = function (message, providersBackstage) {
+      return ModalDialog.parts.body({
+        dom: {
+          tag: 'div',
+          classes: ['tox-dialog__body']
+        },
+        components: [{
+            dom: {
+              tag: 'div',
+              classes: ['tox-dialog__body-content']
+            },
+            components: [{ dom: fromHtml('<p>' + sanitizeHtmlString(providersBackstage.translate(message)) + '</p>') }]
+          }]
+      });
+    };
+    var pFooter = function (buttons) {
+      return ModalDialog.parts.footer({
+        dom: {
+          tag: 'div',
+          classes: ['tox-dialog__footer']
+        },
+        components: buttons
+      });
+    };
+    var pFooterGroup = function (startButtons, endButtons) {
+      return [
+        Container.sketch({
+          dom: {
+            tag: 'div',
+            classes: ['tox-dialog__footer-start']
+          },
+          components: startButtons
+        }),
+        Container.sketch({
+          dom: {
+            tag: 'div',
+            classes: ['tox-dialog__footer-end']
+          },
+          components: endButtons
+        })
+      ];
+    };
+    var renderDialog$1 = function (spec) {
+      var _a;
+      var dialogClass = 'tox-dialog';
+      var blockerClass = dialogClass + '-wrap';
+      var blockerBackdropClass = blockerClass + '__backdrop';
+      var scrollLockClass = dialogClass + '__disable-scroll';
+      return ModalDialog.sketch({
+        lazySink: spec.lazySink,
+        onEscape: function (comp) {
+          spec.onEscape(comp);
+          return Optional.some(true);
+        },
+        useTabstopAt: function (elem) {
+          return !isPseudoStop(elem);
+        },
+        dom: {
+          tag: 'div',
+          classes: [dialogClass].concat(spec.extraClasses),
+          styles: __assign({ position: 'relative' }, spec.extraStyles)
+        },
+        components: __spreadArray([
+          spec.header,
+          spec.body
+        ], spec.footer.toArray(), true),
+        parts: {
+          blocker: {
+            dom: fromHtml('<div class="' + blockerClass + '"></div>'),
+            components: [{
+                dom: {
+                  tag: 'div',
+                  classes: isTouch ? [
+                    blockerBackdropClass,
+                    blockerBackdropClass + '--opaque'
+                  ] : [blockerBackdropClass]
+                }
+              }]
+          }
+        },
+        dragBlockClass: blockerClass,
+        modalBehaviours: derive$1(__spreadArray([
+          Focusing.config({}),
+          config('dialog-events', spec.dialogEvents.concat([runOnSource(focusin(), function (comp, _se) {
+              Keying.focusIn(comp);
+            })])),
+          config('scroll-lock', [
+            runOnAttached(function () {
+              add$2(body(), scrollLockClass);
+            }),
+            runOnDetached(function () {
+              remove$2(body(), scrollLockClass);
+            })
+          ])
+        ], spec.extraBehaviours, true)),
+        eventOrder: __assign((_a = {}, _a[execute$5()] = ['dialog-events'], _a[attachedToDom()] = [
+          'scroll-lock',
+          'dialog-events',
+          'alloy.base.behaviour'
+        ], _a[detachedFromDom()] = [
+          'alloy.base.behaviour',
+          'dialog-events',
+          'scroll-lock'
+        ], _a), spec.eventOrder)
+      });
+    };
+
+    var renderClose = function (providersBackstage) {
+      return Button.sketch({
+        dom: {
+          tag: 'button',
+          classes: [
+            'tox-button',
+            'tox-button--icon',
+            'tox-button--naked'
+          ],
+          attributes: {
+            'type': 'button',
+            'aria-label': providersBackstage.translate('Close'),
+            'title': providersBackstage.translate('Close')
+          }
+        },
+        components: [render$3('close', {
+            tag: 'div',
+            classes: ['tox-icon']
+          }, providersBackstage.icons)],
+        action: function (comp) {
+          emit(comp, formCancelEvent);
+        }
+      });
+    };
+    var renderTitle = function (spec, id, providersBackstage) {
+      var renderComponents = function (data) {
+        return [text$1(providersBackstage.translate(data.title))];
+      };
+      return {
+        dom: {
+          tag: 'div',
+          classes: ['tox-dialog__title'],
+          attributes: __assign({}, id.map(function (x) {
+            return { id: x };
+          }).getOr({}))
+        },
+        components: renderComponents(spec),
+        behaviours: derive$1([Reflecting.config({
+            channel: titleChannel,
+            renderComponents: renderComponents
+          })])
+      };
+    };
+    var renderDragHandle = function () {
+      return { dom: fromHtml('<div class="tox-dialog__draghandle"></div>') };
+    };
+    var renderInlineHeader = function (spec, titleId, providersBackstage) {
+      return Container.sketch({
+        dom: fromHtml('<div class="tox-dialog__header"></div>'),
+        components: [
+          renderTitle(spec, Optional.some(titleId), providersBackstage),
+          renderDragHandle(),
+          renderClose(providersBackstage)
+        ],
+        containerBehaviours: derive$1([Dragging.config({
+            mode: 'mouse',
+            blockerClass: 'blocker',
+            getTarget: function (handle) {
+              return closest$1(handle, '[role="dialog"]').getOrDie();
+            },
+            snaps: {
+              getSnapPoints: function () {
+                return [];
+              },
+              leftAttr: 'data-drag-left',
+              topAttr: 'data-drag-top'
+            }
+          })])
+      });
+    };
+    var renderModalHeader = function (spec, providersBackstage) {
+      var pTitle = ModalDialog.parts.title(renderTitle(spec, Optional.none(), providersBackstage));
+      var pHandle = ModalDialog.parts.draghandle(renderDragHandle());
+      var pClose = ModalDialog.parts.close(renderClose(providersBackstage));
+      var components = [pTitle].concat(spec.draggable ? [pHandle] : []).concat([pClose]);
+      return Container.sketch({
+        dom: fromHtml('<div class="tox-dialog__header"></div>'),
+        components: components
+      });
+    };
+
+    var getHeader = function (title, backstage) {
+      return renderModalHeader({
+        title: backstage.shared.providers.translate(title),
+        draggable: backstage.dialog.isDraggableModal()
+      }, backstage.shared.providers);
+    };
+    var getBusySpec = function (message, bs, providers) {
+      return {
+        dom: {
+          tag: 'div',
+          classes: ['tox-dialog__busy-spinner'],
+          attributes: { 'aria-label': providers.translate(message) },
+          styles: {
+            left: '0px',
+            right: '0px',
+            bottom: '0px',
+            top: '0px',
+            position: 'absolute'
+          }
+        },
+        behaviours: bs,
+        components: [{ dom: fromHtml('<div class="tox-spinner"><div></div><div></div><div></div></div>') }]
+      };
+    };
+    var getEventExtras = function (lazyDialog, providers, extra) {
+      return {
+        onClose: function () {
+          return extra.closeWindow();
+        },
+        onBlock: function (blockEvent) {
+          ModalDialog.setBusy(lazyDialog(), function (_comp, bs) {
+            return getBusySpec(blockEvent.message, bs, providers);
+          });
+        },
+        onUnblock: function () {
+          ModalDialog.setIdle(lazyDialog());
+        }
+      };
+    };
+    var renderModalDialog = function (spec, initialData, dialogEvents, backstage) {
+      var _a;
+      var updateState = function (_comp, incoming) {
+        return Optional.some(incoming);
+      };
+      return build$1(renderDialog$1(__assign(__assign({}, spec), {
+        lazySink: backstage.shared.getSink,
+        extraBehaviours: __spreadArray([
+          Reflecting.config({
+            channel: dialogChannel,
+            updateState: updateState,
+            initialData: initialData
+          }),
+          RepresentingConfigs.memory({})
+        ], spec.extraBehaviours, true),
+        onEscape: function (comp) {
+          emit(comp, formCancelEvent);
+        },
+        dialogEvents: dialogEvents,
+        eventOrder: (_a = {}, _a[receive()] = [
+          Reflecting.name(),
+          Receiving.name()
+        ], _a[attachedToDom()] = [
+          'scroll-lock',
+          Reflecting.name(),
+          'messages',
+          'dialog-events',
+          'alloy.base.behaviour'
+        ], _a[detachedFromDom()] = [
+          'alloy.base.behaviour',
+          'dialog-events',
+          'messages',
+          Reflecting.name(),
+          'scroll-lock'
+        ], _a)
+      })));
+    };
+    var mapMenuButtons = function (buttons) {
+      var mapItems = function (button) {
+        var items = map$2(button.items, function (item) {
+          var cell = Cell(false);
+          return __assign(__assign({}, item), { storage: cell });
+        });
+        return __assign(__assign({}, button), { items: items });
+      };
+      return map$2(buttons, function (button) {
+        if (button.type === 'menu') {
+          return mapItems(button);
+        }
+        return button;
+      });
+    };
+    var extractCellsToObject = function (buttons) {
+      return foldl(buttons, function (acc, button) {
+        if (button.type === 'menu') {
+          var menuButton = button;
+          return foldl(menuButton.items, function (innerAcc, item) {
+            innerAcc[item.name] = item.storage;
+            return innerAcc;
+          }, acc);
+        }
+        return acc;
+      }, {});
+    };
+
+    var initCommonEvents = function (fireApiEvent, extras) {
+      return [
+        runWithTarget(focusin(), onFocus),
+        fireApiEvent(formCloseEvent, function (_api, spec) {
+          extras.onClose();
+          spec.onClose();
+        }),
+        fireApiEvent(formCancelEvent, function (api, spec, _event, self) {
+          spec.onCancel(api);
+          emit(self, formCloseEvent);
+        }),
+        run$1(formUnblockEvent, function (_c, _se) {
+          return extras.onUnblock();
+        }),
+        run$1(formBlockEvent, function (_c, se) {
+          return extras.onBlock(se.event);
+        })
+      ];
+    };
+    var initUrlDialog = function (getInstanceApi, extras) {
+      var fireApiEvent = function (eventName, f) {
+        return run$1(eventName, function (c, se) {
+          withSpec(c, function (spec, _c) {
+            f(getInstanceApi(), spec, se.event, c);
+          });
+        });
+      };
+      var withSpec = function (c, f) {
+        Reflecting.getState(c).get().each(function (currentDialog) {
+          f(currentDialog, c);
+        });
+      };
+      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) {
+            f(getInstanceApi(), spec, se.event, c);
+          });
+        });
+      };
+      var withSpec = function (c, f) {
+        Reflecting.getState(c).get().each(function (currentDialogInit) {
+          f(currentDialogInit.internalDialog, c);
+        });
+      };
+      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 });
+        }),
+        fireApiEvent(formActionEvent, function (api, spec, event, component) {
+          var focusIn = function () {
+            return Keying.focusIn(component);
+          };
+          var isDisabled = function (focused) {
+            return has$1(focused, 'disabled') || getOpt(focused, 'aria-disabled').exists(function (val) {
+              return val === 'true';
+            });
+          };
+          var rootNode = getRootNode(component.element);
+          var current = active(rootNode);
+          spec.onAction(api, {
+            name: event.name,
+            value: event.value
+          });
+          active(rootNode).fold(focusIn, function (focused) {
+            if (isDisabled(focused)) {
+              focusIn();
+            } else if (current.exists(function (cur) {
+                return contains(focused, cur) && isDisabled(cur);
+              })) {
+              focusIn();
+            } else {
+              getSink().toOptional().filter(function (sink) {
+                return !contains(sink.element, focused);
+              }).each(focusIn);
+            }
+          });
+        }),
+        fireApiEvent(formTabChangeEvent, function (api, spec, event) {
+          spec.onTabChange(api, {
+            newTabName: event.name,
+            oldTabName: event.oldName
+          });
+        }),
+        runOnDetached(function (component) {
+          var api = getInstanceApi();
+          Representing.setValue(component, api.getData());
+        })
+      ], false);
+    };
+    var SilverDialogEvents = {
+      initUrlDialog: initUrlDialog,
+      initDialog: initDialog
+    };
+
+    var makeButton = function (button, backstage) {
+      return renderFooterButton(button, button.type, backstage);
+    };
+    var lookup = function (compInSystem, footerButtons, buttonName) {
+      return find$5(footerButtons, function (button) {
+        return button.name === buttonName;
+      }).bind(function (memButton) {
+        return memButton.memento.getOpt(compInSystem);
+      });
+    };
+    var renderComponents = function (_data, state) {
+      var footerButtons = state.map(function (s) {
+        return s.footerButtons;
+      }).getOr([]);
+      var buttonGroups = partition$3(footerButtons, function (button) {
+        return button.align === 'start';
+      });
+      var makeGroup = function (edge, buttons) {
+        return Container.sketch({
+          dom: {
+            tag: 'div',
+            classes: ['tox-dialog__footer-' + edge]
+          },
+          components: map$2(buttons, function (button) {
+            return button.memento.asSpec();
+          })
+        });
+      };
+      var startButtons = makeGroup('start', buttonGroups.pass);
+      var endButtons = makeGroup('end', buttonGroups.fail);
+      return [
+        startButtons,
+        endButtons
+      ];
+    };
+    var renderFooter = function (initSpec, backstage) {
+      var updateState = function (_comp, data) {
+        var footerButtons = map$2(data.buttons, function (button) {
+          var memButton = record(makeButton(button, backstage));
+          return {
+            name: button.name,
+            align: button.align,
+            memento: memButton
+          };
+        });
+        var lookupByName = function (compInSystem, buttonName) {
+          return lookup(compInSystem, footerButtons, buttonName);
+        };
+        return Optional.some({
+          lookupByName: lookupByName,
+          footerButtons: footerButtons
+        });
+      };
+      return {
+        dom: fromHtml('<div class="tox-dialog__footer"></div>'),
+        components: [],
+        behaviours: derive$1([Reflecting.config({
+            channel: footerChannel,
+            initialData: initSpec,
+            updateState: updateState,
+            renderComponents: renderComponents
+          })])
+      };
+    };
+    var renderInlineFooter = function (initSpec, backstage) {
+      return renderFooter(initSpec, backstage);
+    };
+    var renderModalFooter = function (initSpec, backstage) {
+      return ModalDialog.parts.footer(renderFooter(initSpec, backstage));
+    };
+
+    var getCompByName = function (access, name) {
+      var root = access.getRoot();
+      if (root.getSystem().isConnected()) {
+        var form_1 = Composing.getCurrent(access.getFormWrapper()).getOr(access.getFormWrapper());
+        return Form.getField(form_1, name).fold(function () {
+          var footer = access.getFooter();
+          var footerState = Reflecting.getState(footer);
+          return footerState.get().bind(function (f) {
+            return f.lookupByName(form_1, name);
+          });
+        }, function (comp) {
+          return Optional.some(comp);
+        });
+      } else {
+        return Optional.none();
+      }
+    };
+    var validateData$1 = function (access, data) {
+      var root = access.getRoot();
+      return Reflecting.getState(root).get().map(function (dialogState) {
+        return getOrDie(asRaw('data', dialogState.dataValidator, data));
+      }).getOr(data);
+    };
+    var getDialogApi = function (access, doRedial, menuItemStates) {
+      var withRoot = function (f) {
+        var root = access.getRoot();
+        if (root.getSystem().isConnected()) {
+          f(root);
+        }
+      };
+      var getData = function () {
+        var root = access.getRoot();
+        var valueComp = root.getSystem().isConnected() ? access.getFormWrapper() : root;
+        var representedValues = Representing.getValue(valueComp);
+        var menuItemCurrentState = map$1(menuItemStates, function (cell) {
+          return cell.get();
+        });
+        return __assign(__assign({}, representedValues), menuItemCurrentState);
+      };
+      var setData = function (newData) {
+        withRoot(function (_) {
+          var prevData = instanceApi.getData();
+          var mergedData = __assign(__assign({}, prevData), newData);
+          var newInternalData = validateData$1(access, mergedData);
+          var form = access.getFormWrapper();
+          Representing.setValue(form, newInternalData);
+          each(menuItemStates, function (v, k) {
+            if (has$2(mergedData, k)) {
+              v.set(mergedData[k]);
+            }
+          });
+        });
+      };
+      var disable = function (name) {
+        getCompByName(access, name).each(Disabling.disable);
+      };
+      var enable = function (name) {
+        getCompByName(access, name).each(Disabling.enable);
+      };
+      var focus = function (name) {
+        getCompByName(access, name).each(Focusing.focus);
+      };
+      var block = function (message) {
+        if (!isString(message)) {
+          throw new Error('The dialogInstanceAPI.block function should be passed a blocking message of type string as an argument');
+        }
+        withRoot(function (root) {
+          emitWith(root, formBlockEvent, { message: message });
+        });
+      };
+      var unblock = function () {
+        withRoot(function (root) {
+          emit(root, formUnblockEvent);
+        });
+      };
+      var showTab = function (name) {
+        withRoot(function (_) {
+          var body = access.getBody();
+          var bodyState = Reflecting.getState(body);
+          if (bodyState.get().exists(function (b) {
+              return b.isTabPanel();
+            })) {
+            Composing.getCurrent(body).each(function (tabSection) {
+              TabSection.showTab(tabSection, name);
+            });
+          }
+        });
+      };
+      var redial = function (d) {
+        withRoot(function (root) {
+          var dialogInit = doRedial(d);
+          root.getSystem().broadcastOn([dialogChannel], dialogInit);
+          root.getSystem().broadcastOn([titleChannel], dialogInit.internalDialog);
+          root.getSystem().broadcastOn([bodyChannel], dialogInit.internalDialog);
+          root.getSystem().broadcastOn([footerChannel], dialogInit.internalDialog);
+          instanceApi.setData(dialogInit.initialData);
+        });
+      };
+      var close = function () {
+        withRoot(function (root) {
+          emit(root, formCloseEvent);
+        });
+      };
+      var instanceApi = {
+        getData: getData,
+        setData: setData,
+        disable: disable,
+        enable: enable,
+        focus: focus,
+        block: block,
+        unblock: unblock,
+        showTab: showTab,
+        redial: redial,
+        close: close
+      };
+      return instanceApi;
+    };
+
+    var getDialogSizeClasses = function (size) {
+      switch (size) {
+      case 'large':
+        return ['tox-dialog--width-lg'];
+      case 'medium':
+        return ['tox-dialog--width-md'];
+      default:
+        return [];
+      }
+    };
+    var renderDialog = function (dialogInit, extra, backstage) {
+      var header = getHeader(dialogInit.internalDialog.title, backstage);
+      var body = renderModalBody({ body: dialogInit.internalDialog.body }, backstage);
+      var storagedMenuButtons = mapMenuButtons(dialogInit.internalDialog.buttons);
+      var objOfCells = extractCellsToObject(storagedMenuButtons);
+      var footer = renderModalFooter({ buttons: storagedMenuButtons }, backstage);
+      var dialogEvents = SilverDialogEvents.initDialog(function () {
+        return instanceApi;
+      }, getEventExtras(function () {
+        return dialog;
+      }, backstage.shared.providers, extra), backstage.shared.getSink);
+      var dialogSize = getDialogSizeClasses(dialogInit.internalDialog.size);
+      var spec = {
+        header: header,
+        body: body,
+        footer: Optional.some(footer),
+        extraClasses: dialogSize,
+        extraBehaviours: [],
+        extraStyles: {}
+      };
+      var dialog = renderModalDialog(spec, dialogInit, dialogEvents, backstage);
+      var modalAccess = function () {
+        var getForm = function () {
+          var outerForm = ModalDialog.getBody(dialog);
+          return Composing.getCurrent(outerForm).getOr(outerForm);
+        };
+        return {
+          getRoot: constant$1(dialog),
+          getBody: function () {
+            return ModalDialog.getBody(dialog);
+          },
+          getFooter: function () {
+            return ModalDialog.getFooter(dialog);
+          },
+          getFormWrapper: getForm
+        };
+      }();
+      var instanceApi = getDialogApi(modalAccess, extra.redial, objOfCells);
+      return {
+        dialog: dialog,
+        instanceApi: instanceApi
+      };
+    };
+
+    var renderInlineDialog = function (dialogInit, extra, backstage, ariaAttrs) {
+      var _a, _b;
+      var dialogLabelId = generate$6('dialog-label');
+      var dialogContentId = generate$6('dialog-content');
+      var updateState = function (_comp, incoming) {
+        return Optional.some(incoming);
+      };
+      var memHeader = record(renderInlineHeader({
+        title: dialogInit.internalDialog.title,
+        draggable: true
+      }, dialogLabelId, backstage.shared.providers));
+      var memBody = record(renderInlineBody({ body: dialogInit.internalDialog.body }, dialogContentId, backstage, ariaAttrs));
+      var storagedMenuButtons = mapMenuButtons(dialogInit.internalDialog.buttons);
+      var objOfCells = extractCellsToObject(storagedMenuButtons);
+      var memFooter = record(renderInlineFooter({ buttons: storagedMenuButtons }, backstage));
+      var dialogEvents = SilverDialogEvents.initDialog(function () {
+        return instanceApi;
+      }, {
+        onBlock: function (event) {
+          Blocking.block(dialog, function (_comp, bs) {
+            return getBusySpec(event.message, bs, backstage.shared.providers);
+          });
+        },
+        onUnblock: function () {
+          Blocking.unblock(dialog);
+        },
+        onClose: function () {
+          return extra.closeWindow();
+        }
+      }, backstage.shared.getSink);
+      var dialog = build$1({
+        dom: {
+          tag: 'div',
+          classes: [
+            'tox-dialog',
+            'tox-dialog-inline'
+          ],
+          attributes: (_a = { role: 'dialog' }, _a['aria-labelledby'] = dialogLabelId, _a['aria-describedby'] = dialogContentId, _a)
+        },
+        eventOrder: (_b = {}, _b[receive()] = [
+          Reflecting.name(),
+          Receiving.name()
+        ], _b[execute$5()] = ['execute-on-form'], _b[attachedToDom()] = [
+          'reflecting',
+          'execute-on-form'
+        ], _b),
+        behaviours: derive$1([
+          Keying.config({
+            mode: 'cyclic',
+            onEscape: function (c) {
+              emit(c, formCloseEvent);
+              return Optional.some(true);
+            },
+            useTabstopAt: function (elem) {
+              return !isPseudoStop(elem) && (name$2(elem) !== 'button' || get$d(elem, 'disabled') !== 'disabled');
+            }
+          }),
+          Reflecting.config({
+            channel: dialogChannel,
+            updateState: updateState,
+            initialData: dialogInit
+          }),
+          Focusing.config({}),
+          config('execute-on-form', dialogEvents.concat([runOnSource(focusin(), function (comp, _se) {
+              Keying.focusIn(comp);
+            })])),
+          Blocking.config({
+            getRoot: function () {
+              return Optional.some(dialog);
+            }
+          }),
+          Replacing.config({}),
+          RepresentingConfigs.memory({})
+        ]),
+        components: [
+          memHeader.asSpec(),
+          memBody.asSpec(),
+          memFooter.asSpec()
+        ]
+      });
+      var instanceApi = getDialogApi({
+        getRoot: constant$1(dialog),
+        getFooter: function () {
+          return memFooter.get(dialog);
+        },
+        getBody: function () {
+          return memBody.get(dialog);
+        },
+        getFormWrapper: function () {
+          var body = memBody.get(dialog);
+          return Composing.getCurrent(body).getOr(body);
+        }
+      }, extra.redial, objOfCells);
+      return {
+        dialog: dialog,
+        instanceApi: instanceApi
+      };
+    };
+
+    var global$1 = tinymce.util.Tools.resolve('tinymce.util.URI');
+
+    var getUrlDialogApi = function (root) {
+      var withRoot = function (f) {
+        if (root.getSystem().isConnected()) {
+          f(root);
+        }
+      };
+      var block = function (message) {
+        if (!isString(message)) {
+          throw new Error('The urlDialogInstanceAPI.block function should be passed a blocking message of type string as an argument');
+        }
+        withRoot(function (root) {
+          emitWith(root, formBlockEvent, { message: message });
+        });
+      };
+      var unblock = function () {
+        withRoot(function (root) {
+          emit(root, formUnblockEvent);
+        });
+      };
+      var close = function () {
+        withRoot(function (root) {
+          emit(root, formCloseEvent);
+        });
+      };
+      var sendMessage = function (data) {
+        withRoot(function (root) {
+          root.getSystem().broadcastOn([bodySendMessageChannel], data);
+        });
+      };
+      return {
+        block: block,
+        unblock: unblock,
+        close: close,
+        sendMessage: sendMessage
+      };
+    };
+
+    var SUPPORTED_MESSAGE_ACTIONS = [
+      'insertContent',
+      'setContent',
+      'execCommand',
+      'close',
+      'block',
+      'unblock'
+    ];
+    var isSupportedMessage = function (data) {
+      return isObject(data) && SUPPORTED_MESSAGE_ACTIONS.indexOf(data.mceAction) !== -1;
+    };
+    var isCustomMessage = function (data) {
+      return !isSupportedMessage(data) && isObject(data) && has$2(data, 'mceAction');
+    };
+    var handleMessage = function (editor, api, data) {
+      switch (data.mceAction) {
+      case 'insertContent':
+        editor.insertContent(data.content);
+        break;
+      case 'setContent':
+        editor.setContent(data.content);
+        break;
+      case 'execCommand':
+        var ui = isBoolean(data.ui) ? data.ui : false;
+        editor.execCommand(data.cmd, ui, data.value);
+        break;
+      case 'close':
+        api.close();
+        break;
+      case 'block':
+        api.block(data.message);
+        break;
+      case 'unblock':
+        api.unblock();
+        break;
+      }
+    };
+    var renderUrlDialog = function (internalDialog, extra, editor, backstage) {
+      var _a;
+      var header = getHeader(internalDialog.title, backstage);
+      var body = renderIframeBody(internalDialog);
+      var footer = internalDialog.buttons.bind(function (buttons) {
+        if (buttons.length === 0) {
+          return Optional.none();
+        } else {
+          return Optional.some(renderModalFooter({ buttons: buttons }, backstage));
+        }
+      });
+      var dialogEvents = SilverDialogEvents.initUrlDialog(function () {
+        return instanceApi;
+      }, getEventExtras(function () {
+        return dialog;
+      }, backstage.shared.providers, extra));
+      var styles = __assign(__assign({}, internalDialog.height.fold(function () {
+        return {};
+      }, function (height) {
+        return {
+          'height': height + 'px',
+          'max-height': height + 'px'
+        };
+      })), internalDialog.width.fold(function () {
+        return {};
+      }, function (width) {
+        return {
+          'width': width + 'px',
+          'max-width': width + 'px'
+        };
+      }));
+      var classes = internalDialog.width.isNone() && internalDialog.height.isNone() ? ['tox-dialog--width-lg'] : [];
+      var iframeUri = new global$1(internalDialog.url, { base_uri: new global$1(window.location.href) });
+      var iframeDomain = iframeUri.protocol + '://' + iframeUri.host + (iframeUri.port ? ':' + iframeUri.port : '');
+      var messageHandlerUnbinder = unbindable();
+      var extraBehaviours = [
+        config('messages', [
+          runOnAttached(function () {
+            var unbind = bind(SugarElement.fromDom(window), 'message', function (e) {
+              if (iframeUri.isSameOrigin(new global$1(e.raw.origin))) {
+                var data = e.raw.data;
+                if (isSupportedMessage(data)) {
+                  handleMessage(editor, instanceApi, data);
+                } else if (isCustomMessage(data)) {
+                  internalDialog.onMessage(instanceApi, data);
+                }
+              }
+            });
+            messageHandlerUnbinder.set(unbind);
+          }),
+          runOnDetached(messageHandlerUnbinder.clear)
+        ]),
+        Receiving.config({
+          channels: (_a = {}, _a[bodySendMessageChannel] = {
+            onReceive: function (comp, data) {
+              descendant(comp.element, 'iframe').each(function (iframeEle) {
+                var iframeWin = iframeEle.dom.contentWindow;
+                iframeWin.postMessage(data, iframeDomain);
+              });
+            }
+          }, _a)
+        })
+      ];
+      var spec = {
+        header: header,
+        body: body,
+        footer: footer,
+        extraClasses: classes,
+        extraBehaviours: extraBehaviours,
+        extraStyles: styles
+      };
+      var dialog = renderModalDialog(spec, internalDialog, dialogEvents, backstage);
+      var instanceApi = getUrlDialogApi(dialog);
+      return {
+        dialog: dialog,
+        instanceApi: instanceApi
+      };
+    };
+
+    var setup$2 = function (extras) {
+      var sharedBackstage = extras.backstage.shared;
+      var open = function (message, callback) {
+        var closeDialog = function () {
+          ModalDialog.hide(alertDialog);
+          callback();
+        };
+        var memFooterClose = record(renderFooterButton({
+          name: 'close-alert',
+          text: 'OK',
+          primary: true,
+          align: 'end',
+          disabled: false,
+          icon: Optional.none()
+        }, 'cancel', extras.backstage));
+        var titleSpec = pUntitled();
+        var closeSpec = pClose(closeDialog, sharedBackstage.providers);
+        var alertDialog = build$1(renderDialog$1({
+          lazySink: function () {
+            return sharedBackstage.getSink();
+          },
+          header: hiddenHeader(titleSpec, closeSpec),
+          body: pBodyMessage(message, sharedBackstage.providers),
+          footer: Optional.some(pFooter(pFooterGroup([], [memFooterClose.asSpec()]))),
+          onEscape: closeDialog,
+          extraClasses: ['tox-alert-dialog'],
+          extraBehaviours: [],
+          extraStyles: {},
+          dialogEvents: [run$1(formCancelEvent, closeDialog)],
+          eventOrder: {}
+        }));
+        ModalDialog.show(alertDialog);
+        var footerCloseButton = memFooterClose.get(alertDialog);
+        Focusing.focus(footerCloseButton);
+      };
+      return { open: open };
+    };
+
+    var setup$1 = function (extras) {
+      var sharedBackstage = extras.backstage.shared;
+      var open = function (message, callback) {
+        var closeDialog = function (state) {
+          ModalDialog.hide(confirmDialog);
+          callback(state);
+        };
+        var memFooterYes = record(renderFooterButton({
+          name: 'yes',
+          text: 'Yes',
+          primary: true,
+          align: 'end',
+          disabled: false,
+          icon: Optional.none()
+        }, 'submit', extras.backstage));
+        var footerNo = renderFooterButton({
+          name: 'no',
+          text: 'No',
+          primary: false,
+          align: 'end',
+          disabled: false,
+          icon: Optional.none()
+        }, 'cancel', extras.backstage);
+        var titleSpec = pUntitled();
+        var closeSpec = pClose(function () {
+          return closeDialog(false);
+        }, sharedBackstage.providers);
+        var confirmDialog = build$1(renderDialog$1({
+          lazySink: function () {
+            return sharedBackstage.getSink();
+          },
+          header: hiddenHeader(titleSpec, closeSpec),
+          body: pBodyMessage(message, sharedBackstage.providers),
+          footer: Optional.some(pFooter(pFooterGroup([], [
+            footerNo,
+            memFooterYes.asSpec()
+          ]))),
+          onEscape: function () {
+            return closeDialog(false);
+          },
+          extraClasses: ['tox-confirm-dialog'],
+          extraBehaviours: [],
+          extraStyles: {},
+          dialogEvents: [
+            run$1(formCancelEvent, function () {
+              return closeDialog(false);
+            }),
+            run$1(formSubmitEvent, function () {
+              return closeDialog(true);
+            })
+          ],
+          eventOrder: {}
+        }));
+        ModalDialog.show(confirmDialog);
+        var footerYesButton = memFooterYes.get(confirmDialog);
+        Focusing.focus(footerYesButton);
+      };
+      return { open: open };
+    };
+
+    var validateData = function (data, validator) {
+      return getOrDie(asRaw('data', validator, data));
+    };
+    var isAlertOrConfirmDialog = function (target) {
+      return closest(target, '.tox-alert-dialog') || closest(target, '.tox-confirm-dialog');
+    };
+    var inlineAdditionalBehaviours = function (editor, isStickyToolbar, isToolbarLocationTop) {
+      if (isStickyToolbar && isToolbarLocationTop) {
+        return [];
+      } else {
+        return [Docking.config({
+            contextual: {
+              lazyContext: function () {
+                return Optional.some(box$1(SugarElement.fromDom(editor.getContentAreaContainer())));
+              },
+              fadeInClass: 'tox-dialog-dock-fadein',
+              fadeOutClass: 'tox-dialog-dock-fadeout',
+              transitionClass: 'tox-dialog-dock-transition'
+            },
+            modes: ['top']
+          })];
+      }
+    };
+    var setup = function (extras) {
+      var backstage = extras.backstage;
+      var editor = extras.editor;
+      var isStickyToolbar$1 = isStickyToolbar(editor);
+      var alertDialog = setup$2(extras);
+      var confirmDialog = setup$1(extras);
+      var open = function (config, params, closeWindow) {
+        if (params !== undefined && params.inline === 'toolbar') {
+          return openInlineDialog(config, backstage.shared.anchors.inlineDialog(), closeWindow, params.ariaAttrs);
+        } else if (params !== undefined && params.inline === 'cursor') {
+          return openInlineDialog(config, backstage.shared.anchors.cursor(), closeWindow, params.ariaAttrs);
+        } else {
+          return openModalDialog(config, closeWindow);
+        }
+      };
+      var openUrl = function (config, closeWindow) {
+        return openModalUrlDialog(config, closeWindow);
+      };
+      var openModalUrlDialog = function (config, closeWindow) {
+        var factory = function (contents) {
+          var dialog = renderUrlDialog(contents, {
+            closeWindow: function () {
+              ModalDialog.hide(dialog.dialog);
+              closeWindow(dialog.instanceApi);
+            }
+          }, editor, backstage);
+          ModalDialog.show(dialog.dialog);
+          return dialog.instanceApi;
+        };
+        return DialogManager.openUrl(factory, config);
+      };
+      var openModalDialog = function (config, closeWindow) {
+        var factory = function (contents, internalInitialData, dataValidator) {
+          var initialData = internalInitialData;
+          var dialogInit = {
+            dataValidator: dataValidator,
+            initialData: initialData,
+            internalDialog: contents
+          };
+          var dialog = renderDialog(dialogInit, {
+            redial: DialogManager.redial,
+            closeWindow: function () {
+              ModalDialog.hide(dialog.dialog);
+              closeWindow(dialog.instanceApi);
+            }
+          }, backstage);
+          ModalDialog.show(dialog.dialog);
+          dialog.instanceApi.setData(initialData);
+          return dialog.instanceApi;
+        };
+        return DialogManager.open(factory, config);
+      };
+      var openInlineDialog = function (config$1, anchor, closeWindow, ariaAttrs) {
+        var factory = function (contents, internalInitialData, dataValidator) {
+          var initialData = validateData(internalInitialData, dataValidator);
+          var inlineDialog = value$1();
+          var isToolbarLocationTop = backstage.shared.header.isPositionedAtTop();
+          var dialogInit = {
+            dataValidator: dataValidator,
+            initialData: initialData,
+            internalDialog: contents
+          };
+          var refreshDocking = function () {
+            return inlineDialog.on(function (dialog) {
+              InlineView.reposition(dialog);
+              Docking.refresh(dialog);
+            });
+          };
+          var dialogUi = renderInlineDialog(dialogInit, {
+            redial: DialogManager.redial,
+            closeWindow: function () {
+              inlineDialog.on(InlineView.hide);
+              editor.off('ResizeEditor', refreshDocking);
+              inlineDialog.clear();
+              closeWindow(dialogUi.instanceApi);
+            }
+          }, backstage, ariaAttrs);
+          var inlineDialogComp = build$1(InlineView.sketch(__assign(__assign({
+            lazySink: backstage.shared.getSink,
+            dom: {
+              tag: 'div',
+              classes: []
+            },
+            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), true)),
+            isExtraPart: function (_comp, target) {
+              return isAlertOrConfirmDialog(target);
+            }
+          })));
+          inlineDialog.set(inlineDialogComp);
+          InlineView.showWithin(inlineDialogComp, premade(dialogUi.dialog), { anchor: anchor }, Optional.some(body()));
+          if (!isStickyToolbar$1 || !isToolbarLocationTop) {
+            Docking.refresh(inlineDialogComp);
+            editor.on('ResizeEditor', refreshDocking);
+          }
+          dialogUi.instanceApi.setData(initialData);
+          Keying.focusIn(dialogUi.dialog);
+          return dialogUi.instanceApi;
+        };
+        return DialogManager.open(factory, config$1);
+      };
+      var confirm = function (message, callback) {
+        confirmDialog.open(message, function (state) {
+          callback(state);
+        });
+      };
+      var alert = function (message, callback) {
+        alertDialog.open(message, function () {
+          callback();
+        });
+      };
+      var close = function (instanceApi) {
+        instanceApi.close();
+      };
+      return {
+        open: open,
+        openUrl: openUrl,
+        alert: alert,
+        close: close,
+        confirm: confirm
+      };
+    };
+
+    function Theme () {
+      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
+        });
+        return {
+          renderUI: renderUI,
+          getWindowManagerImpl: constant$1(windowMgr),
+          getNotificationManagerImpl: function () {
+            return NotificationManagerImpl(editor, { backstage: backstage }, uiMothership);
+          },
+          ui: getUi()
+        };
+      });
+    }
+
+    Theme();
+
+}());
diff --git a/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.js.gz b/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.js.gz
new file mode 100644
index 0000000..c6dc5c7
Binary files /dev/null and b/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.js.gz differ
diff --git a/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.min.js b/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.min.js
new file mode 100644
index 0000000..81d84bb
--- /dev/null
+++ b/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.min.js
@@ -0,0 +1,9 @@
+/**
+ * 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.10.7 (2022-12-06)
+ */
+!function(){"use strict";function t(o){return function(t){return n=typeof(e=t),(null===e?"null":"object"==n&&(Array.prototype.isPrototypeOf(e)||e.constructor&&"Array"===e.constructor.name)?"array":"object"==n&&(String.prototype.isPrototypeOf(e)||e.constructor&&"String"===e.constructor.name)?"string":n)===o;var e,n}}function e(e){return function(t){return typeof t===e}}function n(e){return function(t){return e===t}}function g(t){return null==t}function f(t,e){if(c(t)){for(var n=0,o=t.length;n<o;++n)if(!e(t[n]))return;return 1}}function st(){}function r(n,o){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return n(o.apply(null,t))}}function rt(t){return function(){return t}}function h(t){return t}function v(t,e){return t===e}var y=t("string"),x=t("object"),c=t("array"),b=n(null),w=e("boolean"),E=n(void 0),k=function(t){return!g(t)},S=e("function"),u=e("number");function C(o){for(var r=[],t=1;t<arguments.length;t++)r[t-1]=arguments[t];return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];var n=r.concat(t);return o.apply(null,n)}}function O(e){return function(t){return!e(t)}}function _(t){return function(){throw new Error(t)}}var T=rt(!1),D=rt(!0),o=tinymce.util.Tools.resolve("tinymce.ThemeManager"),lt=function(){return(lt=Object.assign||function(t){for(var e,n=1,o=arguments.length;n<o;n++)for(var r in e=arguments[n])Object.prototype.hasOwnProperty.call(e,r)&&(t[r]=e[r]);return t}).apply(this,arguments)};function A(t,e){var n={};for(r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(null!=t&&"function"==typeof Object.getOwnPropertySymbols)for(var o=0,r=Object.getOwnPropertySymbols(t);o<r.length;o++)e.indexOf(r[o])<0&&Object.prototype.propertyIsEnumerable.call(t,r[o])&&(n[r[o]]=t[r[o]]);return n}function V(t,e,n){if(n||2===arguments.length)for(var o,r=0,i=e.length;r<i;r++)!o&&r in e||((o=o||Array.prototype.slice.call(e,0,r))[r]=e[r]);return t.concat(o||Array.prototype.slice.call(e))}function i(){return a}var a={fold:function(t,e){return t()},isSome:T,isNone:D,getOr:h,getOrThunk:s,getOrDie:function(t){throw new Error(t||"error: getOrDie called on none.")},getOrNull:rt(null),getOrUndefined:rt(void 0),or:h,orThunk:s,map:i,each:st,bind:i,exists:T,forall:D,filter:function(){return a},toArray:function(){return[]},toString:rt("none()")};function s(t){return t()}function l(t,e){return yt.call(t,e)}function d(t,e){for(var n=0,o=t.length;n<o;n++)if(e(t[n],n))return!0;return!1}function m(t,e){for(var n=[],o=0;o<t;o++)n.push(e(o));return n}function p(t,e){for(var n=[],o=0;o<t.length;o+=e){var r=bt.call(t,o,o+e);n.push(r)}return n}function B(t,e){for(var n=t.length,o=new Array(n),r=0;r<n;r++){var i=t[r];o[r]=e(i,r)}return o}function M(t,e){for(var n=[],o=[],r=0,i=t.length;r<i;r++){var u=t[r];(e(u,r)?n:o).push(u)}return{pass:n,fail:o}}function F(t,e){for(var n=[],o=0,r=t.length;o<r;o++){var i=t[o];e(i,o)&&n.push(i)}return n}function I(t,o,r){return function(t){for(var e,n=t.length-1;0<=n;n--)e=t[n],r=o(r,e,n)}(t),r}function R(t,n,o){return St(t,function(t,e){o=n(o,t,e)}),o}function N(t,e){return function(t,e,n){for(var o=0,r=t.length;o<r;o++){var i=t[o];if(e(i,o))return vt.some(i);if(n(i,o))break}return vt.none()}(t,e,T)}function P(t,e){for(var n=0,o=t.length;n<o;n++)if(e(t[n],n))return vt.some(n);return vt.none()}function ft(t){for(var e=[],n=0,o=t.length;n<o;++n){if(!c(t[n]))throw new Error("Arr.flatten item "+n+" was not an array, input: "+t);xt.apply(e,t[n])}return e}function H(t,e){return ft(B(t,e))}function L(t,e){for(var n=0,o=t.length;n<o;++n)if(!0!==e(t[n],n))return!1;return!0}function z(t){var e=bt.call(t,0);return e.reverse(),e}function U(t,e){return F(t,function(t){return!wt(e,t)})}function j(t,e){for(var n={},o=0,r=t.length;o<r;o++){var i=t[o];n[String(i)]=e(i,o)}return n}function W(t){return[t]}function G(t,e){var n=bt.call(t,0);return n.sort(e),n}function X(t,e){return 0<=e&&e<t.length?vt.some(t[e]):vt.none()}function Y(t){return X(t,0)}function q(t){return X(t,t.length-1)}function K(t,e){for(var n=0;n<t.length;n++){var o=e(t[n],n);if(o.isSome())return o}return vt.none()}function J(t,e){for(var n=Ct(t),o=0,r=n.length;o<r;o++){var i=n[o];e(t[i],i)}}function dt(t,n){return _t(t,function(t,e){return{k:e,v:n(t,e)}})}function $(t,n){var o=[];return J(t,function(t,e){o.push(n(t,e))}),o}function Q(t,e){for(var n=Ct(t),o=0,r=n.length;o<r;o++){var i=n[o],u=t[i];if(e(u,i,t))return vt.some(u)}return vt.none()}function Z(t){return $(t,h)}function tt(t,e){return Tt(t,e)?vt.from(t[e]):vt.none()}function et(t,e){return Tt(t,e)&&void 0!==t[e]&&null!==t[e]}function mt(t,e,n){return void 0===n&&(n=v),t.exists(function(t){return n(t,e)})}function nt(t){for(var e=[],n=function(t){e.push(t)},o=0;o<t.length;o++)t[o].each(n);return e}function ot(t,e){return t?vt.some(e):vt.none()}function it(t,e,n){return""===e||t.length>=e.length&&t.substr(n,n+e.length)===e}function ut(t,e){return-1!==t.indexOf(e)}function at(t){return 0<t.length}function ct(t){return void 0!==t.style&&S(t.style.getPropertyValue)}function gt(t){if(null==t)throw new Error("Node cannot be null or undefined");return{dom:t}}var pt,ht=function(n){function t(){return r}function e(t){return t(n)}var o=rt(n),r={fold:function(t,e){return e(n)},isSome:D,isNone:T,getOr:o,getOrThunk:o,getOrDie:o,getOrNull:o,getOrUndefined:o,or:t,orThunk:t,map:function(t){return ht(t(n))},each:function(t){t(n)},bind:e,exists:e,forall:e,filter:function(t){return t(n)?r:a},toArray:function(){return[n]},toString:function(){return"some("+n+")"}};return r},vt={some:ht,none:i,from:function(t){return null==t?a:ht(t)}},bt=Array.prototype.slice,yt=Array.prototype.indexOf,xt=Array.prototype.push,wt=function(t,e){return-1<l(t,e)},St=function(t,e){for(var n=0,o=t.length;n<o;n++)e(t[n],n)},kt=S(Array.from)?Array.from:function(t){return bt.call(t)},Ct=Object.keys,Ot=Object.hasOwnProperty,_t=function(t,o){var r={};return J(t,function(t,e){var n=o(t,e);r[n.k]=n.v}),r},Tt=function(t,e){return Ot.call(t,e)},Et=function(t,e,n){return t.isSome()&&e.isSome()?vt.some(n(t.getOrDie(),e.getOrDie())):vt.none()},Dt=function(t,e){return it(t,e,0)},At=function(t,e){return it(t,e,t.length-e.length)},Bt=(pt=/^\s+|\s+$/g,function(t){return t.replace(pt,"")}),Mt={fromHtml:function(t,e){var n=(e||document).createElement("div");if(n.innerHTML=t,!n.hasChildNodes()||1<n.childNodes.length)throw console.error("HTML does not have a single root node",t),new Error("HTML must have a single root node");return gt(n.childNodes[0])},fromTag:function(t,e){var n=(e||document).createElement(t);return gt(n)},fromText:function(t,e){var n=(e||document).createTextNode(t);return gt(n)},fromDom:gt,fromPoint:function(t,e,n){return vt.from(t.dom.elementFromPoint(e,n)).map(gt)}};function Ft(t){return t.dom.nodeName.toLowerCase()}function It(e){return function(t){return t.dom.nodeType===e}}function Rt(n){var o,r=!1;return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return r||(r=!0,o=n.apply(null,t)),o}}function Nt(t,e){var n=String(e).toLowerCase();return N(t,function(t){return t.search(n)})}function Pt(e){return function(t){return ut(t,e)}}function Vt(t){return window.matchMedia(t).matches}function Ht(t,e){var n=t.dom;if(1!==n.nodeType)return!1;var o=n;if(void 0!==o.matches)return o.matches(e);if(void 0!==o.msMatchesSelector)return o.msMatchesSelector(e);if(void 0!==o.webkitMatchesSelector)return o.webkitMatchesSelector(e);if(void 0!==o.mozMatchesSelector)return o.mozMatchesSelector(e);throw new Error("Browser lacks native selectors")}function Lt(t){return 1!==t.nodeType&&9!==t.nodeType&&11!==t.nodeType||0===t.childElementCount}function zt(t,e){return t.dom===e.dom}function Ut(t,e){return ln().browser.isIE()?(n=t.dom,o=e.dom,r=Node.DOCUMENT_POSITION_CONTAINED_BY,0!=(n.compareDocumentPosition(o)&r)):(i=t.dom)!==(u=e.dom)&&i.contains(u);var n,o,r,i,u}function jt(t){return Mt.fromDom(t.dom.ownerDocument)}function Wt(t){return Ye(t)?t:jt(t)}function Gt(t){return Mt.fromDom(Wt(t).dom.documentElement)}function Xt(t){return Mt.fromDom(Wt(t).dom.defaultView)}function Yt(t){return vt.from(t.dom.parentNode).map(Mt.fromDom)}function qt(t){return vt.from(t.dom.offsetParent).map(Mt.fromDom)}function Kt(t){return B(t.dom.childNodes,Mt.fromDom)}function Jt(t,e){var n=t.dom.childNodes;return vt.from(n[e]).map(Mt.fromDom)}function $t(t,e){return{element:t,offset:e}}function Qt(t,e){var n=Kt(t);return 0<n.length&&e<n.length?$t(n[e],0):$t(t,e)}function Zt(t){return qe(t)&&k(t.dom.host)}function te(t){return Zt(t)?t:Mt.fromDom(Wt(t).dom.body)}function ee(t){return Mt.fromDom(t.dom.host)}function ne(t,e,n){if(!(y(n)||w(n)||u(n)))throw console.error("Invalid call to Attribute.set. Key ",e,":: Value ",n,":: Element ",t),new Error("Attribute value was not simple");t.setAttribute(e,n+"")}function oe(t,e,n){ne(t.dom,e,n)}function re(t,e){var n=t.dom;J(e,function(t,e){ne(n,e,t)})}function ie(t,e){var n=t.dom.getAttribute(e);return null===n?void 0:n}function ue(t,e){return vt.from(ie(t,e))}function ae(t,e){var n=t.dom;return!(!n||!n.hasAttribute)&&n.hasAttribute(e)}function ce(t,e){t.dom.removeAttribute(e)}function se(t,e,n){if(!y(n))throw console.error("Invalid call to CSS.set. Property ",e,":: Value ",n,":: Element ",t),new Error("CSS value must be a string: "+n);ct(t)&&t.style.setProperty(e,n)}function le(t,e){ct(t)&&t.style.removeProperty(e)}function fe(t,e,n){se(t.dom,e,n)}function de(t,e){var n=t.dom;J(e,function(t,e){se(n,e,t)})}function me(t,e){var n=t.dom;J(e,function(t,e){t.fold(function(){le(n,e)},function(t){se(n,e,t)})})}function ge(t,e){var n=t.dom,o=window.getComputedStyle(n).getPropertyValue(e);return""!==o||vn(t)?o:xn(n,e)}function pe(t,e){var n=t.dom,o=xn(n,e);return vt.from(o).filter(function(t){return 0<t.length})}function he(t,e,n){var o=Mt.fromTag(t);return fe(o,e,n),pe(o,e).isSome()}function ve(t,e){le(t.dom,e),mt(ue(t,"style").map(Bt),"")&&ce(t,"style")}function be(t){return t.dom.offsetWidth}function ye(o,r){function t(t){var e=r(t);if(e<=0||null===e){var n=ge(t,o);return parseFloat(n)||0}return e}function i(r,t){return R(t,function(t,e){var n=ge(r,e),o=void 0===n?0:parseInt(n,10);return isNaN(o)?t:t+o},0)}return{set:function(t,e){if(!u(e)&&!e.match(/^[0-9]+$/))throw new Error(o+".set accepts only positive integer values. Value was "+e);var n=t.dom;ct(n)&&(n.style[o]=e+"px")},get:t,getOuter:t,aggregate:i,max:function(t,e,n){var o=i(t,n);return o<e?e-o:0}}}function xe(t){return wn.get(t)}function we(t){return wn.getOuter(t)}function Se(t,e){return void 0!==t?t:void 0!==e?e:0}function ke(t){var e=t.dom.ownerDocument,n=e.body,o=e.defaultView,r=e.documentElement;if(n===t.dom)return kn(n.offsetLeft,n.offsetTop);var i=Se(null==o?void 0:o.pageYOffset,r.scrollTop),u=Se(null==o?void 0:o.pageXOffset,r.scrollLeft),a=Se(r.clientTop,n.clientTop),c=Se(r.clientLeft,n.clientLeft);return Cn(t).translate(u-c,i-a)}function Ce(t){return On.get(t)}function Oe(t){return On.getOuter(t)}function _e(t){function e(){return t.stopPropagation()}function n(){return t.preventDefault()}var o=r(n,e);return{target:Mt.fromDom(function(t){if(mn()&&k(t.target)){var e=Mt.fromDom(t.target);if(Ge(e)&&hn(e)&&t.composed&&t.composedPath){var n=t.composedPath();if(n)return Y(n)}}return vt.from(t.target)}(t).getOr(t.target)),x:t.clientX,y:t.clientY,stop:e,prevent:n,kill:o,raw:t}}function Te(t,e,n,o,r){var i,u,a=(i=n,u=o,function(t){i(t)&&u(_e(t))});return t.dom.addEventListener(e,a,r),{unbind:C(_n,t,e,a,r)}}function Ee(e,n){Yt(e).each(function(t){t.dom.insertBefore(n.dom,e.dom)})}function De(t,e){vt.from(t.dom.nextSibling).map(Mt.fromDom).fold(function(){Yt(t).each(function(t){Tn(t,e)})},function(t){Ee(t,e)})}function Ae(e,n){Jt(e,0).fold(function(){Tn(e,n)},function(t){e.dom.insertBefore(n.dom,t.dom)})}function Be(e,t){St(t,function(t){Tn(e,t)})}function Me(t){t.dom.textContent="",St(Kt(t),function(t){En(t)})}function Fe(t){var e,n=Kt(t);0<n.length&&(e=t,St(n,function(t){Ee(e,t)})),En(t)}function Ie(t){var e=void 0!==t?t.dom:document,n=e.body.scrollLeft||e.documentElement.scrollLeft,o=e.body.scrollTop||e.documentElement.scrollTop;return kn(n,o)}function Re(t,e,n){var o=(void 0!==n?n.dom:document).defaultView;o&&o.scrollTo(t,e)}function Ne(t,e,n,o){return{x:t,y:e,width:n,height:o,right:t+n,bottom:e+o}}function Pe(t){var o=void 0===t?window:t,e=o.document,r=Ie(Mt.fromDom(e)),n=void 0===o?window:o;return(ln().browser.isFirefox()?vt.none():vt.from(n.visualViewport)).fold(function(){var t=o.document.documentElement,e=t.clientWidth,n=t.clientHeight;return Ne(r.left,r.top,e,n)},function(t){return Ne(Math.max(t.pageLeft,r.left),Math.max(t.pageTop,r.top),t.width,t.height)})}function Ve(o){var t,r=Ie(Mt.fromDom(document)),e=(t=An).owner(o),n=Dn(t,e);return vt.some(n).fold(C(ke,o),function(t){var e=Cn(o),n=I(t,function(t,e){var n=Cn(e);return{left:t.left+n.left,top:t.top+n.top}},{left:0,top:0});return kn(n.left+e.left+r.left,n.top+e.top+r.top)})}function He(t){var e=Ve(t),n=Oe(t),o=we(t);return Bn(e.left,e.top,n,o)}"undefined"!=typeof window||Function("return this;")();function Le(){return Ke(0,0)}function ze(t){function e(t){return function(){return n===t}}var n=t.current,o=t.version;return{current:n,version:o,isEdge:e("Edge"),isChrome:e("Chrome"),isIE:e("IE"),isOpera:e("Opera"),isFirefox:e(Ze),isSafari:e("Safari")}}function Ue(t){function e(t){return function(){return n===t}}var n=t.current,o=t.version;return{current:n,version:o,isWindows:e(nn),isiOS:e("iOS"),isAndroid:e(on),isOSX:e("OSX"),isLinux:e("Linux"),isSolaris:e(rn),isFreeBSD:e(un),isChromeOS:e(an)}}var je,We,Ge=It(1),Xe=It(3),Ye=It(9),qe=It(11),Ke=function(t,e){return{major:t,minor:e}},Je={nu:Ke,detect:function(t,e){var n,o,r=String(e).toLowerCase();return 0===t.length?Le():(o=function(t,e){for(var n=0;n<t.length;n++){var o=t[n];if(o.test(e))return o}}(t,n=r))?Ke(i(1),i(2)):{major:0,minor:0};function i(t){return Number(n.replace(o,"$"+t))}},unknown:Le},$e=/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,Qe={browsers:rt([{name:"Edge",versionRegexes:[/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],search:function(t){return ut(t,"edge/")&&ut(t,"chrome")&&ut(t,"safari")&&ut(t,"applewebkit")}},{name:"Chrome",brand:"Chromium",versionRegexes:[/.*?chrome\/([0-9]+)\.([0-9]+).*/,$e],search:function(t){return ut(t,"chrome")&&!ut(t,"chromeframe")}},{name:"IE",versionRegexes:[/.*?msie\ ?([0-9]+)\.([0-9]+).*/,/.*?rv:([0-9]+)\.([0-9]+).*/],search:function(t){return ut(t,"msie")||ut(t,"trident")}},{name:"Opera",versionRegexes:[$e,/.*?opera\/([0-9]+)\.([0-9]+).*/],search:Pt("opera")},{name:"Firefox",versionRegexes:[/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],search:Pt("firefox")},{name:"Safari",versionRegexes:[$e,/.*?cpu os ([0-9]+)_([0-9]+).*/],search:function(t){return(ut(t,"safari")||ut(t,"mobile/"))&&ut(t,"applewebkit")}}]),oses:rt([{name:"Windows",search:Pt("win"),versionRegexes:[/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]},{name:"iOS",search:function(t){return ut(t,"iphone")||ut(t,"ipad")},versionRegexes:[/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,/.*cpu os ([0-9]+)_([0-9]+).*/,/.*cpu iphone os ([0-9]+)_([0-9]+).*/]},{name:"Android",search:Pt("android"),versionRegexes:[/.*?android\ ?([0-9]+)\.([0-9]+).*/]},{name:"OSX",search:Pt("mac os x"),versionRegexes:[/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]},{name:"Linux",search:Pt("linux"),versionRegexes:[]},{name:"Solaris",search:Pt("sunos"),versionRegexes:[]},{name:"FreeBSD",search:Pt("freebsd"),versionRegexes:[]},{name:"ChromeOS",search:Pt("cros"),versionRegexes:[/.*?chrome\/([0-9]+)\.([0-9]+).*/]}])},Ze="Firefox",tn=function(){return ze({current:void 0,version:Je.unknown()})},en=ze,nn=(rt("Edge"),rt("Chrome"),rt("IE"),rt("Opera"),rt(Ze),rt("Safari"),"Windows"),on="Android",rn="Solaris",un="FreeBSD",an="ChromeOS",cn=function(){return Ue({current:void 0,version:Je.unknown()})},sn=Ue,ln=(rt(nn),rt("iOS"),rt(on),rt("Linux"),rt("OSX"),rt(rn),rt(un),rt(an),Rt(function(){return t=navigator.userAgent,e=vt.from(navigator.userAgentData),n=Vt,p=Qe.browsers(),h=Qe.oses(),v=e.bind(function(t){return o=p,K(t.brands,function(e){var n=e.brand.toLowerCase();return N(o,function(t){var e;return n===(null===(e=t.brand)||void 0===e?void 0:e.toLowerCase())}).map(function(t){return{current:t.name,version:Je.nu(parseInt(e.version,10),0)}})});var o}).orThunk(function(){return Nt(p,n=t).map(function(t){var e=Je.detect(t.versionRegexes,n);return{current:t.name,version:e}});var n}).fold(tn,en),b=Nt(h,o=t).map(function(t){var e=Je.detect(t.versionRegexes,o);return{current:t.name,version:e}}).fold(cn,sn),{browser:v,os:b,deviceType:(i=v,u=t,a=n,c=(r=b).isiOS()&&!0===/ipad/i.test(u),s=r.isiOS()&&!c,f=(l=r.isiOS()||r.isAndroid())||a("(pointer:coarse)"),d=c||!s&&l&&a("(min-device-width:768px)"),m=s||l&&!d,g=i.isSafari()&&r.isiOS()&&!1===/safari/i.test(u),{isiPad:rt(c),isiPhone:rt(s),isTablet:rt(d),isPhone:rt(m),isTouch:rt(f),isAndroid:r.isAndroid,isiOS:r.isiOS,isWebView:rt(g),isDesktop:rt(!m&&!d&&!g)})};var t,e,n,o,r,i,u,a,c,s,l,f,d,m,g,p,h,v,b})),fn=Yt,dn=S(Element.prototype.attachShadow)&&S(Node.prototype.getRootNode),mn=rt(dn),gn=dn?function(t){return Mt.fromDom(t.dom.getRootNode())}:Wt,pn=function(t){var e=gn(t);return Zt(e)?vt.some(e):vt.none()},hn=function(t){return k(t.dom.shadowRoot)},vn=function(t){var e=Xe(t)?t.dom.parentNode:t.dom;if(null==e||null===e.ownerDocument)return!1;var n,o,r=e.ownerDocument;return pn(Mt.fromDom(e)).fold(function(){return r.body.contains(e)},(n=vn,o=ee,function(t){return n(o(t))}))},bn=function(){return yn(Mt.fromDom(document))},yn=function(t){var e=t.dom.body;if(null==e)throw new Error("Body is not available yet");return Mt.fromDom(e)},xn=function(t,e){return ct(t)?t.style.getPropertyValue(e):""},wn=ye("height",function(t){var e=t.dom;return vn(t)?e.getBoundingClientRect().height:e.offsetHeight}),Sn=function(n,o){return{left:n,top:o,translate:function(t,e){return Sn(n+t,o+e)}}},kn=Sn,Cn=function(t){var e,n=t.dom,o=n.ownerDocument.body;return o===n?kn(o.offsetLeft,o.offsetTop):vn(t)?(e=n.getBoundingClientRect(),kn(e.left,e.top)):kn(0,0)},On=ye("width",function(t){return t.dom.offsetWidth}),_n=function(t,e,n,o){t.dom.removeEventListener(e,n,o)},Tn=function(t,e){t.dom.appendChild(e.dom)},En=function(t){var e=t.dom;null!==e.parentNode&&e.parentNode.removeChild(e)},Dn=function(o,t){return o.view(t).fold(rt([]),function(t){var e=o.owner(t),n=Dn(o,e);return[t].concat(n)})},An=Object.freeze({__proto__:null,view:function(t){var e;return(t.dom===document?vt.none():vt.from(null===(e=t.dom.defaultView)||void 0===e?void 0:e.frameElement)).map(Mt.fromDom)},owner:jt}),Bn=function(t,e,n,o){return{x:t,y:e,width:n,height:o,right:t+n,bottom:e+o}},Mn=function(t){var e=ke(t),n=Oe(t),o=we(t);return Bn(e.left,e.top,n,o)},Fn=function(){return Pe(window)},In=function(n){return{isValue:D,isError:T,getOr:rt(n),getOrThunk:rt(n),getOrDie:rt(n),or:function(t){return In(n)},orThunk:function(t){return In(n)},fold:function(t,e){return e(n)},map:function(t){return In(t(n))},mapError:function(t){return In(n)},each:function(t){t(n)},bind:function(t){return t(n)},exists:function(t){return t(n)},forall:function(t){return t(n)},toOptional:function(){return vt.some(n)}}},Rn=function(n){return{isValue:T,isError:D,getOr:h,getOrThunk:function(t){return t()},getOrDie:function(){return _(String(n))()},or:h,orThunk:function(t){return t()},fold:function(t,e){return t(n)},map:function(t){return Rn(n)},mapError:function(t){return Rn(t(n))},each:st,bind:function(t){return Rn(n)},exists:T,forall:D,toOptional:vt.none}},Nn={value:In,error:Rn,fromOption:function(t,e){return t.fold(function(){return Rn(e)},In)}};function Pn(t,e,n){return t.stype===je.Error?e(t.serror):n(t.svalue)}function Vn(t){return{stype:je.Value,svalue:t}}function Hn(t){return{stype:je.Error,serror:t}}function Ln(t,e,n,o){return{tag:"field",key:t,newKey:e,presence:n,prop:o}}function zn(t,e,n){switch(t.tag){case"field":return e(t.key,t.newKey,t.presence,t.prop);case"custom":return n(t.newKey,t.instantiator)}}function Un(u){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];if(0===t.length)throw new Error("Can't merge zero objects");for(var n={},o=0;o<t.length;o++){var r,i=t[o];for(r in i)Tt(i,r)&&(n[r]=u(n[r],i[r]))}return n}}function jn(){return{tag:"required",process:{}}}function Wn(t){return{tag:"defaultedThunk",process:t}}function Gn(t){return Wn(rt(t))}function Xn(){return{tag:"option",process:{}}}function Yn(t){return{tag:"mergeWithThunk",process:t}}function qn(t){return x(t)&&100<Ct(t).length?" removed due to size":JSON.stringify(t,null,2)}function Kn(t,e){return zo([{path:t,getErrorInfo:e}])}function Jn(n){return{extract:function(e,t){return jo(n(t),function(t){return Kn(e,rt(t))})},toString:rt("val")}}function $n(t,e,n,o){return o(tt(t,e).getOrThunk(function(){return n(t)}))}function Qn(e,n,o,r,i){function u(t){return i.extract(n.concat([r]),t)}function t(t){return t.fold(function(){return Lo(vt.none())},function(t){var e=i.extract(n.concat([r]),t);return Wo(e,vt.some)})}var a,c,s,l,f,d;switch(e.tag){case"required":return s=n,d=u,tt(l=o,f=r).fold(function(){return t=f,e=l,Kn(s,function(){return'Could not find valid *required* value for "'+t+'" in '+qn(e)});var t,e},d);case"defaultedThunk":return $n(o,r,e.process,u);case"option":return t(tt(o,r));case"defaultedOptionThunk":return c=e.process,t(tt(a=o,r).map(function(t){return!0===t?c(a):t}));case"mergeWithThunk":return $n(o,r,rt({}),function(t){return u(Yo(e.process(o),t))})}}function Zn(n){return{extract:function(t,e){return n().extract(t,e)},toString:function(){return n().toString()}}}function to(t){var s=$o(t),l=I(t,function(n,t){return zn(t,function(t){var e;return Yo(n,((e={})[t]=!0,e))},rt(n))},{});return{extract:function(t,e){var n,o,r,i,u,a,c=F(w(e)?[]:Ct((r=k,i=o={},u=function(t,e){i[e]=t},a=st,J(e,function(t,e){(r(t,e)?u:a)(t,e)}),o)),function(t){return!et(l,t)});return 0===c.length?s.extract(t,e):(n=c,Kn(t,function(){return"There are unsupported fields: ["+n.join(", ")+"] specified"}))},toString:s.toString}}function eo(o){return{extract:function(n,t){var e=B(t,function(t,e){return o.extract(n.concat(["["+e+"]"]),t)});return Ko(e)},toString:function(){return"array("+o.toString()+")"}}}function no(u){return{extract:function(t,e){for(var n=[],o=0,r=u;o<r.length;o++){var i=r[o].extract(t,e);if(i.stype===je.Value)return i;n.push(i)}return Ko(n)},toString:function(){return"oneOf("+B(u,function(t){return t.toString()}).join(", ")+")"}}}function oo(n,o){return Jn(function(t){var e=typeof t;return n(t)?Lo(t):zo("Expected type: "+o+" but got: "+e)})}function ro(e,a){return{extract:function(i,u){return tt(u,e).fold(function(){return t=e,Kn(i,function(){return'Choice schema did not contain choice key: "'+t+'"'});var t},function(t){return n=i,e=u,tt(o=a,r=t).fold(function(){return t=o,e=r,Kn(n,function(){return'The chosen schema: "'+e+'" did not exist in branches: '+qn(t)});var t,e},function(t){return t.extract(n.concat(["branch: "+r]),e)});var n,e,o,r})},toString:function(){return"chooseOn("+e+"). Possible values: "+Ct(a)}}}function io(e){return Jn(function(t){return e(t).fold(zo,Lo)})}function uo(e,t){return r=function(t){return e(t).fold(Hn,Vn)},i=t,{extract:function(n,o){var t=Ct(o),e=eo(Jn(r)).extract(n,t);return Uo(e,function(t){var e=B(t,function(t){return Ln(t,t,jn(),i)});return $o(e).extract(n,o)})},toString:function(){return"setOf("+i.toString()+")"}};var r,i}function ao(t,e,n){return Ho((r=e.extract([t],o=n),Go(r,function(t){return{input:o,errors:t}})));var o,r}function co(t){return t.fold(function(t){throw new Error(ur(t))},h)}function so(t,e,n){return co(ao(t,e,n))}function lo(t,e){return ro(t,dt(e,$o))}function fo(e){return io(function(t){return wt(e,t)?Nn.value(t):Nn.error('Unsupported value: "'+t+'", choose one of "'+e.join(", ")+'".')})}function mo(t){return ar(t,t,jn(),Zo())}function go(t,e){return ar(t,t,jn(),e)}function po(t){return go(t,er)}function ho(t,e){return ar(t,t,jn(),fo(e))}function vo(t){return go(t,or)}function bo(t,e){return ar(t,t,jn(),$o(e))}function yo(t,e){return ar(t,t,jn(),Qo(e))}function xo(t,e){return ar(t,t,jn(),eo(e))}function wo(t){return ar(t,t,Xn(),Zo())}function So(t,e){return ar(t,t,Xn(),e)}function ko(t){return So(t,tr)}function Co(t){return So(t,er)}function Oo(t){return So(t,or)}function _o(t,e){return So(t,eo(e))}function To(t,e){return So(t,$o(e))}function Eo(t,e){return ar(t,t,Gn(e),Zo())}function Do(t,e,n){return ar(t,t,Gn(e),n)}function Ao(t,e){return Do(t,e,tr)}function Bo(t,e){return Do(t,e,er)}function Mo(t,e,n){return Do(t,e,fo(n))}function Fo(t,e){return Do(t,e,nr)}function Io(t,e){return Do(t,e,or)}function Ro(t,e,n){return Do(t,e,eo(n))}function No(t,e,n){return Do(t,e,$o(n))}function Po(t){var e=t;return{get:function(){return e},set:function(t){e=t}}}(We=je={})[We.Error=0]="Error",We[We.Value=1]="Value";function Vo(u){if(!c(u))throw new Error("cases must be an array");if(0===u.length)throw new Error("there must be at least one case");var a=[],n={};return St(u,function(t,o){var e=Ct(t);if(1!==e.length)throw new Error("one and only one name per case");var r=e[0],i=t[r];if(void 0!==n[r])throw new Error("duplicate key detected:"+r);if("cata"===r)throw new Error("cannot have a case named cata (sorry)");if(!c(i))throw new Error("case arguments must be an array");a.push(r),n[r]=function(){for(var n=[],t=0;t<arguments.length;t++)n[t]=arguments[t];var e=n.length;if(e!==i.length)throw new Error("Wrong number of arguments to case "+r+". Expected "+i.length+" ("+i+"), got "+e);return{fold:function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];if(t.length!==u.length)throw new Error("Wrong number of arguments to fold. Expected "+u.length+", got "+t.length);return t[o].apply(null,n)},match:function(t){var e=Ct(t);if(a.length!==e.length)throw new Error("Wrong number of arguments to match. Expected: "+a.join(",")+"\nActual: "+e.join(","));if(!L(a,function(t){return wt(e,t)}))throw new Error("Not all branches were specified when using match. Specified: "+e.join(", ")+"\nRequired: "+a.join(", "));return t[r].apply(null,n)},log:function(t){console.log(t,{constructors:a,constructor:r,params:n})}}}}),n}var Ho=function(t){return Pn(t,Nn.error,Nn.value)},Lo=Vn,zo=Hn,Uo=function(t,e){return t.stype===je.Value?e(t.svalue):t},jo=function(t,e){return t.stype===je.Error?e(t.serror):t},Wo=function(t,e){return t.stype===je.Value?{stype:je.Value,svalue:e(t.svalue)}:t},Go=function(t,e){return t.stype===je.Error?{stype:je.Error,serror:e(t.serror)}:t},Xo=Pn,Yo=Un(function(t,e){return x(t)&&x(e)?Yo(t,e):e}),qo=Un(function(t,e){return e}),Ko=function(t){var e,n,o=(e=[],n=[],St(t,function(t){Pn(t,function(t){return n.push(t)},function(t){return e.push(t)})}),{values:e,errors:n});return 0<o.errors.length?r(zo,ft)(o.errors):Lo(o.values)},Jo=Jn(Lo),$o=function(n){return{extract:function(i,u){for(var a={},c=[],t=0,e=n;t<e.length;t++)zn(e[t],function(t,e,n,o){var r=Qn(n,i,u,t,o);Xo(r,function(t){c.push.apply(c,t)},function(t){a[e]=t})},function(t,e){a[t]=e(u)});return 0<c.length?zo(c):Lo(a)},toString:function(){return"obj{\n"+B(n,function(t){return zn(t,function(t,e,n,o){return t+" -> "+o.toString()},function(t,e){return"state("+t+")"})}).join("\n")+"}"}}},Qo=r(eo,$o),Zo=rt(Jo),tr=oo(u,"number"),er=oo(y,"string"),nr=oo(w,"boolean"),or=oo(S,"function"),rr=function(e){if(Object(e)!==e)return!0;switch({}.toString.call(e).slice(8,-1)){case"Boolean":case"Number":case"String":case"Date":case"RegExp":case"Blob":case"FileList":case"ImageData":case"ImageBitmap":case"ArrayBuffer":return!0;case"Array":case"Object":return Object.keys(e).every(function(t){return rr(e[t])});default:return!1}},ir=Jn(function(t){return rr(t)?Lo(t):zo("Expected value to be acceptable for sending via postMessage")}),ur=function(t){return"Errors: \n"+B(10<(e=t.errors).length?e.slice(0,10).concat([{path:[],getErrorInfo:rt("... (only showing first ten failures)")}]):e,function(t){return"Failed path: ("+t.path.join(" > ")+")\n"+t.getErrorInfo()}).join("\n")+"\n\nInput object: "+qn(t.input);var e},ar=Ln,cr=function(t,e){return{tag:"custom",newKey:t,instantiator:e}};function sr(t,e){return(n={})[t]=e,n;var n}function lr(t){return e={},St(t,function(t){e[t.key]=t.value}),e;var e}function fr(t){return S(t)?t:T}function dr(t,e,n){for(var o=t.dom,r=fr(n);o.parentNode;){var o=o.parentNode,i=Mt.fromDom(o),u=e(i);if(u.isSome())return u;if(r(i))break}return vt.none()}function mr(t,e,n){var o=e(t),r=fr(n);return o.orThunk(function(){return r(t)?vt.none():dr(t,e,r)})}function gr(t,e){return zt(t.element,e.event.target)}function pr(t){if(!et(t,"can")&&!et(t,"abort")&&!et(t,"run"))throw new Error("EventHandler defined by: "+JSON.stringify(t,null,2)+" does not have can, abort, or run!");return lt(lt({},ai),t)}function hr(t){return rt("alloy."+t)}function vr(t,e){eu(t,t.element,e,{})}function br(t,e,n){eu(t,t.element,e,n)}function yr(t){vr(t,Ii())}function xr(t,e,n){eu(t,e,n,{})}function wr(t,e,n,o){t.getSystem().triggerEvent(n,e,o.event)}function Sr(t,e){return{key:t,value:pr({abort:e})}}function kr(t){return{key:t,value:pr({run:function(t,e){e.event.prevent()}})}}function Cr(t,e){return{key:t,value:pr({run:e})}}function Or(t,n,o){return{key:t,value:pr({run:function(t,e){n.apply(void 0,[t,e].concat(o))}})}}function _r(t){return function(n){return{key:t,value:pr({run:function(t,e){gr(t,e)&&n(t,e)}})}}}function Tr(t,e,n){var o,r=e.partUids[n];return Cr(o=t,function(t,e){t.getSystem().getByUid(r).each(function(t){wr(t,t.element,o,e)})})}function Er(t,r){return Cr(t,function(e,t){var n=t.event,o=e.getSystem().getByDom(n.target).getOrThunk(function(){return mr(n.target,function(t){return e.getSystem().getByDom(t).toOptional()},T).getOr(e)});r(e,o,t)})}function Dr(t){return Cr(t,function(t,e){e.cut()})}function Ar(t,e){return _r(t)(e)}function Br(t){return t.dom.innerHTML}function Mr(t,e){var n,o,r=jt(t).dom,i=Mt.fromDom(r.createDocumentFragment());Be(i,(n=e,(o=(r||document).createElement("div")).innerHTML=n,Kt(Mt.fromDom(o)))),Me(t),Tn(t,i)}function Fr(t){if(Zt(t))return"#shadow-root";var e=Mt.fromDom(t.dom.cloneNode(!1)),n=Mt.fromTag("div"),o=Mt.fromDom(e.dom.cloneNode(!0));return Tn(n,o),Br(n)}function Ir(t){var e=(new Date).getTime();return t+"_"+Math.floor(1e9*Math.random())+ ++su+String(e)}function Rr(t){var e=Ge(t)?t.dom[mu]:null;return vt.from(e)}function Nr(e){function n(t){return"The component must be in a context to execute: "+t+(e?"\n"+Fr(e().element)+" is not in context.":"")}function t(t){return function(){throw new Error(n(t))}}function o(t){return function(){console.warn(n(t))}}return{debugInfo:rt("fake"),triggerEvent:o("triggerEvent"),triggerFocus:o("triggerFocus"),triggerEscape:o("triggerEscape"),broadcast:o("broadcast"),broadcastOn:o("broadcastOn"),broadcastEvent:o("broadcastEvent"),build:t("build"),addToWorld:t("addToWorld"),removeFromWorld:t("removeFromWorld"),addToGui:t("addToGui"),removeFromGui:t("removeFromGui"),getByUid:t("getByUid"),getByDom:t("getByDom"),isConnected:T}}function Pr(t,e){var n=t.toString(),o=n.indexOf(")")+1,r=n.indexOf("("),i=n.substring(r+1,o-1).split(/,\s*/);return t.toFunctionAnnotation=function(){return{name:e,parameters:bu(i)}},t}function Vr(t){return sr(yu,t)}function Hr(o){return t=function(t){for(var e=[],n=1;n<arguments.length;n++)e[n-1]=arguments[n];return o.apply(void 0,V([t.getApis(),t],e,!1))},n=(e=o.toString()).indexOf(")")+1,r=e.indexOf("("),i=e.substring(r+1,n-1).split(/,\s*/),t.toFunctionAnnotation=function(){return{name:"OVERRIDE",parameters:bu(i.slice(1))}},t;var t,e,n,r,i}function Lr(t,r){var i={};return J(t,function(t,o){J(t,function(t,e){var n=tt(i,e).getOr([]);i[e]=n.concat([r(o,t)])})}),i}function zr(t){return{classes:E(t.classes)?[]:t.classes,attributes:E(t.attributes)?{}:t.attributes,styles:E(t.styles)?{}:t.styles}}function Ur(t){return t.cHandler}function jr(t,e){return{name:t,handler:e}}function Wr(t,e,n){var o=e[n];return o?function(u,t,a){try{var e=G(t,function(t,e){var n=t.name,o=e.name,r=a.indexOf(n),i=a.indexOf(o);if(-1===r)throw new Error("The ordering for "+u+" does not have an entry for "+n+".\nOrder specified: "+JSON.stringify(a,null,2));if(-1===i)throw new Error("The ordering for "+u+" does not have an entry for "+o+".\nOrder specified: "+JSON.stringify(a,null,2));return r<i?-1:i<r?1:0});return Nn.value(e)}catch(t){return Nn.error([t])}}("Event: "+n,t,o).map(function(t){var n,e,o,r,i=B(t,function(t){return t.handler});return{can:function(){for(var n=[],t=0;t<arguments.length;t++)n[t]=arguments[t];return R(e,function(t,e){return t&&e.can.apply(void 0,n)},!0)},abort:(o=e=n=i,r=function(t){return t.abort},function(){for(var n=[],t=0;t<arguments.length;t++)n[t]=arguments[t];return R(o,function(t,e){return t||r(e).apply(void 0,n)},!1)}),run:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];St(n,function(t){t.run.apply(void 0,e)})}}}):Nn.error(["The event ("+n+') has more than one behaviour that listens to it.\nWhen this occurs, you must specify an event ordering for the behaviours in your spec (e.g. [ "listing", "toggling" ]).\nThe behaviours that can trigger it are: '+JSON.stringify(B(t,function(t){return t.name}),null,2)])}function Gr(t,e){var n=ie(t,e);return void 0===n||""===n?[]:n.split(" ")}function Xr(t){return void 0!==t.dom.classList}function Yr(t,e){var n,o,r;Xr(t)?t.dom.classList.add(e):(o=e,r=Gr(n=t,"class").concat([o]),oe(n,"class",r.join(" ")))}function qr(t,e){var n,o,r,i;Xr(t)?t.dom.classList.remove(e):(r=e,0<(i=F(Gr(o=t,"class"),function(t){return t!==r})).length?oe(o,"class",i.join(" ")):ce(o,"class")),0===(Xr(n=t)?n.dom.classList:Gr(n,"class")).length&&ce(n,"class")}function Kr(t,e){return Xr(t)&&t.dom.classList.contains(e)}function Jr(e,t){St(t,function(t){Yr(e,t)})}function $r(e,t){St(t,function(t){qr(e,t)})}function Qr(t){return t.dom.value}function Zr(t,e){if(void 0===e)throw new Error("Value.set was undefined");t.dom.value=e}function ti(t){var n,e,o,r,i=(n=tt(t,"behaviours").getOr({}),H(Ct(n),function(t){var e=n[t];return k(e)?[e.me]:[]}));return e=t,r=B(o=i,function(t){return To(t.name(),[mo("config"),Eo("state",xu)])}),{list:o,data:dt(ao("component.behaviours",$o(r),e.behaviours).fold(function(t){throw new Error(ur(t)+"\nComplete spec:\n"+JSON.stringify(e,null,2))},h),function(t){return rt(t.map(function(t){return{config:t.config,state:t.state.init(t.config)}}))})}}function ei(t,e,n){var o,r,i=lt(lt({},(o=t).dom),{uid:o.uid,domChildren:B(o.components,function(t){return t.element})}),u=t.domModification.fold(function(){return zr({})},zr),a=0<e.length?function(e,t,n,o){var r=lt({},t);function i(t){return I(t,function(t,e){return lt(lt({},e.modification),t)},{})}St(n,function(t){r[t.name()]=t.exhibit(e,o)});var u=Lr(r,function(t,e){return{name:t,modification:e}});return zr({classes:I(u.classes,function(t,e){return e.modification.concat(t)},[]),attributes:i(u.attributes),styles:i(u.styles)})}(n,{"alloy.base.modification":u},e,i):u;return lt(lt({},r=i),{attributes:lt(lt({},r.attributes),a.attributes),styles:lt(lt({},r.styles),a.styles),classes:r.classes.concat(a.classes)})}function ni(t,e,n){var o,r,i,u,a,c={"alloy.base.behaviour":t.events},s=t.eventOrder;return r=n,i=e,o=Lr(lt(lt({},c),(u=r,a={},St(i,function(t){a[t.name()]=t.handlers(u)}),a)),jr),Su(o,s).getOrDie()}function oi(t){var n,e,o,r,i,u,a,c,s,l,f=hu(t),d=f.events,m=A(f,["events"]),g=B(tt(m,"components").getOr([]),Tu),p=lt(lt({},m),{events:lt(lt({},cu),d),components:g});return Nn.value((e=Po(vu),o=co(ao("custom.definition",Cu,n=p)),r=ti(n),i=r.list,u=r.data,a=function(t){var e=Mt.fromTag(t.tag);re(e,t.attributes),Jr(e,t.classes),de(e,t.styles),t.innerHtml.each(function(t){return Mr(e,t)});var n=t.domChildren;return Be(e,n),t.value.each(function(t){Zr(e,t)}),t.uid,gu(e,t.uid),e}(ei(o,i,u)),c=ni(o,i,u),s=Po(o.components),l={uid:n.uid,getSystem:e.get,config:function(t){var e=u;return(S(e[t.name()])?e[t.name()]:function(){throw new Error("Could not find "+t.name()+" in "+JSON.stringify(n,null,2))})()},hasConfigured:function(t){return S(u[t.name()])},spec:n,readState:function(t){return u[t]().map(function(t){return t.state.readState()}).getOr("not enabled")},getApis:function(){return o.apis},connect:function(t){e.set(t)},disconnect:function(){e.set(Nr(h))},element:a,syncComponents:function(){var t=H(Kt(a),function(t){return e.get().getByDom(t).fold(function(){return[]},W)});s.set(t)},components:s.get,events:c}));function h(){return l}}function ri(t){var e=Mt.fromText(t);return Ou({element:e})}Vo([{bothErrors:["error1","error2"]},{firstError:["error1","value2"]},{secondError:["value1","error2"]},{bothValues:["value1","value2"]}]);var ii,ui,ai={can:D,abort:T,run:st},ci=rt,si=ci("touchstart"),li=ci("touchmove"),fi=ci("touchend"),di=ci("touchcancel"),mi=ci("mousedown"),gi=ci("mousemove"),pi=ci("mouseout"),hi=ci("mouseup"),vi=ci("mouseover"),bi=ci("focusin"),yi=ci("focusout"),xi=ci("keydown"),wi=ci("keyup"),Si=ci("input"),ki=ci("change"),Ci=ci("click"),Oi=ci("transitioncancel"),_i=ci("transitionend"),Ti=ci("transitionstart"),Ei=ci("selectstart"),Di={tap:hr("tap")},Ai=hr("focus"),Bi=hr("blur.post"),Mi=hr("paste.post"),Fi=hr("receive"),Ii=hr("execute"),Ri=hr("focus.item"),Ni=Di.tap,Pi=hr("longpress"),Vi=hr("sandbox.close"),Hi=hr("typeahead.cancel"),Li=hr("system.init"),zi=hr("system.touchmove"),Ui=hr("system.touchend"),ji=hr("system.scroll"),Wi=hr("system.resize"),Gi=hr("system.attached"),Xi=hr("system.detached"),Yi=hr("system.dismissRequested"),qi=hr("system.repositionRequested"),Ki=hr("focusmanager.shifted"),Ji=hr("slotcontainer.visibility"),$i=hr("change.tab"),Qi=hr("dismiss.tab"),Zi=hr("highlight"),tu=hr("dehighlight"),eu=function(t,e,n,o){var r=lt({target:e},o);t.getSystem().triggerEvent(n,e,r)},nu=lr,ou=_r(Gi()),ru=_r(Xi()),iu=_r(Li()),uu=(ii=Ii(),function(t){return Cr(ii,t)}),au=nu([{key:Ai(),value:pr({can:function(t,e){var n,o=e.event,r=o.originator,i=o.target;return!(zt(n=r,t.element)&&!zt(n,i)&&(console.warn(Ai()+" did not get interpreted by the desired target. \nOriginator: "+Fr(r)+"\nTarget: "+Fr(i)+"\nCheck the "+Ai()+" event handlers"),1))}})}]),cu=Object.freeze({__proto__:null,events:au}),su=0,lu=rt("alloy-id-"),fu=rt("data-alloy-id"),du=lu(),mu=fu(),gu=function(t,e){Object.defineProperty(t.dom,mu,{value:e,writable:!0})},pu=Ir,hu=h,vu=Nr(),bu=function(t){return B(t,function(t){return At(t,"/*")?t.substring(0,t.length-"/*".length):t})},yu=Ir("alloy-premade"),xu={init:function(){return wu({readState:rt("No State required")})}},wu=function(t){return t},Su=function(t,a){var e,n,o,r,i,u,c=$(t,function(r,u){return(1===r.length?Nn.value(r[0].handler):Wr(r,a,u)).map(function(t){var e,i,n=(i=S(e=t)?{can:D,abort:T,run:e}:e,function(t,e){for(var n=[],o=2;o<arguments.length;o++)n[o-2]=arguments[o];var r=[t,e].concat(n);i.abort.apply(void 0,r)?e.stop():i.can.apply(void 0,r)&&i.run.apply(void 0,r)}),o=1<r.length?F(a[u],function(e){return d(r,function(t){return t.name===e})}).join(" > "):r[0].name;return sr(u,{handler:n,purpose:o})})});return e={},n=[],o=[],St(c,function(t){t.fold(function(t){n.push(t)},function(t){o.push(t)})}),0<(u={errors:n,values:o}).errors.length?Nn.error(ft(u.errors)):(i=e,0===(r=u.values).length?Nn.value(i):Nn.value(Yo(i,qo.apply(void 0,r))))},ku="alloy.base.behaviour",Cu=$o([ar("dom","dom",jn(),$o([mo("tag"),Eo("styles",{}),Eo("classes",[]),Eo("attributes",{}),wo("value"),wo("innerHtml")])),mo("components"),mo("uid"),Eo("events",{}),Eo("apis",{}),ar("eventOrder","eventOrder",((ui={})[Ii()]=["disabling",ku,"toggling","typeaheadevents"],ui[Ai()]=[ku,"focusing","keying"],ui[Li()]=[ku,"disabling","toggling","representing"],ui[Si()]=[ku,"representing","streaming","invalidating"],ui[Xi()]=[ku,"representing","item-events","tooltipping"],ui[mi()]=["focusing",ku,"item-type-events"],ui[si()]=["focusing",ku,"item-type-events"],ui[vi()]=["item-type-events","tooltipping"],ui[Fi()]=["receiving","reflecting","tooltipping"],Yn(rt(ui))),Zo()),wo("domModification")]),Ou=function(t){var e=so("external.component",to([mo("element"),wo("uid")]),t),n=Po(Nr()),o=e.uid.getOrThunk(function(){return pu("external")});gu(e.element,o);var r={uid:o,getSystem:n.get,config:vt.none,hasConfigured:T,connect:function(t){n.set(t)},disconnect:function(){n.set(Nr(function(){return r}))},getApis:function(){return{}},element:e.element,spec:t,readState:rt("No state"),syncComponents:st,components:rt([]),events:{}};return Vr(r)},_u=pu,Tu=function(t){return tt(t,yu).getOrThunk(function(){return oi(Tt(t,"uid")?t:lt({uid:_u("")},t)).getOrDie()})},Eu=Vr;function Du(t,e,n,o,r){return t(n,o)?vt.some(n):S(r)&&r(n)?vt.none():e(n,o,r)}function Au(t,e,n){for(var o=t.dom,r=S(n)?n:T;o.parentNode;){var o=o.parentNode,i=Mt.fromDom(o);if(e(i))return vt.some(i);if(r(i))break}return vt.none()}function Bu(t,e,n){return Du(function(t,e){return e(t)},Au,t,e,n)}function Mu(t,e,n){return Bu(t,e,n).isSome()}function Fu(t,e,n){return Au(t,function(t){return Ht(t,e)},n)}function Iu(t,e){return n=e,Lt(o=void 0===t?document:t.dom)?vt.none():vt.from(o.querySelector(n)).map(Mt.fromDom);var n,o}function Ru(t,e,n){return Du(Ht,Fu,t,e,n)}function Nu(){var e=Ir("aria-owns");return{id:e,link:function(t){oe(t,"aria-owns",e)},unlink:function(t){ce(t,"aria-owns")}}}var Pu,Vu,Hu=function(e,t){return Mu(t,function(t){return zt(t,e.element)},T)||(n=e,Bu(t,function(t){if(!Ge(t))return!1;var e=ie(t,"id");return void 0!==e&&-1<e.indexOf("aria-owns")}).bind(function(t){var e=ie(t,"id");return Iu(gn(t),'[aria-owns="'+e+'"]')}).exists(function(t){return Hu(n,t)}));var n},Lu="unknown";function zu(e,t,n){var o,r,i,u;switch(tt(Uu.get(),e).orThunk(function(){return K(Ct(Uu.get()),function(t){return-1<e.indexOf(t)?vt.some(Uu.get()[t]):vt.none()})}).getOr(Pu.NORMAL)){case Pu.NORMAL:return n(Wu());case Pu.LOGGING:var a=(o=e,r=t,i=[],u=(new Date).getTime(),{logEventCut:function(t,e,n){i.push({outcome:"cut",target:e,purpose:n})},logEventStopped:function(t,e,n){i.push({outcome:"stopped",target:e,purpose:n})},logNoParent:function(t,e,n){i.push({outcome:"no-parent",target:e,purpose:n})},logEventNoHandlers:function(t,e){i.push({outcome:"no-handlers-left",target:e})},logEventResponse:function(t,e,n){i.push({outcome:"response",purpose:n,target:e})},write:function(){var t=(new Date).getTime();wt(["mousemove","mouseover","mouseout",Li()],o)||console.log(o,{event:o,time:t-u,target:r.dom,sequence:B(i,function(t){return wt(["cut","stopped","response"],t.outcome)?"{"+t.purpose+"} "+t.outcome+" at ("+Fr(t.target)+")":t.outcome})})}}),c=n(a);return a.write(),c;case Pu.STOP:return!0}}(Vu=Pu=Pu||{})[Vu.STOP=0]="STOP",Vu[Vu.NORMAL=1]="NORMAL",Vu[Vu.LOGGING=2]="LOGGING";var Uu=Po({}),ju=["alloy/data/Fields","alloy/debugging/Debugging"],Wu=rt({logEventCut:st,logEventStopped:st,logNoParent:st,logEventNoHandlers:st,logEventResponse:st,write:st}),Gu=rt([mo("menu"),mo("selectedMenu")]),Xu=rt([mo("item"),mo("selectedItem")]);function Yu(){return bo("markers",[mo("backgroundMenu")].concat(Gu()).concat(Xu()))}function qu(t){return bo("markers",B(t,mo))}function Ku(t,e,n){return void 0!==(o=new Error).stack&&N(o.stack.split("\n"),function(e){return 0<e.indexOf("alloy")&&!d(ju,function(t){return-1<e.indexOf(t)})}).getOr(Lu),ar(e,e,n,io(function(n){return Nn.value(function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return n.apply(void 0,t)})}));var o}function Ju(t){return Ku(0,t,Gn(st))}function $u(t){return Ku(0,t,Gn(vt.none))}function Qu(t){return Ku(0,t,jn())}function Zu(t){return Ku(0,t,jn())}function ta(t,e){return cr(t,rt(e))}function ea(t){return cr(t,h)}function na(t,e,n,o,r,i,u,a){return{x:t,y:e,bubble:n,direction:o,placement:r,restriction:i,label:u+"-"+r,alwaysFit:a=void 0!==a&&a}}function oa(t,e,n,o){var r=t+e;return o<r?n:r<n?o:r}function ra(n,e){return j(["left","right","top","bottom"],function(t){return tt(e,t).map(function(e){return function(t){switch(e){case 1:return t.x;case 0:return t.x+t.width;case 2:return t.y;case 3:return t.y+t.height}}(n)})})}function ia(t,e){return t.x+t.width/2-e.width/2}function ua(t,e){return t.x+t.width-e.width}function aa(t,e){return t.y-e.height}function ca(t){return t.y+t.height}function sa(t,e){return t.y+t.height/2-e.height/2}function la(t,e,n){return na(t.x+t.width,sa(t,e),n.east(),Ua(),"east",ra(t,{left:0}),Ga)}function fa(t,e,n){return na(t.x-e.width,sa(t,e),n.west(),ja(),"west",ra(t,{right:1}),Ga)}function da(){return[Xa,Ya,qa,Ka,$a,Ja,la,fa]}function ma(){return[Ya,Xa,Ka,qa,$a,Ja,la,fa]}function ga(){return[qa,Ka,Xa,Ya,Ja,$a]}function pa(){return[Ka,qa,Ya,Xa,Ja,$a]}function ha(){return[Xa,Ya,qa,Ka,$a,Ja]}function va(){return[Ya,Xa,Ka,qa,$a,Ja]}function ba(n,o,r){return iu(function(t,e){r(t,n,o)})}function ya(t){return{key:t,value:void 0}}function xa(t){var e,n,o,r,i,u,a,c,s=so("Creating behaviour: "+t.name,nc,t);return e=s.fields,n=s.name,o=s.active,r=s.apis,i=s.extra,u=s.state,a=to(e),c=To(n,[So("config",to(e))]),tc(a,c,n,o,r,i,u)}function wa(t){var e,n=so("Creating behaviour: "+t.name,oc,t),o=lo(n.branchKey,n.branches),r=n.name,i=n.active,u=n.apis,a=n.extra,c=n.state,s=To(r,[So("config",e=o)]);return tc(e,s,r,i,u,a,c)}function Sa(){return Mt.fromDom(document)}function ka(t){return t.dom.focus()}function Ca(t){var e=gn(t).dom;return t.dom===e.activeElement}function Oa(t){return void 0===t&&(t=Sa()),vt.from(t.dom.activeElement).map(Mt.fromDom)}function _a(e){return Oa(gn(e)).filter(function(t){return e.dom.contains(t.dom)})}function Ta(t,n){var o=gn(n),e=Oa(o).bind(function(e){function t(t){return zt(e,t)}var r,i;return t(n)?vt.some(n):(r=t,(i=function(t){for(var e=0;e<t.childNodes.length;e++){var n=Mt.fromDom(t.childNodes[e]);if(r(n))return vt.some(n);var o=i(t.childNodes[e]);if(o.isSome())return o}return vt.none()})(n.dom))}),r=t(n);return e.each(function(e){Oa(o).filter(function(t){return zt(t,e)}).fold(function(){ka(e)},st)}),r}function Ea(t,e,n,o,r){function i(t){return t+"px"}return{position:t,left:e.map(i),top:n.map(i),right:o.map(i),bottom:r.map(i)}}function Da(t,e){var n;me(t,lt(lt({},n=e),{position:vt.some(n.position)}))}function Aa(t,e,n,o,r,i){var u=e.rect,a=u.x-n,c=u.y-o,s=r-(a+u.width),l=i-(c+u.height),f=vt.some(a),d=vt.some(c),m=vt.some(s),g=vt.some(l),p=vt.none();return e.direction.fold(function(){return Ea(t,f,d,p,p)},function(){return Ea(t,p,d,m,p)},function(){return Ea(t,f,p,p,g)},function(){return Ea(t,p,p,m,g)},function(){return Ea(t,f,d,p,p)},function(){return Ea(t,f,p,p,g)},function(){return Ea(t,f,d,p,p)},function(){return Ea(t,p,d,m,p)})}function Ba(t,r){return t.fold(function(){var t=r.rect;return Ea("absolute",vt.some(t.x),vt.some(t.y),vt.none(),vt.none())},function(t,e,n,o){return Aa("absolute",r,t,e,n,o)},function(t,e,n,o){return Aa("fixed",r,t,e,n,o)})}function Ma(t,e){var n=C(Ve,e),o=t.fold(n,n,function(){var t=Ie();return Ve(e).translate(-t.left,-t.top)}),r=Oe(e),i=we(e);return Bn(o.left,o.top,r,i)}rt($o(Xu().concat(Gu())));var Fa=rt($o(Xu())),Ia=rt(bo("initSize",[mo("numColumns"),mo("numRows")])),Ra=Vo([{southeast:[]},{southwest:[]},{northeast:[]},{northwest:[]},{south:[]},{north:[]},{east:[]},{west:[]}]),Na=Ra.southeast,Pa=Ra.southwest,Va=Ra.northeast,Ha=Ra.northwest,La=Ra.south,za=Ra.north,Ua=Ra.east,ja=Ra.west,Wa=function(t,e,n){return Math.min(Math.max(t,e),n)},Ga="layout",Xa=function(t,e,n){return na(t.x,ca(t),n.southeast(),Na(),"southeast",ra(t,{left:1,top:3}),Ga)},Ya=function(t,e,n){return na(ua(t,e),ca(t),n.southwest(),Pa(),"southwest",ra(t,{right:0,top:3}),Ga)},qa=function(t,e,n){return na(t.x,aa(t,e),n.northeast(),Va(),"northeast",ra(t,{left:1,bottom:2}),Ga)},Ka=function(t,e,n){return na(ua(t,e),aa(t,e),n.northwest(),Ha(),"northwest",ra(t,{right:0,bottom:2}),Ga)},Ja=function(t,e,n){return na(ia(t,e),aa(t,e),n.north(),za(),"north",ra(t,{bottom:2}),Ga)},$a=function(t,e,n){return na(ia(t,e),ca(t),n.south(),La(),"south",ra(t,{top:3}),Ga)},Qa=Object.freeze({__proto__:null,events:function(a){return nu([Cr(Fi(),function(r,t){var e,i=a.channels,n=Ct(i),u=t,o=(e=u).universal?n:F(n,function(t){return wt(e.channels,t)});St(o,function(t){var e=i[t],n=e.schema,o=so("channel["+t+"] data\nReceiver: "+Fr(r.element),n,u.data);e.onReceive(r,o)})})])}}),Za=[go("channels",uo(Nn.value,to([Qu("onReceive"),Eo("schema",Zo())])))],tc=function(n,t,f,e,o,r,i){function u(t){return et(t,f)?t[f]():vt.none()}var a=dt(o,function(t,e){return r=f,n=function(n){for(var t=[],e=1;e<arguments.length;e++)t[e-1]=arguments[e];var o=[n].concat(t);return n.config({name:rt(r)}).fold(function(){throw new Error("We could not find any behaviour configuration for: "+r+". Using API: "+u)},function(t){var e=Array.prototype.slice.call(o,1);return i.apply(void 0,[n,t.config,t.state].concat(e))})},o=u=e,a=(i=t).toString(),c=a.indexOf(")")+1,s=a.indexOf("("),l=a.substring(s+1,c-1).split(/,\s*/),n.toFunctionAnnotation=function(){return{name:o,parameters:bu(l.slice(0,1).concat(l.slice(3)))}},n;var r,i,u,n,o,a,c,s,l}),c=dt(r,Pr),s=lt(lt(lt({},c),a),{revoke:C(ya,f),config:function(t){var e=so(f+"-config",n,t);return{key:f,value:{config:e,me:s,configAsRaw:Rt(function(){return so(f+"-config",n,t)}),initialConfig:t,state:i}}},schema:rt(t),exhibit:function(t,n){return Et(u(t),tt(e,"exhibit"),function(t,e){return e(n,t.config,t.state)}).getOrThunk(function(){return zr({})})},name:rt(f),handlers:function(t){return u(t).map(function(t){return tt(e,"events").getOr(function(){return{}})(t.config,t.state)}).getOr({})}});return s},ec=lr,nc=to([mo("fields"),mo("name"),Eo("active",{}),Eo("apis",{}),Eo("state",xu),Eo("extra",{})]),oc=to([mo("branchKey"),mo("branches"),mo("name"),Eo("active",{}),Eo("apis",{}),Eo("state",xu),Eo("extra",{})]),rc=rt(void 0),ic=xa({fields:Za,name:"receiving",active:Qa}),uc=Object.freeze({__proto__:null,exhibit:function(t,e){return zr({classes:[],styles:e.useFixed()?{}:{position:"relative"}})}}),ac=Vo([{none:[]},{relative:["x","y","width","height"]},{fixed:["x","y","width","height"]}]),cc=function(t,e,n){var o=kn(e,n);return t.fold(rt(o),rt(o),function(){var t=Ie();return o.translate(-t.left,-t.top)})};function sc(t){return ue(t,Dc)}function lc(t,e,n,o){var r,i,u,a,c,s,l,f,d,m,g,p,h,v,b,y,x,w,S,k,C,O,_,T,E,D,A,B,M,F,I,R,N,P,V,H,L,z,U,j=t.bubble,W=j.offset,G=(N=o,P=t.restriction,V=W,H=ot("left",N.x),L=ot("top",N.y),z=ot("right",N.right),U=ot("bottom",N.bottom),Bn(H,L,z-H,U-L)),X=t.x+W.left,Y=t.y+W.top,q=Bn(X,Y,e,n),K=(r=G.x,i=G.y,u=G.right,a=G.bottom,c=q.x,s=q.y,l=q.right,f=q.bottom,d=q.width,m=q.height,{originInBounds:r<=c&&c<=u&&i<=s&&s<=a,sizeInBounds:l<=u&&r<=l&&f<=a&&i<=f,visibleW:Math.min(d,r<=c?u-c:l-r),visibleH:Math.min(m,i<=s?a-s:f-i)}),J=K.visibleW,$=K.visibleH,Q=K.originInBounds&&K.sizeInBounds,Z=Q?q:(g=G.x,p=G.y,h=G.right,v=G.bottom,b=q.x,y=q.y,x=q.width,w=q.height,S=Math.max(g,h-x),k=Math.max(p,v-w),C=Wa(b,g,S),O=Wa(y,p,k),_=Math.min(C+x,h)-C,T=Math.min(O+w,v)-O,Bn(C,O,_,T)),tt=0<Z.width&&0<Z.height,et=(E=t.direction,B=rt((D=Z).bottom-(A=o).y),M=rt(A.bottom-D.y),F=E.fold(M,M,B,B,M,B,M,M),I=rt(D.right-A.x),R=rt(A.right-D.x),{maxWidth:E.fold(R,I,R,I,R,R,R,I),maxHeight:F}),nt={rect:Z,maxHeight:et.maxHeight,maxWidth:et.maxWidth,direction:t.direction,placement:t.placement,classes:{on:j.classesOn,off:j.classesOff},layout:t.label,testY:Y};function ot(r,i){return P[r].map(function(t){var e="top"===r||"bottom"===r,n=e?V.top:V.left,o=("left"===r||"top"===r?Math.max:Math.min)(t,i)+n;return e?Wa(o,N.y,N.bottom):Wa(o,N.x,N.right)}).getOr(i)}return Q||t.alwaysFit?Ac.fit(nt):Ac.nofit(nt,J,$,tt)}function fc(t){function e(){return n.get().each(t)}var n=Po(vt.none());return{clear:function(){e(),n.set(vt.none())},isSet:function(){return n.get().isSome()},get:function(){return n.get()},set:function(t){e(),n.set(vt.some(t))}}}function dc(){return fc(function(t){return t.destroy()})}function mc(){return fc(function(t){return t.unbind()})}function gc(){var e=fc(st);return lt(lt({},e),{on:function(t){return e.get().each(t)}})}function pc(t,e,n){return Te(t,e,Bc,n,!1)}function hc(t,e,n){return Te(t,e,Bc,n,!0)}function vc(o,n){function r(t){var e,n=null!==(e=t.raw.pseudoElement)&&void 0!==e?e:"";return zt(t.target,o)&&!at(n)&&wt(Fc,t.raw.propertyName)}function t(t){var e;(g(t)||r(t))&&(a.clear(),c.clear(),!g(e=null==t?void 0:t.raw.type)&&e!==_i()||(clearTimeout(i),ce(o,Ic),$r(o,n.classes)))}function e(){a.set(pc(o,_i(),t)),c.set(pc(o,Oi(),t))}var i,u,a=mc(),c=mc();"ontransitionstart"in o.dom?u=pc(o,Ti(),function(t){r(t)&&(u.unbind(),e())}):e();var s,l,f=(s=o,l=d("transition-delay"),R(d("transition-duration"),function(t,e,n){var o=m(l[n])+m(e);return Math.max(t,o)},0));function d(t){var e=ge(s,t);return F(y(e)?e.split(/\s*,\s*/):[],at)}function m(t){if(y(t)&&/^[\d.]+/.test(t)){var e=parseFloat(t);return At(t,"ms")?e:1e3*e}return 0}requestAnimationFrame(function(){i=setTimeout(t,f+17),oe(o,Ic,i)})}function bc(t,e,n,o,r,i){var u,a,c,s,l,f,d,m,g,p=(u=o,a=r,i.exists(function(t){var e=u.mode;return"all"===e||t[e]!==a[e]}));function h(t){return parseFloat(t).toFixed(3)}p||(g=t,L(o.classes,function(t){return Kr(g,t)}))?(fe(t,"position",n.position),c=Ma(e,t),s=Ba(e,lt(lt({},r),{rect:c})),l=j(Fc,function(t){return s[t]}),m=n,Q(l,function(t,e){var n,o,r,i=m[e].map(h),u=t.map(h);return!Et(n=i,o=u,r=void 0===r?v:r).getOr(n.isNone()&&o.isNone())}).isSome()&&(me(t,l),p&&(Jr(f=t,(d=o).classes),ue(f,Ic).each(function(t){clearTimeout(parseInt(t,10)),ce(f,Ic)}),vc(f,d)),be(t))):$r(t,o.classes)}function yc(t,e,n,o){ve(e,"max-height"),ve(e,"max-width");var r,s,i,l,f,d,m,g,p,u={width:Oe(r=e),height:we(r)};return s=e,i=o.preference,l=t,f=u,d=n,m=o.bounds,g=f.width,p=f.height,R(i,function(t,e){var n=C(a,e);return t.fold(rt(t),n)},Ac.nofit({rect:l,maxHeight:f.height,maxWidth:f.width,direction:Na(),placement:"southeast",classes:{on:[],off:[]},layout:"none",testY:l.y},-1,-1,!1)).fold(h,h);function a(t,r,i,u,a){var c=lc(t(l,f,d,s,m),g,p,m);return c.fold(rt(c),function(t,e,n,o){return(a===o?u<n||i<e:!a&&o)?c:Ac.nofit(r,i,u,a)})}}function xc(t,e){var n=t,o=Math.floor(e);fe(n,"max-height",wn.max(n,o,["margin-top","border-top-width","padding-top","padding-bottom","border-bottom-width","margin-bottom"])+"px")}function wc(t,e,n){return void 0===t[e]?n:t[e]}function Sc(t,e,n,o){function r(t){return tt(n,t).getOr([])}function i(t,e,n){var o=U(Vc,n);return{offset:kn(t,e),classesOn:H(n,r),classesOff:H(o,r)}}var u=t*(o=void 0===o?1:o),a=e*o;return{southeast:function(){return i(-t,e,["top","alignLeft"])},southwest:function(){return i(t,e,["top","alignRight"])},south:function(){return i(-t/2,e,["top","alignCentre"])},northeast:function(){return i(-t,-e,["bottom","alignLeft"])},northwest:function(){return i(t,-e,["bottom","alignRight"])},north:function(){return i(-t/2,-e,["bottom","alignCentre"])},east:function(){return i(t,-e/2,["valignCentre","left"])},west:function(){return i(-t,-e/2,["valignCentre","right"])},insetNortheast:function(){return i(u,a,["top","alignLeft","inset"])},insetNorthwest:function(){return i(-u,a,["top","alignRight","inset"])},insetNorth:function(){return i(-u/2,a,["top","alignCentre","inset"])},insetSoutheast:function(){return i(u,-a,["bottom","alignLeft","inset"])},insetSouthwest:function(){return i(-u,-a,["bottom","alignRight","inset"])},insetSouth:function(){return i(-u/2,-a,["bottom","alignCentre","inset"])},insetEast:function(){return i(-u,-a/2,["valignCentre","right","inset"])},insetWest:function(){return i(u,-a/2,["valignCentre","left","inset"])}}}function kc(){return Sc(0,0,{})}function Cc(e,n){return function(t){return"rtl"===Lc(t)?n:e}}ac.none;var Oc,_c,Tc=ac.relative,Ec=ac.fixed,Dc="data-alloy-placement",Ac=Vo([{fit:["reposition"]},{nofit:["reposition","visibleW","visibleH","isVisible"]}]),Bc=D,Mc=_e,Fc=["top","bottom","right","left"],Ic="data-alloy-transition-timer",Rc=rt(function(t,e){xc(t,e),de(t,{"overflow-x":"hidden","overflow-y":"auto"})}),Nc=rt(function(t,e){xc(t,e)}),Pc=function(t,e,n,o){var r,i,u,a,c=yc(t,e,n,o),s=e,l=c,f=Ba((r=o).origin,l);return r.transition.each(function(t){bc(s,r.origin,f,t,l,r.lastPlacement)}),Da(s,f),a=c.placement,oe(e,Dc,a),$r(i=e,(u=c.classes).off),Jr(i,u.on),(0,o.maxHeightFunction)(e,c.maxHeight),(0,o.maxWidthFunction)(e,c.maxWidth),{layout:c.layout,placement:c.placement}},Vc=["valignCentre","alignLeft","alignRight","alignCentre","top","bottom","left","right","inset"],Hc=h,Lc=function(t){return"rtl"===ge(t,"direction")?"rtl":"ltr"};function zc(t){return Mu(t,function(t){return Ge(t)&&ie(t,"data-alloy-vertical-dir")===Oc.BottomToTop})}function Uc(){return To("layouts",[mo("onLtr"),mo("onRtl"),wo("onBottomLtr"),wo("onBottomRtl")])}function jc(e,t,n,o,r,i,u){var a=u.map(zc).getOr(!1),c=t.layouts.map(function(t){return t.onLtr(e)}),s=t.layouts.map(function(t){return t.onRtl(e)});return Cc(a?t.layouts.bind(function(t){return t.onBottomLtr.map(function(t){return t(e)})}).or(c).getOr(r):c.getOr(n),a?t.layouts.bind(function(t){return t.onBottomRtl.map(function(t){return t(e)})}).or(s).getOr(i):s.getOr(o))(e)}function Wc(t){return t.fold(h,function(t,e,n){return t.translate(-e,-n)})}function Gc(t){return t.fold(h,h)}function Xc(t){return R(t,function(t,e){return t.translate(e.left,e.top)},kn(0,0))}function Yc(t){return Xc(B(t,Gc))}function qc(t,e,n){var o,r,i=Ie(jt(t.element)),u=(o=t,r=Xt(n.root).dom,vt.from(r.frameElement).map(Mt.fromDom).filter(function(t){return zt(jt(t),jt(o.element))}).map(ke).getOr(i));return as(u,i.left,i.top)}function Kc(t,e,n,o){var r=us(kn(t,e));return vt.some({point:r,width:n,height:o})}function Jc(t,a,c,s,l){return t.map(function(t){var e=[a,t.point],n=s.fold(function(){return Yc(e)},function(){return Yc(e)},function(){return Xc(B(e,Wc))}),o={x:n.left,y:n.top,width:t.width,height:t.height},r=(c.showAbove?ga:ha)(),i=(c.showAbove?pa:va)(),u=jc(l,c,r,i,r,i,vt.none());return Hc({anchorBox:o,bubble:c.bubble.getOr(kc()),overrides:c.overrides,layouts:u,placer:vt.none()})})}function $c(t,e,n){var o,r=t.document.createRange(),i=r;return e.fold(function(t){i.setStartBefore(t.dom)},function(t,e){i.setStart(t.dom,e)},function(t){i.setStartAfter(t.dom)}),o=r,n.fold(function(t){o.setEndBefore(t.dom)},function(t,e){o.setEnd(t.dom,e)},function(t){o.setEndAfter(t.dom)}),r}function Qc(t,e,n,o,r){var i=t.document.createRange();return i.setStart(e.dom,n),i.setEnd(o.dom,r),i}function Zc(t){return{left:t.left,top:t.top,right:t.right,bottom:t.bottom,width:t.width,height:t.height}}function ts(t,e,n){return e(Mt.fromDom(n.startContainer),n.startOffset,Mt.fromDom(n.endContainer),n.endOffset)}function es(i,t){return r=i,o=t.match({domRange:function(t){return{ltr:rt(t),rtl:vt.none}},relative:function(t,e){return{ltr:Rt(function(){return $c(r,t,e)}),rtl:Rt(function(){return vt.some($c(r,e,t))})}},exact:function(t,e,n,o){return{ltr:Rt(function(){return Qc(r,t,e,n,o)}),rtl:Rt(function(){return vt.some(Qc(r,n,o,t,e))})}}}),((n=(e=o).ltr()).collapsed?e.rtl().filter(function(t){return!1===t.collapsed}).map(function(t){return gs.rtl(Mt.fromDom(t.endContainer),t.endOffset,Mt.fromDom(t.startContainer),t.startOffset)}).getOrThunk(function(){return ts(0,gs.ltr,n)}):ts(0,gs.ltr,n)).match({ltr:function(t,e,n,o){var r=i.document.createRange();return r.setStart(t.dom,e),r.setEnd(n.dom,o),r},rtl:function(t,e,n,o){var r=i.document.createRange();return r.setStart(n.dom,o),r.setEnd(t.dom,e),r}});var r,e,n,o}(Oc=Oc||{}).TopToBottom="toptobottom",Oc.BottomToTop="bottomtotop";var ns="data-alloy-vertical-dir",os=[mo("hotspot"),wo("bubble"),Eo("overrides",{}),Uc(),ta("placement",function(t,e,n){var o=Ma(n,e.hotspot.element),r=jc(t.element,e,ha(),va(),ga(),pa(),vt.some(e.hotspot.element));return vt.some(Hc({anchorBox:o,bubble:e.bubble.getOr(kc()),overrides:e.overrides,layouts:r,placer:vt.none()}))})],rs=[mo("x"),mo("y"),Eo("height",0),Eo("width",0),Eo("bubble",kc()),Eo("overrides",{}),Uc(),ta("placement",function(t,e,n){var o=cc(n,e.x,e.y),r=Bn(o.left,o.top,e.width,e.height),i=jc(t.element,e,da(),ma(),da(),ma(),vt.none());return vt.some(Hc({anchorBox:r,bubble:e.bubble,overrides:e.overrides,layouts:i,placer:vt.none()}))})],is=Vo([{screen:["point"]},{absolute:["point","scrollLeft","scrollTop"]}]),us=is.screen,as=is.absolute,cs=[mo("node"),mo("root"),wo("bubble"),Uc(),Eo("overrides",{}),Eo("showAbove",!1),ta("placement",function(r,i,u){var a=qc(r,0,i);return i.node.filter(vn).bind(function(t){var e=t.dom.getBoundingClientRect(),n=Kc(e.left,e.top,e.width,e.height),o=i.node.getOr(r.element);return Jc(n,a,i,u,o)})})],ss=function(t,e,n,o){return{start:t,soffset:e,finish:n,foffset:o}},ls=Vo([{before:["element"]},{on:["element","offset"]},{after:["element"]}]),fs=(ls.before,ls.on,ls.after,function(t){return t.fold(h,h,h)}),ds=Vo([{domRange:["rng"]},{relative:["startSitu","finishSitu"]},{exact:["start","soffset","finish","foffset"]}]),ms={domRange:ds.domRange,relative:ds.relative,exact:ds.exact,exactFromRange:function(t){return ds.exact(t.start,t.soffset,t.finish,t.foffset)},getWin:function(t){return Xt(t.match({domRange:function(t){return Mt.fromDom(t.startContainer)},relative:function(t,e){return fs(t)},exact:function(t,e,n,o){return t}}))},range:ss},gs=Vo([{ltr:["start","soffset","finish","foffset"]},{rtl:["start","soffset","finish","foffset"]}]);function ps(t){return ef.getOption(t)}function hs(t){return ps(t).filter(function(t){return 0!==t.trim().length||-1<t.indexOf("\xa0")}).isSome()||wt(nf,Ft(t))}function vs(t,e){return Lt(n=void 0===t?document:t.dom)?[]:B(n.querySelectorAll(e),Mt.fromDom);var n}function bs(t){if(0<t.rangeCount){var e=t.getRangeAt(0),n=t.getRangeAt(t.rangeCount-1);return vt.some(ss(Mt.fromDom(e.startContainer),e.startOffset,Mt.fromDom(n.endContainer),n.endOffset))}return vt.none()}function ys(t){if(null===t.anchorNode||null===t.focusNode)return bs(t);var e,n,o,r,i,u,a,c,s,l,f,d=Mt.fromDom(t.anchorNode),m=Mt.fromDom(t.focusNode);return e=d,n=t.anchorOffset,o=m,r=t.focusOffset,u=n,a=o,c=r,(s=jt(i=e).dom.createRange()).setStart(i.dom,u),s.setEnd(a.dom,c),l=s,f=zt(e,o)&&n===r,l.collapsed&&!f?vt.some(ss(d,t.anchorOffset,m,t.focusOffset)):bs(t)}function xs(t,e){var n,o,r=(n=es(t,e)).getClientRects();return 0<(o=0<r.length?r[0]:n.getBoundingClientRect()).width||0<o.height?vt.some(o).map(Zc):vt.none()}function ws(t,e){return{element:t,offset:e}}function Ss(t,e){return(Xe(t)?ws:function(t,e){var n=Kt(t);if(0===n.length)return ws(t,e);if(e<n.length)return ws(n[e],0);var o=n[n.length-1];return ws(o,(Xe(o)?ef.get(o):Kt(o)).length)})(t,e)}function ks(t,e){return e.getSelection.getOrThunk(function(){return function(){return vt.from(t.getSelection()).filter(function(t){return 0<t.rangeCount}).bind(ys)}})().map(function(t){var e=Ss(t.start,t.soffset),n=Ss(t.finish,t.foffset);return ms.range(e.element,e.offset,n.element,n.offset)})}function Cs(t){return t.x+t.width}function Os(t,e){return t.x-e.width}function _s(t,e){return t.y-e.height+t.height}function Ts(t,e,n){return na(Cs(t),t.y,n.southeast(),Na(),"southeast",ra(t,{left:0,top:2}),rf)}function Es(t,e,n){return na(Os(t,e),t.y,n.southwest(),Pa(),"southwest",ra(t,{right:1,top:2}),rf)}function Ds(t,e,n){return na(Cs(t),_s(t,e),n.northeast(),Va(),"northeast",ra(t,{left:0,bottom:3}),rf)}function As(t,e,n){return na(Os(t,e),_s(t,e),n.northwest(),Ha(),"northwest",ra(t,{right:1,bottom:3}),rf)}function Bs(){return[Ts,Es,Ds,As]}function Ms(){return[Es,Ts,As,Ds]}function Fs(t,e,n,o,r,i,u){var a,c,s,l,f,d,m,g,p,h,v,b,y,x,w={anchorBox:n.anchorBox,origin:e};return a=w,c=r.element,s=n.bubble,l=n.layouts,f=i,d=o,m=n.overrides,g=u,h=wc(m,"maxHeightFunction",Rc()),v=wc(m,"maxWidthFunction",st),b=a.anchorBox,y=a.origin,x={bounds:(p=y,d.fold(function(){return p.fold(Fn,Fn,Bn)},function(n){return p.fold(n,n,function(){var t=n(),e=cc(p,t.x,t.y);return Bn(e.left,e.top,t.width,t.height)})})),origin:y,preference:l,maxHeightFunction:h,maxWidthFunction:v,lastPlacement:f,transition:g},Pc(b,c,s,x)}function Is(t,e){Tn(t.element,e.element)}function Rs(e,t){var n,o=e.components();St((n=e).components(),function(t){return En(t.element)}),Me(n.element),n.syncComponents();var r=U(o,t);St(r,function(t){df(t),e.getSystem().removeFromWorld(t)}),St(t,function(t){t.getSystem().isConnected()?Is(e,t):(e.getSystem().addToWorld(t),Is(e,t),vn(e.element)&&mf(t)),e.syncComponents()})}function Ns(t,e){gf(t,e,Tn)}function Ps(t){df(t),En(t.element),t.getSystem().removeFromWorld(t)}function Vs(e){var t=Yt(e.element).bind(function(t){return e.getSystem().getByDom(t).toOptional()});Ps(e),t.each(function(t){t.syncComponents()})}function Hs(t){var e=t.components();St(e,Ps),Me(t.element),t.syncComponents()}function Ls(t,e){pf(t,e,Tn)}function zs(e){var t=Kt(e.element);St(t,function(t){e.getByDom(t).each(df)}),En(e.element)}function Us(e,t,n,o){n.get().each(function(t){Hs(e)}),Ns(t.getAttachPoint(e),e);var r=e.getSystem().build(o);return Ns(e,r),n.set(r),r}function js(t,e,n,o){var r=Us(t,e,n,o);return e.onOpen(t,r),r}function Ws(e,n,o){o.get().each(function(t){Hs(e),Vs(e),n.onClose(e,t),o.clear()})}function Gs(t,e,n){return n.isOpen()}function Xs(t){var n=so("Dismissal",Sf,t),e={};return e[yf()]={schema:to([mo("target")]),onReceive:function(e,t){bf.isOpen(e)&&(bf.isPartOf(e,t.target)||n.isExtraPart(e,t.target)||n.fireEventInstead.fold(function(){return bf.close(e)},function(t){return vr(e,t.event)}))}},e}function Ys(t){var n=so("Reposition",kf,t),e={};return e[xf()]={onReceive:function(e){bf.isOpen(e)&&n.fireEventInstead.fold(function(){return n.doReposition(e)},function(t){return vr(e,t.event)})}},e}function qs(t,e,n){e.store.manager.onLoad(t,e,n)}function Ks(t,e,n){e.store.manager.onUnload(t,e,n)}function Js(){var t=Po(null);return wu({set:t.set,get:t.get,isNotSet:function(){return null===t.get()},clear:function(){t.set(null)},readState:function(){return{mode:"memory",value:t.get()}}})}function $s(){var i=Po({}),u=Po({});return wu({readState:function(){return{mode:"dataset",dataByValue:i.get(),dataByText:u.get()}},lookup:function(t){return tt(i.get(),t).orThunk(function(){return tt(u.get(),t)})},update:function(t){var e=i.get(),n=u.get(),o={},r={};St(t,function(e){tt(o[e.value]=e,"meta").each(function(t){tt(t,"text").each(function(t){r[t]=e})})}),i.set(lt(lt({},e),o)),u.set(lt(lt({},n),r))},clear:function(){i.set({}),u.set({})}})}function Qs(t,e,n,o){var r=e.store;n.update([o]),r.setValue(t,o),e.onSetValue(t,o)}function Zs(o,t){return No(o,{},B(t,function(t){return e=t.name(),n="Cannot configure "+t.name()+" for "+o,ar(e,e,Xn(),Jn(function(t){return zo("The field: "+e+" is forbidden. "+n)}));var e,n}).concat([cr("dump",h)]))}function tl(t){return t.dump}function el(t,e){return lt(lt({},ec(e)),t.dump)}function nl(t){return Tt(t,"uiType")}function ol(t){return t.fold(vt.some,vt.none,vt.some,vt.some)}function rl(t){function e(t){return t.name}return t.fold(e,e,e,e)}function il(n,o){return function(t){var e=so("Converting part type",o,t);return n(e)}}function ul(t,e,n,o){return Yo(e.defaults(t,n,o),n,{uid:t.partUids[e.name]},e.overrides(t,n,o))}function al(r,t){var e={};return St(t,function(t){ol(t).each(function(n){var o=nd(r,n.pname);e[n.name]=function(t){var e=so("Part: "+n.name+" in "+r,$o(n.schema),t);return lt(lt({},o),{config:t,validated:e})}})}),e}function cl(t,e,n){return{uiType:Pf(),owner:t,name:e,config:n,validated:{}}}function sl(t){return H(t,function(t){return t.fold(vt.none,vt.some,vt.none,vt.none).map(function(t){return bo(t.name,t.schema.concat([ea(td())]))}).toArray()})}function ll(t){return B(t,rl)}function fl(t,e,n){return o=e,r={},i={},St(n,function(t){t.fold(function(o){r[o.pname]=Rf(!0,function(t,e,n){return o.factory.sketch(ul(t,o,e,n))})},function(t){var e=o.parts[t.name];i[t.name]=rt(t.factory.sketch(ul(o,t,e[td()]),e))},function(o){r[o.pname]=Rf(!1,function(t,e,n){return o.factory.sketch(ul(t,o,e,n))})},function(o){r[o.pname]=Nf(!0,function(e,t,n){return B(e[o.name],function(t){return o.factory.sketch(Yo(o.defaults(e,t,n),t,o.overrides(e,t)))})})})}),{internals:rt(r),externals:rt(i)};var o,r,i}function dl(t,e,n){return o=vt.some(t),i=(r=e).components,s=dt(n,function(t,e){return o=t,r=!1,{name:rt(n=e),required:function(){return o.fold(function(t,e){return t},function(t,e){return t})},used:function(){return r},replace:function(){if(r)throw new Error("Trying to use the same placeholder more than once: "+n);return r=!0,o}};var n,o,r}),u=o,a=r,c=s,l=H(i,function(t){return If(u,a,t,c)}),J(s,function(t){if(!1===t.used()&&t.required())throw new Error("Placeholder: "+t.name()+" was not found in components list\nNamespace: "+o.getOr("none")+"\nComponents: "+JSON.stringify(r.components,null,2))}),l;var o,r,i,u,a,c,s,l}function ml(t,e,n){var o=e.partUids[n];return t.getSystem().getByUid(o).toOptional()}function gl(t,e,n){return ml(t,e,n).getOrDie("Could not find part: "+n)}function pl(t,e,n){var o={},r=e.partUids,i=t.getSystem();return St(n,function(t){o[t]=rt(i.getByUid(r[t]))}),o}function hl(t,e){var n=t.getSystem();return dt(e.partUids,function(t,e){return rt(n.getByUid(t))})}function vl(t){return Ct(t.partUids)}function bl(t,e,n){var o={},r=e.partUids,i=t.getSystem();return St(n,function(t){o[t]=rt(i.getByUid(r[t]).getOrDie())}),o}function yl(e,t){return lr(B(ll(t),function(t){return{key:t,value:e+"-"+t}}))}function xl(e){return ar("partUids","partUids",Yn(function(t){return yl(t.uid,e)}),Zo())}function wl(t,e,n,o,r){var i;return so(t+" [SpecSchema]",to((i=r,(0<o.length?[bo("parts",o)]:[]).concat([mo("uid"),Eo("dom",{}),Eo("components",[]),ea("originalSpec"),Eo("debug.sketcher",{})]).concat(i)).concat(e)),n)}function Sl(t,e,n,o,r){var i=rd(r),u=wl(t,e,i,sl(n),[xl(n)]),a=fl(0,u,n);return o(u,dl(t,u,a.internals()),i,a.externals())}function kl(t){var r=so("Sketcher for "+t.name,id,t),e=dt(r.apis,Hr),n=dt(r.extraApis,Pr);return lt(lt({name:r.name,configFields:r.configFields,sketch:function(t){return e=r.name,n=r.configFields,(0,r.factory)(wl(e,n,o=rd(t),[],[]),o);var e,n,o}},e),n)}function Cl(t){var e=so("Sketcher for "+t.name,ud,t),n=al(e.name,e.partFields),o=dt(e.apis,Hr),r=dt(e.extraApis,Pr);return lt(lt({name:e.name,partFields:e.partFields,configFields:e.configFields,sketch:function(t){return Sl(e.name,e.configFields,e.partFields,e.factory,t)},parts:n},o),r)}function Ol(t){return"input"===Ft(t)&&"radio"!==ie(t,"type")||"textarea"===Ft(t)}function _l(t,e,n){(e.disabled()?ld:fd)(t,e)}function Tl(t,e){return!0===e.useNative&&wt(sd,Ft(t.element))}function El(t,e){return Tl(t,e)?ae(t.element,"disabled"):"true"===ie(t.element,"aria-disabled")}function Dl(n,o,t,r){var e=vs(n.element,"."+o.highlightClass);St(e,function(e){d(r,function(t){return t.element===e})||(qr(e,o.highlightClass),n.getSystem().getByDom(e).each(function(t){o.onDehighlight(n,t),vr(t,tu())}))})}function Al(t,e,n,o){Dl(t,e,0,[o]),Yl(0,e,0,o)||(Yr(o.element,e.highlightClass),e.onHighlight(t,o),vr(o,Zi()))}function Bl(n,e,t,o){var r=vs(n.element,"."+e.itemClass);return P(r,function(t){return Kr(t,e.highlightClass)}).bind(function(t){var e=oa(t,o,0,r.length-1);return n.getSystem().getByDom(r[e]).toOptional()})}function Ml(t,e,n){var o=z(t.slice(0,e)),r=z(t.slice(e+1));return N(o.concat(r),n)}function Fl(t,e,n){return N(z(t.slice(0,e)),n)}function Il(t,e,n){var o=t.slice(0,e);return N(t.slice(e+1).concat(o),n)}function Rl(t,e,n){return N(t.slice(e+1),n)}function Nl(n){return function(t){var e=t.raw;return wt(n,e.which)}}function Pl(t){return function(e){return L(t,function(t){return t(e)})}}function Vl(t){return!0===t.raw.shiftKey}function Hl(t){return!0===t.raw.ctrlKey}function Ll(t,e){return{matches:t,classification:e}}function zl(t,e,n){e.exists(function(e){return n.exists(function(t){return zt(t,e)})})||br(t,Ki(),{prevFocus:e,newFocus:n})}function Ul(){function o(t){return _a(t.element)}return{get:o,set:function(t,e){var n=o(t);t.getSystem().triggerFocus(e,t.element),zl(t,n,o(t))}}}function jl(){function r(t){return hd.getHighlighted(t).map(function(t){return t.element})}return{get:r,set:function(e,t){var n=r(e);e.getSystem().getByDom(t).fold(st,function(t){hd.highlight(e,t)});var o=r(e);zl(e,n,o)}}}gs.ltr,gs.rtl;function Wl(t,e,n,o,r,i){var u=i.map(Mn);return lf(t,e,n,o,r,u)}function Gl(t,e,n){var o,r,i,u=e.getAttachPoint(t);fe(t.element,"position",ff.getMode(u)),i=e.cloakVisibilityAttr,pe((o=t).element,r="visibility").fold(function(){ce(o.element,i)},function(t){oe(o.element,i,t)}),fe(o.element,r,"hidden")}function Xl(t,e,n){var o,r,i,u=t.element;d(["top","left","right","bottom"],function(t){return pe(u,t).isSome()})||ve(t.element,"position"),r="visibility",i=e.cloakVisibilityAttr,ue((o=t).element,i).fold(function(){return ve(o.element,r)},function(t){return fe(o.element,r,t)})}function Yl(t,e,n,o){return Kr(o.element,e.highlightClass)}function ql(e,t,n){return Iu(e.element,"."+t.itemClass).bind(function(t){return e.getSystem().getByDom(t).toOptional()})}function Kl(e,t,n){var o=vs(e.element,"."+t.itemClass);return(0<o.length?vt.some(o[o.length-1]):vt.none()).bind(function(t){return e.getSystem().getByDom(t).toOptional()})}function Jl(e,t,n){return nt(B(vs(e.element,"."+t.itemClass),function(t){return e.getSystem().getByDom(t).toOptional()}))}var $l,Ql,Zl,tf,ef=($l=Xe,{get:function(t){if(!$l(t))throw new Error("Can only get text value of a text node");return Ql(t).getOr("")},getOption:Ql=function(t){return $l(t)?vt.from(t.dom.nodeValue):vt.none()},set:function(t,e){if(!$l(t))throw new Error("Can only set raw text value of a text node");t.dom.nodeValue=e}}),nf=["img","br"],of=[wo("getSelection"),mo("root"),wo("bubble"),Uc(),Eo("overrides",{}),Eo("showAbove",!1),ta("placement",function(t,e,n){var r=Xt(e.root).dom,o=qc(t,0,e);return Jc(ks(r,e).bind(function(n){return t=r,e=ms.exactFromRange(n),(0<(o=es(t,e).getBoundingClientRect()).width||0<o.height?vt.some(o).map(Zc):vt.none()).orThunk(function(){var t=Mt.fromText("\ufeff");Ee(n.start,t);var e=xs(r,ms.exact(t,0,t,1));return En(t),e}).bind(function(t){return Kc(t.left,t.top,t.width,t.height)});var t,e,o}),o,e,n,ks(r,e).bind(function(t){return Ge(t.start)?vt.some(t.start):fn(t.start)}).getOr(t.element))})],rf="link-layout",uf=lo("type",{selection:of,node:cs,hotspot:os,submenu:[mo("item"),Uc(),Eo("overrides",{}),ta("placement",function(t,e,n){var o=Ma(n,e.item.element),r=jc(t.element,e,Bs(),Ms(),Bs(),Ms(),vt.none());return vt.some(Hc({anchorBox:o,bubble:kc(),overrides:e.overrides,layouts:r,placer:vt.none()}))})],makeshift:rs}),af=[xo("classes",er),Mo("mode","all",["all","layout","placement"])],cf=[Eo("useFixed",T),wo("getBounds")],sf=[go("anchor",uf),To("transition",af)],lf=function(c,s,l,f,t,d){var m=so("placement.info",$o(sf),t),g=m.anchor,p=f.element,h=l.get(f.uid);Ta(function(){fe(p,"position","fixed");var t=pe(p,"visibility");fe(p,"visibility","hidden");var e,n,o,r,i=s.useFixed()?(r=document.documentElement,Ec(0,0,r.clientWidth,r.clientHeight)):(n=ke((e=c).element),o=e.element.dom.getBoundingClientRect(),Tc(n.left,n.top,o.width,o.height)),u=g.placement,a=d.map(rt).or(s.getBounds);u(c,g,i).each(function(t){var e=t.placer.getOr(Fs)(c,i,t,a,f,h,m.transition);l.set(f.uid,e)}),t.fold(function(){ve(p,"visibility")},function(t){fe(p,"visibility",t)}),pe(p,"left").isNone()&&pe(p,"top").isNone()&&pe(p,"right").isNone()&&pe(p,"bottom").isNone()&&mt(pe(p,"position"),"fixed")&&ve(p,"position")},p)},ff=xa({fields:cf,name:"positioning",active:uc,apis:Object.freeze({__proto__:null,position:function(t,e,n,o,r){Wl(t,e,n,o,r,vt.none())},positionWithin:Wl,positionWithinBounds:lf,getMode:function(t,e,n){return e.useFixed()?"fixed":"absolute"},reset:function(t,e,n,o){var r=o.element;St(["position","left","right","top","bottom"],function(t){return ve(r,t)}),ce(r,Dc),n.clear(o.uid)}}),state:Object.freeze({__proto__:null,init:function(){var n={};return wu({readState:function(){return n},clear:function(t){k(t)?delete n[t]:n={}},set:function(t,e){n[t]=e},get:function(t){return tt(n,t)}})}})}),df=function(t){vr(t,Xi());var e=t.components();St(e,df)},mf=function(t){var e=t.components();St(e,mf),vr(t,Gi())},gf=function(t,e,n){t.getSystem().addToWorld(e),n(t.element,e.element),vn(t.element)&&mf(e),t.syncComponents()},pf=function(t,e,n){n(t,e.element);var o=Kt(e.element);St(o,function(t){e.getByDom(t).each(mf)})},hf=Object.freeze({__proto__:null,cloak:Gl,decloak:Xl,open:js,openWhileCloaked:function(t,e,n,o,r){Gl(t,e),js(t,e,n,o),r(),Xl(t,e)},close:Ws,isOpen:Gs,isPartOf:function(e,n,t,o){return Gs(0,0,t)&&t.get().exists(function(t){return n.isPartOf(e,t,o)})},getState:function(t,e,n){return n.get()},setContent:function(t,e,n,o){return n.get().map(function(){return Us(t,e,n,o)})}}),vf=Object.freeze({__proto__:null,events:function(n,o){return nu([Cr(Vi(),function(t,e){Ws(t,n,o)})])}}),bf=xa({fields:[Ju("onOpen"),Ju("onClose"),mo("isPartOf"),mo("getAttachPoint"),Eo("cloakVisibilityAttr","data-precloak-visibility")],name:"sandboxing",active:vf,apis:hf,state:Object.freeze({__proto__:null,init:function(){var t=gc(),e=rt("not-implemented");return wu({readState:e,isOpen:t.isSet,clear:t.clear,set:t.set,get:t.get})}})}),yf=rt("dismiss.popups"),xf=rt("reposition.popups"),wf=rt("mouse.released"),Sf=to([Eo("isExtraPart",T),To("fireEventInstead",[Eo("event",Yi())])]),kf=to([To("fireEventInstead",[Eo("event",qi())]),vo("doReposition")]),Cf=Object.freeze({__proto__:null,onLoad:qs,onUnload:Ks,setValue:function(t,e,n,o){e.store.manager.setValue(t,e,n,o)},getValue:function(t,e,n){return e.store.manager.getValue(t,e,n)},getState:function(t,e,n){return n}}),Of=Object.freeze({__proto__:null,events:function(n,o){var t=n.resetOnDom?[ou(function(t,e){qs(t,n,o)}),ru(function(t,e){Ks(t,n,o)})]:[ba(n,o,qs)];return nu(t)}}),_f=Object.freeze({__proto__:null,memory:Js,dataset:$s,manual:function(){return wu({readState:st})},init:function(t){return t.store.manager.state(t)}}),Tf=[wo("initialValue"),mo("getFallbackEntry"),mo("getDataKey"),mo("setValue"),ta("manager",{setValue:Qs,getValue:function(t,e,n){var o=e.store,r=o.getDataKey(t);return n.lookup(r).getOrThunk(function(){return o.getFallbackEntry(r)})},onLoad:function(e,n,o){n.store.initialValue.each(function(t){Qs(e,n,o,t)})},onUnload:function(t,e,n){n.clear()},state:$s})],Ef=[mo("getValue"),Eo("setValue",st),wo("initialValue"),ta("manager",{setValue:function(t,e,n,o){e.store.setValue(t,o),e.onSetValue(t,o)},getValue:function(t,e,n){return e.store.getValue(t)},onLoad:function(e,n,t){n.store.initialValue.each(function(t){n.store.setValue(e,t)})},onUnload:st,state:xu.init})],Df=xa({fields:[Do("store",{mode:"memory"},lo("mode",{memory:[wo("initialValue"),ta("manager",{setValue:function(t,e,n,o){n.set(o),e.onSetValue(t,o)},getValue:function(t,e,n){return n.get()},onLoad:function(t,e,n){e.store.initialValue.each(function(t){n.isNotSet()&&n.set(t)})},onUnload:function(t,e,n){n.clear()},state:Js})],manual:Ef,dataset:Tf})),Ju("onSetValue"),Eo("resetOnDom",!1)],name:"representing",active:Of,apis:Cf,extra:{setValueFrom:function(t,e){var n=Df.getValue(e);Df.setValue(t,n)}},state:_f}),Af=Zs,Bf=el,Mf="placeholder",Ff=Vo([{single:["required","valueThunk"]},{multiple:["required","valueThunks"]}]),If=function(r,i,u,a){return t=r,n=a,(nl(e=u)&&e.uiType===Mf?(c=e,s=n,(o=t).exists(function(t){return t!==c.owner})?Ff.single(!0,rt(c)):tt(s,c.name).fold(function(){throw new Error("Unknown placeholder component: "+c.name+"\nKnown: ["+Ct(s)+"]\nNamespace: "+o.getOr("none")+"\nSpec: "+JSON.stringify(c,null,2))},function(t){return t.replace()})):Ff.single(!1,rt(e))).fold(function(t,e){var n=nl(u)?e(i,u.config,u.validated):e(i),o=H(tt(n,"components").getOr([]),function(t){return If(r,i,t,a)});return[lt(lt({},n),{components:o})]},function(t,e){if(nl(u)){var n=e(i,u.config,u.validated);return u.validated.preprocess.getOr(h)(n)}return e(i)});var t,e,n,o,c,s},Rf=Ff.single,Nf=Ff.multiple,Pf=rt(Mf),Vf=Vo([{required:["data"]},{external:["data"]},{optional:["data"]},{group:["data"]}]),Hf=Eo("factory",{sketch:h}),Lf=Eo("schema",[]),zf=mo("name"),Uf=ar("pname","pname",Wn(function(t){return"<alloy."+Ir(t.name)+">"}),Zo()),jf=cr("schema",function(){return[wo("preprocess")]}),Wf=Eo("defaults",rt({})),Gf=Eo("overrides",rt({})),Xf=$o([Hf,Lf,zf,Uf,Wf,Gf]),Yf=$o([Hf,Lf,zf,Wf,Gf]),qf=$o([Hf,Lf,zf,Uf,Wf,Gf]),Kf=$o([Hf,jf,zf,mo("unit"),Uf,Wf,Gf]),Jf=il(Vf.required,Xf),$f=il(Vf.external,Yf),Qf=il(Vf.optional,qf),Zf=il(Vf.group,Kf),td=rt("entirety"),ed=Object.freeze({__proto__:null,required:Jf,external:$f,optional:Qf,group:Zf,asNamedPart:ol,name:rl,asCommon:function(t){return t.fold(h,h,h,h)},original:td}),nd=function(t,e){return{uiType:Pf(),owner:t,name:e}},od=Object.freeze({__proto__:null,generate:al,generateOne:cl,schemas:sl,names:ll,substitutes:fl,components:dl,defaultUids:yl,defaultUidsSchema:xl,getAllParts:hl,getAllPartNames:vl,getPart:ml,getPartOrDie:gl,getParts:pl,getPartsOrDie:bl}),rd=function(t){return Tt(t,"uid")?t:lt(lt({},t),{uid:pu("uid")})},id=to([mo("name"),mo("factory"),mo("configFields"),Eo("apis",{}),Eo("extraApis",{})]),ud=to([mo("name"),mo("factory"),mo("configFields"),mo("partFields"),Eo("apis",{}),Eo("extraApis",{})]),ad=Object.freeze({__proto__:null,getCurrent:function(t,e,n){return e.find(t)}}),cd=xa({fields:[mo("find")],name:"composing",apis:ad}),sd=["input","button","textarea","select"],ld=function(e,t,n){t.disableClass.each(function(t){Yr(e.element,t)}),(Tl(e,t)?function(t){oe(t.element,"disabled","disabled")}:function(t){oe(t.element,"aria-disabled","true")})(e),t.onDisabled(e)},fd=function(e,t,n){t.disableClass.each(function(t){qr(e.element,t)}),(Tl(e,t)?function(t){ce(t.element,"disabled")}:function(t){oe(t.element,"aria-disabled","false")})(e),t.onEnabled(e)},dd=Object.freeze({__proto__:null,enable:fd,disable:ld,isDisabled:El,onLoad:_l,set:function(t,e,n,o){(o?ld:fd)(t,e)}}),md=Object.freeze({__proto__:null,exhibit:function(t,e){return zr({classes:e.disabled()?e.disableClass.toArray():[]})},events:function(n,t){return nu([Sr(Ii(),function(t,e){return El(t,n)}),ba(n,t,_l)])}}),gd=xa({fields:[Io("disabled",T),Eo("useNative",!0),wo("disableClass"),Ju("onDisabled"),Ju("onEnabled")],name:"disabling",active:md,apis:dd}),pd=Object.freeze({__proto__:null,dehighlightAll:function(t,e,n){return Dl(t,e,0,[])},dehighlight:function(t,e,n,o){Yl(0,e,0,o)&&(qr(o.element,e.highlightClass),e.onDehighlight(t,o),vr(o,tu()))},highlight:Al,highlightFirst:function(e,n,t){ql(e,n).each(function(t){Al(e,n,0,t)})},highlightLast:function(e,n,t){Kl(e,n).each(function(t){Al(e,n,0,t)})},highlightAt:function(e,n,t,o){var r,i,u;i=o,u=vs((r=e).element,"."+n.itemClass),vt.from(u[i]).fold(function(){return Nn.error(new Error("No element found with index "+i))},r.getSystem().getByDom).fold(function(t){throw t},function(t){Al(e,n,0,t)})},highlightBy:function(e,n,t,o){N(Jl(e,n),o).each(function(t){Al(e,n,0,t)})},isHighlighted:Yl,getHighlighted:function(e,t,n){return Iu(e.element,"."+t.highlightClass).bind(function(t){return e.getSystem().getByDom(t).toOptional()})},getFirst:ql,getLast:Kl,getPrevious:function(t,e,n){return Bl(t,e,0,-1)},getNext:function(t,e,n){return Bl(t,e,0,1)},getCandidates:Jl}),hd=xa({fields:[mo("highlightClass"),mo("itemClass"),Ju("onHighlight"),Ju("onDehighlight")],name:"highlighting",apis:pd}),vd=[8],bd=[9],yd=[13],xd=[27],wd=[32],Sd=[37],kd=[38],Cd=[39],Od=[40],_d=O(Vl);function Td(t,e,n,o,a){function c(e,n,t,o,r){var i=t(e,n,o,r),u=n.event;return N(i,function(t){return t.matches(u)}).map(function(t){return t.classification}).bind(function(t){return t(e,n,o,r)})}var r={schema:function(){return t.concat([Eo("focusManager",Ul()),Do("focusInside","onFocus",io(function(t){return wt(["onFocus","onEnterOrSpace","onApi"],t)?Nn.value(t):Nn.error("Invalid value for focusInside")})),ta("handler",r),ta("state",e),ta("sendFocusIn",a)])},processKey:c,toEvents:function(i,u){var t=i.focusInside!==Zl.OnFocusMode?vt.none():a(i).map(function(n){return Cr(Ai(),function(t,e){n(t,i,u),e.stop()})}),e=[Cr(xi(),function(o,r){c(o,r,n,i,u).fold(function(){var e=o,n=r,t=Nl(wd.concat(yd))(n.event);i.focusInside===Zl.OnEnterOrSpaceMode&&t&&gr(e,n)&&a(i).each(function(t){t(e,i,u),n.stop()})},function(t){r.stop()})}),Cr(wi(),function(t,e){c(t,e,o,i,u).each(function(t){e.stop()})})];return nu(t.toArray().concat(e))}};return r}function Ed(t){function a(t,e){return 0<xe(t.visibilitySelector.bind(function(t){return Ru(e,t)}).getOr(e))}function e(e,n,t){var o=n,r=F(vs(e.element,o.selector),function(t){return a(o,t)});vt.from(r[o.firstTabstop]).each(function(t){n.focusManager.set(e,t)})}function o(n,t,r,i){var e,u=vs(n.element,r.selector);return(e=r).focusManager.get(n).bind(function(t){return Ru(t,e.selector)}).bind(function(t){return P(u,C(zt,t)).bind(function(t){return e=n,o=r,i(u,t,function(t){return a(e=o,n=t)&&e.useTabstopAt(n);var e,n}).fold(function(){return o.cyclic?vt.some(!0):vt.none()},function(t){return o.focusManager.set(e,t),vt.some(!0)});var e,o})})}var n=[wo("onEscape"),wo("onEnter"),Eo("selector",'[data-alloy-tabstop="true"]:not(:disabled)'),Eo("firstTabstop",0),Eo("useTabstopAt",D),wo("visibilitySelector")].concat([t]),r=rt([Ll(Pl([Vl,Nl(bd)]),function(t,e,n){return o(t,0,n,n.cyclic?Ml:Fl)}),Ll(Nl(bd),function(t,e,n){return o(t,0,n,n.cyclic?Il:Rl)}),Ll(Nl(xd),function(e,n,t){return t.onEscape.bind(function(t){return t(e,n)})}),Ll(Pl([_d,Nl(yd)]),function(e,n,t){return t.onEnter.bind(function(t){return t(e,n)})})]),i=rt([]);return Td(n,xu.init,r,i,function(){return vt.some(e)})}function Dd(t,e,n){return Ol(n)&&Nl(wd)(e.event)?vt.none():(xr(t,n,Ii()),vt.some(!0))}function Ad(t,e){return vt.some(!0)}function Bd(t,e,n){return n.execute(t,e,t.element)}function Md(){var n=gc();return wu({readState:function(){return n.get().map(function(t){return{numRows:String(t.numRows),numColumns:String(t.numColumns)}}).getOr({numRows:"?",numColumns:"?"})},setGridSize:function(t,e){n.set({numRows:t,numColumns:e})},getNumRows:function(){return n.get().map(function(t){return t.numRows})},getNumColumns:function(){return n.get().map(function(t){return t.numColumns})}})}function Fd(i){return function(t,e,n,o){var r=i(t.element);return tg(r,t,e,n,o)}}function Id(t,e){return Fd(Cc(t,e))}function Rd(t,e){return Fd(Cc(e,t))}function Nd(r){return function(t,e,n,o){return tg(r,t,e,n,o)}}function Pd(t){return!((e=t.dom).offsetWidth<=0&&e.offsetHeight<=0);var e}function Vd(t,e,n){var o,r=F(vs(t,n),Pd);return P(o=r,function(t){return zt(t,e)}).map(function(t){return{index:t,candidates:o}})}function Hd(t,e){return P(t,function(t){return zt(e,t)})}function Ld(n,t,o,e){return e(Math.floor(t/o),t%o).bind(function(t){var e=t.row*o+t.column;return 0<=e&&e<n.length?vt.some(n[e]):vt.none()})}function zd(r,t,i,u,a){return Ld(r,t,u,function(t,e){var n=t===i-1?r.length-t*u:u,o=oa(e,a,0,n-1);return vt.some({row:t,column:o})})}function Ud(i,t,u,a,c){return Ld(i,t,a,function(t,e){var n=oa(t,c,0,u-1),o=n===u-1?i.length-n*a:a,r=Wa(e,0,o-1);return vt.some({row:n,column:r})})}function jd(e,n,t){Iu(e.element,n.selector).each(function(t){n.focusManager.set(e,t)})}function Wd(r){return function(t,e,n,o){return Vd(t,e,n.selector).bind(function(t){return r(t.candidates,t.index,o.getNumRows().getOr(n.initSize.numRows),o.getNumColumns().getOr(n.initSize.numColumns))})}}function Gd(t,e,n){return n.captureTab?vt.some(!0):vt.none()}function Xd(t,e,n,i){var u=function(t,e,n){var o,r=oa(e,i,0,n.length-1);return r===t?vt.none():"button"===Ft(o=n[r])&&"disabled"===ie(o,"disabled")?u(t,r,n):vt.from(n[r])};return Vd(t,n,e).bind(function(t){var e=t.index,n=t.candidates;return u(e,e,n)})}function Yd(e,n,o){return(r=o).focusManager.get(e).bind(function(t){return Ru(t,r.selector)}).bind(function(t){return o.execute(e,n,t)});var r}function qd(e,n,t){n.getInitial(e).orThunk(function(){return Iu(e.element,n.selector)}).each(function(t){n.focusManager.set(e,t)})}function Kd(t,e,n){return Xd(t,n.selector,e,-1)}function Jd(t,e,n){return Xd(t,n.selector,e,1)}function $d(r){return function(t,e,n,o){return r(t,e,n,o).bind(function(){return n.executeOnMove?Yd(t,e,n):vt.some(!0)})}}function Qd(t,e,n){return n.onEscape(t,e)}function Zd(t,e,n){return vt.from(t[e]).bind(function(t){return vt.from(t[n]).map(function(t){return{rowIndex:e,columnIndex:n,cell:t}})})}function tm(t,e,n,o){return Zd(t,e,oa(n,o,0,t[e].length-1))}function em(t,e,n,o){var r=oa(n,o,0,t.length-1),i=t[r].length;return Zd(t,r,Wa(e,0,i-1))}function nm(t,e,n,o){var r=t[e].length;return Zd(t,e,Wa(n+o,0,r-1))}function om(t,e,n,o){var r=Wa(n+o,0,t.length-1),i=t[r].length;return Zd(t,r,Wa(e,0,i-1))}function rm(e,n,t){n.previousSelector(e).orThunk(function(){var t=n.selectors;return Iu(e.element,t.cell)}).each(function(t){n.focusManager.set(e,t)})}function im(t,o){return function(e,n,i){var u=i.cycles?t:o;return Ru(n,i.selectors.row).bind(function(t){return Hd(vs(t,i.selectors.cell),n).bind(function(o){var r=vs(e,i.selectors.row);return Hd(r,t).bind(function(t){var e,n=(e=i,B(r,function(t){return vs(t,e.selectors.cell)}));return u(n,t,o).map(function(t){return t.cell})})})})}}function um(e,n,o){return o.focusManager.get(e).bind(function(t){return o.execute(e,n,t)})}function am(e,n,t){Iu(e.element,n.selector).each(function(t){n.focusManager.set(e,t)})}function cm(t,e,n){return Xd(t,n.selector,e,-1)}function sm(t,e,n){return Xd(t,n.selector,e,1)}function lm(t,e,n,o){var r=t.getSystem().build(o);gf(t,r,n)}function fm(t,e,n,o){N(Ig(t),function(t){return zt(o.element,t.element)}).each(Vs)}function dm(e,t,n,r,o){var i=Ig(e);return vt.from(i[r]).map(function(t){return fm(e,0,0,t),o.each(function(t){lm(e,0,function(t,e){var n,o=e;Jt(n=t,r).fold(function(){Tn(n,o)},function(t){Ee(t,o)})},t)}),t})}function mm(t,e){var n,o;return{key:t,value:{config:{},me:(n=t,o=nu(e),xa({fields:[mo("enabled")],name:n,active:{events:rt(o)}})),configAsRaw:rt({}),initialConfig:{},state:xu}}}function gm(t,e){e.ignore||(ka(t.element),e.onFocus(t))}function pm(t,e,n){var o=e.aria;o.update(t,o,n.get())}function hm(e,t,n){t.toggleClass.each(function(t){(n.get()?Yr:qr)(e.element,t)})}function vm(t,e,n){Ym(t,e,n,!n.get())}function bm(t,e,n){n.set(!0),hm(t,e,n),pm(t,e,n)}function ym(t,e,n){n.set(!1),hm(t,e,n),pm(t,e,n)}function xm(t,e,n){Ym(t,e,n,e.selected)}function wm(){function t(t,e){e.stop(),yr(t)}return[Cr(Ci(),t),Cr(Ni(),t),Dr(si()),Dr(mi())]}function Sm(t){return nu(ft([t.map(function(n){return uu(function(t,e){n(t),e.stop()})}).toArray(),wm()]))}function km(t){(_a(t.element).isNone()||Vg.isFocused(t))&&(Vg.isFocused(t)||Vg.focus(t),br(t,Ug,{item:t}))}function Cm(t){br(t,jg,{item:t})}function Om(t,e){return t.x+t.width/2-e.width/2}function _m(t,e){return t.x+t.width-e.width}function Tm(t,e){return t.y+t.height-e.height}function Em(t,e){return t.y+t.height/2-e.height/2}function Dm(t,e,n){return na(_m(t,e),Tm(t,e),n.insetSouthwest(),Ha(),"southwest",ra(t,{right:0,bottom:3}),ap)}function Am(t,e,n){return na(t.x,Tm(t,e),n.insetSoutheast(),Va(),"southeast",ra(t,{left:1,bottom:3}),ap)}function Bm(t,e,n){return na(_m(t,e),t.y,n.insetNorthwest(),Pa(),"northwest",ra(t,{right:0,top:2}),ap)}function Mm(t,e,n){return na(t.x,t.y,n.insetNortheast(),Na(),"northeast",ra(t,{left:1,top:2}),ap)}function Fm(t,e,n){return na(_m(t,e),Em(t,e),n.insetEast(),ja(),"east",ra(t,{right:0}),ap)}function Im(t,e,n){return na(t.x,Em(t,e),n.insetWest(),Ua(),"west",ra(t,{left:1}),ap)}function Rm(t){switch(t){case"north":return cp;case"northeast":return Mm;case"northwest":return Bm;case"south":return sp;case"southeast":return Am;case"southwest":return Dm;case"east":return Fm;case"west":return Im}}function Nm(t,e,n,o,r){return sc(o).map(Rm).getOr(cp)(t,e,n,o,r)}function Pm(t){switch(t){case"north":return sp;case"northeast":return Am;case"northwest":return Dm;case"south":return cp;case"southeast":return Mm;case"southwest":return Bm;case"east":return Im;case"west":return Fm}}function Vm(t,e,n,o,r){return sc(o).map(Pm).getOr(cp)(t,e,n,o,r)}function Hm(t){var e=void 0!==t.uid&&et(t,"uid")?t.uid:pu("memento");return{get:function(t){return t.getSystem().getByUid(e).getOrDie()},getOpt:function(t){return t.getSystem().getByUid(e).toOptional()},asSpec:function(){return lt(lt({},t),{uid:e})}}}function Lm(t){return function(){return tt(t,gp).getOr("!not found!")}}function zm(t,e){var n,o=t.toLowerCase();if(dp.isRtl()){var r=At(n=o,"-rtl")?n:n+"-rtl";return Tt(e,r)?r:o}return o}function Um(t,e){return tt(e,zm(t,e))}function jm(t,e){var n=e();return Um(t,n).getOrThunk(Lm(n))}function Wm(){return mm("add-focusable",[ou(function(t){var e,n,o;e=t.element,n="svg",o=function(t){return Ht(t,n)},N(e.dom.childNodes,function(t){return o(Mt.fromDom(t))}).map(Mt.fromDom).each(function(t){return oe(t,"focusable","false")})})])}function Gm(t,e,n,o){var r,i,u,a=(u=e,dp.isRtl()&&Tt(mp,u)?["tox-icon--flip"]:[]),c=tt(n,zm(e,n)).or(o).getOrThunk(Lm(n));return{dom:{tag:t.tag,attributes:null!==(r=t.attributes)&&void 0!==r?r:{},classes:t.classes.concat(a),innerHtml:c},behaviours:ec(V(V([],null!==(i=t.behaviours)&&void 0!==i?i:[],!0),[Wm()],!1))}}function Xm(t,e,n,o){return void 0===o&&(o=vt.none()),Gm(e,t,n(),o)}(tf=Zl=Zl||{}).OnFocusMode="onFocus",tf.OnEnterOrSpaceMode="onEnterOrSpace",tf.OnApiMode="onApi";function Ym(t,e,n,o){(o?bm:ym)(t,e,n)}function qm(t,e,n){oe(t.element,"aria-expanded",n)}function Km(t){return"prepared"===t.type?vt.some(t.menu):vt.none()}var Jm=Ed(cr("cyclic",T)),$m=Ed(cr("cyclic",D)),Qm=Td([Eo("execute",Dd),Eo("useSpace",!1),Eo("useEnter",!0),Eo("useControlEnter",!1),Eo("useDown",!1)],xu.init,function(t,e,n,o){var r=n.useSpace&&!Ol(t.element)?wd:[],i=n.useEnter?yd:[],u=n.useDown?Od:[];return[Ll(Nl(r.concat(i).concat(u)),Bd)].concat(n.useControlEnter?[Ll(Pl([Hl,Nl(yd)]),Bd)]:[])},function(t,e,n,o){return n.useSpace&&!Ol(t.element)?[Ll(Nl(wd),Ad)]:[]},function(){return vt.none()}),Zm=Object.freeze({__proto__:null,flatgrid:Md,init:function(t){return t.state(t)}}),tg=function(e,n,t,o,r){return o.focusManager.get(n).bind(function(t){return e(n.element,t,o,r)}).map(function(t){return o.focusManager.set(n,t),!0})},eg=Nd,ng=Nd,og=Nd,rg=Wd(function(t,e,n,o){return zd(t,e,n,o,-1)}),ig=Wd(function(t,e,n,o){return zd(t,e,n,o,1)}),ug=Wd(function(t,e,n,o){return Ud(t,e,n,o,-1)}),ag=Wd(function(t,e,n,o){return Ud(t,e,n,o,1)}),cg=Td([mo("selector"),Eo("execute",Dd),$u("onEscape"),Eo("captureTab",!1),Ia()],Md,rt([Ll(Nl(Sd),Id(rg,ig)),Ll(Nl(Cd),Rd(rg,ig)),Ll(Nl(kd),eg(ug)),Ll(Nl(Od),ng(ag)),Ll(Pl([Vl,Nl(bd)]),Gd),Ll(Pl([_d,Nl(bd)]),Gd),Ll(Nl(xd),function(t,e,n){return n.onEscape(t,e)}),Ll(Nl(wd.concat(yd)),function(e,n,o,t){return(r=o).focusManager.get(e).bind(function(t){return Ru(t,r.selector)}).bind(function(t){return o.execute(e,n,t)});var r})]),rt([Ll(Nl(wd),Ad)]),function(){return vt.some(jd)}),sg=[mo("selector"),Eo("getInitial",vt.none),Eo("execute",Dd),$u("onEscape"),Eo("executeOnMove",!1),Eo("allowVertical",!0)],lg=rt([Ll(Nl(wd),Ad)]),fg=Td(sg,xu.init,function(t,e,n,o){var r=Sd.concat(n.allowVertical?kd:[]),i=Cd.concat(n.allowVertical?Od:[]);return[Ll(Nl(r),$d(Id(Kd,Jd))),Ll(Nl(i),$d(Rd(Kd,Jd))),Ll(Nl(yd),Yd),Ll(Nl(wd),Yd),Ll(Nl(xd),Qd)]},lg,function(){return vt.some(qd)}),dg=[bo("selectors",[mo("row"),mo("cell")]),Eo("cycles",!0),Eo("previousSelector",vt.none),Eo("execute",Dd)],mg=im(function(t,e,n){return tm(t,e,n,-1)},function(t,e,n){return nm(t,e,n,-1)}),gg=im(function(t,e,n){return tm(t,e,n,1)},function(t,e,n){return nm(t,e,n,1)}),pg=im(function(t,e,n){return em(t,n,e,-1)},function(t,e,n){return om(t,n,e,-1)}),hg=im(function(t,e,n){return em(t,n,e,1)},function(t,e,n){return om(t,n,e,1)}),vg=rt([Ll(Nl(Sd),Id(mg,gg)),Ll(Nl(Cd),Rd(mg,gg)),Ll(Nl(kd),eg(pg)),Ll(Nl(Od),ng(hg)),Ll(Nl(wd.concat(yd)),function(e,n,o){return _a(e.element).bind(function(t){return o.execute(e,n,t)})})]),bg=rt([Ll(Nl(wd),Ad)]),yg=Td(dg,xu.init,vg,bg,function(){return vt.some(rm)}),xg=[mo("selector"),Eo("execute",Dd),Eo("moveOnTab",!1)],wg=rt([Ll(Nl(kd),og(cm)),Ll(Nl(Od),og(sm)),Ll(Pl([Vl,Nl(bd)]),function(t,e,n,o){return n.moveOnTab?og(cm)(t,e,n,o):vt.none()}),Ll(Pl([_d,Nl(bd)]),function(t,e,n,o){return n.moveOnTab?og(sm)(t,e,n,o):vt.none()}),Ll(Nl(yd),um),Ll(Nl(wd),um)]),Sg=rt([Ll(Nl(wd),Ad)]),kg=Td(xg,xu.init,wg,Sg,function(){return vt.some(am)}),Cg=Td([$u("onSpace"),$u("onEnter"),$u("onShiftEnter"),$u("onLeft"),$u("onRight"),$u("onTab"),$u("onShiftTab"),$u("onUp"),$u("onDown"),$u("onEscape"),Eo("stopSpaceKeyup",!1),wo("focusIn")],xu.init,function(t,e,n){return[Ll(Nl(wd),n.onSpace),Ll(Pl([_d,Nl(yd)]),n.onEnter),Ll(Pl([Vl,Nl(yd)]),n.onShiftEnter),Ll(Pl([Vl,Nl(bd)]),n.onShiftTab),Ll(Pl([_d,Nl(bd)]),n.onTab),Ll(Nl(kd),n.onUp),Ll(Nl(Od),n.onDown),Ll(Nl(Sd),n.onLeft),Ll(Nl(Cd),n.onRight),Ll(Nl(wd),n.onSpace),Ll(Nl(xd),n.onEscape)]},function(t,e,n){return n.stopSpaceKeyup?[Ll(Nl(wd),Ad)]:[]},function(t){return t.focusIn}),Og=Jm.schema(),_g=$m.schema(),Tg=fg.schema(),Eg=cg.schema(),Dg=yg.schema(),Ag=Qm.schema(),Bg=kg.schema(),Mg=Cg.schema(),Fg=wa({branchKey:"mode",branches:Object.freeze({__proto__:null,acyclic:Og,cyclic:_g,flow:Tg,flatgrid:Eg,matrix:Dg,execution:Ag,menu:Bg,special:Mg}),name:"keying",active:{events:function(t,e){return t.handler.toEvents(t,e)}},apis:{focusIn:function(e,n,o){n.sendFocusIn(n).fold(function(){e.getSystem().triggerFocus(e.element,e.element)},function(t){t(e,n,o)})},setGridSize:function(t,e,n,o,r){et(n,"setGridSize")?n.setGridSize(o,r):console.error("Layout does not support setGridSize")}},state:Zm}),Ig=function(t,e){return t.components()},Rg=xa({fields:[],name:"replacing",apis:Object.freeze({__proto__:null,append:function(t,e,n,o){lm(t,0,Tn,o)},prepend:function(t,e,n,o){lm(t,0,Ae,o)},remove:fm,replaceAt:dm,replaceBy:function(e,t,n,o,r){return P(Ig(e),o).bind(function(t){return dm(e,0,0,t,r)})},set:function(e,t,n,o){Ta(function(){var t=B(o,e.getSystem().build);Rs(e,t)},e.element)},contents:Ig})}),Ng=Object.freeze({__proto__:null,focus:gm,blur:function(t,e){e.ignore||t.element.dom.blur()},isFocused:function(t){return Ca(t.element)}}),Pg=Object.freeze({__proto__:null,exhibit:function(t,e){return zr(e.ignore?{}:{attributes:{tabindex:"-1"}})},events:function(n){return nu([Cr(Ai(),function(t,e){gm(t,n),e.stop()})].concat(n.stopMousedown?[Cr(mi(),function(t,e){e.event.prevent()})]:[]))}}),Vg=xa({fields:[Ju("onFocus"),Eo("stopMousedown",!1),Eo("ignore",!1)],name:"focusing",active:Pg,apis:Ng}),Hg=Object.freeze({__proto__:null,onLoad:xm,toggle:vm,isOn:function(t,e,n){return n.get()},on:bm,off:ym,set:Ym}),Lg=Object.freeze({__proto__:null,exhibit:function(){return zr({})},events:function(t,e){var n,o,r,i=(n=t,o=e,r=vm,uu(function(t){r(t,n,o)})),u=ba(t,e,xm);return nu(ft([t.toggleOnExecute?[i]:[],[u]]))}}),zg=xa({fields:[Eo("selected",!1),wo("toggleClass"),Eo("toggleOnExecute",!0),Do("aria",{mode:"none"},lo("mode",{pressed:[Eo("syncWithExpanded",!1),ta("update",function(t,e,n){oe(t.element,"aria-pressed",n),e.syncWithExpanded&&qm(t,0,n)})],checked:[ta("update",function(t,e,n){oe(t.element,"aria-checked",n)})],expanded:[ta("update",qm)],selected:[ta("update",function(t,e,n){oe(t.element,"aria-selected",n)})],none:[ta("update",st)]}))],name:"toggling",active:Lg,apis:Hg,state:{init:function(){var e=Po(!1);return{get:function(){return e.get()},set:function(t){return e.set(t)},clear:function(){return e.set(!1)},readState:function(){return e.get()}}}}}),Ug="alloy.item-hover",jg="alloy.item-focus",Wg=rt(Ug),Gg=rt(jg),Xg=[mo("data"),mo("components"),mo("dom"),Eo("hasSubmenu",!1),wo("toggling"),Af("itemBehaviours",[zg,Vg,Fg,Df]),Eo("ignoreFocus",!1),Eo("domModification",{}),ta("builder",function(t){return{dom:t.dom,domModification:lt(lt({},t.domModification),{attributes:lt(lt(lt({role:t.toggling.isSome()?"menuitemcheckbox":"menuitem"},t.domModification.attributes),{"aria-haspopup":t.hasSubmenu}),t.hasSubmenu?{"aria-expanded":!1}:{})}),behaviours:Bf(t.itemBehaviours,[t.toggling.fold(zg.revoke,function(t){return zg.config(lt({aria:{mode:"checked"}},t))}),Vg.config({ignore:t.ignoreFocus,stopMousedown:t.ignoreFocus,onFocus:function(t){Cm(t)}}),Fg.config({mode:"execution"}),Df.config({store:{mode:"memory",initialValue:t.data}}),mm("item-type-events",V(V([],wm(),!0),[Cr(vi(),km),Cr(Ri(),Vg.focus)],!1))]),components:t.components,eventOrder:t.eventOrder}}),Eo("eventOrder",{})],Yg=[mo("dom"),mo("components"),ta("builder",function(t){return{dom:t.dom,components:t.components,events:nu([Cr(Ri(),function(t,e){e.stop()})])}})],qg=rt("item-widget"),Kg=rt([Jf({name:"widget",overrides:function(e){return{behaviours:ec([Df.config({store:{mode:"manual",getValue:function(t){return e.data},setValue:st}})])}}})]),Jg=lo("type",{widget:[mo("uid"),mo("data"),mo("components"),mo("dom"),Eo("autofocus",!1),Eo("ignoreFocus",!1),Af("widgetBehaviours",[Df,Vg,Fg]),Eo("domModification",{}),xl(Kg()),ta("builder",function(n){function o(t){return ml(t,n,"widget").map(function(t){return Fg.focusIn(t),t})}function t(t,e){return Ol(e.event.target)||n.autofocus&&e.setSource(t.element),vt.none()}var e=fl(qg(),n,Kg()),r=dl(qg(),n,e.internals());return{dom:n.dom,components:r,domModification:n.domModification,events:nu([uu(function(t,e){o(t).each(function(t){e.stop()})}),Cr(vi(),km),Cr(Ri(),function(t,e){n.autofocus?o(t):Vg.focus(t)})]),behaviours:Bf(n.widgetBehaviours,[Df.config({store:{mode:"memory",initialValue:n.data}}),Vg.config({ignore:n.ignoreFocus,onFocus:function(t){Cm(t)}}),Fg.config({mode:"special",focusIn:n.autofocus?function(t){o(t)}:rc(),onLeft:t,onRight:t,onEscape:function(t,e){return Vg.isFocused(t)||n.autofocus?(n.autofocus&&e.setSource(t.element),vt.none()):(Vg.focus(t),vt.some(!0))}})])}})],item:Xg,separator:Yg}),$g=rt([Zf({factory:{sketch:function(t){var e=so("menu.spec item",Jg,t);return e.builder(e)}},name:"items",unit:"item",defaults:function(t,e){return Tt(e,"uid")?e:lt(lt({},e),{uid:pu("item")})},overrides:function(t,e){return{type:e.type,ignoreFocus:t.fakeFocus,domModification:{classes:[t.markers.item]}}}})]),Qg=rt([mo("value"),mo("items"),mo("dom"),mo("components"),Eo("eventOrder",{}),Zs("menuBehaviours",[hd,Df,cd,Fg]),Do("movement",{mode:"menu",moveOnTab:!0},lo("mode",{grid:[Ia(),ta("config",function(t,e){return{mode:"flatgrid",selector:"."+t.markers.item,initSize:{numColumns:e.initSize.numColumns,numRows:e.initSize.numRows},focusManager:t.focusManager}})],matrix:[ta("config",function(t,e){return{mode:"matrix",selectors:{row:e.rowSelector,cell:"."+t.markers.item},focusManager:t.focusManager}}),mo("rowSelector")],menu:[Eo("moveOnTab",!0),ta("config",function(t,e){return{mode:"menu",selector:"."+t.markers.item,moveOnTab:e.moveOnTab,focusManager:t.focusManager}})]})),go("markers",Fa()),Eo("fakeFocus",!1),Eo("focusManager",Ul()),Ju("onHighlight")]),Zg=rt("alloy.menu-focus"),tp=Cl({name:"Menu",configFields:Qg(),partFields:$g(),factory:function(t,e,n,o){return{uid:t.uid,dom:t.dom,markers:t.markers,behaviours:el(t.menuBehaviours,[hd.config({highlightClass:t.markers.selectedItem,itemClass:t.markers.item,onHighlight:t.onHighlight}),Df.config({store:{mode:"memory",initialValue:t.value}}),cd.config({find:vt.some}),Fg.config(t.movement.config(t,t.movement))]),events:nu([Cr(Gg(),function(e,n){var t=n.event;e.getSystem().getByDom(t.target).each(function(t){hd.highlight(e,t),n.stop(),br(e,Zg(),{menu:e,item:t})})}),Cr(Wg(),function(t,e){var n=e.event.item;hd.highlight(t,n)})]),components:e,eventOrder:t.eventOrder,domModification:{attributes:{role:"menu"}}}}}),ep=function(n,o,r,t){return tt(r,t).bind(function(t){return tt(n,t).bind(function(t){var e=ep(n,o,r,t);return vt.some([t].concat(e))})}).getOr([])},np=function(){function a(t){return e(t).bind(Km)}function n(t){return tt(c.get(),t)}var c=Po({}),i=Po({}),s=Po({}),l=gc(),u=Po({}),e=function(t){return tt(i.get(),t)};return{setMenuBuilt:function(t,e){var n;i.set(lt(lt({},i.get()),((n={})[t]={type:"prepared",menu:e},n)))},setContents:function(t,e,n,o){l.set(t),c.set(n),i.set(e),u.set(o);var r=function(t,e){var n={};J(t,function(t,e){St(t,function(t){n[t]=e})});var o=e,r=_t(e,function(t,e){return{k:t,v:e}}),i=dt(r,function(t,e){return[e].concat(ep(n,o,r,e))});return dt(n,function(t){return tt(i,t).getOr([t])})}(o,n);s.set(r)},expand:function(n){return tt(c.get(),n).map(function(t){var e=tt(s.get(),n).getOr([]);return[t].concat(e)})},refresh:function(t){return tt(s.get(),t)},collapse:function(t){return tt(s.get(),t).bind(function(t){return 1<t.length?vt.some(t.slice(1)):vt.none()})},lookupMenu:e,lookupItem:n,otherMenus:function(t){var e=u.get();return U(Ct(e),t)},getPrimary:function(){return l.get().bind(a)},getMenus:function(){return i.get()},clear:function(){c.set({}),i.set({}),s.set({}),l.clear()},isClear:function(){return l.get().isNone()},getTriggeringPath:function(t,u){var e=F(n(t).toArray(),function(t){return a(t).isSome()});return tt(s.get(),t).bind(function(t){var n=z(e.concat(t));return function(t){for(var e=[],n=0;n<t.length;n++){var o=t[n];if(!o.isSome())return vt.none();e.push(o.getOrDie())}return vt.some(e)}(H(n,function(t,e){return o=t,r=u,i=n.slice(0,e+1),a(o).bind(function(e){return n=o,Q(c.get(),function(t,e){return t===n}).bind(function(t){return r(t).map(function(t){return{triggeredMenu:e,triggeringItem:t,triggeringPath:i}})});var n}).fold(function(){return mt(l.get(),t)?[]:[vt.none()]},function(t){return[vt.some(t)]});var o,r,i}))})}}},op=Km,rp=rt("collapse-item"),ip=kl({name:"TieredMenu",configFields:[Zu("onExecute"),Zu("onEscape"),Qu("onOpenMenu"),Qu("onOpenSubmenu"),Ju("onRepositionMenu"),Ju("onCollapseMenu"),Eo("highlightImmediately",!0),bo("data",[mo("primary"),mo("menus"),mo("expansions")]),Eo("fakeFocus",!1),Ju("onHighlight"),Ju("onHover"),Yu(),mo("dom"),Eo("navigateOnHover",!0),Eo("stayInDom",!1),Zs("tmenuBehaviours",[Fg,hd,cd,Rg]),Eo("eventOrder",{})],apis:{collapseMenu:function(t,e){t.collapseMenu(e)},highlightPrimary:function(t,e){t.highlightPrimary(e)},repositionMenus:function(t,e){t.repositionMenus(e)}},factory:function(a,t){function n(t){var o,r,e=(o=t,r=a.data.primary,dt(a.data.menus,function(t,e){function n(){return tp.sketch(lt(lt({},t),{value:e,markers:a.markers,fakeFocus:a.fakeFocus,onHighlight:a.onHighlight,focusManager:(a.fakeFocus?jl:Ul)()}))}return e===r?{type:"prepared",menu:o.getSystem().build(n())}:{type:"notbuilt",nbMenu:n}})),n=dt(a.data.menus,function(t,e){return H(t.items,function(t){return"separator"===t.type?[]:[t.data.value]})});return g.setContents(a.data.primary,e,a.data.expansions,n),g.getPrimary()}function c(t){return Df.getValue(t).value}function u(e,t){hd.highlight(e,t),hd.getHighlighted(t).orThunk(function(){return hd.getFirst(t)}).each(function(t){xr(e,t.element,Ri())})}function s(e,t){return nt(B(t,function(t){return e.lookupMenu(t).bind(function(t){return"prepared"===t.type?vt.some(t.menu):vt.none()})}))}function l(e,t,n){var o=s(t,t.otherMenus(n));St(o,function(t){$r(t.element,[a.markers.backgroundMenu]),a.stayInDom||Rg.remove(e,t)})}function f(t,o){var e;J((e=t,r.get().getOrThunk(function(){var n={},t=F(vs(e.element,"."+a.markers.item),function(t){return"true"===ie(t,"aria-haspopup")});return St(t,function(t){e.getSystem().getByDom(t).each(function(t){var e=c(t);n[e]=t})}),r.set(n),n})),function(t,e){var n=wt(o,e);oe(t.element,"aria-expanded",n)})}function d(o,r,i){return vt.from(i[0]).bind(function(t){return r.lookupMenu(t).bind(function(t){if("notbuilt"===t.type)return vt.none();var e=t.menu,n=s(r,i.slice(1));return St(n,function(t){Yr(t.element,a.markers.backgroundMenu)}),vn(e.element)||Rg.append(o,Eu(e)),$r(e.element,[a.markers.backgroundMenu]),u(o,e),l(o,r,i),vt.some(e)})})}var m,e,r=gc(),g=np();function i(r,i,u){if(void 0===u&&(u=m.HighlightSubmenu),i.hasConfigured(gd)&&gd.isDisabled(i))return vt.some(i);var t=c(i);return g.expand(t).bind(function(o){return f(r,o),vt.from(o[0]).bind(function(n){return g.lookupMenu(n).bind(function(t){var e=function(t,e,n){if("notbuilt"!==n.type)return n.menu;var o=t.getSystem().build(n.nbMenu());return g.setMenuBuilt(e,o),o}(r,n,t);return vn(e.element)||Rg.append(r,Eu(e)),a.onOpenSubmenu(r,i,e,z(o)),u===m.HighlightSubmenu?(hd.highlightFirst(e),d(r,g,o)):(hd.dehighlightAll(e),vt.some(i))})})})}function o(e,n){var t=c(n);return g.collapse(t).bind(function(t){return f(e,t),d(e,g,t).map(function(t){return a.onCollapseMenu(e,n,t),t})})}function p(n){return function(e,t){return Ru(t.getSource(),"."+a.markers.item).bind(function(t){return e.getSystem().getByDom(t).toOptional().bind(function(t){return n(e,t).map(D)})})}}function h(t){return hd.getHighlighted(t).bind(hd.getHighlighted)}(e=m={})[e.HighlightSubmenu=0]="HighlightSubmenu",e[e.HighlightParent=1]="HighlightParent";var v=nu([Cr(Zg(),function(n,o){var t=o.event.item;g.lookupItem(c(t)).each(function(){var t=o.event.menu;hd.highlight(n,t);var e=c(o.event.item);g.refresh(e).each(function(t){return l(n,g,t)})})}),uu(function(e,t){var n=t.event.target;e.getSystem().getByDom(n).each(function(t){0===c(t).indexOf("collapse-item")&&o(e,t),i(e,t,m.HighlightSubmenu).fold(function(){a.onExecute(e,t)},st)})}),ou(function(e,t){n(e).each(function(t){Rg.append(e,Eu(t)),a.onOpenMenu(e,t),a.highlightImmediately&&u(e,t)})})].concat(a.navigateOnHover?[Cr(Wg(),function(t,e){var n=e.event.item,o=t,r=c(n);g.refresh(r).bind(function(t){return f(o,t),d(o,g,t)}),i(t,n,m.HighlightParent),a.onHover(t,n)})]:[])),b={collapseMenu:function(e){h(e).each(function(t){o(e,t)})},highlightPrimary:function(e){g.getPrimary().each(function(t){u(e,t)})},repositionMenus:function(o){g.getPrimary().bind(function(e){return h(o).bind(function(t){var e=c(t),n=nt(B(Z(g.getMenus()),op));return g.getTriggeringPath(e,function(t){return e=t,K(n,function(t){return t.getSystem().isConnected()?N(hd.getCandidates(t),function(t){return c(t)===e}):vt.none()});var e})}).map(function(t){return{primary:e,triggeringPath:t}})}).fold(function(){vt.from(o.components()[0]).filter(function(t){return"menu"===ie(t.element,"role")}).each(function(t){a.onRepositionMenu(o,t,[])})},function(t){var e=t.primary,n=t.triggeringPath;a.onRepositionMenu(o,e,n)})}};return{uid:a.uid,dom:a.dom,markers:a.markers,behaviours:el(a.tmenuBehaviours,[Fg.config({mode:"special",onRight:p(function(t,e){return Ol(e.element)?vt.none():i(t,e,m.HighlightSubmenu)}),onLeft:p(function(t,e){return Ol(e.element)?vt.none():o(t,e)}),onEscape:p(function(t,e){return o(t,e).orThunk(function(){return a.onEscape(t,e).map(function(){return t})})}),focusIn:function(e,t){g.getPrimary().each(function(t){xr(e,t.element,Ri())})}}),hd.config({highlightClass:a.markers.selectedMenu,itemClass:a.markers.menu}),cd.config({find:function(t){return hd.getHighlighted(t)}}),Rg.config({})]),eventOrder:a.eventOrder,apis:b,events:v}},extraApis:{tieredData:function(t,e,n){return{primary:t,menus:e,expansions:n}},singleData:function(t,e){return{primary:t,menus:sr(t,e),expansions:{}}},collapseItem:function(t){return{value:Ir(rp()),meta:{text:t}}}}}),up=kl({name:"InlineView",configFields:[mo("lazySink"),Ju("onShow"),Ju("onHide"),Oo("onEscape"),Zs("inlineBehaviours",[bf,Df,ic]),To("fireDismissalEventInstead",[Eo("event",Yi())]),To("fireRepositionEventInstead",[Eo("event",qi())]),Eo("getRelated",vt.none),Eo("isExtraPart",T),Eo("eventOrder",vt.none)],factory:function(d,t){function e(n){bf.isOpen(n)&&Df.getValue(n).each(function(t){switch(t.mode){case"menu":bf.getState(n).each(ip.repositionMenus);break;case"position":var e=d.lazySink(n).getOrDie();ff.positionWithinBounds(e,n,t.config,t.getBounds())}})}function o(t,e,n,o){i(t,e,n,function(){return o.map(function(t){return Mn(t)})})}function r(t,e,n,o){var r,i,u,a,c,s=(r=d,i=t,u=e,a=o,c="horizontal"===n.type?{layouts:{onLtr:ha,onRtl:va}}:{},ip.sketch({dom:{tag:"div"},data:n.data,markers:n.menu.markers,highlightImmediately:n.menu.highlightImmediately,onEscape:function(){return bf.close(i),r.onEscape.map(function(t){return t(i)}),vt.some(!0)},onExecute:function(){return vt.some(!0)},onOpenMenu:function(t,e){ff.positionWithinBounds(l().getOrDie(),e,u,a())},onOpenSubmenu:function(t,e,n,o){var r=l().getOrDie();ff.position(r,n,{anchor:lt({type:"submenu",item:e},f(o))})},onRepositionMenu:function(t,e,n){var o=l().getOrDie();ff.positionWithinBounds(o,e,u,a()),St(n,function(t){var e=f(t.triggeringPath);ff.position(o,t.triggeredMenu,{anchor:lt({type:"submenu",item:t.triggeringItem},e)})})}}));function l(){return r.lazySink(i)}function f(t){return 2===t.length?c:{}}bf.open(t,s),Df.setValue(t,vt.some({mode:"menu",menu:s}))}var i=function(t,e,n,o){var r=d.lazySink(t).getOrDie();bf.openWhileCloaked(t,e,function(){return ff.positionWithinBounds(r,t,n,o())}),Df.setValue(t,vt.some({mode:"position",config:n,getBounds:o}))},n={setContent:function(t,e){bf.setContent(t,e)},showAt:function(t,e,n){o(t,e,n,vt.none())},showWithin:o,showWithinBounds:i,showMenuAt:function(t,e,n){r(t,e,n,vt.none)},showMenuWithinBounds:r,hide:function(t){bf.isOpen(t)&&(Df.setValue(t,vt.none()),bf.close(t))},getContent:function(t){return bf.getState(t)},reposition:e,isOpen:bf.isOpen};return{uid:d.uid,dom:d.dom,behaviours:el(d.inlineBehaviours,[bf.config({isPartOf:function(t,e,n){return Hu(e,n)||(o=n,d.getRelated(t).exists(function(t){return Hu(t,o)}));var o},getAttachPoint:function(t){return d.lazySink(t).getOrDie()},onOpen:function(t){d.onShow(t)},onClose:function(t){d.onHide(t)}}),Df.config({store:{mode:"memory",initialValue:vt.none()}}),ic.config({channels:lt(lt({},Xs(lt({isExtraPart:t.isExtraPart},d.fireDismissalEventInstead.map(function(t){return{fireEventInstead:{event:t.event}}}).getOr({})))),Ys(lt(lt({},d.fireRepositionEventInstead.map(function(t){return{fireEventInstead:{event:t.event}}}).getOr({})),{doReposition:e})))})]),eventOrder:d.eventOrder,apis:n}},apis:{showAt:function(t,e,n,o){t.showAt(e,n,o)},showWithin:function(t,e,n,o,r){t.showWithin(e,n,o,r)},showWithinBounds:function(t,e,n,o,r){t.showWithinBounds(e,n,o,r)},showMenuAt:function(t,e,n,o){t.showMenuAt(e,n,o)},showMenuWithinBounds:function(t,e,n,o,r){t.showMenuWithinBounds(e,n,o,r)},hide:function(t,e){t.hide(e)},isOpen:function(t,e){return t.isOpen(e)},getContent:function(t,e){return t.getContent(e)},setContent:function(t,e,n){t.setContent(e,n)},reposition:function(t,e){t.reposition(e)}}}),ap="layout-inset",cp=function(t,e,n){return na(Om(t,e),t.y,n.insetNorth(),La(),"north",ra(t,{top:2}),ap)},sp=function(t,e,n){return na(Om(t,e),Tm(t,e),n.insetSouth(),za(),"south",ra(t,{bottom:3}),ap)},lp=tinymce.util.Tools.resolve("tinymce.util.Delay"),fp=kl({name:"Button",factory:function(t){function n(e){return tt(t.dom,"attributes").bind(function(t){return tt(t,e)})}var e=Sm(t.action),o=t.dom.tag;return{uid:t.uid,dom:t.dom,components:t.components,events:e,behaviours:Bf(t.buttonBehaviours,[Vg.config({}),Fg.config({mode:"execution",useSpace:!0,useEnter:!0})]),domModification:{attributes:function(){if("button"!==o)return{role:n("role").getOr("button")};var t=n("type").getOr("button"),e=n("role").map(function(t){return{role:t}}).getOr({});return lt({type:t},e)}()},eventOrder:t.eventOrder}},configFields:[Eo("uid",void 0),mo("dom"),Eo("components",[]),Af("buttonBehaviours",[Vg,Fg]),wo("action"),wo("role"),Eo("eventOrder",{})]}),dp=tinymce.util.Tools.resolve("tinymce.util.I18n"),mp={indent:!0,outdent:!0,"table-insert-column-after":!0,"table-insert-column-before":!0,"paste-column-after":!0,"paste-column-before":!0,"unordered-list":!0,"list-bull-circle":!0,"list-bull-default":!0,"list-bull-square":!0},gp="temporary-placeholder",pp={success:"checkmark",error:"warning",err:"error",warning:"warning",warn:"warning",info:"info"},hp=kl({name:"Notification",factory:function(e){function n(t){return{dom:{tag:"div",classes:["tox-bar"],attributes:{style:"width: "+t+"%"}}}}function o(t){return{dom:{tag:"div",classes:["tox-text"],innerHtml:t+"%"}}}var t,r,i,u,a=Hm({dom:{tag:"p",innerHtml:e.translationProvider(e.text)},behaviours:ec([Rg.config({})])}),c=Hm({dom:{tag:"div",classes:e.progress?["tox-progress-bar","tox-progress-indicator"]:["tox-progress-bar"]},components:[{dom:{tag:"div",classes:["tox-bar-container"]},components:[n(0)]},o(0)],behaviours:ec([Rg.config({})])}),s={updateProgress:function(t,e){t.getSystem().isConnected()&&c.getOpt(t).each(function(t){Rg.set(t,[{dom:{tag:"div",classes:["tox-bar-container"]},components:[n(e)]},o(e)])})},updateText:function(t,e){var n;t.getSystem().isConnected()&&(n=a.get(t),Rg.set(n,[ri(e)]))}},l=ft([e.icon.toArray(),e.level.toArray(),e.level.bind(function(t){return vt.from(pp[t])}).toArray()]),f=Hm(fp.sketch({dom:{tag:"button",classes:["tox-notification__dismiss","tox-button","tox-button--naked","tox-button--icon"]},components:[Xm("close",{tag:"div",classes:["tox-icon"],attributes:{"aria-label":e.translationProvider("Close")}},e.iconProvider)],action:function(t){e.onAction(t)}})),d=[(t=l,r={tag:"div",classes:["tox-notification__icon"]},i=e.iconProvider,u=i(),Gm(r,N(t,function(t){return Tt(u,zm(t,u))}).getOr(gp),u,vt.none())),{dom:{tag:"div",classes:["tox-notification__body"]},components:[a.asSpec()],behaviours:ec([Rg.config({})])}];return{uid:e.uid,dom:{tag:"div",attributes:{role:"alert"},classes:e.level.map(function(t){return["tox-notification","tox-notification--in","tox-notification--"+t]}).getOr(["tox-notification","tox-notification--in"])},behaviours:ec([Vg.config({}),mm("notification-events",[Cr(bi(),function(t){f.getOpt(t).each(Vg.focus)})])]),components:d.concat(e.progress?[c.asSpec()]:[]).concat(e.closeButton?[f.asSpec()]:[]),apis:s}},configFields:[wo("level"),mo("progress"),mo("icon"),mo("onAction"),mo("text"),mo("iconProvider"),mo("translationProvider"),Fo("closeButton",!0)],apis:{updateProgress:function(t,e,n){t.updateProgress(e,n)},updateText:function(t,e,n){t.updateText(e,n)}}});function vp(n,o){function r(){b(i)||(clearTimeout(i),i=null)}var i=null;return{cancel:r,throttle:function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];r(),i=setTimeout(function(){i=null,n.apply(null,t)},o)}}}function bp(o,t,e,n,r){var i=Ap(o,function(t){return(e=o).isBlock(n=t)||wt(["BR","IMG","HR","INPUT"],n.nodeName)||"false"===e.getContentEditable(n);var e,n});return vt.from(i.backwards(t,e,n,r))}function yp(n,e){return Bp(Mt.fromDom(n.selection.getNode())).getOrThunk(function(){var i,u,t=Mt.fromHtml('<span data-mce-autocompleter="1" data-mce-bogus="1"></span>',n.getDoc());return Tn(t,Mt.fromDom(e.extractContents())),e.insertNode(t.dom),Yt(t).each(function(t){return t.dom.normalize()}),i=hs,(u=function(t){for(var e=Kt(t),n=e.length-1;0<=n;n--){var o=e[n];if(i(o))return vt.some(o);var r=u(o);if(r.isSome())return r}return vt.none()})(t).map(function(t){var e;n.selection.setCursorLocation(t.dom,"img"===Ft(e=t)?1:ps(e).fold(function(){return Kt(e).length},function(t){return t.length}))}),t})}function xp(t){return t.toString().replace(/\u00A0/g," ").replace(/\uFEFF/g,"")}function wp(t){return""!==t&&-1!==" \xa0\f\n\r\t\v".indexOf(t)}function Sp(t,e){return t.substring(e.length)}function kp(o,t,r,e){return void 0===e&&(e=0),Bp(Mt.fromDom(t.startContainer)).fold(function(){return function(t,o,i,r){if(void 0===r&&(r=0),!o.collapsed||3!==o.startContainer.nodeType)return vt.none();var e=t.getParent(o.startContainer,t.isBlock)||t.getRoot();return bp(t,o.startContainer,o.startOffset,function(t,r,e){return function(t,e){for(var n=r-1;0<=n;n--){var o=t.charAt(n);if(wp(o))return vt.none();if(o===e)break}return vt.some(n)}(e,i).getOr(r)},e).bind(function(t){var e=o.cloneRange();if(e.setStart(t.container,t.offset),e.setEnd(o.endContainer,o.endOffset),e.collapsed)return vt.none();var n=xp(e);return 0!==n.lastIndexOf(i)||Sp(n,i).length<r?vt.none():vt.some({text:Sp(n,i),range:e,triggerChar:i})})}(o,t,r,e)},function(t){var e=o.createRng();e.selectNode(t.dom);var n=xp(e);return vt.some({range:e,text:Sp(n,r),triggerChar:r})})}function Cp(t,e){return{container:t,offset:e}}function Op(t){return ao("toolbarbutton",Hp,t)}function _p(t){return ao("ToggleButton",zp,t)}function Tp(e,t,n,o){void 0===o&&(o={});var r=t(),i=e.selection.getRng().startContainer.nodeValue,u=F(r.lookupByChar(n.triggerChar),function(t){return n.text.length>=t.minChars&&t.matches.getOrThunk(function(){return n=e.dom,function(t){var e=Ip(t.startContainer,t.startOffset);return!bp(n,e.container,e.offset,function(t,e){return 0===e?-1:e},n.getRoot()).filter(function(t){return!wp(t.container.data.charAt(t.offset-1))}).isSome()};var n})(n.range,i,n.text)});if(0===u.length)return vt.none();var a=Mp.all(B(u,function(e){return e.fetch(n.text,e.maxResults,o).then(function(t){return{matchText:n.text,items:t,columns:e.columns,onAction:e.onAction,highlightOn:e.highlightOn}})}));return vt.some({lookupData:a,context:n})}var Ep,Dp,Ap=tinymce.util.Tools.resolve("tinymce.dom.TextSeeker"),Bp=function(t){return Ru(t,"[data-mce-autocompleter]")},Mp=tinymce.util.Tools.resolve("tinymce.util.Promise"),Fp=function(t){if(3===t.nodeType)return Cp(t,t.data.length);var e=t.childNodes;return 0<e.length?Fp(e[e.length-1]):Cp(t,e.length)},Ip=function(t,e){var n=t.childNodes;return 0<n.length&&e<n.length?Ip(n[e],0):0<n.length&&1===t.nodeType&&n.length===e?Fp(n[n.length-1]):Cp(t,e)},Rp=$o([po("type"),Co("text")]),Np=$o([Eo("type","autocompleteitem"),Eo("active",!1),Eo("disabled",!1),Eo("meta",{}),po("value"),Co("text"),Co("icon")]),Pp=$o([po("type"),po("ch"),Ao("minChars",1),Eo("columns",1),Ao("maxResults",10),Oo("matches"),vo("fetch"),vo("onAction"),Ro("highlightOn",[],er)]),Vp=[Fo("disabled",!1),Co("tooltip"),Co("icon"),Co("text"),Io("onSetup",function(){return st})],Hp=$o([po("type"),vo("onAction")].concat(Vp)),Lp=[Fo("active",!1)].concat(Vp),zp=$o(Lp.concat([po("type"),vo("onAction")])),Up=[Io("predicate",T),Mo("scope","node",["node","editor"]),Mo("position","selection",["node","selection","line"])],jp=Vp.concat([Eo("type","contextformbutton"),Eo("primary",!1),vo("onAction"),cr("original",h)]),Wp=Lp.concat([Eo("type","contextformbutton"),Eo("primary",!1),vo("onAction"),cr("original",h)]),Gp=Vp.concat([Eo("type","contextformbutton")]),Xp=Lp.concat([Eo("type","contextformtogglebutton")]),Yp=lo("type",{contextformbutton:jp,contextformtogglebutton:Wp}),qp=$o([Eo("type","contextform"),Io("initValue",rt("")),Co("label"),xo("commands",Yp),So("launch",lo("type",{contextformbutton:Gp,contextformtogglebutton:Xp}))].concat(Up)),Kp=$o([Eo("type","contexttoolbar"),po("items")].concat(Up));function Jp(t){return tt(_h,t).getOr(kh)}function $p(t){return{backgroundMenu:"tox-background-menu",selectedMenu:"tox-selected-menu",selectedItem:"tox-collection__item--active",hasIcons:"tox-menu--has-icons",menu:"color"===t?"tox-swatches":"tox-menu",tieredMenu:"tox-tiered-menu"}}function Qp(t){var e=$p(t);return{backgroundMenu:e.backgroundMenu,selectedMenu:e.selectedMenu,menu:e.menu,selectedItem:e.selectedItem,item:Jp(t)}}function Zp(t,e,n){return{dom:{tag:"div",classes:ft([[$p(n).tieredMenu]])},markers:Qp(n)}}function th(e,n){return function(t){return B(p(t,n),function(t){return{dom:e,components:t}})}}function eh(t,n){var o=[],r=[];return St(t,function(t,e){n(t,e)?(0<r.length&&o.push(r),r=[],Tt(t.dom,"innerHtml")&&r.push(t)):r.push(t)}),0<r.length&&o.push(r),B(o,function(t){return{dom:{tag:"div",classes:["tox-collection__group"]},components:t}})}function nh(e,n){return{dom:{tag:"div",classes:["tox-menu","tox-collection"].concat(1===e?["tox-collection--list"]:["tox-collection--grid"])},components:[tp.parts.items({preprocess:function(t){return"auto"!==e&&1<e?th({tag:"div",classes:["tox-collection__group"]},e)(t):eh(t,function(t,e){return"separator"===n[e].type})}})]}}function oh(t){return d(t,function(t){return"icon"in t&&void 0!==t.icon})}function rh(t){return console.error(ur(t)),console.log(t),vt.none()}function ih(t,e,n,o,r){var i,u=(i=n,{dom:{tag:"div",classes:["tox-collection","tox-collection--horizontal"]},components:[tp.parts.items({preprocess:function(t){return eh(t,function(t,e){return"separator"===i[e].type})}})]});return{value:t,dom:u.dom,components:u.components,items:n}}function uh(t,e,n,o,r){var i,u;return"color"===r?{value:t,dom:(i={dom:{tag:"div",classes:["tox-menu","tox-swatches-menu"]},components:[{dom:{tag:"div",classes:["tox-swatches"]},components:[tp.parts.items({preprocess:"auto"!==o?th({tag:"div",classes:["tox-swatches__row"]},o):h})]}]}).dom,components:i.components,items:n}:"normal"===r&&"auto"===o?{value:t,dom:(i=nh(o,n)).dom,components:i.components,items:n}:"normal"===r&&1===o?{value:t,dom:(i=nh(1,n)).dom,components:i.components,items:n}:"normal"===r?{value:t,dom:(i=nh(o,n)).dom,components:i.components,items:n}:"listpreview"!==r||"auto"===o?{value:t,dom:{tag:"div",classes:ft([[(u=$p(r)).menu,"tox-menu-"+o+"-column"],e?[u.hasIcons]:[]])},components:Ih,items:n}:{value:t,dom:(i={dom:{tag:"div",classes:["tox-menu","tox-collection","tox-collection--toolbar","tox-collection--toolbar-lg"]},components:[tp.parts.items({preprocess:th({tag:"div",classes:["tox-collection__group"]},o)})]}).dom,components:i.components,items:n}}function ah(t,o,e){var r=vs(t.element,"."+e);if(0<r.length){var n=P(r,function(t){var e=t.dom.getBoundingClientRect().top,n=r[0].dom.getBoundingClientRect().top;return Math.abs(e-n)>o}).getOr(r.length);return vt.some({numColumns:n,numRows:Math.ceil(r.length/n)})}return vt.none()}function ch(t,e,n){t.getSystem().broadcastOn([Jh],{})}function sh(t){return t.getParam("height",Math.max(t.getElement().offsetHeight,200))}function lh(t){return t.getParam("width",nv.DOM.getStyle(t.getElement(),"width"))}function fh(t){return vt.from(t.getParam("min_width")).filter(u)}function dh(t){return vt.from(t.getParam("min_height")).filter(u)}function mh(t){return vt.from(t.getParam("max_width")).filter(u)}function gh(t){return vt.from(t.getParam("max_height")).filter(u)}function ph(t){return!1!==t.getParam("menubar",!0,"boolean")}function hh(t){var e=t.getParam("toolbar",!0),n=!0===e,o=y(e),r=c(e)&&0<e.length;return!rv(t)&&(r||o||n)}function vh(e){var t=F(m(9,function(t){return e.getParam("toolbar"+(t+1),!1,"string")}),function(t){return"string"==typeof t});return 0<t.length?vt.some(t):vt.none()}(Dp=Ep={})[Dp.CLOSE_ON_EXECUTE=0]="CLOSE_ON_EXECUTE",Dp[Dp.BUBBLE_TO_SANDBOX=1]="BUBBLE_TO_SANDBOX";var bh,yh,xh,wh,Sh=Ep,kh="tox-menu-nav__js",Ch="tox-collection__item",Oh="tox-swatch",_h={normal:kh,color:Oh},Th="tox-collection__item--enabled",Eh="tox-collection__item-icon",Dh="tox-collection__item-label",Ah="tox-collection__item-caret",Bh="tox-collection__item--active",Mh="tox-collection__item-container",Fh="tox-collection__item-container--row",Ih=[tp.parts.items({})],Rh=[po("type"),po("src"),Co("alt"),Ro("classes",[],er)],Nh=$o(Rh),Ph=[po("type"),po("text"),Co("name"),Ro("classes",["tox-collection__item-label"],er)],Vh=$o(Ph),Hh=Zn(function(){return ro("type",{cardimage:Nh,cardtext:Vh,cardcontainer:Lh})}),Lh=$o([po("type"),Bo("direction","horizontal"),Bo("align","left"),Bo("valign","middle"),xo("items",Hh)]),zh=[Fo("disabled",!1),Co("text"),Co("shortcut"),ar("value","value",Wn(function(){return Ir("menuitem-value")}),Zo()),Eo("meta",{})],Uh=$o([po("type"),Co("label"),xo("items",Hh),Io("onSetup",function(){return st}),Io("onAction",st)].concat(zh)),jh=$o([po("type"),Fo("active",!1),Co("icon")].concat(zh)),Wh=[po("type"),po("fancytype"),Io("onAction",st)],Gh=lo("fancytype",{inserttable:[Eo("initData",{})].concat(Wh),colorswatch:[No("initData",{},[Fo("allowCustomColors",!0),_o("colors",Zo())])].concat(Wh)}),Xh=$o([po("type"),Io("onSetup",function(){return st}),Io("onAction",st),Co("icon")].concat(zh)),Yh=$o([po("type"),vo("getSubmenuItems"),Io("onSetup",function(){return st}),Co("icon")].concat(zh)),qh=$o([po("type"),Co("icon"),Fo("active",!1),Io("onSetup",function(){return st}),vo("onAction")].concat(zh)),Kh=function(t){return e=Ir("unnamed-events"),ec([mm(e,t)]);var e},Jh=Ir("tooltip.exclusive"),$h=Ir("tooltip.show"),Qh=Ir("tooltip.hide"),Zh=Object.freeze({__proto__:null,hideAllExclusive:ch,setComponents:function(t,e,n,o){n.getTooltip().each(function(t){t.getSystem().isConnected()&&Rg.set(t,o)})}}),tv=Object.freeze({__proto__:null,events:function(r,i){function n(e){i.getTooltip().each(function(t){Vs(t),r.onHide(e,t),i.clearTooltip()}),i.clearTimer()}return nu(ft([[Cr($h,function(o){i.resetTimer(function(){var t,e,n=o;i.isShowing()||(ch(n),t=r.lazySink(n).getOrDie(),e=n.getSystem().build({dom:r.tooltipDom,components:r.tooltipComponents,events:nu("normal"===r.mode?[Cr(vi(),function(t){vr(n,$h)}),Cr(pi(),function(t){vr(n,Qh)})]:[]),behaviours:ec([Rg.config({})])}),i.setTooltip(e),Ns(t,e),r.onShow(n,e),ff.position(t,e,{anchor:r.anchor(n)}))},r.delay)}),Cr(Qh,function(t){i.resetTimer(function(){n(t)},r.delay)}),Cr(Fi(),function(t,e){e.universal||wt(e.channels,Jh)&&n(t)}),ru(function(t){n(t)})],"normal"===r.mode?[Cr(bi(),function(t){vr(t,$h)}),Cr(Bi(),function(t){vr(t,Qh)}),Cr(vi(),function(t){vr(t,$h)}),Cr(pi(),function(t){vr(t,Qh)})]:[Cr(Zi(),function(t,e){vr(t,$h)}),Cr(tu(),function(t){vr(t,Qh)})]]))}}),ev=xa({fields:[mo("lazySink"),mo("tooltipDom"),Eo("exclusive",!0),Eo("tooltipComponents",[]),Eo("delay",300),Mo("mode","normal",["normal","follow-highlight"]),Eo("anchor",function(t){return{type:"hotspot",hotspot:t,layouts:{onLtr:rt([$a,Ja,Xa,qa,Ya,Ka]),onRtl:rt([$a,Ja,Xa,qa,Ya,Ka])}}}),Ju("onHide"),Ju("onShow")],name:"tooltipping",active:tv,state:Object.freeze({__proto__:null,init:function(){function n(){o.on(clearTimeout)}var o=gc(),t=gc(),e=rt("not-implemented");return wu({getTooltip:t.get,isShowing:t.isSet,setTooltip:t.set,clearTooltip:t.clear,clearTimer:n,resetTimer:function(t,e){n(),o.set(setTimeout(t,e))},readState:e})}}),apis:Zh}),nv=tinymce.util.Tools.resolve("tinymce.dom.DOMUtils"),ov=tinymce.util.Tools.resolve("tinymce.EditorManager"),rv=function(t){return vh(t).fold(function(){return 0<t.getParam("toolbar",[],"string[]").length},D)};function iv(t){return t.getParam("toolbar_mode","","string")}function uv(t){return t.getParam("toolbar_location",xh.auto,"string")}function av(t){return uv(t)===xh.bottom}function cv(t){if(!t.inline)return vt.none();var e=t.getParam("fixed_toolbar_container","","string");if(0<e.length)return Iu(bn(),e);var n=t.getParam("fixed_toolbar_container_target");return k(n)?vt.some(Mt.fromDom(n)):vt.none()}function sv(t){return t.inline&&cv(t).isSome()}function lv(t){return cv(t).getOrThunk(function(){return te(gn(Mt.fromDom(t.getElement())))})}function fv(t){return t.inline&&!ph(t)&&!hh(t)&&!rv(t)}function dv(t){return(t.getParam("toolbar_sticky",!1,"boolean")||t.inline)&&!sv(t)&&!fv(t)}function mv(t,e){var n=t.outerContainer.element;e&&(t.mothership.broadcastOn([yf()],{target:n}),t.uiMothership.broadcastOn([yf()],{target:n})),t.mothership.broadcastOn([Kv],{readonly:e}),t.uiMothership.broadcastOn([Kv],{readonly:e})}function gv(t,e){t.on("init",function(){t.mode.isReadOnly()&&mv(e,!0)}),t.on("SwitchMode",function(){return mv(e,t.mode.isReadOnly())}),t.getParam("readonly",!1,"boolean")&&t.setMode("readonly")}function pv(){var t;return ic.config({channels:((t={})[Kv]={schema:Jv,onReceive:function(t,e){gd.set(t,e.readonly)}},t)})}function hv(t,e){var n=t.getApi(e);return function(t){t(n)}}function vv(n,o){return ou(function(t){hv(n,t)(function(t){var e=n.onSetup(t);S(e)&&o.set(e)})})}function bv(e,n){return ru(function(t){return hv(e,t)(n.get())})}function yv(t,e,n,o){var r,i,u=Po(st);return{type:"item",dom:e.dom,components:tb(e.optComponents),data:t.data,eventOrder:Zv,hasSubmenu:t.triggersSubmenu,itemBehaviours:ec([mm("item-events",[(r=t,i=n,uu(function(t,e){hv(r,t)(r.onAction),r.triggersSubmenu||i!==Sh.CLOSE_ON_EXECUTE||(vr(t,Vi()),e.stop())})),vv(t,u),bv(t,u)]),gd.config({disabled:function(){return t.disabled||o.isDisabled()},disableClass:"tox-collection__item--state-disabled"}),pv(),Rg.config({})].concat(t.itemBehaviours))}}function xv(t){return{value:t.value,meta:lt({text:t.text.getOr("")},t.meta)}}function wv(t,e,n){return Xm(t,{tag:"div",classes:n=void 0===n?[Eh]:n},e)}function Sv(t){return{dom:{tag:"div",classes:[Dh]},components:[ri(dp.translate(t))]}}function kv(t,e){return{dom:{tag:"div",classes:e,innerHtml:t}}}function Cv(t,e){return{dom:{tag:"div",classes:[Dh]},components:[{dom:{tag:t.tag,styles:t.styles},components:[ri(dp.translate(e))]}]}}function Ov(t){return{dom:{tag:"div",classes:["tox-collection__item-accessory"],innerHtml:(n=eb.mac?{alt:"&#x2325;",ctrl:"&#x2303;",shift:"&#x21E7;",meta:"&#x2318;",access:"&#x2303;&#x2325;"}:{meta:"Ctrl",access:"Shift+Alt"},e=B(t.split("+"),function(t){var e=t.toLowerCase().trim();return Tt(n,e)?n[e]:t}),eb.mac?e.join(""):e.join("+"))}};var n,e}function _v(t){return wv("checkmark",t,["tox-collection__item-checkmark"])}function Tv(t){var e=t.map(function(t){return{attributes:{title:dp.translate(t)}}}).getOr({});return lt({tag:"div",classes:[kh,Ch]},e)}function Ev(t,e,n,o){return void 0===o&&(o=vt.none()),"color"===t.presets?(r=e,i=o,c=t.ariaLabel,s=t.value,{dom:(u=t.iconContent.map(function(t){return e=r.icons,n=i,Um(t,o=e()).or(n).getOrThunk(Lm(o));var e,n,o}).getOr(""),a={tag:"div",attributes:c.map(function(t){return{title:r.translate(t)}}).getOr({}),classes:["tox-swatch"]},lt(lt({},a),"custom"===s?{tag:"button",classes:V(V([],a.classes,!0),["tox-swatches__picker-btn"],!1),innerHtml:u}:"remove"===s?{classes:V(V([],a.classes,!0),["tox-swatch--remove"],!1),innerHtml:u}:{attributes:lt(lt({},a.attributes),{"data-mce-color":s}),styles:{"background-color":s}})),optComponents:[]}):(l=t,f=e,d=o,m={tag:"div",classes:[Eh]},g=n?l.iconContent.map(function(t){return Xm(t,m,f.icons,d)}).orThunk(function(){return vt.some({dom:m})}):vt.none(),p=l.checkMark,h=vt.from(l.meta).fold(function(){return Sv},function(t){return Tt(t,"style")?C(Cv,t.style):Sv}),v=l.htmlContent.fold(function(){return l.textContent.map(h)},function(t){return vt.some(kv(t,[Dh]))}),{dom:Tv(l.ariaLabel),optComponents:[g,v,l.shortcutContent.map(Ov),p,l.caret]});var r,i,u,a,c,s,l,f,d,m,g,p,h,v}function Dv(t,e){return tt(t,"tooltipWorker").map(function(n){return[ev.config({lazySink:e.getSink,tooltipDom:{tag:"div",classes:["tox-tooltip-worker-container"]},tooltipComponents:[],anchor:function(t){return{type:"submenu",item:t,overrides:{maxHeightFunction:Nc}}},mode:"follow-highlight",onShow:function(e,t){n(function(t){ev.setComponents(e,[Ou({element:Mt.fromDom(t)})])})}})]}).getOr([])}function Av(t,e){var n=dp.translate(t),o=nv.DOM.encode(n);if(0<e.length){var r=new RegExp(e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),"gi");return o.replace(r,function(t){return'<span class="tox-autocompleter-highlight">'+t+"</span>"})}return o}function Bv(t){return{value:t}}function Mv(t){return rb.test(t)||ib.test(t)}function Fv(t){var e=t.toString(16);return(1===e.length?"0"+e:e).toUpperCase()}function Iv(t){return Bv(Fv(t.red)+Fv(t.green)+Fv(t.blue))}function Rv(t,e,n,o){return{red:t,green:e,blue:n,alpha:o}}function Nv(t){var e=parseInt(t,10);return e.toString()===t&&0<=e&&e<=255}function Pv(t){var e,n,o,r=(t.hue||0)%360,i=t.saturation/100,u=t.value/100,i=ab(0,ub(i,1)),u=ab(0,ub(u,1));if(0===i)return Rv(e=n=o=cb(255*u),n,o,1);var a=r/60,c=u*i,s=c*(1-Math.abs(a%2-1)),l=u-c;switch(Math.floor(a)){case 0:e=c,n=s,o=0;break;case 1:e=s,n=c,o=0;break;case 2:e=0,n=c,o=s;break;case 3:e=0,n=s,o=c;break;case 4:e=s,n=0,o=c;break;case 5:e=c,n=0,o=s;break;default:e=n=o=0}return Rv(e=cb(255*(e+l)),n=cb(255*(n+l)),o=cb(255*(o+l)),1)}function Vv(t){var e,n,o=(e={value:t.value.replace(rb,function(t,e,n,o){return e+e+n+n+o+o})},null===(n=ib.exec(e.value))?["FFFFFF","FF","FF","FF"]:n);return Rv(parseInt(o[1],16),parseInt(o[2],16),parseInt(o[3],16),1)}function Hv(t,e,n,o){return Rv(parseInt(t,10),parseInt(e,10),parseInt(n,10),parseFloat(o))}function Lv(t){if("transparent"===t)return vt.some(Rv(0,0,0,0));var e=sb.exec(t);if(null!==e)return vt.some(Hv(e[1],e[2],e[3],"1"));var n=lb.exec(t);return null!==n?vt.some(Hv(n[1],n[2],n[3],n[4])):vt.none()}function zv(t){return"rgba("+t.red+","+t.green+","+t.blue+","+t.alpha+")"}function Uv(t,e){return t.fire("ResizeContent",e)}function jv(t,e,n){return{hue:t,saturation:e,value:n}}function Wv(t){var e,n,o=0,r=t.red/255,i=t.green/255,u=t.blue/255,a=Math.min(r,Math.min(i,u)),c=Math.max(r,Math.max(i,u));return a===c?jv(0,0,100*(o=a)):(n=60*((r===a?3:u===a?1:5)-(r===a?i-u:u===a?r-i:u-r)/(c-a)),e=(c-a)/c,o=c,jv(Math.round(n),Math.round(100*e),Math.round(100*o)))}function Gv(t){return Iv(Pv(t))}function Xv(o){return(Mv(e=o)?vt.some({value:(Dt(t=e,"#")?t.substring("#".length):t).toUpperCase()}):vt.none()).orThunk(function(){return Lv(o).map(Iv)}).getOrThunk(function(){var t=document.createElement("canvas");t.height=1,t.width=1;var e=t.getContext("2d");e.clearRect(0,0,t.width,t.height),e.fillStyle="#FFFFFF",e.fillStyle=o,e.fillRect(0,0,1,1);var n=e.getImageData(0,0,1,1).data;return Iv(Rv(n[0],n[1],n[2],n[3]))});var t,e}(yh=bh=bh||{}).default="wrap",yh.floating="floating",yh.sliding="sliding",yh.scrolling="scrolling",(wh=xh=xh||{}).auto="auto",wh.top="top",wh.bottom="bottom";function Yv(t){return gd.config({disabled:t,disableClass:"tox-tbtn--disabled"})}var qv,Kv="silver.readonly",Jv=$o([go("readonly",nr)]),$v=function(t){return gd.config({disabled:t})},Qv=function(t){return gd.config({disabled:t,disableClass:"tox-tbtn--disabled",useNative:!1})},Zv=((qv={})[Ii()]=["disabling","alloy.base.behaviour","toggling","item-events"],qv),tb=nt,eb=tinymce.util.Tools.resolve("tinymce.Env"),nb=function(t,a){return B(t,function(t){switch(t.type){case"cardcontainer":return r=nb((o=t).items,a),i="vertical"===o.direction?"tox-collection__item-container--column":Fh,u="left"===o.align?"tox-collection__item-container--align-left":"tox-collection__item-container--align-right",{dom:{tag:"div",classes:[Mh,i,u,function(){switch(o.valign){case"top":return"tox-collection__item-container--valign-top";case"middle":return"tox-collection__item-container--valign-middle";case"bottom":return"tox-collection__item-container--valign-bottom"}}()]},components:r};case"cardimage":return n=t.src,{dom:{tag:"img",classes:t.classes,attributes:{src:n,alt:t.alt.getOr("")}}};case"cardtext":var e=t.name.exists(function(t){return wt(a.cardText.highlightOn,t)})?vt.from(a.cardText.matchText).getOr(""):"";return kv(Av(t.text,e),t.classes)}var n,o,r,i,u})},ob=al(qg(),Kg()),rb=/^#?([a-f\d])([a-f\d])([a-f\d])$/i,ib=/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i,ub=Math.min,ab=Math.max,cb=Math.round,sb=/^rgb\((\d+),\s*(\d+),\s*(\d+)\)/,lb=/^rgba\((\d+),\s*(\d+),\s*(\d+),\s*(\d?(?:\.\d+)?)\)/,fb=Rv(255,0,0,1),db=tinymce.util.Tools.resolve("tinymce.util.LocalStorage"),mb="tinymce-custom-colors";function gb(t){return!1!==t.getParam("custom_colors")}function pb(t){var e=t.getParam("color_map");return void 0!==e?function(t){for(var e=[],n=0;n<t.length;n+=2)e.push({text:t[n+1],value:"#"+Xv(t[n]).value,type:"choiceitem"});return e}(e):Bb}function hb(t){Mb.add(t)}function vb(t){var e,n=(e=pb(t).length,Math.max(5,Math.ceil(Math.sqrt(e))));return t.getParam("color_cols",n,"number")}function bb(t){var e="choiceitem",n={type:e,text:"Remove color",icon:"color-swatch-remove-color",value:"remove"};return t?[n,{type:e,text:"Custom color",icon:"color-picker",value:"custom"}]:[n]}function yb(e,n,t,o){"custom"===t?Ib(e)(function(t){t.each(function(t){hb(t),e.execCommand("mceApplyTextcolor",n,t),o(t)})},Fb):"remove"===t?(o(""),e.execCommand("mceRemoveTextcolor",n)):(o(t),e.execCommand("mceApplyTextcolor",n,t))}function xb(t,e){return t.concat(B(Mb.state(),function(t){return{type:Ab,text:t,value:t}}).concat(bb(e)))}function wb(e,n){return function(t){t(xb(e,n))}}function Sb(t,e,n){t.setIconFill("forecolor"===e?"tox-icon-text-color__color":"tox-icon-highlight-bg-color__color",n)}function kb(i,n,u,t,o){i.ui.registry.addSplitButton(n,{tooltip:t,presets:"color",icon:"forecolor"===n?"text-color":"highlight-bg-color",select:function(n){var o,r=u;return i.dom.getParents(i.selection.getStart(),function(t){var e;(e=t.style["forecolor"===r?"color":"background-color"])&&(o=o||e)}),vt.from(o).bind(function(t){return Lv(t).map(function(t){var e=Iv(t).value;return ut(n.toLowerCase(),e)})}).getOr(!1)},columns:vb(i),fetch:wb(pb(i),gb(i)),onAction:function(t){yb(i,u,o.get(),st)},onItemAction:function(t,e){yb(i,u,e,function(t){o.set(t),i.fire("TextColorChange",{name:n,color:t})})},onSetup:function(e){function t(t){t.name===n&&Sb(e,t.name,t.color)}return Sb(e,n,o.get()),i.on("TextColorChange",t),function(){i.off("TextColorChange",t)}}})}function Cb(e,t,n,o){e.ui.registry.addNestedMenuItem(t,{text:o,icon:"forecolor"===t?"text-color":"highlight-bg-color",getSubmenuItems:function(){return[{type:"fancymenuitem",fancytype:"colorswatch",onAction:function(t){yb(e,n,t.value,st)}}]}})}function Ob(t,e,n,o,r,i,u,a){return uh(t,oh(e),Rb(e,n,o,"color"!==r?"normal":"color",i,u,a),o,r)}function _b(t,e){var n=Qp(e);return 1===t?{mode:"menu",moveOnTab:!0}:"auto"===t?{mode:"grid",selector:"."+n.item,initSize:{numColumns:1,numRows:1}}:{mode:"matrix",rowSelector:"."+("color"===e?"tox-swatches__row":"tox-collection__group")}}function Tb(t,e){return ri(e+"x"+t)}var Eb,Db,Ab="choiceitem",Bb=[{type:Ab,text:"Light Green",value:"#BFEDD2"},{type:Ab,text:"Light Yellow",value:"#FBEEB8"},{type:Ab,text:"Light Red",value:"#F8CAC6"},{type:Ab,text:"Light Purple",value:"#ECCAFA"},{type:Ab,text:"Light Blue",value:"#C2E0F4"},{type:Ab,text:"Green",value:"#2DC26B"},{type:Ab,text:"Yellow",value:"#F1C40F"},{type:Ab,text:"Red",value:"#E03E2D"},{type:Ab,text:"Purple",value:"#B96AD9"},{type:Ab,text:"Blue",value:"#3598DB"},{type:Ab,text:"Dark Turquoise",value:"#169179"},{type:Ab,text:"Orange",value:"#E67E23"},{type:Ab,text:"Dark Red",value:"#BA372A"},{type:Ab,text:"Dark Purple",value:"#843FA1"},{type:Ab,text:"Dark Blue",value:"#236FA1"},{type:Ab,text:"Light Gray",value:"#ECF0F1"},{type:Ab,text:"Medium Gray",value:"#CED4D9"},{type:Ab,text:"Gray",value:"#95A5A6"},{type:Ab,text:"Dark Gray",value:"#7E8C8D"},{type:Ab,text:"Navy Blue",value:"#34495E"},{type:Ab,text:"Black",value:"#000000"},{type:Ab,text:"White",value:"#ffffff"}],Mb=function(n){void 0===n&&(n=10);function o(t){i.splice(t,1)}var t,e=db.getItem(mb),r=y(e)?JSON.parse(e):[],i=n-(t=r).length<0?t.slice(0,n):t;return{add:function(t){var e;(-1===(e=l(i,t))?vt.none():vt.some(e)).each(o),i.unshift(t),i.length>n&&i.pop(),db.setItem(mb,JSON.stringify(i))},state:function(){return i.slice(0)}}}(10),Fb="#000000",Ib=function(r){return function(n,t){var o=!1;r.windowManager.open({title:"Color Picker",size:"normal",body:{type:"panel",items:[{type:"colorpicker",name:"colorpicker",label:"Color"}]},buttons:[{type:"cancel",name:"cancel",text:"Cancel"},{type:"submit",name:"save",text:"Save",primary:!0}],initialData:{colorpicker:t},onAction:function(t,e){"hex-valid"===e.name&&(o=e.value)},onSubmit:function(t){var e=t.getData().colorpicker;o?(n(vt.from(e)),t.close()):r.windowManager.alert(r.translate(["Invalid hex color code: {0}",e]))},onClose:st,onCancel:function(){n(vt.none())}})}},Rb=function(n,o,r,i,u,a,c){return nt(B(n,function(e){return"choiceitem"===e.type?ao("choicemenuitem",jh,e).fold(rh,function(t){return vt.some(function(e,t,n,o,r,i,u,a){void 0===a&&(a=!0);var c=Ev({presets:n,textContent:t?e.text:vt.none(),htmlContent:vt.none(),ariaLabel:e.text,iconContent:e.icon,shortcutContent:t?e.shortcut:vt.none(),checkMark:t?vt.some(_v(u.icons)):vt.none(),caret:vt.none(),value:e.value},u,a);return Yo(yv({data:xv(e),disabled:e.disabled,getApi:function(e){return{setActive:function(t){zg.set(e,t)},isActive:function(){return zg.isOn(e)},isDisabled:function(){return gd.isDisabled(e)},setDisabled:function(t){return gd.set(e,t)}}},onAction:function(t){return o(e.value)},onSetup:function(t){return t.setActive(r),st},triggersSubmenu:!1,itemBehaviours:[]},c,i,u),{toggling:{toggleClass:Th,toggleOnExecute:!1,selected:e.active}})}(t,1===r,i,o,a(e.value),u,c,oh(n)))}):vt.none()}))},Nb=Ir("cell-over"),Pb=Ir("cell-execute"),Vb={inserttable:function(u){var t=Ir("size-label"),a=function(t){for(var e=[],n=0;n<10;n++){for(var o=[],r=0;r<10;r++)o.push(function(e,n,t){function o(t){return br(t,Pb,{row:e,col:n})}function r(t,e){e.stop(),o(t)}var i;return Tu({dom:{tag:"div",attributes:((i={role:"button"})["aria-labelledby"]=t,i)},behaviours:ec([mm("insert-table-picker-cell",[Cr(vi(),Vg.focus),Cr(Ii(),o),Cr(Ci(),r),Cr(Ni(),r)]),zg.config({toggleClass:"tox-insert-table-picker__selected",toggleOnExecute:!1}),Vg.config({onFocus:function(t){return br(t,Nb,{row:e,col:n})}})])})}(n,r,t));e.push(o)}return e}(t),e=Tb(0,0),c=Hm({dom:{tag:"span",classes:["tox-insert-table-picker__label"],attributes:{id:t}},components:[e],behaviours:ec([Rg.config({})])});return{type:"widget",data:{value:Ir("widget-id")},dom:{tag:"div",classes:["tox-fancymenuitem"]},autofocus:!0,components:[ob.widget({dom:{tag:"div",classes:["tox-insert-table-picker"]},components:H(a,function(t){return B(t,Eu)}).concat(c.asSpec()),behaviours:ec([mm("insert-table-picker",[ou(function(t){Rg.set(c.get(t),[e])}),Er(Nb,function(t,e,n){var o=n.event,r=o.row,i=o.col;!function(t,e,n){for(var o=0;o<10;o++)for(var r=0;r<10;r++)zg.set(t[o][r],o<=e&&r<=n)}(a,r,i),Rg.set(c.get(t),[Tb(r+1,i+1)])}),Er(Pb,function(t,e,n){var o=n.event,r=o.row,i=o.col;u.onAction({numRows:r+1,numColumns:i+1}),vr(t,Vi())})]),Fg.config({initSize:{numRows:10,numColumns:10},mode:"flatgrid",selector:'[role="button"]'})])})]}},colorswatch:function(e,t){var n,o,r,i=(o=t,r=(n=e).initData.allowCustomColors&&o.colorinput.hasCustomColors(),n.initData.colors.fold(function(){return xb(o.colorinput.getColors(),r)},function(t){return t.concat(bb(r))})),u=t.colorinput.getColorCols(),a=Ob(Ir("menu-value"),i,function(t){e.onAction({value:t})},u,"color",Sh.CLOSE_ON_EXECUTE,T,t.shared.providers),c=lt(lt({},a),{markers:Qp("color"),movement:_b(u,"color")});return{type:"widget",data:{value:Ir("widget-id")},dom:{tag:"div",classes:["tox-fancymenuitem"]},autofocus:!0,components:[ob.widget(tp.sketch(c))]}}},Hb=function(t){var e=t.text.fold(function(){return{}},function(t){return{innerHtml:t}});return{type:"separator",dom:lt({tag:"div",classes:[Ch,"tox-collection__group-heading"]},e),components:[]}},Lb=function(t,e,n,o){void 0===o&&(o=!0);var r=Ev({presets:"normal",iconContent:t.icon,textContent:t.text,htmlContent:vt.none(),ariaLabel:t.text,caret:vt.none(),checkMark:vt.none(),shortcutContent:t.shortcut},n,o);return yv({data:xv(t),getApi:function(e){return{isDisabled:function(){return gd.isDisabled(e)},setDisabled:function(t){return gd.set(e,t)}}},disabled:t.disabled,onAction:t.onAction,onSetup:t.onSetup,triggersSubmenu:!1,itemBehaviours:[]},r,e,n)},zb=function(t,e,n,o,r){void 0===o&&(o=!0);var i=(r=void 0!==r&&r)?wv("chevron-down",n.icons,[Ah]):wv("chevron-right",n.icons,[Ah]),u=Ev({presets:"normal",iconContent:t.icon,textContent:t.text,htmlContent:vt.none(),ariaLabel:t.text,caret:vt.some(i),checkMark:vt.none(),shortcutContent:t.shortcut},n,o);return yv({data:xv(t),getApi:function(e){return{isDisabled:function(){return gd.isDisabled(e)},setDisabled:function(t){return gd.set(e,t)}}},disabled:t.disabled,onAction:st,onSetup:t.onSetup,triggersSubmenu:!0,itemBehaviours:[]},u,e,n)},Ub=function(t,e,n,o){void 0===o&&(o=!0);var r=Ev({iconContent:t.icon,textContent:t.text,htmlContent:vt.none(),ariaLabel:t.text,checkMark:vt.some(_v(n.icons)),caret:vt.none(),shortcutContent:t.shortcut,presets:"normal",meta:t.meta},n,o);return Yo(yv({data:xv(t),disabled:t.disabled,getApi:function(e){return{setActive:function(t){zg.set(e,t)},isActive:function(){return zg.isOn(e)},isDisabled:function(){return gd.isDisabled(e)},setDisabled:function(t){return gd.set(e,t)}}},onAction:t.onAction,onSetup:t.onSetup,triggersSubmenu:!1,itemBehaviours:[]},r,e,n),{toggling:{toggleClass:Th,toggleOnExecute:!1,selected:t.active}})},jb=function(e,n){return tt(Vb,e.fancytype).map(function(t){return t(e,n)})};function Wb(t,u,a,e,c,s,l){var n=1===e,o=!n||oh(t);return nt(B(t,function(t){switch(t.type){case"separator":return ao("Autocompleter.Separator",Rp,t).fold(rh,function(t){return vt.some(Hb(t))});case"cardmenuitem":return ao("cardmenuitem",Uh,t).fold(rh,function(e){return vt.some((t=lt(lt({},e),{onAction:function(t){e.onAction(t),a(e.value,e.meta)}}),n=c,o=s,r={itemBehaviours:Dv(e.meta,s),cardText:{matchText:u,highlightOn:l}},i={dom:Tv(t.label),optComponents:[vt.some({dom:{tag:"div",classes:[Mh,Fh]},components:nb(t.items,r)})]},yv({data:xv(lt({text:vt.none()},t)),disabled:t.disabled,getApi:function(n){return{isDisabled:function(){return gd.isDisabled(n)},setDisabled:function(e){gd.set(n,e),St(vs(n.element,"*"),function(t){n.getSystem().getByDom(t).each(function(t){t.hasConfigured(gd)&&gd.set(t,e)})})}}},onAction:t.onAction,onSetup:t.onSetup,triggersSubmenu:!1,itemBehaviours:vt.from(r.itemBehaviours).getOr([])},i,n,o.providers)));var t,n,o,r,i});default:return ao("Autocompleter.Item",Np,t).fold(rh,function(t){return vt.some(function(e,n,t,o,r,i,u,a){void 0===a&&(a=!0);var c=Ev({presets:o,textContent:vt.none(),htmlContent:t?e.text.map(function(t){return Av(t,n)}):vt.none(),ariaLabel:e.text,iconContent:e.icon,shortcutContent:vt.none(),checkMark:vt.none(),caret:vt.none(),value:e.value},u.providers,a,e.icon);return yv({data:xv(e),disabled:e.disabled,getApi:rt({}),onAction:function(t){return r(e.value,e.meta)},onSetup:rt(st),triggersSubmenu:!1,itemBehaviours:Dv(e.meta,u)},c,i,u.providers)}(t,u,n,"normal",a,c,s,o))})}}))}function Gb(t,e,n,o,r){var i=oh(e),u=nt(B(e,function(t){function e(t){return function(t,e,n,o,r){function i(t){return r?lt(lt({},t),{shortcut:vt.none(),icon:t.text.isSome()?vt.none():t.icon}):t}var u=n.shared.providers;switch(t.type){case"menuitem":return ao("menuitem",Xh,t).fold(rh,function(t){return vt.some(Lb(i(t),e,u,o))});case"nestedmenuitem":return ao("nestedmenuitem",Yh,t).fold(rh,function(t){return vt.some(zb(i(t),e,u,o,r))});case"togglemenuitem":return ao("togglemenuitem",qh,t).fold(rh,function(t){return vt.some(Ub(i(t),e,u,o))});case"separator":return ao("separatormenuitem",Rp,t).fold(rh,function(t){return vt.some(Hb(t))});case"fancymenuitem":return ao("fancymenuitem",Gh,t).fold(rh,function(t){return jb(i(t),n)});default:return console.error("Unknown item in general menu",t),vt.none()}}(t,n,o,r?!Tt(t,"text"):i,r)}return"nestedmenuitem"===t.type&&t.getSubmenuItems().length<=0?e(lt(lt({},t),{disabled:!0})):e(t)}));return(r?ih:uh)(t,i,u,1,"normal")}function Xb(t){return ip.singleData(t.value,t)}function Yb(t,e,n){return Ru(t,e,n).isSome()}function qb(n,o){var r=null;return{cancel:function(){null!==r&&(clearTimeout(r),r=null)},schedule:function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];r=setTimeout(function(){n.apply(null,t),r=null},o)}}}function Kb(t){var e=t.raw;return void 0===e.touches||1!==e.touches.length?vt.none():vt.some(e.touches[0])}function Jb(){return ln().browser.isFirefox()}function $b(e,t){var n,o,r,i,u,a,c,s,l,f=lt({stopBackspace:!0},t),d=(u=f,a=gc(),c=Po(!1),s=qb(function(t){u.triggerEvent(Pi(),t),c.set(!0)},400),l=lr([{key:si(),value:function(n){return Kb(n).each(function(t){s.cancel();var e={x:t.clientX,y:t.clientY,target:n.target};s.schedule(n),c.set(!1),a.set(e)}),vt.none()}},{key:li(),value:function(t){return s.cancel(),Kb(t).each(function(i){a.on(function(t){var e=i,n=t,o=Math.abs(e.clientX-n.x),r=Math.abs(e.clientY-n.y);(5<o||5<r)&&a.clear()})}),vt.none()}},{key:fi(),value:function(e){return s.cancel(),a.get().filter(function(t){return zt(t.target,e.target)}).map(function(t){return c.get()?(e.prevent(),!1):u.triggerEvent(Ni(),e)})}}]),{fireIfReady:function(e,t){return tt(l,t).bind(function(t){return t(e)})}}),m=B(["touchstart","touchmove","touchend","touchcancel","gesturestart","mousedown","mouseup","mouseover","mousemove","mouseout","click"].concat(["selectstart","input","contextmenu","change","transitionend","transitioncancel","drag","dragstart","dragend","dragenter","dragleave","dragover","drop","keyup"]),function(t){return pc(e,t,function(e){d.fireIfReady(e,t).each(function(t){t&&e.kill()}),f.triggerEvent(t,e)&&e.kill()})}),g=gc(),p=pc(e,"paste",function(e){d.fireIfReady(e,"paste").each(function(t){t&&e.kill()}),f.triggerEvent("paste",e)&&e.kill(),g.set(setTimeout(function(){f.triggerEvent(Mi(),e)},0))}),h=pc(e,"keydown",function(t){var e;f.triggerEvent("keydown",t)?t.kill():!f.stopBackspace||(e=t).raw.which!==vd[0]||wt(["input","textarea"],Ft(e.target))||Yb(e.target,'[contenteditable="true"]')||t.prevent()}),v=(n=e,o=function(t){f.triggerEvent("focusin",t)&&t.kill()},Jb()?hc(n,"focus",o):pc(n,"focusin",o)),b=gc(),y=(r=e,i=function(t){f.triggerEvent("focusout",t)&&t.kill(),b.set(setTimeout(function(){f.triggerEvent(Bi(),t)},0))},Jb()?hc(r,"blur",i):pc(r,"focusout",i));return{unbind:function(){St(m,function(t){t.unbind()}),h.unbind(),v.unbind(),y.unbind(),p.unbind(),g.on(clearTimeout),b.on(clearTimeout)}}}function Qb(t,e){return Po(tt(t,"target").getOr(e))}function Zb(t,o,e,n,r,i){var u,a,c=t(o,n),s=(u=Po(!1),a=Po(!1),{stop:function(){u.set(!0)},cut:function(){a.set(!0)},isStopped:u.get,isCut:a.get,event:e,setSource:r.set,getSource:r.get});return c.fold(function(){return i.logEventNoHandlers(o,n),ay.complete()},function(e){var n=e.descHandler;return Ur(n)(s),s.isStopped()?(i.logEventStopped(o,e.element,n.purpose),ay.stopped()):s.isCut()?(i.logEventCut(o,e.element,n.purpose),ay.complete()):Yt(e.element).fold(function(){return i.logNoParent(o,e.element,n.purpose),ay.complete()},function(t){return i.logEventResponse(o,e.element,n.purpose),ay.resume(t)})})}function ty(){function r(t){Rr(t.element).each(function(t){delete a[t],i.unregisterId(t)})}var u,i=(u={},{registerId:function(r,i,t){J(t,function(t,e){var n,o=void 0!==u[e]?u[e]:{};o[i]={cHandler:C.apply(void 0,[(n=t).handler].concat(r)),purpose:n.purpose},u[e]=o})},unregisterId:function(n){J(u,function(t,e){Tt(t,n)&&delete t[n]})},filterByType:function(t){return tt(u,t).map(function(t){return $(t,function(t,e){return{id:e,descHandler:t}})}).getOr([])},find:function(t,e,n){return tt(u,e).bind(function(o){return mr(n,function(t){return e=o,Rr(n=t).bind(function(t){return tt(e,t)}).map(function(t){return{element:n,descHandler:t}});var e,n},t)})}}),a={};return{find:function(t,e,n){return i.find(t,e,n)},filter:function(t){return i.filterByType(t)},register:function(t){var n,o=Rr((n=t).element).getOrThunk(function(){return t=n.element,e=Ir(du+"uid-"),gu(t,e),e;var t,e});et(a,o)&&function(t){var e=a[o];if(e!==t)throw new Error('The tagId "'+o+'" is already used by: '+Fr(e.element)+"\nCannot use it for: "+Fr(t.element)+"\nThe conflicting element is"+(vn(e.element)?" ":" not ")+"already in the DOM");r(t)}(t),i.registerId([t],o,t.events),a[o]=t},unregister:r,getById:function(t){return tt(a,t)}}}function ey(n){function o(e){return Yt(n.element).fold(D,function(t){return zt(e,t)})}function s(t,e){return i.find(o,t,e)}function r(e){var t=i.filter(Fi());St(t,function(t){Ur(t.descHandler)(e)})}var i=ty(),t=$b(n.element,{triggerEvent:function(e,n){return zu(e,n.target,function(t){return sy(s,e,n,n.target,t)})}}),u={debugInfo:rt("real"),triggerEvent:function(e,n,o){zu(e,n,function(t){return sy(s,e,o,n,t)})},triggerFocus:function(a,c){Rr(a).fold(function(){ka(a)},function(t){zu(Ai(),a,function(t){var e,n,o=s,r=Ai(),i=t,u=Qb(e={originator:c,kill:st,prevent:st,target:a},n=a);return Zb(o,r,e,n,u,i),!1})})},triggerEscape:function(t,e){u.triggerEvent("keydown",t.element,e.event)},getByUid:function(t){return g(t)},getByDom:function(t){return p(t)},build:Tu,addToGui:function(t){c(t)},removeFromGui:function(t){l(t)},addToWorld:function(t){e(t)},removeFromWorld:function(t){a(t)},broadcast:function(t){f(t)},broadcastOn:function(t,e){d(t,e)},broadcastEvent:function(t,e){m(t,e)},isConnected:D},e=function(t){t.connect(u),Xe(t.element)||(i.register(t),St(t.components(),e),u.triggerEvent(Li(),t.element,{target:t.element}))},a=function(t){Xe(t.element)||(St(t.components(),a),i.unregister(t)),t.disconnect()},c=function(t){Ns(n,t)},l=function(t){Vs(t)},f=function(t){r({universal:!0,data:t})},d=function(t,e){r({universal:!1,channels:t,data:e})},m=function(t,e){var n,o,r=i.filter(t);return o={stop:function(){n.set(!0)},cut:st,isStopped:(n=Po(!1)).get,isCut:T,event:e,setSource:_("Cannot set source of a broadcasted event"),getSource:_("Cannot get source of a broadcasted event")},St(r,function(t){Ur(t.descHandler)(o)}),o.isStopped()},g=function(t){return i.getById(t).fold(function(){return Nn.error(new Error('Could not find component with uid: "'+t+'" in system.'))},Nn.value)},p=function(t){var e=Rr(t).getOr("not found");return g(e)};return e(n),{root:n,element:n.element,destroy:function(){t.unbind(),En(n.element)},add:c,remove:l,getByUid:g,getByDom:p,addToWorld:e,removeFromWorld:a,broadcast:f,broadcastOn:d,broadcastEvent:m}}function ny(t,e,n,o){var r=vy(t,e,n,o);return my.sketch(r)}function oy(t,e){return my.parts.label({dom:{tag:"label",classes:["tox-label"],innerHtml:e.translate(t)}})}function ry(t){return ec([Vg.config({onFocus:t.selectOnFocus?function(t){var e=t.element,n=Qr(e);e.dom.setSelectionRange(0,n.length)}:st})])}function iy(t){return{tag:t.tag,attributes:lt({type:"text"},t.inputAttributes),styles:t.inputStyles,classes:t.inputClasses}}(Db=Eb={})[Db.ContentFocus=0]="ContentFocus",Db[Db.UiFocus=1]="UiFocus";function uy(f,c){function n(){return r.get().isSome()}function s(){n()&&up.hide(d)}var o,t,r=gc(),l=Po(!1),d=Tu(up.sketch({dom:{tag:"div",classes:["tox-autocompleter"]},components:[],fireDismissalEventInstead:{},inlineBehaviours:ec([mm("dismissAutocompleter",[Cr(Yi(),function(){return m()})])]),lazySink:c.getSink})),m=function(){var t;n()&&(t=r.get().map(function(t){return t.element}),Bp(t.getOr(Mt.fromDom(f.selection.getNode()))).each(Fe),s(),r.clear(),l.set(!1))},u=Rt(function(){return n=dt(f.ui.registry.getAll().popups,function(t){return ao("Autocompleter",Pp,t).fold(function(t){throw new Error(ur(t))},h)}),t=$(n,function(t){return t.ch}),e={},St(t,function(t){e[t]={}}),o=Ct(e),r=Z(n),{dataset:n,triggerChars:o,lookupByChar:function(e){return F(r,function(t){return t.ch===e})}};var t,e,n,o,r}),g=function(t){var e=t;r.get().map(function(t){return kp(f.dom,f.selection.getRng(),t.triggerChar).bind(function(t){return Tp(f,u,t,e)})}).getOrThunk(function(){return e=f,t=(n=u)(),o=e.selection.getRng(),r=e.dom,i=o,K(t.triggerChars,function(t){return kp(r,i,t)}).bind(function(t){return Tp(e,n,t)});var e,n,t,o,r,i}).fold(m,function(a){var t,e=a.context;n()||(t=yp(f,e.range),r.set({triggerChar:e.triggerChar,element:t,matchLength:e.text.length}),l.set(!1)),a.lookupData.then(function(u){r.get().map(function(t){var e,n,o,r,i=a.context;t.triggerChar===i.triggerChar&&(n=i.triggerChar,r=K(o=u,function(t){return vt.from(t.columns)}).getOr(1),0<(e=H(o,function(i){return Wb(i.items,i.matchText,function(o,r){var t=f.selection.getRng();kp(f.dom,t,n).fold(function(){return console.error("Lost context. Cursor probably moved")},function(t){var e=t.range,n={hide:function(){m()},reload:function(t){s(),g(t)}};l.set(!0),i.onAction(n,e,o,r),l.set(!1)})},r,Sh.BUBBLE_TO_SANDBOX,c,i.highlightOn)})).length?function(t,e,n,o){t.matchLength=e.text.length;var r,i,u,a,c,s,l=K(n,function(t){return vt.from(t.columns)}).getOr(1);up.showAt(d,tp.sketch((r=uh("autocompleter-value",!0,o,l,"normal"),i=l,a=((u=Eb.ContentFocus)===Eb.ContentFocus?jl:Ul)(),c=_b(i,"normal"),s=Qp("normal"),{dom:r.dom,components:r.components,items:r.items,value:r.value,markers:{selectedItem:s.selectedItem,item:s.item},movement:c,fakeFocus:u===Eb.ContentFocus,focusManager:a,menuBehaviours:Kh("auto"!==i?[]:[ou(function(o,t){ah(o,4,s.item).each(function(t){var e=t.numColumns,n=t.numRows;Fg.setGridSize(o,n,e)})})])})),{anchor:{type:"node",root:Mt.fromDom(f.getBody()),node:vt.from(t.element)}}),up.getContent(d).each(hd.highlightFirst)}(t,i,u,e):(10<=i.text.length-t.matchLength?m:s)())})})})},e={onKeypress:vp(function(t){27!==t.which&&g()},50),cancelIfNecessary:m,isMenuOpen:function(){return up.isOpen(d)},isActive:n,isProcessingAction:l.get,getView:function(){return up.getContent(d)}};function i(t,e){br(t,xi(),{raw:e})}!1===f.hasPlugin("rtc")&&(o=e,(t=f).on("keypress compositionend",o.onKeypress.throttle),t.on("remove",o.onKeypress.cancel),t.on("keydown",function(e){function t(){return o.getView().bind(hd.getHighlighted)}8===e.which&&o.onKeypress.throttle(e),o.isActive()&&(27===e.which&&o.cancelIfNecessary(),o.isMenuOpen()?13===e.which?(t().each(yr),e.preventDefault()):40===e.which?(t().fold(function(){o.getView().each(hd.highlightFirst)},function(t){i(t,e)}),e.preventDefault(),e.stopImmediatePropagation()):37!==e.which&&38!==e.which&&39!==e.which||t().each(function(t){i(t,e),e.preventDefault(),e.stopImmediatePropagation()}):13!==e.which&&38!==e.which&&40!==e.which||o.cancelIfNecessary())}),t.on("NodeChange",function(t){o.isActive()&&!o.isProcessingAction()&&Bp(Mt.fromDom(t.element)).isNone()&&o.cancelIfNecessary()}))}var ay=Vo([{stopped:[]},{resume:["element"]},{complete:[]}]),cy=function(e,n,o,t,r,i){return Zb(e,n,o,t,r,i).fold(D,function(t){return cy(e,n,o,t,r,i)},T)},sy=function(t,e,n,o,r){var i=Qb(n,o);return cy(t,e,n,o,i,r)},ly=kl({name:"Container",factory:function(t){var e=t.dom,n=e.attributes,o=A(e,["attributes"]);return{uid:t.uid,dom:lt({tag:"div",attributes:lt({role:"presentation"},n)},o),components:t.components,behaviours:tl(t.containerBehaviours),events:t.events,domModification:t.domModification,eventOrder:t.eventOrder}},configFields:[Eo("components",[]),Zs("containerBehaviours",[]),Eo("events",{}),Eo("domModification",{}),Eo("eventOrder",{})]}),fy=rt([Eo("prefix","form-field"),Zs("fieldBehaviours",[cd,Df])]),dy=rt([Qf({schema:[mo("dom")],name:"label"}),Qf({factory:{sketch:function(t){return{uid:t.uid,dom:{tag:"span",styles:{display:"none"},attributes:{"aria-hidden":"true"},innerHtml:t.text}}}},schema:[mo("text")],name:"aria-descriptor"}),Jf({factory:{sketch:function(t){var n,o,e=(n=["factory"],o={},J(t,function(t,e){wt(n,e)||(o[e]=t)}),o);return t.factory.sketch(e)}},schema:[mo("factory")],name:"field"})]),my=Cl({name:"FormField",configFields:fy(),partFields:dy(),factory:function(r,t,e,n){var o=el(r.fieldBehaviours,[cd.config({find:function(t){return ml(t,r,"field")}}),Df.config({store:{mode:"manual",getValue:function(t){return cd.getCurrent(t).bind(Df.getValue)},setValue:function(t,e){cd.getCurrent(t).each(function(t){Df.setValue(t,e)})}}})]),i=nu([ou(function(t,e){var o=pl(t,r,["label","field","aria-descriptor"]);o.field().each(function(n){var e=Ir(r.prefix);o.label().each(function(t){oe(t.element,"for",e),oe(n.element,"id",e)}),o["aria-descriptor"]().each(function(t){var e=Ir(r.prefix);oe(t.element,"id",e),oe(n.element,"aria-describedby",e)})})})]);return{uid:r.uid,dom:r.dom,components:t,behaviours:o,events:i,apis:{getField:function(t){return ml(t,r,"field")},getLabel:function(t){return ml(t,r,"label")}}}},apis:{getField:function(t,e){return t.getField(e)},getLabel:function(t,e){return t.getLabel(e)}}}),gy=Object.freeze({__proto__:null,exhibit:function(t,e){return zr({attributes:lr([{key:e.tabAttr,value:"true"}])})}}),py=xa({fields:[Eo("tabAttr","data-alloy-tabstop")],name:"tabstopping",active:gy}),hy=tinymce.util.Tools.resolve("tinymce.html.Entities"),vy=function(t,e,n,o){return{dom:by(n),components:t.toArray().concat([e]),fieldBehaviours:ec(o)}},by=function(t){return{tag:"div",classes:["tox-form__group"].concat(t)}},yy=Ir("form-component-change"),xy=Ir("form-close"),wy=Ir("form-cancel"),Sy=Ir("form-action"),ky=Ir("form-submit"),Cy=Ir("form-block"),Oy=Ir("form-unblock"),_y=Ir("form-tabchange"),Ty=Ir("form-resize"),Ey=rt([wo("data"),Eo("inputAttributes",{}),Eo("inputStyles",{}),Eo("tag","input"),Eo("inputClasses",[]),Ju("onSetValue"),Eo("styles",{}),Eo("eventOrder",{}),Zs("inputBehaviours",[Df,Vg]),Eo("selectOnFocus",!0)]),Dy=kl({name:"Input",configFields:Ey(),factory:function(t,e){return{uid:t.uid,dom:iy(t),components:[],behaviours:lt(lt({},ry(n=t)),el(n.inputBehaviours,[Df.config({store:lt(lt({mode:"manual"},n.data.map(function(t){return{initialValue:t}}).getOr({})),{getValue:function(t){return Qr(t.element)},setValue:function(t,e){Qr(t.element)!==e&&Zr(t.element,e)}}),onSetValue:n.onSetValue})])),eventOrder:t.eventOrder};var n}}),Ay={},By={exports:Ay};function My(t){setTimeout(function(){throw t},0)}function Fy(t){var e=Ft(t);return wt(Xy,e)}function Iy(t,e){qr(e.getRoot(t).getOr(t.element),e.invalidClass),e.notify.each(function(e){Fy(t.element)&&oe(t.element,"aria-invalid",!1),e.getContainer(t).each(function(t){Mr(t,e.validHtml)}),e.onValid(t)})}function Ry(e,t,n,o){Yr(t.getRoot(e).getOr(e.element),t.invalidClass),t.notify.each(function(t){Fy(e.element)&&oe(e.element,"aria-invalid",!0),t.getContainer(e).each(function(t){Mr(t,o)}),t.onInvalid(e,o)})}function Ny(e,t,n){return t.validator.fold(function(){return Gy(Nn.value(!0))},function(t){return t.validate(e)})}function Py(e,n,t){return n.notify.each(function(t){t.onValidate(e)}),Ny(e,n).map(function(t){return e.getSystem().isConnected()?t.fold(function(t){return Ry(e,n,0,t),Nn.error(t)},function(t){return Iy(e,n),Nn.value(t)}):Nn.error("No longer in system")})}!function(){var t=this,e=function(){var t,e,n,o={exports:{}};function r(){}function i(t){if("object"!=typeof this)throw new TypeError("Promises must be constructed via new");if("function"!=typeof t)throw new TypeError("not a function");this._state=0,this._handled=!1,this._value=void 0,this._deferreds=[],f(t,this)}function u(n,o){for(;3===n._state;)n=n._value;0!==n._state?(n._handled=!0,i._immediateFn(function(){var t,e=1===n._state?o.onFulfilled:o.onRejected;if(null!==e){try{t=e(n._value)}catch(t){return void c(o.promise,t)}a(o.promise,t)}else(1===n._state?a:c)(o.promise,n._value)})):n._deferreds.push(o)}function a(e,t){try{if(t===e)throw new TypeError("A promise cannot be resolved with itself.");if(t&&("object"==typeof t||"function"==typeof t)){var n=t.then;if(t instanceof i)return e._state=3,e._value=t,void s(e);if("function"==typeof n)return void f((o=n,r=t,function(){o.apply(r,arguments)}),e)}e._state=1,e._value=t,s(e)}catch(t){c(e,t)}var o,r}function c(t,e){t._state=2,t._value=e,s(t)}function s(t){2===t._state&&0===t._deferreds.length&&i._immediateFn(function(){t._handled||i._unhandledRejectionFn(t._value)});for(var e=0,n=t._deferreds.length;e<n;e++)u(t,t._deferreds[e]);t._deferreds=null}function l(t,e,n){this.onFulfilled="function"==typeof t?t:null,this.onRejected="function"==typeof e?e:null,this.promise=n}function f(t,e){var n=!1;try{t(function(t){n||(n=!0,a(e,t))},function(t){n||(n=!0,c(e,t))})}catch(t){if(n)return;n=!0,c(e,t)}}t=o,e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=setTimeout,i.prototype.catch=function(t){return this.then(null,t)},i.prototype.then=function(t,e){var n=new this.constructor(r);return u(this,new l(t,e,n)),n},i.all=function(t){var a=Array.prototype.slice.call(t);return new i(function(r,i){if(0===a.length)return r([]);for(var u=a.length,t=0;t<a.length;t++)!function e(n,t){try{if(t&&("object"==typeof t||"function"==typeof t)){var o=t.then;if("function"==typeof o)return o.call(t,function(t){e(n,t)},i),0}a[n]=t,0==--u&&r(a)}catch(t){i(t)}}(t,a[t])})},i.resolve=function(e){return e&&"object"==typeof e&&e.constructor===i?e:new i(function(t){t(e)})},i.reject=function(n){return new i(function(t,e){e(n)})},i.race=function(r){return new i(function(t,e){for(var n=0,o=r.length;n<o;n++)r[n].then(t,e)})},i._immediateFn="function"==typeof setImmediate?function(t){setImmediate(t)}:function(t){n(t,0)},i._unhandledRejectionFn=function(t){"undefined"!=typeof console&&console&&console.warn("Possible Unhandled Promise Rejection:",t)},i._setImmediateFn=function(t){i._immediateFn=t},i._setUnhandledRejectionFn=function(t){i._unhandledRejectionFn=t},t.exports?t.exports=i:e.Promise||(e.Promise=i);var d=o.exports;return{boltExport:("undefined"!=typeof window?window:Function("return this;")()).Promise||d}};"object"==typeof Ay&&void 0!==By?By.exports=e():(t="undefined"!=typeof globalThis?globalThis:t||self).EphoxContactWrapper=e()}();var Vy,Hy,Ly=By.exports.boltExport,zy=function(t){function o(t){r()?i(t):e.push(t)}var n=vt.none(),e=[],r=function(){return n.isSome()},i=function(e){n.each(function(t){setTimeout(function(){e(t)},0)})};return t(function(t){r()||(n=vt.some(t),St(e,i),e=[])}),{get:o,map:function(n){return zy(function(e){o(function(t){e(n(t))})})},isReady:r}},Uy={nu:zy,pure:function(e){return zy(function(t){t(e)})}},jy=function(n){function t(t){n().then(t,My)}return{map:function(t){return jy(function(){return n().then(t)})},bind:function(e){return jy(function(){return n().then(function(t){return e(t).toPromise()})})},anonBind:function(t){return jy(function(){return n().then(function(){return t.toPromise()})})},toLazy:function(){return Uy.nu(t)},toCached:function(){var t=null;return jy(function(){return t=null===t?n():t})},toPromise:n,get:t}},Wy=function(t){return jy(function(){return new Ly(t)})},Gy=function(t){return jy(function(){return Ly.resolve(t)})},Xy=["input","textarea"],Yy=Object.freeze({__proto__:null,markValid:Iy,markInvalid:Ry,query:Ny,run:Py,isInvalid:function(t,e){return Kr(e.getRoot(t).getOr(t.element),e.invalidClass)}}),qy=Object.freeze({__proto__:null,events:function(e,t){return e.validator.map(function(t){return nu([Cr(t.onEvent,function(t){Py(t,e).get(h)})].concat(t.validateOnLoad?[ou(function(t){Py(t,e).get(st)})]:[]))}).getOr({})}}),Ky=xa({fields:[mo("invalidClass"),Eo("getRoot",vt.none),To("notify",[Eo("aria","alert"),Eo("getContainer",vt.none),Eo("validHtml",""),Ju("onValid"),Ju("onInvalid"),Ju("onValidate")]),To("validator",[mo("validate"),Eo("onEvent","input"),Eo("validateOnLoad",!0)])],name:"invalidating",active:qy,apis:Yy,extra:{validation:function(n){return function(t){var e=Df.getValue(t);return Gy(n(e))}}}}),Jy=Object.freeze({__proto__:null,getCoupled:function(t,e,n,o){return n.getOrCreate(t,e,o)}}),$y=xa({fields:[go("others",uo(Nn.value,Zo()))],name:"coupling",apis:Jy,state:Object.freeze({__proto__:null,init:function(){var i={},t=rt({});return wu({readState:t,getOrCreate:function(n,o,r){var t=Ct(o.others);if(t)return tt(i,r).getOrThunk(function(){var t=tt(o.others,r).getOrDie("No information found for coupled component: "+r)(n),e=n.getSystem().build(t);return i[r]=e});throw new Error("Cannot find coupled component: "+r+". Known coupled components: "+JSON.stringify(t,null,2))}})}})}),Qy=rt("sink"),Zy=rt(Qf({name:Qy(),overrides:rt({dom:{tag:"div"},behaviours:ec([ff.config({useFixed:D})]),events:nu([Dr(xi()),Dr(mi()),Dr(Ci())])})}));function tx(t,e){var n=t.getHotspot(e).getOr(e),o=t.getAnchorOverrides();return t.layouts.fold(function(){return{type:"hotspot",hotspot:n,overrides:o}},function(t){return{type:"hotspot",hotspot:n,overrides:o,layouts:t}})}function ex(t,e,n,o,r,i,u){var a,c=tx(t,n),s=n,l=o,f=r,d=u,m=e,g=(0,(a=t).fetch)(s).map(m),p=mw(s,a);return g.map(function(t){return t.bind(function(t){return vt.from(ip.sketch(lt(lt({},f.menu()),{uid:pu(""),data:t,highlightImmediately:d===Vy.HighlightFirst,onOpenMenu:function(t,e){var n=p().getOrDie();ff.position(n,e,{anchor:c}),bf.decloak(l)},onOpenSubmenu:function(t,e,n){var o=p().getOrDie();ff.position(o,n,{anchor:{type:"submenu",item:e}}),bf.decloak(l)},onRepositionMenu:function(t,e,n){var o=p().getOrDie();ff.position(o,e,{anchor:c}),St(n,function(t){ff.position(o,t.triggeredMenu,{anchor:{type:"submenu",item:t.triggeringItem}})})},onEscape:function(){return Vg.focus(s),bf.close(l),vt.some(!0)}})))})}).map(function(t){return t.fold(function(){bf.isOpen(o)&&bf.close(o)},function(t){bf.cloak(o),bf.open(o,t),i(o)}),o})}function nx(t,e,n,o,r,i){var u=$y.getCoupled(n,"sandbox");return(bf.isOpen(u)?function(t,e,n,o,r,i,u){return bf.close(o),Gy(o)}:ex)(t,e,n,u,o,r,i)}function ox(t){bf.getState(t).each(function(t){ip.repositionMenus(t)})}function rx(s,l,f){var d=Nu(),t=mw(l,s);return{dom:{tag:"div",classes:s.sandboxClasses,attributes:{id:d.id,role:"listbox"}},behaviours:Bf(s.sandboxBehaviours,[Df.config({store:{mode:"memory",initialValue:l}}),bf.config({onOpen:function(t,e){var n,o,r,i,u,a,c=tx(s,l);d.link(l.element),s.matchWidth&&(n=c.hotspot,o=e,r=s.useMinWidth,u=cd.getCurrent(o).getOr(o),a=Ce(n.element),r?fe(u.element,"min-width",a+"px"):(i=u.element,On.set(i,a))),s.onOpen(c,t,e),void 0!==f&&void 0!==f.onOpen&&f.onOpen(t,e)},onClose:function(t,e){d.unlink(l.element),void 0!==f&&void 0!==f.onClose&&f.onClose(t,e)},isPartOf:function(t,e,n){return Hu(e,n)||Hu(l,n)},getAttachPoint:function(){return t().getOrDie()}}),cd.config({find:function(t){return bf.getState(t).bind(function(t){return cd.getCurrent(t)})}}),ic.config({channels:lt(lt({},Xs({isExtraPart:T})),Ys({doReposition:ox}))})])}}function ix(t){ox($y.getCoupled(t,"sandbox"))}function ux(){return[Eo("sandboxClasses",[]),Af("sandboxBehaviours",[cd,ic,bf,Df])]}function ax(e){return Qf({name:e+"-edge",overrides:function(t){return t.model.manager.edgeActions[e].fold(function(){return{}},function(o){return{events:nu([Or(si(),function(t,e,n){return o(t,n)},[t]),Or(mi(),function(t,e,n){return o(t,n)},[t]),Or(gi(),function(t,e,n){n.mouseIsDown.get()&&o(t,n)},[t])])}})}})}function cx(t){var e=t.event.raw;return-1===e.type.indexOf("touch")?void 0!==e.clientX?vt.some(e).map(function(t){return kn(t.clientX,t.clientY)}):vt.none():void 0!==e.touches&&1===e.touches.length?vt.some(e.touches[0]).map(function(t){return kn(t.clientX,t.clientY)}):vt.none()}function sx(t){return t.model.minX}function lx(t){return t.model.minY}function fx(t){return t.model.minX-1}function dx(t){return t.model.minY-1}function mx(t){return t.model.maxX}function gx(t){return t.model.maxY}function px(t){return t.model.maxX+1}function hx(t){return t.model.maxY+1}function vx(t,e,n){return e(t)-n(t)}function bx(t){return vx(t,mx,sx)}function yx(t){return vx(t,gx,lx)}function xx(t){return bx(t)/2}function wx(t){return yx(t)/2}function Sx(t){return t.stepSize}function kx(t){return t.snapToGrid}function Cx(t){return t.snapStart}function Ox(t){return t.rounded}function _x(t,e){return void 0!==t[e+"-edge"]}function Tx(t){return _x(t,"left")}function Ex(t){return _x(t,"right")}function Dx(t){return _x(t,"top")}function Ax(t){return _x(t,"bottom")}function Bx(t){return t.model.value.get()}function Mx(t,e){return{x:t,y:e}}function Fx(t,e){br(t,Aw(),{value:e})}function Ix(t,e,n,o){return t<e?t:n<t?n:t===e?e-1:Math.max(e,t-o)}function Rx(t,e,n,o){return n<t?t:t<e?e:t===n?n+1:Math.min(n,t+o)}function Nx(t,e,n){return Math.max(e,Math.min(n,t))}function Px(t){var e=t.min,n=t.max,o=t.range,r=t.value,i=t.step,u=t.snap,a=t.snapStart,c=t.rounded,s=t.hasMinEdge,l=t.hasMaxEdge,f=t.minBound,d=t.maxBound,m=t.screenRange,g=s?e-1:e,p=l?n+1:n;if(r<f)return g;if(d<r)return p;var h,v,b,y,x,w=Nx((x=f,Math.min(d,Math.max(r,x))-x)/m*o+e,g,p);return u&&e<=w&&w<=n?(h=w,v=e,b=n,y=i,a.fold(function(){var t=Math.round((h-v)/y)*y;return Nx(v+t,v-1,b+1)},function(t){var e=Math.round((h-t)%y/y),n=Math.floor((h-t)/y),o=Math.floor((b-t)/y),r=Math.min(o,n+e);return Math.max(t,t+r*y)})):c?Math.round(w):w}function Vx(t){var e=t.min,n=t.max,o=t.range,r=t.value,i=t.hasMinEdge,u=t.hasMaxEdge,a=t.maxBound,c=t.maxOffset,s=t.centerMinEdge,l=t.centerMaxEdge;return r<e?i?0:s:n<r?u?a:l:(r-e)/o*c}function Hx(t){return t.element.dom.getBoundingClientRect()}function Lx(t){return Hx(t)[Bw]}function zx(t){return Hx(t).right}function Ux(t){return Hx(t).top}function jx(t){return Hx(t).bottom}function Wx(t){return Hx(t).width}function Gx(t){return Hx(t).height}function Xx(t,e){var n=Hx(t),o=Hx(e);return(n[Bw]+n.right)/2-o[Bw]}function Yx(t,e){var n=Hx(t),o=Hx(e);return(n.top+n.bottom)/2-o.top}function qx(t,e){br(t,Aw(),{value:e})}function Kx(t,e,n){return Px({min:sx(e),max:mx(e),range:bx(e),value:n,step:Sx(e),snap:kx(e),snapStart:Cx(e),rounded:Ox(e),hasMinEdge:Tx(e),hasMaxEdge:Ex(e),minBound:Lx(t),maxBound:zx(t),screenRange:Wx(t)})}function Jx(r){return function(t,e){return qx(t,{x:o=(0<r?Rx:Ix)(Bx(n=e).x,sx(n),mx(n),Sx(n))}),vt.some(o).map(D);var n,o}}function $x(t,e,n,o,r,i){var u,a,c,s,l,f,d,m,g=(a=i,c=n,s=o,l=r,f=Wx(u=e),d=s.bind(function(t){return vt.some(Xx(t,u))}).getOr(0),m=l.bind(function(t){return vt.some(Xx(t,u))}).getOr(f),Vx({min:sx(a),max:mx(a),range:bx(a),value:c,hasMinEdge:Tx(a),hasMaxEdge:Ex(a),minBound:Lx(u),minOffset:0,maxBound:zx(u),maxOffset:f,centerMinEdge:d,centerMaxEdge:m}));return Lx(e)-Lx(t)+g}function Qx(t,e){br(t,Aw(),{value:e})}function Zx(t,e,n){return Px({min:lx(e),max:gx(e),range:yx(e),value:n,step:Sx(e),snap:kx(e),snapStart:Cx(e),rounded:Ox(e),hasMinEdge:Dx(e),hasMaxEdge:Ax(e),minBound:Ux(t),maxBound:jx(t),screenRange:Gx(t)})}function t0(r){return function(t,e){return Qx(t,{y:o=(0<r?Rx:Ix)(Bx(n=e).y,lx(n),gx(n),Sx(n))}),vt.some(o).map(D);var n,o}}function e0(t,e,n,o,r,i){var u,a,c,s,l,f,d,m,g=(a=i,c=n,s=o,l=r,f=Gx(u=e),d=s.bind(function(t){return vt.some(Yx(t,u))}).getOr(0),m=l.bind(function(t){return vt.some(Yx(t,u))}).getOr(f),Vx({min:lx(a),max:gx(a),range:yx(a),value:c,hasMinEdge:Dx(a),hasMaxEdge:Ax(a),minBound:Ux(u),minOffset:0,maxBound:jx(u),maxOffset:f,centerMinEdge:d,centerMaxEdge:m}));return Ux(e)-Ux(t)+g}function n0(t,e){br(t,Aw(),{value:e})}function o0(t,e){return{x:t,y:e}}function r0(u,a){return function(t,e){return o=e,r=0<u?Rx:Ix,n0(t,o0(i=(n=a)?Bx(o).x:r(Bx(o).x,sx(o),mx(o),Sx(o)),n?r(Bx(o).y,lx(o),gx(o),Sx(o)):Bx(o).y)),vt.some(i).map(D);var n,o,r,i}}function i0(t){return"<alloy.field."+t+">"}function u0(f,d,m,g){function p(t,e,n,o,r){var i,u,a=f(uS+"range"),c=[my.parts.label({dom:{tag:"label",innerHtml:n,attributes:{"aria-label":o}}}),my.parts.field({data:r,factory:Dy,inputAttributes:lt({type:"text"},"hex"===e?{"aria-live":"polite"}:{}),inputClasses:[d("textfield")],inputBehaviours:ec([(i=e,u=t,Ky.config({invalidClass:d("invalid"),notify:{onValidate:function(t){br(t,iS,{type:i})},onValid:function(t){br(t,oS,{type:i,value:Df.getValue(t)})},onInvalid:function(t){br(t,rS,{type:i,value:Df.getValue(t)})}},validator:{validate:function(t){var e=Df.getValue(t),n=u(e)?Nn.value(!0):Nn.error(f("aria.input.invalid"));return Gy(n)},validateOnLoad:!1}})),py.config({})]),onSetValue:function(t){Ky.isInvalid(t)&&Ky.run(t).get(st)}})],s="hex"!==e?[my.parts["aria-descriptor"]({text:a})]:[];return{dom:{tag:"div",attributes:{role:"presentation"}},components:c.concat(s)}}function h(t,e){var n=e.red,o=e.green,r=e.blue;Df.setValue(t,{red:n,green:o,blue:r})}function v(t,e){b.getOpt(t).each(function(t){fe(t.element,"background-color","#"+e.value)})}var b=Hm({dom:{tag:"div",classes:[d("rgba-preview")],styles:{"background-color":"white"},attributes:{role:"presentation"}}});return kl({factory:function(){function a(t){return o[t].get()}function c(t,e){o[t].set(e)}function e(t,e){var n=e.event;"hex"!==n.type?c(n.type,vt.none()):g(t)}function n(t,e){var r,n,o,i,u=e.event;"hex"===u.type?function(t,e){m(t);var n=Bv(e);c("hex",vt.some(e));var o=Vv(n);h(t,o),s(o),br(t,Qw,{hex:n}),v(t,n)}(t,u.value):(r=t,n=u.type,o=u.value,i=parseInt(o,10),c(n,vt.some(i)),a("red").bind(function(n){return a("green").bind(function(e){return a("blue").map(function(t){return Rv(n,e,t,1)})})}).each(function(t){var e,n,o=(e=r,n=Iv(t),nS.getField(e,"hex").each(function(t){Vg.isFocused(t)||Df.setValue(e,{hex:n.value})}),n);br(r,Qw,{hex:o}),v(r,o)}))}function t(t){return{label:f(uS+t+".label"),description:f(uS+t+".description")}}function s(t){var e=t.red,n=t.green,o=t.blue;c("red",vt.some(e)),c("green",vt.some(n)),c("blue",vt.some(o))}var o={red:Po(vt.some(255)),green:Po(vt.some(255)),blue:Po(vt.some(255)),hex:Po(vt.some("ffffff"))},r=t("red"),i=t("green"),u=t("blue"),l=t("hex");return Yo(nS.sketch(function(t){return{dom:{tag:"form",classes:[d("rgb-form")],attributes:{"aria-label":f("aria.color.picker")}},components:[t.field("red",my.sketch(p(Nv,"red",r.label,r.description,255))),t.field("green",my.sketch(p(Nv,"green",i.label,i.description,255))),t.field("blue",my.sketch(p(Nv,"blue",u.label,u.description,255))),t.field("hex",my.sketch(p(Mv,"hex",l.label,l.description,"ffffff"))),b.asSpec()],formBehaviours:ec([Ky.config({invalidClass:d("form-invalid")}),mm("rgb-form-events",[Cr(oS,n),Cr(rS,e),Cr(iS,e)])])}}),{apis:{updateHex:function(t,e){var n;Df.setValue(t,{hex:e.value}),h(t,n=Vv(e)),s(n),v(t,e)}}})},name:"RgbForm",configFields:[],apis:{updateHex:function(t,e,n){t.updateHex(e,n)}},extraApis:{}})}function a0(x,w){return kl({name:"ColourPicker",configFields:[mo("dom"),Eo("onValidHex",st),Eo("onInvalidHex",st)],factory:function(t){function e(t,e,n){v.getOpt(t).each(function(t){g.setHue(t,n)})}function n(t,e){b.getOpt(t).each(function(t){m.updateHex(t,e)})}function r(e,n,o,t){var r=o,i=Vv(n);p.paletteRgba.set(i),p.paletteHue.set(r),St(t,function(t){t(e,n,o)})}var o,i,u,a,c,s,l,f,d,m=u0(x,w,t.onValidHex,t.onInvalidHex),g=(l=w,f=$w.parts.spectrum({dom:{tag:"canvas",attributes:{role:"presentation"},classes:[l("sv-palette-spectrum")]}}),d=$w.parts.thumb({dom:{tag:"div",attributes:{role:"presentation"},classes:[l("sv-palette-thumb")],innerHtml:"<div class="+l("sv-palette-inner-thumb")+' role="presentation"></div>'}}),kl({factory:function(t){var e=rt({x:0,y:0}),n=ec([cd.config({find:vt.some}),Vg.config({})]);return $w.sketch({dom:{tag:"div",attributes:{role:"presentation"},classes:[l("sv-palette")]},model:{mode:"xy",getInitialValue:e},rounded:!1,components:[f,d],onChange:function(t,e,n){br(t,tS,{value:n})},onInit:function(t,e,n,o){y(n.element.dom,zv(fb))},sliderBehaviours:n})},name:"SaturationBrightnessPalette",configFields:[],apis:{setHue:function(t,e,n){var o=n;y(e.components()[0].element.dom,zv(Pv(jv(o,100,100))))},setThumb:function(t,e,n){var o=e,r=Wv(Vv(n));$w.setValue(o,{x:r.saturation,y:100-r.value})}},extraApis:{}})),p={paletteRgba:Po(fb),paletteHue:Po(0)},h=Hm((i=$w.parts.spectrum({dom:{tag:"div",classes:[(o=w)("hue-slider-spectrum")],attributes:{role:"presentation"}}}),u=$w.parts.thumb({dom:{tag:"div",classes:[o("hue-slider-thumb")],attributes:{role:"presentation"}}}),$w.sketch({dom:{tag:"div",classes:[o("hue-slider")],attributes:{role:"presentation"}},rounded:!1,model:{mode:"y",getInitialValue:rt({y:0})},components:[i,u],sliderBehaviours:ec([Vg.config({})]),onChange:function(t,e,n){br(t,Zw,{value:n})}}))),v=Hm(g.sketch({})),b=Hm(m.sketch({}));function y(t,e){var n,o,r=t.width,i=t.height,u=t.getContext("2d");null!==u&&(u.fillStyle=e,u.fillRect(0,0,r,i),(n=u.createLinearGradient(0,0,r,0)).addColorStop(0,"rgba(255,255,255,1)"),n.addColorStop(1,"rgba(255,255,255,0)"),u.fillStyle=n,u.fillRect(0,0,r,i),(o=u.createLinearGradient(0,0,0,i)).addColorStop(0,"rgba(0,0,0,0)"),o.addColorStop(1,"rgba(0,0,0,1)"),u.fillStyle=o,u.fillRect(0,0,r,i))}return{uid:t.uid,dom:t.dom,components:[v.asSpec(),h.asSpec(),b.asSpec()],behaviours:ec([mm("colour-picker-events",[Cr(Qw,(s=[e,function(t,e,n){h.getOpt(t).each(function(t){$w.setValue(t,{y:100-n/360*100})})},function(t,e){v.getOpt(t).each(function(t){g.setThumb(t,e)})}],function(t,e){var n=e.event.hex;r(t,n,Wv(Vv(n)).hue,s)})),Cr(tS,(c=[n],function(t,e){var n=e.event.value,o=p.paletteHue.get();r(t,Gv(jv(o,n.x,100-n.y)),o,c)})),Cr(Zw,(a=[e,n],function(t,e){var n=(100-e.event.value.y)/100*360,o=Wv(p.paletteRgba.get());r(t,Gv(jv(n,o.saturation,o.value)),n,a)}))]),cd.config({find:function(t){return b.getOpt(t)}}),Fg.config({mode:"acyclic"})])}}})}function c0(t){return sS[t]}function s0(t,e,n){return Df.config(Yo({store:{mode:"manual",getValue:e,setValue:n}},t.map(function(t){return{store:{initialValue:t}}}).getOr({})))}function l0(r,i){function e(t,e){e.stop()}function n(t){return function(e,n){St(t,function(t){t(e,n)})}}function o(t,e){var n;gd.isDisabled(t)||(n=e.event.raw,a(t,n.dataTransfer.files))}function u(t,e){var n=e.event.raw.target;a(t,n.files)}function a(t,e){var n,o;Df.setValue(t,(n=e,o=fS.explode(i.getSetting("images_file_types","jpeg,jpg,jpe,jfi,jif,jfif,png,gif,bmp,webp","string")),F(kt(n),function(e){return d(o,function(t){return At(e.name.toLowerCase(),"."+t.toLowerCase())})}))),br(t,yy,{name:r.name})}var c=Hm({dom:{tag:"input",attributes:{type:"file",accept:"image/*"},styles:{display:"none"}},behaviours:ec([mm("input-file-events",[Dr(Ci()),Dr(Ni())])])});return ny(r.label.map(function(t){return oy(t,i)}),my.parts.field({factory:{sketch:function(t){return{uid:t.uid,dom:{tag:"div",classes:["tox-dropzone-container"]},behaviours:ec([pS([]),aw(),gd.config({}),zg.config({toggleClass:"dragenter",toggleOnExecute:!1}),mm("dropzone-events",[Cr("dragenter",n([e,zg.toggle])),Cr("dragleave",n([e,zg.toggle])),Cr("dragover",e),Cr("drop",n([e,o])),Cr(ki(),u)])]),components:[{dom:{tag:"div",classes:["tox-dropzone"],styles:{}},components:[{dom:{tag:"p",innerHtml:i.translate("Drop an image here")}},fp.sketch({dom:{tag:"button",innerHtml:i.translate("Browse for an image"),styles:{position:"relative"},classes:["tox-button","tox-button--secondary"]},components:[c.asSpec()],action:function(t){c.get(t).element.dom.click()},buttonBehaviours:ec([py.config({}),$v(i.isDisabled),pv()])})]}]}}}}),["tox-form__group--stretched"],[])}function f0(t){return{dom:{tag:"div",styles:{width:"1px",height:"1px",outline:"none"},attributes:{tabindex:"0"},classes:t},behaviours:ec([Vg.config({ignore:!0}),py.config({})])}}function d0(t){return{dom:{tag:"div",classes:["tox-navobj"]},components:[f0([hS]),t,f0([vS])],behaviours:ec([cS(1)])}}function m0(t,e){br(t,xi(),{raw:{which:9,shiftKey:e}})}function g0(t,e){var n=e.element;Kr(n,hS)?m0(t,!0):Kr(n,vS)&&m0(t,!1)}function p0(t){return Yb(t,["."+hS,"."+vS].join(","),T)}function h0(t,e){return xS(document.createElement("canvas"),t,e)}function v0(t){var e=h0(t.width,t.height);return yS(e).drawImage(t,0,0),e}function b0(t){return t.naturalWidth||t.width}function y0(t){return t.naturalHeight||t.height}function x0(t,o,r){return o=o||"image/png",S(HTMLCanvasElement.prototype.toBlob)?new Ly(function(e,n){t.toBlob(function(t){t?e(t):n()},o,r)}):(g=t.toDataURL(o,r),new Ly(function(t,e){!function(){var t=g.split(","),e=/data:([^;]+)/.exec(t[0]);if(!e)return vt.none();for(var n=e[1],o=t[1],r=atob(o),i=r.length,u=Math.ceil(i/1024),a=new Array(u),c=0;c<u;++c){for(var s=1024*c,l=Math.min(1024+s,i),f=new Array(l-s),d=s,m=0;d<l;++m,++d)f[m]=r[d].charCodeAt(0);a[c]=new Uint8Array(f)}return vt.some(new Blob(a,{type:n}))}().fold(function(){e("uri is not base64: "+g)},t)}));var g}function w0(t,e,n){function o(e,n){return t.then(function(t){return t.toDataURL(e||"image/png",n)})}return{getType:rt(e.type),toBlob:function(){return Ly.resolve(e)},toDataURL:rt(n),toBase64:function(){return n.split(",")[1]},toAdjustedBlob:function(e,n){return t.then(function(t){return x0(t,e,n)})},toAdjustedDataURL:o,toAdjustedBase64:function(t,e){return o(t,e).then(function(t){return t.split(",")[1]})},toCanvas:function(){return t.then(v0)}}}function S0(e,t){return x0(e,t).then(function(t){return w0(Ly.resolve(e),t,e.toDataURL())})}function k0(e){return n=e,new Ly(function(t){var e=new FileReader;e.onloadend=function(){t(e.result)},e.readAsDataURL(n)}).then(function(t){return w0((a=e,new Ly(function(t,e){function n(){r.removeEventListener("load",i),r.removeEventListener("error",u)}var o=URL.createObjectURL(a),r=new Image,i=function(){n(),t(r)},u=function(){n(),e("Unable to load data of type "+a.type+": "+o)};r.addEventListener("load",i),r.addEventListener("error",u),r.src=o,r.complete&&setTimeout(i,0)}).then(function(t){wS(t);var e=h0(b0(t),y0(t));return yS(e).drawImage(t,0,0),e})),e,t);var a});var n}function C0(t,e,n){var o="string"==typeof t?parseFloat(t):t;return n<o?o=n:o<e&&(o=e),o}function O0(){return[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1]}function _0(t,e){for(var n=[],o=new Array(25),r=0;r<5;r++){for(var i=0;i<5;i++)n[i]=e[i+5*r];for(i=0;i<5;i++){for(var u=0,a=0;a<5;a++)u+=t[i+5*a]*n[a];o[i+5*r]=u}}return o}function T0(e,n){return e.toCanvas().then(function(t){return kS(t,e.getType(),n)})}function E0(n){return function(t,e){return T0(t,n(O0(),e))}}function D0(t,e){void 0===e&&(e=2);var n=Math.pow(10,e),o=Math.round(t*n);return Math.ceil(o/n)}function A0(t){return CS(t)}function B0(t){return TS(t)}function M0(t,e){return ES(t,e)}function F0(t,e){return OS(t,e)}function I0(t,e){return _S(t,e)}function R0(t,e){return o=e,(n=t).toCanvas().then(function(t){return MS(t,n.getType(),o)});var n,o}function N0(t,e){return o=e,(n=t).toCanvas().then(function(t){return BS(t,n.getType(),o)});var n,o}function P0(t,e,n){return Xm(t,{tag:"span",classes:["tox-icon","tox-tbtn__icon-wrap"],behaviours:n},e)}function V0(t,e){return P0(t,e,[])}function H0(t,e){return P0(t,e,[Rg.config({})])}function L0(t,e,n){return{dom:{tag:"span",innerHtml:n.translate(t),classes:[e+"__select-label"]},behaviours:ec([Rg.config({})])}}function z0(e,n,o){function t(t,e){var n=Df.getValue(t);return Vg.focus(n),br(n,"keydown",{raw:e.event.raw}),hw.close(n),vt.some(!0)}var r=Po(st),i=e.text.map(function(t){return Hm(L0(t,n,o.providers))}),u=e.icon.map(function(t){return Hm(H0(t,o.providers.icons))}),a=e.role.fold(function(){return{}},function(t){return{role:t}}),c=e.tooltip.fold(function(){return{}},function(t){var e=o.providers.translate(t);return{title:e,"aria-label":e}}),s=Xm("chevron-down",{tag:"div",classes:[n+"__select-chevron"]},o.providers.icons);return Hm(hw.sketch(lt(lt(lt({},e.uid?{uid:e.uid}:{}),a),{dom:{tag:"button",classes:[n,n+"--select"].concat(B(e.classes,function(t){return n+"--"+t})),attributes:lt({},c)},components:tb([u.map(function(t){return t.asSpec()}),i.map(function(t){return t.asSpec()}),vt.some(s)]),matchWidth:!0,useMinWidth:!0,dropdownBehaviours:ec(V(V([],e.dropdownBehaviours,!0),[$v(function(){return e.disabled||o.providers.isDisabled()}),pv(),vw.config({}),Rg.config({}),mm("dropdown-events",[vv(e,r),bv(e,r)]),mm("menubutton-update-display-text",[Cr(NS,function(e,n){i.bind(function(t){return t.getOpt(e)}).each(function(t){Rg.set(t,[ri(o.providers.translate(n.event.text))])})}),Cr(PS,function(e,n){u.bind(function(t){return t.getOpt(e)}).each(function(t){Rg.set(t,[H0(n.event.icon,o.providers.icons)])})})])],!1)),eventOrder:Yo(RS,{mousedown:["focusing","alloy.base.behaviour","item-type-events","normal-dropdown-events"]}),sandboxBehaviours:ec([Fg.config({mode:"special",onLeft:t,onRight:t})]),lazySink:o.getSink,toggleClass:n+"--active",parts:{menu:Zp(0,e.columns,e.presets)},fetch:function(t){return Wy(C(e.fetch,t))}}))).asSpec()}function U0(t){return"separator"===t.type}function j0(t,n,o,e){var r=Ir("primary-menu"),i=HS(t,o.shared.providers.menuItems());if(0===i.items.length)return vt.none();var u=Gb(r,i.items,n,o,e),a=dt(i.menus,function(t,e){return Gb(e,t,n,o,!1)}),c=Yo(a,sr(r,u));return vt.from(ip.tieredData(r,c,i.expansions))}function W0(n){return{isDisabled:function(){return gd.isDisabled(n)},setDisabled:function(t){return gd.set(n,t)},setActive:function(t){var e=n.element;t?(Yr(e,"tox-tbtn--enabled"),oe(e,"aria-pressed",!0)):(qr(e,"tox-tbtn--enabled"),ce(e,"aria-pressed"))},isActive:function(){return Kr(n.element,"tox-tbtn--enabled")}}}function G0(n,t,o,e){return z0({text:n.text,icon:n.icon,tooltip:n.tooltip,role:e,fetch:function(t,e){n.fetch(function(t){e(j0(t,Sh.CLOSE_ON_EXECUTE,o,!1))})},onSetup:n.onSetup,getApi:W0,columns:1,presets:"normal",classes:[],dropdownBehaviours:[py.config({})]},t,o.shared)}function X0(t,e,n,o,r,i){void 0===n&&(n=[]);var u=e.fold(function(){return{}},function(t){return{action:t}}),a=lt({buttonBehaviours:ec([$v(function(){return t.disabled||i.isDisabled()}),pv(),py.config({}),mm("button press",[kr("click"),kr("mousedown")])].concat(n)),eventOrder:{click:["button press","alloy.base.behaviour"],mousedown:["button press","alloy.base.behaviour"]}},u),c=Yo(a,{dom:o});return Yo(c,{components:r})}function Y0(t,e,n,o){void 0===o&&(o=[]);var r={tag:"button",classes:["tox-tbtn"],attributes:t.tooltip.map(function(t){return{"aria-label":n.translate(t),title:n.translate(t)}}).getOr({})},i=t.icon.map(function(t){return V0(t,n.icons)});return X0(t,e,o,r,tb([i]),n)}function q0(t,e,n,o){void 0===o&&(o=[]);var r=Y0(t,vt.some(e),n,o);return fp.sketch(r)}function K0(t,e,n,o,r){void 0===o&&(o=[]),void 0===r&&(r=[]);var i=n.translate(t.text),u=t.icon?t.icon.map(function(t){return V0(t,n.icons)}):vt.none(),a=u.isSome()?tb([u]):[],c=u.isSome()?{}:{innerHtml:i},s=V(V(V(V([],t.primary||t.borderless?["tox-button"]:["tox-button","tox-button--secondary"],!0),u.isSome()?["tox-button--icon"]:[],!0),t.borderless?["tox-button--naked"]:[],!0),r,!0);return X0(t,e,o,lt(lt({tag:"button",classes:s},c),{attributes:{title:i}}),a,n)}function J0(t,e,n,o,r){void 0===o&&(o=[]),void 0===r&&(r=[]);var i=K0(t,vt.some(e),n,o,r);return fp.sketch(i)}function $0(e,n){return function(t){"custom"===n?br(t,Sy,{name:e,value:{}}):"submit"===n?vr(t,ky):"cancel"===n?vr(t,wy):console.error("Unknown button type: ",n)}}function Q0(e,t,n){if("menu"===t){var o=e,r=Hm(G0(lt(lt({},e),{onSetup:function(t){return t.setDisabled(e.disabled),st},fetch:(i=o.items,u=function(){return r},a=n,function(t){t(B(i,function(t){var e,n,o=t.text.fold(function(){return{}},function(t){return{text:t}});return lt(lt({type:t.type,active:!1},o),{onAction:function(t){var e=!t.isActive();t.setActive(e),n.storage.set(e),a.shared.getSink().each(function(t){u().getOpt(t).each(function(t){ka(t.element),br(t,Sy,{name:n.name,value:n.storage.get()})})})},onSetup:(e=n=t,function(t){t.setActive(e.storage.get())})})}))})}),"tox-tbtn",n,vt.none()));return r.asSpec()}var i,u,a;if("custom"===t||"cancel"===t||"submit"===t){var c=$0(e.name,t);return J0(lt(lt({},e),{borderless:!1}),c,n.shared.providers,[])}console.error("Unknown footer button type: ",t)}function Z0(t,e){return Jf({factory:my,name:t,overrides:function(o){return{fieldBehaviours:ec([mm("coupled-input-behaviour",[Cr(Si(),function(n){ml(n,o,e).bind(cd.getCurrent).each(function(e){ml(n,o,"lock").each(function(t){zg.isOn(t)&&o.onLockedChange(n,e,t)})})})])])}}})}function tw(t){var e=/^\s*(\d+(?:\.\d+)?)\s*(|cm|mm|in|px|pt|pc|em|ex|ch|rem|vw|vh|vmin|vmax|%)\s*$/.exec(t);if(null===e)return Nn.error(t);var n=parseFloat(e[1]),o=e[2];return Nn.value({value:n,unit:o})}function ew(t,e){function n(t){return Tt(o,t)}var o={"":96,px:96,pt:72,cm:2.54,pc:12,mm:25.4,in:1};return t.unit===e?vt.some(t.value):n(t.unit)&&n(e)?o[t.unit]===o[e]?vt.some(t.value):vt.some(t.value/o[t.unit]*o[e]):vt.none()}function nw(t){return vt.none()}function ow(o,e){function t(t){return Xm(t,{tag:"span",classes:["tox-icon","tox-lock-icon__"+t]},e.icons)}function n(t){return{dom:{tag:"div",classes:["tox-form__group"]},components:t}}function r(n){return my.parts.field({factory:Dy,inputClasses:["tox-textfield"],inputBehaviours:ec([gd.config({disabled:function(){return o.disabled||e.isDisabled()}}),pv(),py.config({}),mm("size-input-events",[Cr(bi(),function(t,e){br(t,u,{isField1:n})}),Cr(ki(),function(t,e){br(t,yy,{name:o.name})})])]),selectOnFocus:!1})}function i(t){return{dom:{tag:"label",classes:["tox-label"],innerHtml:e.translate(t)}}}var l=nw,u=Ir("ratio-event"),a=US.parts.lock({dom:{tag:"button",classes:["tox-lock","tox-button","tox-button--naked","tox-button--icon"],attributes:{title:e.translate(o.label.getOr("Constrain proportions"))}},components:[t("lock"),t("unlock")],buttonBehaviours:ec([gd.config({disabled:function(){return o.disabled||e.isDisabled()}}),pv(),py.config({})])}),c=US.parts.field1(n([my.parts.label(i("Width")),r(!0)])),s=US.parts.field2(n([my.parts.label(i("Height")),r(!1)]));return US.sketch({dom:{tag:"div",classes:["tox-form__group"]},components:[{dom:{tag:"div",classes:["tox-form__controls-h-stack"]},components:[c,s,n([i("&nbsp;"),a])]}],field1Name:"width",field2Name:"height",locked:!0,markers:{lockClass:"tox-locked"},onLockedChange:function(t,i,e){tw(Df.getValue(t)).each(function(t){l(t).each(function(t){var e,n,o,r;Df.setValue(i,(r=-1!==(r=(e=t).value.toFixed((n=e.unit)in(o={"":0,px:0,pt:1,mm:1,pc:2,ex:2,em:2,ch:2,rem:2,cm:3,in:4,"%":4})?o[n]:1)).indexOf(".")?r.replace(/\.?0*$/,""):r)+e.unit)})})},coupledFieldBehaviours:ec([gd.config({disabled:function(){return o.disabled||e.isDisabled()},onDisabled:function(t){US.getField1(t).bind(my.getField).each(gd.disable),US.getField2(t).bind(my.getField).each(gd.disable),US.getLock(t).each(gd.disable)},onEnabled:function(t){US.getField1(t).bind(my.getField).each(gd.enable),US.getField2(t).bind(my.getField).each(gd.enable),US.getLock(t).each(gd.enable)}}),pv(),mm("size-input-events2",[Cr(u,function(t,e){var n,o,r,i=e.event.isField1,u=i?US.getField1(t):US.getField2(t),a=i?US.getField2(t):US.getField1(t),c=u.map(Df.getValue).getOr(""),s=a.map(Df.getValue).getOr("");n=s,o=tw(c).toOptional(),r=tw(n).toOptional(),l=Et(o,r,function(t,o){return ew(t,o.unit).map(function(t){return o.value/t}).map(function(t){return e=t,n=o.unit,function(t){return ew(t,n).map(function(t){return{value:t*e,unit:n}})};var e,n}).getOr(nw)}).getOr(nw)})])])})}function rw(f,c){function t(t,e,n,o){return Hm(J0({name:t,text:t,disabled:n,primary:o,icon:vt.none(),borderless:!1},e,c))}function e(t,e,n,o){return Hm(q0({name:t,icon:vt.some(t),tooltip:vt.some(e),disabled:o,primary:!1,borderless:!1},n,c))}function d(t,n){t.map(function(t){var e=t.get(n);e.hasConfigured(gd)&&gd.disable(e)})}function m(t,n){t.map(function(t){var e=t.get(n);e.hasConfigured(gd)&&gd.enable(e)})}function r(t,e,n){br(t,e,n)}function i(t){return vr(t,YS.disable()),0}function u(t){return vr(t,YS.enable()),0}function g(t,e){i(t),r(t,jS.transform(),{transform:e}),u(t)}function n(t){return function(){q.getOpt(t).each(function(t){Rg.set(t,[Y])})}}function s(t,e){i(t),r(t,jS.transformApply(),{transform:e,swap:n(t)}),u(t)}function p(){return t("Back",function(t){return r(t,jS.back(),{swap:n(t)})},!1,!1)}function o(){return Hm({dom:{tag:"div",classes:["tox-spacer"]},behaviours:ec([gd.config({})])})}function h(){return t("Apply",function(t){return r(t,jS.apply(),{swap:n(t)})},!0,!0)}function v(e,n){return function(t){return e(t,n)}}function a(t,e){var n,o=e;i(n=t),r(n,jS.tempTransform(),{transform:o}),u(n)}function b(t,e,n,o,r){var i=$w.parts.label({dom:{tag:"label",classes:["tox-label"],innerHtml:c.translate(t)}}),u=$w.parts.spectrum({dom:{tag:"div",classes:["tox-slider__rail"],attributes:{role:"presentation"}}}),a=$w.parts.thumb({dom:{tag:"div",classes:["tox-slider__handle"],attributes:{role:"presentation"}}});return Hm($w.sketch({dom:{tag:"div",classes:["tox-slider"],attributes:{role:"presentation"}},model:{mode:"x",minX:n,maxX:r,getInitialValue:rt({x:o})},components:[i,u,a],sliderBehaviours:ec([Vg.config({})]),onChoose:e}))}function l(t,e,n,o,r){var i,u,a,c,s,l,f=(i=t,u=e,a=n,c=o,s=r,[p(),(l=u,b(i,function(t,e,n){g(t,v(l,n.x/100))},a,c,s)),h()]);return ly.sketch({dom:w,components:f.map(function(t){return t.asSpec()}),containerBehaviours:ec([mm("image-tools-filter-panel-buttons-events",[Cr(YS.disable(),function(t,e){d(f,t)}),Cr(YS.enable(),function(t,e){m(f,t)})])])})}function y(t){return b(t,function(l,t,e){var n=H.getOpt(l),o=z.getOpt(l),r=L.getOpt(l);n.each(function(s){o.each(function(c){r.each(function(t){var o,r,i,e=Df.getValue(s).x/100,n=Df.getValue(t).x/100,u=Df.getValue(c).x/100,a=(o=e,r=n,i=u,function(t){return T0(t,(e=r,n=i,_0(O0(),[C0(o,0,2),0,0,0,0,0,C0(e,0,2),0,0,0,0,0,C0(n,0,2),0,0,0,0,0,1,0,0,0,0,0,1])));var e,n});g(l,a)})})})},0,100,200)}function x(e,n,o){return function(t){r(t,jS.swap(),{transform:n,swap:function(){q.getOpt(t).each(function(t){Rg.set(t,[e]),o(t)})}})}}var w={tag:"div",classes:["tox-image-tools__toolbar","tox-image-tools-edit-panel"]},S=st,k=[p(),o(),t("Apply",function(t){s(t,function(t){var e,n,o,r,i,u,a,c,s,l=f.getRect();return e=l.x,n=l.y,o=l.w,r=l.h,u=e,a=n,c=o,s=r,(i=t).toCanvas().then(function(t){return FS(t,i.getType(),u,a,c,s)})}),f.hideCrop()},!1,!0)],C=ly.sketch({dom:w,components:k.map(function(t){return t.asSpec()}),containerBehaviours:ec([mm("image-tools-crop-buttons-events",[Cr(YS.disable(),function(t,e){d(k,t)}),Cr(YS.enable(),function(t,e){m(k,t)})])])}),O=Hm(ow({name:"size",label:vt.none(),constrain:!0,disabled:!1},c)),_=[p(),o(),O,o(),t("Apply",function(a){O.getOpt(a).each(function(t){var r,i,e=Df.getValue(t),n=parseInt(e.width,10),o=parseInt(e.height,10),u=(r=n,i=o,function(t){return n=r,o=i,(e=t).toCanvas().then(function(t){return DS(t,n,o).then(function(t){return S0(t,e.getType())})});var e,n,o});s(a,u)})},!1,!0)],T=ly.sketch({dom:w,components:_.map(function(t){return t.asSpec()}),containerBehaviours:ec([mm("image-tools-resize-buttons-events",[Cr(YS.disable(),function(t,e){d(_,t)}),Cr(YS.enable(),function(t,e){m(_,t)})])])}),E=v(R0,"h"),D=v(R0,"v"),A=v(N0,-90),B=v(N0,90),M=[p(),o(),e("flip-horizontally","Flip horizontally",function(t){a(t,E)},!1),e("flip-vertically","Flip vertically",function(t){a(t,D)},!1),e("rotate-left","Rotate counterclockwise",function(t){a(t,A)},!1),e("rotate-right","Rotate clockwise",function(t){a(t,B)},!1),o(),h()],F=ly.sketch({dom:w,components:M.map(function(t){return t.asSpec()}),containerBehaviours:ec([mm("image-tools-fliprotate-buttons-events",[Cr(YS.disable(),function(t,e){d(M,t)}),Cr(YS.enable(),function(t,e){m(M,t)})])])}),I=[p(),o(),h()],R=ly.sketch({dom:w,components:I.map(function(t){return t.asSpec()})}),N=l("Brightness",F0,-100,0,100),P=l("Contrast",I0,-100,0,100),V=l("Gamma",M0,-100,0,100),H=y("R"),L=y("G"),z=y("B"),U=[p(),H,L,z,h()],j=ly.sketch({dom:w,components:U.map(function(t){return t.asSpec()})}),W=vt.some(B0),G=vt.some(A0),X=[e("crop","Crop",x(C,vt.none(),function(t){f.showCrop()}),!1),e("resize","Resize",x(T,vt.none(),function(t){O.getOpt(t).each(function(t){var e=f.getMeasurements(),n=e.width,o=e.height;Df.setValue(t,{width:n,height:o})})}),!1),e("orientation","Orientation",x(F,vt.none(),S),!1),e("brightness","Brightness",x(N,vt.none(),S),!1),e("sharpen","Sharpen",x(R,W,S),!1),e("contrast","Contrast",x(P,vt.none(),S),!1),e("color-levels","Color levels",x(j,vt.none(),S),!1),e("gamma","Gamma",x(V,vt.none(),S),!1),e("invert","Invert",x(R,G,S),!1)],Y=ly.sketch({dom:w,components:X.map(function(t){return t.asSpec()})}),q=Hm(ly.sketch({dom:{tag:"div"},components:[Y],containerBehaviours:ec([Rg.config({})])}));return{memContainer:q,getApplyButton:function(t){return q.getOpt(t).map(function(t){var e=t.components()[0];return e.components()[e.components().length-1]})}}}function iw(t){if(k(t.changedTouches))for(var e="screenX screenY pageX pageY clientX clientY".split(" "),n=0;n<e.length;n++)t[e[n]]=t.changedTouches[0][e[n]]}(Hy=Vy=Vy||{})[Hy.HighlightFirst=0]="HighlightFirst",Hy[Hy.HighlightNone=1]="HighlightNone";function uw(o,t){return{uid:o.uid,dom:o.dom,components:t,behaviours:el(o.formBehaviours,[Df.config({store:{mode:"manual",getValue:function(t){return dt(hl(t,o),function(t,o){return t().bind(function(t){var e=cd.getCurrent(t),n=new Error("Cannot find a current component to extract the value from for form part '"+o+"': "+Fr(t.element));return e.fold(function(){return Nn.error(n)},Nn.value)}).map(Df.getValue)})},setValue:function(n,t){J(t,function(e,t){ml(n,o,t).each(function(t){cd.getCurrent(t).each(function(t){Df.setValue(t,e)})})})}}})]),apis:{getField:function(t,e){return ml(t,o,e).bind(cd.getCurrent)}}}}function aw(){return cd.config({find:vt.some})}function cw(t){return e=Br,n=Mr,s0(t,function(t){return e(t.element)},function(t,e){return n(t.element,e)});var e,n}var sw,lw,fw,dw,mw=function(e,t){return e.getSystem().getByUid(t.uid+"-"+Qy()).map(function(t){return function(){return Nn.value(t)}}).getOrThunk(function(){return t.lazySink.fold(function(){return function(){return Nn.error(new Error("No internal sink is specified, nor could an external sink be found"))}},function(t){return function(){return t(e)}})})},gw=rt([mo("dom"),mo("fetch"),Ju("onOpen"),$u("onExecute"),Eo("getHotspot",vt.some),Eo("getAnchorOverrides",rt({})),Uc(),Zs("dropdownBehaviours",[zg,$y,Fg,Vg]),mo("toggleClass"),Eo("eventOrder",{}),wo("lazySink"),Eo("matchWidth",!1),Eo("useMinWidth",!1),wo("role")].concat(ux())),pw=rt([$f({schema:[Yu()],name:"menu",defaults:function(t){return{onExecute:t.onExecute}}}),Zy()]),hw=Cl({name:"Dropdown",configFields:gw(),partFields:pw(),factory:function(e,t,n,o){function r(t){bf.getState(t).each(function(t){ip.highlightPrimary(t)})}function i(t,e){return yr(t),vt.some(!0)}var u,a={expand:function(t){zg.isOn(t)||nx(e,h,t,o,st,Vy.HighlightNone).get(st)},open:function(t){zg.isOn(t)||nx(e,h,t,o,st,Vy.HighlightFirst).get(st)},isOpen:zg.isOn,close:function(t){zg.isOn(t)&&nx(e,h,t,o,st,Vy.HighlightFirst).get(st)},repositionMenus:function(t){zg.isOn(t)&&ix(t)}};return{uid:e.uid,dom:e.dom,components:t,behaviours:el(e.dropdownBehaviours,[zg.config({toggleClass:e.toggleClass,aria:{mode:"expanded"}}),$y.config({others:{sandbox:function(t){return rx(e,t,{onOpen:function(){return zg.on(t)},onClose:function(){return zg.off(t)}})}}}),Fg.config({mode:"special",onSpace:i,onEnter:i,onDown:function(t,e){return hw.isOpen(t)?r($y.getCoupled(t,"sandbox")):hw.open(t),vt.some(!0)},onEscape:function(t,e){return hw.isOpen(t)?(hw.close(t),vt.some(!0)):vt.none()}}),Vg.config({})]),events:Sm(vt.some(function(t){nx(e,h,t,o,r,Vy.HighlightFirst).get(st)})),eventOrder:lt(lt({},e.eventOrder),((u={})[Ii()]=["disabling","toggling","alloy.base.behaviour"],u)),apis:a,domModification:{attributes:lt(lt({"aria-haspopup":"true"},e.role.fold(function(){return{}},function(t){return{role:t}})),"button"===e.dom.tag?{type:tt(e.dom,"attributes").bind(function(t){return tt(t,"type")}).getOr("button")}:{})}}},apis:{open:function(t,e){return t.open(e)},expand:function(t,e){return t.expand(e)},close:function(t,e){return t.close(e)},isOpen:function(t,e){return t.isOpen(e)},repositionMenus:function(t,e){return t.repositionMenus(e)}}}),vw=xa({fields:[],name:"unselecting",active:Object.freeze({__proto__:null,events:function(){return nu([Sr(Ei(),D)])},exhibit:function(){return zr({styles:{"-webkit-user-select":"none","user-select":"none","-ms-user-select":"none","-moz-user-select":"-moz-none"},attributes:{unselectable:"on"}})}})}),bw=Ir("color-input-change"),yw=Ir("color-swatch-change"),xw=Ir("color-picker-cancel"),ww=Qf({schema:[mo("dom")],name:"label"}),Sw=ax("top-left"),kw=ax("top"),Cw=ax("top-right"),Ow=ax("right"),_w=ax("bottom-right"),Tw=ax("bottom"),Ew=ax("bottom-left"),Dw=[ww,ax("left"),Ow,kw,Tw,Sw,Cw,Ew,_w,Jf({name:"thumb",defaults:rt({dom:{styles:{position:"absolute"}}}),overrides:function(t){return{events:nu([Tr(si(),t,"spectrum"),Tr(li(),t,"spectrum"),Tr(fi(),t,"spectrum"),Tr(mi(),t,"spectrum"),Tr(gi(),t,"spectrum"),Tr(hi(),t,"spectrum")])}}}),Jf({schema:[cr("mouseIsDown",function(){return Po(!1)})],name:"spectrum",overrides:function(n){function o(e,t){return r.getValueFromEvent(t).map(function(t){return r.setValueFrom(e,n,t)})}var r=n.model.manager;return{behaviours:ec([Fg.config({mode:"special",onLeft:function(t){return r.onLeft(t,n)},onRight:function(t){return r.onRight(t,n)},onUp:function(t){return r.onUp(t,n)},onDown:function(t){return r.onDown(t,n)}}),Vg.config({})]),events:nu([Cr(si(),o),Cr(li(),o),Cr(mi(),o),Cr(gi(),function(t,e){n.mouseIsDown.get()&&o(t,e)})])}}})],Aw=rt("slider.change.value"),Bw="left",Mw=Jx(-1),Fw=Jx(1),Iw=vt.none,Rw=vt.none,Nw={"top-left":vt.none(),top:vt.none(),"top-right":vt.none(),right:vt.some(function(t,e){Fx(t,{x:px(e)})}),"bottom-right":vt.none(),bottom:vt.none(),"bottom-left":vt.none(),left:vt.some(function(t,e){Fx(t,{x:fx(e)})})},Pw=Object.freeze({__proto__:null,setValueFrom:function(t,e,n){var o=Kx(t,e,n);return qx(t,{x:o}),o},setToMin:function(t,e){qx(t,{x:sx(e)})},setToMax:function(t,e){qx(t,{x:mx(e)})},findValueOfOffset:Kx,getValueFromEvent:function(t){return cx(t).map(function(t){return t.left})},findPositionOfValue:$x,setPositionFromValue:function(t,e,n,o){var r=Bx(n),i=$x(t,o.getSpectrum(t),r.x,o.getLeftEdge(t),o.getRightEdge(t),n),u=Ce(e.element)/2;fe(e.element,"left",i-u+"px")},onLeft:Mw,onRight:Fw,onUp:Iw,onDown:Rw,edgeActions:Nw}),Vw=vt.none,Hw=vt.none,Lw=t0(-1),zw=t0(1),Uw={"top-left":vt.none(),top:vt.some(function(t,e){Fx(t,{y:dx(e)})}),"top-right":vt.none(),right:vt.none(),"bottom-right":vt.none(),bottom:vt.some(function(t,e){Fx(t,{y:hx(e)})}),"bottom-left":vt.none(),left:vt.none()},jw=Object.freeze({__proto__:null,setValueFrom:function(t,e,n){var o=Zx(t,e,n);return Qx(t,{y:o}),o},setToMin:function(t,e){Qx(t,{y:lx(e)})},setToMax:function(t,e){Qx(t,{y:gx(e)})},findValueOfOffset:Zx,getValueFromEvent:function(t){return cx(t).map(function(t){return t.top})},findPositionOfValue:e0,setPositionFromValue:function(t,e,n,o){var r=Bx(n),i=e0(t,o.getSpectrum(t),r.y,o.getTopEdge(t),o.getBottomEdge(t),n),u=xe(e.element)/2;fe(e.element,"top",i-u+"px")},onLeft:Vw,onRight:Hw,onUp:Lw,onDown:zw,edgeActions:Uw}),Ww=cx,Gw=r0(-1,!1),Xw=r0(1,!1),Yw=r0(-1,!0),qw=r0(1,!0),Kw={"top-left":vt.some(function(t,e){Fx(t,Mx(fx(e),dx(e)))}),top:vt.some(function(t,e){Fx(t,Mx(xx(e),dx(e)))}),"top-right":vt.some(function(t,e){Fx(t,Mx(px(e),dx(e)))}),right:vt.some(function(t,e){Fx(t,Mx(px(e),wx(e)))}),"bottom-right":vt.some(function(t,e){Fx(t,Mx(px(e),hx(e)))}),bottom:vt.some(function(t,e){Fx(t,Mx(xx(e),hx(e)))}),"bottom-left":vt.some(function(t,e){Fx(t,Mx(fx(e),hx(e)))}),left:vt.some(function(t,e){Fx(t,Mx(fx(e),wx(e)))})},Jw=Object.freeze({__proto__:null,setValueFrom:function(t,e,n){var o=o0(Kx(t,e,n.left),Zx(t,e,n.top));return n0(t,o),o},setToMin:function(t,e){n0(t,o0(sx(e),lx(e)))},setToMax:function(t,e){n0(t,o0(mx(e),gx(e)))},getValueFromEvent:Ww,setPositionFromValue:function(t,e,n,o){var r=Bx(n),i=$x(t,o.getSpectrum(t),r.x,o.getLeftEdge(t),o.getRightEdge(t),n),u=e0(t,o.getSpectrum(t),r.y,o.getTopEdge(t),o.getBottomEdge(t),n),a=Ce(e.element)/2,c=xe(e.element)/2;fe(e.element,"left",i-a+"px"),fe(e.element,"top",u-c+"px")},onLeft:Gw,onRight:Xw,onUp:Yw,onDown:qw,edgeActions:Kw}),$w=Cl({name:"Slider",configFields:[Eo("stepSize",1),Eo("onChange",st),Eo("onChoose",st),Eo("onInit",st),Eo("onDragStart",st),Eo("onDragEnd",st),Eo("snapToGrid",!1),Eo("rounded",!0),wo("snapStart"),go("model",lo("mode",{x:[Eo("minX",0),Eo("maxX",100),cr("value",function(t){return Po(t.mode.minX)}),mo("getInitialValue"),ta("manager",Pw)],y:[Eo("minY",0),Eo("maxY",100),cr("value",function(t){return Po(t.mode.minY)}),mo("getInitialValue"),ta("manager",jw)],xy:[Eo("minX",0),Eo("maxX",100),Eo("minY",0),Eo("maxY",100),cr("value",function(t){return Po({x:t.mode.minX,y:t.mode.minY})}),mo("getInitialValue"),ta("manager",Jw)]})),Zs("sliderBehaviours",[Fg,Df]),cr("mouseIsDown",function(){return Po(!1)})],partFields:Dw,factory:function(i,t,e,n){function u(t){return gl(t,i,"thumb")}function a(t){return gl(t,i,"spectrum")}function o(t){return ml(t,i,"left-edge")}function r(t){return ml(t,i,"right-edge")}function c(t){return ml(t,i,"top-edge")}function s(t){return ml(t,i,"bottom-edge")}function l(t,e){v.setPositionFromValue(t,e,i,{getLeftEdge:o,getRightEdge:r,getTopEdge:c,getBottomEdge:s,getSpectrum:a})}function f(t,e){h.value.set(e),l(t,u(t))}function d(n){var t=i.mouseIsDown.get();i.mouseIsDown.set(!1),t&&ml(n,i,"thumb").each(function(t){var e=h.value.get();i.onChoose(n,t,e)})}function m(t,e){e.stop(),i.mouseIsDown.set(!0),i.onDragStart(t,u(t))}function g(t,e){e.stop(),i.onDragEnd(t,u(t)),d(t)}var p,h=i.model,v=h.manager;return{uid:i.uid,dom:i.dom,components:t,behaviours:el(i.sliderBehaviours,[Fg.config({mode:"special",focusIn:function(t){return ml(t,i,"spectrum").map(Fg.focusIn).map(D)}}),Df.config({store:{mode:"manual",getValue:function(t){return h.value.get()}}}),ic.config({channels:((p={})[wf()]={onReceive:d},p)})]),events:nu([Cr(Aw(),function(t,e){!function(t,e){f(t,e);var n=u(t);i.onChange(t,n,e),vt.some(!0)}(t,e.event.value)}),ou(function(t,e){var n=h.getInitialValue();h.value.set(n);var o=u(t);l(t,o);var r=a(t);i.onInit(t,o,r,h.value.get())}),Cr(si(),m),Cr(fi(),g),Cr(mi(),m),Cr(hi(),g)]),apis:{resetToMin:function(t){v.setToMin(t,i)},resetToMax:function(t){v.setToMax(t,i)},setValue:f,refresh:l},domModification:{styles:{position:"relative"}}}},apis:{setValue:function(t,e,n){t.setValue(e,n)},resetToMin:function(t,e){t.resetToMin(e)},resetToMax:function(t,e){t.resetToMax(e)},refresh:function(t,e){t.refresh(e)}}}),Qw=Ir("rgb-hex-update"),Zw=Ir("slider-update"),tS=Ir("palette-update"),eS=[Zs("formBehaviours",[Df])],nS={getField:Hr(function(t,e,n){return t.getField(e,n)}),sketch:function(t){var n,e={field:function(t,e){return n.push(t),cl("form",i0(t),e)},record:rt(n=[])},o=t(e),r=B(e.record(),function(t){return Jf({name:t,pname:i0(t)})});return Sl("form",eS,r,uw,o)}},oS=Ir("valid-input"),rS=Ir("invalid-input"),iS=Ir("validating-input"),uS="colorcustom.rgb.",aS=function(t){return cd.config({find:t.getOpt})},cS=function(t){return cd.config({find:function(e){return Jt(e.element,t).bind(function(t){return e.getSystem().getByDom(t).toOptional()})}})},sS={"colorcustom.rgb.red.label":"R","colorcustom.rgb.red.description":"Red component","colorcustom.rgb.green.label":"G","colorcustom.rgb.green.description":"Green component","colorcustom.rgb.blue.label":"B","colorcustom.rgb.blue.description":"Blue component","colorcustom.rgb.hex.label":"#","colorcustom.rgb.hex.description":"Hex color code","colorcustom.rgb.range":"Range 0 to 255","colorcustom.sb.saturation":"Saturation","colorcustom.sb.brightness":"Brightness","colorcustom.sb.picker":"Saturation and Brightness Picker","colorcustom.sb.palette":"Saturation and Brightness Palette","colorcustom.sb.instructions":"Use arrow keys to select saturation and brightness, on x and y axes","colorcustom.hue.hue":"Hue","colorcustom.hue.slider":"Hue Slider","colorcustom.hue.palette":"Hue Palette","colorcustom.hue.instructions":"Use arrow keys to select a hue","aria.color.picker":"Color Picker","aria.input.invalid":"Invalid input"},lS=tinymce.util.Tools.resolve("tinymce.Resource"),fS=tinymce.util.Tools.resolve("tinymce.util.Tools"),dS=$o([Eo("preprocess",h),Eo("postprocess",h)]),mS=function(r,t){var i=so("RepresentingConfigs.memento processors",dS,t);return Df.config({store:{mode:"manual",getValue:function(t){var e=r.get(t),n=Df.getValue(e);return i.postprocess(n)},setValue:function(t,e){var n=i.preprocess(e),o=r.get(t);Df.setValue(o,n)}}})},gS=s0,pS=function(t){return Df.config({store:{mode:"memory",initialValue:t}})},hS=Ir("alloy-fake-before-tabstop"),vS=Ir("alloy-fake-after-tabstop"),bS=!(ln().browser.isIE()||ln().browser.isEdge()),yS=function(t){return t.getContext("2d")},xS=function(t,e,n){return t.width=e,t.height=n,t},wS=function(t){URL.revokeObjectURL(t.src)},SS=[0,.01,.02,.04,.05,.06,.07,.08,.1,.11,.12,.14,.15,.16,.17,.18,.2,.21,.22,.24,.25,.27,.28,.3,.32,.34,.36,.38,.4,.42,.44,.46,.48,.5,.53,.56,.59,.62,.65,.68,.71,.74,.77,.8,.83,.86,.89,.92,.95,.98,1,1.06,1.12,1.18,1.24,1.3,1.36,1.42,1.48,1.54,1.6,1.66,1.72,1.78,1.84,1.9,1.96,2,2.12,2.25,2.37,2.5,2.62,2.75,2.87,3,3.2,3.4,3.6,3.8,4,4.3,4.7,4.9,5,5.5,6,6.5,6.8,7,7.3,7.5,7.8,8,8.4,8.7,9,9.4,9.6,9.8,10],kS=function(t,e,T){var n=yS(t),o=function(t){for(var e,n,o,r,i=t.data,u=T[0],a=T[1],c=T[2],s=T[3],l=T[4],f=T[5],d=T[6],m=T[7],g=T[8],p=T[9],h=T[10],v=T[11],b=T[12],y=T[13],x=T[14],w=T[15],S=T[16],k=T[17],C=T[18],O=T[19],_=0;_<i.length;_+=4)e=i[_],n=i[_+1],o=i[_+2],r=i[_+3],i[_]=e*u+n*a+o*c+r*s+l,i[_+1]=e*f+n*d+o*m+r*g+p,i[_+2]=e*h+n*v+o*b+r*y+x,i[_+3]=e*w+n*S+o*k+r*C+O;return t}(n.getImageData(0,0,t.width,t.height));return n.putImageData(o,0,0),S0(t,e)},CS=(sw=[-1,0,0,0,255,0,-1,0,0,255,0,0,-1,0,255,0,0,0,1,0,0,0,0,0,1],function(t){return T0(t,sw)}),OS=E0(function(t,e){return _0(t,[1,0,0,0,e=C0(255*e,-255,255),0,1,0,0,e,0,0,1,0,e,0,0,0,1,0,0,0,0,0,1])}),_S=E0(function(t,e){var n;return e=C0(e,-1,1),_0(t,[(n=(e*=100)<0?127+e/100*127:127*(0==(n=e%1)?SS[e]:SS[Math.floor(e)]*(1-n)+SS[Math.floor(e)+1]*n)+127)/127,0,0,0,.5*(127-n),0,n/127,0,0,.5*(127-n),0,0,n/127,0,.5*(127-n),0,0,0,1,0,0,0,0,0,1])}),TS=(lw=[0,-1,0,-1,5,-1,0,-1,0],function(t){return a=lw,(u=t).toCanvas().then(function(t){return e=t,n=u.getType(),o=a,r=yS(e),i=function(t,e,n){for(var o=function(t,e,n){return n<t?t=n:t<e&&(t=e),t},r=Math.round(Math.sqrt(n.length)),i=Math.floor(r/2),u=t.data,a=e.data,c=t.width,s=t.height,l=0;l<s;l++)for(var f=0;f<c;f++){for(var d=0,m=0,g=0,p=0;p<r;p++)for(var h=0;h<r;h++){var v=o(f+h-i,0,c-1),b=4*(o(l+p-i,0,s-1)*c+v),y=n[p*r+h];d+=u[b]*y,m+=u[1+b]*y,g+=u[2+b]*y}var x=4*(l*c+f);a[x]=o(d,0,255),a[1+x]=o(m,0,255),a[2+x]=o(g,0,255)}return e}(r.getImageData(0,0,e.width,e.height),r.getImageData(0,0,e.width,e.height),o),r.putImageData(i,0,0),S0(e,n);var e,n,o,r,i});var u,a}),ES=(fw=function(t,e){return 255*Math.pow(t/255,1-e)},function(e,n){return e.toCanvas().then(function(t){return function(t,e,n){for(var o=yS(t),r=new Array(256),i=0;i<r.length;i++)r[i]=fw(i,n);var u=function(t,e){for(var n=t.data,o=0;o<n.length;o+=4)n[o]=e[n[o]],n[o+1]=e[n[o+1]],n[o+2]=e[n[o+2]];return t}(o.getImageData(0,0,t.width,t.height),r);return o.putImageData(u,0,0),S0(t,e)}(t,e.getType(),n)})}),DS=function(t,e,n){var o=b0(t),r=y0(t),i=e/o,u=n/r,a=!1;(i<.5||2<i)&&(i=i<.5?.5:2,a=!0),(u<.5||2<u)&&(u=u<.5?.5:2,a=!0);var c=AS(t,i,u);return a?c.then(function(t){return DS(t,e,n)}):c},AS=function(u,a,c){return new Ly(function(t){var e=b0(u),n=y0(u),o=Math.floor(e*a),r=Math.floor(n*c),i=h0(o,r);yS(i).drawImage(u,0,0,e,n,0,0,o,r),t(i)})},BS=function(t,e,n){var o=(n<0?360+n:n)*Math.PI/180,r=t.width,i=t.height,u=Math.sin(o),a=Math.cos(o),c=D0(Math.abs(r*a)+Math.abs(i*u)),s=D0(Math.abs(r*u)+Math.abs(i*a)),l=h0(c,s),f=yS(l);return f.translate(c/2,s/2),f.rotate(o),f.drawImage(t,-r/2,-i/2),S0(l,e)},MS=function(t,e,n){var o=h0(t.width,t.height),r=yS(o);return"v"===n?(r.scale(1,-1),r.drawImage(t,0,-o.height)):(r.scale(-1,1),r.drawImage(t,-o.width,0)),S0(o,e)},FS=function(t,e,n,o,r,i){var u=h0(r,i);return yS(u).drawImage(t,-n,-o),S0(u,e)},IS=Ir("toolbar.button.execute"),RS=((dw={})[Ii()]=["disabling","alloy.base.behaviour","toggling","toolbar-button-events"],dw),NS=Ir("update-menu-text"),PS=Ir("update-menu-icon"),VS={type:"separator"},HS=function(t,l){var e,n,o;return I((e=y(t)?t.split(" "):t,n=l,0<(o=R(e,function(t,e){return y(e)?""===e?t:"|"===e?0<t.length&&!U0(t[t.length-1])?t.concat([VS]):t:Tt(n,e.toLowerCase())?t.concat([n[e.toLowerCase()]]):t:t.concat([e])},[])).length&&U0(o[o.length-1])&&o.pop(),o),function(t,e){var n,o,r,i,u,a,c=function(t){if(U0(t))return t;var e=tt(t,"value").getOrThunk(function(){return Ir("generated-menu-item")});return Yo({value:e},t)}(e),s=(o=l,Tt(n=c,"getSubmenuItems")?(i=o,u=(r=n).getSubmenuItems(),a=HS(u,i),{item:r,menus:Yo(a.menus,sr(r.value,a.items)),expansions:Yo(a.expansions,sr(r.value,r.value))}):{item:n,menus:{},expansions:{}});return{menus:Yo(t.menus,s.menus),items:[s.item].concat(t.items),expansions:Yo(t.expansions,s.expansions)}},{menus:{},expansions:{},items:[]})},LS=rt([Eo("field1Name","field1"),Eo("field2Name","field2"),Qu("onLockedChange"),qu(["lockClass"]),Eo("locked",!1),Af("coupledFieldBehaviours",[cd,Df])]),zS=rt([Z0("field1","field2"),Z0("field2","field1"),Jf({factory:fp,schema:[mo("dom")],name:"lock",overrides:function(t){return{buttonBehaviours:ec([zg.config({selected:t.locked,toggleClass:t.markers.lockClass,aria:{mode:"pressed"}})])}}})]),US=Cl({name:"FormCoupledInputs",configFields:LS(),partFields:zS(),factory:function(o,t,e,n){return{uid:o.uid,dom:o.dom,components:t,behaviours:Bf(o.coupledFieldBehaviours,[cd.config({find:vt.some}),Df.config({store:{mode:"manual",getValue:function(t){var e=bl(t,o,["field1","field2"]),n={};return n[o.field1Name]=Df.getValue(e.field1()),n[o.field2Name]=Df.getValue(e.field2()),n},setValue:function(t,e){var n=bl(t,o,["field1","field2"]);et(e,o.field1Name)&&Df.setValue(n.field1(),e[o.field1Name]),et(e,o.field2Name)&&Df.setValue(n.field2(),e[o.field2Name])}}})]),apis:{getField1:function(t){return ml(t,o,"field1")},getField2:function(t){return ml(t,o,"field2")},getLock:function(t){return ml(t,o,"lock")}}}},apis:{getField1:function(t,e){return t.getField1(e)},getField2:function(t,e){return t.getField2(e)},getLock:function(t,e){return t.getLock(e)}}}),jS={undo:rt(Ir("undo")),redo:rt(Ir("redo")),zoom:rt(Ir("zoom")),back:rt(Ir("back")),apply:rt(Ir("apply")),swap:rt(Ir("swap")),transform:rt(Ir("transform")),tempTransform:rt(Ir("temp-transform")),transformApply:rt(Ir("transform-apply"))},WS=rt("save-state"),GS=rt("disable"),XS=rt("enable"),YS={formActionEvent:Sy,saveState:WS,disable:GS,enable:XS},qS=tinymce.util.Tools.resolve("tinymce.geom.Rect"),KS=tinymce.util.Tools.resolve("tinymce.util.Observable"),JS=tinymce.util.Tools.resolve("tinymce.util.VK");function $S(t,d){function e(t){var e,n,o,r,i,u,a,c,s=t.raw,l=(e=Math.max,n=y.documentElement,o=y.body,r=e(n.scrollWidth,o.scrollWidth),i=e(n.clientWidth,o.clientWidth),u=e(n.offsetWidth,o.offsetWidth),a=e(n.scrollHeight,o.scrollHeight),c=e(n.clientHeight,o.clientHeight),{width:r<u?i:r,height:a<e(n.offsetHeight,o.offsetHeight)?c:a});iw(s),t.prevent(),p=s.button,h=s.screenX,v=s.screenY;var f=ge(w,"cursor");de(g=Mt.fromTag("div",y),{position:"absolute",top:"0",left:"0",width:l.width+"px",height:l.height+"px","z-index":"2147483647",opacity:"0.0001",cursor:f}),Tn(yn(x),g),b.push(pc(x,"mousemove",m),pc(x,"touchmove",m),pc(x,"mouseup",S),pc(x,"touchend",S)),d.start(s)}function m(t){var e=t.raw;if(iw(e),e.button!==p)return S(t);e.deltaX=e.screenX-h,e.deltaY=e.screenY-v,t.prevent(),d.drag(e)}var n,o,r,g,p,h,v,i=[],b=[],y=null!==(n=d.document)&&void 0!==n?n:document,u=null!==(o=d.root)&&void 0!==o?o:y,x=Mt.fromDom(y),w=Mt.fromDom(u.getElementById(null!==(r=d.handle)&&void 0!==r?r:t)),S=function(t){iw(t.raw),St(b,function(t){return t.unbind()}),b=[],En(g),d.stop&&d.stop(t.raw)};return i.push(pc(w,"mousedown",e),pc(w,"touchstart",e)),{destroy:function(){St(b.concat(i),function(t){return t.unbind()}),b=[],i=[],k(g)&&En(g)}}}function QS(t,e,n,o,r){return q0({name:t,icon:vt.some(e),disabled:n,tooltip:vt.some(t),primary:!1,borderless:!1},o,r)}function ZS(t,e){e?gd.enable(t):gd.disable(t)}var tk=0,ek=function(s,e,l,t,n){function f(t,e){return{x:e.x-t.x,y:e.y-t.y,w:e.w,h:e.h}}function u(t,e,n,o){var r=e.x+n*t.deltaX,i=e.y+o*t.deltaY,u=Math.max(20,e.w+n*t.deltaW),a=Math.max(20,e.h+o*t.deltaH),c=(s=qS.clamp({x:r,y:i,w:u,h:a},l,"move"===t.name),f(l,s));b.fire("updateRect",{rect:c}),h(c)}function o(t){r(s=t)}function r(n){function t(t,e){Iu(m,"#"+d+"-"+t).each(function(t){de(t,{left:e.x+"px",top:e.y+"px",width:Math.max(0,e.w)+"px",height:Math.max(0,e.h)+"px"})})}St(g,function(e){Iu(m,"#"+d+"-"+e.name).each(function(t){de(t,{left:n.w*e.xMul+n.x+"px",top:n.h*e.yMul+n.y+"px"})})}),t("top",{x:e.x,y:e.y,w:e.w,h:n.y-e.y}),t("right",{x:n.x+n.w,y:n.y,w:e.w-n.x-n.w+e.x,h:n.h}),t("bottom",{x:e.x,y:n.y+n.h,w:e.w,h:e.h-n.y-n.h+e.y}),t("left",{x:e.x,y:n.y,w:n.x-e.x,h:n.h}),t("move",n)}var i,a,c=[],d="tox-crid-"+tk++,m=Mt.fromDom(t),g=[{name:"move",xMul:0,yMul:0,deltaX:1,deltaY:1,deltaW:0,deltaH:0,label:"Crop Mask"},{name:"nw",xMul:0,yMul:0,deltaX:1,deltaY:1,deltaW:-1,deltaH:-1,label:"Top Left Crop Handle"},{name:"ne",xMul:1,yMul:0,deltaX:0,deltaY:1,deltaW:1,deltaH:-1,label:"Top Right Crop Handle"},{name:"sw",xMul:0,yMul:1,deltaX:1,deltaY:0,deltaW:-1,deltaH:1,label:"Bottom Left Crop Handle"},{name:"se",xMul:1,yMul:1,deltaX:0,deltaY:0,deltaW:1,deltaH:1,label:"Bottom Right Crop Handle"}],p=["top","right","bottom","left"],h=function(t){var e;o((e=l,{x:t.x+e.x,y:t.y+e.y,w:t.w,h:t.h}))};function v(t){oe(t.target,"aria-grabbed","focus"===t.raw.type?"true":"false")}re(a=Mt.fromTag("div"),{id:d,class:"tox-croprect-container",role:"grid","aria-dropeffect":"execute"}),Tn(m,a),St(p,function(n){Iu(m,"#"+d).each(function(t){var e=Mt.fromTag("div");re(e,{id:d+"-"+n,class:"tox-croprect-block","data-mce-bogus":"all"}),fe(e,"display","none"),Tn(t,e)})}),St(g,function(n){Iu(m,"#"+d).each(function(t){var e=Mt.fromTag("div");re(e,{id:d+"-"+n.name,"aria-label":n.label,"aria-grabbed":"false","data-mce-bogus":"all",role:"gridcell",tabindex:"-1",title:n.label}),Jr(e,["tox-croprect-handle","tox-croprect-handle-"+n.name]),fe(e,"display","none"),Tn(t,e)})}),i=B(g,function(e){var n;return $S(d,{document:t.ownerDocument,root:gn(m).dom,handle:d+"-"+e.name,start:function(){n=s},drag:function(t){u(e,n,t.deltaX,t.deltaY)}})}),r(s),c.push(pc(m,"focusin",v),pc(m,"focusout",v),pc(m,"keydown",function(e){var i;function t(t,e,n,o,r){t.stopPropagation(),t.preventDefault(),u(i,n,o,r)}switch(St(g,function(t){if(ie(e.target,"id")===d+"-"+t.name)return i=t,!1}),e.raw.keyCode){case JS.LEFT:t(e,0,s,-10,0);break;case JS.RIGHT:t(e,0,s,10,0);break;case JS.UP:t(e,0,s,0,-10);break;case JS.DOWN:t(e,0,s,0,10);break;case JS.ENTER:case JS.SPACEBAR:e.prevent(),n()}}));var b=lt(lt({},KS),{toggleVisibility:function(t){var e=V(V([],B(g,function(t){return"#"+d+"-"+t.name}),!0),B(p,function(t){return"#"+d+"-"+t}),!0).join(","),n=vs(m,e);St(n,t?function(t){return ve(t,"display")}:function(t){return fe(t,"display","none")})},setClampRect:function(t){l=t,r(s)},setRect:o,getInnerRect:function(){return f(l,s)},setInnerRect:h,setViewPortRect:function(t){e=t,r(s)},destroy:function(){St(i,function(t){return t.destroy()}),i=[],St(c,function(t){return t.unbind()}),c=[]}});return b};function nk(t){var n,o,e,r,i=Po(t),u=gc(),a=(o=-1,{data:n=[],add:function(t){var e=n.splice(++o);return n.push(t),{state:t,removed:e}},undo:function(){if(e())return n[--o]},redo:function(){if(r())return n[++o]},canUndo:e=function(){return 0<o},canRedo:r=function(){return-1!==o&&o<n.length-1}});function c(t){i.set(t)}function s(t){URL.revokeObjectURL(t.url)}function l(t){var e=f(t);c(e);var n=a.add(e).removed;return fS.each(n,s),e.url}a.add(t);function f(t){return{blob:t,url:URL.createObjectURL(t)}}function d(){u.on(s),u.clear()}return{getBlobState:function(){return i.get()},setBlobState:c,addBlobState:l,getTempState:function(){return u.get().getOrThunk(i.get)},updateTempState:function(t){var e=f(t);return d(),u.set(e),e.url},addTempState:function(t){var e=f(t);return u.set(e),e.url},applyTempState:function(e){return u.get().fold(st,function(t){l(t.blob),e()})},destroyTempState:d,undo:function(){var t=a.undo();return c(t),t.url},redo:function(){var t=a.redo();return c(t),t.url},getHistoryStates:function(){return{undoEnabled:a.canUndo(),redoEnabled:a.canRedo()}}}}function ok(t,e){function i(t){var e=y.getHistoryStates();k.updateButtonUndoStates(t,e.undoEnabled,e.redoEnabled),br(t,YS.formActionEvent,{name:YS.saveState(),value:e.undoEnabled})}function u(t){return t.toBlob()}function a(t){br(t,YS.formActionEvent,{name:YS.disable(),value:{}})}function c(e,t,n,o,r){a(e),k0(t).then(n).then(u).then(o).then(function(t){return w(e,t)}).then(function(){i(e),r(),x(e)}).catch(function(t){console.log(t),e.getSystem().isConnected()&&x(e)})}function r(t,e,n){c(t,y.getBlobState().blob,e,function(t){return y.updateTempState(t)},n)}function s(t){var e=y.getBlobState().url;return y.destroyTempState(),i(t),e}var n,o,l,f,d,m,g,p,h,v,b,y=nk(t.currentState),x=function(t){C.getApplyButton(t).each(function(t){gd.enable(t)}),br(t,YS.formActionEvent,{name:YS.enable(),value:{}})},w=function(t,e){return a(t),S.updateSrc(t,e)},S=(f=t.currentState.url,m=Hm({dom:{tag:"div",classes:["tox-image-tools__image-bg"],attributes:{role:"presentation"}}}),g=Po(1),d=dc(),p=lt(lt({},d),{run:function(t){return d.get().each(t)}}),h=Po({x:0,y:0,w:1,h:1}),v=Po({x:0,y:0,w:1,h:1}),{memContainer:b=Hm(ly.sketch({dom:{tag:"div",classes:["tox-image-tools__image"]},components:[m.asSpec(),{dom:{tag:"img",attributes:{src:f}}},{dom:{tag:"div"},behaviours:ec([mm("image-panel-crop-events",[ou(function(t){b.getOpt(t).each(function(t){var e=t.element.dom,n=ek({x:10,y:10,w:100,h:100},{x:0,y:0,w:200,h:200},{x:0,y:0,w:200,h:200},e,st);n.toggleVisibility(!1),n.on("updateRect",function(t){var e=t.rect,n=g.get(),o={x:Math.round(e.x/n),y:Math.round(e.y/n),w:Math.round(e.w/n),h:Math.round(e.h/n)};h.set(o)}),p.set(n)})}),ru(function(){p.clear()})])])}],containerBehaviours:ec([Rg.config({}),mm("image-panel-events",[ou(function(t){_(t,f)})])])})),updateSrc:_,zoom:function(t,e){var n=g.get(),o=0<e?Math.min(2,n+.1):Math.max(.1,n-.1);g.set(o),b.getOpt(t).each(function(t){var e=t.components()[1].element;O(t,e)})},showCrop:function(){p.run(function(t){t.toggleVisibility(!0)})},hideCrop:function(){p.run(function(t){t.toggleVisibility(!1)})},getRect:function(){return h.get()},getMeasurements:function(){var t=v.get();return{width:t.w,height:t.h}}}),k=(o=Hm(QS("Undo","undo",!0,function(t){br(t,jS.undo(),{direction:1})},n=e)),l=Hm(QS("Redo","redo",!0,function(t){br(t,jS.redo(),{direction:1})},n)),{container:ly.sketch({dom:{tag:"div",classes:["tox-image-tools__toolbar","tox-image-tools__sidebar"]},components:[o.asSpec(),l.asSpec(),QS("Zoom in","zoom-in",!1,function(t){br(t,jS.zoom(),{direction:1})},n),QS("Zoom out","zoom-out",!1,function(t){br(t,jS.zoom(),{direction:-1})},n)]}),updateButtonUndoStates:function(t,e,n){o.getOpt(t).each(function(t){ZS(t,e)}),l.getOpt(t).each(function(t){ZS(t,n)})}}),C=rw(S,e);function O(t,s){b.getOpt(t).each(function(t){var n=g.get(),o=Ce(t.element),r=xe(t.element),i=s.dom.naturalWidth*n,u=s.dom.naturalHeight*n,a=Math.max(0,o/2-i/2),c=Math.max(0,r/2-u/2),e={left:a.toString()+"px",top:c.toString()+"px",width:i.toString()+"px",height:u.toString()+"px",position:"absolute"};de(s,e),m.getOpt(t).each(function(t){de(t.element,e)}),p.run(function(t){var e=h.get();t.setRect({x:e.x*n+a,y:e.y*n+c,w:e.w*n,h:e.h*n}),t.setClampRect({x:a,y:c,w:i,h:u}),t.setViewPortRect({x:0,y:0,w:o,h:r})})})}function _(t,e){var n,i=Mt.fromTag("img");return oe(i,"src",e),n=i.dom,new Mp(function(t){var e=function(){n.removeEventListener("load",e),t(n)};n.complete?t(n):n.addEventListener("load",e)}).then(function(){t.getSystem().isConnected()&&b.getOpt(t).map(function(t){var e=Ou({element:i});Rg.replaceAt(t,1,vt.some(e));var n=v.get(),o={x:0,y:0,w:i.dom.naturalWidth,h:i.dom.naturalHeight};v.set(o);var u,r=qS.inflate(o,-20,-20);h.set(r),n.w===o.w&&n.h===o.h||(u=i,b.getOpt(t).each(function(t){var e=Ce(t.element),n=xe(t.element),o=u.dom.naturalWidth,r=u.dom.naturalHeight,i=Math.min(e/o,n/r);1<=i?g.set(1):g.set(i)})),O(t,i)})})}return{dom:{tag:"div",attributes:{role:"presentation"}},components:[C.memContainer.asSpec(),S.memContainer.asSpec(),k.container],behaviours:ec([Df.config({store:{mode:"manual",getValue:function(){return y.getBlobState()}}}),mm("image-tools-events",[Cr(jS.undo(),function(e,t){var n=y.undo();w(e,n).then(function(t){x(e),i(e)})}),Cr(jS.redo(),function(e,t){var n=y.redo();w(e,n).then(function(t){x(e),i(e)})}),Cr(jS.zoom(),function(t,e){var n=e.event.direction;S.zoom(t,n)}),Cr(jS.back(),function(t,e){var n,o=s(n=t);w(n,o).then(function(t){x(n)}),(0,e.event.swap)(),S.hideCrop()}),Cr(jS.apply(),function(t,e){y.applyTempState(function(){s(t),(0,e.event.swap)()})}),Cr(jS.transform(),function(t,e){return r(t,e.event.transform,st)}),Cr(jS.tempTransform(),function(t,e){var n=e.event.transform;c(t,y.getTempState().blob,n,function(t){return y.addTempState(t)},st)}),Cr(jS.transformApply(),function(t,e){var n=t,o=e.event.transform,r=e.event.swap,i=y.getBlobState().blob;c(n,i,o,function(t){var e=y.addBlobState(t);return s(n),e},r)}),Cr(jS.swap(),function(e,t){k.updateButtonUndoStates(e,!1,!1);var n=t.event.transform,o=t.event.swap;n.fold(function(){o()},function(t){r(e,t,o)})})]),aw()])}}function rk(t){return!Tt(t,"items")}function ik(t,e){function n(t){return{dom:{tag:"td",innerHtml:e.translate(t)}}}return{dom:{tag:"table",classes:["tox-dialog__table"]},components:[{dom:{tag:"thead"},components:[{dom:{tag:"tr"},components:B(t.header,function(t){return{dom:{tag:"th",innerHtml:e.translate(t)}}})}]},{dom:{tag:"tbody"},components:B(t.cells,function(t){return{dom:{tag:"tr"},components:B(t,n)}})}],behaviours:ec([py.config({}),Vg.config({})])}}function uk(n,e){var t=n.label.map(function(t){return oy(t,e)}),o=[gd.config({disabled:function(){return n.disabled||e.isDisabled()}}),pv(),Fg.config({mode:"execution",useEnter:!0!==n.multiline,useControlEnter:!0===n.multiline,execute:function(t){return vr(t,ky),vt.some(!0)}}),mm("textfield-change",[Cr(Si(),function(t,e){br(t,yy,{name:n.name})}),Cr(Mi(),function(t,e){br(t,yy,{name:n.name})})]),py.config({})],r=n.validation.map(function(o){return Ky.config({getRoot:function(t){return Yt(t.element)},invalidClass:"tox-invalid",validator:{validate:function(t){var e=Df.getValue(t),n=o.validator(e);return Gy(!0===n?Nn.value(e):Nn.error(n))},validateOnLoad:o.validateOnLoad}})}).toArray(),i=n.placeholder.fold(rt({}),function(t){return{placeholder:e.translate(t)}}),u=n.inputMode.fold(rt({}),function(t){return{inputmode:t}}),a=lt(lt({},i),u);return ny(t,my.parts.field({tag:!0===n.multiline?"textarea":"input",inputAttributes:a,inputClasses:[n.classname],inputBehaviours:ec(ft([o,r])),selectOnFocus:!1,factory:Dy}),(n.flex?["tox-form__group--stretched"]:[]).concat(n.maximized?["tox-form-group--maximize"]:[]),[gd.config({disabled:function(){return n.disabled||e.isDisabled()},onDisabled:function(t){my.getField(t).each(gd.disable)},onEnabled:function(t){my.getField(t).each(gd.enable)}}),pv()])}function ak(t){var e=Po(null);return wu({readState:function(){return{timer:null!==e.get()?"set":"unset"}},setTimer:function(t){e.set(t)},cancel:function(){var t=e.get();null!==t&&t.cancel()}})}function ck(t,e,n){var o=Df.getValue(n);Df.setValue(e,o),s1(e)}function sk(t,e){var n=t.element,o=Qr(n),r=n.dom;"number"!==ie(n,"type")&&e(r,o)}function lk(t){return{type:"menuitem",value:t.url,text:t.title,meta:{attach:t.attach},onAction:st}}function fk(t,e){return{type:"menuitem",value:e,text:t,meta:{attach:void 0},onAction:st}}function dk(t,e){return n=t,B(F(e,function(t){return t.type===n}),lk);var n}function mk(t,e){var n=t.toLowerCase();return F(e,function(t){return ut((void 0!==t.meta&&void 0!==t.meta.text?t.meta:t).text.toLowerCase(),n)||ut(t.value.toLowerCase(),n)})}function gk(u,a,c){function r(t){var e=Df.getValue(t);c.addToHistory(e.value,u.filetype)}var t,e,n,o,i=a.shared.providers,s=my.parts.field({factory:m1,dismissOnBlur:!0,inputClasses:["tox-textfield"],sandboxClasses:["tox-dialog__popups"],inputAttributes:{"aria-errormessage":v1,type:"url"},minChars:0,responseTime:0,fetch:function(t){var n,o,e,r,i=j0((n=u.filetype,o=c,e=Df.getValue(t),r=void 0!==e.meta.text?e.meta.text:e.value,o.getLinkInformation().fold(function(){return[]},function(t){var e=mk(r,B(o.getHistory(n),function(t){return fk(t,t)}));return"file"===n?R([e,mk(r,dk("header",t.targets)),mk(r,ft([vt.from(t.anchorTop).map(function(t){return fk("<top>",t)}).toArray(),dk("anchor",t.targets),vt.from(t.anchorBottom).map(function(t){return fk("<bottom>",t)}).toArray()]))],function(t,e){return 0===t.length||0===e.length?t.concat(e):t.concat(h1,e)},[]):e})),Sh.BUBBLE_TO_SANDBOX,a,!1);return Gy(i)},getHotspot:function(t){return p.getOpt(t)},onSetValue:function(t,e){t.hasConfigured(Ky)&&Ky.run(t).get(st)},typeaheadBehaviours:ec(ft([c.getValidationHandler().map(function(n){return Ky.config({getRoot:function(t){return Yt(t.element)},invalidClass:"tox-control-wrap--status-invalid",notify:{onInvalid:function(t,e){f.getOpt(t).each(function(t){oe(t.element,"title",i.translate(e))})}},validator:{validate:function(t){var e=Df.getValue(t);return p1(function(o){n({type:u.filetype,url:e.value},function(t){var e,n;"invalid"===t.status?(e=Nn.error(t.message),o(e)):(n=Nn.value(t.message),o(n))})})},validateOnLoad:!1}})}).toArray(),[gd.config({disabled:function(){return u.disabled||i.isDisabled()}}),py.config({}),mm("urlinput-events",ft(["file"===u.filetype?[Cr(Si(),function(t){br(t,yy,{name:u.name})})]:[],[Cr(ki(),function(t){br(t,yy,{name:u.name}),r(t)}),Cr(Mi(),function(t){br(t,yy,{name:u.name}),r(t)})]]))]])),eventOrder:((t={})[Si()]=["streaming","urlinput-events","invalidating"],t),model:{getDisplayText:function(t){return t.value},selectsOver:!1,populateFromBrowse:!1},markers:{openClass:"tox-textfield--popup-open"},lazySink:a.shared.getSink,parts:{menu:Zp(0,0,"normal")},onExecute:function(t,e,n){br(e,ky,{})},onItemExecute:function(t,e,n,o){r(t),br(t,yy,{name:u.name})}}),l=u.label.map(function(t){return oy(t,i)}),f=Hm((e="invalid",n=vt.some(v1),Xm("warning",{tag:"div",classes:["tox-icon","tox-control-wrap__status-icon-"+e],attributes:lt({title:i.translate(o=void 0===o?e:o),"aria-live":"polite"},n.fold(function(){return{}},function(t){return{id:t}}))},i.icons))),d=Hm({dom:{tag:"div",classes:["tox-control-wrap__status-icon-wrap"]},components:[f.asSpec()]}),m=c.getUrlPicker(u.filetype),g=Ir("browser.url.event"),p=Hm({dom:{tag:"div",classes:["tox-control-wrap"]},components:[s,d.asSpec()],behaviours:ec([gd.config({disabled:function(){return u.disabled||i.isDisabled()}})])}),h=Hm(J0({name:u.name,icon:vt.some("browse"),text:u.label.getOr(""),disabled:u.disabled,primary:!1,borderless:!0},function(t){return vr(t,g)},i,[],["tox-browse-url"]));return my.sketch({dom:by([]),components:l.toArray().concat([{dom:{tag:"div",classes:["tox-form__controls-h-stack"]},components:ft([[p.asSpec()],m.map(function(){return h.asSpec()}).toArray()])}]),fieldBehaviours:ec([gd.config({disabled:function(){return u.disabled||i.isDisabled()},onDisabled:function(t){my.getField(t).each(gd.disable),h.getOpt(t).each(gd.disable)},onEnabled:function(t){my.getField(t).each(gd.enable),h.getOpt(t).each(gd.enable)}}),pv(),mm("url-input-events",[Cr(g,function(o){cd.getCurrent(o).each(function(e){var t=Df.getValue(e),n=lt({fieldname:u.name},t);m.each(function(t){t(n).get(function(t){Df.setValue(e,t),br(o,yy,{name:u.name})})})})})])])})}function pk(r){return function(e,n,o){return tt(n,"name").fold(function(){return r(n,o)},function(t){return e.field(t,r(n,o))})}}function hk(e,t,n){var o=Yo(n,{shared:{interpreter:function(t){return x1(e,t,o)}}});return x1(e,t,o)}function vk(t,e,n){function o(){return Mt.fromDom(t.getContentAreaContainer())}function r(){return p||!n()}var i,u,a,c,s,l,f,d,m,g,p=sv(t);return{inlineDialog:(f=o,d=e,m=r,g={maxHeightFunction:Nc()},function(){return m()?{type:"node",root:te(f()),node:vt.from(f()),bubble:Sc(12,12,w1),layouts:{onRtl:function(){return[Mm]},onLtr:function(){return[Bm]}},overrides:g}:{type:"hotspot",hotspot:d(),bubble:Sc(-12,12,w1),layouts:{onRtl:function(){return[Xa]},onLtr:function(){return[Ya]}},overrides:g}}),banner:(c=o,s=e,l=r,function(){return l()?{type:"node",root:te(c()),node:vt.from(c()),layouts:{onRtl:function(){return[cp]},onLtr:function(){return[cp]}}}:{type:"hotspot",hotspot:s(),layouts:{onRtl:function(){return[$a]},onLtr:function(){return[$a]}}}}),cursor:(u=t,function(){return{type:"selection",root:a(),getSelection:function(){var t=u.selection.getRng();return vt.some(ms.range(Mt.fromDom(t.startContainer),t.startOffset,Mt.fromDom(t.endContainer),t.endOffset))}}}),node:(i=a=function(){return Mt.fromDom(t.getBody())},function(t){return{type:"node",root:i(),node:t}})}}function bk(i){return vt.from(i.getParam("style_formats")).filter(c).map(function(t){var e,n,o=(e=i,n=k1(t),e.formatter?r(n.customFormats):e.on("init",function(){r(n.customFormats)}),n.formats);function r(t){St(t,function(t){e.formatter.has(t.name)||e.formatter.register(t.name,t.format)})}return i.getParam("style_formats_merge",!1,"boolean")?S1.concat(o):o}).getOr(S1)}function yk(t,e,n){var o={type:"formatter",isSelected:e(t.format),getStylePreview:n(t.format)};return Yo(t,o)}function xk(c,t,s,l){var f=function(t){return B(t,function(t){var e,n,o,r,i,u=Ct(t);if(et(t,"items")){var a=f(t.items);return Yo(Yo(t,{type:"submenu"}),{getStyleItems:rt(a)})}return et(t,"format")?yk(t,s,l):1===u.length&&wt(u,"title")?Yo(t,{type:"separator"}):(r={type:"formatter",format:o="custom-"+(n=y((e=t).name)?e.name:Ir(e.title)),isSelected:s(o),getStylePreview:l(o)},i=Yo(e,r),c.formatter.register(n,i),i)})};return f(t)}function wk(n){return function(t){if(k(e=t)&&1===e.nodeType){if(t.contentEditable===n)return!0;if(t.getAttribute("data-mce-contenteditable")===n)return!0}var e;return!1}}function Sk(t,e,n,o,r){return{type:t,title:e,url:n,level:o,attach:r}}function kk(t){return t.innerText||t.textContent}function Ck(t){return t&&"A"===t.nodeName&&void 0!==(t.id||t.name)&&JC(t)}function Ok(t){return t&&/^(H[1-6])$/.test(t.nodeName)}function _k(t){return Ok(t)&&JC(t)}function Tk(t){var e,n=t.id||Ir("h");return Sk("header",kk(t),"#"+n,Ok(e=t)?parseInt(e.nodeName.substr(1),10):0,function(){t.id=n})}function Ek(t){var e=t.id||t.name;return Sk("anchor",kk(t)||"#"+e,"#"+e,0,st)}function Dk(t){return 0<C1(t.title).length}function Ak(t){return y(t)&&/^https?/.test(t)}function Bk(t){return x(t)&&Q(t,function(t){return!(c(e=t)&&e.length<=5&&L(e,Ak));var e}).isNone()}function Mk(){var t,e=db.getItem(E1);if(null===e)return{};try{t=JSON.parse(e)}catch(t){if(t instanceof SyntaxError)return console.log("Local storage "+E1+" was not valid JSON",t),{};throw t}return Bk(t)?t:(console.log("Local storage "+E1+" was not valid format",t),{})}function Fk(t){return tt(Mk(),t).getOr([])}function Ik(e,t){var n,o;Ak(e)&&(o=F(tt(n=Mk(),t).getOr([]),function(t){return t!==e}),n[t]=[e].concat(o).slice(0,5),function(t){if(!Bk(t))throw new Error("Bad format for history:\n"+JSON.stringify(t));db.setItem(E1,JSON.stringify(t))}(n))}function Rk(t){return!!t}function Nk(t){return dt(fS.makeMap(t,/[, ]/),Rk)}function Pk(t){return vt.from(t.getParam("file_picker_callback")).filter(S)}function Vk(t){return vt.from(t).filter(y).getOrUndefined()}function Hk(l){return{getHistory:Fk,addToHistory:Ik,getLinkInformation:function(){return!1===(t=l).getParam("typeahead_urls")?vt.none():vt.some({targets:T1(t.getBody()),anchorTop:Vk(t.getParam("anchor_top","#top")),anchorBottom:Vk(t.getParam("anchor_bottom","#bottom"))});var t},getValidationHandler:function(){return vt.from(void 0===(e=(t=l).getParam("file_picker_validator_handler",void 0,"function"))?t.getParam("filepicker_validator_handler",void 0,"function"):e);var t,e},getUrlPicker:function(t){return e=c=l,n=s=t,r=vt.some((o=e).getParam("file_picker_types")).filter(Rk),i=vt.some(o.getParam("file_browser_callback_types")).filter(Rk),u=r.or(i).map(Nk),a=Pk(o).fold(T,function(t){return u.fold(D,function(t){return 0<Ct(t).length&&t})}),(w(a)?a?Pk(e):vt.none():a[n]?Pk(e):vt.none()).map(function(o){return function(e){return Wy(function(n){var t=lt({filetype:s,fieldname:e.fieldname},vt.from(e.meta).getOr({}));o.call(c,function(t,e){if(!y(t))throw new Error("Expected value to be string");if(void 0!==e&&!x(e))throw new Error("Expected meta to be a object");n({value:t,meta:e})},e.value,t)})}});var e,n,o,r,i,u,a,c,s}}}function Lk(t,e,n){var o,r,i,u,a,c,s,l,f,d,m,g,p,h=Po(!1),v={isPositionedAtTop:function(){return"top"===o.get()},getDockingMode:(o=Po(av(e)?"bottom":"top")).get,setDockingMode:o.set},b={shared:{providers:{icons:function(){return e.ui.registry.getAll().icons},menuItems:function(){return e.ui.registry.getAll().menuItems},translate:dp.translate,isDisabled:function(){return e.mode.isReadOnly()||e.ui.isDisabled()},getSetting:e.getParam.bind(e)},interpreter:function(t){return x1(y1,t,b)},anchors:vk(e,n,v.isPositionedAtTop),header:v,getSink:function(){return Nn.value(t)}},urlinput:Hk(e),styleselect:(f=Po([]),d=Po([]),m=Po([]),g=Po([]),p=Po(!(l=function(t){var e=t.items;return void 0!==e&&0<e.length?H(e,l):[t.format]})),(s=e).on("PreInit",function(t){var e=bk(s),n=xk(s,e,y,x);f.set(n),d.set(H(n,l))}),s.on("addStyleModifications",function(t){var e=xk(s,t.items,y,x);m.set(e),p.set(t.replace),g.set(H(e,l))}),{getData:function(){var t=p.get()?[]:f.get(),e=m.get();return t.concat(e)},getFlattenedKeys:function(){var t=p.get()?[]:d.get(),e=g.get();return t.concat(e)}}),colorinput:{colorPicker:function(t,e){Ib(c)(t,e)},hasCustomColors:function(){return gb(a)},getColors:function(){return pb(u)},getColorCols:(i=u=a=c=e,function(){return vb(i)})},dialog:{isDraggableModal:(r=e,function(){return r.getParam("draggable_modal",!1,"boolean")})},isContextMenuOpen:function(){return h.get()},setContextMenuState:function(t){return h.set(t)}};function y(t){return function(){return s.formatter.match(t)}}function x(e){return function(){var t=s.formatter.get(e);return void 0!==t?vt.some({tag:0<t.length&&(t[0].inline||t[0].block)||"div",styles:s.dom.parseStyle(s.formatter.getCssText(e))}):vt.none()}}return b}function zk(t){return(mt(pe(t,"position"),"fixed")?vt.none():qt(t)).orThunk(function(){var n=Mt.fromTag("span");return Yt(t).bind(function(t){Tn(t,n);var e=qt(n);return En(n),e})})}function Uk(t){return zk(t).map(ke).getOrThunk(function(){return kn(0,0)})}function jk(t,e){var n=t.element;Yr(n,e.transitionClass),qr(n,e.fadeOutClass),Yr(n,e.fadeInClass),e.onShow(t)}function Wk(t,e){var n=t.element;Yr(n,e.transitionClass),qr(n,e.fadeInClass),Yr(n,e.fadeOutClass),e.onHide(t)}function Gk(t,e,n){return L(t,function(t){switch(t){case"bottom":return e.bottom<=n.bottom;case"top":return e.y>=n.y}})}function Xk(e,t){return t.getInitialPos().map(function(t){return Bn(t.bounds.x,t.bounds.y,Ce(e),xe(e))})}function Yk(n,o,r){return r.getInitialPos().bind(function(t){switch(r.clearInitialPos(),t.position){case"static":return vt.some(H1.static());case"absolute":var e=zk(n).map(Mn).getOrThunk(function(){return Mn(bn())});return vt.some(H1.absolute(Ea("absolute",tt(t.style,"left").map(function(t){return o.x-e.x}),tt(t.style,"top").map(function(t){return o.y-e.y}),tt(t.style,"right").map(function(t){return e.right-o.right}),tt(t.style,"bottom").map(function(t){return e.bottom-o.bottom}))));default:return vt.none()}})}function qk(t,e,n){var o,r,i,u=t.element;return mt(pe(u,"position"),"fixed")?(r=e,Xk(o=u,i=n).filter(function(t){return Gk(i.getModes(),t,r)}).bind(function(t){return Yk(o,t,i)})):function(t,e,n){var r,o,i=Mn(t);if(Gk(n.getModes(),i,e))return vt.none();r=t,o=i,n.setInitialPos({style:function(){var t={},e=r.dom;if(ct(e))for(var n=0;n<e.style.length;n++){var o=e.style.item(n);t[o]=e.style[o]}return t}(),position:ge(r,"position")||"static",bounds:o});var u=Fn(),a=i.x-u.x,c=e.y-u.y,s=u.bottom-e.bottom,l=i.y<=e.y;return vt.some(H1.fixed(Ea("fixed",vt.some(a),l?vt.some(c):vt.none(),vt.none(),l?vt.none():vt.some(s))))}(u,e,n)}function Kk(e,t,n){n.setDocked(!1),St(["left","right","top","bottom","position"],function(t){return ve(e.element,t)}),t.onUndocked(e)}function Jk(t,e,n,o){var r="fixed"===o.position;n.setDocked(r),Da(t.element,o),(r?e.onDocked:e.onUndocked)(t)}function $k(o,t,r,i,u){void 0===u&&(u=!1),t.contextual.each(function(n){n.lazyContext(o).each(function(t){var e=t.y<i.bottom&&t.bottom>i.y;e!==r.isVisible()&&(r.setVisible(e),u&&!e?(Jr(o.element,[n.fadeOutClass]),n.onHide(o)):(e?jk:Wk)(o,n))})})}function Qk(t,e,n){var o,r,i,u,a,c;n.isDocked()&&(r=e,i=n,c=(o=t).element,i.setDocked(!1),Xk(a=o.element,u=i).bind(function(t){return Yk(a,t,u)}).each(function(t){t.fold(function(){return Kk(o,r,i)},function(t){return Jk(o,r,i,t)},st)}),i.setVisible(!0),r.contextual.each(function(t){$r(c,[t.fadeInClass,t.fadeOutClass,t.transitionClass]),t.onShow(o)}),L1(o,r,i))}function Zk(t,e){return wt(j1.getModes(t),e)}function tC(r){var i=r.element;Yt(i).each(function(t){var e,n,o="padding-"+j1.getModes(r)[0];j1.isDocked(r)?(e=Ce(t),fe(i,"width",e+"px"),fe(t,o,we(n=i)+(parseInt(ge(n,"margin-top"),10)||0)+(parseInt(ge(n,"margin-bottom"),10)||0)+"px")):(ve(i,"width"),ve(t,o))})}function eC(t,e){e?(qr(t,G1.fadeOutClass),Jr(t,[G1.transitionClass,G1.fadeInClass])):(qr(t,G1.fadeInClass),Jr(t,[G1.fadeOutClass,G1.transitionClass]))}function nC(t,e){var n=Mt.fromDom(t.getContainer());e?(Yr(n,X1),qr(n,Y1)):(Yr(n,Y1),qr(n,X1))}function oC(u,t){function o(e){r().each(function(t){return e(t.element)})}function e(t){u.inline||tC(t),nC(u,j1.isDocked(t)),t.getSystem().broadcastOn([xf()],{}),r().each(function(t){return t.getSystem().broadcastOn([xf()],{})})}var n,i=gc(),r=t.getSink,a=u.inline?[]:[ic.config({channels:((n={})[W1()]={onReceive:tC},n)})];return V([Vg.config({}),j1.config({contextual:lt({lazyContext:function(t){var e=we(t.element),n=u.inline?u.getContentAreaContainer():u.getContainer(),o=Mn(Mt.fromDom(n)),r=o.height-e,i=o.y+(Zk(t,"top")?0:e);return vt.some(Bn(o.x,i,o.width,r))},onShow:function(){o(function(t){return eC(t,!0)})},onShown:function(r){o(function(t){return $r(t,[G1.transitionClass,G1.fadeInClass])}),i.get().each(function(t){var e,n=r.element,o=jt(e=t);Oa(o).filter(function(t){return!zt(e,t)}).filter(function(t){return zt(t,Mt.fromDom(o.dom.body))||Ut(n,t)}).each(function(){return ka(e)}),i.clear()})},onHide:function(t){var e=t.element,n=r;_a(e).orThunk(function(){return n().toOptional().bind(function(t){return _a(t.element)})}).fold(i.clear,i.set),o(function(t){return eC(t,!1)})},onHidden:function(){o(function(t){return $r(t,[G1.transitionClass])})}},G1),lazyViewport:function(t){var e=Fn(),n=u.getParam("toolbar_sticky_offset",0,"number"),o=e.y+(Zk(t,"top")?n:0),r=e.height-(Zk(t,"bottom")?n:0);return Bn(e.x,o,e.width,r)},modes:[t.header.getDockingMode()],onDocked:e,onUndocked:e})],a,!0)}function rC(t){return ao("menubutton",$1,t)}function iC(e,t){return t.getAnimationRoot.fold(function(){return e.element},function(t){return t(e)})}function uC(t){return t.dimension.property}function aC(t,e){return t.dimension.getDimension(e)}function cC(t,e){$r(iC(t,e),[e.shrinkingClass,e.growingClass])}function sC(t,e){qr(t.element,e.openClass),Yr(t.element,e.closedClass),fe(t.element,uC(e),"0px"),be(t.element)}function lC(t,e){qr(t.element,e.closedClass),Yr(t.element,e.openClass),ve(t.element,uC(e))}function fC(t,e,n,o){n.setCollapsed(),fe(t.element,uC(e),aC(e,t.element)),be(t.element),cC(t,e),sC(t,e),e.onStartShrink(t),e.onShrunk(t)}function dC(t,e,n){var o=aC(e,t.element);("0px"===o?fC:function(t,e,n,o){var r=o.getOrThunk(function(){return aC(e,t.element)});n.setCollapsed(),fe(t.element,uC(e),r),be(t.element);var i=iC(t,e);qr(i,e.growingClass),Yr(i,e.shrinkingClass),sC(t,e),e.onStartShrink(t)})(t,e,n,vt.some(o))}function mC(t,e,n){var o=iC(t,e),r=Kr(o,e.shrinkingClass),i=aC(e,t.element);lC(t,e);var u=aC(e,t.element);(r?function(){fe(t.element,uC(e),i),be(t.element)}:function(){sC(t,e)})(),qr(o,e.shrinkingClass),Yr(o,e.growingClass),lC(t,e),fe(t.element,uC(e),u),n.setExpanded(),e.onStartGrow(t)}function gC(t,e,n){return!0===Kr(iC(t,e),e.growingClass)}function pC(t,e,n){return!0===Kr(iC(t,e),e.shrinkingClass)}function hC(t){return"<alloy.field."+t+">"}function vC(t){return{element:function(){return t.element.dom}}}function bC(t,n){cd.getCurrent(t).each(function(t){return Rg.set(t,[(e=n,uO.sketch(function(t){return{dom:{tag:"div",classes:["tox-sidebar__pane-container"]},components:(n=t,r=B(Ct(o=e),function(t){var e=o[t],n=co(ao("sidebar",aO,e));return{name:t,getApi:vC,onSetup:n.onSetup,onShow:n.onShow,onHide:n.onHide}}),B(r,function(t){var e=Po(st);return n.slot(t.name,{dom:{tag:"div",classes:["tox-sidebar__pane"]},behaviours:Kh([vv(t,e),bv(t,e),Cr(Ji(),function(e,t){var n=t.event;N(r,function(t){return t.name===n.name}).each(function(t){(n.visible?t.onShow:t.onHide)(t.getApi(e))})})])})})),slotBehaviours:Kh([ou(function(t){return uO.hideAllSlots(t)})])};var n,o,r}))]);var e})}function yC(t){return cd.getCurrent(t).bind(function(t){return nO.isGrowing(t)||nO.hasGrown(t)?cd.getCurrent(t).bind(function(e){return N(uO.getSlotNames(e),function(t){return uO.isShowing(e,t)})}):vt.none()})}function xC(t){var e=Mt.fromHtml(t),n=Kt(e),o=R(void 0!==e.dom.attributes?e.dom.attributes:[],function(t,e){var n;return"class"===e.name?t:lt(lt({},t),((n={})[e.name]=e.value,n))},{}),r=Array.prototype.slice.call(e.dom.classList,0),i=0===n.length?{}:{innerHtml:Br(e)};return lt({tag:Ft(e),classes:r,attributes:o},i)}function wC(t){return cd.getCurrent(t).each(function(t){return ka(t.element)})}function SC(f,d,m){function e(t){var e;!g.get()||"focusin"===(e=t).type&&(e.composed?Y(e.composedPath()):vt.from(e.target)).map(Mt.fromDom).filter(Ge).exists(function(t){return Kr(t,"mce-pastebin")})||(t.preventDefault(),wC(d()),f.editorManager.setActive(f))}var g=Po(!1),n=gc();function o(t){var e,n,o,r,i,u,a,c,s,l;t!==g.get()&&(g.set(t),e=f,n=d(),o=t,r=m.providers,c=n.element,s=o,l="data-mce-"+(i="tabindex"),vt.from(e.iframeElement).map(Mt.fromDom).each(function(e){s?(ue(e,i).each(function(t){return oe(e,l,t)}),oe(e,i,-1)):(ce(e,i),ue(e,l).each(function(t){oe(e,i,t),ce(e,l)}))}),o?(fO.block(n,(a=r,function(t,e){return{dom:{tag:"div",attributes:{"aria-label":a.translate("Loading..."),tabindex:"0"},classes:["tox-throbber__busy-spinner"]},components:[{dom:xC('<div class="tox-spinner"><div></div><div></div><div></div></div>')}]}})),ve(c,"display"),ce(c,"aria-hidden"),e.hasFocus()&&wC(n)):(u=cd.getCurrent(n).exists(function(t){return Ca(t.element)}),fO.unblock(n),fe(c,"display","none"),oe(c,"aria-hidden","true"),u&&e.focus()),f.fire("AfterProgressState",{state:t}))}f.inline||f.on("PreInit",function(){f.dom.bind(f.getWin(),"focusin",e),f.on("BeforeExecCommand",function(t){"mcefocus"===t.command.toLowerCase()&&!0!==t.value&&e(t)})}),f.on("ProgressState",function(t){var e;n.on(lp.clearTimeout),u(t.time)?(e=lp.setEditorTimeout(f,function(){return o(t.state)},t.time),n.set(e)):(o(t.state),n.clear())})}function kC(t,e,n){return{within:t,extra:e,withinWidth:n}}function CC(t,e,o){var n,r=(n=function(t,e){var n=o(t);return vt.some({element:t,start:e,finish:e+n,width:n})},R(t,function(e,t){return n(t,e.len).fold(rt(e),function(t){return{len:t.finish,list:e.list.concat([t])}})},{len:0,list:[]}).list),i=F(r,function(t){return t.finish<=e}),u=I(i,function(t,e){return t+e.width},0);return{within:i,extra:r.slice(i.length),withinWidth:u}}function OC(t){return B(t,function(t){return t.element})}function _C(t,e){var n=B(e,function(t){return Eu(t)});N1.setGroups(t,n)}function TC(t,e,n){var o,r,i,u,a,c,s,l,f,d,m,g,p,h,v,b,y,x,w,S,k=e.builtGroups.get();0!==k.length&&(o=gl(t,e,"primary"),r=$y.getCoupled(t,"overflowGroup"),fe(o.element,"visibility","hidden"),u=K(i=k.concat([r]),function(e){return _a(e.element).bind(function(t){return e.getSystem().getByDom(t).toOptional()})}),n([]),_C(o,i),a=Ce(o.element),0===(s=a,l=e.builtGroups.get(),d=r,y=(0===(m=CC(l,s,f=function(t){return Ce(t.element)})).extra.length?vt.some(m):vt.none()).getOrThunk(function(){return CC(l,s-f(d),f)}),x=y.within,w=y.extra,S=y.withinWidth,(c=1===w.length&&w[0].width<=f(d)?(b=S,kC(OC(x.concat(w)),[],b)):1<=w.length?(p=w,h=d,v=S,kC(OC(x).concat([h]),OC(p),v)):(g=S,kC(OC(x),[],g))).extra.length)?(Rg.remove(o,r),n([])):(_C(o,c.within),n(c.extra)),ve(o.element,"visibility"),be(o.element),u.each(Vg.focus))}function EC(t,e){var n=$y.getCoupled(t,"toolbarSandbox");bf.isOpen(n)?bf.close(n):bf.open(n,e.toolbar())}function DC(t,e,n,o){var r=n.getBounds.map(function(t){return t()}),i=n.lazySink(t).getOrDie();ff.positionWithinBounds(i,e,{anchor:{type:"hotspot",hotspot:t,layouts:o,overrides:{maxWidthFunction:pO()}}},r)}function AC(t,e,n,o,r){N1.setGroups(e,r),DC(t,e,n,o),zg.on(t)}function BC(t){return B(t,function(t){return Eu(t)})}function MC(t,n,o){TC(t,o,function(e){o.overflowGroups.set(e),n.getOpt(t).each(function(t){bO.setGroups(t,BC(e))})})}function FC(e,n){ml(e,n,"overflow-button").bind(function(){return ml(e,n,"overflow")}).each(function(t){QC(e,n),nO.toggleGrow(t)})}function IC(t){var e=t.title.fold(function(){return{}},function(t){return{attributes:{title:t}}});return{dom:lt({tag:"div",classes:["tox-toolbar__group"]},e),components:[wO.parts.items({})],items:t.items,markers:{itemSelector:"*:not(.tox-split-button) > .tox-tbtn:not([disabled]), .tox-split-button:not([disabled]), .tox-toolbar-nav-js:not([disabled])"},tgroupBehaviours:ec([py.config({}),Vg.config({})])}}function RC(t){return wO.sketch(IC(t))}function NC(n,t){var e=ou(function(t){var e=B(n.initGroups,RC);N1.setGroups(t,e)});return ec([Qv(n.providers.isDisabled),pv(),Fg.config({mode:t,onEscape:n.onEscape,selector:".tox-toolbar__group"}),mm("toolbar-events",[e])])}function PC(t){var e=t.cyclicKeying?"cyclic":"acyclic";return{uid:t.uid,dom:{tag:"div",classes:["tox-toolbar-overlord"]},parts:{"overflow-group":IC({title:vt.none(),items:[]}),"overflow-button":Y0({name:"more",icon:vt.some("more-drawer"),disabled:!1,tooltip:vt.some("More..."),primary:!1,borderless:!1},vt.none(),t.providers)},splitToolbarBehaviours:NC(t,e)}}function VC(t){var e=t.cyclicKeying?"cyclic":"acyclic";return N1.sketch({uid:t.uid,dom:{tag:"div",classes:["tox-toolbar"].concat(t.type===bh.scrolling?["tox-toolbar--scrolling"]:[])},components:[N1.parts.groups({})],toolbarBehaviours:NC(t,e)})}function HC(t){return"string"==typeof t?t.split(" "):t}function LC(i,u){var a=lt(lt({},IO),u.menus),n=0<Ct(u.menus).length,t=F(void 0===u.menubar||!0===u.menubar?HC("file edit view insert format tools table help"):HC(!1===u.menubar?"":u.menubar),function(t){var e=Tt(IO,t);return n?e||tt(u.menus,t).exists(function(t){return Tt(t,"items")}):e});return F(B(t,function(t){var e=a[t],n={title:e.title,items:HC(e.items)},o=u,r=i.getParam("removed_menuitems","").split(/[ ,]/);return{text:n.title,getItems:function(){return H(n.items,function(t){var e=t.toLowerCase();return 0===e.trim().length||d(r,function(t){return t===e})?[]:"separator"===e||"|"===e?[{type:"separator"}]:o.menuItems[e]?[o.menuItems[e]]:[]})}}}),function(t){return 0<t.getItems().length&&d(t.getItems(),function(t){return"separator"!==t.type})})}function zC(t){function e(){t._skinLoaded=!0,t.fire("SkinLoaded")}return function(){t.initialized?e():t.on("init",e)}}function UC(n,o,r){return new Mp(function(t,e){r.load(o,t,e),n.on("remove",function(){return r.unload(o)})})}function jC(t,e){var n,o,r,i,u,a,c,s,l,f=(r=(n=e).getParam("skin"),i=n.getParam("skin_url"),!1!==r&&(o=r||"oxide",i=i?n.documentBaseURI.toAbsolute(i):ov.baseURL+"/skins/ui/"+o),i);f&&e.contentCSS.push(f+(t?"/content.inline":"/content")+".min.css"),!1===e.getParam("skin")==0&&y(f)?Mp.all([UC(e,f+"/skin.min.css",e.ui.styleSheetLoader),(c=e,s=f,l=Mt.fromDom(c.getElement()),pn(l).isSome()?UC(c,s+"/skin.shadowdom.min.css",nv.DOM.styleSheetLoader):Mp.resolve())]).then(zC(e),(u=e,a="Skin could not be loaded",function(){return u.fire("SkinLoadError",{message:a})})):zC(e)()}function WC(o,r){return function(e){function t(){e.setActive(o.formatter.match(r));var t=o.formatter.formatChanged(r,e.setActive);n.set(t)}var n=mc();return o.initialized?t():o.once("init",t),function(){o.off("init",t),n.clear()}}}function GC(o,r,i){return function(t){function e(){return i(t)}function n(){i(t),o.on(r,e)}return o.initialized?n():o.once("init",n),function(){o.off("init",n),o.off(r,e)}}}function XC(e){return function(t){return function(){e.undoManager.transact(function(){e.focus(),e.execCommand("mceToggleFormat",!1,t.format)})}}}function YC(t,e){return function(){return t.execCommand(e)}}function qC(t,e,n){var u,a,c,o=n.dataset,r="basic"===o.type?function(){return B(o.data,function(t){return yk(t,n.isSelectedFor,n.getPreviewFor)})}:o.getData;return{items:(u=e,a=n,c=function(t,e,n){var o="formatter"===t.type&&a.isInvalid(t);return 0===e?o?[]:i(t,e,!1,n).toArray():i(t,e,o,n).toArray()},{validateItems:s,getFetch:function(n,o){return function(t,e){e(j0(s(o()),Sh.CLOSE_ON_EXECUTE,n,!1))}}}),getStyleItems:r};function i(t,e,n,o){var r=u.shared.providers.translate(t.title);if("separator"===t.type)return vt.some({type:"separator",text:r});if("submenu"!==t.type)return vt.some(lt({type:"togglemenuitem",text:r,icon:t.icon,active:t.isSelected(o),disabled:n,onAction:a.onAction(t)},t.getStylePreview().fold(function(){return{}},function(t){return{meta:{style:t}}})));var i=H(t.getStyleItems(),function(t){return c(t,e,o)});return 0===e&&i.length<=0?vt.none():vt.some({type:"nestedmenuitem",text:r,disabled:i.length<=0,getSubmenuItems:function(){return H(t.getStyleItems(),function(t){return c(t,e,o)})}})}function s(t){var e=a.getCurrentValue(),n=a.shouldHide?0:1;return H(t,function(t){return c(t,n,e)})}}function KC(t,e,n){var o=qC(0,e,n),r=o.items,i=o.getStyleItems,u=GC(t,"NodeChange",function(t){var e=t.getComponent();n.updateText(e)});return z0({text:n.icon.isSome()?vt.none():n.text,icon:n.icon,tooltip:vt.from(n.tooltip),role:vt.none(),fetch:r.getFetch(e,i),onSetup:u,getApi:function(t){return{getComponent:rt(t)}},columns:1,presets:"normal",classes:n.icon.isSome()?[]:["bespoke"],dropdownBehaviours:[]},"tox-tbtn",e.shared)}function JC(t){return function(t){for(;t=t.parentNode;){var e=t.contentEditable;if(e&&"inherit"!==e)return O1(t)}return!1}(t)&&!_1(t)}function $C(r,t){function e(t){return vl(r)}function n(n,o){return function(t,e){return ml(t,r,e).map(function(t){return n(t,e)}).getOr(o)}}function o(t,e){return"true"!==ie(t.element,"aria-hidden")}var i,u=n(o,!1),a=n(function(t,e){var n;o(t)&&(fe(n=t.element,"display","none"),oe(n,"aria-hidden","true"),br(t,Ji(),{name:e,visible:!1}))}),c=(i=a,function(e,t){St(t,function(t){return i(e,t)})}),s=n(function(t,e){var n;o(t)||(ve(n=t.element,"display"),ce(n,"aria-hidden"),br(t,Ji(),{name:e,visible:!0}))});return{uid:r.uid,dom:r.dom,components:t,behaviours:tl(r.slotBehaviours),apis:{getSlotNames:e,getSlot:function(t,e){return ml(t,r,e)},isShowing:u,hideSlot:a,hideAllSlots:function(t){return c(t,e())},showSlot:s}}}function QC(t,e){ml(t,e,"overflow").each(function(n){TC(t,e,function(t){var e=B(t,function(t){return Eu(t)});N1.setGroups(n,e)}),ml(t,e,"overflow-button").each(function(t){nO.hasGrown(n)&&zg.on(t)}),nO.refresh(n)})}var ZC,t1,e1,n1="data-value",o1=function(e,n,t,o){return B(t,function(t){return rk(t)?{type:"togglemenuitem",text:t.text,value:t.value,active:t.value===o,onAction:function(){Df.setValue(e,t.value),br(e,yy,{name:n}),Vg.focus(e)}}:{type:"nestedmenuitem",text:t.text,getSubmenuItems:function(){return o1(e,n,t.items,o)}}})},r1=function(t,e){return K(t,function(t){return rk(t)?ot(t.value===e,t):r1(t.items,e)})},i1=kl({name:"HtmlSelect",configFields:[mo("options"),Zs("selectBehaviours",[Vg,Df]),Eo("selectClasses",[]),Eo("selectAttributes",{}),wo("data")],factory:function(n,t){var e=B(n.options,function(t){return{dom:{tag:"option",value:t.value,innerHtml:t.text}}}),o=n.data.map(function(t){return sr("initialValue",t)}).getOr({});return{uid:n.uid,dom:{tag:"select",classes:n.selectClasses,attributes:n.selectAttributes},components:e,behaviours:el(n.selectBehaviours,[Vg.config({}),Df.config({store:lt({mode:"manual",getValue:function(t){return Qr(t.element)},setValue:function(t,e){N(n.options,function(t){return t.value===e}).isSome()&&Zr(t.element,e)}},o)})])}}}),u1=Object.freeze({__proto__:null,events:function(t,e){var n=t.stream.streams.setup(t,e);return nu([Cr(t.event,n),ru(function(){return e.cancel()})].concat(t.cancelEvent.map(function(t){return[Cr(t,function(){return e.cancel()})]}).getOr([])))}}),a1=Object.freeze({__proto__:null,throttle:ak,init:function(t){return t.stream.streams.state(t)}}),c1=xa({fields:[go("stream",lo("mode",{throttle:[mo("delay"),Eo("stopEvent",!0),ta("streams",{setup:function(t,e){var n=t.stream,o=vp(t.onStream,n.delay);return e.setTimer(o),function(t,e){o.throttle(t,e),n.stopEvent&&e.stop()}},state:ak})]})),Eo("event","input"),wo("cancelEvent"),Qu("onStream")],name:"streaming",active:u1,state:a1}),s1=function(t){sk(t,function(t,e){return t.setSelectionRange(e.length,e.length)})},l1=rt("alloy.typeahead.itemexecute"),f1=rt([wo("lazySink"),mo("fetch"),Eo("minChars",5),Eo("responseTime",1e3),Ju("onOpen"),Eo("getHotspot",vt.some),Eo("getAnchorOverrides",rt({})),Eo("layouts",vt.none()),Eo("eventOrder",{}),No("model",{},[Eo("getDisplayText",function(t){return void 0!==t.meta&&void 0!==t.meta.text?t.meta.text:t.value}),Eo("selectsOver",!0),Eo("populateFromBrowse",!0)]),Ju("onSetValue"),$u("onExecute"),Ju("onItemExecute"),Eo("inputClasses",[]),Eo("inputAttributes",{}),Eo("inputStyles",{}),Eo("matchWidth",!0),Eo("useMinWidth",!1),Eo("dismissOnBlur",!0),qu(["openClass"]),wo("initialData"),Zs("typeaheadBehaviours",[Vg,Df,c1,Fg,zg,$y]),cr("previewing",function(){return Po(!0)})].concat(Ey()).concat(ux())),d1=rt([$f({schema:[Yu()],name:"menu",overrides:function(o){return{fakeFocus:!0,onHighlight:function(e,n){o.previewing.get()?e.getSystem().getByUid(o.uid).each(function(t){!function(t,e,o){if(t.selectsOver){var n=Df.getValue(e),r=t.getDisplayText(n),i=Df.getValue(o);return 0===t.getDisplayText(i).indexOf(r)?vt.some(function(){var n;ck(0,e,o),n=r.length,sk(e,function(t,e){return t.setSelectionRange(n,e.length)})}):vt.none()}return vt.none()}(o.model,t,n).fold(function(){return hd.dehighlight(e,n)},function(t){return t()})}):e.getSystem().getByUid(o.uid).each(function(t){o.model.populateFromBrowse&&ck(o.model,t,n)}),o.previewing.set(!1)},onExecute:function(t,e){return t.getSystem().getByUid(o.uid).toOptional().map(function(t){return br(t,l1(),{item:e}),!0})},onHover:function(t,e){o.previewing.set(!1),t.getSystem().getByUid(o.uid).each(function(t){o.model.populateFromBrowse&&ck(o.model,t,e)})}}}})]),m1=Cl({name:"Typeahead",configFields:f1(),partFields:d1(),factory:function(r,t,e,i){function n(t,e,n){r.previewing.set(!1);var o=$y.getCoupled(t,"sandbox");bf.isOpen(o)?cd.getCurrent(o).each(function(t){hd.getHighlighted(t).fold(function(){n(t)},function(){wr(o,t.element,"keydown",e)})}):ex(r,u(t),t,o,i,function(t){cd.getCurrent(t).each(n)},Vy.HighlightFirst).get(st)}function u(n){return function(t){return t.map(function(t){var e=H(Z(t.menus),function(t){return F(t.items,function(t){return"item"===t.type})});return Df.getState(n).update(B(e,function(t){return t.data})),t})}}var o=ry(r),a=[Vg.config({}),Df.config({onSetValue:r.onSetValue,store:lt({mode:"dataset",getDataKey:function(t){return Qr(t.element)},getFallbackEntry:function(t){return{value:t,meta:{}}},setValue:function(t,e){Zr(t.element,r.model.getDisplayText(e))}},r.initialData.map(function(t){return sr("initialValue",t)}).getOr({}))}),c1.config({stream:{mode:"throttle",delay:r.responseTime,stopEvent:!1},onStream:function(t,e){var n,o=$y.getCoupled(t,"sandbox");Vg.isFocused(t)&&Qr(t.element).length>=r.minChars&&(n=cd.getCurrent(o).bind(function(t){return hd.getHighlighted(t).map(Df.getValue)}),r.previewing.set(!0),ex(r,u(t),t,o,i,function(t){cd.getCurrent(o).each(function(t){n.fold(function(){r.model.selectsOver&&hd.highlightFirst(t)},function(e){hd.highlightBy(t,function(t){return Df.getValue(t).value===e.value}),hd.getHighlighted(t).orThunk(function(){return hd.highlightFirst(t),vt.none()})})})},Vy.HighlightFirst).get(st))},cancelEvent:Hi()}),Fg.config({mode:"special",onDown:function(t,e){return n(t,e,hd.highlightFirst),vt.some(!0)},onEscape:function(t){var e=$y.getCoupled(t,"sandbox");return bf.isOpen(e)?(bf.close(e),vt.some(!0)):vt.none()},onUp:function(t,e){return n(t,e,hd.highlightLast),vt.some(!0)},onEnter:function(e){var t=$y.getCoupled(e,"sandbox"),n=bf.isOpen(t);if(n&&!r.previewing.get())return cd.getCurrent(t).bind(function(t){return hd.getHighlighted(t)}).map(function(t){return br(e,l1(),{item:t}),!0});var o=Df.getValue(e);return vr(e,Hi()),r.onExecute(t,e,o),n&&bf.close(t),vt.some(!0)}}),zg.config({toggleClass:r.markers.openClass,aria:{mode:"expanded"}}),$y.config({others:{sandbox:function(t){return rx(r,t,{onOpen:function(){return zg.on(t)},onClose:function(){return zg.off(t)}})}}}),mm("typeaheadevents",[uu(function(t){nx(r,u(t),t,i,st,Vy.HighlightFirst).get(st)}),Cr(l1(),function(t,e){var n=$y.getCoupled(t,"sandbox");ck(r.model,t,e.event.item),vr(t,Hi()),r.onItemExecute(t,n,e.event.item,Df.getValue(t)),bf.close(n),s1(t)})].concat(r.dismissOnBlur?[Cr(Bi(),function(t){var e=$y.getCoupled(t,"sandbox");_a(e.element).isNone()&&bf.close(e)})]:[]))];return{uid:r.uid,dom:iy(Yo(r,{inputAttributes:{role:"combobox","aria-autocomplete":"list","aria-haspopup":"true"}})),behaviours:lt(lt({},o),el(r.typeaheadBehaviours,a)),eventOrder:r.eventOrder}}}),g1=function(i){return lt(lt({},i),{toCached:function(){return g1(i.toCached())},bindFuture:function(e){return g1(i.bind(function(t){return t.fold(function(t){return Gy(Nn.error(t))},function(t){return e(t)})}))},bindResult:function(e){return g1(i.map(function(t){return t.bind(e)}))},mapResult:function(e){return g1(i.map(function(t){return t.map(e)}))},mapError:function(e){return g1(i.map(function(t){return t.mapError(e)}))},foldResult:function(e,n){return i.map(function(t){return t.fold(e,n)})},withTimeout:function(t,r){return g1(Wy(function(e){var n=!1,o=setTimeout(function(){n=!0,e(Nn.error(r()))},t);i.get(function(t){n||(clearTimeout(o),e(t))})}))}})},p1=function(t){return g1(Wy(t))},h1={type:"separator"},v1=Ir("aria-invalid"),b1={bar:pk(function(t,e){return n=e.shared,{dom:{tag:"div",classes:["tox-bar","tox-form__controls-h-stack"]},components:B(t.items,n.interpreter)};var n}),collection:pk(function(t,e){return u=t,a=e.shared.providers,c=u.label.map(function(t){return oy(t,a)}),s=n(function(t,e,n,o){e.stop(),a.isDisabled()||br(t,Sy,{name:u.name,value:o})}),l=[Cr(vi(),n(function(t,e,n){ka(n)})),Cr(Ci(),s),Cr(Ni(),s),Cr(bi(),n(function(t,e,n){Iu(t.element,"."+Bh).each(function(t){qr(t,Bh)}),Yr(n,Bh)})),Cr(yi(),n(function(t){Iu(t.element,"."+Bh).each(function(t){qr(t,Bh)})})),uu(n(function(t,e,n,o){br(t,Sy,{name:u.name,value:o})}))],ny(c,my.parts.field({dom:{tag:"div",classes:["tox-collection"].concat(1!==u.columns?["tox-collection--grid"]:["tox-collection--list"])},components:[],factory:{sketch:h},behaviours:ec([gd.config({disabled:a.isDisabled,onDisabled:function(t){o(t,function(t){Yr(t,"tox-collection__item--state-disabled"),oe(t,"aria-disabled",!0)})},onEnabled:function(t){o(t,function(t){qr(t,"tox-collection__item--state-disabled"),ce(t,"aria-disabled")})}}),pv(),Rg.config({}),Df.config({store:{mode:"memory",initialValue:[]},onSetValue:function(o,t){var e=o,n=B(t,function(t){var e=dp.translate(t.text),n=1===u.columns?'<div class="tox-collection__item-label">'+e+"</div>":"",o='<div class="tox-collection__item-icon">'+t.icon+"</div>",r={_:" "," - ":" ","-":" "},i=e.replace(/\_| \- |\-/g,function(t){return r[t]});return'<div class="tox-collection__item'+(a.isDisabled()?" tox-collection__item--state-disabled":"")+'" tabindex="-1" data-collection-item-value="'+hy.encodeAllRaw(t.value)+'" title="'+i+'" aria-label="'+i+'">'+o+n+"</div>"}),r=B("auto"!==u.columns&&1<u.columns?p(n,u.columns):[n],function(t){return'<div class="tox-collection__group">'+t.join("")+"</div>"});Mr(e.element,r.join("")),"auto"===u.columns&&ah(o,5,"tox-collection__item").each(function(t){var e=t.numRows,n=t.numColumns;Fg.setGridSize(o,e,n)}),vr(o,Ty)}}),py.config({}),Fg.config(1===(i=u.columns)?{mode:"menu",moveOnTab:!1,selector:".tox-collection__item"}:"auto"===i?{mode:"flatgrid",selector:".tox-collection__item",initSize:{numColumns:1,numRows:1}}:{mode:"matrix",selectors:{row:".tox-collection__group",cell:"."+Ch}}),mm("collection-events",l)]),eventOrder:((r={})[Ii()]=["disabling","alloy.base.behaviour","collection-events"],r)}),["tox-form__group--collection"],[]);function n(o){return function(e,n){Ru(n.event.target,"[data-collection-item-value]").each(function(t){o(e,n,t,ie(t,"data-collection-item-value"))})}}function o(t,e){return B(vs(t.element,".tox-collection__item"),e)}var u,a,r,i,c,s,l}),alertbanner:pk(function(t,e){return o=e.shared.providers,ly.sketch({dom:{tag:"div",attributes:{role:"alert"},classes:["tox-notification","tox-notification--in","tox-notification--"+(n=t).level]},components:[{dom:{tag:"div",classes:["tox-notification__icon"]},components:[fp.sketch({dom:{tag:"button",classes:["tox-button","tox-button--naked","tox-button--icon"],innerHtml:jm(n.icon,o.icons),attributes:{title:o.translate(n.iconTooltip)}},action:function(t){br(t,Sy,{name:"alert-banner",value:n.url})},buttonBehaviours:ec([Wm()])})]},{dom:{tag:"div",classes:["tox-notification__body"],innerHtml:o.translate(n.text)}}]});var n,o}),input:pk(function(t,e){return o=e.shared.providers,uk({name:(n=t).name,multiline:!1,label:n.label,inputMode:n.inputMode,placeholder:n.placeholder,flex:!1,disabled:n.disabled,classname:"tox-textfield",validation:vt.none(),maximized:n.maximized},o);var n,o}),textarea:pk(function(t,e){return o=e.shared.providers,uk({name:(n=t).name,multiline:!0,label:n.label,inputMode:vt.none(),placeholder:n.placeholder,flex:!0,disabled:n.disabled,classname:"tox-textarea",validation:vt.none(),maximized:n.maximized},o);var n,o}),label:pk(function(t,e){return r={dom:{tag:"label",innerHtml:(o=e.shared).providers.translate((n=t).label),classes:["tox-label"]}},i=B(n.items,o.interpreter),{dom:{tag:"div",classes:["tox-form__group"]},components:[r].concat(i),behaviours:ec([aw(),Rg.config({}),cw(vt.none()),Fg.config({mode:"acyclic"})])};var n,o,r,i}),iframe:(ZC=function(t,e){return n=t,o=e.shared.providers,u=bS&&n.sandboxed,a=lt(lt({},n.label.map(function(t){return{title:t}}).getOr({})),u?{sandbox:"allow-scripts allow-same-origin"}:{}),r=u,i=Po(""),c={getValue:function(t){return i.get()},setValue:function(t,e){var n;r?oe(t.element,"srcdoc",e):(oe(t.element,"src","javascript:''"),(n=t.element.dom.contentWindow.document).open(),n.write(e),n.close()),i.set(e)}},ny(n.label.map(function(t){return oy(t,o)}),my.parts.field({factory:{sketch:function(t){return d0({uid:t.uid,dom:{tag:"iframe",attributes:a},behaviours:ec([py.config({}),Vg.config({}),gS(vt.none(),c.getValue,c.setValue)])})}}}),["tox-form__group--stretched"],[]);var n,o,r,i,u,a,c},function(t,e,n){var o=Yo(e,{source:"dynamic"});return pk(ZC)(t,o,n)}),button:pk(function(t,e){return n=t,o=e.shared.providers,r=$0(n.name,"custom"),ny(vt.none(),my.parts.field(lt({factory:fp},K0(n,vt.some(r),o,[pS(""),aw()]))),[],[]);var n,o,r}),checkbox:pk(function(t,e){return r=t,i=e.shared.providers,u=Df.config({store:{mode:"manual",getValue:function(t){return t.element.dom.checked},setValue:function(t,e){t.element.dom.checked=e}}}),a=my.parts.field({factory:{sketch:h},dom:{tag:"input",classes:["tox-checkbox__input"],attributes:{type:"checkbox"}},behaviours:ec([aw(),gd.config({disabled:function(){return r.disabled||i.isDisabled()}}),py.config({}),Vg.config({}),u,Fg.config({mode:"special",onEnter:n,onSpace:n,stopSpaceKeyup:!0}),mm("checkbox-events",[Cr(ki(),function(t,e){br(t,yy,{name:r.name})})])])}),c=my.parts.label({dom:{tag:"span",classes:["tox-checkbox__label"],innerHtml:i.translate(r.label)},behaviours:ec([vw.config({})])}),s=Hm({dom:{tag:"div",classes:["tox-checkbox__icons"]},components:[o("checked"),o("unchecked")]}),my.sketch({dom:{tag:"label",classes:["tox-checkbox"]},components:[a,s.asSpec(),c],fieldBehaviours:ec([gd.config({disabled:function(){return r.disabled||i.isDisabled()},disableClass:"tox-checkbox--disabled",onDisabled:function(t){my.getField(t).each(gd.disable)},onEnabled:function(t){my.getField(t).each(gd.enable)}}),pv()])});function n(t){return t.element.dom.click(),vt.some(!0)}function o(t){return Xm("checked"===t?"selected":"unselected",{tag:"span",classes:["tox-icon","tox-checkbox-icon__"+t]},i.icons)}var r,i,u,a,c,s}),colorinput:pk(function(t,e){return n=t,r=e.shared,i=e.colorinput,c=my.parts.field({factory:Dy,inputClasses:["tox-textfield"],onSetValue:function(t){return Ky.run(t).get(st)},inputBehaviours:ec([gd.config({disabled:r.providers.isDisabled}),pv(),py.config({}),Ky.config({invalidClass:"tox-textbox-field-invalid",getRoot:function(t){return Yt(t.element)},notify:{onValid:function(t){var e=Df.getValue(t);br(t,bw,{color:e})}},validator:{validateOnLoad:!1,validate:function(t){var e=Df.getValue(t);if(0===e.length)return Gy(Nn.value(!0));var n=Mt.fromTag("span");fe(n,"background-color",e);var o=pe(n,"background-color").fold(function(){return Nn.error("blah")},function(t){return Nn.value(e)});return Gy(o)}}})]),selectOnFocus:!1}),s=n.label.map(function(t){return oy(t,r.providers)}),l=Hm((u={dom:{tag:"span",attributes:{"aria-label":r.providers.translate("Color swatch")}},layouts:{onRtl:function(){return[Ya,Xa,$a]},onLtr:function(){return[Xa,Ya,$a]}},components:[],fetch:wb(i.getColors(),i.hasCustomColors()),columns:i.getColorCols(),presets:"color",onItemAction:function(t,n){l.getOpt(t).each(function(e){"custom"===n?i.colorPicker(function(t){t.fold(function(){return vr(e,xw)},function(t){o(e,t),hb(t)})},"#ffffff"):o(e,"remove"===n?"":n)})}},hw.sketch({dom:u.dom,components:u.components,toggleClass:"mce-active",dropdownBehaviours:ec([$v((a=r).providers.isDisabled),pv(),vw.config({}),py.config({})]),layouts:u.layouts,sandboxClasses:["tox-dialog__popups"],lazySink:a.getSink,fetch:function(e){return Wy(function(t){return u.fetch(t)}).map(function(t){return vt.from(Xb(Yo(Ob(Ir("menu-value"),t,function(t){u.onItemAction(e,t)},u.columns,u.presets,Sh.CLOSE_ON_EXECUTE,T,a.providers),{movement:_b(u.columns,u.presets)})))})},parts:{menu:Zp(0,0,u.presets)}}))),my.sketch({dom:{tag:"div",classes:["tox-form__group"]},components:s.toArray().concat([{dom:{tag:"div",classes:["tox-color-input"]},components:[c,l.asSpec()]}]),fieldBehaviours:ec([mm("form-field-events",[Cr(bw,function(t,e){l.getOpt(t).each(function(t){fe(t.element,"background-color",e.event.color)}),br(t,yy,{name:n.name})}),Cr(yw,function(e,n){my.getField(e).each(function(t){Df.setValue(t,n.event.value),cd.getCurrent(e).each(Vg.focus)})}),Cr(xw,function(e,t){my.getField(e).each(function(t){cd.getCurrent(e).each(Vg.focus)})})])])});function o(t,e){br(t,yw,{value:e})}var n,r,i,u,a,c,s,l}),colorpicker:pk(function(t){var r=Hm(a0(c0,function(t){return"tox-"+t}).sketch({dom:{tag:"div",classes:["tox-color-picker-container"],attributes:{role:"presentation"}},onValidHex:function(t){br(t,Sy,{name:"hex-valid",value:!0})},onInvalidHex:function(t){br(t,Sy,{name:"hex-valid",value:!1})}}));return{dom:{tag:"div"},components:[r.asSpec()],behaviours:ec([Df.config({store:{mode:"manual",getValue:function(t){var e=r.get(t);return cd.getCurrent(e).bind(function(t){return Df.getValue(t).hex}).map(function(t){return"#"+t}).getOr("")},setValue:function(t,e){var n=/^#([a-fA-F0-9]{3}(?:[a-fA-F0-9]{3})?)/.exec(e),o=r.get(t);cd.getCurrent(o).fold(function(){console.log("Can not find form")},function(t){Df.setValue(t,{hex:vt.from(n[1]).getOr("")}),nS.getField(t,"hex").each(function(t){vr(t,Si())})})}}}),aw()])}}),dropzone:pk(function(t,e){return l0(t,e.shared.providers)}),grid:pk(function(t,e){return n=e.shared,{dom:{tag:"div",classes:["tox-form__grid","tox-form__grid--"+t.columns+"col"]},components:B(t.items,n.interpreter)};var n}),listbox:pk(function(t,e){return n=t,r=(o=e).shared.providers,i=Y(n.items).filter(rk),u=n.label.map(function(t){return oy(t,r)}),a={dom:{tag:"div",classes:["tox-listboxfield"]},components:[my.parts.field({dom:{},factory:{sketch:function(t){return z0({uid:t.uid,text:i.map(function(t){return t.text}),icon:vt.none(),tooltip:n.label,role:vt.none(),fetch:function(t,e){e(j0(o1(t,n.name,n.items,Df.getValue(t)),Sh.CLOSE_ON_EXECUTE,o,!1))},onSetup:rt(st),getApi:rt({}),columns:1,presets:"normal",classes:[],dropdownBehaviours:[py.config({}),Df.config({store:{mode:"manual",initialValue:i.map(function(t){return t.value}).getOr(""),getValue:function(t){return ie(t.element,n1)},setValue:function(e,t){r1(n.items,t).each(function(t){oe(e.element,n1,t.value),br(e,NS,{text:t.text})})}}})]},"tox-listbox",o.shared)}}})]},my.sketch({dom:{tag:"div",classes:["tox-form__group"]},components:ft([u.toArray(),[a]]),fieldBehaviours:ec([gd.config({disabled:rt(n.disabled),onDisabled:function(t){my.getField(t).each(gd.disable)},onEnabled:function(t){my.getField(t).each(gd.enable)}})])});var n,o,r,i,u,a}),selectbox:pk(function(t,e){return n=t,o=e.shared.providers,r=B(n.items,function(t){return{text:o.translate(t.text),value:t.value}}),i=n.label.map(function(t){return oy(t,o)}),u={dom:{tag:"div",classes:["tox-selectfield"]},components:ft([[my.parts.field({dom:{},selectAttributes:{size:n.size},options:r,factory:i1,selectBehaviours:ec([gd.config({disabled:function(){return n.disabled||o.isDisabled()}}),py.config({}),mm("selectbox-change",[Cr(ki(),function(t,e){br(t,yy,{name:n.name})})])])})],(1<n.size?vt.none():vt.some(Xm("chevron-down",{tag:"div",classes:["tox-selectfield__icon-js"]},o.icons))).toArray()])},my.sketch({dom:{tag:"div",classes:["tox-form__group"]},components:ft([i.toArray(),[u]]),fieldBehaviours:ec([gd.config({disabled:function(){return n.disabled||o.isDisabled()},onDisabled:function(t){my.getField(t).each(gd.disable)},onEnabled:function(t){my.getField(t).each(gd.enable)}}),pv()])});var n,o,r,i,u}),sizeinput:pk(function(t,e){return ow(t,e.shared.providers)}),urlinput:pk(function(t,e){return gk(t,e,e.urlinput)}),customeditor:pk(function(n){var o=gc(),e=Hm({dom:{tag:n.tag}}),r=gc();return{dom:{tag:"div",classes:["tox-custom-editor"]},behaviours:ec([mm("custom-editor-events",[ou(function(t){e.getOpt(t).each(function(e){(Tt(n,"init")?n.init(e.element.dom):lS.load(n.scriptId,n.scriptUrl).then(function(t){return t(e.element.dom,n.settings)})).then(function(e){r.on(function(t){e.setValue(t)}),r.clear(),o.set(e)})})})]),Df.config({store:{mode:"manual",getValue:function(){return o.get().fold(function(){return r.get().getOr("")},function(t){return t.getValue()})},setValue:function(t,e){o.get().fold(function(){r.set(e)},function(t){return t.setValue(e)})}}}),aw()]),components:[e.asSpec()]}}),htmlpanel:pk(function(t){return"presentation"===t.presets?ly.sketch({dom:{tag:"div",classes:["tox-form__group"],innerHtml:t.html}}):ly.sketch({dom:{tag:"div",classes:["tox-form__group"],innerHtml:t.html,attributes:{role:"document"}},containerBehaviours:ec([py.config({}),Vg.config({})])})}),imagetools:pk(function(t,e){return ok(t,e.shared.providers)}),table:pk(function(t,e){return ik(t,e.shared.providers)}),panel:pk(function(t,e){return{dom:{tag:"div",classes:t.classes},components:B(t.items,e.shared.interpreter)}})},y1={field:function(t,e){return e}},x1=function(e,n,o){return tt(b1,n.type).fold(function(){return console.error('Unknown factory type "'+n.type+'", defaulting to container: ',n),n},function(t){return t(e,n,o)})},w1={valignCentre:[],alignCentre:[],alignLeft:[],alignRight:[],right:[],left:[],bottom:[],top:[]},S1=[{title:"Headings",items:[{title:"Heading 1",format:"h1"},{title:"Heading 2",format:"h2"},{title:"Heading 3",format:"h3"},{title:"Heading 4",format:"h4"},{title:"Heading 5",format:"h5"},{title:"Heading 6",format:"h6"}]},{title:"Inline",items:[{title:"Bold",format:"bold"},{title:"Italic",format:"italic"},{title:"Underline",format:"underline"},{title:"Strikethrough",format:"strikethrough"},{title:"Superscript",format:"superscript"},{title:"Subscript",format:"subscript"},{title:"Code",format:"code"}]},{title:"Blocks",items:[{title:"Paragraph",format:"p"},{title:"Blockquote",format:"blockquote"},{title:"Div",format:"div"},{title:"Pre",format:"pre"}]},{title:"Align",items:[{title:"Left",format:"alignleft"},{title:"Center",format:"aligncenter"},{title:"Right",format:"alignright"},{title:"Justify",format:"alignjustify"}]}],k1=function(t){return R(t,function(t,e){if(Tt(e,"items")){var n=k1(e.items);return{customFormats:t.customFormats.concat(n.customFormats),formats:t.formats.concat([{title:e.title,items:n.formats}])}}if(Tt(e,"inline")||Tt(e,"block")||Tt(e,"selector")){var o="custom-"+(y(e.name)?e.name:e.title.toLowerCase());return{customFormats:t.customFormats.concat([{name:o,format:e}]),formats:t.formats.concat([{title:e.title,format:o,icon:e.icon}])}}return lt(lt({},t),{formats:t.formats.concat(e)})},{customFormats:[],formats:[]})},C1=fS.trim,O1=wk("true"),_1=wk("false"),T1=function(t){var e=B(vs(Mt.fromDom(t),"h1,h2,h3,h4,h5,h6,a:not([href])"),function(t){return t.dom});return F(B(F(e,_k),Tk).concat(B(F(e,Ck),Ek)),Dk)},E1="tinymce-url-history",D1=od,A1=ed,B1=rt([Eo("shell",!1),mo("makeItem"),Eo("setupItem",st),Af("listBehaviours",[Rg])]),M1=rt([Qf({name:"items",overrides:function(){return{behaviours:ec([Rg.config({})])}}})]),F1=Cl({name:rt("CustomList")(),configFields:B1(),partFields:M1(),factory:function(s,t,e,n){var o=s.shell?{behaviours:[Rg.config({})],components:[]}:{behaviours:[],components:t};return{uid:s.uid,dom:s.dom,components:o.components,behaviours:el(s.listBehaviours,o.behaviours),apis:{setItems:function(a,c){var t;t=a,(s.shell?vt.some(t):ml(t,s,"items")).fold(function(){throw console.error("Custom List was defined to not be a shell, but no item container was specified in components"),new Error("Custom List was defined to not be a shell, but no item container was specified in components")},function(e){var t=Rg.contents(e),n=c.length,o=n-t.length,r=0<o?m(o,function(){return s.makeItem()}):[],i=t.slice(n);St(i,function(t){return Rg.remove(e,t)}),St(r,function(t){return Rg.append(e,t)});var u=Rg.contents(e);St(u,function(t,e){s.setupItem(a,t,c[e],e)})})}}}},apis:{setItems:function(t,e,n){t.setItems(e,n)}}}),I1=rt([mo("dom"),Eo("shell",!0),Zs("toolbarBehaviours",[Rg])]),R1=rt([Qf({name:"groups",overrides:function(){return{behaviours:ec([Rg.config({})])}}})]),N1=Cl({name:"Toolbar",configFields:I1(),partFields:R1(),factory:function(o,t,e,n){var r=o.shell?{behaviours:[Rg.config({})],components:[]}:{behaviours:[],components:t};return{uid:o.uid,dom:o.dom,components:r.components,behaviours:el(o.toolbarBehaviours,r.behaviours),apis:{setGroups:function(t,e){var n;n=t,(o.shell?vt.some(n):ml(n,o,"groups")).fold(function(){throw console.error("Toolbar was defined to not be a shell, but no groups container was specified in components"),new Error("Toolbar was defined to not be a shell, but no groups container was specified in components")},function(t){Rg.set(t,e)})}},domModification:{attributes:{role:"group"}}}},apis:{setGroups:function(t,e,n){t.setGroups(e,n)}}}),P1=rt([]),V1=Object.freeze({__proto__:null,setup:st,isDocked:T,getBehaviours:P1}),H1=Vo([{static:[]},{absolute:["positionCss"]},{fixed:["positionCss"]}]),L1=function(t,e,n){var o,r,i,u;t.getSystem().isConnected()&&(i=n,u=(r=e).lazyViewport(o=t),i.isDocked()&&$k(o,r,i,u),qk(o,u,i).each(function(t){t.fold(function(){return Kk(o,r,i)},function(t){return Jk(o,r,i,t)},function(t){$k(o,r,i,u,!0),Jk(o,r,i,t)})}))},z1=Object.freeze({__proto__:null,refresh:L1,reset:Qk,isDocked:function(t,e,n){return n.isDocked()},getModes:function(t,e,n){return n.getModes()},setModes:function(t,e,n,o){return n.setModes(o)}}),U1=Object.freeze({__proto__:null,events:function(o,r){return nu([Ar(_i(),function(e,n){o.contextual.each(function(t){Kr(e.element,t.transitionClass)&&($r(e.element,[t.transitionClass,t.fadeInClass]),(r.isVisible()?t.onShown:t.onHidden)(e)),n.stop()})}),Cr(ji(),function(t,e){L1(t,o,r)}),Cr(Wi(),function(t,e){Qk(t,o,r)})])}}),j1=xa({fields:[To("contextual",[po("fadeInClass"),po("fadeOutClass"),po("transitionClass"),vo("lazyContext"),Ju("onShow"),Ju("onShown"),Ju("onHide"),Ju("onHidden")]),Io("lazyViewport",Fn),Ro("modes",["top","bottom"],er),Ju("onDocked"),Ju("onUndocked")],name:"docking",active:U1,apis:z1,state:Object.freeze({__proto__:null,init:function(t){var e=Po(!1),n=Po(!0),o=gc(),r=Po(t.modes);return wu({isDocked:e.get,setDocked:e.set,getInitialPos:o.get,setInitialPos:o.set,clearInitialPos:o.clear,isVisible:n.get,setVisible:n.set,getModes:r.get,setModes:r.set,readState:function(){return"docked:  "+e.get()+", visible: "+n.get()+", modes: "+r.get().join(",")}})}})}),W1=rt(Ir("toolbar-height-change")),G1={fadeInClass:"tox-editor-dock-fadein",fadeOutClass:"tox-editor-dock-fadeout",transitionClass:"tox-editor-dock-transition"},X1="tox-tinymce--toolbar-sticky-on",Y1="tox-tinymce--toolbar-sticky-off",q1=Object.freeze({__proto__:null,setup:function(t,e,n){t.inline||(e.header.isPositionedAtTop()||t.on("ResizeEditor",function(){n().each(j1.reset)}),t.on("ResizeWindow ResizeEditor",function(){n().each(tC)}),t.on("SkinLoaded",function(){n().each(function(t){j1.isDocked(t)?j1.reset(t):j1.refresh(t)})}),t.on("FullscreenStateChanged",function(){n().each(j1.reset)})),t.on("AfterScrollIntoView",function(b){n().each(function(t){j1.refresh(t);var e,n,o,r,i,u,a,c,s,l,f,d,m,g,p,h,v=t.element;Pd(v)&&(e=b,r=(o=jt(n=v)).dom.defaultView.innerHeight,i=Ie(o),a=He(u=Mt.fromDom(e.elm)),c=xe(u),l=(s=a.y)+c,f=ke(n),d=xe(n),g=(m=f.top)+d,p=Math.abs(m-i.top)<2,h=Math.abs(g-(i.top+r))<2,p&&s<g?Re(i.left,s-d,o):h&&m<l&&Re(i.left,s-r+c+d,o))})}),t.on("PostRender",function(){nC(t,!1)})},isDocked:function(t){return t().map(j1.isDocked).getOr(!1)},getBehaviours:oC}),K1=$o([po("type"),go("items",no([Qo([po("name"),xo("items",er)]),er]))].concat(Vp)),J1=[Co("text"),Co("tooltip"),Co("icon"),vo("fetch"),Io("onSetup",function(){return st})],$1=$o(V([po("type")],J1,!0)),Q1=$o([po("type"),Co("tooltip"),Co("icon"),Co("text"),Oo("select"),vo("fetch"),Io("onSetup",function(){return st}),Mo("presets","normal",["normal","color","listpreview"]),Eo("columns",1),vo("onAction"),vo("onItemAction")]),Z1=kl({factory:function(e,o){var t={focus:Fg.focusIn,setMenus:function(t,e){var n=B(e,function(e){return G0(rC({type:"menubutton",text:e.text,fetch:function(t){t(e.getItems())}}).mapError(function(t){return ur(t)}).getOrDie(),"tox-mbtn",o.backstage,vt.some("menuitem"))});Rg.set(t,n)}};return{uid:e.uid,dom:e.dom,components:[],behaviours:ec([Rg.config({}),mm("menubar-events",[ou(function(t){e.onSetup(t)}),Cr(vi(),function(n,t){Iu(n.element,".tox-mbtn--active").each(function(e){Ru(t.event.target,".tox-mbtn").each(function(t){zt(e,t)||n.getSystem().getByDom(e).each(function(e){n.getSystem().getByDom(t).each(function(t){hw.expand(t),hw.close(e),Vg.focus(t)})})})})}),Cr(Ki(),function(n,t){t.event.prevFocus.bind(function(t){return n.getSystem().getByDom(t).toOptional()}).each(function(e){t.event.newFocus.bind(function(t){return n.getSystem().getByDom(t).toOptional()}).each(function(t){hw.isOpen(e)&&(hw.expand(t),hw.close(e))})})})]),Fg.config({mode:"flow",selector:".tox-mbtn",onEscape:function(t){return e.onEscape(t),vt.some(!0)}}),py.config({})]),apis:t,domModification:{attributes:{role:"menubar"}}}},name:"silver.Menubar",configFields:[mo("dom"),mo("uid"),mo("onEscape"),mo("backstage"),Eo("onSetup",st)],apis:{focus:function(t,e){t.focus(e)},setMenus:function(t,e,n){t.setMenus(e,n)}}}),tO=Object.freeze({__proto__:null,refresh:function(t,e,n){var o;n.isExpanded()&&(ve(t.element,uC(e)),o=aC(e,t.element),fe(t.element,uC(e),o))},grow:function(t,e,n){n.isExpanded()||mC(t,e,n)},shrink:function(t,e,n){n.isExpanded()&&dC(t,e,n)},immediateShrink:function(t,e,n){n.isExpanded()&&fC(t,e,n)},hasGrown:function(t,e,n){return n.isExpanded()},hasShrunk:function(t,e,n){return n.isCollapsed()},isGrowing:gC,isShrinking:pC,isTransitioning:function(t,e,n){return gC(t,e)||pC(t,e)},toggleGrow:function(t,e,n){(n.isExpanded()?dC:mC)(t,e,n)},disableTransitions:cC}),eO=Object.freeze({__proto__:null,exhibit:function(t,e,n){return zr(e.expanded?{classes:[e.openClass],styles:{}}:{classes:[e.closedClass],styles:sr(e.dimension.property,"0px")})},events:function(n,o){return nu([Ar(_i(),function(t,e){e.event.raw.propertyName===n.dimension.property&&(cC(t,n),o.isExpanded()&&ve(t.element,n.dimension.property),(o.isExpanded()?n.onGrown:n.onShrunk)(t))})])}}),nO=xa({fields:[mo("closedClass"),mo("openClass"),mo("shrinkingClass"),mo("growingClass"),wo("getAnimationRoot"),Ju("onShrunk"),Ju("onStartShrink"),Ju("onGrown"),Ju("onStartGrow"),Eo("expanded",!1),go("dimension",lo("property",{width:[ta("property","width"),ta("getDimension",function(t){return Ce(t)+"px"})],height:[ta("property","height"),ta("getDimension",function(t){return xe(t)+"px"})]}))],name:"sliding",active:eO,apis:tO,state:Object.freeze({__proto__:null,init:function(t){var e=Po(t.expanded);return wu({isExpanded:function(){return!0===e.get()},isCollapsed:function(){return!1===e.get()},setCollapsed:C(e.set,!1),setExpanded:C(e.set,!0),readState:function(){return"expanded: "+e.get()}})}})}),oO="container",rO=[Zs("slotBehaviours",[])],iO=dt({getSlotNames:function(t,e){return t.getSlotNames(e)},getSlot:function(t,e,n){return t.getSlot(e,n)},isShowing:function(t,e,n){return t.isShowing(e,n)},hideSlot:function(t,e,n){return t.hideSlot(e,n)},hideAllSlots:function(t,e){return t.hideAllSlots(e)},showSlot:function(t,e,n){return t.showSlot(e,n)}},Hr),uO=lt(lt({},iO),{sketch:function(t){var n,e={slot:function(t,e){return n.push(t),cl(oO,hC(t),e)},record:rt(n=[])},o=t(e),r=B(e.record(),function(t){return Jf({name:t,pname:hC(t)})});return Sl(oO,rO,r,$C,o)}}),aO=$o([Co("icon"),Co("tooltip"),Io("onShow",st),Io("onHide",st),Io("onSetup",function(){return st})]),cO=Ir("FixSizeEvent"),sO=Ir("AutoSizeEvent"),lO=Object.freeze({__proto__:null,block:function(t,e,n,o){oe(t.element,"aria-busy",!0);var r=e.getRoot(t).getOr(t),i=ec([Fg.config({mode:"special",onTab:function(){return vt.some(!0)},onShiftTab:function(){return vt.some(!0)}}),Vg.config({})]),u=o(r,i),a=r.getSystem().build(u);Rg.append(r,Eu(a)),a.hasConfigured(Fg)&&e.focus&&Fg.focusIn(a),n.isBlocked()||e.onBlock(t),n.blockWith(function(){return Rg.remove(r,a)})},unblock:function(t,e,n){ce(t.element,"aria-busy"),n.isBlocked()&&e.onUnblock(t),n.clear()}}),fO=xa({fields:[Io("getRoot",vt.none),Fo("focus",!0),Ju("onBlock"),Ju("onUnblock")],name:"blocking",apis:lO,state:Object.freeze({__proto__:null,init:function(){var e=dc();return wu({readState:e.isSet,blockWith:function(t){e.set({destroy:t})},clear:e.clear,isBlocked:e.isSet})}})}),dO=rt([Zs("splitToolbarBehaviours",[$y]),cr("builtGroups",function(){return Po([])})]),mO=rt([qu(["overflowToggledClass"]),Oo("getOverflowBounds"),mo("lazySink"),cr("overflowGroups",function(){return Po([])})].concat(dO())),gO=rt([Jf({factory:N1,schema:I1(),name:"primary"}),$f({schema:I1(),name:"overflow"}),$f({name:"overflow-button"}),$f({name:"overflow-group"})]),pO=rt(function(t,e){var n=t,o=Math.floor(e);fe(n,"max-width",On.max(n,o,["margin-left","border-left-width","padding-left","padding-right","border-right-width","margin-right"])+"px")}),hO=rt([qu(["toggledClass"]),mo("lazySink"),vo("fetch"),Oo("getBounds"),To("fireDismissalEventInstead",[Eo("event",Yi())]),Uc()]),vO=rt([$f({name:"button",overrides:function(t){return{dom:{attributes:{"aria-haspopup":"true"}},buttonBehaviours:ec([zg.config({toggleClass:t.markers.toggledClass,aria:{mode:"expanded"},toggleOnExecute:!1})])}}}),$f({factory:N1,schema:I1(),name:"toolbar",overrides:function(e){return{toolbarBehaviours:ec([Fg.config({mode:"cyclic",onEscape:function(t){return ml(t,e,"button").each(Vg.focus),vt.none()}})])}}})]),bO=Cl({name:"FloatingToolbarButton",factory:function(u,t,a,e){return lt(lt({},fp.sketch(lt(lt({},e.button()),{action:function(t){EC(t,e)},buttonBehaviours:Bf({dump:e.button().buttonBehaviours},[$y.config({others:{toolbarSandbox:function(t){return o=t,n=a,r=u,{dom:{tag:"div",attributes:{id:(i=Nu()).id}},behaviours:ec([Fg.config({mode:"special",onEscape:function(t){return bf.close(t),vt.some(!0)}}),bf.config({onOpen:function(t,e){r.fetch().get(function(t){AC(o,e,r,n.layouts,t),i.link(o.element),Fg.focusIn(e)})},onClose:function(){zg.off(o),Vg.focus(o),i.unlink(o.element)},isPartOf:function(t,e,n){return Hu(e,n)||Hu(o,n)},getAttachPoint:function(){return r.lazySink(o).getOrDie()}}),ic.config({channels:lt(lt({},Xs(lt({isExtraPart:T},r.fireDismissalEventInstead.map(function(t){return{fireEventInstead:{event:t.event}}}).getOr({})))),Ys({doReposition:function(){bf.getState($y.getCoupled(o,"toolbarSandbox")).each(function(t){DC(o,t,r,n.layouts)})}}))})])};var o,n,r,i}}})])}))),{apis:{setGroups:function(e,n){bf.getState($y.getCoupled(e,"toolbarSandbox")).each(function(t){AC(e,t,u,a.layouts,n)})},reposition:function(e){bf.getState($y.getCoupled(e,"toolbarSandbox")).each(function(t){DC(e,t,u,a.layouts)})},toggle:function(t){EC(t,e)},getToolbar:function(t){return bf.getState($y.getCoupled(t,"toolbarSandbox"))},isOpen:function(t){return bf.isOpen($y.getCoupled(t,"toolbarSandbox"))}}})},configFields:hO(),partFields:vO(),apis:{setGroups:function(t,e,n){t.setGroups(e,n)},reposition:function(t,e){t.reposition(e)},toggle:function(t,e){t.toggle(e)},getToolbar:function(t,e){return t.getToolbar(e)},isOpen:function(t,e){return t.isOpen(e)}}}),yO=rt([mo("items"),qu(["itemSelector"]),Zs("tgroupBehaviours",[Fg])]),xO=rt([Zf({name:"items",unit:"item"})]),wO=Cl({name:"ToolbarGroup",configFields:yO(),partFields:xO(),factory:function(t,e,n,o){return{uid:t.uid,dom:t.dom,components:e,behaviours:el(t.tgroupBehaviours,[Fg.config({mode:"flow",selector:t.markers.itemSelector})]),domModification:{attributes:{role:"toolbar"}}}}}),SO=Cl({name:"SplitFloatingToolbar",configFields:mO(),partFields:gO(),factory:function(n,t,e,o){var r=Hm(bO.sketch({fetch:function(){return Wy(function(t){t(BC(n.overflowGroups.get()))})},layouts:{onLtr:function(){return[Ya,Xa]},onRtl:function(){return[Xa,Ya]},onBottomLtr:function(){return[Ka,qa]},onBottomRtl:function(){return[qa,Ka]}},getBounds:e.getOverflowBounds,lazySink:n.lazySink,fireDismissalEventInstead:{},markers:{toggledClass:n.markers.overflowToggledClass},parts:{button:o["overflow-button"](),toolbar:o.overflow()}}));return{uid:n.uid,dom:n.dom,components:t,behaviours:el(n.splitToolbarBehaviours,[$y.config({others:{overflowGroup:function(){return wO.sketch(lt(lt({},o["overflow-group"]()),{items:[r.asSpec()]}))}}})]),apis:{setGroups:function(t,e){n.builtGroups.set(B(e,t.getSystem().build)),MC(t,r,n)},refresh:function(t){return MC(t,r,n)},toggle:function(t){r.getOpt(t).each(function(t){bO.toggle(t)})},isOpen:function(t){return r.getOpt(t).map(bO.isOpen).getOr(!1)},reposition:function(t){r.getOpt(t).each(function(t){bO.reposition(t)})},getOverflow:function(t){return r.getOpt(t).bind(bO.getToolbar)}},domModification:{attributes:{role:"group"}}}},apis:{setGroups:function(t,e,n){t.setGroups(e,n)},refresh:function(t,e){t.refresh(e)},reposition:function(t,e){t.reposition(e)},toggle:function(t,e){t.toggle(e)},isOpen:function(t,e){return t.isOpen(e)},getOverflow:function(t,e){return t.getOverflow(e)}}}),kO=rt([qu(["closedClass","openClass","shrinkingClass","growingClass","overflowToggledClass"]),Ju("onOpened"),Ju("onClosed")].concat(dO())),CO=rt([Jf({factory:N1,schema:I1(),name:"primary"}),Jf({factory:N1,schema:I1(),name:"overflow",overrides:function(e){return{toolbarBehaviours:ec([nO.config({dimension:{property:"height"},closedClass:e.markers.closedClass,openClass:e.markers.openClass,shrinkingClass:e.markers.shrinkingClass,growingClass:e.markers.growingClass,onShrunk:function(t){ml(t,e,"overflow-button").each(function(t){zg.off(t),Vg.focus(t)}),e.onClosed(t)},onGrown:function(t){Fg.focusIn(t),e.onOpened(t)},onStartGrow:function(t){ml(t,e,"overflow-button").each(zg.on)}}),Fg.config({mode:"acyclic",onEscape:function(t){return ml(t,e,"overflow-button").each(Vg.focus),vt.some(!0)}})])}}}),$f({name:"overflow-button",overrides:function(t){return{buttonBehaviours:ec([zg.config({toggleClass:t.markers.overflowToggledClass,aria:{mode:"pressed"},toggleOnExecute:!1})])}}}),$f({name:"overflow-group"})]),OO=Cl({name:"SplitSlidingToolbar",configFields:kO(),partFields:CO(),factory:function(o,t,e,n){var r="alloy.toolbar.toggle";return{uid:o.uid,dom:o.dom,components:t,behaviours:el(o.splitToolbarBehaviours,[$y.config({others:{overflowGroup:function(e){return wO.sketch(lt(lt({},n["overflow-group"]()),{items:[fp.sketch(lt(lt({},n["overflow-button"]()),{action:function(t){vr(e,r)}}))]}))}}}),mm("toolbar-toggle-events",[Cr(r,function(t){FC(t,o)})])]),apis:{setGroups:function(t,e){var n=B(e,t.getSystem().build);o.builtGroups.set(n),QC(t,o)},refresh:function(t){return QC(t,o)},toggle:function(t){return FC(t,o)},isOpen:function(t){return ml(t,o,"overflow").map(nO.hasGrown).getOr(!1)}},domModification:{attributes:{role:"group"}}}},apis:{setGroups:function(t,e,n){t.setGroups(e,n)},refresh:function(t,e){t.refresh(e)},toggle:function(t,e){t.toggle(e)},isOpen:function(t,e){return t.isOpen(e)}}}),_O=A1.optional({factory:Z1,name:"menubar",schema:[mo("backstage")]}),TO=A1.optional({factory:{sketch:function(t){return F1.sketch({uid:t.uid,dom:t.dom,listBehaviours:ec([Fg.config({mode:"acyclic",selector:".tox-toolbar"})]),makeItem:function(){return VC({type:t.type,uid:Ir("multiple-toolbar-item"),cyclicKeying:!1,initGroups:[],providers:t.providers,onEscape:function(){return t.onEscape(),vt.some(!0)}})},setupItem:function(t,e,n,o){N1.setGroups(e,n)},shell:!0})}},name:"multiple-toolbar",schema:[mo("dom"),mo("onEscape")]}),EO=A1.optional({factory:{sketch:function(t){return(t.type===bh.sliding?function(t){var e=OO.parts.primary({dom:{tag:"div",classes:["tox-toolbar__primary"]}}),n=OO.parts.overflow({dom:{tag:"div",classes:["tox-toolbar__overflow"]}}),o=PC(t);return OO.sketch(lt(lt({},o),{components:[e,n],markers:{openClass:"tox-toolbar__overflow--open",closedClass:"tox-toolbar__overflow--closed",growingClass:"tox-toolbar__overflow--growing",shrinkingClass:"tox-toolbar__overflow--shrinking",overflowToggledClass:"tox-tbtn--enabled"},onOpened:function(t){t.getSystem().broadcastOn([W1()],{type:"opened"})},onClosed:function(t){t.getSystem().broadcastOn([W1()],{type:"closed"})}}))}:t.type===bh.floating?function(i){var t=PC(i),e=SO.parts.primary({dom:{tag:"div",classes:["tox-toolbar__primary"]}});return SO.sketch(lt(lt({},t),{lazySink:i.getSink,getOverflowBounds:function(){var t=i.moreDrawerData.lazyHeader().element,e=He(t),n=Gt(t),o=He(n),r=Math.max(n.dom.scrollHeight,o.height);return Bn(e.x+4,o.y,e.width-8,r)},parts:lt(lt({},t.parts),{overflow:{dom:{tag:"div",classes:["tox-toolbar__overflow"],attributes:i.attributes}}}),components:[e],markers:{overflowToggledClass:"tox-tbtn--enabled"}}))}:VC)({type:t.type,uid:t.uid,onEscape:function(){return t.onEscape(),vt.some(!0)},cyclicKeying:!1,initGroups:[],getSink:t.getSink,providers:t.providers,moreDrawerData:{lazyToolbar:t.lazyToolbar,lazyMoreButton:t.lazyMoreButton,lazyHeader:t.lazyHeader},attributes:t.attributes})}},name:"toolbar",schema:[mo("dom"),mo("onEscape"),mo("getSink")]}),DO=A1.optional({factory:{sketch:function(t){var e=t.editor,n=t.sticky?oC:P1;return{uid:t.uid,dom:t.dom,components:t.components,behaviours:ec(n(e,t.sharedBackstage))}}},name:"header",schema:[mo("dom")]}),AO=A1.optional({name:"socket",schema:[mo("dom")]}),BO=A1.optional({factory:{sketch:function(t){return{uid:t.uid,dom:{tag:"div",classes:["tox-sidebar"],attributes:{role:"complementary"}},components:[{dom:{tag:"div",classes:["tox-sidebar__slider"]},components:[],behaviours:ec([py.config({}),Vg.config({}),nO.config({dimension:{property:"width"},closedClass:"tox-sidebar--sliding-closed",openClass:"tox-sidebar--sliding-open",shrinkingClass:"tox-sidebar--sliding-shrinking",growingClass:"tox-sidebar--sliding-growing",onShrunk:function(t){cd.getCurrent(t).each(uO.hideAllSlots),vr(t,sO)},onGrown:function(t){vr(t,sO)},onStartGrow:function(t){br(t,cO,{width:pe(t.element,"width").getOr("")})},onStartShrink:function(t){br(t,cO,{width:Ce(t.element)+"px"})}}),Rg.config({}),cd.config({find:function(t){return Y(Rg.contents(t))}})])}],behaviours:ec([cS(0),mm("sidebar-sliding-events",[Cr(cO,function(t,e){fe(t.element,"width",e.event.width)}),Cr(sO,function(t,e){ve(t.element,"width")})])])}}},name:"sidebar",schema:[mo("dom")]}),MO=A1.optional({factory:{sketch:function(t){return{uid:t.uid,dom:{tag:"div",attributes:{"aria-hidden":"true"},classes:["tox-throbber"],styles:{display:"none"}},behaviours:ec([Rg.config({}),fO.config({focus:!1}),cd.config({find:function(t){return Y(t.components())}})]),components:[]}}},name:"throbber",schema:[mo("dom")]}),FO=Cl({name:"OuterContainer",factory:function(n,t,e){return{uid:n.uid,dom:n.dom,components:t,apis:{getSocket:function(t){return D1.getPart(t,n,"socket")},setSidebar:function(t,e){D1.getPart(t,n,"sidebar").each(function(t){return bC(t,e)})},toggleSidebar:function(t,e){D1.getPart(t,n,"sidebar").each(function(t){var n=e;cd.getCurrent(t).each(function(e){cd.getCurrent(e).each(function(t){nO.hasGrown(e)?uO.isShowing(t,n)?nO.shrink(e):(uO.hideAllSlots(t),uO.showSlot(t,n)):(uO.hideAllSlots(t),uO.showSlot(t,n),nO.grow(e))})})})},whichSidebar:function(t){return D1.getPart(t,n,"sidebar").bind(yC).getOrNull()},getHeader:function(t){return D1.getPart(t,n,"header")},getToolbar:function(t){return D1.getPart(t,n,"toolbar")},setToolbar:function(t,e){D1.getPart(t,n,"toolbar").each(function(t){t.getApis().setGroups(t,e)})},setToolbars:function(t,e){D1.getPart(t,n,"multiple-toolbar").each(function(t){F1.setItems(t,e)})},refreshToolbar:function(t){D1.getPart(t,n,"toolbar").each(function(t){return t.getApis().refresh(t)})},toggleToolbarDrawer:function(t){D1.getPart(t,n,"toolbar").each(function(e){var t=e.getApis().toggle;null!=t?vt.some(function(t){return t(e)}(t)):vt.none()})},isToolbarDrawerToggled:function(t){return D1.getPart(t,n,"toolbar").bind(function(e){return vt.from(e.getApis().isOpen).map(function(t){return t(e)})}).getOr(!1)},getThrobber:function(t){return D1.getPart(t,n,"throbber")},focusToolbar:function(t){D1.getPart(t,n,"toolbar").orThunk(function(){return D1.getPart(t,n,"multiple-toolbar")}).each(function(t){Fg.focusIn(t)})},setMenubar:function(t,e){D1.getPart(t,n,"menubar").each(function(t){Z1.setMenus(t,e)})},focusMenubar:function(t){D1.getPart(t,n,"menubar").each(function(t){Z1.focus(t)})}},behaviours:n.behaviours}},configFields:[mo("dom"),mo("behaviours")],partFields:[DO,_O,EO,TO,AO,BO,MO],apis:{getSocket:function(t,e){return t.getSocket(e)},setSidebar:function(t,e,n){t.setSidebar(e,n)},toggleSidebar:function(t,e,n){t.toggleSidebar(e,n)},whichSidebar:function(t,e){return t.whichSidebar(e)},getHeader:function(t,e){return t.getHeader(e)},getToolbar:function(t,e){return t.getToolbar(e)},setToolbar:function(t,e,n){var o=B(n,RC);t.setToolbar(e,o)},setToolbars:function(t,e,n){var o=B(n,function(t){return B(t,RC)});t.setToolbars(e,o)},refreshToolbar:function(t,e){return t.refreshToolbar(e)},toggleToolbarDrawer:function(t,e){t.toggleToolbarDrawer(e)},isToolbarDrawerToggled:function(t,e){return t.isToolbarDrawerToggled(e)},getThrobber:function(t,e){return t.getThrobber(e)},setMenubar:function(t,e,n){t.setMenubar(e,n)},focusMenubar:function(t,e){t.focusMenubar(e)},focusToolbar:function(t,e){t.focusToolbar(e)}}}),IO={file:{title:"File",items:"newdocument restoredraft | preview | export print | deleteallconversations"},edit:{title:"Edit",items:"undo redo | cut copy paste pastetext | selectall | searchreplace"},view:{title:"View",items:"code | visualaid visualchars visualblocks | spellchecker | preview fullscreen | showcomments"},insert:{title:"Insert",items:"image link media addcomment pageembed template codesample inserttable | charmap emoticons hr | pagebreak nonbreaking anchor toc | insertdatetime"},format:{title:"Format",items:"bold italic underline strikethrough superscript subscript codeformat | formats blockformats fontformats fontsizes align lineheight | forecolor backcolor | language | removeformat"},tools:{title:"Tools",items:"spellchecker spellcheckerlanguage | a11ycheck code wordcount"},table:{title:"Table",items:"inserttable | cell row column | advtablesort | tableprops deletetable"},help:{title:"Help",items:"help"}},RO=C(jC,!1),NO=C(jC,!0);function PO(t,e,n,o){var r;return{type:"basic",data:(r=t.getParam(e,n,"string"),B(o===t1.SemiColon?r.replace(/;$/,"").split(";"):r.split(" "),function(t){var e=t,n=t,o=t.split("=");return 1<o.length&&(e=o[0],n=o[1]),{title:e,format:n}}))}}function VO(n){var t={type:"basic",data:v_};return{tooltip:"Align",text:vt.none(),icon:vt.some("align-left"),isSelectedFor:function(t){return function(){return n.formatter.match(t)}},getCurrentValue:vt.none,getPreviewFor:function(t){return vt.none},onAction:function(e){return function(){return N(v_,function(t){return t.format===e.format}).each(function(t){return n.execCommand(t.command)})}},updateText:function(t){var e=N(v_,function(t){return n.formatter.match(t.format)}).fold(rt("left"),function(t){return t.title.toLowerCase()});br(t,PS,{icon:"align-"+e})},dataset:t,shouldHide:!1,isInvalid:function(t){return!n.formatter.canApply(t.format)}}}function HO(t){return B(t.split(/\s*,\s*/),function(t){return t.replace(/^['"]+|['"]+$/g,"")})}function LO(r){function i(){function n(t){return t?HO(t)[0]:""}var t=r.queryCommandValue("FontName"),e=a.data,o=t?t.toLowerCase():"";return{matchOpt:N(e,function(t){var e=t.format;return e.toLowerCase()===o||n(e).toLowerCase()===n(o).toLowerCase()}).orThunk(function(){return ot(0===(t=o).indexOf("-apple-system")&&(e=HO(t.toLowerCase()),L(b_,function(t){return-1<e.indexOf(t.toLowerCase())})),{title:u,format:o});var t,e}),font:t}}var u="System Font",a=PO(r,"font_formats","Andale Mono=andale mono,monospace;Arial=arial,helvetica,sans-serif;Arial Black=arial black,sans-serif;Book Antiqua=book antiqua,palatino,serif;Comic Sans MS=comic sans ms,sans-serif;Courier New=courier new,courier,monospace;Georgia=georgia,palatino,serif;Helvetica=helvetica,arial,sans-serif;Impact=impact,sans-serif;Symbol=symbol;Tahoma=tahoma,arial,helvetica,sans-serif;Terminal=terminal,monaco,monospace;Times New Roman=times new roman,times,serif;Trebuchet MS=trebuchet ms,geneva,sans-serif;Verdana=verdana,geneva,sans-serif;Webdings=webdings;Wingdings=wingdings,zapf dingbats",t1.SemiColon);return{tooltip:"Fonts",text:vt.some(u),icon:vt.none(),isSelectedFor:function(e){return function(t){return t.exists(function(t){return t.format===e})}},getCurrentValue:function(){return i().matchOpt},getPreviewFor:function(t){return function(){return vt.some({tag:"div",styles:-1===t.indexOf("dings")?{"font-family":t}:{}})}},onAction:function(t){return function(){r.undoManager.transact(function(){r.focus(),r.execCommand("FontName",!1,t.format)})}},updateText:function(t){var e=i(),n=e.matchOpt,o=e.font,r=n.fold(rt(o),function(t){return t.title});br(t,NS,{text:r})},dataset:a,shouldHide:!1,isInvalid:T}}function zO(n){function i(){var a=vt.none(),c=o.data,s=n.queryCommandValue("FontSize");if(s)for(var t=function(t){var e,n,o,r,i=(n=t,/[0-9.]+px$/.test(e=s)?(o=72*parseInt(e,10)/96,r=Math.pow(10,n||0),Math.round(o*r)/r+"pt"):tt(x_,e).getOr(e)),u=tt(y_,i).getOr("");a=N(c,function(t){return t.format===s||t.format===i||t.format===u})},e=3;a.isNone()&&0<=e;e--)t(e);return{matchOpt:a,size:s}}var t=rt(vt.none),o=PO(n,"fontsize_formats","8pt 10pt 12pt 14pt 18pt 24pt 36pt",t1.Space);return{tooltip:"Font sizes",text:vt.some("12pt"),icon:vt.none(),isSelectedFor:function(e){return function(t){return t.exists(function(t){return t.format===e})}},getPreviewFor:t,getCurrentValue:function(){return i().matchOpt},onAction:function(t){return function(){n.undoManager.transact(function(){n.focus(),n.execCommand("FontSize",!1,t.format)})}},updateText:function(t){var e=i(),n=e.matchOpt,o=e.size,r=n.fold(rt(o),function(t){return t.title});br(t,NS,{text:r})},dataset:o,shouldHide:!1,isInvalid:T}}function UO(t,e){var n=e(),o=B(n,function(t){return t.format});return vt.from(t.formatter.closest(o)).bind(function(e){return N(n,function(t){return t.format===e})}).orThunk(function(){return ot(t.formatter.match("p"),{title:"Paragraph",format:"p"})})}function jO(n){var o=PO(n,"block_formats","Paragraph=p;Heading 1=h1;Heading 2=h2;Heading 3=h3;Heading 4=h4;Heading 5=h5;Heading 6=h6;Preformatted=pre",t1.SemiColon);return{tooltip:"Blocks",text:vt.some("Paragraph"),icon:vt.none(),isSelectedFor:function(t){return function(){return n.formatter.match(t)}},getCurrentValue:vt.none,getPreviewFor:function(e){return function(){var t=n.formatter.get(e);return vt.some({tag:0<t.length&&(t[0].inline||t[0].block)||"div",styles:n.dom.parseStyle(n.formatter.getCssText(e))})}},onAction:XC(n),updateText:function(t){var e=UO(n,function(){return o.data}).fold(rt("Paragraph"),function(t){return t.title});br(t,NS,{text:e})},dataset:o,shouldHide:!1,isInvalid:function(t){return!n.formatter.canApply(t.format)}}}function WO(r,t){return{tooltip:"Formats",text:vt.some("Paragraph"),icon:vt.none(),isSelectedFor:function(t){return function(){return r.formatter.match(t)}},getCurrentValue:vt.none,getPreviewFor:function(e){return function(){var t=r.formatter.get(e);return void 0!==t?vt.some({tag:0<t.length&&(t[0].inline||t[0].block)||"div",styles:r.dom.parseStyle(r.formatter.getCssText(e))}):vt.none()}},onAction:XC(r),updateText:function(t){var n=function(t){var e=t.items;return void 0!==e&&0<e.length?H(e,n):[{title:t.title,format:t.format}]},e=H(bk(r),n),o=UO(r,rt(e)).fold(rt("Paragraph"),function(t){return t.title});br(t,NS,{text:o})},shouldHide:r.getParam("style_formats_autohide",!1,"boolean"),isInvalid:function(t){return!r.formatter.canApply(t.format)},dataset:t}}function GO(e){return{isDisabled:function(){return gd.isDisabled(e)},setDisabled:function(t){return gd.set(e,t)}}}function XO(e){return{setActive:function(t){zg.set(e,t)},isActive:function(){return zg.isOn(e)},isDisabled:function(){return gd.isDisabled(e)},setDisabled:function(t){return gd.set(e,t)}}}function YO(t,e){return t.map(function(t){return{"aria-label":e.translate(t),title:e.translate(t)}}).getOr({})}function qO(e,n,t,o,r,i){var u;return{dom:{tag:"button",classes:["tox-tbtn"].concat(n.isSome()?["tox-tbtn--select"]:[]),attributes:YO(t,i)},components:tb([e.map(function(t){return V0(t,i.icons)}),n.map(function(t){return L0(t,"tox-tbtn",i)})]),eventOrder:((u={})[mi()]=["focusing","alloy.base.behaviour","common-button-display-events"],u),buttonBehaviours:ec([Qv(i.isDisabled),pv(),mm("common-button-display-events",[Cr(mi(),function(t,e){e.event.prevent(),vr(t,T_)})])].concat(o.map(function(t){return k_.config({channel:t,initialData:{icon:e,text:n},renderComponents:function(t,e){return tb([t.icon.map(function(t){return V0(t,i.icons)}),t.text.map(function(t){return L0(t,"tox-tbtn",i)})])}})}).toArray()).concat(r.getOr([])))}}function KO(t,e,n){var o,r=Po(st),i=qO(t.icon,t.text,t.tooltip,vt.none(),vt.none(),n);return fp.sketch({dom:i.dom,components:i.components,eventOrder:RS,buttonBehaviours:ec([mm("toolbar-button-events",[(o={onAction:t.onAction,getApi:e.getApi},uu(function(e,t){hv(o,e)(function(t){br(e,IS,{buttonApi:t}),o.onAction(t)})})),vv(e,r),bv(e,r)]),Qv(function(){return t.disabled||n.isDisabled()}),pv()].concat(e.toolbarButtonBehaviours))})}function JO(r,i){return function(t,e,n){var o=r(t).mapError(function(t){return ur(t)}).getOrDie();return i(o,e,n)}}function $O(n,t,o,r){var e,i=t.outerContainer,u=o.toolbar,a=o.buttons;f(u,y)?(e=u.map(function(t){var e={toolbar:t,buttons:a,allowToolbarGroups:o.allowToolbarGroups};return F_(n,e,{backstage:r},vt.none())}),FO.setToolbars(i,e)):FO.setToolbar(i,F_(n,o,{backstage:r},vt.none()))}function QO(t){return/^[0-9\.]+(|px)$/i.test(""+t)?vt.some(parseInt(""+t,10)):vt.none()}function ZO(t){return u(t)?t+"px":t}function t_(e,t,n){var o=t.filter(function(t){return e<t}),r=n.filter(function(t){return t<e});return o.or(r).getOr(e)}function e_(t){var e=lh(t),n=fh(t),o=mh(t);return QO(e).map(function(t){return t_(t,n,o)})}function n_(u,a,t,e,c){function s(){return x.get()&&!u.removed}function l(t){return y?t.fold(rt(0),function(t){return 1<t.components().length?xe(t.components()[1].element):0}):0}function f(){r.broadcastOn([xf()],{})}function o(t){var e,n,o,r,i;void 0===t&&(t=!1),s()&&(m||(e=p.getOrThunk(function(){var t=QO(ge(bn(),"margin-left")).getOr(0);return Ce(bn())-ke(a).left+t}),fe(c.get().element,"max-width",e+"px")),y&&FO.refreshToolbar(d),m||(n=l(FO.getToolbar(d)),o=Mn(a),r=v()?Math.max(o.y-xe(c.get().element)+n,0):o.bottom,de(d.element,{position:"absolute",top:Math.round(r)+"px",left:Math.round(o.x)+"px"})),g&&(i=c.get(),t?j1.reset(i):j1.refresh(i)),f())}function n(t){var e,n;void 0===t&&(t=!0),!m&&g&&s()&&(e=h.getDockingMode(),(n=function(t){switch(uv(u)){case xh.auto:var e=l(FO.getToolbar(d)),n=xe(t.element)-e,o=Mn(a);if(o.y>n)return"top";var r=Gt(a),i=Math.max(r.dom.scrollHeight,xe(r));return o.bottom<i-n||Fn().bottom<o.bottom-n?"bottom":"top";case xh.bottom:return"bottom";default:return xh.top,"top"}}(c.get()))!==e&&(function(t){var e=c.get();j1.setModes(e,[t]),h.setDockingMode(t);var n=v()?Oc.TopToBottom:Oc.BottomToTop;oe(e.element,ns,n)}(n),t&&o(!0)))}var r=t.uiMothership,d=t.outerContainer,i=nv.DOM,m=sv(u),g=dv(u),p=mh(u).or(e_(u)),h=e.shared.header,v=h.isPositionedAtTop,b=iv(u),y=b===bh.sliding||b===bh.floating,x=Po(!1);return{isVisible:s,isPositionedAtTop:v,show:function(){x.set(!0),fe(d.element,"display","flex"),i.addClass(u.getBody(),"mce-edit-focus"),ve(r.element,"display"),n(!1),o()},hide:function(){x.set(!1),t.outerContainer&&(fe(d.element,"display","none"),i.removeClass(u.getBody(),"mce-edit-focus")),fe(r.element,"display","none")},update:o,updateMode:n,repositionPopups:f}}function o_(t,e){var n=Mn(t);return{pos:e?n.y:n.bottom,bounds:n}}function r_(i,u){return Cr(IS,function(t,e){var n,o=i.get(t),r=(n=o,{hide:function(){return vr(n,Vi())},getValue:function(){return Df.getValue(n)}});u.onAction(r,e.event.buttonApi)})}function i_(t,e,n){return e.bottom-t.y>=(n=void 0===n?.01:n)&&t.bottom-e.y>=n}function u_(t){var e=function(t){var e=t.getBoundingClientRect();if(e.height<=0&&e.width<=0){var n=Qt(Mt.fromDom(t.startContainer),t.startOffset).element;return(Xe(n)?Yt(n):vt.some(n)).filter(Ge).map(function(t){return t.dom.getBoundingClientRect()}).getOr(e)}return e}(t.selection.getRng());if(t.inline){var n=Ie();return Bn(n.left+e.left,n.top+e.top,e.width,e.height)}var o=He(Mt.fromDom(t.getBody()));return Bn(o.x+e.left,o.y+e.top,e.width,e.height)}function a_(t,e,n,o){void 0===o&&(o=0);var r,i,u,a,c=Pe(window),s=Mn(Mt.fromDom(t.getContentAreaContainer())),l=ph(t)||hh(t)||rv(t),f=(r=s,i=c,u=o,{x:a=Math.max(r.x+u,i.x),width:Math.min(r.right-u,i.right)-a}),d=f.x,m=f.width;if(t.inline&&!l)return Bn(d,c.y,m,c.height);var g=function(t,e,n,o,r,i){var u=Mt.fromDom(t.getContainer()),a=Iu(u,".tox-editor-header").getOr(u),c=Mn(a),s=c.y>=e.bottom,l=o&&!s;if(t.inline&&l)return{y:Math.max(c.bottom+i,n.y),bottom:n.bottom};if(t.inline&&!l)return{y:n.y,bottom:Math.min(c.y-i,n.bottom)};var f="line"===r?Mn(u):e;return l?{y:Math.max(c.bottom+i,n.y),bottom:Math.min(f.bottom-i,n.bottom)}:{y:Math.max(f.y+i,n.y),bottom:Math.min(c.y-i,n.bottom)}}(t,s,c,e.header.isPositionedAtTop(),n,o),p=g.y,h=g.bottom;return Bn(d,p,m,h-p)}function c_(t){return"node"===t}function s_(t,r,e,i,n){var u=u_(t),o=i.lastElement().exists(function(t){return zt(e,t)}),a=e,c=t.selection.getRng(),s=Qt(Mt.fromDom(c.startContainer),c.startOffset);return c.startContainer===c.endContainer&&c.startOffset===c.endOffset-1&&zt(s.element,a)?o?Nm:cp:o?function(e,t){var n=pe(e,"position");fe(e,"position",t);var o=i_(u,Mn(r))&&!i.isReposition()?Vm:Nm;return n.each(function(t){return fe(e,"position",t)}),o}(r,i.getMode()):("fixed"===i.getMode()?n.y+Ie().top:n.y)+(xe(r)+12)<=u.y?cp:sp}function l_(e,t){var n=M(F(t,function(t){return t.predicate(e.dom)}),function(t){return"contexttoolbar"===t.type});return{contextToolbars:n.pass,contextForms:n.fail}}function f_(n,t){function o(t){return zt(t,r)}var e,r=Mt.fromDom(t.getBody()),i=Mt.fromDom(t.selection.getNode());return o(e=i)||Ut(r,e)?function(t,e,n){var o=l_(t,e);if(0<o.contextForms.length)return vt.some({elem:t,toolbars:[o.contextForms[0]]});var r=l_(t,n);if(0<r.contextForms.length)return vt.some({elem:t,toolbars:[r.contextForms[0]]});if(0<o.contextToolbars.length||0<r.contextToolbars.length){var i=function(t){if(t.length<=1)return t;function e(e){return d(t,function(t){return t.position===e})}function n(e){return F(t,function(t){return t.position===e})}var o=e("selection"),r=e("node");if(o||r){if(r&&o){var i=n("node"),u=B(n("selection"),function(t){return lt(lt({},t),{position:"node"})});return i.concat(u)}return n(o?"selection":"node")}return n("line")}(o.contextToolbars.concat(r.contextToolbars));return vt.some({elem:t,toolbars:i})}return vt.none()}(i,n.inNodeScope,n.inEditorScope).orThunk(function(){return a=n,(t=o)(e=i)?vt.none():dr(e,function(t){if(Ge(t)){var e=l_(t,a.inNodeScope),n=e.contextToolbars,o=e.contextForms,r=0<o.length?o:(u=n).length<=1?u:i("selection").orThunk(function(){return i("node")}).orThunk(function(){return i("line")}).map(function(t){return t.position}).fold(function(){return[]},function(e){return F(u,function(t){return t.position===e})});return 0<r.length?vt.some({elem:t,toolbars:r}):vt.none()}function i(e){return N(u,function(t){return t.position===e})}var u;return vt.none()},t);var t,e,a}):vt.none()}function d_(a,c){var s={},l=[],f=[],d={},m={},t=Ct(a);return St(t,function(t){var e,n,o,r,i,u=a[t];"contextform"===u.type?(o=t,i=co(ao("ContextForm",qp,r=u)),(s[o]=i).launch.map(function(t){d["form:"+o]=lt(lt({},r.launch),{type:"contextformtogglebutton"===t.type?"togglebutton":"button",onAction:function(){c(i)}})}),("editor"===i.scope?f:l).push(i),m[o]=i):"contexttoolbar"===u.type&&(e=t,ao("ContextToolbar",Kp,n=u).each(function(t){("editor"===n.scope?f:l).push(t),m[e]=t}))}),{forms:s,inNodeScope:l,inEditorScope:f,lookupTable:m,formNavigators:d}}function m_(d,t,m,u){function a(){var t=y.get().getOr("node"),e=c_(t)?1:0;return a_(d,p,t,e)}function c(){return!(d.removed||h()&&g.isContextMenuOpen())}function s(){if(c()){var t=a(),e=mt(y.get(),"node")?(n=d,v.get().filter(vn).map(He).getOrThunk(function(){return u_(n)})):u_(d);return t.height<=0||!i_(e,t)}return 1;var n}function e(){v.clear(),b.clear(),y.clear(),up.hide(x)}function n(){var t;up.isOpen(x)&&(ve(t=x.element,"display"),s()?fe(t,"display","none"):(b.set(0),up.reposition(x)))}function l(t){return{dom:{tag:"div",classes:["tox-pop__dialog"]},components:[t],behaviours:ec([Fg.config({mode:"acyclic"}),mm("pop-dialog-wrap-events",[ou(function(t){d.shortcuts.add("ctrl+F9","focus statusbar",function(){return Fg.focusIn(t)})}),ru(function(t){d.shortcuts.remove("ctrl+F9")})])])}}function f(t,e){var n,o,r,i,c,s,u,a="node"===t?p.anchors.node(e):p.anchors.cursor(),l=(n=d,o=t,r=h(),i={lastElement:v.get,isReposition:function(){return mt(b.get(),0)},getMode:function(){return ff.getMode(m)}},"line"===o?{bubble:Sc(12,0,L_),layouts:{onLtr:function(){return[la]},onRtl:function(){return[fa]}},overrides:z_}:{bubble:Sc(0,12,L_,1/12),layouts:(c=n,s=i,u=o,r?{onLtr:function(t){return[$a,Xa,Ya,qa,Ka,Ja].concat(f(t))},onRtl:function(t){return[$a,Ya,Xa,Ka,qa,Ja].concat(f(t))}}:{onLtr:function(t){return[Ja,$a,qa,Xa,Ka,Ya].concat(f(t))},onRtl:function(t){return[Ja,$a,Ka,Ya,qa,Xa].concat(f(t))}}),overrides:z_});function f(t){return c_(u)?[(a=t,function(t,e,n,o,r){var i=s_(c,o,a,s,r),u=lt(lt({},t),{y:r.y,height:r.height});return lt(lt({},i(u,e,n,o,r)),{alwaysFit:!0})})]:[];var a}return Yo(a,l)}function o(t,e){var n,o,r,i;k.cancel(),c()&&(n=S(t),r=f(o=t[0].position,e),y.set(o),b.set(1),ve(i=x.element,"display"),mt(Et(e,v.get(),zt),!0)||(qr(i,X_),ff.reset(m,x)),up.showWithinBounds(x,l(n),{anchor:r,transition:{classes:[X_],mode:"placement"}},function(){return vt.some(a())}),e.fold(v.clear,v.set),s()&&fe(i,"display","none"))}var r,i,g=u.backstage,p=g.shared,h=ln().deviceType.isTouch,v=gc(),b=gc(),y=gc(),x=Tu((r={sink:m,onEscape:function(){return d.focus(),vt.some(!0)}},i=Po([]),up.sketch({dom:{tag:"div",classes:["tox-pop"]},fireDismissalEventInstead:{event:"doNotDismissYet"},onShow:function(t){i.set([]),up.getContent(t).each(function(t){ve(t.element,"visibility")}),qr(t.element,G_),ve(t.element,"width")},inlineBehaviours:ec([mm("context-toolbar-events",[Ar(_i(),function(t,e){"width"===e.event.raw.propertyName&&(qr(t.element,G_),ve(t.element,"width"))}),Cr(W_,function(t,e){var n=t.element;ve(n,"width");var o=Ce(n);up.setContent(t,e.event.contents),Yr(n,G_);var r=Ce(n);fe(n,"width",o+"px"),up.getContent(t).each(function(t){e.event.focus.bind(function(t){return ka(t),_a(n)}).orThunk(function(){return Fg.focusIn(t),Oa(gn(n))})}),lp.setTimeout(function(){fe(t.element,"width",r+"px")},0)}),Cr(U_,function(e,t){up.getContent(e).each(function(t){i.set(i.get().concat([{bar:t,focus:Oa(gn(e.element))}]))}),br(e,W_,{contents:t.event.forwardContents,focus:vt.none()})}),Cr(j_,function(e,t){q(i.get()).each(function(t){i.set(i.get().slice(0,i.get().length-1)),br(e,W_,{contents:Eu(t.bar),focus:t.focus})})})]),Fg.config({mode:"special",onEscape:function(e){return q(i.get()).fold(function(){return r.onEscape()},function(t){return vr(e,j_),vt.some(!0)})}})]),lazySink:function(){return Nn.value(r.sink)}}))),w=Rt(function(){return d_(t,function(t){var e=S([t]);br(x,U_,{forwardContents:l(e)})})}),S=function(t){var e=d.ui.registry.getAll().buttons,n=w(),o=lt(lt({},e),n.formNavigators),r=iv(d)===bh.scrolling?bh.scrolling:bh.default,i=ft(B(t,function(t){return"contexttoolbar"===t.type?F_(d,{buttons:o,toolbar:t.items,allowToolbarGroups:!1},u,vt.some(["form:"])):(e=p.providers,H_(t,e));var e}));return VC({type:r,uid:Ir("context-toolbar"),initGroups:i,onEscape:vt.none,cyclicKeying:!0,providers:p.providers})},k=vp(function(){d.hasFocus()&&!d.removed&&(Kr(x.element,X_)?k.throttle():f_(w(),d).fold(e,function(t){o(t.toolbars,vt.some(t.elem))}))},17);d.on("init",function(){d.on("remove",e),d.on("ScrollContent ScrollWindow ObjectResized ResizeEditor longpress",n),d.on("click keyup focus SetContent",k.throttle),d.on(V_,e),d.on("contexttoolbar-show",function(e){tt(w().lookupTable,e.toolbarKey).each(function(t){o([t],ot(e.target!==d,e.target)),up.getContent(x).each(Fg.focusIn)})}),d.on("focusout",function(t){lp.setEditorTimeout(d,function(){_a(m.element).isNone()&&_a(x.element).isNone()&&e()},0)}),d.on("SwitchMode",function(){d.mode.isReadOnly()&&e()}),d.on("AfterProgressState",function(t){t.state?e():d.hasFocus()&&k.throttle()}),d.on("NodeChange",function(t){_a(x.element).fold(k.throttle,st)})})}(e1=t1=t1||{})[e1.SemiColon=0]="SemiColon",e1[e1.Space=1]="Space";var g_,p_,h_,v_=[{title:"Left",icon:"align-left",format:"alignleft",command:"JustifyLeft"},{title:"Center",icon:"align-center",format:"aligncenter",command:"JustifyCenter"},{title:"Right",icon:"align-right",format:"alignright",command:"JustifyRight"},{title:"Justify",icon:"align-justify",format:"alignjustify",command:"JustifyFull"}],b_=["-apple-system","Segoe UI","Roboto","Helvetica Neue","sans-serif"],y_={"8pt":"1","10pt":"2","12pt":"3","14pt":"4","18pt":"5","24pt":"6","36pt":"7"},x_={"xx-small":"7pt","x-small":"8pt",small:"10pt",medium:"12pt",large:"14pt","x-large":"18pt","xx-large":"24pt"},w_=Object.freeze({__proto__:null,events:function(r,i){function u(n,o){r.updateState.each(function(t){var e=t(n,o);i.set(e)}),r.renderComponents.each(function(t){var e=B(t(o,i.get()),n.getSystem().build);Rs(n,e)})}return nu([Cr(Fi(),function(t,e){var n,o=e;o.universal||(n=r.channel,wt(o.channels,n)&&u(t,o.data))}),ou(function(e,t){r.initialData.each(function(t){u(e,t)})})])}}),S_=Object.freeze({__proto__:null,getState:function(t,e,n){return n}}),k_=xa({fields:[mo("channel"),wo("renderComponents"),wo("updateState"),wo("initialData")],name:"reflecting",active:w_,apis:S_,state:Object.freeze({__proto__:null,init:function(){var t=Po(vt.none());return{readState:function(){return t.get().getOr("none")},get:t.get,set:t.set,clear:function(){return t.set(vt.none())}}}})}),C_=rt([mo("toggleClass"),mo("fetch"),Qu("onExecute"),Eo("getHotspot",vt.some),Eo("getAnchorOverrides",rt({})),Uc(),Qu("onItemExecute"),wo("lazySink"),mo("dom"),Ju("onOpen"),Zs("splitDropdownBehaviours",[$y,Fg,Vg]),Eo("matchWidth",!1),Eo("useMinWidth",!1),Eo("eventOrder",{}),wo("role")].concat(ux())),O_=rt([Jf({factory:fp,schema:[mo("dom")],name:"arrow",defaults:function(){return{buttonBehaviours:ec([Vg.revoke()])}},overrides:function(e){return{dom:{tag:"span",attributes:{role:"presentation"}},action:function(t){t.getSystem().getByUid(e.uid).each(yr)},buttonBehaviours:ec([zg.config({toggleOnExecute:!1,toggleClass:e.toggleClass})])}}}),Jf({factory:fp,schema:[mo("dom")],name:"button",defaults:function(){return{buttonBehaviours:ec([Vg.revoke()])}},overrides:function(n){return{dom:{tag:"span",attributes:{role:"presentation"}},action:function(e){e.getSystem().getByUid(n.uid).each(function(t){n.onExecute(t,e)})}}}}),Qf({factory:{sketch:function(t){return{uid:t.uid,dom:{tag:"span",styles:{display:"none"},attributes:{"aria-hidden":"true"},innerHtml:t.text}}}},schema:[mo("text")],name:"aria-descriptor"}),$f({schema:[Yu()],name:"menu",defaults:function(o){return{onExecute:function(e,n){e.getSystem().getByUid(o.uid).each(function(t){o.onItemExecute(t,e,n)})}}}}),Zy()]),__=Cl({name:"SplitDropdown",configFields:C_(),partFields:O_(),factory:function(o,t,e,n){function r(t){cd.getCurrent(t).each(function(t){hd.highlightFirst(t),Fg.focusIn(t)})}function i(t){nx(o,h,t,n,r,Vy.HighlightFirst).get(st)}function u(t){return yr(gl(t,o,"button")),vt.some(!0)}var a,c=lt(lt({},nu([ou(function(n,t){ml(n,o,"aria-descriptor").each(function(t){var e=Ir("aria");oe(t.element,"id",e),oe(n.element,"aria-describedby",e)})})])),Sm(vt.some(i))),s={repositionMenus:function(t){zg.isOn(t)&&ix(t)}};return{uid:o.uid,dom:o.dom,components:t,apis:s,eventOrder:lt(lt({},o.eventOrder),((a={})[Ii()]=["disabling","toggling","alloy.base.behaviour"],a)),events:c,behaviours:el(o.splitDropdownBehaviours,[$y.config({others:{sandbox:function(t){var e=gl(t,o,"arrow");return rx(o,t,{onOpen:function(){zg.on(e),zg.on(t)},onClose:function(){zg.off(e),zg.off(t)}})}}}),Fg.config({mode:"special",onSpace:u,onEnter:u,onDown:function(t){return i(t),vt.some(!0)}}),Vg.config({}),zg.config({toggleOnExecute:!1,aria:{mode:"expanded"}})]),domModification:{attributes:{role:o.role.getOr("button"),"aria-haspopup":!0}}}},apis:{repositionMenus:function(t,e){return t.repositionMenus(e)}}}),T_=Ir("focus-button"),E_=function(t,e,n){return KO(t,{toolbarButtonBehaviours:[].concat(0<n.length?[mm("toolbarButtonWith",n)]:[]),getApi:GO,onSetup:t.onSetup},e)},D_=function(t,e,n){return Yo(KO(t,{toolbarButtonBehaviours:[Rg.config({}),zg.config({toggleClass:"tox-tbtn--enabled",aria:{mode:"pressed"},toggleOnExecute:!1})].concat(0<n.length?[mm("toolbarToggleButtonWith",n)]:[]),getApi:XO,onSetup:t.onSetup},e))},A_=[{name:"history",items:["undo","redo"]},{name:"styles",items:["styleselect"]},{name:"formatting",items:["bold","italic"]},{name:"alignment",items:["alignleft","aligncenter","alignright","alignjustify"]},{name:"indentation",items:["outdent","indent"]},{name:"permanent pen",items:["permanentpen"]},{name:"comments",items:["addcomment"]}],B_={button:JO(Op,function(t,e){return n=e.backstage.shared.providers,E_(t,n,[]);var n}),togglebutton:JO(_p,function(t,e){return n=e.backstage.shared.providers,D_(t,n,[]);var n}),menubutton:JO(rC,function(t,e){return G0(t,"tox-tbtn",e.backstage,vt.none())}),splitbutton:JO(function(t){return ao("SplitButton",Q1,t)},function(t,e){return o=t,r=e.backstage.shared,s=Ir("channel-update-split-dropdown-display"),l=Po(st),f={getApi:n,onSetup:o.onSetup},__.sketch({dom:{tag:"div",classes:["tox-split-button"],attributes:lt({"aria-pressed":!1},YO(o.tooltip,r.providers))},onExecute:function(t){o.onAction(n(t))},onItemExecute:function(t,e,n){},splitDropdownBehaviours:ec([Yv(r.providers.isDisabled),pv(),mm("split-dropdown-events",[Cr(T_,Vg.focus),vv(f,l),bv(f,l)]),vw.config({})]),eventOrder:((i={})[Gi()]=["alloy.base.behaviour","split-dropdown-events"],i),toggleClass:"tox-tbtn--enabled",lazySink:r.getSink,fetch:(u=n,a=o,c=r.providers,function(e){return Wy(function(t){return a.fetch(t)}).map(function(t){return vt.from(Xb(Yo(Ob(Ir("menu-value"),t,function(t){a.onItemAction(u(e),t)},a.columns,a.presets,Sh.CLOSE_ON_EXECUTE,a.select.getOr(T),c),{movement:_b(a.columns,a.presets),menuBehaviours:Kh("auto"!==a.columns?[]:[ou(function(o,t){ah(o,4,Jp(a.presets)).each(function(t){var e=t.numRows,n=t.numColumns;Fg.setGridSize(o,e,n)})})])})))})}),parts:{menu:Zp(0,o.columns,o.presets)},components:[__.parts.button(qO(o.icon,o.text,vt.none(),vt.some(s),vt.some([zg.config({toggleClass:"tox-tbtn--enabled",toggleOnExecute:!1})]),r.providers)),__.parts.arrow({dom:{tag:"button",classes:["tox-tbtn","tox-split-button__chevron"],innerHtml:jm("chevron-down",r.providers.icons)},buttonBehaviours:ec([Yv(r.providers.isDisabled),pv(),Wm()])}),__.parts["aria-descriptor"]({text:r.providers.translate("To open the popup, press Shift+Enter")})]});function n(n){return{isDisabled:function(){return gd.isDisabled(n)},setDisabled:function(t){return gd.set(n,t)},setIconFill:function(t,e){Iu(n.element,'svg path[id="'+t+'"], rect[id="'+t+'"]').each(function(t){oe(t,"fill",e)})},setIconStroke:function(t,e){Iu(n.element,'svg path[id="'+t+'"], rect[id="'+t+'"]').each(function(t){oe(t,"stroke",e)})},setActive:function(e){oe(n.element,"aria-pressed",e),Iu(n.element,"span").each(function(t){n.getSystem().getByDom(t).each(function(t){return zg.set(t,e)})})},isActive:function(){return Iu(n.element,"span").exists(function(t){return n.getSystem().getByDom(t).exists(zg.isOn)})}}}var o,r,i,u,a,c,s,l,f}),grouptoolbarbutton:JO(function(t){return ao("GroupToolbarButton",K1,t)},function(t,e,n){var o,r,i,u,a,c,s=n.ui.registry.getAll().buttons,l=((o={})[ns]=e.backstage.shared.header.isPositionedAtTop()?Oc.TopToBottom:Oc.BottomToTop,o);if(iv(n)!==bh.floating)throw new Error("Toolbar groups are only supported when using floating toolbar mode");return i=e.backstage,u=function(t){return F_(n,{buttons:s,toolbar:t,allowToolbarGroups:!1},e,vt.none())},a=l,c=i.shared,bO.sketch({lazySink:c.getSink,fetch:function(){return Wy(function(t){t(B(u(r.items),RC))})},markers:{toggledClass:"tox-tbtn--enabled"},parts:{button:qO((r=t).icon,r.text,r.tooltip,vt.none(),vt.none(),c.providers),toolbar:{dom:{tag:"div",classes:["tox-toolbar__overflow"],attributes:a}}}})}),styleSelectButton:function(t,e){return KC(t,n=e.backstage,WO(t,lt({type:"advanced"},n.styleselect)));var n},fontsizeSelectButton:function(t,e){return KC(t,e.backstage,zO(t))},fontSelectButton:function(t,e){return KC(t,e.backstage,LO(t))},formatButton:function(t,e){return KC(t,e.backstage,jO(t))},alignMenuButton:function(t,e){return KC(t,e.backstage,VO(t))}},M_={styleselect:B_.styleSelectButton,fontsizeselect:B_.fontsizeSelectButton,fontselect:B_.fontSelectButton,formatselect:B_.formatButton,align:B_.alignMenuButton},F_=function(o,c,s,l){var n,t,e,r,i=(e=c.toolbar,r=c.buttons,!1===e?[]:void 0===e||!0===e?(n=r,t=B(A_,function(t){var e=F(t.items,function(t){return Tt(n,t)||Tt(M_,t)});return{name:t.name,items:e}}),F(t,function(t){return 0<t.items.length})):y(e)?B(e.split("|"),function(t){return{items:t.trim().split(" ")}}):f(e,function(t){return Tt(t,"name")&&Tt(t,"items")})?e:(console.error("Toolbar type should be string, string[], boolean or ToolbarGroup[]"),[]));return F(B(i,function(t){var e=H(t.items,function(t){return 0===t.trim().length?[]:(r=o,e=c.buttons,i=t,u=c.allowToolbarGroups,a=s,n=l,tt(e,i.toLowerCase()).orThunk(function(){return n.bind(function(t){return K(t,function(t){return tt(e,t+i.toLowerCase())})})}).fold(function(){return tt(M_,i.toLowerCase()).map(function(t){return t(r,a)}).orThunk(function(){return vt.none()})},function(t){return"grouptoolbarbutton"!==t.type||u?(n=a,o=r,tt(B_,(e=t).type).fold(function(){return console.error("skipping button defined by",e),vt.none()},function(t){return vt.some(t(e,n,o))})):(console.warn("Ignoring the '"+i+"' toolbar button. Group toolbar buttons are only supported when using floating toolbar mode and cannot be nested."),vt.none());var e,n,o}).toArray());var r,e,i,u,a,n});return{title:vt.from(o.translate(t.name)),items:e}}),function(t){return 0<t.items.length})},I_=ln(),R_=I_.os.isiOS()&&I_.os.version.major<=12,N_=Object.freeze({__proto__:null,render:function(n,e,t,o,r){var i=Po(0),u=e.outerContainer;RO(n);var a=Mt.fromDom(r.targetNode),c=te(gn(a)),s=e.mothership;pf(a,s,De),Ls(c,e.uiMothership),n.on("PostRender",function(){$O(n,e,t,o),i.set(n.getWin().innerWidth),FO.setMenubar(u,LC(n,t)),FO.setSidebar(u,t.sidebar),function(n,t){function e(){var t=c.get();t.left===u.innerWidth&&t.top===u.innerHeight||(c.set(kn(u.innerWidth,u.innerHeight)),Uv(n))}function o(){var t=n.getDoc().documentElement,e=s.get();e.left===t.offsetWidth&&e.top===t.offsetHeight||(s.set(kn(t.offsetWidth,t.offsetHeight)),Uv(n))}function r(t){return n.fire("ScrollContent",t)}var i=n.dom,u=n.getWin(),a=n.getDoc().documentElement,c=Po(kn(u.innerWidth,u.innerHeight)),s=Po(kn(a.offsetWidth,a.offsetHeight));i.bind(u,"resize",e),i.bind(u,"scroll",r);var l=hc(Mt.fromDom(n.getBody()),"load",o),f=t.uiMothership.element;n.on("hide",function(){fe(f,"display","none")}),n.on("show",function(){ve(f,"display")}),n.on("NodeChange",o),n.on("remove",function(){l.unbind(),i.unbind(u,"resize",e),i.unbind(u,"scroll",r),u=null})}(n,e)});var l,f,d,m,g=FO.getSocket(u).getOrDie("Could not find expected socket element");R_&&(de(g.element,{overflow:"scroll","-webkit-overflow-scrolling":"touch"}),f=function(){n.fire("ScrollContent")},d=null,m=function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];b(d)&&(d=setTimeout(function(){d=null,f.apply(null,t)},20))},l=pc(g.element,"scroll",m),n.on("remove",l.unbind)),gv(n,e),n.addCommand("ToggleSidebar",function(t,e){FO.toggleSidebar(u,e),n.fire("ToggleSidebar")}),n.addQueryValueHandler("ToggleSidebar",function(){return FO.whichSidebar(u)});var p=iv(n);p!==bh.sliding&&p!==bh.floating||n.on("ResizeWindow ResizeEditor ResizeContent",function(){var t=n.getWin().innerWidth;t!==i.get()&&(FO.refreshToolbar(e.outerContainer),i.set(t))});var h={enable:function(){mv(e,!1)},disable:function(){mv(e,!0)},isDisabled:function(){return gd.isDisabled(u)}};return{iframeContainer:g.element.dom,editorContainer:u.element.dom,api:h}}}),P_=Object.freeze({__proto__:null,render:function(e,n,o,r,t){var i=n.mothership,u=n.uiMothership,a=n.outerContainer,c=Po(null),s=Mt.fromDom(t.targetNode),l=n_(e,s,n,r,c),f=e.getParam("toolbar_persist",!1,"boolean");function d(){var t;c.get()?l.show():(c.set(FO.getHeader(a).getOrDie()),Ls(t=lv(e),i),Ls(t,u),$O(e,n,o,r),FO.setMenubar(a,LC(e,o)),l.show(),function(c,s,l,t){function e(t){var e=o_(s,l.isPositionedAtTop()),n=e.pos,o=e.bounds,r=f.get(),i=r.pos,u=r.bounds,a=o.height!==u.height||o.width!==u.width;f.set({pos:n,bounds:o}),a&&Uv(c,t),l.isVisible()&&(i!==n?l.update(!0):a&&(l.updateMode(),l.repositionPopups()))}var f=Po(o_(s,l.isPositionedAtTop()));t||(c.on("activate",l.show),c.on("deactivate",l.hide)),c.on("SkinLoaded ResizeWindow",function(){return l.update(!0)}),c.on("NodeChange keydown",function(t){lp.requestAnimationFrame(function(){return e(t)})}),c.on("ScrollWindow",function(){return l.updateMode()});var n=mc();n.set(hc(Mt.fromDom(c.getBody()),"load",e)),c.on("remove",function(){n.clear()})}(e,s,l,f),e.nodeChanged())}NO(e),e.on("show",d),e.on("hide",l.hide),f||(e.on("focus",d),e.on("blur",l.hide)),e.on("init",function(){(e.hasFocus()||f)&&d()}),gv(e,n);var m={show:function(){l.show()},hide:function(){l.hide()},enable:function(){mv(n,!1)},disable:function(){mv(n,!0)},isDisabled:function(){return gd.isDisabled(a)}};return{editorContainer:a.element.dom,api:m}}}),V_="contexttoolbar-hide",H_=function(t,e){var n,o,r,i,u=t.label.fold(function(){return{}},function(t){return{"aria-label":t}}),a=Hm(Dy.sketch({inputClasses:["tox-toolbar-textfield","tox-toolbar-nav-js"],data:t.initValue(),inputAttributes:u,selectOnFocus:!0,inputBehaviours:ec([Fg.config({mode:"special",onEnter:function(t){return c.findPrimary(t).map(function(t){return yr(t),!0})},onLeft:function(t,e){return e.cut(),vt.none()},onRight:function(t,e){return e.cut(),vt.none()}})])})),c=(n=a,o=t.commands,r=e,i=B(o,function(t){return Hm(("contextformtogglebutton"===t.type?function(t,e,n){var o=e.original;o.primary;var r=A(o,["primary"]),i=co(_p(lt(lt({},r),{type:"togglebutton",onAction:st})));return D_(i,n.backstage.shared.providers,[r_(t,e)])}:function(t,e,n){var o=e.original;o.primary;var r=A(o,["primary"]),i=co(Op(lt(lt({},r),{type:"button",onAction:st})));return E_(i,n.backstage.shared.providers,[r_(t,e)])})(n,t,{backstage:{shared:{providers:r}}}))}),{asSpecs:function(){return B(i,function(t){return t.asSpec()})},findPrimary:function(n){return K(o,function(t,e){return t.primary?vt.from(i[e]).bind(function(t){return t.getOpt(n)}).filter(O(gd.isDisabled)):vt.none()})}});return[{title:vt.none(),items:[a.asSpec()]},{title:vt.none(),items:c.asSpecs()}]},L_={valignCentre:[],alignCentre:[],alignLeft:["tox-pop--align-left"],alignRight:["tox-pop--align-right"],right:["tox-pop--right"],left:["tox-pop--left"],bottom:["tox-pop--bottom"],top:["tox-pop--top"],inset:["tox-pop--inset"]},z_={maxHeightFunction:Nc(),maxWidthFunction:pO()},U_=Ir("forward-slide"),j_=Ir("backward-slide"),W_=Ir("change-slide-event"),G_="tox-pop--resizing",X_="tox-pop--transition",Y_={unsupportedLength:["em","ex","cap","ch","ic","rem","lh","rlh","vw","vh","vi","vb","vmin","vmax","cm","mm","Q","in","pc","pt","px"],fixed:["px","pt"],relative:["%"],empty:[""]},q_=(h_=["Infinity",(g_="[0-9]+")+"\\."+K_(g_)+K_(p_="[eE][+-]?[0-9]+"),"\\."+g_+K_(p_),g_+K_(p_)].join("|"),new RegExp("^([+-]?(?:"+h_+"))(.*)$"));function K_(t){return"(?:"+t+")?"}function J_(u,a){function e(){var t=a.getOptions(u),r=a.getCurrent(u).map(a.hash),i=gc();return B(t,function(o){return{type:"togglemenuitem",text:a.display(o),onSetup:function(e){function t(t){t&&(i.on(function(t){return t.setActive(!1)}),i.set(e)),e.setActive(t)}t(mt(r,a.hash(o)));var n=a.watcher(u,o,t);return function(){i.clear(),n()}},onAction:function(){return a.setCurrent(u,o)}}})}u.ui.registry.addMenuButton(a.name,{tooltip:a.text,icon:a.icon,fetch:function(t){return t(e())},onSetup:a.onToolbarSetup}),u.ui.registry.addNestedMenuItem(a.name,{type:"nestedmenuitem",text:a.text,getSubmenuItems:e,onSetup:a.onMenuSetup})}function $_(t,e){return function(){t.execCommand("mceToggleFormat",!1,e)}}function Q_(t){var e,n;!function(n){fS.each([{name:"bold",text:"Bold",icon:"bold"},{name:"italic",text:"Italic",icon:"italic"},{name:"underline",text:"Underline",icon:"underline"},{name:"strikethrough",text:"Strikethrough",icon:"strike-through"},{name:"subscript",text:"Subscript",icon:"subscript"},{name:"superscript",text:"Superscript",icon:"superscript"}],function(t,e){n.ui.registry.addToggleButton(t.name,{tooltip:t.text,icon:t.icon,onSetup:WC(n,t.name),onAction:$_(n,t.name)})});for(var t=1;t<=6;t++){var e="h"+t;n.ui.registry.addToggleButton(e,{text:e.toUpperCase(),tooltip:"Heading "+t,onSetup:WC(n,e),onAction:$_(n,e)})}}(t),e=t,fS.each([{name:"cut",text:"Cut",action:"Cut",icon:"cut"},{name:"copy",text:"Copy",action:"Copy",icon:"copy"},{name:"paste",text:"Paste",action:"Paste",icon:"paste"},{name:"help",text:"Help",action:"mceHelp",icon:"help"},{name:"selectall",text:"Select all",action:"SelectAll",icon:"select-all"},{name:"newdocument",text:"New document",action:"mceNewDocument",icon:"new-document"},{name:"removeformat",text:"Clear formatting",action:"RemoveFormat",icon:"remove-formatting"},{name:"remove",text:"Remove",action:"Delete",icon:"remove"}],function(t){e.ui.registry.addButton(t.name,{tooltip:t.text,icon:t.icon,onAction:YC(e,t.action)})}),n=t,fS.each([{name:"blockquote",text:"Blockquote",action:"mceBlockQuote",icon:"quote"}],function(t){n.ui.registry.addToggleButton(t.name,{tooltip:t.text,icon:t.icon,onAction:YC(n,t.action),onSetup:WC(n,t.name)})})}function Z_(e,n){return GC(e,"Undo Redo AddUndo TypingUndo ClearUndos SwitchMode",function(t){t.setDisabled(e.mode.isReadOnly()||!e.undoManager[n]())})}function tT(t){var e;t.ui.registry.addButton("visualaid",{tooltip:"Visual aids",text:"Visual aids",onAction:YC(t,"mceToggleVisualAid")}),t.ui.registry.addToggleMenuItem("visualaid",{text:"Visual aids",onSetup:GC(e=t,"VisualAid",function(t){t.setActive(e.hasVisual)}),onAction:YC(t,"mceToggleVisualAid")})}function eT(t,e){var n,o,r,i,u,a,c,s,l,f,d,m,g,p,h,v,b,y,x,w,S,k,C,O,_,T=t;St([{name:"alignleft",text:"Align left",cmd:"JustifyLeft",icon:"align-left"},{name:"aligncenter",text:"Align center",cmd:"JustifyCenter",icon:"align-center"},{name:"alignright",text:"Align right",cmd:"JustifyRight",icon:"align-right"},{name:"alignjustify",text:"Justify",cmd:"JustifyFull",icon:"align-justify"}],function(t){T.ui.registry.addToggleButton(t.name,{tooltip:t.text,icon:t.icon,onAction:YC(T,t.cmd),onSetup:WC(T,t.name)})}),T.ui.registry.addButton("alignnone",{tooltip:"No alignment",icon:"align-none",onAction:YC(T,"JustifyNone")}),Q_(O=t),_=O,fS.each([{name:"bold",text:"Bold",action:"Bold",icon:"bold",shortcut:"Meta+B"},{name:"italic",text:"Italic",action:"Italic",icon:"italic",shortcut:"Meta+I"},{name:"underline",text:"Underline",action:"Underline",icon:"underline",shortcut:"Meta+U"},{name:"strikethrough",text:"Strikethrough",action:"Strikethrough",icon:"strike-through",shortcut:""},{name:"subscript",text:"Subscript",action:"Subscript",icon:"subscript",shortcut:""},{name:"superscript",text:"Superscript",action:"Superscript",icon:"superscript",shortcut:""},{name:"removeformat",text:"Clear formatting",action:"RemoveFormat",icon:"remove-formatting",shortcut:""},{name:"newdocument",text:"New document",action:"mceNewDocument",icon:"new-document",shortcut:""},{name:"cut",text:"Cut",action:"Cut",icon:"cut",shortcut:"Meta+X"},{name:"copy",text:"Copy",action:"Copy",icon:"copy",shortcut:"Meta+C"},{name:"paste",text:"Paste",action:"Paste",icon:"paste",shortcut:"Meta+V"},{name:"selectall",text:"Select all",action:"SelectAll",icon:"select-all",shortcut:"Meta+A"}],function(t){_.ui.registry.addMenuItem(t.name,{text:t.text,icon:t.icon,shortcut:t.shortcut,onAction:YC(_,t.action)})}),_.ui.registry.addMenuItem("codeformat",{text:"Code",icon:"sourcecode",onAction:$_(_,"code")}),C=qC(0,d=l=e,VO(f=s=t)),f.ui.registry.addNestedMenuItem("align",{text:d.shared.providers.translate("Align"),getSubmenuItems:function(){return C.items.validateItems(C.getStyleItems())}}),p=qC(0,g=l,LO(m=s)),m.ui.registry.addNestedMenuItem("fontformats",{text:g.shared.providers.translate("Fonts"),getSubmenuItems:function(){return p.items.validateItems(p.getStyleItems())}}),h=s,b=lt({type:"advanced"},(v=l).styleselect),y=qC(0,v,WO(h,b)),h.ui.registry.addNestedMenuItem("formats",{text:"Formats",getSubmenuItems:function(){return y.items.validateItems(y.getStyleItems())}}),w=qC(0,l,jO(x=s)),x.ui.registry.addNestedMenuItem("blockformats",{text:"Blocks",getSubmenuItems:function(){return w.items.validateItems(w.getStyleItems())}}),k=qC(0,l,zO(S=s)),S.ui.registry.addNestedMenuItem("fontsizes",{text:"Font sizes",getSubmenuItems:function(){return k.items.validateItems(k.getStyleItems())}}),(a=u=t).ui.registry.addMenuItem("undo",{text:"Undo",icon:"undo",shortcut:"Meta+Z",onSetup:Z_(a,"hasUndo"),onAction:YC(a,"undo")}),a.ui.registry.addMenuItem("redo",{text:"Redo",icon:"redo",shortcut:"Meta+Y",onSetup:Z_(a,"hasRedo"),onAction:YC(a,"redo")}),(c=u).ui.registry.addButton("undo",{tooltip:"Undo",icon:"undo",disabled:!0,onSetup:Z_(c,"hasUndo"),onAction:YC(c,"undo")}),c.ui.registry.addButton("redo",{tooltip:"Redo",icon:"redo",disabled:!0,onSetup:Z_(c,"hasRedo"),onAction:YC(c,"redo")}),function(t){var i;(i=t).addCommand("mceApplyTextcolor",function(t,e){var n,o=t,r=e;(n=i).undoManager.transact(function(){n.focus(),n.formatter.apply(o,{value:r}),n.nodeChanged()})}),i.addCommand("mceRemoveTextcolor",function(t){var e,n=t;(e=i).undoManager.transact(function(){e.focus(),e.formatter.remove(n,{value:null},null,!0),e.nodeChanged()})});var e=Po(Fb),n=Po(Fb);kb(t,"forecolor","forecolor","Text color",e),kb(t,"backcolor","hilitecolor","Background color",n),Cb(t,"forecolor","forecolor","Text color"),Cb(t,"backcolor","hilitecolor","Background color")}(t),tT(t),(r=t).ui.registry.addButton("outdent",{tooltip:"Decrease indent",icon:"outdent",onSetup:GC(i=r,"NodeChange",function(t){t.setDisabled(!i.queryCommandState("outdent"))}),onAction:YC(r,"outdent")}),r.ui.registry.addButton("indent",{tooltip:"Increase indent",icon:"indent",onAction:YC(r,"indent")}),J_(n=t,LT),o=n,vt.from(o.getParam("content_langs",void 0,"array")).map(function(t){return{name:"language",text:"Language",icon:"language",getOptions:rt(t),hash:function(t){return E(t.customCode)?t.code:t.code+"/"+t.customCode},display:function(t){return t.title},watcher:function(t,e,n){return t.formatter.formatChanged("lang",n,!1,{value:e.code,customValue:e.customCode}).unbind},getCurrent:function(t){return mr(Mt.fromDom(t.selection.getNode()),function(t){return vt.some(t).filter(Ge).bind(function(e){return ue(e,"lang").map(function(t){return{code:t,customCode:ue(e,"data-mce-lang").getOrUndefined(),title:""}})})})},setCurrent:function(t,e){return t.execCommand("Lang",!1,e)},onToolbarSetup:function(t){var e=mc();return t.setActive(o.formatter.match("lang",{},void 0,!0)),e.set(o.formatter.formatChanged("lang",t.setActive,!0)),e.clear}}}).each(function(t){return J_(n,t)})}function nT(t,e){return{type:"makeshift",x:t,y:e}}function oT(t){return"longpress"===t.type||0===t.type.indexOf("touch")}function rT(t,e){return"contextmenu"===e.type||"longpress"===e.type?t.inline?function(t){if(oT(t)){var e=t.touches[0];return nT(e.pageX,e.pageY)}return nT(t.pageX,t.pageY)}(e):(n=t.getContentAreaContainer(),o=function(t){if(oT(t)){var e=t.touches[0];return nT(e.clientX,e.clientY)}return nT(t.clientX,t.clientY)}(e),r=nv.DOM.getPos(n),i=r.x,u=r.y,nT(o.x+i,o.y+u)):zT(t);var n,o,r,i,u}function iT(t,e,n){switch(n){case"node":return{type:"node",node:vt.some(Mt.fromDom((o=t).selection.getNode())),root:Mt.fromDom(o.getBody())};case"point":return rT(t,e);case"selection":return zT(t)}var o}function uT(f,d,m,g,p,h){function t(){var e,n,t,o,r,i,u,a,c,s,l=m();t=l,o=g,r=p,u=!(y||v||b&&x),c=iT(e=f,n=d,a=i=h),s=lt({bubble:Sc(0,"point"===a?12:0,jT),layouts:UT,overrides:{maxWidthFunction:pO(),maxHeightFunction:Nc()}},c),j0(t,Sh.CLOSE_ON_EXECUTE,o,!0).map(function(t){n.preventDefault(),up.showMenuWithinBounds(r,{anchor:s},{menu:{markers:Qp("normal"),highlightImmediately:u},data:t,type:"horizontal"},function(){return vt.some(a_(e,o.shared,"node"===i?"node":"selection"))}),e.fire(V_)})}var e,n=ln(),v=n.os.isiOS(),b=n.os.isOSX(),y=n.os.isAndroid(),x=n.deviceType.isTouch();(b||v)&&"node"!==h?(e=function(){(function(t){function e(){lp.setEditorTimeout(t,function(){t.selection.setRng(n)},10),i()}var n=t.selection.getRng();function o(t){t.preventDefault(),t.stopImmediatePropagation()}function r(){return i()}t.once("touchend",e),t.on("mousedown",o,!0),t.once("longpresscancel",r);var i=function(){t.off("touchend",e),t.off("longpresscancel",r),t.off("mousedown",o)}})(f),t()},function(t,e){var n=t.selection;if(!(n.isCollapsed()||e.touches.length<1)){var o=e.touches[0],r=n.getRng();return xs(t.getWin(),ms.domRange(r)).exists(function(t){return t.left<=o.clientX&&t.right>=o.clientX&&t.top<=o.clientY&&t.bottom>=o.clientY})}}(f,d)?e():(f.once("selectionchange",e),f.once("touchend",function(){return f.off("selectionchange",e)}))):t()}function aT(t){return"string"==typeof t?t.split(/[ ,]/):t}function cT(t){return t.getParam("contextmenu_never_use_native",!1,"boolean")}function sT(t){return y(t)?"|"===t:"separator"===t.type}function lT(t,e){if(0===e.length)return t;var n=q(t).filter(function(t){return!sT(t)}).fold(function(){return[]},function(t){return[WT]});return t.concat(n).concat(e).concat([WT])}function fT(t,e){return"longpress"!==e.type&&(2!==e.button||e.target===t.getBody()&&""===e.pointerType)}function dT(t,e){return fT(t,e)?t.selection.getStart(!0):e.target}function mT(s,t,e){function n(t){return up.hide(i)}function o(c){var t;cT(s)&&c.preventDefault(),c.ctrlKey&&!cT(s)||!1===s.getParam("contextmenu")||(t=function(t,e){var n=t.getParam("contextmenu_avoid_overlap","","string"),o=fT(t,e)?"selection":"point";if(at(n)){var r=dT(t,e);return Yb(Mt.fromDom(r),n)?"node":o}return o}(s,c),(r()?uT:function(t,e,n,o,r,i){var u=n(),a=iT(t,e,i);j0(u,Sh.CLOSE_ON_EXECUTE,o,!1).map(function(t){e.preventDefault(),up.showMenuAt(r,{anchor:a},{menu:{markers:Qp("normal")},data:t})})})(s,c,function(){var t,e,n,o=dT(s,c),r=s.ui.registry.getAll(),i=(n=(e=s).ui.registry.getAll().contextMenus,vt.from(e.getParam("contextmenu")).map(aT).getOrThunk(function(){return F(aT("link linkchecker image imagetools table spellchecker configurepermanentpen"),function(t){return Tt(n,t)})})),u=r.contextMenus,a=o;return 0<(t=R(i,function(o,t){return tt(u,t.toLowerCase()).map(function(t){var e=t.update(a);if(y(e))return lT(o,e.split(" "));if(0<e.length){var n=B(e,GT);return lT(o,n)}return o}).getOrThunk(function(){return o.concat([t])})},[])).length&&sT(t[t.length-1])&&t.pop(),t},e,i,t))}var r=ln().deviceType.isTouch,i=Tu(up.sketch({dom:{tag:"div"},lazySink:t,onEscape:function(){return s.focus()},onShow:function(){return e.setContextMenuState(!0)},onHide:function(){return e.setContextMenuState(!1)},fireDismissalEventInstead:{},inlineBehaviours:ec([mm("dismissContextMenu",[Cr(Yi(),function(t,e){bf.close(t),s.focus()})])])}));s.on("init",function(){var t="ResizeEditor ScrollContent ScrollWindow longpresscancel"+(r()?"":" ResizeWindow");s.on(t,n),s.on("longpress contextmenu",o)})}function gT(e){return function(t){return t.translate(-e.left,-e.top)}}function pT(e){return function(t){return t.translate(e.left,e.top)}}function hT(n){return function(t,e){return R(n,function(t,e){return e(t)},kn(t,e))}}function vT(t,e,n){return t.fold(hT([pT(n),gT(e)]),hT([gT(e)]),hT([]))}function bT(t,e,n){return t.fold(hT([pT(n)]),hT([]),hT([pT(e)]))}function yT(t,e,n){return t.fold(hT([]),hT([gT(n)]),hT([pT(e),gT(n)]))}function xT(t,e,n){var o=t.fold(function(t,e){return{position:vt.some("absolute"),left:vt.some(t+"px"),top:vt.some(e+"px")}},function(t,e){return{position:vt.some("absolute"),left:vt.some(t-n.left+"px"),top:vt.some(e-n.top+"px")}},function(t,e){return{position:vt.some("fixed"),left:vt.some(t+"px"),top:vt.some(e+"px")}});return lt({right:vt.none(),bottom:vt.none()},o)}function wT(t,i,u,a){function e(o,r){return function(t,e){var n=o(i,u,a);return r(t.getOr(n.left),e.getOr(n.top))}}return t.fold(e(yT,YT),e(bT,qT),e(vT,KT))}function ST(t,e){var n=ie(t,e);return E(n)?NaN:parseInt(n,10)}function kT(t,e,n,o,r,i){var u,a,c,s,l,f,d=(u=n,a=o,l=ST(s=t.element,(c=e).leftAttr),f=ST(s,c.topAttr),(isNaN(l)||isNaN(f)?vt.none():vt.some(kn(l,f))).fold(function(){return u},function(t){return KT(t.left+a.left,t.top+a.top)})),m=(e.mustSnap?JT:$T)(t,e,d,r,i),g=vT(d,r,i),p=e,h=g,v=t.element;return oe(v,p.leftAttr,h.left+"px"),oe(v,p.topAttr,h.top+"px"),m.fold(function(){return{coord:KT(g.left,g.top),extra:vt.none()}},function(t){return{coord:t.output,extra:t.extra}})}function CT(t,c,s,l){return K(t,function(t){var e,n,o=t.sensor,r=t.range.left,i=t.range.top,u=bT(c,e=s,n=l),a=bT(o,e,n);return Math.abs(u.left-a.left)<=r&&Math.abs(u.top-a.top)<=i?vt.some({output:wT(t.output,c,s,l),extra:t.extra}):vt.none()})}function OT(t,e){var n;t.getSystem().addToGui(e),Yt((n=e).element).filter(Ge).each(function(e){pe(e,"z-index").each(function(t){oe(e,ZT,t)}),fe(e,"z-index",ge(n.element,"z-index"))})}function _T(t){Yt(t.element).filter(Ge).each(function(e){ue(e,ZT).fold(function(){return ve(e,"z-index")},function(t){return fe(e,"z-index",t)}),ce(e,ZT)}),t.getSystem().removeFromGui(t)}function TT(t,e,n){return t.getSystem().build(ly.sketch({dom:{styles:{left:"0px",top:"0px",width:"100%",height:"100%",position:"fixed","z-index":"1000000000000000"},classes:[e]},events:n}))}function ET(t,e){return{bounds:t.getBounds(),height:we(e.element),width:Oe(e.element)}}function DT(A,B,t,e,n){var o=t.update(e,n),M=t.getStartData().getOrThunk(function(){return ET(B,A)});o.each(function(t){var e,n,o,r,i,u,a,c,s,l,f,d,m,g,p,h,v,b,y,x,w,S,k,C,O,_=A,T=M,E=t,D=(e=B).getTarget(_.element);e.repositionTarget&&(n=Ie(jt(_.element)),o=Uk(D),S=pe(w=D,"left"),k=pe(w,"top"),C=pe(w,"position"),O=function(t,e,n){return("fixed"===n?KT:YT)(parseInt(t,10),parseInt(e,10))},r=(S.isSome()&&k.isSome()&&C.isSome()?vt.some(O(S.getOrDie(),k.getOrDie(),C.getOrDie())):vt.none()).getOrThunk(function(){var t=ke(w);return qT(t.left,t.top)}),i=_,u=e.snaps,a=r,c=n,s=o,l=E,f=T,m=u.fold(function(){var n,o,t=vT((n=l.left,o=l.top,a.fold(function(t,e){return YT(t+n,e+o)},function(t,e){return qT(t+n,e+o)},function(t,e){return KT(t+n,e+o)})),c,s);return KT(t.left,t.top)},function(e){var t=kT(i,e,a,l,c,s);return t.extra.each(function(t){e.onSensor(i,t)}),t.coord}),g=c,p=s,h=(d=f).bounds,v=bT(m,g,p),b=Wa(v.left,h.x,h.x+h.width-d.width),y=Wa(v.top,h.y,h.y+h.height-d.height),x=qT(b,y),me(D,xT(m.fold(function(){var t=yT(x,g,p);return YT(t.left,t.top)},rt(x),function(){var t=vT(x,g,p);return KT(t.left,t.top)}),0,o))),e.onDrag(_,D,E)})}function AT(o,t,e,n){t.each(_T),e.snaps.each(function(t){var e,n;e=t,ce(n=o.element,e.leftAttr),ce(n,e.topAttr)});var r=e.getTarget(o.element);n.reset(),e.onDrop(o,r)}function BT(t){return function(e,n){function o(t){n.setStartData(ET(e,t))}return nu(V([Cr(ji(),function(t){n.getStartData().each(function(){return o(t)})})],t(e,n,o),!0))}}function MT(a,c,s){return[Cr(mi(),function(e,t){var n,o,r,i,u;0===t.event.raw.button&&(t.stop(),r={drop:n=function(){return AT(e,vt.some(i),a,c)},delayDrop:(o=qb(n,200)).schedule,forceDrop:n,move:function(t){o.cancel(),DT(e,a,c,nE,t)}},i=TT(e,a.blockerClass,(u=r,nu([Cr(mi(),u.forceDrop),Cr(hi(),u.drop),Cr(gi(),function(t,e){u.move(e.event)}),Cr(pi(),u.delayDrop)]))),s(e),OT(e,i))})]}function FT(a,c,s){function l(t){AT(t,f.get(),a,c),f.clear()}var f=gc();return[Cr(si(),function(e,t){function n(){return l(e)}t.stop();var o,r,i,u=TT(e,a.blockerClass,(r=o=n,i=function(t){DT(e,a,c,rE,t)},nu([Cr(si(),r),Cr(fi(),o),Cr(di(),o),Cr(li(),function(t,e){i(e.event)})])));f.set(u),s(e),OT(e,u)}),Cr(li(),function(t,e){e.stop(),DT(t,a,c,rE,e.event)}),Cr(fi(),function(t,e){e.stop(),l(t)}),Cr(di(),l)]}function IT(t,r,i,u,e,n){return t.fold(function(){return aE.snap({sensor:qT(i-20,u-20),range:kn(e,n),output:qT(vt.some(i),vt.some(u)),extra:{td:r}})},function(t){var e=i-20,n=u-20,o=t.element.dom.getBoundingClientRect();return aE.snap({sensor:qT(e,n),range:kn(40,40),output:qT(vt.some(i-o.width/2),vt.some(u-o.height/2)),extra:{td:r}})})}function RT(t,i,u){return{getSnapPoints:t,leftAttr:"data-drag-left",topAttr:"data-drag-top",onSensor:function(t,e){var n=e.td,o=i.get(),r=n;o.exists(function(t){return zt(t,r)})||(i.set(n),u(n))},mustSnap:!0}}function NT(t){return Hm(fp.sketch({dom:{tag:"div",classes:["tox-selector"]},buttonBehaviours:ec([aE.config({mode:"mouseOrTouch",blockerClass:"blocker",snaps:t}),vw.config({})]),eventOrder:{mousedown:["dragging","alloy.base.behaviour"],touchstart:["dragging","alloy.base.behaviour"]}}))}function PT(a,n){function e(t){var e=He(t);return IT(g.getOpt(n),t,e.x,e.y,e.width,e.height)}function o(t){var e=He(t);return IT(p.getOpt(n),t,e.right,e.bottom,e.width,e.height)}function r(t,i,e,u){var n=e(i);aE.snapTo(t,n),function(t){var e=i.dom.getBoundingClientRect();ve(t.element,"display");var n=Xt(Mt.fromDom(a.getBody())).dom.innerHeight,o=e[u]<0,r=e[u]>n;(o||r)&&fe(t.element,"display","none")}(t)}function i(t){return r(h,t,e,"top")}function u(t){return r(v,t,o,"bottom")}var c=Po([]),s=Po([]),t=Po(!1),l=gc(),f=gc(),d=RT(function(){return B(c.get(),e)},l,function(e){f.get().each(function(t){a.fire("TableSelectorChange",{start:e,finish:t})})}),m=RT(function(){return B(s.get(),o)},f,function(e){l.get().each(function(t){a.fire("TableSelectorChange",{start:t,finish:e})})}),g=NT(d),p=NT(m),h=Tu(g.asSpec()),v=Tu(p.asSpec());ln().deviceType.isTouch()&&(a.on("TableSelectionChange",function(e){t.get()||(Ns(n,h),Ns(n,v),t.set(!0)),l.set(e.start),f.set(e.finish),e.otherCells.each(function(t){c.set(t.upOrLeftCells),s.set(t.downOrRightCells),i(e.start),u(e.finish)})}),a.on("ResizeEditor ResizeWindow ScrollContent",function(){l.get().each(i),f.get().each(u)}),a.on("TableSelectionClear",function(){t.get()&&(Vs(h),Vs(v),t.set(!1)),l.clear(),f.clear()}))}var VT,HT,LT={name:"lineheight",text:"Line height",icon:"line-height",getOptions:function(t){return t.getParam("lineheight_formats","1 1.1 1.2 1.3 1.4 1.5 2","string").split(" ")},hash:function(t){return r=["fixed","relative","empty"],vt.from(q_.exec(t)).bind(function(t){var e=Number(t[1]),n=t[2],o=n;return d(r,function(t){return d(Y_[t],function(t){return o===t})})?vt.some({value:e,unit:n}):vt.none()}).map(function(t){return t.value+t.unit}).getOr(t);var r},display:h,watcher:function(t,e,n){return t.formatter.formatChanged("lineheight",n,!1,{value:e}).unbind},getCurrent:function(t){return vt.from(t.queryCommandValue("LineHeight"))},setCurrent:function(t,e){return t.execCommand("LineHeight",!1,e)}},zT=function(t){return{type:"selection",root:Mt.fromDom(t.selection.getNode())}},UT={onLtr:function(){return[$a,Xa,Ya,qa,Ka,Ja,cp,sp,Mm,Am,Bm,Dm]},onRtl:function(){return[$a,Ya,Xa,Ka,qa,Ja,cp,sp,Bm,Dm,Mm,Am]}},jT={valignCentre:[],alignCentre:[],alignLeft:["tox-pop--align-left"],alignRight:["tox-pop--align-right"],right:["tox-pop--right"],left:["tox-pop--left"],bottom:["tox-pop--bottom"],top:["tox-pop--top"]},WT={type:"separator"},GT=function(e){function t(t){return{text:t.text,icon:t.icon,disabled:t.disabled,shortcut:t.shortcut}}var n;if(y(e))return e;switch(e.type){case"separator":return WT;case"submenu":return lt(lt({type:"nestedmenuitem"},t(e)),{getSubmenuItems:function(){var t=e.getSubmenuItems();return y(t)?t:B(t,GT)}});default:return lt(lt({type:"menuitem"},t(e)),{onAction:(n=e.onAction,function(){return n()})})}},XT=Vo([{offset:["x","y"]},{absolute:["x","y"]},{fixed:["x","y"]}]),YT=XT.offset,qT=XT.absolute,KT=XT.fixed,JT=function(t,e,l,f,d){var n=e.getSnapPoints(t);return CT(n,l,f,d).orThunk(function(){return R(n,function(e,n){var t,o,r,i,u,a,c,s=(t=n.sensor,n.range.left,n.range.top,i=bT(l,o=f,r=d),u=bT(t,o,r),a=Math.abs(i.left-u.left),c=Math.abs(i.top-u.top),kn(a,c));return e.deltas.fold(function(){return{deltas:vt.some(s),snap:vt.some(n)}},function(t){return(s.left+s.top)/2<=(t.left+t.top)/2?{deltas:vt.some(s),snap:vt.some(n)}:e})},{deltas:vt.none(),snap:vt.none()}).snap.map(function(t){return{output:wT(t.output,l,f,d),extra:t.extra}})})},$T=function(t,e,n,o,r){return CT(e.getSnapPoints(t),n,o,r)},QT=Object.freeze({__proto__:null,snapTo:function(t,e,n,o){var r,i,u,a=e.getTarget(t.element);e.repositionTarget&&(r=Ie(jt(t.element)),i=Uk(a),me(a,xT({coord:wT((u=o).output,u.output,r,i),extra:u.extra}.coord,0,i)))}}),ZT="data-initial-z-index",tE=To("snaps",[mo("getSnapPoints"),Ju("onSensor"),mo("leftAttr"),mo("topAttr"),Eo("lazyViewport",Fn),Eo("mustSnap",!1)]),eE=[Eo("useFixed",T),mo("blockerClass"),Eo("getTarget",h),Eo("onDrag",st),Eo("repositionTarget",!0),Eo("onDrop",st),Io("getBounds",Fn),tE],nE=Object.freeze({__proto__:null,getData:function(t){return vt.from(kn(t.x,t.y))},getDelta:function(t,e){return kn(e.left-t.left,e.top-t.top)}}),oE=V(V([],eE,!0),[ta("dragger",{handlers:BT(MT)})],!1),rE=Object.freeze({__proto__:null,getData:function(t){var e,n=t.raw.touches;return 1===n.length?(e=n[0],vt.some(kn(e.clientX,e.clientY))):vt.none()},getDelta:function(t,e){return kn(e.left-t.left,e.top-t.top)}}),iE=V(V([],eE,!0),[ta("dragger",{handlers:BT(FT)})],!1),uE=V(V([],eE,!0),[ta("dragger",{handlers:BT(function(t,e,n){return V(V([],MT(t,e,n),!0),FT(t,e,n),!0)})})],!1),aE=wa({branchKey:"mode",branches:Object.freeze({__proto__:null,mouse:oE,touch:iE,mouseOrTouch:uE}),name:"dragging",active:{events:function(t,e){return t.dragger.handlers(t,e)}},extra:{snap:function(t){return{sensor:t.sensor,range:t.range,output:t.output,extra:vt.from(t.extra)}}},state:Object.freeze({__proto__:null,init:function(){var i=vt.none(),e=vt.none(),t=rt({});return wu({readState:t,reset:function(){i=vt.none(),e=vt.none()},update:function(r,t){return r.getData(t).bind(function(t){return e=r,n=t,o=i.map(function(t){return e.getDelta(t,n)}),i=vt.some(n),o;var e,n,o})},getStartData:function(){return e},setStartData:function(t){e=vt.some(t)}})}}),apis:QT});function cE(t,e,n){var o,r,i,u,a,c,s=Mt.fromDom(t.getContainer());J((o=t,r=e,i=n,u=xe(s),a=Ce(s),(c={}).height=t_(u+r.top,dh(o),gh(o)),i===VT.Both&&(c.width=t_(a+r.left,fh(o),mh(o))),c),function(t,e){return fe(s,e,ZO(t)),0}),t.fire("ResizeEditor")}function sE(t,e,n,o){return cE(t,kn(20*n,20*o),e),vt.some(!0)}function lE(t,e){var n,o,r,i,u,a,c,s,l,f,d,m,g,p,h,v;return{dom:{tag:"div",classes:["tox-statusbar"]},components:(v=[],t.getParam("elementpath",!0,"boolean")&&v.push((g=t,h=e,(p={}).delimiter||(p.delimiter="\xbb"),{dom:{tag:"div",classes:["tox-statusbar__path"],attributes:{role:"navigation"}},behaviours:ec([Fg.config({mode:"flow",selector:"div[role=button]"}),gd.config({disabled:h.isDisabled}),pv(),py.config({}),Rg.config({}),mm("elementPathEvents",[ou(function(r,t){g.shortcuts.add("alt+F11","focus statusbar elementpath",function(){return Fg.focusIn(r)}),g.on("NodeChange",function(t){var e,o,n=function(t){for(var e=[],n=t.length;0<n--;){var o=t[n];if(1===o.nodeType&&!function(t){if(1===t.nodeType){if("BR"===t.nodeName||t.getAttribute("data-mce-bogus"))return 1;if("bookmark"===t.getAttribute("data-mce-type"))return 1}}(o)){var r=g.fire("ResolveName",{name:o.nodeName.toLowerCase(),target:o});if(r.isDefaultPrevented()||e.push({name:r.name,element:o}),r.isPropagationStopped())break}}return e}(t.parents);0<n.length?Rg.set(r,(e=B(n||[],function(e,t){return fp.sketch({dom:{tag:"div",classes:["tox-statusbar__path-item"],attributes:{role:"button","data-index":t,"tab-index":-1,"aria-level":t+1},innerHtml:e.name},action:function(t){g.focus(),g.selection.select(e.element),g.nodeChanged()},buttonBehaviours:ec([$v(h.isDisabled),pv()])})}),o={dom:{tag:"div",classes:["tox-statusbar__path-divider"],attributes:{"aria-hidden":!0},innerHtml:" "+p.delimiter+" "}},R(e.slice(1),function(t,e){var n=t;return n.push(o),n.push(e),n},[e[0]]))):Rg.set(r,[])})})])]),components:[]})),t.hasPlugin("wordcount")&&v.push((f=t,d=e,fp.sketch({dom:{tag:"button",classes:["tox-statusbar__wordcount"]},components:[],buttonBehaviours:ec([$v(d.isDisabled),pv(),py.config({}),Rg.config({}),Df.config({store:{mode:"memory",initialValue:{mode:"words",count:{words:0,characters:0}}}}),mm("wordcount-events",[uu(function(t){var e=Df.getValue(t),n="words"===e.mode?"characters":"words";Df.setValue(t,{mode:n,count:e.count}),b(t,e.count,n)}),ou(function(n){f.on("wordCountUpdate",function(t){var e=Df.getValue(n).mode;Df.setValue(n,{mode:e,count:t.wordCount}),b(n,t.wordCount,e)})})])]),eventOrder:((m={})[Ii()]=["disabling","alloy.base.behaviour","wordcount-events"],m)}))),t.getParam("branding",!0,"boolean")&&v.push({dom:{tag:"span",classes:["tox-statusbar__branding"],innerHtml:'<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="'+(l=dp.translate(["Powered by {0}","Tiny"]))+'">'+l+"</a>"}}),n=0<v.length?[{dom:{tag:"div",classes:["tox-statusbar__text-container"]},components:v}]:[],i=e,a=!(u=r=t).hasPlugin("autoresize"),o=(s=!1===(c=u.getParam("resize",a))?VT.None:"both"===c?VT.Both:VT.Vertical)===VT.None?vt.none():vt.some(Xm("resize-handle",{tag:"div",classes:["tox-statusbar__resize-handle"],attributes:{title:i.translate("Resize")},behaviours:[aE.config({mode:"mouse",repositionTarget:!1,onDrag:function(t,e,n){return cE(r,n,s)},blockerClass:"tox-blocker"}),Fg.config({mode:"special",onLeft:function(){return sE(r,s,-1,0)},onRight:function(){return sE(r,s,1,0)},onUp:function(){return sE(r,s,0,-1)},onDown:function(){return sE(r,s,0,1)}}),py.config({}),Vg.config({})]},i.icons)),n.concat(o.toArray()))};function b(t,e,n){return Rg.set(t,[ri(d.translate(["{0} "+n,e[n]]))])}}function fE(d){function m(){return i.bind(FO.getHeader)}function g(){return Nn.value(y)}function p(){return i.bind(function(t){return FO.getThrobber(t)}).getOrDie("Could not find throbber element")}var t,e,n,o,r=d.inline,h=r?P_:N_,v=dv(d)?q1:V1,i=vt.none(),u=ln(),a=u.browser.isIE()?["tox-platform-ie"]:[],c=u.deviceType.isTouch()?["tox-platform-touch"]:[],s=av(d),l=lv(d),f=dp.isRtl()?{attributes:{dir:"rtl"}}:{},b={attributes:((t={})[ns]=s?Oc.BottomToTop:Oc.TopToBottom,t)},y=Tu((e=zt(bn(),l)&&"grid"===ge(l,"display"),n={dom:lt({tag:"div",classes:["tox","tox-silver-sink","tox-tinymce-aux"].concat(a).concat(c)},f),behaviours:ec([ff.config({useFixed:function(){return v.isDocked(m)}})])},o={dom:{styles:{width:document.body.clientWidth+"px"}},events:nu([Cr(Wi(),function(){fe(J.element,"width",document.body.clientWidth+"px")})])},Yo(n,e?o:{}))),x=Hm({dom:{tag:"div",classes:["tox-anchorbar"]}}),w=Lk(y,d,function(){return i.bind(function(t){return x.getOpt(t)}).getOrDie("Could not find a anchor bar element")}),S=FO.parts.menubar({dom:{tag:"div",classes:["tox-menubar"]},backstage:w,onEscape:function(){d.focus()}}),k=iv(d),C=FO.parts.toolbar(lt({dom:{tag:"div",classes:["tox-toolbar"]},getSink:g,providers:w.shared.providers,onEscape:function(){d.focus()},type:k,lazyToolbar:function(){return i.bind(function(t){return FO.getToolbar(t)}).getOrDie("Could not find more toolbar element")},lazyHeader:function(){return m().getOrDie("Could not find header element")}},b)),O=FO.parts["multiple-toolbar"]({dom:{tag:"div",classes:["tox-toolbar-overlord"]},providers:w.shared.providers,onEscape:function(){d.focus()},type:k}),_=FO.parts.socket({dom:{tag:"div",classes:["tox-edit-area"]}}),T=FO.parts.sidebar({dom:{tag:"div",classes:["tox-sidebar"]}}),E=FO.parts.throbber({dom:{tag:"div",classes:["tox-throbber"]},backstage:w}),D=d.getParam("statusbar",!0,"boolean")&&!r?vt.some(lE(d,w.shared.providers)):vt.none(),A={dom:{tag:"div",classes:["tox-sidebar-wrap"]},components:[_,T]},B=rv(d),M=hh(d),F=ph(d),I=FO.parts.header({dom:lt({tag:"div",classes:["tox-editor-header"]},b),components:ft([F?[S]:[],B?[O]:M?[C]:[],sv(d)?[]:[x.asSpec()]]),sticky:dv(d),editor:d,sharedBackstage:w.shared}),R=ft([s?[]:[I],r?[]:[A],s?[I]:[]]),N=ft([[{dom:{tag:"div",classes:["tox-editor-container"]},components:R}],r?[]:D.toArray(),[E]]),P=fv(d),V=lt(lt({role:"application"},dp.isRtl()?{dir:"rtl"}:{}),P?{"aria-hidden":"true"}:{}),H=Tu(FO.sketch({dom:{tag:"div",classes:["tox","tox-tinymce"].concat(r?["tox-tinymce-inline"]:[]).concat(s?["tox-tinymce--toolbar-bottom"]:[]).concat(c).concat(a),styles:lt({visibility:"hidden"},P?{opacity:"0",border:"0"}:{}),attributes:V},components:N,behaviours:ec([pv(),gd.config({disableClass:"tox-tinymce--disabled"}),Fg.config({mode:"cyclic",selector:".tox-menubar, .tox-toolbar, .tox-toolbar__primary, .tox-toolbar__overflow--open, .tox-sidebar__overflow--open, .tox-statusbar__path, .tox-statusbar__wordcount, .tox-statusbar__branding a, .tox-statusbar__resize-handle"})])})),i=vt.some(H);d.shortcuts.add("alt+F9","focus menubar",function(){FO.focusMenubar(H)}),d.shortcuts.add("alt+F10","focus toolbar",function(){FO.focusToolbar(H)}),d.addCommand("ToggleToolbarDrawer",function(){FO.toggleToolbarDrawer(H)}),d.addQueryStateHandler("ToggleToolbarDrawer",function(){return FO.isToolbarDrawerToggled(H)});var L,z,U,j,W,G,X,Y,q,K=ey(H),J=ey(y);function $(){var t,e,n,o,r,i,u=ZO((o=sh(n=e=d),r=dh(n),i=gh(n),QO(o).map(function(t){return t_(t,r,i)}).getOr(sh(e)))),a=ZO(e_(t=d).getOr(lh(t)));return d.inline||(he("div","width",a)&&fe(H.element,"width",a),he("div","height",u)?fe(H.element,"height",u):fe(H.element,"height","200px")),u}return L=d,z=K,U=J,j=Sa(),W=pc(j,"touchstart",tt),G=pc(j,"touchmove",function(t){return Q(zi(),t)}),X=pc(j,"touchend",function(t){return Q(Ui(),t)}),Y=pc(j,"mousedown",tt),q=pc(j,"mouseup",function(t){0===t.raw.button&&Z(wf(),{target:t.target})}),L.on("PostRender",function(){L.on("click",et),L.on("tap",et),L.on("mouseup",nt),L.on("mousedown",ot),L.on("ScrollWindow",rt),L.on("ResizeWindow",it),L.on("ResizeEditor",ut),L.on("AfterProgressState",at),L.on("DismissPopups",ct)}),L.on("remove",function(){L.off("click",et),L.off("tap",et),L.off("mouseup",nt),L.off("mousedown",ot),L.off("ScrollWindow",rt),L.off("ResizeWindow",it),L.off("ResizeEditor",ut),L.off("AfterProgressState",at),L.off("DismissPopups",ct),Y.unbind(),W.unbind(),G.unbind(),X.unbind(),q.unbind()}),L.on("detach",function(){zs(z),zs(U),z.destroy(),U.destroy()}),{mothership:K,uiMothership:J,backstage:w,renderUI:function(){var o,r;v.setup(d,w.shared,m),eT(d,w),mT(d,g,w),r=(o=d).ui.registry.getAll().sidebars,St(Ct(r),function(e){function n(){return mt(vt.from(o.queryCommandValue("ToggleSidebar")),e)}var t=r[e];o.ui.registry.addToggleButton(e,{icon:t.icon,tooltip:t.tooltip,onAction:function(t){o.execCommand("ToggleSidebar",!1,e),t.setActive(n())},onSetup:function(t){function e(){return t.setActive(n())}return o.on("ToggleSidebar",e),function(){o.off("ToggleSidebar",e)}}})}),SC(d,p,w.shared),dt(d.getParam("toolbar_groups",{},"object"),function(t,e){d.ui.registry.addGroupToolbarButton(e,t)});var t,e=d.ui.registry.getAll(),n=e.buttons,i=e.menuItems,u=e.contextToolbars,a=e.sidebars,c=vh(d),s={menuItems:i,menus:(t=d.getParam("menu"))?dt(t,function(t){return lt(lt({},t),{items:t.items})}):{},menubar:d.getParam("menubar"),toolbar:c.getOrThunk(function(){return d.getParam("toolbar",!0)}),allowToolbarGroups:k===bh.floating,buttons:n,sidebar:a};m_(d,u,y,{backstage:w}),PT(d,y);var l=d.getElement(),f=$();return h.render(d,{mothership:K,uiMothership:J,outerContainer:H},s,w,{targetNode:l,height:f})},getUi:function(){return{channels:{broadcastAll:J.broadcast,broadcastOn:J.broadcastOn,register:st}}}};function Q(e,n){St([z,U],function(t){t.broadcastEvent(e,n)})}function Z(e,n){St([z,U],function(t){t.broadcastOn([e],n)})}function tt(t){return Z(yf(),{target:t.target})}function et(t){return Z(yf(),{target:Mt.fromDom(t.target)})}function nt(t){0===t.button&&Z(wf(),{target:Mt.fromDom(t.target)})}function ot(){St(L.editorManager.get(),function(t){L!==t&&t.fire("DismissPopups",{relatedTarget:L})})}function rt(t){return Q(ji(),Mc(t))}function it(t){Z(xf(),{}),Q(Wi(),Mc(t))}function ut(){return Z(xf(),{})}function at(t){t.state&&Z(yf(),{target:Mt.fromDom(L.getContainer())})}function ct(t){Z(yf(),{target:Mt.fromDom(t.relatedTarget.getContainer())})}}function dE(e){return ar("items","items",jn(),eo(io(function(t){return ao("Checking item of "+e,AD,t).fold(function(t){return Nn.error(ur(t))},function(t){return Nn.value(t)})})))}function mE(t){return y(t.type)&&y(t.name)}function gE(t){return{internalDialog:co(ao("dialog",VD,t)),dataValidator:(e=H(F(zD(t),mE),function(e){return vt.from(UD[e.type]).fold(function(){return[]},function(t){return[go(e.name,t)]})}),$o(e)),initialData:t.initialData};var e}function pE(t){var n=[],o={};return J(t,function(t,e){t.fold(function(){n.push(e)},function(t){o[e]=t})}),0<n.length?Nn.error(n):Nn.value(o)}function hE(t,e){fe(t,"height",e+"px"),ln().browser.isIE()?ve(t,"flex-basis"):fe(t,"flex-basis",e+"px")}function vE(t,d,e){Fu(t,'[role="dialog"]').each(function(f){Iu(f,'[role="tablist"]').each(function(l){e.get().map(function(t){return fe(d,"height","0"),fe(d,"flex-basis","0"),Math.min(t,(n=d,o=l,r=Gt(e=f).dom,i="fixed"===ge(Fu(e,".tox-dialog-wrap").getOr(e),"position")?Math.max(r.clientHeight,window.innerHeight):Math.max(r.offsetHeight,r.scrollHeight),u=xe(n),a=n.dom.offsetLeft>=o.dom.offsetLeft+Ce(o)?Math.max(xe(o),u):u,c=parseInt(ge(e,"margin-top"),10)||0,s=parseInt(ge(e,"margin-bottom"),10)||0,i-(xe(e)+c+s-a)));var e,n,o,r,i,u,a,c,s}).each(function(t){hE(d,t)})})})}function bE(t){return Iu(t,'[role="tabpanel"]')}function yE(t,n){function o(t){var e=pE(Df.getValue(t)).getOr({}),n=i.get(),o=Yo(n,e);i.set(o)}function r(t){var e=i.get();Df.setValue(t,e)}var u,a,i=Po({}),c=Po(null),e=B(t.tabs,function(t){return{value:t.name,dom:{tag:"div",classes:["tox-dialog__body-nav-item"],innerHtml:n.shared.providers.translate(t.title)},view:function(){return[nS.sketch(function(e){return{dom:{tag:"div",classes:["tox-form"]},components:B(t.items,function(t){return hk(e,t,n)}),formBehaviours:ec([Fg.config({mode:"acyclic",useTabstopAt:O(p0)}),mm("TabView.form.events",[ou(r),ru(o)]),ic.config({channels:lr([{key:QD,value:{onReceive:o}},{key:ZD,value:{onReceive:r}}])})])}})]}}}),s=(u=e,a=gc(),{extraEvents:[ou(function(t){var o=t.element;bE(o).each(function(e){var n;fe(e,"visibility","hidden"),t.getSystem().getByDom(e).toOptional().each(function(t){var o,r,i;Y(G((r=e,i=t,B(o=u,function(t,e){Rg.set(i,o[e].view());var n=r.dom.getBoundingClientRect();return Rg.set(i,[]),n.height})),function(t,e){return e<t?-1:t<e?1:0})).fold(a.clear,a.set)}),vE(o,e,a),ve(e,"visibility"),n=t,Y(u).each(function(t){return $D.showTab(n,t.value)}),lp.requestAnimationFrame(function(){vE(o,e,a)})})}),Cr(Wi(),function(t){var e=t.element;bE(e).each(function(t){vE(e,t,a)})}),Cr(Ty,function(t,e){var r=t.element;bE(r).each(function(e){var t=Oa(gn(e));fe(e,"visibility","hidden");var n=pe(e,"height").map(function(t){return parseInt(t,10)});ve(e,"height"),ve(e,"flex-basis");var o=e.dom.getBoundingClientRect().height;n.forall(function(t){return t<o})?(a.set(o),vE(r,e,a)):n.each(function(t){hE(e,t)}),ve(e,"visibility"),t.each(ka)})})],selectFirst:!1});return $D.sketch({dom:{tag:"div",classes:["tox-dialog__body"]},onChangeTab:function(t,e,n){var o=Df.getValue(e);br(t,_y,{name:o,oldName:c.get()}),c.set(o)},tabs:e,components:[$D.parts.tabbar({dom:{tag:"div",classes:["tox-dialog__body-nav"]},components:[YD.parts.tabs({})],markers:{tabClass:"tox-tab",selectedClass:"tox-dialog__body-nav-item--active"},tabbarBehaviours:ec([py.config({})])}),$D.parts.tabview({dom:{tag:"div",classes:["tox-dialog__body-content"]}})],selectFirst:s.selectFirst,tabSectionBehaviours:ec([mm("tabpanel",s.extraEvents),Fg.config({mode:"acyclic"}),cd.config({find:function(t){return Y($D.getViewItems(t))}}),Df.config({store:{mode:"manual",getValue:function(t){return t.getSystem().broadcastOn([QD],{}),i.get()},setValue:function(t,e){i.set(e),t.getSystem().broadcastOn([ZD],{})}}})])})}function xE(t,e,r,n){return{dom:{tag:"div",classes:["tox-dialog__content-js"],attributes:lt(lt({},e.map(function(t){return{id:t}}).getOr({})),n?{"aria-live":"polite"}:{})},components:[],behaviours:ec([cS(0),k_.config({channel:nA,updateState:function(t,e){return vt.some({isTabPanel:function(){return"tabpanel"===e.body.type}})},renderComponents:function(t){return"tabpanel"!==t.body.type?[(n=t.body,o=r,{dom:{tag:"div",classes:["tox-dialog__body"]},components:[{dom:{tag:"div",classes:["tox-dialog__body-content"]},components:[(e=Hm(nS.sketch(function(e){return{dom:{tag:"div",classes:["tox-form"].concat(n.classes)},components:B(n.items,function(t){return hk(e,t,o)})}}))).asSpec()]}],behaviours:ec([Fg.config({mode:"acyclic",useTabstopAt:O(p0)}),aS(e),mS(e,{postprocess:function(t){return pE(t).fold(function(t){return console.error(t),{}},h)}})])})]:[yE(t.body,r)];var n,o,e},initialData:t})])}}(HT=VT=VT||{})[HT.None=0]="None",HT[HT.Both=1]="Both",HT[HT.Vertical=2]="Vertical";var wE,SE=rt([mo("lazySink"),wo("dragBlockClass"),Io("getBounds",Fn),Eo("useTabstopAt",D),Eo("eventOrder",{}),Zs("modalBehaviours",[Fg]),$u("onExecute"),Zu("onEscape")]),kE={sketch:h},CE=rt([Qf({name:"draghandle",overrides:function(t,e){return{behaviours:ec([aE.config({mode:"mouse",getTarget:function(t){return Fu(t,'[role="dialog"]').getOr(t)},blockerClass:t.dragBlockClass.getOrDie(new Error("The drag blocker class was not specified for a dialog with a drag handle: \n"+JSON.stringify(e,null,2)).message),getBounds:t.getDragBounds})])}}}),Jf({schema:[mo("dom")],name:"title"}),Jf({factory:kE,schema:[mo("dom")],name:"close"}),Jf({factory:kE,schema:[mo("dom")],name:"body"}),Qf({factory:kE,schema:[mo("dom")],name:"footer"}),$f({factory:{sketch:function(t,e){return lt(lt({},t),{dom:e.dom,components:e.components})}},schema:[Eo("dom",{tag:"div",styles:{position:"fixed",left:"0px",top:"0px",right:"0px",bottom:"0px"}}),Eo("components",[])],name:"blocker"})]),OE=Cl({name:"ModalDialog",configFields:SE(),partFields:CE(),factory:function(a,t,e,r){var n,i=gc(),o=Ir("modal-events"),u=lt(lt({},a.eventOrder),((n={})[Gi()]=[o].concat(a.eventOrder["alloy.system.attached"]||[]),n));return{uid:a.uid,dom:a.dom,components:t,apis:{show:function(t){i.set(t);var e=a.lazySink(t).getOrDie(),n=r.blocker(),o=e.getSystem().build(lt(lt({},n),{components:n.components.concat([Eu(t)]),behaviours:ec([Vg.config({}),mm("dialog-blocker-events",[Ar(bi(),function(){Fg.focusIn(t)})])])}));Ns(e,o),Fg.focusIn(t)},hide:function(e){i.clear(),Yt(e.element).each(function(t){e.getSystem().getByDom(t).each(function(t){Vs(t)})})},getBody:function(t){return gl(t,a,"body")},getFooter:function(t){return gl(t,a,"footer")},setIdle:function(t){fO.unblock(t)},setBusy:function(t,e){fO.block(t,e)}},eventOrder:u,domModification:{attributes:{role:"dialog","aria-modal":"true"}},behaviours:el(a.modalBehaviours,[Rg.config({}),Fg.config({mode:"cyclic",onEnter:a.onExecute,onEscape:a.onEscape,useTabstopAt:a.useTabstopAt}),fO.config({getRoot:i.get}),mm(o,[ou(function(t){var e,n,o,r=t.element,i=gl(t,a,"title").element,u=ue(r,"id").fold(function(){var t=Ir("dialog-label");return oe(i,"id",t),t},h);oe(r,"aria-labelledby",u),e=t.element,n=gl(t,a,"body").element,o=vt.from(ie(e,"id")).fold(function(){var t=Ir("dialog-describe");return oe(n,"id",t),t},h),oe(e,"aria-describedby",o)})])])}},apis:{show:function(t,e){t.show(e)},hide:function(t,e){t.hide(e)},getBody:function(t,e){return t.getBody(e)},getFooter:function(t,e){return t.getFooter(e)},setBusy:function(t,e,n){t.setBusy(e,n)},setIdle:function(t,e){t.setIdle(e)}}}),_E=$o([po("type"),po("name")].concat(zh)),TE=nr,EE=[ar("name","name",Wn(function(){return Ir("button-name")}),er),Co("icon"),Mo("align","end",["start","end"]),Fo("primary",!1),Fo("disabled",!1)],DE=V(V([],EE,!0),[po("text")],!1),AE=V([ho("type",["submit","cancel","custom"])],DE,!0),BE=lo("type",{submit:AE,cancel:AE,custom:AE,menu:V([ho("type",["menu"]),Co("text"),Co("tooltip"),Co("icon"),xo("items",_E)],EE,!0)}),ME=[po("type"),po("text"),ho("level",["info","warn","error","success"]),po("icon"),Eo("url","")],FE=$o(ME),IE=[po("type"),po("text"),Fo("disabled",!1),Fo("primary",!1),ar("name","name",Wn(function(){return Ir("button-name")}),er),Co("icon"),Fo("borderless",!1)],RE=$o(IE),NE=[po("type"),po("name"),po("label"),Fo("disabled",!1)],PE=$o(NE),VE=nr,HE=[po("type"),po("name")],LE=HE.concat([Co("label")]),zE=LE.concat([Eo("columns","auto")]),UE=$o(zE),jE=Qo([po("value"),po("text"),po("icon")]),WE=$o(LE),GE=er,XE=$o(LE),YE=er,qE=HE.concat([Bo("tag","textarea"),po("scriptId"),po("scriptUrl"),Do("settings",void 0,ir)]),KE=HE.concat([Bo("tag","textarea"),vo("init")]),JE=io(function(t){return ao("customeditor.old",to(KE),t).orThunk(function(){return ao("customeditor.new",to(qE),t)})}),$E=er,QE=$o(LE),ZE=eo(Jo),tD=[po("type"),po("html"),Mo("presets","presentation",["presentation","document"])],eD=$o(tD),nD=LE.concat([Fo("sandboxed",!0)]),oD=$o(nD),rD=er,iD=LE.concat([go("currentState",$o([mo("blob"),po("url")]))]),uD=$o(iD),aD=LE.concat([Co("inputMode"),Co("placeholder"),Fo("maximized",!1),Fo("disabled",!1)]),cD=$o(aD),sD=er,lD=[po("text"),po("value")],fD=[po("text"),xo("items",(wE=Rt(function(){return dD}),{extract:function(t,e){return wE().extract(t,e)},toString:function(){return wE().toString()}}))],dD=no([$o(lD),$o(fD)]),mD=LE.concat([xo("items",dD),Fo("disabled",!1)]),gD=$o(mD),pD=er,hD=LE.concat([yo("items",[po("text"),po("value")]),Ao("size",1),Fo("disabled",!1)]),vD=$o(hD),bD=er,yD=LE.concat([Fo("constrain",!0),Fo("disabled",!1)]),xD=$o(yD),wD=$o([po("width"),po("height")]),SD=[po("type"),xo("header",er),xo("cells",eo(er))],kD=$o(SD),CD=LE.concat([Co("placeholder"),Fo("maximized",!1),Fo("disabled",!1)]),OD=$o(CD),_D=er,TD=LE.concat([Mo("filetype","file",["image","media","file"]),Eo("disabled",!1)]),ED=$o(TD),DD=$o([po("value"),Eo("meta",{})]),AD=Zn(function(){return ro("type",{alertbanner:FE,bar:$o((n=dE("bar"),[po("type"),n])),button:RE,checkbox:PE,colorinput:WE,colorpicker:XE,dropzone:QE,grid:$o((t=dE("grid"),[po("type"),go("columns",tr),t])),iframe:oD,input:cD,listbox:gD,selectbox:vD,sizeinput:xD,textarea:OD,urlinput:ED,customeditor:JE,htmlpanel:eD,imagetools:uD,collection:UE,label:$o((e=dE("label"),[po("type"),po("label"),e])),table:kD,panel:MD});var t,e,n}),BD=[po("type"),Eo("classes",[]),xo("items",AD)],MD=$o(BD),FD=[ar("name","name",Wn(function(){return Ir("tab-name")}),er),po("title"),xo("items",AD)],ID=[po("type"),yo("tabs",FD)],RD=$o(ID),ND=DE,PD=BE,VD=$o([po("title"),go("body",ro("type",{panel:MD,tabpanel:RD})),Bo("size","normal"),xo("buttons",PD),Eo("initialData",{}),Io("onAction",st),Io("onChange",st),Io("onSubmit",st),Io("onClose",st),Io("onCancel",st),Eo("onTabChange",st)]),HD=$o(V([ho("type",["cancel","custom"])],ND,!0)),LD=$o([po("title"),po("url"),ko("height"),ko("width"),_o("buttons",HD),Io("onAction",st),Io("onCancel",st),Io("onClose",st),Io("onMessage",st)]),zD=function(t){return x(t)?[t].concat(H(Z(t),zD)):c(t)?H(t,zD):[]},UD={checkbox:VE,colorinput:GE,colorpicker:YE,dropzone:ZE,input:sD,iframe:rD,sizeinput:wD,selectbox:bD,listbox:pD,size:wD,textarea:_D,urlinput:DD,customeditor:$E,collection:jE,togglemenuitem:TE},jD={open:function(t,e){var n=gE(e);return t(n.internalDialog,n.initialData,n.dataValidator)},openUrl:function(t,e){return t(co(ao("dialog",LD,e)))},redial:gE},WD=kl({name:"TabButton",configFields:[Eo("uid",void 0),mo("value"),ar("dom","dom",Yn(function(){return{attributes:{role:"tab",id:Ir("aria"),"aria-selected":"false"}}}),Zo()),wo("action"),Eo("domModification",{}),Zs("tabButtonBehaviours",[Vg,Fg,Df]),mo("view")],factory:function(t,e){return{uid:t.uid,dom:t.dom,components:t.components,events:Sm(t.action),behaviours:el(t.tabButtonBehaviours,[Vg.config({}),Fg.config({mode:"execution",useSpace:!0,useEnter:!0}),Df.config({store:{mode:"memory",initialValue:t.value}})]),domModification:t.domModification}}}),GD=rt([mo("tabs"),mo("dom"),Eo("clickToDismiss",!1),Zs("tabbarBehaviours",[hd,Fg]),qu(["tabClass","selectedClass"])]),XD=rt([Zf({factory:WD,name:"tabs",unit:"tab",overrides:function(o){return{action:function(t){var e=t.getSystem().getByUid(o.uid).getOrDie(),n=hd.isHighlighted(e,t);(n&&o.clickToDismiss?function(t,e){hd.dehighlight(t,e),br(t,Qi(),{tabbar:t,button:e})}:n?st:function(t,e){hd.highlight(t,e),br(t,$i(),{tabbar:t,button:e})})(e,t)},domModification:{classes:[o.markers.tabClass]}}}})]),YD=Cl({name:"Tabbar",configFields:GD(),partFields:XD(),factory:function(t,e,n,o){return{uid:t.uid,dom:t.dom,components:e,"debug.sketcher":"Tabbar",domModification:{attributes:{role:"tablist"}},behaviours:el(t.tabbarBehaviours,[hd.config({highlightClass:t.markers.selectedClass,itemClass:t.markers.tabClass,onHighlight:function(t,e){oe(e.element,"aria-selected","true")},onDehighlight:function(t,e){oe(e.element,"aria-selected","false")}}),Fg.config({mode:"flow",getInitial:function(t){return hd.getHighlighted(t).map(function(t){return t.element})},selector:"."+t.markers.tabClass,executeOnMove:!0})])}}}),qD=kl({name:"Tabview",configFields:[Zs("tabviewBehaviours",[Rg])],factory:function(t,e){return{uid:t.uid,dom:t.dom,behaviours:el(t.tabviewBehaviours,[Rg.config({})]),domModification:{attributes:{role:"tabpanel"}}}}}),KD=rt([Eo("selectFirst",!0),Ju("onChangeTab"),Ju("onDismissTab"),Eo("tabs",[]),Zs("tabSectionBehaviours",[])]),JD=rt([Jf({factory:YD,schema:[mo("dom"),bo("markers",[mo("tabClass"),mo("selectedClass")])],name:"tabbar",defaults:function(t){return{tabs:t.tabs}}}),Jf({factory:qD,name:"tabview"})]),$D=Cl({name:"TabSection",configFields:KD(),partFields:JD(),factory:function(i,t,e,n){function o(t,e){ml(t,i,"tabbar").each(function(t){e(t).each(yr)})}return{uid:i.uid,dom:i.dom,components:t,behaviours:tl(i.tabSectionBehaviours),events:nu(ft([i.selectFirst?[ou(function(t,e){o(t,hd.getFirst)})]:[],[Cr($i(),function(t,e){var o=e.event.button,r=Df.getValue(o);ml(o,i,"tabview").each(function(n){N(i.tabs,function(t){return t.value===r}).each(function(t){var e=t.view();ue(o.element,"id").each(function(t){oe(n.element,"aria-labelledby",t)}),Rg.set(n,e),i.onChangeTab(n,o,e)})})}),Cr(Qi(),function(t,e){var n=e.event.button;i.onDismissTab(t,n)})]])),apis:{getViewItems:function(t){return ml(t,i,"tabview").map(function(t){return Rg.contents(t)}).getOr([])},showTab:function(t,n){o(t,function(e){return N(hd.getCandidates(e),function(t){return Df.getValue(t)===n}).filter(function(t){return!hd.isHighlighted(e,t)})})}}}},apis:{getViewItems:function(t,e){return t.getViewItems(e)},showTab:function(t,e,n){t.showTab(e,n)}}}),QD="send-data-to-section",ZD="send-data-to-view",tA=Ir("update-dialog"),eA=Ir("update-title"),nA=Ir("update-body"),oA=Ir("update-footer"),rA=Ir("body-send-message");function iA(t){return(iA="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function uA(t,e){return(uA=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function aA(t,e,n){return(aA=function(){if("undefined"!=typeof Reflect&&Reflect.construct&&!Reflect.construct.sham){if("function"==typeof Proxy)return 1;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){})),1}catch(t){return}}}()?Reflect.construct:function(t,e,n){var o=[null];o.push.apply(o,e);var r=new(Function.bind.apply(t,o));return n&&uA(r,n.prototype),r}).apply(null,arguments)}function cA(t){return function(t){if(Array.isArray(t))return sA(t)}(t)||function(){if("undefined"!=typeof Symbol&&null!=t[Symbol.iterator]||null!=t["@@iterator"])return Array.from(t)}()||function(t){if(t){if("string"==typeof t)return sA(t,void 0);var e=Object.prototype.toString.call(t).slice(8,-1);return"Map"===(e="Object"===e&&t.constructor?t.constructor.name:e)||"Set"===e?Array.from(t):"Arguments"===e||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e)?sA(t,void 0):void 0}}(t)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function sA(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,o=new Array(e);n<e;n++)o[n]=t[n];return o}var lA,fA=Object.hasOwnProperty,dA=Object.setPrototypeOf,mA=Object.isFrozen,gA=Object.getPrototypeOf,pA=Object.getOwnPropertyDescriptor,hA=Object.freeze,vA=Object.seal,bA=Object.create,yA="undefined"!=typeof Reflect&&Reflect,xA=yA.apply||function(t,e,n){return t.apply(e,n)},hA=hA||function(t){return t},vA=vA||function(t){return t},wA=yA.construct||function(t,e){return aA(t,cA(e))},SA=MA(Array.prototype.forEach),kA=MA(Array.prototype.pop),CA=MA(Array.prototype.push),OA=MA(String.prototype.toLowerCase),_A=MA(String.prototype.match),TA=MA(String.prototype.replace),EA=MA(String.prototype.indexOf),DA=MA(String.prototype.trim),AA=MA(RegExp.prototype.test),BA=(lA=TypeError,function(){for(var t=arguments.length,e=new Array(t),n=0;n<t;n++)e[n]=arguments[n];return wA(lA,e)});function MA(r){return function(t){for(var e=arguments.length,n=new Array(1<e?e-1:0),o=1;o<e;o++)n[o-1]=arguments[o];return xA(r,t,n)}}function FA(t,e){dA&&dA(t,null);for(var n=e.length;n--;){var o,r=e[n];"string"!=typeof r||(o=OA(r))!==r&&(mA(e)||(e[n]=o),r=o),t[r]=!0}return t}function IA(t){var e,n=bA(null);for(e in t)xA(fA,t,[e])&&(n[e]=t[e]);return n}function RA(t,e){for(;null!==t;){var n=pA(t,e);if(n){if(n.get)return MA(n.get);if("function"==typeof n.value)return MA(n.value)}t=gA(t)}return function(t){return console.warn("fallback value for",t),null}}var NA=hA(["a","abbr","acronym","address","area","article","aside","audio","b","bdi","bdo","big","blink","blockquote","body","br","button","canvas","caption","center","cite","code","col","colgroup","content","data","datalist","dd","decorator","del","details","dfn","dialog","dir","div","dl","dt","element","em","fieldset","figcaption","figure","font","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","img","input","ins","kbd","label","legend","li","main","map","mark","marquee","menu","menuitem","meter","nav","nobr","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","section","select","shadow","small","source","spacer","span","strike","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","tr","track","tt","u","ul","var","video","wbr"]),PA=hA(["svg","a","altglyph","altglyphdef","altglyphitem","animatecolor","animatemotion","animatetransform","circle","clippath","defs","desc","ellipse","filter","font","g","glyph","glyphref","hkern","image","line","lineargradient","marker","mask","metadata","mpath","path","pattern","polygon","polyline","radialgradient","rect","stop","style","switch","symbol","text","textpath","title","tref","tspan","view","vkern"]),VA=hA(["feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feDistantLight","feFlood","feFuncA","feFuncB","feFuncG","feFuncR","feGaussianBlur","feImage","feMerge","feMergeNode","feMorphology","feOffset","fePointLight","feSpecularLighting","feSpotLight","feTile","feTurbulence"]),HA=hA(["animate","color-profile","cursor","discard","fedropshadow","font-face","font-face-format","font-face-name","font-face-src","font-face-uri","foreignobject","hatch","hatchpath","mesh","meshgradient","meshpatch","meshrow","missing-glyph","script","set","solidcolor","unknown","use"]),LA=hA(["math","menclose","merror","mfenced","mfrac","mglyph","mi","mlabeledtr","mmultiscripts","mn","mo","mover","mpadded","mphantom","mroot","mrow","ms","mspace","msqrt","mstyle","msub","msup","msubsup","mtable","mtd","mtext","mtr","munder","munderover"]),zA=hA(["maction","maligngroup","malignmark","mlongdiv","mscarries","mscarry","msgroup","mstack","msline","msrow","semantics","annotation","annotation-xml","mprescripts","none"]),UA=hA(["#text"]),jA=hA(["accept","action","align","alt","autocapitalize","autocomplete","autopictureinpicture","autoplay","background","bgcolor","border","capture","cellpadding","cellspacing","checked","cite","class","clear","color","cols","colspan","controls","controlslist","coords","crossorigin","datetime","decoding","default","dir","disabled","disablepictureinpicture","disableremoteplayback","download","draggable","enctype","enterkeyhint","face","for","headers","height","hidden","high","href","hreflang","id","inputmode","integrity","ismap","kind","label","lang","list","loading","loop","low","max","maxlength","media","method","min","minlength","multiple","muted","name","nonce","noshade","novalidate","nowrap","open","optimum","pattern","placeholder","playsinline","poster","preload","pubdate","radiogroup","readonly","rel","required","rev","reversed","role","rows","rowspan","spellcheck","scope","selected","shape","size","sizes","span","srclang","start","src","srcset","step","style","summary","tabindex","title","translate","type","usemap","valign","value","width","xmlns","slot"]),WA=hA(["accent-height","accumulate","additive","alignment-baseline","ascent","attributename","attributetype","azimuth","basefrequency","baseline-shift","begin","bias","by","class","clip","clippathunits","clip-path","clip-rule","color","color-interpolation","color-interpolation-filters","color-profile","color-rendering","cx","cy","d","dx","dy","diffuseconstant","direction","display","divisor","dur","edgemode","elevation","end","fill","fill-opacity","fill-rule","filter","filterunits","flood-color","flood-opacity","font-family","font-size","font-size-adjust","font-stretch","font-style","font-variant","font-weight","fx","fy","g1","g2","glyph-name","glyphref","gradientunits","gradienttransform","height","href","id","image-rendering","in","in2","k","k1","k2","k3","k4","kerning","keypoints","keysplines","keytimes","lang","lengthadjust","letter-spacing","kernelmatrix","kernelunitlength","lighting-color","local","marker-end","marker-mid","marker-start","markerheight","markerunits","markerwidth","maskcontentunits","maskunits","max","mask","media","method","mode","min","name","numoctaves","offset","operator","opacity","order","orient","orientation","origin","overflow","paint-order","path","pathlength","patterncontentunits","patterntransform","patternunits","points","preservealpha","preserveaspectratio","primitiveunits","r","rx","ry","radius","refx","refy","repeatcount","repeatdur","restart","result","rotate","scale","seed","shape-rendering","specularconstant","specularexponent","spreadmethod","startoffset","stddeviation","stitchtiles","stop-color","stop-opacity","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke","stroke-width","style","surfacescale","systemlanguage","tabindex","targetx","targety","transform","transform-origin","text-anchor","text-decoration","text-rendering","textlength","type","u1","u2","unicode","values","viewbox","visibility","version","vert-adv-y","vert-origin-x","vert-origin-y","width","word-spacing","wrap","writing-mode","xchannelselector","ychannelselector","x","x1","x2","xmlns","y","y1","y2","z","zoomandpan"]),GA=hA(["accent","accentunder","align","bevelled","close","columnsalign","columnlines","columnspan","denomalign","depth","dir","display","displaystyle","encoding","fence","frame","height","href","id","largeop","length","linethickness","lspace","lquote","mathbackground","mathcolor","mathsize","mathvariant","maxsize","minsize","movablelimits","notation","numalign","open","rowalign","rowlines","rowspacing","rowspan","rspace","rquote","scriptlevel","scriptminsize","scriptsizemultiplier","selection","separator","separators","stretchy","subscriptshift","supscriptshift","symmetric","voffset","width","xmlns"]),XA=hA(["xlink:href","xml:id","xlink:title","xml:space","xmlns:xlink"]),YA=vA(/\{\{[\w\W]*|[\w\W]*\}\}/gm),qA=vA(/<%[\w\W]*|[\w\W]*%>/gm),KA=vA(/^data-[\-\w.\u00B7-\uFFFF]/),JA=vA(/^aria-[\-\w]+$/),$A=vA(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),QA=vA(/^(?:\w+script|data):/i),ZA=vA(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),tB=vA(/^html$/i);function eB(t,e){return{dom:{tag:"div",styles:{display:"none"},classes:["tox-dialog__header"]},components:[t,e]}}function nB(t,e){return OE.parts.close(fp.sketch({dom:{tag:"button",classes:["tox-button","tox-button--icon","tox-button--naked"],attributes:{type:"button","aria-label":e.translate("Close")}},action:t,buttonBehaviours:ec([py.config({})])}))}function oB(){return OE.parts.title({dom:{tag:"div",classes:["tox-dialog__title"],innerHtml:"",styles:{display:"none"}}})}function rB(t,e){return OE.parts.body({dom:{tag:"div",classes:["tox-dialog__body"]},components:[{dom:{tag:"div",classes:["tox-dialog__body-content"]},components:[{dom:xC("<p>"+(n=e.translate(t),_B().sanitize(n))+"</p>")}]}]});var n}function iB(t){return OE.parts.footer({dom:{tag:"div",classes:["tox-dialog__footer"]},components:t})}function uB(t,e){return[ly.sketch({dom:{tag:"div",classes:["tox-dialog__footer-start"]},components:t}),ly.sketch({dom:{tag:"div",classes:["tox-dialog__footer-end"]},components:e})]}function aB(e){var t,n="tox-dialog",o=n+"-wrap",r=o+"__backdrop",i=n+"__disable-scroll";return OE.sketch({lazySink:e.lazySink,onEscape:function(t){return e.onEscape(t),vt.some(!0)},useTabstopAt:function(t){return!p0(t)},dom:{tag:"div",classes:[n].concat(e.extraClasses),styles:lt({position:"relative"},e.extraStyles)},components:V([e.header,e.body],e.footer.toArray(),!0),parts:{blocker:{dom:xC('<div class="'+o+'"></div>'),components:[{dom:{tag:"div",classes:TB?[r,r+"--opaque"]:[r]}}]}},dragBlockClass:o,modalBehaviours:ec(V([Vg.config({}),mm("dialog-events",e.dialogEvents.concat([Ar(bi(),function(t,e){Fg.focusIn(t)})])),mm("scroll-lock",[ou(function(){Yr(bn(),i)}),ru(function(){qr(bn(),i)})])],e.extraBehaviours,!0)),eventOrder:lt(((t={})[Ii()]=["dialog-events"],t[Gi()]=["scroll-lock","dialog-events","alloy.base.behaviour"],t[Xi()]=["alloy.base.behaviour","dialog-events","scroll-lock"],t),e.eventOrder)})}function cB(t){return fp.sketch({dom:{tag:"button",classes:["tox-button","tox-button--icon","tox-button--naked"],attributes:{type:"button","aria-label":t.translate("Close"),title:t.translate("Close")}},components:[Xm("close",{tag:"div",classes:["tox-icon"]},t.icons)],action:function(t){vr(t,wy)}})}function sB(t,e,n){function o(t){return[ri(n.translate(t.title))]}return{dom:{tag:"div",classes:["tox-dialog__title"],attributes:lt({},e.map(function(t){return{id:t}}).getOr({}))},components:o(t),behaviours:ec([k_.config({channel:eA,renderComponents:o})])}}function lB(){return{dom:xC('<div class="tox-dialog__draghandle"></div>')}}function fB(t,e){return n={title:e.shared.providers.translate(t),draggable:e.dialog.isDraggableModal()},o=e.shared.providers,r=OE.parts.title(sB(n,vt.none(),o)),i=OE.parts.draghandle(lB()),u=OE.parts.close(cB(o)),a=[r].concat(n.draggable?[i]:[]).concat([u]),ly.sketch({dom:xC('<div class="tox-dialog__header"></div>'),components:a});var n,o,r,i,u,a}function dB(t,e,n){return{dom:{tag:"div",classes:["tox-dialog__busy-spinner"],attributes:{"aria-label":n.translate(t)},styles:{left:"0px",right:"0px",bottom:"0px",top:"0px",position:"absolute"}},behaviours:e,components:[{dom:xC('<div class="tox-spinner"><div></div><div></div><div></div></div>')}]}}function mB(t,o,e){return{onClose:function(){return e.closeWindow()},onBlock:function(n){OE.setBusy(t(),function(t,e){return dB(n.message,e,o)})},onUnblock:function(){OE.setIdle(t())}}}function gB(t,e,n,o){var r;return Tu(aB(lt(lt({},t),{lazySink:o.shared.getSink,extraBehaviours:V([k_.config({channel:tA,updateState:function(t,e){return vt.some(e)},initialData:e}),pS({})],t.extraBehaviours,!0),onEscape:function(t){vr(t,wy)},dialogEvents:n,eventOrder:((r={})[Fi()]=[k_.name(),ic.name()],r[Gi()]=["scroll-lock",k_.name(),"messages","dialog-events","alloy.base.behaviour"],r[Xi()]=["alloy.base.behaviour","dialog-events","messages",k_.name(),"scroll-lock"],r)})))}function pB(t){return B(t,function(t){return"menu"===t.type?(n=B((e=t).items,function(t){var e=Po(!1);return lt(lt({},t),{storage:e})}),lt(lt({},e),{items:n})):t;var e,n})}function hB(t){return R(t,function(t,e){return"menu"!==e.type?t:R(e.items,function(t,e){return t[e.name]=e.storage,t},t)},{})}function vB(t,n){return[Er(bi(),g0),t(xy,function(t,e){n.onClose(),e.onClose()}),t(wy,function(t,e,n,o){e.onCancel(t),vr(o,xy)}),Cr(Oy,function(t,e){return n.onUnblock()}),Cr(Cy,function(t,e){return n.onBlock(e.event)})]}function bB(t,e){function n(t,e){return ly.sketch({dom:{tag:"div",classes:["tox-dialog__footer-"+t]},components:B(e,function(t){return t.memento.asSpec()})})}var o=M(e.map(function(t){return t.footerButtons}).getOr([]),function(t){return"start"===t.align});return[n("start",o.pass),n("end",o.fail)]}function yB(t,n){return{dom:xC('<div class="tox-dialog__footer"></div>'),components:[],behaviours:ec([k_.config({channel:oA,initialData:t,updateState:function(t,e){var r=B(e.buttons,function(t){var e=Hm(Q0(t,t.type,n));return{name:t.name,align:t.align,memento:e}});return vt.some({lookupByName:function(t,e){return n=t,o=e,N(r,function(t){return t.name===o}).bind(function(t){return t.memento.getOpt(n)});var n,o},footerButtons:r})},renderComponents:bB})])}}function xB(t,e){return OE.parts.footer(yB(t,e))}function wB(e,n){if(e.getRoot().getSystem().isConnected()){var o=cd.getCurrent(e.getFormWrapper()).getOr(e.getFormWrapper());return nS.getField(o,n).fold(function(){var t=e.getFooter();return k_.getState(t).get().bind(function(t){return t.lookupByName(o,n)})},function(t){return vt.some(t)})}return vt.none()}function SB(c,o,s){function t(t){var e=c.getRoot();e.getSystem().isConnected()&&t(e)}var l={getData:function(){var t=c.getRoot(),e=t.getSystem().isConnected()?c.getFormWrapper():t,n=Df.getValue(e),o=dt(s,function(t){return t.get()});return lt(lt({},n),o)},setData:function(a){t(function(t){var e,n,o=l.getData(),r=lt(lt({},o),a),i=(e=r,n=c.getRoot(),k_.getState(n).get().map(function(t){return co(ao("data",t.dataValidator,e))}).getOr(e)),u=c.getFormWrapper();Df.setValue(u,i),J(s,function(t,e){Tt(r,e)&&t.set(r[e])})})},disable:function(t){wB(c,t).each(gd.disable)},enable:function(t){wB(c,t).each(gd.enable)},focus:function(t){wB(c,t).each(Vg.focus)},block:function(e){if(!y(e))throw new Error("The dialogInstanceAPI.block function should be passed a blocking message of type string as an argument");t(function(t){br(t,Cy,{message:e})})},unblock:function(){t(function(t){vr(t,Oy)})},showTab:function(n){t(function(t){var e=c.getBody();k_.getState(e).get().exists(function(t){return t.isTabPanel()})&&cd.getCurrent(e).each(function(t){$D.showTab(t,n)})})},redial:function(n){t(function(t){var e=o(n);t.getSystem().broadcastOn([tA],e),t.getSystem().broadcastOn([eA],e.internalDialog),t.getSystem().broadcastOn([nA],e.internalDialog),t.getSystem().broadcastOn([oA],e.internalDialog),l.setData(e.initialData)})},close:function(){t(function(t){vr(t,xy)})}};return l}function kB(t){return x(t)&&-1!==MB.indexOf(t.mceAction)}function CB(o,t,r,e){var n,i,u,a=fB(o.title,e),c=(i={dom:{tag:"div",classes:["tox-dialog__content-js"]},components:[{dom:{tag:"div",classes:["tox-dialog__body-iframe"]},components:[d0({dom:{tag:"iframe",attributes:{src:o.url}},behaviours:ec([py.config({}),Vg.config({})])})]}],behaviours:ec([Fg.config({mode:"acyclic",useTabstopAt:O(p0)})])},OE.parts.body(i)),s=o.buttons.bind(function(t){return 0===t.length?vt.none():vt.some(xB({buttons:t},e))}),l=EB(function(){return v},mB(function(){return h},e.shared.providers,t)),f=lt(lt({},o.height.fold(function(){return{}},function(t){return{height:t+"px","max-height":t+"px"}})),o.width.fold(function(){return{}},function(t){return{width:t+"px","max-width":t+"px"}})),d=o.width.isNone()&&o.height.isNone()?["tox-dialog--width-lg"]:[],m=new BB(o.url,{base_uri:new BB(window.location.href)}),g=m.protocol+"://"+m.host+(m.port?":"+m.port:""),p=mc(),h=gB({header:a,body:c,footer:s,extraClasses:d,extraBehaviours:[mm("messages",[ou(function(){var t=pc(Mt.fromDom(window),"message",function(t){var e,n;m.isSameOrigin(new BB(t.raw.origin))&&(kB(e=t.raw.data)?function(t,e,n){switch(n.mceAction){case"insertContent":t.insertContent(n.content);break;case"setContent":t.setContent(n.content);break;case"execCommand":var o=!!w(n.ui)&&n.ui;t.execCommand(n.cmd,o,n.value);break;case"close":e.close();break;case"block":e.block(n.message);break;case"unblock":e.unblock()}}(r,v,e):!kB(n=e)&&x(n)&&Tt(n,"mceAction")&&o.onMessage(v,e))});p.set(t)}),ru(p.clear)]),ic.config({channels:((n={})[rA]={onReceive:function(t,e){Iu(t.element,"iframe").each(function(t){t.dom.contentWindow.postMessage(e,g)})}},n)})],extraStyles:f},o,l,e),v={block:function(e){if(!y(e))throw new Error("The urlDialogInstanceAPI.block function should be passed a blocking message of type string as an argument");b(function(t){br(t,Cy,{message:e})})},unblock:function(){b(function(t){vr(t,Oy)})},close:function(){b(function(t){vr(t,xy)})},sendMessage:function(e){b(function(t){t.getSystem().broadcastOn([rA],e)})}};function b(t){u.getSystem().isConnected()&&t(u)}return{dialog:u=h,instanceApi:v}}function OB(t){function o(t,y){return jD.open(function(t,e,n){var o,r,i,u,a,c,s,l,f,d,m,g,p,h,v=e,b=(r={redial:jD.redial,closeWindow:function(){OE.hide(b.dialog),y(b.instanceApi)}},i=R,c=fB((o={dataValidator:n,initialData:v,internalDialog:t}).internalDialog.title,i),u=i,a=xE({body:o.internalDialog.body},vt.none(),u,!1),s=OE.parts.body(a),l=pB(o.internalDialog.buttons),f=hB(l),d=xB({buttons:l},i),m=DB(function(){return h},mB(function(){return p},i.shared.providers,r),i.shared.getSink),g=function(){switch(o.internalDialog.size){case"large":return["tox-dialog--width-lg"];case"medium":return["tox-dialog--width-md"];default:return[]}}(),p=gB({header:c,body:s,footer:vt.some(d),extraClasses:g,extraBehaviours:[],extraStyles:{}},o,m,i),h=SB({getRoot:rt(p),getBody:function(){return OE.getBody(p)},getFooter:function(){return OE.getFooter(p)},getFormWrapper:function(){var t=OE.getBody(p);return cd.getCurrent(t).getOr(t)}},r.redial,f),{dialog:p,instanceApi:h});return OE.show(b.dialog),b.instanceApi.setData(v),b.instanceApi},t)}function r(t,M,F,I){return jD.open(function(t,e,n){function o(){return E.on(function(t){up.reposition(t),j1.refresh(t)})}var r,i,u,a,c,s,l,f,d,m,g,p,h,v,b,y,x,w,S,k,C,O,_,T=co(ao("data",n,e)),E=gc(),D=R.shared.header.isPositionedAtTop(),A=(i={dataValidator:n,initialData:T,internalDialog:t},u={redial:jD.redial,closeWindow:function(){E.on(up.hide),N.off("ResizeEditor",o),E.clear(),F(A.instanceApi)}},a=R,c=I,v=Ir("dialog-label"),b=Ir("dialog-content"),y=Hm((f={title:i.internalDialog.title,draggable:!0},d=v,m=a.shared.providers,ly.sketch({dom:xC('<div class="tox-dialog__header"></div>'),components:[sB(f,vt.some(d),m),lB(),cB(m)],containerBehaviours:ec([aE.config({mode:"mouse",blockerClass:"blocker",getTarget:function(t){return Ru(t,'[role="dialog"]').getOrDie()},snaps:{getSnapPoints:function(){return[]},leftAttr:"data-drag-left",topAttr:"data-drag-top"}})])}))),x=Hm((g={body:i.internalDialog.body},p=a,h=c,xE(g,vt.some(b),p,h))),w=pB(i.internalDialog.buttons),S=hB(w),k=Hm(AB({buttons:w},a)),C=DB(function(){return _},{onBlock:function(n){fO.block(O,function(t,e){return dB(n.message,e,a.shared.providers)})},onUnblock:function(){fO.unblock(O)},onClose:function(){return u.closeWindow()}},a.shared.getSink),O=Tu({dom:{tag:"div",classes:["tox-dialog","tox-dialog-inline"],attributes:((s={role:"dialog"})["aria-labelledby"]=v,s["aria-describedby"]=b,s)},eventOrder:((l={})[Fi()]=[k_.name(),ic.name()],l[Ii()]=["execute-on-form"],l[Gi()]=["reflecting","execute-on-form"],l),behaviours:ec([Fg.config({mode:"cyclic",onEscape:function(t){return vr(t,xy),vt.some(!0)},useTabstopAt:function(t){return!p0(t)&&("button"!==Ft(t)||"disabled"!==ie(t,"disabled"))}}),k_.config({channel:tA,updateState:function(t,e){return vt.some(e)},initialData:i}),Vg.config({}),mm("execute-on-form",C.concat([Ar(bi(),function(t,e){Fg.focusIn(t)})])),fO.config({getRoot:function(){return vt.some(O)}}),Rg.config({}),pS({})]),components:[y.asSpec(),x.asSpec(),k.asSpec()]}),_=SB({getRoot:rt(O),getFooter:function(){return k.get(O)},getBody:function(){return x.get(O)},getFormWrapper:function(){var t=x.get(O);return cd.getCurrent(t).getOr(t)}},u.redial,S),{dialog:O,instanceApi:_}),B=Tu(up.sketch(lt(lt({lazySink:R.shared.getSink,dom:{tag:"div",classes:[]},fireDismissalEventInstead:{}},D?{}:{fireRepositionEventInstead:{}}),{inlineBehaviours:ec(V([mm("window-manager-inline-events",[Cr(Yi(),function(t,e){vr(A.dialog,wy)})])],(r=N,P&&D?[]:[j1.config({contextual:{lazyContext:function(){return vt.some(Mn(Mt.fromDom(r.getContentAreaContainer())))},fadeInClass:"tox-dialog-dock-fadein",fadeOutClass:"tox-dialog-dock-fadeout",transitionClass:"tox-dialog-dock-transition"},modes:["top"]})]),!0)),isExtraPart:function(t,e){return Yb(n=e,".tox-alert-dialog")||Yb(n,".tox-confirm-dialog");var n}})));return E.set(B),up.showWithin(B,Eu(A.dialog),{anchor:M},vt.some(bn())),P&&D||(j1.refresh(B),N.on("ResizeEditor",o)),A.instanceApi.setData(T),Fg.focusIn(A.dialog),A.instanceApi},t)}var c,s,l,f,R=t.backstage,N=t.editor,P=dv(N),n=(s=(c=t).backstage.shared,{open:function(t,e){function n(){OE.hide(u),e()}var o=Hm(Q0({name:"close-alert",text:"OK",primary:!0,align:"end",disabled:!1,icon:vt.none()},"cancel",c.backstage)),r=oB(),i=nB(n,s.providers),u=Tu(aB({lazySink:function(){return s.getSink()},header:eB(r,i),body:rB(t,s.providers),footer:vt.some(iB(uB([],[o.asSpec()]))),onEscape:n,extraClasses:["tox-alert-dialog"],extraBehaviours:[],extraStyles:{},dialogEvents:[Cr(wy,n)],eventOrder:{}}));OE.show(u);var a=o.get(u);Vg.focus(a)}}),i=(f=(l=t).backstage.shared,{open:function(t,e){function n(t){OE.hide(a),e(t)}var o=Hm(Q0({name:"yes",text:"Yes",primary:!0,align:"end",disabled:!1,icon:vt.none()},"submit",l.backstage)),r=Q0({name:"no",text:"No",primary:!1,align:"end",disabled:!1,icon:vt.none()},"cancel",l.backstage),i=oB(),u=nB(function(){return n(!1)},f.providers),a=Tu(aB({lazySink:function(){return f.getSink()},header:eB(i,u),body:rB(t,f.providers),footer:vt.some(iB(uB([],[r,o.asSpec()]))),onEscape:function(){return n(!1)},extraClasses:["tox-confirm-dialog"],extraBehaviours:[],extraStyles:{},dialogEvents:[Cr(wy,function(){return n(!1)}),Cr(ky,function(){return n(!0)})],eventOrder:{}}));OE.show(a);var c=o.get(a);Vg.focus(c)}});return{open:function(t,e,n){return void 0!==e&&"toolbar"===e.inline?r(t,R.shared.anchors.inlineDialog(),n,e.ariaAttrs):void 0!==e&&"cursor"===e.inline?r(t,R.shared.anchors.cursor(),n,e.ariaAttrs):o(t,n)},openUrl:function(t,e){return n=e,jD.openUrl(function(t){var e=CB(t,{closeWindow:function(){OE.hide(e.dialog),n(e.instanceApi)}},N,R);return OE.show(e.dialog),e.instanceApi},t);var n},alert:function(t,e){n.open(t,function(){e()})},close:function(t){t.close()},confirm:function(t,e){i.open(t,function(t){e(t)})}}}var _B=function e(t){function l(t){return e(t)}var f=0<arguments.length&&void 0!==t?t:"undefined"==typeof window?null:window;if(l.version="2.3.8",l.removed=[],!f||!f.document||9!==f.document.nodeType)return l.isSupported=!1,l;var n,d=f.document,u=f.document,m=f.DocumentFragment,o=f.HTMLTemplateElement,g=f.Node,a=f.Element,r=f.NodeFilter,i=f.NamedNodeMap,c=void 0===i?f.NamedNodeMap||f.MozNamedAttrMap:i,s=f.HTMLFormElement,p=f.DOMParser,h=f.trustedTypes,v=a.prototype,b=RA(v,"cloneNode"),y=RA(v,"nextSibling"),x=RA(v,"childNodes"),w=RA(v,"parentNode");"function"!=typeof o||(n=u.createElement("template")).content&&n.content.ownerDocument&&(u=n.content.ownerDocument);var S=function(t,e){if("object"!==iA(t)||"function"!=typeof t.createPolicy)return null;var n=null,o="data-tt-policy-suffix",r="dompurify"+((n=e.currentScript&&e.currentScript.hasAttribute(o)?e.currentScript.getAttribute(o):n)?"#"+n:"");try{return t.createPolicy(r,{createHTML:function(t){return t}})}catch(t){return console.warn("TrustedTypes policy "+r+" could not be created."),null}}(h,d),k=S?S.createHTML(""):"",C=u,O=C.implementation,_=C.createNodeIterator,T=C.createDocumentFragment,E=C.getElementsByTagName,D=d.importNode,A={};try{A=IA(u).documentMode?u.documentMode:{}}catch(t){}var B={};function M(t){return t instanceof RegExp||t instanceof Function}function F(t){St&&St===t||(t=IA(t=t&&"object"===iA(t)?t:{}),G="ALLOWED_TAGS"in t?FA({},t.ALLOWED_TAGS):X,Y="ALLOWED_ATTR"in t?FA({},t.ALLOWED_ATTR):q,pt="ADD_URI_SAFE_ATTR"in t?FA(IA(ht),t.ADD_URI_SAFE_ATTR):ht,mt="ADD_DATA_URI_TAGS"in t?FA(IA(gt),t.ADD_DATA_URI_TAGS):gt,ft="FORBID_CONTENTS"in t?FA({},t.FORBID_CONTENTS):dt,J="FORBID_TAGS"in t?FA({},t.FORBID_TAGS):{},$="FORBID_ATTR"in t?FA({},t.FORBID_ATTR):{},I="USE_PROFILES"in t&&t.USE_PROFILES,Q=!1!==t.ALLOW_ARIA_ATTR,Z=!1!==t.ALLOW_DATA_ATTR,tt=t.ALLOW_UNKNOWN_PROTOCOLS||!1,et=t.SAFE_FOR_TEMPLATES||!1,nt=t.WHOLE_DOCUMENT||!1,it=t.RETURN_DOM||!1,ut=t.RETURN_DOM_FRAGMENT||!1,at=t.RETURN_TRUSTED_TYPE||!1,rt=t.FORCE_BODY||!1,ct=!1!==t.SANITIZE_DOM,st=!1!==t.KEEP_CONTENT,lt=t.IN_PLACE||!1,W=t.ALLOWED_URI_REGEXP||W,xt=t.NAMESPACE||yt,t.CUSTOM_ELEMENT_HANDLING&&M(t.CUSTOM_ELEMENT_HANDLING.tagNameCheck)&&(K.tagNameCheck=t.CUSTOM_ELEMENT_HANDLING.tagNameCheck),t.CUSTOM_ELEMENT_HANDLING&&M(t.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)&&(K.attributeNameCheck=t.CUSTOM_ELEMENT_HANDLING.attributeNameCheck),t.CUSTOM_ELEMENT_HANDLING&&"boolean"==typeof t.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements&&(K.allowCustomizedBuiltInElements=t.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements),R=-1===wt.indexOf(t.PARSER_MEDIA_TYPE)?"text/html":t.PARSER_MEDIA_TYPE,N="application/xhtml+xml"===R?function(t){return t}:OA,et&&(Z=!1),ut&&(it=!0),I&&(G=FA({},cA(UA)),Y=[],!0===I.html&&(FA(G,NA),FA(Y,jA)),!0===I.svg&&(FA(G,PA),FA(Y,WA),FA(Y,XA)),!0===I.svgFilters&&(FA(G,VA),FA(Y,WA),FA(Y,XA)),!0===I.mathMl&&(FA(G,LA),FA(Y,GA),FA(Y,XA))),t.ADD_TAGS&&FA(G=G===X?IA(G):G,t.ADD_TAGS),t.ADD_ATTR&&FA(Y=Y===q?IA(Y):Y,t.ADD_ATTR),t.ADD_URI_SAFE_ATTR&&FA(pt,t.ADD_URI_SAFE_ATTR),t.FORBID_CONTENTS&&FA(ft=ft===dt?IA(ft):ft,t.FORBID_CONTENTS),st&&(G["#text"]=!0),nt&&FA(G,["html","head","body"]),G.table&&(FA(G,["tbody"]),delete J.tbody),hA&&hA(t),St=t)}l.isSupported="function"==typeof w&&O&&void 0!==O.createHTMLDocument&&9!==A;var I,R,N,P,V=YA,H=qA,L=KA,z=JA,U=QA,j=ZA,W=$A,G=null,X=FA({},[].concat(cA(NA),cA(PA),cA(VA),cA(LA),cA(UA))),Y=null,q=FA({},[].concat(cA(jA),cA(WA),cA(GA),cA(XA))),K=Object.seal(Object.create(null,{tagNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},allowCustomizedBuiltInElements:{writable:!0,configurable:!1,enumerable:!0,value:!1}})),J=null,$=null,Q=!0,Z=!0,tt=!1,et=!1,nt=!1,ot=!1,rt=!1,it=!1,ut=!1,at=!1,ct=!0,st=!0,lt=!1,ft=null,dt=FA({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","style","svg","template","thead","title","video","xmp"]),mt=null,gt=FA({},["audio","video","img","source","image","track"]),pt=null,ht=FA({},["alt","class","for","id","label","name","pattern","placeholder","role","summary","title","value","style","xmlns"]),vt="http://www.w3.org/1998/Math/MathML",bt="http://www.w3.org/2000/svg",yt="http://www.w3.org/1999/xhtml",xt=yt,wt=["application/xhtml+xml","text/html"],St=null,kt=u.createElement("form"),Ct=FA({},["mi","mo","mn","ms","mtext"]),Ot=FA({},["foreignobject","desc","title","annotation-xml"]),_t=FA({},["title","style","font","a","script"]),Tt=FA({},PA);FA(Tt,VA),FA(Tt,HA);var Et=FA({},LA);function Dt(e){CA(l.removed,{element:e});try{e.parentNode.removeChild(e)}catch(t){try{e.outerHTML=k}catch(t){e.remove()}}}function At(t,e){try{CA(l.removed,{attribute:e.getAttributeNode(t),from:e})}catch(t){CA(l.removed,{attribute:null,from:e})}if(e.removeAttribute(t),"is"===t&&!Y[t])if(it||ut)try{Dt(e)}catch(t){}else try{e.setAttribute(t,"")}catch(t){}}function Bt(t){var e,n,o;rt?t="<remove></remove>"+t:o=(n=_A(t,/^[\r\n\t ]+/))&&n[0],"application/xhtml+xml"===R&&(t='<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>'+t+"</body></html>");var r=S?S.createHTML(t):t;if(xt===yt)try{e=(new p).parseFromString(r,R)}catch(t){}if(!e||!e.documentElement){e=O.createDocument(xt,"template",null);try{e.documentElement.innerHTML=P?"":r}catch(t){}}var i=e.body||e.documentElement;return t&&o&&i.insertBefore(u.createTextNode(o),i.childNodes[0]||null),xt===yt?E.call(e,nt?"html":"body")[0]:nt?e.documentElement:i}function Mt(t){return _.call(t.ownerDocument||t,t,r.SHOW_ELEMENT|r.SHOW_COMMENT|r.SHOW_TEXT,null,!1)}function Ft(t){return"object"===iA(g)?t instanceof g:t&&"object"===iA(t)&&"number"==typeof t.nodeType&&"string"==typeof t.nodeName}function It(t,e,n){B[t]&&SA(B[t],function(t){t.call(l,e,n,St)})}function Rt(t){var e;if(It("beforeSanitizeElements",t,null),t instanceof s&&("string"!=typeof t.nodeName||"string"!=typeof t.textContent||"function"!=typeof t.removeChild||!(t.attributes instanceof c)||"function"!=typeof t.removeAttribute||"function"!=typeof t.setAttribute||"string"!=typeof t.namespaceURI||"function"!=typeof t.insertBefore))return Dt(t),1;if(AA(/[\u0080-\uFFFF]/,t.nodeName))return Dt(t),1;var n=N(t.nodeName);if(It("uponSanitizeElement",t,{tagName:n,allowedTags:G}),t.hasChildNodes()&&!Ft(t.firstElementChild)&&(!Ft(t.content)||!Ft(t.content.firstElementChild))&&AA(/<[/\w]/g,t.innerHTML)&&AA(/<[/\w]/g,t.textContent))return Dt(t),1;if("select"===n&&AA(/<template/i,t.innerHTML))return Dt(t),1;if(G[n]&&!J[n])return t instanceof a&&!function(t){var e=w(t);e&&e.tagName||(e={namespaceURI:yt,tagName:"template"});var n=OA(t.tagName),o=OA(e.tagName);return t.namespaceURI===bt?e.namespaceURI===yt?"svg"===n:e.namespaceURI===vt?"svg"===n&&("annotation-xml"===o||Ct[o]):Boolean(Tt[n]):t.namespaceURI===vt?e.namespaceURI===yt?"math"===n:e.namespaceURI===bt?"math"===n&&Ot[o]:Boolean(Et[n]):t.namespaceURI===yt&&(e.namespaceURI!==bt||Ot[o])&&(e.namespaceURI!==vt||Ct[o])&&!Et[n]&&(_t[n]||!Tt[n])}(t)||("noscript"===n||"noembed"===n)&&AA(/<\/no(script|embed)/i,t.innerHTML)?(Dt(t),1):(et&&3===t.nodeType&&(e=t.textContent,e=TA(e,V," "),e=TA(e,H," "),t.textContent!==e&&(CA(l.removed,{element:t.cloneNode()}),t.textContent=e)),It("afterSanitizeElements",t,null),0);if(!J[n]&&Vt(n)){if(K.tagNameCheck instanceof RegExp&&AA(K.tagNameCheck,n))return;if(K.tagNameCheck instanceof Function&&K.tagNameCheck(n))return}if(st&&!ft[n]){var o=w(t)||t.parentNode,r=x(t)||t.childNodes;if(r&&o)for(var i=r.length-1;0<=i;--i)o.insertBefore(b(r[i],!0),y(t))}return Dt(t),1}function Nt(t,e,n){if(ct&&("id"===e||"name"===e)&&(n in u||n in kt))return!1;if((!Z||$[e]||!AA(L,e))&&(!Q||!AA(z,e)))if(!Y[e]||$[e]){if(!(Vt(t)&&(K.tagNameCheck instanceof RegExp&&AA(K.tagNameCheck,t)||K.tagNameCheck instanceof Function&&K.tagNameCheck(t))&&(K.attributeNameCheck instanceof RegExp&&AA(K.attributeNameCheck,e)||K.attributeNameCheck instanceof Function&&K.attributeNameCheck(e))||"is"===e&&K.allowCustomizedBuiltInElements&&(K.tagNameCheck instanceof RegExp&&AA(K.tagNameCheck,n)||K.tagNameCheck instanceof Function&&K.tagNameCheck(n))))return!1}else if(!pt[e]&&!AA(W,TA(n,j,""))&&("src"!==e&&"xlink:href"!==e&&"href"!==e||"script"===t||0!==EA(n,"data:")||!mt[t])&&(!tt||AA(U,TA(n,j,"")))&&n)return!1;return!0}function Pt(t){It("beforeSanitizeAttributes",t,null);var e=t.attributes;if(e){for(var n={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:Y},o=e.length;o--;){var r,i=(r=e[o]).name,u=r.namespaceURI,a="value"===i?r.value:DA(r.value),c=N(i);if(n.attrName=c,n.attrValue=a,n.keepAttr=!0,n.forceKeepAttr=void 0,It("uponSanitizeAttribute",t,n),a=n.attrValue,!n.forceKeepAttr&&(At(i,t),n.keepAttr))if(AA(/\/>/i,a))At(i,t);else if(et&&(a=TA(a,V," "),a=TA(a,H," ")),Nt(N(t.nodeName),c,a))try{u?t.setAttributeNS(u,i,a):t.setAttribute(i,a),kA(l.removed)}catch(t){}}It("afterSanitizeAttributes",t,null)}}FA(Et,zA);var Vt=function(t){return 0<t.indexOf("-")};return l.sanitize=function(t,e){var n,o,r,i,u;if("string"!=typeof(t=(P=!t)?"\x3c!--\x3e":t)&&!Ft(t)){if("function"!=typeof t.toString)throw BA("toString is not a function");if("string"!=typeof(t=t.toString()))throw BA("dirty is not a string, aborting")}if(!l.isSupported){if("object"===iA(f.toStaticHTML)||"function"==typeof f.toStaticHTML){if("string"==typeof t)return f.toStaticHTML(t);if(Ft(t))return f.toStaticHTML(t.outerHTML)}return t}if(ot||F(e),l.removed=[],lt="string"!=typeof t&&lt){if(t.nodeName){var a=N(t.nodeName);if(!G[a]||J[a])throw BA("root node is forbidden and cannot be sanitized in-place")}}else if(t instanceof g)1===(o=(n=Bt("\x3c!----\x3e")).ownerDocument.importNode(t,!0)).nodeType&&"BODY"===o.nodeName||"HTML"===o.nodeName?n=o:n.appendChild(o);else{if(!it&&!et&&!nt&&-1===t.indexOf("<"))return S&&at?S.createHTML(t):t;if(!(n=Bt(t)))return it?null:at?k:""}n&&rt&&Dt(n.firstChild);for(var c=Mt(lt?t:n);r=c.nextNode();)3===r.nodeType&&r===i||Rt(r)||(r.content instanceof m&&function t(e){var n,o=Mt(e);for(It("beforeSanitizeShadowDOM",e,null);n=o.nextNode();)It("uponSanitizeShadowNode",n,null),Rt(n)||(n.content instanceof m&&t(n.content),Pt(n));It("afterSanitizeShadowDOM",e,null)}(r.content),Pt(r),i=r);if(i=null,lt)return t;if(it){if(ut)for(u=T.call(n.ownerDocument);n.firstChild;)u.appendChild(n.firstChild);else u=n;return Y.shadowroot?D.call(d,u,!0):u}var s=nt?n.outerHTML:n.innerHTML;return nt&&G["!doctype"]&&n.ownerDocument&&n.ownerDocument.doctype&&n.ownerDocument.doctype.name&&AA(tB,n.ownerDocument.doctype.name)&&(s="<!DOCTYPE "+n.ownerDocument.doctype.name+">\n"+s),et&&(s=TA(s,V," "),s=TA(s,H," ")),S&&at?S.createHTML(s):s},l.setConfig=function(t){F(t),ot=!0},l.clearConfig=function(){St=null,ot=!1},l.isValidAttribute=function(t,e,n){return St||F({}),Nt(N(t),N(e),n)},l.addHook=function(t,e){"function"==typeof e&&(B[t]=B[t]||[],CA(B[t],e))},l.removeHook=function(t){if(B[t])return kA(B[t])},l.removeHooks=function(t){B[t]&&(B[t]=[])},l.removeAllHooks=function(){B={}},l}(),TB=eb.deviceType.isTouch(),EB=function(u,t){function e(t,i){return Cr(t,function(n,o){var e,r;e=n,r=function(t,e){i(u(),t,o.event,n)},k_.getState(e).get().each(function(t){r(t,e)})})}return V(V([],vB(e,t),!0),[e(Sy,function(t,e,n){e.onAction(t,{name:n.name})})],!1)},DB=function(u,t,c){function e(t,i){return Cr(t,function(n,o){var e,r;e=n,r=function(t,e){i(u(),t,o.event,n)},k_.getState(e).get().each(function(t){r(t.internalDialog,e)})})}return V(V([],vB(e,t),!0),[e(ky,function(t,e){return e.onSubmit(t)}),e(yy,function(t,e,n){e.onChange(t,{name:n.name})}),e(Sy,function(t,e,n,o){function r(){return Fg.focusIn(o)}function i(t){return ae(t,"disabled")||ue(t,"aria-disabled").exists(function(t){return"true"===t})}var u=gn(o.element),a=Oa(u);e.onAction(t,{name:n.name,value:n.value}),Oa(u).fold(r,function(e){i(e)||a.exists(function(t){return Ut(e,t)&&i(t)})?r():c().toOptional().filter(function(t){return!Ut(t.element,e)}).each(r)})}),e(_y,function(t,e,n){e.onTabChange(t,{newTabName:n.name,oldTabName:n.oldName})}),ru(function(t){var e=u();Df.setValue(t,e.getData())})],!1)},AB=yB,BB=tinymce.util.Tools.resolve("tinymce.util.URI"),MB=["insertContent","setContent","execCommand","close","block","unblock"];o.add("silver",function(t){var e=fE(t),n=e.uiMothership,o=e.backstage,r=e.renderUI,i=e.getUi;return uy(t,o.shared),{renderUI:r,getWindowManagerImpl:rt(OB({editor:t,backstage:o})),getNotificationManagerImpl:function(){return u=t,r=n,l={backstage:o}.backstage.shared,{open:function(t,e){function n(){e(),up.hide(c)}var o=!t.closeButton&&t.timeout&&(0<t.timeout||t.timeout<0),a=Tu(hp.sketch({text:t.text,level:wt(["success","error","warning","warn","info"],t.type)?t.type:void 0,progress:!0===t.progressBar,icon:vt.from(t.icon),closeButton:!o,onAction:n,iconProvider:l.providers.icons,translationProvider:l.providers.translate})),c=Tu(up.sketch(lt({dom:{tag:"div",classes:["tox-notifications-container"]},lazySink:l.getSink,fireDismissalEventInstead:{}},l.header.isPositionedAtTop()?{}:{fireRepositionEventInstead:{}})));function s(){var t=Mn(Mt.fromDom(u.getContentAreaContainer())),e=Fn(),n=Wa(e.x,t.x,t.right),o=Wa(e.y,t.y,t.bottom),r=Math.max(t.right,e.right),i=Math.max(t.bottom,e.bottom);return vt.some(Bn(n,o,r-n,i-o))}return r.add(c),0<t.timeout&&lp.setTimeout(function(){n()},t.timeout),{close:n,moveTo:function(t,e){up.showAt(c,Eu(a),{anchor:{type:"makeshift",x:t,y:e}})},moveRel:function(t,e){var n,o,r,i=Eu(a),u={maxHeightFunction:Nc()};"banner"!==e&&k(t)?(n=function(){switch(e){case"bc-bc":return sp;case"tc-tc":return cp;case"tc-bc":return Ja;default:return $a}}(),o={type:"node",root:bn(),node:vt.some(Mt.fromDom(t)),overrides:u,layouts:{onRtl:function(){return[n]},onLtr:function(){return[n]}}},up.showWithinBounds(c,i,{anchor:o},s)):(r=lt(lt({},l.anchors.banner()),{overrides:u}),up.showWithinBounds(c,i,{anchor:r},s))},text:function(t){hp.updateText(a,t)},settings:t,getEl:function(){return a.element.dom},progressBar:{value:function(t){hp.updateProgress(a,t)}}}},close:function(t){t.close()},reposition:function(n){0<n.length&&St(n,function(t,e){0===e?t.moveRel(null,"banner"):t.moveRel(n[e-1].getEl(),"bc-tc")})},getArgs:function(t){return t.settings}};var u,r,l},ui:i()}})}();
\ No newline at end of file
diff --git a/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.min.js.gz b/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.min.js.gz
new file mode 100644
index 0000000..b30a640
Binary files /dev/null and b/ant-design-vue-jeecg/public/tinymce/themes/silver/theme.min.js.gz differ
diff --git a/ant-design-vue-jeecg/public/tinymce/upfiles.html b/ant-design-vue-jeecg/public/tinymce/upfiles.html
new file mode 100644
index 0000000..bfe17d2
--- /dev/null
+++ b/ant-design-vue-jeecg/public/tinymce/upfiles.html
@@ -0,0 +1,368 @@
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8" />
+<title>upfile</title>
+<meta name="viewport" content="user-scalable=no, width=device-width, initial-scale=1.0, maximum-scale=1.0"/>
+<meta name="apple-mobile-web-app-capable" content="yes" />
+<meta name="apple-mobile-web-app-status-bar-style" content="black" />
+<meta name="format-detection" content="telephone=no">
+<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+<style>
+	html,body{height:100%;margin:0;padding:0;background:#fff;}
+	ul{margin:0;padding:0;list-style:none;}
+	#wrap{padding:10px;}
+	#topbar{padding:10px 0;border-bottom:1px solid #ccc;text-align:right;}
+
+
+
+
+
+
+.tox *:not(svg):not(rect) {
+  box-sizing: inherit;
+  color: inherit;
+  cursor: inherit;
+  direction: inherit;
+  font-family: inherit;
+  font-size: inherit;
+  font-style: inherit;
+  font-weight: inherit;
+  line-height: inherit;
+  -webkit-tap-highlight-color: inherit;
+  text-align: inherit;
+  text-decoration: inherit;
+  text-shadow: inherit;
+  text-transform: inherit;
+  vertical-align: inherit;
+  white-space: inherit;
+}
+
+.tox *:not(svg):not(rect) {
+  /* stylelint-disable-line no-duplicate-selectors */
+  background: transparent;
+  border: 0;
+  float: none;
+  height: auto;
+  margin: 0;
+  max-width: none;
+  outline: 0;
+  padding: 0;
+  position: static;
+  width: auto;
+}
+
+.tox .tox-form__group {
+    box-sizing: border-box;
+    margin-bottom: 4px;
+}
+.tox .tox-label, .tox .tox-toolbar-label {
+    color: rgba(34,47,62,.7);
+    display: block;
+    font-size: 14px;
+    font-style: normal;
+    font-weight: 400;
+    line-height: 1.3;
+    padding: 0 8px 0 0;
+    text-transform: none;
+    white-space: nowrap;
+}
+.tox .tox-selectfield select, .tox .tox-textarea, .tox .tox-textfield, .tox .tox-toolbar-textfield {
+    -webkit-appearance: none;
+    -moz-appearance: none;
+    appearance: none;
+    background-color: #fff;
+    border-color: #ccc;
+    border-radius: 3px;
+    border-style: solid;
+    border-width: 1px;
+    box-shadow: none;
+    box-sizing: border-box;
+    color: #222f3e;
+    font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif;
+    font-size: 16px;
+    line-height: 24px;
+    margin: 0;
+    min-height: 34px;
+    outline: 0;
+    padding: 5px 4.75px;
+    resize: none;
+    width: 100%;
+  }
+.tox .tox-dialog__body-content {
+  box-sizing: border-box;
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  -ms-flex-preferred-size: auto;
+  max-height: 650px;
+  overflow: auto;
+  -webkit-overflow-scrolling: touch;
+  padding: 16px 16px;
+}
+.tox .tox-dialog__body-content {
+  box-sizing: border-box;
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  -ms-flex-preferred-size: auto;
+  max-height: 650px;
+  overflow: auto;
+  -webkit-overflow-scrolling: touch;
+  padding: 16px 16px;
+}
+.tox .tox-dialog__body-content > * {
+  margin-bottom: 0;
+  margin-top: 16px;
+}
+.tox .tox-dialog__body-content > *:first-child {
+  margin-top: 0;
+}
+.tox .tox-dialog__body-content > *:last-child {
+  margin-bottom: 0;
+}
+.tox .tox-dialog__body-content > *:only-child {
+  margin-bottom: 0;
+  margin-top: 0;
+}
+.tox .tox-dialog__body-content a {
+  color: #207ab7;
+  cursor: pointer;
+  text-decoration: none;
+}
+.tox .tox-dialog__body-content a:hover,
+.tox .tox-dialog__body-content a:focus {
+  color: #185d8c;
+  text-decoration: none;
+}
+.tox .tox-dialog__body-content a:active {
+  color: #185d8c;
+  text-decoration: none;
+}
+.tox .tox-dialog__body-content svg {
+  fill: #222f3e;
+}
+
+.tox .tox-form__group--stretched {
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  -ms-flex-preferred-size: auto;
+}
+.tox .tox-form__group {
+    box-sizing: border-box;
+    margin-bottom: 4px;
+}
+.tox .tox-dropzone-container {
+    display: flex;
+    flex: 1;
+}
+
+element.style {
+}
+.tox .tox-dropzone {
+    cursor: pointer;
+    align-items: center;
+    background: #fff;
+    border: 2px dashed #ccc;
+    box-sizing: border-box;
+    display: flex;
+    flex-direction: column;
+    flex-grow: 1;
+    justify-content: center;
+    min-height: 100px;
+    padding: 10px;
+}
+
+.tox .tox-button {
+    background-color: #207ab7;
+    background-image: none;
+    background-position: 0 0;
+    background-repeat: repeat;
+    border-color: #207ab7;
+    border-radius: 3px;
+    border-style: solid;
+    border-width: 1px;
+    box-shadow: none;
+    box-sizing: border-box;
+    color: #fff;
+    cursor: pointer;
+    display: inline-block;
+    font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif;
+    font-size: 14px;
+    font-weight: 700;
+    letter-spacing: normal;
+    line-height: 24px;
+    margin: 0;
+    outline: 0;
+    padding: 4px 16px;
+    text-align: center;
+    text-decoration: none;
+    text-transform: capitalize;
+    white-space: nowrap;
+}
+.tox .tox-button[disabled] {
+  background-color: #207ab7;
+  background-image: none;
+  border-color: #207ab7;
+  box-shadow: none;
+  color: rgba(255, 255, 255, 0.5);
+  cursor: not-allowed;
+}
+.tox .tox-button:focus:not(:disabled) {
+  background-color: #1c6ca1;
+  background-image: none;
+  border-color: #1c6ca1;
+  box-shadow: none;
+  color: #fff;
+}
+.tox .tox-button:hover:not(:disabled) {
+  background-color: #1c6ca1;
+  background-image: none;
+  border-color: #1c6ca1;
+  box-shadow: none;
+  color: #fff;
+}
+.tox .tox-button:active:not(:disabled) {
+  background-color: #185d8c;
+  background-image: none;
+  border-color: #185d8c;
+  box-shadow: none;
+  color: #fff;
+}
+
+.tox .tox-button--secondary {
+    background-color: #f0f0f0;
+    background-image: none;
+    background-position: 0 0;
+    background-repeat: repeat;
+    border-color: #f0f0f0;
+    border-radius: 3px;
+    border-style: solid;
+    border-width: 1px;
+    box-shadow: none;
+    color: #222f3e;
+    outline: 0;
+    padding: 4px 16px;
+    text-decoration: none;
+    text-transform: capitalize;
+}
+.tox .tox-button--secondary[disabled] {
+  background-color: #f0f0f0;
+  background-image: none;
+  border-color: #f0f0f0;
+  box-shadow: none;
+  cursor: pointer;
+  color: rgba(34, 47, 62, 0.5);
+}
+.tox .tox-button--secondary:focus:not(:disabled) {
+  background-color: #e3e3e3;
+  background-image: none;
+  border-color: #e3e3e3;
+  box-shadow: none;
+  color: #222f3e;
+}
+.tox .tox-button--secondary:hover:not(:disabled) {
+  background-color: #e3e3e3;
+  background-image: none;
+  border-color: #e3e3e3;
+  box-shadow: none;
+  color: #222f3e;
+}
+.tox .tox-button--secondary:active:not(:disabled) {
+  background-color: #d6d6d6;
+  background-image: none;
+  border-color: #d6d6d6;
+  box-shadow: none;
+  color: #222f3e;
+}
+</style>
+
+</head>
+<body>
+<div id="wrap">
+    <!-- <div id="topbar"><button class="addfile primary">+ 添加文件</button> -->
+        <!-- <button class="upall primary">全部上传</button>
+        <button class="removeall">清空列表</button></div> -->
+	<ul id="file_list" class="tox">
+        <div role="tabpanel" class="tox-dialog__body-content" style="height: 336px; flex-basis: 210px;" aria-labelledby="aria_5965197812761603939544315">
+            <div class="tox-form">
+                <div class="tox-form__group">
+                    <label class="tox-label" for="form-field_8471486645261603941857554">链接</label>
+                    <div class="tox-form__controls-h-stack">
+                      <div class="tox-control-wrap">
+                          <input type="url" aria-errormessage="aria-invalid_348682591591603941621447" role="combobox" aria-autocomplete="list" aria-haspopup="true" tabindex="-1" data-alloy-tabstop="true" class="tox-textfield" aria-expanded="false" id="upFileUrlID">
+                        </div>
+                    </div>
+                </div>
+                <div class="tox-form__group">
+                    <label class="tox-label" for="form-field_2497330145271603941857555">显示文字</label>
+                     <input type="text" tabindex="-1" data-alloy-tabstop="true" class="tox-textfield" id="upFileTextID">
+                </div>
+                <div style="height: 10px;"></div>
+             <div class="tox-form__group tox-form__group--stretched">
+                <div class="tox-dropzone-container">
+                    <div class="tox-dropzone">
+                      <p style="margin: 10px auto;color:rgba(34,47,62,.7)">拖放一张文件至此</p>
+                      <button id="upfileID" type="button" onclick="getFile()" data-alloy-tabstop="true" tabindex="-1" class="tox-button tox-button--secondary" style="position: relative; min-height: 30px; overflow: visible;">浏览文件<input type="file" accept="image/*" style="display: none;"></button>
+                      <input id="upfileNameID" style="margin: 5px auto;font-size: 12px; color:rgba(34,47,62,.7); width: 300px; text-align: center;" type="text" value="">
+                    </div>
+                </div>
+             </div>
+            </div>
+            <button title="上传文件" type="button" onclick="sendUpFile()" style="width: 80%;position: absolute;bottom:10px;left: 55px; margin: 0 auto;letter-spacing: 2px; display: block;"   class="tox-button"><svg width="24" height="24" style="margin-top:5px;" ><path fill="#fff" d="M19 4a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-4v-2h4V8H5v10h4v2H5a2 2 0 0 1-2-2V6c0-1.1.9-2 2-2h14zm-8 9.4l-2.3 2.3a1 1 0 1 1-1.4-1.4l4-4a1 1 0 0 1 1.4 0l4 4a1 1 0 0 1-1.4 1.4L13 13.4V20a1 1 0 0 1-2 0v-6.6z" fill-rule="nonzero"></path></svg><span style="top:-6px; position: relative; margin-left:5px;">开始上传</span></button>
+      </div>
+    </ul>
+</div>
+
+<script>
+	var editor=parent.tinymce.activeEditor;
+	var upfile=parent.upfile;
+	var upload_handler = upfile.file_callback;
+  var upfileData = ""
+  var upfileUrl = null
+    function addFile(file){
+     upfileData = file[0];
+     document.getElementById('upfileNameID').value=file[0].name;
+    }
+    let inputUrl = document.getElementById('upFileUrlID');
+    let inputText = document.getElementById('upFileTextID');
+    function sendUpFile(){
+      upload_handler(upfileData,function(url,_obj){
+        inputUrl.value = url;
+        inputText.value ?'': inputText.value = url;
+        _obj&&_obj.text?inputText.value=_obj.text:'';
+        upfile.res.url = upfileUrl = url;
+        upfile.res.text = inputText.value;
+
+      })
+    }
+
+    inputUrl.oninput = function(){upfile.res.url = inputUrl.value; upfileUrl=== null?inputText.value=inputUrl.value:'' }
+    inputText.oninput = function(){upfile.res.text=inputText.value;upfileUrl="123";}
+    //拖拽添加
+    document.addEventListener('dragover', function(e){
+        e.stopPropagation();
+        e.preventDefault();
+        e.dataTransfer.dropEffect = 'copy';
+    });
+    document.addEventListener('drop', function(e){
+        e.stopPropagation();
+        e.preventDefault();
+        if(!e.dataTransfer.files){return false;}
+        var dropfiles = e.dataTransfer.files;
+        if(!(dropfiles.length>0)){return false;}
+         addFile(dropfiles);
+    });
+    
+    var global$1 = upfile.tinymce.util.Tools.resolve('tinymce.util.Promise');var global$2 = upfile.tinymce.util.Tools.resolve('tinymce.Env');var global$3 = upfile.tinymce.util.Tools.resolve('tinymce.util.Delay');
+    var pickFile=function(a){return new global$1(function(e){var c=document.createElement("input");c.type="file";c.style.position="fixed";c.style.left="0";c.style.top="0";c.style.opacity="0.001";document.body.appendChild(c);var b=function(f){e(Array.prototype.slice.call(f.target.files))};c.addEventListener("change",b);var d=function(g){var f=function(){e([]);c.parentNode.removeChild(c)};if(global$2.os.isAndroid()&&g.type!=="remove"){global$3.setEditorTimeout(a,f,0)}else{f()}a.off("focusin remove",d)};a.on("focusin remove",d);c.click()})};
+  function getFile(){
+   
+    pickFile(editor).then(function (files){
+      addFile(files);
+    })    
+}
+</script>
+</body>
+</html>
diff --git a/ant-design-vue-jeecg/src/views/modulex/modules/ModulexImport.vue b/ant-design-vue-jeecg/src/views/modulex/modules/ModulexImport.vue
new file mode 100644
index 0000000..301ff72
--- /dev/null
+++ b/ant-design-vue-jeecg/src/views/modulex/modules/ModulexImport.vue
@@ -0,0 +1,206 @@
+<template>
+  <a-modal
+    :title="title"
+    width="50%"
+    :visible="visible"
+    :closable="closable"
+    @cancel="handleCancel"
+    :maskClosable="maskClosable"
+
+    >
+    <a-alert message="请下载" type="info" show-icon style="margin-bottom: 20px;"/>
+    <a-form :form="form" :label-col="{ span: 5 }" :wrapper-col="{ span: 16 }">
+      <!-- <a-alert message="请下载" type="info" show-icon /> -->
+      <a-form-item label="下载标准表格">
+        <div class="standB">
+          <a-button type="primary" icon="download" @click="handleDownload"/>
+        </div>
+        <div class="standBu">
+          <a-alert
+            message="必须下载标准表格,否则审核可能不通过"
+            type="error"
+            closable
+            @close="onClose"
+          />
+        </div>
+      </a-form-item>
+      <a-form-item label="上传标准表格">
+        <a-upload name="file"
+                  :multiple="false"
+                  :action="url.uploadUrl"
+                  :showUploadList="false"
+                  :headers="tokenHeader">
+          <a-button type="primary" icon="upload"></a-button>
+        </a-upload>
+      </a-form-item>
+      <a-form-item v-if="ModalData.isVisible==='true'" class="box">
+        <p>当前状态：<span :class=" ModalData.isError==='true'?stateFontColor:''">{{ ModalData.status }}</span></p>
+        <p>总记录数：{{ ModalData.records }}</p>
+        <p>已上传：{{ ModalData.uploaded }}</p>
+        <a-progress
+          :percent="parseInt(String(ModalData.uploaded/ModalData.records*100))"
+          title="上传进度："
+          status="active"
+          :steps="ModalData.records"/>
+      </a-form-item>
+      <!--      <a-form-model-item label="注意事项" v-if="uploadFinished">-->
+      <a-form-model-item label="注意事项">
+        <a-list size="small" :data-source="datas">
+          <a-list-item slot="renderItem" slot-scope="item,index" style="border-bottom:0px ;"> {{ index + 1 }} . {{
+              item
+            }}
+          </a-list-item>
+        </a-list>
+      </a-form-model-item>
+    </a-form>
+    <template slot="footer">
+      <a-button type="primary" @click="handleCancel" :disabled="ModalData.closeable == 'true' ? false : true">关闭</a-button>
+    </template>
+  </a-modal>
+</template>
+
+<script>
+import {downloadFile, getAction} from "@api/manage"
+import store from '@/store'
+import {JeecgListMixin} from '@/mixins/JeecgListMixin'
+import {mixinDevice} from '@/utils/mixin'
+
+export default {
+  name: 'ModelTest',
+  mixins: [JeecgListMixin, mixinDevice],
+  comments: {},
+  data() {
+    return {
+      closable:false,
+      maskClosable:false,
+      title: '导入xxxxx',
+      visible: false,
+      model: {},
+      // 注意事项默认值
+      uploadFinished: false,
+      ModalData: {
+        uploaded: '0',
+        isVisible: 'false',
+        records: '0',
+        status: '判断文件结构',
+      },
+      form: this.$form.createForm(this),
+      downName:'',
+      url:
+        {
+          downfile: '',
+          uploadUrl: '',
+          list: "/modulex/modulex/list"
+        },
+      datas: [
+        'Racing car sprays burning fuel into crowd.',
+        'Japanese princess to wed commoner.',
+        'Australian walks 100km after outback crash.',
+        'Man charged over missing wedding girl.',
+        'Los Angeles battles huge wildfires.'
+      ],
+      stateFontColor: 'stateFontColor',
+      ws: {}
+
+    }
+  },
+  created() {
+  },
+  computed: {},
+  methods: {
+    // 上传文件
+    handleChange(info) {
+      if (info.file.status !== 'uploading') {
+        console.log(info.file, info.fileList)
+      }
+      if (info.file.status === 'done') {
+        this.$message.success(`${info.file.name} file uploaded successfully`)
+        this.handleUploadFinished()
+      } else if (info.file.status === 'error') {
+        this.$message.error(`${info.file.name} file upload failed.`)
+      }
+    },
+    // 在文件上传结束后调用该方法使注意事项出现
+    handleUploadFinished() {
+      this.uploadFinished = true
+    },
+    // 下载标准文档
+    handleDownload() {
+      console.log(this.downName,"111")
+      downloadFile( this.url.downfile,this.downName)
+      // getAction(this.url.list, params).then((res) =>
+      // getAction(this.url.downfile).then((response) => {
+      //   const url = window.URL.createObjectURL(new Blob([response.data]))
+      //   const link = document.createElement('a')
+      //   link.href = url
+      //   link.setAttribute('download', 'your-document.pdf')
+      //   document.body.appendChild(link)
+      //   link.click()
+      // })
+      //   .catch(error => {
+      //     console.error(error)
+      //   })
+    },
+    add() {
+
+    },
+    show(data,ws) {
+      this.url.uploadUrl = data.uploadUrl
+      this.url.downfile = data.downUrl
+      this.downName = data.downName
+      this.datas = data.note
+      this.title = data.title
+      this.ModalData = {}
+      this.ModalData.closeable = "true"
+      this.visible = true
+      this.ws=ws
+
+    },
+    edit(record) {
+      this.ModalData = record
+      // this.closeable = this.ModalData.closeable === "true"
+    },
+    edit1(record) {
+      this.visible = true
+    },
+
+    close() {
+      this.$emit('close')
+      this.visible = false
+      this.ws.close()
+    },
+    handleCancel() {
+        console.log(this.ModalData,'11111')
+        this.close()
+        this.ws.close()
+    },
+    // 关闭提示标签
+    onClose(e) {
+      console.log(e, 'I was closed.')
+    }
+  }
+}
+</script>
+
+<style scoped>
+.standB {
+  width: 15%;
+  float: left;
+}
+
+.standBu {
+  width: 85%;
+  float: right;
+}
+
+.box {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+}
+
+.stateFontColor {
+  color: red;
+}
+</style>
diff --git a/jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/bugx/entity/BugxExportDto.java b/jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/bugx/entity/BugxExportDto.java
new file mode 100644
index 0000000..ec953d5
--- /dev/null
+++ b/jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/bugx/entity/BugxExportDto.java
@@ -0,0 +1,143 @@
+package org.jeecg.modules.demo.bugx.entity;
+
+import java.io.Serializable;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.jeecgframework.poi.excel.annotation.ExcelIgnore;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.jeecgframework.poi.excel.annotation.Excel;
+import org.jeecg.common.aspect.annotation.Dict;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+/**
+ * @Description: BUG管理
+ * @Author: jeecg-boot
+ * @Date:   2023-04-11
+ * @Version: V1.0
+ */
+@Data
+@Accessors(chain = true)
+@EqualsAndHashCode(callSuper = false)
+@ApiModel(value="bugx对象", description="BUG管理")
+public class BugxExportDto implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    /**主键*/
+    @ApiModelProperty(value = "主键")
+    private java.lang.String id;
+    /**创建人*/
+    @ApiModelProperty(value = "创建人")
+    private java.lang.String createBy;
+    /**创建日期*/
+    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "创建日期")
+    private java.util.Date createTime;
+    /**更新人*/
+    @ApiModelProperty(value = "更新人")
+    private java.lang.String updateBy;
+    /**更新日期*/
+    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "更新日期")
+    private java.util.Date updateTime;
+    /**BUG编码*/
+    @Excel(name = "BUG编码", width = 15)
+    @ApiModelProperty(value = "BUG编码")
+    private java.lang.String bugCode;
+    /**BUG类型*/
+    @ExcelIgnore()
+    @ApiModelProperty(value = "BUG类型")
+    @Dict(dicCode = "bug_type")
+    private java.lang.Integer type;
+
+    @TableField(exist = false)
+    @Excel(name = "BUG类型", width = 15)
+    private java.lang.String typeName;
+    /**项目id*/
+    @Excel(name = "项目", width = 15)
+    @ApiModelProperty(value = "项目id")
+    @Dict(dicCode = "id",dicText = "project_code",dictTable = "projectx")
+    private java.lang.String projectId;
+    /**对应模块id*/
+    @Excel(name = "对应模块", width = 15)
+    @ApiModelProperty(value = "对应模块id")
+    @Dict(dicCode = "id",dicText = "module_code",dictTable = "modulex")
+    private java.lang.String moduleId;
+    /**对应功能id*/
+    @Excel(name = "对应功能", width = 15)
+    @ApiModelProperty(value = "对应功能id")
+    @Dict(dicCode = "id",dicText = "function_code",dictTable = "functionx")
+    private java.lang.String functionId;
+    /**对应规则id*/
+
+    @ExcelIgnore
+    @ApiModelProperty(value = "对应规则id")
+    @Dict(dicCode = "id",dicText = "rule_code",dictTable = "rulex")
+    private java.lang.String ruleId;
+
+    @Excel(name = "对应规则", width = 15)
+    @TableField(exist = false)
+    private java.lang.String rulePm_desc;
+    /**BUG等级*/
+    @Excel(name = "BUG等级", width = 15)
+    @ApiModelProperty(value = "BUG等级")
+    @Dict(dicCode = "work_level")
+    private java.lang.Integer bugLevel;
+    /**BUG描述*/
+    @Excel(name = "BUG描述", width = 15)
+    @ApiModelProperty(value = "BUG描述")
+    private java.lang.String pmDesc;
+    /**BUG图片*/
+    @Excel(name = "BUG图片", width = 15)
+    @ApiModelProperty(value = "BUG图片")
+    private java.lang.String bugPic;
+    /**发布时间*/
+    @Excel(name = "发布时间", width = 15, format = "yyyy-MM-dd")
+    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "发布时间")
+    private java.util.Date publishTime;
+    /**提交内容*/
+    @Excel(name = "提交内容", width = 15)
+    @ApiModelProperty(value = "提交内容")
+    private java.lang.String submitContent;
+    /**提交图片*/
+    @Excel(name = "提交图片", width = 15)
+    @ApiModelProperty(value = "提交图片")
+    private java.lang.String submitPic;
+    /**责任人*/
+    @Excel(name = "责任人", width = 15)
+    @ApiModelProperty(value = "责任人")
+    private java.lang.String managerUsers;
+    /**BUG状态*/
+    @ExcelIgnore
+    @ApiModelProperty(value = "BUG状态")
+    @Dict(dicCode = "bug_status")
+    private java.lang.Integer bugStatus;
+
+    @TableField(exist = false)
+    @Excel(name = "BUG状态", width = 15)
+    private java.lang.String bugStatusName;
+
+    /**提交时间*/
+    @Excel(name = "提交时间", width = 15, format = "yyyy-MM-dd")
+    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "提交时间")
+    private java.util.Date submitTime;
+    /**审核时间*/
+    @Excel(name = "审核时间", width = 15, format = "yyyy-MM-dd")
+    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "审核时间")
+    private java.util.Date auditTime;
+}
diff --git a/jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/fieldx/entity/Fielddc.java b/jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/fieldx/entity/Fielddc.java
new file mode 100644
index 0000000..d7000bf
--- /dev/null
+++ b/jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/fieldx/entity/Fielddc.java
@@ -0,0 +1,48 @@
+package org.jeecg.modules.fieldx.entity;
+
+import io.swagger.annotations.ApiModel;
+import lombok.Data;
+import org.jeecgframework.poi.excel.annotation.Excel;
+
+@Data
+@ApiModel(value = "字段表模板", description = "字段表模板")
+public class Fielddc {
+    private static final long serialVersionUID = 1L;
+
+    @Excel(name = "序号", width = 15)
+    private java.lang.String a;
+    @Excel(name = "表名", width = 15)
+    private java.lang.String c;
+    @Excel(name = "中文名称", width = 15)
+    private java.lang.String ll;
+    @Excel(name = "英文名称", width = 15)
+    private java.lang.String d;
+    @Excel(name = "数据类型", width = 15)
+    private java.lang.String e;
+    @Excel(name = "数据长度", width = 15)
+    private java.lang.String f;
+    @Excel(name = "浮点精度", width = 15)
+    private java.lang.String g;
+    @Excel(name = "显示形式", width = 15)
+    private java.lang.String h;
+    @Excel(name = "是否主键", width = 15)
+    private java.lang.String i;
+    @Excel(name = "是否外键", width = 15)
+    private java.lang.String z;
+    @Excel(name = "关联实体", width = 15)
+    private java.lang.String k;
+    @Excel(name = "关联字段", width = 15)
+    private java.lang.String l;
+    @Excel(name = "是否为空", width = 15)
+    private java.lang.String m;
+    @Excel(name = "是否重复", width = 15)
+    private java.lang.String ml;
+    @Excel(name = "字段规则", width = 15)
+    private java.lang.String o;
+    @Excel(name = "字段状态", width = 15)
+    private java.lang.String p;
+    @Excel(name = "版本状态", width = 15)
+    private java.lang.String q;
+
+
+}