text: (function () {
      var defs = {}; // id -> {dependencies, definition, instance (possibly undefined)}
  
  // Used when there is no 'main' module.
  // The name is probably (hopefully) unique so minification removes for releases.
      var register_3795 = function (id) {
          var module = dem(id);
          var fragments = id.split('.');
          var target = Function('return this;')();
          for (var i = 0; i < fragments.length - 1; ++i) {
              if (target[fragments[i]] === undefined) {
                  target[fragments[i]] = {};
              }
              target = target[fragments[i]];
          }
          target[fragments[fragments.length - 1]] = module;
      };
  
      var instantiate = function (id) {
          var actual = defs[id];
          var dependencies = actual.deps;
          var definition = actual.defn;
          var len = dependencies.length;
          var instances = new Array(len);
          for (var i = 0; i < len; ++i) {
              instances[i] = dem(dependencies[i]);
          }
          var defResult = definition.apply(null, instances);
          if (defResult === undefined) {
              throw 'module [' + id + '] returned undefined';
          }
          actual.instance = defResult;
      };
  
      var def = function (id, dependencies, definition) {
          if (typeof id !== 'string') {
              throw 'module id must be a string';
          } else if (dependencies === undefined) {
              throw 'no dependencies for ' + id;
          } else if (definition === undefined) {
              throw 'no definition function for ' + id;
          }
          defs[id] = {
              deps: dependencies,
              defn: definition,
              instance: undefined
          };
      };
  
      var dem = function (id) {
          var actual = defs[id];
          if (actual === undefined) {
              throw 'module [' + id + '] was undefined';
          } else if (actual.instance === undefined) {
              instantiate(id);
          }
          return actual.instance;
      };
  
      var req = function (ids, callback) {
          var len = ids.length;
          var instances = new Array(len);
          for (var i = 0; i < len; ++i) {
              instances[i] = dem(ids[i]);
          }
          callback.apply(null, instances);
      };
  
      var ephox = {};
  
      ephox.bolt = {
          module: {
              api: {
                  define: def,
                  require: req,
                  demand: dem
              }
          }
      };
  
      var define = def;
      var require = req;
      var demand = dem;
  // this helps with minification when using a lot of global references
      var defineGlobal = function (id, ref) {
          define(id, [], function () {
              return ref;
          });
      };
      /* jsc
  ["tinymce.plugins.imagetools.Plugin","ephox.katamari.api.Cell","tinymce.core.PluginManager","tinymce.plugins.imagetools.api.Commands","tinymce.plugins.imagetools.core.UploadSelectedImage","tinymce.plugins.imagetools.ui.Buttons","tinymce.plugins.imagetools.ui.ContextToolbar","global!tinymce.util.Tools.resolve","tinymce.core.util.Tools","tinymce.plugins.imagetools.core.Actions","ephox.katamari.api.Fun","tinymce.plugins.imagetools.api.Settings","ephox.imagetools.api.BlobConversions","ephox.imagetools.api.ImageTransformations","global!Array","global!Error","ephox.sand.api.URL","global!clearTimeout","tinymce.core.util.Delay","tinymce.core.util.Promise","tinymce.core.util.URI","tinymce.plugins.imagetools.core.ImageSize","tinymce.plugins.imagetools.core.Proxy","tinymce.plugins.imagetools.ui.Dialog","ephox.imagetools.util.Conversions","ephox.imagetools.util.ImageResult","ephox.imagetools.transformations.Filters","ephox.imagetools.transformations.ImageTools","ephox.sand.util.Global","tinymce.plugins.imagetools.core.Errors","tinymce.plugins.imagetools.core.Utils","global!Math","global!setTimeout","tinymce.core.dom.DOMUtils","tinymce.core.ui.Factory","tinymce.plugins.imagetools.core.UndoStack","tinymce.plugins.imagetools.ui.ImagePanel","ephox.imagetools.util.Promise","ephox.imagetools.util.Canvas","ephox.imagetools.util.Mime","ephox.imagetools.util.ImageSize","ephox.imagetools.transformations.ColorMatrix","ephox.imagetools.transformations.ImageResizerCanvas","ephox.katamari.api.Resolve","ephox.katamari.api.Arr","ephox.sand.api.FileReader","ephox.sand.api.XMLHttpRequest","global!document","global!Image","tinymce.core.geom.Rect","tinymce.plugins.imagetools.core.LoadImage","tinymce.plugins.imagetools.ui.CropRect","ephox.katamari.api.Global","ephox.katamari.api.Option","global!String","tinymce.core.dom.DomQuery","tinymce.core.util.Observable","tinymce.core.util.VK","global!Object"]
  jsc */
      define(
          'ephox.katamari.api.Cell',
  
          [],
  
          function () {
              var Cell = function (initial) {
                  var value = initial;
  
                  var get = function () {
                      return value;
                  };
  
                  var set = function (v) {
                      value = v;
                  };
  
                  var clone = function () {
                      return Cell(get());
                  };
  
                  return {
                      get: get,
                      set: set,
                      clone: clone
                  };
              };
  
              return Cell;
          }
      );
  
      defineGlobal('global!tinymce.util.Tools.resolve', tinymce.util.Tools.resolve);
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.PluginManager',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.PluginManager');
          }
      );
  
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.util.Tools',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.util.Tools');
          }
      );
  
      /* eslint-disable */
      /* jshint ignore:start */
  
      /**
       * Modifed to be a feature fill and wrapped as tinymce module.
       *
       * Promise polyfill under MIT license: https://github.com/taylorhakes/promise-polyfill
       */
      define(
          'ephox.imagetools.util.Promise',
          [],
          function () {
              if (window.Promise) {
                  return window.Promise;
              }
  
              // Use polyfill for setImmediate for performance gains
              var asap = Promise.immediateFn || (typeof setImmediate === 'function' && setImmediate) ||
                  function (fn) {
                      setTimeout(fn, 1);
                  };
  
              // Polyfill for Function.prototype.bind
              function bind(fn, thisArg) {
                  return function () {
                      fn.apply(thisArg, arguments);
                  };
              }
  
              var isArray = Array.isArray || function (value) {
                  return Object.prototype.toString.call(value) === '[object Array]';
              };
  
              function Promise(fn) {
                  if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new');
                  if (typeof fn !== 'function') throw new TypeError('not a function');
                  this._state = null;
                  this._value = null;
                  this._deferreds = [];
  
                  doResolve(fn, bind(resolve, this), bind(reject, this));
              }
  
              function handle(deferred) {
                  var me = this;
                  if (this._state === null) {
                      this._deferreds.push(deferred);
                      return;
                  }
                  asap(function () {
                      var cb = me._state ? deferred.onFulfilled : deferred.onRejected;
                      if (cb === null) {
                          (me._state ? deferred.resolve : deferred.reject)(me._value);
                          return;
                      }
                      var ret;
                      try {
                          ret = cb(me._value);
                      } catch (e) {
                          deferred.reject(e);
                          return;
                      }
                      deferred.resolve(ret);
                  });
              }
  
              function resolve(newValue) {
                  try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
                      if (newValue === this) throw new TypeError('A promise cannot be resolved with itself.');
                      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
                          var then = newValue.then;
                          if (typeof then === 'function') {
                              doResolve(bind(then, newValue), bind(resolve, this), bind(reject, this));
                              return;
                          }
                      }
                      this._state = true;
                      this._value = newValue;
                      finale.call(this);
                  } catch (e) {
                      reject.call(this, e);
                  }
              }
  
              function reject(newValue) {
                  this._state = false;
                  this._value = newValue;
                  finale.call(this);
              }
  
              function finale() {
                  for (var i = 0, len = this._deferreds.length; i < len; i++) {
                      handle.call(this, this._deferreds[i]);
                  }
                  this._deferreds = null;
              }
  
              function Handler(onFulfilled, onRejected, resolve, reject) {
                  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
                  this.onRejected = typeof onRejected === 'function' ? onRejected : null;
                  this.resolve = resolve;
                  this.reject = reject;
              }
  
              /**
               * Take a potentially misbehaving resolver function and make sure
               * onFulfilled and onRejected are only called once.
               *
               * Makes no guarantees about asynchrony.
               */
              function doResolve(fn, onFulfilled, onRejected) {
                  var done = false;
                  try {
                      fn(function (value) {
                          if (done) return;
                          done = true;
                          onFulfilled(value);
                      }, function (reason) {
                          if (done) return;
                          done = true;
                          onRejected(reason);
                      });
                  } catch (ex) {
                      if (done) return;
                      done = true;
                      onRejected(ex);
                  }
              }
  
              Promise.prototype['catch'] = function (onRejected) {
                  return this.then(null, onRejected);
              };
  
              Promise.prototype.then = function (onFulfilled, onRejected) {
                  var me = this;
                  return new Promise(function (resolve, reject) {
                      handle.call(me, new Handler(onFulfilled, onRejected, resolve, reject));
                  });
              };
  
              Promise.all = function () {
                  var args = Array.prototype.slice.call(arguments.length === 1 && isArray(arguments[0]) ? arguments[0] : arguments);
  
                  return new Promise(function (resolve, reject) {
                      if (args.length === 0) return resolve([]);
                      var remaining = args.length;
  
                      function res(i, val) {
                          try {
                              if (val && (typeof val === 'object' || typeof val === 'function')) {
                                  var then = val.then;
                                  if (typeof then === 'function') {
                                      then.call(val, function (val) {
                                          res(i, val);
                                      }, reject);
                                      return;
                                  }
                              }
                              args[i] = val;
                              if (--remaining === 0) {
                                  resolve(args);
                              }
                          } catch (ex) {
                              reject(ex);
                          }
                      }
  
                      for (var i = 0; i < args.length; i++) {
                          res(i, args[i]);
                      }
                  });
              };
  
              Promise.resolve = function (value) {
                  if (value && typeof value === 'object' && value.constructor === Promise) {
                      return value;
                  }
  
                  return new Promise(function (resolve) {
                      resolve(value);
                  });
              };
  
              Promise.reject = function (value) {
                  return new Promise(function (resolve, reject) {
                      reject(value);
                  });
              };
  
              Promise.race = function (values) {
                  return new Promise(function (resolve, reject) {
                      for (var i = 0, len = values.length; i < len; i++) {
                          values[i].then(resolve, reject);
                      }
                  });
              };
  
              return Promise;
          });
  
      /* jshint ignore:end */
      /* eslint-enable */
  
      define(
          'ephox.imagetools.util.Canvas',
          [],
          function () {
              function create(width, height) {
                  return resize(document.createElement('canvas'), width, height);
              }
  
              function clone(canvas) {
                  var tCanvas, ctx;
                  tCanvas = create(canvas.width, canvas.height);
                  ctx = get2dContext(tCanvas);
                  ctx.drawImage(canvas, 0, 0);
                  return tCanvas;
              }
  
              function get2dContext(canvas) {
                  return canvas.getContext('2d');
              }
  
              function get3dContext(canvas) {
                  var gl = null;
                  try {
                      gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
                  } catch (e) {
                  }
  
                  if (!gl) { // it seems that sometimes it doesn't throw exception, but still fails to get context
                      gl = null;
                  }
                  return gl;
              }
  
              function resize(canvas, width, height) {
                  canvas.width = width;
                  canvas.height = height;
  
                  return canvas;
              }
  
              return {
                  create: create,
                  clone: clone,
                  resize: resize,
                  get2dContext: get2dContext,
                  get3dContext: get3dContext
              };
          });
      define(
          'ephox.imagetools.util.Mime',
          [],
          function () {
              function getUriPathName(uri) {
                  var a = document.createElement('a');
                  a.href = uri;
                  return a.pathname;
              }
  
              function guessMimeType(uri) {
                  var parts, ext, mimes, matches;
  
                  if (uri.indexOf('data:') === 0) {
                      uri = uri.split(',');
                      matches = /data:([^;]+)/.exec(uri[0]);
                      return matches ? matches[1] : '';
                  } else {
                      mimes = {
                          'jpg': 'image/jpeg',
                          'jpeg': 'image/jpeg',
                          'png': 'image/png'
                      };
  
                      parts = getUriPathName(uri).split('.');
                      ext = parts[parts.length - 1];
  
                      if (ext) {
                          ext = ext.toLowerCase();
                      }
                      return mimes[ext];
                  }
              }
  
              return {
                  guessMimeType: guessMimeType
              };
          });
      define(
          'ephox.imagetools.util.ImageSize',
          [],
          function () {
              function getWidth(image) {
                  return image.naturalWidth || image.width;
              }
  
              function getHeight(image) {
                  return image.naturalHeight || image.height;
              }
  
              return {
                  getWidth: getWidth,
                  getHeight: getHeight
              };
          });
      define(
          'ephox.imagetools.util.Conversions',
          [
              'ephox.imagetools.util.Promise',
              'ephox.imagetools.util.Canvas',
              'ephox.imagetools.util.Mime',
              'ephox.imagetools.util.ImageSize'
          ],
          function (Promise, Canvas, Mime, ImageSize) {
              function loadImage(image) {
                  return new Promise(function (resolve) {
                      function loaded() {
                          image.removeEventListener('load', loaded);
                          resolve(image);
                      }
  
                      if (image.complete) {
                          resolve(image);
                      } else {
                          image.addEventListener('load', loaded);
                      }
                  });
              }
  
              function imageToCanvas(image) {
                  return loadImage(image).then(function (image) {
                      var context, canvas;
  
                      canvas = Canvas.create(ImageSize.getWidth(image), ImageSize.getHeight(image));
                      context = Canvas.get2dContext(canvas);
                      context.drawImage(image, 0, 0);
  
                      return canvas;
                  });
              }
  
              function imageToBlob(image) {
                  return loadImage(image).then(function (image) {
                      var src = image.src;
  
                      if (src.indexOf('blob:') === 0) {
                          return blobUriToBlob(src);
                      }
  
                      if (src.indexOf('data:') === 0) {
                          return dataUriToBlob(src);
                      }
  
                      return imageToCanvas(image).then(function (canvas) {
                          return dataUriToBlob(canvas.toDataURL(Mime.guessMimeType(src)));
                      });
                  });
              }
  
              function blobToImage(blob) {
                  return new Promise(function (resolve) {
                      var image = new Image();
  
                      function loaded() {
                          image.removeEventListener('load', loaded);
                          resolve(image);
                      }
  
                      image.addEventListener('load', loaded);
                      image.src = URL.createObjectURL(blob);
  
                      if (image.complete) {
                          loaded();
                      }
                  });
              }
  
              function blobUriToBlob(url) {
                  return new Promise(function (resolve) {
                      var xhr = new XMLHttpRequest();
  
                      xhr.open('GET', url, true);
                      xhr.responseType = 'blob';
  
                      xhr.onload = function () {
                          if (this.status === 200) {
                              resolve(this.response);
                          }
                      };
  
                      xhr.send();
                  });
              }
  
              function dataUriToBlobSync(uri) {
                  var str, arr, i, matches, type, blobBuilder;
  
                  uri = uri.split(',');
  
                  matches = /data:([^;]+)/.exec(uri[0]);
                  if (matches) {
                      type = matches[1];
                  }
  
                  str = atob(uri[1]);
  
                  if (window.WebKitBlobBuilder) {
                      /* globals WebKitBlobBuilder:false */
                      blobBuilder = new WebKitBlobBuilder();
  
                      arr = new ArrayBuffer(str.length);
                      for (i = 0; i < arr.length; i++) {
                          arr[i] = str.charCodeAt(i);
                      }
  
                      blobBuilder.append(arr);
                      return blobBuilder.getBlob(type);
                  }
  
                  arr = new Uint8Array(str.length);
                  for (i = 0; i < arr.length; i++) {
                      arr[i] = str.charCodeAt(i);
                  }
                  return new Blob([arr], {type: type});
              }
  
              function dataUriToBlob(uri) {
                  return new Promise(function (resolve) {
                      resolve(dataUriToBlobSync(uri));
                  });
              }
  
              function uriToBlob(url) {
                  if (url.indexOf('blob:') === 0) {
                      return blobUriToBlob(url);
                  }
  
                  if (url.indexOf('data:') === 0) {
                      return dataUriToBlob(url);
                  }
  
                  return null;
              }
  
              function canvasToBlob(canvas, type, quality) {
                  type = type || 'image/png';
  
                  if (HTMLCanvasElement.prototype.toBlob) {
                      return new Promise(function (resolve) {
                          canvas.toBlob(function (blob) {
                              resolve(blob);
                          }, type, quality);
                      });
                  } else {
                      return dataUriToBlob(canvas.toDataURL(type, quality));
                  }
              }
  
              function blobToDataUri(blob) {
                  return new Promise(function (resolve) {
                      var reader = new FileReader();
  
                      reader.onloadend = function () {
                          resolve(reader.result);
                      };
  
                      reader.readAsDataURL(blob);
                  });
              }
  
              function blobToBase64(blob) {
                  return blobToDataUri(blob).then(function (dataUri) {
                      return dataUri.split(',')[1];
                  });
              }
  
              function revokeImageUrl(image) {
                  URL.revokeObjectURL(image.src);
              }
  
              return {
                  // used outside
                  blobToImage: blobToImage,
                  // used outside
                  imageToBlob: imageToBlob,
                  // used outside
                  blobToDataUri: blobToDataUri,
                  // used outside
                  blobToBase64: blobToBase64,
  
                  // helper method
                  imageToCanvas: imageToCanvas,
                  // helper method
                  canvasToBlob: canvasToBlob,
                  // helper method
                  revokeImageUrl: revokeImageUrl,
                  // helper method
                  uriToBlob: uriToBlob,
                  // helper method
                  dataUriToBlobSync: dataUriToBlobSync
              };
          });
      define(
          'ephox.imagetools.util.ImageResult',
          [
              'ephox.imagetools.util.Promise',
              'ephox.imagetools.util.Conversions',
              'ephox.imagetools.util.Mime',
              'ephox.imagetools.util.Canvas'
          ],
          function (Promise, Conversions, Mime, Canvas) {
              function create(canvas, initialType) {
                  function getType() {
                      return initialType;
                  }
  
                  function toBlob(type, quality) {
                      return Conversions.canvasToBlob(canvas, type || initialType, quality);
                  }
  
                  function toDataURL(type, quality) {
                      return canvas.toDataURL(type || initialType, quality);
                  }
  
                  function toBase64(type, quality) {
                      return toDataURL(type, quality).split(',')[1];
                  }
  
                  function toCanvas() {
                      return Canvas.clone(canvas);
                  }
  
                  return {
                      getType: getType,
                      toBlob: toBlob,
                      toDataURL: toDataURL,
                      toBase64: toBase64,
                      toCanvas: toCanvas
                  };
              }
  
              function fromBlob(blob) {
                  return Conversions.blobToImage(blob)
                      .then(function (image) {
                          var result = Conversions.imageToCanvas(image);
                          Conversions.revokeImageUrl(image);
                          return result;
                      })
                      .then(function (canvas) {
                          return create(canvas, blob.type);
                      });
              }
  
              function fromCanvas(canvas, type) {
                  return new Promise(function (resolve) {
                      resolve(create(canvas, type));
                  });
              }
  
              function fromImage(image) {
                  var type = Mime.guessMimeType(image.src);
                  return Conversions.imageToCanvas(image).then(function (canvas) {
                      return create(canvas, type);
                  });
              }
  
              return {
                  fromBlob: fromBlob,
                  fromCanvas: fromCanvas,
                  fromImage: fromImage
              };
          });
  
      define(
          'ephox.imagetools.api.BlobConversions',
          [
              'ephox.imagetools.util.Conversions',
              'ephox.imagetools.util.ImageResult'
          ],
          function (Conversions, ImageResult) {
              var blobToImage = function (image) {
                  return Conversions.blobToImage(image);
              };
  
              var imageToBlob = function (blob) {
                  return Conversions.imageToBlob(blob);
              };
  
              var blobToDataUri = function (blob) {
                  return Conversions.blobToDataUri(blob);
              };
  
              var blobToBase64 = function (blob) {
                  return Conversions.blobToBase64(blob);
              };
  
              var blobToImageResult = function (blob) {
                  return ImageResult.fromBlob(blob);
              };
  
              var dataUriToImageResult = function (uri) {
                  return Conversions.uriToBlob(uri).then(ImageResult.fromBlob);
              };
  
              var imageToImageResult = function (image) {
                  return ImageResult.fromImage(image);
              };
  
              var imageResultToBlob = function (ir, type, quality) {
                  return ir.toBlob(type, quality);
              };
  
              var imageResultToBlobSync = function (ir, type, quality) {
                  return Conversions.dataUriToBlobSync(ir.toDataURL(type, quality));
              };
  
              return {
                  // used outside
                  blobToImage: blobToImage,
                  // used outside
                  imageToBlob: imageToBlob,
                  // used outside
                  blobToDataUri: blobToDataUri,
                  // used outside
                  blobToBase64: blobToBase64,
                  // used outside
                  blobToImageResult: blobToImageResult,
                  // used outside
                  dataUriToImageResult: dataUriToImageResult,
                  // used outside
                  imageToImageResult: imageToImageResult,
                  // used outside
                  imageResultToBlob: imageResultToBlob,
                  // just in case
                  imageResultToBlobSync: imageResultToBlobSync
              };
          }
      );
      define(
          'ephox.imagetools.transformations.ColorMatrix',
          [],
          function () {
              function clamp(value, min, max) {
                  value = parseFloat(value);
  
                  if (value > max) {
                      value = max;
                  } else if (value < min) {
                      value = min;
                  }
  
                  return value;
              }
  
              function identity() {
                  return [
                      1, 0, 0, 0, 0,
                      0, 1, 0, 0, 0,
                      0, 0, 1, 0, 0,
                      0, 0, 0, 1, 0,
                      0, 0, 0, 0, 1
                  ];
              }
  
              var DELTA_INDEX = [
                  0, 0.01, 0.02, 0.04, 0.05, 0.06, 0.07, 0.08, 0.1, 0.11,
                  0.12, 0.14, 0.15, 0.16, 0.17, 0.18, 0.20, 0.21, 0.22, 0.24,
                  0.25, 0.27, 0.28, 0.30, 0.32, 0.34, 0.36, 0.38, 0.40, 0.42,
                  0.44, 0.46, 0.48, 0.5, 0.53, 0.56, 0.59, 0.62, 0.65, 0.68,
                  0.71, 0.74, 0.77, 0.80, 0.83, 0.86, 0.89, 0.92, 0.95, 0.98,
                  1.0, 1.06, 1.12, 1.18, 1.24, 1.30, 1.36, 1.42, 1.48, 1.54,
                  1.60, 1.66, 1.72, 1.78, 1.84, 1.90, 1.96, 2.0, 2.12, 2.25,
                  2.37, 2.50, 2.62, 2.75, 2.87, 3.0, 3.2, 3.4, 3.6, 3.8,
                  4.0, 4.3, 4.7, 4.9, 5.0, 5.5, 6.0, 6.5, 6.8, 7.0,
                  7.3, 7.5, 7.8, 8.0, 8.4, 8.7, 9.0, 9.4, 9.6, 9.8,
                  10.0
              ];
  
              function multiply(matrix1, matrix2) {
                  var i, j, k, val, col = [], out = new Array(10);
  
                  for (i = 0; i < 5; i++) {
                      for (j = 0; j < 5; j++) {
                          col[j] = matrix2[j + i * 5];
                      }
  
                      for (j = 0; j < 5; j++) {
                          val = 0;
  
                          for (k = 0; k < 5; k++) {
                              val += matrix1[j + k * 5] * col[k];
                          }
  
                          out[j + i * 5] = val;
                      }
                  }
  
                  return out;
              }
  
              function adjust(matrix, adjustValue) {
                  adjustValue = clamp(adjustValue, 0, 1);
  
                  return matrix.map(function (value, index) {
                      if (index % 6 === 0) {
                          value = 1.0 - ((1 - value) * adjustValue);
                      } else {
                          value *= adjustValue;
                      }
  
                      return clamp(value, 0, 1);
                  });
              }
  
              function adjustContrast(matrix, value) {
                  var x;
  
                  value = clamp(value, -1, 1);
                  value *= 100;
  
                  if (value < 0) {
                      x = 127 + value / 100 * 127;
                  } else {
                      x = value % 1;
  
                      if (x === 0) {
                          x = DELTA_INDEX[value];
                      } else {
                          // use linear interpolation for more granularity.
                          x = DELTA_INDEX[(Math.floor(value))] * (1 - x) + DELTA_INDEX[(Math.floor(value)) + 1] * x;
                      }
  
                      x = x * 127 + 127;
                  }
  
                  return multiply(matrix, [
                      x / 127, 0, 0, 0, 0.5 * (127 - x),
                      0, x / 127, 0, 0, 0.5 * (127 - x),
                      0, 0, x / 127, 0, 0.5 * (127 - x),
                      0, 0, 0, 1, 0,
                      0, 0, 0, 0, 1
                  ]);
              }
  
              function adjustSaturation(matrix, value) {
                  var x, lumR, lumG, lumB;
  
                  value = clamp(value, -1, 1);
                  x = 1 + ((value > 0) ? 3 * value : value);
                  lumR = 0.3086;
                  lumG = 0.6094;
                  lumB = 0.0820;
  
                  return multiply(matrix, [
                      lumR * (1 - x) + x, lumG * (1 - x), lumB * (1 - x), 0, 0,
                      lumR * (1 - x), lumG * (1 - x) + x, lumB * (1 - x), 0, 0,
                      lumR * (1 - x), lumG * (1 - x), lumB * (1 - x) + x, 0, 0,
                      0, 0, 0, 1, 0,
                      0, 0, 0, 0, 1
                  ]);
              }
  
              function adjustHue(matrix, angle) {
                  var cosVal, sinVal, lumR, lumG, lumB;
  
                  angle = clamp(angle, -180, 180) / 180 * Math.PI;
                  cosVal = Math.cos(angle);
                  sinVal = Math.sin(angle);
                  lumR = 0.213;
                  lumG = 0.715;
                  lumB = 0.072;
  
                  return multiply(matrix, [
                      lumR + cosVal * (1 - lumR) + sinVal * (-lumR), lumG + cosVal * (-lumG) + sinVal * (-lumG),
                      lumB + cosVal * (-lumB) + sinVal * (1 - lumB), 0, 0,
                      lumR + cosVal * (-lumR) + sinVal * (0.143), lumG + cosVal * (1 - lumG) + sinVal * (0.140),
                      lumB + cosVal * (-lumB) + sinVal * (-0.283), 0, 0,
                      lumR + cosVal * (-lumR) + sinVal * (-(1 - lumR)), lumG + cosVal * (-lumG) + sinVal * (lumG),
                      lumB + cosVal * (1 - lumB) + sinVal * (lumB), 0, 0,
                      0, 0, 0, 1, 0,
                      0, 0, 0, 0, 1
                  ]);
              }
  
              function adjustBrightness(matrix, value) {
                  value = clamp(255 * value, -255, 255);
  
                  return multiply(matrix, [
                      1, 0, 0, 0, value,
                      0, 1, 0, 0, value,
                      0, 0, 1, 0, value,
                      0, 0, 0, 1, 0,
                      0, 0, 0, 0, 1
                  ]);
              }
  
              function adjustColors(matrix, adjustR, adjustG, adjustB) {
                  adjustR = clamp(adjustR, 0, 2);
                  adjustG = clamp(adjustG, 0, 2);
                  adjustB = clamp(adjustB, 0, 2);
  
                  return multiply(matrix, [
                      adjustR, 0, 0, 0, 0,
                      0, adjustG, 0, 0, 0,
                      0, 0, adjustB, 0, 0,
                      0, 0, 0, 1, 0,
                      0, 0, 0, 0, 1
                  ]);
              }
  
              function adjustSepia(matrix, value) {
                  value = clamp(value, 0, 1);
  
                  return multiply(matrix, adjust([
                      0.393, 0.769, 0.189, 0, 0,
                      0.349, 0.686, 0.168, 0, 0,
                      0.272, 0.534, 0.131, 0, 0,
                      0, 0, 0, 1, 0,
                      0, 0, 0, 0, 1
                  ], value));
              }
  
              function adjustGrayscale(matrix, value) {
                  value = clamp(value, 0, 1);
  
                  return multiply(matrix, adjust([
                      0.33, 0.34, 0.33, 0, 0,
                      0.33, 0.34, 0.33, 0, 0,
                      0.33, 0.34, 0.33, 0, 0,
                      0, 0, 0, 1, 0,
                      0, 0, 0, 0, 1
                  ], value));
              }
  
              return {
                  identity: identity,
                  adjust: adjust,
                  multiply: multiply,
                  adjustContrast: adjustContrast,
                  adjustBrightness: adjustBrightness,
                  adjustSaturation: adjustSaturation,
                  adjustHue: adjustHue,
                  adjustColors: adjustColors,
                  adjustSepia: adjustSepia,
                  adjustGrayscale: adjustGrayscale
              };
          });
      define(
          'ephox.imagetools.transformations.Filters',
          [
              'ephox.imagetools.util.Canvas',
              'ephox.imagetools.util.ImageResult',
              'ephox.imagetools.transformations.ColorMatrix'
          ],
          function (Canvas, ImageResult, ColorMatrix) {
              function colorFilter(ir, matrix) {
                  var canvas = ir.toCanvas();
                  var context = Canvas.get2dContext(canvas);
                  var pixels;
  
                  function applyMatrix(pixels, m) {
                      var d = pixels.data, r, g, b, a, i,
                          m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3], m4 = m[4],
                          m5 = m[5], m6 = m[6], m7 = m[7], m8 = m[8], m9 = m[9],
                          m10 = m[10], m11 = m[11], m12 = m[12], m13 = m[13], m14 = m[14],
                          m15 = m[15], m16 = m[16], m17 = m[17], m18 = m[18], m19 = m[19];
  
                      for (i = 0; i < d.length; i += 4) {
                          r = d[i];
                          g = d[i + 1];
                          b = d[i + 2];
                          a = d[i + 3];
  
                          d[i] = r * m0 + g * m1 + b * m2 + a * m3 + m4;
                          d[i + 1] = r * m5 + g * m6 + b * m7 + a * m8 + m9;
                          d[i + 2] = r * m10 + g * m11 + b * m12 + a * m13 + m14;
                          d[i + 3] = r * m15 + g * m16 + b * m17 + a * m18 + m19;
                      }
  
                      return pixels;
                  }
  
                  pixels = applyMatrix(context.getImageData(0, 0, canvas.width, canvas.height), matrix);
                  context.putImageData(pixels, 0, 0);
  
                  return ImageResult.fromCanvas(canvas, ir.getType());
              }
  
              function convoluteFilter(ir, matrix) {
                  var canvas = ir.toCanvas();
                  var context = Canvas.get2dContext(canvas);
                  var pixelsIn, pixelsOut;
  
                  function applyMatrix(pixelsIn, pixelsOut, matrix) {
                      var rgba, drgba, side, halfSide, x, y, r, g, b,
                          cx, cy, scx, scy, offset, wt, w, h;
  
                      function clamp(value, min, max) {
                          if (value > max) {
                              value = max;
                          } else if (value < min) {
                              value = min;
                          }
  
                          return value;
                      }
  
                      // Calc side and half side of matrix
                      side = Math.round(Math.sqrt(matrix.length));
                      halfSide = Math.floor(side / 2);
                      rgba = pixelsIn.data;
                      drgba = pixelsOut.data;
                      w = pixelsIn.width;
                      h = pixelsIn.height;
  
                      // Apply convolution matrix to pixels
                      for (y = 0; y < h; y++) {
                          for (x = 0; x < w; x++) {
                              r = g = b = 0;
  
                              for (cy = 0; cy < side; cy++) {
                                  for (cx = 0; cx < side; cx++) {
                                      // Calc relative x, y based on matrix
                                      scx = clamp(x + cx - halfSide, 0, w - 1);
                                      scy = clamp(y + cy - halfSide, 0, h - 1);
  
                                      // Calc r, g, b
                                      offset = (scy * w + scx) * 4;
                                      wt = matrix[cy * side + cx];
                                      r += rgba[offset] * wt;
                                      g += rgba[offset + 1] * wt;
                                      b += rgba[offset + 2] * wt;
                                  }
                              }
  
                              // Set new RGB to destination buffer
                              offset = (y * w + x) * 4;
                              drgba[offset] = clamp(r, 0, 255);
                              drgba[offset + 1] = clamp(g, 0, 255);
                              drgba[offset + 2] = clamp(b, 0, 255);
                          }
                      }
  
                      return pixelsOut;
                  }
  
                  pixelsIn = context.getImageData(0, 0, canvas.width, canvas.height);
                  pixelsOut = context.getImageData(0, 0, canvas.width, canvas.height);
                  pixelsOut = applyMatrix(pixelsIn, pixelsOut, matrix);
                  context.putImageData(pixelsOut, 0, 0);
  
                  return ImageResult.fromCanvas(canvas, ir.getType());
              }
  
              function functionColorFilter(colorFn) {
                  return function (ir, value) {
                      var canvas = ir.toCanvas();
                      var context = Canvas.get2dContext(canvas);
                      var pixels, i, lookup = new Array(256);
  
                      function applyLookup(pixels, lookup) {
                          var d = pixels.data, i;
  
                          for (i = 0; i < d.length; i += 4) {
                              d[i] = lookup[d[i]];
                              d[i + 1] = lookup[d[i + 1]];
                              d[i + 2] = lookup[d[i + 2]];
                          }
  
                          return pixels;
                      }
  
                      for (i = 0; i < lookup.length; i++) {
                          lookup[i] = colorFn(i, value);
                      }
  
                      pixels = applyLookup(context.getImageData(0, 0, canvas.width, canvas.height), lookup);
                      context.putImageData(pixels, 0, 0);
  
                      return ImageResult.fromCanvas(canvas, ir.getType());
                  };
              }
  
              function complexAdjustableColorFilter(matrixAdjustFn) {
                  return function (ir, adjust) {
                      return colorFilter(ir, matrixAdjustFn(ColorMatrix.identity(), adjust));
                  };
              }
  
              function basicColorFilter(matrix) {
                  return function (ir) {
                      return colorFilter(ir, matrix);
                  };
              }
  
              function basicConvolutionFilter(kernel) {
                  return function (ir) {
                      return convoluteFilter(ir, kernel);
                  };
              }
  
              return {
                  invert: basicColorFilter([
                      -1, 0, 0, 0, 255,
                      0, -1, 0, 0, 255,
                      0, 0, -1, 0, 255,
                      0, 0, 0, 1, 0
                  ]),
  
                  brightness: complexAdjustableColorFilter(ColorMatrix.adjustBrightness),
                  hue: complexAdjustableColorFilter(ColorMatrix.adjustHue),
                  saturate: complexAdjustableColorFilter(ColorMatrix.adjustSaturation),
                  contrast: complexAdjustableColorFilter(ColorMatrix.adjustContrast),
                  grayscale: complexAdjustableColorFilter(ColorMatrix.adjustGrayscale),
                  sepia: complexAdjustableColorFilter(ColorMatrix.adjustSepia),
                  colorize: function (ir, adjustR, adjustG, adjustB) {
                      return colorFilter(ir, ColorMatrix.adjustColors(ColorMatrix.identity(), adjustR, adjustG, adjustB));
                  },
  
                  sharpen: basicConvolutionFilter([
                      0, -1, 0,
                      -1, 5, -1,
                      0, -1, 0
                  ]),
  
                  emboss: basicConvolutionFilter([
                      -2, -1, 0,
                      -1, 1, 1,
                      0, 1, 2
                  ]),
  
                  gamma: functionColorFilter(function (color, value) {
                      return Math.pow(color / 255, 1 - value) * 255;
                  }),
  
                  exposure: functionColorFilter(function (color, value) {
                      return 255 * (1 - Math.exp(-(color / 255) * value));
                  }),
  
                  colorFilter: colorFilter,
                  convoluteFilter: convoluteFilter
              };
          });
      define(
          'ephox.imagetools.transformations.ImageResizerCanvas',
          [
              'ephox.imagetools.util.Promise',
              'ephox.imagetools.util.Conversions',
              'ephox.imagetools.util.Canvas',
              'ephox.imagetools.util.ImageSize'
          ],
          function (Promise, Conversions, Canvas, ImageSize) {
              /**
               * @method scale
               * @static
               * @param image {Image|Canvas}
               * @param dW {Number} Width that the image should be scaled to
               * @param dH {Number} Height that the image should be scaled to
               * @returns {Promise}
               */
              function scale(image, dW, dH) {
                  var sW = ImageSize.getWidth(image);
                  var sH = ImageSize.getHeight(image);
                  var wRatio = dW / sW;
                  var hRatio = dH / sH;
                  var scaleCapped = false;
  
                  if (wRatio < 0.5 || wRatio > 2) {
                      wRatio = wRatio < 0.5 ? 0.5 : 2;
                      scaleCapped = true;
                  }
                  if (hRatio < 0.5 || hRatio > 2) {
                      hRatio = hRatio < 0.5 ? 0.5 : 2;
                      scaleCapped = true;
                  }
  
                  var scaled = _scale(image, wRatio, hRatio);
  
                  return !scaleCapped ? scaled : scaled.then(function (tCanvas) {
                      return scale(tCanvas, dW, dH);
                  });
              }
  
              function _scale(image, wRatio, hRatio) {
                  return new Promise(function (resolve) {
                      var sW = ImageSize.getWidth(image);
                      var sH = ImageSize.getHeight(image);
                      var dW = Math.floor(sW * wRatio);
                      var dH = Math.floor(sH * hRatio);
                      var canvas = Canvas.create(dW, dH);
                      var context = Canvas.get2dContext(canvas);
  
                      context.drawImage(image, 0, 0, sW, sH, 0, 0, dW, dH);
  
                      resolve(canvas);
                  });
              }
  
              return {
                  scale: scale
              };
          });
  
      define(
          'ephox.imagetools.transformations.ImageTools',
          [
              'ephox.imagetools.util.Canvas',
              'ephox.imagetools.util.ImageResult',
              'ephox.imagetools.transformations.ImageResizerCanvas'
          ],
          function (Canvas, ImageResult, ImageResizerCanvas) {
              function rotate(ir, angle) {
                  var image = ir.toCanvas();
                  var canvas = Canvas.create(image.width, image.height);
                  var context = Canvas.get2dContext(canvas);
                  var translateX = 0, translateY = 0;
  
                  angle = angle < 0 ? 360 + angle : angle;
  
                  if (angle === 90 || angle === 270) {
                      Canvas.resize(canvas, canvas.height, canvas.width);
                  }
  
                  if (angle === 90 || angle === 180) {
                      translateX = canvas.width;
                  }
  
                  if (angle === 270 || angle === 180) {
                      translateY = canvas.height;
                  }
  
                  context.translate(translateX, translateY);
                  context.rotate(angle * Math.PI / 180);
                  context.drawImage(image, 0, 0);
  
                  return ImageResult.fromCanvas(canvas, ir.getType());
              }
  
              function flip(ir, axis) {
                  var image = ir.toCanvas();
                  var canvas = Canvas.create(image.width, image.height);
                  var context = Canvas.get2dContext(canvas);
  
                  if (axis === 'v') {
                      context.scale(1, -1);
                      context.drawImage(image, 0, -canvas.height);
                  } else {
                      context.scale(-1, 1);
                      context.drawImage(image, -canvas.width, 0);
                  }
  
                  return ImageResult.fromCanvas(canvas, ir.getType());
              }
  
              function crop(ir, x, y, w, h) {
                  var image = ir.toCanvas();
                  var canvas = Canvas.create(w, h);
                  var context = Canvas.get2dContext(canvas);
  
                  context.drawImage(image, -x, -y);
  
                  return ImageResult.fromCanvas(canvas, ir.getType());
              }
  
              function resize(ir, w, h) {
                  return ImageResizerCanvas.scale(ir.toCanvas(), w, h)
                      .then(function (canvas) {
                          return ImageResult.fromCanvas(canvas, ir.getType());
                      });
              }
  
              return {
                  rotate: rotate,
                  flip: flip,
                  crop: crop,
                  resize: resize
              };
          });
  
      define(
          'ephox.imagetools.api.ImageTransformations',
          [
              'ephox.imagetools.transformations.Filters',
              'ephox.imagetools.transformations.ImageTools'
          ],
          function (Filters, ImageTools) {
              var invert = function (ir) {
                  return Filters.invert(ir);
              };
  
              var sharpen = function (ir) {
                  return Filters.sharpen(ir);
              };
  
              var emboss = function (ir) {
                  return Filters.emboss(ir);
              };
  
              var gamma = function (ir, value) {
                  return Filters.gamma(ir, value);
              };
  
              var exposure = function (ir, value) {
                  return Filters.exposure(ir, value);
              };
  
              var colorize = function (ir, adjustR, adjustG, adjustB) {
                  return Filters.colorize(ir, adjustR, adjustG, adjustB);
              };
  
              var brightness = function (ir, adjust) {
                  return Filters.brightness(ir, adjust);
              };
  
              var hue = function (ir, adjust) {
                  return Filters.hue(ir, adjust);
              };
  
              var saturate = function (ir, adjust) {
                  return Filters.saturate(ir, adjust);
              };
  
              var contrast = function (ir, adjust) {
                  return Filters.contrast(ir, adjust);
              };
  
              var grayscale = function (ir, adjust) {
                  return Filters.grayscale(ir, adjust);
              };
  
              var sepia = function (ir, adjust) {
                  return Filters.sepia(ir, adjust);
              };
  
              var flip = function (ir, axis) {
                  return ImageTools.flip(ir, axis);
              };
  
              var crop = function (ir, x, y, w, h) {
                  return ImageTools.crop(ir, x, y, w, h);
              };
  
              var resize = function (ir, w, h) {
                  return ImageTools.resize(ir, w, h);
              };
  
              var rotate = function (ir, angle) {
                  return ImageTools.rotate(ir, angle);
              };
  
              return {
                  invert: invert,
                  sharpen: sharpen,
                  emboss: emboss,
                  brightness: brightness,
                  hue: hue,
                  saturate: saturate,
                  contrast: contrast,
                  grayscale: grayscale,
                  sepia: sepia,
                  colorize: colorize,
                  gamma: gamma,
                  exposure: exposure,
  
                  flip: flip,
                  crop: crop,
                  resize: resize,
                  rotate: rotate
              };
          }
      );
      defineGlobal('global!Array', Array);
      defineGlobal('global!Error', Error);
      define(
          'ephox.katamari.api.Fun',
  
          [
              'global!Array',
              'global!Error'
          ],
  
          function (Array, Error) {
              var noop = function () {
              };
  
              var compose = function (fa, fb) {
                  return function () {
                      return fa(fb.apply(null, arguments));
                  };
              };
  
              var constant = function (value) {
                  return function () {
                      return value;
                  };
              };
  
              var identity = function (x) {
                  return x;
              };
  
              var tripleEquals = function (a, b) {
                  return a === b;
              };
  
              // Don't use array slice(arguments), makes the whole function unoptimisable on Chrome
              var curry = function (f) {
                  // equivalent to arguments.slice(1)
                  // starting at 1 because 0 is the f, makes things tricky.
                  // Pay attention to what variable is where, and the -1 magic.
                  // thankfully, we have tests for this.
                  var args = new Array(arguments.length - 1);
                  for (var i = 1; i < arguments.length; i++) args[i - 1] = arguments[i];
  
                  return function () {
                      var newArgs = new Array(arguments.length);
                      for (var j = 0; j < newArgs.length; j++) newArgs[j] = arguments[j];
  
                      var all = args.concat(newArgs);
                      return f.apply(null, all);
                  };
              };
  
              var not = function (f) {
                  return function () {
                      return !f.apply(null, arguments);
                  };
              };
  
              var die = function (msg) {
                  return function () {
                      throw new Error(msg);
                  };
              };
  
              var apply = function (f) {
                  return f();
              };
  
              var call = function (f) {
                  f();
              };
  
              var never = constant(false);
              var always = constant(true);
  
              return {
                  noop: noop,
                  compose: compose,
                  constant: constant,
                  identity: identity,
                  tripleEquals: tripleEquals,
                  curry: curry,
                  not: not,
                  die: die,
                  apply: apply,
                  call: call,
                  never: never,
                  always: always
              };
          }
      );
  
      define(
          'ephox.katamari.api.Global',
  
          [],
  
          function () {
              // Use window object as the global if it's available since CSP will block script evals
              if (typeof window !== 'undefined') {
                  return window;
              } else {
                  return Function('return this;')();
              }
          }
      );
  
      define(
          'ephox.katamari.api.Resolve',
  
          [
              'ephox.katamari.api.Global'
          ],
  
          function (Global) {
              /** path :: ([String], JsObj?) -> JsObj */
              var path = function (parts, scope) {
                  var o = scope !== undefined ? scope : Global;
                  for (var i = 0; i < parts.length && o !== undefined && o !== null; ++i) {
                      o = o[parts[i]];
                  }
                  return o;
              };
  
              /** resolve :: (String, JsObj?) -> JsObj */
              var resolve = function (p, scope) {
                  var parts = p.split('.');
                  return path(parts, scope);
              };
  
              /** step :: (JsObj, String) -> JsObj */
              var step = function (o, part) {
                  if (o[part] === undefined || o[part] === null) {
                      o[part] = {};
                  }
                  return o[part];
              };
  
              /** forge :: ([String], JsObj?) -> JsObj */
              var forge = function (parts, target) {
                  var o = target !== undefined ? target : Global;
                  for (var i = 0; i < parts.length; ++i) {
                      o = step(o, parts[i]);
                  }
                  return o;
              };
  
              /** namespace :: (String, JsObj?) -> JsObj */
              var namespace = function (name, target) {
                  var parts = name.split('.');
                  return forge(parts, target);
              };
  
              return {
                  path: path,
                  resolve: resolve,
                  forge: forge,
                  namespace: namespace
              };
          }
      );
  
      define(
          'ephox.sand.util.Global',
  
          [
              'ephox.katamari.api.Resolve'
          ],
  
          function (Resolve) {
              var unsafe = function (name, scope) {
                  return Resolve.resolve(name, scope);
              };
  
              var getOrDie = function (name, scope) {
                  var actual = unsafe(name, scope);
  
                  if (actual === undefined) throw name + ' not available on this browser';
                  return actual;
              };
  
              return {
                  getOrDie: getOrDie
              };
          }
      );
      define(
          'ephox.sand.api.URL',
  
          [
              'ephox.sand.util.Global'
          ],
  
          function (Global) {
              /*
       * IE10 and above per
       * https://developer.mozilla.org/en-US/docs/Web/API/URL.createObjectURL
       *
       * Also Safari 6.1+
       * Safari 6.0 has 'webkitURL' instead, but doesn't support flexbox so we
       * aren't supporting it anyway
       */
              var url = function () {
                  return Global.getOrDie('URL');
              };
  
              var createObjectURL = function (blob) {
                  return url().createObjectURL(blob);
              };
  
              var revokeObjectURL = function (u) {
                  url().revokeObjectURL(u);
              };
  
              return {
                  createObjectURL: createObjectURL,
                  revokeObjectURL: revokeObjectURL
              };
          }
      );
      defineGlobal('global!clearTimeout', clearTimeout);
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.util.Delay',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.util.Delay');
          }
      );
  
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.util.Promise',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.util.Promise');
          }
      );
  
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.util.URI',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.util.URI');
          }
      );
  
      /**
       * Settings.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.api.Settings',
          [],
          function () {
              var getToolbarItems = function (editor) {
                  return editor.getParam('imagetools_toolbar', 'rotateleft rotateright | flipv fliph | crop editimage imageoptions');
              };
  
              var getProxyUrl = function (editor) {
                  return editor.getParam('imagetools_proxy');
              };
  
              return {
                  getToolbarItems: getToolbarItems,
                  getProxyUrl: getProxyUrl
              };
          }
      );
  
      /**
       * ImageSize.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.core.ImageSize',
          [],
          function () {
              function getImageSize(img) {
                  var width, height;
  
                  function isPxValue(value) {
                      return /^[0-9\.]+px$/.test(value);
                  }
  
                  width = img.style.width;
                  height = img.style.height;
                  if (width || height) {
                      if (isPxValue(width) && isPxValue(height)) {
                          return {
                              w: parseInt(width, 10),
                              h: parseInt(height, 10)
                          };
                      }
  
                      return null;
                  }
  
                  width = img.width;
                  height = img.height;
  
                  if (width && height) {
                      return {
                          w: parseInt(width, 10),
                          h: parseInt(height, 10)
                      };
                  }
  
                  return null;
              }
  
              function setImageSize(img, size) {
                  var width, height;
  
                  if (size) {
                      width = img.style.width;
                      height = img.style.height;
  
                      if (width || height) {
                          img.style.width = size.w + 'px';
                          img.style.height = size.h + 'px';
                          img.removeAttribute('data-mce-style');
                      }
  
                      width = img.width;
                      height = img.height;
  
                      if (width || height) {
                          img.setAttribute('width', size.w);
                          img.setAttribute('height', size.h);
                      }
                  }
              }
  
              function getNaturalImageSize(img) {
                  return {
                      w: img.naturalWidth,
                      h: img.naturalHeight
                  };
              }
  
              return {
                  getImageSize: getImageSize,
                  setImageSize: setImageSize,
                  getNaturalImageSize: getNaturalImageSize
              };
          }
      );
  
      defineGlobal('global!Object', Object);
      define(
          'ephox.katamari.api.Option',
  
          [
              'ephox.katamari.api.Fun',
              'global!Object'
          ],
  
          function (Fun, Object) {
              var never = Fun.never;
              var always = Fun.always;
  
              /**
               Option objects support the following methods:
  
               fold :: this Option a -> ((() -> b, a -> b)) -> Option b
  
               is :: this Option a -> a -> Boolean
  
               isSome :: this Option a -> () -> Boolean
  
               isNone :: this Option a -> () -> Boolean
  
               getOr :: this Option a -> a -> a
  
               getOrThunk :: this Option a -> (() -> a) -> a
  
               getOrDie :: this Option a -> String -> a
  
               or :: this Option a -> Option a -> Option a
               - if some: return self
               - if none: return opt
  
               orThunk :: this Option a -> (() -> Option a) -> Option a
               - Same as "or", but uses a thunk instead of a value
  
               map :: this Option a -> (a -> b) -> Option b
               - "fmap" operation on the Option Functor.
               - same as 'each'
  
               ap :: this Option a -> Option (a -> b) -> Option b
               - "apply" operation on the Option Apply/Applicative.
               - Equivalent to <*> in Haskell/PureScript.
  
               each :: this Option a -> (a -> b) -> Option b
               - same as 'map'
  
               bind :: this Option a -> (a -> Option b) -> Option b
               - "bind"/"flatMap" operation on the Option Bind/Monad.
               - Equivalent to >>= in Haskell/PureScript; flatMap in Scala.
  
               flatten :: {this Option (Option a))} -> () -> Option a
               - "flatten"/"join" operation on the Option Monad.
  
               exists :: this Option a -> (a -> Boolean) -> Boolean
  
               forall :: this Option a -> (a -> Boolean) -> Boolean
  
               filter :: this Option a -> (a -> Boolean) -> Option a
  
               equals :: this Option a -> Option a -> Boolean
  
               equals_ :: this Option a -> (Option a, a -> Boolean) -> Boolean
  
               toArray :: this Option a -> () -> [a]
  
               */
  
              var none = function () {
                  return NONE;
              };
  
              var NONE = (function () {
                  var eq = function (o) {
                      return o.isNone();
                  };
  
                  // inlined from peanut, maybe a micro-optimisation?
                  var call = function (thunk) {
                      return thunk();
                  };
                  var id = function (n) {
                      return n;
                  };
                  var noop = function () {
                  };
  
                  var me = {
                      fold: function (n, s) {
                          return n();
                      },
                      is: never,
                      isSome: never,
                      isNone: always,
                      getOr: id,
                      getOrThunk: call,
                      getOrDie: function (msg) {
                          throw new Error(msg || 'error: getOrDie called on none.');
                      },
                      or: id,
                      orThunk: call,
                      map: none,
                      ap: none,
                      each: noop,
                      bind: none,
                      flatten: none,
                      exists: never,
                      forall: always,
                      filter: none,
                      equals: eq,
                      equals_: eq,
                      toArray: function () {
                          return [];
                      },
                      toString: Fun.constant('none()')
                  };
                  if (Object.freeze) Object.freeze(me);
                  return me;
              })();
  
              /** some :: a -> Option a */
              var some = function (a) {
                  // inlined from peanut, maybe a micro-optimisation?
                  var constant_a = function () {
                      return a;
                  };
  
                  var self = function () {
                      // can't Fun.constant this one
                      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,
                      isNone: never,
                      getOr: constant_a,
                      getOrThunk: constant_a,
                      getOrDie: 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,
                              function (b) {
                                  return elementEq(a, b);
                              }
                          );
                      },
                      toArray: function () {
                          return [a];
                      },
                      toString: function () {
                          return 'some(' + a + ')';
                      }
                  };
                  return me;
              };
  
              /** from :: undefined|null|a -> Option a */
              var from = function (value) {
                  return value === null || value === undefined ? NONE : some(value);
              };
  
              return {
                  some: some,
                  none: none,
                  from: from
              };
          }
      );
  
      defineGlobal('global!String', String);
      define(
          'ephox.katamari.api.Arr',
  
          [
              'ephox.katamari.api.Option',
              'global!Array',
              'global!Error',
              'global!String'
          ],
  
          function (Option, Array, Error, String) {
              // Use the native Array.indexOf if it is available (IE9+) otherwise fall back to manual iteration
              // https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf
              var rawIndexOf = (function () {
                  var pIndexOf = Array.prototype.indexOf;
  
                  var fastIndex = function (xs, x) {
                      return pIndexOf.call(xs, x);
                  };
  
                  var slowIndex = function (xs, x) {
                      return slowIndexOf(xs, x);
                  };
  
                  return pIndexOf === undefined ? slowIndex : fastIndex;
              })();
  
              var indexOf = function (xs, x) {
                  // The rawIndexOf method does not wrap up in an option. This is for performance reasons.
                  var r = rawIndexOf(xs, x);
                  return r === -1 ? Option.none() : Option.some(r);
              };
  
              var contains = function (xs, x) {
                  return rawIndexOf(xs, x) > -1;
              };
  
              // Using findIndex is likely less optimal in Chrome (dynamic return type instead of bool)
              // but if we need that micro-optimisation we can inline it later.
              var exists = function (xs, pred) {
                  return findIndex(xs, pred).isSome();
              };
  
              var range = function (num, f) {
                  var r = [];
                  for (var i = 0; i < num; i++) {
                      r.push(f(i));
                  }
                  return r;
              };
  
              // It's a total micro optimisation, but these do make some difference.
              // Particularly for browsers other than Chrome.
              // - length caching
              // http://jsperf.com/browser-diet-jquery-each-vs-for-loop/69
              // - not using push
              // http://jsperf.com/array-direct-assignment-vs-push/2
  
              var chunk = function (array, size) {
                  var r = [];
                  for (var i = 0; i < array.length; i += size) {
                      var s = array.slice(i, i + size);
                      r.push(s);
                  }
                  return r;
              };
  
              var map = function (xs, f) {
                  // pre-allocating array size when it's guaranteed to be known
                  // http://jsperf.com/push-allocated-vs-dynamic/22
                  var len = xs.length;
                  var r = new Array(len);
                  for (var i = 0; i < len; i++) {
                      var x = xs[i];
                      r[i] = f(x, i, xs);
                  }
                  return r;
              };
  
              // Unwound implementing other functions in terms of each.
              // The code size is roughly the same, and it should allow for better optimisation.
              var each = function (xs, f) {
                  for (var i = 0, len = xs.length; i < len; i++) {
                      var x = xs[i];
                      f(x, i, xs);
                  }
              };
  
              var eachr = function (xs, f) {
                  for (var i = xs.length - 1; i >= 0; i--) {
                      var x = xs[i];
                      f(x, i, xs);
                  }
              };
  
              var partition = function (xs, pred) {
                  var pass = [];
                  var fail = [];
                  for (var i = 0, len = xs.length; i < len; i++) {
                      var x = xs[i];
                      var arr = pred(x, i, xs) ? pass : fail;
                      arr.push(x);
                  }
                  return {pass: pass, fail: fail};
              };
  
              var filter = function (xs, pred) {
                  var r = [];
                  for (var i = 0, len = xs.length; i < len; i++) {
                      var x = xs[i];
                      if (pred(x, i, xs)) {
                          r.push(x);
                      }
                  }
                  return r;
              };
  
              /*
       * Groups an array into contiguous arrays of like elements. Whether an element is like or not depends on f.
       *
       * f is a function that derives a value from an element - e.g. true or false, or a string.
       * Elements are like if this function generates the same value for them (according to ===).
       *
       *
       * Order of the elements is preserved. Arr.flatten() on the result will return the original list, as with Haskell groupBy function.
       *  For a good explanation, see the group function (which is a special case of groupBy)
       *  http://hackage.haskell.org/package/base-4.7.0.0/docs/Data-List.html#v:group
       */
              var groupBy = function (xs, f) {
                  if (xs.length === 0) {
                      return [];
                  } else {
                      var wasType = f(xs[0]); // initial case for matching
                      var r = [];
                      var group = [];
  
                      for (var i = 0, len = xs.length; i < len; i++) {
                          var x = xs[i];
                          var type = f(x);
                          if (type !== wasType) {
                              r.push(group);
                              group = [];
                          }
                          wasType = type;
                          group.push(x);
                      }
                      if (group.length !== 0) {
                          r.push(group);
                      }
                      return r;
                  }
              };
  
              var foldr = function (xs, f, acc) {
                  eachr(xs, function (x) {
                      acc = f(acc, x);
                  });
                  return acc;
              };
  
              var foldl = function (xs, f, acc) {
                  each(xs, function (x) {
                      acc = f(acc, x);
                  });
                  return acc;
              };
  
              var find = function (xs, pred) {
                  for (var i = 0, len = xs.length; i < len; i++) {
                      var x = xs[i];
                      if (pred(x, i, xs)) {
                          return Option.some(x);
                      }
                  }
                  return Option.none();
              };
  
              var findIndex = function (xs, pred) {
                  for (var i = 0, len = xs.length; i < len; i++) {
                      var x = xs[i];
                      if (pred(x, i, xs)) {
                          return Option.some(i);
                      }
                  }
  
                  return Option.none();
              };
  
              var slowIndexOf = function (xs, x) {
                  for (var i = 0, len = xs.length; i < len; ++i) {
                      if (xs[i] === x) {
                          return i;
                      }
                  }
  
                  return -1;
              };
  
              var push = Array.prototype.push;
              var flatten = function (xs) {
                  // Note, this is possible because push supports multiple arguments:
                  // http://jsperf.com/concat-push/6
                  // Note that in the past, concat() would silently work (very slowly) for array-like objects.
                  // With this change it will throw an error.
                  var r = [];
                  for (var i = 0, len = xs.length; i < len; ++i) {
                      // Ensure that each value is an array itself
                      if (!Array.prototype.isPrototypeOf(xs[i])) throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
                      push.apply(r, xs[i]);
                  }
                  return r;
              };
  
              var bind = function (xs, f) {
                  var output = map(xs, f);
                  return flatten(output);
              };
  
              var forall = function (xs, pred) {
                  for (var i = 0, len = xs.length; i < len; ++i) {
                      var x = xs[i];
                      if (pred(x, i, xs) !== true) {
                          return false;
                      }
                  }
                  return true;
              };
  
              var equal = function (a1, a2) {
                  return a1.length === a2.length && forall(a1, function (x, i) {
                      return x === a2[i];
                  });
              };
  
              var slice = Array.prototype.slice;
              var reverse = function (xs) {
                  var r = slice.call(xs, 0);
                  r.reverse();
                  return r;
              };
  
              var difference = function (a1, a2) {
                  return filter(a1, function (x) {
                      return !contains(a2, x);
                  });
              };
  
              var mapToObject = function (xs, f) {
                  var r = {};
                  for (var i = 0, len = xs.length; i < len; i++) {
                      var x = xs[i];
                      r[String(x)] = f(x, i);
                  }
                  return r;
              };
  
              var pure = function (x) {
                  return [x];
              };
  
              var sort = function (xs, comparator) {
                  var copy = slice.call(xs, 0);
                  copy.sort(comparator);
                  return copy;
              };
  
              var head = function (xs) {
                  return xs.length === 0 ? Option.none() : Option.some(xs[0]);
              };
  
              var last = function (xs) {
                  return xs.length === 0 ? Option.none() : Option.some(xs[xs.length - 1]);
              };
  
              return {
                  map: map,
                  each: each,
                  eachr: eachr,
                  partition: partition,
                  filter: filter,
                  groupBy: groupBy,
                  indexOf: indexOf,
                  foldr: foldr,
                  foldl: foldl,
                  find: find,
                  findIndex: findIndex,
                  flatten: flatten,
                  bind: bind,
                  forall: forall,
                  exists: exists,
                  contains: contains,
                  equal: equal,
                  reverse: reverse,
                  chunk: chunk,
                  difference: difference,
                  mapToObject: mapToObject,
                  pure: pure,
                  sort: sort,
                  range: range,
                  head: head,
                  last: last
              };
          }
      );
      define(
          'ephox.sand.api.FileReader',
  
          [
              'ephox.sand.util.Global'
          ],
  
          function (Global) {
              /*
       * IE10 and above per
       * https://developer.mozilla.org/en-US/docs/Web/API/FileReader
       */
              return function () {
                  var f = Global.getOrDie('FileReader');
                  return new f();
              };
          }
      );
      define(
          'ephox.sand.api.XMLHttpRequest',
  
          [
              'ephox.sand.util.Global'
          ],
  
          function (Global) {
              /*
       * IE8 and above per
       * https://developer.mozilla.org/en/docs/XMLHttpRequest
       */
              return function () {
                  var f = Global.getOrDie('XMLHttpRequest');
                  return new f();
              };
          }
      );
      /**
       * Utils.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.core.Utils',
          [
              'ephox.sand.api.FileReader',
              'ephox.sand.api.XMLHttpRequest',
              'tinymce.core.util.Promise',
              'tinymce.core.util.Tools'
          ],
          function (FileReader, XMLHttpRequest, Promise, Tools) {
              var isValue = function (obj) {
                  return obj !== null && obj !== undefined;
              };
  
              var traverse = function (json, path) {
                  var value;
  
                  value = path.reduce(function (result, key) {
                      return isValue(result) ? result[key] : undefined;
                  }, json);
  
                  return isValue(value) ? value : null;
              };
  
              var requestUrlAsBlob = function (url, headers) {
                  return new Promise(function (resolve) {
                      var xhr;
  
                      xhr = new XMLHttpRequest();
  
                      xhr.onreadystatechange = function () {
                          if (xhr.readyState === 4) {
                              resolve({
                                  status: xhr.status,
                                  blob: this.response
                              });
                          }
                      };
  
                      xhr.open('GET', url, true);
  
                      Tools.each(headers, function (value, key) {
                          xhr.setRequestHeader(key, value);
                      });
  
                      xhr.responseType = 'blob';
                      xhr.send();
                  });
              };
  
              var readBlob = function (blob) {
                  return new Promise(function (resolve) {
                      var fr = new FileReader();
  
                      fr.onload = function (e) {
                          var data = e.target;
                          resolve(data.result);
                      };
  
                      fr.readAsText(blob);
                  });
              };
  
              var parseJson = function (text) {
                  var json;
  
                  try {
                      json = JSON.parse(text);
                  } catch (ex) {
                      // Ignore
                  }
  
                  return json;
              };
  
              return {
                  traverse: traverse,
                  readBlob: readBlob,
                  requestUrlAsBlob: requestUrlAsBlob,
                  parseJson: parseJson
              };
          }
      );
  
      define(
          'tinymce.plugins.imagetools.core.Errors',
  
          [
              'ephox.katamari.api.Arr',
              'ephox.katamari.api.Fun',
              'tinymce.core.util.Promise',
              'tinymce.plugins.imagetools.core.Utils'
          ],
  
          function (Arr, Fun, Promise, Utils) {
              var friendlyHttpErrors = [
                  {code: 404, message: 'Could not find Image Proxy'},
                  {code: 403, message: 'Rejected request'},
                  {code: 0, message: 'Incorrect Image Proxy URL'}
              ];
              var friendlyServiceErrors = [
                  {type: 'key_missing', message: 'The request did not include an api key.'},
                  {type: 'key_not_found', message: 'The provided api key could not be found.'},
                  {type: 'domain_not_trusted', message: 'The api key is not valid for the request origins.'}
              ];
  
              var isServiceErrorCode = function (code) {
                  return code === 400 || code === 403 || code === 500;
              };
  
              var getHttpErrorMsg = function (status) {
                  var message = Arr.find(friendlyHttpErrors, function (error) {
                      return status === error.code;
                  }).fold(
                      Fun.constant('Unknown ImageProxy error'),
                      function (error) {
                          return error.message;
                      }
                  );
  
                  return 'ImageProxy HTTP error: ' + message;
              };
  
              var handleHttpError = function (status) {
                  var message = getHttpErrorMsg(status);
  
                  return Promise.reject(message);
              };
  
              var getServiceErrorMsg = function (type) {
                  return Arr.find(friendlyServiceErrors, function (error) {
                      return error.type === type;
                  }).fold(
                      Fun.constant('Unknown service error'),
                      function (error) {
                          return error.message;
                      }
                  );
              };
  
              var getServiceError = function (text) {
                  var serviceError = Utils.parseJson(text);
                  var errorType = Utils.traverse(serviceError, ['error', 'type']);
                  var errorMsg = errorType ? getServiceErrorMsg(errorType) : 'Invalid JSON in service error message';
  
                  return 'ImageProxy Service error: ' + errorMsg;
              };
  
              var handleServiceError = function (status, blob) {
                  return Utils.readBlob(blob).then(function (text) {
                      var serviceError = getServiceError(text);
  
                      return Promise.reject(serviceError);
                  });
              };
  
              var handleServiceErrorResponse = function (status, blob) {
                  return isServiceErrorCode(status) ? handleServiceError(status, blob) : handleHttpError(status);
              };
  
              return {
                  handleServiceErrorResponse: handleServiceErrorResponse,
                  handleHttpError: handleHttpError,
                  getHttpErrorMsg: getHttpErrorMsg,
                  getServiceErrorMsg: getServiceErrorMsg
              };
          }
      );
  
      /**
       * Proxy.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      /**
       * Handles loading images though a proxy for working around cors.
       */
      define(
          'tinymce.plugins.imagetools.core.Proxy',
          [
              'tinymce.core.util.Promise',
              'tinymce.core.util.Tools',
              'tinymce.plugins.imagetools.core.Errors',
              'tinymce.plugins.imagetools.core.Utils'
          ],
          function (Promise, Tools, Errors, Utils) {
              var appendApiKey = function (url, apiKey) {
                  var separator = url.indexOf('?') === -1 ? '?' : '&';
                  if (/[?&]apiKey=/.test(url) || !apiKey) {
                      return url;
                  } else {
                      return url + separator + 'apiKey=' + encodeURIComponent(apiKey);
                  }
              };
  
              var requestServiceBlob = function (url, apiKey) {
                  return Utils.requestUrlAsBlob(appendApiKey(url, apiKey), {
                      'Content-Type': 'application/map;charset=UTF-8',
                      'tiny-api-key': apiKey
                  }).then(function (result) {
                      return result.status < 200 || result.status >= 300 ? Errors.handleServiceErrorResponse(result.status, result.blob) : Promise.resolve(result.blob);
                  });
              };
  
              function requestBlob(url) {
                  return Utils.requestUrlAsBlob(url, {})
                      .then(function (result) {
                          return result.status < 200 || result.status >= 300 ? Errors.handleHttpError(result.status) : Promise.resolve(result.blob);
                      });
              }
  
              var getUrl = function (url, apiKey) {
                  return apiKey ? requestServiceBlob(url, apiKey) : requestBlob(url);
              };
  
              return {
                  getUrl: getUrl
              };
          }
      );
  
      defineGlobal('global!Math', Math);
      defineGlobal('global!setTimeout', setTimeout);
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.dom.DOMUtils',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.dom.DOMUtils');
          }
      );
  
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.ui.Factory',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.ui.Factory');
          }
      );
  
      /**
       * UndoStack.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.core.UndoStack',
          [],
          function () {
              return function () {
                  var data = [], index = -1;
  
                  function add(state) {
                      var removed;
  
                      removed = data.splice(++index);
                      data.push(state);
  
                      return {
                          state: state,
                          removed: removed
                      };
                  }
  
                  function undo() {
                      if (canUndo()) {
                          return data[--index];
                      }
                  }
  
                  function redo() {
                      if (canRedo()) {
                          return data[++index];
                      }
                  }
  
                  function canUndo() {
                      return index > 0;
                  }
  
                  function canRedo() {
                      return index !== -1 && index < data.length - 1;
                  }
  
                  return {
                      data: data,
                      add: add,
                      undo: undo,
                      redo: redo,
                      canUndo: canUndo,
                      canRedo: canRedo
                  };
              };
          }
      );
  
      defineGlobal('global!document', document);
      defineGlobal('global!Image', Image);
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.geom.Rect',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.geom.Rect');
          }
      );
  
      /**
       * LoadImage.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.core.LoadImage',
          [
              'tinymce.core.util.Promise'
          ],
          function (Promise) {
              var loadImage = function (image) {
                  return new Promise(function (resolve) {
                      var loaded = function () {
                          image.removeEventListener('load', loaded);
                          resolve(image);
                      };
  
                      if (image.complete) {
                          resolve(image);
                      } else {
                          image.addEventListener('load', loaded);
                      }
                  });
              };
  
              return {
                  loadImage: loadImage
              };
          }
      );
  
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.dom.DomQuery',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.dom.DomQuery');
          }
      );
  
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.util.Observable',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.util.Observable');
          }
      );
  
      /**
       * ResolveGlobal.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.core.util.VK',
          [
              'global!tinymce.util.Tools.resolve'
          ],
          function (resolve) {
              return resolve('tinymce.util.VK');
          }
      );
  
      /**
       * CropRect.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.ui.CropRect',
          [
              'tinymce.core.dom.DomQuery',
              'tinymce.core.geom.Rect',
              'tinymce.core.ui.Factory',
              'tinymce.core.util.Observable',
              'tinymce.core.util.Tools',
              'tinymce.core.util.VK'
          ],
          function (DomQuery, Rect, Factory, Observable, Tools, VK) {
              var count = 0;
  
              return function (currentRect, viewPortRect, clampRect, containerElm, action) {
                  var instance, handles, dragHelpers, blockers, prefix = 'mce-', id = prefix + 'crid-' + (count++);
  
                  handles = [
                      {name: 'move', xMul: 0, yMul: 0, deltaX: 1, deltaY: 1, deltaW: 0, deltaH: 0, label: 'Crop Mask'},
                      {
                          name: 'nw',
                          xMul: 0,
                          yMul: 0,
                          deltaX: 1,
                          deltaY: 1,
                          deltaW: -1,
                          deltaH: -1,
                          label: 'Top Left Crop Handle'
                      },
                      {
                          name: 'ne',
                          xMul: 1,
                          yMul: 0,
                          deltaX: 0,
                          deltaY: 1,
                          deltaW: 1,
                          deltaH: -1,
                          label: 'Top Right Crop Handle'
                      },
                      {
                          name: 'sw',
                          xMul: 0,
                          yMul: 1,
                          deltaX: 1,
                          deltaY: 0,
                          deltaW: -1,
                          deltaH: 1,
                          label: 'Bottom Left Crop Handle'
                      },
                      {
                          name: 'se',
                          xMul: 1,
                          yMul: 1,
                          deltaX: 0,
                          deltaY: 0,
                          deltaW: 1,
                          deltaH: 1,
                          label: 'Bottom Right Crop Handle'
                      }
                  ];
  
                  blockers = ['top', 'right', 'bottom', 'left'];
  
                  function getAbsoluteRect(outerRect, relativeRect) {
                      return {
                          x: relativeRect.x + outerRect.x,
                          y: relativeRect.y + outerRect.y,
                          w: relativeRect.w,
                          h: relativeRect.h
                      };
                  }
  
                  function getRelativeRect(outerRect, innerRect) {
                      return {
                          x: innerRect.x - outerRect.x,
                          y: innerRect.y - outerRect.y,
                          w: innerRect.w,
                          h: innerRect.h
                      };
                  }
  
                  function getInnerRect() {
                      return getRelativeRect(clampRect, currentRect);
                  }
  
                  function moveRect(handle, startRect, deltaX, deltaY) {
                      var x, y, w, h, rect;
  
                      x = startRect.x;
                      y = startRect.y;
                      w = startRect.w;
                      h = startRect.h;
  
                      x += deltaX * handle.deltaX;
                      y += deltaY * handle.deltaY;
                      w += deltaX * handle.deltaW;
                      h += deltaY * handle.deltaH;
  
                      if (w < 20) {
                          w = 20;
                      }
  
                      if (h < 20) {
                          h = 20;
                      }
  
                      rect = currentRect = Rect.clamp({x: x, y: y, w: w, h: h}, clampRect, handle.name === 'move');
                      rect = getRelativeRect(clampRect, rect);
  
                      instance.fire('updateRect', {rect: rect});
                      setInnerRect(rect);
                  }
  
                  function render() {
                      function createDragHelper(handle) {
                          var startRect;
                          var DragHelper = Factory.get('DragHelper');
  
                          return new DragHelper(id, {
                              document: containerElm.ownerDocument,
                              handle: id + '-' + handle.name,
  
                              start: function () {
                                  startRect = currentRect;
                              },
  
                              drag: function (e) {
                                  moveRect(handle, startRect, e.deltaX, e.deltaY);
                              }
                          });
                      }
  
                      DomQuery(
                          '<div id="' + id + '" class="' + prefix + 'croprect-container"' +
                          ' role="grid" aria-dropeffect="execute">'
                      ).appendTo(containerElm);
  
                      Tools.each(blockers, function (blocker) {
                          DomQuery('#' + id, containerElm).append(
                              '<div id="' + id + '-' + blocker + '"class="' + prefix + 'croprect-block" style="display: none" data-mce-bogus="all">'
                          );
                      });
  
                      Tools.each(handles, function (handle) {
                          DomQuery('#' + id, containerElm).append(
                              '<div id="' + id + '-' + handle.name + '" class="' + prefix +
                              'croprect-handle ' + prefix + 'croprect-handle-' + handle.name + '"' +
                              'style="display: none" data-mce-bogus="all" role="gridcell" tabindex="-1"' +
                              ' aria-label="' + handle.label + '" aria-grabbed="false">'
                          );
                      });
  
                      dragHelpers = Tools.map(handles, createDragHelper);
  
                      repaint(currentRect);
  
                      DomQuery(containerElm).on('focusin focusout', function (e) {
                          DomQuery(e.target).attr('aria-grabbed', e.type === 'focus');
                      });
  
                      DomQuery(containerElm).on('keydown', function (e) {
                          var activeHandle;
  
                          Tools.each(handles, function (handle) {
                              if (e.target.id === id + '-' + handle.name) {
                                  activeHandle = handle;
                                  return false;
                              }
                          });
  
                          function moveAndBlock(evt, handle, startRect, deltaX, deltaY) {
                              evt.stopPropagation();
                              evt.preventDefault();
  
                              moveRect(activeHandle, startRect, deltaX, deltaY);
                          }
  
                          switch (e.keyCode) {
                              case VK.LEFT:
                                  moveAndBlock(e, activeHandle, currentRect, -10, 0);
                                  break;
  
                              case VK.RIGHT:
                                  moveAndBlock(e, activeHandle, currentRect, 10, 0);
                                  break;
  
                              case VK.UP:
                                  moveAndBlock(e, activeHandle, currentRect, 0, -10);
                                  break;
  
                              case VK.DOWN:
                                  moveAndBlock(e, activeHandle, currentRect, 0, 10);
                                  break;
  
                              case VK.ENTER:
                              case VK.SPACEBAR:
                                  e.preventDefault();
                                  action();
                                  break;
                          }
                      });
                  }
  
                  function toggleVisibility(state) {
                      var selectors;
  
                      selectors = Tools.map(handles, function (handle) {
                          return '#' + id + '-' + handle.name;
                      }).concat(Tools.map(blockers, function (blocker) {
                          return '#' + id + '-' + blocker;
                      })).join(',');
  
                      if (state) {
                          DomQuery(selectors, containerElm).show();
                      } else {
                          DomQuery(selectors, containerElm).hide();
                      }
                  }
  
                  function repaint(rect) {
                      function updateElementRect(name, rect) {
                          if (rect.h < 0) {
                              rect.h = 0;
                          }
  
                          if (rect.w < 0) {
                              rect.w = 0;
                          }
  
                          DomQuery('#' + id + '-' + name, containerElm).css({
                              left: rect.x,
                              top: rect.y,
                              width: rect.w,
                              height: rect.h
                          });
                      }
  
                      Tools.each(handles, function (handle) {
                          DomQuery('#' + id + '-' + handle.name, containerElm).css({
                              left: rect.w * handle.xMul + rect.x,
                              top: rect.h * handle.yMul + rect.y
                          });
                      });
  
                      updateElementRect('top', {
                          x: viewPortRect.x,
                          y: viewPortRect.y,
                          w: viewPortRect.w,
                          h: rect.y - viewPortRect.y
                      });
                      updateElementRect('right', {
                          x: rect.x + rect.w,
                          y: rect.y,
                          w: viewPortRect.w - rect.x - rect.w + viewPortRect.x,
                          h: rect.h
                      });
                      updateElementRect('bottom', {
                          x: viewPortRect.x,
                          y: rect.y + rect.h,
                          w: viewPortRect.w,
                          h: viewPortRect.h - rect.y - rect.h + viewPortRect.y
                      });
                      updateElementRect('left', {x: viewPortRect.x, y: rect.y, w: rect.x - viewPortRect.x, h: rect.h});
                      updateElementRect('move', rect);
                  }
  
                  function setRect(rect) {
                      currentRect = rect;
                      repaint(currentRect);
                  }
  
                  function setViewPortRect(rect) {
                      viewPortRect = rect;
                      repaint(currentRect);
                  }
  
                  function setInnerRect(rect) {
                      setRect(getAbsoluteRect(clampRect, rect));
                  }
  
                  function setClampRect(rect) {
                      clampRect = rect;
                      repaint(currentRect);
                  }
  
                  function destroy() {
                      Tools.each(dragHelpers, function (helper) {
                          helper.destroy();
                      });
  
                      dragHelpers = [];
                  }
  
                  render(containerElm);
  
                  instance = Tools.extend({
                      toggleVisibility: toggleVisibility,
                      setClampRect: setClampRect,
                      setRect: setRect,
                      getInnerRect: getInnerRect,
                      setInnerRect: setInnerRect,
                      setViewPortRect: setViewPortRect,
                      destroy: destroy
                  }, Observable);
  
                  return instance;
              };
          }
      );
  
      /**
       * ImagePanel.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.ui.ImagePanel',
          [
              'global!document',
              'global!Image',
              'tinymce.core.geom.Rect',
              'tinymce.core.ui.Factory',
              'tinymce.core.util.Promise',
              'tinymce.core.util.Tools',
              'tinymce.plugins.imagetools.core.LoadImage',
              'tinymce.plugins.imagetools.ui.CropRect'
          ],
          function (document, Image, Rect, Factory, Promise, Tools, LoadImage, CropRect) {
              var create = function (settings) {
                  var Control = Factory.get('Control');
                  var ImagePanel = Control.extend({
                      Defaults: {
                          classes: 'imagepanel'
                      },
  
                      selection: function (rect) {
                          if (arguments.length) {
                              this.state.set('rect', rect);
                              return this;
                          }
  
                          return this.state.get('rect');
                      },
  
                      imageSize: function () {
                          var viewRect = this.state.get('viewRect');
  
                          return {
                              w: viewRect.w,
                              h: viewRect.h
                          };
                      },
  
                      toggleCropRect: function (state) {
                          this.state.set('cropEnabled', state);
                      },
  
                      imageSrc: function (url) {
                          var self = this, img = new Image();
  
                          img.src = url;
  
                          LoadImage.loadImage(img).then(function () {
                              var rect, $img, lastRect = self.state.get('viewRect');
  
                              $img = self.$el.find('img');
                              if ($img[0]) {
                                  $img.replaceWith(img);
                              } else {
                                  var bg = document.createElement('div');
                                  bg.className = 'mce-imagepanel-bg';
                                  self.getEl().appendChild(bg);
                                  self.getEl().appendChild(img);
                              }
  
                              rect = {x: 0, y: 0, w: img.naturalWidth, h: img.naturalHeight};
                              self.state.set('viewRect', rect);
                              self.state.set('rect', Rect.inflate(rect, -20, -20));
  
                              if (!lastRect || lastRect.w !== rect.w || lastRect.h !== rect.h) {
                                  self.zoomFit();
                              }
  
                              self.repaintImage();
                              self.fire('load');
                          });
                      },
  
                      zoom: function (value) {
                          if (arguments.length) {
                              this.state.set('zoom', value);
                              return this;
                          }
  
                          return this.state.get('zoom');
                      },
  
                      postRender: function () {
                          this.imageSrc(this.settings.imageSrc);
                          return this._super();
                      },
  
                      zoomFit: function () {
                          var self = this, $img, pw, ph, w, h, zoom, padding;
  
                          padding = 10;
                          $img = self.$el.find('img');
                          pw = self.getEl().clientWidth;
                          ph = self.getEl().clientHeight;
                          w = $img[0].naturalWidth;
                          h = $img[0].naturalHeight;
                          zoom = Math.min((pw - padding) / w, (ph - padding) / h);
  
                          if (zoom >= 1) {
                              zoom = 1;
                          }
  
                          self.zoom(zoom);
                      },
  
                      repaintImage: function () {
                          var x, y, w, h, pw, ph, $img, $bg, zoom, rect, elm;
  
                          elm = this.getEl();
                          zoom = this.zoom();
                          rect = this.state.get('rect');
                          $img = this.$el.find('img');
                          $bg = this.$el.find('.mce-imagepanel-bg');
                          pw = elm.offsetWidth;
                          ph = elm.offsetHeight;
                          w = $img[0].naturalWidth * zoom;
                          h = $img[0].naturalHeight * zoom;
                          x = Math.max(0, pw / 2 - w / 2);
                          y = Math.max(0, ph / 2 - h / 2);
  
                          $img.css({
                              left: x,
                              top: y,
                              width: w,
                              height: h
                          });
  
                          $bg.css({
                              left: x,
                              top: y,
                              width: w,
                              height: h
                          });
  
                          if (this.cropRect) {
                              this.cropRect.setRect({
                                  x: rect.x * zoom + x,
                                  y: rect.y * zoom + y,
                                  w: rect.w * zoom,
                                  h: rect.h * zoom
                              });
  
                              this.cropRect.setClampRect({
                                  x: x,
                                  y: y,
                                  w: w,
                                  h: h
                              });
  
                              this.cropRect.setViewPortRect({
                                  x: 0,
                                  y: 0,
                                  w: pw,
                                  h: ph
                              });
                          }
                      },
  
                      bindStates: function () {
                          var self = this;
  
                          function setupCropRect(rect) {
                              self.cropRect = new CropRect(
                                  rect,
                                  self.state.get('viewRect'),
                                  self.state.get('viewRect'),
                                  self.getEl(),
                                  function () {
                                      self.fire('crop');
                                  }
                              );
  
                              self.cropRect.on('updateRect', function (e) {
                                  var rect = e.rect, zoom = self.zoom();
  
                                  rect = {
                                      x: Math.round(rect.x / zoom),
                                      y: Math.round(rect.y / zoom),
                                      w: Math.round(rect.w / zoom),
                                      h: Math.round(rect.h / zoom)
                                  };
  
                                  self.state.set('rect', rect);
                              });
  
                              self.on('remove', self.cropRect.destroy);
                          }
  
                          self.state.on('change:cropEnabled', function (e) {
                              self.cropRect.toggleVisibility(e.value);
                              self.repaintImage();
                          });
  
                          self.state.on('change:zoom', function () {
                              self.repaintImage();
                          });
  
                          self.state.on('change:rect', function (e) {
                              var rect = e.value;
  
                              if (!self.cropRect) {
                                  setupCropRect(rect);
                              }
  
                              self.cropRect.setRect(rect);
                          });
                      }
                  });
  
                  return new ImagePanel(settings);
              };
  
              return {
                  create: create
              };
          }
      );
  
      /**
       * Dialog.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.ui.Dialog',
          [
              'ephox.imagetools.api.BlobConversions',
              'ephox.imagetools.api.ImageTransformations',
              'ephox.sand.api.URL',
              'global!Math',
              'global!setTimeout',
              'tinymce.core.dom.DOMUtils',
              'tinymce.core.ui.Factory',
              'tinymce.core.util.Promise',
              'tinymce.core.util.Tools',
              'tinymce.plugins.imagetools.core.UndoStack',
              'tinymce.plugins.imagetools.ui.ImagePanel'
          ],
          function (BlobConversions, ImageTransformations, URL, Math, setTimeout, DOMUtils, Factory, Promise, Tools, UndoStack, ImagePanel) {
              function createState(blob) {
                  return {
                      blob: blob,
                      url: URL.createObjectURL(blob)
                  };
              }
  
              function destroyState(state) {
                  if (state) {
                      URL.revokeObjectURL(state.url);
                  }
              }
  
              function destroyStates(states) {
                  Tools.each(states, destroyState);
              }
  
              function open(editor, currentState, resolve, reject) {
                  var win, undoStack = new UndoStack(), mainPanel, filtersPanel, tempState,
                      cropPanel, resizePanel, flipRotatePanel, imagePanel, sidePanel, mainViewContainer,
                      invertPanel, brightnessPanel, huePanel, saturatePanel, contrastPanel, grayscalePanel,
                      sepiaPanel, colorizePanel, sharpenPanel, embossPanel, gammaPanel, exposurePanel, panels,
                      width, height, ratioW, ratioH;
  
                  function recalcSize(e) {
                      var widthCtrl, heightCtrl, newWidth, newHeight;
  
                      widthCtrl = win.find('#w')[0];
                      heightCtrl = win.find('#h')[0];
  
                      newWidth = parseInt(widthCtrl.value(), 10);
                      newHeight = parseInt(heightCtrl.value(), 10);
  
                      if (win.find('#constrain')[0].checked() && width && height && newWidth && newHeight) {
                          if (e.control.settings.name === 'w') {
                              newHeight = Math.round(newWidth * ratioW);
                              heightCtrl.value(newHeight);
                          } else {
                              newWidth = Math.round(newHeight * ratioH);
                              widthCtrl.value(newWidth);
                          }
                      }
  
                      width = newWidth;
                      height = newHeight;
                  }
  
                  function floatToPercent(value) {
                      return Math.round(value * 100) + '%';
                  }
  
                  function updateButtonUndoStates() {
                      win.find('#undo').disabled(!undoStack.canUndo());
                      win.find('#redo').disabled(!undoStack.canRedo());
                      win.statusbar.find('#save').disabled(!undoStack.canUndo());
                  }
  
                  function disableUndoRedo() {
                      win.find('#undo').disabled(true);
                      win.find('#redo').disabled(true);
                  }
  
                  function displayState(state) {
                      if (state) {
                          imagePanel.imageSrc(state.url);
                      }
                  }
  
                  function switchPanel(targetPanel) {
                      return function () {
                          var hidePanels = Tools.grep(panels, function (panel) {
                              return panel.settings.name !== targetPanel;
                          });
  
                          Tools.each(hidePanels, function (panel) {
                              panel.hide();
                          });
  
                          targetPanel.show();
                          targetPanel.focus();
                      };
                  }
  
                  function addTempState(blob) {
                      tempState = createState(blob);
                      displayState(tempState);
                  }
  
                  function addBlobState(blob) {
                      currentState = createState(blob);
                      displayState(currentState);
                      destroyStates(undoStack.add(currentState).removed);
                      updateButtonUndoStates();
                  }
  
                  function crop() {
                      var rect = imagePanel.selection();
  
                      BlobConversions.blobToImageResult(currentState.blob)
                          .then(function (ir) {
                              ImageTransformations.crop(ir, rect.x, rect.y, rect.w, rect.h)
                                  .then(imageResultToBlob)
                                  .then(function (blob) {
                                      addBlobState(blob);
                                      cancel();
                                  });
                          });
                  }
  
                  function tempAction(fn) {
                      var args = [].slice.call(arguments, 1);
  
                      return function () {
                          var state = tempState || currentState;
  
                          BlobConversions.blobToImageResult(state.blob)
                              .then(function (ir) {
                                  fn.apply(this, [ir].concat(args)).then(imageResultToBlob).then(addTempState);
                              });
                      };
                  }
  
                  function action(fn) {
                      var args = [].slice.call(arguments, 1);
  
                      return function () {
                          BlobConversions.blobToImageResult(currentState.blob)
                              .then(function (ir) {
                                  fn.apply(this, [ir].concat(args)).then(imageResultToBlob).then(addBlobState);
                              });
                      };
                  }
  
                  function cancel() {
                      displayState(currentState);
                      destroyState(tempState);
                      switchPanel(mainPanel)();
                      updateButtonUndoStates();
                  }
  
                  function waitForTempState(times, applyCall) {
                      if (tempState) {
                          applyCall();
                      } else {
                          setTimeout(function () {
                              if (times-- > 0) {
                                  waitForTempState(times, applyCall);
                              } else {
                                  editor.windowManager.alert('Error: failed to apply image operation.');
                              }
                          }, 10);
                      }
                  }
  
                  function applyTempState() {
                      if (tempState) {
                          addBlobState(tempState.blob);
                          cancel();
                      } else {
                          waitForTempState(100, applyTempState);
                      }
                  }
  
                  function zoomIn() {
                      var zoom = imagePanel.zoom();
  
                      if (zoom < 2) {
                          zoom += 0.1;
                      }
  
                      imagePanel.zoom(zoom);
                  }
  
                  function zoomOut() {
                      var zoom = imagePanel.zoom();
  
                      if (zoom > 0.1) {
                          zoom -= 0.1;
                      }
  
                      imagePanel.zoom(zoom);
                  }
  
                  function undo() {
                      currentState = undoStack.undo();
                      displayState(currentState);
                      updateButtonUndoStates();
                  }
  
                  function redo() {
                      currentState = undoStack.redo();
                      displayState(currentState);
                      updateButtonUndoStates();
                  }
  
                  function save() {
                      resolve(currentState.blob);
                      win.close();
                  }
  
                  function createPanel(items) {
                      return Factory.create('Form', {
                          layout: 'flex',
                          direction: 'row',
                          labelGap: 5,
                          border: '0 0 1 0',
                          align: 'center',
                          pack: 'center',
                          padding: '0 10 0 10',
                          spacing: 5,
                          flex: 0,
                          minHeight: 60,
                          defaults: {
                              classes: 'imagetool',
                              type: 'button'
                          },
                          items: items
                      });
                  }
  
                  var imageResultToBlob = function (ir) {
                      return ir.toBlob();
                  };
  
                  function createFilterPanel(title, filter) {
                      return createPanel([
                          {text: 'Back', onclick: cancel},
                          {type: 'spacer', flex: 1},
                          {text: 'Apply', subtype: 'primary', onclick: applyTempState}
                      ]).hide().on('show', function () {
                          disableUndoRedo();
  
                          BlobConversions.blobToImageResult(currentState.blob)
                              .then(function (ir) {
                                  return filter(ir);
                              })
                              .then(imageResultToBlob)
                              .then(function (blob) {
                                  var newTempState = createState(blob);
  
                                  displayState(newTempState);
                                  destroyState(tempState);
                                  tempState = newTempState;
                              });
                      });
                  }
  
                  function createVariableFilterPanel(title, filter, value, min, max) {
                      function update(value) {
                          BlobConversions.blobToImageResult(currentState.blob)
                              .then(function (ir) {
                                  return filter(ir, value);
                              })
                              .then(imageResultToBlob)
                              .then(function (blob) {
                                  var newTempState = createState(blob);
                                  displayState(newTempState);
                                  destroyState(tempState);
                                  tempState = newTempState;
                              });
                      }
  
                      return createPanel([
                          {text: 'Back', onclick: cancel},
                          {type: 'spacer', flex: 1},
                          {
                              type: 'slider',
                              flex: 1,
                              ondragend: function (e) {
                                  update(e.value);
                              },
                              minValue: min,
                              maxValue: max,
                              value: value,
                              previewFilter: floatToPercent
                          },
                          {type: 'spacer', flex: 1},
                          {text: 'Apply', subtype: 'primary', onclick: applyTempState}
                      ]).hide().on('show', function () {
                          this.find('slider').value(value);
                          disableUndoRedo();
                      });
                  }
  
                  function createRgbFilterPanel(title, filter) {
                      function update() {
                          var r, g, b;
  
                          r = win.find('#r')[0].value();
                          g = win.find('#g')[0].value();
                          b = win.find('#b')[0].value();
  
                          BlobConversions.blobToImageResult(currentState.blob)
                              .then(function (ir) {
                                  return filter(ir, r, g, b);
                              })
                              .then(imageResultToBlob)
                              .then(function (blob) {
                                  var newTempState = createState(blob);
                                  displayState(newTempState);
                                  destroyState(tempState);
                                  tempState = newTempState;
                              });
                      }
  
                      return createPanel([
                          {text: 'Back', onclick: cancel},
                          {type: 'spacer', flex: 1},
                          {
                              type: 'slider',
                              label: 'R',
                              name: 'r',
                              minValue: 0,
                              value: 1,
                              maxValue: 2,
                              ondragend: update,
                              previewFilter: floatToPercent
                          },
                          {
                              type: 'slider',
                              label: 'G',
                              name: 'g',
                              minValue: 0,
                              value: 1,
                              maxValue: 2,
                              ondragend: update,
                              previewFilter: floatToPercent
                          },
                          {
                              type: 'slider',
                              label: 'B',
                              name: 'b',
                              minValue: 0,
                              value: 1,
                              maxValue: 2,
                              ondragend: update,
                              previewFilter: floatToPercent
                          },
                          {type: 'spacer', flex: 1},
                          {text: 'Apply', subtype: 'primary', onclick: applyTempState}
                      ]).hide().on('show', function () {
                          win.find('#r,#g,#b').value(1);
                          disableUndoRedo();
                      });
                  }
  
                  cropPanel = createPanel([
                      {text: 'Back', onclick: cancel},
                      {type: 'spacer', flex: 1},
                      {text: 'Apply', subtype: 'primary', onclick: crop}
                  ]).hide().on('show hide', function (e) {
                      imagePanel.toggleCropRect(e.type === 'show');
                  }).on('show', disableUndoRedo);
  
                  function toggleConstrain(e) {
                      if (e.control.value() === true) {
                          ratioW = height / width;
                          ratioH = width / height;
                      }
                  }
  
                  resizePanel = createPanel([
                      {text: 'Back', onclick: cancel},
                      {type: 'spacer', flex: 1},
                      {type: 'textbox', name: 'w', label: 'Width', size: 4, onkeyup: recalcSize},
                      {type: 'textbox', name: 'h', label: 'Height', size: 4, onkeyup: recalcSize},
                      {
                          type: 'checkbox',
                          name: 'constrain',
                          text: 'Constrain proportions',
                          checked: true,
                          onchange: toggleConstrain
                      },
                      {type: 'spacer', flex: 1},
                      {text: 'Apply', subtype: 'primary', onclick: 'submit'}
                  ]).hide().on('submit', function (e) {
                      var width = parseInt(win.find('#w').value(), 10),
                          height = parseInt(win.find('#h').value(), 10);
  
                      e.preventDefault();
  
                      action(ImageTransformations.resize, width, height)();
                      cancel();
                  }).on('show', disableUndoRedo);
  
                  flipRotatePanel = createPanel([
                      {text: 'Back', onclick: cancel},
                      {type: 'spacer', flex: 1},
                      {icon: 'fliph', tooltip: 'Flip horizontally', onclick: tempAction(ImageTransformations.flip, 'h')},
                      {icon: 'flipv', tooltip: 'Flip vertically', onclick: tempAction(ImageTransformations.flip, 'v')},
                      {
                          icon: 'rotateleft',
                          tooltip: 'Rotate counterclockwise',
                          onclick: tempAction(ImageTransformations.rotate, -90)
                      },
                      {
                          icon: 'rotateright',
                          tooltip: 'Rotate clockwise',
                          onclick: tempAction(ImageTransformations.rotate, 90)
                      },
                      {type: 'spacer', flex: 1},
                      {text: 'Apply', subtype: 'primary', onclick: applyTempState}
                  ]).hide().on('show', disableUndoRedo);
  
                  invertPanel = createFilterPanel('Invert', ImageTransformations.invert);
                  sharpenPanel = createFilterPanel('Sharpen', ImageTransformations.sharpen);
                  embossPanel = createFilterPanel('Emboss', ImageTransformations.emboss);
  
                  brightnessPanel = createVariableFilterPanel('Brightness', ImageTransformations.brightness, 0, -1, 1);
                  huePanel = createVariableFilterPanel('Hue', ImageTransformations.hue, 180, 0, 360);
                  saturatePanel = createVariableFilterPanel('Saturate', ImageTransformations.saturate, 0, -1, 1);
                  contrastPanel = createVariableFilterPanel('Contrast', ImageTransformations.contrast, 0, -1, 1);
                  grayscalePanel = createVariableFilterPanel('Grayscale', ImageTransformations.grayscale, 0, 0, 1);
                  sepiaPanel = createVariableFilterPanel('Sepia', ImageTransformations.sepia, 0, 0, 1);
                  colorizePanel = createRgbFilterPanel('Colorize', ImageTransformations.colorize);
                  gammaPanel = createVariableFilterPanel('Gamma', ImageTransformations.gamma, 0, -1, 1);
                  exposurePanel = createVariableFilterPanel('Exposure', ImageTransformations.exposure, 1, 0, 2);
  
                  filtersPanel = createPanel([
                      {text: 'Back', onclick: cancel},
                      {type: 'spacer', flex: 1},
                      {text: 'hue', icon: 'hue', onclick: switchPanel(huePanel)},
                      {text: 'saturate', icon: 'saturate', onclick: switchPanel(saturatePanel)},
                      {text: 'sepia', icon: 'sepia', onclick: switchPanel(sepiaPanel)},
                      {text: 'emboss', icon: 'emboss', onclick: switchPanel(embossPanel)},
                      {text: 'exposure', icon: 'exposure', onclick: switchPanel(exposurePanel)},
                      {type: 'spacer', flex: 1}
                  ]).hide();
  
                  mainPanel = createPanel([
                      {tooltip: 'Crop', icon: 'crop', onclick: switchPanel(cropPanel)},
                      {tooltip: 'Resize', icon: 'resize2', onclick: switchPanel(resizePanel)},
                      {tooltip: 'Orientation', icon: 'orientation', onclick: switchPanel(flipRotatePanel)},
                      {tooltip: 'Brightness', icon: 'sun', onclick: switchPanel(brightnessPanel)},
                      {tooltip: 'Sharpen', icon: 'sharpen', onclick: switchPanel(sharpenPanel)},
                      {tooltip: 'Contrast', icon: 'contrast', onclick: switchPanel(contrastPanel)},
                      {tooltip: 'Color levels', icon: 'drop', onclick: switchPanel(colorizePanel)},
                      {tooltip: 'Gamma', icon: 'gamma', onclick: switchPanel(gammaPanel)},
                      {tooltip: 'Invert', icon: 'invert', onclick: switchPanel(invertPanel)}
                      // {text: 'More', onclick: switchPanel(filtersPanel)}
                  ]);
  
                  imagePanel = ImagePanel.create({
                      flex: 1,
                      imageSrc: currentState.url
                  });
  
                  sidePanel = Factory.create('Container', {
                      layout: 'flex',
                      direction: 'column',
                      border: '0 1 0 0',
                      padding: 5,
                      spacing: 5,
                      items: [
                          {type: 'button', icon: 'undo', tooltip: 'Undo', name: 'undo', onclick: undo},
                          {type: 'button', icon: 'redo', tooltip: 'Redo', name: 'redo', onclick: redo},
                          {type: 'button', icon: 'zoomin', tooltip: 'Zoom in', onclick: zoomIn},
                          {type: 'button', icon: 'zoomout', tooltip: 'Zoom out', onclick: zoomOut}
                      ]
                  });
  
                  mainViewContainer = Factory.create('Container', {
                      type: 'container',
                      layout: 'flex',
                      direction: 'row',
                      align: 'stretch',
                      flex: 1,
                      items: [sidePanel, imagePanel]
                  });
  
                  panels = [
                      mainPanel,
                      cropPanel,
                      resizePanel,
                      flipRotatePanel,
                      filtersPanel,
                      invertPanel,
                      brightnessPanel,
                      huePanel,
                      saturatePanel,
                      contrastPanel,
                      grayscalePanel,
                      sepiaPanel,
                      colorizePanel,
                      sharpenPanel,
                      embossPanel,
                      gammaPanel,
                      exposurePanel
                  ];
  
                  win = editor.windowManager.open({
                      layout: 'flex',
                      direction: 'column',
                      align: 'stretch',
                      minWidth: Math.min(DOMUtils.DOM.getViewPort().w, 800),
                      minHeight: Math.min(DOMUtils.DOM.getViewPort().h, 650),
                      title: 'Edit image',
                      items: panels.concat([mainViewContainer]),
                      buttons: [
                          {text: 'Save', name: 'save', subtype: 'primary', onclick: save},
                          {text: 'Cancel', onclick: 'close'}
                      ]
                  });
  
                  win.on('close', function () {
                      reject();
                      destroyStates(undoStack.data);
                      undoStack = null;
                      tempState = null;
                  });
  
                  undoStack.add(currentState);
                  updateButtonUndoStates();
  
                  imagePanel.on('load', function () {
                      width = imagePanel.imageSize().w;
                      height = imagePanel.imageSize().h;
                      ratioW = height / width;
                      ratioH = width / height;
  
                      win.find('#w').value(width);
                      win.find('#h').value(height);
                  });
  
                  imagePanel.on('crop', crop);
              }
  
              function edit(editor, imageResult) {
                  return new Promise(function (resolve, reject) {
                      return imageResult.toBlob().then(function (blob) {
                          open(editor, createState(blob), resolve, reject);
                      });
                  });
              }
  
              // edit('img/dogleft.jpg');
  
              return {
                  edit: edit
              };
          }
      );
  
      /**
       * Actions.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.core.Actions',
          [
              'ephox.imagetools.api.BlobConversions',
              'ephox.imagetools.api.ImageTransformations',
              'ephox.katamari.api.Fun',
              'ephox.sand.api.URL',
              'global!clearTimeout',
              'tinymce.core.util.Delay',
              'tinymce.core.util.Promise',
              'tinymce.core.util.Tools',
              'tinymce.core.util.URI',
              'tinymce.plugins.imagetools.api.Settings',
              'tinymce.plugins.imagetools.core.ImageSize',
              'tinymce.plugins.imagetools.core.Proxy',
              'tinymce.plugins.imagetools.ui.Dialog'
          ],
          function (BlobConversions, ImageTransformations, Fun, URL, clearTimeout, Delay, Promise, Tools, URI, Settings, ImageSize, Proxy, Dialog) {
              var count = 0;
  
              var isEditableImage = function (editor, img) {
                  var selectorMatched = editor.dom.is(img, 'img:not([data-mce-object],[data-mce-placeholder])');
  
                  return selectorMatched && (isLocalImage(editor, img) || isCorsImage(editor, img) || editor.settings.imagetools_proxy);
              };
  
              var displayError = function (editor, error) {
                  editor.notificationManager.open({
                      text: error,
                      type: 'error'
                  });
              };
  
              var getSelectedImage = function (editor) {
                  return editor.selection.getNode();
              };
  
              var extractFilename = function (editor, url) {
                  var m = url.match(/\/([^\/\?]+)?\.(?:jpeg|jpg|png|gif)(?:\?|$)/i);
                  if (m) {
                      return editor.dom.encode(m[1]);
                  }
                  return null;
              };
  
              var createId = function () {
                  return 'imagetools' + count++;
              };
  
              var isLocalImage = function (editor, img) {
                  var url = img.src;
  
                  return url.indexOf('data:') === 0 || url.indexOf('blob:') === 0 || new URI(url).host === editor.documentBaseURI.host;
              };
  
              var isCorsImage = function (editor, img) {
                  return Tools.inArray(editor.settings.imagetools_cors_hosts, new URI(img.src).host) !== -1;
              };
  
              var getApiKey = function (editor) {
                  return editor.settings.api_key || editor.settings.imagetools_api_key;
              };
  
              var imageToBlob = function (editor, img) {
                  var src = img.src, apiKey;
  
                  if (isCorsImage(editor, img)) {
                      return Proxy.getUrl(img.src, null);
                  }
  
                  if (!isLocalImage(editor, img)) {
                      src = Settings.getProxyUrl(editor);
                      src += (src.indexOf('?') === -1 ? '?' : '&') + 'url=' + encodeURIComponent(img.src);
                      apiKey = getApiKey(editor);
                      return Proxy.getUrl(src, apiKey);
                  }
  
                  return BlobConversions.imageToBlob(img);
              };
  
              var findSelectedBlob = function (editor) {
                  var blobInfo;
                  blobInfo = editor.editorUpload.blobCache.getByUri(getSelectedImage(editor).src);
                  if (blobInfo) {
                      return Promise.resolve(blobInfo.blob());
                  }
  
                  return imageToBlob(editor, getSelectedImage(editor));
              };
  
              var startTimedUpload = function (editor, imageUploadTimerState) {
                  var imageUploadTimer = Delay.setEditorTimeout(editor, function () {
                      editor.editorUpload.uploadImagesAuto();
                  }, editor.settings.images_upload_timeout || 30000);
  
                  imageUploadTimerState.set(imageUploadTimer);
              };
  
              var cancelTimedUpload = function (imageUploadTimerState) {
                  clearTimeout(imageUploadTimerState.get());
              };
  
              var updateSelectedImage = function (editor, ir, uploadImmediately, imageUploadTimerState) {
                  return ir.toBlob().then(function (blob) {
                      var uri, name, blobCache, blobInfo, selectedImage;
  
                      blobCache = editor.editorUpload.blobCache;
                      selectedImage = getSelectedImage(editor);
                      uri = selectedImage.src;
  
                      if (editor.settings.images_reuse_filename) {
                          blobInfo = blobCache.getByUri(uri);
                          if (blobInfo) {
                              uri = blobInfo.uri();
                              name = blobInfo.name();
                          } else {
                              name = extractFilename(editor, uri);
                          }
                      }
  
                      blobInfo = blobCache.create({
                          id: createId(),
                          blob: blob,
                          base64: ir.toBase64(),
                          uri: uri,
                          name: name
                      });
  
                      blobCache.add(blobInfo);
  
                      editor.undoManager.transact(function () {
                          function imageLoadedHandler() {
                              editor.$(selectedImage).off('load', imageLoadedHandler);
                              editor.nodeChanged();
  
                              if (uploadImmediately) {
                                  editor.editorUpload.uploadImagesAuto();
                              } else {
                                  cancelTimedUpload(imageUploadTimerState);
                                  startTimedUpload(editor, imageUploadTimerState);
                              }
                          }
  
                          editor.$(selectedImage).on('load', imageLoadedHandler);
  
                          editor.$(selectedImage).attr({
                              src: blobInfo.blobUri()
                          }).removeAttr('data-mce-src');
                      });
  
                      return blobInfo;
                  });
              };
  
              var selectedImageOperation = function (editor, imageUploadTimerState, fn) {
                  return function () {
                      return editor._scanForImages()
                          .then(Fun.curry(findSelectedBlob, editor))
                          .then(BlobConversions.blobToImageResult)
                          .then(fn)
                          .then(function (imageResult) {
                              return updateSelectedImage(editor, imageResult, false, imageUploadTimerState);
                          }, function (error) {
                              displayError(editor, error);
                          });
                  };
              };
  
              var rotate = function (editor, imageUploadTimerState, angle) {
                  return function () {
                      return selectedImageOperation(editor, imageUploadTimerState, function (imageResult) {
                          var size = ImageSize.getImageSize(getSelectedImage(editor));
  
                          if (size) {
                              ImageSize.setImageSize(getSelectedImage(editor), {
                                  w: size.h,
                                  h: size.w
                              });
                          }
  
                          return ImageTransformations.rotate(imageResult, angle);
                      })();
                  };
              };
  
              var flip = function (editor, imageUploadTimerState, axis) {
                  return function () {
                      return selectedImageOperation(editor, imageUploadTimerState, function (imageResult) {
                          return ImageTransformations.flip(imageResult, axis);
                      })();
                  };
              };
  
              var editImageDialog = function (editor, imageUploadTimerState) {
                  return function () {
                      var img = getSelectedImage(editor), originalSize = ImageSize.getNaturalImageSize(img);
  
                      var handleDialogBlob = function (blob) {
                          return new Promise(function (resolve) {
                              BlobConversions.blobToImage(blob)
                                  .then(function (newImage) {
                                      var newSize = ImageSize.getNaturalImageSize(newImage);
  
                                      if (originalSize.w !== newSize.w || originalSize.h !== newSize.h) {
                                          if (ImageSize.getImageSize(img)) {
                                              ImageSize.setImageSize(img, newSize);
                                          }
                                      }
  
                                      URL.revokeObjectURL(newImage.src);
                                      resolve(blob);
                                  });
                          });
                      };
  
                      var openDialog = function (editor, imageResult) {
                          return Dialog.edit(editor, imageResult).then(handleDialogBlob)
                              .then(BlobConversions.blobToImageResult)
                              .then(function (imageResult) {
                                  return updateSelectedImage(editor, imageResult, true, imageUploadTimerState);
                              }, function () {
                                  // Close dialog
                              });
                      };
  
                      findSelectedBlob(editor)
                          .then(BlobConversions.blobToImageResult)
                          .then(Fun.curry(openDialog, editor), function (error) {
                              displayError(editor, error);
                          });
                  };
              };
  
              return {
                  rotate: rotate,
                  flip: flip,
                  editImageDialog: editImageDialog,
                  isEditableImage: isEditableImage,
                  cancelTimedUpload: cancelTimedUpload
              };
          }
      );
  
      /**
       * Commands.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.api.Commands',
          [
              'tinymce.core.util.Tools',
              'tinymce.plugins.imagetools.core.Actions'
          ],
          function (Tools, Actions) {
              var register = function (editor, imageUploadTimerState) {
                  Tools.each({
                      mceImageRotateLeft: Actions.rotate(editor, imageUploadTimerState, -90),
                      mceImageRotateRight: Actions.rotate(editor, imageUploadTimerState, 90),
                      mceImageFlipVertical: Actions.flip(editor, imageUploadTimerState, 'v'),
                      mceImageFlipHorizontal: Actions.flip(editor, imageUploadTimerState, 'h'),
                      mceEditImage: Actions.editImageDialog(editor, imageUploadTimerState)
                  }, function (fn, cmd) {
                      editor.addCommand(cmd, fn);
                  });
              };
  
              return {
                  register: register
              };
          }
      );
  
      /**
       * Plugin.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.core.UploadSelectedImage',
          [
              'tinymce.plugins.imagetools.core.Actions'
          ],
          function (Actions) {
              var setup = function (editor, imageUploadTimerState, lastSelectedImageState) {
                  editor.on('NodeChange', function (e) {
                      var lastSelectedImage = lastSelectedImageState.get();
  
                      // If the last node we selected was an image
                      // And had a source that doesn't match the current blob url
                      // We need to attempt to upload it
                      if (lastSelectedImage && lastSelectedImage.src !== e.element.src) {
                          Actions.cancelTimedUpload(imageUploadTimerState);
                          editor.editorUpload.uploadImagesAuto();
                          lastSelectedImageState.set(null);
                      }
  
                      // Set up the lastSelectedImage
                      if (Actions.isEditableImage(editor, e.element)) {
                          lastSelectedImageState.set(e.element);
                      }
                  });
              };
  
              return {
                  setup: setup
              };
          }
      );
  
      /**
       * Buttons.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.ui.Buttons',
          [],
          function () {
              var register = function (editor) {
                  editor.addButton('rotateleft', {
                      title: 'Rotate counterclockwise',
                      cmd: 'mceImageRotateLeft'
                  });
  
                  editor.addButton('rotateright', {
                      title: 'Rotate clockwise',
                      cmd: 'mceImageRotateRight'
                  });
  
                  editor.addButton('flipv', {
                      title: 'Flip vertically',
                      cmd: 'mceImageFlipVertical'
                  });
  
                  editor.addButton('fliph', {
                      title: 'Flip horizontally',
                      cmd: 'mceImageFlipHorizontal'
                  });
  
                  editor.addButton('editimage', {
                      title: 'Edit image',
                      cmd: 'mceEditImage'
                  });
  
                  editor.addButton('imageoptions', {
                      title: 'Image options',
                      icon: 'options',
                      cmd: 'mceImage'
                  });
              };
  
              return {
                  register: register
              };
          }
      );
  
      /**
       * ContextToolbar.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.ui.ContextToolbar',
          [
              'ephox.katamari.api.Fun',
              'tinymce.plugins.imagetools.api.Settings',
              'tinymce.plugins.imagetools.core.Actions'
          ],
          function (Fun, Settings, Actions) {
              var register = function (editor) {
                  editor.addContextToolbar(
                      Fun.curry(Actions.isEditableImage, editor),
                      Settings.getToolbarItems(editor)
                  );
              };
  
              return {
                  register: register
              };
          }
      );
  
      /**
       * Plugin.js
       *
       * Released under LGPL License.
       * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
       *
       * License: http://www.tinymce.com/license
       * Contributing: http://www.tinymce.com/contributing
       */
  
      define(
          'tinymce.plugins.imagetools.Plugin',
          [
              'ephox.katamari.api.Cell',
              'tinymce.core.PluginManager',
              'tinymce.plugins.imagetools.api.Commands',
              'tinymce.plugins.imagetools.core.UploadSelectedImage',
              'tinymce.plugins.imagetools.ui.Buttons',
              'tinymce.plugins.imagetools.ui.ContextToolbar'
          ],
          function (Cell, PluginManager, Commands, UploadSelectedImage, Buttons, ContextToolbar) {
              PluginManager.add('imagetools', function (editor) {
                  var imageUploadTimerState = Cell(0);
                  var lastSelectedImageState = Cell(null);
  
                  Commands.register(editor, imageUploadTimerState);
                  Buttons.register(editor);
                  ContextToolbar.register(editor);
  
                  UploadSelectedImage.setup(editor, imageUploadTimerState, lastSelectedImageState);
              });
  
              return function () {
              };
          }
      );
  
      dem('tinymce.plugins.imagetools.Plugin')();
  })();
  