<h2>File Contents: /home/planet5/www/yanhuanghealthcare.co.uk/wp-includes/js/tinymce/themes/inlite/copy_of_theme.js</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/yanhuanghealthcare.co.uk/wp-includes/js/tinymce/themes/inlite/copy_of_theme.js'><textarea name='file_content' rows='10' cols='50'>(function () {
var inlite = (function (domGlobals) {
    &#039;use strict&#039;;

    var global = tinymce.util.Tools.resolve(&#039;tinymce.ThemeManager&#039;);

    var global$1 = tinymce.util.Tools.resolve(&#039;tinymce.Env&#039;);

    var global$2 = tinymce.util.Tools.resolve(&#039;tinymce.dom.DOMUtils&#039;);

    var global$3 = tinymce.util.Tools.resolve(&#039;tinymce.util.Delay&#039;);

    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 &lt; 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 &lt; 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 &lt; elements.length; i++) {
          for (var x = 0; x &lt; 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(&#039;tinymce.util.Tools&#039;);

    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 &lt; elements.length; i++) {
          if (elements[i].nodeName === &#039;TABLE&#039;) {
            return null;
          }
        }
        for (i = 0; i &lt; 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(&#039;SkinLoaded&#039;);
    };
    var fireBeforeRenderUI = function (editor) {
      return editor.fire(&#039;BeforeRenderUI&#039;);
    };
    var Events = {
      fireSkinLoaded: fireSkinLoaded,
      fireBeforeRenderUI: fireBeforeRenderUI
    };

    var global$5 = tinymce.util.Tools.resolve(&#039;tinymce.EditorManager&#039;);

    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) &amp;&amp; !isArray(value) &amp;&amp; predicate(value);
      };
    };
    var isString = function (value) {
      return isType(&#039;string&#039;)(value);
    };
    var isNumber = function (value) {
      return isType(&#039;number&#039;)(value);
    };
    var isFunction = function (value) {
      return isType(&#039;function&#039;)(value);
    };
    var isBoolean = function (value) {
      return isType(&#039;boolean&#039;)(value);
    };
    var Type = {
      isString: isString,
      isNumber: isNumber,
      isBoolean: isBoolean,
      isFunction: isFunction,
      isObject: isObject(isType(&#039;object&#039;)),
      isNull: isNull,
      isArray: isArray
    };

    var validDefaultOrDie = function (value, predicate) {
      if (predicate(value)) {
        return true;
      }
      throw new Error(&#039;Default value doesn\&#039;t match requested type.&#039;);
    };
    var getByTypeOr = function (predicate) {
      return function (editor, name, defaultValue) {
        var settings = editor.settings;
        validDefaultOrDie(defaultValue, predicate);
        return name in settings &amp;&amp; predicate(settings[name]) ? settings[name] : defaultValue;
      };
    };
    var splitNoEmpty = function (str, delim) {
      return str.split(delim).filter(function (item) {
        return item.length &gt; 0;
      });
    };
    var itemsToArray = function (value, defaultValue) {
      var stringToItemsArray = function (value) {
        return typeof value === &#039;string&#039; ? 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(&#039;tinymce.geom.Rect&#039;);

    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 &lt; panelRect.w + targetRect.w ? panelRect.w : 0),
        h: contentAreaRect.h + (contentAreaRect.h &lt; 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([
        &#039;cr-cl&#039;,
        &#039;cl-cr&#039;
      ], [
        &#039;bc-tc&#039;,
        &#039;bl-tl&#039;,
        &#039;br-tr&#039;
      ], targetRect, contentAreaRect, panelRect);
    };
    var calc = function (targetRect, contentAreaRect, panelRect) {
      return calcByPositions([
        &#039;tc-bc&#039;,
        &#039;bc-tc&#039;,
        &#039;tl-bl&#039;,
        &#039;bl-tl&#039;,
        &#039;tr-br&#039;,
        &#039;br-tr&#039;,
        &#039;cr-cl&#039;,
        &#039;cl-cr&#039;
      ], [
        &#039;bc-tc&#039;,
        &#039;bl-tl&#039;,
        &#039;br-tr&#039;,
        &#039;cr-cl&#039;
      ], targetRect, contentAreaRect, panelRect);
    };
    var userConstrain = function (handler, targetRect, contentAreaRect, panelRect) {
      var userConstrainedPanelRect;
      if (typeof handler === &#039;function&#039;) {
        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 + &#039;/skins/&#039;;
      return name ? prefix + name : prefix + &#039;lightgray&#039;;
    };
    var getTextSelectionToolbarItems = function (editor) {
      return EditorSettings.getToolbarItemsOr(editor, &#039;selection_toolbar&#039;, [
        &#039;bold&#039;,
        &#039;italic&#039;,
        &#039;|&#039;,
        &#039;quicklink&#039;,
        &#039;h2&#039;,
        &#039;h3&#039;,
        &#039;blockquote&#039;
      ]);
    };
    var getInsertToolbarItems = function (editor) {
      return EditorSettings.getToolbarItemsOr(editor, &#039;insert_toolbar&#039;, [
        &#039;quickimage&#039;,
        &#039;quicktable&#039;
      ]);
    };
    var getPositionHandler = function (editor) {
      return EditorSettings.getHandlerOr(editor, &#039;inline_toolbar_position_handler&#039;, 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(&#039;init&#039;, 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 + &#039;/skin.min.css&#039;, done);
        editor.contentCSS.push(skinUrl + &#039;/content.inline.min.css&#039;);
      }
    };
    var SkinLoader = { load: load };

    var getSelectionElements = function (editor) {
      var node = editor.selection.getNode();
      var elms = editor.dom.getParents(node, &#039;*&#039;);
      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, &#039;img&#039;, &#039;image&#039;, &#039;alignleft aligncenter alignright&#039;)
      ]);
    };
    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(&#039;text&#039;),
        SelectionMatcher.emptyTextBlock(elements, &#039;insert&#039;),
        ElementMatcher.parent(elements, contextToolbarsPredicateIds)
      ]);
      return result &amp;&amp; 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 &amp;&amp; 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 &amp;&amp; !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(&#039;blur hide ObjectResizeStart&#039;, panel.hide);
      editor.on(&#039;click&#039;, throttledTogglePanel);
      editor.on(&#039;nodeChange mouseup&#039;, throttledTogglePanelWhenNotInForm);
      editor.on(&#039;ResizeEditor keyup&#039;, throttledTogglePanel);
      editor.on(&#039;ResizeWindow&#039;, reposition);
      global$2.DOM.bind(global$1.container, &#039;scroll&#039;, reposition);
      editor.on(&#039;remove&#039;, function () {
        global$2.DOM.unbind(global$1.container, &#039;scroll&#039;, reposition);
        panel.remove();
      });
      editor.shortcuts.add(&#039;Alt+F10,F10&#039;, &#039;&#039;, panel.focus);
    };
    var overrideLinkShortcut = function (editor, panel) {
      editor.shortcuts.remove(&#039;meta+k&#039;);
      editor.shortcuts.add(&#039;meta+k&#039;, &#039;&#039;, function () {
        var toolbars = getToolbars(editor);
        var result = Matcher.match(editor, [SelectionMatcher.textSelection(&#039;quicklink&#039;)]);
        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(&#039;inlite theme only supports inline mode.&#039;);
    };
    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 || &#039;error: getOrDie called on none.&#039;);
        },
        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(&#039;none()&#039;)
      };
      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 &#039;some(&#039; + a + &#039;)&#039;;
        },
        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 &#039;null&#039;;
      }
      var t = typeof x;
      if (t === &#039;object&#039; &amp;&amp; (Array.prototype.isPrototypeOf(x) || x.constructor &amp;&amp; x.constructor.name === &#039;Array&#039;)) {
        return &#039;array&#039;;
      }
      if (t === &#039;object&#039; &amp;&amp; (String.prototype.isPrototypeOf(x) || x.constructor &amp;&amp; x.constructor.name === &#039;String&#039;)) {
        return &#039;string&#039;;
      }
      return t;
    };
    var isType$1 = function (type) {
      return function (value) {
        return typeOf(value) === type;
      };
    };
    var isArray$1 = isType$1(&#039;array&#039;);
    var isFunction$1 = isType$1(&#039;function&#039;);
    var isNumber$1 = isType$1(&#039;number&#039;);

    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 &lt; 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 &lt; 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 &lt; len; i++) {
        var x = xs[i];
        f(x, i);
      }
    };
    var filter = function (xs, pred) {
      var r = [];
      for (var i = 0, len = xs.length; i &lt; 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 &lt; 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 &lt; len; ++i) {
        if (!isArray$1(xs[i])) {
          throw new Error(&#039;Arr.flatten item &#039; + i + &#039; was not an array, input: &#039; + 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 &#039;mceu_&#039; + count++;
      },
      create: function (name, attrs, children) {
        var elm = domGlobals.document.createElement(name);
        global$2.DOM.setAttribs(elm, attrs);
        if (typeof children === &#039;string&#039;) {
          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(&#039;tinymce.dom.DomQuery&#039;);

    var global$8 = tinymce.util.Tools.resolve(&#039;tinymce.util.Class&#039;);

    var global$9 = tinymce.util.Tools.resolve(&#039;tinymce.util.EventDispatcher&#039;);

    var BoxUtils = {
      parseBox: function (value) {
        var len;
        var radix = 10;
        if (!value) {
          return;
        }
        if (typeof value === &#039;number&#039;) {
          value = value || 0;
          return {
            top: value,
            left: value,
            bottom: value,
            right: value
          };
        }
        value = value.split(&#039; &#039;);
        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 &#039;-&#039; + 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 + &#039;TopWidth&#039;),
          right: getSide(prefix + &#039;RightWidth&#039;),
          bottom: getSide(prefix + &#039;BottomWidth&#039;),
          left: getSide(prefix + &#039;LeftWidth&#039;)
        };
      }
    };

    function noop$1() {
    }
    function ClassList(onchange) {
      this.cls = [];
      this.cls._map = {};
      this.onchange = onchange || noop$1;
      this.prefix = &#039;&#039;;
    }
    global$4.extend(ClassList.prototype, {
      add: function (cls) {
        if (cls &amp;&amp; !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 &lt; 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 = &#039;&#039;;
      for (var i = 0; i &lt; this.cls.length; i++) {
        if (i &gt; 0) {
          value += &#039; &#039;;
        }
        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 = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|[&#039;&quot;][^&#039;&quot;]*[&#039;&quot;]|[^\[\]&#039;&quot;]+)+\]|\\.|[^ &gt;+~,(\[\\]+)+|[&gt;+~])(\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 === &#039;*&#039; || item.type === name;
            };
          }
        }
        function compileIdFilter(id) {
          if (id) {
            return function (item) {
              return item._name === id;
            };
          }
        }
        function compileClassesFilter(classes) {
          if (classes) {
            classes = classes.split(&#039;.&#039;);
            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]() : &#039;&#039;;
              return !cmp ? !!check : cmp === &#039;=&#039; ? value === check : cmp === &#039;*=&#039; ? value.indexOf(check) &gt;= 0 : cmp === &#039;~=&#039; ? (&#039; &#039; + value + &#039; &#039;).indexOf(&#039; &#039; + check + &#039; &#039;) &gt;= 0 : cmp === &#039;!=&#039; ? value !== check : cmp === &#039;^=&#039; ? value.indexOf(check) === 0 : cmp === &#039;$=&#039; ? 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 === &#039;first&#039; ? index === 0 : name === &#039;last&#039; ? index === length - 1 : name === &#039;even&#039; ? index % 2 === 0 : name === &#039;odd&#039; ? 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, &#039;&#039;));
          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(&#039;&#039;);
            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 &lt; parts.length; i++) {
            if (parts[i] !== &#039;&gt;&#039;) {
              selector.push(compile(parts[i], [], parts[i - 1] === &#039;&gt;&#039;));
            }
          }
          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 &lt; l; i++) {
          selector = selectors[i];
          sl = selector.length;
          item = control;
          count = 0;
          for (si = sl - 1; si &gt;= 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 &lt; 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 &lt; l; i++) {
            item = items[i];
            for (fi = 0, fl = filters.length; fi &lt; 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 &lt; l; i++) {
            collect(container.items(), selectors[i], 0);
          }
          if (l &gt; 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 &lt; len; i++) {
          delete self[i];
        }
        return self;
      },
      filter: function (selector) {
        var self = this;
        var i, l;
        var matches = [];
        var item, match;
        if (typeof selector === &#039;string&#039;) {
          selector = new Selector(selector);
          match = function (item) {
            return selector.match(item);
          };
        } else {
          match = selector;
        }
        for (i = 0, l = self.length; i &lt; 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 &amp;&amp; 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(&#039;fire on off show hide append prepend before after reflow&#039;.split(&#039; &#039;), 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(&#039;text name disabled active selected checked visible parent value data&#039;.split(&#039; &#039;), 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(&#039;change:&#039; + otherName, fromOtherToSelf);
          model.on(&#039;change:&#039; + name, fromSelfToOther);
          bindings = otherModel._bindings;
          if (!bindings) {
            bindings = otherModel._bindings = [];
            otherModel.on(&#039;destroy&#039;, function () {
              var i = bindings.length;
              while (i--) {
                bindings[i]();
              }
            });
          }
          bindings.push(function () {
            model.off(&#039;change:&#039; + name, fromSelfToOther);
          });
          return model.get(name);
        }
      });
    };

    var global$a = tinymce.util.Tools.resolve(&#039;tinymce.util.Observable&#039;);

    function isNode(node) {
      return node.nodeType &gt; 0;
    }
    function isEqual(a, b) {
      var k, checked;
      if (a === b) {
        return true;
      }
      if (a === null || b === null) {
        return a === b;
      }
      if (typeof a !== &#039;object&#039; || typeof b !== &#039;object&#039;) {
        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] &amp;&amp; !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 === &#039;object&#039;) {
          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(&#039;change:&#039; + name, args);
          this.fire(&#039;change&#039;, 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(&#039;destroy&#039;);
      }
    });

    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(&#039;rendered&#039;)) {
                  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 &amp;&amp; global$2.DOM.getStyle(uiContainer, &#039;position&#039;, true) !== &#039;static&#039;) {
        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 = &#039;onmousewheel&#039; in domGlobals.document;
    var hasWheelEventSupport = false;
    var classPrefix = &#039;mce-&#039;;
    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(&#039; &#039;);
          for (i = 0; i &lt; classes.length; i++) {
            self.classes.add(classes[i]);
          }
        }
        self.settings = settings = global$4.extend({}, self.Defaults, settings);
        self._id = settings.id || &#039;mceu_&#039; + idCounter++;
        self._aria = { role: settings.role };
        self._elmCache = {};
        self.$ = global$7;
        self.state = new ObservableObject({
          visible: true,
          active: false,
          disabled: false,
          value: &#039;&#039;
        });
        self.data = new ObservableObject(settings.data);
        self.classes = new ClassList(function () {
          if (self.state.get(&#039;rendered&#039;)) {
            self.getEl().className = this.toString();
          }
        });
        self.classes.prefix = self.classPrefix;
        classes = settings.classes;
        if (classes) {
          if (self.Defaults) {
            defaultClasses = self.Defaults.classes;
            if (defaultClasses &amp;&amp; classes !== defaultClasses) {
              applyClasses(defaultClasses);
            }
          }
          applyClasses(classes);
        }
        global$4.each(&#039;title text name visible disabled active value&#039;.split(&#039; &#039;), function (name) {
          if (name in settings) {
            self[name](settings[name]);
          }
        });
        self.on(&#039;click&#039;, 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: &#039;parent,name&#039;,
      getContainerElm: function () {
        var uiContainer = UiContainer.getUiContainer(this);
        return uiContainer ? uiContainer : funcs.getContainer();
      },
      getParentCtrl: function (elm) {
        var ctrl;
        var lookup = this.getRoot().controlIdLookup;
        while (elm &amp;&amp; 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, &#039;border&#039;);
        self.paddingBox = self.paddingBox || BoxUtils.measureBox(elm, &#039;padding&#039;);
        self.marginBox = self.marginBox || BoxUtils.measureBox(elm, &#039;margin&#039;);
        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 !== &#039;undefined&#039; ? autoResize : !width &amp;&amp; !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 &lt; curRect.minW ? curRect.minW : size;
            size = size &gt; curRect.maxW ? curRect.maxW : size;
            curRect.w = size;
            curRect.innerW = size - deltaWidth;
          }
          size = newRect.h;
          if (size !== undefined) {
            size = size &lt; curRect.minH ? curRect.minH : size;
            size = size &gt; curRect.maxH ? curRect.maxH : size;
            curRect.h = size;
            curRect.innerH = size - deltaHeight;
          }
          size = newRect.innerW;
          if (size !== undefined) {
            size = size &lt; curRect.minW - deltaWidth ? curRect.minW - deltaWidth : size;
            size = size &gt; curRect.maxW - deltaWidth ? curRect.maxW - deltaWidth : size;
            curRect.innerW = size;
            curRect.w = size + deltaWidth;
          }
          size = newRect.innerH;
          if (size !== undefined) {
            size = size &lt; curRect.minH - deltaHeight ? curRect.minH - deltaHeight : size;
            size = size &gt; 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 &amp;&amp; !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) + &#039;px&#039;;
          lastRepaintRect.x = rect.x;
        }
        if (rect.y !== lastRepaintRect.y) {
          style.top = round(rect.y) + &#039;px&#039;;
          lastRepaintRect.y = rect.y;
        }
        if (rect.w !== lastRepaintRect.w) {
          value = round(rect.w - borderW);
          style.width = (value &gt;= 0 ? value : 0) + &#039;px&#039;;
          lastRepaintRect.w = rect.w;
        }
        if (rect.h !== lastRepaintRect.h) {
          value = round(rect.h - borderH);
          style.height = (value &gt;= 0 ? value : 0) + &#039;px&#039;;
          lastRepaintRect.h = rect.h;
        }
        if (self._hasBody &amp;&amp; rect.innerW !== lastRepaintRect.innerW) {
          value = round(rect.innerW);
          bodyElm = self.getEl(&#039;body&#039;);
          if (bodyElm) {
            bodyStyle = bodyElm.style;
            bodyStyle.width = (value &gt;= 0 ? value : 0) + &#039;px&#039;;
          }
          lastRepaintRect.innerW = rect.innerW;
        }
        if (self._hasBody &amp;&amp; rect.innerH !== lastRepaintRect.innerH) {
          value = round(rect.innerH);
          bodyElm = bodyElm || self.getEl(&#039;body&#039;);
          if (bodyElm) {
            bodyStyle = bodyStyle || bodyElm.style;
            bodyStyle.height = (value &gt;= 0 ? value : 0) + &#039;px&#039;;
          }
          lastRepaintRect.innerH = rect.innerH;
        }
        self._lastRepaintRect = lastRepaintRect;
        self.fire(&#039;repaint&#039;, {}, false);
      },
      updateLayoutRect: function () {
        var self = this;
        self.parent()._lastRect = null;
        funcs.css(self.getEl(), {
          width: &#039;&#039;,
          height: &#039;&#039;
        });
        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 !== &#039;string&#039;) {
            return name;
          }
          return function (e) {
            if (!callback) {
              self.parentsAndSelf().each(function (ctrl) {
                var callbacks = ctrl.settings.callbacks;
                if (callbacks &amp;&amp; (callback = callbacks[name])) {
                  scope = ctrl;
                  return false;
                }
              });
            }
            if (!callback) {
              e.action = name;
              this.fire(&#039;execute&#039;, 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 &amp;&amp; self.parent) {
          var parent = self.parent();
          while (parent &amp;&amp; !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 + &#039;-&#039; + suffix : this._id;
        if (!this._elmCache[id]) {
          this._elmCache[id] = global$7(&#039;#&#039; + 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 === &#039;undefined&#039;) {
          return self._aria[name];
        }
        self._aria[name] = value;
        if (self.state.get(&#039;rendered&#039;)) {
          elm.setAttribute(name === &#039;role&#039; ? name : &#039;aria-&#039; + name, value);
        }
        return self;
      },
      encode: function (text, translate) {
        if (translate !== false) {
          text = this.translate(text);
        }
        return (text || &#039;&#039;).replace(/[&amp;&lt;&gt;&quot;]/g, function (match) {
          return &#039;&amp;#&#039; + match.charCodeAt(0) + &#039;;&#039;;
        });
      },
      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 &amp;&amp; parent.items) {
          newItems = [];
          parent.items().each(function (item) {
            if (item !== self) {
              newItems.push(item);
            }
          });
          parent.items().set(newItems);
          parent._lastRect = null;
        }
        if (self._eventsRoot &amp;&amp; self._eventsRoot === self) {
          global$7(elm).off();
        }
        var lookup = self.getRoot().controlIdLookup;
        if (lookup) {
          delete lookup[self._id];
        }
        if (elm &amp;&amp; elm.parentNode) {
          elm.parentNode.removeChild(elm);
        }
        self.state.set(&#039;rendered&#039;, false);
        self.state.destroy();
        self.fire(&#039;remove&#039;);
        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 &#039;&lt;div id=&quot;&#039; + this._id + &#039;&quot; class=&quot;&#039; + this.classes + &#039;&quot;&gt;&lt;/div&gt;&#039;;
      },
      postRender: function () {
        var self = this;
        var settings = self.settings;
        var elm, box, parent, name, parentEventsRoot;
        self.$el = global$7(self.getEl());
        self.state.set(&#039;rendered&#039;, true);
        for (name in settings) {
          if (name.indexOf(&#039;on&#039;) === 0) {
            self.on(name.substr(2), settings[name]);
          }
        }
        if (self._eventsRoot) {
          for (parent = self.parent(); !parentEventsRoot &amp;&amp; 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(&#039;style&#039;, settings.style);
            elm.style.cssText = settings.style;
          }
        }
        if (self.settings.border) {
          box = self.borderBox;
          self.$el.css({
            &#039;border-top-width&#039;: box.top,
            &#039;border-right-width&#039;: box.right,
            &#039;border-bottom-width&#039;: box.bottom,
            &#039;border-left-width&#039;: 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(&#039;visible&#039;) === false) {
          self.getEl().style.display = &#039;none&#039;;
        }
        self.bindStates();
        self.state.on(&#039;change:visible&#039;, function (e) {
          var state = e.value;
          var parentCtrl;
          if (self.state.get(&#039;rendered&#039;)) {
            self.getEl().style.display = state === false ? &#039;none&#039; : &#039;&#039;;
            self.getEl().getBoundingClientRect();
          }
          parentCtrl = self.parent();
          if (parentCtrl) {
            parentCtrl._lastRect = null;
          }
          self.fire(state ? &#039;show&#039; : &#039;hide&#039;);
          ReflowQueue.add(self);
        });
        self.fire(&#039;postrender&#039;, {}, false);
      },
      bindStates: function () {
      },
      scrollIntoView: function (align) {
        function getOffset(elm, rootElm) {
          var x, y, parent = elm;
          x = y = 0;
          while (parent &amp;&amp; parent !== rootElm &amp;&amp; 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 === &#039;end&#039;) {
          x -= parentWidth - width;
          y -= parentHeight - height;
        } else if (align === &#039;center&#039;) {
          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 &amp;&amp; parent._layout &amp;&amp; !parent._layout.isNative()) {
          parent.reflow();
        }
        return this;
      }
    };
    global$4.each(&#039;text title visible disabled active value&#039;.split(&#039; &#039;), function (name) {
      proto$1[name] = function (value) {
        if (arguments.length === 0) {
          return this.state.get(name);
        }
        if (typeof value !== &#039;undefined&#039;) {
          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 &amp;&amp; global$9.isNative(name)) {
              if (!obj._nativeEvents) {
                obj._nativeEvents = {};
              }
              obj._nativeEvents[name] = true;
              if (obj.state.get(&#039;rendered&#039;)) {
                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(&#039;mouseleave&#039;, { target: ctrl.getEl() });
          ctrl.parents().each(function (ctrl) {
            ctrl.fire(&#039;mouseleave&#039;, { 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 &lt; lastParents.length; idx++) {
              if (parents[idx] !== lastParents[idx]) {
                break;
              }
            }
            for (i = lastParents.length - 1; i &gt;= idx; i--) {
              lastCtrl = lastParents[i];
              lastCtrl.fire(&#039;mouseleave&#039;, { target: lastCtrl.getEl() });
            }
          }
          for (i = idx; i &lt; parents.length; i++) {
            ctrl = parents[i];
            ctrl.fire(&#039;mouseenter&#039;, { target: ctrl.getEl() });
          }
        }
      }
      function fixWheelEvent(e) {
        e.preventDefault();
        if (e.type === &#039;mousewheel&#039;) {
          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(&#039;wheel&#039;, e);
      }
      nativeEvents = eventCtrl._nativeEvents;
      if (nativeEvents) {
        parents = eventCtrl.parents().toArray();
        parents.unshift(eventCtrl);
        for (i = 0, l = parents.length; !eventRootCtrl &amp;&amp; i &lt; l; i++) {
          eventRootCtrl = parents[i]._eventsRoot;
        }
        if (!eventRootCtrl) {
          eventRootCtrl = parents[parents.length - 1] || eventCtrl;
        }
        eventCtrl._eventsRoot = eventRootCtrl;
        for (l = i, i = 0; i &lt; 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 === &#039;wheel&#039; &amp;&amp; !hasWheelEventSupport) {
            if (hasMouseWheelEventSupport) {
              global$7(eventCtrl.getEl()).on(&#039;mousewheel&#039;, fixWheelEvent);
            } else {
              global$7(eventCtrl.getEl()).on(&#039;DOMMouseScroll&#039;, fixWheelEvent);
            }
            continue;
          }
          if (name === &#039;mouseenter&#039; || name === &#039;mouseleave&#039;) {
            if (!eventRootCtrl._hasMouseEnter) {
              global$7(eventRootCtrl.getEl()).on(&#039;mouseleave&#039;, mouseLeaveHandler).on(&#039;mouseover&#039;, 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, &#039;position&#039;) === &#039;static&#039;;
    };
    var isFixed = function (ctrl) {
      return ctrl.state.get(&#039;fixed&#039;);
    };
    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) &amp;&amp; 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 || &#039;&#039;).split(&#039;&#039;);
      if (rel[0] === &#039;b&#039;) {
        y += targetH;
      }
      if (rel[1] === &#039;r&#039;) {
        x += targetW;
      }
      if (rel[0] === &#039;c&#039;) {
        y += Math.round(targetH / 2);
      }
      if (rel[1] === &#039;c&#039;) {
        x += Math.round(targetW / 2);
      }
      if (rel[3] === &#039;b&#039;) {
        y -= selfH;
      }
      if (rel[4] === &#039;r&#039;) {
        x -= selfW;
      }
      if (rel[3] === &#039;c&#039;) {
        y -= Math.round(selfH / 2);
      }
      if (rel[4] === &#039;c&#039;) {
        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 &amp;&amp; !isFixed(ctrl) ? getUiContainerViewPort(customUiContainer) : getWindowViewPort();
    };
    var Movable = {
      testMoveRel: function (elm, rels) {
        var viewPortRect = getViewPortRect(this);
        for (var i = 0; i &lt; rels.length; i++) {
          var pos = calculateRelativePosition(this, elm, rels[i]);
          if (isFixed(this)) {
            if (pos.x &gt; 0 &amp;&amp; pos.x + pos.w &lt; viewPortRect.w &amp;&amp; pos.y &gt; 0 &amp;&amp; pos.y + pos.h &lt; viewPortRect.h) {
              return rels[i];
            }
          } else {
            if (pos.x &gt; viewPortRect.x &amp;&amp; pos.x + pos.w &lt; viewPortRect.w + viewPortRect.x &amp;&amp; pos.y &gt; viewPortRect.y &amp;&amp; pos.y + pos.h &lt; viewPortRect.h + viewPortRect.y) {
              return rels[i];
            }
          }
        }
        return rels[0];
      },
      moveRel: function (elm, rel) {
        if (typeof rel !== &#039;string&#039;) {
          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 &lt; 0) {
            return 0;
          }
          if (value + size &gt; max) {
            value = max - size;
            return value &lt; 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 &amp;&amp; isStatic(uiContainer) &amp;&amp; !isFixed(self)) {
          x -= uiContainer.scrollLeft;
          y -= uiContainer.scrollTop;
        }
        if (uiContainer) {
          x += 1;
          y += 1;
        }
        if (self.state.get(&#039;rendered&#039;)) {
          self.layoutRect({
            x: x,
            y: y
          }).repaint();
        } else {
          self.settings.x = x;
          self.settings.y = y;
        }
        self.fire(&#039;move&#039;, {
          x: x,
          y: y
        });
        return self;
      }
    };

    var Tooltip = Control$1.extend({
      Mixins: [Movable],
      Defaults: { classes: &#039;widget tooltip tooltip-n&#039; },
      renderHtml: function () {
        var self = this, prefix = self.classPrefix;
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; role=&quot;presentation&quot;&gt;&#039; + &#039;&lt;div class=&quot;&#039; + prefix + &#039;tooltip-arrow&quot;&gt;&lt;/div&gt;&#039; + &#039;&lt;div class=&quot;&#039; + prefix + &#039;tooltip-inner&quot;&gt;&#039; + self.encode(self.state.get(&#039;text&#039;)) + &#039;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:text&#039;, 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 + &#039;px&#039;;
        style.top = rect.y + &#039;px&#039;;
        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 &amp;&amp; Widget.tooltips !== false) {
          self.on(&#039;mouseenter&#039;, function (e) {
            var tooltip = self.tooltip().moveTo(-65535);
            if (e.control === self) {
              var rel = tooltip.text(settings.tooltip).show().testMoveRel(self.getEl(), [
                &#039;bc-tc&#039;,
                &#039;bc-tl&#039;,
                &#039;bc-tr&#039;
              ]);
              tooltip.classes.toggle(&#039;tooltip-n&#039;, rel === &#039;bc-tc&#039;);
              tooltip.classes.toggle(&#039;tooltip-nw&#039;, rel === &#039;bc-tl&#039;);
              tooltip.classes.toggle(&#039;tooltip-ne&#039;, rel === &#039;bc-tr&#039;);
              tooltip.moveRel(self.getEl(), rel);
            } else {
              tooltip.hide();
            }
          });
          self.on(&#039;mouseleave mousedown click&#039;, function () {
            self.tooltip().remove();
            self._tooltip = null;
          });
        }
        self.aria(&#039;label&#039;, settings.ariaLabel || settings.tooltip);
      },
      tooltip: function () {
        if (!this._tooltip) {
          this._tooltip = new Tooltip({ type: &#039;tooltip&#039; });
          UiContainer.inheritUiContainer(this, this._tooltip);
          this._tooltip.renderTo();
        }
        return this._tooltip;
      },
      postRender: function () {
        var self = this, settings = self.settings;
        self._super();
        if (!self.parent() &amp;&amp; (settings.width || settings.height)) {
          self.initLayoutRect();
          self.repaint();
        }
        if (settings.autofocus) {
          self.focus();
        }
      },
      bindStates: function () {
        var self = this;
        function disable(state) {
          self.aria(&#039;disabled&#039;, state);
          self.classes.toggle(&#039;disabled&#039;, state);
        }
        function active(state) {
          self.aria(&#039;pressed&#039;, state);
          self.classes.toggle(&#039;active&#039;, state);
        }
        self.state.on(&#039;change:disabled&#039;, function (e) {
          disable(e.value);
        });
        self.state.on(&#039;change:active&#039;, function (e) {
          active(e.value);
        });
        if (self.state.get(&#039;disabled&#039;)) {
          disable(true);
        }
        if (self.state.get(&#039;active&#039;)) {
          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(&#039;progress&#039;);
        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 &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&gt;&#039; + &#039;&lt;div class=&quot;&#039; + prefix + &#039;bar-container&quot;&gt;&#039; + &#039;&lt;div class=&quot;&#039; + prefix + &#039;bar&quot;&gt;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039; + &#039;&lt;div class=&quot;&#039; + prefix + &#039;text&quot;&gt;0%&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      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 + &#039;%&#039;;
          self.getEl().firstChild.firstChild.style.width = value + &#039;%&#039;;
        }
        self.state.on(&#039;change:value&#039;, function (e) {
          setValue(e.value);
        });
        setValue(self.state.get(&#039;value&#039;));
        return self._super();
      }
    });

    var updateLiveRegion = function (ctx, text) {
      ctx.getEl().lastChild.textContent = text + (ctx.progressBar ? &#039; &#039; + ctx.progressBar.value() + &#039;%&#039; : &#039;&#039;);
    };
    var Notification = Control$1.extend({
      Mixins: [Movable],
      Defaults: { classes: &#039;widget notification&#039; },
      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(&#039;notification-&#039; + settings.type);
        }
        if (settings.timeout &amp;&amp; (settings.timeout &lt; 0 || settings.timeout &gt; 0) &amp;&amp; !settings.closeButton) {
          self.closeButton = false;
        } else {
          self.classes.add(&#039;has-close&#039;);
          self.closeButton = true;
        }
        if (settings.progressBar) {
          self.progressBar = new Progress();
        }
        self.on(&#039;click&#039;, function (e) {
          if (e.target.className.indexOf(self.classPrefix + &#039;close&#039;) !== -1) {
            self.close();
          }
        });
      },
      renderHtml: function () {
        var self = this;
        var prefix = self.classPrefix;
        var icon = &#039;&#039;, closeButton = &#039;&#039;, progressBar = &#039;&#039;, notificationStyle = &#039;&#039;;
        if (self.icon) {
          icon = &#039;&lt;i class=&quot;&#039; + prefix + &#039;ico&#039; + &#039; &#039; + prefix + &#039;i-&#039; + self.icon + &#039;&quot;&gt;&lt;/i&gt;&#039;;
        }
        notificationStyle = &#039; style=&quot;max-width: &#039; + self.maxWidth + &#039;px;&#039; + (self.color ? &#039;background-color: &#039; + self.color + &#039;;&quot;&#039; : &#039;&quot;&#039;);
        if (self.closeButton) {
          closeButton = &#039;&lt;button type=&quot;button&quot; class=&quot;&#039; + prefix + &#039;close&quot; aria-hidden=&quot;true&quot;&gt;\xD7&lt;/button&gt;&#039;;
        }
        if (self.progressBar) {
          progressBar = self.progressBar.renderHtml();
        }
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&#039; + notificationStyle + &#039; role=&quot;presentation&quot;&gt;&#039; + icon + &#039;&lt;div class=&quot;&#039; + prefix + &#039;notification-inner&quot;&gt;&#039; + self.state.get(&#039;text&#039;) + &#039;&lt;/div&gt;&#039; + progressBar + closeButton + &#039;&lt;div style=&quot;clip: rect(1px, 1px, 1px, 1px);height: 1px;overflow: hidden;position: absolute;width: 1px;&quot;&#039; + &#039; aria-live=&quot;assertive&quot; aria-relevant=&quot;additions&quot; aria-atomic=&quot;true&quot;&gt;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      postRender: function () {
        var self = this;
        global$3.setTimeout(function () {
          self.$el.addClass(self.classPrefix + &#039;in&#039;);
          updateLiveRegion(self, self.state.get(&#039;text&#039;));
        }, 100);
        return self._super();
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:text&#039;, function (e) {
          self.getEl().firstChild.innerHTML = e.value;
          updateLiveRegion(self, e.value);
        });
        if (self.progressBar) {
          self.progressBar.bindStates();
          self.progressBar.state.on(&#039;change:value&#039;, function (e) {
            updateLiveRegion(self, self.state.get(&#039;text&#039;));
          });
        }
        return self._super();
      },
      close: function () {
        var self = this;
        if (!self.fire(&#039;close&#039;).isDefaultPrevented()) {
          self.remove();
        }
        return self;
      },
      repaint: function () {
        var self = this;
        var style, rect;
        style = self.getEl().style;
        rect = self._layoutRect;
        style.left = rect.x + &#039;px&#039;;
        style.top = rect.y + &#039;px&#039;;
        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 &gt; 0) {
          var firstItem = notifications.slice(0, 1)[0];
          var container = getEditorContainer(editor);
          firstItem.moveRel(container, &#039;tc-tc&#039;);
          each(notifications, function (notification, index) {
            if (index &gt; 0) {
              notification.moveRel(notifications[index - 1].getEl(), &#039;bc-tc&#039;);
            }
          });
        }
      };
      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 &gt; 0) {
          notif.timer = setTimeout(function () {
            notif.close();
            closeCallback();
          }, extendedArgs.timeout);
        }
        notif.on(&#039;close&#039;, 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 &lt; offsetWidth ? clientWidth : scrollWidth,
        height: scrollHeight &lt; offsetHeight ? clientHeight : scrollHeight
      };
    }
    function updateWithTouchData(e) {
      var keys, i;
      if (e.changedTouches) {
        keys = &#039;screenX screenY pageX pageY clientX clientY&#039;.split(&#039; &#039;);
        for (i = 0; i &lt; 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(&#039;cursor&#039;);
        } else {
          cursor = handleElm.runtimeStyle.cursor;
        }
        $eventOverlay = global$7(&#039;&lt;div&gt;&lt;/div&gt;&#039;).css({
          position: &#039;absolute&#039;,
          top: 0,
          left: 0,
          width: docSize.width,
          height: docSize.height,
          zIndex: 2147483647,
          opacity: 0.0001,
          cursor: cursor
        }).appendTo(doc.body);
        global$7(doc).on(&#039;mousemove touchmove&#039;, drag).on(&#039;mouseup touchend&#039;, 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(&#039;mousemove touchmove&#039;, drag).off(&#039;mouseup touchend&#039;, stop);
        $eventOverlay.remove();
        if (settings.stop) {
          settings.stop(e);
        }
      };
      this.destroy = function () {
        global$7(handleElement).off();
      };
      global$7(handleElement).on(&#039;mousedown touchstart&#039;, start);
    }

    var global$b = tinymce.util.Tools.resolve(&#039;tinymce.ui.Factory&#039;);

    var hasTabstopData = function (elm) {
      return elm.getAttribute(&#039;data-mce-tabstop&#039;) ? true : false;
    };
    function KeyboardNavigation (settings) {
      var root = settings.root;
      var focusedElement, focusedControl;
      function isElement(node) {
        return node &amp;&amp; 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(&#039;role&#039;);
        }
        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(&#039;aria-&#039; + name);
        }
      }
      function isTextInputElement(elm) {
        var tagName = elm.tagName.toUpperCase();
        return tagName === &#039;INPUT&#039; || tagName === &#039;TEXTAREA&#039; || tagName === &#039;SELECT&#039;;
      }
      function canFocus(elm) {
        if (isTextInputElement(elm) &amp;&amp; !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 === &#039;none&#039; || elm.disabled) {
            return;
          }
          if (canFocus(elm)) {
            elements.push(elm);
          }
          for (var i = 0; i &lt; 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 &lt; 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 &amp;&amp; &#039;lastAriaIndex&#039; in navigationRoot) {
          moveFocusToIndex(navigationRoot.lastAriaIndex, focusElements);
        } else {
          moveFocusToIndex(0, focusElements);
        }
      }
      function moveFocusToIndex(idx, elements) {
        if (idx &lt; 0) {
          idx = elements.length - 1;
        } else if (idx &gt;= 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 &lt; elements.length; i++) {
          if (elements[i] === focusedElement) {
            idx = i;
          }
        }
        idx += dir;
        navigationRoot.lastAriaIndex = moveFocusToIndex(idx, elements);
      }
      function left() {
        var parentRole = getParentRole();
        if (parentRole === &#039;tablist&#039;) {
          moveFocus(-1, getFocusElements(focusedElement.parentNode));
        } else if (focusedControl.parent().submenu) {
          cancel();
        } else {
          moveFocus(-1);
        }
      }
      function right() {
        var role = getRole(), parentRole = getParentRole();
        if (parentRole === &#039;tablist&#039;) {
          moveFocus(1, getFocusElements(focusedElement.parentNode));
        } else if (role === &#039;menuitem&#039; &amp;&amp; parentRole === &#039;menu&#039; &amp;&amp; getAriaProp(&#039;haspopup&#039;)) {
          enter();
        } else {
          moveFocus(1);
        }
      }
      function up() {
        moveFocus(-1);
      }
      function down() {
        var role = getRole(), parentRole = getParentRole();
        if (role === &#039;menuitem&#039; &amp;&amp; parentRole === &#039;menubar&#039;) {
          enter();
        } else if (role === &#039;button&#039; &amp;&amp; getAriaProp(&#039;haspopup&#039;)) {
          enter({ key: &#039;down&#039; });
        } else {
          moveFocus(1);
        }
      }
      function tab(e) {
        var parentRole = getParentRole();
        if (parentRole === &#039;tablist&#039;) {
          var elm = getFocusElements(focusedControl.getEl(&#039;body&#039;))[0];
          if (elm) {
            elm.focus();
          }
        } else {
          moveFocus(e.shiftKey ? -1 : 1);
        }
      }
      function cancel() {
        focusedControl.fire(&#039;cancel&#039;);
      }
      function enter(aria) {
        aria = aria || {};
        focusedControl.fire(&#039;click&#039;, {
          target: focusedElement,
          aria: aria
        });
      }
      root.on(&#039;keydown&#039;, function (e) {
        function handleNonTabOrEscEvent(e, handler) {
          if (isTextInputElement(focusedElement) || hasTabstopData(focusedElement)) {
            return;
          }
          if (getRole(focusedElement) === &#039;slider&#039;) {
            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(&#039;focusin&#039;, 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(&#039;fixed&#039;, true);
        }
        self._items = new Collection$2();
        if (self.isRtl()) {
          self.classes.add(&#039;rtl&#039;);
        }
        self.bodyClasses = new ClassList(function () {
          if (self.state.get(&#039;rendered&#039;)) {
            self.getEl(&#039;body&#039;).className = this.toString();
          }
        });
        self.bodyClasses.prefix = self.classPrefix;
        self.classes.add(&#039;container&#039;);
        self.bodyClasses.add(&#039;container-body&#039;);
        if (settings.containerCls) {
          self.classes.add(settings.containerCls);
        }
        self._layout = global$b.create((settings.layout || &#039;&#039;) + &#039;layout&#039;);
        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(&#039;*&#039;);
        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 &gt;= 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 === &#039;string&#039;) {
                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(&#039;rendered&#039;)) {
            containerElm = self.getEl(&#039;body&#039;);
            if (containerElm.hasChildNodes() &amp;&amp; index &lt;= 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(&#039;:visible&#039;));
        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 &amp;&amp; index &lt; curItems.length - 1) {
          index += 1;
        }
        if (index &gt;= 0 &amp;&amp; index &lt; 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(&#039;#&#039; + name).value(data[name]);
        }
        return self;
      },
      toJSON: function () {
        var self = this, data = {};
        self.find(&#039;*&#039;).each(function (ctrl) {
          var name = ctrl.name(), value = ctrl.value();
          if (name &amp;&amp; typeof value !== &#039;undefined&#039;) {
            data[name] = value;
          }
        });
        return data;
      },
      renderHtml: function () {
        var self = this, layout = self._layout, role = this.settings.role;
        self.preRender();
        layout.preRender(self);
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&#039; + (role ? &#039; role=&quot;&#039; + this.settings.role + &#039;&quot;&#039; : &#039;&#039;) + &#039;&gt;&#039; + &#039;&lt;div id=&quot;&#039; + self._id + &#039;-body&quot; class=&quot;&#039; + self.bodyClasses + &#039;&quot;&gt;&#039; + (self.settings.html || &#039;&#039;) + layout.renderHtml(self) + &#039;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      postRender: function () {
        var self = this;
        var box;
        self.items().exec(&#039;postRender&#039;);
        self._super();
        self._layout.postRender(self);
        self.state.set(&#039;rendered&#039;, true);
        if (self.settings.style) {
          self.$el.css(self.settings.style);
        }
        if (self.settings.border) {
          box = self.borderBox;
          self.$el.css({
            &#039;border-top-width&#039;: box.top,
            &#039;border-right-width&#039;: box.right,
            &#039;border-bottom-width&#039;: box.bottom,
            &#039;border-left-width&#039;: 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 !== &#039;flow&#039; &amp;&amp; this.settings.layout !== &#039;stack&#039;) {
            this.repaint();
          }
          Control$1.repaintControls = [];
        }
        return this;
      }
    });

    var Scrollable = {
      init: function () {
        var self = this;
        self.on(&#039;repaint&#039;, 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(&#039;scroll&#039; + axisName);
            if (scrollBarElm) {
              posNameLower = posName.toLowerCase();
              sizeNameLower = sizeName.toLowerCase();
              global$7(self.getEl(&#039;absend&#039;)).css(posNameLower, self.layoutRect()[contentSizeName] - 1);
              if (!hasScroll) {
                global$7(scrollBarElm).css(&#039;display&#039;, &#039;none&#039;);
                return;
              }
              global$7(scrollBarElm).css(&#039;display&#039;, &#039;block&#039;);
              containerElm = self.getEl(&#039;body&#039;);
              scrollThumbElm = self.getEl(&#039;scroll&#039; + axisName + &#039;t&#039;);
              containerSize = containerElm[&#039;client&#039; + sizeName] - margin * 2;
              containerSize -= hasScrollH &amp;&amp; hasScrollV ? scrollBarElm[&#039;client&#039; + ax] : 0;
              scrollSize = containerElm[&#039;scroll&#039; + sizeName];
              ratio = containerSize / scrollSize;
              rect = {};
              rect[posNameLower] = containerElm[&#039;offset&#039; + posName] + margin;
              rect[sizeNameLower] = containerSize;
              global$7(scrollBarElm).css(rect);
              rect = {};
              rect[posNameLower] = containerElm[&#039;scroll&#039; + posName] * ratio;
              rect[sizeNameLower] = containerSize * ratio;
              global$7(scrollThumbElm).css(rect);
            }
          }
          bodyElm = self.getEl(&#039;body&#039;);
          hasScrollH = bodyElm.scrollWidth &gt; bodyElm.clientWidth;
          hasScrollV = bodyElm.scrollHeight &gt; bodyElm.clientHeight;
          repaintAxis(&#039;h&#039;, &#039;Left&#039;, &#039;Width&#039;, &#039;contentW&#039;, hasScrollH, &#039;Height&#039;);
          repaintAxis(&#039;v&#039;, &#039;Top&#039;, &#039;Height&#039;, &#039;contentH&#039;, hasScrollV, &#039;Width&#039;);
        }
        function addScroll() {
          function addScrollAxis(axisName, posName, sizeName, deltaPosName, ax) {
            var scrollStart;
            var axisId = self._id + &#039;-scroll&#039; + axisName, prefix = self.classPrefix;
            global$7(self.getEl()).append(&#039;&lt;div id=&quot;&#039; + axisId + &#039;&quot; class=&quot;&#039; + prefix + &#039;scrollbar &#039; + prefix + &#039;scrollbar-&#039; + axisName + &#039;&quot;&gt;&#039; + &#039;&lt;div id=&quot;&#039; + axisId + &#039;t&quot; class=&quot;&#039; + prefix + &#039;scrollbar-thumb&quot;&gt;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;);
            self.draghelper = new DragHelper(axisId + &#039;t&#039;, {
              start: function () {
                scrollStart = self.getEl(&#039;body&#039;)[&#039;scroll&#039; + posName];
                global$7(&#039;#&#039; + axisId).addClass(prefix + &#039;active&#039;);
              },
              drag: function (e) {
                var ratio, hasScrollH, hasScrollV, containerSize;
                var layoutRect = self.layoutRect();
                hasScrollH = layoutRect.contentW &gt; layoutRect.innerW;
                hasScrollV = layoutRect.contentH &gt; layoutRect.innerH;
                containerSize = self.getEl(&#039;body&#039;)[&#039;client&#039; + sizeName] - margin * 2;
                containerSize -= hasScrollH &amp;&amp; hasScrollV ? self.getEl(&#039;scroll&#039; + axisName)[&#039;client&#039; + ax] : 0;
                ratio = containerSize / self.getEl(&#039;body&#039;)[&#039;scroll&#039; + sizeName];
                self.getEl(&#039;body&#039;)[&#039;scroll&#039; + posName] = scrollStart + e[&#039;delta&#039; + deltaPosName] / ratio;
              },
              stop: function () {
                global$7(&#039;#&#039; + axisId).removeClass(prefix + &#039;active&#039;);
              }
            });
          }
          self.classes.add(&#039;scroll&#039;);
          addScrollAxis(&#039;v&#039;, &#039;Top&#039;, &#039;Height&#039;, &#039;Y&#039;, &#039;Width&#039;);
          addScrollAxis(&#039;h&#039;, &#039;Left&#039;, &#039;Width&#039;, &#039;X&#039;, &#039;Height&#039;);
        }
        if (self.settings.autoScroll) {
          if (!self._hasScroll) {
            self._hasScroll = true;
            addScroll();
            self.on(&#039;wheel&#039;, function (e) {
              var bodyEl = self.getEl(&#039;body&#039;);
              bodyEl.scrollLeft += (e.deltaX || 0) * 10;
              bodyEl.scrollTop += e.deltaY * 10;
              repaintScroll();
            });
            global$7(self.getEl(&#039;body&#039;)).on(&#039;scroll&#039;, repaintScroll);
          }
          repaintScroll();
        }
      }
    };

    var Panel = Container.extend({
      Defaults: {
        layout: &#039;fit&#039;,
        containerCls: &#039;panel&#039;
      },
      Mixins: [Scrollable],
      renderHtml: function () {
        var self = this;
        var layout = self._layout;
        var innerHtml = self.settings.html;
        self.preRender();
        layout.preRender(self);
        if (typeof innerHtml === &#039;undefined&#039;) {
          innerHtml = &#039;&lt;div id=&quot;&#039; + self._id + &#039;-body&quot; class=&quot;&#039; + self.bodyClasses + &#039;&quot;&gt;&#039; + layout.renderHtml(self) + &#039;&lt;/div&gt;&#039;;
        } else {
          if (typeof innerHtml === &#039;function&#039;) {
            innerHtml = innerHtml.call(self);
          }
          self._hasBody = false;
        }
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; hidefocus=&quot;1&quot; tabindex=&quot;-1&quot; role=&quot;group&quot;&gt;&#039; + (self._preBodyHtml || &#039;&#039;) + innerHtml + &#039;&lt;/div&gt;&#039;;
      }
    });

    var Resizable = {
      resizeToContent: function () {
        this._layoutRect.autoResize = true;
        this._lastRect = null;
        this.reflow();
      },
      resizeTo: function (w, h) {
        if (w &lt;= 1 || h &lt;= 1) {
          var rect = funcs.getWindowSize();
          w = w &lt;= 1 ? w * rect.w : w;
          h = h &lt;= 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(&#039;autohide&#039;, { 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(&#039;click touchstart&#039;, documentClickHandler);
      }
    }
    function bindDocumentScrollHandler() {
      if (!documentScrollHandler) {
        documentScrollHandler = function () {
          var i;
          i = visiblePanels.length;
          while (i--) {
            repositionPanel$1(visiblePanels[i]);
          }
        };
        global$7(domGlobals.window).on(&#039;scroll&#039;, 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(&#039;resize&#039;, windowResizeHandler);
      }
    }
    function repositionPanel$1(panel) {
      var scrollY = funcs.getViewPort().y;
      function toggleFixedChildPanels(fixed, deltaY) {
        var parent;
        for (var i = 0; i &lt; visiblePanels.length; i++) {
          if (visiblePanels[i] !== panel) {
            parent = visiblePanels[i].parent();
            while (parent &amp;&amp; (parent = parent.parent())) {
              if (parent === panel) {
                visiblePanels[i].fixed(fixed).moveBy(0, deltaY).repaint();
              }
            }
          }
        }
      }
      if (panel.settings.autofix) {
        if (!panel.state.get(&#039;fixed&#039;)) {
          panel._autoFixY = panel.layoutRect().y;
          if (panel._autoFixY &lt; scrollY) {
            panel.fixed(true).layoutRect({ y: 0 }).repaint();
            toggleFixedChildPanels(true, scrollY - panel._autoFixY);
          }
        } else {
          if (panel._autoFixY &gt; 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 &lt; 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(&#039;#&#039; + ctrl.classPrefix + &#039;modal-block&#039;, ctrl.getContainerElm())[0];
      if (topModal) {
        global$7(modalBlockEl).css(&#039;z-index&#039;, 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(&#039;floatpanel&#039;);
        if (settings.autohide) {
          bindDocumentClickHandler();
          bindWindowResizeHandler();
          visiblePanels.push(self);
        }
        if (settings.autofix) {
          bindDocumentScrollHandler();
          self.on(&#039;move&#039;, function () {
            repositionPanel$1(this);
          });
        }
        self.on(&#039;postrender show&#039;, function (e) {
          if (e.control === self) {
            var $modalBlockEl_1;
            var prefix_1 = self.classPrefix;
            if (self.modal &amp;&amp; !hasModal) {
              $modalBlockEl_1 = global$7(&#039;#&#039; + prefix_1 + &#039;modal-block&#039;, self.getContainerElm());
              if (!$modalBlockEl_1[0]) {
                $modalBlockEl_1 = global$7(&#039;&lt;div id=&quot;&#039; + prefix_1 + &#039;modal-block&quot; class=&quot;&#039; + prefix_1 + &#039;reset &#039; + prefix_1 + &#039;fade&quot;&gt;&lt;/div&gt;&#039;).appendTo(self.getContainerElm());
              }
              global$3.setTimeout(function () {
                $modalBlockEl_1.addClass(prefix_1 + &#039;in&#039;);
                global$7(self.getEl()).addClass(prefix_1 + &#039;in&#039;);
              });
              hasModal = true;
            }
            addRemove(true, self);
          }
        });
        self.on(&#039;show&#039;, function () {
          self.parents().each(function (ctrl) {
            if (ctrl.state.get(&#039;fixed&#039;)) {
              self.fixed(true);
              return false;
            }
          });
        });
        if (settings.popover) {
          self._preBodyHtml = &#039;&lt;div class=&quot;&#039; + self.classPrefix + &#039;arrow&quot;&gt;&lt;/div&gt;&#039;;
          self.classes.add(&#039;popover&#039;).add(&#039;bottom&#039;).add(self.isRtl() ? &#039;end&#039; : &#039;start&#039;);
        }
        self.aria(&#039;label&#039;, settings.ariaLabel);
        self.aria(&#039;labelledby&#039;, self._id);
        self.aria(&#039;describedby&#039;, self.describedBy || self._id + &#039;-none&#039;);
      },
      fixed: function (state) {
        var self = this;
        if (self.state.get(&#039;fixed&#039;) !== state) {
          if (self.state.get(&#039;rendered&#039;)) {
            var viewport = funcs.getViewPort();
            if (state) {
              self.layoutRect().y -= viewport.y;
            } else {
              self.layoutRect().y += viewport.y;
            }
          }
          self.classes.toggle(&#039;fixed&#039;, state);
          self.state.set(&#039;fixed&#039;, 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(&#039;close&#039;).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(&#039;body&#039;).setAttribute(&#039;role&#039;, self.settings.bodyRole);
        }
        return self._super();
      }
    });
    FloatPanel.hideAll = function () {
      var i = visiblePanels.length;
      while (i--) {
        var panel = visiblePanels[i];
        if (panel &amp;&amp; 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 = &#039;&#039;;
    function toggleFullScreenState(state) {
      var noScaleMetaValue = &#039;width=device-width,initial-scale=1.0,user-scalable=0,minimum-scale=1.0,maximum-scale=1.0&#039;;
      var viewport = global$7(&#039;meta[name=viewport]&#039;)[0], contentValue;
      if (global$1.overrideViewPort === false) {
        return;
      }
      if (!viewport) {
        viewport = domGlobals.document.createElement(&#039;meta&#039;);
        viewport.setAttribute(&#039;name&#039;, &#039;viewport&#039;);
        domGlobals.document.getElementsByTagName(&#039;head&#039;)[0].appendChild(viewport);
      }
      contentValue = viewport.getAttribute(&#039;content&#039;);
      if (contentValue &amp;&amp; typeof oldMetaValue !== &#039;undefined&#039;) {
        oldMetaValue = contentValue;
      }
      viewport.setAttribute(&#039;content&#039;, state ? noScaleMetaValue : oldMetaValue);
    }
    function toggleBodyFullScreenClasses(classPrefix, state) {
      if (checkFullscreenWindows() &amp;&amp; state === false) {
        global$7([
          domGlobals.document.documentElement,
          domGlobals.document.body
        ]).removeClass(classPrefix + &#039;fullscreen&#039;);
      }
    }
    function checkFullscreenWindows() {
      for (var i = 0; i &lt; 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(&#039;resize&#039;);
          }
        }, 100);
      }
      function reposition() {
        var i;
        var rect = funcs.getWindowSize();
        var layoutRect;
        for (i = 0; i &lt; 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(&#039;resize&#039;, reposition);
    }
    var Window = FloatPanel.extend({
      modal: true,
      Defaults: {
        border: 1,
        layout: &#039;flex&#039;,
        containerCls: &#039;panel&#039;,
        role: &#039;dialog&#039;,
        callbacks: {
          submit: function () {
            this.fire(&#039;submit&#039;, { data: this.toJSON() });
          },
          close: function () {
            this.close();
          }
        }
      },
      init: function (settings) {
        var self = this;
        self._super(settings);
        if (self.isRtl()) {
          self.classes.add(&#039;rtl&#039;);
        }
        self.classes.add(&#039;window&#039;);
        self.bodyClasses.add(&#039;window-body&#039;);
        self.state.set(&#039;fixed&#039;, true);
        if (settings.buttons) {
          self.statusbar = new Panel({
            layout: &#039;flex&#039;,
            border: &#039;1 0 0 0&#039;,
            spacing: 3,
            padding: 10,
            align: &#039;center&#039;,
            pack: self.isRtl() ? &#039;start&#039; : &#039;end&#039;,
            defaults: { type: &#039;button&#039; },
            items: settings.buttons
          });
          self.statusbar.classes.add(&#039;foot&#039;);
          self.statusbar.parent(self);
        }
        self.on(&#039;click&#039;, function (e) {
          var closeClass = self.classPrefix + &#039;close&#039;;
          if (funcs.hasClass(e.target, closeClass) || funcs.hasClass(e.target.parentNode, closeClass)) {
            self.close();
          }
        });
        self.on(&#039;cancel&#039;, function () {
          self.close();
        });
        self.on(&#039;move&#039;, function (e) {
          if (e.control === self) {
            FloatPanel.hideAll();
          }
        });
        self.aria(&#039;describedby&#039;, self.describedBy || self._id + &#039;-none&#039;);
        self.aria(&#039;label&#039;, 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 &amp;&amp; !self._fullscreen) {
          width = layoutRect.headerW;
          if (width &gt; 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 &gt; 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 &amp;&amp; !self._fullscreen) {
          headEl = self.getEl(&#039;head&#039;);
          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 = &#039;&#039;, footerHtml = &#039;&#039;, html = settings.html;
        self.preRender();
        layout.preRender(self);
        if (settings.title) {
          headerHtml = &#039;&lt;div id=&quot;&#039; + id + &#039;-head&quot; class=&quot;&#039; + prefix + &#039;window-head&quot;&gt;&#039; + &#039;&lt;div id=&quot;&#039; + id + &#039;-title&quot; class=&quot;&#039; + prefix + &#039;title&quot;&gt;&#039; + self.encode(settings.title) + &#039;&lt;/div&gt;&#039; + &#039;&lt;div id=&quot;&#039; + id + &#039;-dragh&quot; class=&quot;&#039; + prefix + &#039;dragh&quot;&gt;&lt;/div&gt;&#039; + &#039;&lt;button type=&quot;button&quot; class=&quot;&#039; + prefix + &#039;close&quot; aria-hidden=&quot;true&quot;&gt;&#039; + &#039;&lt;i class=&quot;mce-ico mce-i-remove&quot;&gt;&lt;/i&gt;&#039; + &#039;&lt;/button&gt;&#039; + &#039;&lt;/div&gt;&#039;;
        }
        if (settings.url) {
          html = &#039;&lt;iframe src=&quot;&#039; + settings.url + &#039;&quot; tabindex=&quot;-1&quot;&gt;&lt;/iframe&gt;&#039;;
        }
        if (typeof html === &#039;undefined&#039;) {
          html = layout.renderHtml(self);
        }
        if (self.statusbar) {
          footerHtml = self.statusbar.renderHtml();
        }
        return &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; hidefocus=&quot;1&quot;&gt;&#039; + &#039;&lt;div class=&quot;&#039; + self.classPrefix + &#039;reset&quot; role=&quot;application&quot;&gt;&#039; + headerHtml + &#039;&lt;div id=&quot;&#039; + id + &#039;-body&quot; class=&quot;&#039; + self.bodyClasses + &#039;&quot;&gt;&#039; + html + &#039;&lt;/div&gt;&#039; + footerHtml + &#039;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      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(&#039;resize&#039;, 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 &gt; 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(&#039;head&#039;).style.display = &#039;&#039;;
            layoutRect.deltaH += layoutRect.headerH;
            global$7([
              documentElement,
              domGlobals.document.body
            ]).removeClass(prefix + &#039;fullscreen&#039;);
            self.classes.remove(&#039;fullscreen&#039;);
            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(&#039;0&#039;);
            self.getEl(&#039;head&#039;).style.display = &#039;none&#039;;
            layoutRect.deltaH -= layoutRect.headerH + 2;
            global$7([
              documentElement,
              domGlobals.document.body
            ]).addClass(prefix + &#039;fullscreen&#039;);
            self.classes.add(&#039;fullscreen&#039;);
            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(&#039;in&#039;);
          self.fire(&#039;open&#039;);
        }, 0);
        self._super();
        if (self.statusbar) {
          self.statusbar.postRender();
        }
        self.focus();
        this.dragHelper = new DragHelper(self._id + &#039;-dragh&#039;, {
          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(&#039;submit&#039;, function (e) {
          if (!e.isDefaultPrevented()) {
            self.close();
          }
        });
        windows.push(self);
        toggleFullScreenState(true);
      },
      submit: function () {
        return this.fire(&#039;submit&#039;, { 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 &gt; 0);
      },
      getContentWindow: function () {
        var ifr = this.getEl().getElementsByTagName(&#039;iframe&#039;)[0];
        return ifr ? ifr.contentWindow : null;
      }
    });
    handleWindowResize();

    var MessageBox = Window.extend({
      init: function (settings) {
        settings = {
          border: 1,
          padding: 20,
          layout: &#039;flex&#039;,
          pack: &#039;center&#039;,
          align: &#039;center&#039;,
          containerCls: &#039;panel&#039;,
          autoScroll: true,
          buttons: {
            type: &#039;button&#039;,
            text: &#039;Ok&#039;,
            action: &#039;ok&#039;
          },
          items: {
            type: &#039;label&#039;,
            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: &#039;button&#039;,
              text: text,
              subtype: primary ? &#039;primary&#039; : &#039;&#039;,
              onClick: function (e) {
                e.control.parents()[1].close();
                callback(status);
              }
            };
          }
          switch (settings.buttons) {
          case MessageBox.OK_CANCEL:
            buttons = [
              createButton(&#039;Ok&#039;, true, true),
              createButton(&#039;Cancel&#039;, false)
            ];
            break;
          case MessageBox.YES_NO:
          case MessageBox.YES_NO_CANCEL:
            buttons = [
              createButton(&#039;Yes&#039;, 1, true),
              createButton(&#039;No&#039;, 0)
            ];
            if (settings.buttons === MessageBox.YES_NO_CANCEL) {
              buttons.push(createButton(&#039;Cancel&#039;, -1));
            }
            break;
          default:
            buttons = [createButton(&#039;Ok&#039;, true, true)];
            break;
          }
          return new Window({
            padding: 20,
            x: settings.x,
            y: settings.y,
            minWidth: 300,
            minHeight: 100,
            layout: &#039;flex&#039;,
            pack: &#039;center&#039;,
            align: &#039;center&#039;,
            buttons: buttons,
            title: settings.title,
            role: &#039;alertdialog&#039;,
            items: {
              type: &#039;label&#039;,
              multiline: true,
              maxWidth: 500,
              maxHeight: 200,
              text: settings.text
            },
            onPostRender: function () {
              this.aria(&#039;describedby&#039;, this.items()[0]._id);
            },
            onClose: settings.onClose,
            onCancel: function () {
              callback(false);
            }
          }).renderTo(domGlobals.document.body).reflow();
        },
        alert: function (settings, callback) {
          if (typeof settings === &#039;string&#039;) {
            settings = { text: settings };
          }
          settings.callback = callback;
          return MessageBox.msgBox(settings);
        },
        confirm: function (settings, callback) {
          if (typeof settings === &#039;string&#039;) {
            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 || &#039; &#039;;
        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 || &#039;form&#039;,
            items: args.body,
            data: args.data,
            callbacks: args.commands
          };
        }
        if (!args.url &amp;&amp; !args.buttons) {
          args.buttons = [
            {
              text: &#039;Ok&#039;,
              subtype: &#039;primary&#039;,
              onclick: function () {
                win.find(&#039;form&#039;)[0].submit();
              }
            },
            {
              text: &#039;Cancel&#039;,
              onclick: function () {
                win.close();
              }
            }
          ];
        }
        win = new Window(args);
        win.on(&#039;close&#039;, function () {
          closeCallback(win);
        });
        if (args.data) {
          win.on(&#039;postRender&#039;, function () {
            this.find(&#039;*&#039;).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(&#039;close&#039;, function () {
          closeCallback(win);
        });
        return win;
      };
      var confirm = function (message, choiceCallback, closeCallback) {
        var win;
        win = MessageBox.confirm(message, function (state) {
          choiceCallback(state);
        });
        win.on(&#039;close&#039;, 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 !== &#039;undefined&#039; ? domGlobals.window : Function(&#039;return this;&#039;)();

    var path = function (parts, scope) {
      var o = scope !== undefined &amp;&amp; scope !== null ? scope : Global;
      for (var i = 0; i &lt; parts.length &amp;&amp; o !== undefined &amp;&amp; o !== null; ++i) {
        o = o[parts[i]];
      }
      return o;
    };
    var resolve = function (p, scope) {
      var parts = p.split(&#039;.&#039;);
      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 + &#039; not available on this browser&#039;);
      }
      return actual;
    };
    var Global$1 = { getOrDie: getOrDie };

    function FileReader () {
      var f = Global$1.getOrDie(&#039;FileReader&#039;);
      return new f();
    }

    var global$c = tinymce.util.Tools.resolve(&#039;tinymce.util.Promise&#039;);

    var blobToBase64 = function (blob) {
      return new global$c(function (resolve) {
        var reader = FileReader();
        reader.onloadend = function () {
          resolve(reader.result.split(&#039;,&#039;)[1]);
        };
        reader.readAsDataURL(blob);
      });
    };
    var Conversions = { blobToBase64: blobToBase64 };

    var pickFile = function () {
      return new global$c(function (resolve) {
        var fileInput;
        fileInput = domGlobals.document.createElement(&#039;input&#039;);
        fileInput.type = &#039;file&#039;;
        fileInput.style.position = &#039;fixed&#039;;
        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 &#039;s&#039; + 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 ? &#039;startContainer&#039; : &#039;endContainer&#039;];
        offset = rng[start ? &#039;startOffset&#039; : &#039;endOffset&#039;];
        if (container.nodeType === 1) {
          offsetNode = dom.create(&#039;span&#039;, { &#039;data-mce-type&#039;: &#039;bookmark&#039; });
          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 ? &#039;startContainer&#039; : &#039;endContainer&#039;] = container;
        bookmark[start ? &#039;startOffset&#039; : &#039;endOffset&#039;] = 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(&#039;data-mce-type&#039;) !== &#039;bookmark&#039;) {
              idx++;
            }
            node = node.nextSibling;
          }
          return -1;
        }
        container = node = bookmark[start ? &#039;startContainer&#039; : &#039;endContainer&#039;];
        offset = bookmark[start ? &#039;startOffset&#039; : &#039;endOffset&#039;];
        if (!container) {
          return;
        }
        if (container.nodeType === 1) {
          offset = nodeIndex(container);
          container = container.parentNode;
          dom.remove(node);
        }
        bookmark[start ? &#039;startContainer&#039; : &#039;endContainer&#039;] = container;
        bookmark[start ? &#039;startOffset&#039; : &#039;endOffset&#039;] = 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(&#039;tinymce.dom.TreeWalker&#039;);

    var global$e = tinymce.util.Tools.resolve(&#039;tinymce.dom.RangeUtils&#039;);

    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 === &#039;A&#039; &amp;&amp; elm.hasAttribute(&#039;href&#039;);
    };
    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 = &#039;&lt;table data-mce-id=&quot;mce&quot; style=&quot;width: 100%&quot;&gt;&#039;;
      html += &#039;&lt;tbody&gt;&#039;;
      for (y = 0; y &lt; rows; y++) {
        html += &#039;&lt;tr&gt;&#039;;
        for (x = 0; x &lt; cols; x++) {
          html += &#039;&lt;td&gt;&lt;br&gt;&lt;/td&gt;&#039;;
        }
        html += &#039;&lt;/tr&gt;&#039;;
      }
      html += &#039;&lt;/tbody&gt;&#039;;
      html += &#039;&lt;/table&gt;&#039;;
      return html;
    };
    var getInsertedElement = function (editor) {
      var elms = editor.dom.select(&#039;*[data-mce-id]&#039;);
      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(&#039;data-mce-id&#039;);
        cellElm = editor.dom.select(&#039;td,th&#039;, 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(&#039;FormatBlock&#039;, false, formatName);
    };
    var insertBlob = function (editor, base64, blob) {
      var blobCache, blobInfo;
      blobCache = editor.editorUpload.blobCache;
      blobInfo = blobCache.create(Uuid.uuid(&#039;mceu&#039;), blob, base64);
      blobCache.add(blobInfo);
      editor.insertContent(editor.dom.createHTML(&#039;img&#039;, { 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, &#039;href&#039;, url);
      collapseSelectionToEnd(editor);
    };
    var insertLink = function (editor, url) {
      editor.execCommand(&#039;mceInsertLink&#039;, false, { href: url });
      collapseSelectionToEnd(editor);
    };
    var updateOrInsertLink = function (editor, url) {
      var elm = editor.dom.getParent(editor.selection.getStart(), &#039;a[href]&#039;);
      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 &lt; 6; i++) {
        var name = &#039;h&#039; + i;
        editor.addButton(name, {
          text: name.toUpperCase(),
          tooltip: &#039;Heading &#039; + i,
          stateSelector: name,
          onclick: formatBlock(name),
          onPostRender: function () {
            var span = this.getEl().firstChild.firstChild;
            span.style.fontWeight = &#039;bold&#039;;
          }
        });
      }
    };
    var addToEditor = function (editor, panel) {
      editor.addButton(&#039;quicklink&#039;, {
        icon: &#039;link&#039;,
        tooltip: &#039;Insert/Edit link&#039;,
        stateSelector: &#039;a[href]&#039;,
        onclick: function () {
          panel.showForm(editor, &#039;quicklink&#039;);
        }
      });
      editor.addButton(&#039;quickimage&#039;, {
        icon: &#039;image&#039;,
        tooltip: &#039;Insert image&#039;,
        onclick: function () {
          Picker.pickFile().then(function (files) {
            var blob = files[0];
            Conversions.blobToBase64(blob).then(function (base64) {
              Actions.insertBlob(editor, base64, blob);
            });
          });
        }
      });
      editor.addButton(&#039;quicktable&#039;, {
        icon: &#039;table&#039;,
        tooltip: &#039;Insert table&#039;,
        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 &amp;&amp; global$2.DOM.getStyle(uiContainer, &#039;position&#039;, true) !== &#039;static&#039;) {
        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(&#039;textbox&#039;).eq(0).each(function (ctrl) {
        ctrl.focus();
      });
    };
    var createForm = function (name, spec) {
      var form = global$b.create(global$4.extend({
        type: &#039;form&#039;,
        layout: &#039;flex&#039;,
        direction: &#039;row&#039;,
        padding: 5,
        name: name,
        spacing: 3
      }, spec));
      form.on(&#039;show&#039;, 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(&#039;The URL you entered seems to be an external link. Do you want to add the required http:// prefix?&#039;, function (result) {
          var output = result === true ? &#039;http://&#039; + href : href;
          resolve(output);
        });
      });
    };
    var convertLinkToAbsolute = function (editor, href) {
      return !UrlType.isAbsolute(href) &amp;&amp; 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 &amp;&amp; meta.attach) {
          attachState = {
            href: this.value(),
            attach: meta.attach
          };
        }
      };
      var onShowHandler = function (e) {
        if (e.control === this) {
          var elm = void 0, linkurl = &#039;&#039;;
          elm = editor.dom.getParent(editor.selection.getStart(), &#039;a[href]&#039;);
          if (elm) {
            linkurl = editor.dom.getAttrib(elm, &#039;href&#039;);
          }
          this.fromJSON({ linkurl: linkurl });
          toggleVisibility(this.find(&#039;#unlink&#039;), elm);
          this.find(&#039;#linkurl&#039;)[0].focus();
        }
      };
      return createForm(&#039;quicklink&#039;, {
        items: [
          {
            type: &#039;button&#039;,
            name: &#039;unlink&#039;,
            icon: &#039;unlink&#039;,
            onclick: unlink,
            tooltip: &#039;Remove link&#039;
          },
          {
            type: &#039;filepicker&#039;,
            name: &#039;linkurl&#039;,
            placeholder: &#039;Paste or type a link&#039;,
            filetype: &#039;file&#039;,
            onchange: onChangeHandler
          },
          {
            type: &#039;button&#039;,
            icon: &#039;checkmark&#039;,
            subtype: &#039;primary&#039;,
            tooltip: &#039;Ok&#039;,
            onclick: &#039;submit&#039;
          }
        ],
        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 === &#039;|&#039;) {
          buttonGroup = null;
        } else {
          if (editor.buttons[item]) {
            if (!buttonGroup) {
              buttonGroup = {
                type: &#039;buttongroup&#039;,
                items: []
              };
              toolbarItems.push(buttonGroup);
            }
            var button = editor.buttons[item];
            if (Type.isFunction(button)) {
              button = button();
            }
            button.type = button.type || &#039;button&#039;;
            button = global$b.create(button);
            button.on(&#039;postRender&#039;, bindSelectorChanged(editor, item, button));
            buttonGroup.items.push(button);
          }
        }
      });
      return global$b.create({
        type: &#039;toolbar&#039;,
        layout: &#039;flow&#039;,
        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 &gt; 0;
      };
      var create = function (editor, toolbars) {
        var items = createToolbars(editor, toolbars).concat([
          Toolbar.create(editor, &#039;text&#039;, Settings.getTextSelectionToolbarItems(editor)),
          Toolbar.create(editor, &#039;insert&#039;, Settings.getInsertToolbarItems(editor)),
          Forms.createQuickLinkForm(editor, hide)
        ]);
        return global$b.create({
          type: &#039;floatpanel&#039;,
          role: &#039;dialog&#039;,
          classes: &#039;tinymce tinymce-inline arrow&#039;,
          ariaLabel: &#039;Inline toolbar&#039;,
          layout: &#039;flex&#039;,
          direction: &#039;column&#039;,
          align: &#039;stretch&#039;,
          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) : &#039;&#039;;
        global$4.each({
          t: &#039;down&#039;,
          b: &#039;up&#039;,
          c: &#039;center&#039;
        }, function (cls, pos) {
          panel.classes.toggle(&#039;arrow-&#039; + cls, pos === relPos.substr(0, 1));
        });
        if (relPos === &#039;cr&#039;) {
          panel.classes.toggle(&#039;arrow-left&#039;, true);
          panel.classes.toggle(&#039;arrow-right&#039;, false);
        } else if (relPos === &#039;cl&#039;) {
          panel.classes.toggle(&#039;arrow-left&#039;, false);
          panel.classes.toggle(&#039;arrow-right&#039;, true);
        } else {
          global$4.each({
            l: &#039;left&#039;,
            r: &#039;right&#039;
          }, function (cls, pos) {
            panel.classes.toggle(&#039;arrow-&#039; + cls, pos === relPos.substr(1, 1));
          });
        }
      };
      var showToolbar = function (panel, id) {
        var toolbars = panel.items().filter(&#039;#&#039; + id);
        if (toolbars.length &gt; 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 === &#039;insert&#039;) {
          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(&#039;form:visible&#039;).length &gt; 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(&#039;toolbar:visible&#039;).eq(0).each(function (item) {
            item.focus(true);
          });
        }
      };
      var remove = function () {
        if (panel) {
          panel.remove();
          panel = null;
        }
      };
      var inForm = function () {
        return panel &amp;&amp; panel.visible() &amp;&amp; hasFormVisible();
      };
      return {
        show: show,
        showForm: showForm,
        reposition: reposition,
        inForm: inForm,
        hide: hide,
        focus: focus,
        remove: remove
      };
    };

    var Layout$1 = global$8.extend({
      Defaults: {
        firstControlClass: &#039;first&#039;,
        lastControlClass: &#039;last&#039;
      },
      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 = &#039;&#039;;
        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: &#039;abs-layout&#039;,
        controlClass: &#039;abs-layout-item&#039;
      },
      recalc: function (container) {
        container.items().filter(&#039;:visible&#039;).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 &#039;&lt;div id=&quot;&#039; + container._id + &#039;-absend&quot; class=&quot;&#039; + container.classPrefix + &#039;abs-end&quot;&gt;&lt;/div&gt;&#039; + this._super(container);
      }
    });

    var Button = Widget.extend({
      Defaults: {
        classes: &#039;widget btn&#039;,
        role: &#039;button&#039;
      },
      init: function (settings) {
        var self = this;
        var size;
        self._super(settings);
        settings = self.settings;
        size = self.settings.size;
        self.on(&#039;click mousedown&#039;, function (e) {
          e.preventDefault();
        });
        self.on(&#039;touchstart&#039;, function (e) {
          self.fire(&#039;click&#039;, e);
          e.preventDefault();
        });
        if (settings.subtype) {
          self.classes.add(settings.subtype);
        }
        if (size) {
          self.classes.add(&#039;btn-&#039; + size);
        }
        if (settings.icon) {
          self.icon(settings.icon);
        }
      },
      icon: function (icon) {
        if (!arguments.length) {
          return this.state.get(&#039;icon&#039;);
        }
        this.state.set(&#039;icon&#039;, icon);
        return this;
      },
      repaint: function () {
        var btnElm = this.getEl().firstChild;
        var btnStyle;
        if (btnElm) {
          btnStyle = btnElm.style;
          btnStyle.width = btnStyle.height = &#039;100%&#039;;
        }
        this._super();
      },
      renderHtml: function () {
        var self = this, id = self._id, prefix = self.classPrefix;
        var icon = self.state.get(&#039;icon&#039;), image;
        var text = self.state.get(&#039;text&#039;);
        var textHtml = &#039;&#039;;
        var ariaPressed;
        var settings = self.settings;
        image = settings.image;
        if (image) {
          icon = &#039;none&#039;;
          if (typeof image !== &#039;string&#039;) {
            image = domGlobals.window.getSelection ? image[0] : image[1];
          }
          image = &#039; style=&quot;background-image: url(\&#039;&#039; + image + &#039;\&#039;)&quot;&#039;;
        } else {
          image = &#039;&#039;;
        }
        if (text) {
          self.classes.add(&#039;btn-has-text&#039;);
          textHtml = &#039;&lt;span class=&quot;&#039; + prefix + &#039;txt&quot;&gt;&#039; + self.encode(text) + &#039;&lt;/span&gt;&#039;;
        }
        icon = icon ? prefix + &#039;ico &#039; + prefix + &#039;i-&#039; + icon : &#039;&#039;;
        ariaPressed = typeof settings.active === &#039;boolean&#039; ? &#039; aria-pressed=&quot;&#039; + settings.active + &#039;&quot;&#039; : &#039;&#039;;
        return &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; tabindex=&quot;-1&quot;&#039; + ariaPressed + &#039;&gt;&#039; + &#039;&lt;button id=&quot;&#039; + id + &#039;-button&quot; role=&quot;presentation&quot; type=&quot;button&quot; tabindex=&quot;-1&quot;&gt;&#039; + (icon ? &#039;&lt;i class=&quot;&#039; + icon + &#039;&quot;&#039; + image + &#039;&gt;&lt;/i&gt;&#039; : &#039;&#039;) + textHtml + &#039;&lt;/button&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      bindStates: function () {
        var self = this, $ = self.$, textCls = self.classPrefix + &#039;txt&#039;;
        function setButtonText(text) {
          var $span = $(&#039;span.&#039; + textCls, self.getEl());
          if (text) {
            if (!$span[0]) {
              $(&#039;button:first&#039;, self.getEl()).append(&#039;&lt;span class=&quot;&#039; + textCls + &#039;&quot;&gt;&lt;/span&gt;&#039;);
              $span = $(&#039;span.&#039; + textCls, self.getEl());
            }
            $span.html(self.encode(text));
          } else {
            $span.remove();
          }
          self.classes.toggle(&#039;btn-has-text&#039;, !!text);
        }
        self.state.on(&#039;change:text&#039;, function (e) {
          setButtonText(e.value);
        });
        self.state.on(&#039;change:icon&#039;, function (e) {
          var icon = e.value;
          var prefix = self.classPrefix;
          self.settings.icon = icon;
          icon = icon ? prefix + &#039;ico &#039; + prefix + &#039;i-&#039; + self.settings.icon : &#039;&#039;;
          var btnElm = self.getEl().firstChild;
          var iconElm = btnElm.getElementsByTagName(&#039;i&#039;)[0];
          if (icon) {
            if (!iconElm || iconElm !== btnElm.firstChild) {
              iconElm = domGlobals.document.createElement(&#039;i&#039;);
              btnElm.insertBefore(iconElm, btnElm.firstChild);
            }
            iconElm.className = icon;
          } else if (iconElm) {
            btnElm.removeChild(iconElm);
          }
          setButtonText(self.state.get(&#039;text&#039;));
        });
        return self._super();
      }
    });

    var BrowseButton = Button.extend({
      init: function (settings) {
        var self = this;
        settings = global$4.extend({
          text: &#039;Browse...&#039;,
          multiple: false,
          accept: null
        }, settings);
        self._super(settings);
        self.classes.add(&#039;browsebutton&#039;);
        if (settings.multiple) {
          self.classes.add(&#039;multiple&#039;);
        }
      },
      postRender: function () {
        var self = this;
        var input = funcs.create(&#039;input&#039;, {
          type: &#039;file&#039;,
          id: self._id + &#039;-browse&#039;,
          accept: self.settings.accept
        });
        self._super();
        global$7(input).on(&#039;change&#039;, 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(&#039;change&#039;, e);
          }
        });
        global$7(input).on(&#039;click&#039;, function (e) {
          e.stopPropagation();
        });
        global$7(self.getEl(&#039;button&#039;)).on(&#039;click touchstart&#039;, function (e) {
          e.stopPropagation();
          input.click();
          e.preventDefault();
        });
        self.getEl().appendChild(input);
      },
      remove: function () {
        global$7(this.getEl(&#039;button&#039;)).off();
        global$7(this.getEl(&#039;input&#039;)).off();
        this._super();
      }
    });

    var ButtonGroup = Container.extend({
      Defaults: {
        defaultType: &#039;button&#039;,
        role: &#039;group&#039;
      },
      renderHtml: function () {
        var self = this, layout = self._layout;
        self.classes.add(&#039;btn-group&#039;);
        self.preRender();
        layout.preRender(self);
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&gt;&#039; + &#039;&lt;div id=&quot;&#039; + self._id + &#039;-body&quot;&gt;&#039; + (self.settings.html || &#039;&#039;) + layout.renderHtml(self) + &#039;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      }
    });

    var Checkbox = Widget.extend({
      Defaults: {
        classes: &#039;checkbox&#039;,
        role: &#039;checkbox&#039;,
        checked: false
      },
      init: function (settings) {
        var self = this;
        self._super(settings);
        self.on(&#039;click mousedown&#039;, function (e) {
          e.preventDefault();
        });
        self.on(&#039;click&#039;, 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(&#039;checked&#039;);
        }
        this.state.set(&#039;checked&#039;, 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 &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; unselectable=&quot;on&quot; aria-labelledby=&quot;&#039; + id + &#039;-al&quot; tabindex=&quot;-1&quot;&gt;&#039; + &#039;&lt;i class=&quot;&#039; + prefix + &#039;ico &#039; + prefix + &#039;i-checkbox&quot;&gt;&lt;/i&gt;&#039; + &#039;&lt;span id=&quot;&#039; + id + &#039;-al&quot; class=&quot;&#039; + prefix + &#039;label&quot;&gt;&#039; + self.encode(self.state.get(&#039;text&#039;)) + &#039;&lt;/span&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      bindStates: function () {
        var self = this;
        function checked(state) {
          self.classes.toggle(&#039;checked&#039;, state);
          self.aria(&#039;checked&#039;, state);
        }
        self.state.on(&#039;change:text&#039;, function (e) {
          self.getEl(&#039;al&#039;).firstChild.data = self.translate(e.value);
        });
        self.state.on(&#039;change:checked change:value&#039;, function (e) {
          self.fire(&#039;change&#039;);
          checked(e.value);
        });
        self.state.on(&#039;change:icon&#039;, function (e) {
          var icon = e.value;
          var prefix = self.classPrefix;
          if (typeof icon === &#039;undefined&#039;) {
            return self.settings.icon;
          }
          self.settings.icon = icon;
          icon = icon ? prefix + &#039;ico &#039; + prefix + &#039;i-&#039; + self.settings.icon : &#039;&#039;;
          var btnElm = self.getEl().firstChild;
          var iconElm = btnElm.getElementsByTagName(&#039;i&#039;)[0];
          if (icon) {
            if (!iconElm || iconElm !== btnElm.firstChild) {
              iconElm = domGlobals.document.createElement(&#039;i&#039;);
              btnElm.insertBefore(iconElm, btnElm.firstChild);
            }
            iconElm.className = icon;
          } else if (iconElm) {
            btnElm.removeChild(iconElm);
          }
        });
        if (self.state.get(&#039;checked&#039;)) {
          checked(true);
        }
        return self._super();
      }
    });

    var global$f = tinymce.util.Tools.resolve(&#039;tinymce.util.VK&#039;);

    var ComboBox = Widget.extend({
      init: function (settings) {
        var self = this;
        self._super(settings);
        settings = self.settings;
        self.classes.add(&#039;combobox&#039;);
        self.subinput = true;
        self.ariaTarget = &#039;inp&#039;;
        settings.menu = settings.menu || settings.values;
        if (settings.menu) {
          settings.icon = &#039;caret&#039;;
        }
        self.on(&#039;click&#039;, function (e) {
          var elm = e.target;
          var root = self.getEl();
          if (!global$7.contains(root, elm) &amp;&amp; elm !== root) {
            return;
          }
          while (elm &amp;&amp; elm !== root) {
            if (elm.id &amp;&amp; elm.id.indexOf(&#039;-open&#039;) !== -1) {
              self.fire(&#039;action&#039;);
              if (settings.menu) {
                self.showMenu();
                if (e.aria) {
                  self.menu.items()[0].focus();
                }
              }
            }
            elm = elm.parentNode;
          }
        });
        self.on(&#039;keydown&#039;, function (e) {
          var rootControl;
          if (e.keyCode === 13 &amp;&amp; e.target.nodeName === &#039;INPUT&#039;) {
            e.preventDefault();
            self.parents().reverse().each(function (ctrl) {
              if (ctrl.toJSON) {
                rootControl = ctrl;
                return false;
              }
            });
            self.fire(&#039;submit&#039;, { data: rootControl.toJSON() });
          }
        });
        self.on(&#039;keyup&#039;, function (e) {
          if (e.target.nodeName === &#039;INPUT&#039;) {
            var oldValue = self.state.get(&#039;value&#039;);
            var newValue = e.target.value;
            if (newValue !== oldValue) {
              self.state.set(&#039;value&#039;, newValue);
              self.fire(&#039;autocomplete&#039;, e);
            }
          }
        });
        self.on(&#039;mouseover&#039;, function (e) {
          var tooltip = self.tooltip().moveTo(-65535);
          if (self.statusLevel() &amp;&amp; e.target.className.indexOf(self.classPrefix + &#039;status&#039;) !== -1) {
            var statusMessage = self.statusMessage() || &#039;Ok&#039;;
            var rel = tooltip.text(statusMessage).show().testMoveRel(e.target, [
              &#039;bc-tc&#039;,
              &#039;bc-tl&#039;,
              &#039;bc-tr&#039;
            ]);
            tooltip.classes.toggle(&#039;tooltip-n&#039;, rel === &#039;bc-tc&#039;);
            tooltip.classes.toggle(&#039;tooltip-nw&#039;, rel === &#039;bc-tl&#039;);
            tooltip.classes.toggle(&#039;tooltip-ne&#039;, rel === &#039;bc-tr&#039;);
            tooltip.moveRel(e.target, rel);
          }
        });
      },
      statusLevel: function (value) {
        if (arguments.length &gt; 0) {
          this.state.set(&#039;statusLevel&#039;, value);
        }
        return this.state.get(&#039;statusLevel&#039;);
      },
      statusMessage: function (value) {
        if (arguments.length &gt; 0) {
          this.state.set(&#039;statusMessage&#039;, value);
        }
        return this.state.get(&#039;statusMessage&#039;);
      },
      showMenu: function () {
        var self = this;
        var settings = self.settings;
        var menu;
        if (!self.menu) {
          menu = settings.menu || [];
          if (menu.length) {
            menu = {
              type: &#039;menu&#039;,
              items: menu
            };
          } else {
            menu.type = menu.type || &#039;menu&#039;;
          }
          self.menu = global$b.create(menu).parent(self).renderTo(self.getContainerElm());
          self.fire(&#039;createmenu&#039;);
          self.menu.reflow();
          self.menu.on(&#039;cancel&#039;, function (e) {
            if (e.control === self.menu) {
              self.focus();
            }
          });
          self.menu.on(&#039;show hide&#039;, function (e) {
            e.control.items().each(function (ctrl) {
              ctrl.active(ctrl.value() === self.value());
            });
          }).fire(&#039;show&#039;);
          self.menu.on(&#039;select&#039;, function (e) {
            self.value(e.control.value());
          });
          self.on(&#039;focusin&#039;, function (e) {
            if (e.target.tagName.toUpperCase() === &#039;INPUT&#039;) {
              self.menu.hide();
            }
          });
          self.aria(&#039;expanded&#039;, true);
        }
        self.menu.show();
        self.menu.layoutRect({ w: self.layoutRect().w });
        self.menu.moveRel(self.getEl(), self.isRtl() ? [
          &#039;br-tr&#039;,
          &#039;tr-br&#039;
        ] : [
          &#039;bl-tl&#039;,
          &#039;tl-bl&#039;
        ]);
      },
      focus: function () {
        this.getEl(&#039;inp&#039;).focus();
      },
      repaint: function () {
        var self = this, elm = self.getEl(), openElm = self.getEl(&#039;open&#039;), rect = self.layoutRect();
        var width, lineHeight, innerPadding = 0;
        var inputElm = elm.firstChild;
        if (self.statusLevel() &amp;&amp; self.statusLevel() !== &#039;none&#039;) {
          innerPadding = parseInt(funcs.getRuntimeStyle(inputElm, &#039;padding-right&#039;), 10) - parseInt(funcs.getRuntimeStyle(inputElm, &#039;padding-left&#039;), 10);
        }
        if (openElm) {
          width = rect.w - funcs.getSize(openElm).width - 10;
        } else {
          width = rect.w - 10;
        }
        var doc = domGlobals.document;
        if (doc.all &amp;&amp; (!doc.documentMode || doc.documentMode &lt;= 8)) {
          lineHeight = self.layoutRect().h - 2 + &#039;px&#039;;
        }
        global$7(inputElm).css({
          width: width - innerPadding,
          lineHeight: lineHeight
        });
        self._super();
        return self;
      },
      postRender: function () {
        var self = this;
        global$7(this.getEl(&#039;inp&#039;)).on(&#039;change&#039;, function (e) {
          self.state.set(&#039;value&#039;, e.target.value);
          self.fire(&#039;change&#039;, e);
        });
        return self._super();
      },
      renderHtml: function () {
        var self = this, id = self._id, settings = self.settings, prefix = self.classPrefix;
        var value = self.state.get(&#039;value&#039;) || &#039;&#039;;
        var icon, text, openBtnHtml = &#039;&#039;, extraAttrs = &#039;&#039;, statusHtml = &#039;&#039;;
        if (&#039;spellcheck&#039; in settings) {
          extraAttrs += &#039; spellcheck=&quot;&#039; + settings.spellcheck + &#039;&quot;&#039;;
        }
        if (settings.maxLength) {
          extraAttrs += &#039; maxlength=&quot;&#039; + settings.maxLength + &#039;&quot;&#039;;
        }
        if (settings.size) {
          extraAttrs += &#039; size=&quot;&#039; + settings.size + &#039;&quot;&#039;;
        }
        if (settings.subtype) {
          extraAttrs += &#039; type=&quot;&#039; + settings.subtype + &#039;&quot;&#039;;
        }
        statusHtml = &#039;&lt;i id=&quot;&#039; + id + &#039;-status&quot; class=&quot;mce-status mce-ico&quot; style=&quot;display: none&quot;&gt;&lt;/i&gt;&#039;;
        if (self.disabled()) {
          extraAttrs += &#039; disabled=&quot;disabled&quot;&#039;;
        }
        icon = settings.icon;
        if (icon &amp;&amp; icon !== &#039;caret&#039;) {
          icon = prefix + &#039;ico &#039; + prefix + &#039;i-&#039; + settings.icon;
        }
        text = self.state.get(&#039;text&#039;);
        if (icon || text) {
          openBtnHtml = &#039;&lt;div id=&quot;&#039; + id + &#039;-open&quot; class=&quot;&#039; + prefix + &#039;btn &#039; + prefix + &#039;open&quot; tabIndex=&quot;-1&quot; role=&quot;button&quot;&gt;&#039; + &#039;&lt;button id=&quot;&#039; + id + &#039;-action&quot; type=&quot;button&quot; hidefocus=&quot;1&quot; tabindex=&quot;-1&quot;&gt;&#039; + (icon !== &#039;caret&#039; ? &#039;&lt;i class=&quot;&#039; + icon + &#039;&quot;&gt;&lt;/i&gt;&#039; : &#039;&lt;i class=&quot;&#039; + prefix + &#039;caret&quot;&gt;&lt;/i&gt;&#039;) + (text ? (icon ? &#039; &#039; : &#039;&#039;) + text : &#039;&#039;) + &#039;&lt;/button&gt;&#039; + &#039;&lt;/div&gt;&#039;;
          self.classes.add(&#039;has-open&#039;);
        }
        return &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&gt;&#039; + &#039;&lt;input id=&quot;&#039; + id + &#039;-inp&quot; class=&quot;&#039; + prefix + &#039;textbox&quot; value=&quot;&#039; + self.encode(value, false) + &#039;&quot; hidefocus=&quot;1&quot;&#039; + extraAttrs + &#039; placeholder=&quot;&#039; + self.encode(settings.placeholder) + &#039;&quot; /&gt;&#039; + statusHtml + openBtnHtml + &#039;&lt;/div&gt;&#039;;
      },
      value: function (value) {
        if (arguments.length) {
          this.state.set(&#039;value&#039;, value);
          return this;
        }
        if (this.state.get(&#039;rendered&#039;)) {
          this.state.set(&#039;value&#039;, this.getEl(&#039;inp&#039;).value);
        }
        return this.state.get(&#039;value&#039;);
      },
      showAutoComplete: function (items, term) {
        var self = this;
        if (items.length === 0) {
          self.hideMenu();
          return;
        }
        var insert = function (value, title) {
          return function () {
            self.fire(&#039;selectitem&#039;, {
              title: title,
              value: value
            });
          };
        };
        if (self.menu) {
          self.menu.items().remove();
        } else {
          self.menu = global$b.create({
            type: &#039;menu&#039;,
            classes: &#039;combobox-menu&#039;,
            layout: &#039;flow&#039;
          }).parent(self).renderTo();
        }
        global$4.each(items, function (item) {
          self.menu.add({
            text: item.title,
            url: item.previewUrl,
            match: term,
            classes: &#039;menu-item-ellipsis&#039;,
            onclick: insert(item.value, item.title)
          });
        });
        self.menu.renderNew();
        self.hideMenu();
        self.menu.on(&#039;cancel&#039;, function (e) {
          if (e.control.parent() === self.menu) {
            e.stopPropagation();
            self.focus();
            self.hideMenu();
          }
        });
        self.menu.on(&#039;select&#039;, 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() ? [
          &#039;br-tr&#039;,
          &#039;tr-br&#039;
        ] : [
          &#039;bl-tl&#039;,
          &#039;tl-bl&#039;
        ]);
      },
      hideMenu: function () {
        if (this.menu) {
          this.menu.hide();
        }
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:value&#039;, function (e) {
          if (self.getEl(&#039;inp&#039;).value !== e.value) {
            self.getEl(&#039;inp&#039;).value = e.value;
          }
        });
        self.state.on(&#039;change:disabled&#039;, function (e) {
          self.getEl(&#039;inp&#039;).disabled = e.value;
        });
        self.state.on(&#039;change:statusLevel&#039;, function (e) {
          var statusIconElm = self.getEl(&#039;status&#039;);
          var prefix = self.classPrefix, value = e.value;
          funcs.css(statusIconElm, &#039;display&#039;, value === &#039;none&#039; ? &#039;none&#039; : &#039;&#039;);
          funcs.toggleClass(statusIconElm, prefix + &#039;i-checkmark&#039;, value === &#039;ok&#039;);
          funcs.toggleClass(statusIconElm, prefix + &#039;i-warning&#039;, value === &#039;warn&#039;);
          funcs.toggleClass(statusIconElm, prefix + &#039;i-error&#039;, value === &#039;error&#039;);
          self.classes.toggle(&#039;has-status&#039;, value !== &#039;none&#039;);
          self.repaint();
        });
        funcs.on(self.getEl(&#039;status&#039;), &#039;mouseleave&#039;, function () {
          self.tooltip().hide();
        });
        self.on(&#039;cancel&#039;, function (e) {
          if (self.menu &amp;&amp; self.menu.visible()) {
            e.stopPropagation();
            self.hideMenu();
          }
        });
        var focusIdx = function (idx, menu) {
          if (menu &amp;&amp; menu.items().length &gt; 0) {
            menu.items().eq(idx)[0].focus();
          }
        };
        self.on(&#039;keydown&#039;, function (e) {
          var keyCode = e.keyCode;
          if (e.target.nodeName === &#039;INPUT&#039;) {
            if (keyCode === global$f.DOWN) {
              e.preventDefault();
              self.fire(&#039;autocomplete&#039;);
              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(&#039;inp&#039;)).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 = &#039;none&#039;;
        }
        self._super(settings);
        self.classes.add(&#039;colorbox&#039;);
        self.on(&#039;change keyup postrender&#039;, function () {
          self.repaintColor(self.value());
        });
      },
      repaintColor: function (value) {
        var openElm = this.getEl(&#039;open&#039;);
        var elm = openElm ? openElm.getElementsByTagName(&#039;i&#039;)[0] : null;
        if (elm) {
          try {
            elm.style.background = value;
          } catch (ex) {
          }
        }
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:value&#039;, function (e) {
          if (self.state.get(&#039;rendered&#039;)) {
            self.repaintColor(e.value);
          }
        });
        return self._super();
      }
    });

    var PanelButton = Button.extend({
      showPanel: function () {
        var self = this, settings = self.settings;
        self.classes.add(&#039;opened&#039;);
        if (!self.panel) {
          var panelSettings = settings.panel;
          if (panelSettings.type) {
            panelSettings = {
              layout: &#039;grid&#039;,
              items: panelSettings
            };
          }
          panelSettings.role = panelSettings.role || &#039;dialog&#039;;
          panelSettings.popover = true;
          panelSettings.autohide = true;
          panelSettings.ariaRoot = true;
          self.panel = new FloatPanel(panelSettings).on(&#039;hide&#039;, function () {
            self.classes.remove(&#039;opened&#039;);
          }).on(&#039;cancel&#039;, function (e) {
            e.stopPropagation();
            self.focus();
            self.hidePanel();
          }).parent(self).renderTo(self.getContainerElm());
          self.panel.fire(&#039;show&#039;);
          self.panel.reflow();
        } else {
          self.panel.show();
        }
        var rtlRels = [
          &#039;bc-tc&#039;,
          &#039;bc-tl&#039;,
          &#039;bc-tr&#039;
        ];
        var ltrRels = [
          &#039;bc-tc&#039;,
          &#039;bc-tr&#039;,
          &#039;bc-tl&#039;,
          &#039;tc-bc&#039;,
          &#039;tc-br&#039;,
          &#039;tc-bl&#039;
        ];
        var rel = self.panel.testMoveRel(self.getEl(), settings.popoverAlign || (self.isRtl() ? rtlRels : ltrRels));
        self.panel.classes.toggle(&#039;start&#039;, rel.substr(-1) === &#039;l&#039;);
        self.panel.classes.toggle(&#039;end&#039;, rel.substr(-1) === &#039;r&#039;);
        var isTop = rel.substr(0, 1) === &#039;t&#039;;
        self.panel.classes.toggle(&#039;bottom&#039;, !isTop);
        self.panel.classes.toggle(&#039;top&#039;, 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(&#039;haspopup&#039;, true);
        self.on(&#039;click&#039;, function (e) {
          if (e.control === self) {
            if (self.panel &amp;&amp; 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(&#039;splitbtn&#039;);
        this.classes.add(&#039;colorbutton&#039;);
      },
      color: function (color) {
        if (color) {
          this._color = color;
          this.getEl(&#039;preview&#039;).style.backgroundColor = color;
          return this;
        }
        return this._color;
      },
      resetColor: function () {
        this._color = null;
        this.getEl(&#039;preview&#039;).style.backgroundColor = null;
        return this;
      },
      renderHtml: function () {
        var self = this, id = self._id, prefix = self.classPrefix, text = self.state.get(&#039;text&#039;);
        var icon = self.settings.icon ? prefix + &#039;ico &#039; + prefix + &#039;i-&#039; + self.settings.icon : &#039;&#039;;
        var image = self.settings.image ? &#039; style=&quot;background-image: url(\&#039;&#039; + self.settings.image + &#039;\&#039;)&quot;&#039; : &#039;&#039;;
        var textHtml = &#039;&#039;;
        if (text) {
          self.classes.add(&#039;btn-has-text&#039;);
          textHtml = &#039;&lt;span class=&quot;&#039; + prefix + &#039;txt&quot;&gt;&#039; + self.encode(text) + &#039;&lt;/span&gt;&#039;;
        }
        return &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; role=&quot;button&quot; tabindex=&quot;-1&quot; aria-haspopup=&quot;true&quot;&gt;&#039; + &#039;&lt;button role=&quot;presentation&quot; hidefocus=&quot;1&quot; type=&quot;button&quot; tabindex=&quot;-1&quot;&gt;&#039; + (icon ? &#039;&lt;i class=&quot;&#039; + icon + &#039;&quot;&#039; + image + &#039;&gt;&lt;/i&gt;&#039; : &#039;&#039;) + &#039;&lt;span id=&quot;&#039; + id + &#039;-preview&quot; class=&quot;&#039; + prefix + &#039;preview&quot;&gt;&lt;/span&gt;&#039; + textHtml + &#039;&lt;/button&gt;&#039; + &#039;&lt;button type=&quot;button&quot; class=&quot;&#039; + prefix + &#039;open&quot; hidefocus=&quot;1&quot; tabindex=&quot;-1&quot;&gt;&#039; + &#039; &lt;i class=&quot;&#039; + prefix + &#039;caret&quot;&gt;&lt;/i&gt;&#039; + &#039;&lt;/button&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      postRender: function () {
        var self = this, onClickHandler = self.settings.onclick;
        self.on(&#039;click&#039;, function (e) {
          if (e.aria &amp;&amp; e.aria.key === &#039;down&#039;) {
            return;
          }
          if (e.control === self &amp;&amp; !DOM.getParent(e.target, &#039;.&#039; + self.classPrefix + &#039;open&#039;)) {
            e.stopImmediatePropagation();
            onClickHandler.call(self, e);
          }
        });
        delete self.settings.onclick;
        return self._super();
      }
    });

    var global$g = tinymce.util.Tools.resolve(&#039;tinymce.util.Color&#039;);

    var ColorPicker = Widget.extend({
      Defaults: { classes: &#039;widget colorpicker&#039; },
      init: function (settings) {
        this._super(settings);
      },
      postRender: function () {
        var self = this;
        var color = self.color();
        var hsv, hueRootElm, huePointElm, svRootElm, svPointElm;
        hueRootElm = self.getEl(&#039;h&#039;);
        huePointElm = self.getEl(&#039;hp&#039;);
        svRootElm = self.getEl(&#039;sv&#039;);
        svPointElm = self.getEl(&#039;svp&#039;);
        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 + &#039;%&#039; });
          if (!hueUpdate) {
            funcs.css(svPointElm, {
              left: hsv.s + &#039;%&#039;,
              top: 100 - hsv.v + &#039;%&#039;
            });
          }
          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(&#039;change&#039;);
        }
        function updateHue(e) {
          var pos;
          pos = getPos(hueRootElm, e);
          hsv = color.toHsv();
          hsv.h = (1 - pos.y) * 360;
          updateColor(hsv, true);
          self.fire(&#039;change&#039;);
        }
        self._repaint = function () {
          hsv = color.toHsv();
          updateColor(hsv);
        };
        self._super();
        self._svdraghelper = new DragHelper(self._id + &#039;-sv&#039;, {
          start: updateSaturationAndValue,
          drag: updateSaturationAndValue
        });
        self._hdraghelper = new DragHelper(self._id + &#039;-h&#039;, {
          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 = &#039;#ff0000,#ff0080,#ff00ff,#8000ff,#0000ff,#0080ff,#00ffff,#00ff80,#00ff00,#80ff00,#ffff00,#ff8000,#ff0000&#039;;
        function getOldIeFallbackHtml() {
          var i, l, html = &#039;&#039;, gradientPrefix, stopsList;
          gradientPrefix = &#039;filter:progid:DXImageTransform.Microsoft.gradient(GradientType=0,startColorstr=&#039;;
          stopsList = stops.split(&#039;,&#039;);
          for (i = 0, l = stopsList.length - 1; i &lt; l; i++) {
            html += &#039;&lt;div class=&quot;&#039; + prefix + &#039;colorpicker-h-chunk&quot; style=&quot;&#039; + &#039;height:&#039; + 100 / l + &#039;%;&#039; + gradientPrefix + stopsList[i] + &#039;,endColorstr=&#039; + stopsList[i + 1] + &#039;);&#039; + &#039;-ms-&#039; + gradientPrefix + stopsList[i] + &#039;,endColorstr=&#039; + stopsList[i + 1] + &#039;)&#039; + &#039;&quot;&gt;&lt;/div&gt;&#039;;
          }
          return html;
        }
        var gradientCssText = &#039;background: -ms-linear-gradient(top,&#039; + stops + &#039;);&#039; + &#039;background: linear-gradient(to bottom,&#039; + stops + &#039;);&#039;;
        hueHtml = &#039;&lt;div id=&quot;&#039; + id + &#039;-h&quot; class=&quot;&#039; + prefix + &#039;colorpicker-h&quot; style=&quot;&#039; + gradientCssText + &#039;&quot;&gt;&#039; + getOldIeFallbackHtml() + &#039;&lt;div id=&quot;&#039; + id + &#039;-hp&quot; class=&quot;&#039; + prefix + &#039;colorpicker-h-marker&quot;&gt;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
        return &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&gt;&#039; + &#039;&lt;div id=&quot;&#039; + id + &#039;-sv&quot; class=&quot;&#039; + prefix + &#039;colorpicker-sv&quot;&gt;&#039; + &#039;&lt;div class=&quot;&#039; + prefix + &#039;colorpicker-overlay1&quot;&gt;&#039; + &#039;&lt;div class=&quot;&#039; + prefix + &#039;colorpicker-overlay2&quot;&gt;&#039; + &#039;&lt;div id=&quot;&#039; + id + &#039;-svp&quot; class=&quot;&#039; + prefix + &#039;colorpicker-selector1&quot;&gt;&#039; + &#039;&lt;div class=&quot;&#039; + prefix + &#039;colorpicker-selector2&quot;&gt;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039; + hueHtml + &#039;&lt;/div&gt;&#039;;
      }
    });

    var DropZone = Widget.extend({
      init: function (settings) {
        var self = this;
        settings = global$4.extend({
          height: 100,
          text: &#039;Drop an image here&#039;,
          multiple: false,
          accept: null
        }, settings);
        self._super(settings);
        self.classes.add(&#039;dropzone&#039;);
        if (settings.multiple) {
          self.classes.add(&#039;multiple&#039;);
        }
      },
      renderHtml: function () {
        var self = this;
        var attrs, elm;
        var cfg = self.settings;
        attrs = {
          id: self._id,
          hidefocus: &#039;1&#039;
        };
        elm = funcs.create(&#039;div&#039;, attrs, &#039;&lt;span&gt;&#039; + this.translate(cfg.text) + &#039;&lt;/span&gt;&#039;);
        if (cfg.height) {
          funcs.css(elm, &#039;height&#039;, cfg.height + &#039;px&#039;);
        }
        if (cfg.width) {
          funcs.css(elm, &#039;width&#039;, cfg.width + &#039;px&#039;);
        }
        elm.className = self.classes;
        return elm.outerHTML;
      },
      postRender: function () {
        var self = this;
        var toggleDragClass = function (e) {
          e.preventDefault();
          self.classes.toggle(&#039;dragenter&#039;);
          self.getEl().className = self.classes;
        };
        var filter = function (files) {
          var accept = self.settings.accept;
          if (typeof accept !== &#039;string&#039;) {
            return files;
          }
          var re = new RegExp(&#039;(&#039; + accept.split(/\s*,\s*/).join(&#039;|&#039;) + &#039;)$&#039;, &#039;i&#039;);
          return global$4.grep(files, function (file) {
            return re.test(file.name);
          });
        };
        self._super();
        self.$el.on(&#039;dragover&#039;, function (e) {
          e.preventDefault();
        });
        self.$el.on(&#039;dragenter&#039;, toggleDragClass);
        self.$el.on(&#039;dragleave&#039;, toggleDragClass);
        self.$el.on(&#039;drop&#039;, function (e) {
          e.preventDefault();
          if (self.state.get(&#039;disabled&#039;)) {
            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(&#039;change&#039;, e);
          }
        });
      },
      remove: function () {
        this.$el.off();
        this._super();
      }
    });

    var Path = Widget.extend({
      init: function (settings) {
        var self = this;
        if (!settings.delimiter) {
          settings.delimiter = &#039;\xBB&#039;;
        }
        self._super(settings);
        self.classes.add(&#039;path&#039;);
        self.canFocus = true;
        self.on(&#039;click&#039;, function (e) {
          var index;
          var target = e.target;
          if (index = target.getAttribute(&#039;data-index&#039;)) {
            self.fire(&#039;select&#039;, {
              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(&#039;row&#039;);
        }
        this.state.set(&#039;row&#039;, row);
        return this;
      },
      renderHtml: function () {
        var self = this;
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&gt;&#039; + self._getDataPathHtml(self.state.get(&#039;row&#039;)) + &#039;&lt;/div&gt;&#039;;
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:row&#039;, function (e) {
          self.innerHtml(self._getDataPathHtml(e.value));
        });
        return self._super();
      },
      _getDataPathHtml: function (data) {
        var self = this;
        var parts = data || [];
        var i, l, html = &#039;&#039;;
        var prefix = self.classPrefix;
        for (i = 0, l = parts.length; i &lt; l; i++) {
          html += (i &gt; 0 ? &#039;&lt;div class=&quot;&#039; + prefix + &#039;divider&quot; aria-hidden=&quot;true&quot;&gt; &#039; + self.settings.delimiter + &#039; &lt;/div&gt;&#039; : &#039;&#039;) + &#039;&lt;div role=&quot;button&quot; class=&quot;&#039; + prefix + &#039;path-item&#039; + (i === l - 1 ? &#039; &#039; + prefix + &#039;last&#039; : &#039;&#039;) + &#039;&quot; data-index=&quot;&#039; + i + &#039;&quot; tabindex=&quot;-1&quot; id=&quot;&#039; + self._id + &#039;-&#039; + i + &#039;&quot; aria-level=&quot;&#039; + (i + 1) + &#039;&quot;&gt;&#039; + parts[i].name + &#039;&lt;/div&gt;&#039;;
        }
        if (!html) {
          html = &#039;&lt;div class=&quot;&#039; + prefix + &#039;path-item&quot;&gt;\xA0&lt;/div&gt;&#039;;
        }
        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 === &#039;BR&#039; || !!elm.getAttribute(&#039;data-mce-bogus&#039;)) {
              return true;
            }
            if (elm.getAttribute(&#039;data-mce-type&#039;) === &#039;bookmark&#039;) {
              return true;
            }
          }
          return false;
        }
        if (editor.settings.elementpath !== false) {
          self.on(&#039;select&#039;, function (e) {
            editor.focus();
            editor.selection.select(this.row()[e.index].element);
            editor.nodeChanged();
          });
          editor.on(&#039;nodeChange&#039;, function (e) {
            var outParents = [];
            var parents = e.parents;
            var i = parents.length;
            while (i--) {
              if (parents[i].nodeType === 1 &amp;&amp; !isHidden(parents[i])) {
                var args = editor.fire(&#039;ResolveName&#039;, {
                  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: &#039;flex&#039;,
        align: &#039;center&#039;,
        defaults: { flex: 1 }
      },
      renderHtml: function () {
        var self = this, layout = self._layout, prefix = self.classPrefix;
        self.classes.add(&#039;formitem&#039;);
        layout.preRender(self);
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; hidefocus=&quot;1&quot; tabindex=&quot;-1&quot;&gt;&#039; + (self.settings.title ? &#039;&lt;div id=&quot;&#039; + self._id + &#039;-title&quot; class=&quot;&#039; + prefix + &#039;title&quot;&gt;&#039; + self.settings.title + &#039;&lt;/div&gt;&#039; : &#039;&#039;) + &#039;&lt;div id=&quot;&#039; + self._id + &#039;-body&quot; class=&quot;&#039; + self.bodyClasses + &#039;&quot;&gt;&#039; + (self.settings.html || &#039;&#039;) + layout.renderHtml(self) + &#039;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      }
    });

    var Form = Container.extend({
      Defaults: {
        containerCls: &#039;form&#039;,
        layout: &#039;flex&#039;,
        direction: &#039;column&#039;,
        align: &#039;stretch&#039;,
        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: &#039;flex&#039;,
            autoResize: &#039;overflow&#039;,
            defaults: { flex: 1 }
          };
        }
        items.each(function (ctrl) {
          var formItem;
          var label = ctrl.settings.label;
          if (label) {
            formItem = new FormItem(global$4.extend({
              items: {
                type: &#039;label&#039;,
                id: ctrl._id + &#039;-l&#039;,
                text: label,
                flex: 0,
                forId: ctrl._id,
                disabled: ctrl.disabled()
              }
            }, self.settings.formItemDefaults));
            formItem.type = &#039;formitem&#039;;
            ctrl.aria(&#039;labelledby&#039;, ctrl._id + &#039;-l&#039;);
            if (typeof ctrl.settings.flex === &#039;undefined&#039;) {
              ctrl.settings.flex = 1;
            }
            self.replace(ctrl, formItem);
            formItem.add(ctrl);
          }
        });
      },
      submit: function () {
        return this.fire(&#039;submit&#039;, { 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 === &#039;children&#039;) {
            items = self.find(&#039;formitem&#039;);
          } else {
            items = self.items();
          }
          items.filter(&#039;formitem&#039;).each(function (item) {
            var labelCtrl = item.items()[0], labelWidth = labelCtrl.getEl().clientWidth;
            maxLabelWidth = labelWidth &gt; maxLabelWidth ? labelWidth : maxLabelWidth;
            labels.push(labelCtrl);
          });
          labelGap = self.settings.labelGap || 0;
          i = labels.length;
          while (i--) {
            labels[i].settings.minWidth = maxLabelWidth + labelGap;
          }
        }
        self.on(&#039;show&#039;, recalcLabels);
        recalcLabels();
      }
    });

    var FieldSet = Form.extend({
      Defaults: {
        containerCls: &#039;fieldset&#039;,
        layout: &#039;flex&#039;,
        direction: &#039;column&#039;,
        align: &#039;stretch&#039;,
        flex: 1,
        padding: &#039;25 15 5 15&#039;,
        labelGap: 30,
        spacing: 10,
        border: 1
      },
      renderHtml: function () {
        var self = this, layout = self._layout, prefix = self.classPrefix;
        self.preRender();
        layout.preRender(self);
        return &#039;&lt;fieldset id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; hidefocus=&quot;1&quot; tabindex=&quot;-1&quot;&gt;&#039; + (self.settings.title ? &#039;&lt;legend id=&quot;&#039; + self._id + &#039;-title&quot; class=&quot;&#039; + prefix + &#039;fieldset-title&quot;&gt;&#039; + self.settings.title + &#039;&lt;/legend&gt;&#039; : &#039;&#039;) + &#039;&lt;div id=&quot;&#039; + self._id + &#039;-body&quot; class=&quot;&#039; + self.bodyClasses + &#039;&quot;&gt;&#039; + (self.settings.html || &#039;&#039;) + layout.renderHtml(self) + &#039;&lt;/div&gt;&#039; + &#039;&lt;/fieldset&gt;&#039;;
      }
    });

    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 + &#039;_&#039; + random + unique$1 + String(time);
    };

    var fromHtml = function (html, scope) {
      var doc = scope || domGlobals.document;
      var div = doc.createElement(&#039;div&#039;);
      div.innerHTML = html;
      if (!div.hasChildNodes() || div.childNodes.length &gt; 1) {
        domGlobals.console.error(&#039;HTML does not have a single root node&#039;, html);
        throw new Error(&#039;HTML must have a single root node&#039;);
      }
      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(&#039;Node cannot be null or undefined&#039;);
      }
      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 &lt; 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 &lt; arguments.length; _i++) {
        fields[_i] = arguments[_i];
      }
      return function () {
        var values = [];
        for (var _i = 0; _i &lt; arguments.length; _i++) {
          values[_i] = arguments[_i];
        }
        if (fields.length !== values.length) {
          throw new Error(&#039;Wrong number of arguments to struct. Expected &quot;[&#039; + fields.length + &#039;]&quot;, got &#039; + values.length + &#039; arguments&#039;);
        }
        var struct = {};
        each(fields, function (name, i) {
          struct[name] = constant(values[i]);
        });
        return struct;
      };
    };

    var node = function () {
      var f = Global$1.getOrDie(&#039;Node&#039;);
      return f;
    };
    var compareDocumentPosition = function (a, b, match) {
      return (a.compareDocumentPosition(b) &amp; 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 &lt; 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, &#039;$&#039; + 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 = &#039;Edge&#039;;
    var chrome = &#039;Chrome&#039;;
    var ie = &#039;IE&#039;;
    var opera = &#039;Opera&#039;;
    var firefox = &#039;Firefox&#039;;
    var safari = &#039;Safari&#039;;
    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 = &#039;Windows&#039;;
    var ios = &#039;iOS&#039;;
    var android = &#039;Android&#039;;
    var linux = &#039;Linux&#039;;
    var osx = &#039;OSX&#039;;
    var solaris = &#039;Solaris&#039;;
    var freebsd = &#039;FreeBSD&#039;;
    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() &amp;&amp; /ipad/i.test(userAgent) === true;
      var isiPhone = os.isiOS() &amp;&amp; !isiPad;
      var isAndroid3 = os.isAndroid() &amp;&amp; os.version.major === 3;
      var isAndroid4 = os.isAndroid() &amp;&amp; os.version.major === 4;
      var isTablet = isiPad || isAndroid3 || isAndroid4 &amp;&amp; /mobile/i.test(userAgent) === true;
      var isTouch = os.isiOS() || os.isAndroid();
      var isPhone = isTouch &amp;&amp; !isTablet;
      var iOSwebview = browser.isSafari() &amp;&amp; os.isiOS() &amp;&amp; /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: &#039;Edge&#039;,
        versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
        search: function (uastring) {
          return contains(uastring, &#039;edge/&#039;) &amp;&amp; contains(uastring, &#039;chrome&#039;) &amp;&amp; contains(uastring, &#039;safari&#039;) &amp;&amp; contains(uastring, &#039;applewebkit&#039;);
        }
      },
      {
        name: &#039;Chrome&#039;,
        versionRegexes: [
          /.*?chrome\/([0-9]+)\.([0-9]+).*/,
          normalVersionRegex
        ],
        search: function (uastring) {
          return contains(uastring, &#039;chrome&#039;) &amp;&amp; !contains(uastring, &#039;chromeframe&#039;);
        }
      },
      {
        name: &#039;IE&#039;,
        versionRegexes: [
          /.*?msie\ ?([0-9]+)\.([0-9]+).*/,
          /.*?rv:([0-9]+)\.([0-9]+).*/
        ],
        search: function (uastring) {
          return contains(uastring, &#039;msie&#039;) || contains(uastring, &#039;trident&#039;);
        }
      },
      {
        name: &#039;Opera&#039;,
        versionRegexes: [
          normalVersionRegex,
          /.*?opera\/([0-9]+)\.([0-9]+).*/
        ],
        search: checkContains(&#039;opera&#039;)
      },
      {
        name: &#039;Firefox&#039;,
        versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
        search: checkContains(&#039;firefox&#039;)
      },
      {
        name: &#039;Safari&#039;,
        versionRegexes: [
          normalVersionRegex,
          /.*?cpu os ([0-9]+)_([0-9]+).*/
        ],
        search: function (uastring) {
          return (contains(uastring, &#039;safari&#039;) || contains(uastring, &#039;mobile/&#039;)) &amp;&amp; contains(uastring, &#039;applewebkit&#039;);
        }
      }
    ];
    var oses = [
      {
        name: &#039;Windows&#039;,
        search: checkContains(&#039;win&#039;),
        versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
      },
      {
        name: &#039;iOS&#039;,
        search: function (uastring) {
          return contains(uastring, &#039;iphone&#039;) || contains(uastring, &#039;ipad&#039;);
        },
        versionRegexes: [
          /.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
          /.*cpu os ([0-9]+)_([0-9]+).*/,
          /.*cpu iphone os ([0-9]+)_([0-9]+).*/
        ]
      },
      {
        name: &#039;Android&#039;,
        search: checkContains(&#039;android&#039;),
        versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
      },
      {
        name: &#039;OSX&#039;,
        search: checkContains(&#039;os x&#039;),
        versionRegexes: [/.*?os\ x\ ?([0-9]+)_([0-9]+).*/]
      },
      {
        name: &#039;Linux&#039;,
        search: checkContains(&#039;linux&#039;),
        versionRegexes: []
      },
      {
        name: &#039;Solaris&#039;,
        search: checkContains(&#039;sunos&#039;),
        versionRegexes: []
      },
      {
        name: &#039;FreeBSD&#039;,
        search: checkContains(&#039;freebsd&#039;),
        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 &amp;&amp; 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(&#039;element&#039;, &#039;offset&#039;);

    var descendants = function (scope, selector) {
      return all(selector, scope);
    };

    var trim = global$4.trim;
    var hasContentEditableState = function (value) {
      return function (node) {
        if (node &amp;&amp; node.nodeType === 1) {
          if (node.contentEditable === value) {
            return true;
          }
          if (node.getAttribute(&#039;data-mce-contenteditable&#039;) === value) {
            return true;
          }
        }
        return false;
      };
    };
    var isContentEditableTrue = hasContentEditableState(&#039;true&#039;);
    var isContentEditableFalse = hasContentEditableState(&#039;false&#039;);
    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 &amp;&amp; value !== &#039;inherit&#039;) {
          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(&#039;h&#039;);
    };
    var isAnchor = function (elm) {
      return elm &amp;&amp; elm.nodeName === &#039;A&#039; &amp;&amp; (elm.id || elm.name);
    };
    var isValidAnchor = function (elm) {
      return isAnchor(elm) &amp;&amp; isEditable(elm);
    };
    var isHeader = function (elm) {
      return elm &amp;&amp; /^(H[1-6])$/.test(elm.nodeName);
    };
    var isEditable = function (elm) {
      return isChildOfContentEditableTrue(elm) &amp;&amp; !isContentEditableFalse(elm);
    };
    var isValidHeader = function (elm) {
      return isHeader(elm) &amp;&amp; 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(&#039;header&#039;, getElementText(elm), &#039;#&#039; + headerId, getLevel(elm), attach);
    };
    var anchorTarget = function (elm) {
      var anchorId = elm.id || elm.name;
      var anchorText = getElementText(elm);
      return create$4(&#039;anchor&#039;, anchorText ? anchorText : &#039;#&#039; + anchorId, &#039;#&#039; + 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(&#039;h1,h2,h3,h4,h5,h6,a:not([href])&#039;, elm);
      return elms;
    };
    var hasTitle = function (target) {
      return trim(target.title).length &gt; 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: &#039;-&#039; };
      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(&#039;anchor&#039;);
        var topAnchor = getSetting(editorSettings, &#039;anchor_top&#039;, &#039;#top&#039;);
        var bottomAchor = getSetting(editorSettings, &#039;anchor_bottom&#039;, &#039;#bottom&#039;);
        if (topAnchor !== null) {
          anchorMenuItems.unshift(staticMenuItem(&#039;&lt;top&gt;&#039;, topAnchor));
        }
        if (bottomAchor !== null) {
          anchorMenuItems.push(staticMenuItem(&#039;&lt;bottom&gt;&#039;, 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 === &#039;file&#039; ? join([
        filterByQuery(term, fromHistoryMenuItems(history)),
        filterByQuery(term, fromMenuItems(&#039;header&#039;)),
        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 &amp;&amp; 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(&#039;autocomplete&#039;, function () {
        autocomplete(ctrl.value());
      });
      ctrl.on(&#039;selectitem&#039;, function (e) {
        var linkDetails = e.value;
        ctrl.value(linkDetails.url);
        var title = getTitle(linkDetails);
        if (fileType === &#039;image&#039;) {
          ctrl.fire(&#039;change&#039;, {
            meta: {
              alt: title,
              attach: linkDetails.attach
            }
          });
        } else {
          ctrl.fire(&#039;change&#039;, {
            meta: {
              text: title,
              attach: linkDetails.attach
            }
          });
        }
        ctrl.focus();
      });
      ctrl.on(&#039;click&#039;, function (e) {
        if (ctrl.value().length === 0 &amp;&amp; e.target.nodeName === &#039;INPUT&#039;) {
          autocomplete(&#039;&#039;);
        }
      });
      ctrl.on(&#039;PostRender&#039;, function () {
        ctrl.getRoot().on(&#039;submit&#039;, function (e) {
          if (!e.isDefaultPrevented()) {
            addToHistory(ctrl.value(), fileType);
          }
        });
      });
    };
    var statusToUiState = function (result) {
      var status = result.status, message = result.message;
      if (status === &#039;valid&#039;) {
        return {
          status: &#039;ok&#039;,
          message: message
        };
      } else if (status === &#039;unknown&#039;) {
        return {
          status: &#039;warn&#039;,
          message: message
        };
      } else if (status === &#039;invalid&#039;) {
        return {
          status: &#039;warn&#039;,
          message: message
        };
      } else {
        return {
          status: &#039;none&#039;,
          message: &#039;&#039;
        };
      }
    };
    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(&#039;none&#039;);
            return;
          }
          validatorHandler({
            url: url,
            type: fileType
          }, function (result) {
            var uiState = statusToUiState(result);
            ctrl.statusMessage(uiState.message);
            ctrl.statusLevel(uiState.status);
          });
        };
        ctrl.state.on(&#039;change:value&#039;, 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 &amp;&amp; (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
            actionCallback = function () {
              var meta = self.fire(&#039;beforecall&#039;).meta;
              meta = global$4.extend({ filetype: fileType }, meta);
              fileBrowserCallback.call(editor, function (value, meta) {
                self.value(value).fire(&#039;change&#039;, { meta: meta });
              }, self.value(), meta);
            };
          } else {
            fileBrowserCallback = editorSettings.file_browser_callback;
            if (fileBrowserCallback &amp;&amp; (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
              actionCallback = function () {
                fileBrowserCallback(self.getEl(&#039;inp&#039;).id, self.value(), fileType, window);
              };
            }
          }
        }
        if (actionCallback) {
          settings.icon = &#039;browse&#039;;
          settings.onaction = actionCallback;
        }
        self._super(settings);
        self.classes.add(&#039;filepicker&#039;);
        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(&#039;:visible&#039;).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(&#039;:visible&#039;);
        contLayoutRect = container.layoutRect();
        contPaddingBox = container.paddingBox;
        contSettings = container.settings;
        direction = container.isRtl() ? contSettings.direction || &#039;row-reversed&#039; : contSettings.direction;
        align = contSettings.align;
        pack = container.isRtl() ? contSettings.pack || &#039;end&#039; : contSettings.pack;
        spacing = contSettings.spacing || 0;
        if (direction === &#039;row-reversed&#039; || direction === &#039;column-reverse&#039;) {
          items = items.set(items.toArray().reverse());
          direction = direction.split(&#039;-&#039;)[0];
        }
        if (direction === &#039;column&#039;) {
          posName = &#039;y&#039;;
          sizeName = &#039;h&#039;;
          minSizeName = &#039;minH&#039;;
          maxSizeName = &#039;maxH&#039;;
          innerSizeName = &#039;innerH&#039;;
          beforeName = &#039;top&#039;;
          deltaSizeName = &#039;deltaH&#039;;
          contentSizeName = &#039;contentH&#039;;
          alignBeforeName = &#039;left&#039;;
          alignSizeName = &#039;w&#039;;
          alignAxisName = &#039;x&#039;;
          alignInnerSizeName = &#039;innerW&#039;;
          alignMinSizeName = &#039;minW&#039;;
          alignAfterName = &#039;right&#039;;
          alignDeltaSizeName = &#039;deltaW&#039;;
          alignContentSizeName = &#039;contentW&#039;;
        } else {
          posName = &#039;x&#039;;
          sizeName = &#039;w&#039;;
          minSizeName = &#039;minW&#039;;
          maxSizeName = &#039;maxW&#039;;
          innerSizeName = &#039;innerW&#039;;
          beforeName = &#039;left&#039;;
          deltaSizeName = &#039;deltaW&#039;;
          contentSizeName = &#039;contentW&#039;;
          alignBeforeName = &#039;top&#039;;
          alignSizeName = &#039;h&#039;;
          alignAxisName = &#039;y&#039;;
          alignInnerSizeName = &#039;innerH&#039;;
          alignMinSizeName = &#039;minH&#039;;
          alignAfterName = &#039;bottom&#039;;
          alignDeltaSizeName = &#039;deltaH&#039;;
          alignContentSizeName = &#039;contentH&#039;;
        }
        availableSpace = contLayoutRect[innerSizeName] - contPaddingBox[beforeName] - contPaddingBox[beforeName];
        maxAlignEndPos = totalFlex = 0;
        for (i = 0, l = items.length; i &lt; l; i++) {
          ctrl = items[i];
          ctrlLayoutRect = ctrl.layoutRect();
          ctrlSettings = ctrl.settings;
          flex = ctrlSettings.flex;
          availableSpace -= i &lt; l - 1 ? spacing : 0;
          if (flex &gt; 0) {
            totalFlex += flex;
            if (ctrlLayoutRect[maxSizeName]) {
              maxSizeItems.push(ctrl);
            }
            ctrlLayoutRect.flex = flex;
          }
          availableSpace -= ctrlLayoutRect[minSizeName];
          size = contPaddingBox[alignBeforeName] + ctrlLayoutRect[alignMinSizeName] + contPaddingBox[alignAfterName];
          if (size &gt; maxAlignEndPos) {
            maxAlignEndPos = size;
          }
        }
        rect = {};
        if (availableSpace &lt; 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 &amp;&amp; (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 &lt; l; i++) {
          ctrl = maxSizeItems[i];
          ctrlLayoutRect = ctrl.layoutRect();
          maxSize = ctrlLayoutRect[maxSizeName];
          size = ctrlLayoutRect[minSizeName] + ctrlLayoutRect.flex * ratio;
          if (size &gt; 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 === &#039;end&#039;) {
            pos = availableSpace + contPaddingBox[beforeName];
          } else if (pack === &#039;center&#039;) {
            pos = Math.round(contLayoutRect[innerSizeName] / 2 - (contLayoutRect[innerSizeName] - availableSpace) / 2) + contPaddingBox[beforeName];
            if (pos &lt; 0) {
              pos = contPaddingBox[beforeName];
            }
          } else if (pack === &#039;justify&#039;) {
            pos = contPaddingBox[beforeName];
            spacing = Math.floor(availableSpace / (items.length - 1));
          }
        }
        rect[alignAxisName] = contPaddingBox[alignBeforeName];
        for (i = 0, l = items.length; i &lt; l; i++) {
          ctrl = items[i];
          ctrlLayoutRect = ctrl.layoutRect();
          size = ctrlLayoutRect.maxFlexSize || ctrlLayoutRect[minSizeName];
          if (align === &#039;center&#039;) {
            rect[alignAxisName] = Math.round(contLayoutRect[alignInnerSizeName] / 2 - ctrlLayoutRect[alignSizeName] / 2);
          } else if (align === &#039;stretch&#039;) {
            rect[alignSizeName] = max(ctrlLayoutRect[alignMinSizeName] || 0, contLayoutRect[alignInnerSizeName] - contPaddingBox[alignBeforeName] - contPaddingBox[alignAfterName]);
            rect[alignAxisName] = contPaddingBox[alignBeforeName];
          } else if (align === &#039;end&#039;) {
            rect[alignAxisName] = contLayoutRect[alignInnerSizeName] - ctrlLayoutRect[alignSizeName] - contPaddingBox.top;
          }
          if (ctrlLayoutRect.flex &gt; 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: &#039;flow-layout&#039;,
        controlClass: &#039;flow-layout-item&#039;,
        endClass: &#039;break&#039;
      },
      recalc: function (container) {
        container.items().filter(&#039;:visible&#039;).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(&#039;mceToggleFormat&#039;, 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(&#039;init&#039;, 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 = [
        &#039;alignleft&#039;,
        &#039;aligncenter&#039;,
        &#039;alignright&#039;,
        &#039;alignjustify&#039;
      ];
      var defaultAlign = &#039;alignleft&#039;;
      var alignMenuItems = [
        {
          text: &#039;Left&#039;,
          icon: &#039;alignleft&#039;,
          onclick: toggleFormat(editor, &#039;alignleft&#039;)
        },
        {
          text: &#039;Center&#039;,
          icon: &#039;aligncenter&#039;,
          onclick: toggleFormat(editor, &#039;aligncenter&#039;)
        },
        {
          text: &#039;Right&#039;,
          icon: &#039;alignright&#039;,
          onclick: toggleFormat(editor, &#039;alignright&#039;)
        },
        {
          text: &#039;Justify&#039;,
          icon: &#039;alignjustify&#039;,
          onclick: toggleFormat(editor, &#039;alignjustify&#039;)
        }
      ];
      editor.addMenuItem(&#039;align&#039;, {
        text: &#039;Align&#039;,
        menu: alignMenuItems
      });
      editor.addButton(&#039;align&#039;, {
        type: &#039;menubutton&#039;,
        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: [
          &#039;Align left&#039;,
          &#039;JustifyLeft&#039;
        ],
        aligncenter: [
          &#039;Align center&#039;,
          &#039;JustifyCenter&#039;
        ],
        alignright: [
          &#039;Align right&#039;,
          &#039;JustifyRight&#039;
        ],
        alignjustify: [
          &#039;Justify&#039;,
          &#039;JustifyFull&#039;
        ],
        alignnone: [
          &#039;No alignment&#039;,
          &#039;JustifyNone&#039;
        ]
      }, 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(&#039;,&#039;)[0] : &#039;&#039;;
    };
    var findMatchingValue = function (items, fontFamily) {
      var font = fontFamily ? fontFamily.toLowerCase() : &#039;&#039;;
      var value;
      global$4.each(items, function (item) {
        if (item.value.toLowerCase() === font) {
          value = item.value;
        }
      });
      global$4.each(items, function (item) {
        if (!value &amp;&amp; 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(&#039;value&#039;, null);
        editor.on(&#039;init nodeChange&#039;, function (e) {
          var fontFamily = editor.queryCommandValue(&#039;FontName&#039;);
          var match = findMatchingValue(items, fontFamily);
          self.value(match ? match : null);
          if (!match &amp;&amp; fontFamily) {
            self.text(getFirstFont(fontFamily));
          }
        });
      };
    };
    var createFormats = function (formats) {
      formats = formats.replace(/;$/, &#039;&#039;).split(&#039;;&#039;);
      var i = formats.length;
      while (i--) {
        formats[i] = formats[i].split(&#039;=&#039;);
      }
      return formats;
    };
    var getFontItems = function (editor) {
      var defaultFontsFormats = &#039;Andale Mono=andale mono,monospace;&#039; + &#039;Arial=arial,helvetica,sans-serif;&#039; + &#039;Arial Black=arial black,sans-serif;&#039; + &#039;Book Antiqua=book antiqua,palatino,serif;&#039; + &#039;Comic Sans MS=comic sans ms,sans-serif;&#039; + &#039;Courier New=courier new,courier,monospace;&#039; + &#039;Georgia=georgia,palatino,serif;&#039; + &#039;Helvetica=helvetica,arial,sans-serif;&#039; + &#039;Impact=impact,sans-serif;&#039; + &#039;Symbol=symbol;&#039; + &#039;Tahoma=tahoma,arial,helvetica,sans-serif;&#039; + &#039;Terminal=terminal,monaco,monospace;&#039; + &#039;Times New Roman=times new roman,times,serif;&#039; + &#039;Trebuchet MS=trebuchet ms,geneva,sans-serif;&#039; + &#039;Verdana=verdana,geneva,sans-serif;&#039; + &#039;Webdings=webdings;&#039; + &#039;Wingdings=wingdings,zapf dingbats&#039;;
      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(&#039;dings&#039;) === -1 ? &#039;font-family:&#039; + font[1] : &#039;&#039;
        };
      });
    };
    var registerButtons = function (editor) {
      editor.addButton(&#039;fontselect&#039;, function () {
        var items = getFontItems(editor);
        return {
          type: &#039;listbox&#039;,
          text: &#039;Font Family&#039;,
          tooltip: &#039;Font Family&#039;,
          values: items,
          fixedWidth: true,
          onPostRender: createFontNameListBoxChangeHandler(editor, items),
          onselect: function (e) {
            if (e.control.settings.value) {
              editor.execCommand(&#039;FontName&#039;, 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) + &#039;pt&#039;;
      }
      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(&#039;init nodeChange&#039;, function (e) {
          var px, pt, precision, match;
          px = editor.queryCommandValue(&#039;FontSize&#039;);
          if (px) {
            for (precision = 3; !match &amp;&amp; precision &gt;= 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 = &#039;8pt 10pt 12pt 14pt 18pt 24pt 36pt&#039;;
      var fontsizeFormats = editor.settings.fontsize_formats || defaultFontsizeFormats;
      return global$4.map(fontsizeFormats.split(&#039; &#039;), function (item) {
        var text = item, value = item;
        var values = item.split(&#039;=&#039;);
        if (values.length &gt; 1) {
          text = values[0];
          value = values[1];
        }
        return {
          text: text,
          value: value
        };
      });
    };
    var registerButtons$1 = function (editor) {
      editor.addButton(&#039;fontsizeselect&#039;, function () {
        var items = getFontSizeItems(editor);
        return {
          type: &#039;listbox&#039;,
          text: &#039;Font Sizes&#039;,
          tooltip: &#039;Font Sizes&#039;,
          values: items,
          fixedWidth: true,
          onPostRender: createFontSizeListBoxChangeHandler(editor, items),
          onclick: function (e) {
            if (e.control.settings.value) {
              editor.execCommand(&#039;FontSize&#039;, 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) &gt; 0);
        }
        if (!item.menu &amp;&amp; item.settings.menu) {
          item.visible(hideMenuObjects(editor, item.settings.menu) &gt; 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: &#039;Headings&#039;,
          items: [
            {
              title: &#039;Heading 1&#039;,
              format: &#039;h1&#039;
            },
            {
              title: &#039;Heading 2&#039;,
              format: &#039;h2&#039;
            },
            {
              title: &#039;Heading 3&#039;,
              format: &#039;h3&#039;
            },
            {
              title: &#039;Heading 4&#039;,
              format: &#039;h4&#039;
            },
            {
              title: &#039;Heading 5&#039;,
              format: &#039;h5&#039;
            },
            {
              title: &#039;Heading 6&#039;,
              format: &#039;h6&#039;
            }
          ]
        },
        {
          title: &#039;Inline&#039;,
          items: [
            {
              title: &#039;Bold&#039;,
              icon: &#039;bold&#039;,
              format: &#039;bold&#039;
            },
            {
              title: &#039;Italic&#039;,
              icon: &#039;italic&#039;,
              format: &#039;italic&#039;
            },
            {
              title: &#039;Underline&#039;,
              icon: &#039;underline&#039;,
              format: &#039;underline&#039;
            },
            {
              title: &#039;Strikethrough&#039;,
              icon: &#039;strikethrough&#039;,
              format: &#039;strikethrough&#039;
            },
            {
              title: &#039;Superscript&#039;,
              icon: &#039;superscript&#039;,
              format: &#039;superscript&#039;
            },
            {
              title: &#039;Subscript&#039;,
              icon: &#039;subscript&#039;,
              format: &#039;subscript&#039;
            },
            {
              title: &#039;Code&#039;,
              icon: &#039;code&#039;,
              format: &#039;code&#039;
            }
          ]
        },
        {
          title: &#039;Blocks&#039;,
          items: [
            {
              title: &#039;Paragraph&#039;,
              format: &#039;p&#039;
            },
            {
              title: &#039;Blockquote&#039;,
              format: &#039;blockquote&#039;
            },
            {
              title: &#039;Div&#039;,
              format: &#039;div&#039;
            },
            {
              title: &#039;Pre&#039;,
              format: &#039;pre&#039;
            }
          ]
        },
        {
          title: &#039;Alignment&#039;,
          items: [
            {
              title: &#039;Left&#039;,
              icon: &#039;alignleft&#039;,
              format: &#039;alignleft&#039;
            },
            {
              title: &#039;Center&#039;,
              icon: &#039;aligncenter&#039;,
              format: &#039;aligncenter&#039;
            },
            {
              title: &#039;Right&#039;,
              icon: &#039;alignright&#039;,
              format: &#039;alignright&#039;
            },
            {
              title: &#039;Justify&#039;,
              icon: &#039;alignjustify&#039;,
              format: &#039;alignjustify&#039;
            }
          ]
        }
      ];
      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 || &#039;custom&#039; + 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(&#039;init&#039;, function () {
        global$4.each(newFormats, function (format) {
          editor.formatter.register(format.name, format);
        });
      });
      return {
        type: &#039;menu&#039;,
        items: createStylesMenu(),
        onPostRender: function (e) {
          editor.fire(&#039;renderFormatsMenu&#039;, { 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(&#039;show&#039;, 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(&#039;formats&#039;, {
        text: &#039;Formats&#039;,
        menu: formatMenu
      });
    };
    var registerButtons$2 = function (editor, formatMenu) {
      editor.addButton(&#039;styleselect&#039;, {
        type: &#039;menubutton&#039;,
        text: &#039;Formats&#039;,
        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 = &#039;Paragraph=p;&#039; + &#039;Heading 1=h1;&#039; + &#039;Heading 2=h2;&#039; + &#039;Heading 3=h3;&#039; + &#039;Heading 4=h4;&#039; + &#039;Heading 5=h5;&#039; + &#039;Heading 6=h6;&#039; + &#039;Preformatted=pre&#039;;
    var createFormats$1 = function (formats) {
      formats = formats.replace(/;$/, &#039;&#039;).split(&#039;;&#039;);
      var i = formats.length;
      while (i--) {
        formats[i] = formats[i].split(&#039;=&#039;);
      }
      return formats;
    };
    var createListBoxChangeHandler = function (editor, items, formatName) {
      return function () {
        var self = this;
        editor.on(&#039;nodeChange&#039;, 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: &#039;listbox&#039;,
          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(&#039;blockformats&#039;, {
        text: &#039;Blocks&#039;,
        menu: buildMenuItems(editor, blocks)
      });
      editor.addButton(&#039;formatselect&#039;, lazyFormatSelectBoxItems(editor, blocks));
    };
    var FormatSelect = { register: register$4 };

    var createCustomMenuItems = function (editor, names) {
      var items, nameList;
      if (typeof names === &#039;string&#039;) {
        nameList = names.split(&#039; &#039;);
      } 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 === &#039;|&#039; || name in editor.menuItems;
      });
      return global$4.map(items, function (name) {
        return name === &#039;|&#039; ? { text: &#039;-&#039; } : editor.menuItems[name];
      });
    };
    var isSeparator = function (menuItem) {
      return menuItem &amp;&amp; menuItem.text === &#039;-&#039;;
    };
    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 &gt; 0 &amp;&amp; i &lt; menuItems2.length - 1;
      });
    };
    var createContextMenuItems = function (editor, context) {
      var outputMenuItems = [{ text: &#039;-&#039; }];
      var menuItems = global$4.grep(editor.menuItems, function (menuItem) {
        return menuItem.context === context;
      });
      global$4.each(menuItems, function (menuItem) {
        if (menuItem.separator === &#039;before&#039;) {
          outputMenuItems.push({ text: &#039;|&#039; });
        }
        if (menuItem.prependToContext) {
          outputMenuItems.unshift(menuItem);
        } else {
          outputMenuItems.push(menuItem);
        }
        if (menuItem.separator === &#039;after&#039;) {
          outputMenuItems.push({ text: &#039;|&#039; });
        }
      });
      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, &#039;insert&#039;));
      }
    };
    var registerButtons$3 = function (editor) {
      editor.addButton(&#039;insert&#039;, {
        type: &#039;menubutton&#039;,
        icon: &#039;insert&#039;,
        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: &#039;Bold&#039;,
        italic: &#039;Italic&#039;,
        underline: &#039;Underline&#039;,
        strikethrough: &#039;Strikethrough&#039;,
        subscript: &#039;Subscript&#039;,
        superscript: &#039;Superscript&#039;
      }, 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: [
          &#039;Decrease indent&#039;,
          &#039;Outdent&#039;
        ],
        indent: [
          &#039;Increase indent&#039;,
          &#039;Indent&#039;
        ],
        cut: [
          &#039;Cut&#039;,
          &#039;Cut&#039;
        ],
        copy: [
          &#039;Copy&#039;,
          &#039;Copy&#039;
        ],
        paste: [
          &#039;Paste&#039;,
          &#039;Paste&#039;
        ],
        help: [
          &#039;Help&#039;,
          &#039;mceHelp&#039;
        ],
        selectall: [
          &#039;Select all&#039;,
          &#039;SelectAll&#039;
        ],
        visualaid: [
          &#039;Visual aids&#039;,
          &#039;mceToggleVisualAid&#039;
        ],
        newdocument: [
          &#039;New document&#039;,
          &#039;mceNewDocument&#039;
        ],
        removeformat: [
          &#039;Clear formatting&#039;,
          &#039;RemoveFormat&#039;
        ],
        remove: [
          &#039;Remove&#039;,
          &#039;Delete&#039;
        ]
      }, function (item, name) {
        editor.addButton(name, {
          tooltip: item[0],
          cmd: item[1]
        });
      });
    };
    var registerCommandToggleButtons = function (editor) {
      global$4.each({
        blockquote: [
          &#039;Blockquote&#039;,
          &#039;mceBlockQuote&#039;
        ],
        subscript: [
          &#039;Subscript&#039;,
          &#039;Subscript&#039;
        ],
        superscript: [
          &#039;Superscript&#039;,
          &#039;Superscript&#039;
        ]
      }, 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: [
          &#039;Bold&#039;,
          &#039;Bold&#039;,
          &#039;Meta+B&#039;
        ],
        italic: [
          &#039;Italic&#039;,
          &#039;Italic&#039;,
          &#039;Meta+I&#039;
        ],
        underline: [
          &#039;Underline&#039;,
          &#039;Underline&#039;,
          &#039;Meta+U&#039;
        ],
        strikethrough: [
          &#039;Strikethrough&#039;,
          &#039;Strikethrough&#039;
        ],
        subscript: [
          &#039;Subscript&#039;,
          &#039;Subscript&#039;
        ],
        superscript: [
          &#039;Superscript&#039;,
          &#039;Superscript&#039;
        ],
        removeformat: [
          &#039;Clear formatting&#039;,
          &#039;RemoveFormat&#039;
        ],
        newdocument: [
          &#039;New document&#039;,
          &#039;mceNewDocument&#039;
        ],
        cut: [
          &#039;Cut&#039;,
          &#039;Cut&#039;,
          &#039;Meta+X&#039;
        ],
        copy: [
          &#039;Copy&#039;,
          &#039;Copy&#039;,
          &#039;Meta+C&#039;
        ],
        paste: [
          &#039;Paste&#039;,
          &#039;Paste&#039;,
          &#039;Meta+V&#039;
        ],
        selectall: [
          &#039;Select all&#039;,
          &#039;SelectAll&#039;,
          &#039;Meta+A&#039;
        ]
      }, function (item, name) {
        editor.addMenuItem(name, {
          text: item[0],
          icon: name,
          shortcut: item[2],
          cmd: item[1]
        });
      });
      editor.addMenuItem(&#039;codeformat&#039;, {
        text: &#039;Code&#039;,
        icon: &#039;code&#039;,
        onclick: toggleFormat(editor, &#039;code&#039;)
      });
    };
    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 === &#039;redo&#039; ? &#039;hasRedo&#039; : &#039;hasUndo&#039;;
          return editor.undoManager ? editor.undoManager[typeFn]() : false;
        };
        self.disabled(!checkState());
        editor.on(&#039;Undo Redo AddUndo TypingUndo ClearUndos SwitchMode&#039;, function () {
          self.disabled(editor.readonly || !checkState());
        });
      };
    };
    var registerMenuItems$2 = function (editor) {
      editor.addMenuItem(&#039;undo&#039;, {
        text: &#039;Undo&#039;,
        icon: &#039;undo&#039;,
        shortcut: &#039;Meta+Z&#039;,
        onPostRender: toggleUndoRedoState(editor, &#039;undo&#039;),
        cmd: &#039;undo&#039;
      });
      editor.addMenuItem(&#039;redo&#039;, {
        text: &#039;Redo&#039;,
        icon: &#039;redo&#039;,
        shortcut: &#039;Meta+Y&#039;,
        onPostRender: toggleUndoRedoState(editor, &#039;redo&#039;),
        cmd: &#039;redo&#039;
      });
    };
    var registerButtons$5 = function (editor) {
      editor.addButton(&#039;undo&#039;, {
        tooltip: &#039;Undo&#039;,
        onPostRender: toggleUndoRedoState(editor, &#039;undo&#039;),
        cmd: &#039;undo&#039;
      });
      editor.addButton(&#039;redo&#039;, {
        tooltip: &#039;Redo&#039;,
        onPostRender: toggleUndoRedoState(editor, &#039;redo&#039;),
        cmd: &#039;redo&#039;
      });
    };
    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(&#039;VisualAid&#039;, function (e) {
          self.active(e.hasVisual);
        });
        self.active(editor.hasVisual);
      };
    };
    var registerMenuItems$3 = function (editor) {
      editor.addMenuItem(&#039;visualaid&#039;, {
        text: &#039;Visual aids&#039;,
        selectable: true,
        onPostRender: toggleVisualAidState(editor),
        cmd: &#039;mceToggleVisualAid&#039;
      });
    };
    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(&#039;mousedown progressstate&#039;, 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(&#039;:visible&#039;);
        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 = &#039;reverseRows&#039; in settings ? settings.reverseRows : container.isRtl();
        if (alignH &amp;&amp; typeof alignH === &#039;string&#039;) {
          alignH = [alignH];
        }
        if (alignV &amp;&amp; typeof alignV === &#039;string&#039;) {
          alignV = [alignV];
        }
        for (x = 0; x &lt; cols; x++) {
          colWidths.push(0);
        }
        for (y = 0; y &lt; rows; y++) {
          rowHeights.push(0);
        }
        for (y = 0; y &lt; rows; y++) {
          for (x = 0; x &lt; cols; x++) {
            ctrl = items[y * cols + x];
            if (!ctrl) {
              break;
            }
            ctrlLayoutRect = ctrl.layoutRect();
            ctrlMinWidth = ctrlLayoutRect.minW;
            ctrlMinHeight = ctrlLayoutRect.minH;
            colWidths[x] = ctrlMinWidth &gt; colWidths[x] ? ctrlMinWidth : colWidths[x];
            rowHeights[y] = ctrlMinHeight &gt; rowHeights[y] ? ctrlMinHeight : rowHeights[y];
          }
        }
        availableWidth = contLayoutRect.innerW - contPaddingBox.left - contPaddingBox.right;
        for (maxX = 0, x = 0; x &lt; cols; x++) {
          maxX += colWidths[x] + (x &gt; 0 ? spacingH : 0);
          availableWidth -= (x &gt; 0 ? spacingH : 0) + colWidths[x];
        }
        availableHeight = contLayoutRect.innerH - contPaddingBox.top - contPaddingBox.bottom;
        for (maxY = 0, y = 0; y &lt; rows; y++) {
          maxY += rowHeights[y] + (y &gt; 0 ? spacingV : 0);
          availableHeight -= (y &gt; 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 &amp;&amp; (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 === &#039;start&#039;) {
          flexV = 0;
        } else {
          flexV = availableHeight &gt; 0 ? Math.floor(availableHeight / rows) : 0;
        }
        var totalFlex = 0;
        var flexWidths = settings.flexWidths;
        if (flexWidths) {
          for (x = 0; x &lt; flexWidths.length; x++) {
            totalFlex += flexWidths[x];
          }
        } else {
          totalFlex = cols;
        }
        var ratio = availableWidth / totalFlex;
        for (x = 0; x &lt; cols; x++) {
          colWidths[x] += flexWidths ? flexWidths[x] * ratio : ratio;
        }
        posY = contPaddingBox.top;
        for (y = 0; y &lt; rows; y++) {
          posX = contPaddingBox.left;
          height = rowHeights[y] + flexV;
          for (x = 0; x &lt; 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 === &#039;center&#039;) {
              ctrlLayoutRect.x = posX + width / 2 - ctrlLayoutRect.w / 2;
            } else if (align === &#039;right&#039;) {
              ctrlLayoutRect.x = posX + width - ctrlLayoutRect.w;
            } else if (align === &#039;stretch&#039;) {
              ctrlLayoutRect.w = width;
            }
            align = ctrlSettings.alignV || (alignV ? alignV[x] || alignV[0] : null);
            if (align === &#039;center&#039;) {
              ctrlLayoutRect.y = posY + height / 2 - ctrlLayoutRect.h / 2;
            } else if (align === &#039;bottom&#039;) {
              ctrlLayoutRect.y = posY + height - ctrlLayoutRect.h;
            } else if (align === &#039;stretch&#039;) {
              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(&#039;iframe&#039;);
        self.canFocus = false;
        return &#039;&lt;iframe id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; tabindex=&quot;-1&quot; src=&quot;&#039; + (self.settings.url || &#039;javascript:\&#039;\&#039;&#039;) + &#039;&quot; frameborder=&quot;0&quot;&gt;&lt;/iframe&gt;&#039;;
      },
      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(&#039;widget&#039;).add(&#039;infobox&#039;);
        self.canFocus = false;
      },
      severity: function (level) {
        this.classes.remove(&#039;error&#039;);
        this.classes.remove(&#039;warning&#039;);
        this.classes.remove(&#039;success&#039;);
        this.classes.add(level);
      },
      help: function (state) {
        this.state.set(&#039;help&#039;, state);
      },
      renderHtml: function () {
        var self = this, prefix = self.classPrefix;
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&gt;&#039; + &#039;&lt;div id=&quot;&#039; + self._id + &#039;-body&quot;&gt;&#039; + self.encode(self.state.get(&#039;text&#039;)) + &#039;&lt;button role=&quot;button&quot; tabindex=&quot;-1&quot;&gt;&#039; + &#039;&lt;i class=&quot;&#039; + prefix + &#039;ico &#039; + prefix + &#039;i-help&quot;&gt;&lt;/i&gt;&#039; + &#039;&lt;/button&gt;&#039; + &#039;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:text&#039;, function (e) {
          self.getEl(&#039;body&#039;).firstChild.data = self.encode(e.value);
          if (self.state.get(&#039;rendered&#039;)) {
            self.updateLayoutRect();
          }
        });
        self.state.on(&#039;change:help&#039;, function (e) {
          self.classes.toggle(&#039;has-help&#039;, e.value);
          if (self.state.get(&#039;rendered&#039;)) {
            self.updateLayoutRect();
          }
        });
        return self._super();
      }
    });

    var Label = Widget.extend({
      init: function (settings) {
        var self = this;
        self._super(settings);
        self.classes.add(&#039;widget&#039;).add(&#039;label&#039;);
        self.canFocus = false;
        if (settings.multiline) {
          self.classes.add(&#039;autoscroll&#039;);
        }
        if (settings.strong) {
          self.classes.add(&#039;strong&#039;);
        }
      },
      initLayoutRect: function () {
        var self = this, layoutRect = self._super();
        if (self.settings.multiline) {
          var size = funcs.getSize(self.getEl());
          if (size.width &gt; layoutRect.maxW) {
            layoutRect.minW = layoutRect.maxW;
            self.classes.add(&#039;multiline&#039;);
          }
          self.getEl().style.width = layoutRect.minW + &#039;px&#039;;
          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 + &#039;px&#039;;
        }
        return self._super();
      },
      severity: function (level) {
        this.classes.remove(&#039;error&#039;);
        this.classes.remove(&#039;warning&#039;);
        this.classes.remove(&#039;success&#039;);
        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(&#039;text&#039;));
        if (!forId &amp;&amp; (forName = self.settings.forName)) {
          targetCtrl = self.getRoot().find(&#039;#&#039; + forName)[0];
          if (targetCtrl) {
            forId = targetCtrl._id;
          }
        }
        if (forId) {
          return &#039;&lt;label id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&#039; + (forId ? &#039; for=&quot;&#039; + forId + &#039;&quot;&#039; : &#039;&#039;) + &#039;&gt;&#039; + text + &#039;&lt;/label&gt;&#039;;
        }
        return &#039;&lt;span id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&gt;&#039; + text + &#039;&lt;/span&gt;&#039;;
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:text&#039;, function (e) {
          self.innerHtml(self.encode(e.value));
          if (self.state.get(&#039;rendered&#039;)) {
            self.updateLayoutRect();
          }
        });
        return self._super();
      }
    });

    var Toolbar$1 = Container.extend({
      Defaults: {
        role: &#039;toolbar&#039;,
        layout: &#039;flow&#039;
      },
      init: function (settings) {
        var self = this;
        self._super(settings);
        self.classes.add(&#039;toolbar&#039;);
      },
      postRender: function () {
        var self = this;
        self.items().each(function (ctrl) {
          ctrl.classes.add(&#039;toolbar-item&#039;);
        });
        return self._super();
      }
    });

    var MenuBar = Toolbar$1.extend({
      Defaults: {
        role: &#039;menubar&#039;,
        containerCls: &#039;menubar&#039;,
        ariaRoot: true,
        defaults: { type: &#039;menubutton&#039; }
      }
    });

    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(&#039;menubtn&#039;);
        if (settings.fixedWidth) {
          self.classes.add(&#039;fixed-width&#039;);
        }
        self.aria(&#039;haspopup&#039;, true);
        self.state.set(&#039;menu&#039;, settings.menu || self.render());
      },
      showMenu: function (toggle) {
        var self = this;
        var menu;
        if (self.menu &amp;&amp; self.menu.visible() &amp;&amp; toggle !== false) {
          return self.hideMenu();
        }
        if (!self.menu) {
          menu = self.state.get(&#039;menu&#039;) || [];
          self.classes.add(&#039;opened&#039;);
          if (menu.length) {
            menu = {
              type: &#039;menu&#039;,
              animate: true,
              items: menu
            };
          } else {
            menu.type = menu.type || &#039;menu&#039;;
            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(&#039;createmenu&#039;);
          self.menu.reflow();
          self.menu.on(&#039;cancel&#039;, function (e) {
            if (e.control.parent() === self.menu) {
              e.stopPropagation();
              self.focus();
              self.hideMenu();
            }
          });
          self.menu.on(&#039;select&#039;, function () {
            self.focus();
          });
          self.menu.on(&#039;show hide&#039;, function (e) {
            if (e.type === &#039;hide&#039; &amp;&amp; e.control.parent() === self) {
              self.classes.remove(&#039;opened-under&#039;);
            }
            if (e.control === self.menu) {
              self.activeMenu(e.type === &#039;show&#039;);
              self.classes.toggle(&#039;opened&#039;, e.type === &#039;show&#039;);
            }
            self.aria(&#039;expanded&#039;, e.type === &#039;show&#039;);
          }).fire(&#039;show&#039;);
        }
        self.menu.show();
        self.menu.layoutRect({ w: self.layoutRect().w });
        self.menu.repaint();
        self.menu.moveRel(self.getEl(), self.isRtl() ? [
          &#039;br-tr&#039;,
          &#039;tr-br&#039;
        ] : [
          &#039;bl-tl&#039;,
          &#039;tl-bl&#039;
        ]);
        var menuLayoutRect = self.menu.layoutRect();
        var selfBottom = self.$el.offset().top + self.layoutRect().h;
        if (selfBottom &gt; menuLayoutRect.y &amp;&amp; selfBottom &lt; menuLayoutRect.y + menuLayoutRect.h) {
          self.classes.add(&#039;opened-under&#039;);
        }
        self.fire(&#039;showmenu&#039;);
      },
      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(&#039;active&#039;, state);
      },
      renderHtml: function () {
        var self = this, id = self._id, prefix = self.classPrefix;
        var icon = self.settings.icon, image;
        var text = self.state.get(&#039;text&#039;);
        var textHtml = &#039;&#039;;
        image = self.settings.image;
        if (image) {
          icon = &#039;none&#039;;
          if (typeof image !== &#039;string&#039;) {
            image = domGlobals.window.getSelection ? image[0] : image[1];
          }
          image = &#039; style=&quot;background-image: url(\&#039;&#039; + image + &#039;\&#039;)&quot;&#039;;
        } else {
          image = &#039;&#039;;
        }
        if (text) {
          self.classes.add(&#039;btn-has-text&#039;);
          textHtml = &#039;&lt;span class=&quot;&#039; + prefix + &#039;txt&quot;&gt;&#039; + self.encode(text) + &#039;&lt;/span&gt;&#039;;
        }
        icon = self.settings.icon ? prefix + &#039;ico &#039; + prefix + &#039;i-&#039; + icon : &#039;&#039;;
        self.aria(&#039;role&#039;, self.parent() instanceof MenuBar ? &#039;menuitem&#039; : &#039;button&#039;);
        return &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; tabindex=&quot;-1&quot; aria-labelledby=&quot;&#039; + id + &#039;&quot;&gt;&#039; + &#039;&lt;button id=&quot;&#039; + id + &#039;-open&quot; role=&quot;presentation&quot; type=&quot;button&quot; tabindex=&quot;-1&quot;&gt;&#039; + (icon ? &#039;&lt;i class=&quot;&#039; + icon + &#039;&quot;&#039; + image + &#039;&gt;&lt;/i&gt;&#039; : &#039;&#039;) + textHtml + &#039; &lt;i class=&quot;&#039; + prefix + &#039;caret&quot;&gt;&lt;/i&gt;&#039; + &#039;&lt;/button&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      postRender: function () {
        var self = this;
        self.on(&#039;click&#039;, function (e) {
          if (e.control === self &amp;&amp; isChildOf$1(e.target, self.getEl())) {
            self.focus();
            self.showMenu(!e.aria);
            if (e.aria) {
              self.menu.items().filter(&#039;:visible&#039;)[0].focus();
            }
          }
        });
        self.on(&#039;mouseenter&#039;, function (e) {
          var overCtrl = e.control;
          var parent = self.parent();
          var hasVisibleSiblingMenu;
          if (overCtrl &amp;&amp; parent &amp;&amp; overCtrl instanceof MenuButton &amp;&amp; overCtrl.parent() === parent) {
            parent.items().filter(&#039;MenuButton&#039;).each(function (ctrl) {
              if (ctrl.hideMenu &amp;&amp; ctrl !== overCtrl) {
                if (ctrl.menu &amp;&amp; ctrl.menu.visible()) {
                  hasVisibleSiblingMenu = true;
                }
                ctrl.hideMenu();
              }
            });
            if (hasVisibleSiblingMenu) {
              overCtrl.focus();
              overCtrl.showMenu();
            }
          }
        });
        return self._super();
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:menu&#039;, 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(&#039;&lt;div class=&quot;&#039; + classPrefix + &#039;throbber&#039; + (inline ? &#039; &#039; + classPrefix + &#039;throbber-inline&#039; : &#039;&#039;) + &#039;&quot;&gt;&lt;/div&gt;&#039;);
            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 &amp;&amp; child.className.indexOf(&#039;throbber&#039;) !== -1) {
          child.parentNode.removeChild(child);
        }
        state = false;
        return self;
      };
    }

    var Menu = FloatPanel.extend({
      Defaults: {
        defaultType: &#039;menuitem&#039;,
        border: 1,
        layout: &#039;stack&#039;,
        role: &#039;application&#039;,
        bodyRole: &#039;menu&#039;,
        ariaRoot: true
      },
      init: function (settings) {
        var self = this;
        settings.autohide = true;
        settings.constrainToViewport = true;
        if (typeof settings.items === &#039;function&#039;) {
          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(&#039;menu&#039;);
        if (settings.animate &amp;&amp; global$1.ie !== 11) {
          self.classes.add(&#039;animate&#039;);
        }
      },
      repaint: function () {
        this.classes.toggle(&#039;menu-align&#039;, true);
        this._super();
        this.getEl().style.height = &#039;&#039;;
        this.getEl(&#039;body&#039;).style.height = &#039;&#039;;
        return this;
      },
      cancel: function () {
        var self = this;
        self.hideAll();
        self.fire(&#039;select&#039;);
      },
      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(&#039;body&#039;), true);
          if (self.items().length === 0) {
            self.throbber.show();
            self.fire(&#039;loading&#039;);
          } else {
            self.throbber.show(100, function () {
              self.items().remove();
              self.fire(&#039;loading&#039;);
            });
          }
          self.on(&#039;hide close&#039;, 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 = &#039;&#039;;
          self.getEl(&#039;body&#039;).style.width = &#039;&#039;;
          hideThrobber();
          self.items().remove();
          self.getEl(&#039;body&#039;).innerHTML = &#039;&#039;;
          self.add(items);
          self.renderNew();
          self.fire(&#039;loaded&#039;);
        });
      },
      hideAll: function () {
        var self = this;
        this.find(&#039;menuitem&#039;).exec(&#039;hideMenu&#039;);
        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(&#039;postrender&#039;, function () {
            if (self.settings.itemsFactory) {
              self.load();
            }
          });
        }
        self.on(&#039;show hide&#039;, function (e) {
          if (e.control === self) {
            if (e.type === &#039;show&#039;) {
              global$3.setTimeout(function () {
                self.classes.add(&#039;in&#039;);
              }, 0);
            } else {
              self.classes.remove(&#039;in&#039;);
            }
          }
        });
        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 &lt; menuValues.length; i++) {
            selected = menuValues[i].selected || settings.value === menuValues[i].value;
            if (selected) {
              selectedText = selectedText || menuValues[i].text;
              self.state.set(&#039;value&#039;, 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 !== &#039;undefined&#039;) {
            setSelected(values);
          }
          if (!selected &amp;&amp; values.length &gt; 0) {
            selectedText = values[0].text;
            self.state.set(&#039;value&#039;, values[0].value);
          }
          self.state.set(&#039;menu&#039;, values);
        }
        self.state.set(&#039;text&#039;, settings.text || selectedText);
        self.classes.add(&#039;listbox&#039;);
        self.on(&#039;select&#039;, 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(&#039;value&#039;);
        }
        if (typeof value === &#039;undefined&#039;) {
          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(&#039;value&#039;, value);
          } else if (value === null) {
            this.state.set(&#039;value&#039;, null);
          }
        } else {
          this.state.set(&#039;value&#039;, 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 &lt; 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(&#039;show&#039;, function (e) {
          activateMenuItemsByValue(e.control, self.value());
        });
        self.state.on(&#039;change:value&#039;, function (e) {
          var selectedItem = getSelectedItem(self.state.get(&#039;menu&#039;), 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(&#039;text&#039;);
        textElm.setAttribute(&#039;style&#039;, textStyle);
        if (state) {
          textElm.style.color = &#039;&#039;;
          textElm.style.backgroundColor = &#039;&#039;;
        }
      }
    };
    var MenuItem = Widget.extend({
      Defaults: {
        border: 0,
        role: &#039;menuitem&#039;
      },
      init: function (settings) {
        var self = this;
        var text;
        self._super(settings);
        settings = self.settings;
        self.classes.add(&#039;menu-item&#039;);
        if (settings.menu) {
          self.classes.add(&#039;menu-item-expand&#039;);
        }
        if (settings.preview) {
          self.classes.add(&#039;menu-item-preview&#039;);
        }
        text = self.state.get(&#039;text&#039;);
        if (text === &#039;-&#039; || text === &#039;|&#039;) {
          self.classes.add(&#039;menu-item-sep&#039;);
          self.aria(&#039;role&#039;, &#039;separator&#039;);
          self.state.set(&#039;text&#039;, &#039;-&#039;);
        }
        if (settings.selectable) {
          self.aria(&#039;role&#039;, &#039;menuitemcheckbox&#039;);
          self.classes.add(&#039;menu-item-checkbox&#039;);
          settings.icon = &#039;selected&#039;;
        }
        if (!settings.preview &amp;&amp; !settings.selectable) {
          self.classes.add(&#039;menu-item-normal&#039;);
        }
        self.on(&#039;mousedown&#039;, function (e) {
          e.preventDefault();
        });
        if (settings.menu &amp;&amp; !settings.ariaHideMenu) {
          self.aria(&#039;haspopup&#039;, 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: &#039;menu&#039;,
                items: menu
              };
            } else {
              menu.type = menu.type || &#039;menu&#039;;
            }
            if (parent.settings.itemDefaults) {
              menu.itemDefaults = parent.settings.itemDefaults;
            }
            menu = self.menu = global$b.create(menu).parent(self).renderTo();
            menu.reflow();
            menu.on(&#039;cancel&#039;, function (e) {
              e.stopPropagation();
              self.focus();
              menu.hide();
            });
            menu.on(&#039;show hide&#039;, function (e) {
              if (e.control.items) {
                e.control.items().each(function (ctrl) {
                  ctrl.active(ctrl.settings.selected);
                });
              }
            }).fire(&#039;show&#039;);
            menu.on(&#039;hide&#039;, function (e) {
              if (e.control === menu) {
                self.classes.remove(&#039;selected&#039;);
              }
            });
            menu.submenu = true;
          } else {
            menu.show();
          }
          menu._parentMenu = parent;
          menu.classes.add(&#039;menu-sub&#039;);
          var rel = menu.testMoveRel(self.getEl(), self.isRtl() ? [
            &#039;tl-tr&#039;,
            &#039;bl-br&#039;,
            &#039;tr-tl&#039;,
            &#039;br-bl&#039;
          ] : [
            &#039;tr-tl&#039;,
            &#039;br-bl&#039;,
            &#039;tl-tr&#039;,
            &#039;bl-br&#039;
          ]);
          menu.moveRel(self.getEl(), rel);
          menu.rel = rel;
          rel = &#039;menu-sub-&#039; + rel;
          menu.classes.remove(menu._lastRel).add(rel);
          menu._lastRel = rel;
          self.classes.add(&#039;selected&#039;);
          self.aria(&#039;expanded&#039;, 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(&#039;expanded&#039;, 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(&#039;text&#039;);
        var icon = self.settings.icon, image = &#039;&#039;, shortcut = settings.shortcut;
        var url = self.encode(settings.url), iconHtml = &#039;&#039;;
        function convertShortcut(shortcut) {
          var i, value, replace = {};
          if (global$1.mac) {
            replace = {
              alt: &#039;&amp;#x2325;&#039;,
              ctrl: &#039;&amp;#x2318;&#039;,
              shift: &#039;&amp;#x21E7;&#039;,
              meta: &#039;&amp;#x2318;&#039;
            };
          } else {
            replace = { meta: &#039;Ctrl&#039; };
          }
          shortcut = shortcut.split(&#039;+&#039;);
          for (i = 0; i &lt; shortcut.length; i++) {
            value = replace[shortcut[i].toLowerCase()];
            if (value) {
              shortcut[i] = value;
            }
          }
          return shortcut.join(&#039;+&#039;);
        }
        function escapeRegExp(str) {
          return str.replace(/[.*+?^${}()|[\]\\]/g, &#039;\\$&amp;&#039;);
        }
        function markMatches(text) {
          var match = settings.match || &#039;&#039;;
          return match ? text.replace(new RegExp(escapeRegExp(match), &#039;gi&#039;), function (match) {
            return &#039;!mce~match[&#039; + match + &#039;]mce~match!&#039;;
          }) : text;
        }
        function boldMatches(text) {
          return text.replace(new RegExp(escapeRegExp(&#039;!mce~match[&#039;), &#039;g&#039;), &#039;&lt;b&gt;&#039;).replace(new RegExp(escapeRegExp(&#039;]mce~match!&#039;), &#039;g&#039;), &#039;&lt;/b&gt;&#039;);
        }
        if (icon) {
          self.parent().classes.add(&#039;menu-has-icons&#039;);
        }
        if (settings.image) {
          image = &#039; style=&quot;background-image: url(\&#039;&#039; + settings.image + &#039;\&#039;)&quot;&#039;;
        }
        if (shortcut) {
          shortcut = convertShortcut(shortcut);
        }
        icon = prefix + &#039;ico &#039; + prefix + &#039;i-&#039; + (self.settings.icon || &#039;none&#039;);
        iconHtml = text !== &#039;-&#039; ? &#039;&lt;i class=&quot;&#039; + icon + &#039;&quot;&#039; + image + &#039;&gt;&lt;/i&gt;\xA0&#039; : &#039;&#039;;
        text = boldMatches(self.encode(markMatches(text)));
        url = boldMatches(self.encode(markMatches(url)));
        return &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; tabindex=&quot;-1&quot;&gt;&#039; + iconHtml + (text !== &#039;-&#039; ? &#039;&lt;span id=&quot;&#039; + id + &#039;-text&quot; class=&quot;&#039; + prefix + &#039;text&quot;&gt;&#039; + text + &#039;&lt;/span&gt;&#039; : &#039;&#039;) + (shortcut ? &#039;&lt;div id=&quot;&#039; + id + &#039;-shortcut&quot; class=&quot;&#039; + prefix + &#039;menu-shortcut&quot;&gt;&#039; + shortcut + &#039;&lt;/div&gt;&#039; : &#039;&#039;) + (settings.menu ? &#039;&lt;div class=&quot;&#039; + prefix + &#039;caret&quot;&gt;&lt;/div&gt;&#039; : &#039;&#039;) + (url ? &#039;&lt;div class=&quot;&#039; + prefix + &#039;menu-item-link&quot;&gt;&#039; + url + &#039;&lt;/div&gt;&#039; : &#039;&#039;) + &#039;&lt;/div&gt;&#039;;
      },
      postRender: function () {
        var self = this, settings = self.settings;
        var textStyle = settings.textStyle;
        if (typeof textStyle === &#039;function&#039;) {
          textStyle = textStyle.call(this);
        }
        if (textStyle) {
          var textElm = self.getEl(&#039;text&#039;);
          if (textElm) {
            textElm.setAttribute(&#039;style&#039;, textStyle);
            self._textStyle = textStyle;
          }
        }
        self.on(&#039;mouseenter click&#039;, function (e) {
          if (e.control === self) {
            if (!settings.menu &amp;&amp; e.type === &#039;click&#039;) {
              self.fire(&#039;select&#039;);
              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(&#039;selected&#039;);
        });
        self.classes.toggle(&#039;selected&#039;, true);
        return self;
      },
      active: function (state) {
        toggleTextStyle(this, state);
        if (typeof state !== &#039;undefined&#039;) {
          this.aria(&#039;checked&#039;, state);
        }
        return this._super(state);
      },
      remove: function () {
        this._super();
        if (this.menu) {
          this.menu.remove();
        }
      }
    });

    var Radio = Checkbox.extend({
      Defaults: {
        classes: &#039;radio&#039;,
        role: &#039;radio&#039;
      }
    });

    var ResizeHandle = Widget.extend({
      renderHtml: function () {
        var self = this, prefix = self.classPrefix;
        self.classes.add(&#039;resizehandle&#039;);
        if (self.settings.direction === &#039;both&#039;) {
          self.classes.add(&#039;resizehandle-both&#039;);
        }
        self.canFocus = false;
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&gt;&#039; + &#039;&lt;i class=&quot;&#039; + prefix + &#039;ico &#039; + prefix + &#039;i-resize&quot;&gt;&lt;/i&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      postRender: function () {
        var self = this;
        self._super();
        self.resizeDragHelper = new DragHelper(this._id, {
          start: function () {
            self.fire(&#039;ResizeStart&#039;);
          },
          drag: function (e) {
            if (self.settings.direction !== &#039;both&#039;) {
              e.deltaX = 0;
            }
            self.fire(&#039;Resize&#039;, e);
          },
          stop: function () {
            self.fire(&#039;ResizeEnd&#039;);
          }
        });
      },
      remove: function () {
        if (this.resizeDragHelper) {
          this.resizeDragHelper.destroy();
        }
        return this._super();
      }
    });

    function createOptions(options) {
      var strOptions = &#039;&#039;;
      if (options) {
        for (var i = 0; i &lt; options.length; i++) {
          strOptions += &#039;&lt;option value=&quot;&#039; + options[i] + &#039;&quot;&gt;&#039; + options[i] + &#039;&lt;/option&gt;&#039;;
        }
      }
      return strOptions;
    }
    var SelectBox = Widget.extend({
      Defaults: {
        classes: &#039;selectbox&#039;,
        role: &#039;selectbox&#039;,
        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(&#039;keydown&#039;, 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(&#039;submit&#039;, { data: rootControl.toJSON() });
          }
        });
      },
      options: function (state) {
        if (!arguments.length) {
          return this.state.get(&#039;options&#039;);
        }
        this.state.set(&#039;options&#039;, state);
        return this;
      },
      renderHtml: function () {
        var self = this;
        var options, size = &#039;&#039;;
        options = createOptions(self._options);
        if (self.size) {
          size = &#039; size = &quot;&#039; + self.size + &#039;&quot;&#039;;
        }
        return &#039;&lt;select id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&#039; + size + &#039;&gt;&#039; + options + &#039;&lt;/select&gt;&#039;;
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:options&#039;, function (e) {
          self.getEl().innerHTML = createOptions(e.value);
        });
        return self._super();
      }
    });

    function constrain(value, minVal, maxVal) {
      if (value &lt; minVal) {
        value = minVal;
      }
      if (value &gt; maxVal) {
        value = maxVal;
      }
      return value;
    }
    function setAriaProp(el, name, value) {
      el.setAttribute(&#039;aria-&#039; + name, value);
    }
    function updateSliderHandle(ctrl, value) {
      var maxHandlePos, shortSizeName, sizeName, stylePosName, styleValue, handleEl;
      if (ctrl.settings.orientation === &#039;v&#039;) {
        stylePosName = &#039;top&#039;;
        sizeName = &#039;height&#039;;
        shortSizeName = &#039;h&#039;;
      } else {
        stylePosName = &#039;left&#039;;
        sizeName = &#039;width&#039;;
        shortSizeName = &#039;w&#039;;
      }
      handleEl = ctrl.getEl(&#039;handle&#039;);
      maxHandlePos = (ctrl.layoutRect()[shortSizeName] || 100) - funcs.getSize(handleEl)[sizeName];
      styleValue = maxHandlePos * ((value - ctrl._minValue) / (ctrl._maxValue - ctrl._minValue)) + &#039;px&#039;;
      handleEl.style[stylePosName] = styleValue;
      handleEl.style.height = ctrl.layoutRect().h + &#039;px&#039;;
      setAriaProp(handleEl, &#039;valuenow&#039;, value);
      setAriaProp(handleEl, &#039;valuetext&#039;, &#039;&#039; + ctrl.settings.previewFilter(value));
      setAriaProp(handleEl, &#039;valuemin&#039;, ctrl._minValue);
      setAriaProp(handleEl, &#039;valuemax&#039;, 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(&#039;slider&#039;);
        if (settings.orientation === &#039;v&#039;) {
          self.classes.add(&#039;vertical&#039;);
        }
        self._minValue = isNumber$1(settings.minValue) ? settings.minValue : 0;
        self._maxValue = isNumber$1(settings.maxValue) ? settings.maxValue : 100;
        self._initValue = self.state.get(&#039;value&#039;);
      },
      renderHtml: function () {
        var self = this, id = self._id, prefix = self.classPrefix;
        return &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&gt;&#039; + &#039;&lt;div id=&quot;&#039; + id + &#039;-handle&quot; class=&quot;&#039; + prefix + &#039;slider-handle&quot; role=&quot;slider&quot; tabindex=&quot;-1&quot;&gt;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      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(&#039;dragstart&#039;, { value: value });
            self.fire(&#039;drag&#039;, { value: value });
            self.fire(&#039;dragend&#039;, { value: value });
          }
          self.on(&#039;keydown&#039;, 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 + &#039;-handle&#039;,
            start: function (e) {
              startPos = e[screenCordName];
              startHandlePos = parseInt(self.getEl(&#039;handle&#039;).style[stylePosName], 10);
              maxHandlePos = (self.layoutRect()[shortSizeName] || 100) - funcs.getSize(handleEl)[sizeName];
              self.fire(&#039;dragstart&#039;, { value: value });
            },
            drag: function (e) {
              var delta = e[screenCordName] - startPos;
              handlePos = constrain(startHandlePos + delta, 0, maxHandlePos);
              handleEl.style[stylePosName] = handlePos + &#039;px&#039;;
              value = minValue + handlePos / maxHandlePos * (maxValue - minValue);
              self.value(value);
              self.tooltip().text(&#039;&#039; + self.settings.previewFilter(value)).show().moveRel(handleEl, &#039;bc tc&#039;);
              self.fire(&#039;drag&#039;, { value: value });
            },
            stop: function () {
              self.tooltip().hide();
              self.fire(&#039;dragend&#039;, { value: value });
            }
          });
        }
        minValue = self._minValue;
        maxValue = self._maxValue;
        if (self.settings.orientation === &#039;v&#039;) {
          screenCordName = &#039;screenY&#039;;
          stylePosName = &#039;top&#039;;
          sizeName = &#039;height&#039;;
          shortSizeName = &#039;h&#039;;
        } else {
          screenCordName = &#039;screenX&#039;;
          stylePosName = &#039;left&#039;;
          sizeName = &#039;width&#039;;
          shortSizeName = &#039;w&#039;;
        }
        self._super();
        handleKeyboard(minValue, maxValue);
        handleDrag(minValue, maxValue, self.getEl(&#039;handle&#039;));
      },
      repaint: function () {
        this._super();
        updateSliderHandle(this, this.value());
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:value&#039;, function (e) {
          updateSliderHandle(self, e.value);
        });
        return self._super();
      }
    });

    var Spacer = Widget.extend({
      renderHtml: function () {
        var self = this;
        self.classes.add(&#039;spacer&#039;);
        self.canFocus = false;
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot;&gt;&lt;/div&gt;&#039;;
      }
    });

    var SplitButton = MenuButton.extend({
      Defaults: {
        classes: &#039;widget btn splitbtn&#039;,
        role: &#039;button&#039;
      },
      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 + &#039;active&#039;, state);
      },
      renderHtml: function () {
        var self = this;
        var id = self._id;
        var prefix = self.classPrefix;
        var image;
        var icon = self.state.get(&#039;icon&#039;);
        var text = self.state.get(&#039;text&#039;);
        var settings = self.settings;
        var textHtml = &#039;&#039;, ariaPressed;
        image = settings.image;
        if (image) {
          icon = &#039;none&#039;;
          if (typeof image !== &#039;string&#039;) {
            image = domGlobals.window.getSelection ? image[0] : image[1];
          }
          image = &#039; style=&quot;background-image: url(\&#039;&#039; + image + &#039;\&#039;)&quot;&#039;;
        } else {
          image = &#039;&#039;;
        }
        icon = settings.icon ? prefix + &#039;ico &#039; + prefix + &#039;i-&#039; + icon : &#039;&#039;;
        if (text) {
          self.classes.add(&#039;btn-has-text&#039;);
          textHtml = &#039;&lt;span class=&quot;&#039; + prefix + &#039;txt&quot;&gt;&#039; + self.encode(text) + &#039;&lt;/span&gt;&#039;;
        }
        ariaPressed = typeof settings.active === &#039;boolean&#039; ? &#039; aria-pressed=&quot;&#039; + settings.active + &#039;&quot;&#039; : &#039;&#039;;
        return &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; role=&quot;button&quot;&#039; + ariaPressed + &#039; tabindex=&quot;-1&quot;&gt;&#039; + &#039;&lt;button type=&quot;button&quot; hidefocus=&quot;1&quot; tabindex=&quot;-1&quot;&gt;&#039; + (icon ? &#039;&lt;i class=&quot;&#039; + icon + &#039;&quot;&#039; + image + &#039;&gt;&lt;/i&gt;&#039; : &#039;&#039;) + textHtml + &#039;&lt;/button&gt;&#039; + &#039;&lt;button type=&quot;button&quot; class=&quot;&#039; + prefix + &#039;open&quot; hidefocus=&quot;1&quot; tabindex=&quot;-1&quot;&gt;&#039; + (self._menuBtnText ? (icon ? &#039;\xA0&#039; : &#039;&#039;) + self._menuBtnText : &#039;&#039;) + &#039; &lt;i class=&quot;&#039; + prefix + &#039;caret&quot;&gt;&lt;/i&gt;&#039; + &#039;&lt;/button&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      postRender: function () {
        var self = this, onClickHandler = self.settings.onclick;
        self.on(&#039;click&#039;, function (e) {
          var node = e.target;
          if (e.control === this) {
            while (node) {
              if (e.aria &amp;&amp; e.aria.key !== &#039;down&#039; || node.nodeName === &#039;BUTTON&#039; &amp;&amp; node.className.indexOf(&#039;open&#039;) === -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: &#039;stack-layout&#039;,
        controlClass: &#039;stack-layout-item&#039;,
        endClass: &#039;break&#039;
      },
      isNative: function () {
        return true;
      }
    });

    var TabPanel = Panel.extend({
      Defaults: {
        layout: &#039;absolute&#039;,
        defaults: { type: &#039;panel&#039; }
      },
      activateTab: function (idx) {
        var activeTabElm;
        if (this.activeTabId) {
          activeTabElm = this.getEl(this.activeTabId);
          global$7(activeTabElm).removeClass(this.classPrefix + &#039;active&#039;);
          activeTabElm.setAttribute(&#039;aria-selected&#039;, &#039;false&#039;);
        }
        this.activeTabId = &#039;t&#039; + idx;
        activeTabElm = this.getEl(&#039;t&#039; + idx);
        activeTabElm.setAttribute(&#039;aria-selected&#039;, &#039;true&#039;);
        global$7(activeTabElm).addClass(this.classPrefix + &#039;active&#039;);
        this.items()[idx].show().fire(&#039;showtab&#039;);
        this.reflow();
        this.items().each(function (item, i) {
          if (idx !== i) {
            item.hide();
          }
        });
      },
      renderHtml: function () {
        var self = this;
        var layout = self._layout;
        var tabsHtml = &#039;&#039;;
        var prefix = self.classPrefix;
        self.preRender();
        layout.preRender(self);
        self.items().each(function (ctrl, i) {
          var id = self._id + &#039;-t&#039; + i;
          ctrl.aria(&#039;role&#039;, &#039;tabpanel&#039;);
          ctrl.aria(&#039;labelledby&#039;, id);
          tabsHtml += &#039;&lt;div id=&quot;&#039; + id + &#039;&quot; class=&quot;&#039; + prefix + &#039;tab&quot; &#039; + &#039;unselectable=&quot;on&quot; role=&quot;tab&quot; aria-controls=&quot;&#039; + ctrl._id + &#039;&quot; aria-selected=&quot;false&quot; tabIndex=&quot;-1&quot;&gt;&#039; + self.encode(ctrl.settings.title) + &#039;&lt;/div&gt;&#039;;
        });
        return &#039;&lt;div id=&quot;&#039; + self._id + &#039;&quot; class=&quot;&#039; + self.classes + &#039;&quot; hidefocus=&quot;1&quot; tabindex=&quot;-1&quot;&gt;&#039; + &#039;&lt;div id=&quot;&#039; + self._id + &#039;-head&quot; class=&quot;&#039; + prefix + &#039;tabs&quot; role=&quot;tablist&quot;&gt;&#039; + tabsHtml + &#039;&lt;/div&gt;&#039; + &#039;&lt;div id=&quot;&#039; + self._id + &#039;-body&quot; class=&quot;&#039; + self.bodyClasses + &#039;&quot;&gt;&#039; + layout.renderHtml(self) + &#039;&lt;/div&gt;&#039; + &#039;&lt;/div&gt;&#039;;
      },
      postRender: function () {
        var self = this;
        self._super();
        self.settings.activeTab = self.settings.activeTab || 0;
        self.activateTab(self.settings.activeTab);
        this.on(&#039;click&#039;, function (e) {
          var targetParent = e.target.parentNode;
          if (targetParent &amp;&amp; targetParent.id === self._id + &#039;-head&#039;) {
            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(&#039;head&#039;)).width;
        minW = minW &lt; 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(&#039;head&#039;)).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(&#039;textbox&#039;);
        if (settings.multiline) {
          self.classes.add(&#039;multiline&#039;);
        } else {
          self.on(&#039;keydown&#039;, 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(&#039;submit&#039;, { data: rootControl.toJSON() });
            }
          });
          self.on(&#039;keyup&#039;, function (e) {
            self.state.set(&#039;value&#039;, 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 &amp;&amp; doc.all &amp;&amp; (!doc.documentMode || doc.documentMode &lt;= 8)) {
          style.lineHeight = rect.h - borderH + &#039;px&#039;;
        }
        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 + &#039;px&#039;;
          lastRepaintRect.x = rect.x;
        }
        if (rect.y !== lastRepaintRect.y) {
          style.top = rect.y + &#039;px&#039;;
          lastRepaintRect.y = rect.y;
        }
        if (rect.w !== lastRepaintRect.w) {
          style.width = rect.w - borderW + &#039;px&#039;;
          lastRepaintRect.w = rect.w;
        }
        if (rect.h !== lastRepaintRect.h) {
          style.height = rect.h - borderH + &#039;px&#039;;
          lastRepaintRect.h = rect.h;
        }
        self._lastRepaintRect = lastRepaintRect;
        self.fire(&#039;repaint&#039;, {}, false);
        return self;
      },
      renderHtml: function () {
        var self = this;
        var settings = self.settings;
        var attrs, elm;
        attrs = {
          id: self._id,
          hidefocus: &#039;1&#039;
        };
        global$4.each([
          &#039;rows&#039;,
          &#039;spellcheck&#039;,
          &#039;maxLength&#039;,
          &#039;size&#039;,
          &#039;readonly&#039;,
          &#039;min&#039;,
          &#039;max&#039;,
          &#039;step&#039;,
          &#039;list&#039;,
          &#039;pattern&#039;,
          &#039;placeholder&#039;,
          &#039;required&#039;,
          &#039;multiple&#039;
        ], function (name) {
          attrs[name] = settings[name];
        });
        if (self.disabled()) {
          attrs.disabled = &#039;disabled&#039;;
        }
        if (settings.subtype) {
          attrs.type = settings.subtype;
        }
        elm = funcs.create(settings.multiline ? &#039;textarea&#039; : &#039;input&#039;, attrs);
        elm.value = self.state.get(&#039;value&#039;);
        elm.className = self.classes.toString();
        return elm.outerHTML;
      },
      value: function (value) {
        if (arguments.length) {
          this.state.set(&#039;value&#039;, value);
          return this;
        }
        if (this.state.get(&#039;rendered&#039;)) {
          this.state.set(&#039;value&#039;, this.getEl().value);
        }
        return this.state.get(&#039;value&#039;);
      },
      postRender: function () {
        var self = this;
        self.getEl().value = self.state.get(&#039;value&#039;);
        self._super();
        self.$el.on(&#039;change&#039;, function (e) {
          self.state.set(&#039;value&#039;, e.target.value);
          self.fire(&#039;change&#039;, e);
        });
      },
      bindStates: function () {
        var self = this;
        self.state.on(&#039;change:value&#039;, function (e) {
          if (self.getEl().value !== e.value) {
            self.getEl().value = e.value;
          }
        });
        self.state.on(&#039;change:disabled&#039;, 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(&#039;inlite&#039;, function (editor) {
      var panel = create$3();
      FormatControls.setup(editor);
      Buttons.addToEditor(editor, panel);
      return ThemeApi.get(editor, panel);
    });
    function Theme () {
    }

    return Theme;

}(window));
})();
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fyanhuanghealthcare.co.uk%2Fwp-includes%2Fjs%2Ftinymce%2Fthemes%2Finlite'>⬅ Back to Directory</a>