tinymce-rails 5.0.5 → 5.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3825d9b3942f8c25ceadb1affeef6ce42722a18e44d09d6e3f0544a6f128dfbd
-  data.tar.gz: 77bec138b529b542312107e587982343af10d7900243e28eedbab2efc16fab0e
+  metadata.gz: 0b4b337972d39d3ac9e105de1b323083d52c654dcb3b127156f12a5f3ef0f93b
+  data.tar.gz: 1e2c278b7aa341bb3517a31eb77e182a40f3026f02a7fd4d98c0d6bdc8759717
 SHA512:
-  metadata.gz: de30dfac39f464b3e5ac7fe72b0e500931c6bdb9cbaf9a5b9a4f37881a2877aa86bb0c04cd45cb848337b9682e62bd8d0853c7726682eef79071ab46937172cc
-  data.tar.gz: 66b84cbdbb7b3b5fd917359b59447c116e73a3076a4ffa12f4371ddb2a3c2f54629b226956e366912b446e84d574cc4385340dfce0e189c11a1b94f9fc789a6a
+  metadata.gz: 31369d3ba439cbc04b4006d621c777a20ccbd0417d2bd175f119e92aa66210157bd3edfc584aa4fa828c9c493df27103f46197019e99326a539e92b01361151c
+  data.tar.gz: c2c192c1c0203280ebac10ea212f1490ba368c8d34e051d24836a9886e83fccdd5c5b8d0dd1cc11227d512c8f7d648c3a19f50ada78d9240400321af02465777

data/app/assets/source/tinymce/tinymce.js

@@ -4,24 +4,15 @@
  * For LGPL see License.txt in the project root for license information.
  * For commercial licenses see https://www.tiny.cloud/
  *
- * Version: 5.0.5 (2019-05-09)
+ * Version: 5.0.9 (2019-06-26)
  */
-(function () {
 (function (domGlobals) {
     'use strict';
 
     var noop = function () {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
     };
     var noarg = function (f) {
       return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
         return f();
       };
     };
@@ -250,6 +241,7 @@
     var isFunction = isType('function');
     var isNumber = isType('number');
 
+    var slice = Array.prototype.slice;
     var rawIndexOf = function () {
       var pIndexOf = Array.prototype.indexOf;
       var fastIndex = function (xs, x) {
@@ -280,7 +272,7 @@
     var chunk = function (array, size) {
       var r = [];
       for (var i = 0; i < array.length; i += size) {
-        var s = array.slice(i, i + size);
+        var s = slice.call(array, i, i + size);
         r.push(s);
       }
       return r;
@@ -418,7 +410,6 @@
         return x === a2[i];
       });
     };
-    var slice = Array.prototype.slice;
     var reverse = function (xs) {
       var r = slice.call(xs, 0);
       r.reverse();
@@ -485,471 +476,827 @@
         from: from$1
     });
 
-    var Global = typeof domGlobals.window !== 'undefined' ? domGlobals.window : Function('return this;')();
-
-    var path = function (parts, scope) {
-      var o = scope !== undefined && scope !== null ? scope : Global;
-      for (var i = 0; i < parts.length && o !== undefined && o !== null; ++i)
-        o = o[parts[i]];
-      return o;
-    };
-    var resolve = function (p, scope) {
-      var parts = p.split('.');
-      return path(parts, scope);
-    };
-
-    var unsafe = function (name, scope) {
-      return resolve(name, scope);
-    };
-    var getOrDie = function (name, scope) {
-      var actual = unsafe(name, scope);
-      if (actual === undefined || actual === null)
-        throw name + ' not available on this browser';
-      return actual;
-    };
-    var Global$1 = { getOrDie: getOrDie };
-
-    var url = function () {
-      return Global$1.getOrDie('URL');
-    };
-    var createObjectURL = function (blob) {
-      return url().createObjectURL(blob);
-    };
-    var revokeObjectURL = function (u) {
-      url().revokeObjectURL(u);
-    };
-    var URL = {
-      createObjectURL: createObjectURL,
-      revokeObjectURL: revokeObjectURL
-    };
-
-    var nav = domGlobals.navigator, userAgent = nav.userAgent;
-    var opera, webkit, ie, ie11, ie12, gecko, mac, iDevice, android, fileApi, phone, tablet, windowsPhone;
-    var matchMediaQuery = function (query) {
-      return 'matchMedia' in domGlobals.window ? domGlobals.matchMedia(query).matches : false;
-    };
-    opera = false;
-    android = /Android/.test(userAgent);
-    webkit = /WebKit/.test(userAgent);
-    ie = !webkit && !opera && /MSIE/gi.test(userAgent) && /Explorer/gi.test(nav.appName);
-    ie = ie && /MSIE (\w+)\./.exec(userAgent)[1];
-    ie11 = userAgent.indexOf('Trident/') !== -1 && (userAgent.indexOf('rv:') !== -1 || nav.appName.indexOf('Netscape') !== -1) ? 11 : false;
-    ie12 = userAgent.indexOf('Edge/') !== -1 && !ie && !ie11 ? 12 : false;
-    ie = ie || ie11 || ie12;
-    gecko = !webkit && !ie11 && /Gecko/.test(userAgent);
-    mac = userAgent.indexOf('Mac') !== -1;
-    iDevice = /(iPad|iPhone)/.test(userAgent);
-    fileApi = 'FormData' in domGlobals.window && 'FileReader' in domGlobals.window && 'URL' in domGlobals.window && !!URL.createObjectURL;
-    phone = matchMediaQuery('only screen and (max-device-width: 480px)') && (android || iDevice);
-    tablet = matchMediaQuery('only screen and (min-width: 800px)') && (android || iDevice);
-    windowsPhone = userAgent.indexOf('Windows Phone') !== -1;
-    if (ie12) {
-      webkit = false;
-    }
-    var contentEditable = !iDevice || fileApi || parseInt(userAgent.match(/AppleWebKit\/(\d*)/)[1], 10) >= 534;
-    var Env = {
-      opera: opera,
-      webkit: webkit,
-      ie: ie,
-      gecko: gecko,
-      mac: mac,
-      iOS: iDevice,
-      android: android,
-      contentEditable: contentEditable,
-      transparentSrc: 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7',
-      caretAfter: ie !== 8,
-      range: domGlobals.window.getSelection && 'Range' in domGlobals.window,
-      documentMode: ie && !ie12 ? domGlobals.document.documentMode || 7 : 10,
-      fileApi: fileApi,
-      ceFalse: ie === false || ie > 8,
-      cacheSuffix: null,
-      container: null,
-      overrideViewPort: null,
-      experimentalShadowDom: false,
-      canHaveCSP: ie === false || ie > 11,
-      desktop: !phone && !tablet,
-      windowsPhone: windowsPhone
+    var extendStatics = function (d, b) {
+      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function (d, b) {
+        d.__proto__ = b;
+      } || function (d, b) {
+        for (var p in b)
+          if (b.hasOwnProperty(p))
+            d[p] = b[p];
+      };
+      return extendStatics(d, b);
     };
-
-    var promise = function () {
-      function bind(fn, thisArg) {
-        return function () {
-          fn.apply(thisArg, arguments);
-        };
+    function __extends(d, b) {
+      extendStatics(d, b);
+      function __() {
+        this.constructor = d;
       }
-      var isArray = Array.isArray || function (value) {
-        return Object.prototype.toString.call(value) === '[object Array]';
-      };
-      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');
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    var __assign = function () {
+      __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
         }
-        this._state = null;
-        this._value = null;
-        this._deferreds = [];
-        doResolve(fn, bind(resolve, this), bind(reject, this));
+        return t;
       };
-      var asap = Promise.immediateFn || typeof domGlobals.setImmediate === 'function' && domGlobals.setImmediate || function (fn) {
-        domGlobals.setTimeout(fn, 1);
+      return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+      var t = {};
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+          t[p] = s[p];
+      if (s != null && typeof Object.getOwnPropertySymbols === 'function')
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++)
+          if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+      return t;
+    }
+    function __decorate(decorators, target, key, desc) {
+      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+      if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function')
+        r = Reflect.decorate(decorators, target, key, desc);
+      else
+        for (var i = decorators.length - 1; i >= 0; i--)
+          if (d = decorators[i])
+            r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+    function __param(paramIndex, decorator) {
+      return function (target, key) {
+        decorator(target, key, paramIndex);
       };
-      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;
+    }
+    function __metadata(metadataKey, metadataValue) {
+      if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function')
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+      return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) {
           try {
-            ret = cb(me._value);
+            step(generator.next(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.');
+            reject(e);
           }
-          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;
-            }
+        }
+        function rejected(value) {
+          try {
+            step(generator['throw'](value));
+          } catch (e) {
+            reject(e);
           }
-          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]);
+        function step(result) {
+          result.done ? resolve(result.value) : new P(function (resolve) {
+            resolve(result.value);
+          }).then(fulfilled, rejected);
         }
-        this._deferreds = null;
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    }
+    function __generator(thisArg, body) {
+      var _ = {
+          label: 0,
+          sent: function () {
+            if (t[0] & 1)
+              throw t[1];
+            return t[1];
+          },
+          trys: [],
+          ops: []
+        }, f, y, t, g;
+      return g = {
+        next: verb(0),
+        'throw': verb(1),
+        'return': verb(2)
+      }, typeof Symbol === 'function' && (g[Symbol.iterator] = function () {
+        return this;
+      }), g;
+      function verb(n) {
+        return function (v) {
+          return step([
+            n,
+            v
+          ]);
+        };
       }
-      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 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;
-                }
+      function step(op) {
+        if (f)
+          throw new TypeError('Generator is already executing.');
+        while (_)
+          try {
+            if (f = 1, y && (t = op[0] & 2 ? y['return'] : op[0] ? y['throw'] || ((t = y['return']) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+              return t;
+            if (y = 0, t)
+              op = [
+                op[0] & 2,
+                t.value
+              ];
+            switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return {
+                value: op[1],
+                done: false
+              };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
               }
-              args[i] = val;
-              if (--remaining === 0) {
-                resolve(args);
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
               }
-            } catch (ex) {
-              reject(ex);
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2])
+                _.ops.pop();
+              _.trys.pop();
+              continue;
             }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [
+              6,
+              e
+            ];
+            y = 0;
+          } finally {
+            f = t = 0;
           }
-          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;
+        if (op[0] & 5)
+          throw op[1];
+        return {
+          value: op[0] ? op[1] : void 0,
+          done: true
+        };
+      }
+    }
+    function __exportStar(m, exports) {
+      for (var p in m)
+        if (!exports.hasOwnProperty(p))
+          exports[p] = m[p];
+    }
+    function __values(o) {
+      var m = typeof Symbol === 'function' && o[Symbol.iterator], i = 0;
+      if (m)
+        return m.call(o);
+      return {
+        next: function () {
+          if (o && i >= o.length)
+            o = void 0;
+          return {
+            value: o && o[i++],
+            done: !o
+          };
         }
-        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;
-    };
-    var promiseObj = window.Promise ? window.Promise : promise();
-
-    var requestAnimationFramePromise;
-    var requestAnimationFrame = function (callback, element) {
-      var i, requestAnimationFrameFunc = domGlobals.window.requestAnimationFrame;
-      var vendors = [
-        'ms',
-        'moz',
-        'webkit'
-      ];
-      var featurefill = function (callback) {
-        domGlobals.window.setTimeout(callback, 0);
       };
-      for (i = 0; i < vendors.length && !requestAnimationFrameFunc; i++) {
-        requestAnimationFrameFunc = domGlobals.window[vendors[i] + 'RequestAnimationFrame'];
+    }
+    function __read(o, n) {
+      var m = typeof Symbol === 'function' && o[Symbol.iterator];
+      if (!m)
+        return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+          ar.push(r.value);
+      } catch (error) {
+        e = { error: error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i['return']))
+            m.call(i);
+        } finally {
+          if (e)
+            throw e.error;
+        }
       }
-      if (!requestAnimationFrameFunc) {
-        requestAnimationFrameFunc = featurefill;
+      return ar;
+    }
+    function __spread() {
+      for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+      return ar;
+    }
+    function __await(v) {
+      return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+      if (!Symbol.asyncIterator)
+        throw new TypeError('Symbol.asyncIterator is not defined.');
+      var g = generator.apply(thisArg, _arguments || []), i, q = [];
+      return i = {}, verb('next'), verb('throw'), verb('return'), i[Symbol.asyncIterator] = function () {
+        return this;
+      }, i;
+      function verb(n) {
+        if (g[n])
+          i[n] = function (v) {
+            return new Promise(function (a, b) {
+              q.push([
+                n,
+                v,
+                a,
+                b
+              ]) > 1 || resume(n, v);
+            });
+          };
       }
-      requestAnimationFrameFunc(callback, element);
-    };
-    var wrappedSetTimeout = function (callback, time) {
-      if (typeof time !== 'number') {
-        time = 0;
+      function resume(n, v) {
+        try {
+          step(g[n](v));
+        } catch (e) {
+          settle(q[0][3], e);
+        }
       }
-      return domGlobals.setTimeout(callback, time);
-    };
-    var wrappedSetInterval = function (callback, time) {
-      if (typeof time !== 'number') {
-        time = 1;
+      function step(r) {
+        r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
       }
-      return domGlobals.setInterval(callback, time);
-    };
-    var wrappedClearTimeout = function (id) {
-      return domGlobals.clearTimeout(id);
+      function fulfill(value) {
+        resume('next', value);
+      }
+      function reject(value) {
+        resume('throw', value);
+      }
+      function settle(f, v) {
+        if (f(v), q.shift(), q.length)
+          resume(q[0][0], q[0][1]);
+      }
+    }
+    function __asyncDelegator(o) {
+      var i, p;
+      return i = {}, verb('next'), verb('throw', function (e) {
+        throw e;
+      }), verb('return'), i[Symbol.iterator] = function () {
+        return this;
+      }, i;
+      function verb(n, f) {
+        i[n] = o[n] ? function (v) {
+          return (p = !p) ? {
+            value: __await(o[n](v)),
+            done: n === 'return'
+          } : f ? f(v) : v;
+        } : f;
+      }
+    }
+    function __asyncValues(o) {
+      if (!Symbol.asyncIterator)
+        throw new TypeError('Symbol.asyncIterator is not defined.');
+      var m = o[Symbol.asyncIterator], i;
+      return m ? m.call(o) : (o = typeof __values === 'function' ? __values(o) : o[Symbol.iterator](), i = {}, verb('next'), verb('throw'), verb('return'), i[Symbol.asyncIterator] = function () {
+        return this;
+      }, i);
+      function verb(n) {
+        i[n] = o[n] && function (v) {
+          return new Promise(function (resolve, reject) {
+            v = o[n](v), settle(resolve, reject, v.done, v.value);
+          });
+        };
+      }
+      function settle(resolve, reject, d, v) {
+        Promise.resolve(v).then(function (v) {
+          resolve({
+            value: v,
+            done: d
+          });
+        }, reject);
+      }
+    }
+    function __makeTemplateObject(cooked, raw) {
+      if (Object.defineProperty) {
+        Object.defineProperty(cooked, 'raw', { value: raw });
+      } else {
+        cooked.raw = raw;
+      }
+      return cooked;
+    }
+    function __importStar(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null)
+        for (var k in mod)
+          if (Object.hasOwnProperty.call(mod, k))
+            result[k] = mod[k];
+      result.default = mod;
+      return result;
+    }
+    function __importDefault(mod) {
+      return mod && mod.__esModule ? mod : { default: mod };
+    }
+
+    var tslib_1 = /*#__PURE__*/Object.freeze({
+        __extends: __extends,
+        get __assign () { return __assign; },
+        __rest: __rest,
+        __decorate: __decorate,
+        __param: __param,
+        __metadata: __metadata,
+        __awaiter: __awaiter,
+        __generator: __generator,
+        __exportStar: __exportStar,
+        __values: __values,
+        __read: __read,
+        __spread: __spread,
+        __await: __await,
+        __asyncGenerator: __asyncGenerator,
+        __asyncDelegator: __asyncDelegator,
+        __asyncValues: __asyncValues,
+        __makeTemplateObject: __makeTemplateObject,
+        __importStar: __importStar,
+        __importDefault: __importDefault
+    });
+
+    var Global = typeof domGlobals.window !== 'undefined' ? domGlobals.window : Function('return this;')();
+
+    var path = function (parts, scope) {
+      var o = scope !== undefined && scope !== null ? scope : Global;
+      for (var i = 0; i < parts.length && o !== undefined && o !== null; ++i)
+        o = o[parts[i]];
+      return o;
     };
-    var wrappedClearInterval = function (id) {
-      return domGlobals.clearInterval(id);
+    var resolve = function (p, scope) {
+      var parts = p.split('.');
+      return path(parts, scope);
     };
-    var debounce = function (callback, time) {
-      var timer, func;
-      func = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-        domGlobals.clearTimeout(timer);
-        timer = wrappedSetTimeout(function () {
-          callback.apply(this, args);
-        }, time);
-      };
-      func.stop = function () {
-        domGlobals.clearTimeout(timer);
-      };
-      return func;
+
+    var unsafe = function (name, scope) {
+      return resolve(name, scope);
     };
-    var Delay = {
-      requestAnimationFrame: function (callback, element) {
-        if (requestAnimationFramePromise) {
-          requestAnimationFramePromise.then(callback);
-          return;
-        }
-        requestAnimationFramePromise = new promiseObj(function (resolve) {
-          if (!element) {
-            element = domGlobals.document.body;
-          }
-          requestAnimationFrame(resolve, element);
-        }).then(callback);
-      },
-      setTimeout: wrappedSetTimeout,
-      setInterval: wrappedSetInterval,
-      setEditorTimeout: function (editor, callback, time) {
-        return wrappedSetTimeout(function () {
-          if (!editor.removed) {
-            callback();
-          }
-        }, time);
-      },
-      setEditorInterval: function (editor, callback, time) {
-        var timer;
-        timer = wrappedSetInterval(function () {
-          if (!editor.removed) {
-            callback();
-          } else {
-            domGlobals.clearInterval(timer);
-          }
-        }, time);
-        return timer;
-      },
-      debounce: debounce,
-      throttle: debounce,
-      clearInterval: wrappedClearInterval,
-      clearTimeout: wrappedClearTimeout
+    var getOrDie = function (name, scope) {
+      var actual = unsafe(name, scope);
+      if (actual === undefined || actual === null)
+        throw name + ' not available on this browser';
+      return actual;
     };
+    var Global$1 = { getOrDie: getOrDie };
 
-    var eventExpandoPrefix = 'mce-data-';
-    var mouseEventRe = /^(?:mouse|contextmenu)|click/;
-    var deprecated = {
-      keyLocation: 1,
-      layerX: 1,
-      layerY: 1,
-      returnValue: 1,
-      webkitMovementX: 1,
-      webkitMovementY: 1,
-      keyIdentifier: 1
+    var url = function () {
+      return Global$1.getOrDie('URL');
     };
-    var hasIsDefaultPrevented = function (event) {
-      return event.isDefaultPrevented === returnTrue || event.isDefaultPrevented === returnFalse;
+    var createObjectURL = function (blob) {
+      return url().createObjectURL(blob);
     };
-    var returnFalse = function () {
-      return false;
+    var revokeObjectURL = function (u) {
+      url().revokeObjectURL(u);
     };
-    var returnTrue = function () {
-      return true;
+    var URL = {
+      createObjectURL: createObjectURL,
+      revokeObjectURL: revokeObjectURL
     };
-    var addEvent = function (target, name, callback, capture) {
-      if (target.addEventListener) {
-        target.addEventListener(name, callback, capture || false);
-      } else if (target.attachEvent) {
-        target.attachEvent('on' + name, callback);
-      }
+
+    var nav = domGlobals.navigator, userAgent = nav.userAgent;
+    var opera, webkit, ie, ie11, ie12, gecko, mac, iDevice, android, fileApi, phone, tablet, windowsPhone;
+    var matchMediaQuery = function (query) {
+      return 'matchMedia' in domGlobals.window ? domGlobals.matchMedia(query).matches : false;
     };
-    var removeEvent = function (target, name, callback, capture) {
-      if (target.removeEventListener) {
-        target.removeEventListener(name, callback, capture || false);
-      } else if (target.detachEvent) {
-        target.detachEvent('on' + name, callback);
-      }
+    opera = false;
+    android = /Android/.test(userAgent);
+    webkit = /WebKit/.test(userAgent);
+    ie = !webkit && !opera && /MSIE/gi.test(userAgent) && /Explorer/gi.test(nav.appName);
+    ie = ie && /MSIE (\w+)\./.exec(userAgent)[1];
+    ie11 = userAgent.indexOf('Trident/') !== -1 && (userAgent.indexOf('rv:') !== -1 || nav.appName.indexOf('Netscape') !== -1) ? 11 : false;
+    ie12 = userAgent.indexOf('Edge/') !== -1 && !ie && !ie11 ? 12 : false;
+    ie = ie || ie11 || ie12;
+    gecko = !webkit && !ie11 && /Gecko/.test(userAgent);
+    mac = userAgent.indexOf('Mac') !== -1;
+    iDevice = /(iPad|iPhone)/.test(userAgent);
+    fileApi = 'FormData' in domGlobals.window && 'FileReader' in domGlobals.window && 'URL' in domGlobals.window && !!URL.createObjectURL;
+    phone = matchMediaQuery('only screen and (max-device-width: 480px)') && (android || iDevice);
+    tablet = matchMediaQuery('only screen and (min-width: 800px)') && (android || iDevice);
+    windowsPhone = userAgent.indexOf('Windows Phone') !== -1;
+    if (ie12) {
+      webkit = false;
+    }
+    var contentEditable = !iDevice || fileApi || parseInt(userAgent.match(/AppleWebKit\/(\d*)/)[1], 10) >= 534;
+    var Env = {
+      opera: opera,
+      webkit: webkit,
+      ie: ie,
+      gecko: gecko,
+      mac: mac,
+      iOS: iDevice,
+      android: android,
+      contentEditable: contentEditable,
+      transparentSrc: 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7',
+      caretAfter: ie !== 8,
+      range: domGlobals.window.getSelection && 'Range' in domGlobals.window,
+      documentMode: ie && !ie12 ? domGlobals.document.documentMode || 7 : 10,
+      fileApi: fileApi,
+      ceFalse: ie === false || ie > 8,
+      cacheSuffix: null,
+      container: null,
+      experimentalShadowDom: false,
+      canHaveCSP: ie === false || ie > 11,
+      desktop: !phone && !tablet,
+      windowsPhone: windowsPhone
     };
-    var getTargetFromShadowDom = function (event, defaultTarget) {
-      if (event.composedPath) {
-        var composedPath = event.composedPath();
-        if (composedPath && composedPath.length > 0) {
-          return composedPath[0];
+
+    var promise = function () {
+      function bind(fn, thisArg) {
+        return function () {
+          fn.apply(thisArg, arguments);
+        };
+      }
+      var isArray = Array.isArray || function (value) {
+        return Object.prototype.toString.call(value) === '[object Array]';
+      };
+      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 asap = Promise.immediateFn || typeof domGlobals.setImmediate === 'function' && domGlobals.setImmediate || function (fn) {
+        domGlobals.setTimeout(fn, 1);
+      };
+      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);
+        });
       }
-      return defaultTarget;
-    };
-    var fix = function (originalEvent, data) {
-      var name;
-      var event = data || {};
-      for (name in originalEvent) {
-        if (!deprecated[name]) {
-          event[name] = originalEvent[name];
+      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);
         }
       }
-      if (!event.target) {
-        event.target = event.srcElement || domGlobals.document;
+      function reject(newValue) {
+        this._state = false;
+        this._value = newValue;
+        finale.call(this);
       }
-      if (Env.experimentalShadowDom) {
-        event.target = getTargetFromShadowDom(originalEvent, event.target);
+      function finale() {
+        for (var i = 0, len = this._deferreds.length; i < len; i++) {
+          handle.call(this, this._deferreds[i]);
+        }
+        this._deferreds = null;
       }
-      if (originalEvent && mouseEventRe.test(originalEvent.type) && originalEvent.pageX === undefined && originalEvent.clientX !== undefined) {
-        var eventDoc = event.target.ownerDocument || domGlobals.document;
-        var doc = eventDoc.documentElement;
-        var body = eventDoc.body;
-        event.pageX = originalEvent.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
-        event.pageY = originalEvent.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
+      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;
       }
-      event.preventDefault = function () {
-        event.isDefaultPrevented = returnTrue;
-        if (originalEvent) {
-          if (originalEvent.preventDefault) {
-            originalEvent.preventDefault();
-          } else {
-            originalEvent.returnValue = false;
+      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);
       };
-      event.stopPropagation = function () {
-        event.isPropagationStopped = returnTrue;
-        if (originalEvent) {
-          if (originalEvent.stopPropagation) {
-            originalEvent.stopPropagation();
-          } else {
-            originalEvent.cancelBubble = true;
+      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);
+        });
       };
-      event.stopImmediatePropagation = function () {
-        event.isImmediatePropagationStopped = returnTrue;
-        event.stopPropagation();
+      Promise.reject = function (value) {
+        return new Promise(function (resolve, reject) {
+          reject(value);
+        });
       };
-      if (hasIsDefaultPrevented(event) === false) {
-        event.isDefaultPrevented = returnFalse;
-        event.isPropagationStopped = returnFalse;
-        event.isImmediatePropagationStopped = returnFalse;
+      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;
+    };
+    var promiseObj = window.Promise ? window.Promise : promise();
+
+    var requestAnimationFramePromise;
+    var requestAnimationFrame = function (callback, element) {
+      var i, requestAnimationFrameFunc = domGlobals.window.requestAnimationFrame;
+      var vendors = [
+        'ms',
+        'moz',
+        'webkit'
+      ];
+      var featurefill = function (callback) {
+        domGlobals.window.setTimeout(callback, 0);
+      };
+      for (i = 0; i < vendors.length && !requestAnimationFrameFunc; i++) {
+        requestAnimationFrameFunc = domGlobals.window[vendors[i] + 'RequestAnimationFrame'];
       }
-      if (typeof event.metaKey === 'undefined') {
-        event.metaKey = false;
+      if (!requestAnimationFrameFunc) {
+        requestAnimationFrameFunc = featurefill;
       }
-      return event;
+      requestAnimationFrameFunc(callback, element);
     };
-    var bindOnReady = function (win, callback, eventUtils) {
-      var doc = win.document, event = { type: 'ready' };
-      if (eventUtils.domLoaded) {
-        callback(event);
-        return;
+    var wrappedSetTimeout = function (callback, time) {
+      if (typeof time !== 'number') {
+        time = 0;
       }
-      var isDocReady = function () {
-        return doc.readyState === 'complete' || doc.readyState === 'interactive' && doc.body;
-      };
-      var readyHandler = function () {
-        removeEvent(win, 'DOMContentLoaded', readyHandler);
-        removeEvent(win, 'load', readyHandler);
-        if (!eventUtils.domLoaded) {
-          eventUtils.domLoaded = true;
-          callback(event);
+      return domGlobals.setTimeout(callback, time);
+    };
+    var wrappedSetInterval = function (callback, time) {
+      if (typeof time !== 'number') {
+        time = 1;
+      }
+      return domGlobals.setInterval(callback, time);
+    };
+    var wrappedClearTimeout = function (id) {
+      return domGlobals.clearTimeout(id);
+    };
+    var wrappedClearInterval = function (id) {
+      return domGlobals.clearInterval(id);
+    };
+    var debounce = function (callback, time) {
+      var timer, func;
+      func = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
         }
-      };
-      var waitForDomLoaded = function () {
+        domGlobals.clearTimeout(timer);
+        timer = wrappedSetTimeout(function () {
+          callback.apply(this, args);
+        }, time);
+      };
+      func.stop = function () {
+        domGlobals.clearTimeout(timer);
+      };
+      return func;
+    };
+    var Delay = {
+      requestAnimationFrame: function (callback, element) {
+        if (requestAnimationFramePromise) {
+          requestAnimationFramePromise.then(callback);
+          return;
+        }
+        requestAnimationFramePromise = new promiseObj(function (resolve) {
+          if (!element) {
+            element = domGlobals.document.body;
+          }
+          requestAnimationFrame(resolve, element);
+        }).then(callback);
+      },
+      setTimeout: wrappedSetTimeout,
+      setInterval: wrappedSetInterval,
+      setEditorTimeout: function (editor, callback, time) {
+        return wrappedSetTimeout(function () {
+          if (!editor.removed) {
+            callback();
+          }
+        }, time);
+      },
+      setEditorInterval: function (editor, callback, time) {
+        var timer;
+        timer = wrappedSetInterval(function () {
+          if (!editor.removed) {
+            callback();
+          } else {
+            domGlobals.clearInterval(timer);
+          }
+        }, time);
+        return timer;
+      },
+      debounce: debounce,
+      throttle: debounce,
+      clearInterval: wrappedClearInterval,
+      clearTimeout: wrappedClearTimeout
+    };
+
+    var eventExpandoPrefix = 'mce-data-';
+    var mouseEventRe = /^(?:mouse|contextmenu)|click/;
+    var deprecated = {
+      keyLocation: 1,
+      layerX: 1,
+      layerY: 1,
+      returnValue: 1,
+      webkitMovementX: 1,
+      webkitMovementY: 1,
+      keyIdentifier: 1
+    };
+    var hasIsDefaultPrevented = function (event) {
+      return event.isDefaultPrevented === returnTrue || event.isDefaultPrevented === returnFalse;
+    };
+    var returnFalse = function () {
+      return false;
+    };
+    var returnTrue = function () {
+      return true;
+    };
+    var addEvent = function (target, name, callback, capture) {
+      if (target.addEventListener) {
+        target.addEventListener(name, callback, capture || false);
+      } else if (target.attachEvent) {
+        target.attachEvent('on' + name, callback);
+      }
+    };
+    var removeEvent = function (target, name, callback, capture) {
+      if (target.removeEventListener) {
+        target.removeEventListener(name, callback, capture || false);
+      } else if (target.detachEvent) {
+        target.detachEvent('on' + name, callback);
+      }
+    };
+    var getTargetFromShadowDom = function (event, defaultTarget) {
+      if (event.composedPath) {
+        var composedPath = event.composedPath();
+        if (composedPath && composedPath.length > 0) {
+          return composedPath[0];
+        }
+      }
+      return defaultTarget;
+    };
+    var fix = function (originalEvent, data) {
+      var name;
+      var event = data || {};
+      for (name in originalEvent) {
+        if (!deprecated[name]) {
+          event[name] = originalEvent[name];
+        }
+      }
+      if (!event.target) {
+        event.target = event.srcElement || domGlobals.document;
+      }
+      if (Env.experimentalShadowDom) {
+        event.target = getTargetFromShadowDom(originalEvent, event.target);
+      }
+      if (originalEvent && mouseEventRe.test(originalEvent.type) && originalEvent.pageX === undefined && originalEvent.clientX !== undefined) {
+        var eventDoc = event.target.ownerDocument || domGlobals.document;
+        var doc = eventDoc.documentElement;
+        var body = eventDoc.body;
+        event.pageX = originalEvent.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
+        event.pageY = originalEvent.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
+      }
+      event.preventDefault = function () {
+        event.isDefaultPrevented = returnTrue;
+        if (originalEvent) {
+          if (originalEvent.preventDefault) {
+            originalEvent.preventDefault();
+          } else {
+            originalEvent.returnValue = false;
+          }
+        }
+      };
+      event.stopPropagation = function () {
+        event.isPropagationStopped = returnTrue;
+        if (originalEvent) {
+          if (originalEvent.stopPropagation) {
+            originalEvent.stopPropagation();
+          } else {
+            originalEvent.cancelBubble = true;
+          }
+        }
+      };
+      event.stopImmediatePropagation = function () {
+        event.isImmediatePropagationStopped = returnTrue;
+        event.stopPropagation();
+      };
+      if (hasIsDefaultPrevented(event) === false) {
+        event.isDefaultPrevented = returnFalse;
+        event.isPropagationStopped = returnFalse;
+        event.isImmediatePropagationStopped = returnFalse;
+      }
+      if (typeof event.metaKey === 'undefined') {
+        event.metaKey = false;
+      }
+      return event;
+    };
+    var bindOnReady = function (win, callback, eventUtils) {
+      var doc = win.document, event = { type: 'ready' };
+      if (eventUtils.domLoaded) {
+        callback(event);
+        return;
+      }
+      var isDocReady = function () {
+        return doc.readyState === 'complete' || doc.readyState === 'interactive' && doc.body;
+      };
+      var readyHandler = function () {
+        removeEvent(win, 'DOMContentLoaded', readyHandler);
+        removeEvent(win, 'load', readyHandler);
+        if (!eventUtils.domLoaded) {
+          eventUtils.domLoaded = true;
+          callback(event);
+        }
+      };
+      var waitForDomLoaded = function () {
         if (isDocReady()) {
           removeEvent(doc, 'readystatechange', waitForDomLoaded);
           readyHandler();
@@ -3753,6 +4100,7 @@
     };
     var isElement = isType$1(ELEMENT);
     var isText = isType$1(TEXT);
+    var isDocument = isType$1(DOCUMENT);
 
     var keys = Object.keys;
     var hasOwnProperty$1 = Object.hasOwnProperty;
@@ -3854,6 +4202,9 @@
         return r.length > 0;
       });
     };
+    var reflow = function (e) {
+      return e.dom().offsetWidth;
+    };
 
     var Immutable = function () {
       var fields = [];
@@ -4044,6 +4395,9 @@
         return 0;
       }
     };
+    var hasChild = function (elm, child) {
+      return elm.children && contains(elm.children, child);
+    };
     var getPos = function (body, elm, rootElm) {
       var x = 0, y = 0, offsetParent;
       var doc = body.ownerDocument;
@@ -4060,13 +4414,13 @@
           };
         }
         offsetParent = elm;
-        while (offsetParent && offsetParent !== rootElm && offsetParent.nodeType) {
+        while (offsetParent && offsetParent !== rootElm && offsetParent.nodeType && !hasChild(offsetParent, rootElm)) {
           x += offsetParent.offsetLeft || 0;
           y += offsetParent.offsetTop || 0;
           offsetParent = offsetParent.offsetParent;
         }
         offsetParent = elm.parentNode;
-        while (offsetParent && offsetParent !== rootElm && offsetParent.nodeType) {
+        while (offsetParent && offsetParent !== rootElm && offsetParent.nodeType && !hasChild(offsetParent, rootElm)) {
           x -= offsetParent.scrollLeft || 0;
           y -= offsetParent.scrollTop || 0;
           offsetParent = offsetParent.parentNode;
@@ -4497,6 +4851,9 @@
         return !!node && node.nodeType === type;
       };
     };
+    var isRestrictedNode = function (node) {
+      return !!node && !Object.getPrototypeOf(node);
+    };
     var isElement$1 = isNodeType(1);
     var matchNodeNames = function (names) {
       var items = names.toLowerCase().split(' ');
@@ -4568,7 +4925,7 @@
     };
     var isText$1 = isNodeType(3);
     var isComment = isNodeType(8);
-    var isDocument = isNodeType(9);
+    var isDocument$1 = isNodeType(9);
     var isDocumentFragment = isNodeType(11);
     var isBr = matchNodeNames('br');
     var isContentEditableTrue = hasContentEditableState('true');
@@ -4577,11 +4934,12 @@
       isText: isText$1,
       isElement: isElement$1,
       isComment: isComment,
-      isDocument: isDocument,
+      isDocument: isDocument$1,
       isDocumentFragment: isDocumentFragment,
       isBr: isBr,
       isContentEditableTrue: isContentEditableTrue,
       isContentEditableFalse: isContentEditableFalse,
+      isRestrictedNode: isRestrictedNode,
       matchNodeNames: matchNodeNames,
       hasPropValue: hasPropValue,
       hasAttribute: hasAttribute,
@@ -6399,10 +6757,11 @@
             return;
           }
           files[url] = true;
-          link = create('link', {
+          link = create('link', __assign({
             rel: 'stylesheet',
+            type: 'text/css',
             href: url
-          });
+          }, settings.contentCssCors ? { crossOrigin: 'anonymous' } : {}));
           head.appendChild(link);
         });
       };
@@ -6808,455 +7167,98 @@
       };
       ScriptLoader.prototype.add = function (url, success, scope, failure) {
         var state = this.states[url];
-        if (state === undefined) {
-          this.queue.push(url);
-          this.states[url] = QUEUED;
-        }
-        if (success) {
-          if (!this.scriptLoadedCallbacks[url]) {
-            this.scriptLoadedCallbacks[url] = [];
-          }
-          this.scriptLoadedCallbacks[url].push({
-            success: success,
-            failure: failure,
-            scope: scope || this
-          });
-        }
-      };
-      ScriptLoader.prototype.load = function (url, success, scope, failure) {
-        return this.add(url, success, scope, failure);
-      };
-      ScriptLoader.prototype.remove = function (url) {
-        delete this.states[url];
-        delete this.scriptLoadedCallbacks[url];
-      };
-      ScriptLoader.prototype.loadQueue = function (success, scope, failure) {
-        this.loadScripts(this.queue, success, scope, failure);
-      };
-      ScriptLoader.prototype.loadScripts = function (scripts, success, scope, failure) {
-        var self = this;
-        var loadScripts;
-        var failures = [];
-        var execCallbacks = function (name, url) {
-          each$6(self.scriptLoadedCallbacks[url], function (callback) {
-            if (isFunction(callback[name])) {
-              callback[name].call(callback.scope);
-            }
-          });
-          self.scriptLoadedCallbacks[url] = undefined;
-        };
-        self.queueLoadedCallbacks.push({
-          success: success,
-          failure: failure,
-          scope: scope || this
-        });
-        loadScripts = function () {
-          var loadingScripts = grep$2(scripts);
-          scripts.length = 0;
-          each$6(loadingScripts, function (url) {
-            if (self.states[url] === LOADED) {
-              execCallbacks('success', url);
-              return;
-            }
-            if (self.states[url] === FAILED) {
-              execCallbacks('failure', url);
-              return;
-            }
-            if (self.states[url] !== LOADING) {
-              self.states[url] = LOADING;
-              self.loading++;
-              self.loadScript(url, function () {
-                self.states[url] = LOADED;
-                self.loading--;
-                execCallbacks('success', url);
-                loadScripts();
-              }, function () {
-                self.states[url] = FAILED;
-                self.loading--;
-                failures.push(url);
-                execCallbacks('failure', url);
-                loadScripts();
-              });
-            }
-          });
-          if (!self.loading) {
-            var notifyCallbacks = self.queueLoadedCallbacks.slice(0);
-            self.queueLoadedCallbacks.length = 0;
-            each$6(notifyCallbacks, function (callback) {
-              if (failures.length === 0) {
-                if (isFunction(callback.success)) {
-                  callback.success.call(callback.scope);
-                }
-              } else {
-                if (isFunction(callback.failure)) {
-                  callback.failure.call(callback.scope, failures);
-                }
-              }
-            });
-          }
-        };
-        loadScripts();
-      };
-      ScriptLoader.ScriptLoader = new ScriptLoader();
-      return ScriptLoader;
-    }();
-
-    var extendStatics = function (d, b) {
-      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function (d, b) {
-        d.__proto__ = b;
-      } || function (d, b) {
-        for (var p in b)
-          if (b.hasOwnProperty(p))
-            d[p] = b[p];
-      };
-      return extendStatics(d, b);
-    };
-    function __extends(d, b) {
-      extendStatics(d, b);
-      function __() {
-        this.constructor = d;
-      }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-    var __assign = function () {
-      __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-          s = arguments[i];
-          for (var p in s)
-            if (Object.prototype.hasOwnProperty.call(s, p))
-              t[p] = s[p];
-        }
-        return t;
-      };
-      return __assign.apply(this, arguments);
-    };
-    function __rest(s, e) {
-      var t = {};
-      for (var p in s)
-        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-          t[p] = s[p];
-      if (s != null && typeof Object.getOwnPropertySymbols === 'function')
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++)
-          if (e.indexOf(p[i]) < 0)
-            t[p[i]] = s[p[i]];
-      return t;
-    }
-    function __decorate(decorators, target, key, desc) {
-      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-      if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function')
-        r = Reflect.decorate(decorators, target, key, desc);
-      else
-        for (var i = decorators.length - 1; i >= 0; i--)
-          if (d = decorators[i])
-            r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-      return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
-    function __param(paramIndex, decorator) {
-      return function (target, key) {
-        decorator(target, key, paramIndex);
-      };
-    }
-    function __metadata(metadataKey, metadataValue) {
-      if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function')
-        return Reflect.metadata(metadataKey, metadataValue);
-    }
-    function __awaiter(thisArg, _arguments, P, generator) {
-      return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) {
-          try {
-            step(generator.next(value));
-          } catch (e) {
-            reject(e);
-          }
-        }
-        function rejected(value) {
-          try {
-            step(generator['throw'](value));
-          } catch (e) {
-            reject(e);
-          }
-        }
-        function step(result) {
-          result.done ? resolve(result.value) : new P(function (resolve) {
-            resolve(result.value);
-          }).then(fulfilled, rejected);
-        }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-      });
-    }
-    function __generator(thisArg, body) {
-      var _ = {
-          label: 0,
-          sent: function () {
-            if (t[0] & 1)
-              throw t[1];
-            return t[1];
-          },
-          trys: [],
-          ops: []
-        }, f, y, t, g;
-      return g = {
-        next: verb(0),
-        'throw': verb(1),
-        'return': verb(2)
-      }, typeof Symbol === 'function' && (g[Symbol.iterator] = function () {
-        return this;
-      }), g;
-      function verb(n) {
-        return function (v) {
-          return step([
-            n,
-            v
-          ]);
-        };
-      }
-      function step(op) {
-        if (f)
-          throw new TypeError('Generator is already executing.');
-        while (_)
-          try {
-            if (f = 1, y && (t = op[0] & 2 ? y['return'] : op[0] ? y['throw'] || ((t = y['return']) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
-              return t;
-            if (y = 0, t)
-              op = [
-                op[0] & 2,
-                t.value
-              ];
-            switch (op[0]) {
-            case 0:
-            case 1:
-              t = op;
-              break;
-            case 4:
-              _.label++;
-              return {
-                value: op[1],
-                done: false
-              };
-            case 5:
-              _.label++;
-              y = op[1];
-              op = [0];
-              continue;
-            case 7:
-              op = _.ops.pop();
-              _.trys.pop();
-              continue;
-            default:
-              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                _ = 0;
-                continue;
-              }
-              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                _.label = op[1];
-                break;
-              }
-              if (op[0] === 6 && _.label < t[1]) {
-                _.label = t[1];
-                t = op;
-                break;
-              }
-              if (t && _.label < t[2]) {
-                _.label = t[2];
-                _.ops.push(op);
-                break;
-              }
-              if (t[2])
-                _.ops.pop();
-              _.trys.pop();
-              continue;
-            }
-            op = body.call(thisArg, _);
-          } catch (e) {
-            op = [
-              6,
-              e
-            ];
-            y = 0;
-          } finally {
-            f = t = 0;
-          }
-        if (op[0] & 5)
-          throw op[1];
-        return {
-          value: op[0] ? op[1] : void 0,
-          done: true
-        };
-      }
-    }
-    function __exportStar(m, exports) {
-      for (var p in m)
-        if (!exports.hasOwnProperty(p))
-          exports[p] = m[p];
-    }
-    function __values(o) {
-      var m = typeof Symbol === 'function' && o[Symbol.iterator], i = 0;
-      if (m)
-        return m.call(o);
-      return {
-        next: function () {
-          if (o && i >= o.length)
-            o = void 0;
-          return {
-            value: o && o[i++],
-            done: !o
-          };
-        }
-      };
-    }
-    function __read(o, n) {
-      var m = typeof Symbol === 'function' && o[Symbol.iterator];
-      if (!m)
-        return o;
-      var i = m.call(o), r, ar = [], e;
-      try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
-          ar.push(r.value);
-      } catch (error) {
-        e = { error: error };
-      } finally {
-        try {
-          if (r && !r.done && (m = i['return']))
-            m.call(i);
-        } finally {
-          if (e)
-            throw e.error;
-        }
-      }
-      return ar;
-    }
-    function __spread() {
-      for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-      return ar;
-    }
-    function __await(v) {
-      return this instanceof __await ? (this.v = v, this) : new __await(v);
-    }
-    function __asyncGenerator(thisArg, _arguments, generator) {
-      if (!Symbol.asyncIterator)
-        throw new TypeError('Symbol.asyncIterator is not defined.');
-      var g = generator.apply(thisArg, _arguments || []), i, q = [];
-      return i = {}, verb('next'), verb('throw'), verb('return'), i[Symbol.asyncIterator] = function () {
-        return this;
-      }, i;
-      function verb(n) {
-        if (g[n])
-          i[n] = function (v) {
-            return new Promise(function (a, b) {
-              q.push([
-                n,
-                v,
-                a,
-                b
-              ]) > 1 || resume(n, v);
-            });
-          };
-      }
-      function resume(n, v) {
-        try {
-          step(g[n](v));
-        } catch (e) {
-          settle(q[0][3], e);
+        if (state === undefined) {
+          this.queue.push(url);
+          this.states[url] = QUEUED;
         }
-      }
-      function step(r) {
-        r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
-      }
-      function fulfill(value) {
-        resume('next', value);
-      }
-      function reject(value) {
-        resume('throw', value);
-      }
-      function settle(f, v) {
-        if (f(v), q.shift(), q.length)
-          resume(q[0][0], q[0][1]);
-      }
-    }
-    function __asyncDelegator(o) {
-      var i, p;
-      return i = {}, verb('next'), verb('throw', function (e) {
-        throw e;
-      }), verb('return'), i[Symbol.iterator] = function () {
-        return this;
-      }, i;
-      function verb(n, f) {
-        i[n] = o[n] ? function (v) {
-          return (p = !p) ? {
-            value: __await(o[n](v)),
-            done: n === 'return'
-          } : f ? f(v) : v;
-        } : f;
-      }
-    }
-    function __asyncValues(o) {
-      if (!Symbol.asyncIterator)
-        throw new TypeError('Symbol.asyncIterator is not defined.');
-      var m = o[Symbol.asyncIterator], i;
-      return m ? m.call(o) : (o = typeof __values === 'function' ? __values(o) : o[Symbol.iterator](), i = {}, verb('next'), verb('throw'), verb('return'), i[Symbol.asyncIterator] = function () {
-        return this;
-      }, i);
-      function verb(n) {
-        i[n] = o[n] && function (v) {
-          return new Promise(function (resolve, reject) {
-            v = o[n](v), settle(resolve, reject, v.done, v.value);
+        if (success) {
+          if (!this.scriptLoadedCallbacks[url]) {
+            this.scriptLoadedCallbacks[url] = [];
+          }
+          this.scriptLoadedCallbacks[url].push({
+            success: success,
+            failure: failure,
+            scope: scope || this
+          });
+        }
+      };
+      ScriptLoader.prototype.load = function (url, success, scope, failure) {
+        return this.add(url, success, scope, failure);
+      };
+      ScriptLoader.prototype.remove = function (url) {
+        delete this.states[url];
+        delete this.scriptLoadedCallbacks[url];
+      };
+      ScriptLoader.prototype.loadQueue = function (success, scope, failure) {
+        this.loadScripts(this.queue, success, scope, failure);
+      };
+      ScriptLoader.prototype.loadScripts = function (scripts, success, scope, failure) {
+        var self = this;
+        var loadScripts;
+        var failures = [];
+        var execCallbacks = function (name, url) {
+          each$6(self.scriptLoadedCallbacks[url], function (callback) {
+            if (isFunction(callback[name])) {
+              callback[name].call(callback.scope);
+            }
           });
+          self.scriptLoadedCallbacks[url] = undefined;
         };
-      }
-      function settle(resolve, reject, d, v) {
-        Promise.resolve(v).then(function (v) {
-          resolve({
-            value: v,
-            done: d
+        self.queueLoadedCallbacks.push({
+          success: success,
+          failure: failure,
+          scope: scope || this
+        });
+        loadScripts = function () {
+          var loadingScripts = grep$2(scripts);
+          scripts.length = 0;
+          each$6(loadingScripts, function (url) {
+            if (self.states[url] === LOADED) {
+              execCallbacks('success', url);
+              return;
+            }
+            if (self.states[url] === FAILED) {
+              execCallbacks('failure', url);
+              return;
+            }
+            if (self.states[url] !== LOADING) {
+              self.states[url] = LOADING;
+              self.loading++;
+              self.loadScript(url, function () {
+                self.states[url] = LOADED;
+                self.loading--;
+                execCallbacks('success', url);
+                loadScripts();
+              }, function () {
+                self.states[url] = FAILED;
+                self.loading--;
+                failures.push(url);
+                execCallbacks('failure', url);
+                loadScripts();
+              });
+            }
           });
-        }, reject);
-      }
-    }
-    function __makeTemplateObject(cooked, raw) {
-      if (Object.defineProperty) {
-        Object.defineProperty(cooked, 'raw', { value: raw });
-      } else {
-        cooked.raw = raw;
-      }
-      return cooked;
-    }
-    function __importStar(mod) {
-      if (mod && mod.__esModule)
-        return mod;
-      var result = {};
-      if (mod != null)
-        for (var k in mod)
-          if (Object.hasOwnProperty.call(mod, k))
-            result[k] = mod[k];
-      result.default = mod;
-      return result;
-    }
-    function __importDefault(mod) {
-      return mod && mod.__esModule ? mod : { default: mod };
-    }
-
-    var tslib_1 = /*#__PURE__*/Object.freeze({
-        __extends: __extends,
-        get __assign () { return __assign; },
-        __rest: __rest,
-        __decorate: __decorate,
-        __param: __param,
-        __metadata: __metadata,
-        __awaiter: __awaiter,
-        __generator: __generator,
-        __exportStar: __exportStar,
-        __values: __values,
-        __read: __read,
-        __spread: __spread,
-        __await: __await,
-        __asyncGenerator: __asyncGenerator,
-        __asyncDelegator: __asyncDelegator,
-        __asyncValues: __asyncValues,
-        __makeTemplateObject: __makeTemplateObject,
-        __importStar: __importStar,
-        __importDefault: __importDefault
-    });
+          if (!self.loading) {
+            var notifyCallbacks = self.queueLoadedCallbacks.slice(0);
+            self.queueLoadedCallbacks.length = 0;
+            each$6(notifyCallbacks, function (callback) {
+              if (failures.length === 0) {
+                if (isFunction(callback.success)) {
+                  callback.success.call(callback.scope);
+                }
+              } else {
+                if (isFunction(callback.failure)) {
+                  callback.failure.call(callback.scope, failures);
+                }
+              }
+            });
+          }
+        };
+        loadScripts();
+      };
+      ScriptLoader.ScriptLoader = new ScriptLoader();
+      return ScriptLoader;
+    }();
 
     var Cell = function (initial) {
       var value = initial;
@@ -8277,26 +8279,6 @@
     var containsXY = function (rect, clientX, clientY) {
       return clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom;
     };
-    var overflowX = function (outer, inner) {
-      if (inner.left > outer.left && inner.right < outer.right) {
-        return 0;
-      } else {
-        return inner.left < outer.left ? inner.left - outer.left : inner.right - outer.right;
-      }
-    };
-    var overflowY = function (outer, inner) {
-      if (inner.top > outer.top && inner.bottom < outer.bottom) {
-        return 0;
-      } else {
-        return inner.top < outer.top ? inner.top - outer.top : inner.bottom - outer.bottom;
-      }
-    };
-    var getOverflow = function (outer, inner) {
-      return {
-        x: overflowX(outer, inner),
-        y: overflowY(outer, inner)
-      };
-    };
 
     var getSelectedNode = function (range) {
       var startContainer = range.startContainer, startOffset = range.startOffset;
@@ -11306,7 +11288,7 @@
       return editor.getParam('end_container_on_empty_block', false);
     };
     var getFontStyleValues = function (editor) {
-      return Tools.explode(editor.getParam('font_size_style_values', ''));
+      return Tools.explode(editor.getParam('font_size_style_values', 'xx-small,x-small,small,medium,large,x-large,xx-large'));
     };
     var getFontSizeClasses = function (editor) {
       return Tools.explode(editor.getParam('font_size_classes', ''));
@@ -11323,6 +11305,12 @@
     var shouldReplaceBlobUris = function (editor) {
       return editor.getParam('images_replace_blob_uris', true, 'boolean');
     };
+    var getIconPackName = function (editor) {
+      return editor.getParam('icons', '', 'string');
+    };
+    var getIconsUrl = function (editor) {
+      return editor.getParam('icons_url', '', 'string');
+    };
     var getImageUploadUrl = function (editor) {
       return editor.getParam('images_upload_url', '', 'string');
     };
@@ -11365,6 +11353,9 @@
     var getDirectionality = function (editor) {
       return editor.getParam('directionality', I18n.isRtl() ? 'rtl' : undefined);
     };
+    var getInlineBoundarySelector = function (editor) {
+      return editor.getParam('inline_boundaries_selector', 'a[href],code,.mce-annotation', 'string');
+    };
     var Settings = {
       getIframeAttrs: getIframeAttrs,
       getDocType: getDocType,
@@ -11381,6 +11372,8 @@
       shouldEndContainerOnEmptyBlock: shouldEndContainerOnEmptyBlock,
       getFontStyleValues: getFontStyleValues,
       getFontSizeClasses: getFontSizeClasses,
+      getIconPackName: getIconPackName,
+      getIconsUrl: getIconsUrl,
       getImagesDataImgFilter: getImagesDataImgFilter,
       isAutomaticUploadsEnabled: isAutomaticUploadsEnabled,
       shouldReuseFileName: shouldReuseFileName,
@@ -11395,7 +11388,8 @@
       shouldIndentUseMargin: shouldIndentUseMargin,
       getIndentation: getIndentation,
       getContentCss: getContentCss,
-      getDirectionality: getDirectionality
+      getDirectionality: getDirectionality,
+      getInlineBoundarySelector: getInlineBoundarySelector
     };
 
     var defaultFormat = 'html';
@@ -11759,6 +11753,9 @@
     };
     var Adt = { generate: generate$1 };
 
+    var create$3 = Immutable('start', 'soffset', 'finish', 'foffset');
+    var SimRange = { create: create$3 };
+
     var adt = Adt.generate([
       { before: ['element'] },
       {
@@ -11769,8 +11766,24 @@
       },
       { after: ['element'] }
     ]);
+    var cata = function (subject, onBefore, onOn, onAfter) {
+      return subject.fold(onBefore, onOn, onAfter);
+    };
+    var getStart = function (situ) {
+      return situ.fold(identity, identity, identity);
+    };
+    var before$3 = adt.before;
+    var on = adt.on;
+    var after$2 = adt.after;
+    var Situ = {
+      before: before$3,
+      on: on,
+      after: after$2,
+      cata: cata,
+      getStart: getStart
+    };
 
-    var type$1 = Adt.generate([
+    var adt$1 = Adt.generate([
       { domRange: ['rng'] },
       {
         relative: [
@@ -11787,7 +11800,38 @@
         ]
       }
     ]);
-    var range$1 = Immutable('start', 'soffset', 'finish', 'foffset');
+    var exactFromRange = function (simRange) {
+      return adt$1.exact(simRange.start(), simRange.soffset(), simRange.finish(), simRange.foffset());
+    };
+    var getStart$1 = function (selection) {
+      return selection.match({
+        domRange: function (rng) {
+          return Element.fromDom(rng.startContainer);
+        },
+        relative: function (startSitu, finishSitu) {
+          return Situ.getStart(startSitu);
+        },
+        exact: function (start, soffset, finish, foffset) {
+          return start;
+        }
+      });
+    };
+    var domRange = adt$1.domRange;
+    var relative = adt$1.relative;
+    var exact = adt$1.exact;
+    var getWin = function (selection) {
+      var start = getStart$1(selection);
+      return defaultView(start);
+    };
+    var range$1 = SimRange.create;
+    var Selection = {
+      domRange: domRange,
+      relative: relative,
+      exact: exact,
+      exactFromRange: exactFromRange,
+      getWin: getWin,
+      range: range$1
+    };
 
     var browser$3 = PlatformDetection$1.detect().browser;
     var clamp = function (offset, element) {
@@ -11800,10 +11844,10 @@
       return offset;
     };
     var normalizeRng = function (rng) {
-      return range$1(rng.start(), clamp(rng.soffset(), rng.start()), rng.finish(), clamp(rng.foffset(), rng.finish()));
+      return Selection.range(rng.start(), clamp(rng.soffset(), rng.start()), rng.finish(), clamp(rng.foffset(), rng.finish()));
     };
     var isOrContains = function (root, elm) {
-      return contains$3(root, elm) || eq(root, elm);
+      return !NodeType.isRestrictedNode(elm.dom()) && (contains$3(root, elm) || eq(root, elm));
     };
     var isRngInRoot = function (root) {
       return function (rng) {
@@ -11814,7 +11858,7 @@
       return editor.inline === true || browser$3.isIE();
     };
     var nativeRangeToSelectionRange = function (r) {
-      return range$1(Element.fromDom(r.startContainer), r.startOffset, Element.fromDom(r.endContainer), r.endOffset);
+      return Selection.range(Element.fromDom(r.startContainer), r.startOffset, Element.fromDom(r.endContainer), r.endOffset);
     };
     var readRange = function (win) {
       var selection = win.getSelection();
@@ -12191,7 +12235,6 @@
       return {
         id: id,
         theme: 'silver',
-        popup_css: '',
         plugins: '',
         document_base_url: documentBaseUrl,
         add_form_submit_trigger: true,
@@ -12203,11 +12246,9 @@
         object_resizing: true,
         doctype: '<!DOCTYPE html>',
         visual: true,
-        font_size_style_values: 'xx-small,x-small,small,medium,large,x-large,xx-large',
         font_size_legacy_values: 'xx-small,small,medium,large,x-large,xx-large,300%',
         forced_root_block: 'p',
         hidden_input: true,
-        render_ui: true,
         inline_styles: true,
         convert_fonts_to_spans: true,
         indent: true,
@@ -12215,8 +12256,7 @@
         indent_after: 'p,h1,h2,h3,h4,h5,h6,blockquote,div,title,style,pre,script,td,th,ul,ol,li,dl,dt,dd,area,table,thead,' + 'tfoot,tbody,tr,section,summary,article,hgroup,aside,figure,figcaption,option,optgroup,datalist',
         entity_encoding: 'named',
         url_converter: editor.convertURL,
-        url_converter_scope: editor,
-        ie7_compat: true
+        url_converter_scope: editor
       };
     };
     var getExternalPlugins = function (overrideSettings, settings) {
@@ -12256,7 +12296,6 @@
     var getFiltered = function (predicate, editor, name) {
       return Option.from(editor.settings[name]).filter(predicate);
     };
-    var getString = curry(getFiltered, isString);
     var getParamObject = function (value) {
       var output = {};
       if (typeof value === 'string') {
@@ -12536,27 +12575,6 @@
       };
     };
 
-    var PluginManager = AddOnManager$1.PluginManager;
-    var resolvePluginName = function (targetUrl, suffix) {
-      for (var name in PluginManager.urls) {
-        var matchUrl = PluginManager.urls[name] + '/plugin' + suffix + '.js';
-        if (matchUrl === targetUrl) {
-          return name;
-        }
-      }
-      return null;
-    };
-    var pluginUrlToMessage = function (editor, url) {
-      var plugin = resolvePluginName(url, editor.suffix);
-      return plugin ? I18n.translate([
-        'Failed to load plugin: {0} from url {1}',
-        plugin,
-        url
-      ]) : I18n.translate([
-        'Failed to load plugin url: {0}',
-        url
-      ]);
-    };
     var displayNotification = function (editor, message) {
       editor.notificationManager.open({
         type: 'error',
@@ -12578,8 +12596,20 @@
         message
       ]));
     };
-    var pluginLoadError = function (editor, url) {
-      displayError(editor, pluginUrlToMessage(editor, url));
+    var logError = function (msg) {
+      domGlobals.console.error(msg);
+    };
+    var createLoadError = function (type, url, name) {
+      return name ? 'Failed to load ' + type + ': ' + name + ' from url ' + url : 'Failed to load ' + type + ' url: ' + url;
+    };
+    var pluginLoadError = function (url, name) {
+      logError(createLoadError('plugin', url, name));
+    };
+    var iconsLoadError = function (url, name) {
+      logError(createLoadError('icons', url, name));
+    };
+    var languageLoadError = function (url, name) {
+      logError(createLoadError('language', url, name));
     };
     var pluginInitError = function (editor, name, err) {
       var message = I18n.translate([
@@ -12605,6 +12635,8 @@
     };
     var ErrorReporter = {
       pluginLoadError: pluginLoadError,
+      iconsLoadError: iconsLoadError,
+      languageLoadError: languageLoadError,
       pluginInitError: pluginInitError,
       uploadError: uploadError,
       displayError: displayError,
@@ -12791,7 +12823,7 @@
     };
     var IconManager = CreateIconManager();
 
-    var PluginManager$1 = AddOnManager$1.PluginManager;
+    var PluginManager = AddOnManager$1.PluginManager;
 
     var ThemeManager = AddOnManager$1.ThemeManager;
 
@@ -14255,9 +14287,17 @@
       if (range.collapsed) {
         return false;
       }
-      return foldl(range.getClientRects(), function (state, rect) {
-        return state || containsXY(rect, clientX, clientY);
-      }, false);
+      if (Env.ie <= 11 && range.startOffset === range.endOffset - 1 && range.startContainer === range.endContainer) {
+        var elm = range.startContainer.childNodes[range.startOffset];
+        if (NodeType.isElement(elm)) {
+          return exists(elm.getClientRects(), function (rect) {
+            return containsXY(rect, clientX, clientY);
+          });
+        }
+      }
+      return exists(range.getClientRects(), function (rect) {
+        return containsXY(rect, clientX, clientY);
+      });
     };
     var RangePoint = { isXYWithinRange: isXYWithinRange };
 
@@ -14668,7 +14708,7 @@
         if (startContainer.nodeType !== 1) {
           return null;
         }
-        if (endOffset === startOffset + 1) {
+        if (endOffset === startOffset + 1 && startContainer === range.endContainer) {
           node = startContainer.childNodes[startOffset];
         }
         if (!isContentEditableFalse$9(node)) {
@@ -16178,7 +16218,7 @@
             name = value;
             compareNode = 0;
           }
-          if (!compareNode || isEq$4(dom.getAttrib(compareNode, name), value)) {
+          if (format.remove_similar || (!compareNode || isEq$4(dom.getAttrib(compareNode, name), value))) {
             if (name === 'class') {
               value = dom.getAttrib(node, name);
               if (value) {
@@ -18583,7 +18623,6 @@
       var contextMenuSelectImage = function (evt) {
         var target = evt.target;
         if (isEventOnImageOutsideRange(evt, editor.selection.getRng()) && !evt.isDefaultPrevented()) {
-          evt.preventDefault();
           editor.selection.select(target);
         }
       };
@@ -18878,112 +18917,347 @@
           }
         });
         editor.on('hide blur', hideResizeRect);
-        editor.on('contextmenu', contextMenuSelectImage);
+        editor.on('contextmenu', contextMenuSelectImage, true);
       });
       editor.on('remove', unbindResizeHandleEvents);
       var destroy = function () {
         selectedElm = selectedElmGhost = null;
       };
       return {
-        isResizable: isResizable,
-        showResizeRect: showResizeRect,
-        hideResizeRect: hideResizeRect,
-        updateResizeRect: updateResizeRect,
-        destroy: destroy
+        isResizable: isResizable,
+        showResizeRect: showResizeRect,
+        hideResizeRect: hideResizeRect,
+        updateResizeRect: updateResizeRect,
+        destroy: destroy
+      };
+    };
+
+    function Dimension (name, getOffset) {
+      var set = function (element, h) {
+        if (!isNumber(h) && !h.match(/^[0-9]+$/)) {
+          throw new Error(name + '.set accepts only positive integer values. Value was ' + h);
+        }
+        var dom = element.dom();
+        if (isSupported(dom)) {
+          dom.style[name] = h + 'px';
+        }
+      };
+      var get = function (element) {
+        var r = getOffset(element);
+        if (r <= 0 || r === null) {
+          var css = get$2(element, name);
+          return parseFloat(css) || 0;
+        }
+        return r;
+      };
+      var getOuter = get;
+      var aggregate = function (element, properties) {
+        return foldl(properties, function (acc, property) {
+          var val = get$2(element, property);
+          var value = val === undefined ? 0 : parseInt(val, 10);
+          return isNaN(value) ? acc : acc + value;
+        }, 0);
+      };
+      var max = function (element, value, properties) {
+        var cumulativeInclusions = aggregate(element, properties);
+        var absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0;
+        return absoluteMax;
+      };
+      return {
+        set: set,
+        get: get,
+        getOuter: getOuter,
+        aggregate: aggregate,
+        max: max
+      };
+    }
+
+    var api$1 = Dimension('height', function (element) {
+      var dom = element.dom();
+      return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight;
+    });
+    var get$7 = function (element) {
+      return api$1.get(element);
+    };
+
+    var attached = function (element, scope) {
+      var doc = scope || Element.fromDom(domGlobals.document.documentElement);
+      return ancestor(element, curry(eq, doc)).isSome();
+    };
+    var windowOf = function (element) {
+      var dom = element.dom();
+      if (dom === dom.window && element instanceof domGlobals.Window) {
+        return element;
+      }
+      return isDocument(element) ? dom.defaultView || dom.parentWindow : null;
+    };
+
+    var r = function (left, top) {
+      var translate = function (x, y) {
+        return r(left + x, top + y);
+      };
+      return {
+        left: constant(left),
+        top: constant(top),
+        translate: translate
       };
     };
+    var Position$1 = r;
+
+    var boxPosition = function (dom) {
+      var box = dom.getBoundingClientRect();
+      return Position$1(box.left, box.top);
+    };
+    var firstDefinedOrZero = function (a, b) {
+      return a !== undefined ? a : b !== undefined ? b : 0;
+    };
+    var absolute = function (element) {
+      var doc = element.dom().ownerDocument;
+      var body = doc.body;
+      var win = windowOf(Element.fromDom(doc));
+      var html = doc.documentElement;
+      var scrollTop = firstDefinedOrZero(win.pageYOffset, html.scrollTop);
+      var scrollLeft = firstDefinedOrZero(win.pageXOffset, html.scrollLeft);
+      var clientTop = firstDefinedOrZero(html.clientTop, body.clientTop);
+      var clientLeft = firstDefinedOrZero(html.clientLeft, body.clientLeft);
+      return viewport(element).translate(scrollLeft - clientLeft, scrollTop - clientTop);
+    };
+    var viewport = function (element) {
+      var dom = element.dom();
+      var doc = dom.ownerDocument;
+      var body = doc.body;
+      var html = Element.fromDom(doc.documentElement);
+      if (body === dom) {
+        return Position$1(body.offsetLeft, body.offsetTop);
+      }
+      if (!attached(element, html)) {
+        return Position$1(0, 0);
+      }
+      return boxPosition(dom);
+    };
+
+    var isSafari = PlatformDetection$1.detect().browser.isSafari();
+    var get$8 = function (_DOC) {
+      var doc = _DOC !== undefined ? _DOC.dom() : domGlobals.document;
+      var x = doc.body.scrollLeft || doc.documentElement.scrollLeft;
+      var y = doc.body.scrollTop || doc.documentElement.scrollTop;
+      return Position$1(x, y);
+    };
+    var to = function (x, y, _DOC) {
+      var doc = _DOC !== undefined ? _DOC.dom() : domGlobals.document;
+      var win = doc.defaultView;
+      win.scrollTo(x, y);
+    };
+    var intoView = function (element, alignToTop) {
+      if (isSafari && isFunction(element.dom().scrollIntoViewIfNeeded)) {
+        element.dom().scrollIntoViewIfNeeded(false);
+      } else {
+        element.dom().scrollIntoView(alignToTop);
+      }
+    };
+
+    var walkUp = function (navigation, doc) {
+      var frame = navigation.view(doc);
+      return frame.fold(constant([]), function (f) {
+        var parent = navigation.owner(f);
+        var rest = walkUp(navigation, parent);
+        return [f].concat(rest);
+      });
+    };
+    var pathTo = function (element, navigation) {
+      var d = navigation.owner(element);
+      return walkUp(navigation, d);
+    };
+
+    var view = function (doc) {
+      var element = doc.dom() === domGlobals.document ? Option.none() : Option.from(doc.dom().defaultView.frameElement);
+      return element.map(Element.fromDom);
+    };
+    var owner$1 = function (element) {
+      return owner(element);
+    };
+
+    var Navigation = /*#__PURE__*/Object.freeze({
+        view: view,
+        owner: owner$1
+    });
+
+    var find$4 = function (element) {
+      var doc = Element.fromDom(domGlobals.document);
+      var scroll = get$8(doc);
+      var frames = pathTo(element, Navigation);
+      var offset = viewport(element);
+      var r = foldr(frames, function (b, a) {
+        var loc = viewport(a);
+        return {
+          left: b.left + loc.left(),
+          top: b.top + loc.top()
+        };
+      }, {
+        left: 0,
+        top: 0
+      });
+      return Position$1(r.left + offset.left() + scroll.left(), r.top + offset.top() + scroll.top());
+    };
 
-    var getPos$1 = function (elm) {
-      var x = 0, y = 0;
-      var offsetParent = elm;
-      while (offsetParent && offsetParent.nodeType) {
-        x += offsetParent.offsetLeft || 0;
-        y += offsetParent.offsetTop || 0;
-        offsetParent = offsetParent.offsetParent;
+    var excludeFromDescend = function (element) {
+      return name(element) === 'textarea';
+    };
+    var descend = function (element, offset) {
+      var children$1 = children(element);
+      if (children$1.length === 0 || excludeFromDescend(element)) {
+        return {
+          element: element,
+          offset: offset
+        };
+      } else if (offset < children$1.length && !excludeFromDescend(children$1[offset])) {
+        return {
+          element: children$1[offset],
+          offset: 0
+        };
+      } else {
+        var last = children$1[children$1.length - 1];
+        if (excludeFromDescend(last)) {
+          return {
+            element: element,
+            offset: offset
+          };
+        } else {
+          if (name(last) === 'img') {
+            return {
+              element: last,
+              offset: 1
+            };
+          } else if (isText(last)) {
+            return {
+              element: last,
+              offset: get$5(last).length
+            };
+          } else {
+            return {
+              element: last,
+              offset: children(last).length
+            };
+          }
+        }
       }
+    };
+    var markerInfo = function (element, cleanupFun) {
+      var pos = absolute(element);
+      var height = get$7(element);
       return {
-        x: x,
-        y: y
+        element: element,
+        bottom: pos.top() + height,
+        pos: pos,
+        cleanup: cleanupFun
       };
     };
+    var createMarker = function (element, offset) {
+      var startPoint = descend(element, offset);
+      var span = Element.fromHtml('<span data-mce-bogus="all">' + Zwsp.ZWSP + '</span>');
+      before(startPoint.element, span);
+      return markerInfo(span, function () {
+        return remove$1(span);
+      });
+    };
+    var elementMarker = function (element) {
+      return markerInfo(Element.fromDom(element), noop);
+    };
+    var withMarker = function (editor, f, rng, alignToTop) {
+      preserveWith(editor, function (_s, _e) {
+        return applyWithMarker(editor, f, rng, alignToTop);
+      }, rng);
+    };
+    var applyWithMarker = function (editor, f, rng, alignToTop) {
+      var body = Element.fromDom(editor.getBody());
+      var doc = Element.fromDom(editor.getDoc());
+      reflow(body);
+      var scrollTop = get$8(doc).top();
+      var marker = createMarker(Element.fromDom(rng.startContainer), rng.startOffset);
+      f(doc, scrollTop, marker, alignToTop);
+      marker.cleanup();
+    };
+    var withElement = function (editor, element, f, alignToTop) {
+      var doc = Element.fromDom(editor.getDoc());
+      var scrollTop = get$8(doc).top();
+      f(doc, scrollTop, element, alignToTop);
+    };
+    var preserveWith = function (editor, f, rng) {
+      var startElement = rng.startContainer;
+      var startOffset = rng.startOffset;
+      var endElement = rng.endContainer;
+      var endOffset = rng.endOffset;
+      f(Element.fromDom(startElement), Element.fromDom(endElement));
+      var newRng = editor.dom.createRng();
+      newRng.setStart(startElement, startOffset);
+      newRng.setEnd(endElement, endOffset);
+      editor.selection.setRng(rng);
+    };
     var fireScrollIntoViewEvent = function (editor, elm, alignToTop) {
-      var scrollEvent = {
+      var scrollEvent = editor.fire('ScrollIntoView', {
         elm: elm,
         alignToTop: alignToTop
-      };
-      editor.fire('ScrollIntoView', scrollEvent);
+      });
       return scrollEvent.isDefaultPrevented();
     };
-    var scrollElementIntoView = function (editor, elm, alignToTop) {
-      var y, viewPort;
-      var dom = editor.dom;
-      var root = dom.getRoot();
-      var viewPortY, viewPortH, offsetY = 0;
-      if (fireScrollIntoViewEvent(editor, elm, alignToTop)) {
-        return;
-      }
-      if (!NodeType.isElement(elm)) {
-        return;
-      }
-      if (alignToTop === false) {
-        offsetY = elm.offsetHeight;
-      }
-      if (root.nodeName !== 'BODY') {
-        var scrollContainer = editor.selection.getScrollContainer();
-        if (scrollContainer) {
-          y = getPos$1(elm).y - getPos$1(scrollContainer).y + offsetY;
-          viewPortH = scrollContainer.clientHeight;
-          viewPortY = scrollContainer.scrollTop;
-          if (y < viewPortY || y + 25 > viewPortY + viewPortH) {
-            scrollContainer.scrollTop = y < viewPortY ? y : y - viewPortH + 25;
-          }
-          return;
-        }
+    var scrollTo = function (marker, viewHeight, alignToTop, doc) {
+      var pos = marker.pos;
+      if (alignToTop) {
+        to(pos.left(), pos.top(), doc);
+      } else {
+        var y = pos.top() - viewHeight + (marker.bottom - pos.top());
+        to(pos.left(), y, doc);
       }
-      viewPort = dom.getViewPort(editor.getWin());
-      y = dom.getPos(elm).y + offsetY;
-      viewPortY = viewPort.y;
-      viewPortH = viewPort.h;
-      if (y < viewPort.y || y + 25 > viewPortY + viewPortH) {
-        editor.getWin().scrollTo(0, y < viewPortY ? y : y - viewPortH + 25);
+    };
+    var intoWindowIfNeeded = function (doc, scrollTop, viewHeight, marker, alignToTop) {
+      if (marker.pos.top() < scrollTop) {
+        scrollTo(marker, viewHeight, alignToTop !== false, doc);
+      } else if (marker.bottom > viewHeight + scrollTop) {
+        scrollTo(marker, viewHeight, alignToTop === true, doc);
       }
     };
-    var getViewPortRect = function (editor) {
-      if (editor.inline) {
-        return editor.getBody().getBoundingClientRect();
-      } else {
-        var win = editor.getWin();
-        return {
-          left: 0,
-          right: win.innerWidth,
-          top: 0,
-          bottom: win.innerHeight,
-          width: win.innerWidth,
-          height: win.innerHeight
-        };
+    var intoWindow = function (doc, scrollTop, marker, alignToTop) {
+      var viewHeight = doc.dom().defaultView.innerHeight;
+      intoWindowIfNeeded(doc, scrollTop, viewHeight, marker, alignToTop);
+    };
+    var intoFrame = function (editor, doc, scrollTop, marker, alignToTop) {
+      var frameViewHeight = doc.dom().defaultView.innerHeight;
+      intoWindowIfNeeded(doc, scrollTop, frameViewHeight, marker, alignToTop);
+      var op = find$4(marker.element);
+      var viewTop = get$8().top();
+      var viewBot = domGlobals.window.innerHeight + viewTop;
+      if (op.top() < viewTop) {
+        intoView(marker.element, alignToTop !== false);
+      } else if (op.top() > viewBot) {
+        intoView(marker.element, alignToTop === true);
       }
     };
-    var scrollBy = function (editor, dx, dy) {
-      if (editor.inline) {
-        editor.getBody().scrollLeft += dx;
-        editor.getBody().scrollTop += dy;
-      } else {
-        editor.getWin().scrollBy(dx, dy);
+    var rangeIntoWindow = function (editor, rng, alignToTop) {
+      return withMarker(editor, curry(intoWindow), rng, alignToTop);
+    };
+    var elementIntoWindow = function (editor, element, alignToTop) {
+      return withElement(editor, elementMarker(element), curry(intoWindow), alignToTop);
+    };
+    var rangeIntoFrame = function (editor, rng, alignToTop) {
+      return withMarker(editor, curry(intoFrame, editor), rng, alignToTop);
+    };
+    var elementIntoFrame = function (editor, element, alignToTop) {
+      return withElement(editor, elementMarker(element), curry(intoFrame, editor), alignToTop);
+    };
+    var elementIntoView = function (editor, element, alignToTop) {
+      if (fireScrollIntoViewEvent(editor, element, alignToTop)) {
+        return;
       }
+      var scroller = editor.inline ? elementIntoWindow : elementIntoFrame;
+      scroller(editor, element, alignToTop);
     };
-    var scrollRangeIntoView = function (editor, rng) {
-      head(CaretPosition.fromRangeStart(rng).getClientRects()).each(function (rngRect) {
-        var bodyRect = getViewPortRect(editor);
-        var overflow = getOverflow(bodyRect, rngRect);
-        var margin = 4;
-        var dx = overflow.x > 0 ? overflow.x + margin : overflow.x - margin;
-        var dy = overflow.y > 0 ? overflow.y + margin : overflow.y - margin;
-        scrollBy(editor, overflow.x !== 0 ? dx : 0, overflow.y !== 0 ? dy : 0);
-      });
+    var rangeIntoView = function (editor, rng, alignToTop) {
+      var scroller = editor.inline ? rangeIntoWindow : rangeIntoFrame;
+      scroller(editor, rng, alignToTop);
     };
     var ScrollIntoView = {
-      scrollElementIntoView: scrollElementIntoView,
-      scrollRangeIntoView: scrollRangeIntoView
+      scrollElementIntoView: elementIntoView,
+      scrollRangeIntoView: rangeIntoView
     };
 
     var hasCeProperty = function (node) {
@@ -19617,7 +19891,7 @@
         return elm.dom();
       }).getOr(root);
     };
-    var getStart = function (root, rng, real) {
+    var getStart$2 = function (root, rng, real) {
       return getEndpointElement(root, rng, true, real, function (elm, offset) {
         return Math.min(childNodesCount(elm), offset);
       });
@@ -19677,7 +19951,7 @@
       var node, root;
       var selectedBlocks = [];
       root = dom.getRoot();
-      startElm = dom.getParent(startElm || getStart(root, rng, rng.collapsed), dom.isBlock);
+      startElm = dom.getParent(startElm || getStart$2(root, rng, rng.collapsed), dom.isBlock);
       endElm = dom.getParent(endElm || getEnd(root, rng, rng.collapsed), dom.isBlock);
       if (startElm && startElm !== root) {
         selectedBlocks.push(startElm);
@@ -19792,7 +20066,7 @@
         return isAttachedToDom(rng.startContainer) && isAttachedToDom(rng.endContainer);
       }
     };
-    var Selection = function (dom, win, serializer, editor) {
+    var Selection$1 = function (dom, win, serializer, editor) {
       var bookmarkManager, controlSelection;
       var selectedRange, explicitRange;
       var selectorChangedWithUnbind = SelectorChanged(dom, editor).selectorChangedWithUnbind;
@@ -19814,8 +20088,8 @@
       var setContent = function (content, args) {
         return SetSelectionContent.setContent(editor, content, args);
       };
-      var getStart$1 = function (real) {
-        return getStart(editor.getBody(), getRng(), real);
+      var getStart = function (real) {
+        return getStart$2(editor.getBody(), getRng(), real);
       };
       var getEnd$1 = function (real) {
         return getEnd(editor.getBody(), getRng(), real);
@@ -19873,7 +20147,7 @@
           }
         }
         try {
-          if (selection = getSel()) {
+          if ((selection = getSel()) && !NodeType.isRestrictedNode(selection.anchorNode)) {
             if (selection.rangeCount > 0) {
               rng = selection.getRangeAt(0);
             } else {
@@ -20039,7 +20313,7 @@
         getSel: getSel,
         setRng: setRng,
         getRng: getRng,
-        getStart: getStart$1,
+        getStart: getStart,
         getEnd: getEnd$1,
         getSelectedBlocks: getSelectedBlocks$1,
         normalize: normalize,
@@ -20174,8 +20448,7 @@
     };
 
     var isInlineTarget = function (editor, elm) {
-      var selector = getString(editor, 'inline_boundaries_selector').getOr('a[href],code');
-      return is$1(Element.fromDom(elm), selector);
+      return is$1(Element.fromDom(elm), Settings.getInlineBoundarySelector(editor));
     };
     var isRtl$1 = function (element) {
       return DOMUtils$1.DOM.getStyle(element, 'direction', true) === 'rtl' || hasStrongRtl(element.textContent);
@@ -20256,7 +20529,7 @@
       var parentBlock = getParentBlock(node, rootNode);
       return parentBlock ? parentBlock : rootNode;
     };
-    var before$3 = function (isInlineTarget, rootNode, pos) {
+    var before$4 = function (isInlineTarget, rootNode, pos) {
       var nPos = InlineUtils.normalizeForwards(pos);
       var scope = rescope(rootNode, nPos.container());
       return InlineUtils.findRootInline(isInlineTarget, scope, nPos).fold(function () {
@@ -20285,7 +20558,7 @@
         return nextPos.isNone() ? Option.some(Location.end(inline)) : Option.none();
       });
     };
-    var after$2 = function (isInlineTarget, rootNode, pos) {
+    var after$3 = function (isInlineTarget, rootNode, pos) {
       var nPos = InlineUtils.normalizeBackwards(pos);
       var scope = rescope(rootNode, nPos.container());
       return InlineUtils.findRootInline(isInlineTarget, scope, nPos).fold(function () {
@@ -20299,10 +20572,10 @@
     };
     var readLocation = function (isInlineTarget, rootNode, pos) {
       var location = LazyEvaluator.evaluateUntil([
-        before$3,
+        before$4,
         start$1,
         end,
-        after$2
+        after$3
       ], [
         isInlineTarget,
         rootNode,
@@ -22908,9 +23181,20 @@
     var navigateIgnoreEmptyTextNodes = function (forward, root, from) {
       return CaretFinder.navigateIgnore(forward, root, from, isEmptyText);
     };
+    var getClosestBlock = function (root, pos) {
+      return find(Parents.parentsAndSelf(Element.fromDom(pos.container()), root), isBlock);
+    };
+    var isAtBeforeAfterBlockBoundary = function (forward, root, pos) {
+      return navigateIgnoreEmptyTextNodes(forward, root.dom(), pos).forall(function (newPos) {
+        return getClosestBlock(root, pos).fold(function () {
+          return isInSameBlock(newPos, pos, root.dom()) === false;
+        }, function (fromBlock) {
+          return isInSameBlock(newPos, pos, root.dom()) === false && contains$3(fromBlock, Element.fromDom(newPos.container()));
+        });
+      });
+    };
     var isAtBlockBoundary = function (forward, root, pos) {
-      var parentBlocks = filter(Parents.parentsAndSelf(Element.fromDom(pos.container()), root), isBlock);
-      return head(parentBlocks).fold(function () {
+      return getClosestBlock(root, pos).fold(function () {
         return navigateIgnoreEmptyTextNodes(forward, root.dom(), pos).forall(function (newPos) {
           return isInSameBlock(newPos, pos, root.dom()) === false;
         });
@@ -22920,12 +23204,14 @@
     };
     var isAtStartOfBlock = curry(isAtBlockBoundary, false);
     var isAtEndOfBlock = curry(isAtBlockBoundary, true);
+    var isBeforeBlock = curry(isAtBeforeAfterBlockBoundary, false);
+    var isAfterBlock = curry(isAtBeforeAfterBlockBoundary, true);
 
     var nbsp = '\xA0';
     var isInMiddleOfText = function (pos) {
       return CaretPosition.isTextPosition(pos) && !pos.isAtStart() && !pos.isAtEnd();
     };
-    var getClosestBlock = function (root, pos) {
+    var getClosestBlock$1 = function (root, pos) {
       var parentBlocks = filter(Parents.parentsAndSelf(Element.fromDom(pos.container()), root), isBlock);
       return head(parentBlocks).getOr(root);
     };
@@ -22933,20 +23219,19 @@
       if (isInMiddleOfText(pos)) {
         return isAfterSpace(pos);
       } else {
-        return isAfterSpace(pos) || CaretFinder.prevPosition(getClosestBlock(root, pos).dom(), pos).exists(isAfterSpace);
+        return isAfterSpace(pos) || CaretFinder.prevPosition(getClosestBlock$1(root, pos).dom(), pos).exists(isAfterSpace);
       }
     };
     var hasSpaceAfter = function (root, pos) {
       if (isInMiddleOfText(pos)) {
         return isBeforeSpace(pos);
       } else {
-        return isBeforeSpace(pos) || CaretFinder.nextPosition(getClosestBlock(root, pos).dom(), pos).exists(isBeforeSpace);
+        return isBeforeSpace(pos) || CaretFinder.nextPosition(getClosestBlock$1(root, pos).dom(), pos).exists(isBeforeSpace);
       }
     };
     var isPreValue = function (value) {
       return contains([
         'pre',
-        'pre-line',
         'pre-wrap'
       ], value);
     };
@@ -22977,7 +23262,7 @@
       if (isInPre(pos)) {
         return false;
       } else {
-        return isAtStartOfBlock(root, pos) || isAfterBr(root, pos) || hasSpaceBefore(root, pos);
+        return isAtStartOfBlock(root, pos) || isBeforeBlock(root, pos) || isAfterBr(root, pos) || hasSpaceBefore(root, pos);
       }
     };
     var leanRight = function (pos) {
@@ -22994,7 +23279,7 @@
       if (isInPre(afterPos)) {
         return false;
       } else {
-        return isAtEndOfBlock(root, afterPos) || isBeforeBr(root, afterPos) || hasSpaceAfter(root, afterPos);
+        return isAtEndOfBlock(root, afterPos) || isAfterBlock(root, afterPos) || isBeforeBr(root, afterPos) || hasSpaceAfter(root, afterPos);
       }
     };
     var needsToBeNbsp = function (root, pos) {
@@ -23816,11 +24101,10 @@
           DOM$2.setAttrib(bodyEl, 'contentEditable', null);
         });
         DOM$2.addClass(targetElm, 'mce-content-body');
-        editor.contentDocument = doc = settings.content_document || domGlobals.document;
-        editor.contentWindow = settings.content_window || domGlobals.window;
+        editor.contentDocument = doc = domGlobals.document;
+        editor.contentWindow = domGlobals.window;
         editor.bodyElement = targetElm;
         editor.contentAreaContainer = targetElm;
-        settings.content_document = settings.content_window = null;
         settings.root_name = targetElm.nodeName.toLowerCase();
       }
       body = editor.getBody();
@@ -23853,7 +24137,7 @@
       });
       editor.parser = createParser(editor);
       editor.serializer = Serializer$1(settings, editor);
-      editor.selection = Selection(editor.dom, editor.getWin(), editor.serializer, editor);
+      editor.selection = Selection$1(editor.dom, editor.getWin(), editor.serializer, editor);
       editor.annotator = Annotator(editor);
       editor.formatter = Formatter(editor);
       editor.undoManager = UndoManager(editor);
@@ -24003,11 +24287,11 @@
 
     var DOM$4 = DOMUtils$1.DOM;
     var initPlugin = function (editor, initializedPlugins, plugin) {
-      var Plugin = PluginManager$1.get(plugin);
-      var pluginUrl = PluginManager$1.urls[plugin] || editor.documentBaseUrl.replace(/\/$/, '');
+      var Plugin = PluginManager.get(plugin);
+      var pluginUrl = PluginManager.urls[plugin] || editor.documentBaseUrl.replace(/\/$/, '');
       plugin = Tools.trim(plugin);
       if (Plugin && Tools.inArray(initializedPlugins, plugin) === -1) {
-        Tools.each(PluginManager$1.dependencies(plugin), function (dep) {
+        Tools.each(PluginManager.dependencies(plugin), function (dep) {
           initPlugin(editor, initializedPlugins, dep);
         });
         if (editor.plugins[plugin]) {
@@ -24124,11 +24408,10 @@
       var languageCode = Settings.getLanguageCode(editor);
       var languageUrl = Settings.getLanguageUrl(editor);
       if (I18n.hasCode(languageCode) === false && languageCode !== 'en') {
-        if (languageUrl !== '') {
-          scriptLoader.add(languageUrl);
-        } else {
-          scriptLoader.add(editor.editorManager.baseURL + '/langs/' + languageCode + '.js');
-        }
+        var url_1 = languageUrl !== '' ? languageUrl : editor.editorManager.baseURL + '/langs/' + languageCode + '.js';
+        scriptLoader.add(url_1, noop, undefined, function () {
+          ErrorReporter.languageLoadError(url_1, languageCode);
+        });
       }
     };
     var loadTheme = function (scriptLoader, editor, suffix, callback) {
@@ -24149,41 +24432,70 @@
         callback();
       }
     };
-    var loadIcons = function (editor) {
-      var iconPackName = Tools.trim(editor.getParam('icons', '', 'string'));
-      if (iconPackName.length > 0 && !IconManager.has(iconPackName)) {
-        var urlString = editor.editorManager.baseURL + '/icons/' + iconPackName + '/icons.js';
-        ScriptLoader.ScriptLoader.add(urlString);
-      }
+    var getIconsUrlMetaFromUrl = function (editor) {
+      return Option.from(Settings.getIconsUrl(editor)).filter(function (url) {
+        return url.length > 0;
+      }).map(function (url) {
+        return {
+          url: url,
+          name: Option.none()
+        };
+      });
+    };
+    var getIconsUrlMetaFromName = function (editor) {
+      return Option.from(Settings.getIconPackName(editor)).filter(function (name) {
+        return name.length > 0 && !IconManager.has(name);
+      }).map(function (name) {
+        return {
+          url: editor.editorManager.baseURL + '/icons/' + name + '/icons.js',
+          name: Option.some(name)
+        };
+      });
+    };
+    var loadIcons = function (scriptLoader, editor) {
+      getIconsUrlMetaFromUrl(editor).orThunk(function () {
+        return getIconsUrlMetaFromName(editor);
+      }).each(function (urlMeta) {
+        scriptLoader.add(urlMeta.url, noop, undefined, function () {
+          ErrorReporter.iconsLoadError(urlMeta.url, urlMeta.name.getOrUndefined());
+        });
+      });
     };
     var loadPlugins = function (settings, suffix) {
-      if (Tools.isArray(settings.plugins)) {
+      if (isArray(settings.plugins)) {
         settings.plugins = settings.plugins.join(' ');
       }
       Tools.each(settings.external_plugins, function (url, name) {
-        PluginManager$1.load(name, url);
+        PluginManager.load(name, url, noop, undefined, function () {
+          ErrorReporter.pluginLoadError(name, url);
+        });
         settings.plugins += ' ' + name;
       });
       Tools.each(settings.plugins.split(/[ ,]/), function (plugin) {
         plugin = Tools.trim(plugin);
-        if (plugin && !PluginManager$1.urls[plugin]) {
+        if (plugin && !PluginManager.urls[plugin]) {
           if (hasSkipLoadPrefix(plugin)) {
             plugin = plugin.substr(1, plugin.length);
-            var dependencies = PluginManager$1.dependencies(plugin);
+            var dependencies = PluginManager.dependencies(plugin);
             Tools.each(dependencies, function (dep) {
               var defaultSettings = {
                 prefix: 'plugins/',
                 resource: dep,
                 suffix: '/plugin' + suffix + '.js'
               };
-              dep = PluginManager$1.createUrl(defaultSettings, dep);
-              PluginManager$1.load(dep.resource, dep);
+              dep = PluginManager.createUrl(defaultSettings, dep);
+              PluginManager.load(dep.resource, dep, noop, undefined, function () {
+                ErrorReporter.pluginLoadError(dep.prefix + dep.resource + dep.suffix, dep.resource);
+              });
             });
           } else {
-            PluginManager$1.load(plugin, {
+            var url_2 = {
               prefix: 'plugins/',
               resource: plugin,
               suffix: '/plugin' + suffix + '.js'
+            };
+            PluginManager.load(plugin, url_2, noop, undefined, function () {
+              ErrorReporter.pluginLoadError(url_2.prefix + url_2.resource + url_2.suffix, plugin);
             });
           }
         }
@@ -24193,14 +24505,13 @@
       var scriptLoader = ScriptLoader.ScriptLoader;
       loadTheme(scriptLoader, editor, suffix, function () {
         loadLanguage(scriptLoader, editor);
-        loadIcons(editor);
+        loadIcons(scriptLoader, editor);
         loadPlugins(editor.settings, suffix);
         scriptLoader.loadQueue(function () {
           if (!editor.removed) {
             Init.init(editor);
           }
-        }, editor, function (urls) {
-          ErrorReporter.pluginLoadError(editor, urls[0]);
+        }, editor, function () {
           if (!editor.removed) {
             Init.init(editor);
           }
@@ -24289,6 +24600,7 @@
     };
     var Render = { render: render };
 
+    var internalContentEditableAttr = 'data-mce-contenteditable';
     var toggleClass = function (elm, cls, state) {
       if (has$2(elm, cls) && state === false) {
         remove$4(elm, cls);
@@ -24296,13 +24608,160 @@
         add$3(elm, cls);
       }
     };
-    var create$3 = function (editor) {
-      var activeMode = 'design';
-      var defaultModes = [
-        'design',
-        'readonly'
-      ];
-      var availableModes = {
+    var setEditorCommandState = function (editor, cmd, state) {
+      try {
+        editor.getDoc().execCommand(cmd, false, state);
+      } catch (ex) {
+      }
+    };
+    var setContentEditable = function (elm, state) {
+      elm.dom().contentEditable = state ? 'true' : 'false';
+    };
+    var switchOffContentEditableTrue = function (elm) {
+      each(descendants$1(elm, '*[contenteditable="true"]'), function (elm) {
+        set(elm, internalContentEditableAttr, 'true');
+        setContentEditable(elm, false);
+      });
+    };
+    var switchOnContentEditableTrue = function (elm) {
+      each(descendants$1(elm, '*[' + internalContentEditableAttr + '="true"]'), function (elm) {
+        remove(elm, internalContentEditableAttr);
+        setContentEditable(elm, true);
+      });
+    };
+    var removeFakeSelection = function (editor) {
+      Option.from(editor.selection.getNode()).each(function (elm) {
+        elm.removeAttribute('data-mce-selected');
+      });
+    };
+    var restoreFakeSelection = function (editor) {
+      editor.selection.setRng(editor.selection.getRng());
+    };
+    var toggleReadOnly = function (editor, state) {
+      var body = Element.fromDom(editor.getBody());
+      toggleClass(body, 'mce-content-readonly', state);
+      if (state) {
+        editor.selection.controlSelection.hideResizeRect();
+        editor._selectionOverrides.hideFakeCaret();
+        removeFakeSelection(editor);
+        editor.readonly = true;
+        setContentEditable(body, false);
+        switchOffContentEditableTrue(body);
+      } else {
+        editor.readonly = false;
+        setContentEditable(body, true);
+        switchOnContentEditableTrue(body);
+        setEditorCommandState(editor, 'StyleWithCSS', false);
+        setEditorCommandState(editor, 'enableInlineTableEditing', false);
+        setEditorCommandState(editor, 'enableObjectResizing', false);
+        editor.focus();
+        restoreFakeSelection(editor);
+        editor.nodeChanged();
+      }
+    };
+    var isReadOnly = function (editor) {
+      return editor.readonly === true;
+    };
+    var registerFilters = function (editor) {
+      editor.parser.addAttributeFilter('contenteditable', function (nodes) {
+        if (isReadOnly(editor)) {
+          each(nodes, function (node) {
+            node.attr(internalContentEditableAttr, node.attr('contenteditable'));
+            node.attr('contenteditable', 'false');
+          });
+        }
+      });
+      editor.serializer.addAttributeFilter(internalContentEditableAttr, function (nodes) {
+        if (isReadOnly(editor)) {
+          each(nodes, function (node) {
+            node.attr('contenteditable', node.attr(internalContentEditableAttr));
+          });
+        }
+      });
+      editor.serializer.addTempAttr(internalContentEditableAttr);
+    };
+    var registerReadOnlyContentFilters = function (editor) {
+      if (editor.serializer) {
+        registerFilters(editor);
+      } else {
+        editor.on('PreInit', function () {
+          registerFilters(editor);
+        });
+      }
+    };
+    var preventReadOnlyEvents = function (e) {
+      var target = e.target;
+      if (e.type === 'click' && target.tagName === 'A') {
+        e.preventDefault();
+      }
+    };
+    var registerReadOnlySelectionBlockers = function (editor) {
+      editor.on('ShowCaret', function (e) {
+        if (isReadOnly(editor)) {
+          e.preventDefault();
+        }
+      });
+      editor.on('ObjectSelected', function (e) {
+        if (isReadOnly(editor)) {
+          e.preventDefault();
+        }
+      });
+    };
+
+    var defaultModes = [
+      'design',
+      'readonly'
+    ];
+    var switchToMode = function (editor, activeMode, availableModes, mode) {
+      var oldMode = availableModes[activeMode.get()];
+      var newMode = availableModes[mode];
+      try {
+        newMode.activate();
+      } catch (e) {
+        domGlobals.console.error('problem while activating editor mode ' + mode + ':', e);
+        return;
+      }
+      oldMode.deactivate();
+      if (oldMode.editorReadOnly !== newMode.editorReadOnly) {
+        toggleReadOnly(editor, newMode.editorReadOnly);
+      }
+      activeMode.set(mode);
+      Events.fireSwitchMode(editor, mode);
+    };
+    var setMode = function (editor, availableModes, activeMode, mode) {
+      if (mode === activeMode.get()) {
+        return;
+      } else if (!has(availableModes, mode)) {
+        throw new Error('Editor mode \'' + mode + '\' is invalid');
+      }
+      if (editor.initialized) {
+        switchToMode(editor, activeMode, availableModes, mode);
+      } else {
+        editor.on('init', function () {
+          return switchToMode(editor, activeMode, availableModes, mode);
+        });
+      }
+    };
+    var registerMode = function (availableModes, mode, api) {
+      var _a;
+      if (contains(defaultModes, mode)) {
+        throw new Error('Cannot override default mode ' + mode);
+      }
+      return __assign({}, availableModes, (_a = {}, _a[mode] = __assign({}, api, {
+        deactivate: function () {
+          try {
+            api.deactivate();
+          } catch (e) {
+            domGlobals.console.error('problem while deactivating editor mode ' + mode + ':');
+            domGlobals.console.error(e);
+          }
+        }
+      }), _a));
+    };
+
+    var create$4 = function (editor) {
+      var activeMode = Cell('design');
+      var availableModes = Cell({
         design: {
           activate: noop,
           deactivate: noop,
@@ -24313,85 +24772,22 @@
           deactivate: noop,
           editorReadOnly: true
         }
-      };
-      var setEditorCommandState = function (cmd, state) {
-        try {
-          editor.getDoc().execCommand(cmd, false, state);
-        } catch (ex) {
-        }
-      };
-      var toggleReadOnly = function (state) {
-        toggleClass(Element.fromDom(editor.getBody()), 'mce-content-readonly', state);
-        if (state) {
-          editor.selection.controlSelection.hideResizeRect();
-          editor.readonly = true;
-          editor.getBody().contentEditable = 'false';
-        } else {
-          editor.readonly = false;
-          editor.getBody().contentEditable = 'true';
-          setEditorCommandState('StyleWithCSS', false);
-          setEditorCommandState('enableInlineTableEditing', false);
-          setEditorCommandState('enableObjectResizing', false);
-          editor.focus();
-          editor.nodeChanged();
-        }
-      };
-      var switchToMode = function (mode) {
-        var oldMode = availableModes[activeMode];
-        var newMode = availableModes[mode];
-        try {
-          newMode.activate();
-        } catch (e) {
-          domGlobals.console.error('problem while activating editor mode ' + mode + ':', e);
-          return;
-        }
-        oldMode.deactivate();
-        if (oldMode.editorReadOnly !== newMode.editorReadOnly) {
-          toggleReadOnly(newMode.editorReadOnly);
-        }
-        activeMode = mode;
-        Events.fireSwitchMode(editor, mode);
-      };
-      var set = function (mode) {
-        if (mode === activeMode) {
-          return;
-        } else if (!has(availableModes, mode)) {
-          throw new Error('Editor mode \'' + mode + '\' is invalid');
-        }
-        if (editor.initialized) {
-          switchToMode(mode);
-        } else {
-          editor.on('init', function () {
-            return switchToMode(mode);
-          });
-        }
-      };
-      var get = function () {
-        return activeMode;
-      };
-      var isReadOnly = function () {
-        return editor.readonly === true;
-      };
-      var register = function (mode, api) {
-        if (contains(defaultModes, mode)) {
-          throw new Error('Cannot override default mode ' + mode);
-        }
-        availableModes[mode] = __assign({}, api, {
-          deactivate: function () {
-            try {
-              api.deactivate();
-            } catch (e) {
-              domGlobals.console.error('problem while deactivating editor mode ' + mode + ':');
-              domGlobals.console.error(e);
-            }
-          }
-        });
-      };
+      });
+      registerReadOnlyContentFilters(editor);
+      registerReadOnlySelectionBlockers(editor);
       return {
-        isReadOnly: isReadOnly,
-        set: set,
-        get: get,
-        register: register
+        isReadOnly: function () {
+          return isReadOnly(editor);
+        },
+        set: function (mode) {
+          return setMode(editor, availableModes.get(), activeMode, mode);
+        },
+        get: function () {
+          return activeMode.get();
+        },
+        register: function (mode, api) {
+          availableModes.set(registerMode(availableModes.get(), mode, api));
+        }
       };
     };
 
@@ -25375,7 +25771,7 @@
               value = { href: value };
             }
             anchor = editor.dom.getParent(editor.selection.getNode(), 'a');
-            value.href = value.href.replace(' ', '%20');
+            value.href = value.href.replace(/ /g, '%20');
             if (!anchor || !value.href) {
               editor.formatter.remove('link');
             }
@@ -25452,18 +25848,12 @@
     }();
 
     var nativeEvents = Tools.makeMap('focus blur focusin focusout click dblclick mousedown mouseup mousemove mouseover beforepaste paste cut copy selectionchange ' + 'mouseout mouseenter mouseleave wheel keydown keypress keyup input contextmenu dragstart dragend dragover ' + 'draggesture dragdrop drop drag submit ' + 'compositionstart compositionend compositionupdate touchstart touchmove touchend', ' ');
-    var returnFalse$1 = function () {
-      return false;
-    };
-    var returnTrue$1 = function () {
-      return true;
-    };
     var EventDispatcher = function () {
       function EventDispatcher(settings) {
         this.bindings = {};
         this.settings = settings || {};
         this.scope = this.settings.scope || this;
-        this.toggleEvent = this.settings.toggleEvent || returnFalse$1;
+        this.toggleEvent = this.settings.toggleEvent || never;
       }
       EventDispatcher.isNative = function (name) {
         return !!nativeEvents[name.toLowerCase()];
@@ -25478,17 +25868,17 @@
         }
         if (!args.preventDefault) {
           args.preventDefault = function () {
-            args.isDefaultPrevented = returnTrue$1;
+            args.isDefaultPrevented = always;
           };
           args.stopPropagation = function () {
-            args.isPropagationStopped = returnTrue$1;
+            args.isPropagationStopped = always;
           };
           args.stopImmediatePropagation = function () {
-            args.isImmediatePropagationStopped = returnTrue$1;
+            args.isImmediatePropagationStopped = always;
           };
-          args.isDefaultPrevented = returnFalse$1;
-          args.isPropagationStopped = returnFalse$1;
-          args.isImmediatePropagationStopped = returnFalse$1;
+          args.isDefaultPrevented = never;
+          args.isPropagationStopped = never;
+          args.isImmediatePropagationStopped = never;
         }
         if (this.settings.beforeFire) {
           this.settings.beforeFire(args);
@@ -25515,7 +25905,7 @@
       EventDispatcher.prototype.on = function (name, callback, prepend, extra) {
         var handlers, names, i;
         if (callback === false) {
-          callback = returnFalse$1;
+          callback = never;
         }
         if (callback) {
           var wrappedCallback = { func: callback };
@@ -25652,13 +26042,13 @@
       return editor.getBody();
     };
     var isListening = function (editor) {
-      return !editor.hidden && !editor.readonly;
+      return !editor.hidden && !isReadOnly(editor);
     };
     var fireEvent = function (editor, eventName, e) {
       if (isListening(editor)) {
         editor.fire(eventName, e);
-      } else if (editor.readonly) {
-        e.preventDefault();
+      } else if (isReadOnly(editor)) {
+        preventReadOnlyEvents(e);
       }
     };
     var bindEventDelegate = function (editor, eventName) {
@@ -26157,7 +26547,7 @@
       return URI;
     }();
 
-    var create$4 = function () {
+    var create$5 = function () {
       var buttons = {};
       var menuItems = {};
       var popups = {};
@@ -26202,7 +26592,7 @@
     };
 
     var registry = function () {
-      var bridge = create$4();
+      var bridge = create$5();
       return {
         addAutocompleter: bridge.addAutocompleter,
         addButton: bridge.addButton,
@@ -26235,9 +26625,16 @@
         this.isNotDirty = false;
         this.editorManager = editorManager;
         this.documentBaseUrl = editorManager.documentBaseURL;
-        this.baseUri = editorManager.baseURI;
         extend$3(this, EditorObservable);
         this.settings = getEditorSettings(this, id, this.documentBaseUrl, editorManager.defaultSettings, settings);
+        if (this.settings.suffix) {
+          editorManager.suffix = this.settings.suffix;
+        }
+        this.suffix = editorManager.suffix;
+        if (this.settings.base_url) {
+          editorManager._setBaseUrl(this.settings.base_url);
+        }
+        this.baseUri = editorManager.baseURI;
         AddOnManager$1.languageLoad = this.settings.language_load;
         AddOnManager$1.baseURL = editorManager.baseURL;
         this.id = id;
@@ -26245,18 +26642,14 @@
         this.documentBaseURI = new URI(this.settings.document_base_url, { base_uri: this.baseUri });
         this.baseURI = this.baseUri;
         this.inline = this.settings.inline;
-        this.suffix = editorManager.suffix;
         this.shortcuts = new Shortcuts(this);
         this.editorCommands = new EditorCommands(this);
         if (this.settings.cache_suffix) {
           Env.cacheSuffix = this.settings.cache_suffix.replace(/^[\?\&]+/, '');
         }
-        if (this.settings.override_viewport === false) {
-          Env.overrideViewPort = false;
-        }
         this.ui = { registry: registry() };
         var self = this;
-        var modeInstance = create$3(self);
+        var modeInstance = create$4(self);
         this.mode = modeInstance;
         this.setMode = modeInstance.set;
         editorManager.fire('SetupEditor', { editor: this });
@@ -26727,7 +27120,8 @@
 
     var DOM$9 = DOMUtils$1.DOM;
     var explode$4 = Tools.explode, each$k = Tools.each, extend$4 = Tools.extend;
-    var instanceCounter = 0, beforeUnloadDelegate, boundGlobalEvents = false;
+    var instanceCounter = 0, boundGlobalEvents = false;
+    var beforeUnloadDelegate;
     var legacyEditors = [];
     var editors = [];
     var isValidLegacyKey = function (id) {
@@ -26787,7 +27181,6 @@
       return editor;
     };
     var EditorManager = __assign({}, Observable, {
-      _beforeUnloadHandler: null,
       baseURI: null,
       baseURL: null,
       defaultSettings: {},
@@ -26795,8 +27188,8 @@
       suffix: null,
       $: DomQuery,
       majorVersion: '5',
-      minorVersion: '0.5',
-      releaseDate: '2019-05-09',
+      minorVersion: '0.9',
+      releaseDate: '2019-06-26',
       editors: legacyEditors,
       i18n: I18n,
       activeEditor: null,
@@ -26847,8 +27240,7 @@
         var baseUrl, suffix;
         baseUrl = defaultSettings.base_url;
         if (baseUrl) {
-          this.baseURL = new URI(this.documentBaseURL).toAbsolute(baseUrl.replace(/\/+$/, ''));
-          this.baseURI = new URI(this.baseURL);
+          this._setBaseUrl(baseUrl);
         }
         suffix = defaultSettings.suffix;
         if (defaultSettings.suffix) {
@@ -27036,10 +27428,15 @@
         self.activeEditor = editor;
         self.fire('AddEditor', { editor: editor });
         if (!beforeUnloadDelegate) {
-          beforeUnloadDelegate = function () {
-            self.fire('BeforeUnload');
+          beforeUnloadDelegate = function (e) {
+            var event = self.fire('BeforeUnload');
+            if (event.returnValue) {
+              e.preventDefault();
+              e.returnValue = event.returnValue;
+              return event.returnValue;
+            }
           };
-          DOM$9.bind(window, 'beforeunload', beforeUnloadDelegate);
+          window.addEventListener('beforeunload', beforeUnloadDelegate);
         }
         return editor;
       },
@@ -27072,7 +27469,7 @@
           self.fire('RemoveEditor', { editor: editor });
         }
         if (editors.length === 0) {
-          DOM$9.unbind(window, 'beforeunload', beforeUnloadDelegate);
+          window.removeEventListener('beforeunload', beforeUnloadDelegate);
         }
         editor.remove();
         toggleGlobalEvents(editors.length > 0);
@@ -27128,6 +27525,10 @@
           editor.fire('activate', { relatedTarget: activeEditor });
         }
         this.activeEditor = editor;
+      },
+      _setBaseUrl: function (baseUrl) {
+        this.baseURL = new URI(this.documentBaseURL).toAbsolute(baseUrl.replace(/\/+$/, ''));
+        this.baseURI = new URI(this.baseURL);
       }
     });
     EditorManager.setup();
@@ -27192,7 +27593,7 @@
       if (rel[4] === 'c') {
         x -= round$2(w / 2);
       }
-      return create$5(x, y, w, h);
+      return create$6(x, y, w, h);
     };
     var findBestRelativePosition = function (rect, targetRect, constrainRect, rels) {
       var pos, i;
@@ -27205,7 +27606,7 @@
       return null;
     };
     var inflate = function (rect, w, h) {
-      return create$5(rect.x - w, rect.y - h, rect.w + w * 2, rect.h + h * 2);
+      return create$6(rect.x - w, rect.y - h, rect.w + w * 2, rect.h + h * 2);
     };
     var intersect = function (rect, cropRect) {
       var x1, y1, x2, y2;
@@ -27216,7 +27617,7 @@
       if (x2 - x1 < 0 || y2 - y1 < 0) {
         return null;
       }
-      return create$5(x1, y1, x2 - x1, y2 - y1);
+      return create$6(x1, y1, x2 - x1, y2 - y1);
     };
     var clamp$1 = function (rect, clampRect, fixedSize) {
       var underflowX1, underflowY1, overflowX2, overflowY2, x1, y1, x2, y2, cx2, cy2;
@@ -27240,9 +27641,9 @@
       }
       x2 -= overflowX2;
       y2 -= overflowY2;
-      return create$5(x1, y1, x2 - x1, y2 - y1);
+      return create$6(x1, y1, x2 - x1, y2 - y1);
     };
-    var create$5 = function (x, y, w, h) {
+    var create$6 = function (x, y, w, h) {
       return {
         x: x,
         y: y,
@@ -27251,7 +27652,7 @@
       };
     };
     var fromClientRect = function (clientRect) {
-      return create$5(clientRect.left, clientRect.top, clientRect.width, clientRect.height);
+      return create$6(clientRect.left, clientRect.top, clientRect.width, clientRect.height);
     };
     var Rect = {
       inflate: inflate,
@@ -27259,7 +27660,7 @@
       findBestRelativePosition: findBestRelativePosition,
       intersect: intersect,
       clamp: clamp$1,
-      create: create$5,
+      create: create$6,
       fromClientRect: fromClientRect
     };
 
@@ -27633,7 +28034,7 @@
       return JSONRequest;
     }();
 
-    var create$6 = function () {
+    var create$7 = function () {
       return function () {
         var data = {};
         var keys = [];
@@ -27676,7 +28077,7 @@
     try {
       localStorage = domGlobals.window.localStorage;
     } catch (e) {
-      localStorage = create$6();
+      localStorage = create$7();
     }
     var LocalStorage = localStorage;
 
@@ -27710,7 +28111,7 @@
         Serializer: Serializer$1,
         ControlSelection: ControlSelection,
         BookmarkManager: BookmarkManager$1,
-        Selection: Selection,
+        Selection: Selection$1,
         Event: EventUtils.Event
       },
       html: {
@@ -27781,4 +28182,3 @@
     exportToModuleLoaders(tinymce);
 
 }(window));
-})();