Adding upstream version 6.4.3+dfsg1.upstream/6.4.3+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 19401 insertions, 0 deletions

diff --git a/wp-includes/js/tinymce/themes/inlite/theme.js b/wp-includes/js/tinymce/themes/inlite/theme.js
new file mode 100644
index 0000000..675db3f
--- /dev/null
+++ b/wp-includes/js/tinymce/themes/inlite/theme.js
@@ -0,0 +1,9792 @@
+(function () {
+var inlite = (function (domGlobals) {
+    'use strict';
+
+    var global = tinymce.util.Tools.resolve('tinymce.ThemeManager');
+
+    var global$1 = tinymce.util.Tools.resolve('tinymce.Env');
+
+    var global$2 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
+
+    var global$3 = tinymce.util.Tools.resolve('tinymce.util.Delay');
+
+    var flatten = function (arr) {
+      return arr.reduce(function (results, item) {
+        return Array.isArray(item) ? results.concat(flatten(item)) : results.concat(item);
+      }, []);
+    };
+    var DeepFlatten = { flatten: flatten };
+
+    var result = function (id, rect) {
+      return {
+        id: id,
+        rect: rect
+      };
+    };
+    var match = function (editor, matchers) {
+      for (var i = 0; i < matchers.length; i++) {
+        var f = matchers[i];
+        var result_1 = f(editor);
+        if (result_1) {
+          return result_1;
+        }
+      }
+      return null;
+    };
+    var Matcher = {
+      match: match,
+      result: result
+    };
+
+    var fromClientRect = function (clientRect) {
+      return {
+        x: clientRect.left,
+        y: clientRect.top,
+        w: clientRect.width,
+        h: clientRect.height
+      };
+    };
+    var toClientRect = function (geomRect) {
+      return {
+        left: geomRect.x,
+        top: geomRect.y,
+        width: geomRect.w,
+        height: geomRect.h,
+        right: geomRect.x + geomRect.w,
+        bottom: geomRect.y + geomRect.h
+      };
+    };
+    var Convert = {
+      fromClientRect: fromClientRect,
+      toClientRect: toClientRect
+    };
+
+    var toAbsolute = function (rect) {
+      var vp = global$2.DOM.getViewPort();
+      return {
+        x: rect.x + vp.x,
+        y: rect.y + vp.y,
+        w: rect.w,
+        h: rect.h
+      };
+    };
+    var measureElement = function (elm) {
+      var clientRect = elm.getBoundingClientRect();
+      return toAbsolute({
+        x: clientRect.left,
+        y: clientRect.top,
+        w: Math.max(elm.clientWidth, elm.offsetWidth),
+        h: Math.max(elm.clientHeight, elm.offsetHeight)
+      });
+    };
+    var getElementRect = function (editor, elm) {
+      return measureElement(elm);
+    };
+    var getPageAreaRect = function (editor) {
+      return measureElement(editor.getElement().ownerDocument.body);
+    };
+    var getContentAreaRect = function (editor) {
+      return measureElement(editor.getContentAreaContainer() || editor.getBody());
+    };
+    var getSelectionRect = function (editor) {
+      var clientRect = editor.selection.getBoundingClientRect();
+      return clientRect ? toAbsolute(Convert.fromClientRect(clientRect)) : null;
+    };
+    var Measure = {
+      getElementRect: getElementRect,
+      getPageAreaRect: getPageAreaRect,
+      getContentAreaRect: getContentAreaRect,
+      getSelectionRect: getSelectionRect
+    };
+
+    var element = function (element, predicateIds) {
+      return function (editor) {
+        for (var i = 0; i < predicateIds.length; i++) {
+          if (predicateIds[i].predicate(element)) {
+            var result = Matcher.result(predicateIds[i].id, Measure.getElementRect(editor, element));
+            return result;
+          }
+        }
+        return null;
+      };
+    };
+    var parent = function (elements, predicateIds) {
+      return function (editor) {
+        for (var i = 0; i < elements.length; i++) {
+          for (var x = 0; x < predicateIds.length; x++) {
+            if (predicateIds[x].predicate(elements[i])) {
+              return Matcher.result(predicateIds[x].id, Measure.getElementRect(editor, elements[i]));
+            }
+          }
+        }
+        return null;
+      };
+    };
+    var ElementMatcher = {
+      element: element,
+      parent: parent
+    };
+
+    var global$4 = tinymce.util.Tools.resolve('tinymce.util.Tools');
+
+    var create = function (id, predicate) {
+      return {
+        id: id,
+        predicate: predicate
+      };
+    };
+    var fromContextToolbars = function (toolbars) {
+      return global$4.map(toolbars, function (toolbar) {
+        return create(toolbar.id, toolbar.predicate);
+      });
+    };
+    var PredicateId = {
+      create: create,
+      fromContextToolbars: fromContextToolbars
+    };
+
+    var textSelection = function (id) {
+      return function (editor) {
+        if (!editor.selection.isCollapsed()) {
+          var result = Matcher.result(id, Measure.getSelectionRect(editor));
+          return result;
+        }
+        return null;
+      };
+    };
+    var emptyTextBlock = function (elements, id) {
+      return function (editor) {
+        var i;
+        var textBlockElementsMap = editor.schema.getTextBlockElements();
+        for (i = 0; i < elements.length; i++) {
+          if (elements[i].nodeName === 'TABLE') {
+            return null;
+          }
+        }
+        for (i = 0; i < elements.length; i++) {
+          if (elements[i].nodeName in textBlockElementsMap) {
+            if (editor.dom.isEmpty(elements[i])) {
+              return Matcher.result(id, Measure.getSelectionRect(editor));
+            }
+            return null;
+          }
+        }
+        return null;
+      };
+    };
+    var SelectionMatcher = {
+      textSelection: textSelection,
+      emptyTextBlock: emptyTextBlock
+    };
+
+    var fireSkinLoaded = function (editor) {
+      editor.fire('SkinLoaded');
+    };
+    var fireBeforeRenderUI = function (editor) {
+      return editor.fire('BeforeRenderUI');
+    };
+    var Events = {
+      fireSkinLoaded: fireSkinLoaded,
+      fireBeforeRenderUI: fireBeforeRenderUI
+    };
+
+    var global$5 = tinymce.util.Tools.resolve('tinymce.EditorManager');
+
+    var isType = function (type) {
+      return function (value) {
+        return typeof value === type;
+      };
+    };
+    var isArray = function (value) {
+      return Array.isArray(value);
+    };
+    var isNull = function (value) {
+      return value === null;
+    };
+    var isObject = function (predicate) {
+      return function (value) {
+        return !isNull(value) && !isArray(value) && predicate(value);
+      };
+    };
+    var isString = function (value) {
+      return isType('string')(value);
+    };
+    var isNumber = function (value) {
+      return isType('number')(value);
+    };
+    var isFunction = function (value) {
+      return isType('function')(value);
+    };
+    var isBoolean = function (value) {
+      return isType('boolean')(value);
+    };
+    var Type = {
+      isString: isString,
+      isNumber: isNumber,
+      isBoolean: isBoolean,
+      isFunction: isFunction,
+      isObject: isObject(isType('object')),
+      isNull: isNull,
+      isArray: isArray
+    };
+
+    var validDefaultOrDie = function (value, predicate) {
+      if (predicate(value)) {
+        return true;
+      }
+      throw new Error('Default value doesn\'t match requested type.');
+    };
+    var getByTypeOr = function (predicate) {
+      return function (editor, name, defaultValue) {
+        var settings = editor.settings;
+        validDefaultOrDie(defaultValue, predicate);
+        return name in settings && predicate(settings[name]) ? settings[name] : defaultValue;
+      };
+    };
+    var splitNoEmpty = function (str, delim) {
+      return str.split(delim).filter(function (item) {
+        return item.length > 0;
+      });
+    };
+    var itemsToArray = function (value, defaultValue) {
+      var stringToItemsArray = function (value) {
+        return typeof value === 'string' ? splitNoEmpty(value, /[ ,]/) : value;
+      };
+      var boolToItemsArray = function (value, defaultValue) {
+        return value === false ? [] : defaultValue;
+      };
+      if (Type.isArray(value)) {
+        return value;
+      } else if (Type.isString(value)) {
+        return stringToItemsArray(value);
+      } else if (Type.isBoolean(value)) {
+        return boolToItemsArray(value, defaultValue);
+      }
+      return defaultValue;
+    };
+    var getToolbarItemsOr = function (predicate) {
+      return function (editor, name, defaultValue) {
+        var value = name in editor.settings ? editor.settings[name] : defaultValue;
+        validDefaultOrDie(defaultValue, predicate);
+        return itemsToArray(value, defaultValue);
+      };
+    };
+    var EditorSettings = {
+      getStringOr: getByTypeOr(Type.isString),
+      getBoolOr: getByTypeOr(Type.isBoolean),
+      getNumberOr: getByTypeOr(Type.isNumber),
+      getHandlerOr: getByTypeOr(Type.isFunction),
+      getToolbarItemsOr: getToolbarItemsOr(Type.isArray)
+    };
+
+    var global$6 = tinymce.util.Tools.resolve('tinymce.geom.Rect');
+
+    var result$1 = function (rect, position) {
+      return {
+        rect: rect,
+        position: position
+      };
+    };
+    var moveTo = function (rect, toRect) {
+      return {
+        x: toRect.x,
+        y: toRect.y,
+        w: rect.w,
+        h: rect.h
+      };
+    };
+    var calcByPositions = function (testPositions1, testPositions2, targetRect, contentAreaRect, panelRect) {
+      var relPos, relRect, outputPanelRect;
+      var paddedContentRect = {
+        x: contentAreaRect.x,
+        y: contentAreaRect.y,
+        w: contentAreaRect.w + (contentAreaRect.w < panelRect.w + targetRect.w ? panelRect.w : 0),
+        h: contentAreaRect.h + (contentAreaRect.h < panelRect.h + targetRect.h ? panelRect.h : 0)
+      };
+      relPos = global$6.findBestRelativePosition(panelRect, targetRect, paddedContentRect, testPositions1);
+      targetRect = global$6.clamp(targetRect, paddedContentRect);
+      if (relPos) {
+        relRect = global$6.relativePosition(panelRect, targetRect, relPos);
+        outputPanelRect = moveTo(panelRect, relRect);
+        return result$1(outputPanelRect, relPos);
+      }
+      targetRect = global$6.intersect(paddedContentRect, targetRect);
+      if (targetRect) {
+        relPos = global$6.findBestRelativePosition(panelRect, targetRect, paddedContentRect, testPositions2);
+        if (relPos) {
+          relRect = global$6.relativePosition(panelRect, targetRect, relPos);
+          outputPanelRect = moveTo(panelRect, relRect);
+          return result$1(outputPanelRect, relPos);
+        }
+        outputPanelRect = moveTo(panelRect, targetRect);
+        return result$1(outputPanelRect, relPos);
+      }
+      return null;
+    };
+    var calcInsert = function (targetRect, contentAreaRect, panelRect) {
+      return calcByPositions([
+        'cr-cl',
+        'cl-cr'
+      ], [
+        'bc-tc',
+        'bl-tl',
+        'br-tr'
+      ], targetRect, contentAreaRect, panelRect);
+    };
+    var calc = function (targetRect, contentAreaRect, panelRect) {
+      return calcByPositions([
+        'tc-bc',
+        'bc-tc',
+        'tl-bl',
+        'bl-tl',
+        'tr-br',
+        'br-tr',
+        'cr-cl',
+        'cl-cr'
+      ], [
+        'bc-tc',
+        'bl-tl',
+        'br-tr',
+        'cr-cl'
+      ], targetRect, contentAreaRect, panelRect);
+    };
+    var userConstrain = function (handler, targetRect, contentAreaRect, panelRect) {
+      var userConstrainedPanelRect;
+      if (typeof handler === 'function') {
+        userConstrainedPanelRect = handler({
+          elementRect: Convert.toClientRect(targetRect),
+          contentAreaRect: Convert.toClientRect(contentAreaRect),
+          panelRect: Convert.toClientRect(panelRect)
+        });
+        return Convert.fromClientRect(userConstrainedPanelRect);
+      }
+      return panelRect;
+    };
+    var defaultHandler = function (rects) {
+      return rects.panelRect;
+    };
+    var Layout = {
+      calcInsert: calcInsert,
+      calc: calc,
+      userConstrain: userConstrain,
+      defaultHandler: defaultHandler
+    };
+
+    var toAbsoluteUrl = function (editor, url) {
+      return editor.documentBaseURI.toAbsolute(url);
+    };
+    var urlFromName = function (name) {
+      var prefix = global$5.baseURL + '/skins/';
+      return name ? prefix + name : prefix + 'lightgray';
+    };
+    var getTextSelectionToolbarItems = function (editor) {
+      return EditorSettings.getToolbarItemsOr(editor, 'selection_toolbar', [
+        'bold',
+        'italic',
+        '|',
+        'quicklink',
+        'h2',
+        'h3',
+        'blockquote'
+      ]);
+    };
+    var getInsertToolbarItems = function (editor) {
+      return EditorSettings.getToolbarItemsOr(editor, 'insert_toolbar', [
+        'quickimage',
+        'quicktable'
+      ]);
+    };
+    var getPositionHandler = function (editor) {
+      return EditorSettings.getHandlerOr(editor, 'inline_toolbar_position_handler', Layout.defaultHandler);
+    };
+    var getSkinUrl = function (editor) {
+      var settings = editor.settings;
+      return settings.skin_url ? toAbsoluteUrl(editor, settings.skin_url) : urlFromName(settings.skin);
+    };
+    var isSkinDisabled = function (editor) {
+      return editor.settings.skin === false;
+    };
+    var Settings = {
+      getTextSelectionToolbarItems: getTextSelectionToolbarItems,
+      getInsertToolbarItems: getInsertToolbarItems,
+      getPositionHandler: getPositionHandler,
+      getSkinUrl: getSkinUrl,
+      isSkinDisabled: isSkinDisabled
+    };
+
+    var fireSkinLoaded$1 = function (editor, callback) {
+      var done = function () {
+        editor._skinLoaded = true;
+        Events.fireSkinLoaded(editor);
+        callback();
+      };
+      if (editor.initialized) {
+        done();
+      } else {
+        editor.on('init', done);
+      }
+    };
+    var load = function (editor, callback) {
+      var skinUrl = Settings.getSkinUrl(editor);
+      var done = function () {
+        fireSkinLoaded$1(editor, callback);
+      };
+      if (Settings.isSkinDisabled(editor)) {
+        done();
+      } else {
+        global$2.DOM.styleSheetLoader.load(skinUrl + '/skin.min.css', done);
+        editor.contentCSS.push(skinUrl + '/content.inline.min.css');
+      }
+    };
+    var SkinLoader = { load: load };
+
+    var getSelectionElements = function (editor) {
+      var node = editor.selection.getNode();
+      var elms = editor.dom.getParents(node, '*');
+      return elms;
+    };
+    var createToolbar = function (editor, selector, id, items) {
+      var selectorPredicate = function (elm) {
+        return editor.dom.is(elm, selector);
+      };
+      return {
+        predicate: selectorPredicate,
+        id: id,
+        items: items
+      };
+    };
+    var getToolbars = function (editor) {
+      var contextToolbars = editor.contextToolbars;
+      return DeepFlatten.flatten([
+        contextToolbars ? contextToolbars : [],
+        createToolbar(editor, 'img', 'image', 'alignleft aligncenter alignright')
+      ]);
+    };
+    var findMatchResult = function (editor, toolbars) {
+      var result, elements, contextToolbarsPredicateIds;
+      elements = getSelectionElements(editor);
+      contextToolbarsPredicateIds = PredicateId.fromContextToolbars(toolbars);
+      result = Matcher.match(editor, [
+        ElementMatcher.element(elements[0], contextToolbarsPredicateIds),
+        SelectionMatcher.textSelection('text'),
+        SelectionMatcher.emptyTextBlock(elements, 'insert'),
+        ElementMatcher.parent(elements, contextToolbarsPredicateIds)
+      ]);
+      return result && result.rect ? result : null;
+    };
+    var editorHasFocus = function (editor) {
+      return domGlobals.document.activeElement === editor.getBody();
+    };
+    var togglePanel = function (editor, panel) {
+      var toggle = function () {
+        var toolbars = getToolbars(editor);
+        var result = findMatchResult(editor, toolbars);
+        if (result) {
+          panel.show(editor, result.id, result.rect, toolbars);
+        } else {
+          panel.hide();
+        }
+      };
+      return function () {
+        if (!editor.removed && editorHasFocus(editor)) {
+          toggle();
+        }
+      };
+    };
+    var repositionPanel = function (editor, panel) {
+      return function () {
+        var toolbars = getToolbars(editor);
+        var result = findMatchResult(editor, toolbars);
+        if (result) {
+          panel.reposition(editor, result.id, result.rect);
+        }
+      };
+    };
+    var ignoreWhenFormIsVisible = function (editor, panel, f) {
+      return function () {
+        if (!editor.removed && !panel.inForm()) {
+          f();
+        }
+      };
+    };
+    var bindContextualToolbarsEvents = function (editor, panel) {
+      var throttledTogglePanel = global$3.throttle(togglePanel(editor, panel), 0);
+      var throttledTogglePanelWhenNotInForm = global$3.throttle(ignoreWhenFormIsVisible(editor, panel, togglePanel(editor, panel)), 0);
+      var reposition = repositionPanel(editor, panel);
+      editor.on('blur hide ObjectResizeStart', panel.hide);
+      editor.on('click', throttledTogglePanel);
+      editor.on('nodeChange mouseup', throttledTogglePanelWhenNotInForm);
+      editor.on('ResizeEditor keyup', throttledTogglePanel);
+      editor.on('ResizeWindow', reposition);
+      global$2.DOM.bind(global$1.container, 'scroll', reposition);
+      editor.on('remove', function () {
+        global$2.DOM.unbind(global$1.container, 'scroll', reposition);
+        panel.remove();
+      });
+      editor.shortcuts.add('Alt+F10,F10', '', panel.focus);
+    };
+    var overrideLinkShortcut = function (editor, panel) {
+      editor.shortcuts.remove('meta+k');
+      editor.shortcuts.add('meta+k', '', function () {
+        var toolbars = getToolbars(editor);
+        var result = Matcher.match(editor, [SelectionMatcher.textSelection('quicklink')]);
+        if (result) {
+          panel.show(editor, result.id, result.rect, toolbars);
+        }
+      });
+    };
+    var renderInlineUI = function (editor, panel) {
+      SkinLoader.load(editor, function () {
+        bindContextualToolbarsEvents(editor, panel);
+        overrideLinkShortcut(editor, panel);
+      });
+      return {};
+    };
+    var fail = function (message) {
+      throw new Error(message);
+    };
+    var renderUI = function (editor, panel) {
+      return editor.inline ? renderInlineUI(editor, panel) : fail('inlite theme only supports inline mode.');
+    };
+    var Render = { renderUI: renderUI };
+
+    var noop = function () {
+    };
+    var constant = function (value) {
+      return function () {
+        return value;
+      };
+    };
+    var never = constant(false);
+    var always = constant(true);
+
+    var none = function () {
+      return NONE;
+    };
+    var NONE = function () {
+      var eq = function (o) {
+        return o.isNone();
+      };
+      var call = function (thunk) {
+        return thunk();
+      };
+      var id = function (n) {
+        return n;
+      };
+      var me = {
+        fold: function (n, s) {
+          return n();
+        },
+        is: never,
+        isSome: never,
+        isNone: always,
+        getOr: id,
+        getOrThunk: call,
+        getOrDie: function (msg) {
+          throw new Error(msg || 'error: getOrDie called on none.');
+        },
+        getOrNull: constant(null),
+        getOrUndefined: constant(undefined),
+        or: id,
+        orThunk: call,
+        map: none,
+        each: noop,
+        bind: none,
+        exists: never,
+        forall: always,
+        filter: none,
+        equals: eq,
+        equals_: eq,
+        toArray: function () {
+          return [];
+        },
+        toString: constant('none()')
+      };
+      if (Object.freeze) {
+        Object.freeze(me);
+      }
+      return me;
+    }();
+    var some = function (a) {
+      var constant_a = constant(a);
+      var self = function () {
+        return me;
+      };
+      var bind = function (f) {
+        return f(a);
+      };
+      var me = {
+        fold: function (n, s) {
+          return s(a);
+        },
+        is: function (v) {
+          return a === v;
+        },
+        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 + ')';
+        },
+        equals: function (o) {
+          return o.is(a);
+        },
+        equals_: function (o, elementEq) {
+          return o.fold(never, function (b) {
+            return elementEq(a, b);
+          });
+        }
+      };
+      return me;
+    };
+    var from = function (value) {
+      return value === null || value === undefined ? NONE : some(value);
+    };
+    var Option = {
+      some: some,
+      none: none,
+      from: from
+    };
+
+    var typeOf = function (x) {
+      if (x === null) {
+        return 'null';
+      }
+      var t = typeof x;
+      if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
+        return 'array';
+      }
+      if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
+        return 'string';
+      }
+      return t;
+    };
+    var isType$1 = function (type) {
+      return function (value) {
+        return typeOf(value) === type;
+      };
+    };
+    var isArray$1 = isType$1('array');
+    var isFunction$1 = isType$1('function');
+    var isNumber$1 = isType$1('number');
+
+    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 ? Option.none() : Option.some(r);
+    };
+    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 = 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 = function (xs, f) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        f(x, i);
+      }
+    };
+    var filter = 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 foldl = function (xs, f, acc) {
+      each(xs, function (x) {
+        acc = f(acc, x);
+      });
+      return acc;
+    };
+    var find = function (xs, pred) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          return Option.some(x);
+        }
+      }
+      return Option.none();
+    };
+    var flatten$1 = function (xs) {
+      var r = [];
+      for (var i = 0, len = xs.length; i < len; ++i) {
+        if (!isArray$1(xs[i])) {
+          throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
+        }
+        nativePush.apply(r, xs[i]);
+      }
+      return r;
+    };
+    var from$1 = isFunction$1(Array.from) ? Array.from : function (x) {
+      return nativeSlice.call(x);
+    };
+
+    var count = 0;
+    var funcs = {
+      id: function () {
+        return 'mceu_' + count++;
+      },
+      create: function (name, attrs, children) {
+        var elm = domGlobals.document.createElement(name);
+        global$2.DOM.setAttribs(elm, attrs);
+        if (typeof children === 'string') {
+          elm.innerHTML = children;
+        } else {
+          global$4.each(children, function (child) {
+            if (child.nodeType) {
+              elm.appendChild(child);
+            }
+          });
+        }
+        return elm;
+      },
+      createFragment: function (html) {
+        return global$2.DOM.createFragment(html);
+      },
+      getWindowSize: function () {
+        return global$2.DOM.getViewPort();
+      },
+      getSize: function (elm) {
+        var width, height;
+        if (elm.getBoundingClientRect) {
+          var rect = elm.getBoundingClientRect();
+          width = Math.max(rect.width || rect.right - rect.left, elm.offsetWidth);
+          height = Math.max(rect.height || rect.bottom - rect.bottom, elm.offsetHeight);
+        } else {
+          width = elm.offsetWidth;
+          height = elm.offsetHeight;
+        }
+        return {
+          width: width,
+          height: height
+        };
+      },
+      getPos: function (elm, root) {
+        return global$2.DOM.getPos(elm, root || funcs.getContainer());
+      },
+      getContainer: function () {
+        return global$1.container ? global$1.container : domGlobals.document.body;
+      },
+      getViewPort: function (win) {
+        return global$2.DOM.getViewPort(win);
+      },
+      get: function (id) {
+        return domGlobals.document.getElementById(id);
+      },
+      addClass: function (elm, cls) {
+        return global$2.DOM.addClass(elm, cls);
+      },
+      removeClass: function (elm, cls) {
+        return global$2.DOM.removeClass(elm, cls);
+      },
+      hasClass: function (elm, cls) {
+        return global$2.DOM.hasClass(elm, cls);
+      },
+      toggleClass: function (elm, cls, state) {
+        return global$2.DOM.toggleClass(elm, cls, state);
+      },
+      css: function (elm, name, value) {
+        return global$2.DOM.setStyle(elm, name, value);
+      },
+      getRuntimeStyle: function (elm, name) {
+        return global$2.DOM.getStyle(elm, name, true);
+      },
+      on: function (target, name, callback, scope) {
+        return global$2.DOM.bind(target, name, callback, scope);
+      },
+      off: function (target, name, callback) {
+        return global$2.DOM.unbind(target, name, callback);
+      },
+      fire: function (target, name, args) {
+        return global$2.DOM.fire(target, name, args);
+      },
+      innerHtml: function (elm, html) {
+        global$2.DOM.setHTML(elm, html);
+      }
+    };
+
+    var global$7 = tinymce.util.Tools.resolve('tinymce.dom.DomQuery');
+
+    var global$8 = tinymce.util.Tools.resolve('tinymce.util.Class');
+
+    var global$9 = tinymce.util.Tools.resolve('tinymce.util.EventDispatcher');
+
+    var BoxUtils = {
+      parseBox: function (value) {
+        var len;
+        var radix = 10;
+        if (!value) {
+          return;
+        }
+        if (typeof value === 'number') {
+          value = value || 0;
+          return {
+            top: value,
+            left: value,
+            bottom: value,
+            right: value
+          };
+        }
+        value = value.split(' ');
+        len = value.length;
+        if (len === 1) {
+          value[1] = value[2] = value[3] = value[0];
+        } else if (len === 2) {
+          value[2] = value[0];
+          value[3] = value[1];
+        } else if (len === 3) {
+          value[3] = value[1];
+        }
+        return {
+          top: parseInt(value[0], radix) || 0,
+          right: parseInt(value[1], radix) || 0,
+          bottom: parseInt(value[2], radix) || 0,
+          left: parseInt(value[3], radix) || 0
+        };
+      },
+      measureBox: function (elm, prefix) {
+        function getStyle(name) {
+          var defaultView = elm.ownerDocument.defaultView;
+          if (defaultView) {
+            var computedStyle = defaultView.getComputedStyle(elm, null);
+            if (computedStyle) {
+              name = name.replace(/[A-Z]/g, function (a) {
+                return '-' + a;
+              });
+              return computedStyle.getPropertyValue(name);
+            } else {
+              return null;
+            }
+          }
+          return elm.currentStyle[name];
+        }
+        function getSide(name) {
+          var val = parseFloat(getStyle(name));
+          return isNaN(val) ? 0 : val;
+        }
+        return {
+          top: getSide(prefix + 'TopWidth'),
+          right: getSide(prefix + 'RightWidth'),
+          bottom: getSide(prefix + 'BottomWidth'),
+          left: getSide(prefix + 'LeftWidth')
+        };
+      }
+    };
+
+    function noop$1() {
+    }
+    function ClassList(onchange) {
+      this.cls = [];
+      this.cls._map = {};
+      this.onchange = onchange || noop$1;
+      this.prefix = '';
+    }
+    global$4.extend(ClassList.prototype, {
+      add: function (cls) {
+        if (cls && !this.contains(cls)) {
+          this.cls._map[cls] = true;
+          this.cls.push(cls);
+          this._change();
+        }
+        return this;
+      },
+      remove: function (cls) {
+        if (this.contains(cls)) {
+          var i = void 0;
+          for (i = 0; i < this.cls.length; i++) {
+            if (this.cls[i] === cls) {
+              break;
+            }
+          }
+          this.cls.splice(i, 1);
+          delete this.cls._map[cls];
+          this._change();
+        }
+        return this;
+      },
+      toggle: function (cls, state) {
+        var curState = this.contains(cls);
+        if (curState !== state) {
+          if (curState) {
+            this.remove(cls);
+          } else {
+            this.add(cls);
+          }
+          this._change();
+        }
+        return this;
+      },
+      contains: function (cls) {
+        return !!this.cls._map[cls];
+      },
+      _change: function () {
+        delete this.clsValue;
+        this.onchange.call(this);
+      }
+    });
+    ClassList.prototype.toString = function () {
+      var value;
+      if (this.clsValue) {
+        return this.clsValue;
+      }
+      value = '';
+      for (var i = 0; i < this.cls.length; i++) {
+        if (i > 0) {
+          value += ' ';
+        }
+        value += this.prefix + this.cls[i];
+      }
+      return value;
+    };
+
+    function unique(array) {
+      var uniqueItems = [];
+      var i = array.length, item;
+      while (i--) {
+        item = array[i];
+        if (!item.__checked) {
+          uniqueItems.push(item);
+          item.__checked = 1;
+        }
+      }
+      i = uniqueItems.length;
+      while (i--) {
+        delete uniqueItems[i].__checked;
+      }
+      return uniqueItems;
+    }
+    var expression = /^([\w\\*]+)?(?:#([\w\-\\]+))?(?:\.([\w\\\.]+))?(?:\[\@?([\w\\]+)([\^\$\*!~]?=)([\w\\]+)\])?(?:\:(.+))?/i;
+    var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g;
+    var whiteSpace = /^\s*|\s*$/g;
+    var Collection;
+    var Selector = global$8.extend({
+      init: function (selector) {
+        var match = this.match;
+        function compileNameFilter(name) {
+          if (name) {
+            name = name.toLowerCase();
+            return function (item) {
+              return name === '*' || item.type === name;
+            };
+          }
+        }
+        function compileIdFilter(id) {
+          if (id) {
+            return function (item) {
+              return item._name === id;
+            };
+          }
+        }
+        function compileClassesFilter(classes) {
+          if (classes) {
+            classes = classes.split('.');
+            return function (item) {
+              var i = classes.length;
+              while (i--) {
+                if (!item.classes.contains(classes[i])) {
+                  return false;
+                }
+              }
+              return true;
+            };
+          }
+        }
+        function compileAttrFilter(name, cmp, check) {
+          if (name) {
+            return function (item) {
+              var value = item[name] ? item[name]() : '';
+              return !cmp ? !!check : cmp === '=' ? value === check : cmp === '*=' ? value.indexOf(check) >= 0 : cmp === '~=' ? (' ' + value + ' ').indexOf(' ' + check + ' ') >= 0 : cmp === '!=' ? value !== check : cmp === '^=' ? value.indexOf(check) === 0 : cmp === '$=' ? value.substr(value.length - check.length) === check : false;
+            };
+          }
+        }
+        function compilePsuedoFilter(name) {
+          var notSelectors;
+          if (name) {
+            name = /(?:not\((.+)\))|(.+)/i.exec(name);
+            if (!name[1]) {
+              name = name[2];
+              return function (item, index, length) {
+                return name === 'first' ? index === 0 : name === 'last' ? index === length - 1 : name === 'even' ? index % 2 === 0 : name === 'odd' ? index % 2 === 1 : item[name] ? item[name]() : false;
+              };
+            }
+            notSelectors = parseChunks(name[1], []);
+            return function (item) {
+              return !match(item, notSelectors);
+            };
+          }
+        }
+        function compile(selector, filters, direct) {
+          var parts;
+          function add(filter) {
+            if (filter) {
+              filters.push(filter);
+            }
+          }
+          parts = expression.exec(selector.replace(whiteSpace, ''));
+          add(compileNameFilter(parts[1]));
+          add(compileIdFilter(parts[2]));
+          add(compileClassesFilter(parts[3]));
+          add(compileAttrFilter(parts[4], parts[5], parts[6]));
+          add(compilePsuedoFilter(parts[7]));
+          filters.pseudo = !!parts[7];
+          filters.direct = direct;
+          return filters;
+        }
+        function parseChunks(selector, selectors) {
+          var parts = [];
+          var extra, matches, i;
+          do {
+            chunker.exec('');
+            matches = chunker.exec(selector);
+            if (matches) {
+              selector = matches[3];
+              parts.push(matches[1]);
+              if (matches[2]) {
+                extra = matches[3];
+                break;
+              }
+            }
+          } while (matches);
+          if (extra) {
+            parseChunks(extra, selectors);
+          }
+          selector = [];
+          for (i = 0; i < parts.length; i++) {
+            if (parts[i] !== '>') {
+              selector.push(compile(parts[i], [], parts[i - 1] === '>'));
+            }
+          }
+          selectors.push(selector);
+          return selectors;
+        }
+        this._selectors = parseChunks(selector, []);
+      },
+      match: function (control, selectors) {
+        var i, l, si, sl, selector, fi, fl, filters, index, length, siblings, count, item;
+        selectors = selectors || this._selectors;
+        for (i = 0, l = selectors.length; i < l; i++) {
+          selector = selectors[i];
+          sl = selector.length;
+          item = control;
+          count = 0;
+          for (si = sl - 1; si >= 0; si--) {
+            filters = selector[si];
+            while (item) {
+              if (filters.pseudo) {
+                siblings = item.parent().items();
+                index = length = siblings.length;
+                while (index--) {
+                  if (siblings[index] === item) {
+                    break;
+                  }
+                }
+              }
+              for (fi = 0, fl = filters.length; fi < fl; fi++) {
+                if (!filters[fi](item, index, length)) {
+                  fi = fl + 1;
+                  break;
+                }
+              }
+              if (fi === fl) {
+                count++;
+                break;
+              } else {
+                if (si === sl - 1) {
+                  break;
+                }
+              }
+              item = item.parent();
+            }
+          }
+          if (count === sl) {
+            return true;
+          }
+        }
+        return false;
+      },
+      find: function (container) {
+        var matches = [], i, l;
+        var selectors = this._selectors;
+        function collect(items, selector, index) {
+          var i, l, fi, fl, item;
+          var filters = selector[index];
+          for (i = 0, l = items.length; i < l; i++) {
+            item = items[i];
+            for (fi = 0, fl = filters.length; fi < fl; fi++) {
+              if (!filters[fi](item, i, l)) {
+                fi = fl + 1;
+                break;
+              }
+            }
+            if (fi === fl) {
+              if (index === selector.length - 1) {
+                matches.push(item);
+              } else {
+                if (item.items) {
+                  collect(item.items(), selector, index + 1);
+                }
+              }
+            } else if (filters.direct) {
+              return;
+            }
+            if (item.items) {
+              collect(item.items(), selector, index);
+            }
+          }
+        }
+        if (container.items) {
+          for (i = 0, l = selectors.length; i < l; i++) {
+            collect(container.items(), selectors[i], 0);
+          }
+          if (l > 1) {
+            matches = unique(matches);
+          }
+        }
+        if (!Collection) {
+          Collection = Selector.Collection;
+        }
+        return new Collection(matches);
+      }
+    });
+
+    var Collection$1, proto;
+    var push = Array.prototype.push, slice = Array.prototype.slice;
+    proto = {
+      length: 0,
+      init: function (items) {
+        if (items) {
+          this.add(items);
+        }
+      },
+      add: function (items) {
+        var self = this;
+        if (!global$4.isArray(items)) {
+          if (items instanceof Collection$1) {
+            self.add(items.toArray());
+          } else {
+            push.call(self, items);
+          }
+        } else {
+          push.apply(self, items);
+        }
+        return self;
+      },
+      set: function (items) {
+        var self = this;
+        var len = self.length;
+        var i;
+        self.length = 0;
+        self.add(items);
+        for (i = self.length; i < len; i++) {
+          delete self[i];
+        }
+        return self;
+      },
+      filter: function (selector) {
+        var self = this;
+        var i, l;
+        var matches = [];
+        var item, match;
+        if (typeof selector === 'string') {
+          selector = new Selector(selector);
+          match = function (item) {
+            return selector.match(item);
+          };
+        } else {
+          match = selector;
+        }
+        for (i = 0, l = self.length; i < l; i++) {
+          item = self[i];
+          if (match(item)) {
+            matches.push(item);
+          }
+        }
+        return new Collection$1(matches);
+      },
+      slice: function () {
+        return new Collection$1(slice.apply(this, arguments));
+      },
+      eq: function (index) {
+        return index === -1 ? this.slice(index) : this.slice(index, +index + 1);
+      },
+      each: function (callback) {
+        global$4.each(this, callback);
+        return this;
+      },
+      toArray: function () {
+        return global$4.toArray(this);
+      },
+      indexOf: function (ctrl) {
+        var self = this;
+        var i = self.length;
+        while (i--) {
+          if (self[i] === ctrl) {
+            break;
+          }
+        }
+        return i;
+      },
+      reverse: function () {
+        return new Collection$1(global$4.toArray(this).reverse());
+      },
+      hasClass: function (cls) {
+        return this[0] ? this[0].classes.contains(cls) : false;
+      },
+      prop: function (name, value) {
+        var self = this;
+        var item;
+        if (value !== undefined) {
+          self.each(function (item) {
+            if (item[name]) {
+              item[name](value);
+            }
+          });
+          return self;
+        }
+        item = self[0];
+        if (item && item[name]) {
+          return item[name]();
+        }
+      },
+      exec: function (name) {
+        var self = this, args = global$4.toArray(arguments).slice(1);
+        self.each(function (item) {
+          if (item[name]) {
+            item[name].apply(item, args);
+          }
+        });
+        return self;
+      },
+      remove: function () {
+        var i = this.length;
+        while (i--) {
+          this[i].remove();
+        }
+        return this;
+      },
+      addClass: function (cls) {
+        return this.each(function (item) {
+          item.classes.add(cls);
+        });
+      },
+      removeClass: function (cls) {
+        return this.each(function (item) {
+          item.classes.remove(cls);
+        });
+      }
+    };
+    global$4.each('fire on off show hide append prepend before after reflow'.split(' '), function (name) {
+      proto[name] = function () {
+        var args = global$4.toArray(arguments);
+        this.each(function (ctrl) {
+          if (name in ctrl) {
+            ctrl[name].apply(ctrl, args);
+          }
+        });
+        return this;
+      };
+    });
+    global$4.each('text name disabled active selected checked visible parent value data'.split(' '), function (name) {
+      proto[name] = function (value) {
+        return this.prop(name, value);
+      };
+    });
+    Collection$1 = global$8.extend(proto);
+    Selector.Collection = Collection$1;
+    var Collection$2 = Collection$1;
+
+    var Binding = function (settings) {
+      this.create = settings.create;
+    };
+    Binding.create = function (model, name) {
+      return new Binding({
+        create: function (otherModel, otherName) {
+          var bindings;
+          var fromSelfToOther = function (e) {
+            otherModel.set(otherName, e.value);
+          };
+          var fromOtherToSelf = function (e) {
+            model.set(name, e.value);
+          };
+          otherModel.on('change:' + otherName, fromOtherToSelf);
+          model.on('change:' + name, fromSelfToOther);
+          bindings = otherModel._bindings;
+          if (!bindings) {
+            bindings = otherModel._bindings = [];
+            otherModel.on('destroy', function () {
+              var i = bindings.length;
+              while (i--) {
+                bindings[i]();
+              }
+            });
+          }
+          bindings.push(function () {
+            model.off('change:' + name, fromSelfToOther);
+          });
+          return model.get(name);
+        }
+      });
+    };
+
+    var global$a = tinymce.util.Tools.resolve('tinymce.util.Observable');
+
+    function isNode(node) {
+      return node.nodeType > 0;
+    }
+    function isEqual(a, b) {
+      var k, checked;
+      if (a === b) {
+        return true;
+      }
+      if (a === null || b === null) {
+        return a === b;
+      }
+      if (typeof a !== 'object' || typeof b !== 'object') {
+        return a === b;
+      }
+      if (global$4.isArray(b)) {
+        if (a.length !== b.length) {
+          return false;
+        }
+        k = a.length;
+        while (k--) {
+          if (!isEqual(a[k], b[k])) {
+            return false;
+          }
+        }
+      }
+      if (isNode(a) || isNode(b)) {
+        return a === b;
+      }
+      checked = {};
+      for (k in b) {
+        if (!isEqual(a[k], b[k])) {
+          return false;
+        }
+        checked[k] = true;
+      }
+      for (k in a) {
+        if (!checked[k] && !isEqual(a[k], b[k])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    var ObservableObject = global$8.extend({
+      Mixins: [global$a],
+      init: function (data) {
+        var name, value;
+        data = data || {};
+        for (name in data) {
+          value = data[name];
+          if (value instanceof Binding) {
+            data[name] = value.create(this, name);
+          }
+        }
+        this.data = data;
+      },
+      set: function (name, value) {
+        var key, args;
+        var oldValue = this.data[name];
+        if (value instanceof Binding) {
+          value = value.create(this, name);
+        }
+        if (typeof name === 'object') {
+          for (key in name) {
+            this.set(key, name[key]);
+          }
+          return this;
+        }
+        if (!isEqual(oldValue, value)) {
+          this.data[name] = value;
+          args = {
+            target: this,
+            name: name,
+            value: value,
+            oldValue: oldValue
+          };
+          this.fire('change:' + name, args);
+          this.fire('change', args);
+        }
+        return this;
+      },
+      get: function (name) {
+        return this.data[name];
+      },
+      has: function (name) {
+        return name in this.data;
+      },
+      bind: function (name) {
+        return Binding.create(this, name);
+      },
+      destroy: function () {
+        this.fire('destroy');
+      }
+    });
+
+    var dirtyCtrls = {}, animationFrameRequested;
+    var ReflowQueue = {
+      add: function (ctrl) {
+        var parent = ctrl.parent();
+        if (parent) {
+          if (!parent._layout || parent._layout.isNative()) {
+            return;
+          }
+          if (!dirtyCtrls[parent._id]) {
+            dirtyCtrls[parent._id] = parent;
+          }
+          if (!animationFrameRequested) {
+            animationFrameRequested = true;
+            global$3.requestAnimationFrame(function () {
+              var id, ctrl;
+              animationFrameRequested = false;
+              for (id in dirtyCtrls) {
+                ctrl = dirtyCtrls[id];
+                if (ctrl.state.get('rendered')) {
+                  ctrl.reflow();
+                }
+              }
+              dirtyCtrls = {};
+            }, domGlobals.document.body);
+          }
+        }
+      },
+      remove: function (ctrl) {
+        if (dirtyCtrls[ctrl._id]) {
+          delete dirtyCtrls[ctrl._id];
+        }
+      }
+    };
+
+    var getUiContainerDelta = function (ctrl) {
+      var uiContainer = getUiContainer(ctrl);
+      if (uiContainer && global$2.DOM.getStyle(uiContainer, 'position', true) !== 'static') {
+        var containerPos = global$2.DOM.getPos(uiContainer);
+        var dx = uiContainer.scrollLeft - containerPos.x;
+        var dy = uiContainer.scrollTop - containerPos.y;
+        return Option.some({
+          x: dx,
+          y: dy
+        });
+      } else {
+        return Option.none();
+      }
+    };
+    var setUiContainer = function (editor, ctrl) {
+      var uiContainer = global$2.DOM.select(editor.settings.ui_container)[0];
+      ctrl.getRoot().uiContainer = uiContainer;
+    };
+    var getUiContainer = function (ctrl) {
+      return ctrl ? ctrl.getRoot().uiContainer : null;
+    };
+    var inheritUiContainer = function (fromCtrl, toCtrl) {
+      return toCtrl.uiContainer = getUiContainer(fromCtrl);
+    };
+    var UiContainer = {
+      getUiContainerDelta: getUiContainerDelta,
+      setUiContainer: setUiContainer,
+      getUiContainer: getUiContainer,
+      inheritUiContainer: inheritUiContainer
+    };
+
+    var hasMouseWheelEventSupport = 'onmousewheel' in domGlobals.document;
+    var hasWheelEventSupport = false;
+    var classPrefix = 'mce-';
+    var Control, idCounter = 0;
+    var proto$1 = {
+      Statics: { classPrefix: classPrefix },
+      isRtl: function () {
+        return Control.rtl;
+      },
+      classPrefix: classPrefix,
+      init: function (settings) {
+        var self = this;
+        var classes, defaultClasses;
+        function applyClasses(classes) {
+          var i;
+          classes = classes.split(' ');
+          for (i = 0; i < classes.length; i++) {
+            self.classes.add(classes[i]);
+          }
+        }
+        self.settings = settings = global$4.extend({}, self.Defaults, settings);
+        self._id = settings.id || 'mceu_' + idCounter++;
+        self._aria = { role: settings.role };
+        self._elmCache = {};
+        self.$ = global$7;
+        self.state = new ObservableObject({
+          visible: true,
+          active: false,
+          disabled: false,
+          value: ''
+        });
+        self.data = new ObservableObject(settings.data);
+        self.classes = new ClassList(function () {
+          if (self.state.get('rendered')) {
+            self.getEl().className = this.toString();
+          }
+        });
+        self.classes.prefix = self.classPrefix;
+        classes = settings.classes;
+        if (classes) {
+          if (self.Defaults) {
+            defaultClasses = self.Defaults.classes;
+            if (defaultClasses && classes !== defaultClasses) {
+              applyClasses(defaultClasses);
+            }
+          }
+          applyClasses(classes);
+        }
+        global$4.each('title text name visible disabled active value'.split(' '), function (name) {
+          if (name in settings) {
+            self[name](settings[name]);
+          }
+        });
+        self.on('click', function () {
+          if (self.disabled()) {
+            return false;
+          }
+        });
+        self.settings = settings;
+        self.borderBox = BoxUtils.parseBox(settings.border);
+        self.paddingBox = BoxUtils.parseBox(settings.padding);
+        self.marginBox = BoxUtils.parseBox(settings.margin);
+        if (settings.hidden) {
+          self.hide();
+        }
+      },
+      Properties: 'parent,name',
+      getContainerElm: function () {
+        var uiContainer = UiContainer.getUiContainer(this);
+        return uiContainer ? uiContainer : funcs.getContainer();
+      },
+      getParentCtrl: function (elm) {
+        var ctrl;
+        var lookup = this.getRoot().controlIdLookup;
+        while (elm && lookup) {
+          ctrl = lookup[elm.id];
+          if (ctrl) {
+            break;
+          }
+          elm = elm.parentNode;
+        }
+        return ctrl;
+      },
+      initLayoutRect: function () {
+        var self = this;
+        var settings = self.settings;
+        var borderBox, layoutRect;
+        var elm = self.getEl();
+        var width, height, minWidth, minHeight, autoResize;
+        var startMinWidth, startMinHeight, initialSize;
+        borderBox = self.borderBox = self.borderBox || BoxUtils.measureBox(elm, 'border');
+        self.paddingBox = self.paddingBox || BoxUtils.measureBox(elm, 'padding');
+        self.marginBox = self.marginBox || BoxUtils.measureBox(elm, 'margin');
+        initialSize = funcs.getSize(elm);
+        startMinWidth = settings.minWidth;
+        startMinHeight = settings.minHeight;
+        minWidth = startMinWidth || initialSize.width;
+        minHeight = startMinHeight || initialSize.height;
+        width = settings.width;
+        height = settings.height;
+        autoResize = settings.autoResize;
+        autoResize = typeof autoResize !== 'undefined' ? autoResize : !width && !height;
+        width = width || minWidth;
+        height = height || minHeight;
+        var deltaW = borderBox.left + borderBox.right;
+        var deltaH = borderBox.top + borderBox.bottom;
+        var maxW = settings.maxWidth || 65535;
+        var maxH = settings.maxHeight || 65535;
+        self._layoutRect = layoutRect = {
+          x: settings.x || 0,
+          y: settings.y || 0,
+          w: width,
+          h: height,
+          deltaW: deltaW,
+          deltaH: deltaH,
+          contentW: width - deltaW,
+          contentH: height - deltaH,
+          innerW: width - deltaW,
+          innerH: height - deltaH,
+          startMinWidth: startMinWidth || 0,
+          startMinHeight: startMinHeight || 0,
+          minW: Math.min(minWidth, maxW),
+          minH: Math.min(minHeight, maxH),
+          maxW: maxW,
+          maxH: maxH,
+          autoResize: autoResize,
+          scrollW: 0
+        };
+        self._lastLayoutRect = {};
+        return layoutRect;
+      },
+      layoutRect: function (newRect) {
+        var self = this;
+        var curRect = self._layoutRect, lastLayoutRect, size, deltaWidth, deltaHeight, repaintControls;
+        if (!curRect) {
+          curRect = self.initLayoutRect();
+        }
+        if (newRect) {
+          deltaWidth = curRect.deltaW;
+          deltaHeight = curRect.deltaH;
+          if (newRect.x !== undefined) {
+            curRect.x = newRect.x;
+          }
+          if (newRect.y !== undefined) {
+            curRect.y = newRect.y;
+          }
+          if (newRect.minW !== undefined) {
+            curRect.minW = newRect.minW;
+          }
+          if (newRect.minH !== undefined) {
+            curRect.minH = newRect.minH;
+          }
+          size = newRect.w;
+          if (size !== undefined) {
+            size = size < curRect.minW ? curRect.minW : size;
+            size = size > curRect.maxW ? curRect.maxW : size;
+            curRect.w = size;
+            curRect.innerW = size - deltaWidth;
+          }
+          size = newRect.h;
+          if (size !== undefined) {
+            size = size < curRect.minH ? curRect.minH : size;
+            size = size > curRect.maxH ? curRect.maxH : size;
+            curRect.h = size;
+            curRect.innerH = size - deltaHeight;
+          }
+          size = newRect.innerW;
+          if (size !== undefined) {
+            size = size < curRect.minW - deltaWidth ? curRect.minW - deltaWidth : size;
+            size = size > curRect.maxW - deltaWidth ? curRect.maxW - deltaWidth : size;
+            curRect.innerW = size;
+            curRect.w = size + deltaWidth;
+          }
+          size = newRect.innerH;
+          if (size !== undefined) {
+            size = size < curRect.minH - deltaHeight ? curRect.minH - deltaHeight : size;
+            size = size > curRect.maxH - deltaHeight ? curRect.maxH - deltaHeight : size;
+            curRect.innerH = size;
+            curRect.h = size + deltaHeight;
+          }
+          if (newRect.contentW !== undefined) {
+            curRect.contentW = newRect.contentW;
+          }
+          if (newRect.contentH !== undefined) {
+            curRect.contentH = newRect.contentH;
+          }
+          lastLayoutRect = self._lastLayoutRect;
+          if (lastLayoutRect.x !== curRect.x || lastLayoutRect.y !== curRect.y || lastLayoutRect.w !== curRect.w || lastLayoutRect.h !== curRect.h) {
+            repaintControls = Control.repaintControls;
+            if (repaintControls) {
+              if (repaintControls.map && !repaintControls.map[self._id]) {
+                repaintControls.push(self);
+                repaintControls.map[self._id] = true;
+              }
+            }
+            lastLayoutRect.x = curRect.x;
+            lastLayoutRect.y = curRect.y;
+            lastLayoutRect.w = curRect.w;
+            lastLayoutRect.h = curRect.h;
+          }
+          return self;
+        }
+        return curRect;
+      },
+      repaint: function () {
+        var self = this;
+        var style, bodyStyle, bodyElm, rect, borderBox;
+        var borderW, borderH, lastRepaintRect, round, value;
+        round = !domGlobals.document.createRange ? Math.round : function (value) {
+          return value;
+        };
+        style = self.getEl().style;
+        rect = self._layoutRect;
+        lastRepaintRect = self._lastRepaintRect || {};
+        borderBox = self.borderBox;
+        borderW = borderBox.left + borderBox.right;
+        borderH = borderBox.top + borderBox.bottom;
+        if (rect.x !== lastRepaintRect.x) {
+          style.left = round(rect.x) + 'px';
+          lastRepaintRect.x = rect.x;
+        }
+        if (rect.y !== lastRepaintRect.y) {
+          style.top = round(rect.y) + 'px';
+          lastRepaintRect.y = rect.y;
+        }
+        if (rect.w !== lastRepaintRect.w) {
+          value = round(rect.w - borderW);
+          style.width = (value >= 0 ? value : 0) + 'px';
+          lastRepaintRect.w = rect.w;
+        }
+        if (rect.h !== lastRepaintRect.h) {
+          value = round(rect.h - borderH);
+          style.height = (value >= 0 ? value : 0) + 'px';
+          lastRepaintRect.h = rect.h;
+        }
+        if (self._hasBody && rect.innerW !== lastRepaintRect.innerW) {
+          value = round(rect.innerW);
+          bodyElm = self.getEl('body');
+          if (bodyElm) {
+            bodyStyle = bodyElm.style;
+            bodyStyle.width = (value >= 0 ? value : 0) + 'px';
+          }
+          lastRepaintRect.innerW = rect.innerW;
+        }
+        if (self._hasBody && rect.innerH !== lastRepaintRect.innerH) {
+          value = round(rect.innerH);
+          bodyElm = bodyElm || self.getEl('body');
+          if (bodyElm) {
+            bodyStyle = bodyStyle || bodyElm.style;
+            bodyStyle.height = (value >= 0 ? value : 0) + 'px';
+          }
+          lastRepaintRect.innerH = rect.innerH;
+        }
+        self._lastRepaintRect = lastRepaintRect;
+        self.fire('repaint', {}, false);
+      },
+      updateLayoutRect: function () {
+        var self = this;
+        self.parent()._lastRect = null;
+        funcs.css(self.getEl(), {
+          width: '',
+          height: ''
+        });
+        self._layoutRect = self._lastRepaintRect = self._lastLayoutRect = null;
+        self.initLayoutRect();
+      },
+      on: function (name, callback) {
+        var self = this;
+        function resolveCallbackName(name) {
+          var callback, scope;
+          if (typeof name !== 'string') {
+            return name;
+          }
+          return function (e) {
+            if (!callback) {
+              self.parentsAndSelf().each(function (ctrl) {
+                var callbacks = ctrl.settings.callbacks;
+                if (callbacks && (callback = callbacks[name])) {
+                  scope = ctrl;
+                  return false;
+                }
+              });
+            }
+            if (!callback) {
+              e.action = name;
+              this.fire('execute', e);
+              return;
+            }
+            return callback.call(scope, e);
+          };
+        }
+        getEventDispatcher(self).on(name, resolveCallbackName(callback));
+        return self;
+      },
+      off: function (name, callback) {
+        getEventDispatcher(this).off(name, callback);
+        return this;
+      },
+      fire: function (name, args, bubble) {
+        var self = this;
+        args = args || {};
+        if (!args.control) {
+          args.control = self;
+        }
+        args = getEventDispatcher(self).fire(name, args);
+        if (bubble !== false && self.parent) {
+          var parent = self.parent();
+          while (parent && !args.isPropagationStopped()) {
+            parent.fire(name, args, false);
+            parent = parent.parent();
+          }
+        }
+        return args;
+      },
+      hasEventListeners: function (name) {
+        return getEventDispatcher(this).has(name);
+      },
+      parents: function (selector) {
+        var self = this;
+        var ctrl, parents = new Collection$2();
+        for (ctrl = self.parent(); ctrl; ctrl = ctrl.parent()) {
+          parents.add(ctrl);
+        }
+        if (selector) {
+          parents = parents.filter(selector);
+        }
+        return parents;
+      },
+      parentsAndSelf: function (selector) {
+        return new Collection$2(this).add(this.parents(selector));
+      },
+      next: function () {
+        var parentControls = this.parent().items();
+        return parentControls[parentControls.indexOf(this) + 1];
+      },
+      prev: function () {
+        var parentControls = this.parent().items();
+        return parentControls[parentControls.indexOf(this) - 1];
+      },
+      innerHtml: function (html) {
+        this.$el.html(html);
+        return this;
+      },
+      getEl: function (suffix) {
+        var id = suffix ? this._id + '-' + suffix : this._id;
+        if (!this._elmCache[id]) {
+          this._elmCache[id] = global$7('#' + id)[0];
+        }
+        return this._elmCache[id];
+      },
+      show: function () {
+        return this.visible(true);
+      },
+      hide: function () {
+        return this.visible(false);
+      },
+      focus: function () {
+        try {
+          this.getEl().focus();
+        } catch (ex) {
+        }
+        return this;
+      },
+      blur: function () {
+        this.getEl().blur();
+        return this;
+      },
+      aria: function (name, value) {
+        var self = this, elm = self.getEl(self.ariaTarget);
+        if (typeof value === 'undefined') {
+          return self._aria[name];
+        }
+        self._aria[name] = value;
+        if (self.state.get('rendered')) {
+          elm.setAttribute(name === 'role' ? name : 'aria-' + name, value);
+        }
+        return self;
+      },
+      encode: function (text, translate) {
+        if (translate !== false) {
+          text = this.translate(text);
+        }
+        return (text || '').replace(/[&<>"]/g, function (match) {
+          return '&#' + match.charCodeAt(0) + ';';
+        });
+      },
+      translate: function (text) {
+        return Control.translate ? Control.translate(text) : text;
+      },
+      before: function (items) {
+        var self = this, parent = self.parent();
+        if (parent) {
+          parent.insert(items, parent.items().indexOf(self), true);
+        }
+        return self;
+      },
+      after: function (items) {
+        var self = this, parent = self.parent();
+        if (parent) {
+          parent.insert(items, parent.items().indexOf(self));
+        }
+        return self;
+      },
+      remove: function () {
+        var self = this;
+        var elm = self.getEl();
+        var parent = self.parent();
+        var newItems, i;
+        if (self.items) {
+          var controls = self.items().toArray();
+          i = controls.length;
+          while (i--) {
+            controls[i].remove();
+          }
+        }
+        if (parent && parent.items) {
+          newItems = [];
+          parent.items().each(function (item) {
+            if (item !== self) {
+              newItems.push(item);
+            }
+          });
+          parent.items().set(newItems);
+          parent._lastRect = null;
+        }
+        if (self._eventsRoot && self._eventsRoot === self) {
+          global$7(elm).off();
+        }
+        var lookup = self.getRoot().controlIdLookup;
+        if (lookup) {
+          delete lookup[self._id];
+        }
+        if (elm && elm.parentNode) {
+          elm.parentNode.removeChild(elm);
+        }
+        self.state.set('rendered', false);
+        self.state.destroy();
+        self.fire('remove');
+        return self;
+      },
+      renderBefore: function (elm) {
+        global$7(elm).before(this.renderHtml());
+        this.postRender();
+        return this;
+      },
+      renderTo: function (elm) {
+        global$7(elm || this.getContainerElm()).append(this.renderHtml());
+        this.postRender();
+        return this;
+      },
+      preRender: function () {
+      },
+      render: function () {
+      },
+      renderHtml: function () {
+        return '<div id="' + this._id + '" class="' + this.classes + '"></div>';
+      },
+      postRender: function () {
+        var self = this;
+        var settings = self.settings;
+        var elm, box, parent, name, parentEventsRoot;
+        self.$el = global$7(self.getEl());
+        self.state.set('rendered', true);
+        for (name in settings) {
+          if (name.indexOf('on') === 0) {
+            self.on(name.substr(2), settings[name]);
+          }
+        }
+        if (self._eventsRoot) {
+          for (parent = self.parent(); !parentEventsRoot && parent; parent = parent.parent()) {
+            parentEventsRoot = parent._eventsRoot;
+          }
+          if (parentEventsRoot) {
+            for (name in parentEventsRoot._nativeEvents) {
+              self._nativeEvents[name] = true;
+            }
+          }
+        }
+        bindPendingEvents(self);
+        if (settings.style) {
+          elm = self.getEl();
+          if (elm) {
+            elm.setAttribute('style', settings.style);
+            elm.style.cssText = settings.style;
+          }
+        }
+        if (self.settings.border) {
+          box = self.borderBox;
+          self.$el.css({
+            'border-top-width': box.top,
+            'border-right-width': box.right,
+            'border-bottom-width': box.bottom,
+            'border-left-width': box.left
+          });
+        }
+        var root = self.getRoot();
+        if (!root.controlIdLookup) {
+          root.controlIdLookup = {};
+        }
+        root.controlIdLookup[self._id] = self;
+        for (var key in self._aria) {
+          self.aria(key, self._aria[key]);
+        }
+        if (self.state.get('visible') === false) {
+          self.getEl().style.display = 'none';
+        }
+        self.bindStates();
+        self.state.on('change:visible', function (e) {
+          var state = e.value;
+          var parentCtrl;
+          if (self.state.get('rendered')) {
+            self.getEl().style.display = state === false ? 'none' : '';
+            self.getEl().getBoundingClientRect();
+          }
+          parentCtrl = self.parent();
+          if (parentCtrl) {
+            parentCtrl._lastRect = null;
+          }
+          self.fire(state ? 'show' : 'hide');
+          ReflowQueue.add(self);
+        });
+        self.fire('postrender', {}, false);
+      },
+      bindStates: function () {
+      },
+      scrollIntoView: function (align) {
+        function getOffset(elm, rootElm) {
+          var x, y, parent = elm;
+          x = y = 0;
+          while (parent && parent !== rootElm && parent.nodeType) {
+            x += parent.offsetLeft || 0;
+            y += parent.offsetTop || 0;
+            parent = parent.offsetParent;
+          }
+          return {
+            x: x,
+            y: y
+          };
+        }
+        var elm = this.getEl(), parentElm = elm.parentNode;
+        var x, y, width, height, parentWidth, parentHeight;
+        var pos = getOffset(elm, parentElm);
+        x = pos.x;
+        y = pos.y;
+        width = elm.offsetWidth;
+        height = elm.offsetHeight;
+        parentWidth = parentElm.clientWidth;
+        parentHeight = parentElm.clientHeight;
+        if (align === 'end') {
+          x -= parentWidth - width;
+          y -= parentHeight - height;
+        } else if (align === 'center') {
+          x -= parentWidth / 2 - width / 2;
+          y -= parentHeight / 2 - height / 2;
+        }
+        parentElm.scrollLeft = x;
+        parentElm.scrollTop = y;
+        return this;
+      },
+      getRoot: function () {
+        var ctrl = this, rootControl;
+        var parents = [];
+        while (ctrl) {
+          if (ctrl.rootControl) {
+            rootControl = ctrl.rootControl;
+            break;
+          }
+          parents.push(ctrl);
+          rootControl = ctrl;
+          ctrl = ctrl.parent();
+        }
+        if (!rootControl) {
+          rootControl = this;
+        }
+        var i = parents.length;
+        while (i--) {
+          parents[i].rootControl = rootControl;
+        }
+        return rootControl;
+      },
+      reflow: function () {
+        ReflowQueue.remove(this);
+        var parent = this.parent();
+        if (parent && parent._layout && !parent._layout.isNative()) {
+          parent.reflow();
+        }
+        return this;
+      }
+    };
+    global$4.each('text title visible disabled active value'.split(' '), function (name) {
+      proto$1[name] = function (value) {
+        if (arguments.length === 0) {
+          return this.state.get(name);
+        }
+        if (typeof value !== 'undefined') {
+          this.state.set(name, value);
+        }
+        return this;
+      };
+    });
+    Control = global$8.extend(proto$1);
+    function getEventDispatcher(obj) {
+      if (!obj._eventDispatcher) {
+        obj._eventDispatcher = new global$9({
+          scope: obj,
+          toggleEvent: function (name, state) {
+            if (state && global$9.isNative(name)) {
+              if (!obj._nativeEvents) {
+                obj._nativeEvents = {};
+              }
+              obj._nativeEvents[name] = true;
+              if (obj.state.get('rendered')) {
+                bindPendingEvents(obj);
+              }
+            }
+          }
+        });
+      }
+      return obj._eventDispatcher;
+    }
+    function bindPendingEvents(eventCtrl) {
+      var i, l, parents, eventRootCtrl, nativeEvents, name;
+      function delegate(e) {
+        var control = eventCtrl.getParentCtrl(e.target);
+        if (control) {
+          control.fire(e.type, e);
+        }
+      }
+      function mouseLeaveHandler() {
+        var ctrl = eventRootCtrl._lastHoverCtrl;
+        if (ctrl) {
+          ctrl.fire('mouseleave', { target: ctrl.getEl() });
+          ctrl.parents().each(function (ctrl) {
+            ctrl.fire('mouseleave', { target: ctrl.getEl() });
+          });
+          eventRootCtrl._lastHoverCtrl = null;
+        }
+      }
+      function mouseEnterHandler(e) {
+        var ctrl = eventCtrl.getParentCtrl(e.target), lastCtrl = eventRootCtrl._lastHoverCtrl, idx = 0, i, parents, lastParents;
+        if (ctrl !== lastCtrl) {
+          eventRootCtrl._lastHoverCtrl = ctrl;
+          parents = ctrl.parents().toArray().reverse();
+          parents.push(ctrl);
+          if (lastCtrl) {
+            lastParents = lastCtrl.parents().toArray().reverse();
+            lastParents.push(lastCtrl);
+            for (idx = 0; idx < lastParents.length; idx++) {
+              if (parents[idx] !== lastParents[idx]) {
+                break;
+              }
+            }
+            for (i = lastParents.length - 1; i >= idx; i--) {
+              lastCtrl = lastParents[i];
+              lastCtrl.fire('mouseleave', { target: lastCtrl.getEl() });
+            }
+          }
+          for (i = idx; i < parents.length; i++) {
+            ctrl = parents[i];
+            ctrl.fire('mouseenter', { target: ctrl.getEl() });
+          }
+        }
+      }
+      function fixWheelEvent(e) {
+        e.preventDefault();
+        if (e.type === 'mousewheel') {
+          e.deltaY = -1 / 40 * e.wheelDelta;
+          if (e.wheelDeltaX) {
+            e.deltaX = -1 / 40 * e.wheelDeltaX;
+          }
+        } else {
+          e.deltaX = 0;
+          e.deltaY = e.detail;
+        }
+        e = eventCtrl.fire('wheel', e);
+      }
+      nativeEvents = eventCtrl._nativeEvents;
+      if (nativeEvents) {
+        parents = eventCtrl.parents().toArray();
+        parents.unshift(eventCtrl);
+        for (i = 0, l = parents.length; !eventRootCtrl && i < l; i++) {
+          eventRootCtrl = parents[i]._eventsRoot;
+        }
+        if (!eventRootCtrl) {
+          eventRootCtrl = parents[parents.length - 1] || eventCtrl;
+        }
+        eventCtrl._eventsRoot = eventRootCtrl;
+        for (l = i, i = 0; i < l; i++) {
+          parents[i]._eventsRoot = eventRootCtrl;
+        }
+        var eventRootDelegates = eventRootCtrl._delegates;
+        if (!eventRootDelegates) {
+          eventRootDelegates = eventRootCtrl._delegates = {};
+        }
+        for (name in nativeEvents) {
+          if (!nativeEvents) {
+            return false;
+          }
+          if (name === 'wheel' && !hasWheelEventSupport) {
+            if (hasMouseWheelEventSupport) {
+              global$7(eventCtrl.getEl()).on('mousewheel', fixWheelEvent);
+            } else {
+              global$7(eventCtrl.getEl()).on('DOMMouseScroll', fixWheelEvent);
+            }
+            continue;
+          }
+          if (name === 'mouseenter' || name === 'mouseleave') {
+            if (!eventRootCtrl._hasMouseEnter) {
+              global$7(eventRootCtrl.getEl()).on('mouseleave', mouseLeaveHandler).on('mouseover', mouseEnterHandler);
+              eventRootCtrl._hasMouseEnter = 1;
+            }
+          } else if (!eventRootDelegates[name]) {
+            global$7(eventRootCtrl.getEl()).on(name, delegate);
+            eventRootDelegates[name] = true;
+          }
+          nativeEvents[name] = false;
+        }
+      }
+    }
+    var Control$1 = Control;
+
+    var isStatic = function (elm) {
+      return funcs.getRuntimeStyle(elm, 'position') === 'static';
+    };
+    var isFixed = function (ctrl) {
+      return ctrl.state.get('fixed');
+    };
+    function calculateRelativePosition(ctrl, targetElm, rel) {
+      var ctrlElm, pos, x, y, selfW, selfH, targetW, targetH, viewport, size;
+      viewport = getWindowViewPort();
+      pos = funcs.getPos(targetElm, UiContainer.getUiContainer(ctrl));
+      x = pos.x;
+      y = pos.y;
+      if (isFixed(ctrl) && isStatic(domGlobals.document.body)) {
+        x -= viewport.x;
+        y -= viewport.y;
+      }
+      ctrlElm = ctrl.getEl();
+      size = funcs.getSize(ctrlElm);
+      selfW = size.width;
+      selfH = size.height;
+      size = funcs.getSize(targetElm);
+      targetW = size.width;
+      targetH = size.height;
+      rel = (rel || '').split('');
+      if (rel[0] === 'b') {
+        y += targetH;
+      }
+      if (rel[1] === 'r') {
+        x += targetW;
+      }
+      if (rel[0] === 'c') {
+        y += Math.round(targetH / 2);
+      }
+      if (rel[1] === 'c') {
+        x += Math.round(targetW / 2);
+      }
+      if (rel[3] === 'b') {
+        y -= selfH;
+      }
+      if (rel[4] === 'r') {
+        x -= selfW;
+      }
+      if (rel[3] === 'c') {
+        y -= Math.round(selfH / 2);
+      }
+      if (rel[4] === 'c') {
+        x -= Math.round(selfW / 2);
+      }
+      return {
+        x: x,
+        y: y,
+        w: selfW,
+        h: selfH
+      };
+    }
+    var getUiContainerViewPort = function (customUiContainer) {
+      return {
+        x: 0,
+        y: 0,
+        w: customUiContainer.scrollWidth - 1,
+        h: customUiContainer.scrollHeight - 1
+      };
+    };
+    var getWindowViewPort = function () {
+      var win = domGlobals.window;
+      var x = Math.max(win.pageXOffset, domGlobals.document.body.scrollLeft, domGlobals.document.documentElement.scrollLeft);
+      var y = Math.max(win.pageYOffset, domGlobals.document.body.scrollTop, domGlobals.document.documentElement.scrollTop);
+      var w = win.innerWidth || domGlobals.document.documentElement.clientWidth;
+      var h = win.innerHeight || domGlobals.document.documentElement.clientHeight;
+      return {
+        x: x,
+        y: y,
+        w: w,
+        h: h
+      };
+    };
+    var getViewPortRect = function (ctrl) {
+      var customUiContainer = UiContainer.getUiContainer(ctrl);
+      return customUiContainer && !isFixed(ctrl) ? getUiContainerViewPort(customUiContainer) : getWindowViewPort();
+    };
+    var Movable = {
+      testMoveRel: function (elm, rels) {
+        var viewPortRect = getViewPortRect(this);
+        for (var i = 0; i < rels.length; i++) {
+          var pos = calculateRelativePosition(this, elm, rels[i]);
+          if (isFixed(this)) {
+            if (pos.x > 0 && pos.x + pos.w < viewPortRect.w && pos.y > 0 && pos.y + pos.h < viewPortRect.h) {
+              return rels[i];
+            }
+          } else {
+            if (pos.x > viewPortRect.x && pos.x + pos.w < viewPortRect.w + viewPortRect.x && pos.y > viewPortRect.y && pos.y + pos.h < viewPortRect.h + viewPortRect.y) {
+              return rels[i];
+            }
+          }
+        }
+        return rels[0];
+      },
+      moveRel: function (elm, rel) {
+        if (typeof rel !== 'string') {
+          rel = this.testMoveRel(elm, rel);
+        }
+        var pos = calculateRelativePosition(this, elm, rel);
+        return this.moveTo(pos.x, pos.y);
+      },
+      moveBy: function (dx, dy) {
+        var self = this, rect = self.layoutRect();
+        self.moveTo(rect.x + dx, rect.y + dy);
+        return self;
+      },
+      moveTo: function (x, y) {
+        var self = this;
+        function constrain(value, max, size) {
+          if (value < 0) {
+            return 0;
+          }
+          if (value + size > max) {
+            value = max - size;
+            return value < 0 ? 0 : value;
+          }
+          return value;
+        }
+        if (self.settings.constrainToViewport) {
+          var viewPortRect = getViewPortRect(this);
+          var layoutRect = self.layoutRect();
+          x = constrain(x, viewPortRect.w + viewPortRect.x, layoutRect.w);
+          y = constrain(y, viewPortRect.h + viewPortRect.y, layoutRect.h);
+        }
+        var uiContainer = UiContainer.getUiContainer(self);
+        if (uiContainer && isStatic(uiContainer) && !isFixed(self)) {
+          x -= uiContainer.scrollLeft;
+          y -= uiContainer.scrollTop;
+        }
+        if (uiContainer) {
+          x += 1;
+          y += 1;
+        }
+        if (self.state.get('rendered')) {
+          self.layoutRect({
+            x: x,
+            y: y
+          }).repaint();
+        } else {
+          self.settings.x = x;
+          self.settings.y = y;
+        }
+        self.fire('move', {
+          x: x,
+          y: y
+        });
+        return self;
+      }
+    };
+
+    var Tooltip = Control$1.extend({
+      Mixins: [Movable],
+      Defaults: { classes: 'widget tooltip tooltip-n' },
+      renderHtml: function () {
+        var self = this, prefix = self.classPrefix;
+        return '<div id="' + self._id + '" class="' + self.classes + '" role="presentation">' + '<div class="' + prefix + 'tooltip-arrow"></div>' + '<div class="' + prefix + 'tooltip-inner">' + self.encode(self.state.get('text')) + '</div>' + '</div>';
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:text', function (e) {
+          self.getEl().lastChild.innerHTML = self.encode(e.value);
+        });
+        return self._super();
+      },
+      repaint: function () {
+        var self = this;
+        var style, rect;
+        style = self.getEl().style;
+        rect = self._layoutRect;
+        style.left = rect.x + 'px';
+        style.top = rect.y + 'px';
+        style.zIndex = 65535 + 65535;
+      }
+    });
+
+    var Widget = Control$1.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        settings = self.settings;
+        self.canFocus = true;
+        if (settings.tooltip && Widget.tooltips !== false) {
+          self.on('mouseenter', function (e) {
+            var tooltip = self.tooltip().moveTo(-65535);
+            if (e.control === self) {
+              var rel = tooltip.text(settings.tooltip).show().testMoveRel(self.getEl(), [
+                'bc-tc',
+                'bc-tl',
+                'bc-tr'
+              ]);
+              tooltip.classes.toggle('tooltip-n', rel === 'bc-tc');
+              tooltip.classes.toggle('tooltip-nw', rel === 'bc-tl');
+              tooltip.classes.toggle('tooltip-ne', rel === 'bc-tr');
+              tooltip.moveRel(self.getEl(), rel);
+            } else {
+              tooltip.hide();
+            }
+          });
+          self.on('mouseleave mousedown click', function () {
+            self.tooltip().remove();
+            self._tooltip = null;
+          });
+        }
+        self.aria('label', settings.ariaLabel || settings.tooltip);
+      },
+      tooltip: function () {
+        if (!this._tooltip) {
+          this._tooltip = new Tooltip({ type: 'tooltip' });
+          UiContainer.inheritUiContainer(this, this._tooltip);
+          this._tooltip.renderTo();
+        }
+        return this._tooltip;
+      },
+      postRender: function () {
+        var self = this, settings = self.settings;
+        self._super();
+        if (!self.parent() && (settings.width || settings.height)) {
+          self.initLayoutRect();
+          self.repaint();
+        }
+        if (settings.autofocus) {
+          self.focus();
+        }
+      },
+      bindStates: function () {
+        var self = this;
+        function disable(state) {
+          self.aria('disabled', state);
+          self.classes.toggle('disabled', state);
+        }
+        function active(state) {
+          self.aria('pressed', state);
+          self.classes.toggle('active', state);
+        }
+        self.state.on('change:disabled', function (e) {
+          disable(e.value);
+        });
+        self.state.on('change:active', function (e) {
+          active(e.value);
+        });
+        if (self.state.get('disabled')) {
+          disable(true);
+        }
+        if (self.state.get('active')) {
+          active(true);
+        }
+        return self._super();
+      },
+      remove: function () {
+        this._super();
+        if (this._tooltip) {
+          this._tooltip.remove();
+          this._tooltip = null;
+        }
+      }
+    });
+
+    var Progress = Widget.extend({
+      Defaults: { value: 0 },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.classes.add('progress');
+        if (!self.settings.filter) {
+          self.settings.filter = function (value) {
+            return Math.round(value);
+          };
+        }
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = this.classPrefix;
+        return '<div id="' + id + '" class="' + self.classes + '">' + '<div class="' + prefix + 'bar-container">' + '<div class="' + prefix + 'bar"></div>' + '</div>' + '<div class="' + prefix + 'text">0%</div>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        self._super();
+        self.value(self.settings.value);
+        return self;
+      },
+      bindStates: function () {
+        var self = this;
+        function setValue(value) {
+          value = self.settings.filter(value);
+          self.getEl().lastChild.innerHTML = value + '%';
+          self.getEl().firstChild.firstChild.style.width = value + '%';
+        }
+        self.state.on('change:value', function (e) {
+          setValue(e.value);
+        });
+        setValue(self.state.get('value'));
+        return self._super();
+      }
+    });
+
+    var updateLiveRegion = function (ctx, text) {
+      ctx.getEl().lastChild.textContent = text + (ctx.progressBar ? ' ' + ctx.progressBar.value() + '%' : '');
+    };
+    var Notification = Control$1.extend({
+      Mixins: [Movable],
+      Defaults: { classes: 'widget notification' },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.maxWidth = settings.maxWidth;
+        if (settings.text) {
+          self.text(settings.text);
+        }
+        if (settings.icon) {
+          self.icon = settings.icon;
+        }
+        if (settings.color) {
+          self.color = settings.color;
+        }
+        if (settings.type) {
+          self.classes.add('notification-' + settings.type);
+        }
+        if (settings.timeout && (settings.timeout < 0 || settings.timeout > 0) && !settings.closeButton) {
+          self.closeButton = false;
+        } else {
+          self.classes.add('has-close');
+          self.closeButton = true;
+        }
+        if (settings.progressBar) {
+          self.progressBar = new Progress();
+        }
+        self.on('click', function (e) {
+          if (e.target.className.indexOf(self.classPrefix + 'close') !== -1) {
+            self.close();
+          }
+        });
+      },
+      renderHtml: function () {
+        var self = this;
+        var prefix = self.classPrefix;
+        var icon = '', closeButton = '', progressBar = '', notificationStyle = '';
+        if (self.icon) {
+          icon = '<i class="' + prefix + 'ico' + ' ' + prefix + 'i-' + self.icon + '"></i>';
+        }
+        notificationStyle = ' style="max-width: ' + self.maxWidth + 'px;' + (self.color ? 'background-color: ' + self.color + ';"' : '"');
+        if (self.closeButton) {
+          closeButton = '<button type="button" class="' + prefix + 'close" aria-hidden="true">\xD7</button>';
+        }
+        if (self.progressBar) {
+          progressBar = self.progressBar.renderHtml();
+        }
+        return '<div id="' + self._id + '" class="' + self.classes + '"' + notificationStyle + ' role="presentation">' + icon + '<div class="' + prefix + 'notification-inner">' + self.state.get('text') + '</div>' + progressBar + closeButton + '<div style="clip: rect(1px, 1px, 1px, 1px);height: 1px;overflow: hidden;position: absolute;width: 1px;"' + ' aria-live="assertive" aria-relevant="additions" aria-atomic="true"></div>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        global$3.setTimeout(function () {
+          self.$el.addClass(self.classPrefix + 'in');
+          updateLiveRegion(self, self.state.get('text'));
+        }, 100);
+        return self._super();
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:text', function (e) {
+          self.getEl().firstChild.innerHTML = e.value;
+          updateLiveRegion(self, e.value);
+        });
+        if (self.progressBar) {
+          self.progressBar.bindStates();
+          self.progressBar.state.on('change:value', function (e) {
+            updateLiveRegion(self, self.state.get('text'));
+          });
+        }
+        return self._super();
+      },
+      close: function () {
+        var self = this;
+        if (!self.fire('close').isDefaultPrevented()) {
+          self.remove();
+        }
+        return self;
+      },
+      repaint: function () {
+        var self = this;
+        var style, rect;
+        style = self.getEl().style;
+        rect = self._layoutRect;
+        style.left = rect.x + 'px';
+        style.top = rect.y + 'px';
+        style.zIndex = 65535 - 1;
+      }
+    });
+
+    function NotificationManagerImpl (editor) {
+      var getEditorContainer = function (editor) {
+        return editor.inline ? editor.getElement() : editor.getContentAreaContainer();
+      };
+      var getContainerWidth = function () {
+        var container = getEditorContainer(editor);
+        return funcs.getSize(container).width;
+      };
+      var prePositionNotifications = function (notifications) {
+        each(notifications, function (notification) {
+          notification.moveTo(0, 0);
+        });
+      };
+      var positionNotifications = function (notifications) {
+        if (notifications.length > 0) {
+          var firstItem = notifications.slice(0, 1)[0];
+          var container = getEditorContainer(editor);
+          firstItem.moveRel(container, 'tc-tc');
+          each(notifications, function (notification, index) {
+            if (index > 0) {
+              notification.moveRel(notifications[index - 1].getEl(), 'bc-tc');
+            }
+          });
+        }
+      };
+      var reposition = function (notifications) {
+        prePositionNotifications(notifications);
+        positionNotifications(notifications);
+      };
+      var open = function (args, closeCallback) {
+        var extendedArgs = global$4.extend(args, { maxWidth: getContainerWidth() });
+        var notif = new Notification(extendedArgs);
+        notif.args = extendedArgs;
+        if (extendedArgs.timeout > 0) {
+          notif.timer = setTimeout(function () {
+            notif.close();
+            closeCallback();
+          }, extendedArgs.timeout);
+        }
+        notif.on('close', function () {
+          closeCallback();
+        });
+        notif.renderTo();
+        return notif;
+      };
+      var close = function (notification) {
+        notification.close();
+      };
+      var getArgs = function (notification) {
+        return notification.args;
+      };
+      return {
+        open: open,
+        close: close,
+        reposition: reposition,
+        getArgs: getArgs
+      };
+    }
+
+    function getDocumentSize(doc) {
+      var documentElement, body, scrollWidth, clientWidth;
+      var offsetWidth, scrollHeight, clientHeight, offsetHeight;
+      var max = Math.max;
+      documentElement = doc.documentElement;
+      body = doc.body;
+      scrollWidth = max(documentElement.scrollWidth, body.scrollWidth);
+      clientWidth = max(documentElement.clientWidth, body.clientWidth);
+      offsetWidth = max(documentElement.offsetWidth, body.offsetWidth);
+      scrollHeight = max(documentElement.scrollHeight, body.scrollHeight);
+      clientHeight = max(documentElement.clientHeight, body.clientHeight);
+      offsetHeight = max(documentElement.offsetHeight, body.offsetHeight);
+      return {
+        width: scrollWidth < offsetWidth ? clientWidth : scrollWidth,
+        height: scrollHeight < offsetHeight ? clientHeight : scrollHeight
+      };
+    }
+    function updateWithTouchData(e) {
+      var keys, i;
+      if (e.changedTouches) {
+        keys = 'screenX screenY pageX pageY clientX clientY'.split(' ');
+        for (i = 0; i < keys.length; i++) {
+          e[keys[i]] = e.changedTouches[0][keys[i]];
+        }
+      }
+    }
+    function DragHelper (id, settings) {
+      var $eventOverlay;
+      var doc = settings.document || domGlobals.document;
+      var downButton;
+      var start, stop, drag, startX, startY;
+      settings = settings || {};
+      var handleElement = doc.getElementById(settings.handle || id);
+      start = function (e) {
+        var docSize = getDocumentSize(doc);
+        var handleElm, cursor;
+        updateWithTouchData(e);
+        e.preventDefault();
+        downButton = e.button;
+        handleElm = handleElement;
+        startX = e.screenX;
+        startY = e.screenY;
+        if (domGlobals.window.getComputedStyle) {
+          cursor = domGlobals.window.getComputedStyle(handleElm, null).getPropertyValue('cursor');
+        } else {
+          cursor = handleElm.runtimeStyle.cursor;
+        }
+        $eventOverlay = global$7('<div></div>').css({
+          position: 'absolute',
+          top: 0,
+          left: 0,
+          width: docSize.width,
+          height: docSize.height,
+          zIndex: 2147483647,
+          opacity: 0.0001,
+          cursor: cursor
+        }).appendTo(doc.body);
+        global$7(doc).on('mousemove touchmove', drag).on('mouseup touchend', stop);
+        settings.start(e);
+      };
+      drag = function (e) {
+        updateWithTouchData(e);
+        if (e.button !== downButton) {
+          return stop(e);
+        }
+        e.deltaX = e.screenX - startX;
+        e.deltaY = e.screenY - startY;
+        e.preventDefault();
+        settings.drag(e);
+      };
+      stop = function (e) {
+        updateWithTouchData(e);
+        global$7(doc).off('mousemove touchmove', drag).off('mouseup touchend', stop);
+        $eventOverlay.remove();
+        if (settings.stop) {
+          settings.stop(e);
+        }
+      };
+      this.destroy = function () {
+        global$7(handleElement).off();
+      };
+      global$7(handleElement).on('mousedown touchstart', start);
+    }
+
+    var global$b = tinymce.util.Tools.resolve('tinymce.ui.Factory');
+
+    var hasTabstopData = function (elm) {
+      return elm.getAttribute('data-mce-tabstop') ? true : false;
+    };
+    function KeyboardNavigation (settings) {
+      var root = settings.root;
+      var focusedElement, focusedControl;
+      function isElement(node) {
+        return node && node.nodeType === 1;
+      }
+      try {
+        focusedElement = domGlobals.document.activeElement;
+      } catch (ex) {
+        focusedElement = domGlobals.document.body;
+      }
+      focusedControl = root.getParentCtrl(focusedElement);
+      function getRole(elm) {
+        elm = elm || focusedElement;
+        if (isElement(elm)) {
+          return elm.getAttribute('role');
+        }
+        return null;
+      }
+      function getParentRole(elm) {
+        var role, parent = elm || focusedElement;
+        while (parent = parent.parentNode) {
+          if (role = getRole(parent)) {
+            return role;
+          }
+        }
+      }
+      function getAriaProp(name) {
+        var elm = focusedElement;
+        if (isElement(elm)) {
+          return elm.getAttribute('aria-' + name);
+        }
+      }
+      function isTextInputElement(elm) {
+        var tagName = elm.tagName.toUpperCase();
+        return tagName === 'INPUT' || tagName === 'TEXTAREA' || tagName === 'SELECT';
+      }
+      function canFocus(elm) {
+        if (isTextInputElement(elm) && !elm.hidden) {
+          return true;
+        }
+        if (hasTabstopData(elm)) {
+          return true;
+        }
+        if (/^(button|menuitem|checkbox|tab|menuitemcheckbox|option|gridcell|slider)$/.test(getRole(elm))) {
+          return true;
+        }
+        return false;
+      }
+      function getFocusElements(elm) {
+        var elements = [];
+        function collect(elm) {
+          if (elm.nodeType !== 1 || elm.style.display === 'none' || elm.disabled) {
+            return;
+          }
+          if (canFocus(elm)) {
+            elements.push(elm);
+          }
+          for (var i = 0; i < elm.childNodes.length; i++) {
+            collect(elm.childNodes[i]);
+          }
+        }
+        collect(elm || root.getEl());
+        return elements;
+      }
+      function getNavigationRoot(targetControl) {
+        var navigationRoot, controls;
+        targetControl = targetControl || focusedControl;
+        controls = targetControl.parents().toArray();
+        controls.unshift(targetControl);
+        for (var i = 0; i < controls.length; i++) {
+          navigationRoot = controls[i];
+          if (navigationRoot.settings.ariaRoot) {
+            break;
+          }
+        }
+        return navigationRoot;
+      }
+      function focusFirst(targetControl) {
+        var navigationRoot = getNavigationRoot(targetControl);
+        var focusElements = getFocusElements(navigationRoot.getEl());
+        if (navigationRoot.settings.ariaRemember && 'lastAriaIndex' in navigationRoot) {
+          moveFocusToIndex(navigationRoot.lastAriaIndex, focusElements);
+        } else {
+          moveFocusToIndex(0, focusElements);
+        }
+      }
+      function moveFocusToIndex(idx, elements) {
+        if (idx < 0) {
+          idx = elements.length - 1;
+        } else if (idx >= elements.length) {
+          idx = 0;
+        }
+        if (elements[idx]) {
+          elements[idx].focus();
+        }
+        return idx;
+      }
+      function moveFocus(dir, elements) {
+        var idx = -1;
+        var navigationRoot = getNavigationRoot();
+        elements = elements || getFocusElements(navigationRoot.getEl());
+        for (var i = 0; i < elements.length; i++) {
+          if (elements[i] === focusedElement) {
+            idx = i;
+          }
+        }
+        idx += dir;
+        navigationRoot.lastAriaIndex = moveFocusToIndex(idx, elements);
+      }
+      function left() {
+        var parentRole = getParentRole();
+        if (parentRole === 'tablist') {
+          moveFocus(-1, getFocusElements(focusedElement.parentNode));
+        } else if (focusedControl.parent().submenu) {
+          cancel();
+        } else {
+          moveFocus(-1);
+        }
+      }
+      function right() {
+        var role = getRole(), parentRole = getParentRole();
+        if (parentRole === 'tablist') {
+          moveFocus(1, getFocusElements(focusedElement.parentNode));
+        } else if (role === 'menuitem' && parentRole === 'menu' && getAriaProp('haspopup')) {
+          enter();
+        } else {
+          moveFocus(1);
+        }
+      }
+      function up() {
+        moveFocus(-1);
+      }
+      function down() {
+        var role = getRole(), parentRole = getParentRole();
+        if (role === 'menuitem' && parentRole === 'menubar') {
+          enter();
+        } else if (role === 'button' && getAriaProp('haspopup')) {
+          enter({ key: 'down' });
+        } else {
+          moveFocus(1);
+        }
+      }
+      function tab(e) {
+        var parentRole = getParentRole();
+        if (parentRole === 'tablist') {
+          var elm = getFocusElements(focusedControl.getEl('body'))[0];
+          if (elm) {
+            elm.focus();
+          }
+        } else {
+          moveFocus(e.shiftKey ? -1 : 1);
+        }
+      }
+      function cancel() {
+        focusedControl.fire('cancel');
+      }
+      function enter(aria) {
+        aria = aria || {};
+        focusedControl.fire('click', {
+          target: focusedElement,
+          aria: aria
+        });
+      }
+      root.on('keydown', function (e) {
+        function handleNonTabOrEscEvent(e, handler) {
+          if (isTextInputElement(focusedElement) || hasTabstopData(focusedElement)) {
+            return;
+          }
+          if (getRole(focusedElement) === 'slider') {
+            return;
+          }
+          if (handler(e) !== false) {
+            e.preventDefault();
+          }
+        }
+        if (e.isDefaultPrevented()) {
+          return;
+        }
+        switch (e.keyCode) {
+        case 37:
+          handleNonTabOrEscEvent(e, left);
+          break;
+        case 39:
+          handleNonTabOrEscEvent(e, right);
+          break;
+        case 38:
+          handleNonTabOrEscEvent(e, up);
+          break;
+        case 40:
+          handleNonTabOrEscEvent(e, down);
+          break;
+        case 27:
+          cancel();
+          break;
+        case 14:
+        case 13:
+        case 32:
+          handleNonTabOrEscEvent(e, enter);
+          break;
+        case 9:
+          tab(e);
+          e.preventDefault();
+          break;
+        }
+      });
+      root.on('focusin', function (e) {
+        focusedElement = e.target;
+        focusedControl = e.control;
+      });
+      return { focusFirst: focusFirst };
+    }
+
+    var selectorCache = {};
+    var Container = Control$1.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        settings = self.settings;
+        if (settings.fixed) {
+          self.state.set('fixed', true);
+        }
+        self._items = new Collection$2();
+        if (self.isRtl()) {
+          self.classes.add('rtl');
+        }
+        self.bodyClasses = new ClassList(function () {
+          if (self.state.get('rendered')) {
+            self.getEl('body').className = this.toString();
+          }
+        });
+        self.bodyClasses.prefix = self.classPrefix;
+        self.classes.add('container');
+        self.bodyClasses.add('container-body');
+        if (settings.containerCls) {
+          self.classes.add(settings.containerCls);
+        }
+        self._layout = global$b.create((settings.layout || '') + 'layout');
+        if (self.settings.items) {
+          self.add(self.settings.items);
+        } else {
+          self.add(self.render());
+        }
+        self._hasBody = true;
+      },
+      items: function () {
+        return this._items;
+      },
+      find: function (selector) {
+        selector = selectorCache[selector] = selectorCache[selector] || new Selector(selector);
+        return selector.find(this);
+      },
+      add: function (items) {
+        var self = this;
+        self.items().add(self.create(items)).parent(self);
+        return self;
+      },
+      focus: function (keyboard) {
+        var self = this;
+        var focusCtrl, keyboardNav, items;
+        if (keyboard) {
+          keyboardNav = self.keyboardNav || self.parents().eq(-1)[0].keyboardNav;
+          if (keyboardNav) {
+            keyboardNav.focusFirst(self);
+            return;
+          }
+        }
+        items = self.find('*');
+        if (self.statusbar) {
+          items.add(self.statusbar.items());
+        }
+        items.each(function (ctrl) {
+          if (ctrl.settings.autofocus) {
+            focusCtrl = null;
+            return false;
+          }
+          if (ctrl.canFocus) {
+            focusCtrl = focusCtrl || ctrl;
+          }
+        });
+        if (focusCtrl) {
+          focusCtrl.focus();
+        }
+        return self;
+      },
+      replace: function (oldItem, newItem) {
+        var ctrlElm;
+        var items = this.items();
+        var i = items.length;
+        while (i--) {
+          if (items[i] === oldItem) {
+            items[i] = newItem;
+            break;
+          }
+        }
+        if (i >= 0) {
+          ctrlElm = newItem.getEl();
+          if (ctrlElm) {
+            ctrlElm.parentNode.removeChild(ctrlElm);
+          }
+          ctrlElm = oldItem.getEl();
+          if (ctrlElm) {
+            ctrlElm.parentNode.removeChild(ctrlElm);
+          }
+        }
+        newItem.parent(this);
+      },
+      create: function (items) {
+        var self = this;
+        var settings;
+        var ctrlItems = [];
+        if (!global$4.isArray(items)) {
+          items = [items];
+        }
+        global$4.each(items, function (item) {
+          if (item) {
+            if (!(item instanceof Control$1)) {
+              if (typeof item === 'string') {
+                item = { type: item };
+              }
+              settings = global$4.extend({}, self.settings.defaults, item);
+              item.type = settings.type = settings.type || item.type || self.settings.defaultType || (settings.defaults ? settings.defaults.type : null);
+              item = global$b.create(settings);
+            }
+            ctrlItems.push(item);
+          }
+        });
+        return ctrlItems;
+      },
+      renderNew: function () {
+        var self = this;
+        self.items().each(function (ctrl, index) {
+          var containerElm;
+          ctrl.parent(self);
+          if (!ctrl.state.get('rendered')) {
+            containerElm = self.getEl('body');
+            if (containerElm.hasChildNodes() && index <= containerElm.childNodes.length - 1) {
+              global$7(containerElm.childNodes[index]).before(ctrl.renderHtml());
+            } else {
+              global$7(containerElm).append(ctrl.renderHtml());
+            }
+            ctrl.postRender();
+            ReflowQueue.add(ctrl);
+          }
+        });
+        self._layout.applyClasses(self.items().filter(':visible'));
+        self._lastRect = null;
+        return self;
+      },
+      append: function (items) {
+        return this.add(items).renderNew();
+      },
+      prepend: function (items) {
+        var self = this;
+        self.items().set(self.create(items).concat(self.items().toArray()));
+        return self.renderNew();
+      },
+      insert: function (items, index, before) {
+        var self = this;
+        var curItems, beforeItems, afterItems;
+        items = self.create(items);
+        curItems = self.items();
+        if (!before && index < curItems.length - 1) {
+          index += 1;
+        }
+        if (index >= 0 && index < curItems.length) {
+          beforeItems = curItems.slice(0, index).toArray();
+          afterItems = curItems.slice(index).toArray();
+          curItems.set(beforeItems.concat(items, afterItems));
+        }
+        return self.renderNew();
+      },
+      fromJSON: function (data) {
+        var self = this;
+        for (var name in data) {
+          self.find('#' + name).value(data[name]);
+        }
+        return self;
+      },
+      toJSON: function () {
+        var self = this, data = {};
+        self.find('*').each(function (ctrl) {
+          var name = ctrl.name(), value = ctrl.value();
+          if (name && typeof value !== 'undefined') {
+            data[name] = value;
+          }
+        });
+        return data;
+      },
+      renderHtml: function () {
+        var self = this, layout = self._layout, role = this.settings.role;
+        self.preRender();
+        layout.preRender(self);
+        return '<div id="' + self._id + '" class="' + self.classes + '"' + (role ? ' role="' + this.settings.role + '"' : '') + '>' + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        var box;
+        self.items().exec('postRender');
+        self._super();
+        self._layout.postRender(self);
+        self.state.set('rendered', true);
+        if (self.settings.style) {
+          self.$el.css(self.settings.style);
+        }
+        if (self.settings.border) {
+          box = self.borderBox;
+          self.$el.css({
+            'border-top-width': box.top,
+            'border-right-width': box.right,
+            'border-bottom-width': box.bottom,
+            'border-left-width': box.left
+          });
+        }
+        if (!self.parent()) {
+          self.keyboardNav = KeyboardNavigation({ root: self });
+        }
+        return self;
+      },
+      initLayoutRect: function () {
+        var self = this, layoutRect = self._super();
+        self._layout.recalc(self);
+        return layoutRect;
+      },
+      recalc: function () {
+        var self = this;
+        var rect = self._layoutRect;
+        var lastRect = self._lastRect;
+        if (!lastRect || lastRect.w !== rect.w || lastRect.h !== rect.h) {
+          self._layout.recalc(self);
+          rect = self.layoutRect();
+          self._lastRect = {
+            x: rect.x,
+            y: rect.y,
+            w: rect.w,
+            h: rect.h
+          };
+          return true;
+        }
+      },
+      reflow: function () {
+        var i;
+        ReflowQueue.remove(this);
+        if (this.visible()) {
+          Control$1.repaintControls = [];
+          Control$1.repaintControls.map = {};
+          this.recalc();
+          i = Control$1.repaintControls.length;
+          while (i--) {
+            Control$1.repaintControls[i].repaint();
+          }
+          if (this.settings.layout !== 'flow' && this.settings.layout !== 'stack') {
+            this.repaint();
+          }
+          Control$1.repaintControls = [];
+        }
+        return this;
+      }
+    });
+
+    var Scrollable = {
+      init: function () {
+        var self = this;
+        self.on('repaint', self.renderScroll);
+      },
+      renderScroll: function () {
+        var self = this, margin = 2;
+        function repaintScroll() {
+          var hasScrollH, hasScrollV, bodyElm;
+          function repaintAxis(axisName, posName, sizeName, contentSizeName, hasScroll, ax) {
+            var containerElm, scrollBarElm, scrollThumbElm;
+            var containerSize, scrollSize, ratio, rect;
+            var posNameLower, sizeNameLower;
+            scrollBarElm = self.getEl('scroll' + axisName);
+            if (scrollBarElm) {
+              posNameLower = posName.toLowerCase();
+              sizeNameLower = sizeName.toLowerCase();
+              global$7(self.getEl('absend')).css(posNameLower, self.layoutRect()[contentSizeName] - 1);
+              if (!hasScroll) {
+                global$7(scrollBarElm).css('display', 'none');
+                return;
+              }
+              global$7(scrollBarElm).css('display', 'block');
+              containerElm = self.getEl('body');
+              scrollThumbElm = self.getEl('scroll' + axisName + 't');
+              containerSize = containerElm['client' + sizeName] - margin * 2;
+              containerSize -= hasScrollH && hasScrollV ? scrollBarElm['client' + ax] : 0;
+              scrollSize = containerElm['scroll' + sizeName];
+              ratio = containerSize / scrollSize;
+              rect = {};
+              rect[posNameLower] = containerElm['offset' + posName] + margin;
+              rect[sizeNameLower] = containerSize;
+              global$7(scrollBarElm).css(rect);
+              rect = {};
+              rect[posNameLower] = containerElm['scroll' + posName] * ratio;
+              rect[sizeNameLower] = containerSize * ratio;
+              global$7(scrollThumbElm).css(rect);
+            }
+          }
+          bodyElm = self.getEl('body');
+          hasScrollH = bodyElm.scrollWidth > bodyElm.clientWidth;
+          hasScrollV = bodyElm.scrollHeight > bodyElm.clientHeight;
+          repaintAxis('h', 'Left', 'Width', 'contentW', hasScrollH, 'Height');
+          repaintAxis('v', 'Top', 'Height', 'contentH', hasScrollV, 'Width');
+        }
+        function addScroll() {
+          function addScrollAxis(axisName, posName, sizeName, deltaPosName, ax) {
+            var scrollStart;
+            var axisId = self._id + '-scroll' + axisName, prefix = self.classPrefix;
+            global$7(self.getEl()).append('<div id="' + axisId + '" class="' + prefix + 'scrollbar ' + prefix + 'scrollbar-' + axisName + '">' + '<div id="' + axisId + 't" class="' + prefix + 'scrollbar-thumb"></div>' + '</div>');
+            self.draghelper = new DragHelper(axisId + 't', {
+              start: function () {
+                scrollStart = self.getEl('body')['scroll' + posName];
+                global$7('#' + axisId).addClass(prefix + 'active');
+              },
+              drag: function (e) {
+                var ratio, hasScrollH, hasScrollV, containerSize;
+                var layoutRect = self.layoutRect();
+                hasScrollH = layoutRect.contentW > layoutRect.innerW;
+                hasScrollV = layoutRect.contentH > layoutRect.innerH;
+                containerSize = self.getEl('body')['client' + sizeName] - margin * 2;
+                containerSize -= hasScrollH && hasScrollV ? self.getEl('scroll' + axisName)['client' + ax] : 0;
+                ratio = containerSize / self.getEl('body')['scroll' + sizeName];
+                self.getEl('body')['scroll' + posName] = scrollStart + e['delta' + deltaPosName] / ratio;
+              },
+              stop: function () {
+                global$7('#' + axisId).removeClass(prefix + 'active');
+              }
+            });
+          }
+          self.classes.add('scroll');
+          addScrollAxis('v', 'Top', 'Height', 'Y', 'Width');
+          addScrollAxis('h', 'Left', 'Width', 'X', 'Height');
+        }
+        if (self.settings.autoScroll) {
+          if (!self._hasScroll) {
+            self._hasScroll = true;
+            addScroll();
+            self.on('wheel', function (e) {
+              var bodyEl = self.getEl('body');
+              bodyEl.scrollLeft += (e.deltaX || 0) * 10;
+              bodyEl.scrollTop += e.deltaY * 10;
+              repaintScroll();
+            });
+            global$7(self.getEl('body')).on('scroll', repaintScroll);
+          }
+          repaintScroll();
+        }
+      }
+    };
+
+    var Panel = Container.extend({
+      Defaults: {
+        layout: 'fit',
+        containerCls: 'panel'
+      },
+      Mixins: [Scrollable],
+      renderHtml: function () {
+        var self = this;
+        var layout = self._layout;
+        var innerHtml = self.settings.html;
+        self.preRender();
+        layout.preRender(self);
+        if (typeof innerHtml === 'undefined') {
+          innerHtml = '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + layout.renderHtml(self) + '</div>';
+        } else {
+          if (typeof innerHtml === 'function') {
+            innerHtml = innerHtml.call(self);
+          }
+          self._hasBody = false;
+        }
+        return '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1" role="group">' + (self._preBodyHtml || '') + innerHtml + '</div>';
+      }
+    });
+
+    var Resizable = {
+      resizeToContent: function () {
+        this._layoutRect.autoResize = true;
+        this._lastRect = null;
+        this.reflow();
+      },
+      resizeTo: function (w, h) {
+        if (w <= 1 || h <= 1) {
+          var rect = funcs.getWindowSize();
+          w = w <= 1 ? w * rect.w : w;
+          h = h <= 1 ? h * rect.h : h;
+        }
+        this._layoutRect.autoResize = false;
+        return this.layoutRect({
+          minW: w,
+          minH: h,
+          w: w,
+          h: h
+        }).reflow();
+      },
+      resizeBy: function (dw, dh) {
+        var self = this, rect = self.layoutRect();
+        return self.resizeTo(rect.w + dw, rect.h + dh);
+      }
+    };
+
+    var documentClickHandler, documentScrollHandler, windowResizeHandler;
+    var visiblePanels = [];
+    var zOrder = [];
+    var hasModal;
+    function isChildOf(ctrl, parent) {
+      while (ctrl) {
+        if (ctrl === parent) {
+          return true;
+        }
+        ctrl = ctrl.parent();
+      }
+    }
+    function skipOrHidePanels(e) {
+      var i = visiblePanels.length;
+      while (i--) {
+        var panel = visiblePanels[i], clickCtrl = panel.getParentCtrl(e.target);
+        if (panel.settings.autohide) {
+          if (clickCtrl) {
+            if (isChildOf(clickCtrl, panel) || panel.parent() === clickCtrl) {
+              continue;
+            }
+          }
+          e = panel.fire('autohide', { target: e.target });
+          if (!e.isDefaultPrevented()) {
+            panel.hide();
+          }
+        }
+      }
+    }
+    function bindDocumentClickHandler() {
+      if (!documentClickHandler) {
+        documentClickHandler = function (e) {
+          if (e.button === 2) {
+            return;
+          }
+          skipOrHidePanels(e);
+        };
+        global$7(domGlobals.document).on('click touchstart', documentClickHandler);
+      }
+    }
+    function bindDocumentScrollHandler() {
+      if (!documentScrollHandler) {
+        documentScrollHandler = function () {
+          var i;
+          i = visiblePanels.length;
+          while (i--) {
+            repositionPanel$1(visiblePanels[i]);
+          }
+        };
+        global$7(domGlobals.window).on('scroll', documentScrollHandler);
+      }
+    }
+    function bindWindowResizeHandler() {
+      if (!windowResizeHandler) {
+        var docElm_1 = domGlobals.document.documentElement;
+        var clientWidth_1 = docElm_1.clientWidth, clientHeight_1 = docElm_1.clientHeight;
+        windowResizeHandler = function () {
+          if (!domGlobals.document.all || clientWidth_1 !== docElm_1.clientWidth || clientHeight_1 !== docElm_1.clientHeight) {
+            clientWidth_1 = docElm_1.clientWidth;
+            clientHeight_1 = docElm_1.clientHeight;
+            FloatPanel.hideAll();
+          }
+        };
+        global$7(domGlobals.window).on('resize', windowResizeHandler);
+      }
+    }
+    function repositionPanel$1(panel) {
+      var scrollY = funcs.getViewPort().y;
+      function toggleFixedChildPanels(fixed, deltaY) {
+        var parent;
+        for (var i = 0; i < visiblePanels.length; i++) {
+          if (visiblePanels[i] !== panel) {
+            parent = visiblePanels[i].parent();
+            while (parent && (parent = parent.parent())) {
+              if (parent === panel) {
+                visiblePanels[i].fixed(fixed).moveBy(0, deltaY).repaint();
+              }
+            }
+          }
+        }
+      }
+      if (panel.settings.autofix) {
+        if (!panel.state.get('fixed')) {
+          panel._autoFixY = panel.layoutRect().y;
+          if (panel._autoFixY < scrollY) {
+            panel.fixed(true).layoutRect({ y: 0 }).repaint();
+            toggleFixedChildPanels(true, scrollY - panel._autoFixY);
+          }
+        } else {
+          if (panel._autoFixY > scrollY) {
+            panel.fixed(false).layoutRect({ y: panel._autoFixY }).repaint();
+            toggleFixedChildPanels(false, panel._autoFixY - scrollY);
+          }
+        }
+      }
+    }
+    function addRemove(add, ctrl) {
+      var i, zIndex = FloatPanel.zIndex || 65535, topModal;
+      if (add) {
+        zOrder.push(ctrl);
+      } else {
+        i = zOrder.length;
+        while (i--) {
+          if (zOrder[i] === ctrl) {
+            zOrder.splice(i, 1);
+          }
+        }
+      }
+      if (zOrder.length) {
+        for (i = 0; i < zOrder.length; i++) {
+          if (zOrder[i].modal) {
+            zIndex++;
+            topModal = zOrder[i];
+          }
+          zOrder[i].getEl().style.zIndex = zIndex;
+          zOrder[i].zIndex = zIndex;
+          zIndex++;
+        }
+      }
+      var modalBlockEl = global$7('#' + ctrl.classPrefix + 'modal-block', ctrl.getContainerElm())[0];
+      if (topModal) {
+        global$7(modalBlockEl).css('z-index', topModal.zIndex - 1);
+      } else if (modalBlockEl) {
+        modalBlockEl.parentNode.removeChild(modalBlockEl);
+        hasModal = false;
+      }
+      FloatPanel.currentZIndex = zIndex;
+    }
+    var FloatPanel = Panel.extend({
+      Mixins: [
+        Movable,
+        Resizable
+      ],
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self._eventsRoot = self;
+        self.classes.add('floatpanel');
+        if (settings.autohide) {
+          bindDocumentClickHandler();
+          bindWindowResizeHandler();
+          visiblePanels.push(self);
+        }
+        if (settings.autofix) {
+          bindDocumentScrollHandler();
+          self.on('move', function () {
+            repositionPanel$1(this);
+          });
+        }
+        self.on('postrender show', function (e) {
+          if (e.control === self) {
+            var $modalBlockEl_1;
+            var prefix_1 = self.classPrefix;
+            if (self.modal && !hasModal) {
+              $modalBlockEl_1 = global$7('#' + prefix_1 + 'modal-block', self.getContainerElm());
+              if (!$modalBlockEl_1[0]) {
+                $modalBlockEl_1 = global$7('<div id="' + prefix_1 + 'modal-block" class="' + prefix_1 + 'reset ' + prefix_1 + 'fade"></div>').appendTo(self.getContainerElm());
+              }
+              global$3.setTimeout(function () {
+                $modalBlockEl_1.addClass(prefix_1 + 'in');
+                global$7(self.getEl()).addClass(prefix_1 + 'in');
+              });
+              hasModal = true;
+            }
+            addRemove(true, self);
+          }
+        });
+        self.on('show', function () {
+          self.parents().each(function (ctrl) {
+            if (ctrl.state.get('fixed')) {
+              self.fixed(true);
+              return false;
+            }
+          });
+        });
+        if (settings.popover) {
+          self._preBodyHtml = '<div class="' + self.classPrefix + 'arrow"></div>';
+          self.classes.add('popover').add('bottom').add(self.isRtl() ? 'end' : 'start');
+        }
+        self.aria('label', settings.ariaLabel);
+        self.aria('labelledby', self._id);
+        self.aria('describedby', self.describedBy || self._id + '-none');
+      },
+      fixed: function (state) {
+        var self = this;
+        if (self.state.get('fixed') !== state) {
+          if (self.state.get('rendered')) {
+            var viewport = funcs.getViewPort();
+            if (state) {
+              self.layoutRect().y -= viewport.y;
+            } else {
+              self.layoutRect().y += viewport.y;
+            }
+          }
+          self.classes.toggle('fixed', state);
+          self.state.set('fixed', state);
+        }
+        return self;
+      },
+      show: function () {
+        var self = this;
+        var i;
+        var state = self._super();
+        i = visiblePanels.length;
+        while (i--) {
+          if (visiblePanels[i] === self) {
+            break;
+          }
+        }
+        if (i === -1) {
+          visiblePanels.push(self);
+        }
+        return state;
+      },
+      hide: function () {
+        removeVisiblePanel(this);
+        addRemove(false, this);
+        return this._super();
+      },
+      hideAll: function () {
+        FloatPanel.hideAll();
+      },
+      close: function () {
+        var self = this;
+        if (!self.fire('close').isDefaultPrevented()) {
+          self.remove();
+          addRemove(false, self);
+        }
+        return self;
+      },
+      remove: function () {
+        removeVisiblePanel(this);
+        this._super();
+      },
+      postRender: function () {
+        var self = this;
+        if (self.settings.bodyRole) {
+          this.getEl('body').setAttribute('role', self.settings.bodyRole);
+        }
+        return self._super();
+      }
+    });
+    FloatPanel.hideAll = function () {
+      var i = visiblePanels.length;
+      while (i--) {
+        var panel = visiblePanels[i];
+        if (panel && panel.settings.autohide) {
+          panel.hide();
+          visiblePanels.splice(i, 1);
+        }
+      }
+    };
+    function removeVisiblePanel(panel) {
+      var i;
+      i = visiblePanels.length;
+      while (i--) {
+        if (visiblePanels[i] === panel) {
+          visiblePanels.splice(i, 1);
+        }
+      }
+      i = zOrder.length;
+      while (i--) {
+        if (zOrder[i] === panel) {
+          zOrder.splice(i, 1);
+        }
+      }
+    }
+
+    var windows = [];
+    var oldMetaValue = '';
+    function toggleFullScreenState(state) {
+      var noScaleMetaValue = 'width=device-width,initial-scale=1.0,user-scalable=0,minimum-scale=1.0,maximum-scale=1.0';
+      var viewport = global$7('meta[name=viewport]')[0], contentValue;
+      if (global$1.overrideViewPort === false) {
+        return;
+      }
+      if (!viewport) {
+        viewport = domGlobals.document.createElement('meta');
+        viewport.setAttribute('name', 'viewport');
+        domGlobals.document.getElementsByTagName('head')[0].appendChild(viewport);
+      }
+      contentValue = viewport.getAttribute('content');
+      if (contentValue && typeof oldMetaValue !== 'undefined') {
+        oldMetaValue = contentValue;
+      }
+      viewport.setAttribute('content', state ? noScaleMetaValue : oldMetaValue);
+    }
+    function toggleBodyFullScreenClasses(classPrefix, state) {
+      if (checkFullscreenWindows() && state === false) {
+        global$7([
+          domGlobals.document.documentElement,
+          domGlobals.document.body
+        ]).removeClass(classPrefix + 'fullscreen');
+      }
+    }
+    function checkFullscreenWindows() {
+      for (var i = 0; i < windows.length; i++) {
+        if (windows[i]._fullscreen) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function handleWindowResize() {
+      if (!global$1.desktop) {
+        var lastSize_1 = {
+          w: domGlobals.window.innerWidth,
+          h: domGlobals.window.innerHeight
+        };
+        global$3.setInterval(function () {
+          var w = domGlobals.window.innerWidth, h = domGlobals.window.innerHeight;
+          if (lastSize_1.w !== w || lastSize_1.h !== h) {
+            lastSize_1 = {
+              w: w,
+              h: h
+            };
+            global$7(domGlobals.window).trigger('resize');
+          }
+        }, 100);
+      }
+      function reposition() {
+        var i;
+        var rect = funcs.getWindowSize();
+        var layoutRect;
+        for (i = 0; i < windows.length; i++) {
+          layoutRect = windows[i].layoutRect();
+          windows[i].moveTo(windows[i].settings.x || Math.max(0, rect.w / 2 - layoutRect.w / 2), windows[i].settings.y || Math.max(0, rect.h / 2 - layoutRect.h / 2));
+        }
+      }
+      global$7(domGlobals.window).on('resize', reposition);
+    }
+    var Window = FloatPanel.extend({
+      modal: true,
+      Defaults: {
+        border: 1,
+        layout: 'flex',
+        containerCls: 'panel',
+        role: 'dialog',
+        callbacks: {
+          submit: function () {
+            this.fire('submit', { data: this.toJSON() });
+          },
+          close: function () {
+            this.close();
+          }
+        }
+      },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        if (self.isRtl()) {
+          self.classes.add('rtl');
+        }
+        self.classes.add('window');
+        self.bodyClasses.add('window-body');
+        self.state.set('fixed', true);
+        if (settings.buttons) {
+          self.statusbar = new Panel({
+            layout: 'flex',
+            border: '1 0 0 0',
+            spacing: 3,
+            padding: 10,
+            align: 'center',
+            pack: self.isRtl() ? 'start' : 'end',
+            defaults: { type: 'button' },
+            items: settings.buttons
+          });
+          self.statusbar.classes.add('foot');
+          self.statusbar.parent(self);
+        }
+        self.on('click', function (e) {
+          var closeClass = self.classPrefix + 'close';
+          if (funcs.hasClass(e.target, closeClass) || funcs.hasClass(e.target.parentNode, closeClass)) {
+            self.close();
+          }
+        });
+        self.on('cancel', function () {
+          self.close();
+        });
+        self.on('move', function (e) {
+          if (e.control === self) {
+            FloatPanel.hideAll();
+          }
+        });
+        self.aria('describedby', self.describedBy || self._id + '-none');
+        self.aria('label', settings.title);
+        self._fullscreen = false;
+      },
+      recalc: function () {
+        var self = this;
+        var statusbar = self.statusbar;
+        var layoutRect, width, x, needsRecalc;
+        if (self._fullscreen) {
+          self.layoutRect(funcs.getWindowSize());
+          self.layoutRect().contentH = self.layoutRect().innerH;
+        }
+        self._super();
+        layoutRect = self.layoutRect();
+        if (self.settings.title && !self._fullscreen) {
+          width = layoutRect.headerW;
+          if (width > layoutRect.w) {
+            x = layoutRect.x - Math.max(0, width / 2);
+            self.layoutRect({
+              w: width,
+              x: x
+            });
+            needsRecalc = true;
+          }
+        }
+        if (statusbar) {
+          statusbar.layoutRect({ w: self.layoutRect().innerW }).recalc();
+          width = statusbar.layoutRect().minW + layoutRect.deltaW;
+          if (width > layoutRect.w) {
+            x = layoutRect.x - Math.max(0, width - layoutRect.w);
+            self.layoutRect({
+              w: width,
+              x: x
+            });
+            needsRecalc = true;
+          }
+        }
+        if (needsRecalc) {
+          self.recalc();
+        }
+      },
+      initLayoutRect: function () {
+        var self = this;
+        var layoutRect = self._super();
+        var deltaH = 0, headEl;
+        if (self.settings.title && !self._fullscreen) {
+          headEl = self.getEl('head');
+          var size = funcs.getSize(headEl);
+          layoutRect.headerW = size.width;
+          layoutRect.headerH = size.height;
+          deltaH += layoutRect.headerH;
+        }
+        if (self.statusbar) {
+          deltaH += self.statusbar.layoutRect().h;
+        }
+        layoutRect.deltaH += deltaH;
+        layoutRect.minH += deltaH;
+        layoutRect.h += deltaH;
+        var rect = funcs.getWindowSize();
+        layoutRect.x = self.settings.x || Math.max(0, rect.w / 2 - layoutRect.w / 2);
+        layoutRect.y = self.settings.y || Math.max(0, rect.h / 2 - layoutRect.h / 2);
+        return layoutRect;
+      },
+      renderHtml: function () {
+        var self = this, layout = self._layout, id = self._id, prefix = self.classPrefix;
+        var settings = self.settings;
+        var headerHtml = '', footerHtml = '', html = settings.html;
+        self.preRender();
+        layout.preRender(self);
+        if (settings.title) {
+          headerHtml = '<div id="' + id + '-head" class="' + prefix + 'window-head">' + '<div id="' + id + '-title" class="' + prefix + 'title">' + self.encode(settings.title) + '</div>' + '<div id="' + id + '-dragh" class="' + prefix + 'dragh"></div>' + '<button type="button" class="' + prefix + 'close" aria-hidden="true">' + '<i class="mce-ico mce-i-remove"></i>' + '</button>' + '</div>';
+        }
+        if (settings.url) {
+          html = '<iframe src="' + settings.url + '" tabindex="-1"></iframe>';
+        }
+        if (typeof html === 'undefined') {
+          html = layout.renderHtml(self);
+        }
+        if (self.statusbar) {
+          footerHtml = self.statusbar.renderHtml();
+        }
+        return '<div id="' + id + '" class="' + self.classes + '" hidefocus="1">' + '<div class="' + self.classPrefix + 'reset" role="application">' + headerHtml + '<div id="' + id + '-body" class="' + self.bodyClasses + '">' + html + '</div>' + footerHtml + '</div>' + '</div>';
+      },
+      fullscreen: function (state) {
+        var self = this;
+        var documentElement = domGlobals.document.documentElement;
+        var slowRendering;
+        var prefix = self.classPrefix;
+        var layoutRect;
+        if (state !== self._fullscreen) {
+          global$7(domGlobals.window).on('resize', function () {
+            var time;
+            if (self._fullscreen) {
+              if (!slowRendering) {
+                time = new Date().getTime();
+                var rect = funcs.getWindowSize();
+                self.moveTo(0, 0).resizeTo(rect.w, rect.h);
+                if (new Date().getTime() - time > 50) {
+                  slowRendering = true;
+                }
+              } else {
+                if (!self._timer) {
+                  self._timer = global$3.setTimeout(function () {
+                    var rect = funcs.getWindowSize();
+                    self.moveTo(0, 0).resizeTo(rect.w, rect.h);
+                    self._timer = 0;
+                  }, 50);
+                }
+              }
+            }
+          });
+          layoutRect = self.layoutRect();
+          self._fullscreen = state;
+          if (!state) {
+            self.borderBox = BoxUtils.parseBox(self.settings.border);
+            self.getEl('head').style.display = '';
+            layoutRect.deltaH += layoutRect.headerH;
+            global$7([
+              documentElement,
+              domGlobals.document.body
+            ]).removeClass(prefix + 'fullscreen');
+            self.classes.remove('fullscreen');
+            self.moveTo(self._initial.x, self._initial.y).resizeTo(self._initial.w, self._initial.h);
+          } else {
+            self._initial = {
+              x: layoutRect.x,
+              y: layoutRect.y,
+              w: layoutRect.w,
+              h: layoutRect.h
+            };
+            self.borderBox = BoxUtils.parseBox('0');
+            self.getEl('head').style.display = 'none';
+            layoutRect.deltaH -= layoutRect.headerH + 2;
+            global$7([
+              documentElement,
+              domGlobals.document.body
+            ]).addClass(prefix + 'fullscreen');
+            self.classes.add('fullscreen');
+            var rect = funcs.getWindowSize();
+            self.moveTo(0, 0).resizeTo(rect.w, rect.h);
+          }
+        }
+        return self.reflow();
+      },
+      postRender: function () {
+        var self = this;
+        var startPos;
+        setTimeout(function () {
+          self.classes.add('in');
+          self.fire('open');
+        }, 0);
+        self._super();
+        if (self.statusbar) {
+          self.statusbar.postRender();
+        }
+        self.focus();
+        this.dragHelper = new DragHelper(self._id + '-dragh', {
+          start: function () {
+            startPos = {
+              x: self.layoutRect().x,
+              y: self.layoutRect().y
+            };
+          },
+          drag: function (e) {
+            self.moveTo(startPos.x + e.deltaX, startPos.y + e.deltaY);
+          }
+        });
+        self.on('submit', function (e) {
+          if (!e.isDefaultPrevented()) {
+            self.close();
+          }
+        });
+        windows.push(self);
+        toggleFullScreenState(true);
+      },
+      submit: function () {
+        return this.fire('submit', { data: this.toJSON() });
+      },
+      remove: function () {
+        var self = this;
+        var i;
+        self.dragHelper.destroy();
+        self._super();
+        if (self.statusbar) {
+          this.statusbar.remove();
+        }
+        toggleBodyFullScreenClasses(self.classPrefix, false);
+        i = windows.length;
+        while (i--) {
+          if (windows[i] === self) {
+            windows.splice(i, 1);
+          }
+        }
+        toggleFullScreenState(windows.length > 0);
+      },
+      getContentWindow: function () {
+        var ifr = this.getEl().getElementsByTagName('iframe')[0];
+        return ifr ? ifr.contentWindow : null;
+      }
+    });
+    handleWindowResize();
+
+    var MessageBox = Window.extend({
+      init: function (settings) {
+        settings = {
+          border: 1,
+          padding: 20,
+          layout: 'flex',
+          pack: 'center',
+          align: 'center',
+          containerCls: 'panel',
+          autoScroll: true,
+          buttons: {
+            type: 'button',
+            text: 'Ok',
+            action: 'ok'
+          },
+          items: {
+            type: 'label',
+            multiline: true,
+            maxWidth: 500,
+            maxHeight: 200
+          }
+        };
+        this._super(settings);
+      },
+      Statics: {
+        OK: 1,
+        OK_CANCEL: 2,
+        YES_NO: 3,
+        YES_NO_CANCEL: 4,
+        msgBox: function (settings) {
+          var buttons;
+          var callback = settings.callback || function () {
+          };
+          function createButton(text, status, primary) {
+            return {
+              type: 'button',
+              text: text,
+              subtype: primary ? 'primary' : '',
+              onClick: function (e) {
+                e.control.parents()[1].close();
+                callback(status);
+              }
+            };
+          }
+          switch (settings.buttons) {
+          case MessageBox.OK_CANCEL:
+            buttons = [
+              createButton('Ok', true, true),
+              createButton('Cancel', false)
+            ];
+            break;
+          case MessageBox.YES_NO:
+          case MessageBox.YES_NO_CANCEL:
+            buttons = [
+              createButton('Yes', 1, true),
+              createButton('No', 0)
+            ];
+            if (settings.buttons === MessageBox.YES_NO_CANCEL) {
+              buttons.push(createButton('Cancel', -1));
+            }
+            break;
+          default:
+            buttons = [createButton('Ok', true, true)];
+            break;
+          }
+          return new Window({
+            padding: 20,
+            x: settings.x,
+            y: settings.y,
+            minWidth: 300,
+            minHeight: 100,
+            layout: 'flex',
+            pack: 'center',
+            align: 'center',
+            buttons: buttons,
+            title: settings.title,
+            role: 'alertdialog',
+            items: {
+              type: 'label',
+              multiline: true,
+              maxWidth: 500,
+              maxHeight: 200,
+              text: settings.text
+            },
+            onPostRender: function () {
+              this.aria('describedby', this.items()[0]._id);
+            },
+            onClose: settings.onClose,
+            onCancel: function () {
+              callback(false);
+            }
+          }).renderTo(domGlobals.document.body).reflow();
+        },
+        alert: function (settings, callback) {
+          if (typeof settings === 'string') {
+            settings = { text: settings };
+          }
+          settings.callback = callback;
+          return MessageBox.msgBox(settings);
+        },
+        confirm: function (settings, callback) {
+          if (typeof settings === 'string') {
+            settings = { text: settings };
+          }
+          settings.callback = callback;
+          settings.buttons = MessageBox.OK_CANCEL;
+          return MessageBox.msgBox(settings);
+        }
+      }
+    });
+
+    function WindowManagerImpl (editor) {
+      var open = function (args, params, closeCallback) {
+        var win;
+        args.title = args.title || ' ';
+        args.url = args.url || args.file;
+        if (args.url) {
+          args.width = parseInt(args.width || 320, 10);
+          args.height = parseInt(args.height || 240, 10);
+        }
+        if (args.body) {
+          args.items = {
+            defaults: args.defaults,
+            type: args.bodyType || 'form',
+            items: args.body,
+            data: args.data,
+            callbacks: args.commands
+          };
+        }
+        if (!args.url && !args.buttons) {
+          args.buttons = [
+            {
+              text: 'Ok',
+              subtype: 'primary',
+              onclick: function () {
+                win.find('form')[0].submit();
+              }
+            },
+            {
+              text: 'Cancel',
+              onclick: function () {
+                win.close();
+              }
+            }
+          ];
+        }
+        win = new Window(args);
+        win.on('close', function () {
+          closeCallback(win);
+        });
+        if (args.data) {
+          win.on('postRender', function () {
+            this.find('*').each(function (ctrl) {
+              var name = ctrl.name();
+              if (name in args.data) {
+                ctrl.value(args.data[name]);
+              }
+            });
+          });
+        }
+        win.features = args || {};
+        win.params = params || {};
+        win = win.renderTo(domGlobals.document.body).reflow();
+        return win;
+      };
+      var alert = function (message, choiceCallback, closeCallback) {
+        var win;
+        win = MessageBox.alert(message, function () {
+          choiceCallback();
+        });
+        win.on('close', function () {
+          closeCallback(win);
+        });
+        return win;
+      };
+      var confirm = function (message, choiceCallback, closeCallback) {
+        var win;
+        win = MessageBox.confirm(message, function (state) {
+          choiceCallback(state);
+        });
+        win.on('close', function () {
+          closeCallback(win);
+        });
+        return win;
+      };
+      var close = function (window) {
+        window.close();
+      };
+      var getParams = function (window) {
+        return window.params;
+      };
+      var setParams = function (window, params) {
+        window.params = params;
+      };
+      return {
+        open: open,
+        alert: alert,
+        confirm: confirm,
+        close: close,
+        getParams: getParams,
+        setParams: setParams
+      };
+    }
+
+    var get = function (editor, panel) {
+      var renderUI = function () {
+        return Render.renderUI(editor, panel);
+      };
+      return {
+        renderUI: renderUI,
+        getNotificationManagerImpl: function () {
+          return NotificationManagerImpl(editor);
+        },
+        getWindowManagerImpl: function () {
+          return WindowManagerImpl();
+        }
+      };
+    };
+    var ThemeApi = { get: get };
+
+    var Global = typeof domGlobals.window !== 'undefined' ? domGlobals.window : Function('return this;')();
+
+    var path = function (parts, scope) {
+      var o = scope !== undefined && scope !== null ? scope : Global;
+      for (var i = 0; i < parts.length && o !== undefined && o !== null; ++i) {
+        o = o[parts[i]];
+      }
+      return o;
+    };
+    var resolve = function (p, scope) {
+      var parts = p.split('.');
+      return path(parts, scope);
+    };
+
+    var unsafe = function (name, scope) {
+      return resolve(name, scope);
+    };
+    var getOrDie = function (name, scope) {
+      var actual = unsafe(name, scope);
+      if (actual === undefined || actual === null) {
+        throw new Error(name + ' not available on this browser');
+      }
+      return actual;
+    };
+    var Global$1 = { getOrDie: getOrDie };
+
+    function FileReader () {
+      var f = Global$1.getOrDie('FileReader');
+      return new f();
+    }
+
+    var global$c = tinymce.util.Tools.resolve('tinymce.util.Promise');
+
+    var blobToBase64 = function (blob) {
+      return new global$c(function (resolve) {
+        var reader = FileReader();
+        reader.onloadend = function () {
+          resolve(reader.result.split(',')[1]);
+        };
+        reader.readAsDataURL(blob);
+      });
+    };
+    var Conversions = { blobToBase64: blobToBase64 };
+
+    var pickFile = function () {
+      return new global$c(function (resolve) {
+        var fileInput;
+        fileInput = domGlobals.document.createElement('input');
+        fileInput.type = 'file';
+        fileInput.style.position = 'fixed';
+        fileInput.style.left = 0;
+        fileInput.style.top = 0;
+        fileInput.style.opacity = 0.001;
+        domGlobals.document.body.appendChild(fileInput);
+        fileInput.onchange = function (e) {
+          resolve(Array.prototype.slice.call(e.target.files));
+        };
+        fileInput.click();
+        fileInput.parentNode.removeChild(fileInput);
+      });
+    };
+    var Picker = { pickFile: pickFile };
+
+    var count$1 = 0;
+    var seed = function () {
+      var rnd = function () {
+        return Math.round(Math.random() * 4294967295).toString(36);
+      };
+      return 's' + Date.now().toString(36) + rnd() + rnd() + rnd();
+    };
+    var uuid = function (prefix) {
+      return prefix + count$1++ + seed();
+    };
+    var Uuid = { uuid: uuid };
+
+    var create$1 = function (dom, rng) {
+      var bookmark = {};
+      function setupEndPoint(start) {
+        var offsetNode, container, offset;
+        container = rng[start ? 'startContainer' : 'endContainer'];
+        offset = rng[start ? 'startOffset' : 'endOffset'];
+        if (container.nodeType === 1) {
+          offsetNode = dom.create('span', { 'data-mce-type': 'bookmark' });
+          if (container.hasChildNodes()) {
+            offset = Math.min(offset, container.childNodes.length - 1);
+            if (start) {
+              container.insertBefore(offsetNode, container.childNodes[offset]);
+            } else {
+              dom.insertAfter(offsetNode, container.childNodes[offset]);
+            }
+          } else {
+            container.appendChild(offsetNode);
+          }
+          container = offsetNode;
+          offset = 0;
+        }
+        bookmark[start ? 'startContainer' : 'endContainer'] = container;
+        bookmark[start ? 'startOffset' : 'endOffset'] = offset;
+      }
+      setupEndPoint(true);
+      if (!rng.collapsed) {
+        setupEndPoint();
+      }
+      return bookmark;
+    };
+    var resolve$1 = function (dom, bookmark) {
+      function restoreEndPoint(start) {
+        var container, offset, node;
+        function nodeIndex(container) {
+          var node = container.parentNode.firstChild, idx = 0;
+          while (node) {
+            if (node === container) {
+              return idx;
+            }
+            if (node.nodeType !== 1 || node.getAttribute('data-mce-type') !== 'bookmark') {
+              idx++;
+            }
+            node = node.nextSibling;
+          }
+          return -1;
+        }
+        container = node = bookmark[start ? 'startContainer' : 'endContainer'];
+        offset = bookmark[start ? 'startOffset' : 'endOffset'];
+        if (!container) {
+          return;
+        }
+        if (container.nodeType === 1) {
+          offset = nodeIndex(container);
+          container = container.parentNode;
+          dom.remove(node);
+        }
+        bookmark[start ? 'startContainer' : 'endContainer'] = container;
+        bookmark[start ? 'startOffset' : 'endOffset'] = offset;
+      }
+      restoreEndPoint(true);
+      restoreEndPoint();
+      var rng = dom.createRng();
+      rng.setStart(bookmark.startContainer, bookmark.startOffset);
+      if (bookmark.endContainer) {
+        rng.setEnd(bookmark.endContainer, bookmark.endOffset);
+      }
+      return rng;
+    };
+    var Bookmark = {
+      create: create$1,
+      resolve: resolve$1
+    };
+
+    var global$d = tinymce.util.Tools.resolve('tinymce.dom.TreeWalker');
+
+    var global$e = tinymce.util.Tools.resolve('tinymce.dom.RangeUtils');
+
+    var getSelectedElements = function (rootElm, startNode, endNode) {
+      var walker, node;
+      var elms = [];
+      walker = new global$d(startNode, rootElm);
+      for (node = startNode; node; node = walker.next()) {
+        if (node.nodeType === 1) {
+          elms.push(node);
+        }
+        if (node === endNode) {
+          break;
+        }
+      }
+      return elms;
+    };
+    var unwrapElements = function (editor, elms) {
+      var bookmark, dom, selection;
+      dom = editor.dom;
+      selection = editor.selection;
+      bookmark = Bookmark.create(dom, selection.getRng());
+      global$4.each(elms, function (elm) {
+        editor.dom.remove(elm, true);
+      });
+      selection.setRng(Bookmark.resolve(dom, bookmark));
+    };
+    var isLink = function (elm) {
+      return elm.nodeName === 'A' && elm.hasAttribute('href');
+    };
+    var getParentAnchorOrSelf = function (dom, elm) {
+      var anchorElm = dom.getParent(elm, isLink);
+      return anchorElm ? anchorElm : elm;
+    };
+    var getSelectedAnchors = function (editor) {
+      var startElm, endElm, rootElm, anchorElms, selection, dom, rng;
+      selection = editor.selection;
+      dom = editor.dom;
+      rng = selection.getRng();
+      startElm = getParentAnchorOrSelf(dom, global$e.getNode(rng.startContainer, rng.startOffset));
+      endElm = global$e.getNode(rng.endContainer, rng.endOffset);
+      rootElm = editor.getBody();
+      anchorElms = global$4.grep(getSelectedElements(rootElm, startElm, endElm), isLink);
+      return anchorElms;
+    };
+    var unlinkSelection = function (editor) {
+      unwrapElements(editor, getSelectedAnchors(editor));
+    };
+    var Unlink = { unlinkSelection: unlinkSelection };
+
+    var createTableHtml = function (cols, rows) {
+      var x, y, html;
+      html = '<table data-mce-id="mce" style="width: 100%">';
+      html += '<tbody>';
+      for (y = 0; y < rows; y++) {
+        html += '<tr>';
+        for (x = 0; x < cols; x++) {
+          html += '<td><br></td>';
+        }
+        html += '</tr>';
+      }
+      html += '</tbody>';
+      html += '</table>';
+      return html;
+    };
+    var getInsertedElement = function (editor) {
+      var elms = editor.dom.select('*[data-mce-id]');
+      return elms[0];
+    };
+    var insertTableHtml = function (editor, cols, rows) {
+      editor.undoManager.transact(function () {
+        var tableElm, cellElm;
+        editor.insertContent(createTableHtml(cols, rows));
+        tableElm = getInsertedElement(editor);
+        tableElm.removeAttribute('data-mce-id');
+        cellElm = editor.dom.select('td,th', tableElm);
+        editor.selection.setCursorLocation(cellElm[0], 0);
+      });
+    };
+    var insertTable = function (editor, cols, rows) {
+      editor.plugins.table ? editor.plugins.table.insertTable(cols, rows) : insertTableHtml(editor, cols, rows);
+    };
+    var formatBlock = function (editor, formatName) {
+      editor.execCommand('FormatBlock', false, formatName);
+    };
+    var insertBlob = function (editor, base64, blob) {
+      var blobCache, blobInfo;
+      blobCache = editor.editorUpload.blobCache;
+      blobInfo = blobCache.create(Uuid.uuid('mceu'), blob, base64);
+      blobCache.add(blobInfo);
+      editor.insertContent(editor.dom.createHTML('img', { src: blobInfo.blobUri() }));
+    };
+    var collapseSelectionToEnd = function (editor) {
+      editor.selection.collapse(false);
+    };
+    var unlink = function (editor) {
+      editor.focus();
+      Unlink.unlinkSelection(editor);
+      collapseSelectionToEnd(editor);
+    };
+    var changeHref = function (editor, elm, url) {
+      editor.focus();
+      editor.dom.setAttrib(elm, 'href', url);
+      collapseSelectionToEnd(editor);
+    };
+    var insertLink = function (editor, url) {
+      editor.execCommand('mceInsertLink', false, { href: url });
+      collapseSelectionToEnd(editor);
+    };
+    var updateOrInsertLink = function (editor, url) {
+      var elm = editor.dom.getParent(editor.selection.getStart(), 'a[href]');
+      elm ? changeHref(editor, elm, url) : insertLink(editor, url);
+    };
+    var createLink = function (editor, url) {
+      url.trim().length === 0 ? unlink(editor) : updateOrInsertLink(editor, url);
+    };
+    var Actions = {
+      insertTable: insertTable,
+      formatBlock: formatBlock,
+      insertBlob: insertBlob,
+      createLink: createLink,
+      unlink: unlink
+    };
+
+    var addHeaderButtons = function (editor) {
+      var formatBlock = function (name) {
+        return function () {
+          Actions.formatBlock(editor, name);
+        };
+      };
+      for (var i = 1; i < 6; i++) {
+        var name = 'h' + i;
+        editor.addButton(name, {
+          text: name.toUpperCase(),
+          tooltip: 'Heading ' + i,
+          stateSelector: name,
+          onclick: formatBlock(name),
+          onPostRender: function () {
+            var span = this.getEl().firstChild.firstChild;
+            span.style.fontWeight = 'bold';
+          }
+        });
+      }
+    };
+    var addToEditor = function (editor, panel) {
+      editor.addButton('quicklink', {
+        icon: 'link',
+        tooltip: 'Insert/Edit link',
+        stateSelector: 'a[href]',
+        onclick: function () {
+          panel.showForm(editor, 'quicklink');
+        }
+      });
+      editor.addButton('quickimage', {
+        icon: 'image',
+        tooltip: 'Insert image',
+        onclick: function () {
+          Picker.pickFile().then(function (files) {
+            var blob = files[0];
+            Conversions.blobToBase64(blob).then(function (base64) {
+              Actions.insertBlob(editor, base64, blob);
+            });
+          });
+        }
+      });
+      editor.addButton('quicktable', {
+        icon: 'table',
+        tooltip: 'Insert table',
+        onclick: function () {
+          panel.hide();
+          Actions.insertTable(editor, 2, 2);
+        }
+      });
+      addHeaderButtons(editor);
+    };
+    var Buttons = { addToEditor: addToEditor };
+
+    var getUiContainerDelta$1 = function () {
+      var uiContainer = global$1.container;
+      if (uiContainer && global$2.DOM.getStyle(uiContainer, 'position', true) !== 'static') {
+        var containerPos = global$2.DOM.getPos(uiContainer);
+        var dx = containerPos.x - uiContainer.scrollLeft;
+        var dy = containerPos.y - uiContainer.scrollTop;
+        return Option.some({
+          x: dx,
+          y: dy
+        });
+      } else {
+        return Option.none();
+      }
+    };
+    var UiContainer$1 = { getUiContainerDelta: getUiContainerDelta$1 };
+
+    var isDomainLike = function (href) {
+      return /^www\.|\.(com|org|edu|gov|uk|net|ca|de|jp|fr|au|us|ru|ch|it|nl|se|no|es|mil)$/i.test(href.trim());
+    };
+    var isAbsolute = function (href) {
+      return /^https?:\/\//.test(href.trim());
+    };
+    var UrlType = {
+      isDomainLike: isDomainLike,
+      isAbsolute: isAbsolute
+    };
+
+    var focusFirstTextBox = function (form) {
+      form.find('textbox').eq(0).each(function (ctrl) {
+        ctrl.focus();
+      });
+    };
+    var createForm = function (name, spec) {
+      var form = global$b.create(global$4.extend({
+        type: 'form',
+        layout: 'flex',
+        direction: 'row',
+        padding: 5,
+        name: name,
+        spacing: 3
+      }, spec));
+      form.on('show', function () {
+        focusFirstTextBox(form);
+      });
+      return form;
+    };
+    var toggleVisibility = function (ctrl, state) {
+      return state ? ctrl.show() : ctrl.hide();
+    };
+    var askAboutPrefix = function (editor, href) {
+      return new global$c(function (resolve) {
+        editor.windowManager.confirm('The URL you entered seems to be an external link. Do you want to add the required http:// prefix?', function (result) {
+          var output = result === true ? 'http://' + href : href;
+          resolve(output);
+        });
+      });
+    };
+    var convertLinkToAbsolute = function (editor, href) {
+      return !UrlType.isAbsolute(href) && UrlType.isDomainLike(href) ? askAboutPrefix(editor, href) : global$c.resolve(href);
+    };
+    var createQuickLinkForm = function (editor, hide) {
+      var attachState = {};
+      var unlink = function () {
+        editor.focus();
+        Actions.unlink(editor);
+        hide();
+      };
+      var onChangeHandler = function (e) {
+        var meta = e.meta;
+        if (meta && meta.attach) {
+          attachState = {
+            href: this.value(),
+            attach: meta.attach
+          };
+        }
+      };
+      var onShowHandler = function (e) {
+        if (e.control === this) {
+          var elm = void 0, linkurl = '';
+          elm = editor.dom.getParent(editor.selection.getStart(), 'a[href]');
+          if (elm) {
+            linkurl = editor.dom.getAttrib(elm, 'href');
+          }
+          this.fromJSON({ linkurl: linkurl });
+          toggleVisibility(this.find('#unlink'), elm);
+          this.find('#linkurl')[0].focus();
+        }
+      };
+      return createForm('quicklink', {
+        items: [
+          {
+            type: 'button',
+            name: 'unlink',
+            icon: 'unlink',
+            onclick: unlink,
+            tooltip: 'Remove link'
+          },
+          {
+            type: 'filepicker',
+            name: 'linkurl',
+            placeholder: 'Paste or type a link',
+            filetype: 'file',
+            onchange: onChangeHandler
+          },
+          {
+            type: 'button',
+            icon: 'checkmark',
+            subtype: 'primary',
+            tooltip: 'Ok',
+            onclick: 'submit'
+          }
+        ],
+        onshow: onShowHandler,
+        onsubmit: function (e) {
+          convertLinkToAbsolute(editor, e.data.linkurl).then(function (url) {
+            editor.undoManager.transact(function () {
+              if (url === attachState.href) {
+                attachState.attach();
+                attachState = {};
+              }
+              Actions.createLink(editor, url);
+            });
+            hide();
+          });
+        }
+      });
+    };
+    var Forms = { createQuickLinkForm: createQuickLinkForm };
+
+    var getSelectorStateResult = function (itemName, item) {
+      var result = function (selector, handler) {
+        return {
+          selector: selector,
+          handler: handler
+        };
+      };
+      var activeHandler = function (state) {
+        item.active(state);
+      };
+      var disabledHandler = function (state) {
+        item.disabled(state);
+      };
+      if (item.settings.stateSelector) {
+        return result(item.settings.stateSelector, activeHandler);
+      }
+      if (item.settings.disabledStateSelector) {
+        return result(item.settings.disabledStateSelector, disabledHandler);
+      }
+      return null;
+    };
+    var bindSelectorChanged = function (editor, itemName, item) {
+      return function () {
+        var result = getSelectorStateResult(itemName, item);
+        if (result !== null) {
+          editor.selection.selectorChanged(result.selector, result.handler);
+        }
+      };
+    };
+    var itemsToArray$1 = function (items) {
+      if (Type.isArray(items)) {
+        return items;
+      } else if (Type.isString(items)) {
+        return items.split(/[ ,]/);
+      }
+      return [];
+    };
+    var create$2 = function (editor, name, items) {
+      var toolbarItems = [];
+      var buttonGroup;
+      if (!items) {
+        return;
+      }
+      global$4.each(itemsToArray$1(items), function (item) {
+        if (item === '|') {
+          buttonGroup = null;
+        } else {
+          if (editor.buttons[item]) {
+            if (!buttonGroup) {
+              buttonGroup = {
+                type: 'buttongroup',
+                items: []
+              };
+              toolbarItems.push(buttonGroup);
+            }
+            var button = editor.buttons[item];
+            if (Type.isFunction(button)) {
+              button = button();
+            }
+            button.type = button.type || 'button';
+            button = global$b.create(button);
+            button.on('postRender', bindSelectorChanged(editor, item, button));
+            buttonGroup.items.push(button);
+          }
+        }
+      });
+      return global$b.create({
+        type: 'toolbar',
+        layout: 'flow',
+        name: name,
+        items: toolbarItems
+      });
+    };
+    var Toolbar = { create: create$2 };
+
+    var create$3 = function () {
+      var panel, currentRect;
+      var createToolbars = function (editor, toolbars) {
+        return global$4.map(toolbars, function (toolbar) {
+          return Toolbar.create(editor, toolbar.id, toolbar.items);
+        });
+      };
+      var hasToolbarItems = function (toolbar) {
+        return toolbar.items().length > 0;
+      };
+      var create = function (editor, toolbars) {
+        var items = createToolbars(editor, toolbars).concat([
+          Toolbar.create(editor, 'text', Settings.getTextSelectionToolbarItems(editor)),
+          Toolbar.create(editor, 'insert', Settings.getInsertToolbarItems(editor)),
+          Forms.createQuickLinkForm(editor, hide)
+        ]);
+        return global$b.create({
+          type: 'floatpanel',
+          role: 'dialog',
+          classes: 'tinymce tinymce-inline arrow',
+          ariaLabel: 'Inline toolbar',
+          layout: 'flex',
+          direction: 'column',
+          align: 'stretch',
+          autohide: false,
+          autofix: true,
+          fixed: true,
+          border: 1,
+          items: global$4.grep(items, hasToolbarItems),
+          oncancel: function () {
+            editor.focus();
+          }
+        });
+      };
+      var showPanel = function (panel) {
+        if (panel) {
+          panel.show();
+        }
+      };
+      var movePanelTo = function (panel, pos) {
+        panel.moveTo(pos.x, pos.y);
+      };
+      var togglePositionClass = function (panel, relPos) {
+        relPos = relPos ? relPos.substr(0, 2) : '';
+        global$4.each({
+          t: 'down',
+          b: 'up',
+          c: 'center'
+        }, function (cls, pos) {
+          panel.classes.toggle('arrow-' + cls, pos === relPos.substr(0, 1));
+        });
+        if (relPos === 'cr') {
+          panel.classes.toggle('arrow-left', true);
+          panel.classes.toggle('arrow-right', false);
+        } else if (relPos === 'cl') {
+          panel.classes.toggle('arrow-left', false);
+          panel.classes.toggle('arrow-right', true);
+        } else {
+          global$4.each({
+            l: 'left',
+            r: 'right'
+          }, function (cls, pos) {
+            panel.classes.toggle('arrow-' + cls, pos === relPos.substr(1, 1));
+          });
+        }
+      };
+      var showToolbar = function (panel, id) {
+        var toolbars = panel.items().filter('#' + id);
+        if (toolbars.length > 0) {
+          toolbars[0].show();
+          panel.reflow();
+          return true;
+        }
+        return false;
+      };
+      var repositionPanelAt = function (panel, id, editor, targetRect) {
+        var contentAreaRect, panelRect, result, userConstainHandler;
+        userConstainHandler = Settings.getPositionHandler(editor);
+        contentAreaRect = Measure.getContentAreaRect(editor);
+        panelRect = global$2.DOM.getRect(panel.getEl());
+        if (id === 'insert') {
+          result = Layout.calcInsert(targetRect, contentAreaRect, panelRect);
+        } else {
+          result = Layout.calc(targetRect, contentAreaRect, panelRect);
+        }
+        if (result) {
+          var delta = UiContainer$1.getUiContainerDelta().getOr({
+            x: 0,
+            y: 0
+          });
+          var transposedPanelRect = {
+            x: result.rect.x - delta.x,
+            y: result.rect.y - delta.y,
+            w: result.rect.w,
+            h: result.rect.h
+          };
+          currentRect = targetRect;
+          movePanelTo(panel, Layout.userConstrain(userConstainHandler, targetRect, contentAreaRect, transposedPanelRect));
+          togglePositionClass(panel, result.position);
+          return true;
+        } else {
+          return false;
+        }
+      };
+      var showPanelAt = function (panel, id, editor, targetRect) {
+        showPanel(panel);
+        panel.items().hide();
+        if (!showToolbar(panel, id)) {
+          hide();
+          return;
+        }
+        if (repositionPanelAt(panel, id, editor, targetRect) === false) {
+          hide();
+        }
+      };
+      var hasFormVisible = function () {
+        return panel.items().filter('form:visible').length > 0;
+      };
+      var showForm = function (editor, id) {
+        if (panel) {
+          panel.items().hide();
+          if (!showToolbar(panel, id)) {
+            hide();
+            return;
+          }
+          var contentAreaRect = void 0, panelRect = void 0, result = void 0, userConstainHandler = void 0;
+          showPanel(panel);
+          panel.items().hide();
+          showToolbar(panel, id);
+          userConstainHandler = Settings.getPositionHandler(editor);
+          contentAreaRect = Measure.getContentAreaRect(editor);
+          panelRect = global$2.DOM.getRect(panel.getEl());
+          result = Layout.calc(currentRect, contentAreaRect, panelRect);
+          if (result) {
+            panelRect = result.rect;
+            movePanelTo(panel, Layout.userConstrain(userConstainHandler, currentRect, contentAreaRect, panelRect));
+            togglePositionClass(panel, result.position);
+          }
+        }
+      };
+      var show = function (editor, id, targetRect, toolbars) {
+        if (!panel) {
+          Events.fireBeforeRenderUI(editor);
+          panel = create(editor, toolbars);
+          panel.renderTo().reflow().moveTo(targetRect.x, targetRect.y);
+          editor.nodeChanged();
+        }
+        showPanelAt(panel, id, editor, targetRect);
+      };
+      var reposition = function (editor, id, targetRect) {
+        if (panel) {
+          repositionPanelAt(panel, id, editor, targetRect);
+        }
+      };
+      var hide = function () {
+        if (panel) {
+          panel.hide();
+        }
+      };
+      var focus = function () {
+        if (panel) {
+          panel.find('toolbar:visible').eq(0).each(function (item) {
+            item.focus(true);
+          });
+        }
+      };
+      var remove = function () {
+        if (panel) {
+          panel.remove();
+          panel = null;
+        }
+      };
+      var inForm = function () {
+        return panel && panel.visible() && hasFormVisible();
+      };
+      return {
+        show: show,
+        showForm: showForm,
+        reposition: reposition,
+        inForm: inForm,
+        hide: hide,
+        focus: focus,
+        remove: remove
+      };
+    };
+
+    var Layout$1 = global$8.extend({
+      Defaults: {
+        firstControlClass: 'first',
+        lastControlClass: 'last'
+      },
+      init: function (settings) {
+        this.settings = global$4.extend({}, this.Defaults, settings);
+      },
+      preRender: function (container) {
+        container.bodyClasses.add(this.settings.containerClass);
+      },
+      applyClasses: function (items) {
+        var self = this;
+        var settings = self.settings;
+        var firstClass, lastClass, firstItem, lastItem;
+        firstClass = settings.firstControlClass;
+        lastClass = settings.lastControlClass;
+        items.each(function (item) {
+          item.classes.remove(firstClass).remove(lastClass).add(settings.controlClass);
+          if (item.visible()) {
+            if (!firstItem) {
+              firstItem = item;
+            }
+            lastItem = item;
+          }
+        });
+        if (firstItem) {
+          firstItem.classes.add(firstClass);
+        }
+        if (lastItem) {
+          lastItem.classes.add(lastClass);
+        }
+      },
+      renderHtml: function (container) {
+        var self = this;
+        var html = '';
+        self.applyClasses(container.items());
+        container.items().each(function (item) {
+          html += item.renderHtml();
+        });
+        return html;
+      },
+      recalc: function () {
+      },
+      postRender: function () {
+      },
+      isNative: function () {
+        return false;
+      }
+    });
+
+    var AbsoluteLayout = Layout$1.extend({
+      Defaults: {
+        containerClass: 'abs-layout',
+        controlClass: 'abs-layout-item'
+      },
+      recalc: function (container) {
+        container.items().filter(':visible').each(function (ctrl) {
+          var settings = ctrl.settings;
+          ctrl.layoutRect({
+            x: settings.x,
+            y: settings.y,
+            w: settings.w,
+            h: settings.h
+          });
+          if (ctrl.recalc) {
+            ctrl.recalc();
+          }
+        });
+      },
+      renderHtml: function (container) {
+        return '<div id="' + container._id + '-absend" class="' + container.classPrefix + 'abs-end"></div>' + this._super(container);
+      }
+    });
+
+    var Button = Widget.extend({
+      Defaults: {
+        classes: 'widget btn',
+        role: 'button'
+      },
+      init: function (settings) {
+        var self = this;
+        var size;
+        self._super(settings);
+        settings = self.settings;
+        size = self.settings.size;
+        self.on('click mousedown', function (e) {
+          e.preventDefault();
+        });
+        self.on('touchstart', function (e) {
+          self.fire('click', e);
+          e.preventDefault();
+        });
+        if (settings.subtype) {
+          self.classes.add(settings.subtype);
+        }
+        if (size) {
+          self.classes.add('btn-' + size);
+        }
+        if (settings.icon) {
+          self.icon(settings.icon);
+        }
+      },
+      icon: function (icon) {
+        if (!arguments.length) {
+          return this.state.get('icon');
+        }
+        this.state.set('icon', icon);
+        return this;
+      },
+      repaint: function () {
+        var btnElm = this.getEl().firstChild;
+        var btnStyle;
+        if (btnElm) {
+          btnStyle = btnElm.style;
+          btnStyle.width = btnStyle.height = '100%';
+        }
+        this._super();
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = self.classPrefix;
+        var icon = self.state.get('icon'), image;
+        var text = self.state.get('text');
+        var textHtml = '';
+        var ariaPressed;
+        var settings = self.settings;
+        image = settings.image;
+        if (image) {
+          icon = 'none';
+          if (typeof image !== 'string') {
+            image = domGlobals.window.getSelection ? image[0] : image[1];
+          }
+          image = ' style="background-image: url(\'' + image + '\')"';
+        } else {
+          image = '';
+        }
+        if (text) {
+          self.classes.add('btn-has-text');
+          textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
+        }
+        icon = icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
+        ariaPressed = typeof settings.active === 'boolean' ? ' aria-pressed="' + settings.active + '"' : '';
+        return '<div id="' + id + '" class="' + self.classes + '" tabindex="-1"' + ariaPressed + '>' + '<button id="' + id + '-button" role="presentation" type="button" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + textHtml + '</button>' + '</div>';
+      },
+      bindStates: function () {
+        var self = this, $ = self.$, textCls = self.classPrefix + 'txt';
+        function setButtonText(text) {
+          var $span = $('span.' + textCls, self.getEl());
+          if (text) {
+            if (!$span[0]) {
+              $('button:first', self.getEl()).append('<span class="' + textCls + '"></span>');
+              $span = $('span.' + textCls, self.getEl());
+            }
+            $span.html(self.encode(text));
+          } else {
+            $span.remove();
+          }
+          self.classes.toggle('btn-has-text', !!text);
+        }
+        self.state.on('change:text', function (e) {
+          setButtonText(e.value);
+        });
+        self.state.on('change:icon', function (e) {
+          var icon = e.value;
+          var prefix = self.classPrefix;
+          self.settings.icon = icon;
+          icon = icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
+          var btnElm = self.getEl().firstChild;
+          var iconElm = btnElm.getElementsByTagName('i')[0];
+          if (icon) {
+            if (!iconElm || iconElm !== btnElm.firstChild) {
+              iconElm = domGlobals.document.createElement('i');
+              btnElm.insertBefore(iconElm, btnElm.firstChild);
+            }
+            iconElm.className = icon;
+          } else if (iconElm) {
+            btnElm.removeChild(iconElm);
+          }
+          setButtonText(self.state.get('text'));
+        });
+        return self._super();
+      }
+    });
+
+    var BrowseButton = Button.extend({
+      init: function (settings) {
+        var self = this;
+        settings = global$4.extend({
+          text: 'Browse...',
+          multiple: false,
+          accept: null
+        }, settings);
+        self._super(settings);
+        self.classes.add('browsebutton');
+        if (settings.multiple) {
+          self.classes.add('multiple');
+        }
+      },
+      postRender: function () {
+        var self = this;
+        var input = funcs.create('input', {
+          type: 'file',
+          id: self._id + '-browse',
+          accept: self.settings.accept
+        });
+        self._super();
+        global$7(input).on('change', function (e) {
+          var files = e.target.files;
+          self.value = function () {
+            if (!files.length) {
+              return null;
+            } else if (self.settings.multiple) {
+              return files;
+            } else {
+              return files[0];
+            }
+          };
+          e.preventDefault();
+          if (files.length) {
+            self.fire('change', e);
+          }
+        });
+        global$7(input).on('click', function (e) {
+          e.stopPropagation();
+        });
+        global$7(self.getEl('button')).on('click touchstart', function (e) {
+          e.stopPropagation();
+          input.click();
+          e.preventDefault();
+        });
+        self.getEl().appendChild(input);
+      },
+      remove: function () {
+        global$7(this.getEl('button')).off();
+        global$7(this.getEl('input')).off();
+        this._super();
+      }
+    });
+
+    var ButtonGroup = Container.extend({
+      Defaults: {
+        defaultType: 'button',
+        role: 'group'
+      },
+      renderHtml: function () {
+        var self = this, layout = self._layout;
+        self.classes.add('btn-group');
+        self.preRender();
+        layout.preRender(self);
+        return '<div id="' + self._id + '" class="' + self.classes + '">' + '<div id="' + self._id + '-body">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</div>';
+      }
+    });
+
+    var Checkbox = Widget.extend({
+      Defaults: {
+        classes: 'checkbox',
+        role: 'checkbox',
+        checked: false
+      },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.on('click mousedown', function (e) {
+          e.preventDefault();
+        });
+        self.on('click', function (e) {
+          e.preventDefault();
+          if (!self.disabled()) {
+            self.checked(!self.checked());
+          }
+        });
+        self.checked(self.settings.checked);
+      },
+      checked: function (state) {
+        if (!arguments.length) {
+          return this.state.get('checked');
+        }
+        this.state.set('checked', state);
+        return this;
+      },
+      value: function (state) {
+        if (!arguments.length) {
+          return this.checked();
+        }
+        return this.checked(state);
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = self.classPrefix;
+        return '<div id="' + id + '" class="' + self.classes + '" unselectable="on" aria-labelledby="' + id + '-al" tabindex="-1">' + '<i class="' + prefix + 'ico ' + prefix + 'i-checkbox"></i>' + '<span id="' + id + '-al" class="' + prefix + 'label">' + self.encode(self.state.get('text')) + '</span>' + '</div>';
+      },
+      bindStates: function () {
+        var self = this;
+        function checked(state) {
+          self.classes.toggle('checked', state);
+          self.aria('checked', state);
+        }
+        self.state.on('change:text', function (e) {
+          self.getEl('al').firstChild.data = self.translate(e.value);
+        });
+        self.state.on('change:checked change:value', function (e) {
+          self.fire('change');
+          checked(e.value);
+        });
+        self.state.on('change:icon', function (e) {
+          var icon = e.value;
+          var prefix = self.classPrefix;
+          if (typeof icon === 'undefined') {
+            return self.settings.icon;
+          }
+          self.settings.icon = icon;
+          icon = icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
+          var btnElm = self.getEl().firstChild;
+          var iconElm = btnElm.getElementsByTagName('i')[0];
+          if (icon) {
+            if (!iconElm || iconElm !== btnElm.firstChild) {
+              iconElm = domGlobals.document.createElement('i');
+              btnElm.insertBefore(iconElm, btnElm.firstChild);
+            }
+            iconElm.className = icon;
+          } else if (iconElm) {
+            btnElm.removeChild(iconElm);
+          }
+        });
+        if (self.state.get('checked')) {
+          checked(true);
+        }
+        return self._super();
+      }
+    });
+
+    var global$f = tinymce.util.Tools.resolve('tinymce.util.VK');
+
+    var ComboBox = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        settings = self.settings;
+        self.classes.add('combobox');
+        self.subinput = true;
+        self.ariaTarget = 'inp';
+        settings.menu = settings.menu || settings.values;
+        if (settings.menu) {
+          settings.icon = 'caret';
+        }
+        self.on('click', function (e) {
+          var elm = e.target;
+          var root = self.getEl();
+          if (!global$7.contains(root, elm) && elm !== root) {
+            return;
+          }
+          while (elm && elm !== root) {
+            if (elm.id && elm.id.indexOf('-open') !== -1) {
+              self.fire('action');
+              if (settings.menu) {
+                self.showMenu();
+                if (e.aria) {
+                  self.menu.items()[0].focus();
+                }
+              }
+            }
+            elm = elm.parentNode;
+          }
+        });
+        self.on('keydown', function (e) {
+          var rootControl;
+          if (e.keyCode === 13 && e.target.nodeName === 'INPUT') {
+            e.preventDefault();
+            self.parents().reverse().each(function (ctrl) {
+              if (ctrl.toJSON) {
+                rootControl = ctrl;
+                return false;
+              }
+            });
+            self.fire('submit', { data: rootControl.toJSON() });
+          }
+        });
+        self.on('keyup', function (e) {
+          if (e.target.nodeName === 'INPUT') {
+            var oldValue = self.state.get('value');
+            var newValue = e.target.value;
+            if (newValue !== oldValue) {
+              self.state.set('value', newValue);
+              self.fire('autocomplete', e);
+            }
+          }
+        });
+        self.on('mouseover', function (e) {
+          var tooltip = self.tooltip().moveTo(-65535);
+          if (self.statusLevel() && e.target.className.indexOf(self.classPrefix + 'status') !== -1) {
+            var statusMessage = self.statusMessage() || 'Ok';
+            var rel = tooltip.text(statusMessage).show().testMoveRel(e.target, [
+              'bc-tc',
+              'bc-tl',
+              'bc-tr'
+            ]);
+            tooltip.classes.toggle('tooltip-n', rel === 'bc-tc');
+            tooltip.classes.toggle('tooltip-nw', rel === 'bc-tl');
+            tooltip.classes.toggle('tooltip-ne', rel === 'bc-tr');
+            tooltip.moveRel(e.target, rel);
+          }
+        });
+      },
+      statusLevel: function (value) {
+        if (arguments.length > 0) {
+          this.state.set('statusLevel', value);
+        }
+        return this.state.get('statusLevel');
+      },
+      statusMessage: function (value) {
+        if (arguments.length > 0) {
+          this.state.set('statusMessage', value);
+        }
+        return this.state.get('statusMessage');
+      },
+      showMenu: function () {
+        var self = this;
+        var settings = self.settings;
+        var menu;
+        if (!self.menu) {
+          menu = settings.menu || [];
+          if (menu.length) {
+            menu = {
+              type: 'menu',
+              items: menu
+            };
+          } else {
+            menu.type = menu.type || 'menu';
+          }
+          self.menu = global$b.create(menu).parent(self).renderTo(self.getContainerElm());
+          self.fire('createmenu');
+          self.menu.reflow();
+          self.menu.on('cancel', function (e) {
+            if (e.control === self.menu) {
+              self.focus();
+            }
+          });
+          self.menu.on('show hide', function (e) {
+            e.control.items().each(function (ctrl) {
+              ctrl.active(ctrl.value() === self.value());
+            });
+          }).fire('show');
+          self.menu.on('select', function (e) {
+            self.value(e.control.value());
+          });
+          self.on('focusin', function (e) {
+            if (e.target.tagName.toUpperCase() === 'INPUT') {
+              self.menu.hide();
+            }
+          });
+          self.aria('expanded', true);
+        }
+        self.menu.show();
+        self.menu.layoutRect({ w: self.layoutRect().w });
+        self.menu.moveRel(self.getEl(), self.isRtl() ? [
+          'br-tr',
+          'tr-br'
+        ] : [
+          'bl-tl',
+          'tl-bl'
+        ]);
+      },
+      focus: function () {
+        this.getEl('inp').focus();
+      },
+      repaint: function () {
+        var self = this, elm = self.getEl(), openElm = self.getEl('open'), rect = self.layoutRect();
+        var width, lineHeight, innerPadding = 0;
+        var inputElm = elm.firstChild;
+        if (self.statusLevel() && self.statusLevel() !== 'none') {
+          innerPadding = parseInt(funcs.getRuntimeStyle(inputElm, 'padding-right'), 10) - parseInt(funcs.getRuntimeStyle(inputElm, 'padding-left'), 10);
+        }
+        if (openElm) {
+          width = rect.w - funcs.getSize(openElm).width - 10;
+        } else {
+          width = rect.w - 10;
+        }
+        var doc = domGlobals.document;
+        if (doc.all && (!doc.documentMode || doc.documentMode <= 8)) {
+          lineHeight = self.layoutRect().h - 2 + 'px';
+        }
+        global$7(inputElm).css({
+          width: width - innerPadding,
+          lineHeight: lineHeight
+        });
+        self._super();
+        return self;
+      },
+      postRender: function () {
+        var self = this;
+        global$7(this.getEl('inp')).on('change', function (e) {
+          self.state.set('value', e.target.value);
+          self.fire('change', e);
+        });
+        return self._super();
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, settings = self.settings, prefix = self.classPrefix;
+        var value = self.state.get('value') || '';
+        var icon, text, openBtnHtml = '', extraAttrs = '', statusHtml = '';
+        if ('spellcheck' in settings) {
+          extraAttrs += ' spellcheck="' + settings.spellcheck + '"';
+        }
+        if (settings.maxLength) {
+          extraAttrs += ' maxlength="' + settings.maxLength + '"';
+        }
+        if (settings.size) {
+          extraAttrs += ' size="' + settings.size + '"';
+        }
+        if (settings.subtype) {
+          extraAttrs += ' type="' + settings.subtype + '"';
+        }
+        statusHtml = '<i id="' + id + '-status" class="mce-status mce-ico" style="display: none"></i>';
+        if (self.disabled()) {
+          extraAttrs += ' disabled="disabled"';
+        }
+        icon = settings.icon;
+        if (icon && icon !== 'caret') {
+          icon = prefix + 'ico ' + prefix + 'i-' + settings.icon;
+        }
+        text = self.state.get('text');
+        if (icon || text) {
+          openBtnHtml = '<div id="' + id + '-open" class="' + prefix + 'btn ' + prefix + 'open" tabIndex="-1" role="button">' + '<button id="' + id + '-action" type="button" hidefocus="1" tabindex="-1">' + (icon !== 'caret' ? '<i class="' + icon + '"></i>' : '<i class="' + prefix + 'caret"></i>') + (text ? (icon ? ' ' : '') + text : '') + '</button>' + '</div>';
+          self.classes.add('has-open');
+        }
+        return '<div id="' + id + '" class="' + self.classes + '">' + '<input id="' + id + '-inp" class="' + prefix + 'textbox" value="' + self.encode(value, false) + '" hidefocus="1"' + extraAttrs + ' placeholder="' + self.encode(settings.placeholder) + '" />' + statusHtml + openBtnHtml + '</div>';
+      },
+      value: function (value) {
+        if (arguments.length) {
+          this.state.set('value', value);
+          return this;
+        }
+        if (this.state.get('rendered')) {
+          this.state.set('value', this.getEl('inp').value);
+        }
+        return this.state.get('value');
+      },
+      showAutoComplete: function (items, term) {
+        var self = this;
+        if (items.length === 0) {
+          self.hideMenu();
+          return;
+        }
+        var insert = function (value, title) {
+          return function () {
+            self.fire('selectitem', {
+              title: title,
+              value: value
+            });
+          };
+        };
+        if (self.menu) {
+          self.menu.items().remove();
+        } else {
+          self.menu = global$b.create({
+            type: 'menu',
+            classes: 'combobox-menu',
+            layout: 'flow'
+          }).parent(self).renderTo();
+        }
+        global$4.each(items, function (item) {
+          self.menu.add({
+            text: item.title,
+            url: item.previewUrl,
+            match: term,
+            classes: 'menu-item-ellipsis',
+            onclick: insert(item.value, item.title)
+          });
+        });
+        self.menu.renderNew();
+        self.hideMenu();
+        self.menu.on('cancel', function (e) {
+          if (e.control.parent() === self.menu) {
+            e.stopPropagation();
+            self.focus();
+            self.hideMenu();
+          }
+        });
+        self.menu.on('select', function () {
+          self.focus();
+        });
+        var maxW = self.layoutRect().w;
+        self.menu.layoutRect({
+          w: maxW,
+          minW: 0,
+          maxW: maxW
+        });
+        self.menu.repaint();
+        self.menu.reflow();
+        self.menu.show();
+        self.menu.moveRel(self.getEl(), self.isRtl() ? [
+          'br-tr',
+          'tr-br'
+        ] : [
+          'bl-tl',
+          'tl-bl'
+        ]);
+      },
+      hideMenu: function () {
+        if (this.menu) {
+          this.menu.hide();
+        }
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:value', function (e) {
+          if (self.getEl('inp').value !== e.value) {
+            self.getEl('inp').value = e.value;
+          }
+        });
+        self.state.on('change:disabled', function (e) {
+          self.getEl('inp').disabled = e.value;
+        });
+        self.state.on('change:statusLevel', function (e) {
+          var statusIconElm = self.getEl('status');
+          var prefix = self.classPrefix, value = e.value;
+          funcs.css(statusIconElm, 'display', value === 'none' ? 'none' : '');
+          funcs.toggleClass(statusIconElm, prefix + 'i-checkmark', value === 'ok');
+          funcs.toggleClass(statusIconElm, prefix + 'i-warning', value === 'warn');
+          funcs.toggleClass(statusIconElm, prefix + 'i-error', value === 'error');
+          self.classes.toggle('has-status', value !== 'none');
+          self.repaint();
+        });
+        funcs.on(self.getEl('status'), 'mouseleave', function () {
+          self.tooltip().hide();
+        });
+        self.on('cancel', function (e) {
+          if (self.menu && self.menu.visible()) {
+            e.stopPropagation();
+            self.hideMenu();
+          }
+        });
+        var focusIdx = function (idx, menu) {
+          if (menu && menu.items().length > 0) {
+            menu.items().eq(idx)[0].focus();
+          }
+        };
+        self.on('keydown', function (e) {
+          var keyCode = e.keyCode;
+          if (e.target.nodeName === 'INPUT') {
+            if (keyCode === global$f.DOWN) {
+              e.preventDefault();
+              self.fire('autocomplete');
+              focusIdx(0, self.menu);
+            } else if (keyCode === global$f.UP) {
+              e.preventDefault();
+              focusIdx(-1, self.menu);
+            }
+          }
+        });
+        return self._super();
+      },
+      remove: function () {
+        global$7(this.getEl('inp')).off();
+        if (this.menu) {
+          this.menu.remove();
+        }
+        this._super();
+      }
+    });
+
+    var ColorBox = ComboBox.extend({
+      init: function (settings) {
+        var self = this;
+        settings.spellcheck = false;
+        if (settings.onaction) {
+          settings.icon = 'none';
+        }
+        self._super(settings);
+        self.classes.add('colorbox');
+        self.on('change keyup postrender', function () {
+          self.repaintColor(self.value());
+        });
+      },
+      repaintColor: function (value) {
+        var openElm = this.getEl('open');
+        var elm = openElm ? openElm.getElementsByTagName('i')[0] : null;
+        if (elm) {
+          try {
+            elm.style.background = value;
+          } catch (ex) {
+          }
+        }
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:value', function (e) {
+          if (self.state.get('rendered')) {
+            self.repaintColor(e.value);
+          }
+        });
+        return self._super();
+      }
+    });
+
+    var PanelButton = Button.extend({
+      showPanel: function () {
+        var self = this, settings = self.settings;
+        self.classes.add('opened');
+        if (!self.panel) {
+          var panelSettings = settings.panel;
+          if (panelSettings.type) {
+            panelSettings = {
+              layout: 'grid',
+              items: panelSettings
+            };
+          }
+          panelSettings.role = panelSettings.role || 'dialog';
+          panelSettings.popover = true;
+          panelSettings.autohide = true;
+          panelSettings.ariaRoot = true;
+          self.panel = new FloatPanel(panelSettings).on('hide', function () {
+            self.classes.remove('opened');
+          }).on('cancel', function (e) {
+            e.stopPropagation();
+            self.focus();
+            self.hidePanel();
+          }).parent(self).renderTo(self.getContainerElm());
+          self.panel.fire('show');
+          self.panel.reflow();
+        } else {
+          self.panel.show();
+        }
+        var rtlRels = [
+          'bc-tc',
+          'bc-tl',
+          'bc-tr'
+        ];
+        var ltrRels = [
+          'bc-tc',
+          'bc-tr',
+          'bc-tl',
+          'tc-bc',
+          'tc-br',
+          'tc-bl'
+        ];
+        var rel = self.panel.testMoveRel(self.getEl(), settings.popoverAlign || (self.isRtl() ? rtlRels : ltrRels));
+        self.panel.classes.toggle('start', rel.substr(-1) === 'l');
+        self.panel.classes.toggle('end', rel.substr(-1) === 'r');
+        var isTop = rel.substr(0, 1) === 't';
+        self.panel.classes.toggle('bottom', !isTop);
+        self.panel.classes.toggle('top', isTop);
+        self.panel.moveRel(self.getEl(), rel);
+      },
+      hidePanel: function () {
+        var self = this;
+        if (self.panel) {
+          self.panel.hide();
+        }
+      },
+      postRender: function () {
+        var self = this;
+        self.aria('haspopup', true);
+        self.on('click', function (e) {
+          if (e.control === self) {
+            if (self.panel && self.panel.visible()) {
+              self.hidePanel();
+            } else {
+              self.showPanel();
+              self.panel.focus(!!e.aria);
+            }
+          }
+        });
+        return self._super();
+      },
+      remove: function () {
+        if (this.panel) {
+          this.panel.remove();
+          this.panel = null;
+        }
+        return this._super();
+      }
+    });
+
+    var DOM = global$2.DOM;
+    var ColorButton = PanelButton.extend({
+      init: function (settings) {
+        this._super(settings);
+        this.classes.add('splitbtn');
+        this.classes.add('colorbutton');
+      },
+      color: function (color) {
+        if (color) {
+          this._color = color;
+          this.getEl('preview').style.backgroundColor = color;
+          return this;
+        }
+        return this._color;
+      },
+      resetColor: function () {
+        this._color = null;
+        this.getEl('preview').style.backgroundColor = null;
+        return this;
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = self.classPrefix, text = self.state.get('text');
+        var icon = self.settings.icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
+        var image = self.settings.image ? ' style="background-image: url(\'' + self.settings.image + '\')"' : '';
+        var textHtml = '';
+        if (text) {
+          self.classes.add('btn-has-text');
+          textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
+        }
+        return '<div id="' + id + '" class="' + self.classes + '" role="button" tabindex="-1" aria-haspopup="true">' + '<button role="presentation" hidefocus="1" type="button" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + '<span id="' + id + '-preview" class="' + prefix + 'preview"></span>' + textHtml + '</button>' + '<button type="button" class="' + prefix + 'open" hidefocus="1" tabindex="-1">' + ' <i class="' + prefix + 'caret"></i>' + '</button>' + '</div>';
+      },
+      postRender: function () {
+        var self = this, onClickHandler = self.settings.onclick;
+        self.on('click', function (e) {
+          if (e.aria && e.aria.key === 'down') {
+            return;
+          }
+          if (e.control === self && !DOM.getParent(e.target, '.' + self.classPrefix + 'open')) {
+            e.stopImmediatePropagation();
+            onClickHandler.call(self, e);
+          }
+        });
+        delete self.settings.onclick;
+        return self._super();
+      }
+    });
+
+    var global$g = tinymce.util.Tools.resolve('tinymce.util.Color');
+
+    var ColorPicker = Widget.extend({
+      Defaults: { classes: 'widget colorpicker' },
+      init: function (settings) {
+        this._super(settings);
+      },
+      postRender: function () {
+        var self = this;
+        var color = self.color();
+        var hsv, hueRootElm, huePointElm, svRootElm, svPointElm;
+        hueRootElm = self.getEl('h');
+        huePointElm = self.getEl('hp');
+        svRootElm = self.getEl('sv');
+        svPointElm = self.getEl('svp');
+        function getPos(elm, event) {
+          var pos = funcs.getPos(elm);
+          var x, y;
+          x = event.pageX - pos.x;
+          y = event.pageY - pos.y;
+          x = Math.max(0, Math.min(x / elm.clientWidth, 1));
+          y = Math.max(0, Math.min(y / elm.clientHeight, 1));
+          return {
+            x: x,
+            y: y
+          };
+        }
+        function updateColor(hsv, hueUpdate) {
+          var hue = (360 - hsv.h) / 360;
+          funcs.css(huePointElm, { top: hue * 100 + '%' });
+          if (!hueUpdate) {
+            funcs.css(svPointElm, {
+              left: hsv.s + '%',
+              top: 100 - hsv.v + '%'
+            });
+          }
+          svRootElm.style.background = global$g({
+            s: 100,
+            v: 100,
+            h: hsv.h
+          }).toHex();
+          self.color().parse({
+            s: hsv.s,
+            v: hsv.v,
+            h: hsv.h
+          });
+        }
+        function updateSaturationAndValue(e) {
+          var pos;
+          pos = getPos(svRootElm, e);
+          hsv.s = pos.x * 100;
+          hsv.v = (1 - pos.y) * 100;
+          updateColor(hsv);
+          self.fire('change');
+        }
+        function updateHue(e) {
+          var pos;
+          pos = getPos(hueRootElm, e);
+          hsv = color.toHsv();
+          hsv.h = (1 - pos.y) * 360;
+          updateColor(hsv, true);
+          self.fire('change');
+        }
+        self._repaint = function () {
+          hsv = color.toHsv();
+          updateColor(hsv);
+        };
+        self._super();
+        self._svdraghelper = new DragHelper(self._id + '-sv', {
+          start: updateSaturationAndValue,
+          drag: updateSaturationAndValue
+        });
+        self._hdraghelper = new DragHelper(self._id + '-h', {
+          start: updateHue,
+          drag: updateHue
+        });
+        self._repaint();
+      },
+      rgb: function () {
+        return this.color().toRgb();
+      },
+      value: function (value) {
+        var self = this;
+        if (arguments.length) {
+          self.color().parse(value);
+          if (self._rendered) {
+            self._repaint();
+          }
+        } else {
+          return self.color().toHex();
+        }
+      },
+      color: function () {
+        if (!this._color) {
+          this._color = global$g();
+        }
+        return this._color;
+      },
+      renderHtml: function () {
+        var self = this;
+        var id = self._id;
+        var prefix = self.classPrefix;
+        var hueHtml;
+        var stops = '#ff0000,#ff0080,#ff00ff,#8000ff,#0000ff,#0080ff,#00ffff,#00ff80,#00ff00,#80ff00,#ffff00,#ff8000,#ff0000';
+        function getOldIeFallbackHtml() {
+          var i, l, html = '', gradientPrefix, stopsList;
+          gradientPrefix = 'filter:progid:DXImageTransform.Microsoft.gradient(GradientType=0,startColorstr=';
+          stopsList = stops.split(',');
+          for (i = 0, l = stopsList.length - 1; i < l; i++) {
+            html += '<div class="' + prefix + 'colorpicker-h-chunk" style="' + 'height:' + 100 / l + '%;' + gradientPrefix + stopsList[i] + ',endColorstr=' + stopsList[i + 1] + ');' + '-ms-' + gradientPrefix + stopsList[i] + ',endColorstr=' + stopsList[i + 1] + ')' + '"></div>';
+          }
+          return html;
+        }
+        var gradientCssText = 'background: -ms-linear-gradient(top,' + stops + ');' + 'background: linear-gradient(to bottom,' + stops + ');';
+        hueHtml = '<div id="' + id + '-h" class="' + prefix + 'colorpicker-h" style="' + gradientCssText + '">' + getOldIeFallbackHtml() + '<div id="' + id + '-hp" class="' + prefix + 'colorpicker-h-marker"></div>' + '</div>';
+        return '<div id="' + id + '" class="' + self.classes + '">' + '<div id="' + id + '-sv" class="' + prefix + 'colorpicker-sv">' + '<div class="' + prefix + 'colorpicker-overlay1">' + '<div class="' + prefix + 'colorpicker-overlay2">' + '<div id="' + id + '-svp" class="' + prefix + 'colorpicker-selector1">' + '<div class="' + prefix + 'colorpicker-selector2"></div>' + '</div>' + '</div>' + '</div>' + '</div>' + hueHtml + '</div>';
+      }
+    });
+
+    var DropZone = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        settings = global$4.extend({
+          height: 100,
+          text: 'Drop an image here',
+          multiple: false,
+          accept: null
+        }, settings);
+        self._super(settings);
+        self.classes.add('dropzone');
+        if (settings.multiple) {
+          self.classes.add('multiple');
+        }
+      },
+      renderHtml: function () {
+        var self = this;
+        var attrs, elm;
+        var cfg = self.settings;
+        attrs = {
+          id: self._id,
+          hidefocus: '1'
+        };
+        elm = funcs.create('div', attrs, '<span>' + this.translate(cfg.text) + '</span>');
+        if (cfg.height) {
+          funcs.css(elm, 'height', cfg.height + 'px');
+        }
+        if (cfg.width) {
+          funcs.css(elm, 'width', cfg.width + 'px');
+        }
+        elm.className = self.classes;
+        return elm.outerHTML;
+      },
+      postRender: function () {
+        var self = this;
+        var toggleDragClass = function (e) {
+          e.preventDefault();
+          self.classes.toggle('dragenter');
+          self.getEl().className = self.classes;
+        };
+        var filter = function (files) {
+          var accept = self.settings.accept;
+          if (typeof accept !== 'string') {
+            return files;
+          }
+          var re = new RegExp('(' + accept.split(/\s*,\s*/).join('|') + ')$', 'i');
+          return global$4.grep(files, function (file) {
+            return re.test(file.name);
+          });
+        };
+        self._super();
+        self.$el.on('dragover', function (e) {
+          e.preventDefault();
+        });
+        self.$el.on('dragenter', toggleDragClass);
+        self.$el.on('dragleave', toggleDragClass);
+        self.$el.on('drop', function (e) {
+          e.preventDefault();
+          if (self.state.get('disabled')) {
+            return;
+          }
+          var files = filter(e.dataTransfer.files);
+          self.value = function () {
+            if (!files.length) {
+              return null;
+            } else if (self.settings.multiple) {
+              return files;
+            } else {
+              return files[0];
+            }
+          };
+          if (files.length) {
+            self.fire('change', e);
+          }
+        });
+      },
+      remove: function () {
+        this.$el.off();
+        this._super();
+      }
+    });
+
+    var Path = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        if (!settings.delimiter) {
+          settings.delimiter = '\xBB';
+        }
+        self._super(settings);
+        self.classes.add('path');
+        self.canFocus = true;
+        self.on('click', function (e) {
+          var index;
+          var target = e.target;
+          if (index = target.getAttribute('data-index')) {
+            self.fire('select', {
+              value: self.row()[index],
+              index: index
+            });
+          }
+        });
+        self.row(self.settings.row);
+      },
+      focus: function () {
+        var self = this;
+        self.getEl().firstChild.focus();
+        return self;
+      },
+      row: function (row) {
+        if (!arguments.length) {
+          return this.state.get('row');
+        }
+        this.state.set('row', row);
+        return this;
+      },
+      renderHtml: function () {
+        var self = this;
+        return '<div id="' + self._id + '" class="' + self.classes + '">' + self._getDataPathHtml(self.state.get('row')) + '</div>';
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:row', function (e) {
+          self.innerHtml(self._getDataPathHtml(e.value));
+        });
+        return self._super();
+      },
+      _getDataPathHtml: function (data) {
+        var self = this;
+        var parts = data || [];
+        var i, l, html = '';
+        var prefix = self.classPrefix;
+        for (i = 0, l = parts.length; i < l; i++) {
+          html += (i > 0 ? '<div class="' + prefix + 'divider" aria-hidden="true"> ' + self.settings.delimiter + ' </div>' : '') + '<div role="button" class="' + prefix + 'path-item' + (i === l - 1 ? ' ' + prefix + 'last' : '') + '" data-index="' + i + '" tabindex="-1" id="' + self._id + '-' + i + '" aria-level="' + (i + 1) + '">' + parts[i].name + '</div>';
+        }
+        if (!html) {
+          html = '<div class="' + prefix + 'path-item">\xA0</div>';
+        }
+        return html;
+      }
+    });
+
+    var ElementPath = Path.extend({
+      postRender: function () {
+        var self = this, editor = self.settings.editor;
+        function isHidden(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;
+        }
+        if (editor.settings.elementpath !== false) {
+          self.on('select', function (e) {
+            editor.focus();
+            editor.selection.select(this.row()[e.index].element);
+            editor.nodeChanged();
+          });
+          editor.on('nodeChange', function (e) {
+            var outParents = [];
+            var parents = e.parents;
+            var i = parents.length;
+            while (i--) {
+              if (parents[i].nodeType === 1 && !isHidden(parents[i])) {
+                var args = editor.fire('ResolveName', {
+                  name: parents[i].nodeName.toLowerCase(),
+                  target: parents[i]
+                });
+                if (!args.isDefaultPrevented()) {
+                  outParents.push({
+                    name: args.name,
+                    element: parents[i]
+                  });
+                }
+                if (args.isPropagationStopped()) {
+                  break;
+                }
+              }
+            }
+            self.row(outParents);
+          });
+        }
+        return self._super();
+      }
+    });
+
+    var FormItem = Container.extend({
+      Defaults: {
+        layout: 'flex',
+        align: 'center',
+        defaults: { flex: 1 }
+      },
+      renderHtml: function () {
+        var self = this, layout = self._layout, prefix = self.classPrefix;
+        self.classes.add('formitem');
+        layout.preRender(self);
+        return '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' + (self.settings.title ? '<div id="' + self._id + '-title" class="' + prefix + 'title">' + self.settings.title + '</div>' : '') + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</div>';
+      }
+    });
+
+    var Form = Container.extend({
+      Defaults: {
+        containerCls: 'form',
+        layout: 'flex',
+        direction: 'column',
+        align: 'stretch',
+        flex: 1,
+        padding: 15,
+        labelGap: 30,
+        spacing: 10,
+        callbacks: {
+          submit: function () {
+            this.submit();
+          }
+        }
+      },
+      preRender: function () {
+        var self = this, items = self.items();
+        if (!self.settings.formItemDefaults) {
+          self.settings.formItemDefaults = {
+            layout: 'flex',
+            autoResize: 'overflow',
+            defaults: { flex: 1 }
+          };
+        }
+        items.each(function (ctrl) {
+          var formItem;
+          var label = ctrl.settings.label;
+          if (label) {
+            formItem = new FormItem(global$4.extend({
+              items: {
+                type: 'label',
+                id: ctrl._id + '-l',
+                text: label,
+                flex: 0,
+                forId: ctrl._id,
+                disabled: ctrl.disabled()
+              }
+            }, self.settings.formItemDefaults));
+            formItem.type = 'formitem';
+            ctrl.aria('labelledby', ctrl._id + '-l');
+            if (typeof ctrl.settings.flex === 'undefined') {
+              ctrl.settings.flex = 1;
+            }
+            self.replace(ctrl, formItem);
+            formItem.add(ctrl);
+          }
+        });
+      },
+      submit: function () {
+        return this.fire('submit', { data: this.toJSON() });
+      },
+      postRender: function () {
+        var self = this;
+        self._super();
+        self.fromJSON(self.settings.data);
+      },
+      bindStates: function () {
+        var self = this;
+        self._super();
+        function recalcLabels() {
+          var maxLabelWidth = 0;
+          var labels = [];
+          var i, labelGap, items;
+          if (self.settings.labelGapCalc === false) {
+            return;
+          }
+          if (self.settings.labelGapCalc === 'children') {
+            items = self.find('formitem');
+          } else {
+            items = self.items();
+          }
+          items.filter('formitem').each(function (item) {
+            var labelCtrl = item.items()[0], labelWidth = labelCtrl.getEl().clientWidth;
+            maxLabelWidth = labelWidth > maxLabelWidth ? labelWidth : maxLabelWidth;
+            labels.push(labelCtrl);
+          });
+          labelGap = self.settings.labelGap || 0;
+          i = labels.length;
+          while (i--) {
+            labels[i].settings.minWidth = maxLabelWidth + labelGap;
+          }
+        }
+        self.on('show', recalcLabels);
+        recalcLabels();
+      }
+    });
+
+    var FieldSet = Form.extend({
+      Defaults: {
+        containerCls: 'fieldset',
+        layout: 'flex',
+        direction: 'column',
+        align: 'stretch',
+        flex: 1,
+        padding: '25 15 5 15',
+        labelGap: 30,
+        spacing: 10,
+        border: 1
+      },
+      renderHtml: function () {
+        var self = this, layout = self._layout, prefix = self.classPrefix;
+        self.preRender();
+        layout.preRender(self);
+        return '<fieldset id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' + (self.settings.title ? '<legend id="' + self._id + '-title" class="' + prefix + 'fieldset-title">' + self.settings.title + '</legend>' : '') + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</fieldset>';
+      }
+    });
+
+    var unique$1 = 0;
+    var generate = function (prefix) {
+      var date = new Date();
+      var time = date.getTime();
+      var random = Math.floor(Math.random() * 1000000000);
+      unique$1++;
+      return prefix + '_' + random + unique$1 + String(time);
+    };
+
+    var fromHtml = function (html, scope) {
+      var doc = scope || domGlobals.document;
+      var div = doc.createElement('div');
+      div.innerHTML = html;
+      if (!div.hasChildNodes() || div.childNodes.length > 1) {
+        domGlobals.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 || domGlobals.document;
+      var node = doc.createElement(tag);
+      return fromDom(node);
+    };
+    var fromText = function (text, scope) {
+      var doc = scope || domGlobals.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: constant(node) };
+    };
+    var fromPoint = function (docElm, x, y) {
+      var doc = docElm.dom();
+      return Option.from(doc.elementFromPoint(x, y)).map(fromDom);
+    };
+    var Element = {
+      fromHtml: fromHtml,
+      fromTag: fromTag,
+      fromText: fromText,
+      fromDom: fromDom,
+      fromPoint: fromPoint
+    };
+
+    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 ATTRIBUTE = domGlobals.Node.ATTRIBUTE_NODE;
+    var CDATA_SECTION = domGlobals.Node.CDATA_SECTION_NODE;
+    var COMMENT = domGlobals.Node.COMMENT_NODE;
+    var DOCUMENT = domGlobals.Node.DOCUMENT_NODE;
+    var DOCUMENT_TYPE = domGlobals.Node.DOCUMENT_TYPE_NODE;
+    var DOCUMENT_FRAGMENT = domGlobals.Node.DOCUMENT_FRAGMENT_NODE;
+    var ELEMENT = domGlobals.Node.ELEMENT_NODE;
+    var TEXT = domGlobals.Node.TEXT_NODE;
+    var PROCESSING_INSTRUCTION = domGlobals.Node.PROCESSING_INSTRUCTION_NODE;
+    var ENTITY_REFERENCE = domGlobals.Node.ENTITY_REFERENCE_NODE;
+    var ENTITY = domGlobals.Node.ENTITY_NODE;
+    var NOTATION = domGlobals.Node.NOTATION_NODE;
+
+    var Immutable = function () {
+      var fields = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        fields[_i] = arguments[_i];
+      }
+      return function () {
+        var values = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          values[_i] = arguments[_i];
+        }
+        if (fields.length !== values.length) {
+          throw new Error('Wrong number of arguments to struct. Expected "[' + fields.length + ']", got ' + values.length + ' arguments');
+        }
+        var struct = {};
+        each(fields, function (name, i) {
+          struct[name] = constant(values[i]);
+        });
+        return struct;
+      };
+    };
+
+    var node = function () {
+      var f = Global$1.getOrDie('Node');
+      return f;
+    };
+    var compareDocumentPosition = function (a, b, match) {
+      return (a.compareDocumentPosition(b) & match) !== 0;
+    };
+    var documentPositionPreceding = function (a, b) {
+      return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_PRECEDING);
+    };
+    var documentPositionContainedBy = function (a, b) {
+      return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_CONTAINED_BY);
+    };
+    var Node = {
+      documentPositionPreceding: documentPositionPreceding,
+      documentPositionContainedBy: documentPositionContainedBy
+    };
+
+    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(group(1), group(2));
+    };
+    var detect = function (versionRegexes, agent) {
+      var cleanedAgent = String(agent).toLowerCase();
+      if (versionRegexes.length === 0) {
+        return unknown();
+      }
+      return find$1(versionRegexes, cleanedAgent);
+    };
+    var unknown = function () {
+      return nu(0, 0);
+    };
+    var nu = function (major, minor) {
+      return {
+        major: major,
+        minor: minor
+      };
+    };
+    var Version = {
+      nu: nu,
+      detect: detect,
+      unknown: unknown
+    };
+
+    var edge = 'Edge';
+    var chrome = 'Chrome';
+    var ie = 'IE';
+    var opera = 'Opera';
+    var firefox = 'Firefox';
+    var safari = 'Safari';
+    var isBrowser = function (name, current) {
+      return function () {
+        return current === name;
+      };
+    };
+    var unknown$1 = function () {
+      return nu$1({
+        current: undefined,
+        version: Version.unknown()
+      });
+    };
+    var nu$1 = function (info) {
+      var current = info.current;
+      var version = info.version;
+      return {
+        current: current,
+        version: version,
+        isEdge: isBrowser(edge, current),
+        isChrome: isBrowser(chrome, current),
+        isIE: isBrowser(ie, current),
+        isOpera: isBrowser(opera, current),
+        isFirefox: isBrowser(firefox, current),
+        isSafari: isBrowser(safari, current)
+      };
+    };
+    var Browser = {
+      unknown: unknown$1,
+      nu: nu$1,
+      edge: constant(edge),
+      chrome: constant(chrome),
+      ie: constant(ie),
+      opera: constant(opera),
+      firefox: constant(firefox),
+      safari: constant(safari)
+    };
+
+    var windows$1 = 'Windows';
+    var ios = 'iOS';
+    var android = 'Android';
+    var linux = 'Linux';
+    var osx = 'OSX';
+    var solaris = 'Solaris';
+    var freebsd = 'FreeBSD';
+    var isOS = function (name, current) {
+      return function () {
+        return current === name;
+      };
+    };
+    var unknown$2 = function () {
+      return nu$2({
+        current: undefined,
+        version: Version.unknown()
+      });
+    };
+    var nu$2 = function (info) {
+      var current = info.current;
+      var version = info.version;
+      return {
+        current: current,
+        version: version,
+        isWindows: isOS(windows$1, current),
+        isiOS: isOS(ios, current),
+        isAndroid: isOS(android, current),
+        isOSX: isOS(osx, current),
+        isLinux: isOS(linux, current),
+        isSolaris: isOS(solaris, current),
+        isFreeBSD: isOS(freebsd, current)
+      };
+    };
+    var OperatingSystem = {
+      unknown: unknown$2,
+      nu: nu$2,
+      windows: constant(windows$1),
+      ios: constant(ios),
+      android: constant(android),
+      linux: constant(linux),
+      osx: constant(osx),
+      solaris: constant(solaris),
+      freebsd: constant(freebsd)
+    };
+
+    var DeviceType = function (os, browser, userAgent) {
+      var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
+      var isiPhone = os.isiOS() && !isiPad;
+      var isAndroid3 = os.isAndroid() && os.version.major === 3;
+      var isAndroid4 = os.isAndroid() && os.version.major === 4;
+      var isTablet = isiPad || isAndroid3 || isAndroid4 && /mobile/i.test(userAgent) === true;
+      var isTouch = os.isiOS() || os.isAndroid();
+      var isPhone = isTouch && !isTablet;
+      var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
+      return {
+        isiPad: constant(isiPad),
+        isiPhone: constant(isiPhone),
+        isTablet: constant(isTablet),
+        isPhone: constant(isPhone),
+        isTouch: constant(isTouch),
+        isAndroid: os.isAndroid,
+        isiOS: os.isiOS,
+        isWebView: constant(iOSwebview)
+      };
+    };
+
+    var detect$1 = function (candidates, userAgent) {
+      var agent = String(userAgent).toLowerCase();
+      return find(candidates, function (candidate) {
+        return candidate.search(agent);
+      });
+    };
+    var detectBrowser = function (browsers, userAgent) {
+      return detect$1(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$1(oses, userAgent).map(function (os) {
+        var version = Version.detect(os.versionRegexes, userAgent);
+        return {
+          current: os.name,
+          version: version
+        };
+      });
+    };
+    var UaString = {
+      detectBrowser: detectBrowser,
+      detectOs: detectOs
+    };
+
+    var contains = function (str, substr) {
+      return str.indexOf(substr) !== -1;
+    };
+
+    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',
+        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('os x'),
+        versionRegexes: [/.*?os\ x\ ?([0-9]+)_([0-9]+).*/]
+      },
+      {
+        name: 'Linux',
+        search: checkContains('linux'),
+        versionRegexes: []
+      },
+      {
+        name: 'Solaris',
+        search: checkContains('sunos'),
+        versionRegexes: []
+      },
+      {
+        name: 'FreeBSD',
+        search: checkContains('freebsd'),
+        versionRegexes: []
+      }
+    ];
+    var PlatformInfo = {
+      browsers: constant(browsers),
+      oses: constant(oses)
+    };
+
+    var detect$2 = function (userAgent) {
+      var browsers = PlatformInfo.browsers();
+      var oses = PlatformInfo.oses();
+      var browser = UaString.detectBrowser(browsers, userAgent).fold(Browser.unknown, Browser.nu);
+      var os = UaString.detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
+      var deviceType = DeviceType(os, browser, userAgent);
+      return {
+        browser: browser,
+        os: os,
+        deviceType: deviceType
+      };
+    };
+    var PlatformDetection = { detect: detect$2 };
+
+    var detect$3 = cached(function () {
+      var userAgent = domGlobals.navigator.userAgent;
+      return PlatformDetection.detect(userAgent);
+    });
+    var PlatformDetection$1 = { detect: detect$3 };
+
+    var ELEMENT$1 = ELEMENT;
+    var DOCUMENT$1 = DOCUMENT;
+    var bypassSelector = function (dom) {
+      return dom.nodeType !== ELEMENT$1 && dom.nodeType !== DOCUMENT$1 || dom.childElementCount === 0;
+    };
+    var all = function (selector, scope) {
+      var base = scope === undefined ? domGlobals.document : scope.dom();
+      return bypassSelector(base) ? [] : map(base.querySelectorAll(selector), Element.fromDom);
+    };
+    var one = function (selector, scope) {
+      var base = scope === undefined ? domGlobals.document : scope.dom();
+      return bypassSelector(base) ? Option.none() : Option.from(base.querySelector(selector)).map(Element.fromDom);
+    };
+
+    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 Node.documentPositionContainedBy(e1.dom(), e2.dom());
+    };
+    var browser = PlatformDetection$1.detect().browser;
+    var contains$1 = browser.isIE() ? ieContains : regularContains;
+
+    var spot = Immutable('element', 'offset');
+
+    var descendants = function (scope, selector) {
+      return all(selector, scope);
+    };
+
+    var trim = global$4.trim;
+    var hasContentEditableState = function (value) {
+      return function (node) {
+        if (node && node.nodeType === 1) {
+          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$4 = 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(descendants(Element.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('h');
+    };
+    var isAnchor = function (elm) {
+      return elm && elm.nodeName === 'A' && (elm.id || elm.name);
+    };
+    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$4('header', getElementText(elm), '#' + headerId, getLevel(elm), attach);
+    };
+    var anchorTarget = function (elm) {
+      var anchorId = elm.id || elm.name;
+      var anchorText = getElementText(elm);
+      return create$4('anchor', anchorText ? anchorText : '#' + anchorId, '#' + anchorId, 0, noop);
+    };
+    var getHeaderTargets = function (elms) {
+      return map(filter(elms, isValidHeader), headerTarget);
+    };
+    var getAnchorTargets = function (elms) {
+      return map(filter(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$2 = function (elm) {
+      var elms = getTargetElements(elm);
+      return filter(getHeaderTargets(elms).concat(getAnchorTargets(elms)), hasTitle);
+    };
+    var LinkTargets = { find: find$2 };
+
+    var getActiveEditor = function () {
+      return window.tinymce ? window.tinymce.activeEditor : global$5.activeEditor;
+    };
+    var history = {};
+    var HISTORY_LENGTH = 5;
+    var clearHistory = function () {
+      history = {};
+    };
+    var toMenuItem = function (target) {
+      return {
+        title: target.title,
+        value: {
+          title: { raw: target.title },
+          url: target.url,
+          attach: target.attach
+        }
+      };
+    };
+    var toMenuItems = function (targets) {
+      return global$4.map(targets, toMenuItem);
+    };
+    var staticMenuItem = function (title, url) {
+      return {
+        title: title,
+        value: {
+          title: title,
+          url: url,
+          attach: noop
+        }
+      };
+    };
+    var isUniqueUrl = function (url, targets) {
+      var foundTarget = exists(targets, function (target) {
+        return target.url === url;
+      });
+      return !foundTarget;
+    };
+    var getSetting = function (editorSettings, name, defaultValue) {
+      var value = name in editorSettings ? editorSettings[name] : defaultValue;
+      return value === false ? null : value;
+    };
+    var createMenuItems = function (term, targets, fileType, editorSettings) {
+      var separator = { title: '-' };
+      var fromHistoryMenuItems = function (history) {
+        var historyItems = history.hasOwnProperty(fileType) ? history[fileType] : [];
+        var uniqueHistory = filter(historyItems, function (url) {
+          return isUniqueUrl(url, targets);
+        });
+        return global$4.map(uniqueHistory, function (url) {
+          return {
+            title: url,
+            value: {
+              title: url,
+              url: url,
+              attach: noop
+            }
+          };
+        });
+      };
+      var fromMenuItems = function (type) {
+        var filteredTargets = filter(targets, function (target) {
+          return target.type === type;
+        });
+        return toMenuItems(filteredTargets);
+      };
+      var anchorMenuItems = function () {
+        var anchorMenuItems = fromMenuItems('anchor');
+        var topAnchor = getSetting(editorSettings, 'anchor_top', '#top');
+        var bottomAchor = getSetting(editorSettings, 'anchor_bottom', '#bottom');
+        if (topAnchor !== null) {
+          anchorMenuItems.unshift(staticMenuItem('<top>', topAnchor));
+        }
+        if (bottomAchor !== null) {
+          anchorMenuItems.push(staticMenuItem('<bottom>', bottomAchor));
+        }
+        return anchorMenuItems;
+      };
+      var join = function (items) {
+        return foldl(items, function (a, b) {
+          var bothEmpty = a.length === 0 || b.length === 0;
+          return bothEmpty ? a.concat(b) : a.concat(separator, b);
+        }, []);
+      };
+      if (editorSettings.typeahead_urls === false) {
+        return [];
+      }
+      return fileType === 'file' ? join([
+        filterByQuery(term, fromHistoryMenuItems(history)),
+        filterByQuery(term, fromMenuItems('header')),
+        filterByQuery(term, anchorMenuItems())
+      ]) : filterByQuery(term, fromHistoryMenuItems(history));
+    };
+    var addToHistory = function (url, fileType) {
+      var items = history[fileType];
+      if (!/^https?/.test(url)) {
+        return;
+      }
+      if (items) {
+        if (indexOf(items, url).isNone()) {
+          history[fileType] = items.slice(0, HISTORY_LENGTH).concat(url);
+        }
+      } else {
+        history[fileType] = [url];
+      }
+    };
+    var filterByQuery = function (term, menuItems) {
+      var lowerCaseTerm = term.toLowerCase();
+      var result = global$4.grep(menuItems, function (item) {
+        return item.title.toLowerCase().indexOf(lowerCaseTerm) !== -1;
+      });
+      return result.length === 1 && result[0].title === term ? [] : result;
+    };
+    var getTitle = function (linkDetails) {
+      var title = linkDetails.title;
+      return title.raw ? title.raw : title;
+    };
+    var setupAutoCompleteHandler = function (ctrl, editorSettings, bodyElm, fileType) {
+      var autocomplete = function (term) {
+        var linkTargets = LinkTargets.find(bodyElm);
+        var menuItems = createMenuItems(term, linkTargets, fileType, editorSettings);
+        ctrl.showAutoComplete(menuItems, term);
+      };
+      ctrl.on('autocomplete', function () {
+        autocomplete(ctrl.value());
+      });
+      ctrl.on('selectitem', function (e) {
+        var linkDetails = e.value;
+        ctrl.value(linkDetails.url);
+        var title = getTitle(linkDetails);
+        if (fileType === 'image') {
+          ctrl.fire('change', {
+            meta: {
+              alt: title,
+              attach: linkDetails.attach
+            }
+          });
+        } else {
+          ctrl.fire('change', {
+            meta: {
+              text: title,
+              attach: linkDetails.attach
+            }
+          });
+        }
+        ctrl.focus();
+      });
+      ctrl.on('click', function (e) {
+        if (ctrl.value().length === 0 && e.target.nodeName === 'INPUT') {
+          autocomplete('');
+        }
+      });
+      ctrl.on('PostRender', function () {
+        ctrl.getRoot().on('submit', function (e) {
+          if (!e.isDefaultPrevented()) {
+            addToHistory(ctrl.value(), fileType);
+          }
+        });
+      });
+    };
+    var statusToUiState = function (result) {
+      var status = result.status, message = result.message;
+      if (status === 'valid') {
+        return {
+          status: 'ok',
+          message: message
+        };
+      } else if (status === 'unknown') {
+        return {
+          status: 'warn',
+          message: message
+        };
+      } else if (status === 'invalid') {
+        return {
+          status: 'warn',
+          message: message
+        };
+      } else {
+        return {
+          status: 'none',
+          message: ''
+        };
+      }
+    };
+    var setupLinkValidatorHandler = function (ctrl, editorSettings, fileType) {
+      var validatorHandler = editorSettings.filepicker_validator_handler;
+      if (validatorHandler) {
+        var validateUrl_1 = function (url) {
+          if (url.length === 0) {
+            ctrl.statusLevel('none');
+            return;
+          }
+          validatorHandler({
+            url: url,
+            type: fileType
+          }, function (result) {
+            var uiState = statusToUiState(result);
+            ctrl.statusMessage(uiState.message);
+            ctrl.statusLevel(uiState.status);
+          });
+        };
+        ctrl.state.on('change:value', function (e) {
+          validateUrl_1(e.value);
+        });
+      }
+    };
+    var FilePicker = ComboBox.extend({
+      Statics: { clearHistory: clearHistory },
+      init: function (settings) {
+        var self = this, editor = getActiveEditor(), editorSettings = editor.settings;
+        var actionCallback, fileBrowserCallback, fileBrowserCallbackTypes;
+        var fileType = settings.filetype;
+        settings.spellcheck = false;
+        fileBrowserCallbackTypes = editorSettings.file_picker_types || editorSettings.file_browser_callback_types;
+        if (fileBrowserCallbackTypes) {
+          fileBrowserCallbackTypes = global$4.makeMap(fileBrowserCallbackTypes, /[, ]/);
+        }
+        if (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType]) {
+          fileBrowserCallback = editorSettings.file_picker_callback;
+          if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
+            actionCallback = function () {
+              var meta = self.fire('beforecall').meta;
+              meta = global$4.extend({ filetype: fileType }, meta);
+              fileBrowserCallback.call(editor, function (value, meta) {
+                self.value(value).fire('change', { meta: meta });
+              }, self.value(), meta);
+            };
+          } else {
+            fileBrowserCallback = editorSettings.file_browser_callback;
+            if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
+              actionCallback = function () {
+                fileBrowserCallback(self.getEl('inp').id, self.value(), fileType, window);
+              };
+            }
+          }
+        }
+        if (actionCallback) {
+          settings.icon = 'browse';
+          settings.onaction = actionCallback;
+        }
+        self._super(settings);
+        self.classes.add('filepicker');
+        setupAutoCompleteHandler(self, editorSettings, editor.getBody(), fileType);
+        setupLinkValidatorHandler(self, editorSettings, fileType);
+      }
+    });
+
+    var FitLayout = AbsoluteLayout.extend({
+      recalc: function (container) {
+        var contLayoutRect = container.layoutRect(), paddingBox = container.paddingBox;
+        container.items().filter(':visible').each(function (ctrl) {
+          ctrl.layoutRect({
+            x: paddingBox.left,
+            y: paddingBox.top,
+            w: contLayoutRect.innerW - paddingBox.right - paddingBox.left,
+            h: contLayoutRect.innerH - paddingBox.top - paddingBox.bottom
+          });
+          if (ctrl.recalc) {
+            ctrl.recalc();
+          }
+        });
+      }
+    });
+
+    var FlexLayout = AbsoluteLayout.extend({
+      recalc: function (container) {
+        var i, l, items, contLayoutRect, contPaddingBox, contSettings, align, pack, spacing, totalFlex, availableSpace, direction;
+        var ctrl, ctrlLayoutRect, ctrlSettings, flex;
+        var maxSizeItems = [];
+        var size, maxSize, ratio, rect, pos, maxAlignEndPos;
+        var sizeName, minSizeName, posName, maxSizeName, beforeName, innerSizeName, deltaSizeName, contentSizeName;
+        var alignAxisName, alignInnerSizeName, alignSizeName, alignMinSizeName, alignBeforeName, alignAfterName;
+        var alignDeltaSizeName, alignContentSizeName;
+        var max = Math.max, min = Math.min;
+        items = container.items().filter(':visible');
+        contLayoutRect = container.layoutRect();
+        contPaddingBox = container.paddingBox;
+        contSettings = container.settings;
+        direction = container.isRtl() ? contSettings.direction || 'row-reversed' : contSettings.direction;
+        align = contSettings.align;
+        pack = container.isRtl() ? contSettings.pack || 'end' : contSettings.pack;
+        spacing = contSettings.spacing || 0;
+        if (direction === 'row-reversed' || direction === 'column-reverse') {
+          items = items.set(items.toArray().reverse());
+          direction = direction.split('-')[0];
+        }
+        if (direction === 'column') {
+          posName = 'y';
+          sizeName = 'h';
+          minSizeName = 'minH';
+          maxSizeName = 'maxH';
+          innerSizeName = 'innerH';
+          beforeName = 'top';
+          deltaSizeName = 'deltaH';
+          contentSizeName = 'contentH';
+          alignBeforeName = 'left';
+          alignSizeName = 'w';
+          alignAxisName = 'x';
+          alignInnerSizeName = 'innerW';
+          alignMinSizeName = 'minW';
+          alignAfterName = 'right';
+          alignDeltaSizeName = 'deltaW';
+          alignContentSizeName = 'contentW';
+        } else {
+          posName = 'x';
+          sizeName = 'w';
+          minSizeName = 'minW';
+          maxSizeName = 'maxW';
+          innerSizeName = 'innerW';
+          beforeName = 'left';
+          deltaSizeName = 'deltaW';
+          contentSizeName = 'contentW';
+          alignBeforeName = 'top';
+          alignSizeName = 'h';
+          alignAxisName = 'y';
+          alignInnerSizeName = 'innerH';
+          alignMinSizeName = 'minH';
+          alignAfterName = 'bottom';
+          alignDeltaSizeName = 'deltaH';
+          alignContentSizeName = 'contentH';
+        }
+        availableSpace = contLayoutRect[innerSizeName] - contPaddingBox[beforeName] - contPaddingBox[beforeName];
+        maxAlignEndPos = totalFlex = 0;
+        for (i = 0, l = items.length; i < l; i++) {
+          ctrl = items[i];
+          ctrlLayoutRect = ctrl.layoutRect();
+          ctrlSettings = ctrl.settings;
+          flex = ctrlSettings.flex;
+          availableSpace -= i < l - 1 ? spacing : 0;
+          if (flex > 0) {
+            totalFlex += flex;
+            if (ctrlLayoutRect[maxSizeName]) {
+              maxSizeItems.push(ctrl);
+            }
+            ctrlLayoutRect.flex = flex;
+          }
+          availableSpace -= ctrlLayoutRect[minSizeName];
+          size = contPaddingBox[alignBeforeName] + ctrlLayoutRect[alignMinSizeName] + contPaddingBox[alignAfterName];
+          if (size > maxAlignEndPos) {
+            maxAlignEndPos = size;
+          }
+        }
+        rect = {};
+        if (availableSpace < 0) {
+          rect[minSizeName] = contLayoutRect[minSizeName] - availableSpace + contLayoutRect[deltaSizeName];
+        } else {
+          rect[minSizeName] = contLayoutRect[innerSizeName] - availableSpace + contLayoutRect[deltaSizeName];
+        }
+        rect[alignMinSizeName] = maxAlignEndPos + contLayoutRect[alignDeltaSizeName];
+        rect[contentSizeName] = contLayoutRect[innerSizeName] - availableSpace;
+        rect[alignContentSizeName] = maxAlignEndPos;
+        rect.minW = min(rect.minW, contLayoutRect.maxW);
+        rect.minH = min(rect.minH, contLayoutRect.maxH);
+        rect.minW = max(rect.minW, contLayoutRect.startMinWidth);
+        rect.minH = max(rect.minH, contLayoutRect.startMinHeight);
+        if (contLayoutRect.autoResize && (rect.minW !== contLayoutRect.minW || rect.minH !== contLayoutRect.minH)) {
+          rect.w = rect.minW;
+          rect.h = rect.minH;
+          container.layoutRect(rect);
+          this.recalc(container);
+          if (container._lastRect === null) {
+            var parentCtrl = container.parent();
+            if (parentCtrl) {
+              parentCtrl._lastRect = null;
+              parentCtrl.recalc();
+            }
+          }
+          return;
+        }
+        ratio = availableSpace / totalFlex;
+        for (i = 0, l = maxSizeItems.length; i < l; i++) {
+          ctrl = maxSizeItems[i];
+          ctrlLayoutRect = ctrl.layoutRect();
+          maxSize = ctrlLayoutRect[maxSizeName];
+          size = ctrlLayoutRect[minSizeName] + ctrlLayoutRect.flex * ratio;
+          if (size > maxSize) {
+            availableSpace -= ctrlLayoutRect[maxSizeName] - ctrlLayoutRect[minSizeName];
+            totalFlex -= ctrlLayoutRect.flex;
+            ctrlLayoutRect.flex = 0;
+            ctrlLayoutRect.maxFlexSize = maxSize;
+          } else {
+            ctrlLayoutRect.maxFlexSize = 0;
+          }
+        }
+        ratio = availableSpace / totalFlex;
+        pos = contPaddingBox[beforeName];
+        rect = {};
+        if (totalFlex === 0) {
+          if (pack === 'end') {
+            pos = availableSpace + contPaddingBox[beforeName];
+          } else if (pack === 'center') {
+            pos = Math.round(contLayoutRect[innerSizeName] / 2 - (contLayoutRect[innerSizeName] - availableSpace) / 2) + contPaddingBox[beforeName];
+            if (pos < 0) {
+              pos = contPaddingBox[beforeName];
+            }
+          } else if (pack === 'justify') {
+            pos = contPaddingBox[beforeName];
+            spacing = Math.floor(availableSpace / (items.length - 1));
+          }
+        }
+        rect[alignAxisName] = contPaddingBox[alignBeforeName];
+        for (i = 0, l = items.length; i < l; i++) {
+          ctrl = items[i];
+          ctrlLayoutRect = ctrl.layoutRect();
+          size = ctrlLayoutRect.maxFlexSize || ctrlLayoutRect[minSizeName];
+          if (align === 'center') {
+            rect[alignAxisName] = Math.round(contLayoutRect[alignInnerSizeName] / 2 - ctrlLayoutRect[alignSizeName] / 2);
+          } else if (align === 'stretch') {
+            rect[alignSizeName] = max(ctrlLayoutRect[alignMinSizeName] || 0, contLayoutRect[alignInnerSizeName] - contPaddingBox[alignBeforeName] - contPaddingBox[alignAfterName]);
+            rect[alignAxisName] = contPaddingBox[alignBeforeName];
+          } else if (align === 'end') {
+            rect[alignAxisName] = contLayoutRect[alignInnerSizeName] - ctrlLayoutRect[alignSizeName] - contPaddingBox.top;
+          }
+          if (ctrlLayoutRect.flex > 0) {
+            size += ctrlLayoutRect.flex * ratio;
+          }
+          rect[sizeName] = size;
+          rect[posName] = pos;
+          ctrl.layoutRect(rect);
+          if (ctrl.recalc) {
+            ctrl.recalc();
+          }
+          pos += size + spacing;
+        }
+      }
+    });
+
+    var FlowLayout = Layout$1.extend({
+      Defaults: {
+        containerClass: 'flow-layout',
+        controlClass: 'flow-layout-item',
+        endClass: 'break'
+      },
+      recalc: function (container) {
+        container.items().filter(':visible').each(function (ctrl) {
+          if (ctrl.recalc) {
+            ctrl.recalc();
+          }
+        });
+      },
+      isNative: function () {
+        return true;
+      }
+    });
+
+    var descendant = function (scope, selector) {
+      return one(selector, scope);
+    };
+
+    var toggleFormat = function (editor, fmt) {
+      return function () {
+        editor.execCommand('mceToggleFormat', false, fmt);
+      };
+    };
+    var addFormatChangedListener = function (editor, name, changed) {
+      var handler = function (state) {
+        changed(state, name);
+      };
+      if (editor.formatter) {
+        editor.formatter.formatChanged(name, handler);
+      } else {
+        editor.on('init', function () {
+          editor.formatter.formatChanged(name, handler);
+        });
+      }
+    };
+    var postRenderFormatToggle = function (editor, name) {
+      return function (e) {
+        addFormatChangedListener(editor, name, function (state) {
+          e.control.active(state);
+        });
+      };
+    };
+
+    var register = function (editor) {
+      var alignFormats = [
+        'alignleft',
+        'aligncenter',
+        'alignright',
+        'alignjustify'
+      ];
+      var defaultAlign = 'alignleft';
+      var alignMenuItems = [
+        {
+          text: 'Left',
+          icon: 'alignleft',
+          onclick: toggleFormat(editor, 'alignleft')
+        },
+        {
+          text: 'Center',
+          icon: 'aligncenter',
+          onclick: toggleFormat(editor, 'aligncenter')
+        },
+        {
+          text: 'Right',
+          icon: 'alignright',
+          onclick: toggleFormat(editor, 'alignright')
+        },
+        {
+          text: 'Justify',
+          icon: 'alignjustify',
+          onclick: toggleFormat(editor, 'alignjustify')
+        }
+      ];
+      editor.addMenuItem('align', {
+        text: 'Align',
+        menu: alignMenuItems
+      });
+      editor.addButton('align', {
+        type: 'menubutton',
+        icon: defaultAlign,
+        menu: alignMenuItems,
+        onShowMenu: function (e) {
+          var menu = e.control.menu;
+          global$4.each(alignFormats, function (formatName, idx) {
+            menu.items().eq(idx).each(function (item) {
+              return item.active(editor.formatter.match(formatName));
+            });
+          });
+        },
+        onPostRender: function (e) {
+          var ctrl = e.control;
+          global$4.each(alignFormats, function (formatName, idx) {
+            addFormatChangedListener(editor, formatName, function (state) {
+              ctrl.icon(defaultAlign);
+              if (state) {
+                ctrl.icon(formatName);
+              }
+            });
+          });
+        }
+      });
+      global$4.each({
+        alignleft: [
+          'Align left',
+          'JustifyLeft'
+        ],
+        aligncenter: [
+          'Align center',
+          'JustifyCenter'
+        ],
+        alignright: [
+          'Align right',
+          'JustifyRight'
+        ],
+        alignjustify: [
+          'Justify',
+          'JustifyFull'
+        ],
+        alignnone: [
+          'No alignment',
+          'JustifyNone'
+        ]
+      }, function (item, name) {
+        editor.addButton(name, {
+          active: false,
+          tooltip: item[0],
+          cmd: item[1],
+          onPostRender: postRenderFormatToggle(editor, name)
+        });
+      });
+    };
+    var Align = { register: register };
+
+    var getFirstFont = function (fontFamily) {
+      return fontFamily ? fontFamily.split(',')[0] : '';
+    };
+    var findMatchingValue = function (items, fontFamily) {
+      var font = fontFamily ? fontFamily.toLowerCase() : '';
+      var value;
+      global$4.each(items, function (item) {
+        if (item.value.toLowerCase() === font) {
+          value = item.value;
+        }
+      });
+      global$4.each(items, function (item) {
+        if (!value && getFirstFont(item.value).toLowerCase() === getFirstFont(font).toLowerCase()) {
+          value = item.value;
+        }
+      });
+      return value;
+    };
+    var createFontNameListBoxChangeHandler = function (editor, items) {
+      return function () {
+        var self = this;
+        self.state.set('value', null);
+        editor.on('init nodeChange', function (e) {
+          var fontFamily = editor.queryCommandValue('FontName');
+          var match = findMatchingValue(items, fontFamily);
+          self.value(match ? match : null);
+          if (!match && fontFamily) {
+            self.text(getFirstFont(fontFamily));
+          }
+        });
+      };
+    };
+    var createFormats = function (formats) {
+      formats = formats.replace(/;$/, '').split(';');
+      var i = formats.length;
+      while (i--) {
+        formats[i] = formats[i].split('=');
+      }
+      return formats;
+    };
+    var getFontItems = function (editor) {
+      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 fonts = createFormats(editor.settings.font_formats || defaultFontsFormats);
+      return global$4.map(fonts, function (font) {
+        return {
+          text: { raw: font[0] },
+          value: font[1],
+          textStyle: font[1].indexOf('dings') === -1 ? 'font-family:' + font[1] : ''
+        };
+      });
+    };
+    var registerButtons = function (editor) {
+      editor.addButton('fontselect', function () {
+        var items = getFontItems(editor);
+        return {
+          type: 'listbox',
+          text: 'Font Family',
+          tooltip: 'Font Family',
+          values: items,
+          fixedWidth: true,
+          onPostRender: createFontNameListBoxChangeHandler(editor, items),
+          onselect: function (e) {
+            if (e.control.settings.value) {
+              editor.execCommand('FontName', false, e.control.settings.value);
+            }
+          }
+        };
+      });
+    };
+    var register$1 = function (editor) {
+      registerButtons(editor);
+    };
+    var FontSelect = { register: register$1 };
+
+    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';
+      }
+      return fontSize;
+    };
+    var findMatchingValue$1 = function (items, pt, px) {
+      var value;
+      global$4.each(items, function (item) {
+        if (item.value === px) {
+          value = px;
+        } else if (item.value === pt) {
+          value = pt;
+        }
+      });
+      return value;
+    };
+    var createFontSizeListBoxChangeHandler = function (editor, items) {
+      return function () {
+        var self = this;
+        editor.on('init nodeChange', function (e) {
+          var px, pt, precision, match;
+          px = editor.queryCommandValue('FontSize');
+          if (px) {
+            for (precision = 3; !match && precision >= 0; precision--) {
+              pt = toPt(px, precision);
+              match = findMatchingValue$1(items, pt, px);
+            }
+          }
+          self.value(match ? match : null);
+          if (!match) {
+            self.text(pt);
+          }
+        });
+      };
+    };
+    var getFontSizeItems = function (editor) {
+      var defaultFontsizeFormats = '8pt 10pt 12pt 14pt 18pt 24pt 36pt';
+      var fontsizeFormats = editor.settings.fontsize_formats || defaultFontsizeFormats;
+      return global$4.map(fontsizeFormats.split(' '), function (item) {
+        var text = item, value = item;
+        var values = item.split('=');
+        if (values.length > 1) {
+          text = values[0];
+          value = values[1];
+        }
+        return {
+          text: text,
+          value: value
+        };
+      });
+    };
+    var registerButtons$1 = function (editor) {
+      editor.addButton('fontsizeselect', function () {
+        var items = getFontSizeItems(editor);
+        return {
+          type: 'listbox',
+          text: 'Font Sizes',
+          tooltip: 'Font Sizes',
+          values: items,
+          fixedWidth: true,
+          onPostRender: createFontSizeListBoxChangeHandler(editor, items),
+          onclick: function (e) {
+            if (e.control.settings.value) {
+              editor.execCommand('FontSize', false, e.control.settings.value);
+            }
+          }
+        };
+      });
+    };
+    var register$2 = function (editor) {
+      registerButtons$1(editor);
+    };
+    var FontSizeSelect = { register: register$2 };
+
+    var hideMenuObjects = function (editor, menu) {
+      var count = menu.length;
+      global$4.each(menu, function (item) {
+        if (item.menu) {
+          item.hidden = hideMenuObjects(editor, item.menu) === 0;
+        }
+        var formatName = item.format;
+        if (formatName) {
+          item.hidden = !editor.formatter.canApply(formatName);
+        }
+        if (item.hidden) {
+          count--;
+        }
+      });
+      return count;
+    };
+    var hideFormatMenuItems = function (editor, menu) {
+      var count = menu.items().length;
+      menu.items().each(function (item) {
+        if (item.menu) {
+          item.visible(hideFormatMenuItems(editor, item.menu) > 0);
+        }
+        if (!item.menu && item.settings.menu) {
+          item.visible(hideMenuObjects(editor, item.settings.menu) > 0);
+        }
+        var formatName = item.settings.format;
+        if (formatName) {
+          item.visible(editor.formatter.canApply(formatName));
+        }
+        if (!item.visible()) {
+          count--;
+        }
+      });
+      return count;
+    };
+    var createFormatMenu = function (editor) {
+      var count = 0;
+      var newFormats = [];
+      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 createMenu = function (formats) {
+        var menu = [];
+        if (!formats) {
+          return;
+        }
+        global$4.each(formats, function (format) {
+          var menuItem = {
+            text: format.title,
+            icon: format.icon
+          };
+          if (format.items) {
+            menuItem.menu = createMenu(format.items);
+          } else {
+            var formatName = format.format || 'custom' + count++;
+            if (!format.format) {
+              format.name = formatName;
+              newFormats.push(format);
+            }
+            menuItem.format = formatName;
+            menuItem.cmd = format.cmd;
+          }
+          menu.push(menuItem);
+        });
+        return menu;
+      };
+      var createStylesMenu = function () {
+        var menu;
+        if (editor.settings.style_formats_merge) {
+          if (editor.settings.style_formats) {
+            menu = createMenu(defaultStyleFormats.concat(editor.settings.style_formats));
+          } else {
+            menu = createMenu(defaultStyleFormats);
+          }
+        } else {
+          menu = createMenu(editor.settings.style_formats || defaultStyleFormats);
+        }
+        return menu;
+      };
+      editor.on('init', function () {
+        global$4.each(newFormats, function (format) {
+          editor.formatter.register(format.name, format);
+        });
+      });
+      return {
+        type: 'menu',
+        items: createStylesMenu(),
+        onPostRender: function (e) {
+          editor.fire('renderFormatsMenu', { control: e.control });
+        },
+        itemDefaults: {
+          preview: true,
+          textStyle: function () {
+            if (this.settings.format) {
+              return editor.formatter.getCssText(this.settings.format);
+            }
+          },
+          onPostRender: function () {
+            var self = this;
+            self.parent().on('show', function () {
+              var formatName, command;
+              formatName = self.settings.format;
+              if (formatName) {
+                self.disabled(!editor.formatter.canApply(formatName));
+                self.active(editor.formatter.match(formatName));
+              }
+              command = self.settings.cmd;
+              if (command) {
+                self.active(editor.queryCommandState(command));
+              }
+            });
+          },
+          onclick: function () {
+            if (this.settings.format) {
+              toggleFormat(editor, this.settings.format)();
+            }
+            if (this.settings.cmd) {
+              editor.execCommand(this.settings.cmd);
+            }
+          }
+        }
+      };
+    };
+    var registerMenuItems = function (editor, formatMenu) {
+      editor.addMenuItem('formats', {
+        text: 'Formats',
+        menu: formatMenu
+      });
+    };
+    var registerButtons$2 = function (editor, formatMenu) {
+      editor.addButton('styleselect', {
+        type: 'menubutton',
+        text: 'Formats',
+        menu: formatMenu,
+        onShowMenu: function () {
+          if (editor.settings.style_formats_autohide) {
+            hideFormatMenuItems(editor, this.menu);
+          }
+        }
+      });
+    };
+    var register$3 = function (editor) {
+      var formatMenu = createFormatMenu(editor);
+      registerMenuItems(editor, formatMenu);
+      registerButtons$2(editor, formatMenu);
+    };
+    var Formats = { register: register$3 };
+
+    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 createFormats$1 = function (formats) {
+      formats = formats.replace(/;$/, '').split(';');
+      var i = formats.length;
+      while (i--) {
+        formats[i] = formats[i].split('=');
+      }
+      return formats;
+    };
+    var createListBoxChangeHandler = function (editor, items, formatName) {
+      return function () {
+        var self = this;
+        editor.on('nodeChange', function (e) {
+          var formatter = editor.formatter;
+          var value = null;
+          global$4.each(e.parents, function (node) {
+            global$4.each(items, function (item) {
+              if (formatName) {
+                if (formatter.matchNode(node, formatName, { value: item.value })) {
+                  value = item.value;
+                }
+              } else {
+                if (formatter.matchNode(node, item.value)) {
+                  value = item.value;
+                }
+              }
+              if (value) {
+                return false;
+              }
+            });
+            if (value) {
+              return false;
+            }
+          });
+          self.value(value);
+        });
+      };
+    };
+    var lazyFormatSelectBoxItems = function (editor, blocks) {
+      return function () {
+        var items = [];
+        global$4.each(blocks, function (block) {
+          items.push({
+            text: block[0],
+            value: block[1],
+            textStyle: function () {
+              return editor.formatter.getCssText(block[1]);
+            }
+          });
+        });
+        return {
+          type: 'listbox',
+          text: blocks[0][0],
+          values: items,
+          fixedWidth: true,
+          onselect: function (e) {
+            if (e.control) {
+              var fmt = e.control.value();
+              toggleFormat(editor, fmt)();
+            }
+          },
+          onPostRender: createListBoxChangeHandler(editor, items)
+        };
+      };
+    };
+    var buildMenuItems = function (editor, blocks) {
+      return global$4.map(blocks, function (block) {
+        return {
+          text: block[0],
+          onclick: toggleFormat(editor, block[1]),
+          textStyle: function () {
+            return editor.formatter.getCssText(block[1]);
+          }
+        };
+      });
+    };
+    var register$4 = function (editor) {
+      var blocks = createFormats$1(editor.settings.block_formats || defaultBlocks);
+      editor.addMenuItem('blockformats', {
+        text: 'Blocks',
+        menu: buildMenuItems(editor, blocks)
+      });
+      editor.addButton('formatselect', lazyFormatSelectBoxItems(editor, blocks));
+    };
+    var FormatSelect = { register: register$4 };
+
+    var createCustomMenuItems = function (editor, names) {
+      var items, nameList;
+      if (typeof names === 'string') {
+        nameList = names.split(' ');
+      } else if (global$4.isArray(names)) {
+        return flatten$1(global$4.map(names, function (names) {
+          return createCustomMenuItems(editor, names);
+        }));
+      }
+      items = global$4.grep(nameList, function (name) {
+        return name === '|' || name in editor.menuItems;
+      });
+      return global$4.map(items, function (name) {
+        return name === '|' ? { text: '-' } : editor.menuItems[name];
+      });
+    };
+    var isSeparator = function (menuItem) {
+      return menuItem && menuItem.text === '-';
+    };
+    var trimMenuItems = function (menuItems) {
+      var menuItems2 = filter(menuItems, function (menuItem, i) {
+        return !isSeparator(menuItem) || !isSeparator(menuItems[i - 1]);
+      });
+      return filter(menuItems2, function (menuItem, i) {
+        return !isSeparator(menuItem) || i > 0 && i < menuItems2.length - 1;
+      });
+    };
+    var createContextMenuItems = function (editor, context) {
+      var outputMenuItems = [{ text: '-' }];
+      var menuItems = global$4.grep(editor.menuItems, function (menuItem) {
+        return menuItem.context === context;
+      });
+      global$4.each(menuItems, function (menuItem) {
+        if (menuItem.separator === 'before') {
+          outputMenuItems.push({ text: '|' });
+        }
+        if (menuItem.prependToContext) {
+          outputMenuItems.unshift(menuItem);
+        } else {
+          outputMenuItems.push(menuItem);
+        }
+        if (menuItem.separator === 'after') {
+          outputMenuItems.push({ text: '|' });
+        }
+      });
+      return outputMenuItems;
+    };
+    var createInsertMenu = function (editor) {
+      var insertButtonItems = editor.settings.insert_button_items;
+      if (insertButtonItems) {
+        return trimMenuItems(createCustomMenuItems(editor, insertButtonItems));
+      } else {
+        return trimMenuItems(createContextMenuItems(editor, 'insert'));
+      }
+    };
+    var registerButtons$3 = function (editor) {
+      editor.addButton('insert', {
+        type: 'menubutton',
+        icon: 'insert',
+        menu: [],
+        oncreatemenu: function () {
+          this.menu.add(createInsertMenu(editor));
+          this.menu.renderNew();
+        }
+      });
+    };
+    var register$5 = function (editor) {
+      registerButtons$3(editor);
+    };
+    var InsertButton = { register: register$5 };
+
+    var registerFormatButtons = function (editor) {
+      global$4.each({
+        bold: 'Bold',
+        italic: 'Italic',
+        underline: 'Underline',
+        strikethrough: 'Strikethrough',
+        subscript: 'Subscript',
+        superscript: 'Superscript'
+      }, function (text, name) {
+        editor.addButton(name, {
+          active: false,
+          tooltip: text,
+          onPostRender: postRenderFormatToggle(editor, name),
+          onclick: toggleFormat(editor, name)
+        });
+      });
+    };
+    var registerCommandButtons = function (editor) {
+      global$4.each({
+        outdent: [
+          'Decrease indent',
+          'Outdent'
+        ],
+        indent: [
+          'Increase indent',
+          'Indent'
+        ],
+        cut: [
+          'Cut',
+          'Cut'
+        ],
+        copy: [
+          'Copy',
+          'Copy'
+        ],
+        paste: [
+          'Paste',
+          'Paste'
+        ],
+        help: [
+          'Help',
+          'mceHelp'
+        ],
+        selectall: [
+          'Select all',
+          'SelectAll'
+        ],
+        visualaid: [
+          'Visual aids',
+          'mceToggleVisualAid'
+        ],
+        newdocument: [
+          'New document',
+          'mceNewDocument'
+        ],
+        removeformat: [
+          'Clear formatting',
+          'RemoveFormat'
+        ],
+        remove: [
+          'Remove',
+          'Delete'
+        ]
+      }, function (item, name) {
+        editor.addButton(name, {
+          tooltip: item[0],
+          cmd: item[1]
+        });
+      });
+    };
+    var registerCommandToggleButtons = function (editor) {
+      global$4.each({
+        blockquote: [
+          'Blockquote',
+          'mceBlockQuote'
+        ],
+        subscript: [
+          'Subscript',
+          'Subscript'
+        ],
+        superscript: [
+          'Superscript',
+          'Superscript'
+        ]
+      }, function (item, name) {
+        editor.addButton(name, {
+          active: false,
+          tooltip: item[0],
+          cmd: item[1],
+          onPostRender: postRenderFormatToggle(editor, name)
+        });
+      });
+    };
+    var registerButtons$4 = function (editor) {
+      registerFormatButtons(editor);
+      registerCommandButtons(editor);
+      registerCommandToggleButtons(editor);
+    };
+    var registerMenuItems$1 = function (editor) {
+      global$4.each({
+        bold: [
+          'Bold',
+          'Bold',
+          'Meta+B'
+        ],
+        italic: [
+          'Italic',
+          'Italic',
+          'Meta+I'
+        ],
+        underline: [
+          'Underline',
+          'Underline',
+          'Meta+U'
+        ],
+        strikethrough: [
+          'Strikethrough',
+          'Strikethrough'
+        ],
+        subscript: [
+          'Subscript',
+          'Subscript'
+        ],
+        superscript: [
+          'Superscript',
+          'Superscript'
+        ],
+        removeformat: [
+          'Clear formatting',
+          'RemoveFormat'
+        ],
+        newdocument: [
+          'New document',
+          'mceNewDocument'
+        ],
+        cut: [
+          'Cut',
+          'Cut',
+          'Meta+X'
+        ],
+        copy: [
+          'Copy',
+          'Copy',
+          'Meta+C'
+        ],
+        paste: [
+          'Paste',
+          'Paste',
+          'Meta+V'
+        ],
+        selectall: [
+          'Select all',
+          'SelectAll',
+          'Meta+A'
+        ]
+      }, function (item, name) {
+        editor.addMenuItem(name, {
+          text: item[0],
+          icon: name,
+          shortcut: item[2],
+          cmd: item[1]
+        });
+      });
+      editor.addMenuItem('codeformat', {
+        text: 'Code',
+        icon: 'code',
+        onclick: toggleFormat(editor, 'code')
+      });
+    };
+    var register$6 = function (editor) {
+      registerButtons$4(editor);
+      registerMenuItems$1(editor);
+    };
+    var SimpleControls = { register: register$6 };
+
+    var toggleUndoRedoState = function (editor, type) {
+      return function () {
+        var self = this;
+        var checkState = function () {
+          var typeFn = type === 'redo' ? 'hasRedo' : 'hasUndo';
+          return editor.undoManager ? editor.undoManager[typeFn]() : false;
+        };
+        self.disabled(!checkState());
+        editor.on('Undo Redo AddUndo TypingUndo ClearUndos SwitchMode', function () {
+          self.disabled(editor.readonly || !checkState());
+        });
+      };
+    };
+    var registerMenuItems$2 = function (editor) {
+      editor.addMenuItem('undo', {
+        text: 'Undo',
+        icon: 'undo',
+        shortcut: 'Meta+Z',
+        onPostRender: toggleUndoRedoState(editor, 'undo'),
+        cmd: 'undo'
+      });
+      editor.addMenuItem('redo', {
+        text: 'Redo',
+        icon: 'redo',
+        shortcut: 'Meta+Y',
+        onPostRender: toggleUndoRedoState(editor, 'redo'),
+        cmd: 'redo'
+      });
+    };
+    var registerButtons$5 = function (editor) {
+      editor.addButton('undo', {
+        tooltip: 'Undo',
+        onPostRender: toggleUndoRedoState(editor, 'undo'),
+        cmd: 'undo'
+      });
+      editor.addButton('redo', {
+        tooltip: 'Redo',
+        onPostRender: toggleUndoRedoState(editor, 'redo'),
+        cmd: 'redo'
+      });
+    };
+    var register$7 = function (editor) {
+      registerMenuItems$2(editor);
+      registerButtons$5(editor);
+    };
+    var UndoRedo = { register: register$7 };
+
+    var toggleVisualAidState = function (editor) {
+      return function () {
+        var self = this;
+        editor.on('VisualAid', function (e) {
+          self.active(e.hasVisual);
+        });
+        self.active(editor.hasVisual);
+      };
+    };
+    var registerMenuItems$3 = function (editor) {
+      editor.addMenuItem('visualaid', {
+        text: 'Visual aids',
+        selectable: true,
+        onPostRender: toggleVisualAidState(editor),
+        cmd: 'mceToggleVisualAid'
+      });
+    };
+    var register$8 = function (editor) {
+      registerMenuItems$3(editor);
+    };
+    var VisualAid = { register: register$8 };
+
+    var setupEnvironment = function () {
+      Widget.tooltips = !global$1.iOS;
+      Control$1.translate = function (text) {
+        return global$5.translate(text);
+      };
+    };
+    var setupUiContainer = function (editor) {
+      if (editor.settings.ui_container) {
+        global$1.container = descendant(Element.fromDom(domGlobals.document.body), editor.settings.ui_container).fold(constant(null), function (elm) {
+          return elm.dom();
+        });
+      }
+    };
+    var setupRtlMode = function (editor) {
+      if (editor.rtl) {
+        Control$1.rtl = true;
+      }
+    };
+    var setupHideFloatPanels = function (editor) {
+      editor.on('mousedown progressstate', function () {
+        FloatPanel.hideAll();
+      });
+    };
+    var setup = function (editor) {
+      setupRtlMode(editor);
+      setupHideFloatPanels(editor);
+      setupUiContainer(editor);
+      setupEnvironment();
+      FormatSelect.register(editor);
+      Align.register(editor);
+      SimpleControls.register(editor);
+      UndoRedo.register(editor);
+      FontSizeSelect.register(editor);
+      FontSelect.register(editor);
+      Formats.register(editor);
+      VisualAid.register(editor);
+      InsertButton.register(editor);
+    };
+    var FormatControls = { setup: setup };
+
+    var GridLayout = AbsoluteLayout.extend({
+      recalc: function (container) {
+        var settings, rows, cols, items, contLayoutRect, width, height, rect, ctrlLayoutRect, ctrl, x, y, posX, posY, ctrlSettings, contPaddingBox, align, spacingH, spacingV, alignH, alignV, maxX, maxY;
+        var colWidths = [];
+        var rowHeights = [];
+        var ctrlMinWidth, ctrlMinHeight, availableWidth, availableHeight, reverseRows, idx;
+        settings = container.settings;
+        items = container.items().filter(':visible');
+        contLayoutRect = container.layoutRect();
+        cols = settings.columns || Math.ceil(Math.sqrt(items.length));
+        rows = Math.ceil(items.length / cols);
+        spacingH = settings.spacingH || settings.spacing || 0;
+        spacingV = settings.spacingV || settings.spacing || 0;
+        alignH = settings.alignH || settings.align;
+        alignV = settings.alignV || settings.align;
+        contPaddingBox = container.paddingBox;
+        reverseRows = 'reverseRows' in settings ? settings.reverseRows : container.isRtl();
+        if (alignH && typeof alignH === 'string') {
+          alignH = [alignH];
+        }
+        if (alignV && typeof alignV === 'string') {
+          alignV = [alignV];
+        }
+        for (x = 0; x < cols; x++) {
+          colWidths.push(0);
+        }
+        for (y = 0; y < rows; y++) {
+          rowHeights.push(0);
+        }
+        for (y = 0; y < rows; y++) {
+          for (x = 0; x < cols; x++) {
+            ctrl = items[y * cols + x];
+            if (!ctrl) {
+              break;
+            }
+            ctrlLayoutRect = ctrl.layoutRect();
+            ctrlMinWidth = ctrlLayoutRect.minW;
+            ctrlMinHeight = ctrlLayoutRect.minH;
+            colWidths[x] = ctrlMinWidth > colWidths[x] ? ctrlMinWidth : colWidths[x];
+            rowHeights[y] = ctrlMinHeight > rowHeights[y] ? ctrlMinHeight : rowHeights[y];
+          }
+        }
+        availableWidth = contLayoutRect.innerW - contPaddingBox.left - contPaddingBox.right;
+        for (maxX = 0, x = 0; x < cols; x++) {
+          maxX += colWidths[x] + (x > 0 ? spacingH : 0);
+          availableWidth -= (x > 0 ? spacingH : 0) + colWidths[x];
+        }
+        availableHeight = contLayoutRect.innerH - contPaddingBox.top - contPaddingBox.bottom;
+        for (maxY = 0, y = 0; y < rows; y++) {
+          maxY += rowHeights[y] + (y > 0 ? spacingV : 0);
+          availableHeight -= (y > 0 ? spacingV : 0) + rowHeights[y];
+        }
+        maxX += contPaddingBox.left + contPaddingBox.right;
+        maxY += contPaddingBox.top + contPaddingBox.bottom;
+        rect = {};
+        rect.minW = maxX + (contLayoutRect.w - contLayoutRect.innerW);
+        rect.minH = maxY + (contLayoutRect.h - contLayoutRect.innerH);
+        rect.contentW = rect.minW - contLayoutRect.deltaW;
+        rect.contentH = rect.minH - contLayoutRect.deltaH;
+        rect.minW = Math.min(rect.minW, contLayoutRect.maxW);
+        rect.minH = Math.min(rect.minH, contLayoutRect.maxH);
+        rect.minW = Math.max(rect.minW, contLayoutRect.startMinWidth);
+        rect.minH = Math.max(rect.minH, contLayoutRect.startMinHeight);
+        if (contLayoutRect.autoResize && (rect.minW !== contLayoutRect.minW || rect.minH !== contLayoutRect.minH)) {
+          rect.w = rect.minW;
+          rect.h = rect.minH;
+          container.layoutRect(rect);
+          this.recalc(container);
+          if (container._lastRect === null) {
+            var parentCtrl = container.parent();
+            if (parentCtrl) {
+              parentCtrl._lastRect = null;
+              parentCtrl.recalc();
+            }
+          }
+          return;
+        }
+        if (contLayoutRect.autoResize) {
+          rect = container.layoutRect(rect);
+          rect.contentW = rect.minW - contLayoutRect.deltaW;
+          rect.contentH = rect.minH - contLayoutRect.deltaH;
+        }
+        var flexV;
+        if (settings.packV === 'start') {
+          flexV = 0;
+        } else {
+          flexV = availableHeight > 0 ? Math.floor(availableHeight / rows) : 0;
+        }
+        var totalFlex = 0;
+        var flexWidths = settings.flexWidths;
+        if (flexWidths) {
+          for (x = 0; x < flexWidths.length; x++) {
+            totalFlex += flexWidths[x];
+          }
+        } else {
+          totalFlex = cols;
+        }
+        var ratio = availableWidth / totalFlex;
+        for (x = 0; x < cols; x++) {
+          colWidths[x] += flexWidths ? flexWidths[x] * ratio : ratio;
+        }
+        posY = contPaddingBox.top;
+        for (y = 0; y < rows; y++) {
+          posX = contPaddingBox.left;
+          height = rowHeights[y] + flexV;
+          for (x = 0; x < cols; x++) {
+            if (reverseRows) {
+              idx = y * cols + cols - 1 - x;
+            } else {
+              idx = y * cols + x;
+            }
+            ctrl = items[idx];
+            if (!ctrl) {
+              break;
+            }
+            ctrlSettings = ctrl.settings;
+            ctrlLayoutRect = ctrl.layoutRect();
+            width = Math.max(colWidths[x], ctrlLayoutRect.startMinWidth);
+            ctrlLayoutRect.x = posX;
+            ctrlLayoutRect.y = posY;
+            align = ctrlSettings.alignH || (alignH ? alignH[x] || alignH[0] : null);
+            if (align === 'center') {
+              ctrlLayoutRect.x = posX + width / 2 - ctrlLayoutRect.w / 2;
+            } else if (align === 'right') {
+              ctrlLayoutRect.x = posX + width - ctrlLayoutRect.w;
+            } else if (align === 'stretch') {
+              ctrlLayoutRect.w = width;
+            }
+            align = ctrlSettings.alignV || (alignV ? alignV[x] || alignV[0] : null);
+            if (align === 'center') {
+              ctrlLayoutRect.y = posY + height / 2 - ctrlLayoutRect.h / 2;
+            } else if (align === 'bottom') {
+              ctrlLayoutRect.y = posY + height - ctrlLayoutRect.h;
+            } else if (align === 'stretch') {
+              ctrlLayoutRect.h = height;
+            }
+            ctrl.layoutRect(ctrlLayoutRect);
+            posX += width + spacingH;
+            if (ctrl.recalc) {
+              ctrl.recalc();
+            }
+          }
+          posY += height + spacingV;
+        }
+      }
+    });
+
+    var Iframe = Widget.extend({
+      renderHtml: function () {
+        var self = this;
+        self.classes.add('iframe');
+        self.canFocus = false;
+        return '<iframe id="' + self._id + '" class="' + self.classes + '" tabindex="-1" src="' + (self.settings.url || 'javascript:\'\'') + '" frameborder="0"></iframe>';
+      },
+      src: function (src) {
+        this.getEl().src = src;
+      },
+      html: function (html, callback) {
+        var self = this, body = this.getEl().contentWindow.document.body;
+        if (!body) {
+          global$3.setTimeout(function () {
+            self.html(html);
+          });
+        } else {
+          body.innerHTML = html;
+          if (callback) {
+            callback();
+          }
+        }
+        return this;
+      }
+    });
+
+    var InfoBox = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.classes.add('widget').add('infobox');
+        self.canFocus = false;
+      },
+      severity: function (level) {
+        this.classes.remove('error');
+        this.classes.remove('warning');
+        this.classes.remove('success');
+        this.classes.add(level);
+      },
+      help: function (state) {
+        this.state.set('help', state);
+      },
+      renderHtml: function () {
+        var self = this, prefix = self.classPrefix;
+        return '<div id="' + self._id + '" class="' + self.classes + '">' + '<div id="' + self._id + '-body">' + self.encode(self.state.get('text')) + '<button role="button" tabindex="-1">' + '<i class="' + prefix + 'ico ' + prefix + 'i-help"></i>' + '</button>' + '</div>' + '</div>';
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:text', function (e) {
+          self.getEl('body').firstChild.data = self.encode(e.value);
+          if (self.state.get('rendered')) {
+            self.updateLayoutRect();
+          }
+        });
+        self.state.on('change:help', function (e) {
+          self.classes.toggle('has-help', e.value);
+          if (self.state.get('rendered')) {
+            self.updateLayoutRect();
+          }
+        });
+        return self._super();
+      }
+    });
+
+    var Label = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.classes.add('widget').add('label');
+        self.canFocus = false;
+        if (settings.multiline) {
+          self.classes.add('autoscroll');
+        }
+        if (settings.strong) {
+          self.classes.add('strong');
+        }
+      },
+      initLayoutRect: function () {
+        var self = this, layoutRect = self._super();
+        if (self.settings.multiline) {
+          var size = funcs.getSize(self.getEl());
+          if (size.width > layoutRect.maxW) {
+            layoutRect.minW = layoutRect.maxW;
+            self.classes.add('multiline');
+          }
+          self.getEl().style.width = layoutRect.minW + 'px';
+          layoutRect.startMinH = layoutRect.h = layoutRect.minH = Math.min(layoutRect.maxH, funcs.getSize(self.getEl()).height);
+        }
+        return layoutRect;
+      },
+      repaint: function () {
+        var self = this;
+        if (!self.settings.multiline) {
+          self.getEl().style.lineHeight = self.layoutRect().h + 'px';
+        }
+        return self._super();
+      },
+      severity: function (level) {
+        this.classes.remove('error');
+        this.classes.remove('warning');
+        this.classes.remove('success');
+        this.classes.add(level);
+      },
+      renderHtml: function () {
+        var self = this;
+        var targetCtrl, forName, forId = self.settings.forId;
+        var text = self.settings.html ? self.settings.html : self.encode(self.state.get('text'));
+        if (!forId && (forName = self.settings.forName)) {
+          targetCtrl = self.getRoot().find('#' + forName)[0];
+          if (targetCtrl) {
+            forId = targetCtrl._id;
+          }
+        }
+        if (forId) {
+          return '<label id="' + self._id + '" class="' + self.classes + '"' + (forId ? ' for="' + forId + '"' : '') + '>' + text + '</label>';
+        }
+        return '<span id="' + self._id + '" class="' + self.classes + '">' + text + '</span>';
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:text', function (e) {
+          self.innerHtml(self.encode(e.value));
+          if (self.state.get('rendered')) {
+            self.updateLayoutRect();
+          }
+        });
+        return self._super();
+      }
+    });
+
+    var Toolbar$1 = Container.extend({
+      Defaults: {
+        role: 'toolbar',
+        layout: 'flow'
+      },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.classes.add('toolbar');
+      },
+      postRender: function () {
+        var self = this;
+        self.items().each(function (ctrl) {
+          ctrl.classes.add('toolbar-item');
+        });
+        return self._super();
+      }
+    });
+
+    var MenuBar = Toolbar$1.extend({
+      Defaults: {
+        role: 'menubar',
+        containerCls: 'menubar',
+        ariaRoot: true,
+        defaults: { type: 'menubutton' }
+      }
+    });
+
+    function isChildOf$1(node, parent) {
+      while (node) {
+        if (parent === node) {
+          return true;
+        }
+        node = node.parentNode;
+      }
+      return false;
+    }
+    var MenuButton = Button.extend({
+      init: function (settings) {
+        var self = this;
+        self._renderOpen = true;
+        self._super(settings);
+        settings = self.settings;
+        self.classes.add('menubtn');
+        if (settings.fixedWidth) {
+          self.classes.add('fixed-width');
+        }
+        self.aria('haspopup', true);
+        self.state.set('menu', settings.menu || self.render());
+      },
+      showMenu: function (toggle) {
+        var self = this;
+        var menu;
+        if (self.menu && self.menu.visible() && toggle !== false) {
+          return self.hideMenu();
+        }
+        if (!self.menu) {
+          menu = self.state.get('menu') || [];
+          self.classes.add('opened');
+          if (menu.length) {
+            menu = {
+              type: 'menu',
+              animate: true,
+              items: menu
+            };
+          } else {
+            menu.type = menu.type || 'menu';
+            menu.animate = true;
+          }
+          if (!menu.renderTo) {
+            self.menu = global$b.create(menu).parent(self).renderTo();
+          } else {
+            self.menu = menu.parent(self).show().renderTo();
+          }
+          self.fire('createmenu');
+          self.menu.reflow();
+          self.menu.on('cancel', function (e) {
+            if (e.control.parent() === self.menu) {
+              e.stopPropagation();
+              self.focus();
+              self.hideMenu();
+            }
+          });
+          self.menu.on('select', function () {
+            self.focus();
+          });
+          self.menu.on('show hide', function (e) {
+            if (e.type === 'hide' && e.control.parent() === self) {
+              self.classes.remove('opened-under');
+            }
+            if (e.control === self.menu) {
+              self.activeMenu(e.type === 'show');
+              self.classes.toggle('opened', e.type === 'show');
+            }
+            self.aria('expanded', e.type === 'show');
+          }).fire('show');
+        }
+        self.menu.show();
+        self.menu.layoutRect({ w: self.layoutRect().w });
+        self.menu.repaint();
+        self.menu.moveRel(self.getEl(), self.isRtl() ? [
+          'br-tr',
+          'tr-br'
+        ] : [
+          'bl-tl',
+          'tl-bl'
+        ]);
+        var menuLayoutRect = self.menu.layoutRect();
+        var selfBottom = self.$el.offset().top + self.layoutRect().h;
+        if (selfBottom > menuLayoutRect.y && selfBottom < menuLayoutRect.y + menuLayoutRect.h) {
+          self.classes.add('opened-under');
+        }
+        self.fire('showmenu');
+      },
+      hideMenu: function () {
+        var self = this;
+        if (self.menu) {
+          self.menu.items().each(function (item) {
+            if (item.hideMenu) {
+              item.hideMenu();
+            }
+          });
+          self.menu.hide();
+        }
+      },
+      activeMenu: function (state) {
+        this.classes.toggle('active', state);
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = self.classPrefix;
+        var icon = self.settings.icon, image;
+        var text = self.state.get('text');
+        var textHtml = '';
+        image = self.settings.image;
+        if (image) {
+          icon = 'none';
+          if (typeof image !== 'string') {
+            image = domGlobals.window.getSelection ? image[0] : image[1];
+          }
+          image = ' style="background-image: url(\'' + image + '\')"';
+        } else {
+          image = '';
+        }
+        if (text) {
+          self.classes.add('btn-has-text');
+          textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
+        }
+        icon = self.settings.icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
+        self.aria('role', self.parent() instanceof MenuBar ? 'menuitem' : 'button');
+        return '<div id="' + id + '" class="' + self.classes + '" tabindex="-1" aria-labelledby="' + id + '">' + '<button id="' + id + '-open" role="presentation" type="button" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + textHtml + ' <i class="' + prefix + 'caret"></i>' + '</button>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        self.on('click', function (e) {
+          if (e.control === self && isChildOf$1(e.target, self.getEl())) {
+            self.focus();
+            self.showMenu(!e.aria);
+            if (e.aria) {
+              self.menu.items().filter(':visible')[0].focus();
+            }
+          }
+        });
+        self.on('mouseenter', function (e) {
+          var overCtrl = e.control;
+          var parent = self.parent();
+          var hasVisibleSiblingMenu;
+          if (overCtrl && parent && overCtrl instanceof MenuButton && overCtrl.parent() === parent) {
+            parent.items().filter('MenuButton').each(function (ctrl) {
+              if (ctrl.hideMenu && ctrl !== overCtrl) {
+                if (ctrl.menu && ctrl.menu.visible()) {
+                  hasVisibleSiblingMenu = true;
+                }
+                ctrl.hideMenu();
+              }
+            });
+            if (hasVisibleSiblingMenu) {
+              overCtrl.focus();
+              overCtrl.showMenu();
+            }
+          }
+        });
+        return self._super();
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:menu', function () {
+          if (self.menu) {
+            self.menu.remove();
+          }
+          self.menu = null;
+        });
+        return self._super();
+      },
+      remove: function () {
+        this._super();
+        if (this.menu) {
+          this.menu.remove();
+        }
+      }
+    });
+
+    function Throbber (elm, inline) {
+      var self = this;
+      var state;
+      var classPrefix = Control$1.classPrefix;
+      var timer;
+      self.show = function (time, callback) {
+        function render() {
+          if (state) {
+            global$7(elm).append('<div class="' + classPrefix + 'throbber' + (inline ? ' ' + classPrefix + 'throbber-inline' : '') + '"></div>');
+            if (callback) {
+              callback();
+            }
+          }
+        }
+        self.hide();
+        state = true;
+        if (time) {
+          timer = global$3.setTimeout(render, time);
+        } else {
+          render();
+        }
+        return self;
+      };
+      self.hide = function () {
+        var child = elm.lastChild;
+        global$3.clearTimeout(timer);
+        if (child && child.className.indexOf('throbber') !== -1) {
+          child.parentNode.removeChild(child);
+        }
+        state = false;
+        return self;
+      };
+    }
+
+    var Menu = FloatPanel.extend({
+      Defaults: {
+        defaultType: 'menuitem',
+        border: 1,
+        layout: 'stack',
+        role: 'application',
+        bodyRole: 'menu',
+        ariaRoot: true
+      },
+      init: function (settings) {
+        var self = this;
+        settings.autohide = true;
+        settings.constrainToViewport = true;
+        if (typeof settings.items === 'function') {
+          settings.itemsFactory = settings.items;
+          settings.items = [];
+        }
+        if (settings.itemDefaults) {
+          var items = settings.items;
+          var i = items.length;
+          while (i--) {
+            items[i] = global$4.extend({}, settings.itemDefaults, items[i]);
+          }
+        }
+        self._super(settings);
+        self.classes.add('menu');
+        if (settings.animate && global$1.ie !== 11) {
+          self.classes.add('animate');
+        }
+      },
+      repaint: function () {
+        this.classes.toggle('menu-align', true);
+        this._super();
+        this.getEl().style.height = '';
+        this.getEl('body').style.height = '';
+        return this;
+      },
+      cancel: function () {
+        var self = this;
+        self.hideAll();
+        self.fire('select');
+      },
+      load: function () {
+        var self = this;
+        var time, factory;
+        function hideThrobber() {
+          if (self.throbber) {
+            self.throbber.hide();
+            self.throbber = null;
+          }
+        }
+        factory = self.settings.itemsFactory;
+        if (!factory) {
+          return;
+        }
+        if (!self.throbber) {
+          self.throbber = new Throbber(self.getEl('body'), true);
+          if (self.items().length === 0) {
+            self.throbber.show();
+            self.fire('loading');
+          } else {
+            self.throbber.show(100, function () {
+              self.items().remove();
+              self.fire('loading');
+            });
+          }
+          self.on('hide close', hideThrobber);
+        }
+        self.requestTime = time = new Date().getTime();
+        self.settings.itemsFactory(function (items) {
+          if (items.length === 0) {
+            self.hide();
+            return;
+          }
+          if (self.requestTime !== time) {
+            return;
+          }
+          self.getEl().style.width = '';
+          self.getEl('body').style.width = '';
+          hideThrobber();
+          self.items().remove();
+          self.getEl('body').innerHTML = '';
+          self.add(items);
+          self.renderNew();
+          self.fire('loaded');
+        });
+      },
+      hideAll: function () {
+        var self = this;
+        this.find('menuitem').exec('hideMenu');
+        return self._super();
+      },
+      preRender: function () {
+        var self = this;
+        self.items().each(function (ctrl) {
+          var settings = ctrl.settings;
+          if (settings.icon || settings.image || settings.selectable) {
+            self._hasIcons = true;
+            return false;
+          }
+        });
+        if (self.settings.itemsFactory) {
+          self.on('postrender', function () {
+            if (self.settings.itemsFactory) {
+              self.load();
+            }
+          });
+        }
+        self.on('show hide', function (e) {
+          if (e.control === self) {
+            if (e.type === 'show') {
+              global$3.setTimeout(function () {
+                self.classes.add('in');
+              }, 0);
+            } else {
+              self.classes.remove('in');
+            }
+          }
+        });
+        return self._super();
+      }
+    });
+
+    var ListBox = MenuButton.extend({
+      init: function (settings) {
+        var self = this;
+        var values, selected, selectedText, lastItemCtrl;
+        function setSelected(menuValues) {
+          for (var i = 0; i < menuValues.length; i++) {
+            selected = menuValues[i].selected || settings.value === menuValues[i].value;
+            if (selected) {
+              selectedText = selectedText || menuValues[i].text;
+              self.state.set('value', menuValues[i].value);
+              return true;
+            }
+            if (menuValues[i].menu) {
+              if (setSelected(menuValues[i].menu)) {
+                return true;
+              }
+            }
+          }
+        }
+        self._super(settings);
+        settings = self.settings;
+        self._values = values = settings.values;
+        if (values) {
+          if (typeof settings.value !== 'undefined') {
+            setSelected(values);
+          }
+          if (!selected && values.length > 0) {
+            selectedText = values[0].text;
+            self.state.set('value', values[0].value);
+          }
+          self.state.set('menu', values);
+        }
+        self.state.set('text', settings.text || selectedText);
+        self.classes.add('listbox');
+        self.on('select', function (e) {
+          var ctrl = e.control;
+          if (lastItemCtrl) {
+            e.lastControl = lastItemCtrl;
+          }
+          if (settings.multiple) {
+            ctrl.active(!ctrl.active());
+          } else {
+            self.value(e.control.value());
+          }
+          lastItemCtrl = ctrl;
+        });
+      },
+      value: function (value) {
+        if (arguments.length === 0) {
+          return this.state.get('value');
+        }
+        if (typeof value === 'undefined') {
+          return this;
+        }
+        function valueExists(values) {
+          return exists(values, function (a) {
+            return a.menu ? valueExists(a.menu) : a.value === value;
+          });
+        }
+        if (this.settings.values) {
+          if (valueExists(this.settings.values)) {
+            this.state.set('value', value);
+          } else if (value === null) {
+            this.state.set('value', null);
+          }
+        } else {
+          this.state.set('value', value);
+        }
+        return this;
+      },
+      bindStates: function () {
+        var self = this;
+        function activateMenuItemsByValue(menu, value) {
+          if (menu instanceof Menu) {
+            menu.items().each(function (ctrl) {
+              if (!ctrl.hasMenus()) {
+                ctrl.active(ctrl.value() === value);
+              }
+            });
+          }
+        }
+        function getSelectedItem(menuValues, value) {
+          var selectedItem;
+          if (!menuValues) {
+            return;
+          }
+          for (var i = 0; i < menuValues.length; i++) {
+            if (menuValues[i].value === value) {
+              return menuValues[i];
+            }
+            if (menuValues[i].menu) {
+              selectedItem = getSelectedItem(menuValues[i].menu, value);
+              if (selectedItem) {
+                return selectedItem;
+              }
+            }
+          }
+        }
+        self.on('show', function (e) {
+          activateMenuItemsByValue(e.control, self.value());
+        });
+        self.state.on('change:value', function (e) {
+          var selectedItem = getSelectedItem(self.state.get('menu'), e.value);
+          if (selectedItem) {
+            self.text(selectedItem.text);
+          } else {
+            self.text(self.settings.text);
+          }
+        });
+        return self._super();
+      }
+    });
+
+    var toggleTextStyle = function (ctrl, state) {
+      var textStyle = ctrl._textStyle;
+      if (textStyle) {
+        var textElm = ctrl.getEl('text');
+        textElm.setAttribute('style', textStyle);
+        if (state) {
+          textElm.style.color = '';
+          textElm.style.backgroundColor = '';
+        }
+      }
+    };
+    var MenuItem = Widget.extend({
+      Defaults: {
+        border: 0,
+        role: 'menuitem'
+      },
+      init: function (settings) {
+        var self = this;
+        var text;
+        self._super(settings);
+        settings = self.settings;
+        self.classes.add('menu-item');
+        if (settings.menu) {
+          self.classes.add('menu-item-expand');
+        }
+        if (settings.preview) {
+          self.classes.add('menu-item-preview');
+        }
+        text = self.state.get('text');
+        if (text === '-' || text === '|') {
+          self.classes.add('menu-item-sep');
+          self.aria('role', 'separator');
+          self.state.set('text', '-');
+        }
+        if (settings.selectable) {
+          self.aria('role', 'menuitemcheckbox');
+          self.classes.add('menu-item-checkbox');
+          settings.icon = 'selected';
+        }
+        if (!settings.preview && !settings.selectable) {
+          self.classes.add('menu-item-normal');
+        }
+        self.on('mousedown', function (e) {
+          e.preventDefault();
+        });
+        if (settings.menu && !settings.ariaHideMenu) {
+          self.aria('haspopup', true);
+        }
+      },
+      hasMenus: function () {
+        return !!this.settings.menu;
+      },
+      showMenu: function () {
+        var self = this;
+        var settings = self.settings;
+        var menu;
+        var parent = self.parent();
+        parent.items().each(function (ctrl) {
+          if (ctrl !== self) {
+            ctrl.hideMenu();
+          }
+        });
+        if (settings.menu) {
+          menu = self.menu;
+          if (!menu) {
+            menu = settings.menu;
+            if (menu.length) {
+              menu = {
+                type: 'menu',
+                items: menu
+              };
+            } else {
+              menu.type = menu.type || 'menu';
+            }
+            if (parent.settings.itemDefaults) {
+              menu.itemDefaults = parent.settings.itemDefaults;
+            }
+            menu = self.menu = global$b.create(menu).parent(self).renderTo();
+            menu.reflow();
+            menu.on('cancel', function (e) {
+              e.stopPropagation();
+              self.focus();
+              menu.hide();
+            });
+            menu.on('show hide', function (e) {
+              if (e.control.items) {
+                e.control.items().each(function (ctrl) {
+                  ctrl.active(ctrl.settings.selected);
+                });
+              }
+            }).fire('show');
+            menu.on('hide', function (e) {
+              if (e.control === menu) {
+                self.classes.remove('selected');
+              }
+            });
+            menu.submenu = true;
+          } else {
+            menu.show();
+          }
+          menu._parentMenu = parent;
+          menu.classes.add('menu-sub');
+          var rel = menu.testMoveRel(self.getEl(), self.isRtl() ? [
+            'tl-tr',
+            'bl-br',
+            'tr-tl',
+            'br-bl'
+          ] : [
+            'tr-tl',
+            'br-bl',
+            'tl-tr',
+            'bl-br'
+          ]);
+          menu.moveRel(self.getEl(), rel);
+          menu.rel = rel;
+          rel = 'menu-sub-' + rel;
+          menu.classes.remove(menu._lastRel).add(rel);
+          menu._lastRel = rel;
+          self.classes.add('selected');
+          self.aria('expanded', true);
+        }
+      },
+      hideMenu: function () {
+        var self = this;
+        if (self.menu) {
+          self.menu.items().each(function (item) {
+            if (item.hideMenu) {
+              item.hideMenu();
+            }
+          });
+          self.menu.hide();
+          self.aria('expanded', false);
+        }
+        return self;
+      },
+      renderHtml: function () {
+        var self = this;
+        var id = self._id;
+        var settings = self.settings;
+        var prefix = self.classPrefix;
+        var text = self.state.get('text');
+        var icon = self.settings.icon, image = '', shortcut = settings.shortcut;
+        var url = self.encode(settings.url), iconHtml = '';
+        function convertShortcut(shortcut) {
+          var i, value, replace = {};
+          if (global$1.mac) {
+            replace = {
+              alt: '&#x2325;',
+              ctrl: '&#x2318;',
+              shift: '&#x21E7;',
+              meta: '&#x2318;'
+            };
+          } else {
+            replace = { meta: 'Ctrl' };
+          }
+          shortcut = shortcut.split('+');
+          for (i = 0; i < shortcut.length; i++) {
+            value = replace[shortcut[i].toLowerCase()];
+            if (value) {
+              shortcut[i] = value;
+            }
+          }
+          return shortcut.join('+');
+        }
+        function escapeRegExp(str) {
+          return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        }
+        function markMatches(text) {
+          var match = settings.match || '';
+          return match ? text.replace(new RegExp(escapeRegExp(match), 'gi'), function (match) {
+            return '!mce~match[' + match + ']mce~match!';
+          }) : text;
+        }
+        function boldMatches(text) {
+          return text.replace(new RegExp(escapeRegExp('!mce~match['), 'g'), '<b>').replace(new RegExp(escapeRegExp(']mce~match!'), 'g'), '</b>');
+        }
+        if (icon) {
+          self.parent().classes.add('menu-has-icons');
+        }
+        if (settings.image) {
+          image = ' style="background-image: url(\'' + settings.image + '\')"';
+        }
+        if (shortcut) {
+          shortcut = convertShortcut(shortcut);
+        }
+        icon = prefix + 'ico ' + prefix + 'i-' + (self.settings.icon || 'none');
+        iconHtml = text !== '-' ? '<i class="' + icon + '"' + image + '></i>\xA0' : '';
+        text = boldMatches(self.encode(markMatches(text)));
+        url = boldMatches(self.encode(markMatches(url)));
+        return '<div id="' + id + '" class="' + self.classes + '" tabindex="-1">' + iconHtml + (text !== '-' ? '<span id="' + id + '-text" class="' + prefix + 'text">' + text + '</span>' : '') + (shortcut ? '<div id="' + id + '-shortcut" class="' + prefix + 'menu-shortcut">' + shortcut + '</div>' : '') + (settings.menu ? '<div class="' + prefix + 'caret"></div>' : '') + (url ? '<div class="' + prefix + 'menu-item-link">' + url + '</div>' : '') + '</div>';
+      },
+      postRender: function () {
+        var self = this, settings = self.settings;
+        var textStyle = settings.textStyle;
+        if (typeof textStyle === 'function') {
+          textStyle = textStyle.call(this);
+        }
+        if (textStyle) {
+          var textElm = self.getEl('text');
+          if (textElm) {
+            textElm.setAttribute('style', textStyle);
+            self._textStyle = textStyle;
+          }
+        }
+        self.on('mouseenter click', function (e) {
+          if (e.control === self) {
+            if (!settings.menu && e.type === 'click') {
+              self.fire('select');
+              global$3.requestAnimationFrame(function () {
+                self.parent().hideAll();
+              });
+            } else {
+              self.showMenu();
+              if (e.aria) {
+                self.menu.focus(true);
+              }
+            }
+          }
+        });
+        self._super();
+        return self;
+      },
+      hover: function () {
+        var self = this;
+        self.parent().items().each(function (ctrl) {
+          ctrl.classes.remove('selected');
+        });
+        self.classes.toggle('selected', true);
+        return self;
+      },
+      active: function (state) {
+        toggleTextStyle(this, state);
+        if (typeof state !== 'undefined') {
+          this.aria('checked', state);
+        }
+        return this._super(state);
+      },
+      remove: function () {
+        this._super();
+        if (this.menu) {
+          this.menu.remove();
+        }
+      }
+    });
+
+    var Radio = Checkbox.extend({
+      Defaults: {
+        classes: 'radio',
+        role: 'radio'
+      }
+    });
+
+    var ResizeHandle = Widget.extend({
+      renderHtml: function () {
+        var self = this, prefix = self.classPrefix;
+        self.classes.add('resizehandle');
+        if (self.settings.direction === 'both') {
+          self.classes.add('resizehandle-both');
+        }
+        self.canFocus = false;
+        return '<div id="' + self._id + '" class="' + self.classes + '">' + '<i class="' + prefix + 'ico ' + prefix + 'i-resize"></i>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        self._super();
+        self.resizeDragHelper = new DragHelper(this._id, {
+          start: function () {
+            self.fire('ResizeStart');
+          },
+          drag: function (e) {
+            if (self.settings.direction !== 'both') {
+              e.deltaX = 0;
+            }
+            self.fire('Resize', e);
+          },
+          stop: function () {
+            self.fire('ResizeEnd');
+          }
+        });
+      },
+      remove: function () {
+        if (this.resizeDragHelper) {
+          this.resizeDragHelper.destroy();
+        }
+        return this._super();
+      }
+    });
+
+    function createOptions(options) {
+      var strOptions = '';
+      if (options) {
+        for (var i = 0; i < options.length; i++) {
+          strOptions += '<option value="' + options[i] + '">' + options[i] + '</option>';
+        }
+      }
+      return strOptions;
+    }
+    var SelectBox = Widget.extend({
+      Defaults: {
+        classes: 'selectbox',
+        role: 'selectbox',
+        options: []
+      },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        if (self.settings.size) {
+          self.size = self.settings.size;
+        }
+        if (self.settings.options) {
+          self._options = self.settings.options;
+        }
+        self.on('keydown', function (e) {
+          var rootControl;
+          if (e.keyCode === 13) {
+            e.preventDefault();
+            self.parents().reverse().each(function (ctrl) {
+              if (ctrl.toJSON) {
+                rootControl = ctrl;
+                return false;
+              }
+            });
+            self.fire('submit', { data: rootControl.toJSON() });
+          }
+        });
+      },
+      options: function (state) {
+        if (!arguments.length) {
+          return this.state.get('options');
+        }
+        this.state.set('options', state);
+        return this;
+      },
+      renderHtml: function () {
+        var self = this;
+        var options, size = '';
+        options = createOptions(self._options);
+        if (self.size) {
+          size = ' size = "' + self.size + '"';
+        }
+        return '<select id="' + self._id + '" class="' + self.classes + '"' + size + '>' + options + '</select>';
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:options', function (e) {
+          self.getEl().innerHTML = createOptions(e.value);
+        });
+        return self._super();
+      }
+    });
+
+    function constrain(value, minVal, maxVal) {
+      if (value < minVal) {
+        value = minVal;
+      }
+      if (value > maxVal) {
+        value = maxVal;
+      }
+      return value;
+    }
+    function setAriaProp(el, name, value) {
+      el.setAttribute('aria-' + name, value);
+    }
+    function updateSliderHandle(ctrl, value) {
+      var maxHandlePos, shortSizeName, sizeName, stylePosName, styleValue, handleEl;
+      if (ctrl.settings.orientation === 'v') {
+        stylePosName = 'top';
+        sizeName = 'height';
+        shortSizeName = 'h';
+      } else {
+        stylePosName = 'left';
+        sizeName = 'width';
+        shortSizeName = 'w';
+      }
+      handleEl = ctrl.getEl('handle');
+      maxHandlePos = (ctrl.layoutRect()[shortSizeName] || 100) - funcs.getSize(handleEl)[sizeName];
+      styleValue = maxHandlePos * ((value - ctrl._minValue) / (ctrl._maxValue - ctrl._minValue)) + 'px';
+      handleEl.style[stylePosName] = styleValue;
+      handleEl.style.height = ctrl.layoutRect().h + 'px';
+      setAriaProp(handleEl, 'valuenow', value);
+      setAriaProp(handleEl, 'valuetext', '' + ctrl.settings.previewFilter(value));
+      setAriaProp(handleEl, 'valuemin', ctrl._minValue);
+      setAriaProp(handleEl, 'valuemax', ctrl._maxValue);
+    }
+    var Slider = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        if (!settings.previewFilter) {
+          settings.previewFilter = function (value) {
+            return Math.round(value * 100) / 100;
+          };
+        }
+        self._super(settings);
+        self.classes.add('slider');
+        if (settings.orientation === 'v') {
+          self.classes.add('vertical');
+        }
+        self._minValue = isNumber$1(settings.minValue) ? settings.minValue : 0;
+        self._maxValue = isNumber$1(settings.maxValue) ? settings.maxValue : 100;
+        self._initValue = self.state.get('value');
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = self.classPrefix;
+        return '<div id="' + id + '" class="' + self.classes + '">' + '<div id="' + id + '-handle" class="' + prefix + 'slider-handle" role="slider" tabindex="-1"></div>' + '</div>';
+      },
+      reset: function () {
+        this.value(this._initValue).repaint();
+      },
+      postRender: function () {
+        var self = this;
+        var minValue, maxValue, screenCordName, stylePosName, sizeName, shortSizeName;
+        function toFraction(min, max, val) {
+          return (val + min) / (max - min);
+        }
+        function fromFraction(min, max, val) {
+          return val * (max - min) - min;
+        }
+        function handleKeyboard(minValue, maxValue) {
+          function alter(delta) {
+            var value;
+            value = self.value();
+            value = fromFraction(minValue, maxValue, toFraction(minValue, maxValue, value) + delta * 0.05);
+            value = constrain(value, minValue, maxValue);
+            self.value(value);
+            self.fire('dragstart', { value: value });
+            self.fire('drag', { value: value });
+            self.fire('dragend', { value: value });
+          }
+          self.on('keydown', function (e) {
+            switch (e.keyCode) {
+            case 37:
+            case 38:
+              alter(-1);
+              break;
+            case 39:
+            case 40:
+              alter(1);
+              break;
+            }
+          });
+        }
+        function handleDrag(minValue, maxValue, handleEl) {
+          var startPos, startHandlePos, maxHandlePos, handlePos, value;
+          self._dragHelper = new DragHelper(self._id, {
+            handle: self._id + '-handle',
+            start: function (e) {
+              startPos = e[screenCordName];
+              startHandlePos = parseInt(self.getEl('handle').style[stylePosName], 10);
+              maxHandlePos = (self.layoutRect()[shortSizeName] || 100) - funcs.getSize(handleEl)[sizeName];
+              self.fire('dragstart', { value: value });
+            },
+            drag: function (e) {
+              var delta = e[screenCordName] - startPos;
+              handlePos = constrain(startHandlePos + delta, 0, maxHandlePos);
+              handleEl.style[stylePosName] = handlePos + 'px';
+              value = minValue + handlePos / maxHandlePos * (maxValue - minValue);
+              self.value(value);
+              self.tooltip().text('' + self.settings.previewFilter(value)).show().moveRel(handleEl, 'bc tc');
+              self.fire('drag', { value: value });
+            },
+            stop: function () {
+              self.tooltip().hide();
+              self.fire('dragend', { value: value });
+            }
+          });
+        }
+        minValue = self._minValue;
+        maxValue = self._maxValue;
+        if (self.settings.orientation === 'v') {
+          screenCordName = 'screenY';
+          stylePosName = 'top';
+          sizeName = 'height';
+          shortSizeName = 'h';
+        } else {
+          screenCordName = 'screenX';
+          stylePosName = 'left';
+          sizeName = 'width';
+          shortSizeName = 'w';
+        }
+        self._super();
+        handleKeyboard(minValue, maxValue);
+        handleDrag(minValue, maxValue, self.getEl('handle'));
+      },
+      repaint: function () {
+        this._super();
+        updateSliderHandle(this, this.value());
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:value', function (e) {
+          updateSliderHandle(self, e.value);
+        });
+        return self._super();
+      }
+    });
+
+    var Spacer = Widget.extend({
+      renderHtml: function () {
+        var self = this;
+        self.classes.add('spacer');
+        self.canFocus = false;
+        return '<div id="' + self._id + '" class="' + self.classes + '"></div>';
+      }
+    });
+
+    var SplitButton = MenuButton.extend({
+      Defaults: {
+        classes: 'widget btn splitbtn',
+        role: 'button'
+      },
+      repaint: function () {
+        var self = this;
+        var elm = self.getEl();
+        var rect = self.layoutRect();
+        var mainButtonElm, menuButtonElm;
+        self._super();
+        mainButtonElm = elm.firstChild;
+        menuButtonElm = elm.lastChild;
+        global$7(mainButtonElm).css({
+          width: rect.w - funcs.getSize(menuButtonElm).width,
+          height: rect.h - 2
+        });
+        global$7(menuButtonElm).css({ height: rect.h - 2 });
+        return self;
+      },
+      activeMenu: function (state) {
+        var self = this;
+        global$7(self.getEl().lastChild).toggleClass(self.classPrefix + 'active', state);
+      },
+      renderHtml: function () {
+        var self = this;
+        var id = self._id;
+        var prefix = self.classPrefix;
+        var image;
+        var icon = self.state.get('icon');
+        var text = self.state.get('text');
+        var settings = self.settings;
+        var textHtml = '', ariaPressed;
+        image = settings.image;
+        if (image) {
+          icon = 'none';
+          if (typeof image !== 'string') {
+            image = domGlobals.window.getSelection ? image[0] : image[1];
+          }
+          image = ' style="background-image: url(\'' + image + '\')"';
+        } else {
+          image = '';
+        }
+        icon = settings.icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
+        if (text) {
+          self.classes.add('btn-has-text');
+          textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
+        }
+        ariaPressed = typeof settings.active === 'boolean' ? ' aria-pressed="' + settings.active + '"' : '';
+        return '<div id="' + id + '" class="' + self.classes + '" role="button"' + ariaPressed + ' tabindex="-1">' + '<button type="button" hidefocus="1" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + textHtml + '</button>' + '<button type="button" class="' + prefix + 'open" hidefocus="1" tabindex="-1">' + (self._menuBtnText ? (icon ? '\xA0' : '') + self._menuBtnText : '') + ' <i class="' + prefix + 'caret"></i>' + '</button>' + '</div>';
+      },
+      postRender: function () {
+        var self = this, onClickHandler = self.settings.onclick;
+        self.on('click', function (e) {
+          var node = e.target;
+          if (e.control === this) {
+            while (node) {
+              if (e.aria && e.aria.key !== 'down' || node.nodeName === 'BUTTON' && node.className.indexOf('open') === -1) {
+                e.stopImmediatePropagation();
+                if (onClickHandler) {
+                  onClickHandler.call(this, e);
+                }
+                return;
+              }
+              node = node.parentNode;
+            }
+          }
+        });
+        delete self.settings.onclick;
+        return self._super();
+      }
+    });
+
+    var StackLayout = FlowLayout.extend({
+      Defaults: {
+        containerClass: 'stack-layout',
+        controlClass: 'stack-layout-item',
+        endClass: 'break'
+      },
+      isNative: function () {
+        return true;
+      }
+    });
+
+    var TabPanel = Panel.extend({
+      Defaults: {
+        layout: 'absolute',
+        defaults: { type: 'panel' }
+      },
+      activateTab: function (idx) {
+        var activeTabElm;
+        if (this.activeTabId) {
+          activeTabElm = this.getEl(this.activeTabId);
+          global$7(activeTabElm).removeClass(this.classPrefix + 'active');
+          activeTabElm.setAttribute('aria-selected', 'false');
+        }
+        this.activeTabId = 't' + idx;
+        activeTabElm = this.getEl('t' + idx);
+        activeTabElm.setAttribute('aria-selected', 'true');
+        global$7(activeTabElm).addClass(this.classPrefix + 'active');
+        this.items()[idx].show().fire('showtab');
+        this.reflow();
+        this.items().each(function (item, i) {
+          if (idx !== i) {
+            item.hide();
+          }
+        });
+      },
+      renderHtml: function () {
+        var self = this;
+        var layout = self._layout;
+        var tabsHtml = '';
+        var prefix = self.classPrefix;
+        self.preRender();
+        layout.preRender(self);
+        self.items().each(function (ctrl, i) {
+          var id = self._id + '-t' + i;
+          ctrl.aria('role', 'tabpanel');
+          ctrl.aria('labelledby', id);
+          tabsHtml += '<div id="' + id + '" class="' + prefix + 'tab" ' + 'unselectable="on" role="tab" aria-controls="' + ctrl._id + '" aria-selected="false" tabIndex="-1">' + self.encode(ctrl.settings.title) + '</div>';
+        });
+        return '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' + '<div id="' + self._id + '-head" class="' + prefix + 'tabs" role="tablist">' + tabsHtml + '</div>' + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + layout.renderHtml(self) + '</div>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        self._super();
+        self.settings.activeTab = self.settings.activeTab || 0;
+        self.activateTab(self.settings.activeTab);
+        this.on('click', function (e) {
+          var targetParent = e.target.parentNode;
+          if (targetParent && targetParent.id === self._id + '-head') {
+            var i = targetParent.childNodes.length;
+            while (i--) {
+              if (targetParent.childNodes[i] === e.target) {
+                self.activateTab(i);
+              }
+            }
+          }
+        });
+      },
+      initLayoutRect: function () {
+        var self = this;
+        var rect, minW, minH;
+        minW = funcs.getSize(self.getEl('head')).width;
+        minW = minW < 0 ? 0 : minW;
+        minH = 0;
+        self.items().each(function (item) {
+          minW = Math.max(minW, item.layoutRect().minW);
+          minH = Math.max(minH, item.layoutRect().minH);
+        });
+        self.items().each(function (ctrl) {
+          ctrl.settings.x = 0;
+          ctrl.settings.y = 0;
+          ctrl.settings.w = minW;
+          ctrl.settings.h = minH;
+          ctrl.layoutRect({
+            x: 0,
+            y: 0,
+            w: minW,
+            h: minH
+          });
+        });
+        var headH = funcs.getSize(self.getEl('head')).height;
+        self.settings.minWidth = minW;
+        self.settings.minHeight = minH + headH;
+        rect = self._super();
+        rect.deltaH += headH;
+        rect.innerH = rect.h - rect.deltaH;
+        return rect;
+      }
+    });
+
+    var TextBox = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.classes.add('textbox');
+        if (settings.multiline) {
+          self.classes.add('multiline');
+        } else {
+          self.on('keydown', function (e) {
+            var rootControl;
+            if (e.keyCode === 13) {
+              e.preventDefault();
+              self.parents().reverse().each(function (ctrl) {
+                if (ctrl.toJSON) {
+                  rootControl = ctrl;
+                  return false;
+                }
+              });
+              self.fire('submit', { data: rootControl.toJSON() });
+            }
+          });
+          self.on('keyup', function (e) {
+            self.state.set('value', e.target.value);
+          });
+        }
+      },
+      repaint: function () {
+        var self = this;
+        var style, rect, borderBox, borderW, borderH = 0, lastRepaintRect;
+        style = self.getEl().style;
+        rect = self._layoutRect;
+        lastRepaintRect = self._lastRepaintRect || {};
+        var doc = domGlobals.document;
+        if (!self.settings.multiline && doc.all && (!doc.documentMode || doc.documentMode <= 8)) {
+          style.lineHeight = rect.h - borderH + 'px';
+        }
+        borderBox = self.borderBox;
+        borderW = borderBox.left + borderBox.right + 8;
+        borderH = borderBox.top + borderBox.bottom + (self.settings.multiline ? 8 : 0);
+        if (rect.x !== lastRepaintRect.x) {
+          style.left = rect.x + 'px';
+          lastRepaintRect.x = rect.x;
+        }
+        if (rect.y !== lastRepaintRect.y) {
+          style.top = rect.y + 'px';
+          lastRepaintRect.y = rect.y;
+        }
+        if (rect.w !== lastRepaintRect.w) {
+          style.width = rect.w - borderW + 'px';
+          lastRepaintRect.w = rect.w;
+        }
+        if (rect.h !== lastRepaintRect.h) {
+          style.height = rect.h - borderH + 'px';
+          lastRepaintRect.h = rect.h;
+        }
+        self._lastRepaintRect = lastRepaintRect;
+        self.fire('repaint', {}, false);
+        return self;
+      },
+      renderHtml: function () {
+        var self = this;
+        var settings = self.settings;
+        var attrs, elm;
+        attrs = {
+          id: self._id,
+          hidefocus: '1'
+        };
+        global$4.each([
+          'rows',
+          'spellcheck',
+          'maxLength',
+          'size',
+          'readonly',
+          'min',
+          'max',
+          'step',
+          'list',
+          'pattern',
+          'placeholder',
+          'required',
+          'multiple'
+        ], function (name) {
+          attrs[name] = settings[name];
+        });
+        if (self.disabled()) {
+          attrs.disabled = 'disabled';
+        }
+        if (settings.subtype) {
+          attrs.type = settings.subtype;
+        }
+        elm = funcs.create(settings.multiline ? 'textarea' : 'input', attrs);
+        elm.value = self.state.get('value');
+        elm.className = self.classes.toString();
+        return elm.outerHTML;
+      },
+      value: function (value) {
+        if (arguments.length) {
+          this.state.set('value', value);
+          return this;
+        }
+        if (this.state.get('rendered')) {
+          this.state.set('value', this.getEl().value);
+        }
+        return this.state.get('value');
+      },
+      postRender: function () {
+        var self = this;
+        self.getEl().value = self.state.get('value');
+        self._super();
+        self.$el.on('change', function (e) {
+          self.state.set('value', e.target.value);
+          self.fire('change', e);
+        });
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:value', function (e) {
+          if (self.getEl().value !== e.value) {
+            self.getEl().value = e.value;
+          }
+        });
+        self.state.on('change:disabled', function (e) {
+          self.getEl().disabled = e.value;
+        });
+        return self._super();
+      },
+      remove: function () {
+        this.$el.off();
+        this._super();
+      }
+    });
+
+    var getApi = function () {
+      return {
+        Selector: Selector,
+        Collection: Collection$2,
+        ReflowQueue: ReflowQueue,
+        Control: Control$1,
+        Factory: global$b,
+        KeyboardNavigation: KeyboardNavigation,
+        Container: Container,
+        DragHelper: DragHelper,
+        Scrollable: Scrollable,
+        Panel: Panel,
+        Movable: Movable,
+        Resizable: Resizable,
+        FloatPanel: FloatPanel,
+        Window: Window,
+        MessageBox: MessageBox,
+        Tooltip: Tooltip,
+        Widget: Widget,
+        Progress: Progress,
+        Notification: Notification,
+        Layout: Layout$1,
+        AbsoluteLayout: AbsoluteLayout,
+        Button: Button,
+        ButtonGroup: ButtonGroup,
+        Checkbox: Checkbox,
+        ComboBox: ComboBox,
+        ColorBox: ColorBox,
+        PanelButton: PanelButton,
+        ColorButton: ColorButton,
+        ColorPicker: ColorPicker,
+        Path: Path,
+        ElementPath: ElementPath,
+        FormItem: FormItem,
+        Form: Form,
+        FieldSet: FieldSet,
+        FilePicker: FilePicker,
+        FitLayout: FitLayout,
+        FlexLayout: FlexLayout,
+        FlowLayout: FlowLayout,
+        FormatControls: FormatControls,
+        GridLayout: GridLayout,
+        Iframe: Iframe,
+        InfoBox: InfoBox,
+        Label: Label,
+        Toolbar: Toolbar$1,
+        MenuBar: MenuBar,
+        MenuButton: MenuButton,
+        MenuItem: MenuItem,
+        Throbber: Throbber,
+        Menu: Menu,
+        ListBox: ListBox,
+        Radio: Radio,
+        ResizeHandle: ResizeHandle,
+        SelectBox: SelectBox,
+        Slider: Slider,
+        Spacer: Spacer,
+        SplitButton: SplitButton,
+        StackLayout: StackLayout,
+        TabPanel: TabPanel,
+        TextBox: TextBox,
+        DropZone: DropZone,
+        BrowseButton: BrowseButton
+      };
+    };
+    var appendTo = function (target) {
+      if (target.ui) {
+        global$4.each(getApi(), function (ref, key) {
+          target.ui[key] = ref;
+        });
+      } else {
+        target.ui = getApi();
+      }
+    };
+    var registerToFactory = function () {
+      global$4.each(getApi(), function (ref, key) {
+        global$b.add(key, ref);
+      });
+    };
+    var Api = {
+      appendTo: appendTo,
+      registerToFactory: registerToFactory
+    };
+
+    Api.registerToFactory();
+    Api.appendTo(window.tinymce ? window.tinymce : {});
+    global.add('inlite', function (editor) {
+      var panel = create$3();
+      FormatControls.setup(editor);
+      Buttons.addToEditor(editor, panel);
+      return ThemeApi.get(editor, panel);
+    });
+    function Theme () {
+    }
+
+    return Theme;
+
+}(window));
+})();
diff --git a/wp-includes/js/tinymce/themes/inlite/theme.min.js b/wp-includes/js/tinymce/themes/inlite/theme.min.js
new file mode 100644
index 0000000..8eba581
--- /dev/null
+++ b/wp-includes/js/tinymce/themes/inlite/theme.min.js
@@ -0,0 +1 @@
+!function(_){"use strict";var u,t,e,n,i,r=tinymce.util.Tools.resolve("tinymce.ThemeManager"),h=tinymce.util.Tools.resolve("tinymce.Env"),v=tinymce.util.Tools.resolve("tinymce.dom.DOMUtils"),c=tinymce.util.Tools.resolve("tinymce.util.Delay"),o=function(t){return t.reduce(function(t,e){return Array.isArray(e)?t.concat(o(e)):t.concat(e)},[])},s={flatten:o},a=function(t,e){for(var n=0;n<e.length;n++){var i=(0,e[n])(t);if(i)return i}return null},l=function(t,e){return{id:t,rect:e}},d=function(t){return{x:t.left,y:t.top,w:t.width,h:t.height}},f=function(t){return{left:t.x,top:t.y,width:t.w,height:t.h,right:t.x+t.w,bottom:t.y+t.h}},m=function(t){var e=v.DOM.getViewPort();return{x:t.x+e.x,y:t.y+e.y,w:t.w,h:t.h}},g=function(t){var e=t.getBoundingClientRect();return m({x:e.left,y:e.top,w:Math.max(t.clientWidth,t.offsetWidth),h:Math.max(t.clientHeight,t.offsetHeight)})},p=function(t,e){return g(e)},b=function(t){return g(t.getContentAreaContainer()||t.getBody())},y=function(t){var e=t.selection.getBoundingClientRect();return e?m(d(e)):null},x=function(n,i){return function(t){for(var e=0;e<i.length;e++)if(i[e].predicate(n))return l(i[e].id,p(t,n));return null}},w=function(i,r){return function(t){for(var e=0;e<i.length;e++)for(var n=0;n<r.length;n++)if(r[n].predicate(i[e]))return l(r[n].id,p(t,i[e]));return null}},R=tinymce.util.Tools.resolve("tinymce.util.Tools"),C=function(t,e){return{id:t,predicate:e}},k=function(t){return R.map(t,function(t){return C(t.id,t.predicate)})},E=function(e){return function(t){return t.selection.isCollapsed()?null:l(e,y(t))}},H=function(i,r){return function(t){var e,n=t.schema.getTextBlockElements();for(e=0;e<i.length;e++)if("TABLE"===i[e].nodeName)return null;for(e=0;e<i.length;e++)if(i[e].nodeName in n)return t.dom.isEmpty(i[e])?l(r,y(t)):null;return null}},T=function(t){t.fire("SkinLoaded")},S=function(t){return t.fire("BeforeRenderUI")},M=tinymce.util.Tools.resolve("tinymce.EditorManager"),N=function(e){return function(t){return typeof t===e}},O=function(t){return Array.isArray(t)},W=function(t){return N("string")(t)},P=function(t){return N("number")(t)},D=function(t){return N("boolean")(t)},A=function(t){return N("function")(t)},B=(N("object"),O),L=function(t,e){if(e(t))return!0;throw new Error("Default value doesn't match requested type.")},I=function(r){return function(t,e,n){var i=t.settings;return L(n,r),e in i&&r(i[e])?i[e]:n}},z={getStringOr:I(W),getBoolOr:I(D),getNumberOr:I(P),getHandlerOr:I(A),getToolbarItemsOr:(u=B,function(t,e,n){var i,r,o,s,a,l=e in t.settings?t.settings[e]:n;return L(n,u),r=n,B(i=l)?i:W(i)?"string"==typeof(s=i)?(a=/[ ,]/,s.split(a).filter(function(t){return 0<t.length})):s:D(i)?(o=r,!1===i?[]:o):r})},F=tinymce.util.Tools.resolve("tinymce.geom.Rect"),U=function(t,e){return{rect:t,position:e}},V=function(t,e){return{x:e.x,y:e.y,w:t.w,h:t.h}},q=function(t,e,n,i,r){var o,s,a,l={x:i.x,y:i.y,w:i.w+(i.w<r.w+n.w?r.w:0),h:i.h+(i.h<r.h+n.h?r.h:0)};return o=F.findBestRelativePosition(r,n,l,t),n=F.clamp(n,l),o?(s=F.relativePosition(r,n,o),a=V(r,s),U(a,o)):(n=F.intersect(l,n))?((o=F.findBestRelativePosition(r,n,l,e))?(s=F.relativePosition(r,n,o),a=V(r,s)):a=V(r,n),U(a,o)):null},Y=function(t,e,n){return q(["cr-cl","cl-cr"],["bc-tc","bl-tl","br-tr"],t,e,n)},$=function(t,e,n){return q(["tc-bc","bc-tc","tl-bl","bl-tl","tr-br","br-tr","cr-cl","cl-cr"],["bc-tc","bl-tl","br-tr","cr-cl"],t,e,n)},X=function(t,e,n,i){var r;return"function"==typeof t?(r=t({elementRect:f(e),contentAreaRect:f(n),panelRect:f(i)}),d(r)):i},j=function(t){return t.panelRect},J=function(t){return z.getToolbarItemsOr(t,"selection_toolbar",["bold","italic","|","quicklink","h2","h3","blockquote"])},G=function(t){return z.getToolbarItemsOr(t,"insert_toolbar",["quickimage","quicktable"])},K=function(t){return z.getHandlerOr(t,"inline_toolbar_position_handler",j)},Z=function(t){var e,n,i,r,o=t.settings;return o.skin_url?(i=t,r=o.skin_url,i.documentBaseURI.toAbsolute(r)):(e=o.skin,n=M.baseURL+"/skins/",e?n+e:n+"lightgray")},Q=function(t){return!1===t.settings.skin},tt=function(i,r){var t=Z(i),e=function(){var t,e,n;e=r,n=function(){t._skinLoaded=!0,T(t),e()},(t=i).initialized?n():t.on("init",n)};Q(i)?e():(v.DOM.styleSheetLoader.load(t+"/skin.min.css",e),i.contentCSS.push(t+"/content.inline.min.css"))},et=function(t){var e,n,i,r,o=t.contextToolbars;return s.flatten([o||[],(e=t,n="img",i="image",r="alignleft aligncenter alignright",{predicate:function(t){return e.dom.is(t,n)},id:i,items:r})])},nt=function(t,e){var n,i,r,o,s;return s=(o=t).selection.getNode(),i=o.dom.getParents(s,"*"),r=k(e),(n=a(t,[x(i[0],r),E("text"),H(i,"insert"),w(i,r)]))&&n.rect?n:null},it=function(i,r){return function(){var t,e,n;i.removed||(n=i,_.document.activeElement!==n.getBody())||(t=et(i),(e=nt(i,t))?r.show(i,e.id,e.rect,t):r.hide())}},rt=function(t,e){var n,i,r,o,s,a=c.throttle(it(t,e),0),l=c.throttle((r=it(n=t,i=e),function(){n.removed||i.inForm()||r()}),0),u=(o=t,s=e,function(){var t=et(o),e=nt(o,t);e&&s.reposition(o,e.id,e.rect)});t.on("blur hide ObjectResizeStart",e.hide),t.on("click",a),t.on("nodeChange mouseup",l),t.on("ResizeEditor keyup",a),t.on("ResizeWindow",u),v.DOM.bind(h.container,"scroll",u),t.on("remove",function(){v.DOM.unbind(h.container,"scroll",u),e.remove()}),t.shortcuts.add("Alt+F10,F10","",e.focus)},ot=function(t,e){return tt(t,function(){var n,i;rt(t,e),i=e,(n=t).shortcuts.remove("meta+k"),n.shortcuts.add("meta+k","",function(){var t=et(n),e=a(n,[E("quicklink")]);e&&i.show(n,e.id,e.rect,t)})}),{}},st=function(t,e){return t.inline?ot(t,e):function(t){throw new Error(t)}("inlite theme only supports inline mode.")},at=function(){},lt=function(t){return function(){return t}},ut=lt(!1),ct=lt(!0),dt=function(){return ft},ft=(t=function(t){return t.isNone()},i={fold:function(t,e){return t()},is:ut,isSome:ut,isNone:ct,getOr:n=function(t){return t},getOrThunk:e=function(t){return t()},getOrDie:function(t){throw new Error(t||"error: getOrDie called on none.")},getOrNull:lt(null),getOrUndefined:lt(undefined),or:n,orThunk:e,map:dt,each:at,bind:dt,exists:ut,forall:ct,filter:dt,equals:t,equals_:t,toArray:function(){return[]},toString:lt("none()")},Object.freeze&&Object.freeze(i),i),ht=function(n){var t=lt(n),e=function(){return r},i=function(t){return t(n)},r={fold:function(t,e){return e(n)},is:function(t){return n===t},isSome:ct,isNone:ut,getOr:t,getOrThunk:t,getOrDie:t,getOrNull:t,getOrUndefined:t,or:e,orThunk:e,map:function(t){return ht(t(n))},each:function(t){t(n)},bind:i,exists:i,forall:i,filter:function(t){return t(n)?r:ft},toArray:function(){return[n]},toString:function(){return"some("+n+")"},equals:function(t){return t.is(n)},equals_:function(t,e){return t.fold(ut,function(t){return e(n,t)})}};return r},mt={some:ht,none:dt,from:function(t){return null===t||t===undefined?ft:ht(t)}},gt=function(e){return function(t){return function(t){if(null===t)return"null";var e=typeof t;return"object"===e&&(Array.prototype.isPrototypeOf(t)||t.constructor&&"Array"===t.constructor.name)?"array":"object"===e&&(String.prototype.isPrototypeOf(t)||t.constructor&&"String"===t.constructor.name)?"string":e}(t)===e}},pt=gt("array"),vt=gt("function"),bt=gt("number"),yt=(Array.prototype.slice,Array.prototype.indexOf),xt=Array.prototype.push,wt=function(t,e){var n,i,r=(n=t,i=e,yt.call(n,i));return-1===r?mt.none():mt.some(r)},_t=function(t,e){for(var n=0,i=t.length;n<i;n++)if(e(t[n],n))return!0;return!1},Rt=function(t,e){for(var n=t.length,i=new Array(n),r=0;r<n;r++){var o=t[r];i[r]=e(o,r)}return i},Ct=function(t,e){for(var n=0,i=t.length;n<i;n++)e(t[n],n)},kt=function(t,e){for(var n=[],i=0,r=t.length;i<r;i++){var o=t[i];e(o,i)&&n.push(o)}return n},Et=(vt(Array.from)&&Array.from,0),Ht={id:function(){return"mceu_"+Et++},create:function(t,e,n){var i=_.document.createElement(t);return v.DOM.setAttribs(i,e),"string"==typeof n?i.innerHTML=n:R.each(n,function(t){t.nodeType&&i.appendChild(t)}),i},createFragment:function(t){return v.DOM.createFragment(t)},getWindowSize:function(){return v.DOM.getViewPort()},getSize:function(t){var e,n;if(t.getBoundingClientRect){var i=t.getBoundingClientRect();e=Math.max(i.width||i.right-i.left,t.offsetWidth),n=Math.max(i.height||i.bottom-i.bottom,t.offsetHeight)}else e=t.offsetWidth,n=t.offsetHeight;return{width:e,height:n}},getPos:function(t,e){return v.DOM.getPos(t,e||Ht.getContainer())},getContainer:function(){return h.container?h.container:_.document.body},getViewPort:function(t){return v.DOM.getViewPort(t)},get:function(t){return _.document.getElementById(t)},addClass:function(t,e){return v.DOM.addClass(t,e)},removeClass:function(t,e){return v.DOM.removeClass(t,e)},hasClass:function(t,e){return v.DOM.hasClass(t,e)},toggleClass:function(t,e,n){return v.DOM.toggleClass(t,e,n)},css:function(t,e,n){return v.DOM.setStyle(t,e,n)},getRuntimeStyle:function(t,e){return v.DOM.getStyle(t,e,!0)},on:function(t,e,n,i){return v.DOM.bind(t,e,n,i)},off:function(t,e,n){return v.DOM.unbind(t,e,n)},fire:function(t,e,n){return v.DOM.fire(t,e,n)},innerHtml:function(t,e){v.DOM.setHTML(t,e)}},Tt=tinymce.util.Tools.resolve("tinymce.dom.DomQuery"),St=tinymce.util.Tools.resolve("tinymce.util.Class"),Mt=tinymce.util.Tools.resolve("tinymce.util.EventDispatcher"),Nt=function(t){var e;if(t)return"number"==typeof t?{top:t=t||0,left:t,bottom:t,right:t}:(1===(e=(t=t.split(" ")).length)?t[1]=t[2]=t[3]=t[0]:2===e?(t[2]=t[0],t[3]=t[1]):3===e&&(t[3]=t[1]),{top:parseInt(t[0],10)||0,right:parseInt(t[1],10)||0,bottom:parseInt(t[2],10)||0,left:parseInt(t[3],10)||0})},Ot=function(i,t){function e(t){var e=parseFloat(function(t){var e=i.ownerDocument.defaultView;if(e){var n=e.getComputedStyle(i,null);return n?(t=t.replace(/[A-Z]/g,function(t){return"-"+t}),n.getPropertyValue(t)):null}return i.currentStyle[t]}(t));return isNaN(e)?0:e}return{top:e(t+"TopWidth"),right:e(t+"RightWidth"),bottom:e(t+"BottomWidth"),left:e(t+"LeftWidth")}};function Wt(){}function Pt(t){this.cls=[],this.cls._map={},this.onchange=t||Wt,this.prefix=""}R.extend(Pt.prototype,{add:function(t){return t&&!this.contains(t)&&(this.cls._map[t]=!0,this.cls.push(t),this._change()),this},remove:function(t){if(this.contains(t)){var e=void 0;for(e=0;e<this.cls.length&&this.cls[e]!==t;e++);this.cls.splice(e,1),delete this.cls._map[t],this._change()}return this},toggle:function(t,e){var n=this.contains(t);return n!==e&&(n?this.remove(t):this.add(t),this._change()),this},contains:function(t){return!!this.cls._map[t]},_change:function(){delete this.clsValue,this.onchange.call(this)}}),Pt.prototype.toString=function(){var t;if(this.clsValue)return this.clsValue;t="";for(var e=0;e<this.cls.length;e++)0<e&&(t+=" "),t+=this.prefix+this.cls[e];return t};var Dt,At,Bt,Lt=/^([\w\\*]+)?(?:#([\w\-\\]+))?(?:\.([\w\\\.]+))?(?:\[\@?([\w\\]+)([\^\$\*!~]?=)([\w\\]+)\])?(?:\:(.+))?/i,It=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,zt=/^\s*|\s*$/g,Ft=St.extend({init:function(t){var o=this.match;function s(t,e,n){var i;function r(t){t&&e.push(t)}return r(function(e){if(e)return e=e.toLowerCase(),function(t){return"*"===e||t.type===e}}((i=Lt.exec(t.replace(zt,"")))[1])),r(function(e){if(e)return function(t){return t._name===e}}(i[2])),r(function(n){if(n)return n=n.split("."),function(t){for(var e=n.length;e--;)if(!t.classes.contains(n[e]))return!1;return!0}}(i[3])),r(function(n,i,r){if(n)return function(t){var e=t[n]?t[n]():"";return i?"="===i?e===r:"*="===i?0<=e.indexOf(r):"~="===i?0<=(" "+e+" ").indexOf(" "+r+" "):"!="===i?e!==r:"^="===i?0===e.indexOf(r):"$="===i&&e.substr(e.length-r.length)===r:!!r}}(i[4],i[5],i[6])),r(function(i){var e;if(i)return(i=/(?:not\((.+)\))|(.+)/i.exec(i))[1]?(e=a(i[1],[]),function(t){return!o(t,e)}):(i=i[2],function(t,e,n){return"first"===i?0===e:"last"===i?e===n-1:"even"===i?e%2==0:"odd"===i?e%2==1:!!t[i]&&t[i]()})}(i[7])),e.pseudo=!!i[7],e.direct=n,e}function a(t,e){var n,i,r,o=[];do{if(It.exec(""),(i=It.exec(t))&&(t=i[3],o.push(i[1]),i[2])){n=i[3];break}}while(i);for(n&&a(n,e),t=[],r=0;r<o.length;r++)">"!==o[r]&&t.push(s(o[r],[],">"===o[r-1]));return e.push(t),e}this._selectors=a(t,[])},match:function(t,e){var n,i,r,o,s,a,l,u,c,d,f,h,m;for(n=0,i=(e=e||this._selectors).length;n<i;n++){for(m=t,h=0,r=(o=(s=e[n]).length)-1;0<=r;r--)for(u=s[r];m;){if(u.pseudo)for(c=d=(f=m.parent().items()).length;c--&&f[c]!==m;);for(a=0,l=u.length;a<l;a++)if(!u[a](m,c,d)){a=l+1;break}if(a===l){h++;break}if(r===o-1)break;m=m.parent()}if(h===o)return!0}return!1},find:function(t){var e,n,u=[],i=this._selectors;function c(t,e,n){var i,r,o,s,a,l=e[n];for(i=0,r=t.length;i<r;i++){for(a=t[i],o=0,s=l.length;o<s;o++)if(!l[o](a,i,r)){o=s+1;break}if(o===s)n===e.length-1?u.push(a):a.items&&c(a.items(),e,n+1);else if(l.direct)return;a.items&&c(a.items(),e,n)}}if(t.items){for(e=0,n=i.length;e<n;e++)c(t.items(),i[e],0);1<n&&(u=function(t){for(var e,n=[],i=t.length;i--;)(e=t[i]).__checked||(n.push(e),e.__checked=1);for(i=n.length;i--;)delete n[i].__checked;return n}(u))}return Dt||(Dt=Ft.Collection),new Dt(u)}}),Ut=Array.prototype.push,Vt=Array.prototype.slice;Bt={length:0,init:function(t){t&&this.add(t)},add:function(t){return R.isArray(t)?Ut.apply(this,t):t instanceof At?this.add(t.toArray()):Ut.call(this,t),this},set:function(t){var e,n=this,i=n.length;for(n.length=0,n.add(t),e=n.length;e<i;e++)delete n[e];return n},filter:function(e){var t,n,i,r,o=[];for("string"==typeof e?(e=new Ft(e),r=function(t){return e.match(t)}):r=e,t=0,n=this.length;t<n;t++)r(i=this[t])&&o.push(i);return new At(o)},slice:function(){return new At(Vt.apply(this,arguments))},eq:function(t){return-1===t?this.slice(t):this.slice(t,+t+1)},each:function(t){return R.each(this,t),this},toArray:function(){return R.toArray(this)},indexOf:function(t){for(var e=this.length;e--&&this[e]!==t;);return e},reverse:function(){return new At(R.toArray(this).reverse())},hasClass:function(t){return!!this[0]&&this[0].classes.contains(t)},prop:function(e,n){var t;return n!==undefined?(this.each(function(t){t[e]&&t[e](n)}),this):(t=this[0])&&t[e]?t[e]():void 0},exec:function(e){var n=R.toArray(arguments).slice(1);return this.each(function(t){t[e]&&t[e].apply(t,n)}),this},remove:function(){for(var t=this.length;t--;)this[t].remove();return this},addClass:function(e){return this.each(function(t){t.classes.add(e)})},removeClass:function(e){return this.each(function(t){t.classes.remove(e)})}},R.each("fire on off show hide append prepend before after reflow".split(" "),function(n){Bt[n]=function(){var e=R.toArray(arguments);return this.each(function(t){n in t&&t[n].apply(t,e)}),this}}),R.each("text name disabled active selected checked visible parent value data".split(" "),function(e){Bt[e]=function(t){return this.prop(e,t)}}),At=St.extend(Bt);var qt=Ft.Collection=At,Yt=function(t){this.create=t.create};Yt.create=function(r,o){return new Yt({create:function(e,n){var i,t=function(t){e.set(n,t.value)};return e.on("change:"+n,function(t){r.set(o,t.value)}),r.on("change:"+o,t),(i=e._bindings)||(i=e._bindings=[],e.on("destroy",function(){for(var t=i.length;t--;)i[t]()})),i.push(function(){r.off("change:"+o,t)}),r.get(o)}})};var $t=tinymce.util.Tools.resolve("tinymce.util.Observable");function Xt(t){return 0<t.nodeType}var jt,Jt,Gt=St.extend({Mixins:[$t],init:function(t){var e,n;for(e in t=t||{})(n=t[e])instanceof Yt&&(t[e]=n.create(this,e));this.data=t},set:function(e,n){var i,r,o=this.data[e];if(n instanceof Yt&&(n=n.create(this,e)),"object"==typeof e){for(i in e)this.set(i,e[i]);return this}return function t(e,n){var i,r;if(e===n)return!0;if(null===e||null===n)return e===n;if("object"!=typeof e||"object"!=typeof n)return e===n;if(R.isArray(n)){if(e.length!==n.length)return!1;for(i=e.length;i--;)if(!t(e[i],n[i]))return!1}if(Xt(e)||Xt(n))return e===n;for(i in r={},n){if(!t(e[i],n[i]))return!1;r[i]=!0}for(i in e)if(!r[i]&&!t(e[i],n[i]))return!1;return!0}(o,n)||(this.data[e]=n,r={target:this,name:e,value:n,oldValue:o},this.fire("change:"+e,r),this.fire("change",r)),this},get:function(t){return this.data[t]},has:function(t){return t in this.data},bind:function(t){return Yt.create(this,t)},destroy:function(){this.fire("destroy")}}),Kt={},Zt={add:function(t){var e=t.parent();if(e){if(!e._layout||e._layout.isNative())return;Kt[e._id]||(Kt[e._id]=e),jt||(jt=!0,c.requestAnimationFrame(function(){var t,e;for(t in jt=!1,Kt)(e=Kt[t]).state.get("rendered")&&e.reflow();Kt={}},_.document.body))}},remove:function(t){Kt[t._id]&&delete Kt[t._id]}},Qt=function(t){return t?t.getRoot().uiContainer:null},te={getUiContainerDelta:function(t){var e=Qt(t);if(e&&"static"!==v.DOM.getStyle(e,"position",!0)){var n=v.DOM.getPos(e),i=e.scrollLeft-n.x,r=e.scrollTop-n.y;return mt.some({x:i,y:r})}return mt.none()},setUiContainer:function(t,e){var n=v.DOM.select(t.settings.ui_container)[0];e.getRoot().uiContainer=n},getUiContainer:Qt,inheritUiContainer:function(t,e){return e.uiContainer=Qt(t)}},ee="onmousewheel"in _.document,ne=!1,ie=0,re={Statics:{classPrefix:"mce-"},isRtl:function(){return Jt.rtl},classPrefix:"mce-",init:function(e){var t,n,i=this;function r(t){var e;for(t=t.split(" "),e=0;e<t.length;e++)i.classes.add(t[e])}i.settings=e=R.extend({},i.Defaults,e),i._id=e.id||"mceu_"+ie++,i._aria={role:e.role},i._elmCache={},i.$=Tt,i.state=new Gt({visible:!0,active:!1,disabled:!1,value:""}),i.data=new Gt(e.data),i.classes=new Pt(function(){i.state.get("rendered")&&(i.getEl().className=this.toString())}),i.classes.prefix=i.classPrefix,(t=e.classes)&&(i.Defaults&&(n=i.Defaults.classes)&&t!==n&&r(n),r(t)),R.each("title text name visible disabled active value".split(" "),function(t){t in e&&i[t](e[t])}),i.on("click",function(){if(i.disabled())return!1}),i.settings=e,i.borderBox=Nt(e.border),i.paddingBox=Nt(e.padding),i.marginBox=Nt(e.margin),e.hidden&&i.hide()},Properties:"parent,name",getContainerElm:function(){var t=te.getUiContainer(this);return t||Ht.getContainer()},getParentCtrl:function(t){for(var e,n=this.getRoot().controlIdLookup;t&&n&&!(e=n[t.id]);)t=t.parentNode;return e},initLayoutRect:function(){var t,e,n,i,r,o,s,a,l,u,c=this,d=c.settings,f=c.getEl();t=c.borderBox=c.borderBox||Ot(f,"border"),c.paddingBox=c.paddingBox||Ot(f,"padding"),c.marginBox=c.marginBox||Ot(f,"margin"),u=Ht.getSize(f),a=d.minWidth,l=d.minHeight,r=a||u.width,o=l||u.height,n=d.width,i=d.height,s=void 0!==(s=d.autoResize)?s:!n&&!i,n=n||r,i=i||o;var h=t.left+t.right,m=t.top+t.bottom,g=d.maxWidth||65535,p=d.maxHeight||65535;return c._layoutRect=e={x:d.x||0,y:d.y||0,w:n,h:i,deltaW:h,deltaH:m,contentW:n-h,contentH:i-m,innerW:n-h,innerH:i-m,startMinWidth:a||0,startMinHeight:l||0,minW:Math.min(r,g),minH:Math.min(o,p),maxW:g,maxH:p,autoResize:s,scrollW:0},c._lastLayoutRect={},e},layoutRect:function(t){var e,n,i,r,o,s=this,a=s._layoutRect;return a||(a=s.initLayoutRect()),t?(i=a.deltaW,r=a.deltaH,t.x!==undefined&&(a.x=t.x),t.y!==undefined&&(a.y=t.y),t.minW!==undefined&&(a.minW=t.minW),t.minH!==undefined&&(a.minH=t.minH),(n=t.w)!==undefined&&(n=(n=n<a.minW?a.minW:n)>a.maxW?a.maxW:n,a.w=n,a.innerW=n-i),(n=t.h)!==undefined&&(n=(n=n<a.minH?a.minH:n)>a.maxH?a.maxH:n,a.h=n,a.innerH=n-r),(n=t.innerW)!==undefined&&(n=(n=n<a.minW-i?a.minW-i:n)>a.maxW-i?a.maxW-i:n,a.innerW=n,a.w=n+i),(n=t.innerH)!==undefined&&(n=(n=n<a.minH-r?a.minH-r:n)>a.maxH-r?a.maxH-r:n,a.innerH=n,a.h=n+r),t.contentW!==undefined&&(a.contentW=t.contentW),t.contentH!==undefined&&(a.contentH=t.contentH),(e=s._lastLayoutRect).x===a.x&&e.y===a.y&&e.w===a.w&&e.h===a.h||((o=Jt.repaintControls)&&o.map&&!o.map[s._id]&&(o.push(s),o.map[s._id]=!0),e.x=a.x,e.y=a.y,e.w=a.w,e.h=a.h),s):a},repaint:function(){var t,e,n,i,r,o,s,a,l,u,c=this;l=_.document.createRange?function(t){return t}:Math.round,t=c.getEl().style,i=c._layoutRect,a=c._lastRepaintRect||{},o=(r=c.borderBox).left+r.right,s=r.top+r.bottom,i.x!==a.x&&(t.left=l(i.x)+"px",a.x=i.x),i.y!==a.y&&(t.top=l(i.y)+"px",a.y=i.y),i.w!==a.w&&(u=l(i.w-o),t.width=(0<=u?u:0)+"px",a.w=i.w),i.h!==a.h&&(u=l(i.h-s),t.height=(0<=u?u:0)+"px",a.h=i.h),c._hasBody&&i.innerW!==a.innerW&&(u=l(i.innerW),(n=c.getEl("body"))&&((e=n.style).width=(0<=u?u:0)+"px"),a.innerW=i.innerW),c._hasBody&&i.innerH!==a.innerH&&(u=l(i.innerH),(n=n||c.getEl("body"))&&((e=e||n.style).height=(0<=u?u:0)+"px"),a.innerH=i.innerH),c._lastRepaintRect=a,c.fire("repaint",{},!1)},updateLayoutRect:function(){var t=this;t.parent()._lastRect=null,Ht.css(t.getEl(),{width:"",height:""}),t._layoutRect=t._lastRepaintRect=t._lastLayoutRect=null,t.initLayoutRect()},on:function(t,e){var n,i,r,o=this;return oe(o).on(t,"string"!=typeof(n=e)?n:function(t){return i||o.parentsAndSelf().each(function(t){var e=t.settings.callbacks;if(e&&(i=e[n]))return r=t,!1}),i?i.call(r,t):(t.action=n,void this.fire("execute",t))}),o},off:function(t,e){return oe(this).off(t,e),this},fire:function(t,e,n){if((e=e||{}).control||(e.control=this),e=oe(this).fire(t,e),!1!==n&&this.parent)for(var i=this.parent();i&&!e.isPropagationStopped();)i.fire(t,e,!1),i=i.parent();return e},hasEventListeners:function(t){return oe(this).has(t)},parents:function(t){var e,n=new qt;for(e=this.parent();e;e=e.parent())n.add(e);return t&&(n=n.filter(t)),n},parentsAndSelf:function(t){return new qt(this).add(this.parents(t))},next:function(){var t=this.parent().items();return t[t.indexOf(this)+1]},prev:function(){var t=this.parent().items();return t[t.indexOf(this)-1]},innerHtml:function(t){return this.$el.html(t),this},getEl:function(t){var e=t?this._id+"-"+t:this._id;return this._elmCache[e]||(this._elmCache[e]=Tt("#"+e)[0]),this._elmCache[e]},show:function(){return this.visible(!0)},hide:function(){return this.visible(!1)},focus:function(){try{this.getEl().focus()}catch(t){}return this},blur:function(){return this.getEl().blur(),this},aria:function(t,e){var n=this,i=n.getEl(n.ariaTarget);return void 0===e?n._aria[t]:(n._aria[t]=e,n.state.get("rendered")&&i.setAttribute("role"===t?t:"aria-"+t,e),n)},encode:function(t,e){return!1!==e&&(t=this.translate(t)),(t||"").replace(/[&<>"]/g,function(t){return"&#"+t.charCodeAt(0)+";"})},translate:function(t){return Jt.translate?Jt.translate(t):t},before:function(t){var e=this.parent();return e&&e.insert(t,e.items().indexOf(this),!0),this},after:function(t){var e=this.parent();return e&&e.insert(t,e.items().indexOf(this)),this},remove:function(){var e,t,n=this,i=n.getEl(),r=n.parent();if(n.items){var o=n.items().toArray();for(t=o.length;t--;)o[t].remove()}r&&r.items&&(e=[],r.items().each(function(t){t!==n&&e.push(t)}),r.items().set(e),r._lastRect=null),n._eventsRoot&&n._eventsRoot===n&&Tt(i).off();var s=n.getRoot().controlIdLookup;return s&&delete s[n._id],i&&i.parentNode&&i.parentNode.removeChild(i),n.state.set("rendered",!1),n.state.destroy(),n.fire("remove"),n},renderBefore:function(t){return Tt(t).before(this.renderHtml()),this.postRender(),this},renderTo:function(t){return Tt(t||this.getContainerElm()).append(this.renderHtml()),this.postRender(),this},preRender:function(){},render:function(){},renderHtml:function(){return'<div id="'+this._id+'" class="'+this.classes+'"></div>'},postRender:function(){var t,e,n,i,r,o=this,s=o.settings;for(i in o.$el=Tt(o.getEl()),o.state.set("rendered",!0),s)0===i.indexOf("on")&&o.on(i.substr(2),s[i]);if(o._eventsRoot){for(n=o.parent();!r&&n;n=n.parent())r=n._eventsRoot;if(r)for(i in r._nativeEvents)o._nativeEvents[i]=!0}se(o),s.style&&(t=o.getEl())&&(t.setAttribute("style",s.style),t.style.cssText=s.style),o.settings.border&&(e=o.borderBox,o.$el.css({"border-top-width":e.top,"border-right-width":e.right,"border-bottom-width":e.bottom,"border-left-width":e.left}));var a=o.getRoot();for(var l in a.controlIdLookup||(a.controlIdLookup={}),(a.controlIdLookup[o._id]=o)._aria)o.aria(l,o._aria[l]);!1===o.state.get("visible")&&(o.getEl().style.display="none"),o.bindStates(),o.state.on("change:visible",function(t){var e,n=t.value;o.state.get("rendered")&&(o.getEl().style.display=!1===n?"none":"",o.getEl().getBoundingClientRect()),(e=o.parent())&&(e._lastRect=null),o.fire(n?"show":"hide"),Zt.add(o)}),o.fire("postrender",{},!1)},bindStates:function(){},scrollIntoView:function(t){var e,n,i,r,o,s,a=this.getEl(),l=a.parentNode,u=function(t,e){var n,i,r=t;for(n=i=0;r&&r!==e&&r.nodeType;)n+=r.offsetLeft||0,i+=r.offsetTop||0,r=r.offsetParent;return{x:n,y:i}}(a,l);return e=u.x,n=u.y,i=a.offsetWidth,r=a.offsetHeight,o=l.clientWidth,s=l.clientHeight,"end"===t?(e-=o-i,n-=s-r):"center"===t&&(e-=o/2-i/2,n-=s/2-r/2),l.scrollLeft=e,l.scrollTop=n,this},getRoot:function(){for(var t,e=this,n=[];e;){if(e.rootControl){t=e.rootControl;break}n.push(e),e=(t=e).parent()}t||(t=this);for(var i=n.length;i--;)n[i].rootControl=t;return t},reflow:function(){Zt.remove(this);var t=this.parent();return t&&t._layout&&!t._layout.isNative()&&t.reflow(),this}};function oe(n){return n._eventDispatcher||(n._eventDispatcher=new Mt({scope:n,toggleEvent:function(t,e){e&&Mt.isNative(t)&&(n._nativeEvents||(n._nativeEvents={}),n._nativeEvents[t]=!0,n.state.get("rendered")&&se(n))}})),n._eventDispatcher}function se(a){var t,e,n,l,i,r;function o(t){var e=a.getParentCtrl(t.target);e&&e.fire(t.type,t)}function s(){var t=l._lastHoverCtrl;t&&(t.fire("mouseleave",{target:t.getEl()}),t.parents().each(function(t){t.fire("mouseleave",{target:t.getEl()})}),l._lastHoverCtrl=null)}function u(t){var e,n,i,r=a.getParentCtrl(t.target),o=l._lastHoverCtrl,s=0;if(r!==o){if((n=(l._lastHoverCtrl=r).parents().toArray().reverse()).push(r),o){for((i=o.parents().toArray().reverse()).push(o),s=0;s<i.length&&n[s]===i[s];s++);for(e=i.length-1;s<=e;e--)(o=i[e]).fire("mouseleave",{target:o.getEl()})}for(e=s;e<n.length;e++)(r=n[e]).fire("mouseenter",{target:r.getEl()})}}function c(t){t.preventDefault(),"mousewheel"===t.type?(t.deltaY=-.025*t.wheelDelta,t.wheelDeltaX&&(t.deltaX=-.025*t.wheelDeltaX)):(t.deltaX=0,t.deltaY=t.detail),t=a.fire("wheel",t)}if(i=a._nativeEvents){for((n=a.parents().toArray()).unshift(a),t=0,e=n.length;!l&&t<e;t++)l=n[t]._eventsRoot;for(l||(l=n[n.length-1]||a),a._eventsRoot=l,e=t,t=0;t<e;t++)n[t]._eventsRoot=l;var d=l._delegates;for(r in d||(d=l._delegates={}),i){if(!i)return!1;"wheel"!==r||ne?("mouseenter"===r||"mouseleave"===r?l._hasMouseEnter||(Tt(l.getEl()).on("mouseleave",s).on("mouseover",u),l._hasMouseEnter=1):d[r]||(Tt(l.getEl()).on(r,o),d[r]=!0),i[r]=!1):ee?Tt(a.getEl()).on("mousewheel",c):Tt(a.getEl()).on("DOMMouseScroll",c)}}}R.each("text title visible disabled active value".split(" "),function(e){re[e]=function(t){return 0===arguments.length?this.state.get(e):(void 0!==t&&this.state.set(e,t),this)}});var ae=Jt=St.extend(re),le=function(t){return"static"===Ht.getRuntimeStyle(t,"position")},ue=function(t){return t.state.get("fixed")};function ce(t,e,n){var i,r,o,s,a,l,u,c,d,f;return d=de(),o=(r=Ht.getPos(e,te.getUiContainer(t))).x,s=r.y,ue(t)&&le(_.document.body)&&(o-=d.x,s-=d.y),i=t.getEl(),a=(f=Ht.getSize(i)).width,l=f.height,u=(f=Ht.getSize(e)).width,c=f.height,"b"===(n=(n||"").split(""))[0]&&(s+=c),"r"===n[1]&&(o+=u),"c"===n[0]&&(s+=Math.round(c/2)),"c"===n[1]&&(o+=Math.round(u/2)),"b"===n[3]&&(s-=l),"r"===n[4]&&(o-=a),"c"===n[3]&&(s-=Math.round(l/2)),"c"===n[4]&&(o-=Math.round(a/2)),{x:o,y:s,w:a,h:l}}var de=function(){var t=_.window;return{x:Math.max(t.pageXOffset,_.document.body.scrollLeft,_.document.documentElement.scrollLeft),y:Math.max(t.pageYOffset,_.document.body.scrollTop,_.document.documentElement.scrollTop),w:t.innerWidth||_.document.documentElement.clientWidth,h:t.innerHeight||_.document.documentElement.clientHeight}},fe=function(t){var e,n=te.getUiContainer(t);return n&&!ue(t)?{x:0,y:0,w:(e=n).scrollWidth-1,h:e.scrollHeight-1}:de()},he={testMoveRel:function(t,e){for(var n=fe(this),i=0;i<e.length;i++){var r=ce(this,t,e[i]);if(ue(this)){if(0<r.x&&r.x+r.w<n.w&&0<r.y&&r.y+r.h<n.h)return e[i]}else if(r.x>n.x&&r.x+r.w<n.w+n.x&&r.y>n.y&&r.y+r.h<n.h+n.y)return e[i]}return e[0]},moveRel:function(t,e){"string"!=typeof e&&(e=this.testMoveRel(t,e));var n=ce(this,t,e);return this.moveTo(n.x,n.y)},moveBy:function(t,e){var n=this.layoutRect();return this.moveTo(n.x+t,n.y+e),this},moveTo:function(t,e){var n=this;function i(t,e,n){return t<0?0:e<t+n&&(t=e-n)<0?0:t}if(n.settings.constrainToViewport){var r=fe(this),o=n.layoutRect();t=i(t,r.w+r.x,o.w),e=i(e,r.h+r.y,o.h)}var s=te.getUiContainer(n);return s&&le(s)&&!ue(n)&&(t-=s.scrollLeft,e-=s.scrollTop),s&&(t+=1,e+=1),n.state.get("rendered")?n.layoutRect({x:t,y:e}).repaint():(n.settings.x=t,n.settings.y=e),n.fire("move",{x:t,y:e}),n}},me=ae.extend({Mixins:[he],Defaults:{classes:"widget tooltip tooltip-n"},renderHtml:function(){var t=this,e=t.classPrefix;return'<div id="'+t._id+'" class="'+t.classes+'" role="presentation"><div class="'+e+'tooltip-arrow"></div><div class="'+e+'tooltip-inner">'+t.encode(t.state.get("text"))+"</div></div>"},bindStates:function(){var e=this;return e.state.on("change:text",function(t){e.getEl().lastChild.innerHTML=e.encode(t.value)}),e._super()},repaint:function(){var t,e;t=this.getEl().style,e=this._layoutRect,t.left=e.x+"px",t.top=e.y+"px",t.zIndex=131070}}),ge=ae.extend({init:function(i){var r=this;r._super(i),i=r.settings,r.canFocus=!0,i.tooltip&&!1!==ge.tooltips&&(r.on("mouseenter",function(t){var e=r.tooltip().moveTo(-65535);if(t.control===r){var n=e.text(i.tooltip).show().testMoveRel(r.getEl(),["bc-tc","bc-tl","bc-tr"]);e.classes.toggle("tooltip-n","bc-tc"===n),e.classes.toggle("tooltip-nw","bc-tl"===n),e.classes.toggle("tooltip-ne","bc-tr"===n),e.moveRel(r.getEl(),n)}else e.hide()}),r.on("mouseleave mousedown click",function(){r.tooltip().remove(),r._tooltip=null})),r.aria("label",i.ariaLabel||i.tooltip)},tooltip:function(){return this._tooltip||(this._tooltip=new me({type:"tooltip"}),te.inheritUiContainer(this,this._tooltip),this._tooltip.renderTo()),this._tooltip},postRender:function(){var t=this,e=t.settings;t._super(),t.parent()||!e.width&&!e.height||(t.initLayoutRect(),t.repaint()),e.autofocus&&t.focus()},bindStates:function(){var e=this;function n(t){e.aria("disabled",t),e.classes.toggle("disabled",t)}function i(t){e.aria("pressed",t),e.classes.toggle("active",t)}return e.state.on("change:disabled",function(t){n(t.value)}),e.state.on("change:active",function(t){i(t.value)}),e.state.get("disabled")&&n(!0),e.state.get("active")&&i(!0),e._super()},remove:function(){this._super(),this._tooltip&&(this._tooltip.remove(),this._tooltip=null)}}),pe=ge.extend({Defaults:{value:0},init:function(t){this._super(t),this.classes.add("progress"),this.settings.filter||(this.settings.filter=function(t){return Math.round(t)})},renderHtml:function(){var t=this._id,e=this.classPrefix;return'<div id="'+t+'" class="'+this.classes+'"><div class="'+e+'bar-container"><div class="'+e+'bar"></div></div><div class="'+e+'text">0%</div></div>'},postRender:function(){return this._super(),this.value(this.settings.value),this},bindStates:function(){var e=this;function n(t){t=e.settings.filter(t),e.getEl().lastChild.innerHTML=t+"%",e.getEl().firstChild.firstChild.style.width=t+"%"}return e.state.on("change:value",function(t){n(t.value)}),n(e.state.get("value")),e._super()}}),ve=function(t,e){t.getEl().lastChild.textContent=e+(t.progressBar?" "+t.progressBar.value()+"%":"")},be=ae.extend({Mixins:[he],Defaults:{classes:"widget notification"},init:function(t){var e=this;e._super(t),e.maxWidth=t.maxWidth,t.text&&e.text(t.text),t.icon&&(e.icon=t.icon),t.color&&(e.color=t.color),t.type&&e.classes.add("notification-"+t.type),t.timeout&&(t.timeout<0||0<t.timeout)&&!t.closeButton?e.closeButton=!1:(e.classes.add("has-close"),e.closeButton=!0),t.progressBar&&(e.progressBar=new pe),e.on("click",function(t){-1!==t.target.className.indexOf(e.classPrefix+"close")&&e.close()})},renderHtml:function(){var t,e=this,n=e.classPrefix,i="",r="",o="";return e.icon&&(i='<i class="'+n+"ico "+n+"i-"+e.icon+'"></i>'),t=' style="max-width: '+e.maxWidth+"px;"+(e.color?"background-color: "+e.color+';"':'"'),e.closeButton&&(r='<button type="button" class="'+n+'close" aria-hidden="true">\xd7</button>'),e.progressBar&&(o=e.progressBar.renderHtml()),'<div id="'+e._id+'" class="'+e.classes+'"'+t+' role="presentation">'+i+'<div class="'+n+'notification-inner">'+e.state.get("text")+"</div>"+o+r+'<div style="clip: rect(1px, 1px, 1px, 1px);height: 1px;overflow: hidden;position: absolute;width: 1px;" aria-live="assertive" aria-relevant="additions" aria-atomic="true"></div></div>'},postRender:function(){var t=this;return c.setTimeout(function(){t.$el.addClass(t.classPrefix+"in"),ve(t,t.state.get("text"))},100),t._super()},bindStates:function(){var e=this;return e.state.on("change:text",function(t){e.getEl().firstChild.innerHTML=t.value,ve(e,t.value)}),e.progressBar&&(e.progressBar.bindStates(),e.progressBar.state.on("change:value",function(t){ve(e,e.state.get("text"))})),e._super()},close:function(){return this.fire("close").isDefaultPrevented()||this.remove(),this},repaint:function(){var t,e;t=this.getEl().style,e=this._layoutRect,t.left=e.x+"px",t.top=e.y+"px",t.zIndex=65534}});function ye(o){var s=function(t){return t.inline?t.getElement():t.getContentAreaContainer()};return{open:function(t,e){var n,i=R.extend(t,{maxWidth:(n=s(o),Ht.getSize(n).width)}),r=new be(i);return 0<(r.args=i).timeout&&(r.timer=setTimeout(function(){r.close(),e()},i.timeout)),r.on("close",function(){e()}),r.renderTo(),r},close:function(t){t.close()},reposition:function(t){Ct(t,function(t){t.moveTo(0,0)}),function(n){if(0<n.length){var t=n.slice(0,1)[0],e=s(o);t.moveRel(e,"tc-tc"),Ct(n,function(t,e){0<e&&t.moveRel(n[e-1].getEl(),"bc-tc")})}}(t)},getArgs:function(t){return t.args}}}function xe(t){var e,n;if(t.changedTouches)for(e="screenX screenY pageX pageY clientX clientY".split(" "),n=0;n<e.length;n++)t[e[n]]=t.changedTouches[0][e[n]]}function we(t,h){var m,g,e,p,v,b,y,x=h.document||_.document;h=h||{};var w=x.getElementById(h.handle||t);e=function(t){var e,n,i,r,o,s,a,l,u,c,d,f=(e=x,u=Math.max,n=e.documentElement,i=e.body,r=u(n.scrollWidth,i.scrollWidth),o=u(n.clientWidth,i.clientWidth),s=u(n.offsetWidth,i.offsetWidth),a=u(n.scrollHeight,i.scrollHeight),l=u(n.clientHeight,i.clientHeight),{width:r<s?o:r,height:a<u(n.offsetHeight,i.offsetHeight)?l:a});xe(t),t.preventDefault(),g=t.button,c=w,b=t.screenX,y=t.screenY,d=_.window.getComputedStyle?_.window.getComputedStyle(c,null).getPropertyValue("cursor"):c.runtimeStyle.cursor,m=Tt("<div></div>").css({position:"absolute",top:0,left:0,width:f.width,height:f.height,zIndex:2147483647,opacity:1e-4,cursor:d}).appendTo(x.body),Tt(x).on("mousemove touchmove",v).on("mouseup touchend",p),h.start(t)},v=function(t){if(xe(t),t.button!==g)return p(t);t.deltaX=t.screenX-b,t.deltaY=t.screenY-y,t.preventDefault(),h.drag(t)},p=function(t){xe(t),Tt(x).off("mousemove touchmove",v).off("mouseup touchend",p),m.remove(),h.stop&&h.stop(t)},this.destroy=function(){Tt(w).off()},Tt(w).on("mousedown touchstart",e)}var _e=tinymce.util.Tools.resolve("tinymce.ui.Factory"),Re=function(t){return!!t.getAttribute("data-mce-tabstop")};function Ce(t){var o,r,n=t.root;function i(t){return t&&1===t.nodeType}try{o=_.document.activeElement}catch(e){o=_.document.body}function s(t){return i(t=t||o)?t.getAttribute("role"):null}function a(t){for(var e,n=t||o;n=n.parentNode;)if(e=s(n))return e}function l(t){var e=o;if(i(e))return e.getAttribute("aria-"+t)}function u(t){var e=t.tagName.toUpperCase();return"INPUT"===e||"TEXTAREA"===e||"SELECT"===e}function c(e){var r=[];return function t(e){if(1===e.nodeType&&"none"!==e.style.display&&!e.disabled){var n;(u(n=e)&&!n.hidden||Re(n)||/^(button|menuitem|checkbox|tab|menuitemcheckbox|option|gridcell|slider)$/.test(s(n)))&&r.push(e);for(var i=0;i<e.childNodes.length;i++)t(e.childNodes[i])}}(e||n.getEl()),r}function d(t){var e,n;(n=(t=t||r).parents().toArray()).unshift(t);for(var i=0;i<n.length&&!(e=n[i]).settings.ariaRoot;i++);return e}function f(t,e){return t<0?t=e.length-1:t>=e.length&&(t=0),e[t]&&e[t].focus(),t}function h(t,e){var n=-1,i=d();e=e||c(i.getEl());for(var r=0;r<e.length;r++)e[r]===o&&(n=r);n+=t,i.lastAriaIndex=f(n,e)}function m(){"tablist"===a()?h(-1,c(o.parentNode)):r.parent().submenu?b():h(-1)}function g(){var t=s(),e=a();"tablist"===e?h(1,c(o.parentNode)):"menuitem"===t&&"menu"===e&&l("haspopup")?y():h(1)}function p(){h(-1)}function v(){var t=s(),e=a();"menuitem"===t&&"menubar"===e?y():"button"===t&&l("haspopup")?y({key:"down"}):h(1)}function b(){r.fire("cancel")}function y(t){t=t||{},r.fire("click",{target:o,aria:t})}return r=n.getParentCtrl(o),n.on("keydown",function(t){function e(t,e){u(o)||Re(o)||"slider"!==s(o)&&!1!==e(t)&&t.preventDefault()}if(!t.isDefaultPrevented())switch(t.keyCode){case 37:e(t,m);break;case 39:e(t,g);break;case 38:e(t,p);break;case 40:e(t,v);break;case 27:b();break;case 14:case 13:case 32:e(t,y);break;case 9:!function(t){if("tablist"===a()){var e=c(r.getEl("body"))[0];e&&e.focus()}else h(t.shiftKey?-1:1)}(t),t.preventDefault()}}),n.on("focusin",function(t){o=t.target,r=t.control}),{focusFirst:function(t){var e=d(t),n=c(e.getEl());e.settings.ariaRemember&&"lastAriaIndex"in e?f(e.lastAriaIndex,n):f(0,n)}}}var ke,Ee,He,Te,Se={},Me=ae.extend({init:function(t){var e=this;e._super(t),(t=e.settings).fixed&&e.state.set("fixed",!0),e._items=new qt,e.isRtl()&&e.classes.add("rtl"),e.bodyClasses=new Pt(function(){e.state.get("rendered")&&(e.getEl("body").className=this.toString())}),e.bodyClasses.prefix=e.classPrefix,e.classes.add("container"),e.bodyClasses.add("container-body"),t.containerCls&&e.classes.add(t.containerCls),e._layout=_e.create((t.layout||"")+"layout"),e.settings.items?e.add(e.settings.items):e.add(e.render()),e._hasBody=!0},items:function(){return this._items},find:function(t){return(t=Se[t]=Se[t]||new Ft(t)).find(this)},add:function(t){return this.items().add(this.create(t)).parent(this),this},focus:function(t){var e,n,i,r=this;if(!t||!(n=r.keyboardNav||r.parents().eq(-1)[0].keyboardNav))return i=r.find("*"),r.statusbar&&i.add(r.statusbar.items()),i.each(function(t){if(t.settings.autofocus)return e=null,!1;t.canFocus&&(e=e||t)}),e&&e.focus(),r;n.focusFirst(r)},replace:function(t,e){for(var n,i=this.items(),r=i.length;r--;)if(i[r]===t){i[r]=e;break}0<=r&&((n=e.getEl())&&n.parentNode.removeChild(n),(n=t.getEl())&&n.parentNode.removeChild(n)),e.parent(this)},create:function(t){var e,n=this,i=[];return R.isArray(t)||(t=[t]),R.each(t,function(t){t&&(t instanceof ae||("string"==typeof t&&(t={type:t}),e=R.extend({},n.settings.defaults,t),t.type=e.type=e.type||t.type||n.settings.defaultType||(e.defaults?e.defaults.type:null),t=_e.create(e)),i.push(t))}),i},renderNew:function(){var i=this;return i.items().each(function(t,e){var n;t.parent(i),t.state.get("rendered")||((n=i.getEl("body")).hasChildNodes()&&e<=n.childNodes.length-1?Tt(n.childNodes[e]).before(t.renderHtml()):Tt(n).append(t.renderHtml()),t.postRender(),Zt.add(t))}),i._layout.applyClasses(i.items().filter(":visible")),i._lastRect=null,i},append:function(t){return this.add(t).renderNew()},prepend:function(t){return this.items().set(this.create(t).concat(this.items().toArray())),this.renderNew()},insert:function(t,e,n){var i,r,o;return t=this.create(t),i=this.items(),!n&&e<i.length-1&&(e+=1),0<=e&&e<i.length&&(r=i.slice(0,e).toArray(),o=i.slice(e).toArray(),i.set(r.concat(t,o))),this.renderNew()},fromJSON:function(t){for(var e in t)this.find("#"+e).value(t[e]);return this},toJSON:function(){var i={};return this.find("*").each(function(t){var e=t.name(),n=t.value();e&&void 0!==n&&(i[e]=n)}),i},renderHtml:function(){var t=this,e=t._layout,n=this.settings.role;return t.preRender(),e.preRender(t),'<div id="'+t._id+'" class="'+t.classes+'"'+(n?' role="'+this.settings.role+'"':"")+'><div id="'+t._id+'-body" class="'+t.bodyClasses+'">'+(t.settings.html||"")+e.renderHtml(t)+"</div></div>"},postRender:function(){var t,e=this;return e.items().exec("postRender"),e._super(),e._layout.postRender(e),e.state.set("rendered",!0),e.settings.style&&e.$el.css(e.settings.style),e.settings.border&&(t=e.borderBox,e.$el.css({"border-top-width":t.top,"border-right-width":t.right,"border-bottom-width":t.bottom,"border-left-width":t.left})),e.parent()||(e.keyboardNav=Ce({root:e})),e},initLayoutRect:function(){var t=this._super();return this._layout.recalc(this),t},recalc:function(){var t=this,e=t._layoutRect,n=t._lastRect;if(!n||n.w!==e.w||n.h!==e.h)return t._layout.recalc(t),e=t.layoutRect(),t._lastRect={x:e.x,y:e.y,w:e.w,h:e.h},!0},reflow:function(){var t;if(Zt.remove(this),this.visible()){for(ae.repaintControls=[],ae.repaintControls.map={},this.recalc(),t=ae.repaintControls.length;t--;)ae.repaintControls[t].repaint();"flow"!==this.settings.layout&&"stack"!==this.settings.layout&&this.repaint(),ae.repaintControls=[]}return this}}),Ne={init:function(){this.on("repaint",this.renderScroll)},renderScroll:function(){var p=this,v=2;function n(){var m,g,t;function e(t,e,n,i,r,o){var s,a,l,u,c,d,f,h;if(a=p.getEl("scroll"+t)){if(f=e.toLowerCase(),h=n.toLowerCase(),Tt(p.getEl("absend")).css(f,p.layoutRect()[i]-1),!r)return void Tt(a).css("display","none");Tt(a).css("display","block"),s=p.getEl("body"),l=p.getEl("scroll"+t+"t"),u=s["client"+n]-2*v,c=(u-=m&&g?a["client"+o]:0)/s["scroll"+n],(d={})[f]=s["offset"+e]+v,d[h]=u,Tt(a).css(d),(d={})[f]=s["scroll"+e]*c,d[h]=u*c,Tt(l).css(d)}}t=p.getEl("body"),m=t.scrollWidth>t.clientWidth,g=t.scrollHeight>t.clientHeight,e("h","Left","Width","contentW",m,"Height"),e("v","Top","Height","contentH",g,"Width")}p.settings.autoScroll&&(p._hasScroll||(p._hasScroll=!0,function(){function t(s,a,l,u,c){var d,t=p._id+"-scroll"+s,e=p.classPrefix;Tt(p.getEl()).append('<div id="'+t+'" class="'+e+"scrollbar "+e+"scrollbar-"+s+'"><div id="'+t+'t" class="'+e+'scrollbar-thumb"></div></div>'),p.draghelper=new we(t+"t",{start:function(){d=p.getEl("body")["scroll"+a],Tt("#"+t).addClass(e+"active")},drag:function(t){var e,n,i,r,o=p.layoutRect();n=o.contentW>o.innerW,i=o.contentH>o.innerH,r=p.getEl("body")["client"+l]-2*v,e=(r-=n&&i?p.getEl("scroll"+s)["client"+c]:0)/p.getEl("body")["scroll"+l],p.getEl("body")["scroll"+a]=d+t["delta"+u]/e},stop:function(){Tt("#"+t).removeClass(e+"active")}})}p.classes.add("scroll"),t("v","Top","Height","Y","Width"),t("h","Left","Width","X","Height")}(),p.on("wheel",function(t){var e=p.getEl("body");e.scrollLeft+=10*(t.deltaX||0),e.scrollTop+=10*t.deltaY,n()}),Tt(p.getEl("body")).on("scroll",n)),n())}},Oe=Me.extend({Defaults:{layout:"fit",containerCls:"panel"},Mixins:[Ne],renderHtml:function(){var t=this,e=t._layout,n=t.settings.html;return t.preRender(),e.preRender(t),void 0===n?n='<div id="'+t._id+'-body" class="'+t.bodyClasses+'">'+e.renderHtml(t)+"</div>":("function"==typeof n&&(n=n.call(t)),t._hasBody=!1),'<div id="'+t._id+'" class="'+t.classes+'" hidefocus="1" tabindex="-1" role="group">'+(t._preBodyHtml||"")+n+"</div>"}}),We={resizeToContent:function(){this._layoutRect.autoResize=!0,this._lastRect=null,this.reflow()},resizeTo:function(t,e){if(t<=1||e<=1){var n=Ht.getWindowSize();t=t<=1?t*n.w:t,e=e<=1?e*n.h:e}return this._layoutRect.autoResize=!1,this.layoutRect({minW:t,minH:e,w:t,h:e}).reflow()},resizeBy:function(t,e){var n=this.layoutRect();return this.resizeTo(n.w+t,n.h+e)}},Pe=[],De=[];function Ae(t,e){for(;t;){if(t===e)return!0;t=t.parent()}}function Be(){ke||(ke=function(t){2!==t.button&&function(t){for(var e=Pe.length;e--;){var n=Pe[e],i=n.getParentCtrl(t.target);if(n.settings.autohide){if(i&&(Ae(i,n)||n.parent()===i))continue;(t=n.fire("autohide",{target:t.target})).isDefaultPrevented()||n.hide()}}}(t)},Tt(_.document).on("click touchstart",ke))}function Le(r){var t=Ht.getViewPort().y;function e(t,e){for(var n,i=0;i<Pe.length;i++)if(Pe[i]!==r)for(n=Pe[i].parent();n&&(n=n.parent());)n===r&&Pe[i].fixed(t).moveBy(0,e).repaint()}r.settings.autofix&&(r.state.get("fixed")?r._autoFixY>t&&(r.fixed(!1).layoutRect({y:r._autoFixY}).repaint(),e(!1,r._autoFixY-t)):(r._autoFixY=r.layoutRect().y,r._autoFixY<t&&(r.fixed(!0).layoutRect({y:0}).repaint(),e(!0,t-r._autoFixY))))}function Ie(t,e){var n,i,r=ze.zIndex||65535;if(t)De.push(e);else for(n=De.length;n--;)De[n]===e&&De.splice(n,1);if(De.length)for(n=0;n<De.length;n++)De[n].modal&&(r++,i=De[n]),De[n].getEl().style.zIndex=r,De[n].zIndex=r,r++;var o=Tt("#"+e.classPrefix+"modal-block",e.getContainerElm())[0];i?Tt(o).css("z-index",i.zIndex-1):o&&(o.parentNode.removeChild(o),Te=!1),ze.currentZIndex=r}var ze=Oe.extend({Mixins:[he,We],init:function(t){var i=this;i._super(t),(i._eventsRoot=i).classes.add("floatpanel"),t.autohide&&(Be(),function(){if(!He){var t=_.document.documentElement,e=t.clientWidth,n=t.clientHeight;He=function(){_.document.all&&e===t.clientWidth&&n===t.clientHeight||(e=t.clientWidth,n=t.clientHeight,ze.hideAll())},Tt(_.window).on("resize",He)}}(),Pe.push(i)),t.autofix&&(Ee||(Ee=function(){var t;for(t=Pe.length;t--;)Le(Pe[t])},Tt(_.window).on("scroll",Ee)),i.on("move",function(){Le(this)})),i.on("postrender show",function(t){if(t.control===i){var e,n=i.classPrefix;i.modal&&!Te&&((e=Tt("#"+n+"modal-block",i.getContainerElm()))[0]||(e=Tt('<div id="'+n+'modal-block" class="'+n+"reset "+n+'fade"></div>').appendTo(i.getContainerElm())),c.setTimeout(function(){e.addClass(n+"in"),Tt(i.getEl()).addClass(n+"in")}),Te=!0),Ie(!0,i)}}),i.on("show",function(){i.parents().each(function(t){if(t.state.get("fixed"))return i.fixed(!0),!1})}),t.popover&&(i._preBodyHtml='<div class="'+i.classPrefix+'arrow"></div>',i.classes.add("popover").add("bottom").add(i.isRtl()?"end":"start")),i.aria("label",t.ariaLabel),i.aria("labelledby",i._id),i.aria("describedby",i.describedBy||i._id+"-none")},fixed:function(t){var e=this;if(e.state.get("fixed")!==t){if(e.state.get("rendered")){var n=Ht.getViewPort();t?e.layoutRect().y-=n.y:e.layoutRect().y+=n.y}e.classes.toggle("fixed",t),e.state.set("fixed",t)}return e},show:function(){var t,e=this._super();for(t=Pe.length;t--&&Pe[t]!==this;);return-1===t&&Pe.push(this),e},hide:function(){return Fe(this),Ie(!1,this),this._super()},hideAll:function(){ze.hideAll()},close:function(){return this.fire("close").isDefaultPrevented()||(this.remove(),Ie(!1,this)),this},remove:function(){Fe(this),this._super()},postRender:function(){return this.settings.bodyRole&&this.getEl("body").setAttribute("role",this.settings.bodyRole),this._super()}});function Fe(t){var e;for(e=Pe.length;e--;)Pe[e]===t&&Pe.splice(e,1);for(e=De.length;e--;)De[e]===t&&De.splice(e,1)}ze.hideAll=function(){for(var t=Pe.length;t--;){var e=Pe[t];e&&e.settings.autohide&&(e.hide(),Pe.splice(t,1))}};var Ue=[],Ve="";function qe(t){var e,n=Tt("meta[name=viewport]")[0];!1!==h.overrideViewPort&&(n||((n=_.document.createElement("meta")).setAttribute("name","viewport"),_.document.getElementsByTagName("head")[0].appendChild(n)),(e=n.getAttribute("content"))&&void 0!==Ve&&(Ve=e),n.setAttribute("content",t?"width=device-width,initial-scale=1.0,user-scalable=0,minimum-scale=1.0,maximum-scale=1.0":Ve))}function Ye(t,e){(function(){for(var t=0;t<Ue.length;t++)if(Ue[t]._fullscreen)return!0;return!1})()&&!1===e&&Tt([_.document.documentElement,_.document.body]).removeClass(t+"fullscreen")}var $e=ze.extend({modal:!0,Defaults:{border:1,layout:"flex",containerCls:"panel",role:"dialog",callbacks:{submit:function(){this.fire("submit",{data:this.toJSON()})},close:function(){this.close()}}},init:function(t){var n=this;n._super(t),n.isRtl()&&n.classes.add("rtl"),n.classes.add("window"),n.bodyClasses.add("window-body"),n.state.set("fixed",!0),t.buttons&&(n.statusbar=new Oe({layout:"flex",border:"1 0 0 0",spacing:3,padding:10,align:"center",pack:n.isRtl()?"start":"end",defaults:{type:"button"},items:t.buttons}),n.statusbar.classes.add("foot"),n.statusbar.parent(n)),n.on("click",function(t){var e=n.classPrefix+"close";(Ht.hasClass(t.target,e)||Ht.hasClass(t.target.parentNode,e))&&n.close()}),n.on("cancel",function(){n.close()}),n.on("move",function(t){t.control===n&&ze.hideAll()}),n.aria("describedby",n.describedBy||n._id+"-none"),n.aria("label",t.title),n._fullscreen=!1},recalc:function(){var t,e,n,i,r=this,o=r.statusbar;r._fullscreen&&(r.layoutRect(Ht.getWindowSize()),r.layoutRect().contentH=r.layoutRect().innerH),r._super(),t=r.layoutRect(),r.settings.title&&!r._fullscreen&&(e=t.headerW)>t.w&&(n=t.x-Math.max(0,e/2),r.layoutRect({w:e,x:n}),i=!0),o&&(o.layoutRect({w:r.layoutRect().innerW}).recalc(),(e=o.layoutRect().minW+t.deltaW)>t.w&&(n=t.x-Math.max(0,e-t.w),r.layoutRect({w:e,x:n}),i=!0)),i&&r.recalc()},initLayoutRect:function(){var t,e=this,n=e._super(),i=0;if(e.settings.title&&!e._fullscreen){t=e.getEl("head");var r=Ht.getSize(t);n.headerW=r.width,n.headerH=r.height,i+=n.headerH}e.statusbar&&(i+=e.statusbar.layoutRect().h),n.deltaH+=i,n.minH+=i,n.h+=i;var o=Ht.getWindowSize();return n.x=e.settings.x||Math.max(0,o.w/2-n.w/2),n.y=e.settings.y||Math.max(0,o.h/2-n.h/2),n},renderHtml:function(){var t=this,e=t._layout,n=t._id,i=t.classPrefix,r=t.settings,o="",s="",a=r.html;return t.preRender(),e.preRender(t),r.title&&(o='<div id="'+n+'-head" class="'+i+'window-head"><div id="'+n+'-title" class="'+i+'title">'+t.encode(r.title)+'</div><div id="'+n+'-dragh" class="'+i+'dragh"></div><button type="button" class="'+i+'close" aria-hidden="true"><i class="mce-ico mce-i-remove"></i></button></div>'),r.url&&(a='<iframe src="'+r.url+'" tabindex="-1"></iframe>'),void 0===a&&(a=e.renderHtml(t)),t.statusbar&&(s=t.statusbar.renderHtml()),'<div id="'+n+'" class="'+t.classes+'" hidefocus="1"><div class="'+t.classPrefix+'reset" role="application">'+o+'<div id="'+n+'-body" class="'+t.bodyClasses+'">'+a+"</div>"+s+"</div></div>"},fullscreen:function(t){var n,e,i=this,r=_.document.documentElement,o=i.classPrefix;if(t!==i._fullscreen)if(Tt(_.window).on("resize",function(){var t;if(i._fullscreen)if(n)i._timer||(i._timer=c.setTimeout(function(){var t=Ht.getWindowSize();i.moveTo(0,0).resizeTo(t.w,t.h),i._timer=0},50));else{t=(new Date).getTime();var e=Ht.getWindowSize();i.moveTo(0,0).resizeTo(e.w,e.h),50<(new Date).getTime()-t&&(n=!0)}}),e=i.layoutRect(),i._fullscreen=t){i._initial={x:e.x,y:e.y,w:e.w,h:e.h},i.borderBox=Nt("0"),i.getEl("head").style.display="none",e.deltaH-=e.headerH+2,Tt([r,_.document.body]).addClass(o+"fullscreen"),i.classes.add("fullscreen");var s=Ht.getWindowSize();i.moveTo(0,0).resizeTo(s.w,s.h)}else i.borderBox=Nt(i.settings.border),i.getEl("head").style.display="",e.deltaH+=e.headerH,Tt([r,_.document.body]).removeClass(o+"fullscreen"),i.classes.remove("fullscreen"),i.moveTo(i._initial.x,i._initial.y).resizeTo(i._initial.w,i._initial.h);return i.reflow()},postRender:function(){var e,n=this;setTimeout(function(){n.classes.add("in"),n.fire("open")},0),n._super(),n.statusbar&&n.statusbar.postRender(),n.focus(),this.dragHelper=new we(n._id+"-dragh",{start:function(){e={x:n.layoutRect().x,y:n.layoutRect().y}},drag:function(t){n.moveTo(e.x+t.deltaX,e.y+t.deltaY)}}),n.on("submit",function(t){t.isDefaultPrevented()||n.close()}),Ue.push(n),qe(!0)},submit:function(){return this.fire("submit",{data:this.toJSON()})},remove:function(){var t,e=this;for(e.dragHelper.destroy(),e._super(),e.statusbar&&this.statusbar.remove(),Ye(e.classPrefix,!1),t=Ue.length;t--;)Ue[t]===e&&Ue.splice(t,1);qe(0<Ue.length)},getContentWindow:function(){var t=this.getEl().getElementsByTagName("iframe")[0];return t?t.contentWindow:null}});!function(){if(!h.desktop){var n={w:_.window.innerWidth,h:_.window.innerHeight};c.setInterval(function(){var t=_.window.innerWidth,e=_.window.innerHeight;n.w===t&&n.h===e||(n={w:t,h:e},Tt(_.window).trigger("resize"))},100)}Tt(_.window).on("resize",function(){var t,e,n=Ht.getWindowSize();for(t=0;t<Ue.length;t++)e=Ue[t].layoutRect(),Ue[t].moveTo(Ue[t].settings.x||Math.max(0,n.w/2-e.w/2),Ue[t].settings.y||Math.max(0,n.h/2-e.h/2))})}();var Xe,je,Je,Ge=$e.extend({init:function(t){t={border:1,padding:20,layout:"flex",pack:"center",align:"center",containerCls:"panel",autoScroll:!0,buttons:{type:"button",text:"Ok",action:"ok"},items:{type:"label",multiline:!0,maxWidth:500,maxHeight:200}},this._super(t)},Statics:{OK:1,OK_CANCEL:2,YES_NO:3,YES_NO_CANCEL:4,msgBox:function(t){var e,i=t.callback||function(){};function n(t,e,n){return{type:"button",text:t,subtype:n?"primary":"",onClick:function(t){t.control.parents()[1].close(),i(e)}}}switch(t.buttons){case Ge.OK_CANCEL:e=[n("Ok",!0,!0),n("Cancel",!1)];break;case Ge.YES_NO:case Ge.YES_NO_CANCEL:e=[n("Yes",1,!0),n("No",0)],t.buttons===Ge.YES_NO_CANCEL&&e.push(n("Cancel",-1));break;default:e=[n("Ok",!0,!0)]}return new $e({padding:20,x:t.x,y:t.y,minWidth:300,minHeight:100,layout:"flex",pack:"center",align:"center",buttons:e,title:t.title,role:"alertdialog",items:{type:"label",multiline:!0,maxWidth:500,maxHeight:200,text:t.text},onPostRender:function(){this.aria("describedby",this.items()[0]._id)},onClose:t.onClose,onCancel:function(){i(!1)}}).renderTo(_.document.body).reflow()},alert:function(t,e){return"string"==typeof t&&(t={text:t}),t.callback=e,Ge.msgBox(t)},confirm:function(t,e){return"string"==typeof t&&(t={text:t}),t.callback=e,t.buttons=Ge.OK_CANCEL,Ge.msgBox(t)}}}),Ke=function(t,e){return{renderUI:function(){return st(t,e)},getNotificationManagerImpl:function(){return ye(t)},getWindowManagerImpl:function(){return{open:function(n,t,e){var i;return n.title=n.title||" ",n.url=n.url||n.file,n.url&&(n.width=parseInt(n.width||320,10),n.height=parseInt(n.height||240,10)),n.body&&(n.items={defaults:n.defaults,type:n.bodyType||"form",items:n.body,data:n.data,callbacks:n.commands}),n.url||n.buttons||(n.buttons=[{text:"Ok",subtype:"primary",onclick:function(){i.find("form")[0].submit()}},{text:"Cancel",onclick:function(){i.close()}}]),(i=new $e(n)).on("close",function(){e(i)}),n.data&&i.on("postRender",function(){this.find("*").each(function(t){var e=t.name();e in n.data&&t.value(n.data[e])})}),i.features=n||{},i.params=t||{},i=i.renderTo(_.document.body).reflow()},alert:function(t,e,n){var i;return(i=Ge.alert(t,function(){e()})).on("close",function(){n(i)}),i},confirm:function(t,e,n){var i;return(i=Ge.confirm(t,function(t){e(t)})).on("close",function(){n(i)}),i},close:function(t){t.close()},getParams:function(t){return t.params},setParams:function(t,e){t.params=e}}}}},Ze="undefined"!=typeof _.window?_.window:Function("return this;")(),Qe=function(t,e){return function(t,e){for(var n=e!==undefined&&null!==e?e:Ze,i=0;i<t.length&&n!==undefined&&null!==n;++i)n=n[t[i]];return n}(t.split("."),e)},tn=function(t,e){var n=Qe(t,e);if(n===undefined||null===n)throw new Error(t+" not available on this browser");return n},en=tinymce.util.Tools.resolve("tinymce.util.Promise"),nn=function(n){return new en(function(t){var e=new(tn("FileReader"));e.onloadend=function(){t(e.result.split(",")[1])},e.readAsDataURL(n)})},rn=function(){return new en(function(e){var t;(t=_.document.createElement("input")).type="file",t.style.position="fixed",t.style.left=0,t.style.top=0,t.style.opacity=.001,_.document.body.appendChild(t),t.onchange=function(t){e(Array.prototype.slice.call(t.target.files))},t.click(),t.parentNode.removeChild(t)})},on=0,sn=function(t){return t+on+++(e=function(){return Math.round(4294967295*Math.random()).toString(36)},"s"+Date.now().toString(36)+e()+e()+e());var e},an=function(r,o){var s={};function t(t){var e,n,i;n=o[t?"startContainer":"endContainer"],i=o[t?"startOffset":"endOffset"],1===n.nodeType&&(e=r.create("span",{"data-mce-type":"bookmark"}),n.hasChildNodes()?(i=Math.min(i,n.childNodes.length-1),t?n.insertBefore(e,n.childNodes[i]):r.insertAfter(e,n.childNodes[i])):n.appendChild(e),n=e,i=0),s[t?"startContainer":"endContainer"]=n,s[t?"startOffset":"endOffset"]=i}return t(!0),o.collapsed||t(),s},ln=function(r,o){function t(t){var e,n,i;e=i=o[t?"startContainer":"endContainer"],n=o[t?"startOffset":"endOffset"],e&&(1===e.nodeType&&(n=function(t){for(var e=t.parentNode.firstChild,n=0;e;){if(e===t)return n;1===e.nodeType&&"bookmark"===e.getAttribute("data-mce-type")||n++,e=e.nextSibling}return-1}(e),e=e.parentNode,r.remove(i)),o[t?"startContainer":"endContainer"]=e,o[t?"startOffset":"endOffset"]=n)}t(!0),t();var e=r.createRng();return e.setStart(o.startContainer,o.startOffset),o.endContainer&&e.setEnd(o.endContainer,o.endOffset),e},un=tinymce.util.Tools.resolve("tinymce.dom.TreeWalker"),cn=tinymce.util.Tools.resolve("tinymce.dom.RangeUtils"),dn=function(t){return"A"===t.nodeName&&t.hasAttribute("href")},fn=function(t){var e,n,i,r,o,s,a,l;return r=t.selection,o=t.dom,s=r.getRng(),a=o,l=cn.getNode(s.startContainer,s.startOffset),e=a.getParent(l,dn)||l,n=cn.getNode(s.endContainer,s.endOffset),i=t.getBody(),R.grep(function(t,e,n){var i,r,o=[];for(i=new un(e,t),r=e;r&&(1===r.nodeType&&o.push(r),r!==n);r=i.next());return o}(i,e,n),dn)},hn=function(t){var e,n,i,r,o;n=fn(e=t),r=e.dom,o=e.selection,i=an(r,o.getRng()),R.each(n,function(t){e.dom.remove(t,!0)}),o.setRng(ln(r,i))},mn=function(t){t.selection.collapse(!1)},gn=function(t){t.focus(),hn(t),mn(t)},pn=function(t,e){var n,i,r,o,s,a=t.dom.getParent(t.selection.getStart(),"a[href]");a?(o=a,s=e,(r=t).focus(),r.dom.setAttrib(o,"href",s),mn(r)):(i=e,(n=t).execCommand("mceInsertLink",!1,{href:i}),mn(n))},vn=function(t,e,n){var i,r,o;t.plugins.table?t.plugins.table.insertTable(e,n):(r=e,o=n,(i=t).undoManager.transact(function(){var t,e;i.insertContent(function(t,e){var n,i,r;for(r='<table data-mce-id="mce" style="width: 100%">',r+="<tbody>",i=0;i<e;i++){for(r+="<tr>",n=0;n<t;n++)r+="<td><br></td>";r+="</tr>"}return r+="</tbody>",r+="</table>"}(r,o)),(t=i.dom.select("*[data-mce-id]")[0]).removeAttribute("data-mce-id"),e=i.dom.select("td,th",t),i.selection.setCursorLocation(e[0],0)}))},bn=function(t,e){t.execCommand("FormatBlock",!1,e)},yn=function(t,e,n){var i,r;r=(i=t.editorUpload.blobCache).create(sn("mceu"),n,e),i.add(r),t.insertContent(t.dom.createHTML("img",{src:r.blobUri()}))},xn=function(t,e){0===e.trim().length?gn(t):pn(t,e)},wn=gn,_n=function(n,t){n.addButton("quicklink",{icon:"link",tooltip:"Insert/Edit link",stateSelector:"a[href]",onclick:function(){t.showForm(n,"quicklink")}}),n.addButton("quickimage",{icon:"image",tooltip:"Insert image",onclick:function(){rn().then(function(t){var e=t[0];nn(e).then(function(t){yn(n,t,e)})})}}),n.addButton("quicktable",{icon:"table",tooltip:"Insert table",onclick:function(){t.hide(),vn(n,2,2)}}),function(e){for(var t=function(t){return function(){bn(e,t)}},n=1;n<6;n++){var i="h"+n;e.addButton(i,{text:i.toUpperCase(),tooltip:"Heading "+n,stateSelector:i,onclick:t(i),onPostRender:function(){this.getEl().firstChild.firstChild.style.fontWeight="bold"}})}}(n)},Rn=function(){var t=h.container;if(t&&"static"!==v.DOM.getStyle(t,"position",!0)){var e=v.DOM.getPos(t),n=e.x-t.scrollLeft,i=e.y-t.scrollTop;return mt.some({x:n,y:i})}return mt.none()},Cn=function(t){return/^www\.|\.(com|org|edu|gov|uk|net|ca|de|jp|fr|au|us|ru|ch|it|nl|se|no|es|mil)$/i.test(t.trim())},kn=function(t){return/^https?:\/\//.test(t.trim())},En=function(t,e){return!kn(e)&&Cn(e)?(n=t,i=e,new en(function(e){n.windowManager.confirm("The URL you entered seems to be an external link. Do you want to add the required http:// prefix?",function(t){e(!0===t?"http://"+i:i)})})):en.resolve(e);var n,i},Hn=function(r,e){var t,n,i,o={};return t="quicklink",n={items:[{type:"button",name:"unlink",icon:"unlink",onclick:function(){r.focus(),wn(r),e()},tooltip:"Remove link"},{type:"filepicker",name:"linkurl",placeholder:"Paste or type a link",filetype:"file",onchange:function(t){var e=t.meta;e&&e.attach&&(o={href:this.value(),attach:e.attach})}},{type:"button",icon:"checkmark",subtype:"primary",tooltip:"Ok",onclick:"submit"}],onshow:function(t){if(t.control===this){var e,n="";(e=r.dom.getParent(r.selection.getStart(),"a[href]"))&&(n=r.dom.getAttrib(e,"href")),this.fromJSON({linkurl:n}),i=this.find("#unlink"),e?i.show():i.hide(),this.find("#linkurl")[0].focus()}var i},onsubmit:function(t){En(r,t.data.linkurl).then(function(t){r.undoManager.transact(function(){t===o.href&&(o.attach(),o={}),xn(r,t)}),e()})}},(i=_e.create(R.extend({type:"form",layout:"flex",direction:"row",padding:5,name:t,spacing:3},n))).on("show",function(){i.find("textbox").eq(0).each(function(t){t.focus()})}),i},Tn=function(n,t,e){var o,i,s=[];if(e)return R.each(B(i=e)?i:W(i)?i.split(/[ ,]/):[],function(t){if("|"===t)o=null;else if(n.buttons[t]){o||(o={type:"buttongroup",items:[]},s.push(o));var e=n.buttons[t];A(e)&&(e=e()),e.type=e.type||"button",(e=_e.create(e)).on("postRender",(i=n,r=e,function(){var e,t,n=(t=function(t,e){return{selector:t,handler:e}},(e=r).settings.stateSelector?t(e.settings.stateSelector,function(t){e.active(t)}):e.settings.disabledStateSelector?t(e.settings.disabledStateSelector,function(t){e.disabled(t)}):null);null!==n&&i.selection.selectorChanged(n.selector,n.handler)})),o.items.push(e)}var i,r}),_e.create({type:"toolbar",layout:"flow",name:t,items:s})},Sn=function(){var l,c,o=function(t){return 0<t.items().length},u=function(t,e){var n,i,r=(n=t,i=e,R.map(i,function(t){return Tn(n,t.id,t.items)})).concat([Tn(t,"text",J(t)),Tn(t,"insert",G(t)),Hn(t,p)]);return _e.create({type:"floatpanel",role:"dialog",classes:"tinymce tinymce-inline arrow",ariaLabel:"Inline toolbar",layout:"flex",direction:"column",align:"stretch",autohide:!1,autofix:!0,fixed:!0,border:1,items:R.grep(r,o),oncancel:function(){t.focus()}})},d=function(t){t&&t.show()},f=function(t,e){t.moveTo(e.x,e.y)},h=function(n,i){i=i?i.substr(0,2):"",R.each({t:"down",b:"up",c:"center"},function(t,e){n.classes.toggle("arrow-"+t,e===i.substr(0,1))}),"cr"===i?(n.classes.toggle("arrow-left",!0),n.classes.toggle("arrow-right",!1)):"cl"===i?(n.classes.toggle("arrow-left",!1),n.classes.toggle("arrow-right",!0)):R.each({l:"left",r:"right"},function(t,e){n.classes.toggle("arrow-"+t,e===i.substr(1,1))})},m=function(t,e){var n=t.items().filter("#"+e);return 0<n.length&&(n[0].show(),t.reflow(),!0)},g=function(t,e,n,i){var r,o,s,a;if(a=K(n),r=b(n),o=v.DOM.getRect(t.getEl()),s="insert"===e?Y(i,r,o):$(i,r,o)){var l=Rn().getOr({x:0,y:0}),u={x:s.rect.x-l.x,y:s.rect.y-l.y,w:s.rect.w,h:s.rect.h};return f(t,X(a,c=i,r,u)),h(t,s.position),!0}return!1},p=function(){l&&l.hide()};return{show:function(t,e,n,i){var r,o,s,a;l||(S(t),(l=u(t,i)).renderTo().reflow().moveTo(n.x,n.y),t.nodeChanged()),o=e,s=t,a=n,d(r=l),r.items().hide(),m(r,o)?!1===g(r,o,s,a)&&p():p()},showForm:function(t,e){if(l){if(l.items().hide(),!m(l,e))return void p();var n,i,r,o=void 0;d(l),l.items().hide(),m(l,e),r=K(t),n=b(t),o=v.DOM.getRect(l.getEl()),(i=$(c,n,o))&&(o=i.rect,f(l,X(r,c,n,o)),h(l,i.position))}},reposition:function(t,e,n){l&&g(l,e,t,n)},inForm:function(){return l&&l.visible()&&0<l.items().filter("form:visible").length},hide:p,focus:function(){l&&l.find("toolbar:visible").eq(0).each(function(t){t.focus(!0)})},remove:function(){l&&(l.remove(),l=null)}}},Mn=St.extend({Defaults:{firstControlClass:"first",lastControlClass:"last"},init:function(t){this.settings=R.extend({},this.Defaults,t)},preRender:function(t){t.bodyClasses.add(this.settings.containerClass)},applyClasses:function(t){var e,n,i,r,o=this.settings;e=o.firstControlClass,n=o.lastControlClass,t.each(function(t){t.classes.remove(e).remove(n).add(o.controlClass),t.visible()&&(i||(i=t),r=t)}),i&&i.classes.add(e),r&&r.classes.add(n)},renderHtml:function(t){var e="";return this.applyClasses(t.items()),t.items().each(function(t){e+=t.renderHtml()}),e},recalc:function(){},postRender:function(){},isNative:function(){return!1}}),Nn=Mn.extend({Defaults:{containerClass:"abs-layout",controlClass:"abs-layout-item"},recalc:function(t){t.items().filter(":visible").each(function(t){var e=t.settings;t.layoutRect({x:e.x,y:e.y,w:e.w,h:e.h}),t.recalc&&t.recalc()})},renderHtml:function(t){return'<div id="'+t._id+'-absend" class="'+t.classPrefix+'abs-end"></div>'+this._super(t)}}),On=ge.extend({Defaults:{classes:"widget btn",role:"button"},init:function(t){var e,n=this;n._super(t),t=n.settings,e=n.settings.size,n.on("click mousedown",function(t){t.preventDefault()}),n.on("touchstart",function(t){n.fire("click",t),t.preventDefault()}),t.subtype&&n.classes.add(t.subtype),e&&n.classes.add("btn-"+e),t.icon&&n.icon(t.icon)},icon:function(t){return arguments.length?(this.state.set("icon",t),this):this.state.get("icon")},repaint:function(){var t,e=this.getEl().firstChild;e&&((t=e.style).width=t.height="100%"),this._super()},renderHtml:function(){var t,e,n=this,i=n._id,r=n.classPrefix,o=n.state.get("icon"),s=n.state.get("text"),a="",l=n.settings;return(t=l.image)?(o="none","string"!=typeof t&&(t=_.window.getSelection?t[0]:t[1]),t=" style=\"background-image: url('"+t+"')\""):t="",s&&(n.classes.add("btn-has-text"),a='<span class="'+r+'txt">'+n.encode(s)+"</span>"),o=o?r+"ico "+r+"i-"+o:"",e="boolean"==typeof l.active?' aria-pressed="'+l.active+'"':"",'<div id="'+i+'" class="'+n.classes+'" tabindex="-1"'+e+'><button id="'+i+'-button" role="presentation" type="button" tabindex="-1">'+(o?'<i class="'+o+'"'+t+"></i>":"")+a+"</button></div>"},bindStates:function(){var o=this,n=o.$,i=o.classPrefix+"txt";function s(t){var e=n("span."+i,o.getEl());t?(e[0]||(n("button:first",o.getEl()).append('<span class="'+i+'"></span>'),e=n("span."+i,o.getEl())),e.html(o.encode(t))):e.remove(),o.classes.toggle("btn-has-text",!!t)}return o.state.on("change:text",function(t){s(t.value)}),o.state.on("change:icon",function(t){var e=t.value,n=o.classPrefix;e=(o.settings.icon=e)?n+"ico "+n+"i-"+o.settings.icon:"";var i=o.getEl().firstChild,r=i.getElementsByTagName("i")[0];e?(r&&r===i.firstChild||(r=_.document.createElement("i"),i.insertBefore(r,i.firstChild)),r.className=e):r&&i.removeChild(r),s(o.state.get("text"))}),o._super()}}),Wn=On.extend({init:function(t){t=R.extend({text:"Browse...",multiple:!1,accept:null},t),this._super(t),this.classes.add("browsebutton"),t.multiple&&this.classes.add("multiple")},postRender:function(){var n=this,e=Ht.create("input",{type:"file",id:n._id+"-browse",accept:n.settings.accept});n._super(),Tt(e).on("change",function(t){var e=t.target.files;n.value=function(){return e.length?n.settings.multiple?e:e[0]:null},t.preventDefault(),e.length&&n.fire("change",t)}),Tt(e).on("click",function(t){t.stopPropagation()}),Tt(n.getEl("button")).on("click touchstart",function(t){t.stopPropagation(),e.click(),t.preventDefault()}),n.getEl().appendChild(e)},remove:function(){Tt(this.getEl("button")).off(),Tt(this.getEl("input")).off(),this._super()}}),Pn=Me.extend({Defaults:{defaultType:"button",role:"group"},renderHtml:function(){var t=this,e=t._layout;return t.classes.add("btn-group"),t.preRender(),e.preRender(t),'<div id="'+t._id+'" class="'+t.classes+'"><div id="'+t._id+'-body">'+(t.settings.html||"")+e.renderHtml(t)+"</div></div>"}}),Dn=ge.extend({Defaults:{classes:"checkbox",role:"checkbox",checked:!1},init:function(t){var e=this;e._super(t),e.on("click mousedown",function(t){t.preventDefault()}),e.on("click",function(t){t.preventDefault(),e.disabled()||e.checked(!e.checked())}),e.checked(e.settings.checked)},checked:function(t){return arguments.length?(this.state.set("checked",t),this):this.state.get("checked")},value:function(t){return arguments.length?this.checked(t):this.checked()},renderHtml:function(){var t=this,e=t._id,n=t.classPrefix;return'<div id="'+e+'" class="'+t.classes+'" unselectable="on" aria-labelledby="'+e+'-al" tabindex="-1"><i class="'+n+"ico "+n+'i-checkbox"></i><span id="'+e+'-al" class="'+n+'label">'+t.encode(t.state.get("text"))+"</span></div>"},bindStates:function(){var o=this;function e(t){o.classes.toggle("checked",t),o.aria("checked",t)}return o.state.on("change:text",function(t){o.getEl("al").firstChild.data=o.translate(t.value)}),o.state.on("change:checked change:value",function(t){o.fire("change"),e(t.value)}),o.state.on("change:icon",function(t){var e=t.value,n=o.classPrefix;if(void 0===e)return o.settings.icon;e=(o.settings.icon=e)?n+"ico "+n+"i-"+o.settings.icon:"";var i=o.getEl().firstChild,r=i.getElementsByTagName("i")[0];e?(r&&r===i.firstChild||(r=_.document.createElement("i"),i.insertBefore(r,i.firstChild)),r.className=e):r&&i.removeChild(r)}),o.state.get("checked")&&e(!0),o._super()}}),An=tinymce.util.Tools.resolve("tinymce.util.VK"),Bn=ge.extend({init:function(i){var r=this;r._super(i),i=r.settings,r.classes.add("combobox"),r.subinput=!0,r.ariaTarget="inp",i.menu=i.menu||i.values,i.menu&&(i.icon="caret"),r.on("click",function(t){var e=t.target,n=r.getEl();if(Tt.contains(n,e)||e===n)for(;e&&e!==n;)e.id&&-1!==e.id.indexOf("-open")&&(r.fire("action"),i.menu&&(r.showMenu(),t.aria&&r.menu.items()[0].focus())),e=e.parentNode}),r.on("keydown",function(t){var e;13===t.keyCode&&"INPUT"===t.target.nodeName&&(t.preventDefault(),r.parents().reverse().each(function(t){if(t.toJSON)return e=t,!1}),r.fire("submit",{data:e.toJSON()}))}),r.on("keyup",function(t){if("INPUT"===t.target.nodeName){var e=r.state.get("value"),n=t.target.value;n!==e&&(r.state.set("value",n),r.fire("autocomplete",t))}}),r.on("mouseover",function(t){var e=r.tooltip().moveTo(-65535);if(r.statusLevel()&&-1!==t.target.className.indexOf(r.classPrefix+"status")){var n=r.statusMessage()||"Ok",i=e.text(n).show().testMoveRel(t.target,["bc-tc","bc-tl","bc-tr"]);e.classes.toggle("tooltip-n","bc-tc"===i),e.classes.toggle("tooltip-nw","bc-tl"===i),e.classes.toggle("tooltip-ne","bc-tr"===i),e.moveRel(t.target,i)}})},statusLevel:function(t){return 0<arguments.length&&this.state.set("statusLevel",t),this.state.get("statusLevel")},statusMessage:function(t){return 0<arguments.length&&this.state.set("statusMessage",t),this.state.get("statusMessage")},showMenu:function(){var t,e=this,n=e.settings;e.menu||((t=n.menu||[]).length?t={type:"menu",items:t}:t.type=t.type||"menu",e.menu=_e.create(t).parent(e).renderTo(e.getContainerElm()),e.fire("createmenu"),e.menu.reflow(),e.menu.on("cancel",function(t){t.control===e.menu&&e.focus()}),e.menu.on("show hide",function(t){t.control.items().each(function(t){t.active(t.value()===e.value())})}).fire("show"),e.menu.on("select",function(t){e.value(t.control.value())}),e.on("focusin",function(t){"INPUT"===t.target.tagName.toUpperCase()&&e.menu.hide()}),e.aria("expanded",!0)),e.menu.show(),e.menu.layoutRect({w:e.layoutRect().w}),e.menu.moveRel(e.getEl(),e.isRtl()?["br-tr","tr-br"]:["bl-tl","tl-bl"])},focus:function(){this.getEl("inp").focus()},repaint:function(){var t,e,n=this,i=n.getEl(),r=n.getEl("open"),o=n.layoutRect(),s=0,a=i.firstChild;n.statusLevel()&&"none"!==n.statusLevel()&&(s=parseInt(Ht.getRuntimeStyle(a,"padding-right"),10)-parseInt(Ht.getRuntimeStyle(a,"padding-left"),10)),t=r?o.w-Ht.getSize(r).width-10:o.w-10;var l=_.document;return l.all&&(!l.documentMode||l.documentMode<=8)&&(e=n.layoutRect().h-2+"px"),Tt(a).css({width:t-s,lineHeight:e}),n._super(),n},postRender:function(){var e=this;return Tt(this.getEl("inp")).on("change",function(t){e.state.set("value",t.target.value),e.fire("change",t)}),e._super()},renderHtml:function(){var t,e,n,i=this,r=i._id,o=i.settings,s=i.classPrefix,a=i.state.get("value")||"",l="",u="";return"spellcheck"in o&&(u+=' spellcheck="'+o.spellcheck+'"'),o.maxLength&&(u+=' maxlength="'+o.maxLength+'"'),o.size&&(u+=' size="'+o.size+'"'),o.subtype&&(u+=' type="'+o.subtype+'"'),n='<i id="'+r+'-status" class="mce-status mce-ico" style="display: none"></i>',i.disabled()&&(u+=' disabled="disabled"'),(t=o.icon)&&"caret"!==t&&(t=s+"ico "+s+"i-"+o.icon),e=i.state.get("text"),(t||e)&&(l='<div id="'+r+'-open" class="'+s+"btn "+s+'open" tabIndex="-1" role="button"><button id="'+r+'-action" type="button" hidefocus="1" tabindex="-1">'+("caret"!==t?'<i class="'+t+'"></i>':'<i class="'+s+'caret"></i>')+(e?(t?" ":"")+e:"")+"</button></div>",i.classes.add("has-open")),'<div id="'+r+'" class="'+i.classes+'"><input id="'+r+'-inp" class="'+s+'textbox" value="'+i.encode(a,!1)+'" hidefocus="1"'+u+' placeholder="'+i.encode(o.placeholder)+'" />'+n+l+"</div>"},value:function(t){return arguments.length?(this.state.set("value",t),this):(this.state.get("rendered")&&this.state.set("value",this.getEl("inp").value),this.state.get("value"))},showAutoComplete:function(t,i){var r=this;if(0!==t.length){r.menu?r.menu.items().remove():r.menu=_e.create({type:"menu",classes:"combobox-menu",layout:"flow"}).parent(r).renderTo(),R.each(t,function(t){var e,n;r.menu.add({text:t.title,url:t.previewUrl,match:i,classes:"menu-item-ellipsis",onclick:(e=t.value,n=t.title,function(){r.fire("selectitem",{title:n,value:e})})})}),r.menu.renderNew(),r.hideMenu(),r.menu.on("cancel",function(t){t.control.parent()===r.menu&&(t.stopPropagation(),r.focus(),r.hideMenu())}),r.menu.on("select",function(){r.focus()});var e=r.layoutRect().w;r.menu.layoutRect({w:e,minW:0,maxW:e}),r.menu.repaint(),r.menu.reflow(),r.menu.show(),r.menu.moveRel(r.getEl(),r.isRtl()?["br-tr","tr-br"]:["bl-tl","tl-bl"])}else r.hideMenu()},hideMenu:function(){this.menu&&this.menu.hide()},bindStates:function(){var r=this;r.state.on("change:value",function(t){r.getEl("inp").value!==t.value&&(r.getEl("inp").value=t.value)}),r.state.on("change:disabled",function(t){r.getEl("inp").disabled=t.value}),r.state.on("change:statusLevel",function(t){var e=r.getEl("status"),n=r.classPrefix,i=t.value;Ht.css(e,"display","none"===i?"none":""),Ht.toggleClass(e,n+"i-checkmark","ok"===i),Ht.toggleClass(e,n+"i-warning","warn"===i),Ht.toggleClass(e,n+"i-error","error"===i),r.classes.toggle("has-status","none"!==i),r.repaint()}),Ht.on(r.getEl("status"),"mouseleave",function(){r.tooltip().hide()}),r.on("cancel",function(t){r.menu&&r.menu.visible()&&(t.stopPropagation(),r.hideMenu())});var n=function(t,e){e&&0<e.items().length&&e.items().eq(t)[0].focus()};return r.on("keydown",function(t){var e=t.keyCode;"INPUT"===t.target.nodeName&&(e===An.DOWN?(t.preventDefault(),r.fire("autocomplete"),n(0,r.menu)):e===An.UP&&(t.preventDefault(),n(-1,r.menu)))}),r._super()},remove:function(){Tt(this.getEl("inp")).off(),this.menu&&this.menu.remove(),this._super()}}),Ln=Bn.extend({init:function(t){var e=this;t.spellcheck=!1,t.onaction&&(t.icon="none"),e._super(t),e.classes.add("colorbox"),e.on("change keyup postrender",function(){e.repaintColor(e.value())})},repaintColor:function(t){var e=this.getEl("open"),n=e?e.getElementsByTagName("i")[0]:null;if(n)try{n.style.background=t}catch(i){}},bindStates:function(){var e=this;return e.state.on("change:value",function(t){e.state.get("rendered")&&e.repaintColor(t.value)}),e._super()}}),In=On.extend({showPanel:function(){var e=this,t=e.settings;if(e.classes.add("opened"),e.panel)e.panel.show();else{var n=t.panel;n.type&&(n={layout:"grid",items:n}),n.role=n.role||"dialog",n.popover=!0,n.autohide=!0,n.ariaRoot=!0,e.panel=new ze(n).on("hide",function(){e.classes.remove("opened")}).on("cancel",function(t){t.stopPropagation(),e.focus(),e.hidePanel()}).parent(e).renderTo(e.getContainerElm()),e.panel.fire("show"),e.panel.reflow()}var i=e.panel.testMoveRel(e.getEl(),t.popoverAlign||(e.isRtl()?["bc-tc","bc-tl","bc-tr"]:["bc-tc","bc-tr","bc-tl","tc-bc","tc-br","tc-bl"]));e.panel.classes.toggle("start","l"===i.substr(-1)),e.panel.classes.toggle("end","r"===i.substr(-1));var r="t"===i.substr(0,1);e.panel.classes.toggle("bottom",!r),e.panel.classes.toggle("top",r),e.panel.moveRel(e.getEl(),i)},hidePanel:function(){this.panel&&this.panel.hide()},postRender:function(){var e=this;return e.aria("haspopup",!0),e.on("click",function(t){t.control===e&&(e.panel&&e.panel.visible()?e.hidePanel():(e.showPanel(),e.panel.focus(!!t.aria)))}),e._super()},remove:function(){return this.panel&&(this.panel.remove(),this.panel=null),this._super()}}),zn=v.DOM,Fn=In.extend({init:function(t){this._super(t),this.classes.add("splitbtn"),this.classes.add("colorbutton")},color:function(t){return t?(this._color=t,this.getEl("preview").style.backgroundColor=t,this):this._color},resetColor:function(){return this._color=null,this.getEl("preview").style.backgroundColor=null,this},renderHtml:function(){var t=this,e=t._id,n=t.classPrefix,i=t.state.get("text"),r=t.settings.icon?n+"ico "+n+"i-"+t.settings.icon:"",o=t.settings.image?" style=\"background-image: url('"+t.settings.image+"')\"":"",s="";return i&&(t.classes.add("btn-has-text"),s='<span class="'+n+'txt">'+t.encode(i)+"</span>"),'<div id="'+e+'" class="'+t.classes+'" role="button" tabindex="-1" aria-haspopup="true"><button role="presentation" hidefocus="1" type="button" tabindex="-1">'+(r?'<i class="'+r+'"'+o+"></i>":"")+'<span id="'+e+'-preview" class="'+n+'preview"></span>'+s+'</button><button type="button" class="'+n+'open" hidefocus="1" tabindex="-1"> <i class="'+n+'caret"></i></button></div>'},postRender:function(){var e=this,n=e.settings.onclick;return e.on("click",function(t){t.aria&&"down"===t.aria.key||t.control!==e||zn.getParent(t.target,"."+e.classPrefix+"open")||(t.stopImmediatePropagation(),n.call(e,t))}),delete e.settings.onclick,e._super()}}),Un=tinymce.util.Tools.resolve("tinymce.util.Color"),Vn=ge.extend({Defaults:{classes:"widget colorpicker"},init:function(t){this._super(t)},postRender:function(){var n,i,r,o,s,a=this,l=a.color();function u(t,e){var n,i,r=Ht.getPos(t);return n=e.pageX-r.x,i=e.pageY-r.y,{x:n=Math.max(0,Math.min(n/t.clientWidth,1)),y:i=Math.max(0,Math.min(i/t.clientHeight,1))}}function c(t,e){var n=(360-t.h)/360;Ht.css(r,{top:100*n+"%"}),e||Ht.css(s,{left:t.s+"%",top:100-t.v+"%"}),o.style.background=Un({s:100,v:100,h:t.h}).toHex(),a.color().parse({s:t.s,v:t.v,h:t.h})}function t(t){var e;e=u(o,t),n.s=100*e.x,n.v=100*(1-e.y),c(n),a.fire("change")}function e(t){var e;e=u(i,t),(n=l.toHsv()).h=360*(1-e.y),c(n,!0),a.fire("change")}i=a.getEl("h"),r=a.getEl("hp"),o=a.getEl("sv"),s=a.getEl("svp"),a._repaint=function(){c(n=l.toHsv())},a._super(),a._svdraghelper=new we(a._id+"-sv",{start:t,drag:t}),a._hdraghelper=new we(a._id+"-h",{start:e,drag:e}),a._repaint()},rgb:function(){return this.color().toRgb()},value:function(t){if(!arguments.length)return this.color().toHex();this.color().parse(t),this._rendered&&this._repaint()},color:function(){return this._color||(this._color=Un()),this._color},renderHtml:function(){var t,e=this._id,o=this.classPrefix,s="#ff0000,#ff0080,#ff00ff,#8000ff,#0000ff,#0080ff,#00ffff,#00ff80,#00ff00,#80ff00,#ffff00,#ff8000,#ff0000";return t='<div id="'+e+'-h" class="'+o+'colorpicker-h" style="background: -ms-linear-gradient(top,'+s+");background: linear-gradient(to bottom,"+s+');">'+function(){var t,e,n,i,r="";for(n="filter:progid:DXImageTransform.Microsoft.gradient(GradientType=0,startColorstr=",t=0,e=(i=s.split(",")).length-1;t<e;t++)r+='<div class="'+o+'colorpicker-h-chunk" style="height:'+100/e+"%;"+n+i[t]+",endColorstr="+i[t+1]+");-ms-"+n+i[t]+",endColorstr="+i[t+1]+')"></div>';return r}()+'<div id="'+e+'-hp" class="'+o+'colorpicker-h-marker"></div></div>','<div id="'+e+'" class="'+this.classes+'"><div id="'+e+'-sv" class="'+o+'colorpicker-sv"><div class="'+o+'colorpicker-overlay1"><div class="'+o+'colorpicker-overlay2"><div id="'+e+'-svp" class="'+o+'colorpicker-selector1"><div class="'+o+'colorpicker-selector2"></div></div></div></div></div>'+t+"</div>"}}),qn=ge.extend({init:function(t){t=R.extend({height:100,text:"Drop an image here",multiple:!1,accept:null},t),this._super(t),this.classes.add("dropzone"),t.multiple&&this.classes.add("multiple")},renderHtml:function(){var t,e,n=this.settings;return t={id:this._id,hidefocus:"1"},e=Ht.create("div",t,"<span>"+this.translate(n.text)+"</span>"),n.height&&Ht.css(e,"height",n.height+"px"),n.width&&Ht.css(e,"width",n.width+"px"),e.className=this.classes,e.outerHTML},postRender:function(){var i=this,t=function(t){t.preventDefault(),i.classes.toggle("dragenter"),i.getEl().className=i.classes};i._super(),i.$el.on("dragover",function(t){t.preventDefault()}),i.$el.on("dragenter",t),i.$el.on("dragleave",t),i.$el.on("drop",function(t){if(t.preventDefault(),!i.state.get("disabled")){var e=function(t){var e=i.settings.accept;if("string"!=typeof e)return t;var n=new RegExp("("+e.split(/\s*,\s*/).join("|")+")$","i");return R.grep(t,function(t){return n.test(t.name)})}(t.dataTransfer.files);i.value=function(){return e.length?i.settings.multiple?e:e[0]:null},e.length&&i.fire("change",t)}})},remove:function(){this.$el.off(),this._super()}}),Yn=ge.extend({init:function(t){var n=this;t.delimiter||(t.delimiter="\xbb"),n._super(t),n.classes.add("path"),n.canFocus=!0,n.on("click",function(t){var e;(e=t.target.getAttribute("data-index"))&&n.fire("select",{value:n.row()[e],index:e})}),n.row(n.settings.row)},focus:function(){return this.getEl().firstChild.focus(),this},row:function(t){return arguments.length?(this.state.set("row",t),this):this.state.get("row")},renderHtml:function(){return'<div id="'+this._id+'" class="'+this.classes+'">'+this._getDataPathHtml(this.state.get("row"))+"</div>"},bindStates:function(){var e=this;return e.state.on("change:row",function(t){e.innerHtml(e._getDataPathHtml(t.value))}),e._super()},_getDataPathHtml:function(t){var e,n,i=t||[],r="",o=this.classPrefix;for(e=0,n=i.length;e<n;e++)r+=(0<e?'<div class="'+o+'divider" aria-hidden="true"> '+this.settings.delimiter+" </div>":"")+'<div role="button" class="'+o+"path-item"+(e===n-1?" "+o+"last":"")+'" data-index="'+e+'" tabindex="-1" id="'+this._id+"-"+e+'" aria-level="'+(e+1)+'">'+i[e].name+"</div>";return r||(r='<div class="'+o+'path-item">\xa0</div>'),r}}),$n=Yn.extend({postRender:function(){var o=this,s=o.settings.editor;function a(t){if(1===t.nodeType){if("BR"===t.nodeName||t.getAttribute("data-mce-bogus"))return!0;if("bookmark"===t.getAttribute("data-mce-type"))return!0}return!1}return!1!==s.settings.elementpath&&(o.on("select",function(t){s.focus(),s.selection.select(this.row()[t.index].element),s.nodeChanged()}),s.on("nodeChange",function(t){for(var e=[],n=t.parents,i=n.length;i--;)if(1===n[i].nodeType&&!a(n[i])){var r=s.fire("ResolveName",{name:n[i].nodeName.toLowerCase(),target:n[i]});if(r.isDefaultPrevented()||e.push({name:r.name,element:n[i]}),r.isPropagationStopped())break}o.row(e)})),o._super()}}),Xn=Me.extend({Defaults:{layout:"flex",align:"center",defaults:{flex:1}},renderHtml:function(){var t=this,e=t._layout,n=t.classPrefix;return t.classes.add("formitem"),e.preRender(t),'<div id="'+t._id+'" class="'+t.classes+'" hidefocus="1" tabindex="-1">'+(t.settings.title?'<div id="'+t._id+'-title" class="'+n+'title">'+t.settings.title+"</div>":"")+'<div id="'+t._id+'-body" class="'+t.bodyClasses+'">'+(t.settings.html||"")+e.renderHtml(t)+"</div></div>"}}),jn=Me.extend({Defaults:{containerCls:"form",layout:"flex",direction:"column",align:"stretch",flex:1,padding:15,labelGap:30,spacing:10,callbacks:{submit:function(){this.submit()}}},preRender:function(){var i=this,t=i.items();i.settings.formItemDefaults||(i.settings.formItemDefaults={layout:"flex",autoResize:"overflow",defaults:{flex:1}}),t.each(function(t){var e,n=t.settings.label;n&&((e=new Xn(R.extend({items:{type:"label",id:t._id+"-l",text:n,flex:0,forId:t._id,disabled:t.disabled()}},i.settings.formItemDefaults))).type="formitem",t.aria("labelledby",t._id+"-l"),"undefined"==typeof t.settings.flex&&(t.settings.flex=1),i.replace(t,e),e.add(t))})},submit:function(){return this.fire("submit",{data:this.toJSON()})},postRender:function(){this._super(),this.fromJSON(this.settings.data)},bindStates:function(){var n=this;function t(){var t,e,i=0,r=[];if(!1!==n.settings.labelGapCalc)for(("children"===n.settings.labelGapCalc?n.find("formitem"):n.items()).filter("formitem").each(function(t){var e=t.items()[0],n=e.getEl().clientWidth;i=i<n?n:i,r.push(e)}),e=n.settings.labelGap||0,t=r.length;t--;)r[t].settings.minWidth=i+e}n._super(),n.on("show",t),t()}}),Jn=jn.extend({Defaults:{containerCls:"fieldset",layout:"flex",direction:"column",align:"stretch",flex:1,padding:"25 15 5 15",labelGap:30,spacing:10,border:1},renderHtml:function(){var t=this,e=t._layout,n=t.classPrefix;return t.preRender(),e.preRender(t),'<fieldset id="'+t._id+'" class="'+t.classes+'" hidefocus="1" tabindex="-1">'+(t.settings.title?'<legend id="'+t._id+'-title" class="'+n+'fieldset-title">'+t.settings.title+"</legend>":"")+'<div id="'+t._id+'-body" class="'+t.bodyClasses+'">'+(t.settings.html||"")+e.renderHtml(t)+"</div></fieldset>"}}),Gn=0,Kn=function(t){if(null===t||t===undefined)throw new Error("Node cannot be null or undefined");return{dom:lt(t)}},Zn={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 Kn(n.childNodes[0])},fromTag:function(t,e){var n=(e||_.document).createElement(t);return Kn(n)},fromText:function(t,e){var n=(e||_.document).createTextNode(t);return Kn(n)},fromDom:Kn,fromPoint:function(t,e,n){var i=t.dom();return mt.from(i.elementFromPoint(e,n)).map(Kn)}},Qn=(_.Node.ATTRIBUTE_NODE,_.Node.CDATA_SECTION_NODE,_.Node.COMMENT_NODE,_.Node.DOCUMENT_NODE),ti=(_.Node.DOCUMENT_TYPE_NODE,_.Node.DOCUMENT_FRAGMENT_NODE,_.Node.ELEMENT_NODE),ei=(_.Node.TEXT_NODE,_.Node.PROCESSING_INSTRUCTION_NODE,_.Node.ENTITY_REFERENCE_NODE,_.Node.ENTITY_NODE,_.Node.NOTATION_NODE,function(t,e){var n=function(t,e){for(var n=0;n<t.length;n++){var i=t[n];if(i.test(e))return i}return undefined}(t,e);if(!n)return{major:0,minor:0};var i=function(t){return Number(e.replace(n,"$"+t))};return ii(i(1),i(2))}),ni=function(){return ii(0,0)},ii=function(t,e){return{major:t,minor:e}},ri={nu:ii,detect:function(t,e){var n=String(e).toLowerCase();return 0===t.length?ni():ei(t,n)},unknown:ni},oi="Firefox",si=function(t,e){return function(){return e===t}},ai=function(t){var e=t.current;return{current:e,version:t.version,isEdge:si("Edge",e),isChrome:si("Chrome",e),isIE:si("IE",e),isOpera:si("Opera",e),isFirefox:si(oi,e),isSafari:si("Safari",e)}},li={unknown:function(){return ai({current:undefined,version:ri.unknown()})},nu:ai,edge:lt("Edge"),chrome:lt("Chrome"),ie:lt("IE"),opera:lt("Opera"),firefox:lt(oi),safari:lt("Safari")},ui="Windows",ci="Android",di="Solaris",fi="FreeBSD",hi=function(t,e){return function(){return e===t}},mi=function(t){var e=t.current;return{current:e,version:t.version,isWindows:hi(ui,e),isiOS:hi("iOS",e),isAndroid:hi(ci,e),isOSX:hi("OSX",e),isLinux:hi("Linux",e),isSolaris:hi(di,e),isFreeBSD:hi(fi,e)}},gi={unknown:function(){return mi({current:undefined,version:ri.unknown()})},nu:mi,windows:lt(ui),ios:lt("iOS"),android:lt(ci),linux:lt("Linux"),osx:lt("OSX"),solaris:lt(di),freebsd:lt(fi)},pi=function(t,e){var n=String(e).toLowerCase();return function(t,e){for(var n=0,i=t.length;n<i;n++){var r=t[n];if(e(r,n))return mt.some(r)}return mt.none()}(t,function(t){return t.search(n)})},vi=function(t,n){return pi(t,n).map(function(t){var e=ri.detect(t.versionRegexes,n);return{current:t.name,version:e}})},bi=function(t,n){return pi(t,n).map(function(t){var e=ri.detect(t.versionRegexes,n);return{current:t.name,version:e}})},yi=function(t,e){return-1!==t.indexOf(e)},xi=/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,wi=function(e){return function(t){return yi(t,e)}},_i=[{name:"Edge",versionRegexes:[/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],search:function(t){return yi(t,"edge/")&&yi(t,"chrome")&&yi(t,"safari")&&yi(t,"applewebkit")}},{name:"Chrome",versionRegexes:[/.*?chrome\/([0-9]+)\.([0-9]+).*/,xi],search:function(t){return yi(t,"chrome")&&!yi(t,"chromeframe")}},{name:"IE",versionRegexes:[/.*?msie\ ?([0-9]+)\.([0-9]+).*/,/.*?rv:([0-9]+)\.([0-9]+).*/],search:function(t){return yi(t,"msie")||yi(t,"trident")}},{name:"Opera",versionRegexes:[xi,/.*?opera\/([0-9]+)\.([0-9]+).*/],search:wi("opera")},{name:"Firefox",versionRegexes:[/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],search:wi("firefox")},{name:"Safari",versionRegexes:[xi,/.*?cpu os ([0-9]+)_([0-9]+).*/],search:function(t){return(yi(t,"safari")||yi(t,"mobile/"))&&yi(t,"applewebkit")}}],Ri=[{name:"Windows",search:wi("win"),versionRegexes:[/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]},{name:"iOS",search:function(t){return yi(t,"iphone")||yi(t,"ipad")},versionRegexes:[/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,/.*cpu os ([0-9]+)_([0-9]+).*/,/.*cpu iphone os ([0-9]+)_([0-9]+).*/]},{name:"Android",search:wi("android"),versionRegexes:[/.*?android\ ?([0-9]+)\.([0-9]+).*/]},{name:"OSX",search:wi("os x"),versionRegexes:[/.*?os\ x\ ?([0-9]+)_([0-9]+).*/]},{name:"Linux",search:wi("linux"),versionRegexes:[]},{name:"Solaris",search:wi("sunos"),versionRegexes:[]},{name:"FreeBSD",search:wi("freebsd"),versionRegexes:[]}],Ci={browsers:lt(_i),oses:lt(Ri)},ki=function(t){var e,n,i,r,o,s,a,l,u,c,d,f=Ci.browsers(),h=Ci.oses(),m=vi(f,t).fold(li.unknown,li.nu),g=bi(h,t).fold(gi.unknown,gi.nu);return{browser:m,os:g,deviceType:(n=m,i=t,r=(e=g).isiOS()&&!0===/ipad/i.test(i),o=e.isiOS()&&!r,s=e.isAndroid()&&3===e.version.major,a=e.isAndroid()&&4===e.version.major,l=r||s||a&&!0===/mobile/i.test(i),u=e.isiOS()||e.isAndroid(),c=u&&!l,d=n.isSafari()&&e.isiOS()&&!1===/safari/i.test(i),{isiPad:lt(r),isiPhone:lt(o),isTablet:lt(l),isPhone:lt(c),isTouch:lt(u),isAndroid:e.isAndroid,isiOS:e.isiOS,isWebView:lt(d)})}},Ei=(Je=!(Xe=function(){var t=_.navigator.userAgent;return ki(t)}),function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return Je||(Je=!0,je=Xe.apply(null,t)),je}),Hi=ti,Ti=Qn,Si=function(t){return t.nodeType!==Hi&&t.nodeType!==Ti||0===t.childElementCount},Mi=(Ei().browser.isIE(),function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e]}("element","offset"),R.trim),Ni=function(e){return function(t){if(t&&1===t.nodeType){if(t.contentEditable===e)return!0;if(t.getAttribute("data-mce-contenteditable")===e)return!0}return!1}},Oi=Ni("true"),Wi=Ni("false"),Pi=function(t,e,n,i,r){return{type:t,title:e,url:n,level:i,attach:r}},Di=function(t){return t.innerText||t.textContent},Ai=function(t){return t.id?t.id:(e="h",n=(new Date).getTime(),e+"_"+Math.floor(1e9*Math.random())+ ++Gn+String(n));var e,n},Bi=function(t){return(e=t)&&"A"===e.nodeName&&(e.id||e.name)&&Ii(t);var e},Li=function(t){return t&&/^(H[1-6])$/.test(t.nodeName)},Ii=function(t){return function(t){for(;t=t.parentNode;){var e=t.contentEditable;if(e&&"inherit"!==e)return Oi(t)}return!1}(t)&&!Wi(t)},zi=function(t){return Li(t)&&Ii(t)},Fi=function(t){var e,n=Ai(t);return Pi("header",Di(t),"#"+n,Li(e=t)?parseInt(e.nodeName.substr(1),10):0,function(){t.id=n})},Ui=function(t){var e=t.id||t.name,n=Di(t);return Pi("anchor",n||"#"+e,"#"+e,0,at)},Vi=function(t){var e,n,i,r,o,s;return e="h1,h2,h3,h4,h5,h6,a:not([href])",n=t,Rt((Ei().browser.isIE(),function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e]}("element","offset"),i=Zn.fromDom(n),r=e,s=(o=i)===undefined?_.document:o.dom(),Si(s)?[]:Rt(s.querySelectorAll(r),Zn.fromDom)),function(t){return t.dom()})},qi=function(t){return 0<Mi(t.title).length},Yi=function(t){var e,n=Vi(t);return kt((e=n,Rt(kt(e,zi),Fi)).concat(Rt(kt(n,Bi),Ui)),qi)},$i={},Xi=function(t){return{title:t.title,value:{title:{raw:t.title},url:t.url,attach:t.attach}}},ji=function(t,e){return{title:t,value:{title:t,url:e,attach:at}}},Ji=function(t,e,n){var i=e in t?t[e]:n;return!1===i?null:i},Gi=function(t,i,r,e){var n,o,s,a,l,u,c={title:"-"},d=function(t){var e=t.hasOwnProperty(r)?t[r]:[],n=kt(e,function(t){return e=t,!_t(i,function(t){return t.url===e});var e});return R.map(n,function(t){return{title:t,value:{title:t,url:t,attach:at}}})},f=function(e){var t,n=kt(i,function(t){return t.type===e});return t=n,R.map(t,Xi)};return!1===e.typeahead_urls?[]:"file"===r?(n=[Ki(t,d($i)),Ki(t,f("header")),Ki(t,(a=f("anchor"),l=Ji(e,"anchor_top","#top"),u=Ji(e,"anchor_bottom","#bottom"),null!==l&&a.unshift(ji("<top>",l)),null!==u&&a.push(ji("<bottom>",u)),a))],o=function(t,e){return 0===t.length||0===e.length?t.concat(e):t.concat(c,e)},s=[],Ct(n,function(t){s=o(s,t)}),s):Ki(t,d($i))},Ki=function(t,e){var n=t.toLowerCase(),i=R.grep(e,function(t){return-1!==t.title.toLowerCase().indexOf(n)});return 1===i.length&&i[0].title===t?[]:i},Zi=function(r,i,o,s){var e=function(t){var e=Yi(o),n=Gi(t,e,s,i);r.showAutoComplete(n,t)};r.on("autocomplete",function(){e(r.value())}),r.on("selectitem",function(t){var e=t.value;r.value(e.url);var n,i=(n=e.title).raw?n.raw:n;"image"===s?r.fire("change",{meta:{alt:i,attach:e.attach}}):r.fire("change",{meta:{text:i,attach:e.attach}}),r.focus()}),r.on("click",function(t){0===r.value().length&&"INPUT"===t.target.nodeName&&e("")}),r.on("PostRender",function(){r.getRoot().on("submit",function(t){var e,n,i;t.isDefaultPrevented()||(e=r.value(),i=$i[n=s],/^https?/.test(e)&&(i?wt(i,e).isNone()&&($i[n]=i.slice(0,5).concat(e)):$i[n]=[e]))})})},Qi=function(o,t,n){var i=t.filepicker_validator_handler;i&&o.state.on("change:value",function(t){var e;0!==(e=t.value).length?i({url:e,type:n},function(t){var e,n,i,r=(n=(e=t).status,i=e.message,"valid"===n?{status:"ok",message:i}:"unknown"===n?{status:"warn",message:i}:"invalid"===n?{status:"warn",message:i}:{status:"none",message:""});o.statusMessage(r.message),o.statusLevel(r.status)}):o.statusLevel("none")})},tr=Bn.extend({Statics:{clearHistory:function(){$i={}}},init:function(t){var e,n,i,r=this,o=window.tinymce?window.tinymce.activeEditor:M.activeEditor,s=o.settings,a=t.filetype;t.spellcheck=!1,(i=s.file_picker_types||s.file_browser_callback_types)&&(i=R.makeMap(i,/[, ]/)),i&&!i[a]||(!(n=s.file_picker_callback)||i&&!i[a]?!(n=s.file_browser_callback)||i&&!i[a]||(e=function(){n(r.getEl("inp").id,r.value(),a,window)}):e=function(){var t=r.fire("beforecall").meta;t=R.extend({filetype:a},t),n.call(o,function(t,e){r.value(t).fire("change",{meta:e})},r.value(),t)}),e&&(t.icon="browse",t.onaction=e),r._super(t),r.classes.add("filepicker"),Zi(r,s,o.getBody(),a),Qi(r,s,a)}}),er=Nn.extend({recalc:function(t){var e=t.layoutRect(),n=t.paddingBox;t.items().filter(":visible").each(function(t){t.layoutRect({x:n.left,y:n.top,w:e.innerW-n.right-n.left,h:e.innerH-n.top-n.bottom}),t.recalc&&t.recalc()})}}),nr=Nn.extend({recalc:function(t){var e,n,i,r,o,s,a,l,u,c,d,f,h,m,g,p,v,b,y,x,w,_,R,C,k,E,H,T,S,M,N,O,W,P,D,A,B,L=[],I=Math.max,z=Math.min;for(i=t.items().filter(":visible"),r=t.layoutRect(),o=t.paddingBox,s=t.settings,f=t.isRtl()?s.direction||"row-reversed":s.direction,a=s.align,l=t.isRtl()?s.pack||"end":s.pack,u=s.spacing||0,"row-reversed"!==f&&"column-reverse"!==f||(i=i.set(i.toArray().reverse()),f=f.split("-")[0]),"column"===f?(C="y",_="h",R="minH",k="maxH",H="innerH",E="top",T="deltaH",S="contentH",P="left",O="w",M="x",N="innerW",W="minW",D="right",A="deltaW",B="contentW"):(C="x",_="w",R="minW",k="maxW",H="innerW",E="left",T="deltaW",S="contentW",P="top",O="h",M="y",N="innerH",W="minH",D="bottom",A="deltaH",B="contentH"),d=r[H]-o[E]-o[E],w=c=0,e=0,n=i.length;e<n;e++)m=(h=i[e]).layoutRect(),d-=e<n-1?u:0,0<(g=h.settings.flex)&&(c+=g,m[k]&&L.push(h),m.flex=g),d-=m[R],w<(p=o[P]+m[W]+o[D])&&(w=p);if((y={})[R]=d<0?r[R]-d+r[T]:r[H]-d+r[T],y[W]=w+r[A],y[S]=r[H]-d,y[B]=w,y.minW=z(y.minW,r.maxW),y.minH=z(y.minH,r.maxH),y.minW=I(y.minW,r.startMinWidth),y.minH=I(y.minH,r.startMinHeight),!r.autoResize||y.minW===r.minW&&y.minH===r.minH){for(b=d/c,e=0,n=L.length;e<n;e++)(v=(m=(h=L[e]).layoutRect())[k])<(p=m[R]+m.flex*b)?(d-=m[k]-m[R],c-=m.flex,m.flex=0,m.maxFlexSize=v):m.maxFlexSize=0;for(b=d/c,x=o[E],y={},0===c&&("end"===l?x=d+o[E]:"center"===l?(x=Math.round(r[H]/2-(r[H]-d)/2)+o[E])<0&&(x=o[E]):"justify"===l&&(x=o[E],u=Math.floor(d/(i.length-1)))),y[M]=o[P],e=0,n=i.length;e<n;e++)p=(m=(h=i[e]).layoutRect()).maxFlexSize||m[R],"center"===a?y[M]=Math.round(r[N]/2-m[O]/2):"stretch"===a?(y[O]=I(m[W]||0,r[N]-o[P]-o[D]),y[M]=o[P]):"end"===a&&(y[M]=r[N]-m[O]-o.top),0<m.flex&&(p+=m.flex*b),y[_]=p,y[C]=x,h.layoutRect(y),h.recalc&&h.recalc(),x+=p+u}else if(y.w=y.minW,y.h=y.minH,t.layoutRect(y),this.recalc(t),null===t._lastRect){var F=t.parent();F&&(F._lastRect=null,F.recalc())}}}),ir=Mn.extend({Defaults:{containerClass:"flow-layout",controlClass:"flow-layout-item",endClass:"break"},recalc:function(t){t.items().filter(":visible").each(function(t){t.recalc&&t.recalc()})},isNative:function(){return!0}}),rr=function(t,e){return n=e,r=(i=t)===undefined?_.document:i.dom(),Si(r)?mt.none():mt.from(r.querySelector(n)).map(Zn.fromDom);var n,i,r},or=function(t,e){return function(){t.execCommand("mceToggleFormat",!1,e)}},sr=function(t,e,n){var i=function(t){n(t,e)};t.formatter?t.formatter.formatChanged(e,i):t.on("init",function(){t.formatter.formatChanged(e,i)})},ar=function(t,n){return function(e){sr(t,n,function(t){e.control.active(t)})}},lr=function(i){var e=["alignleft","aligncenter","alignright","alignjustify"],r="alignleft",t=[{text:"Left",icon:"alignleft",onclick:or(i,"alignleft")},{text:"Center",icon:"aligncenter",onclick:or(i,"aligncenter")},{text:"Right",icon:"alignright",onclick:or(i,"alignright")},{text:"Justify",icon:"alignjustify",onclick:or(i,"alignjustify")}];i.addMenuItem("align",{text:"Align",menu:t}),i.addButton("align",{type:"menubutton",icon:r,menu:t,onShowMenu:function(t){var n=t.control.menu;R.each(e,function(e,t){n.items().eq(t).each(function(t){return t.active(i.formatter.match(e))})})},onPostRender:function(t){var n=t.control;R.each(e,function(e,t){sr(i,e,function(t){n.icon(r),t&&n.icon(e)})})}}),R.each({alignleft:["Align left","JustifyLeft"],aligncenter:["Align center","JustifyCenter"],alignright:["Align right","JustifyRight"],alignjustify:["Justify","JustifyFull"],alignnone:["No alignment","JustifyNone"]},function(t,e){i.addButton(e,{active:!1,tooltip:t[0],cmd:t[1],onPostRender:ar(i,e)})})},ur=function(t){return t?t.split(",")[0]:""},cr=function(l,u){return function(){var a=this;a.state.set("value",null),l.on("init nodeChange",function(t){var e,n,i,r,o=l.queryCommandValue("FontName"),s=(e=u,r=(n=o)?n.toLowerCase():"",R.each(e,function(t){t.value.toLowerCase()===r&&(i=t.value)}),R.each(e,function(t){i||ur(t.value).toLowerCase()!==ur(r).toLowerCase()||(i=t.value)}),i);a.value(s||null),!s&&o&&a.text(ur(o))})}},dr=function(n){n.addButton("fontselect",function(){var t,e=(t=function(t){for(var e=(t=t.replace(/;$/,"").split(";")).length;e--;)t[e]=t[e].split("=");return t}(n.settings.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"),R.map(t,function(t){return{text:{raw:t[0]},value:t[1],textStyle:-1===t[1].indexOf("dings")?"font-family:"+t[1]:""}}));return{type:"listbox",text:"Font Family",tooltip:"Font Family",values:e,fixedWidth:!0,onPostRender:cr(n,e),onselect:function(t){t.control.settings.value&&n.execCommand("FontName",!1,t.control.settings.value)}}})},fr=function(t){dr(t)},hr=function(t,e){return/[0-9.]+px$/.test(t)?(n=72*parseInt(t,10)/96,i=e||0,r=Math.pow(10,i),Math.round(n*r)/r+"pt"):t;var n,i,r},mr=function(t,e,n){var i;return R.each(t,function(t){t.value===n?i=n:t.value===e&&(i=e)}),i},gr=function(n){n.addButton("fontsizeselect",function(){var t,s,a,e=(t=n.settings.fontsize_formats||"8pt 10pt 12pt 14pt 18pt 24pt 36pt",R.map(t.split(" "),function(t){var e=t,n=t,i=t.split("=");return 1<i.length&&(e=i[0],n=i[1]),{text:e,value:n}}));return{type:"listbox",text:"Font Sizes",tooltip:"Font Sizes",values:e,fixedWidth:!0,onPostRender:(s=n,a=e,function(){var o=this;s.on("init nodeChange",function(t){var e,n,i,r;if(e=s.queryCommandValue("FontSize"))for(i=3;!r&&0<=i;i--)n=hr(e,i),r=mr(a,n,e);o.value(r||null),r||o.text(n)})}),onclick:function(t){t.control.settings.value&&n.execCommand("FontSize",!1,t.control.settings.value)}}})},pr=function(t){gr(t)},vr=function(n,t){var i=t.length;return R.each(t,function(t){t.menu&&(t.hidden=0===vr(n,t.menu));var e=t.format;e&&(t.hidden=!n.formatter.canApply(e)),t.hidden&&i--}),i},br=function(n,t){var i=t.items().length;return t.items().each(function(t){t.menu&&t.visible(0<br(n,t.menu)),!t.menu&&t.settings.menu&&t.visible(0<vr(n,t.settings.menu));var e=t.settings.format;e&&t.visible(n.formatter.canApply(e)),t.visible()||i--}),i},yr=function(t){var i,r,o,e,s,n,a,l,u=(r=0,o=[],e=[{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"}]}],s=function(t){var i=[];if(t)return R.each(t,function(t){var e={text:t.title,icon:t.icon};if(t.items)e.menu=s(t.items);else{var n=t.format||"custom"+r++;t.format||(t.name=n,o.push(t)),e.format=n,e.cmd=t.cmd}i.push(e)}),i},(i=t).on("init",function(){R.each(o,function(t){i.formatter.register(t.name,t)})}),{type:"menu",items:i.settings.style_formats_merge?i.settings.style_formats?s(e.concat(i.settings.style_formats)):s(e):s(i.settings.style_formats||e),onPostRender:function(t){i.fire("renderFormatsMenu",{control:t.control})},itemDefaults:{preview:!0,textStyle:function(){if(this.settings.format)return i.formatter.getCssText(this.settings.format)},onPostRender:function(){var n=this;n.parent().on("show",function(){var t,e;(t=n.settings.format)&&(n.disabled(!i.formatter.canApply(t)),n.active(i.formatter.match(t))),(e=n.settings.cmd)&&n.active(i.queryCommandState(e))})},onclick:function(){this.settings.format&&or(i,this.settings.format)(),this.settings.cmd&&i.execCommand(this.settings.cmd)}}});n=u,t.addMenuItem("formats",{text:"Formats",menu:n}),l=u,(a=t).addButton("styleselect",{type:"menubutton",text:"Formats",menu:l,onShowMenu:function(){a.settings.style_formats_autohide&&br(a,this.menu)}})},xr=function(n,t){return function(){var r,o,s,e=[];return R.each(t,function(t){e.push({text:t[0],value:t[1],textStyle:function(){return n.formatter.getCssText(t[1])}})}),{type:"listbox",text:t[0][0],values:e,fixedWidth:!0,onselect:function(t){if(t.control){var e=t.control.value();or(n,e)()}},onPostRender:(r=n,o=e,function(){var e=this;r.on("nodeChange",function(t){var n=r.formatter,i=null;R.each(t.parents,function(e){if(R.each(o,function(t){if(s?n.matchNode(e,s,{value:t.value})&&(i=t.value):n.matchNode(e,t.value)&&(i=t.value),i)return!1}),i)return!1}),e.value(i)})})}}},wr=function(t){var e,n,i=function(t){for(var e=(t=t.replace(/;$/,"").split(";")).length;e--;)t[e]=t[e].split("=");return t}(t.settings.block_formats||"Paragraph=p;Heading 1=h1;Heading 2=h2;Heading 3=h3;Heading 4=h4;Heading 5=h5;Heading 6=h6;Preformatted=pre");t.addMenuItem("blockformats",{text:"Blocks",menu:(e=t,n=i,R.map(n,function(t){return{text:t[0],onclick:or(e,t[1]),textStyle:function(){return e.formatter.getCssText(t[1])}}}))}),t.addButton("formatselect",xr(t,i))},_r=function(e,t){var n,i;if("string"==typeof t)i=t.split(" ");else if(R.isArray(t))return function(t){for(var e=[],n=0,i=t.length;n<i;++n){if(!pt(t[n]))throw new Error("Arr.flatten item "+n+" was not an array, input: "+t);xt.apply(e,t[n])}return e}(R.map(t,function(t){return _r(e,t)}));return n=R.grep(i,function(t){return"|"===t||t in e.menuItems}),R.map(n,function(t){return"|"===t?{text:"-"}:e.menuItems[t]})},Rr=function(t){return t&&"-"===t.text},Cr=function(n){var i=kt(n,function(t,e){return!Rr(t)||!Rr(n[e-1])});return kt(i,function(t,e){return!Rr(t)||0<e&&e<i.length-1})},kr=function(t){var e,n,i,r,o=t.settings.insert_button_items;return Cr(o?_r(t,o):(e=t,n="insert",i=[{text:"-"}],r=R.grep(e.menuItems,function(t){return t.context===n}),R.each(r,function(t){"before"===t.separator&&i.push({text:"|"}),t.prependToContext?i.unshift(t):i.push(t),"after"===t.separator&&i.push({text:"|"})}),i))},Er=function(t){var e;(e=t).addButton("insert",{type:"menubutton",icon:"insert",menu:[],oncreatemenu:function(){this.menu.add(kr(e)),this.menu.renderNew()}})},Hr=function(t){var n,i,r;n=t,R.each({bold:"Bold",italic:"Italic",underline:"Underline",strikethrough:"Strikethrough",subscript:"Subscript",superscript:"Superscript"},function(t,e){n.addButton(e,{active:!1,tooltip:t,onPostRender:ar(n,e),onclick:or(n,e)})}),i=t,R.each({outdent:["Decrease indent","Outdent"],indent:["Increase indent","Indent"],cut:["Cut","Cut"],copy:["Copy","Copy"],paste:["Paste","Paste"],help:["Help","mceHelp"],selectall:["Select all","SelectAll"],visualaid:["Visual aids","mceToggleVisualAid"],newdocument:["New document","mceNewDocument"],removeformat:["Clear formatting","RemoveFormat"],remove:["Remove","Delete"]},function(t,e){i.addButton(e,{tooltip:t[0],cmd:t[1]})}),r=t,R.each({blockquote:["Blockquote","mceBlockQuote"],subscript:["Subscript","Subscript"],superscript:["Superscript","Superscript"]},function(t,e){r.addButton(e,{active:!1,tooltip:t[0],cmd:t[1],onPostRender:ar(r,e)})})},Tr=function(t){var n;Hr(t),n=t,R.each({bold:["Bold","Bold","Meta+B"],italic:["Italic","Italic","Meta+I"],underline:["Underline","Underline","Meta+U"],strikethrough:["Strikethrough","Strikethrough"],subscript:["Subscript","Subscript"],superscript:["Superscript","Superscript"],removeformat:["Clear formatting","RemoveFormat"],newdocument:["New document","mceNewDocument"],cut:["Cut","Cut","Meta+X"],copy:["Copy","Copy","Meta+C"],paste:["Paste","Paste","Meta+V"],selectall:["Select all","SelectAll","Meta+A"]},function(t,e){n.addMenuItem(e,{text:t[0],icon:e,shortcut:t[2],cmd:t[1]})}),n.addMenuItem("codeformat",{text:"Code",icon:"code",onclick:or(n,"code")})},Sr=function(n,i){return function(){var t=this,e=function(){var t="redo"===i?"hasRedo":"hasUndo";return!!n.undoManager&&n.undoManager[t]()};t.disabled(!e()),n.on("Undo Redo AddUndo TypingUndo ClearUndos SwitchMode",function(){t.disabled(n.readonly||!e())})}},Mr=function(t){var e,n;(e=t).addMenuItem("undo",{text:"Undo",icon:"undo",shortcut:"Meta+Z",onPostRender:Sr(e,"undo"),cmd:"undo"}),e.addMenuItem("redo",{text:"Redo",icon:"redo",shortcut:"Meta+Y",onPostRender:Sr(e,"redo"),cmd:"redo"}),(n=t).addButton("undo",{tooltip:"Undo",onPostRender:Sr(n,"undo"),cmd:"undo"}),n.addButton("redo",{tooltip:"Redo",onPostRender:Sr(n,"redo"),cmd:"redo"})},Nr=function(t){var e,n;(e=t).addMenuItem("visualaid",{text:"Visual aids",selectable:!0,onPostRender:(n=e,function(){var e=this;n.on("VisualAid",function(t){e.active(t.hasVisual)}),e.active(n.hasVisual)}),cmd:"mceToggleVisualAid"})},Or={setup:function(t){var e;t.rtl&&(ae.rtl=!0),t.on("mousedown progressstate",function(){ze.hideAll()}),(e=t).settings.ui_container&&(h.container=rr(Zn.fromDom(_.document.body),e.settings.ui_container).fold(lt(null),function(t){return t.dom()})),ge.tooltips=!h.iOS,ae.translate=function(t){return M.translate(t)},wr(t),lr(t),Tr(t),Mr(t),pr(t),fr(t),yr(t),Nr(t),Er(t)}},Wr=Nn.extend({recalc:function(t){var e,n,i,r,o,s,a,l,u,c,d,f,h,m,g,p,v,b,y,x,w,_,R,C,k,E,H,T,S=[],M=[];e=t.settings,r=t.items().filter(":visible"),o=t.layoutRect(),i=e.columns||Math.ceil(Math.sqrt(r.length)),n=Math.ceil(r.length/i),b=e.spacingH||e.spacing||0,y=e.spacingV||e.spacing||0,x=e.alignH||e.align,w=e.alignV||e.align,p=t.paddingBox,T="reverseRows"in e?e.reverseRows:t.isRtl(),x&&"string"==typeof x&&(x=[x]),w&&"string"==typeof w&&(w=[w]);for(d=0;d<i;d++)S.push(0);for(f=0;f<n;f++)M.push(0);for(f=0;f<n;f++)for(d=0;d<i&&(c=r[f*i+d]);d++)C=(u=c.layoutRect()).minW,k=u.minH,S[d]=C>S[d]?C:S[d],M[f]=k>M[f]?k:M[f];for(E=o.innerW-p.left-p.right,d=_=0;d<i;d++)_+=S[d]+(0<d?b:0),E-=(0<d?b:0)+S[d];for(H=o.innerH-p.top-p.bottom,f=R=0;f<n;f++)R+=M[f]+(0<f?y:0),H-=(0<f?y:0)+M[f];if(_+=p.left+p.right,R+=p.top+p.bottom,(l={}).minW=_+(o.w-o.innerW),l.minH=R+(o.h-o.innerH),l.contentW=l.minW-o.deltaW,l.contentH=l.minH-o.deltaH,l.minW=Math.min(l.minW,o.maxW),l.minH=Math.min(l.minH,o.maxH),l.minW=Math.max(l.minW,o.startMinWidth),l.minH=Math.max(l.minH,o.startMinHeight),!o.autoResize||l.minW===o.minW&&l.minH===o.minH){var N;o.autoResize&&((l=t.layoutRect(l)).contentW=l.minW-o.deltaW,l.contentH=l.minH-o.deltaH),N="start"===e.packV?0:0<H?Math.floor(H/n):0;var O=0,W=e.flexWidths;if(W)for(d=0;d<W.length;d++)O+=W[d];else O=i;var P=E/O;for(d=0;d<i;d++)S[d]+=W?W[d]*P:P;for(m=p.top,f=0;f<n;f++){for(h=p.left,a=M[f]+N,d=0;d<i&&(c=r[T?f*i+i-1-d:f*i+d]);d++)g=c.settings,u=c.layoutRect(),s=Math.max(S[d],u.startMinWidth),u.x=h,u.y=m,"center"===(v=g.alignH||(x?x[d]||x[0]:null))?u.x=h+s/2-u.w/2:"right"===v?u.x=h+s-u.w:"stretch"===v&&(u.w=s),"center"===(v=g.alignV||(w?w[d]||w[0]:null))?u.y=m+a/2-u.h/2:"bottom"===v?u.y=m+a-u.h:"stretch"===v&&(u.h=a),c.layoutRect(u),h+=s+b,c.recalc&&c.recalc();m+=a+y}}else if(l.w=l.minW,l.h=l.minH,t.layoutRect(l),this.recalc(t),null===t._lastRect){var D=t.parent();D&&(D._lastRect=null,D.recalc())}}}),Pr=ge.extend({renderHtml:function(){var t=this;return t.classes.add("iframe"),t.canFocus=!1,'<iframe id="'+t._id+'" class="'+t.classes+'" tabindex="-1" src="'+(t.settings.url||"javascript:''")+'" frameborder="0"></iframe>'},src:function(t){this.getEl().src=t},html:function(t,e){var n=this,i=this.getEl().contentWindow.document.body;return i?(i.innerHTML=t,e&&e()):c.setTimeout(function(){n.html(t)}),this}}),Dr=ge.extend({init:function(t){this._super(t),this.classes.add("widget").add("infobox"),this.canFocus=!1},severity:function(t){this.classes.remove("error"),this.classes.remove("warning"),this.classes.remove("success"),this.classes.add(t)},help:function(t){this.state.set("help",t)},renderHtml:function(){var t=this,e=t.classPrefix;return'<div id="'+t._id+'" class="'+t.classes+'"><div id="'+t._id+'-body">'+t.encode(t.state.get("text"))+'<button role="button" tabindex="-1"><i class="'+e+"ico "+e+'i-help"></i></button></div></div>'},bindStates:function(){var e=this;return e.state.on("change:text",function(t){e.getEl("body").firstChild.data=e.encode(t.value),e.state.get("rendered")&&e.updateLayoutRect()}),e.state.on("change:help",function(t){e.classes.toggle("has-help",t.value),e.state.get("rendered")&&e.updateLayoutRect()}),e._super()}}),Ar=ge.extend({init:function(t){var e=this;e._super(t),e.classes.add("widget").add("label"),e.canFocus=!1,t.multiline&&e.classes.add("autoscroll"),t.strong&&e.classes.add("strong")},initLayoutRect:function(){var t=this,e=t._super();return t.settings.multiline&&(Ht.getSize(t.getEl()).width>e.maxW&&(e.minW=e.maxW,t.classes.add("multiline")),t.getEl().style.width=e.minW+"px",e.startMinH=e.h=e.minH=Math.min(e.maxH,Ht.getSize(t.getEl()).height)),e},repaint:function(){return this.settings.multiline||(this.getEl().style.lineHeight=this.layoutRect().h+"px"),this._super()},severity:function(t){this.classes.remove("error"),this.classes.remove("warning"),this.classes.remove("success"),this.classes.add(t)},renderHtml:function(){var t,e,n=this,i=n.settings.forId,r=n.settings.html?n.settings.html:n.encode(n.state.get("text"));return!i&&(e=n.settings.forName)&&(t=n.getRoot().find("#"+e)[0])&&(i=t._id),i?'<label id="'+n._id+'" class="'+n.classes+'"'+(i?' for="'+i+'"':"")+">"+r+"</label>":'<span id="'+n._id+'" class="'+n.classes+'">'+r+"</span>"},bindStates:function(){var e=this;return e.state.on("change:text",function(t){e.innerHtml(e.encode(t.value)),e.state.get("rendered")&&e.updateLayoutRect()}),e._super()}}),Br=Me.extend({Defaults:{role:"toolbar",layout:"flow"},init:function(t){this._super(t),this.classes.add("toolbar")},postRender:function(){return this.items().each(function(t){t.classes.add("toolbar-item")}),this._super()}}),Lr=Br.extend({Defaults:{role:"menubar",containerCls:"menubar",ariaRoot:!0,defaults:{type:"menubutton"}}}),Ir=On.extend({init:function(t){var e=this;e._renderOpen=!0,e._super(t),t=e.settings,e.classes.add("menubtn"),t.fixedWidth&&e.classes.add("fixed-width"),e.aria("haspopup",!0),e.state.set("menu",t.menu||e.render())},showMenu:function(t){var e,n=this;if(n.menu&&n.menu.visible()&&!1!==t)return n.hideMenu();n.menu||(e=n.state.get("menu")||[],n.classes.add("opened"),e.length?e={type:"menu",animate:!0,items:e}:(e.type=e.type||"menu",e.animate=!0),e.renderTo?n.menu=e.parent(n).show().renderTo():n.menu=_e.create(e).parent(n).renderTo(),n.fire("createmenu"),n.menu.reflow(),n.menu.on("cancel",function(t){t.control.parent()===n.menu&&(t.stopPropagation(),n.focus(),n.hideMenu())}),n.menu.on("select",function(){n.focus()}),n.menu.on("show hide",function(t){"hide"===t.type&&t.control.parent()===n&&n.classes.remove("opened-under"),t.control===n.menu&&(n.activeMenu("show"===t.type),n.classes.toggle("opened","show"===t.type)),n.aria("expanded","show"===t.type)}).fire("show")),n.menu.show(),n.menu.layoutRect({w:n.layoutRect().w}),n.menu.repaint(),n.menu.moveRel(n.getEl(),n.isRtl()?["br-tr","tr-br"]:["bl-tl","tl-bl"]);var i=n.menu.layoutRect(),r=n.$el.offset().top+n.layoutRect().h;r>i.y&&r<i.y+i.h&&n.classes.add("opened-under"),n.fire("showmenu")},hideMenu:function(){this.menu&&(this.menu.items().each(function(t){t.hideMenu&&t.hideMenu()}),this.menu.hide())},activeMenu:function(t){this.classes.toggle("active",t)},renderHtml:function(){var t,e=this,n=e._id,i=e.classPrefix,r=e.settings.icon,o=e.state.get("text"),s="";return(t=e.settings.image)?(r="none","string"!=typeof t&&(t=_.window.getSelection?t[0]:t[1]),t=" style=\"background-image: url('"+t+"')\""):t="",o&&(e.classes.add("btn-has-text"),s='<span class="'+i+'txt">'+e.encode(o)+"</span>"),r=e.settings.icon?i+"ico "+i+"i-"+r:"",e.aria("role",e.parent()instanceof Lr?"menuitem":"button"),'<div id="'+n+'" class="'+e.classes+'" tabindex="-1" aria-labelledby="'+n+'"><button id="'+n+'-open" role="presentation" type="button" tabindex="-1">'+(r?'<i class="'+r+'"'+t+"></i>":"")+s+' <i class="'+i+'caret"></i></button></div>'},postRender:function(){var r=this;return r.on("click",function(t){t.control===r&&function(t,e){for(;t;){if(e===t)return!0;t=t.parentNode}return!1}(t.target,r.getEl())&&(r.focus(),r.showMenu(!t.aria),t.aria&&r.menu.items().filter(":visible")[0].focus())}),r.on("mouseenter",function(t){var e,n=t.control,i=r.parent();n&&i&&n instanceof Ir&&n.parent()===i&&(i.items().filter("MenuButton").each(function(t){t.hideMenu&&t!==n&&(t.menu&&t.menu.visible()&&(e=!0),t.hideMenu())}),e&&(n.focus(),n.showMenu()))}),r._super()},bindStates:function(){var t=this;return t.state.on("change:menu",function(){t.menu&&t.menu.remove(),t.menu=null}),t._super()},remove:function(){this._super(),this.menu&&this.menu.remove()}});function zr(i,r){var o,s,a=this,l=ae.classPrefix;a.show=function(t,e){function n(){o&&(Tt(i).append('<div class="'+l+"throbber"+(r?" "+l+"throbber-inline":"")+'"></div>'),e&&e())}return a.hide(),o=!0,t?s=c.setTimeout(n,t):n(),a},a.hide=function(){var t=i.lastChild;return c.clearTimeout(s),t&&-1!==t.className.indexOf("throbber")&&t.parentNode.removeChild(t),o=!1,a}}var Fr=ze.extend({Defaults:{defaultType:"menuitem",border:1,layout:"stack",role:"application",bodyRole:"menu",ariaRoot:!0},init:function(t){if(t.autohide=!0,t.constrainToViewport=!0,"function"==typeof t.items&&(t.itemsFactory=t.items,t.items=[]),t.itemDefaults)for(var e=t.items,n=e.length;n--;)e[n]=R.extend({},t.itemDefaults,e[n]);this._super(t),this.classes.add("menu"),t.animate&&11!==h.ie&&this.classes.add("animate")},repaint:function(){return this.classes.toggle("menu-align",!0),this._super(),this.getEl().style.height="",this.getEl("body").style.height="",this},cancel:function(){this.hideAll(),this.fire("select")},load:function(){var e,n=this;function i(){n.throbber&&(n.throbber.hide(),n.throbber=null)}n.settings.itemsFactory&&(n.throbber||(n.throbber=new zr(n.getEl("body"),!0),0===n.items().length?(n.throbber.show(),n.fire("loading")):n.throbber.show(100,function(){n.items().remove(),n.fire("loading")}),n.on("hide close",i)),n.requestTime=e=(new Date).getTime(),n.settings.itemsFactory(function(t){0!==t.length?n.requestTime===e&&(n.getEl().style.width="",n.getEl("body").style.width="",i(),n.items().remove(),n.getEl("body").innerHTML="",n.add(t),n.renderNew(),n.fire("loaded")):n.hide()}))},hideAll:function(){return this.find("menuitem").exec("hideMenu"),this._super()},preRender:function(){var n=this;return n.items().each(function(t){var e=t.settings;if(e.icon||e.image||e.selectable)return!(n._hasIcons=!0)}),n.settings.itemsFactory&&n.on("postrender",function(){n.settings.itemsFactory&&n.load()}),n.on("show hide",function(t){t.control===n&&("show"===t.type?c.setTimeout(function(){n.classes.add("in")},0):n.classes.remove("in"))}),n._super()}}),Ur=Ir.extend({init:function(i){var e,r,o,n,s=this;s._super(i),i=s.settings,s._values=e=i.values,e&&("undefined"!=typeof i.value&&function t(e){for(var n=0;n<e.length;n++){if(r=e[n].selected||i.value===e[n].value)return o=o||e[n].text,s.state.set("value",e[n].value),!0;if(e[n].menu&&t(e[n].menu))return!0}}(e),!r&&0<e.length&&(o=e[0].text,s.state.set("value",e[0].value)),s.state.set("menu",e)),s.state.set("text",i.text||o),s.classes.add("listbox"),s.on("select",function(t){var e=t.control;n&&(t.lastControl=n),i.multiple?e.active(!e.active()):s.value(t.control.value()),n=e})},value:function(n){return 0===arguments.length?this.state.get("value"):(void 0===n||(this.settings.values&&!function e(t){return _t(t,function(t){return t.menu?e(t.menu):t.value===n})}(this.settings.values)?null===n&&this.state.set("value",null):this.state.set("value",n)),this)},bindStates:function(){var i=this;return i.on("show",function(t){var e,n;e=t.control,n=i.value(),e instanceof Fr&&e.items().each(function(t){t.hasMenus()||t.active(t.value()===n)})}),i.state.on("change:value",function(e){var n=function t(e,n){var i;if(e)for(var r=0;r<e.length;r++){if(e[r].value===n)return e[r];if(e[r].menu&&(i=t(e[r].menu,n)))return i}}(i.state.get("menu"),e.value);n?i.text(n.text):i.text(i.settings.text)}),i._super()}}),Vr=ge.extend({Defaults:{border:0,role:"menuitem"},init:function(t){var e,n=this;n._super(t),t=n.settings,n.classes.add("menu-item"),t.menu&&n.classes.add("menu-item-expand"),t.preview&&n.classes.add("menu-item-preview"),"-"!==(e=n.state.get("text"))&&"|"!==e||(n.classes.add("menu-item-sep"),n.aria("role","separator"),n.state.set("text","-")),t.selectable&&(n.aria("role","menuitemcheckbox"),n.classes.add("menu-item-checkbox"),t.icon="selected"),t.preview||t.selectable||n.classes.add("menu-item-normal"),n.on("mousedown",function(t){t.preventDefault()}),t.menu&&!t.ariaHideMenu&&n.aria("haspopup",!0)},hasMenus:function(){return!!this.settings.menu},showMenu:function(){var e,n=this,t=n.settings,i=n.parent();if(i.items().each(function(t){t!==n&&t.hideMenu()}),t.menu){(e=n.menu)?e.show():((e=t.menu).length?e={type:"menu",items:e}:e.type=e.type||"menu",i.settings.itemDefaults&&(e.itemDefaults=i.settings.itemDefaults),(e=n.menu=_e.create(e).parent(n).renderTo()).reflow(),e.on("cancel",function(t){t.stopPropagation(),n.focus(),e.hide()}),e.on("show hide",function(t){t.control.items&&t.control.items().each(function(t){t.active(t.settings.selected)})}).fire("show"),e.on("hide",function(t){t.control===e&&n.classes.remove("selected")}),e.submenu=!0),e._parentMenu=i,e.classes.add("menu-sub");var r=e.testMoveRel(n.getEl(),n.isRtl()?["tl-tr","bl-br","tr-tl","br-bl"]:["tr-tl","br-bl","tl-tr","bl-br"]);e.moveRel(n.getEl(),r),r="menu-sub-"+(e.rel=r),e.classes.remove(e._lastRel).add(r),e._lastRel=r,n.classes.add("selected"),n.aria("expanded",!0)}},hideMenu:function(){var t=this;return t.menu&&(t.menu.items().each(function(t){t.hideMenu&&t.hideMenu()}),t.menu.hide(),t.aria("expanded",!1)),t},renderHtml:function(){var t,e=this,n=e._id,i=e.settings,r=e.classPrefix,o=e.state.get("text"),s=e.settings.icon,a="",l=i.shortcut,u=e.encode(i.url);function c(t){return t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function d(t){var e=i.match||"";return e?t.replace(new RegExp(c(e),"gi"),function(t){return"!mce~match["+t+"]mce~match!"}):t}function f(t){return t.replace(new RegExp(c("!mce~match["),"g"),"<b>").replace(new RegExp(c("]mce~match!"),"g"),"</b>")}return s&&e.parent().classes.add("menu-has-icons"),i.image&&(a=" style=\"background-image: url('"+i.image+"')\""),l&&(l=function(t){var e,n,i={};for(i=h.mac?{alt:"&#x2325;",ctrl:"&#x2318;",shift:"&#x21E7;",meta:"&#x2318;"}:{meta:"Ctrl"},t=t.split("+"),e=0;e<t.length;e++)(n=i[t[e].toLowerCase()])&&(t[e]=n);return t.join("+")}(l)),s=r+"ico "+r+"i-"+(e.settings.icon||"none"),t="-"!==o?'<i class="'+s+'"'+a+"></i>\xa0":"",o=f(e.encode(d(o))),u=f(e.encode(d(u))),'<div id="'+n+'" class="'+e.classes+'" tabindex="-1">'+t+("-"!==o?'<span id="'+n+'-text" class="'+r+'text">'+o+"</span>":"")+(l?'<div id="'+n+'-shortcut" class="'+r+'menu-shortcut">'+l+"</div>":"")+(i.menu?'<div class="'+r+'caret"></div>':"")+(u?'<div class="'+r+'menu-item-link">'+u+"</div>":"")+"</div>"},postRender:function(){var e=this,n=e.settings,t=n.textStyle;if("function"==typeof t&&(t=t.call(this)),t){var i=e.getEl("text");i&&(i.setAttribute("style",t),e._textStyle=t)}return e.on("mouseenter click",function(t){t.control===e&&(n.menu||"click"!==t.type?(e.showMenu(),t.aria&&e.menu.focus(!0)):(e.fire("select"),c.requestAnimationFrame(function(){e.parent().hideAll()})))}),e._super(),e},hover:function(){return this.parent().items().each(function(t){t.classes.remove("selected")}),this.classes.toggle("selected",!0),this},active:function(t){return function(t,e){var n=t._textStyle;if(n){var i=t.getEl("text");i.setAttribute("style",n),e&&(i.style.color="",i.style.backgroundColor="")}}(this,t),void 0!==t&&this.aria("checked",t),this._super(t)},remove:function(){this._super(),this.menu&&this.menu.remove()}}),qr=Dn.extend({Defaults:{classes:"radio",role:"radio"}}),Yr=ge.extend({renderHtml:function(){var t=this,e=t.classPrefix;return t.classes.add("resizehandle"),"both"===t.settings.direction&&t.classes.add("resizehandle-both"),t.canFocus=!1,'<div id="'+t._id+'" class="'+t.classes+'"><i class="'+e+"ico "+e+'i-resize"></i></div>'},postRender:function(){var e=this;e._super(),e.resizeDragHelper=new we(this._id,{start:function(){e.fire("ResizeStart")},drag:function(t){"both"!==e.settings.direction&&(t.deltaX=0),e.fire("Resize",t)},stop:function(){e.fire("ResizeEnd")}})},remove:function(){return this.resizeDragHelper&&this.resizeDragHelper.destroy(),this._super()}});function $r(t){var e="";if(t)for(var n=0;n<t.length;n++)e+='<option value="'+t[n]+'">'+t[n]+"</option>";return e}var Xr=ge.extend({Defaults:{classes:"selectbox",role:"selectbox",options:[]},init:function(t){var n=this;n._super(t),n.settings.size&&(n.size=n.settings.size),n.settings.options&&(n._options=n.settings.options),n.on("keydown",function(t){var e;13===t.keyCode&&(t.preventDefault(),n.parents().reverse().each(function(t){if(t.toJSON)return e=t,!1}),n.fire("submit",{data:e.toJSON()}))})},options:function(t){return arguments.length?(this.state.set("options",t),this):this.state.get("options")},renderHtml:function(){var t,e=this,n="";return t=$r(e._options),e.size&&(n=' size = "'+e.size+'"'),'<select id="'+e._id+'" class="'+e.classes+'"'+n+">"+t+"</select>"},bindStates:function(){var e=this;return e.state.on("change:options",function(t){e.getEl().innerHTML=$r(t.value)}),e._super()}});function jr(t,e,n){return t<e&&(t=e),n<t&&(t=n),t}function Jr(t,e,n){t.setAttribute("aria-"+e,n)}function Gr(t,e){var n,i,r,o,s;"v"===t.settings.orientation?(r="top",i="height",n="h"):(r="left",i="width",n="w"),s=t.getEl("handle"),o=((t.layoutRect()[n]||100)-Ht.getSize(s)[i])*((e-t._minValue)/(t._maxValue-t._minValue))+"px",s.style[r]=o,s.style.height=t.layoutRect().h+"px",Jr(s,"valuenow",e),Jr(s,"valuetext",""+t.settings.previewFilter(e)),Jr(s,"valuemin",t._minValue),Jr(s,"valuemax",t._maxValue)}var Kr=ge.extend({init:function(t){var e=this;t.previewFilter||(t.previewFilter=function(t){return Math.round(100*t)/100}),e._super(t),e.classes.add("slider"),"v"===t.orientation&&e.classes.add("vertical"),e._minValue=bt(t.minValue)?t.minValue:0,e._maxValue=bt(t.maxValue)?t.maxValue:100,e._initValue=e.state.get("value")},renderHtml:function(){var t=this._id,e=this.classPrefix;return'<div id="'+t+'" class="'+this.classes+'"><div id="'+t+'-handle" class="'+e+'slider-handle" role="slider" tabindex="-1"></div></div>'},reset:function(){this.value(this._initValue).repaint()},postRender:function(){var t,e,n,i,r,o,s,a,l,u,c,d,f,h,m=this;t=m._minValue,e=m._maxValue,"v"===m.settings.orientation?(n="screenY",i="top",r="height",o="h"):(n="screenX",i="left",r="width",o="w"),m._super(),function(o,s){function e(t){var e,n,i,r;e=jr(e=(((e=m.value())+(r=n=o))/((i=s)-r)+.05*t)*(i-n)-n,o,s),m.value(e),m.fire("dragstart",{value:e}),m.fire("drag",{value:e}),m.fire("dragend",{value:e})}m.on("keydown",function(t){switch(t.keyCode){case 37:case 38:e(-1);break;case 39:case 40:e(1)}})}(t,e),s=t,a=e,l=m.getEl("handle"),m._dragHelper=new we(m._id,{handle:m._id+"-handle",start:function(t){u=t[n],c=parseInt(m.getEl("handle").style[i],10),d=(m.layoutRect()[o]||100)-Ht.getSize(l)[r],m.fire("dragstart",{value:h})},drag:function(t){var e=t[n]-u;f=jr(c+e,0,d),l.style[i]=f+"px",h=s+f/d*(a-s),m.value(h),m.tooltip().text(""+m.settings.previewFilter(h)).show().moveRel(l,"bc tc"),m.fire("drag",{value:h})},stop:function(){m.tooltip().hide(),m.fire("dragend",{value:h})}})},repaint:function(){this._super(),Gr(this,this.value())},bindStates:function(){var e=this;return e.state.on("change:value",function(t){Gr(e,t.value)}),e._super()}}),Zr=ge.extend({renderHtml:function(){return this.classes.add("spacer"),this.canFocus=!1,'<div id="'+this._id+'" class="'+this.classes+'"></div>'}}),Qr=Ir.extend({Defaults:{classes:"widget btn splitbtn",role:"button"},repaint:function(){var t,e,n=this.getEl(),i=this.layoutRect();return this._super(),t=n.firstChild,e=n.lastChild,Tt(t).css({width:i.w-Ht.getSize(e).width,height:i.h-2}),Tt(e).css({height:i.h-2}),this},activeMenu:function(t){Tt(this.getEl().lastChild).toggleClass(this.classPrefix+"active",t)},renderHtml:function(){var t,e,n=this,i=n._id,r=n.classPrefix,o=n.state.get("icon"),s=n.state.get("text"),a=n.settings,l="";return(t=a.image)?(o="none","string"!=typeof t&&(t=_.window.getSelection?t[0]:t[1]),t=" style=\"background-image: url('"+t+"')\""):t="",o=a.icon?r+"ico "+r+"i-"+o:"",s&&(n.classes.add("btn-has-text"),l='<span class="'+r+'txt">'+n.encode(s)+"</span>"),e="boolean"==typeof a.active?' aria-pressed="'+a.active+'"':"",'<div id="'+i+'" class="'+n.classes+'" role="button"'+e+' tabindex="-1"><button type="button" hidefocus="1" tabindex="-1">'+(o?'<i class="'+o+'"'+t+"></i>":"")+l+'</button><button type="button" class="'+r+'open" hidefocus="1" tabindex="-1">'+(n._menuBtnText?(o?"\xa0":"")+n._menuBtnText:"")+' <i class="'+r+'caret"></i></button></div>'},postRender:function(){var n=this.settings.onclick;return this.on("click",function(t){var e=t.target;if(t.control===this)for(;e;){if(t.aria&&"down"!==t.aria.key||"BUTTON"===e.nodeName&&-1===e.className.indexOf("open"))return t.stopImmediatePropagation(),void(n&&n.call(this,t));e=e.parentNode}}),delete this.settings.onclick,this._super()}}),to=ir.extend({Defaults:{containerClass:"stack-layout",controlClass:"stack-layout-item",endClass:"break"},isNative:function(){return!0}}),eo=Oe.extend({Defaults:{layout:"absolute",defaults:{type:"panel"}},activateTab:function(n){var t;this.activeTabId&&(t=this.getEl(this.activeTabId),Tt(t).removeClass(this.classPrefix+"active"),t.setAttribute("aria-selected","false")),this.activeTabId="t"+n,(t=this.getEl("t"+n)).setAttribute("aria-selected","true"),Tt(t).addClass(this.classPrefix+"active"),this.items()[n].show().fire("showtab"),this.reflow(),this.items().each(function(t,e){n!==e&&t.hide()})},renderHtml:function(){var i=this,t=i._layout,r="",o=i.classPrefix;return i.preRender(),t.preRender(i),i.items().each(function(t,e){var n=i._id+"-t"+e;t.aria("role","tabpanel"),t.aria("labelledby",n),r+='<div id="'+n+'" class="'+o+'tab" unselectable="on" role="tab" aria-controls="'+t._id+'" aria-selected="false" tabIndex="-1">'+i.encode(t.settings.title)+"</div>"}),'<div id="'+i._id+'" class="'+i.classes+'" hidefocus="1" tabindex="-1"><div id="'+i._id+'-head" class="'+o+'tabs" role="tablist">'+r+'</div><div id="'+i._id+'-body" class="'+i.bodyClasses+'">'+t.renderHtml(i)+"</div></div>"},postRender:function(){var i=this;i._super(),i.settings.activeTab=i.settings.activeTab||0,i.activateTab(i.settings.activeTab),this.on("click",function(t){var e=t.target.parentNode;if(e&&e.id===i._id+"-head")for(var n=e.childNodes.length;n--;)e.childNodes[n]===t.target&&i.activateTab(n)})},initLayoutRect:function(){var t,e,n,i=this;e=(e=Ht.getSize(i.getEl("head")).width)<0?0:e,n=0,i.items().each(function(t){e=Math.max(e,t.layoutRect().minW),n=Math.max(n,t.layoutRect().minH)}),i.items().each(function(t){t.settings.x=0,t.settings.y=0,t.settings.w=e,t.settings.h=n,t.layoutRect({x:0,y:0,w:e,h:n})});var r=Ht.getSize(i.getEl("head")).height;return i.settings.minWidth=e,i.settings.minHeight=n+r,(t=i._super()).deltaH+=r,t.innerH=t.h-t.deltaH,t}}),no=ge.extend({init:function(t){var n=this;n._super(t),n.classes.add("textbox"),t.multiline?n.classes.add("multiline"):(n.on("keydown",function(t){var e;13===t.keyCode&&(t.preventDefault(),n.parents().reverse().each(function(t){if(t.toJSON)return e=t,!1}),n.fire("submit",{data:e.toJSON()}))}),n.on("keyup",function(t){n.state.set("value",t.target.value)}))},repaint:function(){var t,e,n,i,r,o=this,s=0;t=o.getEl().style,e=o._layoutRect,r=o._lastRepaintRect||{};var a=_.document;return!o.settings.multiline&&a.all&&(!a.documentMode||a.documentMode<=8)&&(t.lineHeight=e.h-s+"px"),i=(n=o.borderBox).left+n.right+8,s=n.top+n.bottom+(o.settings.multiline?8:0),e.x!==r.x&&(t.left=e.x+"px",r.x=e.x),e.y!==r.y&&(t.top=e.y+"px",r.y=e.y),e.w!==r.w&&(t.width=e.w-i+"px",r.w=e.w),e.h!==r.h&&(t.height=e.h-s+"px",r.h=e.h),o._lastRepaintRect=r,o.fire("repaint",{},!1),o},renderHtml:function(){var e,t,n=this,i=n.settings;return e={id:n._id,hidefocus:"1"},R.each(["rows","spellcheck","maxLength","size","readonly","min","max","step","list","pattern","placeholder","required","multiple"],function(t){e[t]=i[t]}),n.disabled()&&(e.disabled="disabled"),i.subtype&&(e.type=i.subtype),(t=Ht.create(i.multiline?"textarea":"input",e)).value=n.state.get("value"),t.className=n.classes.toString(),t.outerHTML},value:function(t){return arguments.length?(this.state.set("value",t),this):(this.state.get("rendered")&&this.state.set("value",this.getEl().value),this.state.get("value"))},postRender:function(){var e=this;e.getEl().value=e.state.get("value"),e._super(),e.$el.on("change",function(t){e.state.set("value",t.target.value),e.fire("change",t)})},bindStates:function(){var e=this;return e.state.on("change:value",function(t){e.getEl().value!==t.value&&(e.getEl().value=t.value)}),e.state.on("change:disabled",function(t){e.getEl().disabled=t.value}),e._super()},remove:function(){this.$el.off(),this._super()}}),io=function(){return{Selector:Ft,Collection:qt,ReflowQueue:Zt,Control:ae,Factory:_e,KeyboardNavigation:Ce,Container:Me,DragHelper:we,Scrollable:Ne,Panel:Oe,Movable:he,Resizable:We,FloatPanel:ze,Window:$e,MessageBox:Ge,Tooltip:me,Widget:ge,Progress:pe,Notification:be,Layout:Mn,AbsoluteLayout:Nn,Button:On,ButtonGroup:Pn,Checkbox:Dn,ComboBox:Bn,ColorBox:Ln,PanelButton:In,ColorButton:Fn,ColorPicker:Vn,Path:Yn,ElementPath:$n,FormItem:Xn,Form:jn,FieldSet:Jn,FilePicker:tr,FitLayout:er,FlexLayout:nr,FlowLayout:ir,FormatControls:Or,GridLayout:Wr,Iframe:Pr,InfoBox:Dr,Label:Ar,Toolbar:Br,MenuBar:Lr,MenuButton:Ir,MenuItem:Vr,Throbber:zr,Menu:Fr,ListBox:Ur,Radio:qr,ResizeHandle:Yr,SelectBox:Xr,Slider:Kr,Spacer:Zr,SplitButton:Qr,StackLayout:to,TabPanel:eo,TextBox:no,DropZone:qn,BrowseButton:Wn}},ro=function(n){n.ui?R.each(io(),function(t,e){n.ui[e]=t}):n.ui=io()};R.each(io(),function(t,e){_e.add(e,t)}),ro(window.tinymce?window.tinymce:{}),r.add("inlite",function(t){var e=Sn();return Or.setup(t),_n(t,e),Ke(t,e)})}(window);
\ No newline at end of file
diff --git a/wp-includes/js/tinymce/themes/modern/theme.js b/wp-includes/js/tinymce/themes/modern/theme.js
new file mode 100644
index 0000000..51c215c
--- /dev/null
+++ b/wp-includes/js/tinymce/themes/modern/theme.js
@@ -0,0 +1,9607 @@
+(function () {
+var modern = (function (domGlobals) {
+    'use strict';
+
+    var global = tinymce.util.Tools.resolve('tinymce.ThemeManager');
+
+    var global$1 = tinymce.util.Tools.resolve('tinymce.EditorManager');
+
+    var global$2 = tinymce.util.Tools.resolve('tinymce.util.Tools');
+
+    var isBrandingEnabled = function (editor) {
+      return editor.getParam('branding', true, 'boolean');
+    };
+    var hasMenubar = function (editor) {
+      return getMenubar(editor) !== false;
+    };
+    var getMenubar = function (editor) {
+      return editor.getParam('menubar');
+    };
+    var hasStatusbar = function (editor) {
+      return editor.getParam('statusbar', true, 'boolean');
+    };
+    var getToolbarSize = function (editor) {
+      return editor.getParam('toolbar_items_size');
+    };
+    var isReadOnly = function (editor) {
+      return editor.getParam('readonly', false, 'boolean');
+    };
+    var getFixedToolbarContainer = function (editor) {
+      return editor.getParam('fixed_toolbar_container');
+    };
+    var getInlineToolbarPositionHandler = function (editor) {
+      return editor.getParam('inline_toolbar_position_handler');
+    };
+    var getMenu = function (editor) {
+      return editor.getParam('menu');
+    };
+    var getRemovedMenuItems = function (editor) {
+      return editor.getParam('removed_menuitems', '');
+    };
+    var getMinWidth = function (editor) {
+      return editor.getParam('min_width', 100, 'number');
+    };
+    var getMinHeight = function (editor) {
+      return editor.getParam('min_height', 100, 'number');
+    };
+    var getMaxWidth = function (editor) {
+      return editor.getParam('max_width', 65535, 'number');
+    };
+    var getMaxHeight = function (editor) {
+      return editor.getParam('max_height', 65535, 'number');
+    };
+    var isSkinDisabled = function (editor) {
+      return editor.settings.skin === false;
+    };
+    var isInline = function (editor) {
+      return editor.getParam('inline', false, 'boolean');
+    };
+    var getResize = function (editor) {
+      var resize = editor.getParam('resize', 'vertical');
+      if (resize === false) {
+        return 'none';
+      } else if (resize === 'both') {
+        return 'both';
+      } else {
+        return 'vertical';
+      }
+    };
+    var getSkinUrl = function (editor) {
+      var settings = editor.settings;
+      var skin = settings.skin;
+      var skinUrl = settings.skin_url;
+      if (skin !== false) {
+        var skinName = skin ? skin : 'lightgray';
+        if (skinUrl) {
+          skinUrl = editor.documentBaseURI.toAbsolute(skinUrl);
+        } else {
+          skinUrl = global$1.baseURL + '/skins/' + skinName;
+        }
+      }
+      return skinUrl;
+    };
+    var getIndexedToolbars = function (settings, defaultToolbar) {
+      var toolbars = [];
+      for (var i = 1; i < 10; i++) {
+        var toolbar = settings['toolbar' + i];
+        if (!toolbar) {
+          break;
+        }
+        toolbars.push(toolbar);
+      }
+      var mainToolbar = settings.toolbar ? [settings.toolbar] : [defaultToolbar];
+      return toolbars.length > 0 ? toolbars : mainToolbar;
+    };
+    var getToolbars = function (editor) {
+      var toolbar = editor.getParam('toolbar');
+      var defaultToolbar = 'undo redo | styleselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent | link image';
+      if (toolbar === false) {
+        return [];
+      } else if (global$2.isArray(toolbar)) {
+        return global$2.grep(toolbar, function (toolbar) {
+          return toolbar.length > 0;
+        });
+      } else {
+        return getIndexedToolbars(editor.settings, defaultToolbar);
+      }
+    };
+
+    var global$3 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
+
+    var global$4 = tinymce.util.Tools.resolve('tinymce.ui.Factory');
+
+    var global$5 = tinymce.util.Tools.resolve('tinymce.util.I18n');
+
+    var fireSkinLoaded = function (editor) {
+      return editor.fire('SkinLoaded');
+    };
+    var fireResizeEditor = function (editor) {
+      return editor.fire('ResizeEditor');
+    };
+    var fireBeforeRenderUI = function (editor) {
+      return editor.fire('BeforeRenderUI');
+    };
+    var Events = {
+      fireSkinLoaded: fireSkinLoaded,
+      fireResizeEditor: fireResizeEditor,
+      fireBeforeRenderUI: fireBeforeRenderUI
+    };
+
+    var focus = function (panel, type) {
+      return function () {
+        var item = panel.find(type)[0];
+        if (item) {
+          item.focus(true);
+        }
+      };
+    };
+    var addKeys = function (editor, panel) {
+      editor.shortcuts.add('Alt+F9', '', focus(panel, 'menubar'));
+      editor.shortcuts.add('Alt+F10,F10', '', focus(panel, 'toolbar'));
+      editor.shortcuts.add('Alt+F11', '', focus(panel, 'elementpath'));
+      panel.on('cancel', function () {
+        editor.focus();
+      });
+    };
+    var A11y = { addKeys: addKeys };
+
+    var global$6 = tinymce.util.Tools.resolve('tinymce.geom.Rect');
+
+    var global$7 = tinymce.util.Tools.resolve('tinymce.util.Delay');
+
+    var noop = function () {
+    };
+    var constant = function (value) {
+      return function () {
+        return value;
+      };
+    };
+    var never = constant(false);
+    var always = constant(true);
+
+    var none = function () {
+      return NONE;
+    };
+    var NONE = function () {
+      var eq = function (o) {
+        return o.isNone();
+      };
+      var call = function (thunk) {
+        return thunk();
+      };
+      var id = function (n) {
+        return n;
+      };
+      var me = {
+        fold: function (n, s) {
+          return n();
+        },
+        is: never,
+        isSome: never,
+        isNone: always,
+        getOr: id,
+        getOrThunk: call,
+        getOrDie: function (msg) {
+          throw new Error(msg || 'error: getOrDie called on none.');
+        },
+        getOrNull: constant(null),
+        getOrUndefined: constant(undefined),
+        or: id,
+        orThunk: call,
+        map: none,
+        each: noop,
+        bind: none,
+        exists: never,
+        forall: always,
+        filter: none,
+        equals: eq,
+        equals_: eq,
+        toArray: function () {
+          return [];
+        },
+        toString: constant('none()')
+      };
+      if (Object.freeze) {
+        Object.freeze(me);
+      }
+      return me;
+    }();
+    var some = function (a) {
+      var constant_a = constant(a);
+      var self = function () {
+        return me;
+      };
+      var bind = function (f) {
+        return f(a);
+      };
+      var me = {
+        fold: function (n, s) {
+          return s(a);
+        },
+        is: function (v) {
+          return a === v;
+        },
+        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 + ')';
+        },
+        equals: function (o) {
+          return o.is(a);
+        },
+        equals_: function (o, elementEq) {
+          return o.fold(never, function (b) {
+            return elementEq(a, b);
+          });
+        }
+      };
+      return me;
+    };
+    var from = function (value) {
+      return value === null || value === undefined ? NONE : some(value);
+    };
+    var Option = {
+      some: some,
+      none: none,
+      from: from
+    };
+
+    var getUiContainerDelta = function (ctrl) {
+      var uiContainer = getUiContainer(ctrl);
+      if (uiContainer && global$3.DOM.getStyle(uiContainer, 'position', true) !== 'static') {
+        var containerPos = global$3.DOM.getPos(uiContainer);
+        var dx = uiContainer.scrollLeft - containerPos.x;
+        var dy = uiContainer.scrollTop - containerPos.y;
+        return Option.some({
+          x: dx,
+          y: dy
+        });
+      } else {
+        return Option.none();
+      }
+    };
+    var setUiContainer = function (editor, ctrl) {
+      var uiContainer = global$3.DOM.select(editor.settings.ui_container)[0];
+      ctrl.getRoot().uiContainer = uiContainer;
+    };
+    var getUiContainer = function (ctrl) {
+      return ctrl ? ctrl.getRoot().uiContainer : null;
+    };
+    var inheritUiContainer = function (fromCtrl, toCtrl) {
+      return toCtrl.uiContainer = getUiContainer(fromCtrl);
+    };
+    var UiContainer = {
+      getUiContainerDelta: getUiContainerDelta,
+      setUiContainer: setUiContainer,
+      getUiContainer: getUiContainer,
+      inheritUiContainer: inheritUiContainer
+    };
+
+    var createToolbar = function (editor, items, size) {
+      var toolbarItems = [];
+      var buttonGroup;
+      if (!items) {
+        return;
+      }
+      global$2.each(items.split(/[ ,]/), function (item) {
+        var itemName;
+        var bindSelectorChanged = function () {
+          var selection = editor.selection;
+          if (item.settings.stateSelector) {
+            selection.selectorChanged(item.settings.stateSelector, function (state) {
+              item.active(state);
+            }, true);
+          }
+          if (item.settings.disabledStateSelector) {
+            selection.selectorChanged(item.settings.disabledStateSelector, function (state) {
+              item.disabled(state);
+            });
+          }
+        };
+        if (item === '|') {
+          buttonGroup = null;
+        } else {
+          if (!buttonGroup) {
+            buttonGroup = {
+              type: 'buttongroup',
+              items: []
+            };
+            toolbarItems.push(buttonGroup);
+          }
+          if (editor.buttons[item]) {
+            itemName = item;
+            item = editor.buttons[itemName];
+            if (typeof item === 'function') {
+              item = item();
+            }
+            item.type = item.type || 'button';
+            item.size = size;
+            item = global$4.create(item);
+            buttonGroup.items.push(item);
+            if (editor.initialized) {
+              bindSelectorChanged();
+            } else {
+              editor.on('init', bindSelectorChanged);
+            }
+          }
+        }
+      });
+      return {
+        type: 'toolbar',
+        layout: 'flow',
+        items: toolbarItems
+      };
+    };
+    var createToolbars = function (editor, size) {
+      var toolbars = [];
+      var addToolbar = function (items) {
+        if (items) {
+          toolbars.push(createToolbar(editor, items, size));
+        }
+      };
+      global$2.each(getToolbars(editor), function (toolbar) {
+        addToolbar(toolbar);
+      });
+      if (toolbars.length) {
+        return {
+          type: 'panel',
+          layout: 'stack',
+          classes: 'toolbar-grp',
+          ariaRoot: true,
+          ariaRemember: true,
+          items: toolbars
+        };
+      }
+    };
+    var Toolbar = {
+      createToolbar: createToolbar,
+      createToolbars: createToolbars
+    };
+
+    var DOM = global$3.DOM;
+    var toClientRect = function (geomRect) {
+      return {
+        left: geomRect.x,
+        top: geomRect.y,
+        width: geomRect.w,
+        height: geomRect.h,
+        right: geomRect.x + geomRect.w,
+        bottom: geomRect.y + geomRect.h
+      };
+    };
+    var hideAllFloatingPanels = function (editor) {
+      global$2.each(editor.contextToolbars, function (toolbar) {
+        if (toolbar.panel) {
+          toolbar.panel.hide();
+        }
+      });
+    };
+    var movePanelTo = function (panel, pos) {
+      panel.moveTo(pos.left, pos.top);
+    };
+    var togglePositionClass = function (panel, relPos, predicate) {
+      relPos = relPos ? relPos.substr(0, 2) : '';
+      global$2.each({
+        t: 'down',
+        b: 'up'
+      }, function (cls, pos) {
+        panel.classes.toggle('arrow-' + cls, predicate(pos, relPos.substr(0, 1)));
+      });
+      global$2.each({
+        l: 'left',
+        r: 'right'
+      }, function (cls, pos) {
+        panel.classes.toggle('arrow-' + cls, predicate(pos, relPos.substr(1, 1)));
+      });
+    };
+    var userConstrain = function (handler, x, y, elementRect, contentAreaRect, panelRect) {
+      panelRect = toClientRect({
+        x: x,
+        y: y,
+        w: panelRect.w,
+        h: panelRect.h
+      });
+      if (handler) {
+        panelRect = handler({
+          elementRect: toClientRect(elementRect),
+          contentAreaRect: toClientRect(contentAreaRect),
+          panelRect: panelRect
+        });
+      }
+      return panelRect;
+    };
+    var addContextualToolbars = function (editor) {
+      var scrollContainer;
+      var getContextToolbars = function () {
+        return editor.contextToolbars || [];
+      };
+      var getElementRect = function (elm) {
+        var pos, targetRect, root;
+        pos = DOM.getPos(editor.getContentAreaContainer());
+        targetRect = editor.dom.getRect(elm);
+        root = editor.dom.getRoot();
+        if (root.nodeName === 'BODY') {
+          targetRect.x -= root.ownerDocument.documentElement.scrollLeft || root.scrollLeft;
+          targetRect.y -= root.ownerDocument.documentElement.scrollTop || root.scrollTop;
+        }
+        targetRect.x += pos.x;
+        targetRect.y += pos.y;
+        return targetRect;
+      };
+      var reposition = function (match, shouldShow) {
+        var relPos, panelRect, elementRect, contentAreaRect, panel, relRect, testPositions, smallElementWidthThreshold;
+        var handler = getInlineToolbarPositionHandler(editor);
+        if (editor.removed) {
+          return;
+        }
+        if (!match || !match.toolbar.panel) {
+          hideAllFloatingPanels(editor);
+          return;
+        }
+        testPositions = [
+          'bc-tc',
+          'tc-bc',
+          'tl-bl',
+          'bl-tl',
+          'tr-br',
+          'br-tr'
+        ];
+        panel = match.toolbar.panel;
+        if (shouldShow) {
+          panel.show();
+        }
+        elementRect = getElementRect(match.element);
+        panelRect = DOM.getRect(panel.getEl());
+        contentAreaRect = DOM.getRect(editor.getContentAreaContainer() || editor.getBody());
+        var delta = UiContainer.getUiContainerDelta(panel).getOr({
+          x: 0,
+          y: 0
+        });
+        elementRect.x += delta.x;
+        elementRect.y += delta.y;
+        panelRect.x += delta.x;
+        panelRect.y += delta.y;
+        contentAreaRect.x += delta.x;
+        contentAreaRect.y += delta.y;
+        smallElementWidthThreshold = 25;
+        if (DOM.getStyle(match.element, 'display', true) !== 'inline') {
+          var clientRect = match.element.getBoundingClientRect();
+          elementRect.w = clientRect.width;
+          elementRect.h = clientRect.height;
+        }
+        if (!editor.inline) {
+          contentAreaRect.w = editor.getDoc().documentElement.offsetWidth;
+        }
+        if (editor.selection.controlSelection.isResizable(match.element) && elementRect.w < smallElementWidthThreshold) {
+          elementRect = global$6.inflate(elementRect, 0, 8);
+        }
+        relPos = global$6.findBestRelativePosition(panelRect, elementRect, contentAreaRect, testPositions);
+        elementRect = global$6.clamp(elementRect, contentAreaRect);
+        if (relPos) {
+          relRect = global$6.relativePosition(panelRect, elementRect, relPos);
+          movePanelTo(panel, userConstrain(handler, relRect.x, relRect.y, elementRect, contentAreaRect, panelRect));
+        } else {
+          contentAreaRect.h += panelRect.h;
+          elementRect = global$6.intersect(contentAreaRect, elementRect);
+          if (elementRect) {
+            relPos = global$6.findBestRelativePosition(panelRect, elementRect, contentAreaRect, [
+              'bc-tc',
+              'bl-tl',
+              'br-tr'
+            ]);
+            if (relPos) {
+              relRect = global$6.relativePosition(panelRect, elementRect, relPos);
+              movePanelTo(panel, userConstrain(handler, relRect.x, relRect.y, elementRect, contentAreaRect, panelRect));
+            } else {
+              movePanelTo(panel, userConstrain(handler, elementRect.x, elementRect.y, elementRect, contentAreaRect, panelRect));
+            }
+          } else {
+            panel.hide();
+          }
+        }
+        togglePositionClass(panel, relPos, function (pos1, pos2) {
+          return pos1 === pos2;
+        });
+      };
+      var repositionHandler = function (show) {
+        return function () {
+          var execute = function () {
+            if (editor.selection) {
+              reposition(findFrontMostMatch(editor.selection.getNode()), show);
+            }
+          };
+          global$7.requestAnimationFrame(execute);
+        };
+      };
+      var bindScrollEvent = function (panel) {
+        if (!scrollContainer) {
+          var reposition_1 = repositionHandler(true);
+          var uiContainer_1 = UiContainer.getUiContainer(panel);
+          scrollContainer = editor.selection.getScrollContainer() || editor.getWin();
+          DOM.bind(scrollContainer, 'scroll', reposition_1);
+          DOM.bind(uiContainer_1, 'scroll', reposition_1);
+          editor.on('remove', function () {
+            DOM.unbind(scrollContainer, 'scroll', reposition_1);
+            DOM.unbind(uiContainer_1, 'scroll', reposition_1);
+          });
+        }
+      };
+      var showContextToolbar = function (match) {
+        var panel;
+        if (match.toolbar.panel) {
+          match.toolbar.panel.show();
+          reposition(match);
+          return;
+        }
+        panel = global$4.create({
+          type: 'floatpanel',
+          role: 'dialog',
+          classes: 'tinymce tinymce-inline arrow',
+          ariaLabel: 'Inline toolbar',
+          layout: 'flex',
+          direction: 'column',
+          align: 'stretch',
+          autohide: false,
+          autofix: true,
+          fixed: true,
+          border: 1,
+          items: Toolbar.createToolbar(editor, match.toolbar.items),
+          oncancel: function () {
+            editor.focus();
+          }
+        });
+        UiContainer.setUiContainer(editor, panel);
+        bindScrollEvent(panel);
+        match.toolbar.panel = panel;
+        panel.renderTo().reflow();
+        reposition(match);
+      };
+      var hideAllContextToolbars = function () {
+        global$2.each(getContextToolbars(), function (toolbar) {
+          if (toolbar.panel) {
+            toolbar.panel.hide();
+          }
+        });
+      };
+      var findFrontMostMatch = function (targetElm) {
+        var i, y, parentsAndSelf;
+        var toolbars = getContextToolbars();
+        parentsAndSelf = editor.$(targetElm).parents().add(targetElm);
+        for (i = parentsAndSelf.length - 1; i >= 0; i--) {
+          for (y = toolbars.length - 1; y >= 0; y--) {
+            if (toolbars[y].predicate(parentsAndSelf[i])) {
+              return {
+                toolbar: toolbars[y],
+                element: parentsAndSelf[i]
+              };
+            }
+          }
+        }
+        return null;
+      };
+      editor.on('click keyup setContent ObjectResized', function (e) {
+        if (e.type === 'setcontent' && !e.selection) {
+          return;
+        }
+        global$7.setEditorTimeout(editor, function () {
+          var match;
+          match = findFrontMostMatch(editor.selection.getNode());
+          if (match) {
+            hideAllContextToolbars();
+            showContextToolbar(match);
+          } else {
+            hideAllContextToolbars();
+          }
+        });
+      });
+      editor.on('blur hide contextmenu', hideAllContextToolbars);
+      editor.on('ObjectResizeStart', function () {
+        var match = findFrontMostMatch(editor.selection.getNode());
+        if (match && match.toolbar.panel) {
+          match.toolbar.panel.hide();
+        }
+      });
+      editor.on('ResizeEditor ResizeWindow', repositionHandler(true));
+      editor.on('nodeChange', repositionHandler(false));
+      editor.on('remove', function () {
+        global$2.each(getContextToolbars(), function (toolbar) {
+          if (toolbar.panel) {
+            toolbar.panel.remove();
+          }
+        });
+        editor.contextToolbars = {};
+      });
+      editor.shortcuts.add('ctrl+F9', '', function () {
+        var match = findFrontMostMatch(editor.selection.getNode());
+        if (match && match.toolbar.panel) {
+          match.toolbar.panel.items()[0].focus();
+        }
+      });
+    };
+    var ContextToolbars = { addContextualToolbars: addContextualToolbars };
+
+    var typeOf = function (x) {
+      if (x === null) {
+        return 'null';
+      }
+      var t = typeof x;
+      if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
+        return 'array';
+      }
+      if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
+        return 'string';
+      }
+      return t;
+    };
+    var isType = function (type) {
+      return function (value) {
+        return typeOf(value) === type;
+      };
+    };
+    var isArray = isType('array');
+    var isFunction = isType('function');
+    var isNumber = isType('number');
+
+    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 ? Option.none() : Option.some(r);
+    };
+    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 = 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 = function (xs, f) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        f(x, i);
+      }
+    };
+    var filter = 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 foldl = function (xs, f, acc) {
+      each(xs, function (x) {
+        acc = f(acc, x);
+      });
+      return acc;
+    };
+    var find = function (xs, pred) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          return Option.some(x);
+        }
+      }
+      return Option.none();
+    };
+    var findIndex = function (xs, pred) {
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          return Option.some(i);
+        }
+      }
+      return Option.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 from$1 = isFunction(Array.from) ? Array.from : function (x) {
+      return nativeSlice.call(x);
+    };
+
+    var defaultMenus = {
+      file: {
+        title: 'File',
+        items: 'newdocument restoredraft | preview | print'
+      },
+      edit: {
+        title: 'Edit',
+        items: 'undo redo | cut copy paste pastetext | selectall'
+      },
+      view: {
+        title: 'View',
+        items: 'code | visualaid visualchars visualblocks | spellchecker | preview fullscreen'
+      },
+      insert: {
+        title: 'Insert',
+        items: 'image link media template codesample inserttable | charmap hr | pagebreak nonbreaking anchor toc | insertdatetime'
+      },
+      format: {
+        title: 'Format',
+        items: 'bold italic underline strikethrough superscript subscript codeformat | blockformats align | removeformat'
+      },
+      tools: {
+        title: 'Tools',
+        items: 'spellchecker spellcheckerlanguage | a11ycheck code'
+      },
+      table: { title: 'Table' },
+      help: { title: 'Help' }
+    };
+    var delimiterMenuNamePair = function () {
+      return {
+        name: '|',
+        item: { text: '|' }
+      };
+    };
+    var createMenuNameItemPair = function (name, item) {
+      var menuItem = item ? {
+        name: name,
+        item: item
+      } : null;
+      return name === '|' ? delimiterMenuNamePair() : menuItem;
+    };
+    var hasItemName = function (namedMenuItems, name) {
+      return findIndex(namedMenuItems, function (namedMenuItem) {
+        return namedMenuItem.name === name;
+      }).isSome();
+    };
+    var isSeparator = function (namedMenuItem) {
+      return namedMenuItem && namedMenuItem.item.text === '|';
+    };
+    var cleanupMenu = function (namedMenuItems, removedMenuItems) {
+      var menuItemsPass1 = filter(namedMenuItems, function (namedMenuItem) {
+        return removedMenuItems.hasOwnProperty(namedMenuItem.name) === false;
+      });
+      var menuItemsPass2 = filter(menuItemsPass1, function (namedMenuItem, i) {
+        return !isSeparator(namedMenuItem) || !isSeparator(menuItemsPass1[i - 1]);
+      });
+      return filter(menuItemsPass2, function (namedMenuItem, i) {
+        return !isSeparator(namedMenuItem) || i > 0 && i < menuItemsPass2.length - 1;
+      });
+    };
+    var createMenu = function (editorMenuItems, menus, removedMenuItems, context) {
+      var menuButton, menu, namedMenuItems, isUserDefined;
+      if (menus) {
+        menu = menus[context];
+        isUserDefined = true;
+      } else {
+        menu = defaultMenus[context];
+      }
+      if (menu) {
+        menuButton = { text: menu.title };
+        namedMenuItems = [];
+        global$2.each((menu.items || '').split(/[ ,]/), function (name) {
+          var namedMenuItem = createMenuNameItemPair(name, editorMenuItems[name]);
+          if (namedMenuItem) {
+            namedMenuItems.push(namedMenuItem);
+          }
+        });
+        if (!isUserDefined) {
+          global$2.each(editorMenuItems, function (item, name) {
+            if (item.context === context && !hasItemName(namedMenuItems, name)) {
+              if (item.separator === 'before') {
+                namedMenuItems.push(delimiterMenuNamePair());
+              }
+              if (item.prependToContext) {
+                namedMenuItems.unshift(createMenuNameItemPair(name, item));
+              } else {
+                namedMenuItems.push(createMenuNameItemPair(name, item));
+              }
+              if (item.separator === 'after') {
+                namedMenuItems.push(delimiterMenuNamePair());
+              }
+            }
+          });
+        }
+        menuButton.menu = map(cleanupMenu(namedMenuItems, removedMenuItems), function (menuItem) {
+          return menuItem.item;
+        });
+        if (!menuButton.menu.length) {
+          return null;
+        }
+      }
+      return menuButton;
+    };
+    var getDefaultMenubar = function (editor) {
+      var name;
+      var defaultMenuBar = [];
+      var menu = getMenu(editor);
+      if (menu) {
+        for (name in menu) {
+          defaultMenuBar.push(name);
+        }
+      } else {
+        for (name in defaultMenus) {
+          defaultMenuBar.push(name);
+        }
+      }
+      return defaultMenuBar;
+    };
+    var createMenuButtons = function (editor) {
+      var menuButtons = [];
+      var defaultMenuBar = getDefaultMenubar(editor);
+      var removedMenuItems = global$2.makeMap(getRemovedMenuItems(editor).split(/[ ,]/));
+      var menubar = getMenubar(editor);
+      var enabledMenuNames = typeof menubar === 'string' ? menubar.split(/[ ,]/) : defaultMenuBar;
+      for (var i = 0; i < enabledMenuNames.length; i++) {
+        var menuItems = enabledMenuNames[i];
+        var menu = createMenu(editor.menuItems, getMenu(editor), removedMenuItems, menuItems);
+        if (menu) {
+          menuButtons.push(menu);
+        }
+      }
+      return menuButtons;
+    };
+    var Menubar = { createMenuButtons: createMenuButtons };
+
+    var DOM$1 = global$3.DOM;
+    var getSize = function (elm) {
+      return {
+        width: elm.clientWidth,
+        height: elm.clientHeight
+      };
+    };
+    var resizeTo = function (editor, width, height) {
+      var containerElm, iframeElm, containerSize, iframeSize;
+      containerElm = editor.getContainer();
+      iframeElm = editor.getContentAreaContainer().firstChild;
+      containerSize = getSize(containerElm);
+      iframeSize = getSize(iframeElm);
+      if (width !== null) {
+        width = Math.max(getMinWidth(editor), width);
+        width = Math.min(getMaxWidth(editor), width);
+        DOM$1.setStyle(containerElm, 'width', width + (containerSize.width - iframeSize.width));
+        DOM$1.setStyle(iframeElm, 'width', width);
+      }
+      height = Math.max(getMinHeight(editor), height);
+      height = Math.min(getMaxHeight(editor), height);
+      DOM$1.setStyle(iframeElm, 'height', height);
+      Events.fireResizeEditor(editor);
+    };
+    var resizeBy = function (editor, dw, dh) {
+      var elm = editor.getContentAreaContainer();
+      resizeTo(editor, elm.clientWidth + dw, elm.clientHeight + dh);
+    };
+    var Resize = {
+      resizeTo: resizeTo,
+      resizeBy: resizeBy
+    };
+
+    var global$8 = tinymce.util.Tools.resolve('tinymce.Env');
+
+    var api = function (elm) {
+      return {
+        element: function () {
+          return elm;
+        }
+      };
+    };
+    var trigger = function (sidebar, panel, callbackName) {
+      var callback = sidebar.settings[callbackName];
+      if (callback) {
+        callback(api(panel.getEl('body')));
+      }
+    };
+    var hidePanels = function (name, container, sidebars) {
+      global$2.each(sidebars, function (sidebar) {
+        var panel = container.items().filter('#' + sidebar.name)[0];
+        if (panel && panel.visible() && sidebar.name !== name) {
+          trigger(sidebar, panel, 'onhide');
+          panel.visible(false);
+        }
+      });
+    };
+    var deactivateButtons = function (toolbar) {
+      toolbar.items().each(function (ctrl) {
+        ctrl.active(false);
+      });
+    };
+    var findSidebar = function (sidebars, name) {
+      return global$2.grep(sidebars, function (sidebar) {
+        return sidebar.name === name;
+      })[0];
+    };
+    var showPanel = function (editor, name, sidebars) {
+      return function (e) {
+        var btnCtrl = e.control;
+        var container = btnCtrl.parents().filter('panel')[0];
+        var panel = container.find('#' + name)[0];
+        var sidebar = findSidebar(sidebars, name);
+        hidePanels(name, container, sidebars);
+        deactivateButtons(btnCtrl.parent());
+        if (panel && panel.visible()) {
+          trigger(sidebar, panel, 'onhide');
+          panel.hide();
+          btnCtrl.active(false);
+        } else {
+          if (panel) {
+            panel.show();
+            trigger(sidebar, panel, 'onshow');
+          } else {
+            panel = global$4.create({
+              type: 'container',
+              name: name,
+              layout: 'stack',
+              classes: 'sidebar-panel',
+              html: ''
+            });
+            container.prepend(panel);
+            trigger(sidebar, panel, 'onrender');
+            trigger(sidebar, panel, 'onshow');
+          }
+          btnCtrl.active(true);
+        }
+        Events.fireResizeEditor(editor);
+      };
+    };
+    var isModernBrowser = function () {
+      return !global$8.ie || global$8.ie >= 11;
+    };
+    var hasSidebar = function (editor) {
+      return isModernBrowser() && editor.sidebars ? editor.sidebars.length > 0 : false;
+    };
+    var createSidebar = function (editor) {
+      var buttons = global$2.map(editor.sidebars, function (sidebar) {
+        var settings = sidebar.settings;
+        return {
+          type: 'button',
+          icon: settings.icon,
+          image: settings.image,
+          tooltip: settings.tooltip,
+          onclick: showPanel(editor, sidebar.name, editor.sidebars)
+        };
+      });
+      return {
+        type: 'panel',
+        name: 'sidebar',
+        layout: 'stack',
+        classes: 'sidebar',
+        items: [{
+            type: 'toolbar',
+            layout: 'stack',
+            classes: 'sidebar-toolbar',
+            items: buttons
+          }]
+      };
+    };
+    var Sidebar = {
+      hasSidebar: hasSidebar,
+      createSidebar: createSidebar
+    };
+
+    var fireSkinLoaded$1 = function (editor) {
+      var done = function () {
+        editor._skinLoaded = true;
+        Events.fireSkinLoaded(editor);
+      };
+      return function () {
+        if (editor.initialized) {
+          done();
+        } else {
+          editor.on('init', done);
+        }
+      };
+    };
+    var SkinLoaded = { fireSkinLoaded: fireSkinLoaded$1 };
+
+    var DOM$2 = global$3.DOM;
+    var switchMode = function (panel) {
+      return function (e) {
+        panel.find('*').disabled(e.mode === 'readonly');
+      };
+    };
+    var editArea = function (border) {
+      return {
+        type: 'panel',
+        name: 'iframe',
+        layout: 'stack',
+        classes: 'edit-area',
+        border: border,
+        html: ''
+      };
+    };
+    var editAreaContainer = function (editor) {
+      return {
+        type: 'panel',
+        layout: 'stack',
+        classes: 'edit-aria-container',
+        border: '1 0 0 0',
+        items: [
+          editArea('0'),
+          Sidebar.createSidebar(editor)
+        ]
+      };
+    };
+    var render = function (editor, theme, args) {
+      var panel, resizeHandleCtrl, startSize;
+      if (isSkinDisabled(editor) === false && args.skinUiCss) {
+        DOM$2.styleSheetLoader.load(args.skinUiCss, SkinLoaded.fireSkinLoaded(editor));
+      } else {
+        SkinLoaded.fireSkinLoaded(editor)();
+      }
+      panel = theme.panel = global$4.create({
+        type: 'panel',
+        role: 'application',
+        classes: 'tinymce',
+        style: 'visibility: hidden',
+        layout: 'stack',
+        border: 1,
+        items: [
+          {
+            type: 'container',
+            classes: 'top-part',
+            items: [
+              hasMenubar(editor) === false ? null : {
+                type: 'menubar',
+                border: '0 0 1 0',
+                items: Menubar.createMenuButtons(editor)
+              },
+              Toolbar.createToolbars(editor, getToolbarSize(editor))
+            ]
+          },
+          Sidebar.hasSidebar(editor) ? editAreaContainer(editor) : editArea('1 0 0 0')
+        ]
+      });
+      UiContainer.setUiContainer(editor, panel);
+      if (getResize(editor) !== 'none') {
+        resizeHandleCtrl = {
+          type: 'resizehandle',
+          direction: getResize(editor),
+          onResizeStart: function () {
+            var elm = editor.getContentAreaContainer().firstChild;
+            startSize = {
+              width: elm.clientWidth,
+              height: elm.clientHeight
+            };
+          },
+          onResize: function (e) {
+            if (getResize(editor) === 'both') {
+              Resize.resizeTo(editor, startSize.width + e.deltaX, startSize.height + e.deltaY);
+            } else {
+              Resize.resizeTo(editor, null, startSize.height + e.deltaY);
+            }
+          }
+        };
+      }
+      if (hasStatusbar(editor)) {
+        var linkHtml = '<a href="https://www.tiny.cloud/?utm_campaign=editor_referral&amp;utm_medium=poweredby&amp;utm_source=tinymce" rel="noopener" target="_blank" role="presentation" tabindex="-1">Tiny</a>';
+        var html = global$5.translate([
+          'Powered by {0}',
+          linkHtml
+        ]);
+        var brandingLabel = isBrandingEnabled(editor) ? {
+          type: 'label',
+          classes: 'branding',
+          html: ' ' + html
+        } : null;
+        panel.add({
+          type: 'panel',
+          name: 'statusbar',
+          classes: 'statusbar',
+          layout: 'flow',
+          border: '1 0 0 0',
+          ariaRoot: true,
+          items: [
+            {
+              type: 'elementpath',
+              editor: editor
+            },
+            resizeHandleCtrl,
+            brandingLabel
+          ]
+        });
+      }
+      Events.fireBeforeRenderUI(editor);
+      editor.on('SwitchMode', switchMode(panel));
+      panel.renderBefore(args.targetNode).reflow();
+      if (isReadOnly(editor)) {
+        editor.setMode('readonly');
+      }
+      if (args.width) {
+        DOM$2.setStyle(panel.getEl(), 'width', args.width);
+      }
+      editor.on('remove', function () {
+        panel.remove();
+        panel = null;
+      });
+      A11y.addKeys(editor, panel);
+      ContextToolbars.addContextualToolbars(editor);
+      return {
+        iframeContainer: panel.find('#iframe')[0].getEl(),
+        editorContainer: panel.getEl()
+      };
+    };
+    var Iframe = { render: render };
+
+    var global$9 = tinymce.util.Tools.resolve('tinymce.dom.DomQuery');
+
+    var count = 0;
+    var funcs = {
+      id: function () {
+        return 'mceu_' + count++;
+      },
+      create: function (name, attrs, children) {
+        var elm = domGlobals.document.createElement(name);
+        global$3.DOM.setAttribs(elm, attrs);
+        if (typeof children === 'string') {
+          elm.innerHTML = children;
+        } else {
+          global$2.each(children, function (child) {
+            if (child.nodeType) {
+              elm.appendChild(child);
+            }
+          });
+        }
+        return elm;
+      },
+      createFragment: function (html) {
+        return global$3.DOM.createFragment(html);
+      },
+      getWindowSize: function () {
+        return global$3.DOM.getViewPort();
+      },
+      getSize: function (elm) {
+        var width, height;
+        if (elm.getBoundingClientRect) {
+          var rect = elm.getBoundingClientRect();
+          width = Math.max(rect.width || rect.right - rect.left, elm.offsetWidth);
+          height = Math.max(rect.height || rect.bottom - rect.bottom, elm.offsetHeight);
+        } else {
+          width = elm.offsetWidth;
+          height = elm.offsetHeight;
+        }
+        return {
+          width: width,
+          height: height
+        };
+      },
+      getPos: function (elm, root) {
+        return global$3.DOM.getPos(elm, root || funcs.getContainer());
+      },
+      getContainer: function () {
+        return global$8.container ? global$8.container : domGlobals.document.body;
+      },
+      getViewPort: function (win) {
+        return global$3.DOM.getViewPort(win);
+      },
+      get: function (id) {
+        return domGlobals.document.getElementById(id);
+      },
+      addClass: function (elm, cls) {
+        return global$3.DOM.addClass(elm, cls);
+      },
+      removeClass: function (elm, cls) {
+        return global$3.DOM.removeClass(elm, cls);
+      },
+      hasClass: function (elm, cls) {
+        return global$3.DOM.hasClass(elm, cls);
+      },
+      toggleClass: function (elm, cls, state) {
+        return global$3.DOM.toggleClass(elm, cls, state);
+      },
+      css: function (elm, name, value) {
+        return global$3.DOM.setStyle(elm, name, value);
+      },
+      getRuntimeStyle: function (elm, name) {
+        return global$3.DOM.getStyle(elm, name, true);
+      },
+      on: function (target, name, callback, scope) {
+        return global$3.DOM.bind(target, name, callback, scope);
+      },
+      off: function (target, name, callback) {
+        return global$3.DOM.unbind(target, name, callback);
+      },
+      fire: function (target, name, args) {
+        return global$3.DOM.fire(target, name, args);
+      },
+      innerHtml: function (elm, html) {
+        global$3.DOM.setHTML(elm, html);
+      }
+    };
+
+    var isStatic = function (elm) {
+      return funcs.getRuntimeStyle(elm, 'position') === 'static';
+    };
+    var isFixed = function (ctrl) {
+      return ctrl.state.get('fixed');
+    };
+    function calculateRelativePosition(ctrl, targetElm, rel) {
+      var ctrlElm, pos, x, y, selfW, selfH, targetW, targetH, viewport, size;
+      viewport = getWindowViewPort();
+      pos = funcs.getPos(targetElm, UiContainer.getUiContainer(ctrl));
+      x = pos.x;
+      y = pos.y;
+      if (isFixed(ctrl) && isStatic(domGlobals.document.body)) {
+        x -= viewport.x;
+        y -= viewport.y;
+      }
+      ctrlElm = ctrl.getEl();
+      size = funcs.getSize(ctrlElm);
+      selfW = size.width;
+      selfH = size.height;
+      size = funcs.getSize(targetElm);
+      targetW = size.width;
+      targetH = size.height;
+      rel = (rel || '').split('');
+      if (rel[0] === 'b') {
+        y += targetH;
+      }
+      if (rel[1] === 'r') {
+        x += targetW;
+      }
+      if (rel[0] === 'c') {
+        y += Math.round(targetH / 2);
+      }
+      if (rel[1] === 'c') {
+        x += Math.round(targetW / 2);
+      }
+      if (rel[3] === 'b') {
+        y -= selfH;
+      }
+      if (rel[4] === 'r') {
+        x -= selfW;
+      }
+      if (rel[3] === 'c') {
+        y -= Math.round(selfH / 2);
+      }
+      if (rel[4] === 'c') {
+        x -= Math.round(selfW / 2);
+      }
+      return {
+        x: x,
+        y: y,
+        w: selfW,
+        h: selfH
+      };
+    }
+    var getUiContainerViewPort = function (customUiContainer) {
+      return {
+        x: 0,
+        y: 0,
+        w: customUiContainer.scrollWidth - 1,
+        h: customUiContainer.scrollHeight - 1
+      };
+    };
+    var getWindowViewPort = function () {
+      var win = domGlobals.window;
+      var x = Math.max(win.pageXOffset, domGlobals.document.body.scrollLeft, domGlobals.document.documentElement.scrollLeft);
+      var y = Math.max(win.pageYOffset, domGlobals.document.body.scrollTop, domGlobals.document.documentElement.scrollTop);
+      var w = win.innerWidth || domGlobals.document.documentElement.clientWidth;
+      var h = win.innerHeight || domGlobals.document.documentElement.clientHeight;
+      return {
+        x: x,
+        y: y,
+        w: w,
+        h: h
+      };
+    };
+    var getViewPortRect = function (ctrl) {
+      var customUiContainer = UiContainer.getUiContainer(ctrl);
+      return customUiContainer && !isFixed(ctrl) ? getUiContainerViewPort(customUiContainer) : getWindowViewPort();
+    };
+    var Movable = {
+      testMoveRel: function (elm, rels) {
+        var viewPortRect = getViewPortRect(this);
+        for (var i = 0; i < rels.length; i++) {
+          var pos = calculateRelativePosition(this, elm, rels[i]);
+          if (isFixed(this)) {
+            if (pos.x > 0 && pos.x + pos.w < viewPortRect.w && pos.y > 0 && pos.y + pos.h < viewPortRect.h) {
+              return rels[i];
+            }
+          } else {
+            if (pos.x > viewPortRect.x && pos.x + pos.w < viewPortRect.w + viewPortRect.x && pos.y > viewPortRect.y && pos.y + pos.h < viewPortRect.h + viewPortRect.y) {
+              return rels[i];
+            }
+          }
+        }
+        return rels[0];
+      },
+      moveRel: function (elm, rel) {
+        if (typeof rel !== 'string') {
+          rel = this.testMoveRel(elm, rel);
+        }
+        var pos = calculateRelativePosition(this, elm, rel);
+        return this.moveTo(pos.x, pos.y);
+      },
+      moveBy: function (dx, dy) {
+        var self = this, rect = self.layoutRect();
+        self.moveTo(rect.x + dx, rect.y + dy);
+        return self;
+      },
+      moveTo: function (x, y) {
+        var self = this;
+        function constrain(value, max, size) {
+          if (value < 0) {
+            return 0;
+          }
+          if (value + size > max) {
+            value = max - size;
+            return value < 0 ? 0 : value;
+          }
+          return value;
+        }
+        if (self.settings.constrainToViewport) {
+          var viewPortRect = getViewPortRect(this);
+          var layoutRect = self.layoutRect();
+          x = constrain(x, viewPortRect.w + viewPortRect.x, layoutRect.w);
+          y = constrain(y, viewPortRect.h + viewPortRect.y, layoutRect.h);
+        }
+        var uiContainer = UiContainer.getUiContainer(self);
+        if (uiContainer && isStatic(uiContainer) && !isFixed(self)) {
+          x -= uiContainer.scrollLeft;
+          y -= uiContainer.scrollTop;
+        }
+        if (uiContainer) {
+          x += 1;
+          y += 1;
+        }
+        if (self.state.get('rendered')) {
+          self.layoutRect({
+            x: x,
+            y: y
+          }).repaint();
+        } else {
+          self.settings.x = x;
+          self.settings.y = y;
+        }
+        self.fire('move', {
+          x: x,
+          y: y
+        });
+        return self;
+      }
+    };
+
+    var global$a = tinymce.util.Tools.resolve('tinymce.util.Class');
+
+    var global$b = tinymce.util.Tools.resolve('tinymce.util.EventDispatcher');
+
+    var BoxUtils = {
+      parseBox: function (value) {
+        var len;
+        var radix = 10;
+        if (!value) {
+          return;
+        }
+        if (typeof value === 'number') {
+          value = value || 0;
+          return {
+            top: value,
+            left: value,
+            bottom: value,
+            right: value
+          };
+        }
+        value = value.split(' ');
+        len = value.length;
+        if (len === 1) {
+          value[1] = value[2] = value[3] = value[0];
+        } else if (len === 2) {
+          value[2] = value[0];
+          value[3] = value[1];
+        } else if (len === 3) {
+          value[3] = value[1];
+        }
+        return {
+          top: parseInt(value[0], radix) || 0,
+          right: parseInt(value[1], radix) || 0,
+          bottom: parseInt(value[2], radix) || 0,
+          left: parseInt(value[3], radix) || 0
+        };
+      },
+      measureBox: function (elm, prefix) {
+        function getStyle(name) {
+          var defaultView = elm.ownerDocument.defaultView;
+          if (defaultView) {
+            var computedStyle = defaultView.getComputedStyle(elm, null);
+            if (computedStyle) {
+              name = name.replace(/[A-Z]/g, function (a) {
+                return '-' + a;
+              });
+              return computedStyle.getPropertyValue(name);
+            } else {
+              return null;
+            }
+          }
+          return elm.currentStyle[name];
+        }
+        function getSide(name) {
+          var val = parseFloat(getStyle(name));
+          return isNaN(val) ? 0 : val;
+        }
+        return {
+          top: getSide(prefix + 'TopWidth'),
+          right: getSide(prefix + 'RightWidth'),
+          bottom: getSide(prefix + 'BottomWidth'),
+          left: getSide(prefix + 'LeftWidth')
+        };
+      }
+    };
+
+    function noop$1() {
+    }
+    function ClassList(onchange) {
+      this.cls = [];
+      this.cls._map = {};
+      this.onchange = onchange || noop$1;
+      this.prefix = '';
+    }
+    global$2.extend(ClassList.prototype, {
+      add: function (cls) {
+        if (cls && !this.contains(cls)) {
+          this.cls._map[cls] = true;
+          this.cls.push(cls);
+          this._change();
+        }
+        return this;
+      },
+      remove: function (cls) {
+        if (this.contains(cls)) {
+          var i = void 0;
+          for (i = 0; i < this.cls.length; i++) {
+            if (this.cls[i] === cls) {
+              break;
+            }
+          }
+          this.cls.splice(i, 1);
+          delete this.cls._map[cls];
+          this._change();
+        }
+        return this;
+      },
+      toggle: function (cls, state) {
+        var curState = this.contains(cls);
+        if (curState !== state) {
+          if (curState) {
+            this.remove(cls);
+          } else {
+            this.add(cls);
+          }
+          this._change();
+        }
+        return this;
+      },
+      contains: function (cls) {
+        return !!this.cls._map[cls];
+      },
+      _change: function () {
+        delete this.clsValue;
+        this.onchange.call(this);
+      }
+    });
+    ClassList.prototype.toString = function () {
+      var value;
+      if (this.clsValue) {
+        return this.clsValue;
+      }
+      value = '';
+      for (var i = 0; i < this.cls.length; i++) {
+        if (i > 0) {
+          value += ' ';
+        }
+        value += this.prefix + this.cls[i];
+      }
+      return value;
+    };
+
+    function unique(array) {
+      var uniqueItems = [];
+      var i = array.length, item;
+      while (i--) {
+        item = array[i];
+        if (!item.__checked) {
+          uniqueItems.push(item);
+          item.__checked = 1;
+        }
+      }
+      i = uniqueItems.length;
+      while (i--) {
+        delete uniqueItems[i].__checked;
+      }
+      return uniqueItems;
+    }
+    var expression = /^([\w\\*]+)?(?:#([\w\-\\]+))?(?:\.([\w\\\.]+))?(?:\[\@?([\w\\]+)([\^\$\*!~]?=)([\w\\]+)\])?(?:\:(.+))?/i;
+    var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g;
+    var whiteSpace = /^\s*|\s*$/g;
+    var Collection;
+    var Selector = global$a.extend({
+      init: function (selector) {
+        var match = this.match;
+        function compileNameFilter(name) {
+          if (name) {
+            name = name.toLowerCase();
+            return function (item) {
+              return name === '*' || item.type === name;
+            };
+          }
+        }
+        function compileIdFilter(id) {
+          if (id) {
+            return function (item) {
+              return item._name === id;
+            };
+          }
+        }
+        function compileClassesFilter(classes) {
+          if (classes) {
+            classes = classes.split('.');
+            return function (item) {
+              var i = classes.length;
+              while (i--) {
+                if (!item.classes.contains(classes[i])) {
+                  return false;
+                }
+              }
+              return true;
+            };
+          }
+        }
+        function compileAttrFilter(name, cmp, check) {
+          if (name) {
+            return function (item) {
+              var value = item[name] ? item[name]() : '';
+              return !cmp ? !!check : cmp === '=' ? value === check : cmp === '*=' ? value.indexOf(check) >= 0 : cmp === '~=' ? (' ' + value + ' ').indexOf(' ' + check + ' ') >= 0 : cmp === '!=' ? value !== check : cmp === '^=' ? value.indexOf(check) === 0 : cmp === '$=' ? value.substr(value.length - check.length) === check : false;
+            };
+          }
+        }
+        function compilePsuedoFilter(name) {
+          var notSelectors;
+          if (name) {
+            name = /(?:not\((.+)\))|(.+)/i.exec(name);
+            if (!name[1]) {
+              name = name[2];
+              return function (item, index, length) {
+                return name === 'first' ? index === 0 : name === 'last' ? index === length - 1 : name === 'even' ? index % 2 === 0 : name === 'odd' ? index % 2 === 1 : item[name] ? item[name]() : false;
+              };
+            }
+            notSelectors = parseChunks(name[1], []);
+            return function (item) {
+              return !match(item, notSelectors);
+            };
+          }
+        }
+        function compile(selector, filters, direct) {
+          var parts;
+          function add(filter) {
+            if (filter) {
+              filters.push(filter);
+            }
+          }
+          parts = expression.exec(selector.replace(whiteSpace, ''));
+          add(compileNameFilter(parts[1]));
+          add(compileIdFilter(parts[2]));
+          add(compileClassesFilter(parts[3]));
+          add(compileAttrFilter(parts[4], parts[5], parts[6]));
+          add(compilePsuedoFilter(parts[7]));
+          filters.pseudo = !!parts[7];
+          filters.direct = direct;
+          return filters;
+        }
+        function parseChunks(selector, selectors) {
+          var parts = [];
+          var extra, matches, i;
+          do {
+            chunker.exec('');
+            matches = chunker.exec(selector);
+            if (matches) {
+              selector = matches[3];
+              parts.push(matches[1]);
+              if (matches[2]) {
+                extra = matches[3];
+                break;
+              }
+            }
+          } while (matches);
+          if (extra) {
+            parseChunks(extra, selectors);
+          }
+          selector = [];
+          for (i = 0; i < parts.length; i++) {
+            if (parts[i] !== '>') {
+              selector.push(compile(parts[i], [], parts[i - 1] === '>'));
+            }
+          }
+          selectors.push(selector);
+          return selectors;
+        }
+        this._selectors = parseChunks(selector, []);
+      },
+      match: function (control, selectors) {
+        var i, l, si, sl, selector, fi, fl, filters, index, length, siblings, count, item;
+        selectors = selectors || this._selectors;
+        for (i = 0, l = selectors.length; i < l; i++) {
+          selector = selectors[i];
+          sl = selector.length;
+          item = control;
+          count = 0;
+          for (si = sl - 1; si >= 0; si--) {
+            filters = selector[si];
+            while (item) {
+              if (filters.pseudo) {
+                siblings = item.parent().items();
+                index = length = siblings.length;
+                while (index--) {
+                  if (siblings[index] === item) {
+                    break;
+                  }
+                }
+              }
+              for (fi = 0, fl = filters.length; fi < fl; fi++) {
+                if (!filters[fi](item, index, length)) {
+                  fi = fl + 1;
+                  break;
+                }
+              }
+              if (fi === fl) {
+                count++;
+                break;
+              } else {
+                if (si === sl - 1) {
+                  break;
+                }
+              }
+              item = item.parent();
+            }
+          }
+          if (count === sl) {
+            return true;
+          }
+        }
+        return false;
+      },
+      find: function (container) {
+        var matches = [], i, l;
+        var selectors = this._selectors;
+        function collect(items, selector, index) {
+          var i, l, fi, fl, item;
+          var filters = selector[index];
+          for (i = 0, l = items.length; i < l; i++) {
+            item = items[i];
+            for (fi = 0, fl = filters.length; fi < fl; fi++) {
+              if (!filters[fi](item, i, l)) {
+                fi = fl + 1;
+                break;
+              }
+            }
+            if (fi === fl) {
+              if (index === selector.length - 1) {
+                matches.push(item);
+              } else {
+                if (item.items) {
+                  collect(item.items(), selector, index + 1);
+                }
+              }
+            } else if (filters.direct) {
+              return;
+            }
+            if (item.items) {
+              collect(item.items(), selector, index);
+            }
+          }
+        }
+        if (container.items) {
+          for (i = 0, l = selectors.length; i < l; i++) {
+            collect(container.items(), selectors[i], 0);
+          }
+          if (l > 1) {
+            matches = unique(matches);
+          }
+        }
+        if (!Collection) {
+          Collection = Selector.Collection;
+        }
+        return new Collection(matches);
+      }
+    });
+
+    var Collection$1, proto;
+    var push = Array.prototype.push, slice = Array.prototype.slice;
+    proto = {
+      length: 0,
+      init: function (items) {
+        if (items) {
+          this.add(items);
+        }
+      },
+      add: function (items) {
+        var self = this;
+        if (!global$2.isArray(items)) {
+          if (items instanceof Collection$1) {
+            self.add(items.toArray());
+          } else {
+            push.call(self, items);
+          }
+        } else {
+          push.apply(self, items);
+        }
+        return self;
+      },
+      set: function (items) {
+        var self = this;
+        var len = self.length;
+        var i;
+        self.length = 0;
+        self.add(items);
+        for (i = self.length; i < len; i++) {
+          delete self[i];
+        }
+        return self;
+      },
+      filter: function (selector) {
+        var self = this;
+        var i, l;
+        var matches = [];
+        var item, match;
+        if (typeof selector === 'string') {
+          selector = new Selector(selector);
+          match = function (item) {
+            return selector.match(item);
+          };
+        } else {
+          match = selector;
+        }
+        for (i = 0, l = self.length; i < l; i++) {
+          item = self[i];
+          if (match(item)) {
+            matches.push(item);
+          }
+        }
+        return new Collection$1(matches);
+      },
+      slice: function () {
+        return new Collection$1(slice.apply(this, arguments));
+      },
+      eq: function (index) {
+        return index === -1 ? this.slice(index) : this.slice(index, +index + 1);
+      },
+      each: function (callback) {
+        global$2.each(this, callback);
+        return this;
+      },
+      toArray: function () {
+        return global$2.toArray(this);
+      },
+      indexOf: function (ctrl) {
+        var self = this;
+        var i = self.length;
+        while (i--) {
+          if (self[i] === ctrl) {
+            break;
+          }
+        }
+        return i;
+      },
+      reverse: function () {
+        return new Collection$1(global$2.toArray(this).reverse());
+      },
+      hasClass: function (cls) {
+        return this[0] ? this[0].classes.contains(cls) : false;
+      },
+      prop: function (name, value) {
+        var self = this;
+        var item;
+        if (value !== undefined) {
+          self.each(function (item) {
+            if (item[name]) {
+              item[name](value);
+            }
+          });
+          return self;
+        }
+        item = self[0];
+        if (item && item[name]) {
+          return item[name]();
+        }
+      },
+      exec: function (name) {
+        var self = this, args = global$2.toArray(arguments).slice(1);
+        self.each(function (item) {
+          if (item[name]) {
+            item[name].apply(item, args);
+          }
+        });
+        return self;
+      },
+      remove: function () {
+        var i = this.length;
+        while (i--) {
+          this[i].remove();
+        }
+        return this;
+      },
+      addClass: function (cls) {
+        return this.each(function (item) {
+          item.classes.add(cls);
+        });
+      },
+      removeClass: function (cls) {
+        return this.each(function (item) {
+          item.classes.remove(cls);
+        });
+      }
+    };
+    global$2.each('fire on off show hide append prepend before after reflow'.split(' '), function (name) {
+      proto[name] = function () {
+        var args = global$2.toArray(arguments);
+        this.each(function (ctrl) {
+          if (name in ctrl) {
+            ctrl[name].apply(ctrl, args);
+          }
+        });
+        return this;
+      };
+    });
+    global$2.each('text name disabled active selected checked visible parent value data'.split(' '), function (name) {
+      proto[name] = function (value) {
+        return this.prop(name, value);
+      };
+    });
+    Collection$1 = global$a.extend(proto);
+    Selector.Collection = Collection$1;
+    var Collection$2 = Collection$1;
+
+    var Binding = function (settings) {
+      this.create = settings.create;
+    };
+    Binding.create = function (model, name) {
+      return new Binding({
+        create: function (otherModel, otherName) {
+          var bindings;
+          var fromSelfToOther = function (e) {
+            otherModel.set(otherName, e.value);
+          };
+          var fromOtherToSelf = function (e) {
+            model.set(name, e.value);
+          };
+          otherModel.on('change:' + otherName, fromOtherToSelf);
+          model.on('change:' + name, fromSelfToOther);
+          bindings = otherModel._bindings;
+          if (!bindings) {
+            bindings = otherModel._bindings = [];
+            otherModel.on('destroy', function () {
+              var i = bindings.length;
+              while (i--) {
+                bindings[i]();
+              }
+            });
+          }
+          bindings.push(function () {
+            model.off('change:' + name, fromSelfToOther);
+          });
+          return model.get(name);
+        }
+      });
+    };
+
+    var global$c = tinymce.util.Tools.resolve('tinymce.util.Observable');
+
+    function isNode(node) {
+      return node.nodeType > 0;
+    }
+    function isEqual(a, b) {
+      var k, checked;
+      if (a === b) {
+        return true;
+      }
+      if (a === null || b === null) {
+        return a === b;
+      }
+      if (typeof a !== 'object' || typeof b !== 'object') {
+        return a === b;
+      }
+      if (global$2.isArray(b)) {
+        if (a.length !== b.length) {
+          return false;
+        }
+        k = a.length;
+        while (k--) {
+          if (!isEqual(a[k], b[k])) {
+            return false;
+          }
+        }
+      }
+      if (isNode(a) || isNode(b)) {
+        return a === b;
+      }
+      checked = {};
+      for (k in b) {
+        if (!isEqual(a[k], b[k])) {
+          return false;
+        }
+        checked[k] = true;
+      }
+      for (k in a) {
+        if (!checked[k] && !isEqual(a[k], b[k])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    var ObservableObject = global$a.extend({
+      Mixins: [global$c],
+      init: function (data) {
+        var name, value;
+        data = data || {};
+        for (name in data) {
+          value = data[name];
+          if (value instanceof Binding) {
+            data[name] = value.create(this, name);
+          }
+        }
+        this.data = data;
+      },
+      set: function (name, value) {
+        var key, args;
+        var oldValue = this.data[name];
+        if (value instanceof Binding) {
+          value = value.create(this, name);
+        }
+        if (typeof name === 'object') {
+          for (key in name) {
+            this.set(key, name[key]);
+          }
+          return this;
+        }
+        if (!isEqual(oldValue, value)) {
+          this.data[name] = value;
+          args = {
+            target: this,
+            name: name,
+            value: value,
+            oldValue: oldValue
+          };
+          this.fire('change:' + name, args);
+          this.fire('change', args);
+        }
+        return this;
+      },
+      get: function (name) {
+        return this.data[name];
+      },
+      has: function (name) {
+        return name in this.data;
+      },
+      bind: function (name) {
+        return Binding.create(this, name);
+      },
+      destroy: function () {
+        this.fire('destroy');
+      }
+    });
+
+    var dirtyCtrls = {}, animationFrameRequested;
+    var ReflowQueue = {
+      add: function (ctrl) {
+        var parent = ctrl.parent();
+        if (parent) {
+          if (!parent._layout || parent._layout.isNative()) {
+            return;
+          }
+          if (!dirtyCtrls[parent._id]) {
+            dirtyCtrls[parent._id] = parent;
+          }
+          if (!animationFrameRequested) {
+            animationFrameRequested = true;
+            global$7.requestAnimationFrame(function () {
+              var id, ctrl;
+              animationFrameRequested = false;
+              for (id in dirtyCtrls) {
+                ctrl = dirtyCtrls[id];
+                if (ctrl.state.get('rendered')) {
+                  ctrl.reflow();
+                }
+              }
+              dirtyCtrls = {};
+            }, domGlobals.document.body);
+          }
+        }
+      },
+      remove: function (ctrl) {
+        if (dirtyCtrls[ctrl._id]) {
+          delete dirtyCtrls[ctrl._id];
+        }
+      }
+    };
+
+    var hasMouseWheelEventSupport = 'onmousewheel' in domGlobals.document;
+    var hasWheelEventSupport = false;
+    var classPrefix = 'mce-';
+    var Control, idCounter = 0;
+    var proto$1 = {
+      Statics: { classPrefix: classPrefix },
+      isRtl: function () {
+        return Control.rtl;
+      },
+      classPrefix: classPrefix,
+      init: function (settings) {
+        var self = this;
+        var classes, defaultClasses;
+        function applyClasses(classes) {
+          var i;
+          classes = classes.split(' ');
+          for (i = 0; i < classes.length; i++) {
+            self.classes.add(classes[i]);
+          }
+        }
+        self.settings = settings = global$2.extend({}, self.Defaults, settings);
+        self._id = settings.id || 'mceu_' + idCounter++;
+        self._aria = { role: settings.role };
+        self._elmCache = {};
+        self.$ = global$9;
+        self.state = new ObservableObject({
+          visible: true,
+          active: false,
+          disabled: false,
+          value: ''
+        });
+        self.data = new ObservableObject(settings.data);
+        self.classes = new ClassList(function () {
+          if (self.state.get('rendered')) {
+            self.getEl().className = this.toString();
+          }
+        });
+        self.classes.prefix = self.classPrefix;
+        classes = settings.classes;
+        if (classes) {
+          if (self.Defaults) {
+            defaultClasses = self.Defaults.classes;
+            if (defaultClasses && classes !== defaultClasses) {
+              applyClasses(defaultClasses);
+            }
+          }
+          applyClasses(classes);
+        }
+        global$2.each('title text name visible disabled active value'.split(' '), function (name) {
+          if (name in settings) {
+            self[name](settings[name]);
+          }
+        });
+        self.on('click', function () {
+          if (self.disabled()) {
+            return false;
+          }
+        });
+        self.settings = settings;
+        self.borderBox = BoxUtils.parseBox(settings.border);
+        self.paddingBox = BoxUtils.parseBox(settings.padding);
+        self.marginBox = BoxUtils.parseBox(settings.margin);
+        if (settings.hidden) {
+          self.hide();
+        }
+      },
+      Properties: 'parent,name',
+      getContainerElm: function () {
+        var uiContainer = UiContainer.getUiContainer(this);
+        return uiContainer ? uiContainer : funcs.getContainer();
+      },
+      getParentCtrl: function (elm) {
+        var ctrl;
+        var lookup = this.getRoot().controlIdLookup;
+        while (elm && lookup) {
+          ctrl = lookup[elm.id];
+          if (ctrl) {
+            break;
+          }
+          elm = elm.parentNode;
+        }
+        return ctrl;
+      },
+      initLayoutRect: function () {
+        var self = this;
+        var settings = self.settings;
+        var borderBox, layoutRect;
+        var elm = self.getEl();
+        var width, height, minWidth, minHeight, autoResize;
+        var startMinWidth, startMinHeight, initialSize;
+        borderBox = self.borderBox = self.borderBox || BoxUtils.measureBox(elm, 'border');
+        self.paddingBox = self.paddingBox || BoxUtils.measureBox(elm, 'padding');
+        self.marginBox = self.marginBox || BoxUtils.measureBox(elm, 'margin');
+        initialSize = funcs.getSize(elm);
+        startMinWidth = settings.minWidth;
+        startMinHeight = settings.minHeight;
+        minWidth = startMinWidth || initialSize.width;
+        minHeight = startMinHeight || initialSize.height;
+        width = settings.width;
+        height = settings.height;
+        autoResize = settings.autoResize;
+        autoResize = typeof autoResize !== 'undefined' ? autoResize : !width && !height;
+        width = width || minWidth;
+        height = height || minHeight;
+        var deltaW = borderBox.left + borderBox.right;
+        var deltaH = borderBox.top + borderBox.bottom;
+        var maxW = settings.maxWidth || 65535;
+        var maxH = settings.maxHeight || 65535;
+        self._layoutRect = layoutRect = {
+          x: settings.x || 0,
+          y: settings.y || 0,
+          w: width,
+          h: height,
+          deltaW: deltaW,
+          deltaH: deltaH,
+          contentW: width - deltaW,
+          contentH: height - deltaH,
+          innerW: width - deltaW,
+          innerH: height - deltaH,
+          startMinWidth: startMinWidth || 0,
+          startMinHeight: startMinHeight || 0,
+          minW: Math.min(minWidth, maxW),
+          minH: Math.min(minHeight, maxH),
+          maxW: maxW,
+          maxH: maxH,
+          autoResize: autoResize,
+          scrollW: 0
+        };
+        self._lastLayoutRect = {};
+        return layoutRect;
+      },
+      layoutRect: function (newRect) {
+        var self = this;
+        var curRect = self._layoutRect, lastLayoutRect, size, deltaWidth, deltaHeight, repaintControls;
+        if (!curRect) {
+          curRect = self.initLayoutRect();
+        }
+        if (newRect) {
+          deltaWidth = curRect.deltaW;
+          deltaHeight = curRect.deltaH;
+          if (newRect.x !== undefined) {
+            curRect.x = newRect.x;
+          }
+          if (newRect.y !== undefined) {
+            curRect.y = newRect.y;
+          }
+          if (newRect.minW !== undefined) {
+            curRect.minW = newRect.minW;
+          }
+          if (newRect.minH !== undefined) {
+            curRect.minH = newRect.minH;
+          }
+          size = newRect.w;
+          if (size !== undefined) {
+            size = size < curRect.minW ? curRect.minW : size;
+            size = size > curRect.maxW ? curRect.maxW : size;
+            curRect.w = size;
+            curRect.innerW = size - deltaWidth;
+          }
+          size = newRect.h;
+          if (size !== undefined) {
+            size = size < curRect.minH ? curRect.minH : size;
+            size = size > curRect.maxH ? curRect.maxH : size;
+            curRect.h = size;
+            curRect.innerH = size - deltaHeight;
+          }
+          size = newRect.innerW;
+          if (size !== undefined) {
+            size = size < curRect.minW - deltaWidth ? curRect.minW - deltaWidth : size;
+            size = size > curRect.maxW - deltaWidth ? curRect.maxW - deltaWidth : size;
+            curRect.innerW = size;
+            curRect.w = size + deltaWidth;
+          }
+          size = newRect.innerH;
+          if (size !== undefined) {
+            size = size < curRect.minH - deltaHeight ? curRect.minH - deltaHeight : size;
+            size = size > curRect.maxH - deltaHeight ? curRect.maxH - deltaHeight : size;
+            curRect.innerH = size;
+            curRect.h = size + deltaHeight;
+          }
+          if (newRect.contentW !== undefined) {
+            curRect.contentW = newRect.contentW;
+          }
+          if (newRect.contentH !== undefined) {
+            curRect.contentH = newRect.contentH;
+          }
+          lastLayoutRect = self._lastLayoutRect;
+          if (lastLayoutRect.x !== curRect.x || lastLayoutRect.y !== curRect.y || lastLayoutRect.w !== curRect.w || lastLayoutRect.h !== curRect.h) {
+            repaintControls = Control.repaintControls;
+            if (repaintControls) {
+              if (repaintControls.map && !repaintControls.map[self._id]) {
+                repaintControls.push(self);
+                repaintControls.map[self._id] = true;
+              }
+            }
+            lastLayoutRect.x = curRect.x;
+            lastLayoutRect.y = curRect.y;
+            lastLayoutRect.w = curRect.w;
+            lastLayoutRect.h = curRect.h;
+          }
+          return self;
+        }
+        return curRect;
+      },
+      repaint: function () {
+        var self = this;
+        var style, bodyStyle, bodyElm, rect, borderBox;
+        var borderW, borderH, lastRepaintRect, round, value;
+        round = !domGlobals.document.createRange ? Math.round : function (value) {
+          return value;
+        };
+        style = self.getEl().style;
+        rect = self._layoutRect;
+        lastRepaintRect = self._lastRepaintRect || {};
+        borderBox = self.borderBox;
+        borderW = borderBox.left + borderBox.right;
+        borderH = borderBox.top + borderBox.bottom;
+        if (rect.x !== lastRepaintRect.x) {
+          style.left = round(rect.x) + 'px';
+          lastRepaintRect.x = rect.x;
+        }
+        if (rect.y !== lastRepaintRect.y) {
+          style.top = round(rect.y) + 'px';
+          lastRepaintRect.y = rect.y;
+        }
+        if (rect.w !== lastRepaintRect.w) {
+          value = round(rect.w - borderW);
+          style.width = (value >= 0 ? value : 0) + 'px';
+          lastRepaintRect.w = rect.w;
+        }
+        if (rect.h !== lastRepaintRect.h) {
+          value = round(rect.h - borderH);
+          style.height = (value >= 0 ? value : 0) + 'px';
+          lastRepaintRect.h = rect.h;
+        }
+        if (self._hasBody && rect.innerW !== lastRepaintRect.innerW) {
+          value = round(rect.innerW);
+          bodyElm = self.getEl('body');
+          if (bodyElm) {
+            bodyStyle = bodyElm.style;
+            bodyStyle.width = (value >= 0 ? value : 0) + 'px';
+          }
+          lastRepaintRect.innerW = rect.innerW;
+        }
+        if (self._hasBody && rect.innerH !== lastRepaintRect.innerH) {
+          value = round(rect.innerH);
+          bodyElm = bodyElm || self.getEl('body');
+          if (bodyElm) {
+            bodyStyle = bodyStyle || bodyElm.style;
+            bodyStyle.height = (value >= 0 ? value : 0) + 'px';
+          }
+          lastRepaintRect.innerH = rect.innerH;
+        }
+        self._lastRepaintRect = lastRepaintRect;
+        self.fire('repaint', {}, false);
+      },
+      updateLayoutRect: function () {
+        var self = this;
+        self.parent()._lastRect = null;
+        funcs.css(self.getEl(), {
+          width: '',
+          height: ''
+        });
+        self._layoutRect = self._lastRepaintRect = self._lastLayoutRect = null;
+        self.initLayoutRect();
+      },
+      on: function (name, callback) {
+        var self = this;
+        function resolveCallbackName(name) {
+          var callback, scope;
+          if (typeof name !== 'string') {
+            return name;
+          }
+          return function (e) {
+            if (!callback) {
+              self.parentsAndSelf().each(function (ctrl) {
+                var callbacks = ctrl.settings.callbacks;
+                if (callbacks && (callback = callbacks[name])) {
+                  scope = ctrl;
+                  return false;
+                }
+              });
+            }
+            if (!callback) {
+              e.action = name;
+              this.fire('execute', e);
+              return;
+            }
+            return callback.call(scope, e);
+          };
+        }
+        getEventDispatcher(self).on(name, resolveCallbackName(callback));
+        return self;
+      },
+      off: function (name, callback) {
+        getEventDispatcher(this).off(name, callback);
+        return this;
+      },
+      fire: function (name, args, bubble) {
+        var self = this;
+        args = args || {};
+        if (!args.control) {
+          args.control = self;
+        }
+        args = getEventDispatcher(self).fire(name, args);
+        if (bubble !== false && self.parent) {
+          var parent = self.parent();
+          while (parent && !args.isPropagationStopped()) {
+            parent.fire(name, args, false);
+            parent = parent.parent();
+          }
+        }
+        return args;
+      },
+      hasEventListeners: function (name) {
+        return getEventDispatcher(this).has(name);
+      },
+      parents: function (selector) {
+        var self = this;
+        var ctrl, parents = new Collection$2();
+        for (ctrl = self.parent(); ctrl; ctrl = ctrl.parent()) {
+          parents.add(ctrl);
+        }
+        if (selector) {
+          parents = parents.filter(selector);
+        }
+        return parents;
+      },
+      parentsAndSelf: function (selector) {
+        return new Collection$2(this).add(this.parents(selector));
+      },
+      next: function () {
+        var parentControls = this.parent().items();
+        return parentControls[parentControls.indexOf(this) + 1];
+      },
+      prev: function () {
+        var parentControls = this.parent().items();
+        return parentControls[parentControls.indexOf(this) - 1];
+      },
+      innerHtml: function (html) {
+        this.$el.html(html);
+        return this;
+      },
+      getEl: function (suffix) {
+        var id = suffix ? this._id + '-' + suffix : this._id;
+        if (!this._elmCache[id]) {
+          this._elmCache[id] = global$9('#' + id)[0];
+        }
+        return this._elmCache[id];
+      },
+      show: function () {
+        return this.visible(true);
+      },
+      hide: function () {
+        return this.visible(false);
+      },
+      focus: function () {
+        try {
+          this.getEl().focus();
+        } catch (ex) {
+        }
+        return this;
+      },
+      blur: function () {
+        this.getEl().blur();
+        return this;
+      },
+      aria: function (name, value) {
+        var self = this, elm = self.getEl(self.ariaTarget);
+        if (typeof value === 'undefined') {
+          return self._aria[name];
+        }
+        self._aria[name] = value;
+        if (self.state.get('rendered')) {
+          elm.setAttribute(name === 'role' ? name : 'aria-' + name, value);
+        }
+        return self;
+      },
+      encode: function (text, translate) {
+        if (translate !== false) {
+          text = this.translate(text);
+        }
+        return (text || '').replace(/[&<>"]/g, function (match) {
+          return '&#' + match.charCodeAt(0) + ';';
+        });
+      },
+      translate: function (text) {
+        return Control.translate ? Control.translate(text) : text;
+      },
+      before: function (items) {
+        var self = this, parent = self.parent();
+        if (parent) {
+          parent.insert(items, parent.items().indexOf(self), true);
+        }
+        return self;
+      },
+      after: function (items) {
+        var self = this, parent = self.parent();
+        if (parent) {
+          parent.insert(items, parent.items().indexOf(self));
+        }
+        return self;
+      },
+      remove: function () {
+        var self = this;
+        var elm = self.getEl();
+        var parent = self.parent();
+        var newItems, i;
+        if (self.items) {
+          var controls = self.items().toArray();
+          i = controls.length;
+          while (i--) {
+            controls[i].remove();
+          }
+        }
+        if (parent && parent.items) {
+          newItems = [];
+          parent.items().each(function (item) {
+            if (item !== self) {
+              newItems.push(item);
+            }
+          });
+          parent.items().set(newItems);
+          parent._lastRect = null;
+        }
+        if (self._eventsRoot && self._eventsRoot === self) {
+          global$9(elm).off();
+        }
+        var lookup = self.getRoot().controlIdLookup;
+        if (lookup) {
+          delete lookup[self._id];
+        }
+        if (elm && elm.parentNode) {
+          elm.parentNode.removeChild(elm);
+        }
+        self.state.set('rendered', false);
+        self.state.destroy();
+        self.fire('remove');
+        return self;
+      },
+      renderBefore: function (elm) {
+        global$9(elm).before(this.renderHtml());
+        this.postRender();
+        return this;
+      },
+      renderTo: function (elm) {
+        global$9(elm || this.getContainerElm()).append(this.renderHtml());
+        this.postRender();
+        return this;
+      },
+      preRender: function () {
+      },
+      render: function () {
+      },
+      renderHtml: function () {
+        return '<div id="' + this._id + '" class="' + this.classes + '"></div>';
+      },
+      postRender: function () {
+        var self = this;
+        var settings = self.settings;
+        var elm, box, parent, name, parentEventsRoot;
+        self.$el = global$9(self.getEl());
+        self.state.set('rendered', true);
+        for (name in settings) {
+          if (name.indexOf('on') === 0) {
+            self.on(name.substr(2), settings[name]);
+          }
+        }
+        if (self._eventsRoot) {
+          for (parent = self.parent(); !parentEventsRoot && parent; parent = parent.parent()) {
+            parentEventsRoot = parent._eventsRoot;
+          }
+          if (parentEventsRoot) {
+            for (name in parentEventsRoot._nativeEvents) {
+              self._nativeEvents[name] = true;
+            }
+          }
+        }
+        bindPendingEvents(self);
+        if (settings.style) {
+          elm = self.getEl();
+          if (elm) {
+            elm.setAttribute('style', settings.style);
+            elm.style.cssText = settings.style;
+          }
+        }
+        if (self.settings.border) {
+          box = self.borderBox;
+          self.$el.css({
+            'border-top-width': box.top,
+            'border-right-width': box.right,
+            'border-bottom-width': box.bottom,
+            'border-left-width': box.left
+          });
+        }
+        var root = self.getRoot();
+        if (!root.controlIdLookup) {
+          root.controlIdLookup = {};
+        }
+        root.controlIdLookup[self._id] = self;
+        for (var key in self._aria) {
+          self.aria(key, self._aria[key]);
+        }
+        if (self.state.get('visible') === false) {
+          self.getEl().style.display = 'none';
+        }
+        self.bindStates();
+        self.state.on('change:visible', function (e) {
+          var state = e.value;
+          var parentCtrl;
+          if (self.state.get('rendered')) {
+            self.getEl().style.display = state === false ? 'none' : '';
+            self.getEl().getBoundingClientRect();
+          }
+          parentCtrl = self.parent();
+          if (parentCtrl) {
+            parentCtrl._lastRect = null;
+          }
+          self.fire(state ? 'show' : 'hide');
+          ReflowQueue.add(self);
+        });
+        self.fire('postrender', {}, false);
+      },
+      bindStates: function () {
+      },
+      scrollIntoView: function (align) {
+        function getOffset(elm, rootElm) {
+          var x, y, parent = elm;
+          x = y = 0;
+          while (parent && parent !== rootElm && parent.nodeType) {
+            x += parent.offsetLeft || 0;
+            y += parent.offsetTop || 0;
+            parent = parent.offsetParent;
+          }
+          return {
+            x: x,
+            y: y
+          };
+        }
+        var elm = this.getEl(), parentElm = elm.parentNode;
+        var x, y, width, height, parentWidth, parentHeight;
+        var pos = getOffset(elm, parentElm);
+        x = pos.x;
+        y = pos.y;
+        width = elm.offsetWidth;
+        height = elm.offsetHeight;
+        parentWidth = parentElm.clientWidth;
+        parentHeight = parentElm.clientHeight;
+        if (align === 'end') {
+          x -= parentWidth - width;
+          y -= parentHeight - height;
+        } else if (align === 'center') {
+          x -= parentWidth / 2 - width / 2;
+          y -= parentHeight / 2 - height / 2;
+        }
+        parentElm.scrollLeft = x;
+        parentElm.scrollTop = y;
+        return this;
+      },
+      getRoot: function () {
+        var ctrl = this, rootControl;
+        var parents = [];
+        while (ctrl) {
+          if (ctrl.rootControl) {
+            rootControl = ctrl.rootControl;
+            break;
+          }
+          parents.push(ctrl);
+          rootControl = ctrl;
+          ctrl = ctrl.parent();
+        }
+        if (!rootControl) {
+          rootControl = this;
+        }
+        var i = parents.length;
+        while (i--) {
+          parents[i].rootControl = rootControl;
+        }
+        return rootControl;
+      },
+      reflow: function () {
+        ReflowQueue.remove(this);
+        var parent = this.parent();
+        if (parent && parent._layout && !parent._layout.isNative()) {
+          parent.reflow();
+        }
+        return this;
+      }
+    };
+    global$2.each('text title visible disabled active value'.split(' '), function (name) {
+      proto$1[name] = function (value) {
+        if (arguments.length === 0) {
+          return this.state.get(name);
+        }
+        if (typeof value !== 'undefined') {
+          this.state.set(name, value);
+        }
+        return this;
+      };
+    });
+    Control = global$a.extend(proto$1);
+    function getEventDispatcher(obj) {
+      if (!obj._eventDispatcher) {
+        obj._eventDispatcher = new global$b({
+          scope: obj,
+          toggleEvent: function (name, state) {
+            if (state && global$b.isNative(name)) {
+              if (!obj._nativeEvents) {
+                obj._nativeEvents = {};
+              }
+              obj._nativeEvents[name] = true;
+              if (obj.state.get('rendered')) {
+                bindPendingEvents(obj);
+              }
+            }
+          }
+        });
+      }
+      return obj._eventDispatcher;
+    }
+    function bindPendingEvents(eventCtrl) {
+      var i, l, parents, eventRootCtrl, nativeEvents, name;
+      function delegate(e) {
+        var control = eventCtrl.getParentCtrl(e.target);
+        if (control) {
+          control.fire(e.type, e);
+        }
+      }
+      function mouseLeaveHandler() {
+        var ctrl = eventRootCtrl._lastHoverCtrl;
+        if (ctrl) {
+          ctrl.fire('mouseleave', { target: ctrl.getEl() });
+          ctrl.parents().each(function (ctrl) {
+            ctrl.fire('mouseleave', { target: ctrl.getEl() });
+          });
+          eventRootCtrl._lastHoverCtrl = null;
+        }
+      }
+      function mouseEnterHandler(e) {
+        var ctrl = eventCtrl.getParentCtrl(e.target), lastCtrl = eventRootCtrl._lastHoverCtrl, idx = 0, i, parents, lastParents;
+        if (ctrl !== lastCtrl) {
+          eventRootCtrl._lastHoverCtrl = ctrl;
+          parents = ctrl.parents().toArray().reverse();
+          parents.push(ctrl);
+          if (lastCtrl) {
+            lastParents = lastCtrl.parents().toArray().reverse();
+            lastParents.push(lastCtrl);
+            for (idx = 0; idx < lastParents.length; idx++) {
+              if (parents[idx] !== lastParents[idx]) {
+                break;
+              }
+            }
+            for (i = lastParents.length - 1; i >= idx; i--) {
+              lastCtrl = lastParents[i];
+              lastCtrl.fire('mouseleave', { target: lastCtrl.getEl() });
+            }
+          }
+          for (i = idx; i < parents.length; i++) {
+            ctrl = parents[i];
+            ctrl.fire('mouseenter', { target: ctrl.getEl() });
+          }
+        }
+      }
+      function fixWheelEvent(e) {
+        e.preventDefault();
+        if (e.type === 'mousewheel') {
+          e.deltaY = -1 / 40 * e.wheelDelta;
+          if (e.wheelDeltaX) {
+            e.deltaX = -1 / 40 * e.wheelDeltaX;
+          }
+        } else {
+          e.deltaX = 0;
+          e.deltaY = e.detail;
+        }
+        e = eventCtrl.fire('wheel', e);
+      }
+      nativeEvents = eventCtrl._nativeEvents;
+      if (nativeEvents) {
+        parents = eventCtrl.parents().toArray();
+        parents.unshift(eventCtrl);
+        for (i = 0, l = parents.length; !eventRootCtrl && i < l; i++) {
+          eventRootCtrl = parents[i]._eventsRoot;
+        }
+        if (!eventRootCtrl) {
+          eventRootCtrl = parents[parents.length - 1] || eventCtrl;
+        }
+        eventCtrl._eventsRoot = eventRootCtrl;
+        for (l = i, i = 0; i < l; i++) {
+          parents[i]._eventsRoot = eventRootCtrl;
+        }
+        var eventRootDelegates = eventRootCtrl._delegates;
+        if (!eventRootDelegates) {
+          eventRootDelegates = eventRootCtrl._delegates = {};
+        }
+        for (name in nativeEvents) {
+          if (!nativeEvents) {
+            return false;
+          }
+          if (name === 'wheel' && !hasWheelEventSupport) {
+            if (hasMouseWheelEventSupport) {
+              global$9(eventCtrl.getEl()).on('mousewheel', fixWheelEvent);
+            } else {
+              global$9(eventCtrl.getEl()).on('DOMMouseScroll', fixWheelEvent);
+            }
+            continue;
+          }
+          if (name === 'mouseenter' || name === 'mouseleave') {
+            if (!eventRootCtrl._hasMouseEnter) {
+              global$9(eventRootCtrl.getEl()).on('mouseleave', mouseLeaveHandler).on('mouseover', mouseEnterHandler);
+              eventRootCtrl._hasMouseEnter = 1;
+            }
+          } else if (!eventRootDelegates[name]) {
+            global$9(eventRootCtrl.getEl()).on(name, delegate);
+            eventRootDelegates[name] = true;
+          }
+          nativeEvents[name] = false;
+        }
+      }
+    }
+    var Control$1 = Control;
+
+    var hasTabstopData = function (elm) {
+      return elm.getAttribute('data-mce-tabstop') ? true : false;
+    };
+    function KeyboardNavigation (settings) {
+      var root = settings.root;
+      var focusedElement, focusedControl;
+      function isElement(node) {
+        return node && node.nodeType === 1;
+      }
+      try {
+        focusedElement = domGlobals.document.activeElement;
+      } catch (ex) {
+        focusedElement = domGlobals.document.body;
+      }
+      focusedControl = root.getParentCtrl(focusedElement);
+      function getRole(elm) {
+        elm = elm || focusedElement;
+        if (isElement(elm)) {
+          return elm.getAttribute('role');
+        }
+        return null;
+      }
+      function getParentRole(elm) {
+        var role, parent = elm || focusedElement;
+        while (parent = parent.parentNode) {
+          if (role = getRole(parent)) {
+            return role;
+          }
+        }
+      }
+      function getAriaProp(name) {
+        var elm = focusedElement;
+        if (isElement(elm)) {
+          return elm.getAttribute('aria-' + name);
+        }
+      }
+      function isTextInputElement(elm) {
+        var tagName = elm.tagName.toUpperCase();
+        return tagName === 'INPUT' || tagName === 'TEXTAREA' || tagName === 'SELECT';
+      }
+      function canFocus(elm) {
+        if (isTextInputElement(elm) && !elm.hidden) {
+          return true;
+        }
+        if (hasTabstopData(elm)) {
+          return true;
+        }
+        if (/^(button|menuitem|checkbox|tab|menuitemcheckbox|option|gridcell|slider)$/.test(getRole(elm))) {
+          return true;
+        }
+        return false;
+      }
+      function getFocusElements(elm) {
+        var elements = [];
+        function collect(elm) {
+          if (elm.nodeType !== 1 || elm.style.display === 'none' || elm.disabled) {
+            return;
+          }
+          if (canFocus(elm)) {
+            elements.push(elm);
+          }
+          for (var i = 0; i < elm.childNodes.length; i++) {
+            collect(elm.childNodes[i]);
+          }
+        }
+        collect(elm || root.getEl());
+        return elements;
+      }
+      function getNavigationRoot(targetControl) {
+        var navigationRoot, controls;
+        targetControl = targetControl || focusedControl;
+        controls = targetControl.parents().toArray();
+        controls.unshift(targetControl);
+        for (var i = 0; i < controls.length; i++) {
+          navigationRoot = controls[i];
+          if (navigationRoot.settings.ariaRoot) {
+            break;
+          }
+        }
+        return navigationRoot;
+      }
+      function focusFirst(targetControl) {
+        var navigationRoot = getNavigationRoot(targetControl);
+        var focusElements = getFocusElements(navigationRoot.getEl());
+        if (navigationRoot.settings.ariaRemember && 'lastAriaIndex' in navigationRoot) {
+          moveFocusToIndex(navigationRoot.lastAriaIndex, focusElements);
+        } else {
+          moveFocusToIndex(0, focusElements);
+        }
+      }
+      function moveFocusToIndex(idx, elements) {
+        if (idx < 0) {
+          idx = elements.length - 1;
+        } else if (idx >= elements.length) {
+          idx = 0;
+        }
+        if (elements[idx]) {
+          elements[idx].focus();
+        }
+        return idx;
+      }
+      function moveFocus(dir, elements) {
+        var idx = -1;
+        var navigationRoot = getNavigationRoot();
+        elements = elements || getFocusElements(navigationRoot.getEl());
+        for (var i = 0; i < elements.length; i++) {
+          if (elements[i] === focusedElement) {
+            idx = i;
+          }
+        }
+        idx += dir;
+        navigationRoot.lastAriaIndex = moveFocusToIndex(idx, elements);
+      }
+      function left() {
+        var parentRole = getParentRole();
+        if (parentRole === 'tablist') {
+          moveFocus(-1, getFocusElements(focusedElement.parentNode));
+        } else if (focusedControl.parent().submenu) {
+          cancel();
+        } else {
+          moveFocus(-1);
+        }
+      }
+      function right() {
+        var role = getRole(), parentRole = getParentRole();
+        if (parentRole === 'tablist') {
+          moveFocus(1, getFocusElements(focusedElement.parentNode));
+        } else if (role === 'menuitem' && parentRole === 'menu' && getAriaProp('haspopup')) {
+          enter();
+        } else {
+          moveFocus(1);
+        }
+      }
+      function up() {
+        moveFocus(-1);
+      }
+      function down() {
+        var role = getRole(), parentRole = getParentRole();
+        if (role === 'menuitem' && parentRole === 'menubar') {
+          enter();
+        } else if (role === 'button' && getAriaProp('haspopup')) {
+          enter({ key: 'down' });
+        } else {
+          moveFocus(1);
+        }
+      }
+      function tab(e) {
+        var parentRole = getParentRole();
+        if (parentRole === 'tablist') {
+          var elm = getFocusElements(focusedControl.getEl('body'))[0];
+          if (elm) {
+            elm.focus();
+          }
+        } else {
+          moveFocus(e.shiftKey ? -1 : 1);
+        }
+      }
+      function cancel() {
+        focusedControl.fire('cancel');
+      }
+      function enter(aria) {
+        aria = aria || {};
+        focusedControl.fire('click', {
+          target: focusedElement,
+          aria: aria
+        });
+      }
+      root.on('keydown', function (e) {
+        function handleNonTabOrEscEvent(e, handler) {
+          if (isTextInputElement(focusedElement) || hasTabstopData(focusedElement)) {
+            return;
+          }
+          if (getRole(focusedElement) === 'slider') {
+            return;
+          }
+          if (handler(e) !== false) {
+            e.preventDefault();
+          }
+        }
+        if (e.isDefaultPrevented()) {
+          return;
+        }
+        switch (e.keyCode) {
+        case 37:
+          handleNonTabOrEscEvent(e, left);
+          break;
+        case 39:
+          handleNonTabOrEscEvent(e, right);
+          break;
+        case 38:
+          handleNonTabOrEscEvent(e, up);
+          break;
+        case 40:
+          handleNonTabOrEscEvent(e, down);
+          break;
+        case 27:
+          cancel();
+          break;
+        case 14:
+        case 13:
+        case 32:
+          handleNonTabOrEscEvent(e, enter);
+          break;
+        case 9:
+          tab(e);
+          e.preventDefault();
+          break;
+        }
+      });
+      root.on('focusin', function (e) {
+        focusedElement = e.target;
+        focusedControl = e.control;
+      });
+      return { focusFirst: focusFirst };
+    }
+
+    var selectorCache = {};
+    var Container = Control$1.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        settings = self.settings;
+        if (settings.fixed) {
+          self.state.set('fixed', true);
+        }
+        self._items = new Collection$2();
+        if (self.isRtl()) {
+          self.classes.add('rtl');
+        }
+        self.bodyClasses = new ClassList(function () {
+          if (self.state.get('rendered')) {
+            self.getEl('body').className = this.toString();
+          }
+        });
+        self.bodyClasses.prefix = self.classPrefix;
+        self.classes.add('container');
+        self.bodyClasses.add('container-body');
+        if (settings.containerCls) {
+          self.classes.add(settings.containerCls);
+        }
+        self._layout = global$4.create((settings.layout || '') + 'layout');
+        if (self.settings.items) {
+          self.add(self.settings.items);
+        } else {
+          self.add(self.render());
+        }
+        self._hasBody = true;
+      },
+      items: function () {
+        return this._items;
+      },
+      find: function (selector) {
+        selector = selectorCache[selector] = selectorCache[selector] || new Selector(selector);
+        return selector.find(this);
+      },
+      add: function (items) {
+        var self = this;
+        self.items().add(self.create(items)).parent(self);
+        return self;
+      },
+      focus: function (keyboard) {
+        var self = this;
+        var focusCtrl, keyboardNav, items;
+        if (keyboard) {
+          keyboardNav = self.keyboardNav || self.parents().eq(-1)[0].keyboardNav;
+          if (keyboardNav) {
+            keyboardNav.focusFirst(self);
+            return;
+          }
+        }
+        items = self.find('*');
+        if (self.statusbar) {
+          items.add(self.statusbar.items());
+        }
+        items.each(function (ctrl) {
+          if (ctrl.settings.autofocus) {
+            focusCtrl = null;
+            return false;
+          }
+          if (ctrl.canFocus) {
+            focusCtrl = focusCtrl || ctrl;
+          }
+        });
+        if (focusCtrl) {
+          focusCtrl.focus();
+        }
+        return self;
+      },
+      replace: function (oldItem, newItem) {
+        var ctrlElm;
+        var items = this.items();
+        var i = items.length;
+        while (i--) {
+          if (items[i] === oldItem) {
+            items[i] = newItem;
+            break;
+          }
+        }
+        if (i >= 0) {
+          ctrlElm = newItem.getEl();
+          if (ctrlElm) {
+            ctrlElm.parentNode.removeChild(ctrlElm);
+          }
+          ctrlElm = oldItem.getEl();
+          if (ctrlElm) {
+            ctrlElm.parentNode.removeChild(ctrlElm);
+          }
+        }
+        newItem.parent(this);
+      },
+      create: function (items) {
+        var self = this;
+        var settings;
+        var ctrlItems = [];
+        if (!global$2.isArray(items)) {
+          items = [items];
+        }
+        global$2.each(items, function (item) {
+          if (item) {
+            if (!(item instanceof Control$1)) {
+              if (typeof item === 'string') {
+                item = { type: item };
+              }
+              settings = global$2.extend({}, self.settings.defaults, item);
+              item.type = settings.type = settings.type || item.type || self.settings.defaultType || (settings.defaults ? settings.defaults.type : null);
+              item = global$4.create(settings);
+            }
+            ctrlItems.push(item);
+          }
+        });
+        return ctrlItems;
+      },
+      renderNew: function () {
+        var self = this;
+        self.items().each(function (ctrl, index) {
+          var containerElm;
+          ctrl.parent(self);
+          if (!ctrl.state.get('rendered')) {
+            containerElm = self.getEl('body');
+            if (containerElm.hasChildNodes() && index <= containerElm.childNodes.length - 1) {
+              global$9(containerElm.childNodes[index]).before(ctrl.renderHtml());
+            } else {
+              global$9(containerElm).append(ctrl.renderHtml());
+            }
+            ctrl.postRender();
+            ReflowQueue.add(ctrl);
+          }
+        });
+        self._layout.applyClasses(self.items().filter(':visible'));
+        self._lastRect = null;
+        return self;
+      },
+      append: function (items) {
+        return this.add(items).renderNew();
+      },
+      prepend: function (items) {
+        var self = this;
+        self.items().set(self.create(items).concat(self.items().toArray()));
+        return self.renderNew();
+      },
+      insert: function (items, index, before) {
+        var self = this;
+        var curItems, beforeItems, afterItems;
+        items = self.create(items);
+        curItems = self.items();
+        if (!before && index < curItems.length - 1) {
+          index += 1;
+        }
+        if (index >= 0 && index < curItems.length) {
+          beforeItems = curItems.slice(0, index).toArray();
+          afterItems = curItems.slice(index).toArray();
+          curItems.set(beforeItems.concat(items, afterItems));
+        }
+        return self.renderNew();
+      },
+      fromJSON: function (data) {
+        var self = this;
+        for (var name in data) {
+          self.find('#' + name).value(data[name]);
+        }
+        return self;
+      },
+      toJSON: function () {
+        var self = this, data = {};
+        self.find('*').each(function (ctrl) {
+          var name = ctrl.name(), value = ctrl.value();
+          if (name && typeof value !== 'undefined') {
+            data[name] = value;
+          }
+        });
+        return data;
+      },
+      renderHtml: function () {
+        var self = this, layout = self._layout, role = this.settings.role;
+        self.preRender();
+        layout.preRender(self);
+        return '<div id="' + self._id + '" class="' + self.classes + '"' + (role ? ' role="' + this.settings.role + '"' : '') + '>' + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        var box;
+        self.items().exec('postRender');
+        self._super();
+        self._layout.postRender(self);
+        self.state.set('rendered', true);
+        if (self.settings.style) {
+          self.$el.css(self.settings.style);
+        }
+        if (self.settings.border) {
+          box = self.borderBox;
+          self.$el.css({
+            'border-top-width': box.top,
+            'border-right-width': box.right,
+            'border-bottom-width': box.bottom,
+            'border-left-width': box.left
+          });
+        }
+        if (!self.parent()) {
+          self.keyboardNav = KeyboardNavigation({ root: self });
+        }
+        return self;
+      },
+      initLayoutRect: function () {
+        var self = this, layoutRect = self._super();
+        self._layout.recalc(self);
+        return layoutRect;
+      },
+      recalc: function () {
+        var self = this;
+        var rect = self._layoutRect;
+        var lastRect = self._lastRect;
+        if (!lastRect || lastRect.w !== rect.w || lastRect.h !== rect.h) {
+          self._layout.recalc(self);
+          rect = self.layoutRect();
+          self._lastRect = {
+            x: rect.x,
+            y: rect.y,
+            w: rect.w,
+            h: rect.h
+          };
+          return true;
+        }
+      },
+      reflow: function () {
+        var i;
+        ReflowQueue.remove(this);
+        if (this.visible()) {
+          Control$1.repaintControls = [];
+          Control$1.repaintControls.map = {};
+          this.recalc();
+          i = Control$1.repaintControls.length;
+          while (i--) {
+            Control$1.repaintControls[i].repaint();
+          }
+          if (this.settings.layout !== 'flow' && this.settings.layout !== 'stack') {
+            this.repaint();
+          }
+          Control$1.repaintControls = [];
+        }
+        return this;
+      }
+    });
+
+    function getDocumentSize(doc) {
+      var documentElement, body, scrollWidth, clientWidth;
+      var offsetWidth, scrollHeight, clientHeight, offsetHeight;
+      var max = Math.max;
+      documentElement = doc.documentElement;
+      body = doc.body;
+      scrollWidth = max(documentElement.scrollWidth, body.scrollWidth);
+      clientWidth = max(documentElement.clientWidth, body.clientWidth);
+      offsetWidth = max(documentElement.offsetWidth, body.offsetWidth);
+      scrollHeight = max(documentElement.scrollHeight, body.scrollHeight);
+      clientHeight = max(documentElement.clientHeight, body.clientHeight);
+      offsetHeight = max(documentElement.offsetHeight, body.offsetHeight);
+      return {
+        width: scrollWidth < offsetWidth ? clientWidth : scrollWidth,
+        height: scrollHeight < offsetHeight ? clientHeight : scrollHeight
+      };
+    }
+    function updateWithTouchData(e) {
+      var keys, i;
+      if (e.changedTouches) {
+        keys = 'screenX screenY pageX pageY clientX clientY'.split(' ');
+        for (i = 0; i < keys.length; i++) {
+          e[keys[i]] = e.changedTouches[0][keys[i]];
+        }
+      }
+    }
+    function DragHelper (id, settings) {
+      var $eventOverlay;
+      var doc = settings.document || domGlobals.document;
+      var downButton;
+      var start, stop, drag, startX, startY;
+      settings = settings || {};
+      var handleElement = doc.getElementById(settings.handle || id);
+      start = function (e) {
+        var docSize = getDocumentSize(doc);
+        var handleElm, cursor;
+        updateWithTouchData(e);
+        e.preventDefault();
+        downButton = e.button;
+        handleElm = handleElement;
+        startX = e.screenX;
+        startY = e.screenY;
+        if (domGlobals.window.getComputedStyle) {
+          cursor = domGlobals.window.getComputedStyle(handleElm, null).getPropertyValue('cursor');
+        } else {
+          cursor = handleElm.runtimeStyle.cursor;
+        }
+        $eventOverlay = global$9('<div></div>').css({
+          position: 'absolute',
+          top: 0,
+          left: 0,
+          width: docSize.width,
+          height: docSize.height,
+          zIndex: 2147483647,
+          opacity: 0.0001,
+          cursor: cursor
+        }).appendTo(doc.body);
+        global$9(doc).on('mousemove touchmove', drag).on('mouseup touchend', stop);
+        settings.start(e);
+      };
+      drag = function (e) {
+        updateWithTouchData(e);
+        if (e.button !== downButton) {
+          return stop(e);
+        }
+        e.deltaX = e.screenX - startX;
+        e.deltaY = e.screenY - startY;
+        e.preventDefault();
+        settings.drag(e);
+      };
+      stop = function (e) {
+        updateWithTouchData(e);
+        global$9(doc).off('mousemove touchmove', drag).off('mouseup touchend', stop);
+        $eventOverlay.remove();
+        if (settings.stop) {
+          settings.stop(e);
+        }
+      };
+      this.destroy = function () {
+        global$9(handleElement).off();
+      };
+      global$9(handleElement).on('mousedown touchstart', start);
+    }
+
+    var Scrollable = {
+      init: function () {
+        var self = this;
+        self.on('repaint', self.renderScroll);
+      },
+      renderScroll: function () {
+        var self = this, margin = 2;
+        function repaintScroll() {
+          var hasScrollH, hasScrollV, bodyElm;
+          function repaintAxis(axisName, posName, sizeName, contentSizeName, hasScroll, ax) {
+            var containerElm, scrollBarElm, scrollThumbElm;
+            var containerSize, scrollSize, ratio, rect;
+            var posNameLower, sizeNameLower;
+            scrollBarElm = self.getEl('scroll' + axisName);
+            if (scrollBarElm) {
+              posNameLower = posName.toLowerCase();
+              sizeNameLower = sizeName.toLowerCase();
+              global$9(self.getEl('absend')).css(posNameLower, self.layoutRect()[contentSizeName] - 1);
+              if (!hasScroll) {
+                global$9(scrollBarElm).css('display', 'none');
+                return;
+              }
+              global$9(scrollBarElm).css('display', 'block');
+              containerElm = self.getEl('body');
+              scrollThumbElm = self.getEl('scroll' + axisName + 't');
+              containerSize = containerElm['client' + sizeName] - margin * 2;
+              containerSize -= hasScrollH && hasScrollV ? scrollBarElm['client' + ax] : 0;
+              scrollSize = containerElm['scroll' + sizeName];
+              ratio = containerSize / scrollSize;
+              rect = {};
+              rect[posNameLower] = containerElm['offset' + posName] + margin;
+              rect[sizeNameLower] = containerSize;
+              global$9(scrollBarElm).css(rect);
+              rect = {};
+              rect[posNameLower] = containerElm['scroll' + posName] * ratio;
+              rect[sizeNameLower] = containerSize * ratio;
+              global$9(scrollThumbElm).css(rect);
+            }
+          }
+          bodyElm = self.getEl('body');
+          hasScrollH = bodyElm.scrollWidth > bodyElm.clientWidth;
+          hasScrollV = bodyElm.scrollHeight > bodyElm.clientHeight;
+          repaintAxis('h', 'Left', 'Width', 'contentW', hasScrollH, 'Height');
+          repaintAxis('v', 'Top', 'Height', 'contentH', hasScrollV, 'Width');
+        }
+        function addScroll() {
+          function addScrollAxis(axisName, posName, sizeName, deltaPosName, ax) {
+            var scrollStart;
+            var axisId = self._id + '-scroll' + axisName, prefix = self.classPrefix;
+            global$9(self.getEl()).append('<div id="' + axisId + '" class="' + prefix + 'scrollbar ' + prefix + 'scrollbar-' + axisName + '">' + '<div id="' + axisId + 't" class="' + prefix + 'scrollbar-thumb"></div>' + '</div>');
+            self.draghelper = new DragHelper(axisId + 't', {
+              start: function () {
+                scrollStart = self.getEl('body')['scroll' + posName];
+                global$9('#' + axisId).addClass(prefix + 'active');
+              },
+              drag: function (e) {
+                var ratio, hasScrollH, hasScrollV, containerSize;
+                var layoutRect = self.layoutRect();
+                hasScrollH = layoutRect.contentW > layoutRect.innerW;
+                hasScrollV = layoutRect.contentH > layoutRect.innerH;
+                containerSize = self.getEl('body')['client' + sizeName] - margin * 2;
+                containerSize -= hasScrollH && hasScrollV ? self.getEl('scroll' + axisName)['client' + ax] : 0;
+                ratio = containerSize / self.getEl('body')['scroll' + sizeName];
+                self.getEl('body')['scroll' + posName] = scrollStart + e['delta' + deltaPosName] / ratio;
+              },
+              stop: function () {
+                global$9('#' + axisId).removeClass(prefix + 'active');
+              }
+            });
+          }
+          self.classes.add('scroll');
+          addScrollAxis('v', 'Top', 'Height', 'Y', 'Width');
+          addScrollAxis('h', 'Left', 'Width', 'X', 'Height');
+        }
+        if (self.settings.autoScroll) {
+          if (!self._hasScroll) {
+            self._hasScroll = true;
+            addScroll();
+            self.on('wheel', function (e) {
+              var bodyEl = self.getEl('body');
+              bodyEl.scrollLeft += (e.deltaX || 0) * 10;
+              bodyEl.scrollTop += e.deltaY * 10;
+              repaintScroll();
+            });
+            global$9(self.getEl('body')).on('scroll', repaintScroll);
+          }
+          repaintScroll();
+        }
+      }
+    };
+
+    var Panel = Container.extend({
+      Defaults: {
+        layout: 'fit',
+        containerCls: 'panel'
+      },
+      Mixins: [Scrollable],
+      renderHtml: function () {
+        var self = this;
+        var layout = self._layout;
+        var innerHtml = self.settings.html;
+        self.preRender();
+        layout.preRender(self);
+        if (typeof innerHtml === 'undefined') {
+          innerHtml = '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + layout.renderHtml(self) + '</div>';
+        } else {
+          if (typeof innerHtml === 'function') {
+            innerHtml = innerHtml.call(self);
+          }
+          self._hasBody = false;
+        }
+        return '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1" role="group">' + (self._preBodyHtml || '') + innerHtml + '</div>';
+      }
+    });
+
+    var Resizable = {
+      resizeToContent: function () {
+        this._layoutRect.autoResize = true;
+        this._lastRect = null;
+        this.reflow();
+      },
+      resizeTo: function (w, h) {
+        if (w <= 1 || h <= 1) {
+          var rect = funcs.getWindowSize();
+          w = w <= 1 ? w * rect.w : w;
+          h = h <= 1 ? h * rect.h : h;
+        }
+        this._layoutRect.autoResize = false;
+        return this.layoutRect({
+          minW: w,
+          minH: h,
+          w: w,
+          h: h
+        }).reflow();
+      },
+      resizeBy: function (dw, dh) {
+        var self = this, rect = self.layoutRect();
+        return self.resizeTo(rect.w + dw, rect.h + dh);
+      }
+    };
+
+    var documentClickHandler, documentScrollHandler, windowResizeHandler;
+    var visiblePanels = [];
+    var zOrder = [];
+    var hasModal;
+    function isChildOf(ctrl, parent) {
+      while (ctrl) {
+        if (ctrl === parent) {
+          return true;
+        }
+        ctrl = ctrl.parent();
+      }
+    }
+    function skipOrHidePanels(e) {
+      var i = visiblePanels.length;
+      while (i--) {
+        var panel = visiblePanels[i], clickCtrl = panel.getParentCtrl(e.target);
+        if (panel.settings.autohide) {
+          if (clickCtrl) {
+            if (isChildOf(clickCtrl, panel) || panel.parent() === clickCtrl) {
+              continue;
+            }
+          }
+          e = panel.fire('autohide', { target: e.target });
+          if (!e.isDefaultPrevented()) {
+            panel.hide();
+          }
+        }
+      }
+    }
+    function bindDocumentClickHandler() {
+      if (!documentClickHandler) {
+        documentClickHandler = function (e) {
+          if (e.button === 2) {
+            return;
+          }
+          skipOrHidePanels(e);
+        };
+        global$9(domGlobals.document).on('click touchstart', documentClickHandler);
+      }
+    }
+    function bindDocumentScrollHandler() {
+      if (!documentScrollHandler) {
+        documentScrollHandler = function () {
+          var i;
+          i = visiblePanels.length;
+          while (i--) {
+            repositionPanel(visiblePanels[i]);
+          }
+        };
+        global$9(domGlobals.window).on('scroll', documentScrollHandler);
+      }
+    }
+    function bindWindowResizeHandler() {
+      if (!windowResizeHandler) {
+        var docElm_1 = domGlobals.document.documentElement;
+        var clientWidth_1 = docElm_1.clientWidth, clientHeight_1 = docElm_1.clientHeight;
+        windowResizeHandler = function () {
+          if (!domGlobals.document.all || clientWidth_1 !== docElm_1.clientWidth || clientHeight_1 !== docElm_1.clientHeight) {
+            clientWidth_1 = docElm_1.clientWidth;
+            clientHeight_1 = docElm_1.clientHeight;
+            FloatPanel.hideAll();
+          }
+        };
+        global$9(domGlobals.window).on('resize', windowResizeHandler);
+      }
+    }
+    function repositionPanel(panel) {
+      var scrollY = funcs.getViewPort().y;
+      function toggleFixedChildPanels(fixed, deltaY) {
+        var parent;
+        for (var i = 0; i < visiblePanels.length; i++) {
+          if (visiblePanels[i] !== panel) {
+            parent = visiblePanels[i].parent();
+            while (parent && (parent = parent.parent())) {
+              if (parent === panel) {
+                visiblePanels[i].fixed(fixed).moveBy(0, deltaY).repaint();
+              }
+            }
+          }
+        }
+      }
+      if (panel.settings.autofix) {
+        if (!panel.state.get('fixed')) {
+          panel._autoFixY = panel.layoutRect().y;
+          if (panel._autoFixY < scrollY) {
+            panel.fixed(true).layoutRect({ y: 0 }).repaint();
+            toggleFixedChildPanels(true, scrollY - panel._autoFixY);
+          }
+        } else {
+          if (panel._autoFixY > scrollY) {
+            panel.fixed(false).layoutRect({ y: panel._autoFixY }).repaint();
+            toggleFixedChildPanels(false, panel._autoFixY - scrollY);
+          }
+        }
+      }
+    }
+    function addRemove(add, ctrl) {
+      var i, zIndex = FloatPanel.zIndex || 65535, topModal;
+      if (add) {
+        zOrder.push(ctrl);
+      } else {
+        i = zOrder.length;
+        while (i--) {
+          if (zOrder[i] === ctrl) {
+            zOrder.splice(i, 1);
+          }
+        }
+      }
+      if (zOrder.length) {
+        for (i = 0; i < zOrder.length; i++) {
+          if (zOrder[i].modal) {
+            zIndex++;
+            topModal = zOrder[i];
+          }
+          zOrder[i].getEl().style.zIndex = zIndex;
+          zOrder[i].zIndex = zIndex;
+          zIndex++;
+        }
+      }
+      var modalBlockEl = global$9('#' + ctrl.classPrefix + 'modal-block', ctrl.getContainerElm())[0];
+      if (topModal) {
+        global$9(modalBlockEl).css('z-index', topModal.zIndex - 1);
+      } else if (modalBlockEl) {
+        modalBlockEl.parentNode.removeChild(modalBlockEl);
+        hasModal = false;
+      }
+      FloatPanel.currentZIndex = zIndex;
+    }
+    var FloatPanel = Panel.extend({
+      Mixins: [
+        Movable,
+        Resizable
+      ],
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self._eventsRoot = self;
+        self.classes.add('floatpanel');
+        if (settings.autohide) {
+          bindDocumentClickHandler();
+          bindWindowResizeHandler();
+          visiblePanels.push(self);
+        }
+        if (settings.autofix) {
+          bindDocumentScrollHandler();
+          self.on('move', function () {
+            repositionPanel(this);
+          });
+        }
+        self.on('postrender show', function (e) {
+          if (e.control === self) {
+            var $modalBlockEl_1;
+            var prefix_1 = self.classPrefix;
+            if (self.modal && !hasModal) {
+              $modalBlockEl_1 = global$9('#' + prefix_1 + 'modal-block', self.getContainerElm());
+              if (!$modalBlockEl_1[0]) {
+                $modalBlockEl_1 = global$9('<div id="' + prefix_1 + 'modal-block" class="' + prefix_1 + 'reset ' + prefix_1 + 'fade"></div>').appendTo(self.getContainerElm());
+              }
+              global$7.setTimeout(function () {
+                $modalBlockEl_1.addClass(prefix_1 + 'in');
+                global$9(self.getEl()).addClass(prefix_1 + 'in');
+              });
+              hasModal = true;
+            }
+            addRemove(true, self);
+          }
+        });
+        self.on('show', function () {
+          self.parents().each(function (ctrl) {
+            if (ctrl.state.get('fixed')) {
+              self.fixed(true);
+              return false;
+            }
+          });
+        });
+        if (settings.popover) {
+          self._preBodyHtml = '<div class="' + self.classPrefix + 'arrow"></div>';
+          self.classes.add('popover').add('bottom').add(self.isRtl() ? 'end' : 'start');
+        }
+        self.aria('label', settings.ariaLabel);
+        self.aria('labelledby', self._id);
+        self.aria('describedby', self.describedBy || self._id + '-none');
+      },
+      fixed: function (state) {
+        var self = this;
+        if (self.state.get('fixed') !== state) {
+          if (self.state.get('rendered')) {
+            var viewport = funcs.getViewPort();
+            if (state) {
+              self.layoutRect().y -= viewport.y;
+            } else {
+              self.layoutRect().y += viewport.y;
+            }
+          }
+          self.classes.toggle('fixed', state);
+          self.state.set('fixed', state);
+        }
+        return self;
+      },
+      show: function () {
+        var self = this;
+        var i;
+        var state = self._super();
+        i = visiblePanels.length;
+        while (i--) {
+          if (visiblePanels[i] === self) {
+            break;
+          }
+        }
+        if (i === -1) {
+          visiblePanels.push(self);
+        }
+        return state;
+      },
+      hide: function () {
+        removeVisiblePanel(this);
+        addRemove(false, this);
+        return this._super();
+      },
+      hideAll: function () {
+        FloatPanel.hideAll();
+      },
+      close: function () {
+        var self = this;
+        if (!self.fire('close').isDefaultPrevented()) {
+          self.remove();
+          addRemove(false, self);
+        }
+        return self;
+      },
+      remove: function () {
+        removeVisiblePanel(this);
+        this._super();
+      },
+      postRender: function () {
+        var self = this;
+        if (self.settings.bodyRole) {
+          this.getEl('body').setAttribute('role', self.settings.bodyRole);
+        }
+        return self._super();
+      }
+    });
+    FloatPanel.hideAll = function () {
+      var i = visiblePanels.length;
+      while (i--) {
+        var panel = visiblePanels[i];
+        if (panel && panel.settings.autohide) {
+          panel.hide();
+          visiblePanels.splice(i, 1);
+        }
+      }
+    };
+    function removeVisiblePanel(panel) {
+      var i;
+      i = visiblePanels.length;
+      while (i--) {
+        if (visiblePanels[i] === panel) {
+          visiblePanels.splice(i, 1);
+        }
+      }
+      i = zOrder.length;
+      while (i--) {
+        if (zOrder[i] === panel) {
+          zOrder.splice(i, 1);
+        }
+      }
+    }
+
+    var isFixed$1 = function (inlineToolbarContainer, editor) {
+      return !!(inlineToolbarContainer && !editor.settings.ui_container);
+    };
+    var render$1 = function (editor, theme, args) {
+      var panel, inlineToolbarContainer;
+      var DOM = global$3.DOM;
+      var fixedToolbarContainer = getFixedToolbarContainer(editor);
+      if (fixedToolbarContainer) {
+        inlineToolbarContainer = DOM.select(fixedToolbarContainer)[0];
+      }
+      var reposition = function () {
+        if (panel && panel.moveRel && panel.visible() && !panel._fixed) {
+          var scrollContainer = editor.selection.getScrollContainer(), body = editor.getBody();
+          var deltaX = 0, deltaY = 0;
+          if (scrollContainer) {
+            var bodyPos = DOM.getPos(body), scrollContainerPos = DOM.getPos(scrollContainer);
+            deltaX = Math.max(0, scrollContainerPos.x - bodyPos.x);
+            deltaY = Math.max(0, scrollContainerPos.y - bodyPos.y);
+          }
+          panel.fixed(false).moveRel(body, editor.rtl ? [
+            'tr-br',
+            'br-tr'
+          ] : [
+            'tl-bl',
+            'bl-tl',
+            'tr-br'
+          ]).moveBy(deltaX, deltaY);
+        }
+      };
+      var show = function () {
+        if (panel) {
+          panel.show();
+          reposition();
+          DOM.addClass(editor.getBody(), 'mce-edit-focus');
+        }
+      };
+      var hide = function () {
+        if (panel) {
+          panel.hide();
+          FloatPanel.hideAll();
+          DOM.removeClass(editor.getBody(), 'mce-edit-focus');
+        }
+      };
+      var render = function () {
+        if (panel) {
+          if (!panel.visible()) {
+            show();
+          }
+          return;
+        }
+        panel = theme.panel = global$4.create({
+          type: inlineToolbarContainer ? 'panel' : 'floatpanel',
+          role: 'application',
+          classes: 'tinymce tinymce-inline',
+          layout: 'flex',
+          direction: 'column',
+          align: 'stretch',
+          autohide: false,
+          autofix: true,
+          fixed: isFixed$1(inlineToolbarContainer, editor),
+          border: 1,
+          items: [
+            hasMenubar(editor) === false ? null : {
+              type: 'menubar',
+              border: '0 0 1 0',
+              items: Menubar.createMenuButtons(editor)
+            },
+            Toolbar.createToolbars(editor, getToolbarSize(editor))
+          ]
+        });
+        UiContainer.setUiContainer(editor, panel);
+        Events.fireBeforeRenderUI(editor);
+        if (inlineToolbarContainer) {
+          panel.renderTo(inlineToolbarContainer).reflow();
+        } else {
+          panel.renderTo().reflow();
+        }
+        A11y.addKeys(editor, panel);
+        show();
+        ContextToolbars.addContextualToolbars(editor);
+        editor.on('nodeChange', reposition);
+        editor.on('ResizeWindow', reposition);
+        editor.on('activate', show);
+        editor.on('deactivate', hide);
+        editor.nodeChanged();
+      };
+      editor.settings.content_editable = true;
+      editor.on('focus', function () {
+        if (isSkinDisabled(editor) === false && args.skinUiCss) {
+          DOM.styleSheetLoader.load(args.skinUiCss, render, render);
+        } else {
+          render();
+        }
+      });
+      editor.on('blur hide', hide);
+      editor.on('remove', function () {
+        if (panel) {
+          panel.remove();
+          panel = null;
+        }
+      });
+      if (isSkinDisabled(editor) === false && args.skinUiCss) {
+        DOM.styleSheetLoader.load(args.skinUiCss, SkinLoaded.fireSkinLoaded(editor));
+      } else {
+        SkinLoaded.fireSkinLoaded(editor)();
+      }
+      return {};
+    };
+    var Inline = { render: render$1 };
+
+    function Throbber (elm, inline) {
+      var self = this;
+      var state;
+      var classPrefix = Control$1.classPrefix;
+      var timer;
+      self.show = function (time, callback) {
+        function render() {
+          if (state) {
+            global$9(elm).append('<div class="' + classPrefix + 'throbber' + (inline ? ' ' + classPrefix + 'throbber-inline' : '') + '"></div>');
+            if (callback) {
+              callback();
+            }
+          }
+        }
+        self.hide();
+        state = true;
+        if (time) {
+          timer = global$7.setTimeout(render, time);
+        } else {
+          render();
+        }
+        return self;
+      };
+      self.hide = function () {
+        var child = elm.lastChild;
+        global$7.clearTimeout(timer);
+        if (child && child.className.indexOf('throbber') !== -1) {
+          child.parentNode.removeChild(child);
+        }
+        state = false;
+        return self;
+      };
+    }
+
+    var setup = function (editor, theme) {
+      var throbber;
+      editor.on('ProgressState', function (e) {
+        throbber = throbber || new Throbber(theme.panel.getEl('body'));
+        if (e.state) {
+          throbber.show(e.time);
+        } else {
+          throbber.hide();
+        }
+      });
+    };
+    var ProgressState = { setup: setup };
+
+    var renderUI = function (editor, theme, args) {
+      var skinUrl = getSkinUrl(editor);
+      if (skinUrl) {
+        args.skinUiCss = skinUrl + '/skin.min.css';
+        editor.contentCSS.push(skinUrl + '/content' + (editor.inline ? '.inline' : '') + '.min.css');
+      }
+      ProgressState.setup(editor, theme);
+      return isInline(editor) ? Inline.render(editor, theme, args) : Iframe.render(editor, theme, args);
+    };
+    var Render = { renderUI: renderUI };
+
+    var Tooltip = Control$1.extend({
+      Mixins: [Movable],
+      Defaults: { classes: 'widget tooltip tooltip-n' },
+      renderHtml: function () {
+        var self = this, prefix = self.classPrefix;
+        return '<div id="' + self._id + '" class="' + self.classes + '" role="presentation">' + '<div class="' + prefix + 'tooltip-arrow"></div>' + '<div class="' + prefix + 'tooltip-inner">' + self.encode(self.state.get('text')) + '</div>' + '</div>';
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:text', function (e) {
+          self.getEl().lastChild.innerHTML = self.encode(e.value);
+        });
+        return self._super();
+      },
+      repaint: function () {
+        var self = this;
+        var style, rect;
+        style = self.getEl().style;
+        rect = self._layoutRect;
+        style.left = rect.x + 'px';
+        style.top = rect.y + 'px';
+        style.zIndex = 65535 + 65535;
+      }
+    });
+
+    var Widget = Control$1.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        settings = self.settings;
+        self.canFocus = true;
+        if (settings.tooltip && Widget.tooltips !== false) {
+          self.on('mouseenter', function (e) {
+            var tooltip = self.tooltip().moveTo(-65535);
+            if (e.control === self) {
+              var rel = tooltip.text(settings.tooltip).show().testMoveRel(self.getEl(), [
+                'bc-tc',
+                'bc-tl',
+                'bc-tr'
+              ]);
+              tooltip.classes.toggle('tooltip-n', rel === 'bc-tc');
+              tooltip.classes.toggle('tooltip-nw', rel === 'bc-tl');
+              tooltip.classes.toggle('tooltip-ne', rel === 'bc-tr');
+              tooltip.moveRel(self.getEl(), rel);
+            } else {
+              tooltip.hide();
+            }
+          });
+          self.on('mouseleave mousedown click', function () {
+            self.tooltip().remove();
+            self._tooltip = null;
+          });
+        }
+        self.aria('label', settings.ariaLabel || settings.tooltip);
+      },
+      tooltip: function () {
+        if (!this._tooltip) {
+          this._tooltip = new Tooltip({ type: 'tooltip' });
+          UiContainer.inheritUiContainer(this, this._tooltip);
+          this._tooltip.renderTo();
+        }
+        return this._tooltip;
+      },
+      postRender: function () {
+        var self = this, settings = self.settings;
+        self._super();
+        if (!self.parent() && (settings.width || settings.height)) {
+          self.initLayoutRect();
+          self.repaint();
+        }
+        if (settings.autofocus) {
+          self.focus();
+        }
+      },
+      bindStates: function () {
+        var self = this;
+        function disable(state) {
+          self.aria('disabled', state);
+          self.classes.toggle('disabled', state);
+        }
+        function active(state) {
+          self.aria('pressed', state);
+          self.classes.toggle('active', state);
+        }
+        self.state.on('change:disabled', function (e) {
+          disable(e.value);
+        });
+        self.state.on('change:active', function (e) {
+          active(e.value);
+        });
+        if (self.state.get('disabled')) {
+          disable(true);
+        }
+        if (self.state.get('active')) {
+          active(true);
+        }
+        return self._super();
+      },
+      remove: function () {
+        this._super();
+        if (this._tooltip) {
+          this._tooltip.remove();
+          this._tooltip = null;
+        }
+      }
+    });
+
+    var Progress = Widget.extend({
+      Defaults: { value: 0 },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.classes.add('progress');
+        if (!self.settings.filter) {
+          self.settings.filter = function (value) {
+            return Math.round(value);
+          };
+        }
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = this.classPrefix;
+        return '<div id="' + id + '" class="' + self.classes + '">' + '<div class="' + prefix + 'bar-container">' + '<div class="' + prefix + 'bar"></div>' + '</div>' + '<div class="' + prefix + 'text">0%</div>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        self._super();
+        self.value(self.settings.value);
+        return self;
+      },
+      bindStates: function () {
+        var self = this;
+        function setValue(value) {
+          value = self.settings.filter(value);
+          self.getEl().lastChild.innerHTML = value + '%';
+          self.getEl().firstChild.firstChild.style.width = value + '%';
+        }
+        self.state.on('change:value', function (e) {
+          setValue(e.value);
+        });
+        setValue(self.state.get('value'));
+        return self._super();
+      }
+    });
+
+    var updateLiveRegion = function (ctx, text) {
+      ctx.getEl().lastChild.textContent = text + (ctx.progressBar ? ' ' + ctx.progressBar.value() + '%' : '');
+    };
+    var Notification = Control$1.extend({
+      Mixins: [Movable],
+      Defaults: { classes: 'widget notification' },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.maxWidth = settings.maxWidth;
+        if (settings.text) {
+          self.text(settings.text);
+        }
+        if (settings.icon) {
+          self.icon = settings.icon;
+        }
+        if (settings.color) {
+          self.color = settings.color;
+        }
+        if (settings.type) {
+          self.classes.add('notification-' + settings.type);
+        }
+        if (settings.timeout && (settings.timeout < 0 || settings.timeout > 0) && !settings.closeButton) {
+          self.closeButton = false;
+        } else {
+          self.classes.add('has-close');
+          self.closeButton = true;
+        }
+        if (settings.progressBar) {
+          self.progressBar = new Progress();
+        }
+        self.on('click', function (e) {
+          if (e.target.className.indexOf(self.classPrefix + 'close') !== -1) {
+            self.close();
+          }
+        });
+      },
+      renderHtml: function () {
+        var self = this;
+        var prefix = self.classPrefix;
+        var icon = '', closeButton = '', progressBar = '', notificationStyle = '';
+        if (self.icon) {
+          icon = '<i class="' + prefix + 'ico' + ' ' + prefix + 'i-' + self.icon + '"></i>';
+        }
+        notificationStyle = ' style="max-width: ' + self.maxWidth + 'px;' + (self.color ? 'background-color: ' + self.color + ';"' : '"');
+        if (self.closeButton) {
+          closeButton = '<button type="button" class="' + prefix + 'close" aria-hidden="true">\xD7</button>';
+        }
+        if (self.progressBar) {
+          progressBar = self.progressBar.renderHtml();
+        }
+        return '<div id="' + self._id + '" class="' + self.classes + '"' + notificationStyle + ' role="presentation">' + icon + '<div class="' + prefix + 'notification-inner">' + self.state.get('text') + '</div>' + progressBar + closeButton + '<div style="clip: rect(1px, 1px, 1px, 1px);height: 1px;overflow: hidden;position: absolute;width: 1px;"' + ' aria-live="assertive" aria-relevant="additions" aria-atomic="true"></div>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        global$7.setTimeout(function () {
+          self.$el.addClass(self.classPrefix + 'in');
+          updateLiveRegion(self, self.state.get('text'));
+        }, 100);
+        return self._super();
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:text', function (e) {
+          self.getEl().firstChild.innerHTML = e.value;
+          updateLiveRegion(self, e.value);
+        });
+        if (self.progressBar) {
+          self.progressBar.bindStates();
+          self.progressBar.state.on('change:value', function (e) {
+            updateLiveRegion(self, self.state.get('text'));
+          });
+        }
+        return self._super();
+      },
+      close: function () {
+        var self = this;
+        if (!self.fire('close').isDefaultPrevented()) {
+          self.remove();
+        }
+        return self;
+      },
+      repaint: function () {
+        var self = this;
+        var style, rect;
+        style = self.getEl().style;
+        rect = self._layoutRect;
+        style.left = rect.x + 'px';
+        style.top = rect.y + 'px';
+        style.zIndex = 65535 - 1;
+      }
+    });
+
+    function NotificationManagerImpl (editor) {
+      var getEditorContainer = function (editor) {
+        return editor.inline ? editor.getElement() : editor.getContentAreaContainer();
+      };
+      var getContainerWidth = function () {
+        var container = getEditorContainer(editor);
+        return funcs.getSize(container).width;
+      };
+      var prePositionNotifications = function (notifications) {
+        each(notifications, function (notification) {
+          notification.moveTo(0, 0);
+        });
+      };
+      var positionNotifications = function (notifications) {
+        if (notifications.length > 0) {
+          var firstItem = notifications.slice(0, 1)[0];
+          var container = getEditorContainer(editor);
+          firstItem.moveRel(container, 'tc-tc');
+          each(notifications, function (notification, index) {
+            if (index > 0) {
+              notification.moveRel(notifications[index - 1].getEl(), 'bc-tc');
+            }
+          });
+        }
+      };
+      var reposition = function (notifications) {
+        prePositionNotifications(notifications);
+        positionNotifications(notifications);
+      };
+      var open = function (args, closeCallback) {
+        var extendedArgs = global$2.extend(args, { maxWidth: getContainerWidth() });
+        var notif = new Notification(extendedArgs);
+        notif.args = extendedArgs;
+        if (extendedArgs.timeout > 0) {
+          notif.timer = setTimeout(function () {
+            notif.close();
+            closeCallback();
+          }, extendedArgs.timeout);
+        }
+        notif.on('close', function () {
+          closeCallback();
+        });
+        notif.renderTo();
+        return notif;
+      };
+      var close = function (notification) {
+        notification.close();
+      };
+      var getArgs = function (notification) {
+        return notification.args;
+      };
+      return {
+        open: open,
+        close: close,
+        reposition: reposition,
+        getArgs: getArgs
+      };
+    }
+
+    var windows = [];
+    var oldMetaValue = '';
+    function toggleFullScreenState(state) {
+      var noScaleMetaValue = 'width=device-width,initial-scale=1.0,user-scalable=0,minimum-scale=1.0,maximum-scale=1.0';
+      var viewport = global$9('meta[name=viewport]')[0], contentValue;
+      if (global$8.overrideViewPort === false) {
+        return;
+      }
+      if (!viewport) {
+        viewport = domGlobals.document.createElement('meta');
+        viewport.setAttribute('name', 'viewport');
+        domGlobals.document.getElementsByTagName('head')[0].appendChild(viewport);
+      }
+      contentValue = viewport.getAttribute('content');
+      if (contentValue && typeof oldMetaValue !== 'undefined') {
+        oldMetaValue = contentValue;
+      }
+      viewport.setAttribute('content', state ? noScaleMetaValue : oldMetaValue);
+    }
+    function toggleBodyFullScreenClasses(classPrefix, state) {
+      if (checkFullscreenWindows() && state === false) {
+        global$9([
+          domGlobals.document.documentElement,
+          domGlobals.document.body
+        ]).removeClass(classPrefix + 'fullscreen');
+      }
+    }
+    function checkFullscreenWindows() {
+      for (var i = 0; i < windows.length; i++) {
+        if (windows[i]._fullscreen) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function handleWindowResize() {
+      if (!global$8.desktop) {
+        var lastSize_1 = {
+          w: domGlobals.window.innerWidth,
+          h: domGlobals.window.innerHeight
+        };
+        global$7.setInterval(function () {
+          var w = domGlobals.window.innerWidth, h = domGlobals.window.innerHeight;
+          if (lastSize_1.w !== w || lastSize_1.h !== h) {
+            lastSize_1 = {
+              w: w,
+              h: h
+            };
+            global$9(domGlobals.window).trigger('resize');
+          }
+        }, 100);
+      }
+      function reposition() {
+        var i;
+        var rect = funcs.getWindowSize();
+        var layoutRect;
+        for (i = 0; i < windows.length; i++) {
+          layoutRect = windows[i].layoutRect();
+          windows[i].moveTo(windows[i].settings.x || Math.max(0, rect.w / 2 - layoutRect.w / 2), windows[i].settings.y || Math.max(0, rect.h / 2 - layoutRect.h / 2));
+        }
+      }
+      global$9(domGlobals.window).on('resize', reposition);
+    }
+    var Window = FloatPanel.extend({
+      modal: true,
+      Defaults: {
+        border: 1,
+        layout: 'flex',
+        containerCls: 'panel',
+        role: 'dialog',
+        callbacks: {
+          submit: function () {
+            this.fire('submit', { data: this.toJSON() });
+          },
+          close: function () {
+            this.close();
+          }
+        }
+      },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        if (self.isRtl()) {
+          self.classes.add('rtl');
+        }
+        self.classes.add('window');
+        self.bodyClasses.add('window-body');
+        self.state.set('fixed', true);
+        if (settings.buttons) {
+          self.statusbar = new Panel({
+            layout: 'flex',
+            border: '1 0 0 0',
+            spacing: 3,
+            padding: 10,
+            align: 'center',
+            pack: self.isRtl() ? 'start' : 'end',
+            defaults: { type: 'button' },
+            items: settings.buttons
+          });
+          self.statusbar.classes.add('foot');
+          self.statusbar.parent(self);
+        }
+        self.on('click', function (e) {
+          var closeClass = self.classPrefix + 'close';
+          if (funcs.hasClass(e.target, closeClass) || funcs.hasClass(e.target.parentNode, closeClass)) {
+            self.close();
+          }
+        });
+        self.on('cancel', function () {
+          self.close();
+        });
+        self.on('move', function (e) {
+          if (e.control === self) {
+            FloatPanel.hideAll();
+          }
+        });
+        self.aria('describedby', self.describedBy || self._id + '-none');
+        self.aria('label', settings.title);
+        self._fullscreen = false;
+      },
+      recalc: function () {
+        var self = this;
+        var statusbar = self.statusbar;
+        var layoutRect, width, x, needsRecalc;
+        if (self._fullscreen) {
+          self.layoutRect(funcs.getWindowSize());
+          self.layoutRect().contentH = self.layoutRect().innerH;
+        }
+        self._super();
+        layoutRect = self.layoutRect();
+        if (self.settings.title && !self._fullscreen) {
+          width = layoutRect.headerW;
+          if (width > layoutRect.w) {
+            x = layoutRect.x - Math.max(0, width / 2);
+            self.layoutRect({
+              w: width,
+              x: x
+            });
+            needsRecalc = true;
+          }
+        }
+        if (statusbar) {
+          statusbar.layoutRect({ w: self.layoutRect().innerW }).recalc();
+          width = statusbar.layoutRect().minW + layoutRect.deltaW;
+          if (width > layoutRect.w) {
+            x = layoutRect.x - Math.max(0, width - layoutRect.w);
+            self.layoutRect({
+              w: width,
+              x: x
+            });
+            needsRecalc = true;
+          }
+        }
+        if (needsRecalc) {
+          self.recalc();
+        }
+      },
+      initLayoutRect: function () {
+        var self = this;
+        var layoutRect = self._super();
+        var deltaH = 0, headEl;
+        if (self.settings.title && !self._fullscreen) {
+          headEl = self.getEl('head');
+          var size = funcs.getSize(headEl);
+          layoutRect.headerW = size.width;
+          layoutRect.headerH = size.height;
+          deltaH += layoutRect.headerH;
+        }
+        if (self.statusbar) {
+          deltaH += self.statusbar.layoutRect().h;
+        }
+        layoutRect.deltaH += deltaH;
+        layoutRect.minH += deltaH;
+        layoutRect.h += deltaH;
+        var rect = funcs.getWindowSize();
+        layoutRect.x = self.settings.x || Math.max(0, rect.w / 2 - layoutRect.w / 2);
+        layoutRect.y = self.settings.y || Math.max(0, rect.h / 2 - layoutRect.h / 2);
+        return layoutRect;
+      },
+      renderHtml: function () {
+        var self = this, layout = self._layout, id = self._id, prefix = self.classPrefix;
+        var settings = self.settings;
+        var headerHtml = '', footerHtml = '', html = settings.html;
+        self.preRender();
+        layout.preRender(self);
+        if (settings.title) {
+          headerHtml = '<div id="' + id + '-head" class="' + prefix + 'window-head">' + '<div id="' + id + '-title" class="' + prefix + 'title">' + self.encode(settings.title) + '</div>' + '<div id="' + id + '-dragh" class="' + prefix + 'dragh"></div>' + '<button type="button" class="' + prefix + 'close" aria-hidden="true">' + '<i class="mce-ico mce-i-remove"></i>' + '</button>' + '</div>';
+        }
+        if (settings.url) {
+          html = '<iframe src="' + settings.url + '" tabindex="-1"></iframe>';
+        }
+        if (typeof html === 'undefined') {
+          html = layout.renderHtml(self);
+        }
+        if (self.statusbar) {
+          footerHtml = self.statusbar.renderHtml();
+        }
+        return '<div id="' + id + '" class="' + self.classes + '" hidefocus="1">' + '<div class="' + self.classPrefix + 'reset" role="application">' + headerHtml + '<div id="' + id + '-body" class="' + self.bodyClasses + '">' + html + '</div>' + footerHtml + '</div>' + '</div>';
+      },
+      fullscreen: function (state) {
+        var self = this;
+        var documentElement = domGlobals.document.documentElement;
+        var slowRendering;
+        var prefix = self.classPrefix;
+        var layoutRect;
+        if (state !== self._fullscreen) {
+          global$9(domGlobals.window).on('resize', function () {
+            var time;
+            if (self._fullscreen) {
+              if (!slowRendering) {
+                time = new Date().getTime();
+                var rect = funcs.getWindowSize();
+                self.moveTo(0, 0).resizeTo(rect.w, rect.h);
+                if (new Date().getTime() - time > 50) {
+                  slowRendering = true;
+                }
+              } else {
+                if (!self._timer) {
+                  self._timer = global$7.setTimeout(function () {
+                    var rect = funcs.getWindowSize();
+                    self.moveTo(0, 0).resizeTo(rect.w, rect.h);
+                    self._timer = 0;
+                  }, 50);
+                }
+              }
+            }
+          });
+          layoutRect = self.layoutRect();
+          self._fullscreen = state;
+          if (!state) {
+            self.borderBox = BoxUtils.parseBox(self.settings.border);
+            self.getEl('head').style.display = '';
+            layoutRect.deltaH += layoutRect.headerH;
+            global$9([
+              documentElement,
+              domGlobals.document.body
+            ]).removeClass(prefix + 'fullscreen');
+            self.classes.remove('fullscreen');
+            self.moveTo(self._initial.x, self._initial.y).resizeTo(self._initial.w, self._initial.h);
+          } else {
+            self._initial = {
+              x: layoutRect.x,
+              y: layoutRect.y,
+              w: layoutRect.w,
+              h: layoutRect.h
+            };
+            self.borderBox = BoxUtils.parseBox('0');
+            self.getEl('head').style.display = 'none';
+            layoutRect.deltaH -= layoutRect.headerH + 2;
+            global$9([
+              documentElement,
+              domGlobals.document.body
+            ]).addClass(prefix + 'fullscreen');
+            self.classes.add('fullscreen');
+            var rect = funcs.getWindowSize();
+            self.moveTo(0, 0).resizeTo(rect.w, rect.h);
+          }
+        }
+        return self.reflow();
+      },
+      postRender: function () {
+        var self = this;
+        var startPos;
+        setTimeout(function () {
+          self.classes.add('in');
+          self.fire('open');
+        }, 0);
+        self._super();
+        if (self.statusbar) {
+          self.statusbar.postRender();
+        }
+        self.focus();
+        this.dragHelper = new DragHelper(self._id + '-dragh', {
+          start: function () {
+            startPos = {
+              x: self.layoutRect().x,
+              y: self.layoutRect().y
+            };
+          },
+          drag: function (e) {
+            self.moveTo(startPos.x + e.deltaX, startPos.y + e.deltaY);
+          }
+        });
+        self.on('submit', function (e) {
+          if (!e.isDefaultPrevented()) {
+            self.close();
+          }
+        });
+        windows.push(self);
+        toggleFullScreenState(true);
+      },
+      submit: function () {
+        return this.fire('submit', { data: this.toJSON() });
+      },
+      remove: function () {
+        var self = this;
+        var i;
+        self.dragHelper.destroy();
+        self._super();
+        if (self.statusbar) {
+          this.statusbar.remove();
+        }
+        toggleBodyFullScreenClasses(self.classPrefix, false);
+        i = windows.length;
+        while (i--) {
+          if (windows[i] === self) {
+            windows.splice(i, 1);
+          }
+        }
+        toggleFullScreenState(windows.length > 0);
+      },
+      getContentWindow: function () {
+        var ifr = this.getEl().getElementsByTagName('iframe')[0];
+        return ifr ? ifr.contentWindow : null;
+      }
+    });
+    handleWindowResize();
+
+    var MessageBox = Window.extend({
+      init: function (settings) {
+        settings = {
+          border: 1,
+          padding: 20,
+          layout: 'flex',
+          pack: 'center',
+          align: 'center',
+          containerCls: 'panel',
+          autoScroll: true,
+          buttons: {
+            type: 'button',
+            text: 'Ok',
+            action: 'ok'
+          },
+          items: {
+            type: 'label',
+            multiline: true,
+            maxWidth: 500,
+            maxHeight: 200
+          }
+        };
+        this._super(settings);
+      },
+      Statics: {
+        OK: 1,
+        OK_CANCEL: 2,
+        YES_NO: 3,
+        YES_NO_CANCEL: 4,
+        msgBox: function (settings) {
+          var buttons;
+          var callback = settings.callback || function () {
+          };
+          function createButton(text, status, primary) {
+            return {
+              type: 'button',
+              text: text,
+              subtype: primary ? 'primary' : '',
+              onClick: function (e) {
+                e.control.parents()[1].close();
+                callback(status);
+              }
+            };
+          }
+          switch (settings.buttons) {
+          case MessageBox.OK_CANCEL:
+            buttons = [
+              createButton('Ok', true, true),
+              createButton('Cancel', false)
+            ];
+            break;
+          case MessageBox.YES_NO:
+          case MessageBox.YES_NO_CANCEL:
+            buttons = [
+              createButton('Yes', 1, true),
+              createButton('No', 0)
+            ];
+            if (settings.buttons === MessageBox.YES_NO_CANCEL) {
+              buttons.push(createButton('Cancel', -1));
+            }
+            break;
+          default:
+            buttons = [createButton('Ok', true, true)];
+            break;
+          }
+          return new Window({
+            padding: 20,
+            x: settings.x,
+            y: settings.y,
+            minWidth: 300,
+            minHeight: 100,
+            layout: 'flex',
+            pack: 'center',
+            align: 'center',
+            buttons: buttons,
+            title: settings.title,
+            role: 'alertdialog',
+            items: {
+              type: 'label',
+              multiline: true,
+              maxWidth: 500,
+              maxHeight: 200,
+              text: settings.text
+            },
+            onPostRender: function () {
+              this.aria('describedby', this.items()[0]._id);
+            },
+            onClose: settings.onClose,
+            onCancel: function () {
+              callback(false);
+            }
+          }).renderTo(domGlobals.document.body).reflow();
+        },
+        alert: function (settings, callback) {
+          if (typeof settings === 'string') {
+            settings = { text: settings };
+          }
+          settings.callback = callback;
+          return MessageBox.msgBox(settings);
+        },
+        confirm: function (settings, callback) {
+          if (typeof settings === 'string') {
+            settings = { text: settings };
+          }
+          settings.callback = callback;
+          settings.buttons = MessageBox.OK_CANCEL;
+          return MessageBox.msgBox(settings);
+        }
+      }
+    });
+
+    function WindowManagerImpl (editor) {
+      var open = function (args, params, closeCallback) {
+        var win;
+        args.title = args.title || ' ';
+        args.url = args.url || args.file;
+        if (args.url) {
+          args.width = parseInt(args.width || 320, 10);
+          args.height = parseInt(args.height || 240, 10);
+        }
+        if (args.body) {
+          args.items = {
+            defaults: args.defaults,
+            type: args.bodyType || 'form',
+            items: args.body,
+            data: args.data,
+            callbacks: args.commands
+          };
+        }
+        if (!args.url && !args.buttons) {
+          args.buttons = [
+            {
+              text: 'Ok',
+              subtype: 'primary',
+              onclick: function () {
+                win.find('form')[0].submit();
+              }
+            },
+            {
+              text: 'Cancel',
+              onclick: function () {
+                win.close();
+              }
+            }
+          ];
+        }
+        win = new Window(args);
+        win.on('close', function () {
+          closeCallback(win);
+        });
+        if (args.data) {
+          win.on('postRender', function () {
+            this.find('*').each(function (ctrl) {
+              var name = ctrl.name();
+              if (name in args.data) {
+                ctrl.value(args.data[name]);
+              }
+            });
+          });
+        }
+        win.features = args || {};
+        win.params = params || {};
+        win = win.renderTo(domGlobals.document.body).reflow();
+        return win;
+      };
+      var alert = function (message, choiceCallback, closeCallback) {
+        var win;
+        win = MessageBox.alert(message, function () {
+          choiceCallback();
+        });
+        win.on('close', function () {
+          closeCallback(win);
+        });
+        return win;
+      };
+      var confirm = function (message, choiceCallback, closeCallback) {
+        var win;
+        win = MessageBox.confirm(message, function (state) {
+          choiceCallback(state);
+        });
+        win.on('close', function () {
+          closeCallback(win);
+        });
+        return win;
+      };
+      var close = function (window) {
+        window.close();
+      };
+      var getParams = function (window) {
+        return window.params;
+      };
+      var setParams = function (window, params) {
+        window.params = params;
+      };
+      return {
+        open: open,
+        alert: alert,
+        confirm: confirm,
+        close: close,
+        getParams: getParams,
+        setParams: setParams
+      };
+    }
+
+    var get = function (editor) {
+      var renderUI = function (args) {
+        return Render.renderUI(editor, this, args);
+      };
+      var resizeTo = function (w, h) {
+        return Resize.resizeTo(editor, w, h);
+      };
+      var resizeBy = function (dw, dh) {
+        return Resize.resizeBy(editor, dw, dh);
+      };
+      var getNotificationManagerImpl = function () {
+        return NotificationManagerImpl(editor);
+      };
+      var getWindowManagerImpl = function () {
+        return WindowManagerImpl();
+      };
+      return {
+        renderUI: renderUI,
+        resizeTo: resizeTo,
+        resizeBy: resizeBy,
+        getNotificationManagerImpl: getNotificationManagerImpl,
+        getWindowManagerImpl: getWindowManagerImpl
+      };
+    };
+    var ThemeApi = { get: get };
+
+    var Layout = global$a.extend({
+      Defaults: {
+        firstControlClass: 'first',
+        lastControlClass: 'last'
+      },
+      init: function (settings) {
+        this.settings = global$2.extend({}, this.Defaults, settings);
+      },
+      preRender: function (container) {
+        container.bodyClasses.add(this.settings.containerClass);
+      },
+      applyClasses: function (items) {
+        var self = this;
+        var settings = self.settings;
+        var firstClass, lastClass, firstItem, lastItem;
+        firstClass = settings.firstControlClass;
+        lastClass = settings.lastControlClass;
+        items.each(function (item) {
+          item.classes.remove(firstClass).remove(lastClass).add(settings.controlClass);
+          if (item.visible()) {
+            if (!firstItem) {
+              firstItem = item;
+            }
+            lastItem = item;
+          }
+        });
+        if (firstItem) {
+          firstItem.classes.add(firstClass);
+        }
+        if (lastItem) {
+          lastItem.classes.add(lastClass);
+        }
+      },
+      renderHtml: function (container) {
+        var self = this;
+        var html = '';
+        self.applyClasses(container.items());
+        container.items().each(function (item) {
+          html += item.renderHtml();
+        });
+        return html;
+      },
+      recalc: function () {
+      },
+      postRender: function () {
+      },
+      isNative: function () {
+        return false;
+      }
+    });
+
+    var AbsoluteLayout = Layout.extend({
+      Defaults: {
+        containerClass: 'abs-layout',
+        controlClass: 'abs-layout-item'
+      },
+      recalc: function (container) {
+        container.items().filter(':visible').each(function (ctrl) {
+          var settings = ctrl.settings;
+          ctrl.layoutRect({
+            x: settings.x,
+            y: settings.y,
+            w: settings.w,
+            h: settings.h
+          });
+          if (ctrl.recalc) {
+            ctrl.recalc();
+          }
+        });
+      },
+      renderHtml: function (container) {
+        return '<div id="' + container._id + '-absend" class="' + container.classPrefix + 'abs-end"></div>' + this._super(container);
+      }
+    });
+
+    var Button = Widget.extend({
+      Defaults: {
+        classes: 'widget btn',
+        role: 'button'
+      },
+      init: function (settings) {
+        var self = this;
+        var size;
+        self._super(settings);
+        settings = self.settings;
+        size = self.settings.size;
+        self.on('click mousedown', function (e) {
+          e.preventDefault();
+        });
+        self.on('touchstart', function (e) {
+          self.fire('click', e);
+          e.preventDefault();
+        });
+        if (settings.subtype) {
+          self.classes.add(settings.subtype);
+        }
+        if (size) {
+          self.classes.add('btn-' + size);
+        }
+        if (settings.icon) {
+          self.icon(settings.icon);
+        }
+      },
+      icon: function (icon) {
+        if (!arguments.length) {
+          return this.state.get('icon');
+        }
+        this.state.set('icon', icon);
+        return this;
+      },
+      repaint: function () {
+        var btnElm = this.getEl().firstChild;
+        var btnStyle;
+        if (btnElm) {
+          btnStyle = btnElm.style;
+          btnStyle.width = btnStyle.height = '100%';
+        }
+        this._super();
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = self.classPrefix;
+        var icon = self.state.get('icon'), image;
+        var text = self.state.get('text');
+        var textHtml = '';
+        var ariaPressed;
+        var settings = self.settings;
+        image = settings.image;
+        if (image) {
+          icon = 'none';
+          if (typeof image !== 'string') {
+            image = domGlobals.window.getSelection ? image[0] : image[1];
+          }
+          image = ' style="background-image: url(\'' + image + '\')"';
+        } else {
+          image = '';
+        }
+        if (text) {
+          self.classes.add('btn-has-text');
+          textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
+        }
+        icon = icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
+        ariaPressed = typeof settings.active === 'boolean' ? ' aria-pressed="' + settings.active + '"' : '';
+        return '<div id="' + id + '" class="' + self.classes + '" tabindex="-1"' + ariaPressed + '>' + '<button id="' + id + '-button" role="presentation" type="button" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + textHtml + '</button>' + '</div>';
+      },
+      bindStates: function () {
+        var self = this, $ = self.$, textCls = self.classPrefix + 'txt';
+        function setButtonText(text) {
+          var $span = $('span.' + textCls, self.getEl());
+          if (text) {
+            if (!$span[0]) {
+              $('button:first', self.getEl()).append('<span class="' + textCls + '"></span>');
+              $span = $('span.' + textCls, self.getEl());
+            }
+            $span.html(self.encode(text));
+          } else {
+            $span.remove();
+          }
+          self.classes.toggle('btn-has-text', !!text);
+        }
+        self.state.on('change:text', function (e) {
+          setButtonText(e.value);
+        });
+        self.state.on('change:icon', function (e) {
+          var icon = e.value;
+          var prefix = self.classPrefix;
+          self.settings.icon = icon;
+          icon = icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
+          var btnElm = self.getEl().firstChild;
+          var iconElm = btnElm.getElementsByTagName('i')[0];
+          if (icon) {
+            if (!iconElm || iconElm !== btnElm.firstChild) {
+              iconElm = domGlobals.document.createElement('i');
+              btnElm.insertBefore(iconElm, btnElm.firstChild);
+            }
+            iconElm.className = icon;
+          } else if (iconElm) {
+            btnElm.removeChild(iconElm);
+          }
+          setButtonText(self.state.get('text'));
+        });
+        return self._super();
+      }
+    });
+
+    var BrowseButton = Button.extend({
+      init: function (settings) {
+        var self = this;
+        settings = global$2.extend({
+          text: 'Browse...',
+          multiple: false,
+          accept: null
+        }, settings);
+        self._super(settings);
+        self.classes.add('browsebutton');
+        if (settings.multiple) {
+          self.classes.add('multiple');
+        }
+      },
+      postRender: function () {
+        var self = this;
+        var input = funcs.create('input', {
+          type: 'file',
+          id: self._id + '-browse',
+          accept: self.settings.accept
+        });
+        self._super();
+        global$9(input).on('change', function (e) {
+          var files = e.target.files;
+          self.value = function () {
+            if (!files.length) {
+              return null;
+            } else if (self.settings.multiple) {
+              return files;
+            } else {
+              return files[0];
+            }
+          };
+          e.preventDefault();
+          if (files.length) {
+            self.fire('change', e);
+          }
+        });
+        global$9(input).on('click', function (e) {
+          e.stopPropagation();
+        });
+        global$9(self.getEl('button')).on('click touchstart', function (e) {
+          e.stopPropagation();
+          input.click();
+          e.preventDefault();
+        });
+        self.getEl().appendChild(input);
+      },
+      remove: function () {
+        global$9(this.getEl('button')).off();
+        global$9(this.getEl('input')).off();
+        this._super();
+      }
+    });
+
+    var ButtonGroup = Container.extend({
+      Defaults: {
+        defaultType: 'button',
+        role: 'group'
+      },
+      renderHtml: function () {
+        var self = this, layout = self._layout;
+        self.classes.add('btn-group');
+        self.preRender();
+        layout.preRender(self);
+        return '<div id="' + self._id + '" class="' + self.classes + '">' + '<div id="' + self._id + '-body">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</div>';
+      }
+    });
+
+    var Checkbox = Widget.extend({
+      Defaults: {
+        classes: 'checkbox',
+        role: 'checkbox',
+        checked: false
+      },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.on('click mousedown', function (e) {
+          e.preventDefault();
+        });
+        self.on('click', function (e) {
+          e.preventDefault();
+          if (!self.disabled()) {
+            self.checked(!self.checked());
+          }
+        });
+        self.checked(self.settings.checked);
+      },
+      checked: function (state) {
+        if (!arguments.length) {
+          return this.state.get('checked');
+        }
+        this.state.set('checked', state);
+        return this;
+      },
+      value: function (state) {
+        if (!arguments.length) {
+          return this.checked();
+        }
+        return this.checked(state);
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = self.classPrefix;
+        return '<div id="' + id + '" class="' + self.classes + '" unselectable="on" aria-labelledby="' + id + '-al" tabindex="-1">' + '<i class="' + prefix + 'ico ' + prefix + 'i-checkbox"></i>' + '<span id="' + id + '-al" class="' + prefix + 'label">' + self.encode(self.state.get('text')) + '</span>' + '</div>';
+      },
+      bindStates: function () {
+        var self = this;
+        function checked(state) {
+          self.classes.toggle('checked', state);
+          self.aria('checked', state);
+        }
+        self.state.on('change:text', function (e) {
+          self.getEl('al').firstChild.data = self.translate(e.value);
+        });
+        self.state.on('change:checked change:value', function (e) {
+          self.fire('change');
+          checked(e.value);
+        });
+        self.state.on('change:icon', function (e) {
+          var icon = e.value;
+          var prefix = self.classPrefix;
+          if (typeof icon === 'undefined') {
+            return self.settings.icon;
+          }
+          self.settings.icon = icon;
+          icon = icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
+          var btnElm = self.getEl().firstChild;
+          var iconElm = btnElm.getElementsByTagName('i')[0];
+          if (icon) {
+            if (!iconElm || iconElm !== btnElm.firstChild) {
+              iconElm = domGlobals.document.createElement('i');
+              btnElm.insertBefore(iconElm, btnElm.firstChild);
+            }
+            iconElm.className = icon;
+          } else if (iconElm) {
+            btnElm.removeChild(iconElm);
+          }
+        });
+        if (self.state.get('checked')) {
+          checked(true);
+        }
+        return self._super();
+      }
+    });
+
+    var global$d = tinymce.util.Tools.resolve('tinymce.util.VK');
+
+    var ComboBox = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        settings = self.settings;
+        self.classes.add('combobox');
+        self.subinput = true;
+        self.ariaTarget = 'inp';
+        settings.menu = settings.menu || settings.values;
+        if (settings.menu) {
+          settings.icon = 'caret';
+        }
+        self.on('click', function (e) {
+          var elm = e.target;
+          var root = self.getEl();
+          if (!global$9.contains(root, elm) && elm !== root) {
+            return;
+          }
+          while (elm && elm !== root) {
+            if (elm.id && elm.id.indexOf('-open') !== -1) {
+              self.fire('action');
+              if (settings.menu) {
+                self.showMenu();
+                if (e.aria) {
+                  self.menu.items()[0].focus();
+                }
+              }
+            }
+            elm = elm.parentNode;
+          }
+        });
+        self.on('keydown', function (e) {
+          var rootControl;
+          if (e.keyCode === 13 && e.target.nodeName === 'INPUT') {
+            e.preventDefault();
+            self.parents().reverse().each(function (ctrl) {
+              if (ctrl.toJSON) {
+                rootControl = ctrl;
+                return false;
+              }
+            });
+            self.fire('submit', { data: rootControl.toJSON() });
+          }
+        });
+        self.on('keyup', function (e) {
+          if (e.target.nodeName === 'INPUT') {
+            var oldValue = self.state.get('value');
+            var newValue = e.target.value;
+            if (newValue !== oldValue) {
+              self.state.set('value', newValue);
+              self.fire('autocomplete', e);
+            }
+          }
+        });
+        self.on('mouseover', function (e) {
+          var tooltip = self.tooltip().moveTo(-65535);
+          if (self.statusLevel() && e.target.className.indexOf(self.classPrefix + 'status') !== -1) {
+            var statusMessage = self.statusMessage() || 'Ok';
+            var rel = tooltip.text(statusMessage).show().testMoveRel(e.target, [
+              'bc-tc',
+              'bc-tl',
+              'bc-tr'
+            ]);
+            tooltip.classes.toggle('tooltip-n', rel === 'bc-tc');
+            tooltip.classes.toggle('tooltip-nw', rel === 'bc-tl');
+            tooltip.classes.toggle('tooltip-ne', rel === 'bc-tr');
+            tooltip.moveRel(e.target, rel);
+          }
+        });
+      },
+      statusLevel: function (value) {
+        if (arguments.length > 0) {
+          this.state.set('statusLevel', value);
+        }
+        return this.state.get('statusLevel');
+      },
+      statusMessage: function (value) {
+        if (arguments.length > 0) {
+          this.state.set('statusMessage', value);
+        }
+        return this.state.get('statusMessage');
+      },
+      showMenu: function () {
+        var self = this;
+        var settings = self.settings;
+        var menu;
+        if (!self.menu) {
+          menu = settings.menu || [];
+          if (menu.length) {
+            menu = {
+              type: 'menu',
+              items: menu
+            };
+          } else {
+            menu.type = menu.type || 'menu';
+          }
+          self.menu = global$4.create(menu).parent(self).renderTo(self.getContainerElm());
+          self.fire('createmenu');
+          self.menu.reflow();
+          self.menu.on('cancel', function (e) {
+            if (e.control === self.menu) {
+              self.focus();
+            }
+          });
+          self.menu.on('show hide', function (e) {
+            e.control.items().each(function (ctrl) {
+              ctrl.active(ctrl.value() === self.value());
+            });
+          }).fire('show');
+          self.menu.on('select', function (e) {
+            self.value(e.control.value());
+          });
+          self.on('focusin', function (e) {
+            if (e.target.tagName.toUpperCase() === 'INPUT') {
+              self.menu.hide();
+            }
+          });
+          self.aria('expanded', true);
+        }
+        self.menu.show();
+        self.menu.layoutRect({ w: self.layoutRect().w });
+        self.menu.moveRel(self.getEl(), self.isRtl() ? [
+          'br-tr',
+          'tr-br'
+        ] : [
+          'bl-tl',
+          'tl-bl'
+        ]);
+      },
+      focus: function () {
+        this.getEl('inp').focus();
+      },
+      repaint: function () {
+        var self = this, elm = self.getEl(), openElm = self.getEl('open'), rect = self.layoutRect();
+        var width, lineHeight, innerPadding = 0;
+        var inputElm = elm.firstChild;
+        if (self.statusLevel() && self.statusLevel() !== 'none') {
+          innerPadding = parseInt(funcs.getRuntimeStyle(inputElm, 'padding-right'), 10) - parseInt(funcs.getRuntimeStyle(inputElm, 'padding-left'), 10);
+        }
+        if (openElm) {
+          width = rect.w - funcs.getSize(openElm).width - 10;
+        } else {
+          width = rect.w - 10;
+        }
+        var doc = domGlobals.document;
+        if (doc.all && (!doc.documentMode || doc.documentMode <= 8)) {
+          lineHeight = self.layoutRect().h - 2 + 'px';
+        }
+        global$9(inputElm).css({
+          width: width - innerPadding,
+          lineHeight: lineHeight
+        });
+        self._super();
+        return self;
+      },
+      postRender: function () {
+        var self = this;
+        global$9(this.getEl('inp')).on('change', function (e) {
+          self.state.set('value', e.target.value);
+          self.fire('change', e);
+        });
+        return self._super();
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, settings = self.settings, prefix = self.classPrefix;
+        var value = self.state.get('value') || '';
+        var icon, text, openBtnHtml = '', extraAttrs = '', statusHtml = '';
+        if ('spellcheck' in settings) {
+          extraAttrs += ' spellcheck="' + settings.spellcheck + '"';
+        }
+        if (settings.maxLength) {
+          extraAttrs += ' maxlength="' + settings.maxLength + '"';
+        }
+        if (settings.size) {
+          extraAttrs += ' size="' + settings.size + '"';
+        }
+        if (settings.subtype) {
+          extraAttrs += ' type="' + settings.subtype + '"';
+        }
+        statusHtml = '<i id="' + id + '-status" class="mce-status mce-ico" style="display: none"></i>';
+        if (self.disabled()) {
+          extraAttrs += ' disabled="disabled"';
+        }
+        icon = settings.icon;
+        if (icon && icon !== 'caret') {
+          icon = prefix + 'ico ' + prefix + 'i-' + settings.icon;
+        }
+        text = self.state.get('text');
+        if (icon || text) {
+          openBtnHtml = '<div id="' + id + '-open" class="' + prefix + 'btn ' + prefix + 'open" tabIndex="-1" role="button">' + '<button id="' + id + '-action" type="button" hidefocus="1" tabindex="-1">' + (icon !== 'caret' ? '<i class="' + icon + '"></i>' : '<i class="' + prefix + 'caret"></i>') + (text ? (icon ? ' ' : '') + text : '') + '</button>' + '</div>';
+          self.classes.add('has-open');
+        }
+        return '<div id="' + id + '" class="' + self.classes + '">' + '<input id="' + id + '-inp" class="' + prefix + 'textbox" value="' + self.encode(value, false) + '" hidefocus="1"' + extraAttrs + ' placeholder="' + self.encode(settings.placeholder) + '" />' + statusHtml + openBtnHtml + '</div>';
+      },
+      value: function (value) {
+        if (arguments.length) {
+          this.state.set('value', value);
+          return this;
+        }
+        if (this.state.get('rendered')) {
+          this.state.set('value', this.getEl('inp').value);
+        }
+        return this.state.get('value');
+      },
+      showAutoComplete: function (items, term) {
+        var self = this;
+        if (items.length === 0) {
+          self.hideMenu();
+          return;
+        }
+        var insert = function (value, title) {
+          return function () {
+            self.fire('selectitem', {
+              title: title,
+              value: value
+            });
+          };
+        };
+        if (self.menu) {
+          self.menu.items().remove();
+        } else {
+          self.menu = global$4.create({
+            type: 'menu',
+            classes: 'combobox-menu',
+            layout: 'flow'
+          }).parent(self).renderTo();
+        }
+        global$2.each(items, function (item) {
+          self.menu.add({
+            text: item.title,
+            url: item.previewUrl,
+            match: term,
+            classes: 'menu-item-ellipsis',
+            onclick: insert(item.value, item.title)
+          });
+        });
+        self.menu.renderNew();
+        self.hideMenu();
+        self.menu.on('cancel', function (e) {
+          if (e.control.parent() === self.menu) {
+            e.stopPropagation();
+            self.focus();
+            self.hideMenu();
+          }
+        });
+        self.menu.on('select', function () {
+          self.focus();
+        });
+        var maxW = self.layoutRect().w;
+        self.menu.layoutRect({
+          w: maxW,
+          minW: 0,
+          maxW: maxW
+        });
+        self.menu.repaint();
+        self.menu.reflow();
+        self.menu.show();
+        self.menu.moveRel(self.getEl(), self.isRtl() ? [
+          'br-tr',
+          'tr-br'
+        ] : [
+          'bl-tl',
+          'tl-bl'
+        ]);
+      },
+      hideMenu: function () {
+        if (this.menu) {
+          this.menu.hide();
+        }
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:value', function (e) {
+          if (self.getEl('inp').value !== e.value) {
+            self.getEl('inp').value = e.value;
+          }
+        });
+        self.state.on('change:disabled', function (e) {
+          self.getEl('inp').disabled = e.value;
+        });
+        self.state.on('change:statusLevel', function (e) {
+          var statusIconElm = self.getEl('status');
+          var prefix = self.classPrefix, value = e.value;
+          funcs.css(statusIconElm, 'display', value === 'none' ? 'none' : '');
+          funcs.toggleClass(statusIconElm, prefix + 'i-checkmark', value === 'ok');
+          funcs.toggleClass(statusIconElm, prefix + 'i-warning', value === 'warn');
+          funcs.toggleClass(statusIconElm, prefix + 'i-error', value === 'error');
+          self.classes.toggle('has-status', value !== 'none');
+          self.repaint();
+        });
+        funcs.on(self.getEl('status'), 'mouseleave', function () {
+          self.tooltip().hide();
+        });
+        self.on('cancel', function (e) {
+          if (self.menu && self.menu.visible()) {
+            e.stopPropagation();
+            self.hideMenu();
+          }
+        });
+        var focusIdx = function (idx, menu) {
+          if (menu && menu.items().length > 0) {
+            menu.items().eq(idx)[0].focus();
+          }
+        };
+        self.on('keydown', function (e) {
+          var keyCode = e.keyCode;
+          if (e.target.nodeName === 'INPUT') {
+            if (keyCode === global$d.DOWN) {
+              e.preventDefault();
+              self.fire('autocomplete');
+              focusIdx(0, self.menu);
+            } else if (keyCode === global$d.UP) {
+              e.preventDefault();
+              focusIdx(-1, self.menu);
+            }
+          }
+        });
+        return self._super();
+      },
+      remove: function () {
+        global$9(this.getEl('inp')).off();
+        if (this.menu) {
+          this.menu.remove();
+        }
+        this._super();
+      }
+    });
+
+    var ColorBox = ComboBox.extend({
+      init: function (settings) {
+        var self = this;
+        settings.spellcheck = false;
+        if (settings.onaction) {
+          settings.icon = 'none';
+        }
+        self._super(settings);
+        self.classes.add('colorbox');
+        self.on('change keyup postrender', function () {
+          self.repaintColor(self.value());
+        });
+      },
+      repaintColor: function (value) {
+        var openElm = this.getEl('open');
+        var elm = openElm ? openElm.getElementsByTagName('i')[0] : null;
+        if (elm) {
+          try {
+            elm.style.background = value;
+          } catch (ex) {
+          }
+        }
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:value', function (e) {
+          if (self.state.get('rendered')) {
+            self.repaintColor(e.value);
+          }
+        });
+        return self._super();
+      }
+    });
+
+    var PanelButton = Button.extend({
+      showPanel: function () {
+        var self = this, settings = self.settings;
+        self.classes.add('opened');
+        if (!self.panel) {
+          var panelSettings = settings.panel;
+          if (panelSettings.type) {
+            panelSettings = {
+              layout: 'grid',
+              items: panelSettings
+            };
+          }
+          panelSettings.role = panelSettings.role || 'dialog';
+          panelSettings.popover = true;
+          panelSettings.autohide = true;
+          panelSettings.ariaRoot = true;
+          self.panel = new FloatPanel(panelSettings).on('hide', function () {
+            self.classes.remove('opened');
+          }).on('cancel', function (e) {
+            e.stopPropagation();
+            self.focus();
+            self.hidePanel();
+          }).parent(self).renderTo(self.getContainerElm());
+          self.panel.fire('show');
+          self.panel.reflow();
+        } else {
+          self.panel.show();
+        }
+        var rtlRels = [
+          'bc-tc',
+          'bc-tl',
+          'bc-tr'
+        ];
+        var ltrRels = [
+          'bc-tc',
+          'bc-tr',
+          'bc-tl',
+          'tc-bc',
+          'tc-br',
+          'tc-bl'
+        ];
+        var rel = self.panel.testMoveRel(self.getEl(), settings.popoverAlign || (self.isRtl() ? rtlRels : ltrRels));
+        self.panel.classes.toggle('start', rel.substr(-1) === 'l');
+        self.panel.classes.toggle('end', rel.substr(-1) === 'r');
+        var isTop = rel.substr(0, 1) === 't';
+        self.panel.classes.toggle('bottom', !isTop);
+        self.panel.classes.toggle('top', isTop);
+        self.panel.moveRel(self.getEl(), rel);
+      },
+      hidePanel: function () {
+        var self = this;
+        if (self.panel) {
+          self.panel.hide();
+        }
+      },
+      postRender: function () {
+        var self = this;
+        self.aria('haspopup', true);
+        self.on('click', function (e) {
+          if (e.control === self) {
+            if (self.panel && self.panel.visible()) {
+              self.hidePanel();
+            } else {
+              self.showPanel();
+              self.panel.focus(!!e.aria);
+            }
+          }
+        });
+        return self._super();
+      },
+      remove: function () {
+        if (this.panel) {
+          this.panel.remove();
+          this.panel = null;
+        }
+        return this._super();
+      }
+    });
+
+    var DOM$3 = global$3.DOM;
+    var ColorButton = PanelButton.extend({
+      init: function (settings) {
+        this._super(settings);
+        this.classes.add('splitbtn');
+        this.classes.add('colorbutton');
+      },
+      color: function (color) {
+        if (color) {
+          this._color = color;
+          this.getEl('preview').style.backgroundColor = color;
+          return this;
+        }
+        return this._color;
+      },
+      resetColor: function () {
+        this._color = null;
+        this.getEl('preview').style.backgroundColor = null;
+        return this;
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = self.classPrefix, text = self.state.get('text');
+        var icon = self.settings.icon ? prefix + 'ico ' + prefix + 'i-' + self.settings.icon : '';
+        var image = self.settings.image ? ' style="background-image: url(\'' + self.settings.image + '\')"' : '';
+        var textHtml = '';
+        if (text) {
+          self.classes.add('btn-has-text');
+          textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
+        }
+        return '<div id="' + id + '" class="' + self.classes + '" role="button" tabindex="-1" aria-haspopup="true">' + '<button role="presentation" hidefocus="1" type="button" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + '<span id="' + id + '-preview" class="' + prefix + 'preview"></span>' + textHtml + '</button>' + '<button type="button" class="' + prefix + 'open" hidefocus="1" tabindex="-1">' + ' <i class="' + prefix + 'caret"></i>' + '</button>' + '</div>';
+      },
+      postRender: function () {
+        var self = this, onClickHandler = self.settings.onclick;
+        self.on('click', function (e) {
+          if (e.aria && e.aria.key === 'down') {
+            return;
+          }
+          if (e.control === self && !DOM$3.getParent(e.target, '.' + self.classPrefix + 'open')) {
+            e.stopImmediatePropagation();
+            onClickHandler.call(self, e);
+          }
+        });
+        delete self.settings.onclick;
+        return self._super();
+      }
+    });
+
+    var global$e = tinymce.util.Tools.resolve('tinymce.util.Color');
+
+    var ColorPicker = Widget.extend({
+      Defaults: { classes: 'widget colorpicker' },
+      init: function (settings) {
+        this._super(settings);
+      },
+      postRender: function () {
+        var self = this;
+        var color = self.color();
+        var hsv, hueRootElm, huePointElm, svRootElm, svPointElm;
+        hueRootElm = self.getEl('h');
+        huePointElm = self.getEl('hp');
+        svRootElm = self.getEl('sv');
+        svPointElm = self.getEl('svp');
+        function getPos(elm, event) {
+          var pos = funcs.getPos(elm);
+          var x, y;
+          x = event.pageX - pos.x;
+          y = event.pageY - pos.y;
+          x = Math.max(0, Math.min(x / elm.clientWidth, 1));
+          y = Math.max(0, Math.min(y / elm.clientHeight, 1));
+          return {
+            x: x,
+            y: y
+          };
+        }
+        function updateColor(hsv, hueUpdate) {
+          var hue = (360 - hsv.h) / 360;
+          funcs.css(huePointElm, { top: hue * 100 + '%' });
+          if (!hueUpdate) {
+            funcs.css(svPointElm, {
+              left: hsv.s + '%',
+              top: 100 - hsv.v + '%'
+            });
+          }
+          svRootElm.style.background = global$e({
+            s: 100,
+            v: 100,
+            h: hsv.h
+          }).toHex();
+          self.color().parse({
+            s: hsv.s,
+            v: hsv.v,
+            h: hsv.h
+          });
+        }
+        function updateSaturationAndValue(e) {
+          var pos;
+          pos = getPos(svRootElm, e);
+          hsv.s = pos.x * 100;
+          hsv.v = (1 - pos.y) * 100;
+          updateColor(hsv);
+          self.fire('change');
+        }
+        function updateHue(e) {
+          var pos;
+          pos = getPos(hueRootElm, e);
+          hsv = color.toHsv();
+          hsv.h = (1 - pos.y) * 360;
+          updateColor(hsv, true);
+          self.fire('change');
+        }
+        self._repaint = function () {
+          hsv = color.toHsv();
+          updateColor(hsv);
+        };
+        self._super();
+        self._svdraghelper = new DragHelper(self._id + '-sv', {
+          start: updateSaturationAndValue,
+          drag: updateSaturationAndValue
+        });
+        self._hdraghelper = new DragHelper(self._id + '-h', {
+          start: updateHue,
+          drag: updateHue
+        });
+        self._repaint();
+      },
+      rgb: function () {
+        return this.color().toRgb();
+      },
+      value: function (value) {
+        var self = this;
+        if (arguments.length) {
+          self.color().parse(value);
+          if (self._rendered) {
+            self._repaint();
+          }
+        } else {
+          return self.color().toHex();
+        }
+      },
+      color: function () {
+        if (!this._color) {
+          this._color = global$e();
+        }
+        return this._color;
+      },
+      renderHtml: function () {
+        var self = this;
+        var id = self._id;
+        var prefix = self.classPrefix;
+        var hueHtml;
+        var stops = '#ff0000,#ff0080,#ff00ff,#8000ff,#0000ff,#0080ff,#00ffff,#00ff80,#00ff00,#80ff00,#ffff00,#ff8000,#ff0000';
+        function getOldIeFallbackHtml() {
+          var i, l, html = '', gradientPrefix, stopsList;
+          gradientPrefix = 'filter:progid:DXImageTransform.Microsoft.gradient(GradientType=0,startColorstr=';
+          stopsList = stops.split(',');
+          for (i = 0, l = stopsList.length - 1; i < l; i++) {
+            html += '<div class="' + prefix + 'colorpicker-h-chunk" style="' + 'height:' + 100 / l + '%;' + gradientPrefix + stopsList[i] + ',endColorstr=' + stopsList[i + 1] + ');' + '-ms-' + gradientPrefix + stopsList[i] + ',endColorstr=' + stopsList[i + 1] + ')' + '"></div>';
+          }
+          return html;
+        }
+        var gradientCssText = 'background: -ms-linear-gradient(top,' + stops + ');' + 'background: linear-gradient(to bottom,' + stops + ');';
+        hueHtml = '<div id="' + id + '-h" class="' + prefix + 'colorpicker-h" style="' + gradientCssText + '">' + getOldIeFallbackHtml() + '<div id="' + id + '-hp" class="' + prefix + 'colorpicker-h-marker"></div>' + '</div>';
+        return '<div id="' + id + '" class="' + self.classes + '">' + '<div id="' + id + '-sv" class="' + prefix + 'colorpicker-sv">' + '<div class="' + prefix + 'colorpicker-overlay1">' + '<div class="' + prefix + 'colorpicker-overlay2">' + '<div id="' + id + '-svp" class="' + prefix + 'colorpicker-selector1">' + '<div class="' + prefix + 'colorpicker-selector2"></div>' + '</div>' + '</div>' + '</div>' + '</div>' + hueHtml + '</div>';
+      }
+    });
+
+    var DropZone = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        settings = global$2.extend({
+          height: 100,
+          text: 'Drop an image here',
+          multiple: false,
+          accept: null
+        }, settings);
+        self._super(settings);
+        self.classes.add('dropzone');
+        if (settings.multiple) {
+          self.classes.add('multiple');
+        }
+      },
+      renderHtml: function () {
+        var self = this;
+        var attrs, elm;
+        var cfg = self.settings;
+        attrs = {
+          id: self._id,
+          hidefocus: '1'
+        };
+        elm = funcs.create('div', attrs, '<span>' + this.translate(cfg.text) + '</span>');
+        if (cfg.height) {
+          funcs.css(elm, 'height', cfg.height + 'px');
+        }
+        if (cfg.width) {
+          funcs.css(elm, 'width', cfg.width + 'px');
+        }
+        elm.className = self.classes;
+        return elm.outerHTML;
+      },
+      postRender: function () {
+        var self = this;
+        var toggleDragClass = function (e) {
+          e.preventDefault();
+          self.classes.toggle('dragenter');
+          self.getEl().className = self.classes;
+        };
+        var filter = function (files) {
+          var accept = self.settings.accept;
+          if (typeof accept !== 'string') {
+            return files;
+          }
+          var re = new RegExp('(' + accept.split(/\s*,\s*/).join('|') + ')$', 'i');
+          return global$2.grep(files, function (file) {
+            return re.test(file.name);
+          });
+        };
+        self._super();
+        self.$el.on('dragover', function (e) {
+          e.preventDefault();
+        });
+        self.$el.on('dragenter', toggleDragClass);
+        self.$el.on('dragleave', toggleDragClass);
+        self.$el.on('drop', function (e) {
+          e.preventDefault();
+          if (self.state.get('disabled')) {
+            return;
+          }
+          var files = filter(e.dataTransfer.files);
+          self.value = function () {
+            if (!files.length) {
+              return null;
+            } else if (self.settings.multiple) {
+              return files;
+            } else {
+              return files[0];
+            }
+          };
+          if (files.length) {
+            self.fire('change', e);
+          }
+        });
+      },
+      remove: function () {
+        this.$el.off();
+        this._super();
+      }
+    });
+
+    var Path = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        if (!settings.delimiter) {
+          settings.delimiter = '\xBB';
+        }
+        self._super(settings);
+        self.classes.add('path');
+        self.canFocus = true;
+        self.on('click', function (e) {
+          var index;
+          var target = e.target;
+          if (index = target.getAttribute('data-index')) {
+            self.fire('select', {
+              value: self.row()[index],
+              index: index
+            });
+          }
+        });
+        self.row(self.settings.row);
+      },
+      focus: function () {
+        var self = this;
+        self.getEl().firstChild.focus();
+        return self;
+      },
+      row: function (row) {
+        if (!arguments.length) {
+          return this.state.get('row');
+        }
+        this.state.set('row', row);
+        return this;
+      },
+      renderHtml: function () {
+        var self = this;
+        return '<div id="' + self._id + '" class="' + self.classes + '">' + self._getDataPathHtml(self.state.get('row')) + '</div>';
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:row', function (e) {
+          self.innerHtml(self._getDataPathHtml(e.value));
+        });
+        return self._super();
+      },
+      _getDataPathHtml: function (data) {
+        var self = this;
+        var parts = data || [];
+        var i, l, html = '';
+        var prefix = self.classPrefix;
+        for (i = 0, l = parts.length; i < l; i++) {
+          html += (i > 0 ? '<div class="' + prefix + 'divider" aria-hidden="true"> ' + self.settings.delimiter + ' </div>' : '') + '<div role="button" class="' + prefix + 'path-item' + (i === l - 1 ? ' ' + prefix + 'last' : '') + '" data-index="' + i + '" tabindex="-1" id="' + self._id + '-' + i + '" aria-level="' + (i + 1) + '">' + parts[i].name + '</div>';
+        }
+        if (!html) {
+          html = '<div class="' + prefix + 'path-item">\xA0</div>';
+        }
+        return html;
+      }
+    });
+
+    var ElementPath = Path.extend({
+      postRender: function () {
+        var self = this, editor = self.settings.editor;
+        function isHidden(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;
+        }
+        if (editor.settings.elementpath !== false) {
+          self.on('select', function (e) {
+            editor.focus();
+            editor.selection.select(this.row()[e.index].element);
+            editor.nodeChanged();
+          });
+          editor.on('nodeChange', function (e) {
+            var outParents = [];
+            var parents = e.parents;
+            var i = parents.length;
+            while (i--) {
+              if (parents[i].nodeType === 1 && !isHidden(parents[i])) {
+                var args = editor.fire('ResolveName', {
+                  name: parents[i].nodeName.toLowerCase(),
+                  target: parents[i]
+                });
+                if (!args.isDefaultPrevented()) {
+                  outParents.push({
+                    name: args.name,
+                    element: parents[i]
+                  });
+                }
+                if (args.isPropagationStopped()) {
+                  break;
+                }
+              }
+            }
+            self.row(outParents);
+          });
+        }
+        return self._super();
+      }
+    });
+
+    var FormItem = Container.extend({
+      Defaults: {
+        layout: 'flex',
+        align: 'center',
+        defaults: { flex: 1 }
+      },
+      renderHtml: function () {
+        var self = this, layout = self._layout, prefix = self.classPrefix;
+        self.classes.add('formitem');
+        layout.preRender(self);
+        return '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' + (self.settings.title ? '<div id="' + self._id + '-title" class="' + prefix + 'title">' + self.settings.title + '</div>' : '') + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</div>';
+      }
+    });
+
+    var Form = Container.extend({
+      Defaults: {
+        containerCls: 'form',
+        layout: 'flex',
+        direction: 'column',
+        align: 'stretch',
+        flex: 1,
+        padding: 15,
+        labelGap: 30,
+        spacing: 10,
+        callbacks: {
+          submit: function () {
+            this.submit();
+          }
+        }
+      },
+      preRender: function () {
+        var self = this, items = self.items();
+        if (!self.settings.formItemDefaults) {
+          self.settings.formItemDefaults = {
+            layout: 'flex',
+            autoResize: 'overflow',
+            defaults: { flex: 1 }
+          };
+        }
+        items.each(function (ctrl) {
+          var formItem;
+          var label = ctrl.settings.label;
+          if (label) {
+            formItem = new FormItem(global$2.extend({
+              items: {
+                type: 'label',
+                id: ctrl._id + '-l',
+                text: label,
+                flex: 0,
+                forId: ctrl._id,
+                disabled: ctrl.disabled()
+              }
+            }, self.settings.formItemDefaults));
+            formItem.type = 'formitem';
+            ctrl.aria('labelledby', ctrl._id + '-l');
+            if (typeof ctrl.settings.flex === 'undefined') {
+              ctrl.settings.flex = 1;
+            }
+            self.replace(ctrl, formItem);
+            formItem.add(ctrl);
+          }
+        });
+      },
+      submit: function () {
+        return this.fire('submit', { data: this.toJSON() });
+      },
+      postRender: function () {
+        var self = this;
+        self._super();
+        self.fromJSON(self.settings.data);
+      },
+      bindStates: function () {
+        var self = this;
+        self._super();
+        function recalcLabels() {
+          var maxLabelWidth = 0;
+          var labels = [];
+          var i, labelGap, items;
+          if (self.settings.labelGapCalc === false) {
+            return;
+          }
+          if (self.settings.labelGapCalc === 'children') {
+            items = self.find('formitem');
+          } else {
+            items = self.items();
+          }
+          items.filter('formitem').each(function (item) {
+            var labelCtrl = item.items()[0], labelWidth = labelCtrl.getEl().clientWidth;
+            maxLabelWidth = labelWidth > maxLabelWidth ? labelWidth : maxLabelWidth;
+            labels.push(labelCtrl);
+          });
+          labelGap = self.settings.labelGap || 0;
+          i = labels.length;
+          while (i--) {
+            labels[i].settings.minWidth = maxLabelWidth + labelGap;
+          }
+        }
+        self.on('show', recalcLabels);
+        recalcLabels();
+      }
+    });
+
+    var FieldSet = Form.extend({
+      Defaults: {
+        containerCls: 'fieldset',
+        layout: 'flex',
+        direction: 'column',
+        align: 'stretch',
+        flex: 1,
+        padding: '25 15 5 15',
+        labelGap: 30,
+        spacing: 10,
+        border: 1
+      },
+      renderHtml: function () {
+        var self = this, layout = self._layout, prefix = self.classPrefix;
+        self.preRender();
+        layout.preRender(self);
+        return '<fieldset id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' + (self.settings.title ? '<legend id="' + self._id + '-title" class="' + prefix + 'fieldset-title">' + self.settings.title + '</legend>' : '') + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + (self.settings.html || '') + layout.renderHtml(self) + '</div>' + '</fieldset>';
+      }
+    });
+
+    var unique$1 = 0;
+    var generate = function (prefix) {
+      var date = new Date();
+      var time = date.getTime();
+      var random = Math.floor(Math.random() * 1000000000);
+      unique$1++;
+      return prefix + '_' + random + unique$1 + String(time);
+    };
+
+    var fromHtml = function (html, scope) {
+      var doc = scope || domGlobals.document;
+      var div = doc.createElement('div');
+      div.innerHTML = html;
+      if (!div.hasChildNodes() || div.childNodes.length > 1) {
+        domGlobals.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 || domGlobals.document;
+      var node = doc.createElement(tag);
+      return fromDom(node);
+    };
+    var fromText = function (text, scope) {
+      var doc = scope || domGlobals.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: constant(node) };
+    };
+    var fromPoint = function (docElm, x, y) {
+      var doc = docElm.dom();
+      return Option.from(doc.elementFromPoint(x, y)).map(fromDom);
+    };
+    var Element = {
+      fromHtml: fromHtml,
+      fromTag: fromTag,
+      fromText: fromText,
+      fromDom: fromDom,
+      fromPoint: fromPoint
+    };
+
+    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 ATTRIBUTE = domGlobals.Node.ATTRIBUTE_NODE;
+    var CDATA_SECTION = domGlobals.Node.CDATA_SECTION_NODE;
+    var COMMENT = domGlobals.Node.COMMENT_NODE;
+    var DOCUMENT = domGlobals.Node.DOCUMENT_NODE;
+    var DOCUMENT_TYPE = domGlobals.Node.DOCUMENT_TYPE_NODE;
+    var DOCUMENT_FRAGMENT = domGlobals.Node.DOCUMENT_FRAGMENT_NODE;
+    var ELEMENT = domGlobals.Node.ELEMENT_NODE;
+    var TEXT = domGlobals.Node.TEXT_NODE;
+    var PROCESSING_INSTRUCTION = domGlobals.Node.PROCESSING_INSTRUCTION_NODE;
+    var ENTITY_REFERENCE = domGlobals.Node.ENTITY_REFERENCE_NODE;
+    var ENTITY = domGlobals.Node.ENTITY_NODE;
+    var NOTATION = domGlobals.Node.NOTATION_NODE;
+
+    var Global = typeof domGlobals.window !== 'undefined' ? domGlobals.window : Function('return this;')();
+
+    var path = function (parts, scope) {
+      var o = scope !== undefined && scope !== null ? scope : Global;
+      for (var i = 0; i < parts.length && o !== undefined && o !== null; ++i) {
+        o = o[parts[i]];
+      }
+      return o;
+    };
+    var resolve = function (p, scope) {
+      var parts = p.split('.');
+      return path(parts, scope);
+    };
+
+    var unsafe = function (name, scope) {
+      return resolve(name, scope);
+    };
+    var getOrDie = function (name, scope) {
+      var actual = unsafe(name, scope);
+      if (actual === undefined || actual === null) {
+        throw new Error(name + ' not available on this browser');
+      }
+      return actual;
+    };
+    var Global$1 = { getOrDie: getOrDie };
+
+    var Immutable = function () {
+      var fields = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        fields[_i] = arguments[_i];
+      }
+      return function () {
+        var values = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          values[_i] = arguments[_i];
+        }
+        if (fields.length !== values.length) {
+          throw new Error('Wrong number of arguments to struct. Expected "[' + fields.length + ']", got ' + values.length + ' arguments');
+        }
+        var struct = {};
+        each(fields, function (name, i) {
+          struct[name] = constant(values[i]);
+        });
+        return struct;
+      };
+    };
+
+    var node = function () {
+      var f = Global$1.getOrDie('Node');
+      return f;
+    };
+    var compareDocumentPosition = function (a, b, match) {
+      return (a.compareDocumentPosition(b) & match) !== 0;
+    };
+    var documentPositionPreceding = function (a, b) {
+      return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_PRECEDING);
+    };
+    var documentPositionContainedBy = function (a, b) {
+      return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_CONTAINED_BY);
+    };
+    var Node = {
+      documentPositionPreceding: documentPositionPreceding,
+      documentPositionContainedBy: documentPositionContainedBy
+    };
+
+    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(group(1), group(2));
+    };
+    var detect = function (versionRegexes, agent) {
+      var cleanedAgent = String(agent).toLowerCase();
+      if (versionRegexes.length === 0) {
+        return unknown();
+      }
+      return find$1(versionRegexes, cleanedAgent);
+    };
+    var unknown = function () {
+      return nu(0, 0);
+    };
+    var nu = function (major, minor) {
+      return {
+        major: major,
+        minor: minor
+      };
+    };
+    var Version = {
+      nu: nu,
+      detect: detect,
+      unknown: unknown
+    };
+
+    var edge = 'Edge';
+    var chrome = 'Chrome';
+    var ie = 'IE';
+    var opera = 'Opera';
+    var firefox = 'Firefox';
+    var safari = 'Safari';
+    var isBrowser = function (name, current) {
+      return function () {
+        return current === name;
+      };
+    };
+    var unknown$1 = function () {
+      return nu$1({
+        current: undefined,
+        version: Version.unknown()
+      });
+    };
+    var nu$1 = function (info) {
+      var current = info.current;
+      var version = info.version;
+      return {
+        current: current,
+        version: version,
+        isEdge: isBrowser(edge, current),
+        isChrome: isBrowser(chrome, current),
+        isIE: isBrowser(ie, current),
+        isOpera: isBrowser(opera, current),
+        isFirefox: isBrowser(firefox, current),
+        isSafari: isBrowser(safari, current)
+      };
+    };
+    var Browser = {
+      unknown: unknown$1,
+      nu: nu$1,
+      edge: constant(edge),
+      chrome: constant(chrome),
+      ie: constant(ie),
+      opera: constant(opera),
+      firefox: constant(firefox),
+      safari: constant(safari)
+    };
+
+    var windows$1 = 'Windows';
+    var ios = 'iOS';
+    var android = 'Android';
+    var linux = 'Linux';
+    var osx = 'OSX';
+    var solaris = 'Solaris';
+    var freebsd = 'FreeBSD';
+    var isOS = function (name, current) {
+      return function () {
+        return current === name;
+      };
+    };
+    var unknown$2 = function () {
+      return nu$2({
+        current: undefined,
+        version: Version.unknown()
+      });
+    };
+    var nu$2 = function (info) {
+      var current = info.current;
+      var version = info.version;
+      return {
+        current: current,
+        version: version,
+        isWindows: isOS(windows$1, current),
+        isiOS: isOS(ios, current),
+        isAndroid: isOS(android, current),
+        isOSX: isOS(osx, current),
+        isLinux: isOS(linux, current),
+        isSolaris: isOS(solaris, current),
+        isFreeBSD: isOS(freebsd, current)
+      };
+    };
+    var OperatingSystem = {
+      unknown: unknown$2,
+      nu: nu$2,
+      windows: constant(windows$1),
+      ios: constant(ios),
+      android: constant(android),
+      linux: constant(linux),
+      osx: constant(osx),
+      solaris: constant(solaris),
+      freebsd: constant(freebsd)
+    };
+
+    var DeviceType = function (os, browser, userAgent) {
+      var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
+      var isiPhone = os.isiOS() && !isiPad;
+      var isAndroid3 = os.isAndroid() && os.version.major === 3;
+      var isAndroid4 = os.isAndroid() && os.version.major === 4;
+      var isTablet = isiPad || isAndroid3 || isAndroid4 && /mobile/i.test(userAgent) === true;
+      var isTouch = os.isiOS() || os.isAndroid();
+      var isPhone = isTouch && !isTablet;
+      var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
+      return {
+        isiPad: constant(isiPad),
+        isiPhone: constant(isiPhone),
+        isTablet: constant(isTablet),
+        isPhone: constant(isPhone),
+        isTouch: constant(isTouch),
+        isAndroid: os.isAndroid,
+        isiOS: os.isiOS,
+        isWebView: constant(iOSwebview)
+      };
+    };
+
+    var detect$1 = function (candidates, userAgent) {
+      var agent = String(userAgent).toLowerCase();
+      return find(candidates, function (candidate) {
+        return candidate.search(agent);
+      });
+    };
+    var detectBrowser = function (browsers, userAgent) {
+      return detect$1(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$1(oses, userAgent).map(function (os) {
+        var version = Version.detect(os.versionRegexes, userAgent);
+        return {
+          current: os.name,
+          version: version
+        };
+      });
+    };
+    var UaString = {
+      detectBrowser: detectBrowser,
+      detectOs: detectOs
+    };
+
+    var contains = function (str, substr) {
+      return str.indexOf(substr) !== -1;
+    };
+
+    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',
+        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('os x'),
+        versionRegexes: [/.*?os\ x\ ?([0-9]+)_([0-9]+).*/]
+      },
+      {
+        name: 'Linux',
+        search: checkContains('linux'),
+        versionRegexes: []
+      },
+      {
+        name: 'Solaris',
+        search: checkContains('sunos'),
+        versionRegexes: []
+      },
+      {
+        name: 'FreeBSD',
+        search: checkContains('freebsd'),
+        versionRegexes: []
+      }
+    ];
+    var PlatformInfo = {
+      browsers: constant(browsers),
+      oses: constant(oses)
+    };
+
+    var detect$2 = function (userAgent) {
+      var browsers = PlatformInfo.browsers();
+      var oses = PlatformInfo.oses();
+      var browser = UaString.detectBrowser(browsers, userAgent).fold(Browser.unknown, Browser.nu);
+      var os = UaString.detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
+      var deviceType = DeviceType(os, browser, userAgent);
+      return {
+        browser: browser,
+        os: os,
+        deviceType: deviceType
+      };
+    };
+    var PlatformDetection = { detect: detect$2 };
+
+    var detect$3 = cached(function () {
+      var userAgent = domGlobals.navigator.userAgent;
+      return PlatformDetection.detect(userAgent);
+    });
+    var PlatformDetection$1 = { detect: detect$3 };
+
+    var ELEMENT$1 = ELEMENT;
+    var DOCUMENT$1 = DOCUMENT;
+    var bypassSelector = function (dom) {
+      return dom.nodeType !== ELEMENT$1 && dom.nodeType !== DOCUMENT$1 || dom.childElementCount === 0;
+    };
+    var all = function (selector, scope) {
+      var base = scope === undefined ? domGlobals.document : scope.dom();
+      return bypassSelector(base) ? [] : map(base.querySelectorAll(selector), Element.fromDom);
+    };
+    var one = function (selector, scope) {
+      var base = scope === undefined ? domGlobals.document : scope.dom();
+      return bypassSelector(base) ? Option.none() : Option.from(base.querySelector(selector)).map(Element.fromDom);
+    };
+
+    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 Node.documentPositionContainedBy(e1.dom(), e2.dom());
+    };
+    var browser = PlatformDetection$1.detect().browser;
+    var contains$1 = browser.isIE() ? ieContains : regularContains;
+
+    var spot = Immutable('element', 'offset');
+
+    var descendants = function (scope, selector) {
+      return all(selector, scope);
+    };
+
+    var trim = global$2.trim;
+    var hasContentEditableState = function (value) {
+      return function (node) {
+        if (node && node.nodeType === 1) {
+          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 = 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(descendants(Element.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('h');
+    };
+    var isAnchor = function (elm) {
+      return elm && elm.nodeName === 'A' && (elm.id || elm.name);
+    };
+    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('header', getElementText(elm), '#' + headerId, getLevel(elm), attach);
+    };
+    var anchorTarget = function (elm) {
+      var anchorId = elm.id || elm.name;
+      var anchorText = getElementText(elm);
+      return create('anchor', anchorText ? anchorText : '#' + anchorId, '#' + anchorId, 0, noop);
+    };
+    var getHeaderTargets = function (elms) {
+      return map(filter(elms, isValidHeader), headerTarget);
+    };
+    var getAnchorTargets = function (elms) {
+      return map(filter(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$2 = function (elm) {
+      var elms = getTargetElements(elm);
+      return filter(getHeaderTargets(elms).concat(getAnchorTargets(elms)), hasTitle);
+    };
+    var LinkTargets = { find: find$2 };
+
+    var getActiveEditor = function () {
+      return window.tinymce ? window.tinymce.activeEditor : global$1.activeEditor;
+    };
+    var history = {};
+    var HISTORY_LENGTH = 5;
+    var clearHistory = function () {
+      history = {};
+    };
+    var toMenuItem = function (target) {
+      return {
+        title: target.title,
+        value: {
+          title: { raw: target.title },
+          url: target.url,
+          attach: target.attach
+        }
+      };
+    };
+    var toMenuItems = function (targets) {
+      return global$2.map(targets, toMenuItem);
+    };
+    var staticMenuItem = function (title, url) {
+      return {
+        title: title,
+        value: {
+          title: title,
+          url: url,
+          attach: noop
+        }
+      };
+    };
+    var isUniqueUrl = function (url, targets) {
+      var foundTarget = exists(targets, function (target) {
+        return target.url === url;
+      });
+      return !foundTarget;
+    };
+    var getSetting = function (editorSettings, name, defaultValue) {
+      var value = name in editorSettings ? editorSettings[name] : defaultValue;
+      return value === false ? null : value;
+    };
+    var createMenuItems = function (term, targets, fileType, editorSettings) {
+      var separator = { title: '-' };
+      var fromHistoryMenuItems = function (history) {
+        var historyItems = history.hasOwnProperty(fileType) ? history[fileType] : [];
+        var uniqueHistory = filter(historyItems, function (url) {
+          return isUniqueUrl(url, targets);
+        });
+        return global$2.map(uniqueHistory, function (url) {
+          return {
+            title: url,
+            value: {
+              title: url,
+              url: url,
+              attach: noop
+            }
+          };
+        });
+      };
+      var fromMenuItems = function (type) {
+        var filteredTargets = filter(targets, function (target) {
+          return target.type === type;
+        });
+        return toMenuItems(filteredTargets);
+      };
+      var anchorMenuItems = function () {
+        var anchorMenuItems = fromMenuItems('anchor');
+        var topAnchor = getSetting(editorSettings, 'anchor_top', '#top');
+        var bottomAchor = getSetting(editorSettings, 'anchor_bottom', '#bottom');
+        if (topAnchor !== null) {
+          anchorMenuItems.unshift(staticMenuItem('<top>', topAnchor));
+        }
+        if (bottomAchor !== null) {
+          anchorMenuItems.push(staticMenuItem('<bottom>', bottomAchor));
+        }
+        return anchorMenuItems;
+      };
+      var join = function (items) {
+        return foldl(items, function (a, b) {
+          var bothEmpty = a.length === 0 || b.length === 0;
+          return bothEmpty ? a.concat(b) : a.concat(separator, b);
+        }, []);
+      };
+      if (editorSettings.typeahead_urls === false) {
+        return [];
+      }
+      return fileType === 'file' ? join([
+        filterByQuery(term, fromHistoryMenuItems(history)),
+        filterByQuery(term, fromMenuItems('header')),
+        filterByQuery(term, anchorMenuItems())
+      ]) : filterByQuery(term, fromHistoryMenuItems(history));
+    };
+    var addToHistory = function (url, fileType) {
+      var items = history[fileType];
+      if (!/^https?/.test(url)) {
+        return;
+      }
+      if (items) {
+        if (indexOf(items, url).isNone()) {
+          history[fileType] = items.slice(0, HISTORY_LENGTH).concat(url);
+        }
+      } else {
+        history[fileType] = [url];
+      }
+    };
+    var filterByQuery = function (term, menuItems) {
+      var lowerCaseTerm = term.toLowerCase();
+      var result = global$2.grep(menuItems, function (item) {
+        return item.title.toLowerCase().indexOf(lowerCaseTerm) !== -1;
+      });
+      return result.length === 1 && result[0].title === term ? [] : result;
+    };
+    var getTitle = function (linkDetails) {
+      var title = linkDetails.title;
+      return title.raw ? title.raw : title;
+    };
+    var setupAutoCompleteHandler = function (ctrl, editorSettings, bodyElm, fileType) {
+      var autocomplete = function (term) {
+        var linkTargets = LinkTargets.find(bodyElm);
+        var menuItems = createMenuItems(term, linkTargets, fileType, editorSettings);
+        ctrl.showAutoComplete(menuItems, term);
+      };
+      ctrl.on('autocomplete', function () {
+        autocomplete(ctrl.value());
+      });
+      ctrl.on('selectitem', function (e) {
+        var linkDetails = e.value;
+        ctrl.value(linkDetails.url);
+        var title = getTitle(linkDetails);
+        if (fileType === 'image') {
+          ctrl.fire('change', {
+            meta: {
+              alt: title,
+              attach: linkDetails.attach
+            }
+          });
+        } else {
+          ctrl.fire('change', {
+            meta: {
+              text: title,
+              attach: linkDetails.attach
+            }
+          });
+        }
+        ctrl.focus();
+      });
+      ctrl.on('click', function (e) {
+        if (ctrl.value().length === 0 && e.target.nodeName === 'INPUT') {
+          autocomplete('');
+        }
+      });
+      ctrl.on('PostRender', function () {
+        ctrl.getRoot().on('submit', function (e) {
+          if (!e.isDefaultPrevented()) {
+            addToHistory(ctrl.value(), fileType);
+          }
+        });
+      });
+    };
+    var statusToUiState = function (result) {
+      var status = result.status, message = result.message;
+      if (status === 'valid') {
+        return {
+          status: 'ok',
+          message: message
+        };
+      } else if (status === 'unknown') {
+        return {
+          status: 'warn',
+          message: message
+        };
+      } else if (status === 'invalid') {
+        return {
+          status: 'warn',
+          message: message
+        };
+      } else {
+        return {
+          status: 'none',
+          message: ''
+        };
+      }
+    };
+    var setupLinkValidatorHandler = function (ctrl, editorSettings, fileType) {
+      var validatorHandler = editorSettings.filepicker_validator_handler;
+      if (validatorHandler) {
+        var validateUrl_1 = function (url) {
+          if (url.length === 0) {
+            ctrl.statusLevel('none');
+            return;
+          }
+          validatorHandler({
+            url: url,
+            type: fileType
+          }, function (result) {
+            var uiState = statusToUiState(result);
+            ctrl.statusMessage(uiState.message);
+            ctrl.statusLevel(uiState.status);
+          });
+        };
+        ctrl.state.on('change:value', function (e) {
+          validateUrl_1(e.value);
+        });
+      }
+    };
+    var FilePicker = ComboBox.extend({
+      Statics: { clearHistory: clearHistory },
+      init: function (settings) {
+        var self = this, editor = getActiveEditor(), editorSettings = editor.settings;
+        var actionCallback, fileBrowserCallback, fileBrowserCallbackTypes;
+        var fileType = settings.filetype;
+        settings.spellcheck = false;
+        fileBrowserCallbackTypes = editorSettings.file_picker_types || editorSettings.file_browser_callback_types;
+        if (fileBrowserCallbackTypes) {
+          fileBrowserCallbackTypes = global$2.makeMap(fileBrowserCallbackTypes, /[, ]/);
+        }
+        if (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType]) {
+          fileBrowserCallback = editorSettings.file_picker_callback;
+          if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
+            actionCallback = function () {
+              var meta = self.fire('beforecall').meta;
+              meta = global$2.extend({ filetype: fileType }, meta);
+              fileBrowserCallback.call(editor, function (value, meta) {
+                self.value(value).fire('change', { meta: meta });
+              }, self.value(), meta);
+            };
+          } else {
+            fileBrowserCallback = editorSettings.file_browser_callback;
+            if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
+              actionCallback = function () {
+                fileBrowserCallback(self.getEl('inp').id, self.value(), fileType, window);
+              };
+            }
+          }
+        }
+        if (actionCallback) {
+          settings.icon = 'browse';
+          settings.onaction = actionCallback;
+        }
+        self._super(settings);
+        self.classes.add('filepicker');
+        setupAutoCompleteHandler(self, editorSettings, editor.getBody(), fileType);
+        setupLinkValidatorHandler(self, editorSettings, fileType);
+      }
+    });
+
+    var FitLayout = AbsoluteLayout.extend({
+      recalc: function (container) {
+        var contLayoutRect = container.layoutRect(), paddingBox = container.paddingBox;
+        container.items().filter(':visible').each(function (ctrl) {
+          ctrl.layoutRect({
+            x: paddingBox.left,
+            y: paddingBox.top,
+            w: contLayoutRect.innerW - paddingBox.right - paddingBox.left,
+            h: contLayoutRect.innerH - paddingBox.top - paddingBox.bottom
+          });
+          if (ctrl.recalc) {
+            ctrl.recalc();
+          }
+        });
+      }
+    });
+
+    var FlexLayout = AbsoluteLayout.extend({
+      recalc: function (container) {
+        var i, l, items, contLayoutRect, contPaddingBox, contSettings, align, pack, spacing, totalFlex, availableSpace, direction;
+        var ctrl, ctrlLayoutRect, ctrlSettings, flex;
+        var maxSizeItems = [];
+        var size, maxSize, ratio, rect, pos, maxAlignEndPos;
+        var sizeName, minSizeName, posName, maxSizeName, beforeName, innerSizeName, deltaSizeName, contentSizeName;
+        var alignAxisName, alignInnerSizeName, alignSizeName, alignMinSizeName, alignBeforeName, alignAfterName;
+        var alignDeltaSizeName, alignContentSizeName;
+        var max = Math.max, min = Math.min;
+        items = container.items().filter(':visible');
+        contLayoutRect = container.layoutRect();
+        contPaddingBox = container.paddingBox;
+        contSettings = container.settings;
+        direction = container.isRtl() ? contSettings.direction || 'row-reversed' : contSettings.direction;
+        align = contSettings.align;
+        pack = container.isRtl() ? contSettings.pack || 'end' : contSettings.pack;
+        spacing = contSettings.spacing || 0;
+        if (direction === 'row-reversed' || direction === 'column-reverse') {
+          items = items.set(items.toArray().reverse());
+          direction = direction.split('-')[0];
+        }
+        if (direction === 'column') {
+          posName = 'y';
+          sizeName = 'h';
+          minSizeName = 'minH';
+          maxSizeName = 'maxH';
+          innerSizeName = 'innerH';
+          beforeName = 'top';
+          deltaSizeName = 'deltaH';
+          contentSizeName = 'contentH';
+          alignBeforeName = 'left';
+          alignSizeName = 'w';
+          alignAxisName = 'x';
+          alignInnerSizeName = 'innerW';
+          alignMinSizeName = 'minW';
+          alignAfterName = 'right';
+          alignDeltaSizeName = 'deltaW';
+          alignContentSizeName = 'contentW';
+        } else {
+          posName = 'x';
+          sizeName = 'w';
+          minSizeName = 'minW';
+          maxSizeName = 'maxW';
+          innerSizeName = 'innerW';
+          beforeName = 'left';
+          deltaSizeName = 'deltaW';
+          contentSizeName = 'contentW';
+          alignBeforeName = 'top';
+          alignSizeName = 'h';
+          alignAxisName = 'y';
+          alignInnerSizeName = 'innerH';
+          alignMinSizeName = 'minH';
+          alignAfterName = 'bottom';
+          alignDeltaSizeName = 'deltaH';
+          alignContentSizeName = 'contentH';
+        }
+        availableSpace = contLayoutRect[innerSizeName] - contPaddingBox[beforeName] - contPaddingBox[beforeName];
+        maxAlignEndPos = totalFlex = 0;
+        for (i = 0, l = items.length; i < l; i++) {
+          ctrl = items[i];
+          ctrlLayoutRect = ctrl.layoutRect();
+          ctrlSettings = ctrl.settings;
+          flex = ctrlSettings.flex;
+          availableSpace -= i < l - 1 ? spacing : 0;
+          if (flex > 0) {
+            totalFlex += flex;
+            if (ctrlLayoutRect[maxSizeName]) {
+              maxSizeItems.push(ctrl);
+            }
+            ctrlLayoutRect.flex = flex;
+          }
+          availableSpace -= ctrlLayoutRect[minSizeName];
+          size = contPaddingBox[alignBeforeName] + ctrlLayoutRect[alignMinSizeName] + contPaddingBox[alignAfterName];
+          if (size > maxAlignEndPos) {
+            maxAlignEndPos = size;
+          }
+        }
+        rect = {};
+        if (availableSpace < 0) {
+          rect[minSizeName] = contLayoutRect[minSizeName] - availableSpace + contLayoutRect[deltaSizeName];
+        } else {
+          rect[minSizeName] = contLayoutRect[innerSizeName] - availableSpace + contLayoutRect[deltaSizeName];
+        }
+        rect[alignMinSizeName] = maxAlignEndPos + contLayoutRect[alignDeltaSizeName];
+        rect[contentSizeName] = contLayoutRect[innerSizeName] - availableSpace;
+        rect[alignContentSizeName] = maxAlignEndPos;
+        rect.minW = min(rect.minW, contLayoutRect.maxW);
+        rect.minH = min(rect.minH, contLayoutRect.maxH);
+        rect.minW = max(rect.minW, contLayoutRect.startMinWidth);
+        rect.minH = max(rect.minH, contLayoutRect.startMinHeight);
+        if (contLayoutRect.autoResize && (rect.minW !== contLayoutRect.minW || rect.minH !== contLayoutRect.minH)) {
+          rect.w = rect.minW;
+          rect.h = rect.minH;
+          container.layoutRect(rect);
+          this.recalc(container);
+          if (container._lastRect === null) {
+            var parentCtrl = container.parent();
+            if (parentCtrl) {
+              parentCtrl._lastRect = null;
+              parentCtrl.recalc();
+            }
+          }
+          return;
+        }
+        ratio = availableSpace / totalFlex;
+        for (i = 0, l = maxSizeItems.length; i < l; i++) {
+          ctrl = maxSizeItems[i];
+          ctrlLayoutRect = ctrl.layoutRect();
+          maxSize = ctrlLayoutRect[maxSizeName];
+          size = ctrlLayoutRect[minSizeName] + ctrlLayoutRect.flex * ratio;
+          if (size > maxSize) {
+            availableSpace -= ctrlLayoutRect[maxSizeName] - ctrlLayoutRect[minSizeName];
+            totalFlex -= ctrlLayoutRect.flex;
+            ctrlLayoutRect.flex = 0;
+            ctrlLayoutRect.maxFlexSize = maxSize;
+          } else {
+            ctrlLayoutRect.maxFlexSize = 0;
+          }
+        }
+        ratio = availableSpace / totalFlex;
+        pos = contPaddingBox[beforeName];
+        rect = {};
+        if (totalFlex === 0) {
+          if (pack === 'end') {
+            pos = availableSpace + contPaddingBox[beforeName];
+          } else if (pack === 'center') {
+            pos = Math.round(contLayoutRect[innerSizeName] / 2 - (contLayoutRect[innerSizeName] - availableSpace) / 2) + contPaddingBox[beforeName];
+            if (pos < 0) {
+              pos = contPaddingBox[beforeName];
+            }
+          } else if (pack === 'justify') {
+            pos = contPaddingBox[beforeName];
+            spacing = Math.floor(availableSpace / (items.length - 1));
+          }
+        }
+        rect[alignAxisName] = contPaddingBox[alignBeforeName];
+        for (i = 0, l = items.length; i < l; i++) {
+          ctrl = items[i];
+          ctrlLayoutRect = ctrl.layoutRect();
+          size = ctrlLayoutRect.maxFlexSize || ctrlLayoutRect[minSizeName];
+          if (align === 'center') {
+            rect[alignAxisName] = Math.round(contLayoutRect[alignInnerSizeName] / 2 - ctrlLayoutRect[alignSizeName] / 2);
+          } else if (align === 'stretch') {
+            rect[alignSizeName] = max(ctrlLayoutRect[alignMinSizeName] || 0, contLayoutRect[alignInnerSizeName] - contPaddingBox[alignBeforeName] - contPaddingBox[alignAfterName]);
+            rect[alignAxisName] = contPaddingBox[alignBeforeName];
+          } else if (align === 'end') {
+            rect[alignAxisName] = contLayoutRect[alignInnerSizeName] - ctrlLayoutRect[alignSizeName] - contPaddingBox.top;
+          }
+          if (ctrlLayoutRect.flex > 0) {
+            size += ctrlLayoutRect.flex * ratio;
+          }
+          rect[sizeName] = size;
+          rect[posName] = pos;
+          ctrl.layoutRect(rect);
+          if (ctrl.recalc) {
+            ctrl.recalc();
+          }
+          pos += size + spacing;
+        }
+      }
+    });
+
+    var FlowLayout = Layout.extend({
+      Defaults: {
+        containerClass: 'flow-layout',
+        controlClass: 'flow-layout-item',
+        endClass: 'break'
+      },
+      recalc: function (container) {
+        container.items().filter(':visible').each(function (ctrl) {
+          if (ctrl.recalc) {
+            ctrl.recalc();
+          }
+        });
+      },
+      isNative: function () {
+        return true;
+      }
+    });
+
+    var descendant = function (scope, selector) {
+      return one(selector, scope);
+    };
+
+    var toggleFormat = function (editor, fmt) {
+      return function () {
+        editor.execCommand('mceToggleFormat', false, fmt);
+      };
+    };
+    var addFormatChangedListener = function (editor, name, changed) {
+      var handler = function (state) {
+        changed(state, name);
+      };
+      if (editor.formatter) {
+        editor.formatter.formatChanged(name, handler);
+      } else {
+        editor.on('init', function () {
+          editor.formatter.formatChanged(name, handler);
+        });
+      }
+    };
+    var postRenderFormatToggle = function (editor, name) {
+      return function (e) {
+        addFormatChangedListener(editor, name, function (state) {
+          e.control.active(state);
+        });
+      };
+    };
+
+    var register = function (editor) {
+      var alignFormats = [
+        'alignleft',
+        'aligncenter',
+        'alignright',
+        'alignjustify'
+      ];
+      var defaultAlign = 'alignleft';
+      var alignMenuItems = [
+        {
+          text: 'Left',
+          icon: 'alignleft',
+          onclick: toggleFormat(editor, 'alignleft')
+        },
+        {
+          text: 'Center',
+          icon: 'aligncenter',
+          onclick: toggleFormat(editor, 'aligncenter')
+        },
+        {
+          text: 'Right',
+          icon: 'alignright',
+          onclick: toggleFormat(editor, 'alignright')
+        },
+        {
+          text: 'Justify',
+          icon: 'alignjustify',
+          onclick: toggleFormat(editor, 'alignjustify')
+        }
+      ];
+      editor.addMenuItem('align', {
+        text: 'Align',
+        menu: alignMenuItems
+      });
+      editor.addButton('align', {
+        type: 'menubutton',
+        icon: defaultAlign,
+        menu: alignMenuItems,
+        onShowMenu: function (e) {
+          var menu = e.control.menu;
+          global$2.each(alignFormats, function (formatName, idx) {
+            menu.items().eq(idx).each(function (item) {
+              return item.active(editor.formatter.match(formatName));
+            });
+          });
+        },
+        onPostRender: function (e) {
+          var ctrl = e.control;
+          global$2.each(alignFormats, function (formatName, idx) {
+            addFormatChangedListener(editor, formatName, function (state) {
+              ctrl.icon(defaultAlign);
+              if (state) {
+                ctrl.icon(formatName);
+              }
+            });
+          });
+        }
+      });
+      global$2.each({
+        alignleft: [
+          'Align left',
+          'JustifyLeft'
+        ],
+        aligncenter: [
+          'Align center',
+          'JustifyCenter'
+        ],
+        alignright: [
+          'Align right',
+          'JustifyRight'
+        ],
+        alignjustify: [
+          'Justify',
+          'JustifyFull'
+        ],
+        alignnone: [
+          'No alignment',
+          'JustifyNone'
+        ]
+      }, function (item, name) {
+        editor.addButton(name, {
+          active: false,
+          tooltip: item[0],
+          cmd: item[1],
+          onPostRender: postRenderFormatToggle(editor, name)
+        });
+      });
+    };
+    var Align = { register: register };
+
+    var getFirstFont = function (fontFamily) {
+      return fontFamily ? fontFamily.split(',')[0] : '';
+    };
+    var findMatchingValue = function (items, fontFamily) {
+      var font = fontFamily ? fontFamily.toLowerCase() : '';
+      var value;
+      global$2.each(items, function (item) {
+        if (item.value.toLowerCase() === font) {
+          value = item.value;
+        }
+      });
+      global$2.each(items, function (item) {
+        if (!value && getFirstFont(item.value).toLowerCase() === getFirstFont(font).toLowerCase()) {
+          value = item.value;
+        }
+      });
+      return value;
+    };
+    var createFontNameListBoxChangeHandler = function (editor, items) {
+      return function () {
+        var self = this;
+        self.state.set('value', null);
+        editor.on('init nodeChange', function (e) {
+          var fontFamily = editor.queryCommandValue('FontName');
+          var match = findMatchingValue(items, fontFamily);
+          self.value(match ? match : null);
+          if (!match && fontFamily) {
+            self.text(getFirstFont(fontFamily));
+          }
+        });
+      };
+    };
+    var createFormats = function (formats) {
+      formats = formats.replace(/;$/, '').split(';');
+      var i = formats.length;
+      while (i--) {
+        formats[i] = formats[i].split('=');
+      }
+      return formats;
+    };
+    var getFontItems = function (editor) {
+      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 fonts = createFormats(editor.settings.font_formats || defaultFontsFormats);
+      return global$2.map(fonts, function (font) {
+        return {
+          text: { raw: font[0] },
+          value: font[1],
+          textStyle: font[1].indexOf('dings') === -1 ? 'font-family:' + font[1] : ''
+        };
+      });
+    };
+    var registerButtons = function (editor) {
+      editor.addButton('fontselect', function () {
+        var items = getFontItems(editor);
+        return {
+          type: 'listbox',
+          text: 'Font Family',
+          tooltip: 'Font Family',
+          values: items,
+          fixedWidth: true,
+          onPostRender: createFontNameListBoxChangeHandler(editor, items),
+          onselect: function (e) {
+            if (e.control.settings.value) {
+              editor.execCommand('FontName', false, e.control.settings.value);
+            }
+          }
+        };
+      });
+    };
+    var register$1 = function (editor) {
+      registerButtons(editor);
+    };
+    var FontSelect = { register: register$1 };
+
+    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';
+      }
+      return fontSize;
+    };
+    var findMatchingValue$1 = function (items, pt, px) {
+      var value;
+      global$2.each(items, function (item) {
+        if (item.value === px) {
+          value = px;
+        } else if (item.value === pt) {
+          value = pt;
+        }
+      });
+      return value;
+    };
+    var createFontSizeListBoxChangeHandler = function (editor, items) {
+      return function () {
+        var self = this;
+        editor.on('init nodeChange', function (e) {
+          var px, pt, precision, match;
+          px = editor.queryCommandValue('FontSize');
+          if (px) {
+            for (precision = 3; !match && precision >= 0; precision--) {
+              pt = toPt(px, precision);
+              match = findMatchingValue$1(items, pt, px);
+            }
+          }
+          self.value(match ? match : null);
+          if (!match) {
+            self.text(pt);
+          }
+        });
+      };
+    };
+    var getFontSizeItems = function (editor) {
+      var defaultFontsizeFormats = '8pt 10pt 12pt 14pt 18pt 24pt 36pt';
+      var fontsizeFormats = editor.settings.fontsize_formats || defaultFontsizeFormats;
+      return global$2.map(fontsizeFormats.split(' '), function (item) {
+        var text = item, value = item;
+        var values = item.split('=');
+        if (values.length > 1) {
+          text = values[0];
+          value = values[1];
+        }
+        return {
+          text: text,
+          value: value
+        };
+      });
+    };
+    var registerButtons$1 = function (editor) {
+      editor.addButton('fontsizeselect', function () {
+        var items = getFontSizeItems(editor);
+        return {
+          type: 'listbox',
+          text: 'Font Sizes',
+          tooltip: 'Font Sizes',
+          values: items,
+          fixedWidth: true,
+          onPostRender: createFontSizeListBoxChangeHandler(editor, items),
+          onclick: function (e) {
+            if (e.control.settings.value) {
+              editor.execCommand('FontSize', false, e.control.settings.value);
+            }
+          }
+        };
+      });
+    };
+    var register$2 = function (editor) {
+      registerButtons$1(editor);
+    };
+    var FontSizeSelect = { register: register$2 };
+
+    var hideMenuObjects = function (editor, menu) {
+      var count = menu.length;
+      global$2.each(menu, function (item) {
+        if (item.menu) {
+          item.hidden = hideMenuObjects(editor, item.menu) === 0;
+        }
+        var formatName = item.format;
+        if (formatName) {
+          item.hidden = !editor.formatter.canApply(formatName);
+        }
+        if (item.hidden) {
+          count--;
+        }
+      });
+      return count;
+    };
+    var hideFormatMenuItems = function (editor, menu) {
+      var count = menu.items().length;
+      menu.items().each(function (item) {
+        if (item.menu) {
+          item.visible(hideFormatMenuItems(editor, item.menu) > 0);
+        }
+        if (!item.menu && item.settings.menu) {
+          item.visible(hideMenuObjects(editor, item.settings.menu) > 0);
+        }
+        var formatName = item.settings.format;
+        if (formatName) {
+          item.visible(editor.formatter.canApply(formatName));
+        }
+        if (!item.visible()) {
+          count--;
+        }
+      });
+      return count;
+    };
+    var createFormatMenu = function (editor) {
+      var count = 0;
+      var newFormats = [];
+      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 createMenu = function (formats) {
+        var menu = [];
+        if (!formats) {
+          return;
+        }
+        global$2.each(formats, function (format) {
+          var menuItem = {
+            text: format.title,
+            icon: format.icon
+          };
+          if (format.items) {
+            menuItem.menu = createMenu(format.items);
+          } else {
+            var formatName = format.format || 'custom' + count++;
+            if (!format.format) {
+              format.name = formatName;
+              newFormats.push(format);
+            }
+            menuItem.format = formatName;
+            menuItem.cmd = format.cmd;
+          }
+          menu.push(menuItem);
+        });
+        return menu;
+      };
+      var createStylesMenu = function () {
+        var menu;
+        if (editor.settings.style_formats_merge) {
+          if (editor.settings.style_formats) {
+            menu = createMenu(defaultStyleFormats.concat(editor.settings.style_formats));
+          } else {
+            menu = createMenu(defaultStyleFormats);
+          }
+        } else {
+          menu = createMenu(editor.settings.style_formats || defaultStyleFormats);
+        }
+        return menu;
+      };
+      editor.on('init', function () {
+        global$2.each(newFormats, function (format) {
+          editor.formatter.register(format.name, format);
+        });
+      });
+      return {
+        type: 'menu',
+        items: createStylesMenu(),
+        onPostRender: function (e) {
+          editor.fire('renderFormatsMenu', { control: e.control });
+        },
+        itemDefaults: {
+          preview: true,
+          textStyle: function () {
+            if (this.settings.format) {
+              return editor.formatter.getCssText(this.settings.format);
+            }
+          },
+          onPostRender: function () {
+            var self = this;
+            self.parent().on('show', function () {
+              var formatName, command;
+              formatName = self.settings.format;
+              if (formatName) {
+                self.disabled(!editor.formatter.canApply(formatName));
+                self.active(editor.formatter.match(formatName));
+              }
+              command = self.settings.cmd;
+              if (command) {
+                self.active(editor.queryCommandState(command));
+              }
+            });
+          },
+          onclick: function () {
+            if (this.settings.format) {
+              toggleFormat(editor, this.settings.format)();
+            }
+            if (this.settings.cmd) {
+              editor.execCommand(this.settings.cmd);
+            }
+          }
+        }
+      };
+    };
+    var registerMenuItems = function (editor, formatMenu) {
+      editor.addMenuItem('formats', {
+        text: 'Formats',
+        menu: formatMenu
+      });
+    };
+    var registerButtons$2 = function (editor, formatMenu) {
+      editor.addButton('styleselect', {
+        type: 'menubutton',
+        text: 'Formats',
+        menu: formatMenu,
+        onShowMenu: function () {
+          if (editor.settings.style_formats_autohide) {
+            hideFormatMenuItems(editor, this.menu);
+          }
+        }
+      });
+    };
+    var register$3 = function (editor) {
+      var formatMenu = createFormatMenu(editor);
+      registerMenuItems(editor, formatMenu);
+      registerButtons$2(editor, formatMenu);
+    };
+    var Formats = { register: register$3 };
+
+    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 createFormats$1 = function (formats) {
+      formats = formats.replace(/;$/, '').split(';');
+      var i = formats.length;
+      while (i--) {
+        formats[i] = formats[i].split('=');
+      }
+      return formats;
+    };
+    var createListBoxChangeHandler = function (editor, items, formatName) {
+      return function () {
+        var self = this;
+        editor.on('nodeChange', function (e) {
+          var formatter = editor.formatter;
+          var value = null;
+          global$2.each(e.parents, function (node) {
+            global$2.each(items, function (item) {
+              if (formatName) {
+                if (formatter.matchNode(node, formatName, { value: item.value })) {
+                  value = item.value;
+                }
+              } else {
+                if (formatter.matchNode(node, item.value)) {
+                  value = item.value;
+                }
+              }
+              if (value) {
+                return false;
+              }
+            });
+            if (value) {
+              return false;
+            }
+          });
+          self.value(value);
+        });
+      };
+    };
+    var lazyFormatSelectBoxItems = function (editor, blocks) {
+      return function () {
+        var items = [];
+        global$2.each(blocks, function (block) {
+          items.push({
+            text: block[0],
+            value: block[1],
+            textStyle: function () {
+              return editor.formatter.getCssText(block[1]);
+            }
+          });
+        });
+        return {
+          type: 'listbox',
+          text: blocks[0][0],
+          values: items,
+          fixedWidth: true,
+          onselect: function (e) {
+            if (e.control) {
+              var fmt = e.control.value();
+              toggleFormat(editor, fmt)();
+            }
+          },
+          onPostRender: createListBoxChangeHandler(editor, items)
+        };
+      };
+    };
+    var buildMenuItems = function (editor, blocks) {
+      return global$2.map(blocks, function (block) {
+        return {
+          text: block[0],
+          onclick: toggleFormat(editor, block[1]),
+          textStyle: function () {
+            return editor.formatter.getCssText(block[1]);
+          }
+        };
+      });
+    };
+    var register$4 = function (editor) {
+      var blocks = createFormats$1(editor.settings.block_formats || defaultBlocks);
+      editor.addMenuItem('blockformats', {
+        text: 'Blocks',
+        menu: buildMenuItems(editor, blocks)
+      });
+      editor.addButton('formatselect', lazyFormatSelectBoxItems(editor, blocks));
+    };
+    var FormatSelect = { register: register$4 };
+
+    var createCustomMenuItems = function (editor, names) {
+      var items, nameList;
+      if (typeof names === 'string') {
+        nameList = names.split(' ');
+      } else if (global$2.isArray(names)) {
+        return flatten(global$2.map(names, function (names) {
+          return createCustomMenuItems(editor, names);
+        }));
+      }
+      items = global$2.grep(nameList, function (name) {
+        return name === '|' || name in editor.menuItems;
+      });
+      return global$2.map(items, function (name) {
+        return name === '|' ? { text: '-' } : editor.menuItems[name];
+      });
+    };
+    var isSeparator$1 = function (menuItem) {
+      return menuItem && menuItem.text === '-';
+    };
+    var trimMenuItems = function (menuItems) {
+      var menuItems2 = filter(menuItems, function (menuItem, i) {
+        return !isSeparator$1(menuItem) || !isSeparator$1(menuItems[i - 1]);
+      });
+      return filter(menuItems2, function (menuItem, i) {
+        return !isSeparator$1(menuItem) || i > 0 && i < menuItems2.length - 1;
+      });
+    };
+    var createContextMenuItems = function (editor, context) {
+      var outputMenuItems = [{ text: '-' }];
+      var menuItems = global$2.grep(editor.menuItems, function (menuItem) {
+        return menuItem.context === context;
+      });
+      global$2.each(menuItems, function (menuItem) {
+        if (menuItem.separator === 'before') {
+          outputMenuItems.push({ text: '|' });
+        }
+        if (menuItem.prependToContext) {
+          outputMenuItems.unshift(menuItem);
+        } else {
+          outputMenuItems.push(menuItem);
+        }
+        if (menuItem.separator === 'after') {
+          outputMenuItems.push({ text: '|' });
+        }
+      });
+      return outputMenuItems;
+    };
+    var createInsertMenu = function (editor) {
+      var insertButtonItems = editor.settings.insert_button_items;
+      if (insertButtonItems) {
+        return trimMenuItems(createCustomMenuItems(editor, insertButtonItems));
+      } else {
+        return trimMenuItems(createContextMenuItems(editor, 'insert'));
+      }
+    };
+    var registerButtons$3 = function (editor) {
+      editor.addButton('insert', {
+        type: 'menubutton',
+        icon: 'insert',
+        menu: [],
+        oncreatemenu: function () {
+          this.menu.add(createInsertMenu(editor));
+          this.menu.renderNew();
+        }
+      });
+    };
+    var register$5 = function (editor) {
+      registerButtons$3(editor);
+    };
+    var InsertButton = { register: register$5 };
+
+    var registerFormatButtons = function (editor) {
+      global$2.each({
+        bold: 'Bold',
+        italic: 'Italic',
+        underline: 'Underline',
+        strikethrough: 'Strikethrough',
+        subscript: 'Subscript',
+        superscript: 'Superscript'
+      }, function (text, name) {
+        editor.addButton(name, {
+          active: false,
+          tooltip: text,
+          onPostRender: postRenderFormatToggle(editor, name),
+          onclick: toggleFormat(editor, name)
+        });
+      });
+    };
+    var registerCommandButtons = function (editor) {
+      global$2.each({
+        outdent: [
+          'Decrease indent',
+          'Outdent'
+        ],
+        indent: [
+          'Increase indent',
+          'Indent'
+        ],
+        cut: [
+          'Cut',
+          'Cut'
+        ],
+        copy: [
+          'Copy',
+          'Copy'
+        ],
+        paste: [
+          'Paste',
+          'Paste'
+        ],
+        help: [
+          'Help',
+          'mceHelp'
+        ],
+        selectall: [
+          'Select all',
+          'SelectAll'
+        ],
+        visualaid: [
+          'Visual aids',
+          'mceToggleVisualAid'
+        ],
+        newdocument: [
+          'New document',
+          'mceNewDocument'
+        ],
+        removeformat: [
+          'Clear formatting',
+          'RemoveFormat'
+        ],
+        remove: [
+          'Remove',
+          'Delete'
+        ]
+      }, function (item, name) {
+        editor.addButton(name, {
+          tooltip: item[0],
+          cmd: item[1]
+        });
+      });
+    };
+    var registerCommandToggleButtons = function (editor) {
+      global$2.each({
+        blockquote: [
+          'Blockquote',
+          'mceBlockQuote'
+        ],
+        subscript: [
+          'Subscript',
+          'Subscript'
+        ],
+        superscript: [
+          'Superscript',
+          'Superscript'
+        ]
+      }, function (item, name) {
+        editor.addButton(name, {
+          active: false,
+          tooltip: item[0],
+          cmd: item[1],
+          onPostRender: postRenderFormatToggle(editor, name)
+        });
+      });
+    };
+    var registerButtons$4 = function (editor) {
+      registerFormatButtons(editor);
+      registerCommandButtons(editor);
+      registerCommandToggleButtons(editor);
+    };
+    var registerMenuItems$1 = function (editor) {
+      global$2.each({
+        bold: [
+          'Bold',
+          'Bold',
+          'Meta+B'
+        ],
+        italic: [
+          'Italic',
+          'Italic',
+          'Meta+I'
+        ],
+        underline: [
+          'Underline',
+          'Underline',
+          'Meta+U'
+        ],
+        strikethrough: [
+          'Strikethrough',
+          'Strikethrough'
+        ],
+        subscript: [
+          'Subscript',
+          'Subscript'
+        ],
+        superscript: [
+          'Superscript',
+          'Superscript'
+        ],
+        removeformat: [
+          'Clear formatting',
+          'RemoveFormat'
+        ],
+        newdocument: [
+          'New document',
+          'mceNewDocument'
+        ],
+        cut: [
+          'Cut',
+          'Cut',
+          'Meta+X'
+        ],
+        copy: [
+          'Copy',
+          'Copy',
+          'Meta+C'
+        ],
+        paste: [
+          'Paste',
+          'Paste',
+          'Meta+V'
+        ],
+        selectall: [
+          'Select all',
+          'SelectAll',
+          'Meta+A'
+        ]
+      }, function (item, name) {
+        editor.addMenuItem(name, {
+          text: item[0],
+          icon: name,
+          shortcut: item[2],
+          cmd: item[1]
+        });
+      });
+      editor.addMenuItem('codeformat', {
+        text: 'Code',
+        icon: 'code',
+        onclick: toggleFormat(editor, 'code')
+      });
+    };
+    var register$6 = function (editor) {
+      registerButtons$4(editor);
+      registerMenuItems$1(editor);
+    };
+    var SimpleControls = { register: register$6 };
+
+    var toggleUndoRedoState = function (editor, type) {
+      return function () {
+        var self = this;
+        var checkState = function () {
+          var typeFn = type === 'redo' ? 'hasRedo' : 'hasUndo';
+          return editor.undoManager ? editor.undoManager[typeFn]() : false;
+        };
+        self.disabled(!checkState());
+        editor.on('Undo Redo AddUndo TypingUndo ClearUndos SwitchMode', function () {
+          self.disabled(editor.readonly || !checkState());
+        });
+      };
+    };
+    var registerMenuItems$2 = function (editor) {
+      editor.addMenuItem('undo', {
+        text: 'Undo',
+        icon: 'undo',
+        shortcut: 'Meta+Z',
+        onPostRender: toggleUndoRedoState(editor, 'undo'),
+        cmd: 'undo'
+      });
+      editor.addMenuItem('redo', {
+        text: 'Redo',
+        icon: 'redo',
+        shortcut: 'Meta+Y',
+        onPostRender: toggleUndoRedoState(editor, 'redo'),
+        cmd: 'redo'
+      });
+    };
+    var registerButtons$5 = function (editor) {
+      editor.addButton('undo', {
+        tooltip: 'Undo',
+        onPostRender: toggleUndoRedoState(editor, 'undo'),
+        cmd: 'undo'
+      });
+      editor.addButton('redo', {
+        tooltip: 'Redo',
+        onPostRender: toggleUndoRedoState(editor, 'redo'),
+        cmd: 'redo'
+      });
+    };
+    var register$7 = function (editor) {
+      registerMenuItems$2(editor);
+      registerButtons$5(editor);
+    };
+    var UndoRedo = { register: register$7 };
+
+    var toggleVisualAidState = function (editor) {
+      return function () {
+        var self = this;
+        editor.on('VisualAid', function (e) {
+          self.active(e.hasVisual);
+        });
+        self.active(editor.hasVisual);
+      };
+    };
+    var registerMenuItems$3 = function (editor) {
+      editor.addMenuItem('visualaid', {
+        text: 'Visual aids',
+        selectable: true,
+        onPostRender: toggleVisualAidState(editor),
+        cmd: 'mceToggleVisualAid'
+      });
+    };
+    var register$8 = function (editor) {
+      registerMenuItems$3(editor);
+    };
+    var VisualAid = { register: register$8 };
+
+    var setupEnvironment = function () {
+      Widget.tooltips = !global$8.iOS;
+      Control$1.translate = function (text) {
+        return global$1.translate(text);
+      };
+    };
+    var setupUiContainer = function (editor) {
+      if (editor.settings.ui_container) {
+        global$8.container = descendant(Element.fromDom(domGlobals.document.body), editor.settings.ui_container).fold(constant(null), function (elm) {
+          return elm.dom();
+        });
+      }
+    };
+    var setupRtlMode = function (editor) {
+      if (editor.rtl) {
+        Control$1.rtl = true;
+      }
+    };
+    var setupHideFloatPanels = function (editor) {
+      editor.on('mousedown progressstate', function () {
+        FloatPanel.hideAll();
+      });
+    };
+    var setup$1 = function (editor) {
+      setupRtlMode(editor);
+      setupHideFloatPanels(editor);
+      setupUiContainer(editor);
+      setupEnvironment();
+      FormatSelect.register(editor);
+      Align.register(editor);
+      SimpleControls.register(editor);
+      UndoRedo.register(editor);
+      FontSizeSelect.register(editor);
+      FontSelect.register(editor);
+      Formats.register(editor);
+      VisualAid.register(editor);
+      InsertButton.register(editor);
+    };
+    var FormatControls = { setup: setup$1 };
+
+    var GridLayout = AbsoluteLayout.extend({
+      recalc: function (container) {
+        var settings, rows, cols, items, contLayoutRect, width, height, rect, ctrlLayoutRect, ctrl, x, y, posX, posY, ctrlSettings, contPaddingBox, align, spacingH, spacingV, alignH, alignV, maxX, maxY;
+        var colWidths = [];
+        var rowHeights = [];
+        var ctrlMinWidth, ctrlMinHeight, availableWidth, availableHeight, reverseRows, idx;
+        settings = container.settings;
+        items = container.items().filter(':visible');
+        contLayoutRect = container.layoutRect();
+        cols = settings.columns || Math.ceil(Math.sqrt(items.length));
+        rows = Math.ceil(items.length / cols);
+        spacingH = settings.spacingH || settings.spacing || 0;
+        spacingV = settings.spacingV || settings.spacing || 0;
+        alignH = settings.alignH || settings.align;
+        alignV = settings.alignV || settings.align;
+        contPaddingBox = container.paddingBox;
+        reverseRows = 'reverseRows' in settings ? settings.reverseRows : container.isRtl();
+        if (alignH && typeof alignH === 'string') {
+          alignH = [alignH];
+        }
+        if (alignV && typeof alignV === 'string') {
+          alignV = [alignV];
+        }
+        for (x = 0; x < cols; x++) {
+          colWidths.push(0);
+        }
+        for (y = 0; y < rows; y++) {
+          rowHeights.push(0);
+        }
+        for (y = 0; y < rows; y++) {
+          for (x = 0; x < cols; x++) {
+            ctrl = items[y * cols + x];
+            if (!ctrl) {
+              break;
+            }
+            ctrlLayoutRect = ctrl.layoutRect();
+            ctrlMinWidth = ctrlLayoutRect.minW;
+            ctrlMinHeight = ctrlLayoutRect.minH;
+            colWidths[x] = ctrlMinWidth > colWidths[x] ? ctrlMinWidth : colWidths[x];
+            rowHeights[y] = ctrlMinHeight > rowHeights[y] ? ctrlMinHeight : rowHeights[y];
+          }
+        }
+        availableWidth = contLayoutRect.innerW - contPaddingBox.left - contPaddingBox.right;
+        for (maxX = 0, x = 0; x < cols; x++) {
+          maxX += colWidths[x] + (x > 0 ? spacingH : 0);
+          availableWidth -= (x > 0 ? spacingH : 0) + colWidths[x];
+        }
+        availableHeight = contLayoutRect.innerH - contPaddingBox.top - contPaddingBox.bottom;
+        for (maxY = 0, y = 0; y < rows; y++) {
+          maxY += rowHeights[y] + (y > 0 ? spacingV : 0);
+          availableHeight -= (y > 0 ? spacingV : 0) + rowHeights[y];
+        }
+        maxX += contPaddingBox.left + contPaddingBox.right;
+        maxY += contPaddingBox.top + contPaddingBox.bottom;
+        rect = {};
+        rect.minW = maxX + (contLayoutRect.w - contLayoutRect.innerW);
+        rect.minH = maxY + (contLayoutRect.h - contLayoutRect.innerH);
+        rect.contentW = rect.minW - contLayoutRect.deltaW;
+        rect.contentH = rect.minH - contLayoutRect.deltaH;
+        rect.minW = Math.min(rect.minW, contLayoutRect.maxW);
+        rect.minH = Math.min(rect.minH, contLayoutRect.maxH);
+        rect.minW = Math.max(rect.minW, contLayoutRect.startMinWidth);
+        rect.minH = Math.max(rect.minH, contLayoutRect.startMinHeight);
+        if (contLayoutRect.autoResize && (rect.minW !== contLayoutRect.minW || rect.minH !== contLayoutRect.minH)) {
+          rect.w = rect.minW;
+          rect.h = rect.minH;
+          container.layoutRect(rect);
+          this.recalc(container);
+          if (container._lastRect === null) {
+            var parentCtrl = container.parent();
+            if (parentCtrl) {
+              parentCtrl._lastRect = null;
+              parentCtrl.recalc();
+            }
+          }
+          return;
+        }
+        if (contLayoutRect.autoResize) {
+          rect = container.layoutRect(rect);
+          rect.contentW = rect.minW - contLayoutRect.deltaW;
+          rect.contentH = rect.minH - contLayoutRect.deltaH;
+        }
+        var flexV;
+        if (settings.packV === 'start') {
+          flexV = 0;
+        } else {
+          flexV = availableHeight > 0 ? Math.floor(availableHeight / rows) : 0;
+        }
+        var totalFlex = 0;
+        var flexWidths = settings.flexWidths;
+        if (flexWidths) {
+          for (x = 0; x < flexWidths.length; x++) {
+            totalFlex += flexWidths[x];
+          }
+        } else {
+          totalFlex = cols;
+        }
+        var ratio = availableWidth / totalFlex;
+        for (x = 0; x < cols; x++) {
+          colWidths[x] += flexWidths ? flexWidths[x] * ratio : ratio;
+        }
+        posY = contPaddingBox.top;
+        for (y = 0; y < rows; y++) {
+          posX = contPaddingBox.left;
+          height = rowHeights[y] + flexV;
+          for (x = 0; x < cols; x++) {
+            if (reverseRows) {
+              idx = y * cols + cols - 1 - x;
+            } else {
+              idx = y * cols + x;
+            }
+            ctrl = items[idx];
+            if (!ctrl) {
+              break;
+            }
+            ctrlSettings = ctrl.settings;
+            ctrlLayoutRect = ctrl.layoutRect();
+            width = Math.max(colWidths[x], ctrlLayoutRect.startMinWidth);
+            ctrlLayoutRect.x = posX;
+            ctrlLayoutRect.y = posY;
+            align = ctrlSettings.alignH || (alignH ? alignH[x] || alignH[0] : null);
+            if (align === 'center') {
+              ctrlLayoutRect.x = posX + width / 2 - ctrlLayoutRect.w / 2;
+            } else if (align === 'right') {
+              ctrlLayoutRect.x = posX + width - ctrlLayoutRect.w;
+            } else if (align === 'stretch') {
+              ctrlLayoutRect.w = width;
+            }
+            align = ctrlSettings.alignV || (alignV ? alignV[x] || alignV[0] : null);
+            if (align === 'center') {
+              ctrlLayoutRect.y = posY + height / 2 - ctrlLayoutRect.h / 2;
+            } else if (align === 'bottom') {
+              ctrlLayoutRect.y = posY + height - ctrlLayoutRect.h;
+            } else if (align === 'stretch') {
+              ctrlLayoutRect.h = height;
+            }
+            ctrl.layoutRect(ctrlLayoutRect);
+            posX += width + spacingH;
+            if (ctrl.recalc) {
+              ctrl.recalc();
+            }
+          }
+          posY += height + spacingV;
+        }
+      }
+    });
+
+    var Iframe$1 = Widget.extend({
+      renderHtml: function () {
+        var self = this;
+        self.classes.add('iframe');
+        self.canFocus = false;
+        return '<iframe id="' + self._id + '" class="' + self.classes + '" tabindex="-1" src="' + (self.settings.url || 'javascript:\'\'') + '" frameborder="0"></iframe>';
+      },
+      src: function (src) {
+        this.getEl().src = src;
+      },
+      html: function (html, callback) {
+        var self = this, body = this.getEl().contentWindow.document.body;
+        if (!body) {
+          global$7.setTimeout(function () {
+            self.html(html);
+          });
+        } else {
+          body.innerHTML = html;
+          if (callback) {
+            callback();
+          }
+        }
+        return this;
+      }
+    });
+
+    var InfoBox = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.classes.add('widget').add('infobox');
+        self.canFocus = false;
+      },
+      severity: function (level) {
+        this.classes.remove('error');
+        this.classes.remove('warning');
+        this.classes.remove('success');
+        this.classes.add(level);
+      },
+      help: function (state) {
+        this.state.set('help', state);
+      },
+      renderHtml: function () {
+        var self = this, prefix = self.classPrefix;
+        return '<div id="' + self._id + '" class="' + self.classes + '">' + '<div id="' + self._id + '-body">' + self.encode(self.state.get('text')) + '<button role="button" tabindex="-1">' + '<i class="' + prefix + 'ico ' + prefix + 'i-help"></i>' + '</button>' + '</div>' + '</div>';
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:text', function (e) {
+          self.getEl('body').firstChild.data = self.encode(e.value);
+          if (self.state.get('rendered')) {
+            self.updateLayoutRect();
+          }
+        });
+        self.state.on('change:help', function (e) {
+          self.classes.toggle('has-help', e.value);
+          if (self.state.get('rendered')) {
+            self.updateLayoutRect();
+          }
+        });
+        return self._super();
+      }
+    });
+
+    var Label = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.classes.add('widget').add('label');
+        self.canFocus = false;
+        if (settings.multiline) {
+          self.classes.add('autoscroll');
+        }
+        if (settings.strong) {
+          self.classes.add('strong');
+        }
+      },
+      initLayoutRect: function () {
+        var self = this, layoutRect = self._super();
+        if (self.settings.multiline) {
+          var size = funcs.getSize(self.getEl());
+          if (size.width > layoutRect.maxW) {
+            layoutRect.minW = layoutRect.maxW;
+            self.classes.add('multiline');
+          }
+          self.getEl().style.width = layoutRect.minW + 'px';
+          layoutRect.startMinH = layoutRect.h = layoutRect.minH = Math.min(layoutRect.maxH, funcs.getSize(self.getEl()).height);
+        }
+        return layoutRect;
+      },
+      repaint: function () {
+        var self = this;
+        if (!self.settings.multiline) {
+          self.getEl().style.lineHeight = self.layoutRect().h + 'px';
+        }
+        return self._super();
+      },
+      severity: function (level) {
+        this.classes.remove('error');
+        this.classes.remove('warning');
+        this.classes.remove('success');
+        this.classes.add(level);
+      },
+      renderHtml: function () {
+        var self = this;
+        var targetCtrl, forName, forId = self.settings.forId;
+        var text = self.settings.html ? self.settings.html : self.encode(self.state.get('text'));
+        if (!forId && (forName = self.settings.forName)) {
+          targetCtrl = self.getRoot().find('#' + forName)[0];
+          if (targetCtrl) {
+            forId = targetCtrl._id;
+          }
+        }
+        if (forId) {
+          return '<label id="' + self._id + '" class="' + self.classes + '"' + (forId ? ' for="' + forId + '"' : '') + '>' + text + '</label>';
+        }
+        return '<span id="' + self._id + '" class="' + self.classes + '">' + text + '</span>';
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:text', function (e) {
+          self.innerHtml(self.encode(e.value));
+          if (self.state.get('rendered')) {
+            self.updateLayoutRect();
+          }
+        });
+        return self._super();
+      }
+    });
+
+    var Toolbar$1 = Container.extend({
+      Defaults: {
+        role: 'toolbar',
+        layout: 'flow'
+      },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.classes.add('toolbar');
+      },
+      postRender: function () {
+        var self = this;
+        self.items().each(function (ctrl) {
+          ctrl.classes.add('toolbar-item');
+        });
+        return self._super();
+      }
+    });
+
+    var MenuBar = Toolbar$1.extend({
+      Defaults: {
+        role: 'menubar',
+        containerCls: 'menubar',
+        ariaRoot: true,
+        defaults: { type: 'menubutton' }
+      }
+    });
+
+    function isChildOf$1(node, parent) {
+      while (node) {
+        if (parent === node) {
+          return true;
+        }
+        node = node.parentNode;
+      }
+      return false;
+    }
+    var MenuButton = Button.extend({
+      init: function (settings) {
+        var self = this;
+        self._renderOpen = true;
+        self._super(settings);
+        settings = self.settings;
+        self.classes.add('menubtn');
+        if (settings.fixedWidth) {
+          self.classes.add('fixed-width');
+        }
+        self.aria('haspopup', true);
+        self.state.set('menu', settings.menu || self.render());
+      },
+      showMenu: function (toggle) {
+        var self = this;
+        var menu;
+        if (self.menu && self.menu.visible() && toggle !== false) {
+          return self.hideMenu();
+        }
+        if (!self.menu) {
+          menu = self.state.get('menu') || [];
+          self.classes.add('opened');
+          if (menu.length) {
+            menu = {
+              type: 'menu',
+              animate: true,
+              items: menu
+            };
+          } else {
+            menu.type = menu.type || 'menu';
+            menu.animate = true;
+          }
+          if (!menu.renderTo) {
+            self.menu = global$4.create(menu).parent(self).renderTo();
+          } else {
+            self.menu = menu.parent(self).show().renderTo();
+          }
+          self.fire('createmenu');
+          self.menu.reflow();
+          self.menu.on('cancel', function (e) {
+            if (e.control.parent() === self.menu) {
+              e.stopPropagation();
+              self.focus();
+              self.hideMenu();
+            }
+          });
+          self.menu.on('select', function () {
+            self.focus();
+          });
+          self.menu.on('show hide', function (e) {
+            if (e.type === 'hide' && e.control.parent() === self) {
+              self.classes.remove('opened-under');
+            }
+            if (e.control === self.menu) {
+              self.activeMenu(e.type === 'show');
+              self.classes.toggle('opened', e.type === 'show');
+            }
+            self.aria('expanded', e.type === 'show');
+          }).fire('show');
+        }
+        self.menu.show();
+        self.menu.layoutRect({ w: self.layoutRect().w });
+        self.menu.repaint();
+        self.menu.moveRel(self.getEl(), self.isRtl() ? [
+          'br-tr',
+          'tr-br'
+        ] : [
+          'bl-tl',
+          'tl-bl'
+        ]);
+        var menuLayoutRect = self.menu.layoutRect();
+        var selfBottom = self.$el.offset().top + self.layoutRect().h;
+        if (selfBottom > menuLayoutRect.y && selfBottom < menuLayoutRect.y + menuLayoutRect.h) {
+          self.classes.add('opened-under');
+        }
+        self.fire('showmenu');
+      },
+      hideMenu: function () {
+        var self = this;
+        if (self.menu) {
+          self.menu.items().each(function (item) {
+            if (item.hideMenu) {
+              item.hideMenu();
+            }
+          });
+          self.menu.hide();
+        }
+      },
+      activeMenu: function (state) {
+        this.classes.toggle('active', state);
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = self.classPrefix;
+        var icon = self.settings.icon, image;
+        var text = self.state.get('text');
+        var textHtml = '';
+        image = self.settings.image;
+        if (image) {
+          icon = 'none';
+          if (typeof image !== 'string') {
+            image = domGlobals.window.getSelection ? image[0] : image[1];
+          }
+          image = ' style="background-image: url(\'' + image + '\')"';
+        } else {
+          image = '';
+        }
+        if (text) {
+          self.classes.add('btn-has-text');
+          textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
+        }
+        icon = self.settings.icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
+        self.aria('role', self.parent() instanceof MenuBar ? 'menuitem' : 'button');
+        return '<div id="' + id + '" class="' + self.classes + '" tabindex="-1" aria-labelledby="' + id + '">' + '<button id="' + id + '-open" role="presentation" type="button" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + textHtml + ' <i class="' + prefix + 'caret"></i>' + '</button>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        self.on('click', function (e) {
+          if (e.control === self && isChildOf$1(e.target, self.getEl())) {
+            self.focus();
+            self.showMenu(!e.aria);
+            if (e.aria) {
+              self.menu.items().filter(':visible')[0].focus();
+            }
+          }
+        });
+        self.on('mouseenter', function (e) {
+          var overCtrl = e.control;
+          var parent = self.parent();
+          var hasVisibleSiblingMenu;
+          if (overCtrl && parent && overCtrl instanceof MenuButton && overCtrl.parent() === parent) {
+            parent.items().filter('MenuButton').each(function (ctrl) {
+              if (ctrl.hideMenu && ctrl !== overCtrl) {
+                if (ctrl.menu && ctrl.menu.visible()) {
+                  hasVisibleSiblingMenu = true;
+                }
+                ctrl.hideMenu();
+              }
+            });
+            if (hasVisibleSiblingMenu) {
+              overCtrl.focus();
+              overCtrl.showMenu();
+            }
+          }
+        });
+        return self._super();
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:menu', function () {
+          if (self.menu) {
+            self.menu.remove();
+          }
+          self.menu = null;
+        });
+        return self._super();
+      },
+      remove: function () {
+        this._super();
+        if (this.menu) {
+          this.menu.remove();
+        }
+      }
+    });
+
+    var Menu = FloatPanel.extend({
+      Defaults: {
+        defaultType: 'menuitem',
+        border: 1,
+        layout: 'stack',
+        role: 'application',
+        bodyRole: 'menu',
+        ariaRoot: true
+      },
+      init: function (settings) {
+        var self = this;
+        settings.autohide = true;
+        settings.constrainToViewport = true;
+        if (typeof settings.items === 'function') {
+          settings.itemsFactory = settings.items;
+          settings.items = [];
+        }
+        if (settings.itemDefaults) {
+          var items = settings.items;
+          var i = items.length;
+          while (i--) {
+            items[i] = global$2.extend({}, settings.itemDefaults, items[i]);
+          }
+        }
+        self._super(settings);
+        self.classes.add('menu');
+        if (settings.animate && global$8.ie !== 11) {
+          self.classes.add('animate');
+        }
+      },
+      repaint: function () {
+        this.classes.toggle('menu-align', true);
+        this._super();
+        this.getEl().style.height = '';
+        this.getEl('body').style.height = '';
+        return this;
+      },
+      cancel: function () {
+        var self = this;
+        self.hideAll();
+        self.fire('select');
+      },
+      load: function () {
+        var self = this;
+        var time, factory;
+        function hideThrobber() {
+          if (self.throbber) {
+            self.throbber.hide();
+            self.throbber = null;
+          }
+        }
+        factory = self.settings.itemsFactory;
+        if (!factory) {
+          return;
+        }
+        if (!self.throbber) {
+          self.throbber = new Throbber(self.getEl('body'), true);
+          if (self.items().length === 0) {
+            self.throbber.show();
+            self.fire('loading');
+          } else {
+            self.throbber.show(100, function () {
+              self.items().remove();
+              self.fire('loading');
+            });
+          }
+          self.on('hide close', hideThrobber);
+        }
+        self.requestTime = time = new Date().getTime();
+        self.settings.itemsFactory(function (items) {
+          if (items.length === 0) {
+            self.hide();
+            return;
+          }
+          if (self.requestTime !== time) {
+            return;
+          }
+          self.getEl().style.width = '';
+          self.getEl('body').style.width = '';
+          hideThrobber();
+          self.items().remove();
+          self.getEl('body').innerHTML = '';
+          self.add(items);
+          self.renderNew();
+          self.fire('loaded');
+        });
+      },
+      hideAll: function () {
+        var self = this;
+        this.find('menuitem').exec('hideMenu');
+        return self._super();
+      },
+      preRender: function () {
+        var self = this;
+        self.items().each(function (ctrl) {
+          var settings = ctrl.settings;
+          if (settings.icon || settings.image || settings.selectable) {
+            self._hasIcons = true;
+            return false;
+          }
+        });
+        if (self.settings.itemsFactory) {
+          self.on('postrender', function () {
+            if (self.settings.itemsFactory) {
+              self.load();
+            }
+          });
+        }
+        self.on('show hide', function (e) {
+          if (e.control === self) {
+            if (e.type === 'show') {
+              global$7.setTimeout(function () {
+                self.classes.add('in');
+              }, 0);
+            } else {
+              self.classes.remove('in');
+            }
+          }
+        });
+        return self._super();
+      }
+    });
+
+    var ListBox = MenuButton.extend({
+      init: function (settings) {
+        var self = this;
+        var values, selected, selectedText, lastItemCtrl;
+        function setSelected(menuValues) {
+          for (var i = 0; i < menuValues.length; i++) {
+            selected = menuValues[i].selected || settings.value === menuValues[i].value;
+            if (selected) {
+              selectedText = selectedText || menuValues[i].text;
+              self.state.set('value', menuValues[i].value);
+              return true;
+            }
+            if (menuValues[i].menu) {
+              if (setSelected(menuValues[i].menu)) {
+                return true;
+              }
+            }
+          }
+        }
+        self._super(settings);
+        settings = self.settings;
+        self._values = values = settings.values;
+        if (values) {
+          if (typeof settings.value !== 'undefined') {
+            setSelected(values);
+          }
+          if (!selected && values.length > 0) {
+            selectedText = values[0].text;
+            self.state.set('value', values[0].value);
+          }
+          self.state.set('menu', values);
+        }
+        self.state.set('text', settings.text || selectedText);
+        self.classes.add('listbox');
+        self.on('select', function (e) {
+          var ctrl = e.control;
+          if (lastItemCtrl) {
+            e.lastControl = lastItemCtrl;
+          }
+          if (settings.multiple) {
+            ctrl.active(!ctrl.active());
+          } else {
+            self.value(e.control.value());
+          }
+          lastItemCtrl = ctrl;
+        });
+      },
+      value: function (value) {
+        if (arguments.length === 0) {
+          return this.state.get('value');
+        }
+        if (typeof value === 'undefined') {
+          return this;
+        }
+        function valueExists(values) {
+          return exists(values, function (a) {
+            return a.menu ? valueExists(a.menu) : a.value === value;
+          });
+        }
+        if (this.settings.values) {
+          if (valueExists(this.settings.values)) {
+            this.state.set('value', value);
+          } else if (value === null) {
+            this.state.set('value', null);
+          }
+        } else {
+          this.state.set('value', value);
+        }
+        return this;
+      },
+      bindStates: function () {
+        var self = this;
+        function activateMenuItemsByValue(menu, value) {
+          if (menu instanceof Menu) {
+            menu.items().each(function (ctrl) {
+              if (!ctrl.hasMenus()) {
+                ctrl.active(ctrl.value() === value);
+              }
+            });
+          }
+        }
+        function getSelectedItem(menuValues, value) {
+          var selectedItem;
+          if (!menuValues) {
+            return;
+          }
+          for (var i = 0; i < menuValues.length; i++) {
+            if (menuValues[i].value === value) {
+              return menuValues[i];
+            }
+            if (menuValues[i].menu) {
+              selectedItem = getSelectedItem(menuValues[i].menu, value);
+              if (selectedItem) {
+                return selectedItem;
+              }
+            }
+          }
+        }
+        self.on('show', function (e) {
+          activateMenuItemsByValue(e.control, self.value());
+        });
+        self.state.on('change:value', function (e) {
+          var selectedItem = getSelectedItem(self.state.get('menu'), e.value);
+          if (selectedItem) {
+            self.text(selectedItem.text);
+          } else {
+            self.text(self.settings.text);
+          }
+        });
+        return self._super();
+      }
+    });
+
+    var toggleTextStyle = function (ctrl, state) {
+      var textStyle = ctrl._textStyle;
+      if (textStyle) {
+        var textElm = ctrl.getEl('text');
+        textElm.setAttribute('style', textStyle);
+        if (state) {
+          textElm.style.color = '';
+          textElm.style.backgroundColor = '';
+        }
+      }
+    };
+    var MenuItem = Widget.extend({
+      Defaults: {
+        border: 0,
+        role: 'menuitem'
+      },
+      init: function (settings) {
+        var self = this;
+        var text;
+        self._super(settings);
+        settings = self.settings;
+        self.classes.add('menu-item');
+        if (settings.menu) {
+          self.classes.add('menu-item-expand');
+        }
+        if (settings.preview) {
+          self.classes.add('menu-item-preview');
+        }
+        text = self.state.get('text');
+        if (text === '-' || text === '|') {
+          self.classes.add('menu-item-sep');
+          self.aria('role', 'separator');
+          self.state.set('text', '-');
+        }
+        if (settings.selectable) {
+          self.aria('role', 'menuitemcheckbox');
+          self.classes.add('menu-item-checkbox');
+          settings.icon = 'selected';
+        }
+        if (!settings.preview && !settings.selectable) {
+          self.classes.add('menu-item-normal');
+        }
+        self.on('mousedown', function (e) {
+          e.preventDefault();
+        });
+        if (settings.menu && !settings.ariaHideMenu) {
+          self.aria('haspopup', true);
+        }
+      },
+      hasMenus: function () {
+        return !!this.settings.menu;
+      },
+      showMenu: function () {
+        var self = this;
+        var settings = self.settings;
+        var menu;
+        var parent = self.parent();
+        parent.items().each(function (ctrl) {
+          if (ctrl !== self) {
+            ctrl.hideMenu();
+          }
+        });
+        if (settings.menu) {
+          menu = self.menu;
+          if (!menu) {
+            menu = settings.menu;
+            if (menu.length) {
+              menu = {
+                type: 'menu',
+                items: menu
+              };
+            } else {
+              menu.type = menu.type || 'menu';
+            }
+            if (parent.settings.itemDefaults) {
+              menu.itemDefaults = parent.settings.itemDefaults;
+            }
+            menu = self.menu = global$4.create(menu).parent(self).renderTo();
+            menu.reflow();
+            menu.on('cancel', function (e) {
+              e.stopPropagation();
+              self.focus();
+              menu.hide();
+            });
+            menu.on('show hide', function (e) {
+              if (e.control.items) {
+                e.control.items().each(function (ctrl) {
+                  ctrl.active(ctrl.settings.selected);
+                });
+              }
+            }).fire('show');
+            menu.on('hide', function (e) {
+              if (e.control === menu) {
+                self.classes.remove('selected');
+              }
+            });
+            menu.submenu = true;
+          } else {
+            menu.show();
+          }
+          menu._parentMenu = parent;
+          menu.classes.add('menu-sub');
+          var rel = menu.testMoveRel(self.getEl(), self.isRtl() ? [
+            'tl-tr',
+            'bl-br',
+            'tr-tl',
+            'br-bl'
+          ] : [
+            'tr-tl',
+            'br-bl',
+            'tl-tr',
+            'bl-br'
+          ]);
+          menu.moveRel(self.getEl(), rel);
+          menu.rel = rel;
+          rel = 'menu-sub-' + rel;
+          menu.classes.remove(menu._lastRel).add(rel);
+          menu._lastRel = rel;
+          self.classes.add('selected');
+          self.aria('expanded', true);
+        }
+      },
+      hideMenu: function () {
+        var self = this;
+        if (self.menu) {
+          self.menu.items().each(function (item) {
+            if (item.hideMenu) {
+              item.hideMenu();
+            }
+          });
+          self.menu.hide();
+          self.aria('expanded', false);
+        }
+        return self;
+      },
+      renderHtml: function () {
+        var self = this;
+        var id = self._id;
+        var settings = self.settings;
+        var prefix = self.classPrefix;
+        var text = self.state.get('text');
+        var icon = self.settings.icon, image = '', shortcut = settings.shortcut;
+        var url = self.encode(settings.url), iconHtml = '';
+        function convertShortcut(shortcut) {
+          var i, value, replace = {};
+          if (global$8.mac) {
+            replace = {
+              alt: '&#x2325;',
+              ctrl: '&#x2318;',
+              shift: '&#x21E7;',
+              meta: '&#x2318;'
+            };
+          } else {
+            replace = { meta: 'Ctrl' };
+          }
+          shortcut = shortcut.split('+');
+          for (i = 0; i < shortcut.length; i++) {
+            value = replace[shortcut[i].toLowerCase()];
+            if (value) {
+              shortcut[i] = value;
+            }
+          }
+          return shortcut.join('+');
+        }
+        function escapeRegExp(str) {
+          return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        }
+        function markMatches(text) {
+          var match = settings.match || '';
+          return match ? text.replace(new RegExp(escapeRegExp(match), 'gi'), function (match) {
+            return '!mce~match[' + match + ']mce~match!';
+          }) : text;
+        }
+        function boldMatches(text) {
+          return text.replace(new RegExp(escapeRegExp('!mce~match['), 'g'), '<b>').replace(new RegExp(escapeRegExp(']mce~match!'), 'g'), '</b>');
+        }
+        if (icon) {
+          self.parent().classes.add('menu-has-icons');
+        }
+        if (settings.image) {
+          image = ' style="background-image: url(\'' + settings.image + '\')"';
+        }
+        if (shortcut) {
+          shortcut = convertShortcut(shortcut);
+        }
+        icon = prefix + 'ico ' + prefix + 'i-' + (self.settings.icon || 'none');
+        iconHtml = text !== '-' ? '<i class="' + icon + '"' + image + '></i>\xA0' : '';
+        text = boldMatches(self.encode(markMatches(text)));
+        url = boldMatches(self.encode(markMatches(url)));
+        return '<div id="' + id + '" class="' + self.classes + '" tabindex="-1">' + iconHtml + (text !== '-' ? '<span id="' + id + '-text" class="' + prefix + 'text">' + text + '</span>' : '') + (shortcut ? '<div id="' + id + '-shortcut" class="' + prefix + 'menu-shortcut">' + shortcut + '</div>' : '') + (settings.menu ? '<div class="' + prefix + 'caret"></div>' : '') + (url ? '<div class="' + prefix + 'menu-item-link">' + url + '</div>' : '') + '</div>';
+      },
+      postRender: function () {
+        var self = this, settings = self.settings;
+        var textStyle = settings.textStyle;
+        if (typeof textStyle === 'function') {
+          textStyle = textStyle.call(this);
+        }
+        if (textStyle) {
+          var textElm = self.getEl('text');
+          if (textElm) {
+            textElm.setAttribute('style', textStyle);
+            self._textStyle = textStyle;
+          }
+        }
+        self.on('mouseenter click', function (e) {
+          if (e.control === self) {
+            if (!settings.menu && e.type === 'click') {
+              self.fire('select');
+              global$7.requestAnimationFrame(function () {
+                self.parent().hideAll();
+              });
+            } else {
+              self.showMenu();
+              if (e.aria) {
+                self.menu.focus(true);
+              }
+            }
+          }
+        });
+        self._super();
+        return self;
+      },
+      hover: function () {
+        var self = this;
+        self.parent().items().each(function (ctrl) {
+          ctrl.classes.remove('selected');
+        });
+        self.classes.toggle('selected', true);
+        return self;
+      },
+      active: function (state) {
+        toggleTextStyle(this, state);
+        if (typeof state !== 'undefined') {
+          this.aria('checked', state);
+        }
+        return this._super(state);
+      },
+      remove: function () {
+        this._super();
+        if (this.menu) {
+          this.menu.remove();
+        }
+      }
+    });
+
+    var Radio = Checkbox.extend({
+      Defaults: {
+        classes: 'radio',
+        role: 'radio'
+      }
+    });
+
+    var ResizeHandle = Widget.extend({
+      renderHtml: function () {
+        var self = this, prefix = self.classPrefix;
+        self.classes.add('resizehandle');
+        if (self.settings.direction === 'both') {
+          self.classes.add('resizehandle-both');
+        }
+        self.canFocus = false;
+        return '<div id="' + self._id + '" class="' + self.classes + '">' + '<i class="' + prefix + 'ico ' + prefix + 'i-resize"></i>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        self._super();
+        self.resizeDragHelper = new DragHelper(this._id, {
+          start: function () {
+            self.fire('ResizeStart');
+          },
+          drag: function (e) {
+            if (self.settings.direction !== 'both') {
+              e.deltaX = 0;
+            }
+            self.fire('Resize', e);
+          },
+          stop: function () {
+            self.fire('ResizeEnd');
+          }
+        });
+      },
+      remove: function () {
+        if (this.resizeDragHelper) {
+          this.resizeDragHelper.destroy();
+        }
+        return this._super();
+      }
+    });
+
+    function createOptions(options) {
+      var strOptions = '';
+      if (options) {
+        for (var i = 0; i < options.length; i++) {
+          strOptions += '<option value="' + options[i] + '">' + options[i] + '</option>';
+        }
+      }
+      return strOptions;
+    }
+    var SelectBox = Widget.extend({
+      Defaults: {
+        classes: 'selectbox',
+        role: 'selectbox',
+        options: []
+      },
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        if (self.settings.size) {
+          self.size = self.settings.size;
+        }
+        if (self.settings.options) {
+          self._options = self.settings.options;
+        }
+        self.on('keydown', function (e) {
+          var rootControl;
+          if (e.keyCode === 13) {
+            e.preventDefault();
+            self.parents().reverse().each(function (ctrl) {
+              if (ctrl.toJSON) {
+                rootControl = ctrl;
+                return false;
+              }
+            });
+            self.fire('submit', { data: rootControl.toJSON() });
+          }
+        });
+      },
+      options: function (state) {
+        if (!arguments.length) {
+          return this.state.get('options');
+        }
+        this.state.set('options', state);
+        return this;
+      },
+      renderHtml: function () {
+        var self = this;
+        var options, size = '';
+        options = createOptions(self._options);
+        if (self.size) {
+          size = ' size = "' + self.size + '"';
+        }
+        return '<select id="' + self._id + '" class="' + self.classes + '"' + size + '>' + options + '</select>';
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:options', function (e) {
+          self.getEl().innerHTML = createOptions(e.value);
+        });
+        return self._super();
+      }
+    });
+
+    function constrain(value, minVal, maxVal) {
+      if (value < minVal) {
+        value = minVal;
+      }
+      if (value > maxVal) {
+        value = maxVal;
+      }
+      return value;
+    }
+    function setAriaProp(el, name, value) {
+      el.setAttribute('aria-' + name, value);
+    }
+    function updateSliderHandle(ctrl, value) {
+      var maxHandlePos, shortSizeName, sizeName, stylePosName, styleValue, handleEl;
+      if (ctrl.settings.orientation === 'v') {
+        stylePosName = 'top';
+        sizeName = 'height';
+        shortSizeName = 'h';
+      } else {
+        stylePosName = 'left';
+        sizeName = 'width';
+        shortSizeName = 'w';
+      }
+      handleEl = ctrl.getEl('handle');
+      maxHandlePos = (ctrl.layoutRect()[shortSizeName] || 100) - funcs.getSize(handleEl)[sizeName];
+      styleValue = maxHandlePos * ((value - ctrl._minValue) / (ctrl._maxValue - ctrl._minValue)) + 'px';
+      handleEl.style[stylePosName] = styleValue;
+      handleEl.style.height = ctrl.layoutRect().h + 'px';
+      setAriaProp(handleEl, 'valuenow', value);
+      setAriaProp(handleEl, 'valuetext', '' + ctrl.settings.previewFilter(value));
+      setAriaProp(handleEl, 'valuemin', ctrl._minValue);
+      setAriaProp(handleEl, 'valuemax', ctrl._maxValue);
+    }
+    var Slider = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        if (!settings.previewFilter) {
+          settings.previewFilter = function (value) {
+            return Math.round(value * 100) / 100;
+          };
+        }
+        self._super(settings);
+        self.classes.add('slider');
+        if (settings.orientation === 'v') {
+          self.classes.add('vertical');
+        }
+        self._minValue = isNumber(settings.minValue) ? settings.minValue : 0;
+        self._maxValue = isNumber(settings.maxValue) ? settings.maxValue : 100;
+        self._initValue = self.state.get('value');
+      },
+      renderHtml: function () {
+        var self = this, id = self._id, prefix = self.classPrefix;
+        return '<div id="' + id + '" class="' + self.classes + '">' + '<div id="' + id + '-handle" class="' + prefix + 'slider-handle" role="slider" tabindex="-1"></div>' + '</div>';
+      },
+      reset: function () {
+        this.value(this._initValue).repaint();
+      },
+      postRender: function () {
+        var self = this;
+        var minValue, maxValue, screenCordName, stylePosName, sizeName, shortSizeName;
+        function toFraction(min, max, val) {
+          return (val + min) / (max - min);
+        }
+        function fromFraction(min, max, val) {
+          return val * (max - min) - min;
+        }
+        function handleKeyboard(minValue, maxValue) {
+          function alter(delta) {
+            var value;
+            value = self.value();
+            value = fromFraction(minValue, maxValue, toFraction(minValue, maxValue, value) + delta * 0.05);
+            value = constrain(value, minValue, maxValue);
+            self.value(value);
+            self.fire('dragstart', { value: value });
+            self.fire('drag', { value: value });
+            self.fire('dragend', { value: value });
+          }
+          self.on('keydown', function (e) {
+            switch (e.keyCode) {
+            case 37:
+            case 38:
+              alter(-1);
+              break;
+            case 39:
+            case 40:
+              alter(1);
+              break;
+            }
+          });
+        }
+        function handleDrag(minValue, maxValue, handleEl) {
+          var startPos, startHandlePos, maxHandlePos, handlePos, value;
+          self._dragHelper = new DragHelper(self._id, {
+            handle: self._id + '-handle',
+            start: function (e) {
+              startPos = e[screenCordName];
+              startHandlePos = parseInt(self.getEl('handle').style[stylePosName], 10);
+              maxHandlePos = (self.layoutRect()[shortSizeName] || 100) - funcs.getSize(handleEl)[sizeName];
+              self.fire('dragstart', { value: value });
+            },
+            drag: function (e) {
+              var delta = e[screenCordName] - startPos;
+              handlePos = constrain(startHandlePos + delta, 0, maxHandlePos);
+              handleEl.style[stylePosName] = handlePos + 'px';
+              value = minValue + handlePos / maxHandlePos * (maxValue - minValue);
+              self.value(value);
+              self.tooltip().text('' + self.settings.previewFilter(value)).show().moveRel(handleEl, 'bc tc');
+              self.fire('drag', { value: value });
+            },
+            stop: function () {
+              self.tooltip().hide();
+              self.fire('dragend', { value: value });
+            }
+          });
+        }
+        minValue = self._minValue;
+        maxValue = self._maxValue;
+        if (self.settings.orientation === 'v') {
+          screenCordName = 'screenY';
+          stylePosName = 'top';
+          sizeName = 'height';
+          shortSizeName = 'h';
+        } else {
+          screenCordName = 'screenX';
+          stylePosName = 'left';
+          sizeName = 'width';
+          shortSizeName = 'w';
+        }
+        self._super();
+        handleKeyboard(minValue, maxValue);
+        handleDrag(minValue, maxValue, self.getEl('handle'));
+      },
+      repaint: function () {
+        this._super();
+        updateSliderHandle(this, this.value());
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:value', function (e) {
+          updateSliderHandle(self, e.value);
+        });
+        return self._super();
+      }
+    });
+
+    var Spacer = Widget.extend({
+      renderHtml: function () {
+        var self = this;
+        self.classes.add('spacer');
+        self.canFocus = false;
+        return '<div id="' + self._id + '" class="' + self.classes + '"></div>';
+      }
+    });
+
+    var SplitButton = MenuButton.extend({
+      Defaults: {
+        classes: 'widget btn splitbtn',
+        role: 'button'
+      },
+      repaint: function () {
+        var self = this;
+        var elm = self.getEl();
+        var rect = self.layoutRect();
+        var mainButtonElm, menuButtonElm;
+        self._super();
+        mainButtonElm = elm.firstChild;
+        menuButtonElm = elm.lastChild;
+        global$9(mainButtonElm).css({
+          width: rect.w - funcs.getSize(menuButtonElm).width,
+          height: rect.h - 2
+        });
+        global$9(menuButtonElm).css({ height: rect.h - 2 });
+        return self;
+      },
+      activeMenu: function (state) {
+        var self = this;
+        global$9(self.getEl().lastChild).toggleClass(self.classPrefix + 'active', state);
+      },
+      renderHtml: function () {
+        var self = this;
+        var id = self._id;
+        var prefix = self.classPrefix;
+        var image;
+        var icon = self.state.get('icon');
+        var text = self.state.get('text');
+        var settings = self.settings;
+        var textHtml = '', ariaPressed;
+        image = settings.image;
+        if (image) {
+          icon = 'none';
+          if (typeof image !== 'string') {
+            image = domGlobals.window.getSelection ? image[0] : image[1];
+          }
+          image = ' style="background-image: url(\'' + image + '\')"';
+        } else {
+          image = '';
+        }
+        icon = settings.icon ? prefix + 'ico ' + prefix + 'i-' + icon : '';
+        if (text) {
+          self.classes.add('btn-has-text');
+          textHtml = '<span class="' + prefix + 'txt">' + self.encode(text) + '</span>';
+        }
+        ariaPressed = typeof settings.active === 'boolean' ? ' aria-pressed="' + settings.active + '"' : '';
+        return '<div id="' + id + '" class="' + self.classes + '" role="button"' + ariaPressed + ' tabindex="-1">' + '<button type="button" hidefocus="1" tabindex="-1">' + (icon ? '<i class="' + icon + '"' + image + '></i>' : '') + textHtml + '</button>' + '<button type="button" class="' + prefix + 'open" hidefocus="1" tabindex="-1">' + (self._menuBtnText ? (icon ? '\xA0' : '') + self._menuBtnText : '') + ' <i class="' + prefix + 'caret"></i>' + '</button>' + '</div>';
+      },
+      postRender: function () {
+        var self = this, onClickHandler = self.settings.onclick;
+        self.on('click', function (e) {
+          var node = e.target;
+          if (e.control === this) {
+            while (node) {
+              if (e.aria && e.aria.key !== 'down' || node.nodeName === 'BUTTON' && node.className.indexOf('open') === -1) {
+                e.stopImmediatePropagation();
+                if (onClickHandler) {
+                  onClickHandler.call(this, e);
+                }
+                return;
+              }
+              node = node.parentNode;
+            }
+          }
+        });
+        delete self.settings.onclick;
+        return self._super();
+      }
+    });
+
+    var StackLayout = FlowLayout.extend({
+      Defaults: {
+        containerClass: 'stack-layout',
+        controlClass: 'stack-layout-item',
+        endClass: 'break'
+      },
+      isNative: function () {
+        return true;
+      }
+    });
+
+    var TabPanel = Panel.extend({
+      Defaults: {
+        layout: 'absolute',
+        defaults: { type: 'panel' }
+      },
+      activateTab: function (idx) {
+        var activeTabElm;
+        if (this.activeTabId) {
+          activeTabElm = this.getEl(this.activeTabId);
+          global$9(activeTabElm).removeClass(this.classPrefix + 'active');
+          activeTabElm.setAttribute('aria-selected', 'false');
+        }
+        this.activeTabId = 't' + idx;
+        activeTabElm = this.getEl('t' + idx);
+        activeTabElm.setAttribute('aria-selected', 'true');
+        global$9(activeTabElm).addClass(this.classPrefix + 'active');
+        this.items()[idx].show().fire('showtab');
+        this.reflow();
+        this.items().each(function (item, i) {
+          if (idx !== i) {
+            item.hide();
+          }
+        });
+      },
+      renderHtml: function () {
+        var self = this;
+        var layout = self._layout;
+        var tabsHtml = '';
+        var prefix = self.classPrefix;
+        self.preRender();
+        layout.preRender(self);
+        self.items().each(function (ctrl, i) {
+          var id = self._id + '-t' + i;
+          ctrl.aria('role', 'tabpanel');
+          ctrl.aria('labelledby', id);
+          tabsHtml += '<div id="' + id + '" class="' + prefix + 'tab" ' + 'unselectable="on" role="tab" aria-controls="' + ctrl._id + '" aria-selected="false" tabIndex="-1">' + self.encode(ctrl.settings.title) + '</div>';
+        });
+        return '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' + '<div id="' + self._id + '-head" class="' + prefix + 'tabs" role="tablist">' + tabsHtml + '</div>' + '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' + layout.renderHtml(self) + '</div>' + '</div>';
+      },
+      postRender: function () {
+        var self = this;
+        self._super();
+        self.settings.activeTab = self.settings.activeTab || 0;
+        self.activateTab(self.settings.activeTab);
+        this.on('click', function (e) {
+          var targetParent = e.target.parentNode;
+          if (targetParent && targetParent.id === self._id + '-head') {
+            var i = targetParent.childNodes.length;
+            while (i--) {
+              if (targetParent.childNodes[i] === e.target) {
+                self.activateTab(i);
+              }
+            }
+          }
+        });
+      },
+      initLayoutRect: function () {
+        var self = this;
+        var rect, minW, minH;
+        minW = funcs.getSize(self.getEl('head')).width;
+        minW = minW < 0 ? 0 : minW;
+        minH = 0;
+        self.items().each(function (item) {
+          minW = Math.max(minW, item.layoutRect().minW);
+          minH = Math.max(minH, item.layoutRect().minH);
+        });
+        self.items().each(function (ctrl) {
+          ctrl.settings.x = 0;
+          ctrl.settings.y = 0;
+          ctrl.settings.w = minW;
+          ctrl.settings.h = minH;
+          ctrl.layoutRect({
+            x: 0,
+            y: 0,
+            w: minW,
+            h: minH
+          });
+        });
+        var headH = funcs.getSize(self.getEl('head')).height;
+        self.settings.minWidth = minW;
+        self.settings.minHeight = minH + headH;
+        rect = self._super();
+        rect.deltaH += headH;
+        rect.innerH = rect.h - rect.deltaH;
+        return rect;
+      }
+    });
+
+    var TextBox = Widget.extend({
+      init: function (settings) {
+        var self = this;
+        self._super(settings);
+        self.classes.add('textbox');
+        if (settings.multiline) {
+          self.classes.add('multiline');
+        } else {
+          self.on('keydown', function (e) {
+            var rootControl;
+            if (e.keyCode === 13) {
+              e.preventDefault();
+              self.parents().reverse().each(function (ctrl) {
+                if (ctrl.toJSON) {
+                  rootControl = ctrl;
+                  return false;
+                }
+              });
+              self.fire('submit', { data: rootControl.toJSON() });
+            }
+          });
+          self.on('keyup', function (e) {
+            self.state.set('value', e.target.value);
+          });
+        }
+      },
+      repaint: function () {
+        var self = this;
+        var style, rect, borderBox, borderW, borderH = 0, lastRepaintRect;
+        style = self.getEl().style;
+        rect = self._layoutRect;
+        lastRepaintRect = self._lastRepaintRect || {};
+        var doc = domGlobals.document;
+        if (!self.settings.multiline && doc.all && (!doc.documentMode || doc.documentMode <= 8)) {
+          style.lineHeight = rect.h - borderH + 'px';
+        }
+        borderBox = self.borderBox;
+        borderW = borderBox.left + borderBox.right + 8;
+        borderH = borderBox.top + borderBox.bottom + (self.settings.multiline ? 8 : 0);
+        if (rect.x !== lastRepaintRect.x) {
+          style.left = rect.x + 'px';
+          lastRepaintRect.x = rect.x;
+        }
+        if (rect.y !== lastRepaintRect.y) {
+          style.top = rect.y + 'px';
+          lastRepaintRect.y = rect.y;
+        }
+        if (rect.w !== lastRepaintRect.w) {
+          style.width = rect.w - borderW + 'px';
+          lastRepaintRect.w = rect.w;
+        }
+        if (rect.h !== lastRepaintRect.h) {
+          style.height = rect.h - borderH + 'px';
+          lastRepaintRect.h = rect.h;
+        }
+        self._lastRepaintRect = lastRepaintRect;
+        self.fire('repaint', {}, false);
+        return self;
+      },
+      renderHtml: function () {
+        var self = this;
+        var settings = self.settings;
+        var attrs, elm;
+        attrs = {
+          id: self._id,
+          hidefocus: '1'
+        };
+        global$2.each([
+          'rows',
+          'spellcheck',
+          'maxLength',
+          'size',
+          'readonly',
+          'min',
+          'max',
+          'step',
+          'list',
+          'pattern',
+          'placeholder',
+          'required',
+          'multiple'
+        ], function (name) {
+          attrs[name] = settings[name];
+        });
+        if (self.disabled()) {
+          attrs.disabled = 'disabled';
+        }
+        if (settings.subtype) {
+          attrs.type = settings.subtype;
+        }
+        elm = funcs.create(settings.multiline ? 'textarea' : 'input', attrs);
+        elm.value = self.state.get('value');
+        elm.className = self.classes.toString();
+        return elm.outerHTML;
+      },
+      value: function (value) {
+        if (arguments.length) {
+          this.state.set('value', value);
+          return this;
+        }
+        if (this.state.get('rendered')) {
+          this.state.set('value', this.getEl().value);
+        }
+        return this.state.get('value');
+      },
+      postRender: function () {
+        var self = this;
+        self.getEl().value = self.state.get('value');
+        self._super();
+        self.$el.on('change', function (e) {
+          self.state.set('value', e.target.value);
+          self.fire('change', e);
+        });
+      },
+      bindStates: function () {
+        var self = this;
+        self.state.on('change:value', function (e) {
+          if (self.getEl().value !== e.value) {
+            self.getEl().value = e.value;
+          }
+        });
+        self.state.on('change:disabled', function (e) {
+          self.getEl().disabled = e.value;
+        });
+        return self._super();
+      },
+      remove: function () {
+        this.$el.off();
+        this._super();
+      }
+    });
+
+    var getApi = function () {
+      return {
+        Selector: Selector,
+        Collection: Collection$2,
+        ReflowQueue: ReflowQueue,
+        Control: Control$1,
+        Factory: global$4,
+        KeyboardNavigation: KeyboardNavigation,
+        Container: Container,
+        DragHelper: DragHelper,
+        Scrollable: Scrollable,
+        Panel: Panel,
+        Movable: Movable,
+        Resizable: Resizable,
+        FloatPanel: FloatPanel,
+        Window: Window,
+        MessageBox: MessageBox,
+        Tooltip: Tooltip,
+        Widget: Widget,
+        Progress: Progress,
+        Notification: Notification,
+        Layout: Layout,
+        AbsoluteLayout: AbsoluteLayout,
+        Button: Button,
+        ButtonGroup: ButtonGroup,
+        Checkbox: Checkbox,
+        ComboBox: ComboBox,
+        ColorBox: ColorBox,
+        PanelButton: PanelButton,
+        ColorButton: ColorButton,
+        ColorPicker: ColorPicker,
+        Path: Path,
+        ElementPath: ElementPath,
+        FormItem: FormItem,
+        Form: Form,
+        FieldSet: FieldSet,
+        FilePicker: FilePicker,
+        FitLayout: FitLayout,
+        FlexLayout: FlexLayout,
+        FlowLayout: FlowLayout,
+        FormatControls: FormatControls,
+        GridLayout: GridLayout,
+        Iframe: Iframe$1,
+        InfoBox: InfoBox,
+        Label: Label,
+        Toolbar: Toolbar$1,
+        MenuBar: MenuBar,
+        MenuButton: MenuButton,
+        MenuItem: MenuItem,
+        Throbber: Throbber,
+        Menu: Menu,
+        ListBox: ListBox,
+        Radio: Radio,
+        ResizeHandle: ResizeHandle,
+        SelectBox: SelectBox,
+        Slider: Slider,
+        Spacer: Spacer,
+        SplitButton: SplitButton,
+        StackLayout: StackLayout,
+        TabPanel: TabPanel,
+        TextBox: TextBox,
+        DropZone: DropZone,
+        BrowseButton: BrowseButton
+      };
+    };
+    var appendTo = function (target) {
+      if (target.ui) {
+        global$2.each(getApi(), function (ref, key) {
+          target.ui[key] = ref;
+        });
+      } else {
+        target.ui = getApi();
+      }
+    };
+    var registerToFactory = function () {
+      global$2.each(getApi(), function (ref, key) {
+        global$4.add(key, ref);
+      });
+    };
+    var Api = {
+      appendTo: appendTo,
+      registerToFactory: registerToFactory
+    };
+
+    Api.registerToFactory();
+    Api.appendTo(window.tinymce ? window.tinymce : {});
+    global.add('modern', function (editor) {
+      FormatControls.setup(editor);
+      return ThemeApi.get(editor);
+    });
+    function Theme () {
+    }
+
+    return Theme;
+
+}(window));
+})();
diff --git a/wp-includes/js/tinymce/themes/modern/theme.min.js b/wp-includes/js/tinymce/themes/modern/theme.min.js
new file mode 100644
index 0000000..0f406aa
--- /dev/null
+++ b/wp-includes/js/tinymce/themes/modern/theme.min.js
@@ -0,0 +1 @@
+!function(_){"use strict";var e,t,n,i,r=tinymce.util.Tools.resolve("tinymce.ThemeManager"),l=tinymce.util.Tools.resolve("tinymce.EditorManager"),w=tinymce.util.Tools.resolve("tinymce.util.Tools"),d=function(e){return!1!==c(e)},c=function(e){return e.getParam("menubar")},f=function(e){return e.getParam("toolbar_items_size")},h=function(e){return e.getParam("menu")},m=function(e){return!1===e.settings.skin},g=function(e){var t=e.getParam("resize","vertical");return!1===t?"none":"both"===t?"both":"vertical"},p=tinymce.util.Tools.resolve("tinymce.dom.DOMUtils"),v=tinymce.util.Tools.resolve("tinymce.ui.Factory"),b=tinymce.util.Tools.resolve("tinymce.util.I18n"),o=function(e){return e.fire("SkinLoaded")},y=function(e){return e.fire("ResizeEditor")},x=function(e){return e.fire("BeforeRenderUI")},s=function(t,n){return function(){var e=t.find(n)[0];e&&e.focus(!0)}},R=function(e,t){e.shortcuts.add("Alt+F9","",s(t,"menubar")),e.shortcuts.add("Alt+F10,F10","",s(t,"toolbar")),e.shortcuts.add("Alt+F11","",s(t,"elementpath")),t.on("cancel",function(){e.focus()})},C=tinymce.util.Tools.resolve("tinymce.geom.Rect"),u=tinymce.util.Tools.resolve("tinymce.util.Delay"),E=function(){},k=function(e){return function(){return e}},a=k(!1),H=k(!0),S=function(){return T},T=(e=function(e){return e.isNone()},i={fold:function(e,t){return e()},is:a,isSome:a,isNone:H,getOr:n=function(e){return e},getOrThunk:t=function(e){return e()},getOrDie:function(e){throw new Error(e||"error: getOrDie called on none.")},getOrNull:k(null),getOrUndefined:k(undefined),or:n,orThunk:t,map:S,each:E,bind:S,exists:a,forall:H,filter:S,equals:e,equals_:e,toArray:function(){return[]},toString:k("none()")},Object.freeze&&Object.freeze(i),i),M=function(n){var e=k(n),t=function(){return r},i=function(e){return e(n)},r={fold:function(e,t){return t(n)},is:function(e){return n===e},isSome:H,isNone:a,getOr:e,getOrThunk:e,getOrDie:e,getOrNull:e,getOrUndefined:e,or:t,orThunk:t,map:function(e){return M(e(n))},each:function(e){e(n)},bind:i,exists:i,forall:i,filter:function(e){return e(n)?r:T},toArray:function(){return[n]},toString:function(){return"some("+n+")"},equals:function(e){return e.is(n)},equals_:function(e,t){return e.fold(a,function(e){return t(n,e)})}};return r},N={some:M,none:S,from:function(e){return null===e||e===undefined?T:M(e)}},P=function(e){return e?e.getRoot().uiContainer:null},W={getUiContainerDelta:function(e){var t=P(e);if(t&&"static"!==p.DOM.getStyle(t,"position",!0)){var n=p.DOM.getPos(t),i=t.scrollLeft-n.x,r=t.scrollTop-n.y;return N.some({x:i,y:r})}return N.none()},setUiContainer:function(e,t){var n=p.DOM.select(e.settings.ui_container)[0];t.getRoot().uiContainer=n},getUiContainer:P,inheritUiContainer:function(e,t){return t.uiContainer=P(e)}},D=function(i,e,r){var o,s=[];if(e)return w.each(e.split(/[ ,]/),function(t){var e,n=function(){var e=i.selection;t.settings.stateSelector&&e.selectorChanged(t.settings.stateSelector,function(e){t.active(e)},!0),t.settings.disabledStateSelector&&e.selectorChanged(t.settings.disabledStateSelector,function(e){t.disabled(e)})};"|"===t?o=null:(o||(o={type:"buttongroup",items:[]},s.push(o)),i.buttons[t]&&(e=t,"function"==typeof(t=i.buttons[e])&&(t=t()),t.type=t.type||"button",t.size=r,t=v.create(t),o.items.push(t),i.initialized?n():i.on("init",n)))}),{type:"toolbar",layout:"flow",items:s}},O=D,A=function(n,i){var e,t,r=[];if(w.each(!1===(t=(e=n).getParam("toolbar"))?[]:w.isArray(t)?w.grep(t,function(e){return 0<e.length}):function(e,t){for(var n=[],i=1;i<10;i++){var r=e["toolbar"+i];if(!r)break;n.push(r)}var o=e.toolbar?[e.toolbar]:[t];return 0<n.length?n:o}(e.settings,"undo redo | styleselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent | link image"),function(e){var t;(t=e)&&r.push(D(n,t,i))}),r.length)return{type:"panel",layout:"stack",classes:"toolbar-grp",ariaRoot:!0,ariaRemember:!0,items:r}},B=p.DOM,L=function(e){return{left:e.x,top:e.y,width:e.w,height:e.h,right:e.x+e.w,bottom:e.y+e.h}},z=function(e,t){e.moveTo(t.left,t.top)},I=function(e,t,n,i,r,o){return o=L({x:t,y:n,w:o.w,h:o.h}),e&&(o=e({elementRect:L(i),contentAreaRect:L(r),panelRect:o})),o},F=function(x){var i,o=function(){return x.contextToolbars||[]},n=function(e,t){var n,i,r,o,s,a,l,u=x.getParam("inline_toolbar_position_handler");if(!x.removed){if(!e||!e.toolbar.panel)return c=x,void w.each(c.contextToolbars,function(e){e.panel&&e.panel.hide()});var c,d,f,h,m;l=["bc-tc","tc-bc","tl-bl","bl-tl","tr-br","br-tr"],s=e.toolbar.panel,t&&s.show(),d=e.element,f=B.getPos(x.getContentAreaContainer()),h=x.dom.getRect(d),"BODY"===(m=x.dom.getRoot()).nodeName&&(h.x-=m.ownerDocument.documentElement.scrollLeft||m.scrollLeft,h.y-=m.ownerDocument.documentElement.scrollTop||m.scrollTop),h.x+=f.x,h.y+=f.y,r=h,i=B.getRect(s.getEl()),o=B.getRect(x.getContentAreaContainer()||x.getBody());var g,p,v,b=W.getUiContainerDelta(s).getOr({x:0,y:0});if(r.x+=b.x,r.y+=b.y,i.x+=b.x,i.y+=b.y,o.x+=b.x,o.y+=b.y,"inline"!==B.getStyle(e.element,"display",!0)){var y=e.element.getBoundingClientRect();r.w=y.width,r.h=y.height}x.inline||(o.w=x.getDoc().documentElement.offsetWidth),x.selection.controlSelection.isResizable(e.element)&&r.w<25&&(r=C.inflate(r,0,8)),n=C.findBestRelativePosition(i,r,o,l),r=C.clamp(r,o),n?(a=C.relativePosition(i,r,n),z(s,I(u,a.x,a.y,r,o,i))):(o.h+=i.h,(r=C.intersect(o,r))?(n=C.findBestRelativePosition(i,r,o,["bc-tc","bl-tl","br-tr"]))?(a=C.relativePosition(i,r,n),z(s,I(u,a.x,a.y,r,o,i))):z(s,I(u,r.x,r.y,r,o,i)):s.hide()),g=s,v=function(e,t){return e===t},p=(p=n)?p.substr(0,2):"",w.each({t:"down",b:"up"},function(e,t){g.classes.toggle("arrow-"+e,v(t,p.substr(0,1)))}),w.each({l:"left",r:"right"},function(e,t){g.classes.toggle("arrow-"+e,v(t,p.substr(1,1)))})}},r=function(e){return function(){u.requestAnimationFrame(function(){x.selection&&n(a(x.selection.getNode()),e)})}},t=function(e){var t;if(e.toolbar.panel)return e.toolbar.panel.show(),void n(e);t=v.create({type:"floatpanel",role:"dialog",classes:"tinymce tinymce-inline arrow",ariaLabel:"Inline toolbar",layout:"flex",direction:"column",align:"stretch",autohide:!1,autofix:!0,fixed:!0,border:1,items:O(x,e.toolbar.items),oncancel:function(){x.focus()}}),W.setUiContainer(x,t),function(e){if(!i){var t=r(!0),n=W.getUiContainer(e);i=x.selection.getScrollContainer()||x.getWin(),B.bind(i,"scroll",t),B.bind(n,"scroll",t),x.on("remove",function(){B.unbind(i,"scroll",t),B.unbind(n,"scroll",t)})}}(t),(e.toolbar.panel=t).renderTo().reflow(),n(e)},s=function(){w.each(o(),function(e){e.panel&&e.panel.hide()})},a=function(e){var t,n,i,r=o();for(t=(i=x.$(e).parents().add(e)).length-1;0<=t;t--)for(n=r.length-1;0<=n;n--)if(r[n].predicate(i[t]))return{toolbar:r[n],element:i[t]};return null};x.on("click keyup setContent ObjectResized",function(e){("setcontent"!==e.type||e.selection)&&u.setEditorTimeout(x,function(){var e;(e=a(x.selection.getNode()))?(s(),t(e)):s()})}),x.on("blur hide contextmenu",s),x.on("ObjectResizeStart",function(){var e=a(x.selection.getNode());e&&e.toolbar.panel&&e.toolbar.panel.hide()}),x.on("ResizeEditor ResizeWindow",r(!0)),x.on("nodeChange",r(!1)),x.on("remove",function(){w.each(o(),function(e){e.panel&&e.panel.remove()}),x.contextToolbars={}}),x.shortcuts.add("ctrl+F9","",function(){var e=a(x.selection.getNode());e&&e.toolbar.panel&&e.toolbar.panel.items()[0].focus()})},U=function(t){return function(e){return function(e){if(null===e)return"null";var t=typeof e;return"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}(e)===t}},V=U("array"),Y=U("function"),$=U("number"),q=(Array.prototype.slice,Array.prototype.indexOf),X=Array.prototype.push,j=function(e,t){var n,i,r=(n=e,i=t,q.call(n,i));return-1===r?N.none():N.some(r)},J=function(e,t){for(var n=0,i=e.length;n<i;n++)if(t(e[n],n))return!0;return!1},G=function(e,t){for(var n=e.length,i=new Array(n),r=0;r<n;r++){var o=e[r];i[r]=t(o,r)}return i},K=function(e,t){for(var n=0,i=e.length;n<i;n++)t(e[n],n)},Z=function(e,t){for(var n=[],i=0,r=e.length;i<r;i++){var o=e[i];t(o,i)&&n.push(o)}return n},Q=(Y(Array.from)&&Array.from,{file:{title:"File",items:"newdocument restoredraft | preview | print"},edit:{title:"Edit",items:"undo redo | cut copy paste pastetext | selectall"},view:{title:"View",items:"code | visualaid visualchars visualblocks | spellchecker | preview fullscreen"},insert:{title:"Insert",items:"image link media template codesample inserttable | charmap hr | pagebreak nonbreaking anchor toc | insertdatetime"},format:{title:"Format",items:"bold italic underline strikethrough superscript subscript codeformat | blockformats align | removeformat"},tools:{title:"Tools",items:"spellchecker spellcheckerlanguage | a11ycheck code"},table:{title:"Table"},help:{title:"Help"}}),ee=function(e,t){return"|"===e?{name:"|",item:{text:"|"}}:t?{name:e,item:t}:null},te=function(e,t){return function(e,t){for(var n=0,i=e.length;n<i;n++)if(t(e[n],n))return N.some(n);return N.none()}(e,function(e){return e.name===t}).isSome()},ne=function(e){return e&&"|"===e.item.text},ie=function(n,e,t,i){var r,o,s,a,l,u,c;return e?(o=e[i],a=!0):o=Q[i],o&&(r={text:o.title},s=[],w.each((o.items||"").split(/[ ,]/),function(e){var t=ee(e,n[e]);t&&s.push(t)}),a||w.each(n,function(e,t){e.context!==i||te(s,t)||("before"===e.separator&&s.push({name:"|",item:{text:"|"}}),e.prependToContext?s.unshift(ee(t,e)):s.push(ee(t,e)),"after"===e.separator&&s.push({name:"|",item:{text:"|"}}))}),r.menu=G((l=t,u=Z(s,function(e){return!1===l.hasOwnProperty(e.name)}),c=Z(u,function(e,t){return!ne(e)||!ne(u[t-1])}),Z(c,function(e,t){return!ne(e)||0<t&&t<c.length-1})),function(e){return e.item}),!r.menu.length)?null:r},re=function(e){for(var t,n=[],i=function(e){var t,n=[],i=h(e);if(i)for(t in i)n.push(t);else for(t in Q)n.push(t);return n}(e),r=w.makeMap((t=e,t.getParam("removed_menuitems","")).split(/[ ,]/)),o=c(e),s="string"==typeof o?o.split(/[ ,]/):i,a=0;a<s.length;a++){var l=s[a],u=ie(e.menuItems,h(e),r,l);u&&n.push(u)}return n},oe=p.DOM,se=function(e){return{width:e.clientWidth,height:e.clientHeight}},ae=function(e,t,n){var i,r,o,s;i=e.getContainer(),r=e.getContentAreaContainer().firstChild,o=se(i),s=se(r),null!==t&&(t=Math.max(e.getParam("min_width",100,"number"),t),t=Math.min(e.getParam("max_width",65535,"number"),t),oe.setStyle(i,"width",t+(o.width-s.width)),oe.setStyle(r,"width",t)),n=Math.max(e.getParam("min_height",100,"number"),n),n=Math.min(e.getParam("max_height",65535,"number"),n),oe.setStyle(r,"height",n),y(e)},le=ae,ue=function(e,t,n){var i=e.getContentAreaContainer();ae(e,i.clientWidth+t,i.clientHeight+n)},ce=tinymce.util.Tools.resolve("tinymce.Env"),de=function(e,t,n){var i,r=e.settings[n];r&&r((i=t.getEl("body"),{element:function(){return i}}))},fe=function(c,d,f){return function(e){var t,n,i,r,o,s=e.control,a=s.parents().filter("panel")[0],l=a.find("#"+d)[0],u=(t=f,n=d,w.grep(t,function(e){return e.name===n})[0]);i=d,r=a,o=f,w.each(o,function(e){var t=r.items().filter("#"+e.name)[0];t&&t.visible()&&e.name!==i&&(de(e,t,"onhide"),t.visible(!1))}),s.parent().items().each(function(e){e.active(!1)}),l&&l.visible()?(de(u,l,"onhide"),l.hide(),s.active(!1)):(l?l.show():(l=v.create({type:"container",name:d,layout:"stack",classes:"sidebar-panel",html:""}),a.prepend(l),de(u,l,"onrender")),de(u,l,"onshow"),s.active(!0)),y(c)}},he=function(e){return!(ce.ie&&!(11<=ce.ie)||!e.sidebars)&&0<e.sidebars.length},me=function(n){return{type:"panel",name:"sidebar",layout:"stack",classes:"sidebar",items:[{type:"toolbar",layout:"stack",classes:"sidebar-toolbar",items:w.map(n.sidebars,function(e){var t=e.settings;return{type:"button",icon:t.icon,image:t.image,tooltip:t.tooltip,onclick:fe(n,e.name,n.sidebars)}})}]}},ge=function(e){var t=function(){e._skinLoaded=!0,o(e)};return function(){e.initialized?t():e.on("init",t)}},pe=p.DOM,ve=function(e){return{type:"panel",name:"iframe",layout:"stack",classes:"edit-area",border:e,html:""}},be=function(t,e,n){var i,r,o,s,a;if(!1===m(t)&&n.skinUiCss?pe.styleSheetLoader.load(n.skinUiCss,ge(t)):ge(t)(),i=e.panel=v.create({type:"panel",role:"application",classes:"tinymce",style:"visibility: hidden",layout:"stack",border:1,items:[{type:"container",classes:"top-part",items:[!1===d(t)?null:{type:"menubar",border:"0 0 1 0",items:re(t)},A(t,f(t))]},he(t)?(s=t,{type:"panel",layout:"stack",classes:"edit-aria-container",border:"1 0 0 0",items:[ve("0"),me(s)]}):ve("1 0 0 0")]}),W.setUiContainer(t,i),"none"!==g(t)&&(r={type:"resizehandle",direction:g(t),onResizeStart:function(){var e=t.getContentAreaContainer().firstChild;o={width:e.clientWidth,height:e.clientHeight}},onResize:function(e){"both"===g(t)?le(t,o.width+e.deltaX,o.height+e.deltaY):le(t,null,o.height+e.deltaY)}}),t.getParam("statusbar",!0,"boolean")){var l=b.translate(["Powered by {0}",'<a href="https://www.tiny.cloud/?utm_campaign=editor_referral&amp;utm_medium=poweredby&amp;utm_source=tinymce" rel="noopener" target="_blank" role="presentation" tabindex="-1">Tiny</a>']),u=t.getParam("branding",!0,"boolean")?{type:"label",classes:"branding",html:" "+l}:null;i.add({type:"panel",name:"statusbar",classes:"statusbar",layout:"flow",border:"1 0 0 0",ariaRoot:!0,items:[{type:"elementpath",editor:t},r,u]})}return x(t),t.on("SwitchMode",(a=i,function(e){a.find("*").disabled("readonly"===e.mode)})),i.renderBefore(n.targetNode).reflow(),t.getParam("readonly",!1,"boolean")&&t.setMode("readonly"),n.width&&pe.setStyle(i.getEl(),"width",n.width),t.on("remove",function(){i.remove(),i=null}),R(t,i),F(t),{iframeContainer:i.find("#iframe")[0].getEl(),editorContainer:i.getEl()}},ye=tinymce.util.Tools.resolve("tinymce.dom.DomQuery"),xe=0,we={id:function(){return"mceu_"+xe++},create:function(e,t,n){var i=_.document.createElement(e);return p.DOM.setAttribs(i,t),"string"==typeof n?i.innerHTML=n:w.each(n,function(e){e.nodeType&&i.appendChild(e)}),i},createFragment:function(e){return p.DOM.createFragment(e)},getWindowSize:function(){return p.DOM.getViewPort()},getSize:function(e){var t,n;if(e.getBoundingClientRect){var i=e.getBoundingClientRect();t=Math.max(i.width||i.right-i.left,e.offsetWidth),n=Math.max(i.height||i.bottom-i.bottom,e.offsetHeight)}else t=e.offsetWidth,n=e.offsetHeight;return{width:t,height:n}},getPos:function(e,t){return p.DOM.getPos(e,t||we.getContainer())},getContainer:function(){return ce.container?ce.container:_.document.body},getViewPort:function(e){return p.DOM.getViewPort(e)},get:function(e){return _.document.getElementById(e)},addClass:function(e,t){return p.DOM.addClass(e,t)},removeClass:function(e,t){return p.DOM.removeClass(e,t)},hasClass:function(e,t){return p.DOM.hasClass(e,t)},toggleClass:function(e,t,n){return p.DOM.toggleClass(e,t,n)},css:function(e,t,n){return p.DOM.setStyle(e,t,n)},getRuntimeStyle:function(e,t){return p.DOM.getStyle(e,t,!0)},on:function(e,t,n,i){return p.DOM.bind(e,t,n,i)},off:function(e,t,n){return p.DOM.unbind(e,t,n)},fire:function(e,t,n){return p.DOM.fire(e,t,n)},innerHtml:function(e,t){p.DOM.setHTML(e,t)}},_e=function(e){return"static"===we.getRuntimeStyle(e,"position")},Re=function(e){return e.state.get("fixed")};function Ce(e,t,n){var i,r,o,s,a,l,u,c,d,f;return d=Ee(),o=(r=we.getPos(t,W.getUiContainer(e))).x,s=r.y,Re(e)&&_e(_.document.body)&&(o-=d.x,s-=d.y),i=e.getEl(),a=(f=we.getSize(i)).width,l=f.height,u=(f=we.getSize(t)).width,c=f.height,"b"===(n=(n||"").split(""))[0]&&(s+=c),"r"===n[1]&&(o+=u),"c"===n[0]&&(s+=Math.round(c/2)),"c"===n[1]&&(o+=Math.round(u/2)),"b"===n[3]&&(s-=l),"r"===n[4]&&(o-=a),"c"===n[3]&&(s-=Math.round(l/2)),"c"===n[4]&&(o-=Math.round(a/2)),{x:o,y:s,w:a,h:l}}var Ee=function(){var e=_.window;return{x:Math.max(e.pageXOffset,_.document.body.scrollLeft,_.document.documentElement.scrollLeft),y:Math.max(e.pageYOffset,_.document.body.scrollTop,_.document.documentElement.scrollTop),w:e.innerWidth||_.document.documentElement.clientWidth,h:e.innerHeight||_.document.documentElement.clientHeight}},ke=function(e){var t,n=W.getUiContainer(e);return n&&!Re(e)?{x:0,y:0,w:(t=n).scrollWidth-1,h:t.scrollHeight-1}:Ee()},He={testMoveRel:function(e,t){for(var n=ke(this),i=0;i<t.length;i++){var r=Ce(this,e,t[i]);if(Re(this)){if(0<r.x&&r.x+r.w<n.w&&0<r.y&&r.y+r.h<n.h)return t[i]}else if(r.x>n.x&&r.x+r.w<n.w+n.x&&r.y>n.y&&r.y+r.h<n.h+n.y)return t[i]}return t[0]},moveRel:function(e,t){"string"!=typeof t&&(t=this.testMoveRel(e,t));var n=Ce(this,e,t);return this.moveTo(n.x,n.y)},moveBy:function(e,t){var n=this.layoutRect();return this.moveTo(n.x+e,n.y+t),this},moveTo:function(e,t){var n=this;function i(e,t,n){return e<0?0:t<e+n&&(e=t-n)<0?0:e}if(n.settings.constrainToViewport){var r=ke(this),o=n.layoutRect();e=i(e,r.w+r.x,o.w),t=i(t,r.h+r.y,o.h)}var s=W.getUiContainer(n);return s&&_e(s)&&!Re(n)&&(e-=s.scrollLeft,t-=s.scrollTop),s&&(e+=1,t+=1),n.state.get("rendered")?n.layoutRect({x:e,y:t}).repaint():(n.settings.x=e,n.settings.y=t),n.fire("move",{x:e,y:t}),n}},Se=tinymce.util.Tools.resolve("tinymce.util.Class"),Te=tinymce.util.Tools.resolve("tinymce.util.EventDispatcher"),Me=function(e){var t;if(e)return"number"==typeof e?{top:e=e||0,left:e,bottom:e,right:e}:(1===(t=(e=e.split(" ")).length)?e[1]=e[2]=e[3]=e[0]:2===t?(e[2]=e[0],e[3]=e[1]):3===t&&(e[3]=e[1]),{top:parseInt(e[0],10)||0,right:parseInt(e[1],10)||0,bottom:parseInt(e[2],10)||0,left:parseInt(e[3],10)||0})},Ne=function(i,e){function t(e){var t=parseFloat(function(e){var t=i.ownerDocument.defaultView;if(t){var n=t.getComputedStyle(i,null);return n?(e=e.replace(/[A-Z]/g,function(e){return"-"+e}),n.getPropertyValue(e)):null}return i.currentStyle[e]}(e));return isNaN(t)?0:t}return{top:t(e+"TopWidth"),right:t(e+"RightWidth"),bottom:t(e+"BottomWidth"),left:t(e+"LeftWidth")}};function Pe(){}function We(e){this.cls=[],this.cls._map={},this.onchange=e||Pe,this.prefix=""}w.extend(We.prototype,{add:function(e){return e&&!this.contains(e)&&(this.cls._map[e]=!0,this.cls.push(e),this._change()),this},remove:function(e){if(this.contains(e)){var t=void 0;for(t=0;t<this.cls.length&&this.cls[t]!==e;t++);this.cls.splice(t,1),delete this.cls._map[e],this._change()}return this},toggle:function(e,t){var n=this.contains(e);return n!==t&&(n?this.remove(e):this.add(e),this._change()),this},contains:function(e){return!!this.cls._map[e]},_change:function(){delete this.clsValue,this.onchange.call(this)}}),We.prototype.toString=function(){var e;if(this.clsValue)return this.clsValue;e="";for(var t=0;t<this.cls.length;t++)0<t&&(e+=" "),e+=this.prefix+this.cls[t];return e};var De,Oe,Ae,Be=/^([\w\\*]+)?(?:#([\w\-\\]+))?(?:\.([\w\\\.]+))?(?:\[\@?([\w\\]+)([\^\$\*!~]?=)([\w\\]+)\])?(?:\:(.+))?/i,Le=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,ze=/^\s*|\s*$/g,Ie=Se.extend({init:function(e){var o=this.match;function s(e,t,n){var i;function r(e){e&&t.push(e)}return r(function(t){if(t)return t=t.toLowerCase(),function(e){return"*"===t||e.type===t}}((i=Be.exec(e.replace(ze,"")))[1])),r(function(t){if(t)return function(e){return e._name===t}}(i[2])),r(function(n){if(n)return n=n.split("."),function(e){for(var t=n.length;t--;)if(!e.classes.contains(n[t]))return!1;return!0}}(i[3])),r(function(n,i,r){if(n)return function(e){var t=e[n]?e[n]():"";return i?"="===i?t===r:"*="===i?0<=t.indexOf(r):"~="===i?0<=(" "+t+" ").indexOf(" "+r+" "):"!="===i?t!==r:"^="===i?0===t.indexOf(r):"$="===i&&t.substr(t.length-r.length)===r:!!r}}(i[4],i[5],i[6])),r(function(i){var t;if(i)return(i=/(?:not\((.+)\))|(.+)/i.exec(i))[1]?(t=a(i[1],[]),function(e){return!o(e,t)}):(i=i[2],function(e,t,n){return"first"===i?0===t:"last"===i?t===n-1:"even"===i?t%2==0:"odd"===i?t%2==1:!!e[i]&&e[i]()})}(i[7])),t.pseudo=!!i[7],t.direct=n,t}function a(e,t){var n,i,r,o=[];do{if(Le.exec(""),(i=Le.exec(e))&&(e=i[3],o.push(i[1]),i[2])){n=i[3];break}}while(i);for(n&&a(n,t),e=[],r=0;r<o.length;r++)">"!==o[r]&&e.push(s(o[r],[],">"===o[r-1]));return t.push(e),t}this._selectors=a(e,[])},match:function(e,t){var n,i,r,o,s,a,l,u,c,d,f,h,m;for(n=0,i=(t=t||this._selectors).length;n<i;n++){for(m=e,h=0,r=(o=(s=t[n]).length)-1;0<=r;r--)for(u=s[r];m;){if(u.pseudo)for(c=d=(f=m.parent().items()).length;c--&&f[c]!==m;);for(a=0,l=u.length;a<l;a++)if(!u[a](m,c,d)){a=l+1;break}if(a===l){h++;break}if(r===o-1)break;m=m.parent()}if(h===o)return!0}return!1},find:function(e){var t,n,u=[],i=this._selectors;function c(e,t,n){var i,r,o,s,a,l=t[n];for(i=0,r=e.length;i<r;i++){for(a=e[i],o=0,s=l.length;o<s;o++)if(!l[o](a,i,r)){o=s+1;break}if(o===s)n===t.length-1?u.push(a):a.items&&c(a.items(),t,n+1);else if(l.direct)return;a.items&&c(a.items(),t,n)}}if(e.items){for(t=0,n=i.length;t<n;t++)c(e.items(),i[t],0);1<n&&(u=function(e){for(var t,n=[],i=e.length;i--;)(t=e[i]).__checked||(n.push(t),t.__checked=1);for(i=n.length;i--;)delete n[i].__checked;return n}(u))}return De||(De=Ie.Collection),new De(u)}}),Fe=Array.prototype.push,Ue=Array.prototype.slice;Ae={length:0,init:function(e){e&&this.add(e)},add:function(e){return w.isArray(e)?Fe.apply(this,e):e instanceof Oe?this.add(e.toArray()):Fe.call(this,e),this},set:function(e){var t,n=this,i=n.length;for(n.length=0,n.add(e),t=n.length;t<i;t++)delete n[t];return n},filter:function(t){var e,n,i,r,o=[];for("string"==typeof t?(t=new Ie(t),r=function(e){return t.match(e)}):r=t,e=0,n=this.length;e<n;e++)r(i=this[e])&&o.push(i);return new Oe(o)},slice:function(){return new Oe(Ue.apply(this,arguments))},eq:function(e){return-1===e?this.slice(e):this.slice(e,+e+1)},each:function(e){return w.each(this,e),this},toArray:function(){return w.toArray(this)},indexOf:function(e){for(var t=this.length;t--&&this[t]!==e;);return t},reverse:function(){return new Oe(w.toArray(this).reverse())},hasClass:function(e){return!!this[0]&&this[0].classes.contains(e)},prop:function(t,n){var e;return n!==undefined?(this.each(function(e){e[t]&&e[t](n)}),this):(e=this[0])&&e[t]?e[t]():void 0},exec:function(t){var n=w.toArray(arguments).slice(1);return this.each(function(e){e[t]&&e[t].apply(e,n)}),this},remove:function(){for(var e=this.length;e--;)this[e].remove();return this},addClass:function(t){return this.each(function(e){e.classes.add(t)})},removeClass:function(t){return this.each(function(e){e.classes.remove(t)})}},w.each("fire on off show hide append prepend before after reflow".split(" "),function(n){Ae[n]=function(){var t=w.toArray(arguments);return this.each(function(e){n in e&&e[n].apply(e,t)}),this}}),w.each("text name disabled active selected checked visible parent value data".split(" "),function(t){Ae[t]=function(e){return this.prop(t,e)}}),Oe=Se.extend(Ae);var Ve=Ie.Collection=Oe,Ye=function(e){this.create=e.create};Ye.create=function(r,o){return new Ye({create:function(t,n){var i,e=function(e){t.set(n,e.value)};return t.on("change:"+n,function(e){r.set(o,e.value)}),r.on("change:"+o,e),(i=t._bindings)||(i=t._bindings=[],t.on("destroy",function(){for(var e=i.length;e--;)i[e]()})),i.push(function(){r.off("change:"+o,e)}),r.get(o)}})};var $e=tinymce.util.Tools.resolve("tinymce.util.Observable");function qe(e){return 0<e.nodeType}var Xe,je,Je=Se.extend({Mixins:[$e],init:function(e){var t,n;for(t in e=e||{})(n=e[t])instanceof Ye&&(e[t]=n.create(this,t));this.data=e},set:function(t,n){var i,r,o=this.data[t];if(n instanceof Ye&&(n=n.create(this,t)),"object"==typeof t){for(i in t)this.set(i,t[i]);return this}return function e(t,n){var i,r;if(t===n)return!0;if(null===t||null===n)return t===n;if("object"!=typeof t||"object"!=typeof n)return t===n;if(w.isArray(n)){if(t.length!==n.length)return!1;for(i=t.length;i--;)if(!e(t[i],n[i]))return!1}if(qe(t)||qe(n))return t===n;for(i in r={},n){if(!e(t[i],n[i]))return!1;r[i]=!0}for(i in t)if(!r[i]&&!e(t[i],n[i]))return!1;return!0}(o,n)||(this.data[t]=n,r={target:this,name:t,value:n,oldValue:o},this.fire("change:"+t,r),this.fire("change",r)),this},get:function(e){return this.data[e]},has:function(e){return e in this.data},bind:function(e){return Ye.create(this,e)},destroy:function(){this.fire("destroy")}}),Ge={},Ke={add:function(e){var t=e.parent();if(t){if(!t._layout||t._layout.isNative())return;Ge[t._id]||(Ge[t._id]=t),Xe||(Xe=!0,u.requestAnimationFrame(function(){var e,t;for(e in Xe=!1,Ge)(t=Ge[e]).state.get("rendered")&&t.reflow();Ge={}},_.document.body))}},remove:function(e){Ge[e._id]&&delete Ge[e._id]}},Ze="onmousewheel"in _.document,Qe=!1,et=0,tt={Statics:{classPrefix:"mce-"},isRtl:function(){return je.rtl},classPrefix:"mce-",init:function(t){var e,n,i=this;function r(e){var t;for(e=e.split(" "),t=0;t<e.length;t++)i.classes.add(e[t])}i.settings=t=w.extend({},i.Defaults,t),i._id=t.id||"mceu_"+et++,i._aria={role:t.role},i._elmCache={},i.$=ye,i.state=new Je({visible:!0,active:!1,disabled:!1,value:""}),i.data=new Je(t.data),i.classes=new We(function(){i.state.get("rendered")&&(i.getEl().className=this.toString())}),i.classes.prefix=i.classPrefix,(e=t.classes)&&(i.Defaults&&(n=i.Defaults.classes)&&e!==n&&r(n),r(e)),w.each("title text name visible disabled active value".split(" "),function(e){e in t&&i[e](t[e])}),i.on("click",function(){if(i.disabled())return!1}),i.settings=t,i.borderBox=Me(t.border),i.paddingBox=Me(t.padding),i.marginBox=Me(t.margin),t.hidden&&i.hide()},Properties:"parent,name",getContainerElm:function(){var e=W.getUiContainer(this);return e||we.getContainer()},getParentCtrl:function(e){for(var t,n=this.getRoot().controlIdLookup;e&&n&&!(t=n[e.id]);)e=e.parentNode;return t},initLayoutRect:function(){var e,t,n,i,r,o,s,a,l,u,c=this,d=c.settings,f=c.getEl();e=c.borderBox=c.borderBox||Ne(f,"border"),c.paddingBox=c.paddingBox||Ne(f,"padding"),c.marginBox=c.marginBox||Ne(f,"margin"),u=we.getSize(f),a=d.minWidth,l=d.minHeight,r=a||u.width,o=l||u.height,n=d.width,i=d.height,s=void 0!==(s=d.autoResize)?s:!n&&!i,n=n||r,i=i||o;var h=e.left+e.right,m=e.top+e.bottom,g=d.maxWidth||65535,p=d.maxHeight||65535;return c._layoutRect=t={x:d.x||0,y:d.y||0,w:n,h:i,deltaW:h,deltaH:m,contentW:n-h,contentH:i-m,innerW:n-h,innerH:i-m,startMinWidth:a||0,startMinHeight:l||0,minW:Math.min(r,g),minH:Math.min(o,p),maxW:g,maxH:p,autoResize:s,scrollW:0},c._lastLayoutRect={},t},layoutRect:function(e){var t,n,i,r,o,s=this,a=s._layoutRect;return a||(a=s.initLayoutRect()),e?(i=a.deltaW,r=a.deltaH,e.x!==undefined&&(a.x=e.x),e.y!==undefined&&(a.y=e.y),e.minW!==undefined&&(a.minW=e.minW),e.minH!==undefined&&(a.minH=e.minH),(n=e.w)!==undefined&&(n=(n=n<a.minW?a.minW:n)>a.maxW?a.maxW:n,a.w=n,a.innerW=n-i),(n=e.h)!==undefined&&(n=(n=n<a.minH?a.minH:n)>a.maxH?a.maxH:n,a.h=n,a.innerH=n-r),(n=e.innerW)!==undefined&&(n=(n=n<a.minW-i?a.minW-i:n)>a.maxW-i?a.maxW-i:n,a.innerW=n,a.w=n+i),(n=e.innerH)!==undefined&&(n=(n=n<a.minH-r?a.minH-r:n)>a.maxH-r?a.maxH-r:n,a.innerH=n,a.h=n+r),e.contentW!==undefined&&(a.contentW=e.contentW),e.contentH!==undefined&&(a.contentH=e.contentH),(t=s._lastLayoutRect).x===a.x&&t.y===a.y&&t.w===a.w&&t.h===a.h||((o=je.repaintControls)&&o.map&&!o.map[s._id]&&(o.push(s),o.map[s._id]=!0),t.x=a.x,t.y=a.y,t.w=a.w,t.h=a.h),s):a},repaint:function(){var e,t,n,i,r,o,s,a,l,u,c=this;l=_.document.createRange?function(e){return e}:Math.round,e=c.getEl().style,i=c._layoutRect,a=c._lastRepaintRect||{},o=(r=c.borderBox).left+r.right,s=r.top+r.bottom,i.x!==a.x&&(e.left=l(i.x)+"px",a.x=i.x),i.y!==a.y&&(e.top=l(i.y)+"px",a.y=i.y),i.w!==a.w&&(u=l(i.w-o),e.width=(0<=u?u:0)+"px",a.w=i.w),i.h!==a.h&&(u=l(i.h-s),e.height=(0<=u?u:0)+"px",a.h=i.h),c._hasBody&&i.innerW!==a.innerW&&(u=l(i.innerW),(n=c.getEl("body"))&&((t=n.style).width=(0<=u?u:0)+"px"),a.innerW=i.innerW),c._hasBody&&i.innerH!==a.innerH&&(u=l(i.innerH),(n=n||c.getEl("body"))&&((t=t||n.style).height=(0<=u?u:0)+"px"),a.innerH=i.innerH),c._lastRepaintRect=a,c.fire("repaint",{},!1)},updateLayoutRect:function(){var e=this;e.parent()._lastRect=null,we.css(e.getEl(),{width:"",height:""}),e._layoutRect=e._lastRepaintRect=e._lastLayoutRect=null,e.initLayoutRect()},on:function(e,t){var n,i,r,o=this;return nt(o).on(e,"string"!=typeof(n=t)?n:function(e){return i||o.parentsAndSelf().each(function(e){var t=e.settings.callbacks;if(t&&(i=t[n]))return r=e,!1}),i?i.call(r,e):(e.action=n,void this.fire("execute",e))}),o},off:function(e,t){return nt(this).off(e,t),this},fire:function(e,t,n){if((t=t||{}).control||(t.control=this),t=nt(this).fire(e,t),!1!==n&&this.parent)for(var i=this.parent();i&&!t.isPropagationStopped();)i.fire(e,t,!1),i=i.parent();return t},hasEventListeners:function(e){return nt(this).has(e)},parents:function(e){var t,n=new Ve;for(t=this.parent();t;t=t.parent())n.add(t);return e&&(n=n.filter(e)),n},parentsAndSelf:function(e){return new Ve(this).add(this.parents(e))},next:function(){var e=this.parent().items();return e[e.indexOf(this)+1]},prev:function(){var e=this.parent().items();return e[e.indexOf(this)-1]},innerHtml:function(e){return this.$el.html(e),this},getEl:function(e){var t=e?this._id+"-"+e:this._id;return this._elmCache[t]||(this._elmCache[t]=ye("#"+t)[0]),this._elmCache[t]},show:function(){return this.visible(!0)},hide:function(){return this.visible(!1)},focus:function(){try{this.getEl().focus()}catch(e){}return this},blur:function(){return this.getEl().blur(),this},aria:function(e,t){var n=this,i=n.getEl(n.ariaTarget);return void 0===t?n._aria[e]:(n._aria[e]=t,n.state.get("rendered")&&i.setAttribute("role"===e?e:"aria-"+e,t),n)},encode:function(e,t){return!1!==t&&(e=this.translate(e)),(e||"").replace(/[&<>"]/g,function(e){return"&#"+e.charCodeAt(0)+";"})},translate:function(e){return je.translate?je.translate(e):e},before:function(e){var t=this.parent();return t&&t.insert(e,t.items().indexOf(this),!0),this},after:function(e){var t=this.parent();return t&&t.insert(e,t.items().indexOf(this)),this},remove:function(){var t,e,n=this,i=n.getEl(),r=n.parent();if(n.items){var o=n.items().toArray();for(e=o.length;e--;)o[e].remove()}r&&r.items&&(t=[],r.items().each(function(e){e!==n&&t.push(e)}),r.items().set(t),r._lastRect=null),n._eventsRoot&&n._eventsRoot===n&&ye(i).off();var s=n.getRoot().controlIdLookup;return s&&delete s[n._id],i&&i.parentNode&&i.parentNode.removeChild(i),n.state.set("rendered",!1),n.state.destroy(),n.fire("remove"),n},renderBefore:function(e){return ye(e).before(this.renderHtml()),this.postRender(),this},renderTo:function(e){return ye(e||this.getContainerElm()).append(this.renderHtml()),this.postRender(),this},preRender:function(){},render:function(){},renderHtml:function(){return'<div id="'+this._id+'" class="'+this.classes+'"></div>'},postRender:function(){var e,t,n,i,r,o=this,s=o.settings;for(i in o.$el=ye(o.getEl()),o.state.set("rendered",!0),s)0===i.indexOf("on")&&o.on(i.substr(2),s[i]);if(o._eventsRoot){for(n=o.parent();!r&&n;n=n.parent())r=n._eventsRoot;if(r)for(i in r._nativeEvents)o._nativeEvents[i]=!0}it(o),s.style&&(e=o.getEl())&&(e.setAttribute("style",s.style),e.style.cssText=s.style),o.settings.border&&(t=o.borderBox,o.$el.css({"border-top-width":t.top,"border-right-width":t.right,"border-bottom-width":t.bottom,"border-left-width":t.left}));var a=o.getRoot();for(var l in a.controlIdLookup||(a.controlIdLookup={}),(a.controlIdLookup[o._id]=o)._aria)o.aria(l,o._aria[l]);!1===o.state.get("visible")&&(o.getEl().style.display="none"),o.bindStates(),o.state.on("change:visible",function(e){var t,n=e.value;o.state.get("rendered")&&(o.getEl().style.display=!1===n?"none":"",o.getEl().getBoundingClientRect()),(t=o.parent())&&(t._lastRect=null),o.fire(n?"show":"hide"),Ke.add(o)}),o.fire("postrender",{},!1)},bindStates:function(){},scrollIntoView:function(e){var t,n,i,r,o,s,a=this.getEl(),l=a.parentNode,u=function(e,t){var n,i,r=e;for(n=i=0;r&&r!==t&&r.nodeType;)n+=r.offsetLeft||0,i+=r.offsetTop||0,r=r.offsetParent;return{x:n,y:i}}(a,l);return t=u.x,n=u.y,i=a.offsetWidth,r=a.offsetHeight,o=l.clientWidth,s=l.clientHeight,"end"===e?(t-=o-i,n-=s-r):"center"===e&&(t-=o/2-i/2,n-=s/2-r/2),l.scrollLeft=t,l.scrollTop=n,this},getRoot:function(){for(var e,t=this,n=[];t;){if(t.rootControl){e=t.rootControl;break}n.push(t),t=(e=t).parent()}e||(e=this);for(var i=n.length;i--;)n[i].rootControl=e;return e},reflow:function(){Ke.remove(this);var e=this.parent();return e&&e._layout&&!e._layout.isNative()&&e.reflow(),this}};function nt(n){return n._eventDispatcher||(n._eventDispatcher=new Te({scope:n,toggleEvent:function(e,t){t&&Te.isNative(e)&&(n._nativeEvents||(n._nativeEvents={}),n._nativeEvents[e]=!0,n.state.get("rendered")&&it(n))}})),n._eventDispatcher}function it(a){var e,t,n,l,i,r;function o(e){var t=a.getParentCtrl(e.target);t&&t.fire(e.type,e)}function s(){var e=l._lastHoverCtrl;e&&(e.fire("mouseleave",{target:e.getEl()}),e.parents().each(function(e){e.fire("mouseleave",{target:e.getEl()})}),l._lastHoverCtrl=null)}function u(e){var t,n,i,r=a.getParentCtrl(e.target),o=l._lastHoverCtrl,s=0;if(r!==o){if((n=(l._lastHoverCtrl=r).parents().toArray().reverse()).push(r),o){for((i=o.parents().toArray().reverse()).push(o),s=0;s<i.length&&n[s]===i[s];s++);for(t=i.length-1;s<=t;t--)(o=i[t]).fire("mouseleave",{target:o.getEl()})}for(t=s;t<n.length;t++)(r=n[t]).fire("mouseenter",{target:r.getEl()})}}function c(e){e.preventDefault(),"mousewheel"===e.type?(e.deltaY=-.025*e.wheelDelta,e.wheelDeltaX&&(e.deltaX=-.025*e.wheelDeltaX)):(e.deltaX=0,e.deltaY=e.detail),e=a.fire("wheel",e)}if(i=a._nativeEvents){for((n=a.parents().toArray()).unshift(a),e=0,t=n.length;!l&&e<t;e++)l=n[e]._eventsRoot;for(l||(l=n[n.length-1]||a),a._eventsRoot=l,t=e,e=0;e<t;e++)n[e]._eventsRoot=l;var d=l._delegates;for(r in d||(d=l._delegates={}),i){if(!i)return!1;"wheel"!==r||Qe?("mouseenter"===r||"mouseleave"===r?l._hasMouseEnter||(ye(l.getEl()).on("mouseleave",s).on("mouseover",u),l._hasMouseEnter=1):d[r]||(ye(l.getEl()).on(r,o),d[r]=!0),i[r]=!1):Ze?ye(a.getEl()).on("mousewheel",c):ye(a.getEl()).on("DOMMouseScroll",c)}}}w.each("text title visible disabled active value".split(" "),function(t){tt[t]=function(e){return 0===arguments.length?this.state.get(t):(void 0!==e&&this.state.set(t,e),this)}});var rt=je=Se.extend(tt),ot=function(e){return!!e.getAttribute("data-mce-tabstop")};function st(e){var o,r,n=e.root;function i(e){return e&&1===e.nodeType}try{o=_.document.activeElement}catch(t){o=_.document.body}function s(e){return i(e=e||o)?e.getAttribute("role"):null}function a(e){for(var t,n=e||o;n=n.parentNode;)if(t=s(n))return t}function l(e){var t=o;if(i(t))return t.getAttribute("aria-"+e)}function u(e){var t=e.tagName.toUpperCase();return"INPUT"===t||"TEXTAREA"===t||"SELECT"===t}function c(t){var r=[];return function e(t){if(1===t.nodeType&&"none"!==t.style.display&&!t.disabled){var n;(u(n=t)&&!n.hidden||ot(n)||/^(button|menuitem|checkbox|tab|menuitemcheckbox|option|gridcell|slider)$/.test(s(n)))&&r.push(t);for(var i=0;i<t.childNodes.length;i++)e(t.childNodes[i])}}(t||n.getEl()),r}function d(e){var t,n;(n=(e=e||r).parents().toArray()).unshift(e);for(var i=0;i<n.length&&!(t=n[i]).settings.ariaRoot;i++);return t}function f(e,t){return e<0?e=t.length-1:e>=t.length&&(e=0),t[e]&&t[e].focus(),e}function h(e,t){var n=-1,i=d();t=t||c(i.getEl());for(var r=0;r<t.length;r++)t[r]===o&&(n=r);n+=e,i.lastAriaIndex=f(n,t)}function m(){"tablist"===a()?h(-1,c(o.parentNode)):r.parent().submenu?b():h(-1)}function g(){var e=s(),t=a();"tablist"===t?h(1,c(o.parentNode)):"menuitem"===e&&"menu"===t&&l("haspopup")?y():h(1)}function p(){h(-1)}function v(){var e=s(),t=a();"menuitem"===e&&"menubar"===t?y():"button"===e&&l("haspopup")?y({key:"down"}):h(1)}function b(){r.fire("cancel")}function y(e){e=e||{},r.fire("click",{target:o,aria:e})}return r=n.getParentCtrl(o),n.on("keydown",function(e){function t(e,t){u(o)||ot(o)||"slider"!==s(o)&&!1!==t(e)&&e.preventDefault()}if(!e.isDefaultPrevented())switch(e.keyCode){case 37:t(e,m);break;case 39:t(e,g);break;case 38:t(e,p);break;case 40:t(e,v);break;case 27:b();break;case 14:case 13:case 32:t(e,y);break;case 9:!function(e){if("tablist"===a()){var t=c(r.getEl("body"))[0];t&&t.focus()}else h(e.shiftKey?-1:1)}(e),e.preventDefault()}}),n.on("focusin",function(e){o=e.target,r=e.control}),{focusFirst:function(e){var t=d(e),n=c(t.getEl());t.settings.ariaRemember&&"lastAriaIndex"in t?f(t.lastAriaIndex,n):f(0,n)}}}var at={},lt=rt.extend({init:function(e){var t=this;t._super(e),(e=t.settings).fixed&&t.state.set("fixed",!0),t._items=new Ve,t.isRtl()&&t.classes.add("rtl"),t.bodyClasses=new We(function(){t.state.get("rendered")&&(t.getEl("body").className=this.toString())}),t.bodyClasses.prefix=t.classPrefix,t.classes.add("container"),t.bodyClasses.add("container-body"),e.containerCls&&t.classes.add(e.containerCls),t._layout=v.create((e.layout||"")+"layout"),t.settings.items?t.add(t.settings.items):t.add(t.render()),t._hasBody=!0},items:function(){return this._items},find:function(e){return(e=at[e]=at[e]||new Ie(e)).find(this)},add:function(e){return this.items().add(this.create(e)).parent(this),this},focus:function(e){var t,n,i,r=this;if(!e||!(n=r.keyboardNav||r.parents().eq(-1)[0].keyboardNav))return i=r.find("*"),r.statusbar&&i.add(r.statusbar.items()),i.each(function(e){if(e.settings.autofocus)return t=null,!1;e.canFocus&&(t=t||e)}),t&&t.focus(),r;n.focusFirst(r)},replace:function(e,t){for(var n,i=this.items(),r=i.length;r--;)if(i[r]===e){i[r]=t;break}0<=r&&((n=t.getEl())&&n.parentNode.removeChild(n),(n=e.getEl())&&n.parentNode.removeChild(n)),t.parent(this)},create:function(e){var t,n=this,i=[];return w.isArray(e)||(e=[e]),w.each(e,function(e){e&&(e instanceof rt||("string"==typeof e&&(e={type:e}),t=w.extend({},n.settings.defaults,e),e.type=t.type=t.type||e.type||n.settings.defaultType||(t.defaults?t.defaults.type:null),e=v.create(t)),i.push(e))}),i},renderNew:function(){var i=this;return i.items().each(function(e,t){var n;e.parent(i),e.state.get("rendered")||((n=i.getEl("body")).hasChildNodes()&&t<=n.childNodes.length-1?ye(n.childNodes[t]).before(e.renderHtml()):ye(n).append(e.renderHtml()),e.postRender(),Ke.add(e))}),i._layout.applyClasses(i.items().filter(":visible")),i._lastRect=null,i},append:function(e){return this.add(e).renderNew()},prepend:function(e){return this.items().set(this.create(e).concat(this.items().toArray())),this.renderNew()},insert:function(e,t,n){var i,r,o;return e=this.create(e),i=this.items(),!n&&t<i.length-1&&(t+=1),0<=t&&t<i.length&&(r=i.slice(0,t).toArray(),o=i.slice(t).toArray(),i.set(r.concat(e,o))),this.renderNew()},fromJSON:function(e){for(var t in e)this.find("#"+t).value(e[t]);return this},toJSON:function(){var i={};return this.find("*").each(function(e){var t=e.name(),n=e.value();t&&void 0!==n&&(i[t]=n)}),i},renderHtml:function(){var e=this,t=e._layout,n=this.settings.role;return e.preRender(),t.preRender(e),'<div id="'+e._id+'" class="'+e.classes+'"'+(n?' role="'+this.settings.role+'"':"")+'><div id="'+e._id+'-body" class="'+e.bodyClasses+'">'+(e.settings.html||"")+t.renderHtml(e)+"</div></div>"},postRender:function(){var e,t=this;return t.items().exec("postRender"),t._super(),t._layout.postRender(t),t.state.set("rendered",!0),t.settings.style&&t.$el.css(t.settings.style),t.settings.border&&(e=t.borderBox,t.$el.css({"border-top-width":e.top,"border-right-width":e.right,"border-bottom-width":e.bottom,"border-left-width":e.left})),t.parent()||(t.keyboardNav=st({root:t})),t},initLayoutRect:function(){var e=this._super();return this._layout.recalc(this),e},recalc:function(){var e=this,t=e._layoutRect,n=e._lastRect;if(!n||n.w!==t.w||n.h!==t.h)return e._layout.recalc(e),t=e.layoutRect(),e._lastRect={x:t.x,y:t.y,w:t.w,h:t.h},!0},reflow:function(){var e;if(Ke.remove(this),this.visible()){for(rt.repaintControls=[],rt.repaintControls.map={},this.recalc(),e=rt.repaintControls.length;e--;)rt.repaintControls[e].repaint();"flow"!==this.settings.layout&&"stack"!==this.settings.layout&&this.repaint(),rt.repaintControls=[]}return this}});function ut(e){var t,n;if(e.changedTouches)for(t="screenX screenY pageX pageY clientX clientY".split(" "),n=0;n<t.length;n++)e[t[n]]=e.changedTouches[0][t[n]]}function ct(e,h){var m,g,t,p,v,b,y,x=h.document||_.document;h=h||{};var w=x.getElementById(h.handle||e);t=function(e){var t,n,i,r,o,s,a,l,u,c,d,f=(t=x,u=Math.max,n=t.documentElement,i=t.body,r=u(n.scrollWidth,i.scrollWidth),o=u(n.clientWidth,i.clientWidth),s=u(n.offsetWidth,i.offsetWidth),a=u(n.scrollHeight,i.scrollHeight),l=u(n.clientHeight,i.clientHeight),{width:r<s?o:r,height:a<u(n.offsetHeight,i.offsetHeight)?l:a});ut(e),e.preventDefault(),g=e.button,c=w,b=e.screenX,y=e.screenY,d=_.window.getComputedStyle?_.window.getComputedStyle(c,null).getPropertyValue("cursor"):c.runtimeStyle.cursor,m=ye("<div></div>").css({position:"absolute",top:0,left:0,width:f.width,height:f.height,zIndex:2147483647,opacity:1e-4,cursor:d}).appendTo(x.body),ye(x).on("mousemove touchmove",v).on("mouseup touchend",p),h.start(e)},v=function(e){if(ut(e),e.button!==g)return p(e);e.deltaX=e.screenX-b,e.deltaY=e.screenY-y,e.preventDefault(),h.drag(e)},p=function(e){ut(e),ye(x).off("mousemove touchmove",v).off("mouseup touchend",p),m.remove(),h.stop&&h.stop(e)},this.destroy=function(){ye(w).off()},ye(w).on("mousedown touchstart",t)}var dt,ft,ht,mt,gt={init:function(){this.on("repaint",this.renderScroll)},renderScroll:function(){var p=this,v=2;function n(){var m,g,e;function t(e,t,n,i,r,o){var s,a,l,u,c,d,f,h;if(a=p.getEl("scroll"+e)){if(f=t.toLowerCase(),h=n.toLowerCase(),ye(p.getEl("absend")).css(f,p.layoutRect()[i]-1),!r)return void ye(a).css("display","none");ye(a).css("display","block"),s=p.getEl("body"),l=p.getEl("scroll"+e+"t"),u=s["client"+n]-2*v,c=(u-=m&&g?a["client"+o]:0)/s["scroll"+n],(d={})[f]=s["offset"+t]+v,d[h]=u,ye(a).css(d),(d={})[f]=s["scroll"+t]*c,d[h]=u*c,ye(l).css(d)}}e=p.getEl("body"),m=e.scrollWidth>e.clientWidth,g=e.scrollHeight>e.clientHeight,t("h","Left","Width","contentW",m,"Height"),t("v","Top","Height","contentH",g,"Width")}p.settings.autoScroll&&(p._hasScroll||(p._hasScroll=!0,function(){function e(s,a,l,u,c){var d,e=p._id+"-scroll"+s,t=p.classPrefix;ye(p.getEl()).append('<div id="'+e+'" class="'+t+"scrollbar "+t+"scrollbar-"+s+'"><div id="'+e+'t" class="'+t+'scrollbar-thumb"></div></div>'),p.draghelper=new ct(e+"t",{start:function(){d=p.getEl("body")["scroll"+a],ye("#"+e).addClass(t+"active")},drag:function(e){var t,n,i,r,o=p.layoutRect();n=o.contentW>o.innerW,i=o.contentH>o.innerH,r=p.getEl("body")["client"+l]-2*v,t=(r-=n&&i?p.getEl("scroll"+s)["client"+c]:0)/p.getEl("body")["scroll"+l],p.getEl("body")["scroll"+a]=d+e["delta"+u]/t},stop:function(){ye("#"+e).removeClass(t+"active")}})}p.classes.add("scroll"),e("v","Top","Height","Y","Width"),e("h","Left","Width","X","Height")}(),p.on("wheel",function(e){var t=p.getEl("body");t.scrollLeft+=10*(e.deltaX||0),t.scrollTop+=10*e.deltaY,n()}),ye(p.getEl("body")).on("scroll",n)),n())}},pt=lt.extend({Defaults:{layout:"fit",containerCls:"panel"},Mixins:[gt],renderHtml:function(){var e=this,t=e._layout,n=e.settings.html;return e.preRender(),t.preRender(e),void 0===n?n='<div id="'+e._id+'-body" class="'+e.bodyClasses+'">'+t.renderHtml(e)+"</div>":("function"==typeof n&&(n=n.call(e)),e._hasBody=!1),'<div id="'+e._id+'" class="'+e.classes+'" hidefocus="1" tabindex="-1" role="group">'+(e._preBodyHtml||"")+n+"</div>"}}),vt={resizeToContent:function(){this._layoutRect.autoResize=!0,this._lastRect=null,this.reflow()},resizeTo:function(e,t){if(e<=1||t<=1){var n=we.getWindowSize();e=e<=1?e*n.w:e,t=t<=1?t*n.h:t}return this._layoutRect.autoResize=!1,this.layoutRect({minW:e,minH:t,w:e,h:t}).reflow()},resizeBy:function(e,t){var n=this.layoutRect();return this.resizeTo(n.w+e,n.h+t)}},bt=[],yt=[];function xt(e,t){for(;e;){if(e===t)return!0;e=e.parent()}}function wt(){dt||(dt=function(e){2!==e.button&&function(e){for(var t=bt.length;t--;){var n=bt[t],i=n.getParentCtrl(e.target);if(n.settings.autohide){if(i&&(xt(i,n)||n.parent()===i))continue;(e=n.fire("autohide",{target:e.target})).isDefaultPrevented()||n.hide()}}}(e)},ye(_.document).on("click touchstart",dt))}function _t(r){var e=we.getViewPort().y;function t(e,t){for(var n,i=0;i<bt.length;i++)if(bt[i]!==r)for(n=bt[i].parent();n&&(n=n.parent());)n===r&&bt[i].fixed(e).moveBy(0,t).repaint()}r.settings.autofix&&(r.state.get("fixed")?r._autoFixY>e&&(r.fixed(!1).layoutRect({y:r._autoFixY}).repaint(),t(!1,r._autoFixY-e)):(r._autoFixY=r.layoutRect().y,r._autoFixY<e&&(r.fixed(!0).layoutRect({y:0}).repaint(),t(!0,e-r._autoFixY))))}function Rt(e,t){var n,i,r=Ct.zIndex||65535;if(e)yt.push(t);else for(n=yt.length;n--;)yt[n]===t&&yt.splice(n,1);if(yt.length)for(n=0;n<yt.length;n++)yt[n].modal&&(r++,i=yt[n]),yt[n].getEl().style.zIndex=r,yt[n].zIndex=r,r++;var o=ye("#"+t.classPrefix+"modal-block",t.getContainerElm())[0];i?ye(o).css("z-index",i.zIndex-1):o&&(o.parentNode.removeChild(o),mt=!1),Ct.currentZIndex=r}var Ct=pt.extend({Mixins:[He,vt],init:function(e){var i=this;i._super(e),(i._eventsRoot=i).classes.add("floatpanel"),e.autohide&&(wt(),function(){if(!ht){var e=_.document.documentElement,t=e.clientWidth,n=e.clientHeight;ht=function(){_.document.all&&t===e.clientWidth&&n===e.clientHeight||(t=e.clientWidth,n=e.clientHeight,Ct.hideAll())},ye(_.window).on("resize",ht)}}(),bt.push(i)),e.autofix&&(ft||(ft=function(){var e;for(e=bt.length;e--;)_t(bt[e])},ye(_.window).on("scroll",ft)),i.on("move",function(){_t(this)})),i.on("postrender show",function(e){if(e.control===i){var t,n=i.classPrefix;i.modal&&!mt&&((t=ye("#"+n+"modal-block",i.getContainerElm()))[0]||(t=ye('<div id="'+n+'modal-block" class="'+n+"reset "+n+'fade"></div>').appendTo(i.getContainerElm())),u.setTimeout(function(){t.addClass(n+"in"),ye(i.getEl()).addClass(n+"in")}),mt=!0),Rt(!0,i)}}),i.on("show",function(){i.parents().each(function(e){if(e.state.get("fixed"))return i.fixed(!0),!1})}),e.popover&&(i._preBodyHtml='<div class="'+i.classPrefix+'arrow"></div>',i.classes.add("popover").add("bottom").add(i.isRtl()?"end":"start")),i.aria("label",e.ariaLabel),i.aria("labelledby",i._id),i.aria("describedby",i.describedBy||i._id+"-none")},fixed:function(e){var t=this;if(t.state.get("fixed")!==e){if(t.state.get("rendered")){var n=we.getViewPort();e?t.layoutRect().y-=n.y:t.layoutRect().y+=n.y}t.classes.toggle("fixed",e),t.state.set("fixed",e)}return t},show:function(){var e,t=this._super();for(e=bt.length;e--&&bt[e]!==this;);return-1===e&&bt.push(this),t},hide:function(){return Et(this),Rt(!1,this),this._super()},hideAll:function(){Ct.hideAll()},close:function(){return this.fire("close").isDefaultPrevented()||(this.remove(),Rt(!1,this)),this},remove:function(){Et(this),this._super()},postRender:function(){return this.settings.bodyRole&&this.getEl("body").setAttribute("role",this.settings.bodyRole),this._super()}});function Et(e){var t;for(t=bt.length;t--;)bt[t]===e&&bt.splice(t,1);for(t=yt.length;t--;)yt[t]===e&&yt.splice(t,1)}Ct.hideAll=function(){for(var e=bt.length;e--;){var t=bt[e];t&&t.settings.autohide&&(t.hide(),bt.splice(e,1))}};var kt=function(s,n,e){var a,i,l=p.DOM,t=s.getParam("fixed_toolbar_container");t&&(i=l.select(t)[0]);var r=function(){if(a&&a.moveRel&&a.visible()&&!a._fixed){var e=s.selection.getScrollContainer(),t=s.getBody(),n=0,i=0;if(e){var r=l.getPos(t),o=l.getPos(e);n=Math.max(0,o.x-r.x),i=Math.max(0,o.y-r.y)}a.fixed(!1).moveRel(t,s.rtl?["tr-br","br-tr"]:["tl-bl","bl-tl","tr-br"]).moveBy(n,i)}},o=function(){a&&(a.show(),r(),l.addClass(s.getBody(),"mce-edit-focus"))},u=function(){a&&(a.hide(),Ct.hideAll(),l.removeClass(s.getBody(),"mce-edit-focus"))},c=function(){var e,t;a?a.visible()||o():(a=n.panel=v.create({type:i?"panel":"floatpanel",role:"application",classes:"tinymce tinymce-inline",layout:"flex",direction:"column",align:"stretch",autohide:!1,autofix:!0,fixed:(e=i,t=s,!(!e||t.settings.ui_container)),border:1,items:[!1===d(s)?null:{type:"menubar",border:"0 0 1 0",items:re(s)},A(s,f(s))]}),W.setUiContainer(s,a),x(s),i?a.renderTo(i).reflow():a.renderTo().reflow(),R(s,a),o(),F(s),s.on("nodeChange",r),s.on("ResizeWindow",r),s.on("activate",o),s.on("deactivate",u),s.nodeChanged())};return s.settings.content_editable=!0,s.on("focus",function(){!1===m(s)&&e.skinUiCss?l.styleSheetLoader.load(e.skinUiCss,c,c):c()}),s.on("blur hide",u),s.on("remove",function(){a&&(a.remove(),a=null)}),!1===m(s)&&e.skinUiCss?l.styleSheetLoader.load(e.skinUiCss,ge(s)):ge(s)(),{}};function Ht(i,r){var o,s,a=this,l=rt.classPrefix;a.show=function(e,t){function n(){o&&(ye(i).append('<div class="'+l+"throbber"+(r?" "+l+"throbber-inline":"")+'"></div>'),t&&t())}return a.hide(),o=!0,e?s=u.setTimeout(n,e):n(),a},a.hide=function(){var e=i.lastChild;return u.clearTimeout(s),e&&-1!==e.className.indexOf("throbber")&&e.parentNode.removeChild(e),o=!1,a}}var St=function(e,t){var n;e.on("ProgressState",function(e){n=n||new Ht(t.panel.getEl("body")),e.state?n.show(e.time):n.hide()})},Tt=function(e,t,n){var i=function(e){var t=e.settings,n=t.skin,i=t.skin_url;if(!1!==n){var r=n||"lightgray";i=i?e.documentBaseURI.toAbsolute(i):l.baseURL+"/skins/"+r}return i}(e);return i&&(n.skinUiCss=i+"/skin.min.css",e.contentCSS.push(i+"/content"+(e.inline?".inline":"")+".min.css")),St(e,t),e.getParam("inline",!1,"boolean")?kt(e,t,n):be(e,t,n)},Mt=rt.extend({Mixins:[He],Defaults:{classes:"widget tooltip tooltip-n"},renderHtml:function(){var e=this,t=e.classPrefix;return'<div id="'+e._id+'" class="'+e.classes+'" role="presentation"><div class="'+t+'tooltip-arrow"></div><div class="'+t+'tooltip-inner">'+e.encode(e.state.get("text"))+"</div></div>"},bindStates:function(){var t=this;return t.state.on("change:text",function(e){t.getEl().lastChild.innerHTML=t.encode(e.value)}),t._super()},repaint:function(){var e,t;e=this.getEl().style,t=this._layoutRect,e.left=t.x+"px",e.top=t.y+"px",e.zIndex=131070}}),Nt=rt.extend({init:function(i){var r=this;r._super(i),i=r.settings,r.canFocus=!0,i.tooltip&&!1!==Nt.tooltips&&(r.on("mouseenter",function(e){var t=r.tooltip().moveTo(-65535);if(e.control===r){var n=t.text(i.tooltip).show().testMoveRel(r.getEl(),["bc-tc","bc-tl","bc-tr"]);t.classes.toggle("tooltip-n","bc-tc"===n),t.classes.toggle("tooltip-nw","bc-tl"===n),t.classes.toggle("tooltip-ne","bc-tr"===n),t.moveRel(r.getEl(),n)}else t.hide()}),r.on("mouseleave mousedown click",function(){r.tooltip().remove(),r._tooltip=null})),r.aria("label",i.ariaLabel||i.tooltip)},tooltip:function(){return this._tooltip||(this._tooltip=new Mt({type:"tooltip"}),W.inheritUiContainer(this,this._tooltip),this._tooltip.renderTo()),this._tooltip},postRender:function(){var e=this,t=e.settings;e._super(),e.parent()||!t.width&&!t.height||(e.initLayoutRect(),e.repaint()),t.autofocus&&e.focus()},bindStates:function(){var t=this;function n(e){t.aria("disabled",e),t.classes.toggle("disabled",e)}function i(e){t.aria("pressed",e),t.classes.toggle("active",e)}return t.state.on("change:disabled",function(e){n(e.value)}),t.state.on("change:active",function(e){i(e.value)}),t.state.get("disabled")&&n(!0),t.state.get("active")&&i(!0),t._super()},remove:function(){this._super(),this._tooltip&&(this._tooltip.remove(),this._tooltip=null)}}),Pt=Nt.extend({Defaults:{value:0},init:function(e){this._super(e),this.classes.add("progress"),this.settings.filter||(this.settings.filter=function(e){return Math.round(e)})},renderHtml:function(){var e=this._id,t=this.classPrefix;return'<div id="'+e+'" class="'+this.classes+'"><div class="'+t+'bar-container"><div class="'+t+'bar"></div></div><div class="'+t+'text">0%</div></div>'},postRender:function(){return this._super(),this.value(this.settings.value),this},bindStates:function(){var t=this;function n(e){e=t.settings.filter(e),t.getEl().lastChild.innerHTML=e+"%",t.getEl().firstChild.firstChild.style.width=e+"%"}return t.state.on("change:value",function(e){n(e.value)}),n(t.state.get("value")),t._super()}}),Wt=function(e,t){e.getEl().lastChild.textContent=t+(e.progressBar?" "+e.progressBar.value()+"%":"")},Dt=rt.extend({Mixins:[He],Defaults:{classes:"widget notification"},init:function(e){var t=this;t._super(e),t.maxWidth=e.maxWidth,e.text&&t.text(e.text),e.icon&&(t.icon=e.icon),e.color&&(t.color=e.color),e.type&&t.classes.add("notification-"+e.type),e.timeout&&(e.timeout<0||0<e.timeout)&&!e.closeButton?t.closeButton=!1:(t.classes.add("has-close"),t.closeButton=!0),e.progressBar&&(t.progressBar=new Pt),t.on("click",function(e){-1!==e.target.className.indexOf(t.classPrefix+"close")&&t.close()})},renderHtml:function(){var e,t=this,n=t.classPrefix,i="",r="",o="";return t.icon&&(i='<i class="'+n+"ico "+n+"i-"+t.icon+'"></i>'),e=' style="max-width: '+t.maxWidth+"px;"+(t.color?"background-color: "+t.color+';"':'"'),t.closeButton&&(r='<button type="button" class="'+n+'close" aria-hidden="true">\xd7</button>'),t.progressBar&&(o=t.progressBar.renderHtml()),'<div id="'+t._id+'" class="'+t.classes+'"'+e+' role="presentation">'+i+'<div class="'+n+'notification-inner">'+t.state.get("text")+"</div>"+o+r+'<div style="clip: rect(1px, 1px, 1px, 1px);height: 1px;overflow: hidden;position: absolute;width: 1px;" aria-live="assertive" aria-relevant="additions" aria-atomic="true"></div></div>'},postRender:function(){var e=this;return u.setTimeout(function(){e.$el.addClass(e.classPrefix+"in"),Wt(e,e.state.get("text"))},100),e._super()},bindStates:function(){var t=this;return t.state.on("change:text",function(e){t.getEl().firstChild.innerHTML=e.value,Wt(t,e.value)}),t.progressBar&&(t.progressBar.bindStates(),t.progressBar.state.on("change:value",function(e){Wt(t,t.state.get("text"))})),t._super()},close:function(){return this.fire("close").isDefaultPrevented()||this.remove(),this},repaint:function(){var e,t;e=this.getEl().style,t=this._layoutRect,e.left=t.x+"px",e.top=t.y+"px",e.zIndex=65534}});function Ot(o){var s=function(e){return e.inline?e.getElement():e.getContentAreaContainer()};return{open:function(e,t){var n,i=w.extend(e,{maxWidth:(n=s(o),we.getSize(n).width)}),r=new Dt(i);return 0<(r.args=i).timeout&&(r.timer=setTimeout(function(){r.close(),t()},i.timeout)),r.on("close",function(){t()}),r.renderTo(),r},close:function(e){e.close()},reposition:function(e){K(e,function(e){e.moveTo(0,0)}),function(n){if(0<n.length){var e=n.slice(0,1)[0],t=s(o);e.moveRel(t,"tc-tc"),K(n,function(e,t){0<t&&e.moveRel(n[t-1].getEl(),"bc-tc")})}}(e)},getArgs:function(e){return e.args}}}var At=[],Bt="";function Lt(e){var t,n=ye("meta[name=viewport]")[0];!1!==ce.overrideViewPort&&(n||((n=_.document.createElement("meta")).setAttribute("name","viewport"),_.document.getElementsByTagName("head")[0].appendChild(n)),(t=n.getAttribute("content"))&&void 0!==Bt&&(Bt=t),n.setAttribute("content",e?"width=device-width,initial-scale=1.0,user-scalable=0,minimum-scale=1.0,maximum-scale=1.0":Bt))}function zt(e,t){(function(){for(var e=0;e<At.length;e++)if(At[e]._fullscreen)return!0;return!1})()&&!1===t&&ye([_.document.documentElement,_.document.body]).removeClass(e+"fullscreen")}var It=Ct.extend({modal:!0,Defaults:{border:1,layout:"flex",containerCls:"panel",role:"dialog",callbacks:{submit:function(){this.fire("submit",{data:this.toJSON()})},close:function(){this.close()}}},init:function(e){var n=this;n._super(e),n.isRtl()&&n.classes.add("rtl"),n.classes.add("window"),n.bodyClasses.add("window-body"),n.state.set("fixed",!0),e.buttons&&(n.statusbar=new pt({layout:"flex",border:"1 0 0 0",spacing:3,padding:10,align:"center",pack:n.isRtl()?"start":"end",defaults:{type:"button"},items:e.buttons}),n.statusbar.classes.add("foot"),n.statusbar.parent(n)),n.on("click",function(e){var t=n.classPrefix+"close";(we.hasClass(e.target,t)||we.hasClass(e.target.parentNode,t))&&n.close()}),n.on("cancel",function(){n.close()}),n.on("move",function(e){e.control===n&&Ct.hideAll()}),n.aria("describedby",n.describedBy||n._id+"-none"),n.aria("label",e.title),n._fullscreen=!1},recalc:function(){var e,t,n,i,r=this,o=r.statusbar;r._fullscreen&&(r.layoutRect(we.getWindowSize()),r.layoutRect().contentH=r.layoutRect().innerH),r._super(),e=r.layoutRect(),r.settings.title&&!r._fullscreen&&(t=e.headerW)>e.w&&(n=e.x-Math.max(0,t/2),r.layoutRect({w:t,x:n}),i=!0),o&&(o.layoutRect({w:r.layoutRect().innerW}).recalc(),(t=o.layoutRect().minW+e.deltaW)>e.w&&(n=e.x-Math.max(0,t-e.w),r.layoutRect({w:t,x:n}),i=!0)),i&&r.recalc()},initLayoutRect:function(){var e,t=this,n=t._super(),i=0;if(t.settings.title&&!t._fullscreen){e=t.getEl("head");var r=we.getSize(e);n.headerW=r.width,n.headerH=r.height,i+=n.headerH}t.statusbar&&(i+=t.statusbar.layoutRect().h),n.deltaH+=i,n.minH+=i,n.h+=i;var o=we.getWindowSize();return n.x=t.settings.x||Math.max(0,o.w/2-n.w/2),n.y=t.settings.y||Math.max(0,o.h/2-n.h/2),n},renderHtml:function(){var e=this,t=e._layout,n=e._id,i=e.classPrefix,r=e.settings,o="",s="",a=r.html;return e.preRender(),t.preRender(e),r.title&&(o='<div id="'+n+'-head" class="'+i+'window-head"><div id="'+n+'-title" class="'+i+'title">'+e.encode(r.title)+'</div><div id="'+n+'-dragh" class="'+i+'dragh"></div><button type="button" class="'+i+'close" aria-hidden="true"><i class="mce-ico mce-i-remove"></i></button></div>'),r.url&&(a='<iframe src="'+r.url+'" tabindex="-1"></iframe>'),void 0===a&&(a=t.renderHtml(e)),e.statusbar&&(s=e.statusbar.renderHtml()),'<div id="'+n+'" class="'+e.classes+'" hidefocus="1"><div class="'+e.classPrefix+'reset" role="application">'+o+'<div id="'+n+'-body" class="'+e.bodyClasses+'">'+a+"</div>"+s+"</div></div>"},fullscreen:function(e){var n,t,i=this,r=_.document.documentElement,o=i.classPrefix;if(e!==i._fullscreen)if(ye(_.window).on("resize",function(){var e;if(i._fullscreen)if(n)i._timer||(i._timer=u.setTimeout(function(){var e=we.getWindowSize();i.moveTo(0,0).resizeTo(e.w,e.h),i._timer=0},50));else{e=(new Date).getTime();var t=we.getWindowSize();i.moveTo(0,0).resizeTo(t.w,t.h),50<(new Date).getTime()-e&&(n=!0)}}),t=i.layoutRect(),i._fullscreen=e){i._initial={x:t.x,y:t.y,w:t.w,h:t.h},i.borderBox=Me("0"),i.getEl("head").style.display="none",t.deltaH-=t.headerH+2,ye([r,_.document.body]).addClass(o+"fullscreen"),i.classes.add("fullscreen");var s=we.getWindowSize();i.moveTo(0,0).resizeTo(s.w,s.h)}else i.borderBox=Me(i.settings.border),i.getEl("head").style.display="",t.deltaH+=t.headerH,ye([r,_.document.body]).removeClass(o+"fullscreen"),i.classes.remove("fullscreen"),i.moveTo(i._initial.x,i._initial.y).resizeTo(i._initial.w,i._initial.h);return i.reflow()},postRender:function(){var t,n=this;setTimeout(function(){n.classes.add("in"),n.fire("open")},0),n._super(),n.statusbar&&n.statusbar.postRender(),n.focus(),this.dragHelper=new ct(n._id+"-dragh",{start:function(){t={x:n.layoutRect().x,y:n.layoutRect().y}},drag:function(e){n.moveTo(t.x+e.deltaX,t.y+e.deltaY)}}),n.on("submit",function(e){e.isDefaultPrevented()||n.close()}),At.push(n),Lt(!0)},submit:function(){return this.fire("submit",{data:this.toJSON()})},remove:function(){var e,t=this;for(t.dragHelper.destroy(),t._super(),t.statusbar&&this.statusbar.remove(),zt(t.classPrefix,!1),e=At.length;e--;)At[e]===t&&At.splice(e,1);Lt(0<At.length)},getContentWindow:function(){var e=this.getEl().getElementsByTagName("iframe")[0];return e?e.contentWindow:null}});!function(){if(!ce.desktop){var n={w:_.window.innerWidth,h:_.window.innerHeight};u.setInterval(function(){var e=_.window.innerWidth,t=_.window.innerHeight;n.w===e&&n.h===t||(n={w:e,h:t},ye(_.window).trigger("resize"))},100)}ye(_.window).on("resize",function(){var e,t,n=we.getWindowSize();for(e=0;e<At.length;e++)t=At[e].layoutRect(),At[e].moveTo(At[e].settings.x||Math.max(0,n.w/2-t.w/2),At[e].settings.y||Math.max(0,n.h/2-t.h/2))})}();var Ft,Ut,Vt,Yt=It.extend({init:function(e){e={border:1,padding:20,layout:"flex",pack:"center",align:"center",containerCls:"panel",autoScroll:!0,buttons:{type:"button",text:"Ok",action:"ok"},items:{type:"label",multiline:!0,maxWidth:500,maxHeight:200}},this._super(e)},Statics:{OK:1,OK_CANCEL:2,YES_NO:3,YES_NO_CANCEL:4,msgBox:function(e){var t,i=e.callback||function(){};function n(e,t,n){return{type:"button",text:e,subtype:n?"primary":"",onClick:function(e){e.control.parents()[1].close(),i(t)}}}switch(e.buttons){case Yt.OK_CANCEL:t=[n("Ok",!0,!0),n("Cancel",!1)];break;case Yt.YES_NO:case Yt.YES_NO_CANCEL:t=[n("Yes",1,!0),n("No",0)],e.buttons===Yt.YES_NO_CANCEL&&t.push(n("Cancel",-1));break;default:t=[n("Ok",!0,!0)]}return new It({padding:20,x:e.x,y:e.y,minWidth:300,minHeight:100,layout:"flex",pack:"center",align:"center",buttons:t,title:e.title,role:"alertdialog",items:{type:"label",multiline:!0,maxWidth:500,maxHeight:200,text:e.text},onPostRender:function(){this.aria("describedby",this.items()[0]._id)},onClose:e.onClose,onCancel:function(){i(!1)}}).renderTo(_.document.body).reflow()},alert:function(e,t){return"string"==typeof e&&(e={text:e}),e.callback=t,Yt.msgBox(e)},confirm:function(e,t){return"string"==typeof e&&(e={text:e}),e.callback=t,e.buttons=Yt.OK_CANCEL,Yt.msgBox(e)}}}),$t=function(n){return{renderUI:function(e){return Tt(n,this,e)},resizeTo:function(e,t){return le(n,e,t)},resizeBy:function(e,t){return ue(n,e,t)},getNotificationManagerImpl:function(){return Ot(n)},getWindowManagerImpl:function(){return{open:function(n,e,t){var i;return n.title=n.title||" ",n.url=n.url||n.file,n.url&&(n.width=parseInt(n.width||320,10),n.height=parseInt(n.height||240,10)),n.body&&(n.items={defaults:n.defaults,type:n.bodyType||"form",items:n.body,data:n.data,callbacks:n.commands}),n.url||n.buttons||(n.buttons=[{text:"Ok",subtype:"primary",onclick:function(){i.find("form")[0].submit()}},{text:"Cancel",onclick:function(){i.close()}}]),(i=new It(n)).on("close",function(){t(i)}),n.data&&i.on("postRender",function(){this.find("*").each(function(e){var t=e.name();t in n.data&&e.value(n.data[t])})}),i.features=n||{},i.params=e||{},i=i.renderTo(_.document.body).reflow()},alert:function(e,t,n){var i;return(i=Yt.alert(e,function(){t()})).on("close",function(){n(i)}),i},confirm:function(e,t,n){var i;return(i=Yt.confirm(e,function(e){t(e)})).on("close",function(){n(i)}),i},close:function(e){e.close()},getParams:function(e){return e.params},setParams:function(e,t){e.params=t}}}}},qt=Se.extend({Defaults:{firstControlClass:"first",lastControlClass:"last"},init:function(e){this.settings=w.extend({},this.Defaults,e)},preRender:function(e){e.bodyClasses.add(this.settings.containerClass)},applyClasses:function(e){var t,n,i,r,o=this.settings;t=o.firstControlClass,n=o.lastControlClass,e.each(function(e){e.classes.remove(t).remove(n).add(o.controlClass),e.visible()&&(i||(i=e),r=e)}),i&&i.classes.add(t),r&&r.classes.add(n)},renderHtml:function(e){var t="";return this.applyClasses(e.items()),e.items().each(function(e){t+=e.renderHtml()}),t},recalc:function(){},postRender:function(){},isNative:function(){return!1}}),Xt=qt.extend({Defaults:{containerClass:"abs-layout",controlClass:"abs-layout-item"},recalc:function(e){e.items().filter(":visible").each(function(e){var t=e.settings;e.layoutRect({x:t.x,y:t.y,w:t.w,h:t.h}),e.recalc&&e.recalc()})},renderHtml:function(e){return'<div id="'+e._id+'-absend" class="'+e.classPrefix+'abs-end"></div>'+this._super(e)}}),jt=Nt.extend({Defaults:{classes:"widget btn",role:"button"},init:function(e){var t,n=this;n._super(e),e=n.settings,t=n.settings.size,n.on("click mousedown",function(e){e.preventDefault()}),n.on("touchstart",function(e){n.fire("click",e),e.preventDefault()}),e.subtype&&n.classes.add(e.subtype),t&&n.classes.add("btn-"+t),e.icon&&n.icon(e.icon)},icon:function(e){return arguments.length?(this.state.set("icon",e),this):this.state.get("icon")},repaint:function(){var e,t=this.getEl().firstChild;t&&((e=t.style).width=e.height="100%"),this._super()},renderHtml:function(){var e,t,n=this,i=n._id,r=n.classPrefix,o=n.state.get("icon"),s=n.state.get("text"),a="",l=n.settings;return(e=l.image)?(o="none","string"!=typeof e&&(e=_.window.getSelection?e[0]:e[1]),e=" style=\"background-image: url('"+e+"')\""):e="",s&&(n.classes.add("btn-has-text"),a='<span class="'+r+'txt">'+n.encode(s)+"</span>"),o=o?r+"ico "+r+"i-"+o:"",t="boolean"==typeof l.active?' aria-pressed="'+l.active+'"':"",'<div id="'+i+'" class="'+n.classes+'" tabindex="-1"'+t+'><button id="'+i+'-button" role="presentation" type="button" tabindex="-1">'+(o?'<i class="'+o+'"'+e+"></i>":"")+a+"</button></div>"},bindStates:function(){var o=this,n=o.$,i=o.classPrefix+"txt";function s(e){var t=n("span."+i,o.getEl());e?(t[0]||(n("button:first",o.getEl()).append('<span class="'+i+'"></span>'),t=n("span."+i,o.getEl())),t.html(o.encode(e))):t.remove(),o.classes.toggle("btn-has-text",!!e)}return o.state.on("change:text",function(e){s(e.value)}),o.state.on("change:icon",function(e){var t=e.value,n=o.classPrefix;t=(o.settings.icon=t)?n+"ico "+n+"i-"+o.settings.icon:"";var i=o.getEl().firstChild,r=i.getElementsByTagName("i")[0];t?(r&&r===i.firstChild||(r=_.document.createElement("i"),i.insertBefore(r,i.firstChild)),r.className=t):r&&i.removeChild(r),s(o.state.get("text"))}),o._super()}}),Jt=jt.extend({init:function(e){e=w.extend({text:"Browse...",multiple:!1,accept:null},e),this._super(e),this.classes.add("browsebutton"),e.multiple&&this.classes.add("multiple")},postRender:function(){var n=this,t=we.create("input",{type:"file",id:n._id+"-browse",accept:n.settings.accept});n._super(),ye(t).on("change",function(e){var t=e.target.files;n.value=function(){return t.length?n.settings.multiple?t:t[0]:null},e.preventDefault(),t.length&&n.fire("change",e)}),ye(t).on("click",function(e){e.stopPropagation()}),ye(n.getEl("button")).on("click touchstart",function(e){e.stopPropagation(),t.click(),e.preventDefault()}),n.getEl().appendChild(t)},remove:function(){ye(this.getEl("button")).off(),ye(this.getEl("input")).off(),this._super()}}),Gt=lt.extend({Defaults:{defaultType:"button",role:"group"},renderHtml:function(){var e=this,t=e._layout;return e.classes.add("btn-group"),e.preRender(),t.preRender(e),'<div id="'+e._id+'" class="'+e.classes+'"><div id="'+e._id+'-body">'+(e.settings.html||"")+t.renderHtml(e)+"</div></div>"}}),Kt=Nt.extend({Defaults:{classes:"checkbox",role:"checkbox",checked:!1},init:function(e){var t=this;t._super(e),t.on("click mousedown",function(e){e.preventDefault()}),t.on("click",function(e){e.preventDefault(),t.disabled()||t.checked(!t.checked())}),t.checked(t.settings.checked)},checked:function(e){return arguments.length?(this.state.set("checked",e),this):this.state.get("checked")},value:function(e){return arguments.length?this.checked(e):this.checked()},renderHtml:function(){var e=this,t=e._id,n=e.classPrefix;return'<div id="'+t+'" class="'+e.classes+'" unselectable="on" aria-labelledby="'+t+'-al" tabindex="-1"><i class="'+n+"ico "+n+'i-checkbox"></i><span id="'+t+'-al" class="'+n+'label">'+e.encode(e.state.get("text"))+"</span></div>"},bindStates:function(){var o=this;function t(e){o.classes.toggle("checked",e),o.aria("checked",e)}return o.state.on("change:text",function(e){o.getEl("al").firstChild.data=o.translate(e.value)}),o.state.on("change:checked change:value",function(e){o.fire("change"),t(e.value)}),o.state.on("change:icon",function(e){var t=e.value,n=o.classPrefix;if(void 0===t)return o.settings.icon;t=(o.settings.icon=t)?n+"ico "+n+"i-"+o.settings.icon:"";var i=o.getEl().firstChild,r=i.getElementsByTagName("i")[0];t?(r&&r===i.firstChild||(r=_.document.createElement("i"),i.insertBefore(r,i.firstChild)),r.className=t):r&&i.removeChild(r)}),o.state.get("checked")&&t(!0),o._super()}}),Zt=tinymce.util.Tools.resolve("tinymce.util.VK"),Qt=Nt.extend({init:function(i){var r=this;r._super(i),i=r.settings,r.classes.add("combobox"),r.subinput=!0,r.ariaTarget="inp",i.menu=i.menu||i.values,i.menu&&(i.icon="caret"),r.on("click",function(e){var t=e.target,n=r.getEl();if(ye.contains(n,t)||t===n)for(;t&&t!==n;)t.id&&-1!==t.id.indexOf("-open")&&(r.fire("action"),i.menu&&(r.showMenu(),e.aria&&r.menu.items()[0].focus())),t=t.parentNode}),r.on("keydown",function(e){var t;13===e.keyCode&&"INPUT"===e.target.nodeName&&(e.preventDefault(),r.parents().reverse().each(function(e){if(e.toJSON)return t=e,!1}),r.fire("submit",{data:t.toJSON()}))}),r.on("keyup",function(e){if("INPUT"===e.target.nodeName){var t=r.state.get("value"),n=e.target.value;n!==t&&(r.state.set("value",n),r.fire("autocomplete",e))}}),r.on("mouseover",function(e){var t=r.tooltip().moveTo(-65535);if(r.statusLevel()&&-1!==e.target.className.indexOf(r.classPrefix+"status")){var n=r.statusMessage()||"Ok",i=t.text(n).show().testMoveRel(e.target,["bc-tc","bc-tl","bc-tr"]);t.classes.toggle("tooltip-n","bc-tc"===i),t.classes.toggle("tooltip-nw","bc-tl"===i),t.classes.toggle("tooltip-ne","bc-tr"===i),t.moveRel(e.target,i)}})},statusLevel:function(e){return 0<arguments.length&&this.state.set("statusLevel",e),this.state.get("statusLevel")},statusMessage:function(e){return 0<arguments.length&&this.state.set("statusMessage",e),this.state.get("statusMessage")},showMenu:function(){var e,t=this,n=t.settings;t.menu||((e=n.menu||[]).length?e={type:"menu",items:e}:e.type=e.type||"menu",t.menu=v.create(e).parent(t).renderTo(t.getContainerElm()),t.fire("createmenu"),t.menu.reflow(),t.menu.on("cancel",function(e){e.control===t.menu&&t.focus()}),t.menu.on("show hide",function(e){e.control.items().each(function(e){e.active(e.value()===t.value())})}).fire("show"),t.menu.on("select",function(e){t.value(e.control.value())}),t.on("focusin",function(e){"INPUT"===e.target.tagName.toUpperCase()&&t.menu.hide()}),t.aria("expanded",!0)),t.menu.show(),t.menu.layoutRect({w:t.layoutRect().w}),t.menu.moveRel(t.getEl(),t.isRtl()?["br-tr","tr-br"]:["bl-tl","tl-bl"])},focus:function(){this.getEl("inp").focus()},repaint:function(){var e,t,n=this,i=n.getEl(),r=n.getEl("open"),o=n.layoutRect(),s=0,a=i.firstChild;n.statusLevel()&&"none"!==n.statusLevel()&&(s=parseInt(we.getRuntimeStyle(a,"padding-right"),10)-parseInt(we.getRuntimeStyle(a,"padding-left"),10)),e=r?o.w-we.getSize(r).width-10:o.w-10;var l=_.document;return l.all&&(!l.documentMode||l.documentMode<=8)&&(t=n.layoutRect().h-2+"px"),ye(a).css({width:e-s,lineHeight:t}),n._super(),n},postRender:function(){var t=this;return ye(this.getEl("inp")).on("change",function(e){t.state.set("value",e.target.value),t.fire("change",e)}),t._super()},renderHtml:function(){var e,t,n,i=this,r=i._id,o=i.settings,s=i.classPrefix,a=i.state.get("value")||"",l="",u="";return"spellcheck"in o&&(u+=' spellcheck="'+o.spellcheck+'"'),o.maxLength&&(u+=' maxlength="'+o.maxLength+'"'),o.size&&(u+=' size="'+o.size+'"'),o.subtype&&(u+=' type="'+o.subtype+'"'),n='<i id="'+r+'-status" class="mce-status mce-ico" style="display: none"></i>',i.disabled()&&(u+=' disabled="disabled"'),(e=o.icon)&&"caret"!==e&&(e=s+"ico "+s+"i-"+o.icon),t=i.state.get("text"),(e||t)&&(l='<div id="'+r+'-open" class="'+s+"btn "+s+'open" tabIndex="-1" role="button"><button id="'+r+'-action" type="button" hidefocus="1" tabindex="-1">'+("caret"!==e?'<i class="'+e+'"></i>':'<i class="'+s+'caret"></i>')+(t?(e?" ":"")+t:"")+"</button></div>",i.classes.add("has-open")),'<div id="'+r+'" class="'+i.classes+'"><input id="'+r+'-inp" class="'+s+'textbox" value="'+i.encode(a,!1)+'" hidefocus="1"'+u+' placeholder="'+i.encode(o.placeholder)+'" />'+n+l+"</div>"},value:function(e){return arguments.length?(this.state.set("value",e),this):(this.state.get("rendered")&&this.state.set("value",this.getEl("inp").value),this.state.get("value"))},showAutoComplete:function(e,i){var r=this;if(0!==e.length){r.menu?r.menu.items().remove():r.menu=v.create({type:"menu",classes:"combobox-menu",layout:"flow"}).parent(r).renderTo(),w.each(e,function(e){var t,n;r.menu.add({text:e.title,url:e.previewUrl,match:i,classes:"menu-item-ellipsis",onclick:(t=e.value,n=e.title,function(){r.fire("selectitem",{title:n,value:t})})})}),r.menu.renderNew(),r.hideMenu(),r.menu.on("cancel",function(e){e.control.parent()===r.menu&&(e.stopPropagation(),r.focus(),r.hideMenu())}),r.menu.on("select",function(){r.focus()});var t=r.layoutRect().w;r.menu.layoutRect({w:t,minW:0,maxW:t}),r.menu.repaint(),r.menu.reflow(),r.menu.show(),r.menu.moveRel(r.getEl(),r.isRtl()?["br-tr","tr-br"]:["bl-tl","tl-bl"])}else r.hideMenu()},hideMenu:function(){this.menu&&this.menu.hide()},bindStates:function(){var r=this;r.state.on("change:value",function(e){r.getEl("inp").value!==e.value&&(r.getEl("inp").value=e.value)}),r.state.on("change:disabled",function(e){r.getEl("inp").disabled=e.value}),r.state.on("change:statusLevel",function(e){var t=r.getEl("status"),n=r.classPrefix,i=e.value;we.css(t,"display","none"===i?"none":""),we.toggleClass(t,n+"i-checkmark","ok"===i),we.toggleClass(t,n+"i-warning","warn"===i),we.toggleClass(t,n+"i-error","error"===i),r.classes.toggle("has-status","none"!==i),r.repaint()}),we.on(r.getEl("status"),"mouseleave",function(){r.tooltip().hide()}),r.on("cancel",function(e){r.menu&&r.menu.visible()&&(e.stopPropagation(),r.hideMenu())});var n=function(e,t){t&&0<t.items().length&&t.items().eq(e)[0].focus()};return r.on("keydown",function(e){var t=e.keyCode;"INPUT"===e.target.nodeName&&(t===Zt.DOWN?(e.preventDefault(),r.fire("autocomplete"),n(0,r.menu)):t===Zt.UP&&(e.preventDefault(),n(-1,r.menu)))}),r._super()},remove:function(){ye(this.getEl("inp")).off(),this.menu&&this.menu.remove(),this._super()}}),en=Qt.extend({init:function(e){var t=this;e.spellcheck=!1,e.onaction&&(e.icon="none"),t._super(e),t.classes.add("colorbox"),t.on("change keyup postrender",function(){t.repaintColor(t.value())})},repaintColor:function(e){var t=this.getEl("open"),n=t?t.getElementsByTagName("i")[0]:null;if(n)try{n.style.background=e}catch(i){}},bindStates:function(){var t=this;return t.state.on("change:value",function(e){t.state.get("rendered")&&t.repaintColor(e.value)}),t._super()}}),tn=jt.extend({showPanel:function(){var t=this,e=t.settings;if(t.classes.add("opened"),t.panel)t.panel.show();else{var n=e.panel;n.type&&(n={layout:"grid",items:n}),n.role=n.role||"dialog",n.popover=!0,n.autohide=!0,n.ariaRoot=!0,t.panel=new Ct(n).on("hide",function(){t.classes.remove("opened")}).on("cancel",function(e){e.stopPropagation(),t.focus(),t.hidePanel()}).parent(t).renderTo(t.getContainerElm()),t.panel.fire("show"),t.panel.reflow()}var i=t.panel.testMoveRel(t.getEl(),e.popoverAlign||(t.isRtl()?["bc-tc","bc-tl","bc-tr"]:["bc-tc","bc-tr","bc-tl","tc-bc","tc-br","tc-bl"]));t.panel.classes.toggle("start","l"===i.substr(-1)),t.panel.classes.toggle("end","r"===i.substr(-1));var r="t"===i.substr(0,1);t.panel.classes.toggle("bottom",!r),t.panel.classes.toggle("top",r),t.panel.moveRel(t.getEl(),i)},hidePanel:function(){this.panel&&this.panel.hide()},postRender:function(){var t=this;return t.aria("haspopup",!0),t.on("click",function(e){e.control===t&&(t.panel&&t.panel.visible()?t.hidePanel():(t.showPanel(),t.panel.focus(!!e.aria)))}),t._super()},remove:function(){return this.panel&&(this.panel.remove(),this.panel=null),this._super()}}),nn=p.DOM,rn=tn.extend({init:function(e){this._super(e),this.classes.add("splitbtn"),this.classes.add("colorbutton")},color:function(e){return e?(this._color=e,this.getEl("preview").style.backgroundColor=e,this):this._color},resetColor:function(){return this._color=null,this.getEl("preview").style.backgroundColor=null,this},renderHtml:function(){var e=this,t=e._id,n=e.classPrefix,i=e.state.get("text"),r=e.settings.icon?n+"ico "+n+"i-"+e.settings.icon:"",o=e.settings.image?" style=\"background-image: url('"+e.settings.image+"')\"":"",s="";return i&&(e.classes.add("btn-has-text"),s='<span class="'+n+'txt">'+e.encode(i)+"</span>"),'<div id="'+t+'" class="'+e.classes+'" role="button" tabindex="-1" aria-haspopup="true"><button role="presentation" hidefocus="1" type="button" tabindex="-1">'+(r?'<i class="'+r+'"'+o+"></i>":"")+'<span id="'+t+'-preview" class="'+n+'preview"></span>'+s+'</button><button type="button" class="'+n+'open" hidefocus="1" tabindex="-1"> <i class="'+n+'caret"></i></button></div>'},postRender:function(){var t=this,n=t.settings.onclick;return t.on("click",function(e){e.aria&&"down"===e.aria.key||e.control!==t||nn.getParent(e.target,"."+t.classPrefix+"open")||(e.stopImmediatePropagation(),n.call(t,e))}),delete t.settings.onclick,t._super()}}),on=tinymce.util.Tools.resolve("tinymce.util.Color"),sn=Nt.extend({Defaults:{classes:"widget colorpicker"},init:function(e){this._super(e)},postRender:function(){var n,i,r,o,s,a=this,l=a.color();function u(e,t){var n,i,r=we.getPos(e);return n=t.pageX-r.x,i=t.pageY-r.y,{x:n=Math.max(0,Math.min(n/e.clientWidth,1)),y:i=Math.max(0,Math.min(i/e.clientHeight,1))}}function c(e,t){var n=(360-e.h)/360;we.css(r,{top:100*n+"%"}),t||we.css(s,{left:e.s+"%",top:100-e.v+"%"}),o.style.background=on({s:100,v:100,h:e.h}).toHex(),a.color().parse({s:e.s,v:e.v,h:e.h})}function e(e){var t;t=u(o,e),n.s=100*t.x,n.v=100*(1-t.y),c(n),a.fire("change")}function t(e){var t;t=u(i,e),(n=l.toHsv()).h=360*(1-t.y),c(n,!0),a.fire("change")}i=a.getEl("h"),r=a.getEl("hp"),o=a.getEl("sv"),s=a.getEl("svp"),a._repaint=function(){c(n=l.toHsv())},a._super(),a._svdraghelper=new ct(a._id+"-sv",{start:e,drag:e}),a._hdraghelper=new ct(a._id+"-h",{start:t,drag:t}),a._repaint()},rgb:function(){return this.color().toRgb()},value:function(e){if(!arguments.length)return this.color().toHex();this.color().parse(e),this._rendered&&this._repaint()},color:function(){return this._color||(this._color=on()),this._color},renderHtml:function(){var e,t=this._id,o=this.classPrefix,s="#ff0000,#ff0080,#ff00ff,#8000ff,#0000ff,#0080ff,#00ffff,#00ff80,#00ff00,#80ff00,#ffff00,#ff8000,#ff0000";return e='<div id="'+t+'-h" class="'+o+'colorpicker-h" style="background: -ms-linear-gradient(top,'+s+");background: linear-gradient(to bottom,"+s+');">'+function(){var e,t,n,i,r="";for(n="filter:progid:DXImageTransform.Microsoft.gradient(GradientType=0,startColorstr=",e=0,t=(i=s.split(",")).length-1;e<t;e++)r+='<div class="'+o+'colorpicker-h-chunk" style="height:'+100/t+"%;"+n+i[e]+",endColorstr="+i[e+1]+");-ms-"+n+i[e]+",endColorstr="+i[e+1]+')"></div>';return r}()+'<div id="'+t+'-hp" class="'+o+'colorpicker-h-marker"></div></div>','<div id="'+t+'" class="'+this.classes+'"><div id="'+t+'-sv" class="'+o+'colorpicker-sv"><div class="'+o+'colorpicker-overlay1"><div class="'+o+'colorpicker-overlay2"><div id="'+t+'-svp" class="'+o+'colorpicker-selector1"><div class="'+o+'colorpicker-selector2"></div></div></div></div></div>'+e+"</div>"}}),an=Nt.extend({init:function(e){e=w.extend({height:100,text:"Drop an image here",multiple:!1,accept:null},e),this._super(e),this.classes.add("dropzone"),e.multiple&&this.classes.add("multiple")},renderHtml:function(){var e,t,n=this.settings;return e={id:this._id,hidefocus:"1"},t=we.create("div",e,"<span>"+this.translate(n.text)+"</span>"),n.height&&we.css(t,"height",n.height+"px"),n.width&&we.css(t,"width",n.width+"px"),t.className=this.classes,t.outerHTML},postRender:function(){var i=this,e=function(e){e.preventDefault(),i.classes.toggle("dragenter"),i.getEl().className=i.classes};i._super(),i.$el.on("dragover",function(e){e.preventDefault()}),i.$el.on("dragenter",e),i.$el.on("dragleave",e),i.$el.on("drop",function(e){if(e.preventDefault(),!i.state.get("disabled")){var t=function(e){var t=i.settings.accept;if("string"!=typeof t)return e;var n=new RegExp("("+t.split(/\s*,\s*/).join("|")+")$","i");return w.grep(e,function(e){return n.test(e.name)})}(e.dataTransfer.files);i.value=function(){return t.length?i.settings.multiple?t:t[0]:null},t.length&&i.fire("change",e)}})},remove:function(){this.$el.off(),this._super()}}),ln=Nt.extend({init:function(e){var n=this;e.delimiter||(e.delimiter="\xbb"),n._super(e),n.classes.add("path"),n.canFocus=!0,n.on("click",function(e){var t;(t=e.target.getAttribute("data-index"))&&n.fire("select",{value:n.row()[t],index:t})}),n.row(n.settings.row)},focus:function(){return this.getEl().firstChild.focus(),this},row:function(e){return arguments.length?(this.state.set("row",e),this):this.state.get("row")},renderHtml:function(){return'<div id="'+this._id+'" class="'+this.classes+'">'+this._getDataPathHtml(this.state.get("row"))+"</div>"},bindStates:function(){var t=this;return t.state.on("change:row",function(e){t.innerHtml(t._getDataPathHtml(e.value))}),t._super()},_getDataPathHtml:function(e){var t,n,i=e||[],r="",o=this.classPrefix;for(t=0,n=i.length;t<n;t++)r+=(0<t?'<div class="'+o+'divider" aria-hidden="true"> '+this.settings.delimiter+" </div>":"")+'<div role="button" class="'+o+"path-item"+(t===n-1?" "+o+"last":"")+'" data-index="'+t+'" tabindex="-1" id="'+this._id+"-"+t+'" aria-level="'+(t+1)+'">'+i[t].name+"</div>";return r||(r='<div class="'+o+'path-item">\xa0</div>'),r}}),un=ln.extend({postRender:function(){var o=this,s=o.settings.editor;function a(e){if(1===e.nodeType){if("BR"===e.nodeName||e.getAttribute("data-mce-bogus"))return!0;if("bookmark"===e.getAttribute("data-mce-type"))return!0}return!1}return!1!==s.settings.elementpath&&(o.on("select",function(e){s.focus(),s.selection.select(this.row()[e.index].element),s.nodeChanged()}),s.on("nodeChange",function(e){for(var t=[],n=e.parents,i=n.length;i--;)if(1===n[i].nodeType&&!a(n[i])){var r=s.fire("ResolveName",{name:n[i].nodeName.toLowerCase(),target:n[i]});if(r.isDefaultPrevented()||t.push({name:r.name,element:n[i]}),r.isPropagationStopped())break}o.row(t)})),o._super()}}),cn=lt.extend({Defaults:{layout:"flex",align:"center",defaults:{flex:1}},renderHtml:function(){var e=this,t=e._layout,n=e.classPrefix;return e.classes.add("formitem"),t.preRender(e),'<div id="'+e._id+'" class="'+e.classes+'" hidefocus="1" tabindex="-1">'+(e.settings.title?'<div id="'+e._id+'-title" class="'+n+'title">'+e.settings.title+"</div>":"")+'<div id="'+e._id+'-body" class="'+e.bodyClasses+'">'+(e.settings.html||"")+t.renderHtml(e)+"</div></div>"}}),dn=lt.extend({Defaults:{containerCls:"form",layout:"flex",direction:"column",align:"stretch",flex:1,padding:15,labelGap:30,spacing:10,callbacks:{submit:function(){this.submit()}}},preRender:function(){var i=this,e=i.items();i.settings.formItemDefaults||(i.settings.formItemDefaults={layout:"flex",autoResize:"overflow",defaults:{flex:1}}),e.each(function(e){var t,n=e.settings.label;n&&((t=new cn(w.extend({items:{type:"label",id:e._id+"-l",text:n,flex:0,forId:e._id,disabled:e.disabled()}},i.settings.formItemDefaults))).type="formitem",e.aria("labelledby",e._id+"-l"),"undefined"==typeof e.settings.flex&&(e.settings.flex=1),i.replace(e,t),t.add(e))})},submit:function(){return this.fire("submit",{data:this.toJSON()})},postRender:function(){this._super(),this.fromJSON(this.settings.data)},bindStates:function(){var n=this;function e(){var e,t,i=0,r=[];if(!1!==n.settings.labelGapCalc)for(("children"===n.settings.labelGapCalc?n.find("formitem"):n.items()).filter("formitem").each(function(e){var t=e.items()[0],n=t.getEl().clientWidth;i=i<n?n:i,r.push(t)}),t=n.settings.labelGap||0,e=r.length;e--;)r[e].settings.minWidth=i+t}n._super(),n.on("show",e),e()}}),fn=dn.extend({Defaults:{containerCls:"fieldset",layout:"flex",direction:"column",align:"stretch",flex:1,padding:"25 15 5 15",labelGap:30,spacing:10,border:1},renderHtml:function(){var e=this,t=e._layout,n=e.classPrefix;return e.preRender(),t.preRender(e),'<fieldset id="'+e._id+'" class="'+e.classes+'" hidefocus="1" tabindex="-1">'+(e.settings.title?'<legend id="'+e._id+'-title" class="'+n+'fieldset-title">'+e.settings.title+"</legend>":"")+'<div id="'+e._id+'-body" class="'+e.bodyClasses+'">'+(e.settings.html||"")+t.renderHtml(e)+"</div></fieldset>"}}),hn=0,mn=function(e){if(null===e||e===undefined)throw new Error("Node cannot be null or undefined");return{dom:k(e)}},gn={fromHtml:function(e,t){var n=(t||_.document).createElement("div");if(n.innerHTML=e,!n.hasChildNodes()||1<n.childNodes.length)throw _.console.error("HTML does not have a single root node",e),new Error("HTML must have a single root node");return mn(n.childNodes[0])},fromTag:function(e,t){var n=(t||_.document).createElement(e);return mn(n)},fromText:function(e,t){var n=(t||_.document).createTextNode(e);return mn(n)},fromDom:mn,fromPoint:function(e,t,n){var i=e.dom();return N.from(i.elementFromPoint(t,n)).map(mn)}},pn=(_.Node.ATTRIBUTE_NODE,_.Node.CDATA_SECTION_NODE,_.Node.COMMENT_NODE,_.Node.DOCUMENT_NODE),vn=(_.Node.DOCUMENT_TYPE_NODE,_.Node.DOCUMENT_FRAGMENT_NODE,_.Node.ELEMENT_NODE),bn=(_.Node.TEXT_NODE,_.Node.PROCESSING_INSTRUCTION_NODE,_.Node.ENTITY_REFERENCE_NODE,_.Node.ENTITY_NODE,_.Node.NOTATION_NODE,"undefined"!=typeof _.window?_.window:Function("return this;")(),function(e,t){var n=function(e,t){for(var n=0;n<e.length;n++){var i=e[n];if(i.test(t))return i}return undefined}(e,t);if(!n)return{major:0,minor:0};var i=function(e){return Number(t.replace(n,"$"+e))};return xn(i(1),i(2))}),yn=function(){return xn(0,0)},xn=function(e,t){return{major:e,minor:t}},wn={nu:xn,detect:function(e,t){var n=String(t).toLowerCase();return 0===e.length?yn():bn(e,n)},unknown:yn},_n="Firefox",Rn=function(e,t){return function(){return t===e}},Cn=function(e){var t=e.current;return{current:t,version:e.version,isEdge:Rn("Edge",t),isChrome:Rn("Chrome",t),isIE:Rn("IE",t),isOpera:Rn("Opera",t),isFirefox:Rn(_n,t),isSafari:Rn("Safari",t)}},En={unknown:function(){return Cn({current:undefined,version:wn.unknown()})},nu:Cn,edge:k("Edge"),chrome:k("Chrome"),ie:k("IE"),opera:k("Opera"),firefox:k(_n),safari:k("Safari")},kn="Windows",Hn="Android",Sn="Solaris",Tn="FreeBSD",Mn=function(e,t){return function(){return t===e}},Nn=function(e){var t=e.current;return{current:t,version:e.version,isWindows:Mn(kn,t),isiOS:Mn("iOS",t),isAndroid:Mn(Hn,t),isOSX:Mn("OSX",t),isLinux:Mn("Linux",t),isSolaris:Mn(Sn,t),isFreeBSD:Mn(Tn,t)}},Pn={unknown:function(){return Nn({current:undefined,version:wn.unknown()})},nu:Nn,windows:k(kn),ios:k("iOS"),android:k(Hn),linux:k("Linux"),osx:k("OSX"),solaris:k(Sn),freebsd:k(Tn)},Wn=function(e,t){var n=String(t).toLowerCase();return function(e,t){for(var n=0,i=e.length;n<i;n++){var r=e[n];if(t(r,n))return N.some(r)}return N.none()}(e,function(e){return e.search(n)})},Dn=function(e,n){return Wn(e,n).map(function(e){var t=wn.detect(e.versionRegexes,n);return{current:e.name,version:t}})},On=function(e,n){return Wn(e,n).map(function(e){var t=wn.detect(e.versionRegexes,n);return{current:e.name,version:t}})},An=function(e,t){return-1!==e.indexOf(t)},Bn=/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,Ln=function(t){return function(e){return An(e,t)}},zn=[{name:"Edge",versionRegexes:[/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],search:function(e){return An(e,"edge/")&&An(e,"chrome")&&An(e,"safari")&&An(e,"applewebkit")}},{name:"Chrome",versionRegexes:[/.*?chrome\/([0-9]+)\.([0-9]+).*/,Bn],search:function(e){return An(e,"chrome")&&!An(e,"chromeframe")}},{name:"IE",versionRegexes:[/.*?msie\ ?([0-9]+)\.([0-9]+).*/,/.*?rv:([0-9]+)\.([0-9]+).*/],search:function(e){return An(e,"msie")||An(e,"trident")}},{name:"Opera",versionRegexes:[Bn,/.*?opera\/([0-9]+)\.([0-9]+).*/],search:Ln("opera")},{name:"Firefox",versionRegexes:[/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],search:Ln("firefox")},{name:"Safari",versionRegexes:[Bn,/.*?cpu os ([0-9]+)_([0-9]+).*/],search:function(e){return(An(e,"safari")||An(e,"mobile/"))&&An(e,"applewebkit")}}],In=[{name:"Windows",search:Ln("win"),versionRegexes:[/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]},{name:"iOS",search:function(e){return An(e,"iphone")||An(e,"ipad")},versionRegexes:[/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,/.*cpu os ([0-9]+)_([0-9]+).*/,/.*cpu iphone os ([0-9]+)_([0-9]+).*/]},{name:"Android",search:Ln("android"),versionRegexes:[/.*?android\ ?([0-9]+)\.([0-9]+).*/]},{name:"OSX",search:Ln("os x"),versionRegexes:[/.*?os\ x\ ?([0-9]+)_([0-9]+).*/]},{name:"Linux",search:Ln("linux"),versionRegexes:[]},{name:"Solaris",search:Ln("sunos"),versionRegexes:[]},{name:"FreeBSD",search:Ln("freebsd"),versionRegexes:[]}],Fn={browsers:k(zn),oses:k(In)},Un=function(e){var t,n,i,r,o,s,a,l,u,c,d,f=Fn.browsers(),h=Fn.oses(),m=Dn(f,e).fold(En.unknown,En.nu),g=On(h,e).fold(Pn.unknown,Pn.nu);return{browser:m,os:g,deviceType:(n=m,i=e,r=(t=g).isiOS()&&!0===/ipad/i.test(i),o=t.isiOS()&&!r,s=t.isAndroid()&&3===t.version.major,a=t.isAndroid()&&4===t.version.major,l=r||s||a&&!0===/mobile/i.test(i),u=t.isiOS()||t.isAndroid(),c=u&&!l,d=n.isSafari()&&t.isiOS()&&!1===/safari/i.test(i),{isiPad:k(r),isiPhone:k(o),isTablet:k(l),isPhone:k(c),isTouch:k(u),isAndroid:t.isAndroid,isiOS:t.isiOS,isWebView:k(d)})}},Vn=(Vt=!(Ft=function(){var e=_.navigator.userAgent;return Un(e)}),function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Vt||(Vt=!0,Ut=Ft.apply(null,e)),Ut}),Yn=vn,$n=pn,qn=function(e){return e.nodeType!==Yn&&e.nodeType!==$n||0===e.childElementCount},Xn=(Vn().browser.isIE(),function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t]}("element","offset"),w.trim),jn=function(t){return function(e){if(e&&1===e.nodeType){if(e.contentEditable===t)return!0;if(e.getAttribute("data-mce-contenteditable")===t)return!0}return!1}},Jn=jn("true"),Gn=jn("false"),Kn=function(e,t,n,i,r){return{type:e,title:t,url:n,level:i,attach:r}},Zn=function(e){return e.innerText||e.textContent},Qn=function(e){return e.id?e.id:(t="h",n=(new Date).getTime(),t+"_"+Math.floor(1e9*Math.random())+ ++hn+String(n));var t,n},ei=function(e){return(t=e)&&"A"===t.nodeName&&(t.id||t.name)&&ni(e);var t},ti=function(e){return e&&/^(H[1-6])$/.test(e.nodeName)},ni=function(e){return function(e){for(;e=e.parentNode;){var t=e.contentEditable;if(t&&"inherit"!==t)return Jn(e)}return!1}(e)&&!Gn(e)},ii=function(e){return ti(e)&&ni(e)},ri=function(e){var t,n=Qn(e);return Kn("header",Zn(e),"#"+n,ti(t=e)?parseInt(t.nodeName.substr(1),10):0,function(){e.id=n})},oi=function(e){var t=e.id||e.name,n=Zn(e);return Kn("anchor",n||"#"+t,"#"+t,0,E)},si=function(e){var t,n,i,r,o,s;return t="h1,h2,h3,h4,h5,h6,a:not([href])",n=e,G((Vn().browser.isIE(),function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t]}("element","offset"),i=gn.fromDom(n),r=t,s=(o=i)===undefined?_.document:o.dom(),qn(s)?[]:G(s.querySelectorAll(r),gn.fromDom)),function(e){return e.dom()})},ai=function(e){return 0<Xn(e.title).length},li=function(e){var t,n=si(e);return Z((t=n,G(Z(t,ii),ri)).concat(G(Z(n,ei),oi)),ai)},ui={},ci=function(e){return{title:e.title,value:{title:{raw:e.title},url:e.url,attach:e.attach}}},di=function(e,t){return{title:e,value:{title:e,url:t,attach:E}}},fi=function(e,t,n){var i=t in e?e[t]:n;return!1===i?null:i},hi=function(e,i,r,t){var n,o,s,a,l,u,c={title:"-"},d=function(e){var t=e.hasOwnProperty(r)?e[r]:[],n=Z(t,function(e){return t=e,!J(i,function(e){return e.url===t});var t});return w.map(n,function(e){return{title:e,value:{title:e,url:e,attach:E}}})},f=function(t){var e,n=Z(i,function(e){return e.type===t});return e=n,w.map(e,ci)};return!1===t.typeahead_urls?[]:"file"===r?(n=[mi(e,d(ui)),mi(e,f("header")),mi(e,(a=f("anchor"),l=fi(t,"anchor_top","#top"),u=fi(t,"anchor_bottom","#bottom"),null!==l&&a.unshift(di("<top>",l)),null!==u&&a.push(di("<bottom>",u)),a))],o=function(e,t){return 0===e.length||0===t.length?e.concat(t):e.concat(c,t)},s=[],K(n,function(e){s=o(s,e)}),s):mi(e,d(ui))},mi=function(e,t){var n=e.toLowerCase(),i=w.grep(t,function(e){return-1!==e.title.toLowerCase().indexOf(n)});return 1===i.length&&i[0].title===e?[]:i},gi=function(r,i,o,s){var t=function(e){var t=li(o),n=hi(e,t,s,i);r.showAutoComplete(n,e)};r.on("autocomplete",function(){t(r.value())}),r.on("selectitem",function(e){var t=e.value;r.value(t.url);var n,i=(n=t.title).raw?n.raw:n;"image"===s?r.fire("change",{meta:{alt:i,attach:t.attach}}):r.fire("change",{meta:{text:i,attach:t.attach}}),r.focus()}),r.on("click",function(e){0===r.value().length&&"INPUT"===e.target.nodeName&&t("")}),r.on("PostRender",function(){r.getRoot().on("submit",function(e){var t,n,i;e.isDefaultPrevented()||(t=r.value(),i=ui[n=s],/^https?/.test(t)&&(i?j(i,t).isNone()&&(ui[n]=i.slice(0,5).concat(t)):ui[n]=[t]))})})},pi=function(o,e,n){var i=e.filepicker_validator_handler;i&&o.state.on("change:value",function(e){var t;0!==(t=e.value).length?i({url:t,type:n},function(e){var t,n,i,r=(n=(t=e).status,i=t.message,"valid"===n?{status:"ok",message:i}:"unknown"===n?{status:"warn",message:i}:"invalid"===n?{status:"warn",message:i}:{status:"none",message:""});o.statusMessage(r.message),o.statusLevel(r.status)}):o.statusLevel("none")})},vi=Qt.extend({Statics:{clearHistory:function(){ui={}}},init:function(e){var t,n,i,r=this,o=window.tinymce?window.tinymce.activeEditor:l.activeEditor,s=o.settings,a=e.filetype;e.spellcheck=!1,(i=s.file_picker_types||s.file_browser_callback_types)&&(i=w.makeMap(i,/[, ]/)),i&&!i[a]||(!(n=s.file_picker_callback)||i&&!i[a]?!(n=s.file_browser_callback)||i&&!i[a]||(t=function(){n(r.getEl("inp").id,r.value(),a,window)}):t=function(){var e=r.fire("beforecall").meta;e=w.extend({filetype:a},e),n.call(o,function(e,t){r.value(e).fire("change",{meta:t})},r.value(),e)}),t&&(e.icon="browse",e.onaction=t),r._super(e),r.classes.add("filepicker"),gi(r,s,o.getBody(),a),pi(r,s,a)}}),bi=Xt.extend({recalc:function(e){var t=e.layoutRect(),n=e.paddingBox;e.items().filter(":visible").each(function(e){e.layoutRect({x:n.left,y:n.top,w:t.innerW-n.right-n.left,h:t.innerH-n.top-n.bottom}),e.recalc&&e.recalc()})}}),yi=Xt.extend({recalc:function(e){var t,n,i,r,o,s,a,l,u,c,d,f,h,m,g,p,v,b,y,x,w,_,R,C,E,k,H,S,T,M,N,P,W,D,O,A,B,L=[],z=Math.max,I=Math.min;for(i=e.items().filter(":visible"),r=e.layoutRect(),o=e.paddingBox,s=e.settings,f=e.isRtl()?s.direction||"row-reversed":s.direction,a=s.align,l=e.isRtl()?s.pack||"end":s.pack,u=s.spacing||0,"row-reversed"!==f&&"column-reverse"!==f||(i=i.set(i.toArray().reverse()),f=f.split("-")[0]),"column"===f?(C="y",_="h",R="minH",E="maxH",H="innerH",k="top",S="deltaH",T="contentH",D="left",P="w",M="x",N="innerW",W="minW",O="right",A="deltaW",B="contentW"):(C="x",_="w",R="minW",E="maxW",H="innerW",k="left",S="deltaW",T="contentW",D="top",P="h",M="y",N="innerH",W="minH",O="bottom",A="deltaH",B="contentH"),d=r[H]-o[k]-o[k],w=c=0,t=0,n=i.length;t<n;t++)m=(h=i[t]).layoutRect(),d-=t<n-1?u:0,0<(g=h.settings.flex)&&(c+=g,m[E]&&L.push(h),m.flex=g),d-=m[R],w<(p=o[D]+m[W]+o[O])&&(w=p);if((y={})[R]=d<0?r[R]-d+r[S]:r[H]-d+r[S],y[W]=w+r[A],y[T]=r[H]-d,y[B]=w,y.minW=I(y.minW,r.maxW),y.minH=I(y.minH,r.maxH),y.minW=z(y.minW,r.startMinWidth),y.minH=z(y.minH,r.startMinHeight),!r.autoResize||y.minW===r.minW&&y.minH===r.minH){for(b=d/c,t=0,n=L.length;t<n;t++)(v=(m=(h=L[t]).layoutRect())[E])<(p=m[R]+m.flex*b)?(d-=m[E]-m[R],c-=m.flex,m.flex=0,m.maxFlexSize=v):m.maxFlexSize=0;for(b=d/c,x=o[k],y={},0===c&&("end"===l?x=d+o[k]:"center"===l?(x=Math.round(r[H]/2-(r[H]-d)/2)+o[k])<0&&(x=o[k]):"justify"===l&&(x=o[k],u=Math.floor(d/(i.length-1)))),y[M]=o[D],t=0,n=i.length;t<n;t++)p=(m=(h=i[t]).layoutRect()).maxFlexSize||m[R],"center"===a?y[M]=Math.round(r[N]/2-m[P]/2):"stretch"===a?(y[P]=z(m[W]||0,r[N]-o[D]-o[O]),y[M]=o[D]):"end"===a&&(y[M]=r[N]-m[P]-o.top),0<m.flex&&(p+=m.flex*b),y[_]=p,y[C]=x,h.layoutRect(y),h.recalc&&h.recalc(),x+=p+u}else if(y.w=y.minW,y.h=y.minH,e.layoutRect(y),this.recalc(e),null===e._lastRect){var F=e.parent();F&&(F._lastRect=null,F.recalc())}}}),xi=qt.extend({Defaults:{containerClass:"flow-layout",controlClass:"flow-layout-item",endClass:"break"},recalc:function(e){e.items().filter(":visible").each(function(e){e.recalc&&e.recalc()})},isNative:function(){return!0}}),wi=function(e,t){return n=t,r=(i=e)===undefined?_.document:i.dom(),qn(r)?N.none():N.from(r.querySelector(n)).map(gn.fromDom);var n,i,r},_i=function(e,t){return function(){e.execCommand("mceToggleFormat",!1,t)}},Ri=function(e,t,n){var i=function(e){n(e,t)};e.formatter?e.formatter.formatChanged(t,i):e.on("init",function(){e.formatter.formatChanged(t,i)})},Ci=function(e,n){return function(t){Ri(e,n,function(e){t.control.active(e)})}},Ei=function(i){var t=["alignleft","aligncenter","alignright","alignjustify"],r="alignleft",e=[{text:"Left",icon:"alignleft",onclick:_i(i,"alignleft")},{text:"Center",icon:"aligncenter",onclick:_i(i,"aligncenter")},{text:"Right",icon:"alignright",onclick:_i(i,"alignright")},{text:"Justify",icon:"alignjustify",onclick:_i(i,"alignjustify")}];i.addMenuItem("align",{text:"Align",menu:e}),i.addButton("align",{type:"menubutton",icon:r,menu:e,onShowMenu:function(e){var n=e.control.menu;w.each(t,function(t,e){n.items().eq(e).each(function(e){return e.active(i.formatter.match(t))})})},onPostRender:function(e){var n=e.control;w.each(t,function(t,e){Ri(i,t,function(e){n.icon(r),e&&n.icon(t)})})}}),w.each({alignleft:["Align left","JustifyLeft"],aligncenter:["Align center","JustifyCenter"],alignright:["Align right","JustifyRight"],alignjustify:["Justify","JustifyFull"],alignnone:["No alignment","JustifyNone"]},function(e,t){i.addButton(t,{active:!1,tooltip:e[0],cmd:e[1],onPostRender:Ci(i,t)})})},ki=function(e){return e?e.split(",")[0]:""},Hi=function(l,u){return function(){var a=this;a.state.set("value",null),l.on("init nodeChange",function(e){var t,n,i,r,o=l.queryCommandValue("FontName"),s=(t=u,r=(n=o)?n.toLowerCase():"",w.each(t,function(e){e.value.toLowerCase()===r&&(i=e.value)}),w.each(t,function(e){i||ki(e.value).toLowerCase()!==ki(r).toLowerCase()||(i=e.value)}),i);a.value(s||null),!s&&o&&a.text(ki(o))})}},Si=function(n){n.addButton("fontselect",function(){var e,t=(e=function(e){for(var t=(e=e.replace(/;$/,"").split(";")).length;t--;)e[t]=e[t].split("=");return e}(n.settings.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"),w.map(e,function(e){return{text:{raw:e[0]},value:e[1],textStyle:-1===e[1].indexOf("dings")?"font-family:"+e[1]:""}}));return{type:"listbox",text:"Font Family",tooltip:"Font Family",values:t,fixedWidth:!0,onPostRender:Hi(n,t),onselect:function(e){e.control.settings.value&&n.execCommand("FontName",!1,e.control.settings.value)}}})},Ti=function(e){Si(e)},Mi=function(e,t){return/[0-9.]+px$/.test(e)?(n=72*parseInt(e,10)/96,i=t||0,r=Math.pow(10,i),Math.round(n*r)/r+"pt"):e;var n,i,r},Ni=function(e,t,n){var i;return w.each(e,function(e){e.value===n?i=n:e.value===t&&(i=t)}),i},Pi=function(n){n.addButton("fontsizeselect",function(){var e,s,a,t=(e=n.settings.fontsize_formats||"8pt 10pt 12pt 14pt 18pt 24pt 36pt",w.map(e.split(" "),function(e){var t=e,n=e,i=e.split("=");return 1<i.length&&(t=i[0],n=i[1]),{text:t,value:n}}));return{type:"listbox",text:"Font Sizes",tooltip:"Font Sizes",values:t,fixedWidth:!0,onPostRender:(s=n,a=t,function(){var o=this;s.on("init nodeChange",function(e){var t,n,i,r;if(t=s.queryCommandValue("FontSize"))for(i=3;!r&&0<=i;i--)n=Mi(t,i),r=Ni(a,n,t);o.value(r||null),r||o.text(n)})}),onclick:function(e){e.control.settings.value&&n.execCommand("FontSize",!1,e.control.settings.value)}}})},Wi=function(e){Pi(e)},Di=function(n,e){var i=e.length;return w.each(e,function(e){e.menu&&(e.hidden=0===Di(n,e.menu));var t=e.format;t&&(e.hidden=!n.formatter.canApply(t)),e.hidden&&i--}),i},Oi=function(n,e){var i=e.items().length;return e.items().each(function(e){e.menu&&e.visible(0<Oi(n,e.menu)),!e.menu&&e.settings.menu&&e.visible(0<Di(n,e.settings.menu));var t=e.settings.format;t&&e.visible(n.formatter.canApply(t)),e.visible()||i--}),i},Ai=function(e){var i,r,o,t,s,n,a,l,u=(r=0,o=[],t=[{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"}]}],s=function(e){var i=[];if(e)return w.each(e,function(e){var t={text:e.title,icon:e.icon};if(e.items)t.menu=s(e.items);else{var n=e.format||"custom"+r++;e.format||(e.name=n,o.push(e)),t.format=n,t.cmd=e.cmd}i.push(t)}),i},(i=e).on("init",function(){w.each(o,function(e){i.formatter.register(e.name,e)})}),{type:"menu",items:i.settings.style_formats_merge?i.settings.style_formats?s(t.concat(i.settings.style_formats)):s(t):s(i.settings.style_formats||t),onPostRender:function(e){i.fire("renderFormatsMenu",{control:e.control})},itemDefaults:{preview:!0,textStyle:function(){if(this.settings.format)return i.formatter.getCssText(this.settings.format)},onPostRender:function(){var n=this;n.parent().on("show",function(){var e,t;(e=n.settings.format)&&(n.disabled(!i.formatter.canApply(e)),n.active(i.formatter.match(e))),(t=n.settings.cmd)&&n.active(i.queryCommandState(t))})},onclick:function(){this.settings.format&&_i(i,this.settings.format)(),this.settings.cmd&&i.execCommand(this.settings.cmd)}}});n=u,e.addMenuItem("formats",{text:"Formats",menu:n}),l=u,(a=e).addButton("styleselect",{type:"menubutton",text:"Formats",menu:l,onShowMenu:function(){a.settings.style_formats_autohide&&Oi(a,this.menu)}})},Bi=function(n,e){return function(){var r,o,s,t=[];return w.each(e,function(e){t.push({text:e[0],value:e[1],textStyle:function(){return n.formatter.getCssText(e[1])}})}),{type:"listbox",text:e[0][0],values:t,fixedWidth:!0,onselect:function(e){if(e.control){var t=e.control.value();_i(n,t)()}},onPostRender:(r=n,o=t,function(){var t=this;r.on("nodeChange",function(e){var n=r.formatter,i=null;w.each(e.parents,function(t){if(w.each(o,function(e){if(s?n.matchNode(t,s,{value:e.value})&&(i=e.value):n.matchNode(t,e.value)&&(i=e.value),i)return!1}),i)return!1}),t.value(i)})})}}},Li=function(e){var t,n,i=function(e){for(var t=(e=e.replace(/;$/,"").split(";")).length;t--;)e[t]=e[t].split("=");return e}(e.settings.block_formats||"Paragraph=p;Heading 1=h1;Heading 2=h2;Heading 3=h3;Heading 4=h4;Heading 5=h5;Heading 6=h6;Preformatted=pre");e.addMenuItem("blockformats",{text:"Blocks",menu:(t=e,n=i,w.map(n,function(e){return{text:e[0],onclick:_i(t,e[1]),textStyle:function(){return t.formatter.getCssText(e[1])}}}))}),e.addButton("formatselect",Bi(e,i))},zi=function(t,e){var n,i;if("string"==typeof e)i=e.split(" ");else if(w.isArray(e))return function(e){for(var t=[],n=0,i=e.length;n<i;++n){if(!V(e[n]))throw new Error("Arr.flatten item "+n+" was not an array, input: "+e);X.apply(t,e[n])}return t}(w.map(e,function(e){return zi(t,e)}));return n=w.grep(i,function(e){return"|"===e||e in t.menuItems}),w.map(n,function(e){return"|"===e?{text:"-"}:t.menuItems[e]})},Ii=function(e){return e&&"-"===e.text},Fi=function(n){var i=Z(n,function(e,t){return!Ii(e)||!Ii(n[t-1])});return Z(i,function(e,t){return!Ii(e)||0<t&&t<i.length-1})},Ui=function(e){var t,n,i,r,o=e.settings.insert_button_items;return Fi(o?zi(e,o):(t=e,n="insert",i=[{text:"-"}],r=w.grep(t.menuItems,function(e){return e.context===n}),w.each(r,function(e){"before"===e.separator&&i.push({text:"|"}),e.prependToContext?i.unshift(e):i.push(e),"after"===e.separator&&i.push({text:"|"})}),i))},Vi=function(e){var t;(t=e).addButton("insert",{type:"menubutton",icon:"insert",menu:[],oncreatemenu:function(){this.menu.add(Ui(t)),this.menu.renderNew()}})},Yi=function(e){var n,i,r;n=e,w.each({bold:"Bold",italic:"Italic",underline:"Underline",strikethrough:"Strikethrough",subscript:"Subscript",superscript:"Superscript"},function(e,t){n.addButton(t,{active:!1,tooltip:e,onPostRender:Ci(n,t),onclick:_i(n,t)})}),i=e,w.each({outdent:["Decrease indent","Outdent"],indent:["Increase indent","Indent"],cut:["Cut","Cut"],copy:["Copy","Copy"],paste:["Paste","Paste"],help:["Help","mceHelp"],selectall:["Select all","SelectAll"],visualaid:["Visual aids","mceToggleVisualAid"],newdocument:["New document","mceNewDocument"],removeformat:["Clear formatting","RemoveFormat"],remove:["Remove","Delete"]},function(e,t){i.addButton(t,{tooltip:e[0],cmd:e[1]})}),r=e,w.each({blockquote:["Blockquote","mceBlockQuote"],subscript:["Subscript","Subscript"],superscript:["Superscript","Superscript"]},function(e,t){r.addButton(t,{active:!1,tooltip:e[0],cmd:e[1],onPostRender:Ci(r,t)})})},$i=function(e){var n;Yi(e),n=e,w.each({bold:["Bold","Bold","Meta+B"],italic:["Italic","Italic","Meta+I"],underline:["Underline","Underline","Meta+U"],strikethrough:["Strikethrough","Strikethrough"],subscript:["Subscript","Subscript"],superscript:["Superscript","Superscript"],removeformat:["Clear formatting","RemoveFormat"],newdocument:["New document","mceNewDocument"],cut:["Cut","Cut","Meta+X"],copy:["Copy","Copy","Meta+C"],paste:["Paste","Paste","Meta+V"],selectall:["Select all","SelectAll","Meta+A"]},function(e,t){n.addMenuItem(t,{text:e[0],icon:t,shortcut:e[2],cmd:e[1]})}),n.addMenuItem("codeformat",{text:"Code",icon:"code",onclick:_i(n,"code")})},qi=function(n,i){return function(){var e=this,t=function(){var e="redo"===i?"hasRedo":"hasUndo";return!!n.undoManager&&n.undoManager[e]()};e.disabled(!t()),n.on("Undo Redo AddUndo TypingUndo ClearUndos SwitchMode",function(){e.disabled(n.readonly||!t())})}},Xi=function(e){var t,n;(t=e).addMenuItem("undo",{text:"Undo",icon:"undo",shortcut:"Meta+Z",onPostRender:qi(t,"undo"),cmd:"undo"}),t.addMenuItem("redo",{text:"Redo",icon:"redo",shortcut:"Meta+Y",onPostRender:qi(t,"redo"),cmd:"redo"}),(n=e).addButton("undo",{tooltip:"Undo",onPostRender:qi(n,"undo"),cmd:"undo"}),n.addButton("redo",{tooltip:"Redo",onPostRender:qi(n,"redo"),cmd:"redo"})},ji=function(e){var t,n;(t=e).addMenuItem("visualaid",{text:"Visual aids",selectable:!0,onPostRender:(n=t,function(){var t=this;n.on("VisualAid",function(e){t.active(e.hasVisual)}),t.active(n.hasVisual)}),cmd:"mceToggleVisualAid"})},Ji={setup:function(e){var t;e.rtl&&(rt.rtl=!0),e.on("mousedown progressstate",function(){Ct.hideAll()}),(t=e).settings.ui_container&&(ce.container=wi(gn.fromDom(_.document.body),t.settings.ui_container).fold(k(null),function(e){return e.dom()})),Nt.tooltips=!ce.iOS,rt.translate=function(e){return l.translate(e)},Li(e),Ei(e),$i(e),Xi(e),Wi(e),Ti(e),Ai(e),ji(e),Vi(e)}},Gi=Xt.extend({recalc:function(e){var t,n,i,r,o,s,a,l,u,c,d,f,h,m,g,p,v,b,y,x,w,_,R,C,E,k,H,S,T=[],M=[];t=e.settings,r=e.items().filter(":visible"),o=e.layoutRect(),i=t.columns||Math.ceil(Math.sqrt(r.length)),n=Math.ceil(r.length/i),b=t.spacingH||t.spacing||0,y=t.spacingV||t.spacing||0,x=t.alignH||t.align,w=t.alignV||t.align,p=e.paddingBox,S="reverseRows"in t?t.reverseRows:e.isRtl(),x&&"string"==typeof x&&(x=[x]),w&&"string"==typeof w&&(w=[w]);for(d=0;d<i;d++)T.push(0);for(f=0;f<n;f++)M.push(0);for(f=0;f<n;f++)for(d=0;d<i&&(c=r[f*i+d]);d++)C=(u=c.layoutRect()).minW,E=u.minH,T[d]=C>T[d]?C:T[d],M[f]=E>M[f]?E:M[f];for(k=o.innerW-p.left-p.right,d=_=0;d<i;d++)_+=T[d]+(0<d?b:0),k-=(0<d?b:0)+T[d];for(H=o.innerH-p.top-p.bottom,f=R=0;f<n;f++)R+=M[f]+(0<f?y:0),H-=(0<f?y:0)+M[f];if(_+=p.left+p.right,R+=p.top+p.bottom,(l={}).minW=_+(o.w-o.innerW),l.minH=R+(o.h-o.innerH),l.contentW=l.minW-o.deltaW,l.contentH=l.minH-o.deltaH,l.minW=Math.min(l.minW,o.maxW),l.minH=Math.min(l.minH,o.maxH),l.minW=Math.max(l.minW,o.startMinWidth),l.minH=Math.max(l.minH,o.startMinHeight),!o.autoResize||l.minW===o.minW&&l.minH===o.minH){var N;o.autoResize&&((l=e.layoutRect(l)).contentW=l.minW-o.deltaW,l.contentH=l.minH-o.deltaH),N="start"===t.packV?0:0<H?Math.floor(H/n):0;var P=0,W=t.flexWidths;if(W)for(d=0;d<W.length;d++)P+=W[d];else P=i;var D=k/P;for(d=0;d<i;d++)T[d]+=W?W[d]*D:D;for(m=p.top,f=0;f<n;f++){for(h=p.left,a=M[f]+N,d=0;d<i&&(c=r[S?f*i+i-1-d:f*i+d]);d++)g=c.settings,u=c.layoutRect(),s=Math.max(T[d],u.startMinWidth),u.x=h,u.y=m,"center"===(v=g.alignH||(x?x[d]||x[0]:null))?u.x=h+s/2-u.w/2:"right"===v?u.x=h+s-u.w:"stretch"===v&&(u.w=s),"center"===(v=g.alignV||(w?w[d]||w[0]:null))?u.y=m+a/2-u.h/2:"bottom"===v?u.y=m+a-u.h:"stretch"===v&&(u.h=a),c.layoutRect(u),h+=s+b,c.recalc&&c.recalc();m+=a+y}}else if(l.w=l.minW,l.h=l.minH,e.layoutRect(l),this.recalc(e),null===e._lastRect){var O=e.parent();O&&(O._lastRect=null,O.recalc())}}}),Ki=Nt.extend({renderHtml:function(){var e=this;return e.classes.add("iframe"),e.canFocus=!1,'<iframe id="'+e._id+'" class="'+e.classes+'" tabindex="-1" src="'+(e.settings.url||"javascript:''")+'" frameborder="0"></iframe>'},src:function(e){this.getEl().src=e},html:function(e,t){var n=this,i=this.getEl().contentWindow.document.body;return i?(i.innerHTML=e,t&&t()):u.setTimeout(function(){n.html(e)}),this}}),Zi=Nt.extend({init:function(e){this._super(e),this.classes.add("widget").add("infobox"),this.canFocus=!1},severity:function(e){this.classes.remove("error"),this.classes.remove("warning"),this.classes.remove("success"),this.classes.add(e)},help:function(e){this.state.set("help",e)},renderHtml:function(){var e=this,t=e.classPrefix;return'<div id="'+e._id+'" class="'+e.classes+'"><div id="'+e._id+'-body">'+e.encode(e.state.get("text"))+'<button role="button" tabindex="-1"><i class="'+t+"ico "+t+'i-help"></i></button></div></div>'},bindStates:function(){var t=this;return t.state.on("change:text",function(e){t.getEl("body").firstChild.data=t.encode(e.value),t.state.get("rendered")&&t.updateLayoutRect()}),t.state.on("change:help",function(e){t.classes.toggle("has-help",e.value),t.state.get("rendered")&&t.updateLayoutRect()}),t._super()}}),Qi=Nt.extend({init:function(e){var t=this;t._super(e),t.classes.add("widget").add("label"),t.canFocus=!1,e.multiline&&t.classes.add("autoscroll"),e.strong&&t.classes.add("strong")},initLayoutRect:function(){var e=this,t=e._super();return e.settings.multiline&&(we.getSize(e.getEl()).width>t.maxW&&(t.minW=t.maxW,e.classes.add("multiline")),e.getEl().style.width=t.minW+"px",t.startMinH=t.h=t.minH=Math.min(t.maxH,we.getSize(e.getEl()).height)),t},repaint:function(){return this.settings.multiline||(this.getEl().style.lineHeight=this.layoutRect().h+"px"),this._super()},severity:function(e){this.classes.remove("error"),this.classes.remove("warning"),this.classes.remove("success"),this.classes.add(e)},renderHtml:function(){var e,t,n=this,i=n.settings.forId,r=n.settings.html?n.settings.html:n.encode(n.state.get("text"));return!i&&(t=n.settings.forName)&&(e=n.getRoot().find("#"+t)[0])&&(i=e._id),i?'<label id="'+n._id+'" class="'+n.classes+'"'+(i?' for="'+i+'"':"")+">"+r+"</label>":'<span id="'+n._id+'" class="'+n.classes+'">'+r+"</span>"},bindStates:function(){var t=this;return t.state.on("change:text",function(e){t.innerHtml(t.encode(e.value)),t.state.get("rendered")&&t.updateLayoutRect()}),t._super()}}),er=lt.extend({Defaults:{role:"toolbar",layout:"flow"},init:function(e){this._super(e),this.classes.add("toolbar")},postRender:function(){return this.items().each(function(e){e.classes.add("toolbar-item")}),this._super()}}),tr=er.extend({Defaults:{role:"menubar",containerCls:"menubar",ariaRoot:!0,defaults:{type:"menubutton"}}}),nr=jt.extend({init:function(e){var t=this;t._renderOpen=!0,t._super(e),e=t.settings,t.classes.add("menubtn"),e.fixedWidth&&t.classes.add("fixed-width"),t.aria("haspopup",!0),t.state.set("menu",e.menu||t.render())},showMenu:function(e){var t,n=this;if(n.menu&&n.menu.visible()&&!1!==e)return n.hideMenu();n.menu||(t=n.state.get("menu")||[],n.classes.add("opened"),t.length?t={type:"menu",animate:!0,items:t}:(t.type=t.type||"menu",t.animate=!0),t.renderTo?n.menu=t.parent(n).show().renderTo():n.menu=v.create(t).parent(n).renderTo(),n.fire("createmenu"),n.menu.reflow(),n.menu.on("cancel",function(e){e.control.parent()===n.menu&&(e.stopPropagation(),n.focus(),n.hideMenu())}),n.menu.on("select",function(){n.focus()}),n.menu.on("show hide",function(e){"hide"===e.type&&e.control.parent()===n&&n.classes.remove("opened-under"),e.control===n.menu&&(n.activeMenu("show"===e.type),n.classes.toggle("opened","show"===e.type)),n.aria("expanded","show"===e.type)}).fire("show")),n.menu.show(),n.menu.layoutRect({w:n.layoutRect().w}),n.menu.repaint(),n.menu.moveRel(n.getEl(),n.isRtl()?["br-tr","tr-br"]:["bl-tl","tl-bl"]);var i=n.menu.layoutRect(),r=n.$el.offset().top+n.layoutRect().h;r>i.y&&r<i.y+i.h&&n.classes.add("opened-under"),n.fire("showmenu")},hideMenu:function(){this.menu&&(this.menu.items().each(function(e){e.hideMenu&&e.hideMenu()}),this.menu.hide())},activeMenu:function(e){this.classes.toggle("active",e)},renderHtml:function(){var e,t=this,n=t._id,i=t.classPrefix,r=t.settings.icon,o=t.state.get("text"),s="";return(e=t.settings.image)?(r="none","string"!=typeof e&&(e=_.window.getSelection?e[0]:e[1]),e=" style=\"background-image: url('"+e+"')\""):e="",o&&(t.classes.add("btn-has-text"),s='<span class="'+i+'txt">'+t.encode(o)+"</span>"),r=t.settings.icon?i+"ico "+i+"i-"+r:"",t.aria("role",t.parent()instanceof tr?"menuitem":"button"),'<div id="'+n+'" class="'+t.classes+'" tabindex="-1" aria-labelledby="'+n+'"><button id="'+n+'-open" role="presentation" type="button" tabindex="-1">'+(r?'<i class="'+r+'"'+e+"></i>":"")+s+' <i class="'+i+'caret"></i></button></div>'},postRender:function(){var r=this;return r.on("click",function(e){e.control===r&&function(e,t){for(;e;){if(t===e)return!0;e=e.parentNode}return!1}(e.target,r.getEl())&&(r.focus(),r.showMenu(!e.aria),e.aria&&r.menu.items().filter(":visible")[0].focus())}),r.on("mouseenter",function(e){var t,n=e.control,i=r.parent();n&&i&&n instanceof nr&&n.parent()===i&&(i.items().filter("MenuButton").each(function(e){e.hideMenu&&e!==n&&(e.menu&&e.menu.visible()&&(t=!0),e.hideMenu())}),t&&(n.focus(),n.showMenu()))}),r._super()},bindStates:function(){var e=this;return e.state.on("change:menu",function(){e.menu&&e.menu.remove(),e.menu=null}),e._super()},remove:function(){this._super(),this.menu&&this.menu.remove()}}),ir=Ct.extend({Defaults:{defaultType:"menuitem",border:1,layout:"stack",role:"application",bodyRole:"menu",ariaRoot:!0},init:function(e){if(e.autohide=!0,e.constrainToViewport=!0,"function"==typeof e.items&&(e.itemsFactory=e.items,e.items=[]),e.itemDefaults)for(var t=e.items,n=t.length;n--;)t[n]=w.extend({},e.itemDefaults,t[n]);this._super(e),this.classes.add("menu"),e.animate&&11!==ce.ie&&this.classes.add("animate")},repaint:function(){return this.classes.toggle("menu-align",!0),this._super(),this.getEl().style.height="",this.getEl("body").style.height="",this},cancel:function(){this.hideAll(),this.fire("select")},load:function(){var t,n=this;function i(){n.throbber&&(n.throbber.hide(),n.throbber=null)}n.settings.itemsFactory&&(n.throbber||(n.throbber=new Ht(n.getEl("body"),!0),0===n.items().length?(n.throbber.show(),n.fire("loading")):n.throbber.show(100,function(){n.items().remove(),n.fire("loading")}),n.on("hide close",i)),n.requestTime=t=(new Date).getTime(),n.settings.itemsFactory(function(e){0!==e.length?n.requestTime===t&&(n.getEl().style.width="",n.getEl("body").style.width="",i(),n.items().remove(),n.getEl("body").innerHTML="",n.add(e),n.renderNew(),n.fire("loaded")):n.hide()}))},hideAll:function(){return this.find("menuitem").exec("hideMenu"),this._super()},preRender:function(){var n=this;return n.items().each(function(e){var t=e.settings;if(t.icon||t.image||t.selectable)return!(n._hasIcons=!0)}),n.settings.itemsFactory&&n.on("postrender",function(){n.settings.itemsFactory&&n.load()}),n.on("show hide",function(e){e.control===n&&("show"===e.type?u.setTimeout(function(){n.classes.add("in")},0):n.classes.remove("in"))}),n._super()}}),rr=nr.extend({init:function(i){var t,r,o,n,s=this;s._super(i),i=s.settings,s._values=t=i.values,t&&("undefined"!=typeof i.value&&function e(t){for(var n=0;n<t.length;n++){if(r=t[n].selected||i.value===t[n].value)return o=o||t[n].text,s.state.set("value",t[n].value),!0;if(t[n].menu&&e(t[n].menu))return!0}}(t),!r&&0<t.length&&(o=t[0].text,s.state.set("value",t[0].value)),s.state.set("menu",t)),s.state.set("text",i.text||o),s.classes.add("listbox"),s.on("select",function(e){var t=e.control;n&&(e.lastControl=n),i.multiple?t.active(!t.active()):s.value(e.control.value()),n=t})},value:function(n){return 0===arguments.length?this.state.get("value"):(void 0===n||(this.settings.values&&!function t(e){return J(e,function(e){return e.menu?t(e.menu):e.value===n})}(this.settings.values)?null===n&&this.state.set("value",null):this.state.set("value",n)),this)},bindStates:function(){var i=this;return i.on("show",function(e){var t,n;t=e.control,n=i.value(),t instanceof ir&&t.items().each(function(e){e.hasMenus()||e.active(e.value()===n)})}),i.state.on("change:value",function(t){var n=function e(t,n){var i;if(t)for(var r=0;r<t.length;r++){if(t[r].value===n)return t[r];if(t[r].menu&&(i=e(t[r].menu,n)))return i}}(i.state.get("menu"),t.value);n?i.text(n.text):i.text(i.settings.text)}),i._super()}}),or=Nt.extend({Defaults:{border:0,role:"menuitem"},init:function(e){var t,n=this;n._super(e),e=n.settings,n.classes.add("menu-item"),e.menu&&n.classes.add("menu-item-expand"),e.preview&&n.classes.add("menu-item-preview"),"-"!==(t=n.state.get("text"))&&"|"!==t||(n.classes.add("menu-item-sep"),n.aria("role","separator"),n.state.set("text","-")),e.selectable&&(n.aria("role","menuitemcheckbox"),n.classes.add("menu-item-checkbox"),e.icon="selected"),e.preview||e.selectable||n.classes.add("menu-item-normal"),n.on("mousedown",function(e){e.preventDefault()}),e.menu&&!e.ariaHideMenu&&n.aria("haspopup",!0)},hasMenus:function(){return!!this.settings.menu},showMenu:function(){var t,n=this,e=n.settings,i=n.parent();if(i.items().each(function(e){e!==n&&e.hideMenu()}),e.menu){(t=n.menu)?t.show():((t=e.menu).length?t={type:"menu",items:t}:t.type=t.type||"menu",i.settings.itemDefaults&&(t.itemDefaults=i.settings.itemDefaults),(t=n.menu=v.create(t).parent(n).renderTo()).reflow(),t.on("cancel",function(e){e.stopPropagation(),n.focus(),t.hide()}),t.on("show hide",function(e){e.control.items&&e.control.items().each(function(e){e.active(e.settings.selected)})}).fire("show"),t.on("hide",function(e){e.control===t&&n.classes.remove("selected")}),t.submenu=!0),t._parentMenu=i,t.classes.add("menu-sub");var r=t.testMoveRel(n.getEl(),n.isRtl()?["tl-tr","bl-br","tr-tl","br-bl"]:["tr-tl","br-bl","tl-tr","bl-br"]);t.moveRel(n.getEl(),r),r="menu-sub-"+(t.rel=r),t.classes.remove(t._lastRel).add(r),t._lastRel=r,n.classes.add("selected"),n.aria("expanded",!0)}},hideMenu:function(){var e=this;return e.menu&&(e.menu.items().each(function(e){e.hideMenu&&e.hideMenu()}),e.menu.hide(),e.aria("expanded",!1)),e},renderHtml:function(){var e,t=this,n=t._id,i=t.settings,r=t.classPrefix,o=t.state.get("text"),s=t.settings.icon,a="",l=i.shortcut,u=t.encode(i.url);function c(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function d(e){var t=i.match||"";return t?e.replace(new RegExp(c(t),"gi"),function(e){return"!mce~match["+e+"]mce~match!"}):e}function f(e){return e.replace(new RegExp(c("!mce~match["),"g"),"<b>").replace(new RegExp(c("]mce~match!"),"g"),"</b>")}return s&&t.parent().classes.add("menu-has-icons"),i.image&&(a=" style=\"background-image: url('"+i.image+"')\""),l&&(l=function(e){var t,n,i={};for(i=ce.mac?{alt:"&#x2325;",ctrl:"&#x2318;",shift:"&#x21E7;",meta:"&#x2318;"}:{meta:"Ctrl"},e=e.split("+"),t=0;t<e.length;t++)(n=i[e[t].toLowerCase()])&&(e[t]=n);return e.join("+")}(l)),s=r+"ico "+r+"i-"+(t.settings.icon||"none"),e="-"!==o?'<i class="'+s+'"'+a+"></i>\xa0":"",o=f(t.encode(d(o))),u=f(t.encode(d(u))),'<div id="'+n+'" class="'+t.classes+'" tabindex="-1">'+e+("-"!==o?'<span id="'+n+'-text" class="'+r+'text">'+o+"</span>":"")+(l?'<div id="'+n+'-shortcut" class="'+r+'menu-shortcut">'+l+"</div>":"")+(i.menu?'<div class="'+r+'caret"></div>':"")+(u?'<div class="'+r+'menu-item-link">'+u+"</div>":"")+"</div>"},postRender:function(){var t=this,n=t.settings,e=n.textStyle;if("function"==typeof e&&(e=e.call(this)),e){var i=t.getEl("text");i&&(i.setAttribute("style",e),t._textStyle=e)}return t.on("mouseenter click",function(e){e.control===t&&(n.menu||"click"!==e.type?(t.showMenu(),e.aria&&t.menu.focus(!0)):(t.fire("select"),u.requestAnimationFrame(function(){t.parent().hideAll()})))}),t._super(),t},hover:function(){return this.parent().items().each(function(e){e.classes.remove("selected")}),this.classes.toggle("selected",!0),this},active:function(e){return function(e,t){var n=e._textStyle;if(n){var i=e.getEl("text");i.setAttribute("style",n),t&&(i.style.color="",i.style.backgroundColor="")}}(this,e),void 0!==e&&this.aria("checked",e),this._super(e)},remove:function(){this._super(),this.menu&&this.menu.remove()}}),sr=Kt.extend({Defaults:{classes:"radio",role:"radio"}}),ar=Nt.extend({renderHtml:function(){var e=this,t=e.classPrefix;return e.classes.add("resizehandle"),"both"===e.settings.direction&&e.classes.add("resizehandle-both"),e.canFocus=!1,'<div id="'+e._id+'" class="'+e.classes+'"><i class="'+t+"ico "+t+'i-resize"></i></div>'},postRender:function(){var t=this;t._super(),t.resizeDragHelper=new ct(this._id,{start:function(){t.fire("ResizeStart")},drag:function(e){"both"!==t.settings.direction&&(e.deltaX=0),t.fire("Resize",e)},stop:function(){t.fire("ResizeEnd")}})},remove:function(){return this.resizeDragHelper&&this.resizeDragHelper.destroy(),this._super()}});function lr(e){var t="";if(e)for(var n=0;n<e.length;n++)t+='<option value="'+e[n]+'">'+e[n]+"</option>";return t}var ur=Nt.extend({Defaults:{classes:"selectbox",role:"selectbox",options:[]},init:function(e){var n=this;n._super(e),n.settings.size&&(n.size=n.settings.size),n.settings.options&&(n._options=n.settings.options),n.on("keydown",function(e){var t;13===e.keyCode&&(e.preventDefault(),n.parents().reverse().each(function(e){if(e.toJSON)return t=e,!1}),n.fire("submit",{data:t.toJSON()}))})},options:function(e){return arguments.length?(this.state.set("options",e),this):this.state.get("options")},renderHtml:function(){var e,t=this,n="";return e=lr(t._options),t.size&&(n=' size = "'+t.size+'"'),'<select id="'+t._id+'" class="'+t.classes+'"'+n+">"+e+"</select>"},bindStates:function(){var t=this;return t.state.on("change:options",function(e){t.getEl().innerHTML=lr(e.value)}),t._super()}});function cr(e,t,n){return e<t&&(e=t),n<e&&(e=n),e}function dr(e,t,n){e.setAttribute("aria-"+t,n)}function fr(e,t){var n,i,r,o,s;"v"===e.settings.orientation?(r="top",i="height",n="h"):(r="left",i="width",n="w"),s=e.getEl("handle"),o=((e.layoutRect()[n]||100)-we.getSize(s)[i])*((t-e._minValue)/(e._maxValue-e._minValue))+"px",s.style[r]=o,s.style.height=e.layoutRect().h+"px",dr(s,"valuenow",t),dr(s,"valuetext",""+e.settings.previewFilter(t)),dr(s,"valuemin",e._minValue),dr(s,"valuemax",e._maxValue)}var hr=Nt.extend({init:function(e){var t=this;e.previewFilter||(e.previewFilter=function(e){return Math.round(100*e)/100}),t._super(e),t.classes.add("slider"),"v"===e.orientation&&t.classes.add("vertical"),t._minValue=$(e.minValue)?e.minValue:0,t._maxValue=$(e.maxValue)?e.maxValue:100,t._initValue=t.state.get("value")},renderHtml:function(){var e=this._id,t=this.classPrefix;return'<div id="'+e+'" class="'+this.classes+'"><div id="'+e+'-handle" class="'+t+'slider-handle" role="slider" tabindex="-1"></div></div>'},reset:function(){this.value(this._initValue).repaint()},postRender:function(){var e,t,n,i,r,o,s,a,l,u,c,d,f,h,m=this;e=m._minValue,t=m._maxValue,"v"===m.settings.orientation?(n="screenY",i="top",r="height",o="h"):(n="screenX",i="left",r="width",o="w"),m._super(),function(o,s){function t(e){var t,n,i,r;t=cr(t=(((t=m.value())+(r=n=o))/((i=s)-r)+.05*e)*(i-n)-n,o,s),m.value(t),m.fire("dragstart",{value:t}),m.fire("drag",{value:t}),m.fire("dragend",{value:t})}m.on("keydown",function(e){switch(e.keyCode){case 37:case 38:t(-1);break;case 39:case 40:t(1)}})}(e,t),s=e,a=t,l=m.getEl("handle"),m._dragHelper=new ct(m._id,{handle:m._id+"-handle",start:function(e){u=e[n],c=parseInt(m.getEl("handle").style[i],10),d=(m.layoutRect()[o]||100)-we.getSize(l)[r],m.fire("dragstart",{value:h})},drag:function(e){var t=e[n]-u;f=cr(c+t,0,d),l.style[i]=f+"px",h=s+f/d*(a-s),m.value(h),m.tooltip().text(""+m.settings.previewFilter(h)).show().moveRel(l,"bc tc"),m.fire("drag",{value:h})},stop:function(){m.tooltip().hide(),m.fire("dragend",{value:h})}})},repaint:function(){this._super(),fr(this,this.value())},bindStates:function(){var t=this;return t.state.on("change:value",function(e){fr(t,e.value)}),t._super()}}),mr=Nt.extend({renderHtml:function(){return this.classes.add("spacer"),this.canFocus=!1,'<div id="'+this._id+'" class="'+this.classes+'"></div>'}}),gr=nr.extend({Defaults:{classes:"widget btn splitbtn",role:"button"},repaint:function(){var e,t,n=this.getEl(),i=this.layoutRect();return this._super(),e=n.firstChild,t=n.lastChild,ye(e).css({width:i.w-we.getSize(t).width,height:i.h-2}),ye(t).css({height:i.h-2}),this},activeMenu:function(e){ye(this.getEl().lastChild).toggleClass(this.classPrefix+"active",e)},renderHtml:function(){var e,t,n=this,i=n._id,r=n.classPrefix,o=n.state.get("icon"),s=n.state.get("text"),a=n.settings,l="";return(e=a.image)?(o="none","string"!=typeof e&&(e=_.window.getSelection?e[0]:e[1]),e=" style=\"background-image: url('"+e+"')\""):e="",o=a.icon?r+"ico "+r+"i-"+o:"",s&&(n.classes.add("btn-has-text"),l='<span class="'+r+'txt">'+n.encode(s)+"</span>"),t="boolean"==typeof a.active?' aria-pressed="'+a.active+'"':"",'<div id="'+i+'" class="'+n.classes+'" role="button"'+t+' tabindex="-1"><button type="button" hidefocus="1" tabindex="-1">'+(o?'<i class="'+o+'"'+e+"></i>":"")+l+'</button><button type="button" class="'+r+'open" hidefocus="1" tabindex="-1">'+(n._menuBtnText?(o?"\xa0":"")+n._menuBtnText:"")+' <i class="'+r+'caret"></i></button></div>'},postRender:function(){var n=this.settings.onclick;return this.on("click",function(e){var t=e.target;if(e.control===this)for(;t;){if(e.aria&&"down"!==e.aria.key||"BUTTON"===t.nodeName&&-1===t.className.indexOf("open"))return e.stopImmediatePropagation(),void(n&&n.call(this,e));t=t.parentNode}}),delete this.settings.onclick,this._super()}}),pr=xi.extend({Defaults:{containerClass:"stack-layout",controlClass:"stack-layout-item",endClass:"break"},isNative:function(){return!0}}),vr=pt.extend({Defaults:{layout:"absolute",defaults:{type:"panel"}},activateTab:function(n){var e;this.activeTabId&&(e=this.getEl(this.activeTabId),ye(e).removeClass(this.classPrefix+"active"),e.setAttribute("aria-selected","false")),this.activeTabId="t"+n,(e=this.getEl("t"+n)).setAttribute("aria-selected","true"),ye(e).addClass(this.classPrefix+"active"),this.items()[n].show().fire("showtab"),this.reflow(),this.items().each(function(e,t){n!==t&&e.hide()})},renderHtml:function(){var i=this,e=i._layout,r="",o=i.classPrefix;return i.preRender(),e.preRender(i),i.items().each(function(e,t){var n=i._id+"-t"+t;e.aria("role","tabpanel"),e.aria("labelledby",n),r+='<div id="'+n+'" class="'+o+'tab" unselectable="on" role="tab" aria-controls="'+e._id+'" aria-selected="false" tabIndex="-1">'+i.encode(e.settings.title)+"</div>"}),'<div id="'+i._id+'" class="'+i.classes+'" hidefocus="1" tabindex="-1"><div id="'+i._id+'-head" class="'+o+'tabs" role="tablist">'+r+'</div><div id="'+i._id+'-body" class="'+i.bodyClasses+'">'+e.renderHtml(i)+"</div></div>"},postRender:function(){var i=this;i._super(),i.settings.activeTab=i.settings.activeTab||0,i.activateTab(i.settings.activeTab),this.on("click",function(e){var t=e.target.parentNode;if(t&&t.id===i._id+"-head")for(var n=t.childNodes.length;n--;)t.childNodes[n]===e.target&&i.activateTab(n)})},initLayoutRect:function(){var e,t,n,i=this;t=(t=we.getSize(i.getEl("head")).width)<0?0:t,n=0,i.items().each(function(e){t=Math.max(t,e.layoutRect().minW),n=Math.max(n,e.layoutRect().minH)}),i.items().each(function(e){e.settings.x=0,e.settings.y=0,e.settings.w=t,e.settings.h=n,e.layoutRect({x:0,y:0,w:t,h:n})});var r=we.getSize(i.getEl("head")).height;return i.settings.minWidth=t,i.settings.minHeight=n+r,(e=i._super()).deltaH+=r,e.innerH=e.h-e.deltaH,e}}),br=Nt.extend({init:function(e){var n=this;n._super(e),n.classes.add("textbox"),e.multiline?n.classes.add("multiline"):(n.on("keydown",function(e){var t;13===e.keyCode&&(e.preventDefault(),n.parents().reverse().each(function(e){if(e.toJSON)return t=e,!1}),n.fire("submit",{data:t.toJSON()}))}),n.on("keyup",function(e){n.state.set("value",e.target.value)}))},repaint:function(){var e,t,n,i,r,o=this,s=0;e=o.getEl().style,t=o._layoutRect,r=o._lastRepaintRect||{};var a=_.document;return!o.settings.multiline&&a.all&&(!a.documentMode||a.documentMode<=8)&&(e.lineHeight=t.h-s+"px"),i=(n=o.borderBox).left+n.right+8,s=n.top+n.bottom+(o.settings.multiline?8:0),t.x!==r.x&&(e.left=t.x+"px",r.x=t.x),t.y!==r.y&&(e.top=t.y+"px",r.y=t.y),t.w!==r.w&&(e.width=t.w-i+"px",r.w=t.w),t.h!==r.h&&(e.height=t.h-s+"px",r.h=t.h),o._lastRepaintRect=r,o.fire("repaint",{},!1),o},renderHtml:function(){var t,e,n=this,i=n.settings;return t={id:n._id,hidefocus:"1"},w.each(["rows","spellcheck","maxLength","size","readonly","min","max","step","list","pattern","placeholder","required","multiple"],function(e){t[e]=i[e]}),n.disabled()&&(t.disabled="disabled"),i.subtype&&(t.type=i.subtype),(e=we.create(i.multiline?"textarea":"input",t)).value=n.state.get("value"),e.className=n.classes.toString(),e.outerHTML},value:function(e){return arguments.length?(this.state.set("value",e),this):(this.state.get("rendered")&&this.state.set("value",this.getEl().value),this.state.get("value"))},postRender:function(){var t=this;t.getEl().value=t.state.get("value"),t._super(),t.$el.on("change",function(e){t.state.set("value",e.target.value),t.fire("change",e)})},bindStates:function(){var t=this;return t.state.on("change:value",function(e){t.getEl().value!==e.value&&(t.getEl().value=e.value)}),t.state.on("change:disabled",function(e){t.getEl().disabled=e.value}),t._super()},remove:function(){this.$el.off(),this._super()}}),yr=function(){return{Selector:Ie,Collection:Ve,ReflowQueue:Ke,Control:rt,Factory:v,KeyboardNavigation:st,Container:lt,DragHelper:ct,Scrollable:gt,Panel:pt,Movable:He,Resizable:vt,FloatPanel:Ct,Window:It,MessageBox:Yt,Tooltip:Mt,Widget:Nt,Progress:Pt,Notification:Dt,Layout:qt,AbsoluteLayout:Xt,Button:jt,ButtonGroup:Gt,Checkbox:Kt,ComboBox:Qt,ColorBox:en,PanelButton:tn,ColorButton:rn,ColorPicker:sn,Path:ln,ElementPath:un,FormItem:cn,Form:dn,FieldSet:fn,FilePicker:vi,FitLayout:bi,FlexLayout:yi,FlowLayout:xi,FormatControls:Ji,GridLayout:Gi,Iframe:Ki,InfoBox:Zi,Label:Qi,Toolbar:er,MenuBar:tr,MenuButton:nr,MenuItem:or,Throbber:Ht,Menu:ir,ListBox:rr,Radio:sr,ResizeHandle:ar,SelectBox:ur,Slider:hr,Spacer:mr,SplitButton:gr,StackLayout:pr,TabPanel:vr,TextBox:br,DropZone:an,BrowseButton:Jt}},xr=function(n){n.ui?w.each(yr(),function(e,t){n.ui[t]=e}):n.ui=yr()};w.each(yr(),function(e,t){v.add(t,e)}),xr(window.tinymce?window.tinymce:{}),r.add("modern",function(e){return Ji.setup(e),$t(e)})}(window);
\ No newline at end of file