@sapui5/sap.ui.richtexteditor 1.96.24 → 1.96.26

package/src/sap/ui/richtexteditor/js/tiny_mce5/plugins/imagetools/plugin.js

@@ -1,4 +1,6 @@
-
+/**
+ * Copyright (c) Tiny Technologies, Inc. All rights reserved.
+ */
 (function () {
     'use strict';
 
@@ -16,9 +18,40 @@
       };
     };
 
-    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
+    var global$5 = tinymce.util.Tools.resolve('tinymce.PluginManager');
 
-    var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');
+    var global$4 = tinymce.util.Tools.resolve('tinymce.util.Tools');
+
+    var typeOf = function (x) {
+      var t = typeof x;
+      if (x === null) {
+        return 'null';
+      } else if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
+        return 'array';
+      } else if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
+        return 'string';
+      } else {
+        return t;
+      }
+    };
+    var isType = function (type) {
+      return function (value) {
+        return typeOf(value) === type;
+      };
+    };
+    var isSimpleType = function (type) {
+      return function (value) {
+        return typeof value === type;
+      };
+    };
+    var isArray = isType('array');
+    var isNullable = function (a) {
+      return a === null || a === undefined;
+    };
+    var isNonNullable = function (a) {
+      return !isNullable(a);
+    };
+    var isFunction = isSimpleType('function');
 
     var noop = function () {
     };
@@ -27,6 +60,9 @@
         return value;
       };
     };
+    var identity = function (x) {
+      return x;
+    };
     var never = constant(false);
     var always = constant(true);
 
@@ -34,20 +70,14 @@
       return NONE;
     };
     var NONE = function () {
-      var eq = function (o) {
-        return o.isNone();
-      };
       var call = function (thunk) {
         return thunk();
       };
-      var id = function (n) {
-        return n;
-      };
+      var id = identity;
       var me = {
         fold: function (n, _s) {
           return n();
         },
-        is: never,
         isSome: never,
         isNone: always,
         getOr: id,
@@ -64,9 +94,9 @@
         bind: none,
         exists: never,
         forall: always,
-        filter: none,
-        equals: eq,
-        equals_: eq,
+        filter: function () {
+          return none();
+        },
         toArray: function () {
           return [];
         },
@@ -86,9 +116,6 @@
         fold: function (n, s) {
           return s(a);
         },
-        is: function (v) {
-          return a === v;
-        },
         isSome: always,
         isNone: never,
         getOr: constant_a,
@@ -115,14 +142,6 @@
         },
         toString: function () {
           return 'some(' + a + ')';
-        },
-        equals: function (o) {
-          return o.is(a);
-        },
-        equals_: function (o, elementEq) {
-          return o.fold(never, function (b) {
-            return elementEq(a, b);
-          });
         }
       };
       return me;
@@ -136,254 +155,279 @@
       from: from
     };
 
-    var isSimpleType = function (type) {
-      return function (value) {
-        return typeof value === type;
-      };
-    };
-    var isNullable = function (a) {
-      return a === null || a === undefined;
-    };
-    var isNonNullable = function (a) {
-      return !isNullable(a);
-    };
-    var isFunction = isSimpleType('function');
+    var exports$1 = {}, module = { exports: exports$1 };
+    (function (define, exports, module, require) {
+      (function (global, factory) {
+        typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.EphoxContactWrapper = factory());
+      }(this, function () {
+        var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+        var promise = { exports: {} };
+        (function (module) {
+          (function (root) {
+            var setTimeoutFunc = setTimeout;
+            function noop() {
+            }
+            function bind(fn, thisArg) {
+              return function () {
+                fn.apply(thisArg, arguments);
+              };
+            }
+            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 = 0;
+              this._handled = false;
+              this._value = undefined;
+              this._deferreds = [];
+              doResolve(fn, this);
+            }
+            function handle(self, deferred) {
+              while (self._state === 3) {
+                self = self._value;
+              }
+              if (self._state === 0) {
+                self._deferreds.push(deferred);
+                return;
+              }
+              self._handled = true;
+              Promise._immediateFn(function () {
+                var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
+                if (cb === null) {
+                  (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
+                  return;
+                }
+                var ret;
+                try {
+                  ret = cb(self._value);
+                } catch (e) {
+                  reject(deferred.promise, e);
+                  return;
+                }
+                resolve(deferred.promise, ret);
+              });
+            }
+            function resolve(self, newValue) {
+              try {
+                if (newValue === self)
+                  throw new TypeError('A promise cannot be resolved with itself.');
+                if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+                  var then = newValue.then;
+                  if (newValue instanceof Promise) {
+                    self._state = 3;
+                    self._value = newValue;
+                    finale(self);
+                    return;
+                  } else if (typeof then === 'function') {
+                    doResolve(bind(then, newValue), self);
+                    return;
+                  }
+                }
+                self._state = 1;
+                self._value = newValue;
+                finale(self);
+              } catch (e) {
+                reject(self, e);
+              }
+            }
+            function reject(self, newValue) {
+              self._state = 2;
+              self._value = newValue;
+              finale(self);
+            }
+            function finale(self) {
+              if (self._state === 2 && self._deferreds.length === 0) {
+                Promise._immediateFn(function () {
+                  if (!self._handled) {
+                    Promise._unhandledRejectionFn(self._value);
+                  }
+                });
+              }
+              for (var i = 0, len = self._deferreds.length; i < len; i++) {
+                handle(self, self._deferreds[i]);
+              }
+              self._deferreds = null;
+            }
+            function Handler(onFulfilled, onRejected, promise) {
+              this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+              this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+              this.promise = promise;
+            }
+            function doResolve(fn, self) {
+              var done = false;
+              try {
+                fn(function (value) {
+                  if (done)
+                    return;
+                  done = true;
+                  resolve(self, value);
+                }, function (reason) {
+                  if (done)
+                    return;
+                  done = true;
+                  reject(self, reason);
+                });
+              } catch (ex) {
+                if (done)
+                  return;
+                done = true;
+                reject(self, ex);
+              }
+            }
+            Promise.prototype['catch'] = function (onRejected) {
+              return this.then(null, onRejected);
+            };
+            Promise.prototype.then = function (onFulfilled, onRejected) {
+              var prom = new this.constructor(noop);
+              handle(this, new Handler(onFulfilled, onRejected, prom));
+              return prom;
+            };
+            Promise.all = function (arr) {
+              var args = Array.prototype.slice.call(arr);
+              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);
+                }
+              });
+            };
+            Promise._immediateFn = typeof setImmediate === 'function' ? function (fn) {
+              setImmediate(fn);
+            } : function (fn) {
+              setTimeoutFunc(fn, 0);
+            };
+            Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
+              if (typeof console !== 'undefined' && console) {
+                console.warn('Possible Unhandled Promise Rejection:', err);
+              }
+            };
+            Promise._setImmediateFn = function _setImmediateFn(fn) {
+              Promise._immediateFn = fn;
+            };
+            Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
+              Promise._unhandledRejectionFn = fn;
+            };
+            if (module.exports) {
+              module.exports = Promise;
+            } else if (!root.Promise) {
+              root.Promise = Promise;
+            }
+          }(commonjsGlobal));
+        }(promise));
+        var promisePolyfill = promise.exports;
+        var Global = function () {
+          if (typeof window !== 'undefined') {
+            return window;
+          } else {
+            return Function('return this;')();
+          }
+        }();
+        var promisePolyfill_1 = { boltExport: Global.Promise || promisePolyfill };
+        return promisePolyfill_1;
+      }));
+    }(undefined, exports$1, module));
+    var Promise$1 = module.exports.boltExport;
 
-    function create(width, height) {
+    var create$1 = function (width, height) {
       return resize(document.createElement('canvas'), width, height);
-    }
-    function clone(canvas) {
-      var tCanvas = create(canvas.width, canvas.height);
+    };
+    var clone = function (canvas) {
+      var tCanvas = create$1(canvas.width, canvas.height);
       var ctx = get2dContext(tCanvas);
       ctx.drawImage(canvas, 0, 0);
       return tCanvas;
-    }
-    function get2dContext(canvas) {
+    };
+    var get2dContext = function (canvas) {
       return canvas.getContext('2d');
-    }
-    function resize(canvas, width, height) {
+    };
+    var resize = function (canvas, width, height) {
       canvas.width = width;
       canvas.height = height;
       return canvas;
-    }
+    };
 
-    function getWidth(image) {
+    var getWidth = function (image) {
       return image.naturalWidth || image.width;
-    }
-    function getHeight(image) {
+    };
+    var getHeight = function (image) {
       return image.naturalHeight || image.height;
-    }
-
-    var promise = function () {
-      var Promise = function (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));
-      };
-      var anyWindow = window;
-      var asap = Promise.immediateFn || typeof anyWindow.setImmediate === 'function' && anyWindow.setImmediate || function (fn) {
-        setTimeout(fn, 1);
-      };
-      function bind(fn, thisArg) {
-        return function () {
-          return fn.apply(thisArg, arguments);
-        };
-      }
-      var isArray = Array.isArray || function (value) {
-        return Object.prototype.toString.call(value) === '[object Array]';
-      };
-      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 {
-          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, _a = this._deferreds; _i < _a.length; _i++) {
-          var deferred = _a[_i];
-          handle.call(this, deferred);
-        }
-        this._deferreds = [];
-      }
-      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;
-      }
-      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 values = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          values[_i] = arguments[_i];
-        }
-        var args = Array.prototype.slice.call(values.length === 1 && isArray(values[0]) ? values[0] : values);
-        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 (reason) {
-        return new Promise(function (resolve, reject) {
-          reject(reason);
-        });
-      };
-      Promise.race = function (values) {
-        return new Promise(function (resolve, reject) {
-          for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
-            var value = values_1[_i];
-            value.then(resolve, reject);
-          }
-        });
-      };
-      return Promise;
     };
-    var Promise = window.Promise ? window.Promise : promise();
 
-    function imageToBlob(image) {
+    var imageToBlob$2 = function (image) {
       var src = image.src;
       if (src.indexOf('data:') === 0) {
         return dataUriToBlob(src);
       }
       return anyUriToBlob(src);
-    }
-    function blobToImage(blob) {
-      return new Promise(function (resolve, reject) {
+    };
+    var blobToImage$1 = function (blob) {
+      return new Promise$1(function (resolve, reject) {
         var blobUrl = URL.createObjectURL(blob);
         var image = new Image();
         var removeListeners = function () {
           image.removeEventListener('load', loaded);
           image.removeEventListener('error', error);
         };
-        function loaded() {
+        var loaded = function () {
           removeListeners();
           resolve(image);
-        }
-        function error() {
+        };
+        var error = function () {
           removeListeners();
           reject('Unable to load data of type ' + blob.type + ': ' + blobUrl);
-        }
+        };
         image.addEventListener('load', loaded);
         image.addEventListener('error', error);
         image.src = blobUrl;
         if (image.complete) {
-          loaded();
+          setTimeout(loaded, 0);
         }
       });
-    }
-    function anyUriToBlob(url) {
-      return new Promise(function (resolve, reject) {
+    };
+    var anyUriToBlob = function (url) {
+      return new Promise$1(function (resolve, reject) {
         var xhr = new XMLHttpRequest();
         xhr.open('GET', url, true);
         xhr.responseType = 'blob';
@@ -407,8 +451,8 @@
         };
         xhr.send();
       });
-    }
-    function dataUriToBlobSync(uri) {
+    };
+    var dataUriToBlobSync = function (uri) {
       var data = uri.split(',');
       var matches = /data:([^;]+)/.exec(data[0]);
       if (!matches) {
@@ -431,18 +475,18 @@
         byteArrays[sliceIndex] = new Uint8Array(bytes);
       }
       return Optional.some(new Blob(byteArrays, { type: mimetype }));
-    }
-    function dataUriToBlob(uri) {
-      return new Promise(function (resolve, reject) {
+    };
+    var dataUriToBlob = function (uri) {
+      return new Promise$1(function (resolve, reject) {
         dataUriToBlobSync(uri).fold(function () {
           reject('uri is not base64: ' + uri);
         }, resolve);
       });
-    }
-    function canvasToBlob(canvas, type, quality) {
+    };
+    var canvasToBlob = function (canvas, type, quality) {
       type = type || 'image/png';
       if (isFunction(HTMLCanvasElement.prototype.toBlob)) {
-        return new Promise(function (resolve, reject) {
+        return new Promise$1(function (resolve, reject) {
           canvas.toBlob(function (blob) {
             if (blob) {
               resolve(blob);
@@ -454,49 +498,66 @@
       } else {
         return dataUriToBlob(canvas.toDataURL(type, quality));
       }
-    }
-    function canvasToDataURL(canvas, type, quality) {
+    };
+    var canvasToDataURL = function (canvas, type, quality) {
       type = type || 'image/png';
       return canvas.toDataURL(type, quality);
-    }
-    function blobToCanvas(blob) {
-      return blobToImage(blob).then(function (image) {
+    };
+    var blobToCanvas = function (blob) {
+      return blobToImage$1(blob).then(function (image) {
         revokeImageUrl(image);
-        var canvas = create(getWidth(image), getHeight(image));
+        var canvas = create$1(getWidth(image), getHeight(image));
         var context = get2dContext(canvas);
         context.drawImage(image, 0, 0);
         return canvas;
       });
-    }
-    function blobToDataUri(blob) {
-      return new Promise(function (resolve) {
+    };
+    var blobToDataUri = function (blob) {
+      return new Promise$1(function (resolve) {
         var reader = new FileReader();
         reader.onloadend = function () {
           resolve(reader.result);
         };
         reader.readAsDataURL(blob);
       });
-    }
-    function revokeImageUrl(image) {
+    };
+    var revokeImageUrl = function (image) {
       URL.revokeObjectURL(image.src);
-    }
+    };
 
-    var blobToImage$1 = function (blob) {
-      return blobToImage(blob);
+    var blobToImage = function (blob) {
+      return blobToImage$1(blob);
     };
     var imageToBlob$1 = function (image) {
-      return imageToBlob(image);
+      return imageToBlob$2(image);
     };
 
-    var each = function (xs, f) {
+    var nativeIndexOf = Array.prototype.indexOf;
+    var rawIndexOf = function (ts, t) {
+      return nativeIndexOf.call(ts, t);
+    };
+    var contains = function (xs, x) {
+      return rawIndexOf(xs, x) > -1;
+    };
+    var each$1 = function (xs, f) {
       for (var i = 0, len = xs.length; i < len; i++) {
         var x = xs[i];
         f(x, i);
       }
     };
+    var filter = function (xs, pred) {
+      var r = [];
+      for (var i = 0, len = xs.length; i < len; i++) {
+        var x = xs[i];
+        if (pred(x, i)) {
+          r.push(x);
+        }
+      }
+      return r;
+    };
     var foldl = function (xs, f, acc) {
-      each(xs, function (x) {
-        acc = f(acc, x);
+      each$1(xs, function (x, i) {
+        acc = f(acc, x, i);
       });
       return acc;
     };
@@ -514,35 +575,154 @@
     var find = function (xs, pred) {
       return findUntil(xs, pred, never);
     };
+    var forall = function (xs, pred) {
+      for (var i = 0, len = xs.length; i < len; ++i) {
+        var x = xs[i];
+        if (pred(x, i) !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
 
-    function create$1(getCanvas, blob, uri) {
+    var keys = Object.keys;
+    var each = function (obj, f) {
+      var props = keys(obj);
+      for (var k = 0, len = props.length; k < len; k++) {
+        var i = props[k];
+        var x = obj[i];
+        f(x, i);
+      }
+    };
+
+    var generate = function (cases) {
+      if (!isArray(cases)) {
+        throw new Error('cases must be an array');
+      }
+      if (cases.length === 0) {
+        throw new Error('there must be at least one case');
+      }
+      var constructors = [];
+      var adt = {};
+      each$1(cases, function (acase, count) {
+        var keys$1 = keys(acase);
+        if (keys$1.length !== 1) {
+          throw new Error('one and only one name per case');
+        }
+        var key = keys$1[0];
+        var value = acase[key];
+        if (adt[key] !== undefined) {
+          throw new Error('duplicate key detected:' + key);
+        } else if (key === 'cata') {
+          throw new Error('cannot have a case named cata (sorry)');
+        } else if (!isArray(value)) {
+          throw new Error('case arguments must be an array');
+        }
+        constructors.push(key);
+        adt[key] = function () {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          var argLength = args.length;
+          if (argLength !== value.length) {
+            throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength);
+          }
+          var match = function (branches) {
+            var branchKeys = keys(branches);
+            if (constructors.length !== branchKeys.length) {
+              throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(','));
+            }
+            var allReqd = forall(constructors, function (reqKey) {
+              return contains(branchKeys, reqKey);
+            });
+            if (!allReqd) {
+              throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', '));
+            }
+            return branches[key].apply(null, args);
+          };
+          return {
+            fold: function () {
+              var foldArgs = [];
+              for (var _i = 0; _i < arguments.length; _i++) {
+                foldArgs[_i] = arguments[_i];
+              }
+              if (foldArgs.length !== cases.length) {
+                throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + foldArgs.length);
+              }
+              var target = foldArgs[count];
+              return target.apply(null, args);
+            },
+            match: match,
+            log: function (label) {
+              console.log(label, {
+                constructors: constructors,
+                constructor: key,
+                params: args
+              });
+            }
+          };
+        };
+      });
+      return adt;
+    };
+    var Adt = { generate: generate };
+
+    Adt.generate([
+      {
+        bothErrors: [
+          'error1',
+          'error2'
+        ]
+      },
+      {
+        firstError: [
+          'error1',
+          'value2'
+        ]
+      },
+      {
+        secondError: [
+          'value1',
+          'error2'
+        ]
+      },
+      {
+        bothValues: [
+          'value1',
+          'value2'
+        ]
+      }
+    ]);
+
+    var create = function (getCanvas, blob, uri) {
       var initialType = blob.type;
       var getType = constant(initialType);
-      function toBlob() {
-        return Promise.resolve(blob);
-      }
+      var toBlob = function () {
+        return Promise$1.resolve(blob);
+      };
       var toDataURL = constant(uri);
-      function toBase64() {
+      var toBase64 = function () {
         return uri.split(',')[1];
-      }
-      function toAdjustedBlob(type, quality) {
+      };
+      var toAdjustedBlob = function (type, quality) {
         return getCanvas.then(function (canvas) {
           return canvasToBlob(canvas, type, quality);
         });
-      }
-      function toAdjustedDataURL(type, quality) {
+      };
+      var toAdjustedDataURL = function (type, quality) {
         return getCanvas.then(function (canvas) {
           return canvasToDataURL(canvas, type, quality);
         });
-      }
-      function toAdjustedBase64(type, quality) {
+      };
+      var toAdjustedBase64 = function (type, quality) {
         return toAdjustedDataURL(type, quality).then(function (dataurl) {
           return dataurl.split(',')[1];
         });
-      }
-      function toCanvas() {
+      };
+      var toCanvas = function () {
         return getCanvas.then(clone);
-      }
+      };
       return {
         getType: getType,
         toBlob: toBlob,
@@ -553,50 +733,54 @@
         toAdjustedBase64: toAdjustedBase64,
         toCanvas: toCanvas
       };
-    }
-    function fromBlob(blob) {
+    };
+    var fromBlob = function (blob) {
       return blobToDataUri(blob).then(function (uri) {
-        return create$1(blobToCanvas(blob), blob, uri);
+        return create(blobToCanvas(blob), blob, uri);
       });
-    }
-    function fromCanvas(canvas, type) {
+    };
+    var fromCanvas = function (canvas, type) {
       return canvasToBlob(canvas, type).then(function (blob) {
-        return create$1(Promise.resolve(canvas), blob, canvas.toDataURL());
+        return create(Promise$1.resolve(canvas), blob, canvas.toDataURL());
       });
-    }
+    };
 
-    function rotate(ir, angle) {
+    var ceilWithPrecision = function (num, precision) {
+      if (precision === void 0) {
+        precision = 2;
+      }
+      var mul = Math.pow(10, precision);
+      var upper = Math.round(num * mul);
+      return Math.ceil(upper / mul);
+    };
+    var rotate$2 = function (ir, angle) {
       return ir.toCanvas().then(function (canvas) {
         return applyRotate(canvas, ir.getType(), angle);
       });
-    }
-    function applyRotate(image, type, angle) {
-      var canvas = create(image.width, image.height);
+    };
+    var applyRotate = function (image, type, angle) {
+      var degrees = angle < 0 ? 360 + angle : angle;
+      var rad = degrees * Math.PI / 180;
+      var width = image.width;
+      var height = image.height;
+      var sin = Math.sin(rad);
+      var cos = Math.cos(rad);
+      var newWidth = ceilWithPrecision(Math.abs(width * cos) + Math.abs(height * sin));
+      var newHeight = ceilWithPrecision(Math.abs(width * sin) + Math.abs(height * cos));
+      var canvas = create$1(newWidth, newHeight);
       var context = get2dContext(canvas);
-      var translateX = 0;
-      var translateY = 0;
-      angle = angle < 0 ? 360 + angle : angle;
-      if (angle === 90 || angle === 270) {
-        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);
+      context.translate(newWidth / 2, newHeight / 2);
+      context.rotate(rad);
+      context.drawImage(image, -width / 2, -height / 2);
       return fromCanvas(canvas, type);
-    }
-    function flip(ir, axis) {
+    };
+    var flip$2 = function (ir, axis) {
       return ir.toCanvas().then(function (canvas) {
         return applyFlip(canvas, ir.getType(), axis);
       });
-    }
-    function applyFlip(image, type, axis) {
-      var canvas = create(image.width, image.height);
+    };
+    var applyFlip = function (image, type, axis) {
+      var canvas = create$1(image.width, image.height);
       var context = get2dContext(canvas);
       if (axis === 'v') {
         context.scale(1, -1);
@@ -606,30 +790,20 @@
         context.drawImage(image, -canvas.width, 0);
       }
       return fromCanvas(canvas, type);
-    }
+    };
 
     var flip$1 = function (ir, axis) {
-      return flip(ir, axis);
+      return flip$2(ir, axis);
     };
     var rotate$1 = function (ir, angle) {
-      return rotate(ir, angle);
-    };
-
-    var keys = Object.keys;
-    var each$1 = function (obj, f) {
-      var props = keys(obj);
-      for (var k = 0, len = props.length; k < len; k++) {
-        var i = props[k];
-        var x = obj[i];
-        f(x, i);
-      }
+      return rotate$2(ir, angle);
     };
 
     var sendRequest = function (url, headers, withCredentials) {
       if (withCredentials === void 0) {
         withCredentials = false;
       }
-      return new Promise(function (resolve) {
+      return new Promise$1(function (resolve) {
         var xhr = new XMLHttpRequest();
         xhr.onreadystatechange = function () {
           if (xhr.readyState === 4) {
@@ -641,7 +815,7 @@
         };
         xhr.open('GET', url, true);
         xhr.withCredentials = withCredentials;
-        each$1(headers, function (value, key) {
+        each(headers, function (value, key) {
           xhr.setRequestHeader(key, value);
         });
         xhr.responseType = 'blob';
@@ -649,7 +823,7 @@
       });
     };
     var readBlobText = function (blob) {
-      return new Promise(function (resolve, reject) {
+      return new Promise$1(function (resolve, reject) {
         var reader = new FileReader();
         reader.onload = function () {
           resolve(reader.result);
@@ -719,7 +893,7 @@
     };
     var handleHttpError = function (status) {
       var message = getHttpErrorMsg(status);
-      return Promise.reject(message);
+      return Promise$1.reject(message);
     };
     var getServiceErrorMsg = function (type) {
       return find(friendlyServiceErrors, function (error) {
@@ -741,7 +915,7 @@
     var handleServiceError = function (blob) {
       return readBlobText(blob).then(function (text) {
         var serviceError = getServiceError(text);
-        return Promise.reject(serviceError);
+        return Promise$1.reject(serviceError);
       });
     };
     var handleServiceErrorResponse = function (status, blob) {
@@ -765,12 +939,12 @@
         'tiny-api-key': apiKey
       };
       return sendRequest(appendApiKey(url, apiKey), headers).then(function (result) {
-        return isError(result.status) ? handleServiceErrorResponse(result.status, result.blob) : Promise.resolve(result.blob);
+        return isError(result.status) ? handleServiceErrorResponse(result.status, result.blob) : Promise$1.resolve(result.blob);
       });
     };
     var requestBlob = function (url, withCredentials) {
       return sendRequest(url, {}, withCredentials).then(function (result) {
-        return isError(result.status) ? handleHttpError(result.status) : Promise.resolve(result.blob);
+        return isError(result.status) ? handleHttpError(result.status) : Promise$1.resolve(result.blob);
       });
     };
     var getUrl = function (url, apiKey, withCredentials) {
@@ -843,9 +1017,9 @@
       }
     };
 
-    var Global = typeof window !== 'undefined' ? window : Function('return this;')();
+    typeof window !== 'undefined' ? window : Function('return this;')();
 
-    var child = function (scope, predicate) {
+    var child$1 = function (scope, predicate) {
       var pred = function (node) {
         return predicate(SugarElement.fromDom(node));
       };
@@ -853,17 +1027,17 @@
       return result.map(SugarElement.fromDom);
     };
 
-    var child$1 = function (scope, selector) {
-      return child(scope, function (e) {
+    var child = function (scope, selector) {
+      return child$1(scope, function (e) {
         return is(e, selector);
       });
     };
 
-    var global$2 = tinymce.util.Tools.resolve('tinymce.util.Delay');
+    var global$3 = tinymce.util.Tools.resolve('tinymce.util.Delay');
 
-    var global$3 = tinymce.util.Tools.resolve('tinymce.util.Promise');
+    var global$2 = tinymce.util.Tools.resolve('tinymce.util.Promise');
 
-    var global$4 = tinymce.util.Tools.resolve('tinymce.util.URI');
+    var global$1 = tinymce.util.Tools.resolve('tinymce.util.URI');
 
     var getToolbarItems = function (editor) {
       return editor.getParam('imagetools_toolbar', 'rotateleft rotateright flipv fliph editimage imageoptions');
@@ -890,11 +1064,11 @@
       return editor.getParam('images_reuse_filename', false, 'boolean');
     };
 
-    function getImageSize(img) {
+    var getImageSize = function (img) {
       var width, height;
-      function isPxValue(value) {
+      var isPxValue = function (value) {
         return /^[0-9\.]+px$/.test(value);
-      }
+      };
       width = img.style.width;
       height = img.style.height;
       if (width || height) {
@@ -915,8 +1089,8 @@
         };
       }
       return null;
-    }
-    function setImageSize(img, size) {
+    };
+    var setImageSize = function (img, size) {
       var width, height;
       if (size) {
         width = img.style.width;
@@ -929,39 +1103,39 @@
         width = img.width;
         height = img.height;
         if (width || height) {
-          img.setAttribute('width', size.w);
-          img.setAttribute('height', size.h);
+          img.setAttribute('width', String(size.w));
+          img.setAttribute('height', String(size.h));
         }
       }
-    }
-    function getNaturalImageSize(img) {
+    };
+    var getNaturalImageSize = function (img) {
       return {
         w: img.naturalWidth,
         h: img.naturalHeight
       };
-    }
+    };
 
     var count = 0;
     var getFigureImg = function (elem) {
-      return child$1(SugarElement.fromDom(elem), 'img');
+      return child(SugarElement.fromDom(elem), 'img');
     };
     var isFigure = function (editor, elem) {
       return editor.dom.is(elem, 'figure');
     };
-    var getEditableImage = function (editor, elem) {
-      var isImage = function (imgNode) {
-        return editor.dom.is(imgNode, 'img:not([data-mce-object],[data-mce-placeholder])');
-      };
+    var isImage = function (editor, imgNode) {
+      return editor.dom.is(imgNode, 'img:not([data-mce-object],[data-mce-placeholder])');
+    };
+    var getEditableImage = function (editor, node) {
       var isEditable = function (imgNode) {
-        return isImage(imgNode) && (isLocalImage(editor, imgNode) || isCorsImage(editor, imgNode) || getProxyUrl(editor));
+        return isImage(editor, imgNode) && (isLocalImage(editor, imgNode) || isCorsImage(editor, imgNode) || isNonNullable(getProxyUrl(editor)));
       };
-      if (isFigure(editor, elem)) {
-        var imgOpt = getFigureImg(elem);
-        return imgOpt.map(function (img) {
+      if (isFigure(editor, node)) {
+        return getFigureImg(node).bind(function (img) {
           return isEditable(img.dom) ? Optional.some(img.dom) : Optional.none();
         });
+      } else {
+        return isEditable(node) ? Optional.some(node) : Optional.none();
       }
-      return isEditable(elem) ? Optional.some(elem) : Optional.none();
     };
     var displayError = function (editor, error) {
       editor.notificationManager.open({
@@ -971,31 +1145,31 @@
     };
     var getSelectedImage = function (editor) {
       var elem = editor.selection.getNode();
-      if (isFigure(editor, elem)) {
-        return getFigureImg(elem);
-      } else {
+      var figureElm = editor.dom.getParent(elem, 'figure.image');
+      if (figureElm !== null && isFigure(editor, figureElm)) {
+        return getFigureImg(figureElm);
+      } else if (isImage(editor, elem)) {
         return Optional.some(SugarElement.fromDom(elem));
+      } else {
+        return Optional.none();
       }
     };
-    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 extractFilename = function (editor, url, group) {
+      var m = url.match(/(?:\/|^)(([^\/\?]+)\.(?:[a-z0-9.]+))(?:\?|$)/i);
+      return isNonNullable(m) ? editor.dom.encode(m[group]) : 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 global$4(url).host === editor.documentBaseURI.host;
+      return url.indexOf('data:') === 0 || url.indexOf('blob:') === 0 || new global$1(url).host === editor.documentBaseURI.host;
     };
     var isCorsImage = function (editor, img) {
-      return global$1.inArray(getCorsHosts(editor), new global$4(img.src).host) !== -1;
+      return global$4.inArray(getCorsHosts(editor), new global$1(img.src).host) !== -1;
     };
     var isCorsWithCredentialsImage = function (editor, img) {
-      return global$1.inArray(getCredentialsHosts(editor), new global$4(img.src).host) !== -1;
+      return global$4.inArray(getCredentialsHosts(editor), new global$1(img.src).host) !== -1;
     };
     var defaultFetchImage = function (editor, img) {
       if (isCorsImage(editor, img)) {
@@ -1009,7 +1183,7 @@
       }
       return imageToBlob$1(img);
     };
-    var imageToBlob$2 = function (editor, img) {
+    var imageToBlob = function (editor, img) {
       return getFetchImage(editor).fold(function () {
         return defaultFetchImage(editor, img);
       }, function (customFetchImage) {
@@ -1019,31 +1193,34 @@
     var findBlob = function (editor, img) {
       var blobInfo = editor.editorUpload.blobCache.getByUri(img.src);
       if (blobInfo) {
-        return global$3.resolve(blobInfo.blob());
+        return global$2.resolve(blobInfo.blob());
       }
-      return imageToBlob$2(editor, img);
+      return imageToBlob(editor, img);
     };
     var startTimedUpload = function (editor, imageUploadTimerState) {
-      var imageUploadTimer = global$2.setEditorTimeout(editor, function () {
+      var imageUploadTimer = global$3.setEditorTimeout(editor, function () {
         editor.editorUpload.uploadImagesAuto();
       }, getUploadTimeout(editor));
       imageUploadTimerState.set(imageUploadTimer);
     };
     var cancelTimedUpload = function (imageUploadTimerState) {
-      global$2.clearTimeout(imageUploadTimerState.get());
+      global$3.clearTimeout(imageUploadTimerState.get());
     };
-    var updateSelectedImage = function (editor, ir, uploadImmediately, imageUploadTimerState, selectedImage, size) {
+    var updateSelectedImage = function (editor, origBlob, ir, uploadImmediately, imageUploadTimerState, selectedImage, size) {
       return ir.toBlob().then(function (blob) {
-        var uri, name, blobInfo;
+        var uri, name, filename, blobInfo;
         var blobCache = editor.editorUpload.blobCache;
         uri = selectedImage.src;
+        var useFilename = origBlob.type === blob.type;
         if (shouldReuseFilename(editor)) {
           blobInfo = blobCache.getByUri(uri);
-          if (blobInfo) {
+          if (isNonNullable(blobInfo)) {
             uri = blobInfo.uri();
             name = blobInfo.name();
+            filename = blobInfo.filename();
           } else {
-            name = extractFilename(editor, uri);
+            name = extractFilename(editor, uri, 2);
+            filename = extractFilename(editor, uri, 1);
           }
         }
         blobInfo = blobCache.create({
@@ -1051,11 +1228,12 @@
           blob: blob,
           base64: ir.toBase64(),
           uri: uri,
-          name: name
+          name: name,
+          filename: useFilename ? filename : undefined
         });
         blobCache.add(blobInfo);
         editor.undoManager.transact(function () {
-          function imageLoadedHandler() {
+          var imageLoadedHandler = function () {
             editor.$(selectedImage).off('load', imageLoadedHandler);
             editor.nodeChanged();
             if (uploadImmediately) {
@@ -1064,7 +1242,7 @@
               cancelTimedUpload(imageUploadTimerState);
               startTimedUpload(editor, imageUploadTimerState);
             }
-          }
+          };
           editor.$(selectedImage).on('load', imageLoadedHandler);
           if (size) {
             editor.$(selectedImage).attr({
@@ -1085,32 +1263,32 @@
         }, function (img) {
           return editor._scanForImages().then(function () {
             return findBlob(editor, img.dom);
-          }).then(blobToImageResult).then(fn).then(function (imageResult) {
-            return updateSelectedImage(editor, imageResult, false, imageUploadTimerState, img.dom, size);
-          }, function (error) {
+          }).then(function (blob) {
+            return blobToImageResult(blob).then(fn).then(function (imageResult) {
+              return updateSelectedImage(editor, blob, imageResult, false, imageUploadTimerState, img.dom, size);
+            });
+          }).catch(function (error) {
             displayError(editor, error);
           });
         });
       };
     };
-    var rotate$2 = function (editor, imageUploadTimerState, angle) {
+    var rotate = function (editor, imageUploadTimerState, angle) {
       return function () {
         var imgOpt = getSelectedImage(editor);
-        var flippedSize = imgOpt.fold(function () {
-          return null;
-        }, function (img) {
+        var flippedSize = imgOpt.map(function (img) {
           var size = getImageSize(img.dom);
           return size ? {
             w: size.h,
             h: size.w
           } : null;
-        });
+        }).getOrNull();
         return selectedImageOperation(editor, imageUploadTimerState, function (imageResult) {
           return rotate$1(imageResult, angle);
         }, flippedSize)();
       };
     };
-    var flip$2 = function (editor, imageUploadTimerState, axis) {
+    var flip = function (editor, imageUploadTimerState, axis) {
       return function () {
         return selectedImageOperation(editor, imageUploadTimerState, function (imageResult) {
           return flip$1(imageResult, axis);
@@ -1118,7 +1296,7 @@
       };
     };
     var handleDialogBlob = function (editor, imageUploadTimerState, img, originalSize, blob) {
-      return blobToImage$1(blob).then(function (newImage) {
+      return blobToImage(blob).then(function (newImage) {
         var newSize = getNaturalImageSize(newImage);
         if (originalSize.w !== newSize.w || originalSize.h !== newSize.h) {
           if (getImageSize(img)) {
@@ -1128,8 +1306,7 @@
         URL.revokeObjectURL(newImage.src);
         return blob;
       }).then(blobToImageResult).then(function (imageResult) {
-        return updateSelectedImage(editor, imageResult, true, imageUploadTimerState, img);
-      }, function () {
+        return updateSelectedImage(editor, blob, imageResult, true, imageUploadTimerState, img);
       });
     };
 
@@ -1181,8 +1358,7 @@
               });
               api.close();
             },
-            onCancel: function () {
-            },
+            onCancel: noop,
             onAction: function (api, details) {
               switch (details.name) {
               case saveState:
@@ -1207,8 +1383,7 @@
         var originalSizeOpt = originalImgOpt.map(function (origImg) {
           return getNaturalImageSize(origImg.dom);
         });
-        var imgOpt = getSelectedImage(editor);
-        imgOpt.each(function (img) {
+        originalImgOpt.each(function (img) {
           getEditableImage(editor, img.dom).each(function (_) {
             findBlob(editor, img.dom).then(function (blob) {
               var state = createState(blob);
@@ -1219,12 +1394,12 @@
       };
     };
 
-    var register = function (editor, imageUploadTimerState) {
-      global$1.each({
-        mceImageRotateLeft: rotate$2(editor, imageUploadTimerState, -90),
-        mceImageRotateRight: rotate$2(editor, imageUploadTimerState, 90),
-        mceImageFlipVertical: flip$2(editor, imageUploadTimerState, 'v'),
-        mceImageFlipHorizontal: flip$2(editor, imageUploadTimerState, 'h'),
+    var register$2 = function (editor, imageUploadTimerState) {
+      global$4.each({
+        mceImageRotateLeft: rotate(editor, imageUploadTimerState, -90),
+        mceImageRotateRight: rotate(editor, imageUploadTimerState, 90),
+        mceImageFlipVertical: flip(editor, imageUploadTimerState, 'v'),
+        mceImageFlipHorizontal: flip(editor, imageUploadTimerState, 'h'),
         mceEditImage: makeOpen(editor, imageUploadTimerState)
       }, function (fn, cmd) {
         editor.addCommand(cmd, fn);
@@ -1234,58 +1409,77 @@
     var setup = function (editor, imageUploadTimerState, lastSelectedImageState) {
       editor.on('NodeChange', function (e) {
         var lastSelectedImage = lastSelectedImageState.get();
-        if (lastSelectedImage && lastSelectedImage.src !== e.element.src) {
+        var selectedImage = getEditableImage(editor, e.element);
+        if (lastSelectedImage && !selectedImage.exists(function (img) {
+            return lastSelectedImage.src === img.src;
+          })) {
           cancelTimedUpload(imageUploadTimerState);
           editor.editorUpload.uploadImagesAuto();
           lastSelectedImageState.set(null);
         }
-        getEditableImage(editor, e.element).each(lastSelectedImageState.set);
+        selectedImage.each(lastSelectedImageState.set);
       });
     };
 
     var register$1 = function (editor) {
+      var changeHandlers = [];
       var cmd = function (command) {
         return function () {
           return editor.execCommand(command);
         };
       };
+      var isEditableImage = function () {
+        return getSelectedImage(editor).exists(function (element) {
+          return getEditableImage(editor, element.dom).isSome();
+        });
+      };
+      var onSetup = function (api) {
+        var handler = function (isEditableImage) {
+          return api.setDisabled(!isEditableImage);
+        };
+        handler(isEditableImage());
+        changeHandlers = changeHandlers.concat([handler]);
+        return function () {
+          changeHandlers = filter(changeHandlers, function (h) {
+            return h !== handler;
+          });
+        };
+      };
+      editor.on('NodeChange', function () {
+        var isEditable = isEditableImage();
+        each$1(changeHandlers, function (handler) {
+          return handler(isEditable);
+        });
+      });
       editor.ui.registry.addButton('rotateleft', {
         tooltip: 'Rotate counterclockwise',
         icon: 'rotate-left',
-        onAction: cmd('mceImageRotateLeft')
+        onAction: cmd('mceImageRotateLeft'),
+        onSetup: onSetup
       });
       editor.ui.registry.addButton('rotateright', {
         tooltip: 'Rotate clockwise',
         icon: 'rotate-right',
-        onAction: cmd('mceImageRotateRight')
+        onAction: cmd('mceImageRotateRight'),
+        onSetup: onSetup
       });
       editor.ui.registry.addButton('flipv', {
         tooltip: 'Flip vertically',
         icon: 'flip-vertically',
-        onAction: cmd('mceImageFlipVertical')
+        onAction: cmd('mceImageFlipVertical'),
+        onSetup: onSetup
       });
       editor.ui.registry.addButton('fliph', {
         tooltip: 'Flip horizontally',
         icon: 'flip-horizontally',
-        onAction: cmd('mceImageFlipHorizontal')
+        onAction: cmd('mceImageFlipHorizontal'),
+        onSetup: onSetup
       });
       editor.ui.registry.addButton('editimage', {
         tooltip: 'Edit image',
         icon: 'edit-image',
         onAction: cmd('mceEditImage'),
-        onSetup: function (buttonApi) {
-          var setDisabled = function () {
-            var elementOpt = getSelectedImage(editor);
-            elementOpt.each(function (element) {
-              var disabled = getEditableImage(editor, element.dom).isNone();
-              buttonApi.setDisabled(disabled);
-            });
-          };
-          editor.on('NodeChange', setDisabled);
-          return function () {
-            editor.off('NodeChange', setDisabled);
-          };
-        }
+        onSetup: onSetup
       });
       editor.ui.registry.addButton('imageoptions', {
         tooltip: 'Image options',
@@ -1294,20 +1488,18 @@
       });
       editor.ui.registry.addContextMenu('imagetools', {
         update: function (element) {
-          return getEditableImage(editor, element).fold(function () {
-            return [];
-          }, function (_) {
-            return [{
-                text: 'Edit image',
-                icon: 'edit-image',
-                onAction: cmd('mceEditImage')
-              }];
-          });
+          return getEditableImage(editor, element).map(function (_) {
+            return {
+              text: 'Edit image',
+              icon: 'edit-image',
+              onAction: cmd('mceEditImage')
+            };
+          }).toArray();
         }
       });
     };
 
-    var register$2 = function (editor) {
+    var register = function (editor) {
       editor.ui.registry.addContextToolbar('imagetools', {
         items: getToolbarItems(editor),
         predicate: function (elem) {
@@ -1319,12 +1511,12 @@
     };
 
     function Plugin () {
-      global.add('imagetools', function (editor) {
+      global$5.add('imagetools', function (editor) {
         var imageUploadTimerState = Cell(0);
         var lastSelectedImageState = Cell(null);
-        register(editor, imageUploadTimerState);
+        register$2(editor, imageUploadTimerState);
         register$1(editor);
-        register$2(editor);
+        register(editor);
         setup(editor, imageUploadTimerState, lastSelectedImageState);
       });
     }