/**
* Copyright (c) Tiny Technologies, Inc. All rights reserved.
* Licensed under the LGPL or a commercial license.
* For LGPL see License.txt in the project root for license information.
* For commercial licenses see https://www.tiny.cloud/
*
* Version: 5.10.8 (2023-10-19)
*/
(function () {
'use strict';
var Cell = function (initial) {
var value = initial;
var get = function () {
return value;
};
var set = function (v) {
value = v;
};
return {
get: get,
set: set
};
};
var global$5 = tinymce.util.Tools.resolve('tinymce.PluginManager');
var global$4 = tinymce.util.Tools.resolve('tinymce.util.Tools');
var typeOf = function (x) {
var t = typeof x;
if (x === null) {
return 'null';
} else if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
return 'array';
} else if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
return 'string';
} else {
return t;
}
};
var isType = function (type) {
return function (value) {
return typeOf(value) === type;
};
};
var isSimpleType = function (type) {
return function (value) {
return typeof value === type;
};
};
var isArray = isType('array');
var isNullable = function (a) {
return a === null || a === undefined;
};
var isNonNullable = function (a) {
return !isNullable(a);
};
var isFunction = isSimpleType('function');
var noop = function () {
};
var constant = function (value) {
return function () {
return value;
};
};
var identity = function (x) {
return x;
};
var never = constant(false);
var always = constant(true);
var none = function () {
return NONE;
};
var NONE = function () {
var call = function (thunk) {
return thunk();
};
var id = identity;
var me = {
fold: function (n, _s) {
return n();
},
isSome: never,
isNone: always,
getOr: id,
getOrThunk: call,
getOrDie: function (msg) {
throw new Error(msg || 'error: getOrDie called on none.');
},
getOrNull: constant(null),
getOrUndefined: constant(undefined),
or: id,
orThunk: call,
map: none,
each: noop,
bind: none,
exists: never,
forall: always,
filter: function () {
return none();
},
toArray: function () {
return [];
},
toString: constant('none()')
};
return me;
}();
var some = function (a) {
var constant_a = constant(a);
var self = function () {
return me;
};
var bind = function (f) {
return f(a);
};
var me = {
fold: function (n, s) {
return s(a);
},
isSome: always,
isNone: never,
getOr: constant_a,
getOrThunk: constant_a,
getOrDie: constant_a,
getOrNull: constant_a,
getOrUndefined: constant_a,
or: self,
orThunk: self,
map: function (f) {
return some(f(a));
},
each: function (f) {
f(a);
},
bind: bind,
exists: bind,
forall: bind,
filter: function (f) {
return f(a) ? me : NONE;
},
toArray: function () {
return [a];
},
toString: function () {
return 'some(' + a + ')';
}
};
return me;
};
var from = function (value) {
return value === null || value === undefined ? NONE : some(value);
};
var Optional = {
some: some,
none: none,
from: from
};
var exports$1 = {}, module = { exports: exports$1 };
(function (define, exports, module, require) {
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.EphoxContactWrapper = factory());
}(this, function () {
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
var promise = { exports: {} };
(function (module) {
(function (root) {
var setTimeoutFunc = setTimeout;
function noop() {
}
function bind(fn, thisArg) {
return function () {
fn.apply(thisArg, arguments);
};
}
function Promise(fn) {
if (typeof this !== 'object')
throw new TypeError('Promises must be constructed via new');
if (typeof fn !== 'function')
throw new TypeError('not a function');
this._state = 0;
this._handled = false;
this._value = undefined;
this._deferreds = [];
doResolve(fn, this);
}
function handle(self, deferred) {
while (self._state === 3) {
self = self._value;
}
if (self._state === 0) {
self._deferreds.push(deferred);
return;
}
self._handled = true;
Promise._immediateFn(function () {
var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
if (cb === null) {
(self._state === 1 ? resolve : reject)(deferred.promise, self._value);
return;
}
var ret;
try {
ret = cb(self._value);
} catch (e) {
reject(deferred.promise, e);
return;
}
resolve(deferred.promise, ret);
});
}
function resolve(self, newValue) {
try {
if (newValue === self)
throw new TypeError('A promise cannot be resolved with itself.');
if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
var then = newValue.then;
if (newValue instanceof Promise) {
self._state = 3;
self._value = newValue;
finale(self);
return;
} else if (typeof then === 'function') {
doResolve(bind(then, newValue), self);
return;
}
}
self._state = 1;
self._value = newValue;
finale(self);
} catch (e) {
reject(self, e);
}
}
function reject(self, newValue) {
self._state = 2;
self._value = newValue;
finale(self);
}
function finale(self) {
if (self._state === 2 && self._deferreds.length === 0) {
Promise._immediateFn(function () {
if (!self._handled) {
Promise._unhandledRejectionFn(self._value);
}
});
}
for (var i = 0, len = self._deferreds.length; i < len; i++) {
handle(self, self._deferreds[i]);
}
self._deferreds = null;
}
function Handler(onFulfilled, onRejected, promise) {
this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
this.onRejected = typeof onRejected === 'function' ? onRejected : null;
this.promise = promise;
}
function doResolve(fn, self) {
var done = false;
try {
fn(function (value) {
if (done)
return;
done = true;
resolve(self, value);
}, function (reason) {
if (done)
return;
done = true;
reject(self, reason);
});
} catch (ex) {
if (done)
return;
done = true;
reject(self, ex);
}
}
Promise.prototype['catch'] = function (onRejected) {
return this.then(null, onRejected);
};
Promise.prototype.then = function (onFulfilled, onRejected) {
var prom = new this.constructor(noop);
handle(this, new Handler(onFulfilled, onRejected, prom));
return prom;
};
Promise.all = function (arr) {
var args = Array.prototype.slice.call(arr);
return new Promise(function (resolve, reject) {
if (args.length === 0)
return resolve([]);
var remaining = args.length;
function res(i, val) {
try {
if (val && (typeof val === 'object' || typeof val === 'function')) {
var then = val.then;
if (typeof then === 'function') {
then.call(val, function (val) {
res(i, val);
}, reject);
return;
}
}
args[i] = val;
if (--remaining === 0) {
resolve(args);
}
} catch (ex) {
reject(ex);
}
}
for (var i = 0; i < args.length; i++) {
res(i, args[i]);
}
});
};
Promise.resolve = function (value) {
if (value && typeof value === 'object' && value.constructor === Promise) {
return value;
}
return new Promise(function (resolve) {
resolve(value);
});
};
Promise.reject = function (value) {
return new Promise(function (resolve, reject) {
reject(value);
});
};
Promise.race = function (values) {
return new Promise(function (resolve, reject) {
for (var i = 0, len = values.length; i < len; i++) {
values[i].then(resolve, reject);
}
});
};
Promise._immediateFn = typeof setImmediate === 'function' ? function (fn) {
setImmediate(fn);
} : function (fn) {
setTimeoutFunc(fn, 0);
};
Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
if (typeof console !== 'undefined' && console) {
console.warn('Possible Unhandled Promise Rejection:', err);
}
};
Promise._setImmediateFn = function _setImmediateFn(fn) {
Promise._immediateFn = fn;
};
Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
Promise._unhandledRejectionFn = fn;
};
if (module.exports) {
module.exports = Promise;
} else if (!root.Promise) {
root.Promise = Promise;
}
}(commonjsGlobal));
}(promise));
var promisePolyfill = promise.exports;
var Global = function () {
if (typeof window !== 'undefined') {
return window;
} else {
return Function('return this;')();
}
}();
var promisePolyfill_1 = { boltExport: Global.Promise || promisePolyfill };
return promisePolyfill_1;
}));
}(undefined, exports$1, module));
var Promise$1 = module.exports.boltExport;
var create$1 = function (width, height) {
return resize(document.createElement('canvas'), width, height);
};
var clone = function (canvas) {
var tCanvas = create$1(canvas.width, canvas.height);
var ctx = get2dContext(tCanvas);
ctx.drawImage(canvas, 0, 0);
return tCanvas;
};
var get2dContext = function (canvas) {
return canvas.getContext('2d');
};
var resize = function (canvas, width, height) {
canvas.width = width;
canvas.height = height;
return canvas;
};
var getWidth = function (image) {
return image.naturalWidth || image.width;
};
var getHeight = function (image) {
return image.naturalHeight || image.height;
};
var imageToBlob$2 = function (image) {
var src = image.src;
if (src.indexOf('data:') === 0) {
return dataUriToBlob(src);
}
return anyUriToBlob(src);
};
var blobToImage$1 = function (blob) {
return new Promise$1(function (resolve, reject) {
var blobUrl = URL.createObjectURL(blob);
var image = new Image();
var removeListeners = function () {
image.removeEventListener('load', loaded);
image.removeEventListener('error', error);
};
var loaded = function () {
removeListeners();
resolve(image);
};
var error = function () {
removeListeners();
reject('Unable to load data of type ' + blob.type + ': ' + blobUrl);
};
image.addEventListener('load', loaded);
image.addEventListener('error', error);
image.src = blobUrl;
if (image.complete) {
setTimeout(loaded, 0);
}
});
};
var anyUriToBlob = function (url) {
return new Promise$1(function (resolve, reject) {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, true);
xhr.responseType = 'blob';
xhr.onload = function () {
if (this.status === 200) {
resolve(this.response);
}
};
xhr.onerror = function () {
var _this = this;
var corsError = function () {
var obj = new Error('No access to download image');
obj.code = 18;
obj.name = 'SecurityError';
return obj;
};
var genericError = function () {
return new Error('Error ' + _this.status + ' downloading image');
};
reject(this.status === 0 ? corsError() : genericError());
};
xhr.send();
});
};
var dataUriToBlobSync = function (uri) {
var data = uri.split(',');
var matches = /data:([^;]+)/.exec(data[0]);
if (!matches) {
return Optional.none();
}
var mimetype = matches[1];
var base64 = data[1];
var sliceSize = 1024;
var byteCharacters = atob(base64);
var bytesLength = byteCharacters.length;
var slicesCount = Math.ceil(bytesLength / sliceSize);
var byteArrays = new Array(slicesCount);
for (var sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
var begin = sliceIndex * sliceSize;
var end = Math.min(begin + sliceSize, bytesLength);
var bytes = new Array(end - begin);
for (var offset = begin, i = 0; offset < end; ++i, ++offset) {
bytes[i] = byteCharacters[offset].charCodeAt(0);
}
byteArrays[sliceIndex] = new Uint8Array(bytes);
}
return Optional.some(new Blob(byteArrays, { type: mimetype }));
};
var dataUriToBlob = function (uri) {
return new Promise$1(function (resolve, reject) {
dataUriToBlobSync(uri).fold(function () {
reject('uri is not base64: ' + uri);
}, resolve);
});
};
var canvasToBlob = function (canvas, type, quality) {
type = type || 'image/png';
if (isFunction(HTMLCanvasElement.prototype.toBlob)) {
return new Promise$1(function (resolve, reject) {
canvas.toBlob(function (blob) {
if (blob) {
resolve(blob);
} else {
reject();
}
}, type, quality);
});
} else {
return dataUriToBlob(canvas.toDataURL(type, quality));
}
};
var canvasToDataURL = function (canvas, type, quality) {
type = type || 'image/png';
return canvas.toDataURL(type, quality);
};
var blobToCanvas = function (blob) {
return blobToImage$1(blob).then(function (image) {
revokeImageUrl(image);
var canvas = create$1(getWidth(image), getHeight(image));
var context = get2dContext(canvas);
context.drawImage(image, 0, 0);
return canvas;
});
};
var blobToDataUri = function (blob) {
return new Promise$1(function (resolve) {
var reader = new FileReader();
reader.onloadend = function () {
resolve(reader.result);
};
reader.readAsDataURL(blob);
});
};
var revokeImageUrl = function (image) {
URL.revokeObjectURL(image.src);
};
var blobToImage = function (blob) {
return blobToImage$1(blob);
};
var imageToBlob$1 = function (image) {
return imageToBlob$2(image);
};
var nativeIndexOf = Array.prototype.indexOf;
var rawIndexOf = function (ts, t) {
return nativeIndexOf.call(ts, t);
};
var contains = function (xs, x) {
return rawIndexOf(xs, x) > -1;
};
var each$1 = function (xs, f) {
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
f(x, i);
}
};
var filter = function (xs, pred) {
var r = [];
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
if (pred(x, i)) {
r.push(x);
}
}
return r;
};
var foldl = function (xs, f, acc) {
each$1(xs, function (x, i) {
acc = f(acc, x, i);
});
return acc;
};
var findUntil = function (xs, pred, until) {
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
if (pred(x, i)) {
return Optional.some(x);
} else if (until(x, i)) {
break;
}
}
return Optional.none();
};
var find = function (xs, pred) {
return findUntil(xs, pred, never);
};
var forall = function (xs, pred) {
for (var i = 0, len = xs.length; i < len; ++i) {
var x = xs[i];
if (pred(x, i) !== true) {
return false;
}
}
return true;
};
var keys = Object.keys;
var each = function (obj, f) {
var props = keys(obj);
for (var k = 0, len = props.length; k < len; k++) {
var i = props[k];
var x = obj[i];
f(x, i);
}
};
var generate = function (cases) {
if (!isArray(cases)) {
throw new Error('cases must be an array');
}
if (cases.length === 0) {
throw new Error('there must be at least one case');
}
var constructors = [];
var adt = {};
each$1(cases, function (acase, count) {
var keys$1 = keys(acase);
if (keys$1.length !== 1) {
throw new Error('one and only one name per case');
}
var key = keys$1[0];
var value = acase[key];
if (adt[key] !== undefined) {
throw new Error('duplicate key detected:' + key);
} else if (key === 'cata') {
throw new Error('cannot have a case named cata (sorry)');
} else if (!isArray(value)) {
throw new Error('case arguments must be an array');
}
constructors.push(key);
adt[key] = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var argLength = args.length;
if (argLength !== value.length) {
throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength);
}
var match = function (branches) {
var branchKeys = keys(branches);
if (constructors.length !== branchKeys.length) {
throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(','));
}
var allReqd = forall(constructors, function (reqKey) {
return contains(branchKeys, reqKey);
});
if (!allReqd) {
throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', '));
}
return branches[key].apply(null, args);
};
return {
fold: function () {
var foldArgs = [];
for (var _i = 0; _i < arguments.length; _i++) {
foldArgs[_i] = arguments[_i];
}
if (foldArgs.length !== cases.length) {
throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + foldArgs.length);
}
var target = foldArgs[count];
return target.apply(null, args);
},
match: match,
log: function (label) {
console.log(label, {
constructors: constructors,
constructor: key,
params: args
});
}
};
};
});
return adt;
};
var Adt = { generate: generate };
Adt.generate([
{
bothErrors: [
'error1',
'error2'
]
},
{
firstError: [
'error1',
'value2'
]
},
{
secondError: [
'value1',
'error2'
]
},
{
bothValues: [
'value1',
'value2'
]
}
]);
var create = function (getCanvas, blob, uri) {
var initialType = blob.type;
var getType = constant(initialType);
var toBlob = function () {
return Promise$1.resolve(blob);
};
var toDataURL = constant(uri);
var toBase64 = function () {
return uri.split(',')[1];
};
var toAdjustedBlob = function (type, quality) {
return getCanvas.then(function (canvas) {
return canvasToBlob(canvas, type, quality);
});
};
var toAdjustedDataURL = function (type, quality) {
return getCanvas.then(function (canvas) {
return canvasToDataURL(canvas, type, quality);
});
};
var toAdjustedBase64 = function (type, quality) {
return toAdjustedDataURL(type, quality).then(function (dataurl) {
return dataurl.split(',')[1];
});
};
var toCanvas = function () {
return getCanvas.then(clone);
};
return {
getType: getType,
toBlob: toBlob,
toDataURL: toDataURL,
toBase64: toBase64,
toAdjustedBlob: toAdjustedBlob,
toAdjustedDataURL: toAdjustedDataURL,
toAdjustedBase64: toAdjustedBase64,
toCanvas: toCanvas
};
};
var fromBlob = function (blob) {
return blobToDataUri(blob).then(function (uri) {
return create(blobToCanvas(blob), blob, uri);
});
};
var fromCanvas = function (canvas, type) {
return canvasToBlob(canvas, type).then(function (blob) {
return create(Promise$1.resolve(canvas), blob, canvas.toDataURL());
});
};
var ceilWithPrecision = function (num, precision) {
if (precision === void 0) {
precision = 2;
}
var mul = Math.pow(10, precision);
var upper = Math.round(num * mul);
return Math.ceil(upper / mul);
};
var rotate$2 = function (ir, angle) {
return ir.toCanvas().then(function (canvas) {
return applyRotate(canvas, ir.getType(), angle);
});
};
var applyRotate = function (image, type, angle) {
var degrees = angle < 0 ? 360 + angle : angle;
var rad = degrees * Math.PI / 180;
var width = image.width;
var height = image.height;
var sin = Math.sin(rad);
var cos = Math.cos(rad);
var newWidth = ceilWithPrecision(Math.abs(width * cos) + Math.abs(height * sin));
var newHeight = ceilWithPrecision(Math.abs(width * sin) + Math.abs(height * cos));
var canvas = create$1(newWidth, newHeight);
var context = get2dContext(canvas);
context.translate(newWidth / 2, newHeight / 2);
context.rotate(rad);
context.drawImage(image, -width / 2, -height / 2);
return fromCanvas(canvas, type);
};
var flip$2 = function (ir, axis) {
return ir.toCanvas().then(function (canvas) {
return applyFlip(canvas, ir.getType(), axis);
});
};
var applyFlip = function (image, type, axis) {
var canvas = create$1(image.width, image.height);
var context = get2dContext(canvas);
if (axis === 'v') {
context.scale(1, -1);
context.drawImage(image, 0, -canvas.height);
} else {
context.scale(-1, 1);
context.drawImage(image, -canvas.width, 0);
}
return fromCanvas(canvas, type);
};
var flip$1 = function (ir, axis) {
return flip$2(ir, axis);
};
var rotate$1 = function (ir, angle) {
return rotate$2(ir, angle);
};
var sendRequest = function (url, headers, withCredentials) {
if (withCredentials === void 0) {
withCredentials = false;
}
return new Promise$1(function (resolve) {
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function () {
if (xhr.readyState === 4) {
resolve({
status: xhr.status,
blob: xhr.response
});
}
};
xhr.open('GET', url, true);
xhr.withCredentials = withCredentials;
each(headers, function (value, key) {
xhr.setRequestHeader(key, value);
});
xhr.responseType = 'blob';
xhr.send();
});
};
var readBlobText = function (blob) {
return new Promise$1(function (resolve, reject) {
var reader = new FileReader();
reader.onload = function () {
resolve(reader.result);
};
reader.onerror = function (e) {
reject(e);
};
reader.readAsText(blob);
});
};
var parseJson = function (text) {
try {
return Optional.some(JSON.parse(text));
} catch (ex) {
return Optional.none();
}
};
var friendlyHttpErrors = [
{
code: 404,
message: 'Could not find Image Proxy'
},
{
code: 403,
message: 'Rejected request'
},
{
code: 0,
message: 'Incorrect Image Proxy URL'
}
];
var friendlyServiceErrors = [
{
type: 'not_found',
message: 'Failed to load image.'
},
{
type: 'key_missing',
message: 'The request did not include an api key.'
},
{
type: 'key_not_found',
message: 'The provided api key could not be found.'
},
{
type: 'domain_not_trusted',
message: 'The api key is not valid for the request origins.'
}
];
var traverseJson = function (json, path) {
var value = foldl(path, function (result, key) {
return isNonNullable(result) ? result[key] : undefined;
}, json);
return Optional.from(value);
};
var isServiceErrorCode = function (code, blob) {
return (blob === null || blob === void 0 ? void 0 : blob.type) === 'application/json' && (code === 400 || code === 403 || code === 404 || code === 500);
};
var getHttpErrorMsg = function (status) {
var message = find(friendlyHttpErrors, function (error) {
return status === error.code;
}).fold(constant('Unknown ImageProxy error'), function (error) {
return error.message;
});
return 'ImageProxy HTTP error: ' + message;
};
var handleHttpError = function (status) {
var message = getHttpErrorMsg(status);
return Promise$1.reject(message);
};
var getServiceErrorMsg = function (type) {
return find(friendlyServiceErrors, function (error) {
return error.type === type;
}).fold(constant('Unknown service error'), function (error) {
return error.message;
});
};
var getServiceError = function (text) {
var serviceError = parseJson(text);
var errorMsg = serviceError.bind(function (err) {
return traverseJson(err, [
'error',
'type'
]).map(getServiceErrorMsg);
}).getOr('Invalid JSON in service error message');
return 'ImageProxy Service error: ' + errorMsg;
};
var handleServiceError = function (blob) {
return readBlobText(blob).then(function (text) {
var serviceError = getServiceError(text);
return Promise$1.reject(serviceError);
});
};
var handleServiceErrorResponse = function (status, blob) {
return isServiceErrorCode(status, blob) ? handleServiceError(blob) : handleHttpError(status);
};
var appendApiKey = function (url, apiKey) {
var separator = url.indexOf('?') === -1 ? '?' : '&';
if (/[?&]apiKey=/.test(url)) {
return url;
} else {
return url + separator + 'apiKey=' + encodeURIComponent(apiKey);
}
};
var isError = function (status) {
return status < 200 || status >= 300;
};
var requestServiceBlob = function (url, apiKey) {
var headers = {
'Content-Type': 'application/json;charset=UTF-8',
'tiny-api-key': apiKey
};
return sendRequest(appendApiKey(url, apiKey), headers).then(function (result) {
return isError(result.status) ? handleServiceErrorResponse(result.status, result.blob) : Promise$1.resolve(result.blob);
});
};
var requestBlob = function (url, withCredentials) {
return sendRequest(url, {}, withCredentials).then(function (result) {
return isError(result.status) ? handleHttpError(result.status) : Promise$1.resolve(result.blob);
});
};
var getUrl = function (url, apiKey, withCredentials) {
if (withCredentials === void 0) {
withCredentials = false;
}
return apiKey ? requestServiceBlob(url, apiKey) : requestBlob(url, withCredentials);
};
var blobToImageResult = function (blob) {
return fromBlob(blob);
};
var ELEMENT = 1;
var fromHtml = function (html, scope) {
var doc = scope || document;
var div = doc.createElement('div');
div.innerHTML = html;
if (!div.hasChildNodes() || div.childNodes.length > 1) {
console.error('HTML does not have a single root node', html);
throw new Error('HTML must have a single root node');
}
return fromDom(div.childNodes[0]);
};
var fromTag = function (tag, scope) {
var doc = scope || document;
var node = doc.createElement(tag);
return fromDom(node);
};
var fromText = function (text, scope) {
var doc = scope || document;
var node = doc.createTextNode(text);
return fromDom(node);
};
var fromDom = function (node) {
if (node === null || node === undefined) {
throw new Error('Node cannot be null or undefined');
}
return { dom: node };
};
var fromPoint = function (docElm, x, y) {
return Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom);
};
var SugarElement = {
fromHtml: fromHtml,
fromTag: fromTag,
fromText: fromText,
fromDom: fromDom,
fromPoint: fromPoint
};
var is = function (element, selector) {
var dom = element.dom;
if (dom.nodeType !== ELEMENT) {
return false;
} else {
var elem = dom;
if (elem.matches !== undefined) {
return elem.matches(selector);
} else if (elem.msMatchesSelector !== undefined) {
return elem.msMatchesSelector(selector);
} else if (elem.webkitMatchesSelector !== undefined) {
return elem.webkitMatchesSelector(selector);
} else if (elem.mozMatchesSelector !== undefined) {
return elem.mozMatchesSelector(selector);
} else {
throw new Error('Browser lacks native selectors');
}
}
};
typeof window !== 'undefined' ? window : Function('return this;')();
var child$1 = function (scope, predicate) {
var pred = function (node) {
return predicate(SugarElement.fromDom(node));
};
var result = find(scope.dom.childNodes, pred);
return result.map(SugarElement.fromDom);
};
var child = function (scope, selector) {
return child$1(scope, function (e) {
return is(e, selector);
});
};
var global$3 = tinymce.util.Tools.resolve('tinymce.util.Delay');
var global$2 = tinymce.util.Tools.resolve('tinymce.util.Promise');
var global$1 = tinymce.util.Tools.resolve('tinymce.util.URI');
var getToolbarItems = function (editor) {
return editor.getParam('imagetools_toolbar', 'rotateleft rotateright flipv fliph editimage imageoptions');
};
var getProxyUrl = function (editor) {
return editor.getParam('imagetools_proxy');
};
var getCorsHosts = function (editor) {
return editor.getParam('imagetools_cors_hosts', [], 'string[]');
};
var getCredentialsHosts = function (editor) {
return editor.getParam('imagetools_credentials_hosts', [], 'string[]');
};
var getFetchImage = function (editor) {
return Optional.from(editor.getParam('imagetools_fetch_image', null, 'function'));
};
var getApiKey = function (editor) {
return editor.getParam('api_key', editor.getParam('imagetools_api_key', '', 'string'), 'string');
};
var getUploadTimeout = function (editor) {
return editor.getParam('images_upload_timeout', 30000, 'number');
};
var shouldReuseFilename = function (editor) {
return editor.getParam('images_reuse_filename', false, 'boolean');
};
var getImageSize = function (img) {
var width, height;
var isPxValue = function (value) {
return /^[0-9\.]+px$/.test(value);
};
width = img.style.width;
height = img.style.height;
if (width || height) {
if (isPxValue(width) && isPxValue(height)) {
return {
w: parseInt(width, 10),
h: parseInt(height, 10)
};
}
return null;
}
width = img.width;
height = img.height;
if (width && height) {
return {
w: parseInt(width, 10),
h: parseInt(height, 10)
};
}
return null;
};
var setImageSize = function (img, size) {
var width, height;
if (size) {
width = img.style.width;
height = img.style.height;
if (width || height) {
img.style.width = size.w + 'px';
img.style.height = size.h + 'px';
img.removeAttribute('data-mce-style');
}
width = img.width;
height = img.height;
if (width || height) {
img.setAttribute('width', String(size.w));
img.setAttribute('height', String(size.h));
}
}
};
var getNaturalImageSize = function (img) {
return {
w: img.naturalWidth,
h: img.naturalHeight
};
};
var count = 0;
var getFigureImg = function (elem) {
return child(SugarElement.fromDom(elem), 'img');
};
var isFigure = function (editor, elem) {
return editor.dom.is(elem, 'figure');
};
var isImage = function (editor, imgNode) {
return editor.dom.is(imgNode, 'img:not([data-mce-object],[data-mce-placeholder])');
};
var getEditableImage = function (editor, node) {
var isEditable = function (imgNode) {
return isImage(editor, imgNode) && (isLocalImage(editor, imgNode) || isCorsImage(editor, imgNode) || isNonNullable(getProxyUrl(editor)));
};
if (isFigure(editor, node)) {
return getFigureImg(node).bind(function (img) {
return isEditable(img.dom) ? Optional.some(img.dom) : Optional.none();
});
} else {
return isEditable(node) ? Optional.some(node) : Optional.none();
}
};
var displayError = function (editor, error) {
editor.notificationManager.open({
text: error,
type: 'error'
});
};
var getSelectedImage = function (editor) {
var elem = editor.selection.getNode();
var figureElm = editor.dom.getParent(elem, 'figure.image');
if (figureElm !== null && isFigure(editor, figureElm)) {
return getFigureImg(figureElm);
} else if (isImage(editor, elem)) {
return Optional.some(SugarElement.fromDom(elem));
} else {
return Optional.none();
}
};
var extractFilename = function (editor, url, group) {
var m = url.match(/(?:\/|^)(([^\/\?]+)\.(?:[a-z0-9.]+))(?:\?|$)/i);
return isNonNullable(m) ? editor.dom.encode(m[group]) : null;
};
var createId = function () {
return 'imagetools' + count++;
};
var isLocalImage = function (editor, img) {
var url = img.src;
return url.indexOf('data:') === 0 || url.indexOf('blob:') === 0 || new global$1(url).host === editor.documentBaseURI.host;
};
var isCorsImage = function (editor, img) {
return global$4.inArray(getCorsHosts(editor), new global$1(img.src).host) !== -1;
};
var isCorsWithCredentialsImage = function (editor, img) {
return global$4.inArray(getCredentialsHosts(editor), new global$1(img.src).host) !== -1;
};
var defaultFetchImage = function (editor, img) {
if (isCorsImage(editor, img)) {
return getUrl(img.src, null, isCorsWithCredentialsImage(editor, img));
}
if (!isLocalImage(editor, img)) {
var proxyUrl = getProxyUrl(editor);
var src = proxyUrl + (proxyUrl.indexOf('?') === -1 ? '?' : '&') + 'url=' + encodeURIComponent(img.src);
var apiKey = getApiKey(editor);
return getUrl(src, apiKey, false);
}
return imageToBlob$1(img);
};
var imageToBlob = function (editor, img) {
return getFetchImage(editor).fold(function () {
return defaultFetchImage(editor, img);
}, function (customFetchImage) {
return customFetchImage(img);
});
};
var findBlob = function (editor, img) {
var blobInfo = editor.editorUpload.blobCache.getByUri(img.src);
if (blobInfo) {
return global$2.resolve(blobInfo.blob());
}
return imageToBlob(editor, img);
};
var startTimedUpload = function (editor, imageUploadTimerState) {
var imageUploadTimer = global$3.setEditorTimeout(editor, function () {
editor.editorUpload.uploadImagesAuto();
}, getUploadTimeout(editor));
imageUploadTimerState.set(imageUploadTimer);
};
var cancelTimedUpload = function (imageUploadTimerState) {
global$3.clearTimeout(imageUploadTimerState.get());
};
var updateSelectedImage = function (editor, origBlob, ir, uploadImmediately, imageUploadTimerState, selectedImage, size) {
return ir.toBlob().then(function (blob) {
var uri, name, filename, blobInfo;
var blobCache = editor.editorUpload.blobCache;
uri = selectedImage.src;
var useFilename = origBlob.type === blob.type;
if (shouldReuseFilename(editor)) {
blobInfo = blobCache.getByUri(uri);
if (isNonNullable(blobInfo)) {
uri = blobInfo.uri();
name = blobInfo.name();
filename = blobInfo.filename();
} else {
name = extractFilename(editor, uri, 2);
filename = extractFilename(editor, uri, 1);
}
}
blobInfo = blobCache.create({
id: createId(),
blob: blob,
base64: ir.toBase64(),
uri: uri,
name: name,
filename: useFilename ? filename : undefined
});
blobCache.add(blobInfo);
editor.undoManager.transact(function () {
var imageLoadedHandler = function () {
editor.$(selectedImage).off('load', imageLoadedHandler);
editor.nodeChanged();
if (uploadImmediately) {
editor.editorUpload.uploadImagesAuto();
} else {
cancelTimedUpload(imageUploadTimerState);
startTimedUpload(editor, imageUploadTimerState);
}
};
editor.$(selectedImage).on('load', imageLoadedHandler);
if (size) {
editor.$(selectedImage).attr({
width: size.w,
height: size.h
});
}
editor.$(selectedImage).attr({ src: blobInfo.blobUri() }).removeAttr('data-mce-src');
});
return blobInfo;
});
};
var selectedImageOperation = function (editor, imageUploadTimerState, fn, size) {
return function () {
var imgOpt = getSelectedImage(editor);
return imgOpt.fold(function () {
displayError(editor, 'Could not find selected image');
}, function (img) {
return editor._scanForImages().then(function () {
return findBlob(editor, img.dom);
}).then(function (blob) {
return blobToImageResult(blob).then(fn).then(function (imageResult) {
return updateSelectedImage(editor, blob, imageResult, false, imageUploadTimerState, img.dom, size);
});
}).catch(function (error) {
displayError(editor, error);
});
});
};
};
var rotate = function (editor, imageUploadTimerState, angle) {
return function () {
var imgOpt = getSelectedImage(editor);
var flippedSize = imgOpt.map(function (img) {
var size = getImageSize(img.dom);
return size ? {
w: size.h,
h: size.w
} : null;
}).getOrNull();
return selectedImageOperation(editor, imageUploadTimerState, function (imageResult) {
return rotate$1(imageResult, angle);
}, flippedSize)();
};
};
var flip = function (editor, imageUploadTimerState, axis) {
return function () {
return selectedImageOperation(editor, imageUploadTimerState, function (imageResult) {
return flip$1(imageResult, axis);
})();
};
};
var handleDialogBlob = function (editor, imageUploadTimerState, img, originalSize, blob) {
return blobToImage(blob).then(function (newImage) {
var newSize = getNaturalImageSize(newImage);
if (originalSize.w !== newSize.w || originalSize.h !== newSize.h) {
if (getImageSize(img)) {
setImageSize(img, newSize);
}
}
URL.revokeObjectURL(newImage.src);
return blob;
}).then(blobToImageResult).then(function (imageResult) {
return updateSelectedImage(editor, blob, imageResult, true, imageUploadTimerState, img);
});
};
var saveState = 'save-state';
var disable = 'disable';
var enable = 'enable';
var createState = function (blob) {
return {
blob: blob,
url: URL.createObjectURL(blob)
};
};
var makeOpen = function (editor, imageUploadTimerState) {
return function () {
var getLoadedSpec = function (currentState) {
return {
title: 'Edit Image',
size: 'large',
body: {
type: 'panel',
items: [{
type: 'imagetools',
name: 'imagetools',
label: 'Edit Image',
currentState: currentState
}]
},
buttons: [
{
type: 'cancel',
name: 'cancel',
text: 'Cancel'
},
{
type: 'submit',
name: 'save',
text: 'Save',
primary: true,
disabled: true
}
],
onSubmit: function (api) {
var blob = api.getData().imagetools.blob;
originalImgOpt.each(function (originalImg) {
originalSizeOpt.each(function (originalSize) {
handleDialogBlob(editor, imageUploadTimerState, originalImg.dom, originalSize, blob);
});
});
api.close();
},
onCancel: noop,
onAction: function (api, details) {
switch (details.name) {
case saveState:
if (details.value) {
api.enable('save');
} else {
api.disable('save');
}
break;
case disable:
api.disable('save');
api.disable('cancel');
break;
case enable:
api.enable('cancel');
break;
}
}
};
};
var originalImgOpt = getSelectedImage(editor);
var originalSizeOpt = originalImgOpt.map(function (origImg) {
return getNaturalImageSize(origImg.dom);
});
originalImgOpt.each(function (img) {
getEditableImage(editor, img.dom).each(function (_) {
findBlob(editor, img.dom).then(function (blob) {
var state = createState(blob);
editor.windowManager.open(getLoadedSpec(state));
});
});
});
};
};
var register$2 = function (editor, imageUploadTimerState) {
global$4.each({
mceImageRotateLeft: rotate(editor, imageUploadTimerState, -90),
mceImageRotateRight: rotate(editor, imageUploadTimerState, 90),
mceImageFlipVertical: flip(editor, imageUploadTimerState, 'v'),
mceImageFlipHorizontal: flip(editor, imageUploadTimerState, 'h'),
mceEditImage: makeOpen(editor, imageUploadTimerState)
}, function (fn, cmd) {
editor.addCommand(cmd, fn);
});
};
var setup = function (editor, imageUploadTimerState, lastSelectedImageState) {
editor.on('NodeChange', function (e) {
var lastSelectedImage = lastSelectedImageState.get();
var selectedImage = getEditableImage(editor, e.element);
if (lastSelectedImage && !selectedImage.exists(function (img) {
return lastSelectedImage.src === img.src;
})) {
cancelTimedUpload(imageUploadTimerState);
editor.editorUpload.uploadImagesAuto();
lastSelectedImageState.set(null);
}
selectedImage.each(lastSelectedImageState.set);
});
};
var register$1 = function (editor) {
var changeHandlers = [];
var cmd = function (command) {
return function () {
return editor.execCommand(command);
};
};
var isEditableImage = function () {
return getSelectedImage(editor).exists(function (element) {
return getEditableImage(editor, element.dom).isSome();
});
};
var onSetup = function (api) {
var handler = function (isEditableImage) {
return api.setDisabled(!isEditableImage);
};
handler(isEditableImage());
changeHandlers = changeHandlers.concat([handler]);
return function () {
changeHandlers = filter(changeHandlers, function (h) {
return h !== handler;
});
};
};
editor.on('NodeChange', function () {
var isEditable = isEditableImage();
each$1(changeHandlers, function (handler) {
return handler(isEditable);
});
});
editor.ui.registry.addButton('rotateleft', {
tooltip: 'Rotate counterclockwise',
icon: 'rotate-left',
onAction: cmd('mceImageRotateLeft'),
onSetup: onSetup
});
editor.ui.registry.addButton('rotateright', {
tooltip: 'Rotate clockwise',
icon: 'rotate-right',
onAction: cmd('mceImageRotateRight'),
onSetup: onSetup
});
editor.ui.registry.addButton('flipv', {
tooltip: 'Flip vertically',
icon: 'flip-vertically',
onAction: cmd('mceImageFlipVertical'),
onSetup: onSetup
});
editor.ui.registry.addButton('fliph', {
tooltip: 'Flip horizontally',
icon: 'flip-horizontally',
onAction: cmd('mceImageFlipHorizontal'),
onSetup: onSetup
});
editor.ui.registry.addButton('editimage', {
tooltip: 'Edit image',
icon: 'edit-image',
onAction: cmd('mceEditImage'),
onSetup: onSetup
});
editor.ui.registry.addButton('imageoptions', {
tooltip: 'Image options',
icon: 'image',
onAction: cmd('mceImage')
});
editor.ui.registry.addContextMenu('imagetools', {
update: function (element) {
return getEditableImage(editor, element).map(function (_) {
return {
text: 'Edit image',
icon: 'edit-image',
onAction: cmd('mceEditImage')
};
}).toArray();
}
});
};
var register = function (editor) {
editor.ui.registry.addContextToolbar('imagetools', {
items: getToolbarItems(editor),
predicate: function (elem) {
return getEditableImage(editor, elem).isSome();
},
position: 'node',
scope: 'node'
});
};
function Plugin () {
global$5.add('imagetools', function (editor) {
var imageUploadTimerState = Cell(0);
var lastSelectedImageState = Cell(null);
register$2(editor, imageUploadTimerState);
register$1(editor);
register(editor);
setup(editor, imageUploadTimerState, lastSelectedImageState);
});
}
Plugin();
}());