text: (function () {
  var image = (function (domGlobals) {
      'use strict';
  
      var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
  
      var hasDimensions = function (editor) {
        return editor.settings.image_dimensions === false ? false : true;
      };
      var hasAdvTab = function (editor) {
        return editor.settings.image_advtab === true ? true : false;
      };
      var getPrependUrl = function (editor) {
        return editor.getParam('image_prepend_url', '');
      };
      var getClassList = function (editor) {
        return editor.getParam('image_class_list');
      };
      var hasDescription = function (editor) {
        return editor.settings.image_description === false ? false : true;
      };
      var hasImageTitle = function (editor) {
        return editor.settings.image_title === true ? true : false;
      };
      var hasImageCaption = function (editor) {
        return editor.settings.image_caption === true ? true : false;
      };
      var getImageList = function (editor) {
        return editor.getParam('image_list', false);
      };
      var hasUploadUrl = function (editor) {
        return editor.getParam('images_upload_url', false);
      };
      var hasUploadHandler = function (editor) {
        return editor.getParam('images_upload_handler', false);
      };
      var getUploadUrl = function (editor) {
        return editor.getParam('images_upload_url');
      };
      var getUploadHandler = function (editor) {
        return editor.getParam('images_upload_handler');
      };
      var getUploadBasePath = function (editor) {
        return editor.getParam('images_upload_base_path');
      };
      var getUploadCredentials = function (editor) {
        return editor.getParam('images_upload_credentials');
      };
      var Settings = {
        hasDimensions: hasDimensions,
        hasAdvTab: hasAdvTab,
        getPrependUrl: getPrependUrl,
        getClassList: getClassList,
        hasDescription: hasDescription,
        hasImageTitle: hasImageTitle,
        hasImageCaption: hasImageCaption,
        getImageList: getImageList,
        hasUploadUrl: hasUploadUrl,
        hasUploadHandler: hasUploadHandler,
        getUploadUrl: getUploadUrl,
        getUploadHandler: getUploadHandler,
        getUploadBasePath: getUploadBasePath,
        getUploadCredentials: getUploadCredentials
      };
  
      var Global = typeof domGlobals.window !== 'undefined' ? domGlobals.window : Function('return this;')();
  
      var path = function (parts, scope) {
        var o = scope !== undefined && scope !== null ? scope : Global;
        for (var i = 0; i < parts.length && o !== undefined && o !== null; ++i)
          o = o[parts[i]];
        return o;
      };
      var resolve = function (p, scope) {
        var parts = p.split('.');
        return path(parts, scope);
      };
  
      var unsafe = function (name, scope) {
        return resolve(name, scope);
      };
      var getOrDie = function (name, scope) {
        var actual = unsafe(name, scope);
        if (actual === undefined || actual === null)
          throw name + ' not available on this browser';
        return actual;
      };
      var Global$1 = { getOrDie: getOrDie };
  
      function FileReader () {
        var f = Global$1.getOrDie('FileReader');
        return new f();
      }
  
      var global$1 = tinymce.util.Tools.resolve('tinymce.util.Promise');
  
      var global$2 = tinymce.util.Tools.resolve('tinymce.util.Tools');
  
      var global$3 = tinymce.util.Tools.resolve('tinymce.util.XHR');
  
      var parseIntAndGetMax = function (val1, val2) {
        return Math.max(parseInt(val1, 10), parseInt(val2, 10));
      };
      var getImageSize = function (url, callback) {
        var img = domGlobals.document.createElement('img');
        function done(width, height) {
          if (img.parentNode) {
            img.parentNode.removeChild(img);
          }
          callback({
            width: width,
            height: height
          });
        }
        img.onload = function () {
          var width = parseIntAndGetMax(img.width, img.clientWidth);
          var height = parseIntAndGetMax(img.height, img.clientHeight);
          done(width, height);
        };
        img.onerror = function () {
          done(0, 0);
        };
        var style = img.style;
        style.visibility = 'hidden';
        style.position = 'fixed';
        style.bottom = style.left = '0px';
        style.width = style.height = 'auto';
        domGlobals.document.body.appendChild(img);
        img.src = url;
      };
      var buildListItems = function (inputList, itemCallback, startItems) {
        function appendItems(values, output) {
          output = output || [];
          global$2.each(values, function (item) {
            var menuItem = { text: item.text || item.title };
            if (item.menu) {
              menuItem.menu = appendItems(item.menu);
            } else {
              menuItem.value = item.value;
              itemCallback(menuItem);
            }
            output.push(menuItem);
          });
          return output;
        }
        return appendItems(inputList, startItems || []);
      };
      var removePixelSuffix = function (value) {
        if (value) {
          value = value.replace(/px$/, '');
        }
        return value;
      };
      var addPixelSuffix = function (value) {
        if (value.length > 0 && /^[0-9]+$/.test(value)) {
          value += 'px';
        }
        return value;
      };
      var mergeMargins = function (css) {
        if (css.margin) {
          var splitMargin = css.margin.split(' ');
          switch (splitMargin.length) {
          case 1:
            css['margin-top'] = css['margin-top'] || splitMargin[0];
            css['margin-right'] = css['margin-right'] || splitMargin[0];
            css['margin-bottom'] = css['margin-bottom'] || splitMargin[0];
            css['margin-left'] = css['margin-left'] || splitMargin[0];
            break;
          case 2:
            css['margin-top'] = css['margin-top'] || splitMargin[0];
            css['margin-right'] = css['margin-right'] || splitMargin[1];
            css['margin-bottom'] = css['margin-bottom'] || splitMargin[0];
            css['margin-left'] = css['margin-left'] || splitMargin[1];
            break;
          case 3:
            css['margin-top'] = css['margin-top'] || splitMargin[0];
            css['margin-right'] = css['margin-right'] || splitMargin[1];
            css['margin-bottom'] = css['margin-bottom'] || splitMargin[2];
            css['margin-left'] = css['margin-left'] || splitMargin[1];
            break;
          case 4:
            css['margin-top'] = css['margin-top'] || splitMargin[0];
            css['margin-right'] = css['margin-right'] || splitMargin[1];
            css['margin-bottom'] = css['margin-bottom'] || splitMargin[2];
            css['margin-left'] = css['margin-left'] || splitMargin[3];
          }
          delete css.margin;
        }
        return css;
      };
      var createImageList = function (editor, callback) {
        var imageList = Settings.getImageList(editor);
        if (typeof imageList === 'string') {
          global$3.send({
            url: imageList,
            success: function (text) {
              callback(JSON.parse(text));
            }
          });
        } else if (typeof imageList === 'function') {
          imageList(callback);
        } else {
          callback(imageList);
        }
      };
      var waitLoadImage = function (editor, data, imgElm) {
        function selectImage() {
          imgElm.onload = imgElm.onerror = null;
          if (editor.selection) {
            editor.selection.select(imgElm);
            editor.nodeChanged();
          }
        }
        imgElm.onload = function () {
          if (!data.width && !data.height && Settings.hasDimensions(editor)) {
            editor.dom.setAttribs(imgElm, {
              width: imgElm.clientWidth,
              height: imgElm.clientHeight
            });
          }
          selectImage();
        };
        imgElm.onerror = selectImage;
      };
      var blobToDataUri = function (blob) {
        return new global$1(function (resolve, reject) {
          var reader = FileReader();
          reader.onload = function () {
            resolve(reader.result);
          };
          reader.onerror = function () {
            reject(reader.error.message);
          };
          reader.readAsDataURL(blob);
        });
      };
      var Utils = {
        getImageSize: getImageSize,
        buildListItems: buildListItems,
        removePixelSuffix: removePixelSuffix,
        addPixelSuffix: addPixelSuffix,
        mergeMargins: mergeMargins,
        createImageList: createImageList,
        waitLoadImage: waitLoadImage,
        blobToDataUri: blobToDataUri
      };
  
      var global$4 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
  
      var hasOwnProperty = Object.prototype.hasOwnProperty;
      var shallow = function (old, nu) {
        return nu;
      };
      var baseMerge = function (merger) {
        return function () {
          var objects = new Array(arguments.length);
          for (var i = 0; i < objects.length; i++)
            objects[i] = arguments[i];
          if (objects.length === 0)
            throw new Error('Can\'t merge zero objects');
          var ret = {};
          for (var j = 0; j < objects.length; j++) {
            var curObject = objects[j];
            for (var key in curObject)
              if (hasOwnProperty.call(curObject, key)) {
                ret[key] = merger(ret[key], curObject[key]);
              }
          }
          return ret;
        };
      };
      var merge = baseMerge(shallow);
  
      var DOM = global$4.DOM;
      var getHspace = function (image) {
        if (image.style.marginLeft && image.style.marginRight && image.style.marginLeft === image.style.marginRight) {
          return Utils.removePixelSuffix(image.style.marginLeft);
        } else {
          return '';
        }
      };
      var getVspace = function (image) {
        if (image.style.marginTop && image.style.marginBottom && image.style.marginTop === image.style.marginBottom) {
          return Utils.removePixelSuffix(image.style.marginTop);
        } else {
          return '';
        }
      };
      var getBorder = function (image) {
        if (image.style.borderWidth) {
          return Utils.removePixelSuffix(image.style.borderWidth);
        } else {
          return '';
        }
      };
      var getAttrib = function (image, name) {
        if (image.hasAttribute(name)) {
          return image.getAttribute(name);
        } else {
          return '';
        }
      };
      var getStyle = function (image, name) {
        return image.style[name] ? image.style[name] : '';
      };
      var hasCaption = function (image) {
        return image.parentNode !== null && image.parentNode.nodeName === 'FIGURE';
      };
      var setAttrib = function (image, name, value) {
        image.setAttribute(name, value);
      };
      var wrapInFigure = function (image) {
        var figureElm = DOM.create('figure', { class: 'image' });
        DOM.insertAfter(figureElm, image);
        figureElm.appendChild(image);
        figureElm.appendChild(DOM.create('figcaption', { contentEditable: true }, 'Caption'));
        figureElm.contentEditable = 'false';
      };
      var removeFigure = function (image) {
        var figureElm = image.parentNode;
        DOM.insertAfter(image, figureElm);
        DOM.remove(figureElm);
      };
      var toggleCaption = function (image) {
        if (hasCaption(image)) {
          removeFigure(image);
        } else {
          wrapInFigure(image);
        }
      };
      var normalizeStyle = function (image, normalizeCss) {
        var attrValue = image.getAttribute('style');
        var value = normalizeCss(attrValue !== null ? attrValue : '');
        if (value.length > 0) {
          image.setAttribute('style', value);
          image.setAttribute('data-mce-style', value);
        } else {
          image.removeAttribute('style');
        }
      };
      var setSize = function (name, normalizeCss) {
        return function (image, name, value) {
          if (image.style[name]) {
            image.style[name] = Utils.addPixelSuffix(value);
            normalizeStyle(image, normalizeCss);
          } else {
            setAttrib(image, name, value);
          }
        };
      };
      var getSize = function (image, name) {
        if (image.style[name]) {
          return Utils.removePixelSuffix(image.style[name]);
        } else {
          return getAttrib(image, name);
        }
      };
      var setHspace = function (image, value) {
        var pxValue = Utils.addPixelSuffix(value);
        image.style.marginLeft = pxValue;
        image.style.marginRight = pxValue;
      };
      var setVspace = function (image, value) {
        var pxValue = Utils.addPixelSuffix(value);
        image.style.marginTop = pxValue;
        image.style.marginBottom = pxValue;
      };
      var setBorder = function (image, value) {
        var pxValue = Utils.addPixelSuffix(value);
        image.style.borderWidth = pxValue;
      };
      var setBorderStyle = function (image, value) {
        image.style.borderStyle = value;
      };
      var getBorderStyle = function (image) {
        return getStyle(image, 'borderStyle');
      };
      var isFigure = function (elm) {
        return elm.nodeName === 'FIGURE';
      };
      var defaultData = function () {
        return {
          src: '',
          alt: '',
          title: '',
          width: '',
          height: '',
          class: '',
          style: '',
          caption: false,
          hspace: '',
          vspace: '',
          border: '',
          borderStyle: ''
        };
      };
      var getStyleValue = function (normalizeCss, data) {
        var image = domGlobals.document.createElement('img');
        setAttrib(image, 'style', data.style);
        if (getHspace(image) || data.hspace !== '') {
          setHspace(image, data.hspace);
        }
        if (getVspace(image) || data.vspace !== '') {
          setVspace(image, data.vspace);
        }
        if (getBorder(image) || data.border !== '') {
          setBorder(image, data.border);
        }
        if (getBorderStyle(image) || data.borderStyle !== '') {
          setBorderStyle(image, data.borderStyle);
        }
        return normalizeCss(image.getAttribute('style'));
      };
      var create = function (normalizeCss, data) {
        var image = domGlobals.document.createElement('img');
        write(normalizeCss, merge(data, { caption: false }), image);
        setAttrib(image, 'alt', data.alt);
        if (data.caption) {
          var figure = DOM.create('figure', { class: 'image' });
          figure.appendChild(image);
          figure.appendChild(DOM.create('figcaption', { contentEditable: true }, 'Caption'));
          figure.contentEditable = 'false';
          return figure;
        } else {
          return image;
        }
      };
      var read = function (normalizeCss, image) {
        return {
          src: getAttrib(image, 'src'),
          alt: getAttrib(image, 'alt'),
          title: getAttrib(image, 'title'),
          width: getSize(image, 'width'),
          height: getSize(image, 'height'),
          class: getAttrib(image, 'class'),
          style: normalizeCss(getAttrib(image, 'style')),
          caption: hasCaption(image),
          hspace: getHspace(image),
          vspace: getVspace(image),
          border: getBorder(image),
          borderStyle: getStyle(image, 'borderStyle')
        };
      };
      var updateProp = function (image, oldData, newData, name, set) {
        if (newData[name] !== oldData[name]) {
          set(image, name, newData[name]);
        }
      };
      var normalized = function (set, normalizeCss) {
        return function (image, name, value) {
          set(image, value);
          normalizeStyle(image, normalizeCss);
        };
      };
      var write = function (normalizeCss, newData, image) {
        var oldData = read(normalizeCss, image);
        updateProp(image, oldData, newData, 'caption', function (image, _name, _value) {
          return toggleCaption(image);
        });
        updateProp(image, oldData, newData, 'src', setAttrib);
        updateProp(image, oldData, newData, 'alt', setAttrib);
        updateProp(image, oldData, newData, 'title', setAttrib);
        updateProp(image, oldData, newData, 'width', setSize('width', normalizeCss));
        updateProp(image, oldData, newData, 'height', setSize('height', normalizeCss));
        updateProp(image, oldData, newData, 'class', setAttrib);
        updateProp(image, oldData, newData, 'style', normalized(function (image, value) {
          return setAttrib(image, 'style', value);
        }, normalizeCss));
        updateProp(image, oldData, newData, 'hspace', normalized(setHspace, normalizeCss));
        updateProp(image, oldData, newData, 'vspace', normalized(setVspace, normalizeCss));
        updateProp(image, oldData, newData, 'border', normalized(setBorder, normalizeCss));
        updateProp(image, oldData, newData, 'borderStyle', normalized(setBorderStyle, normalizeCss));
      };
  
      var normalizeCss = function (editor, cssText) {
        var css = editor.dom.styles.parse(cssText);
        var mergedCss = Utils.mergeMargins(css);
        var compressed = editor.dom.styles.parse(editor.dom.styles.serialize(mergedCss));
        return editor.dom.styles.serialize(compressed);
      };
      var getSelectedImage = function (editor) {
        var imgElm = editor.selection.getNode();
        var figureElm = editor.dom.getParent(imgElm, 'figure.image');
        if (figureElm) {
          return editor.dom.select('img', figureElm)[0];
        }
        if (imgElm && (imgElm.nodeName !== 'IMG' || imgElm.getAttribute('data-mce-object') || imgElm.getAttribute('data-mce-placeholder'))) {
          return null;
        }
        return imgElm;
      };
      var splitTextBlock = function (editor, figure) {
        var dom = editor.dom;
        var textBlock = dom.getParent(figure.parentNode, function (node) {
          return editor.schema.getTextBlockElements()[node.nodeName];
        }, editor.getBody());
        if (textBlock) {
          return dom.split(textBlock, figure);
        } else {
          return figure;
        }
      };
      var readImageDataFromSelection = function (editor) {
        var image = getSelectedImage(editor);
        return image ? read(function (css) {
          return normalizeCss(editor, css);
        }, image) : defaultData();
      };
      var insertImageAtCaret = function (editor, data) {
        var elm = create(function (css) {
          return normalizeCss(editor, css);
        }, data);
        editor.dom.setAttrib(elm, 'data-mce-id', '__mcenew');
        editor.focus();
        editor.selection.setContent(elm.outerHTML);
        var insertedElm = editor.dom.select('*[data-mce-id="__mcenew"]')[0];
        editor.dom.setAttrib(insertedElm, 'data-mce-id', null);
        if (isFigure(insertedElm)) {
          var figure = splitTextBlock(editor, insertedElm);
          editor.selection.select(figure);
        } else {
          editor.selection.select(insertedElm);
        }
      };
      var syncSrcAttr = function (editor, image) {
        editor.dom.setAttrib(image, 'src', image.getAttribute('src'));
      };
      var deleteImage = function (editor, image) {
        if (image) {
          var elm = editor.dom.is(image.parentNode, 'figure.image') ? image.parentNode : image;
          editor.dom.remove(elm);
          editor.focus();
          editor.nodeChanged();
          if (editor.dom.isEmpty(editor.getBody())) {
            editor.setContent('');
            editor.selection.setCursorLocation();
          }
        }
      };
      var writeImageDataToSelection = function (editor, data) {
        var image = getSelectedImage(editor);
        write(function (css) {
          return normalizeCss(editor, css);
        }, data, image);
        syncSrcAttr(editor, image);
        if (isFigure(image.parentNode)) {
          var figure = image.parentNode;
          splitTextBlock(editor, figure);
          editor.selection.select(image.parentNode);
        } else {
          editor.selection.select(image);
          Utils.waitLoadImage(editor, data, image);
        }
      };
      var insertOrUpdateImage = function (editor, data) {
        var image = getSelectedImage(editor);
        if (image) {
          if (data.src) {
            writeImageDataToSelection(editor, data);
          } else {
            deleteImage(editor, image);
          }
        } else if (data.src) {
          insertImageAtCaret(editor, data);
        }
      };
  
      var updateVSpaceHSpaceBorder = function (editor) {
        return function (evt) {
          var dom = editor.dom;
          var rootControl = evt.control.rootControl;
          if (!Settings.hasAdvTab(editor)) {
            return;
          }
          var data = rootControl.toJSON();
          var css = dom.parseStyle(data.style);
          rootControl.find('#vspace').value('');
          rootControl.find('#hspace').value('');
          css = Utils.mergeMargins(css);
          if (css['margin-top'] && css['margin-bottom'] || css['margin-right'] && css['margin-left']) {
            if (css['margin-top'] === css['margin-bottom']) {
              rootControl.find('#vspace').value(Utils.removePixelSuffix(css['margin-top']));
            } else {
              rootControl.find('#vspace').value('');
            }
            if (css['margin-right'] === css['margin-left']) {
              rootControl.find('#hspace').value(Utils.removePixelSuffix(css['margin-right']));
            } else {
              rootControl.find('#hspace').value('');
            }
          }
          if (css['border-width']) {
            rootControl.find('#border').value(Utils.removePixelSuffix(css['border-width']));
          } else {
            rootControl.find('#border').value('');
          }
          if (css['border-style']) {
            rootControl.find('#borderStyle').value(css['border-style']);
          } else {
            rootControl.find('#borderStyle').value('');
          }
          rootControl.find('#style').value(dom.serializeStyle(dom.parseStyle(dom.serializeStyle(css))));
        };
      };
      var updateStyle = function (editor, win) {
        win.find('#style').each(function (ctrl) {
          var value = getStyleValue(function (css) {
            return normalizeCss(editor, css);
          }, merge(defaultData(), win.toJSON()));
          ctrl.value(value);
        });
      };
      var makeTab = function (editor) {
        return {
          title: 'Advanced',
          type: 'form',
          pack: 'start',
          items: [
            {
              label: 'Style',
              name: 'style',
              type: 'textbox',
              onchange: updateVSpaceHSpaceBorder(editor)
            },
            {
              type: 'form',
              layout: 'grid',
              packV: 'start',
              columns: 2,
              padding: 0,
              defaults: {
                type: 'textbox',
                maxWidth: 50,
                onchange: function (evt) {
                  updateStyle(editor, evt.control.rootControl);
                }
              },
              items: [
                {
                  label: 'Vertical space',
                  name: 'vspace'
                },
                {
                  label: 'Border width',
                  name: 'border'
                },
                {
                  label: 'Horizontal space',
                  name: 'hspace'
                },
                {
                  label: 'Border style',
                  type: 'listbox',
                  name: 'borderStyle',
                  width: 90,
                  maxWidth: 90,
                  onselect: function (evt) {
                    updateStyle(editor, evt.control.rootControl);
                  },
                  values: [
                    {
                      text: 'Select...',
                      value: ''
                    },
                    {
                      text: 'Solid',
                      value: 'solid'
                    },
                    {
                      text: 'Dotted',
                      value: 'dotted'
                    },
                    {
                      text: 'Dashed',
                      value: 'dashed'
                    },
                    {
                      text: 'Double',
                      value: 'double'
                    },
                    {
                      text: 'Groove',
                      value: 'groove'
                    },
                    {
                      text: 'Ridge',
                      value: 'ridge'
                    },
                    {
                      text: 'Inset',
                      value: 'inset'
                    },
                    {
                      text: 'Outset',
                      value: 'outset'
                    },
                    {
                      text: 'None',
                      value: 'none'
                    },
                    {
                      text: 'Hidden',
                      value: 'hidden'
                    }
                  ]
                }
              ]
            }
          ]
        };
      };
      var AdvTab = { makeTab: makeTab };
  
      var doSyncSize = function (widthCtrl, heightCtrl) {
        widthCtrl.state.set('oldVal', widthCtrl.value());
        heightCtrl.state.set('oldVal', heightCtrl.value());
      };
      var doSizeControls = function (win, f) {
        var widthCtrl = win.find('#width')[0];
        var heightCtrl = win.find('#height')[0];
        var constrained = win.find('#constrain')[0];
        if (widthCtrl && heightCtrl && constrained) {
          f(widthCtrl, heightCtrl, constrained.checked());
        }
      };
      var doUpdateSize = function (widthCtrl, heightCtrl, isContrained) {
        var oldWidth = widthCtrl.state.get('oldVal');
        var oldHeight = heightCtrl.state.get('oldVal');
        var newWidth = widthCtrl.value();
        var newHeight = heightCtrl.value();
        if (isContrained && oldWidth && oldHeight && newWidth && newHeight) {
          if (newWidth !== oldWidth) {
            newHeight = Math.round(newWidth / oldWidth * newHeight);
            if (!isNaN(newHeight)) {
              heightCtrl.value(newHeight);
            }
          } else {
            newWidth = Math.round(newHeight / oldHeight * newWidth);
            if (!isNaN(newWidth)) {
              widthCtrl.value(newWidth);
            }
          }
        }
        doSyncSize(widthCtrl, heightCtrl);
      };
      var syncSize = function (win) {
        doSizeControls(win, doSyncSize);
      };
      var updateSize = function (win) {
        doSizeControls(win, doUpdateSize);
      };
      var createUi = function () {
        var recalcSize = function (evt) {
          updateSize(evt.control.rootControl);
        };
        return {
          type: 'container',
          label: 'Dimensions',
          layout: 'flex',
          align: 'center',
          spacing: 5,
          items: [
            {
              name: 'width',
              type: 'textbox',
              maxLength: 5,
              size: 5,
              onchange: recalcSize,
              ariaLabel: 'Width'
            },
            {
              type: 'label',
              text: 'x'
            },
            {
              name: 'height',
              type: 'textbox',
              maxLength: 5,
              size: 5,
              onchange: recalcSize,
              ariaLabel: 'Height'
            },
            {
              name: 'constrain',
              type: 'checkbox',
              checked: true,
              text: 'Constrain proportions'
            }
          ]
        };
      };
      var SizeManager = {
        createUi: createUi,
        syncSize: syncSize,
        updateSize: updateSize
      };
  
      var onSrcChange = function (evt, editor) {
        var srcURL, prependURL, absoluteURLPattern;
        var meta = evt.meta || {};
        var control = evt.control;
        var rootControl = control.rootControl;
        var imageListCtrl = rootControl.find('#image-list')[0];
        if (imageListCtrl) {
          imageListCtrl.value(editor.convertURL(control.value(), 'src'));
        }
        global$2.each(meta, function (value, key) {
          rootControl.find('#' + key).value(value);
        });
        if (!meta.width && !meta.height) {
          srcURL = editor.convertURL(control.value(), 'src');
          prependURL = Settings.getPrependUrl(editor);
          absoluteURLPattern = new RegExp('^(?:[a-z]+:)?//', 'i');
          if (prependURL && !absoluteURLPattern.test(srcURL) && srcURL.substring(0, prependURL.length) !== prependURL) {
            srcURL = prependURL + srcURL;
          }
          control.value(srcURL);
          Utils.getImageSize(editor.documentBaseURI.toAbsolute(control.value()), function (data) {
            if (data.width && data.height && Settings.hasDimensions(editor)) {
              rootControl.find('#width').value(data.width);
              rootControl.find('#height').value(data.height);
              SizeManager.syncSize(rootControl);
            }
          });
        }
      };
      var onBeforeCall = function (evt) {
        evt.meta = evt.control.rootControl.toJSON();
      };
      var getGeneralItems = function (editor, imageListCtrl) {
        var generalFormItems = [
          {
            name: 'src',
            type: 'filepicker',
            filetype: 'image',
            label: 'Source',
            autofocus: true,
            onchange: function (evt) {
              onSrcChange(evt, editor);
            },
            onbeforecall: onBeforeCall
          },
          imageListCtrl
        ];
        if (Settings.hasDescription(editor)) {
          generalFormItems.push({
            name: 'alt',
            type: 'textbox',
            label: 'Image description'
          });
        }
        if (Settings.hasImageTitle(editor)) {
          generalFormItems.push({
            name: 'title',
            type: 'textbox',
            label: 'Image Title'
          });
        }
        if (Settings.hasDimensions(editor)) {
          generalFormItems.push(SizeManager.createUi());
        }
        if (Settings.getClassList(editor)) {
          generalFormItems.push({
            name: 'class',
            type: 'listbox',
            label: 'Class',
            values: Utils.buildListItems(Settings.getClassList(editor), function (item) {
              if (item.value) {
                item.textStyle = function () {
                  return editor.formatter.getCssText({
                    inline: 'img',
                    classes: [item.value]
                  });
                };
              }
            })
          });
        }
        if (Settings.hasImageCaption(editor)) {
          generalFormItems.push({
            name: 'caption',
            type: 'checkbox',
            label: 'Caption'
          });
        }
        return generalFormItems;
      };
      var makeTab$1 = function (editor, imageListCtrl) {
        return {
          title: 'General',
          type: 'form',
          items: getGeneralItems(editor, imageListCtrl)
        };
      };
      var MainTab = {
        makeTab: makeTab$1,
        getGeneralItems: getGeneralItems
      };
  
      var url = function () {
        return Global$1.getOrDie('URL');
      };
      var createObjectURL = function (blob) {
        return url().createObjectURL(blob);
      };
      var revokeObjectURL = function (u) {
        url().revokeObjectURL(u);
      };
      var URL = {
        createObjectURL: createObjectURL,
        revokeObjectURL: revokeObjectURL
      };
  
      var global$5 = tinymce.util.Tools.resolve('tinymce.ui.Factory');
  
      function XMLHttpRequest () {
        var f = Global$1.getOrDie('XMLHttpRequest');
        return new f();
      }
  
      var noop = function () {
      };
      var pathJoin = function (path1, path2) {
        if (path1) {
          return path1.replace(/\/$/, '') + '/' + path2.replace(/^\//, '');
        }
        return path2;
      };
      function Uploader (settings) {
        var defaultHandler = function (blobInfo, success, failure, progress) {
          var xhr, formData;
          xhr = XMLHttpRequest();
          xhr.open('POST', settings.url);
          xhr.withCredentials = settings.credentials;
          xhr.upload.onprogress = function (e) {
            progress(e.loaded / e.total * 100);
          };
          xhr.onerror = function () {
            failure('Image upload failed due to a XHR Transport error. Code: ' + xhr.status);
          };
          xhr.onload = function () {
            var json;
            if (xhr.status < 200 || xhr.status >= 300) {
              failure('HTTP Error: ' + xhr.status);
              return;
            }
            json = JSON.parse(xhr.responseText);
            if (!json || typeof json.location !== 'string') {
              failure('Invalid JSON: ' + xhr.responseText);
              return;
            }
            success(pathJoin(settings.basePath, json.location));
          };
          formData = new domGlobals.FormData();
          formData.append('file', blobInfo.blob(), blobInfo.filename());
          xhr.send(formData);
        };
        var uploadBlob = function (blobInfo, handler) {
          return new global$1(function (resolve, reject) {
            try {
              handler(blobInfo, resolve, reject, noop);
            } catch (ex) {
              reject(ex.message);
            }
          });
        };
        var isDefaultHandler = function (handler) {
          return handler === defaultHandler;
        };
        var upload = function (blobInfo) {
          return !settings.url && isDefaultHandler(settings.handler) ? global$1.reject('Upload url missing from the settings.') : uploadBlob(blobInfo, settings.handler);
        };
        settings = global$2.extend({
          credentials: false,
          handler: defaultHandler
        }, settings);
        return { upload: upload };
      }
  
      var onFileInput = function (editor) {
        return function (evt) {
          var Throbber = global$5.get('Throbber');
          var rootControl = evt.control.rootControl;
          var throbber = new Throbber(rootControl.getEl());
          var file = evt.control.value();
          var blobUri = URL.createObjectURL(file);
          var uploader = Uploader({
            url: Settings.getUploadUrl(editor),
            basePath: Settings.getUploadBasePath(editor),
            credentials: Settings.getUploadCredentials(editor),
            handler: Settings.getUploadHandler(editor)
          });
          var finalize = function () {
            throbber.hide();
            URL.revokeObjectURL(blobUri);
          };
          throbber.show();
          return Utils.blobToDataUri(file).then(function (dataUrl) {
            var blobInfo = editor.editorUpload.blobCache.create({
              blob: file,
              blobUri: blobUri,
              name: file.name ? file.name.replace(/\.[^\.]+$/, '') : null,
              base64: dataUrl.split(',')[1]
            });
            return uploader.upload(blobInfo).then(function (url) {
              var src = rootControl.find('#src');
              src.value(url);
              rootControl.find('tabpanel')[0].activateTab(0);
              src.fire('change');
              finalize();
              return url;
            });
          }).catch(function (err) {
            editor.windowManager.alert(err);
            finalize();
          });
        };
      };
      var acceptExts = '.jpg,.jpeg,.png,.gif';
      var makeTab$2 = function (editor) {
        return {
          title: 'Upload',
          type: 'form',
          layout: 'flex',
          direction: 'column',
          align: 'stretch',
          padding: '20 20 20 20',
          items: [
            {
              type: 'container',
              layout: 'flex',
              direction: 'column',
              align: 'center',
              spacing: 10,
              items: [
                {
                  text: 'Browse for an image',
                  type: 'browsebutton',
                  accept: acceptExts,
                  onchange: onFileInput(editor)
                },
                {
                  text: 'OR',
                  type: 'label'
                }
              ]
            },
            {
              text: 'Drop an image here',
              type: 'dropzone',
              accept: acceptExts,
              height: 100,
              onchange: onFileInput(editor)
            }
          ]
        };
      };
      var UploadTab = { makeTab: makeTab$2 };
  
      function curry(fn) {
        var initialArgs = [];
        for (var _i = 1; _i < arguments.length; _i++) {
          initialArgs[_i - 1] = arguments[_i];
        }
        return function () {
          var restArgs = [];
          for (var _i = 0; _i < arguments.length; _i++) {
            restArgs[_i] = arguments[_i];
          }
          var all = initialArgs.concat(restArgs);
          return fn.apply(null, all);
        };
      }
  
      var submitForm = function (editor, evt) {
        var win = evt.control.getRoot();
        SizeManager.updateSize(win);
        editor.undoManager.transact(function () {
          var data = merge(readImageDataFromSelection(editor), win.toJSON());
          insertOrUpdateImage(editor, data);
        });
        editor.editorUpload.uploadImagesAuto();
      };
      function Dialog (editor) {
        function showDialog(imageList) {
          var data = readImageDataFromSelection(editor);
          var win, imageListCtrl;
          if (imageList) {
            imageListCtrl = {
              type: 'listbox',
              label: 'Image list',
              name: 'image-list',
              values: Utils.buildListItems(imageList, function (item) {
                item.value = editor.convertURL(item.value || item.url, 'src');
              }, [{
                  text: 'None',
                  value: ''
                }]),
              value: data.src && editor.convertURL(data.src, 'src'),
              onselect: function (e) {
                var altCtrl = win.find('#alt');
                if (!altCtrl.value() || e.lastControl && altCtrl.value() === e.lastControl.text()) {
                  altCtrl.value(e.control.text());
                }
                win.find('#src').value(e.control.value()).fire('change');
              },
              onPostRender: function () {
                imageListCtrl = this;
              }
            };
          }
          if (Settings.hasAdvTab(editor) || Settings.hasUploadUrl(editor) || Settings.hasUploadHandler(editor)) {
            var body = [MainTab.makeTab(editor, imageListCtrl)];
            if (Settings.hasAdvTab(editor)) {
              body.push(AdvTab.makeTab(editor));
            }
            if (Settings.hasUploadUrl(editor) || Settings.hasUploadHandler(editor)) {
              body.push(UploadTab.makeTab(editor));
            }
            win = editor.windowManager.open({
              title: 'Insert/edit image',
              data: data,
              bodyType: 'tabpanel',
              body: body,
              onSubmit: curry(submitForm, editor)
            });
          } else {
            win = editor.windowManager.open({
              title: 'Insert/edit image',
              data: data,
              body: MainTab.getGeneralItems(editor, imageListCtrl),
              onSubmit: curry(submitForm, editor)
            });
          }
          SizeManager.syncSize(win);
        }
        function open() {
          Utils.createImageList(editor, showDialog);
        }
        return { open: open };
      }
  
      var register = function (editor) {
        editor.addCommand('mceImage', Dialog(editor).open);
      };
      var Commands = { register: register };
  
      var hasImageClass = function (node) {
        var className = node.attr('class');
        return className && /\bimage\b/.test(className);
      };
      var toggleContentEditableState = function (state) {
        return function (nodes) {
          var i = nodes.length, node;
          var toggleContentEditable = function (node) {
            node.attr('contenteditable', state ? 'true' : null);
          };
          while (i--) {
            node = nodes[i];
            if (hasImageClass(node)) {
              node.attr('contenteditable', state ? 'false' : null);
              global$2.each(node.getAll('figcaption'), toggleContentEditable);
            }
          }
        };
      };
      var setup = function (editor) {
        editor.on('preInit', function () {
          editor.parser.addNodeFilter('figure', toggleContentEditableState(true));
          editor.serializer.addNodeFilter('figure', toggleContentEditableState(false));
        });
      };
      var FilterContent = { setup: setup };
  
      var register$1 = function (editor) {
        editor.addButton('image', {
          icon: 'image',
          tooltip: 'Insert/edit image',
          onclick: Dialog(editor).open,
          stateSelector: 'img:not([data-mce-object],[data-mce-placeholder]),figure.image'
        });
        editor.addMenuItem('image', {
          icon: 'image',
          text: 'Image',
          onclick: Dialog(editor).open,
          context: 'insert',
          prependToContext: true
        });
      };
      var Buttons = { register: register$1 };
  
      global.add('image', function (editor) {
        FilterContent.setup(editor);
        Buttons.register(editor);
        Commands.register(editor);
      });
      function Plugin () {
      }
  
      return Plugin;
  
  }(window));
  })();
  