var modern = (function (domGlobals) {

    'use strict';

    var global = tinymce.util.Tools.resolve('tinymce.ThemeManager');

    var global$1 = tinymce.util.Tools.resolve('tinymce.EditorManager');

    var global$2 = tinymce.util.Tools.resolve('tinymce.util.Tools');

    var isBrandingEnabled = function (editor) {

      return editor.getParam('branding', true, 'boolean');

    };

    var hasMenubar = function (editor) {

      return getMenubar(editor) !== false;

    };

    var getMenubar = function (editor) {

      return editor.getParam('menubar');

    };

    var hasStatusbar = function (editor) {

      return editor.getParam('statusbar', true, 'boolean');

    };

    var getToolbarSize = function (editor) {

      return editor.getParam('toolbar_items_size');

    };

    var isReadOnly = function (editor) {

      return editor.getParam('readonly', false, 'boolean');

    };

    var getFixedToolbarContainer = function (editor) {

      return editor.getParam('fixed_toolbar_container');

    };

    var getInlineToolbarPositionHandler = function (editor) {

      return editor.getParam('inline_toolbar_position_handler');

    };

    var getMenu = function (editor) {

      return editor.getParam('menu');

    };

    var getRemovedMenuItems = function (editor) {

      return editor.getParam('removed_menuitems', '');

    };

    var getMinWidth = function (editor) {

      return editor.getParam('min_width', 100, 'number');

    };

    var getMinHeight = function (editor) {

      return editor.getParam('min_height', 100, 'number');

    };

    var getMaxWidth = function (editor) {

      return editor.getParam('max_width', 65535, 'number');

    };

    var getMaxHeight = function (editor) {

      return editor.getParam('max_height', 65535, 'number');

    };

    var isSkinDisabled = function (editor) {

      return editor.settings.skin === false;

    };

    var isInline = function (editor) {

      return editor.getParam('inline', false, 'boolean');

    };

    var getResize = function (editor) {

      var resize = editor.getParam('resize', 'vertical');

      if (resize === false) {

        return 'none';

      } else if (resize === 'both') {

        return 'both';

        return 'vertical';

      }

    };

    var getSkinUrl = function (editor) {

      var settings = editor.settings;

      var skin = settings.skin;

      var skinUrl = settings.skin_url;

      if (skin !== false) {

        var skinName = skin ? skin : 'lightgray';

        if (skinUrl) {

          skinUrl = editor.documentBaseURI.toAbsolute(skinUrl);

        } else {

          skinUrl = global$1.baseURL + '/skins/' + skinName;

        }

      }

      return skinUrl;

    };

    var getIndexedToolbars = function (settings, defaultToolbar) {

      var toolbars = [];

      for (var i = 1; i < 10; i++) {

        var toolbar = settings['toolbar' + i];

        if (!toolbar) {

          break;

        }

        toolbars.push(toolbar);

      }

      var mainToolbar = settings.toolbar ? [settings.toolbar] : [defaultToolbar];

      return toolbars.length > 0 ? toolbars : mainToolbar;

    };

    var getToolbars = function (editor) {

      var toolbar = editor.getParam('toolbar');

      var defaultToolbar = 'undo redo | styleselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent | link image';

      if (toolbar === false) {

        return [];

      } else if (global$2.isArray(toolbar)) {

        return global$2.grep(toolbar, function (toolbar) {

          return toolbar.length > 0;

        });

      } else {

        return getIndexedToolbars(editor.settings, defaultToolbar);

      }

    };

    var global$3 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');

    var global$4 = tinymce.util.Tools.resolve('tinymce.ui.Factory');

    var global$5 = tinymce.util.Tools.resolve('tinymce.util.I18n');

    var fireSkinLoaded = function (editor) {

      return editor.fire('SkinLoaded');

    };

    var fireResizeEditor = function (editor) {

      return editor.fire('ResizeEditor');

    };

    var fireBeforeRenderUI = function (editor) {

      return editor.fire('BeforeRenderUI');

    };

    var Events = {

      fireSkinLoaded: fireSkinLoaded,

      fireResizeEditor: fireResizeEditor,

      fireBeforeRenderUI: fireBeforeRenderUI

    };

    var focus = function (panel, type) {

      return function () {

        var item = panel.find(type)[0];

        if (item) {

          item.focus(true);

        }

      };

    };

    var addKeys = function (editor, panel) {

      editor.shortcuts.add('Alt+F9', '', focus(panel, 'menubar'));

      editor.shortcuts.add('Alt+F10,F10', '', focus(panel, 'toolbar'));

      editor.shortcuts.add('Alt+F11', '', focus(panel, 'elementpath'));

      panel.on('cancel', function () {

        editor.focus();

    };

    var A11y = { addKeys: addKeys };

    var global$6 = tinymce.util.Tools.resolve('tinymce.geom.Rect');

    var global$7 = tinymce.util.Tools.resolve('tinymce.util.Delay');

    var noop = function () {

      var args = [];

        args[_i] = arguments[_i];

      }

    };

    var constant = function (value) {

      return function () {

        return value;

      };

    };

    var never = constant(false);

    var always = constant(true);

    var never$1 = never;

    var always$1 = always;

    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 noop = function () {

      };

      var nul = function () {

        return null;

      };

      var undef = function () {

        return undefined;

      };

      var me = {

        fold: function (n, s) {

          return n();

        },

        is: never$1,

        isSome: never$1,

        isNone: always$1,

        getOr: id,

        getOrThunk: call,

        getOrDie: function (msg) {

          throw new Error(msg || 'error: getOrDie called on none.');

        },

        getOrNull: nul,

        getOrUndefined: undef,

        or: id,

        orThunk: call,

        map: none,

        ap: none,

        each: noop,

        bind: none,

        flatten: none,

        exists: never$1,

        forall: always$1,

        filter: none,

        equals: eq,

        equals_: eq,

        toArray: function () {

          return [];

        },

        toString: constant('none()')

      };

      if (Object.freeze)

        Object.freeze(me);

    }();

    var some = function (a) {

      var constant_a = function () {

        return a;

      };

      var self = function () {

        return me;

      };

      var map = function (f) {

        return some(f(a));

      };

      var bind = function (f) {

        return f(a);

      };

      var me = {

        fold: function (n, s) {

          return s(a);

        },

        is: function (v) {

          return a === v;

        },

        isSome: always$1,

        isNone: never$1,

        getOr: constant_a,

        getOrThunk: constant_a,

        getOrDie: constant_a,

        getOrNull: constant_a,

        getOrUndefined: constant_a,

        or: self,

        orThunk: self,

        map: map,

        ap: function (optfab) {

          return optfab.fold(none, function (fab) {

            return some(fab(a));

        },

        each: function (f) {

          f(a);

        },

        bind: bind,

        flatten: constant_a,

        exists: bind,

        forall: bind,

        filter: function (f) {

          return f(a) ? me : NONE;

        },

        equals: function (o) {

          return o.is(a);

        },

        equals_: function (o, elementEq) {

          return o.fold(never$1, function (b) {

            return elementEq(a, b);

          });

        },

        toArray: function () {

          return [a];

        },

        toString: function () {

          return 'some(' + a + ')';

        }

      };

      return me;

    };

    var from = function (value) {

      return value === null || value === undefined ? NONE : some(value);

    };

    var Option = {

      some: some,

      none: none,

      from: from

    };

    var getUiContainerDelta = function (ctrl) {

      var uiContainer = getUiContainer(ctrl);

      if (uiContainer && global$3.DOM.getStyle(uiContainer, 'position', true) !== 'static') {

        var containerPos = global$3.DOM.getPos(uiContainer);

        var dx = uiContainer.scrollLeft - containerPos.x;

        var dy = uiContainer.scrollTop - containerPos.y;

        return Option.some({

          x: dx,

          y: dy

        });

        return Option.none();

      }

    };

    var setUiContainer = function (editor, ctrl) {

      var uiContainer = global$3.DOM.select(editor.settings.ui_container)[0];

      ctrl.getRoot().uiContainer = uiContainer;

    };

    var getUiContainer = function (ctrl) {

      return ctrl ? ctrl.getRoot().uiContainer : null;

    };

    var inheritUiContainer = function (fromCtrl, toCtrl) {

      return toCtrl.uiContainer = getUiContainer(fromCtrl);

    };

    var UiContainer = {

      getUiContainerDelta: getUiContainerDelta,

      setUiContainer: setUiContainer,

      getUiContainer: getUiContainer,

      inheritUiContainer: inheritUiContainer

    };

    var createToolbar = function (editor, items, size) {

      var toolbarItems = [];

      var buttonGroup;

      if (!items) {

      global$2.each(items.split(/[ ,]/), function (item) {

        var itemName;

        var bindSelectorChanged = function () {

          var selection = editor.selection;

          if (item.settings.stateSelector) {

            selection.selectorChanged(item.settings.stateSelector, function (state) {

              item.active(state);

            }, true);

          }

          if (item.settings.disabledStateSelector) {

            selection.selectorChanged(item.settings.disabledStateSelector, function (state) {

              item.disabled(state);

            });

        if (item === '|') {

          buttonGroup = null;

        } else {

          if (!buttonGroup) {

            buttonGroup = {

              type: 'buttongroup',

              items: []

            };

            toolbarItems.push(buttonGroup);

          }

          if (editor.buttons[item]) {

            itemName = item;

            item = editor.buttons[itemName];

            if (typeof item === 'function') {

              item = item();

            }

            item.type = item.type || 'button';

            item.size = size;

            item = global$4.create(item);

            buttonGroup.items.push(item);

            if (editor.initialized) {

              bindSelectorChanged();

            } else {

              editor.on('init', bindSelectorChanged);

            }

          }

      return {

        type: 'toolbar',

        layout: 'flow',

        items: toolbarItems

      };

    };

    var createToolbars = function (editor, size) {

      var toolbars = [];

      var addToolbar = function (items) {

        if (items) {

          toolbars.push(createToolbar(editor, items, size));

        }

      };

      global$2.each(getToolbars(editor), function (toolbar) {

        addToolbar(toolbar);

      });

      if (toolbars.length) {

        return {

          type: 'panel',

          layout: 'stack',

          classes: 'toolbar-grp',

          ariaRoot: true,

          ariaRemember: true,

          items: toolbars

        };

      }

    };

    var Toolbar = {

      createToolbar: createToolbar,

      createToolbars: createToolbars

    };

    var DOM = global$3.DOM;

    var toClientRect = function (geomRect) {

      return {

        left: geomRect.x,

        top: geomRect.y,

        width: geomRect.w,

        height: geomRect.h,

        right: geomRect.x + geomRect.w,

        bottom: geomRect.y + geomRect.h

      };

    };

    var hideAllFloatingPanels = function (editor) {

      global$2.each(editor.contextToolbars, function (toolbar) {

    var movePanelTo = function (panel, pos) {

      panel.moveTo(pos.left, pos.top);

    };

    var togglePositionClass = function (panel, relPos, predicate) {

      relPos = relPos ? relPos.substr(0, 2) : '';

      global$2.each({

        t: 'down',

        b: 'up'

      }, function (cls, pos) {

        panel.classes.toggle('arrow-' + cls, predicate(pos, relPos.substr(0, 1)));

      });

      global$2.each({

        l: 'left',

        r: 'right'

      }, function (cls, pos) {

        panel.classes.toggle('arrow-' + cls, predicate(pos, relPos.substr(1, 1)));

      });

    };

    var userConstrain = function (handler, x, y, elementRect, contentAreaRect, panelRect) {

      panelRect = toClientRect({

        x: x,

        y: y,

        w: panelRect.w,

        h: panelRect.h

      });

      if (handler) {

        panelRect = handler({

          elementRect: toClientRect(elementRect),

          contentAreaRect: toClientRect(contentAreaRect),

          panelRect: panelRect

        });

      }

      return panelRect;

    };

    var addContextualToolbars = function (editor) {

      var scrollContainer;

      var getContextToolbars = function () {

        return editor.contextToolbars || [];

      };

      var getElementRect = function (elm) {

        var pos, targetRect, root;

        pos = DOM.getPos(editor.getContentAreaContainer());

        targetRect = editor.dom.getRect(elm);

        root = editor.dom.getRoot();

        if (root.nodeName === 'BODY') {

          targetRect.x -= root.ownerDocument.documentElement.scrollLeft || root.scrollLeft;

          targetRect.y -= root.ownerDocument.documentElement.scrollTop || root.scrollTop;

        }

        targetRect.x += pos.x;

        targetRect.y += pos.y;

        return targetRect;

      };

      var reposition = function (match, shouldShow) {

        var relPos, panelRect, elementRect, contentAreaRect, panel, relRect, testPositions, smallElementWidthThreshold;

        var handler = getInlineToolbarPositionHandler(editor);

        if (editor.removed) {

          return;

        }

        if (!match || !match.toolbar.panel) {

          hideAllFloatingPanels(editor);

          return;

        }

        testPositions = [

          'bc-tc',

          'tc-bc',

          'tl-bl',

          'bl-tl',

          'tr-br',

          'br-tr'

        ];