tinymce
Version:
Web based JavaScript HTML WYSIWYG editor control.
1,683 lines (1,631 loc) • 298 kB
JavaScript
/**
* 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.3.1 (2020-05-27)
*/
(function (domGlobals) {
'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 noop = function () {
};
var compose = function (fa, fb) {
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return fa(fb.apply(null, args));
};
};
var constant = function (value) {
return function () {
return value;
};
};
var identity = function (x) {
return x;
};
function curry(fn) {
var initialArgs = [];
for (var _i = 1; _i < arguments.length; _i++) {
initialArgs[_i - 1] = arguments[_i];
}
return function () {
var restArgs = [];
for (var _i = 0; _i < arguments.length; _i++) {
restArgs[_i] = arguments[_i];
}
var all = initialArgs.concat(restArgs);
return fn.apply(null, all);
};
}
var not = function (f) {
return function (t) {
return !f(t);
};
};
var die = function (msg) {
return function () {
throw new Error(msg);
};
};
var never = constant(false);
var always = constant(true);
var none = function () {
return NONE;
};
var NONE = function () {
var eq = function (o) {
return o.isNone();
};
var call = function (thunk) {
return thunk();
};
var id = function (n) {
return n;
};
var me = {
fold: function (n, _s) {
return n();
},
is: never,
isSome: never,
isNone: always,
getOr: id,
getOrThunk: call,
getOrDie: function (msg) {
throw new Error(msg || 'error: getOrDie called on none.');
},
getOrNull: constant(null),
getOrUndefined: constant(undefined),
or: id,
orThunk: call,
map: none,
each: noop,
bind: none,
exists: never,
forall: always,
filter: none,
equals: eq,
equals_: eq,
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);
},
is: function (v) {
return a === v;
},
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 + ')';
},
equals: function (o) {
return o.is(a);
},
equals_: function (o, elementEq) {
return o.fold(never, function (b) {
return elementEq(a, b);
});
}
};
return me;
};
var from = function (value) {
return value === null || value === undefined ? NONE : some(value);
};
var Option = {
some: some,
none: none,
from: from
};
var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
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 isString = isType('string');
var isArray = isType('array');
var isBoolean = isSimpleType('boolean');
var isFunction = isSimpleType('function');
var isNumber = isSimpleType('number');
var nativeSlice = Array.prototype.slice;
var nativeIndexOf = Array.prototype.indexOf;
var nativePush = Array.prototype.push;
var rawIndexOf = function (ts, t) {
return nativeIndexOf.call(ts, t);
};
var contains = function (xs, x) {
return rawIndexOf(xs, x) > -1;
};
var exists = function (xs, pred) {
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
if (pred(x, i)) {
return true;
}
}
return false;
};
var map = function (xs, f) {
var len = xs.length;
var r = new Array(len);
for (var i = 0; i < len; i++) {
var x = xs[i];
r[i] = f(x, i);
}
return r;
};
var each = function (xs, f) {
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
f(x, i);
}
};
var eachr = function (xs, f) {
for (var i = xs.length - 1; i >= 0; 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 foldr = function (xs, f, acc) {
eachr(xs, function (x) {
acc = f(acc, x);
});
return acc;
};
var foldl = function (xs, f, acc) {
each(xs, function (x) {
acc = f(acc, x);
});
return acc;
};
var findUntil = function (xs, pred, until) {
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
if (pred(x, i)) {
return Option.some(x);
} else if (until(x, i)) {
break;
}
}
return Option.none();
};
var find = function (xs, pred) {
return findUntil(xs, pred, never);
};
var findIndex = function (xs, pred) {
for (var i = 0, len = xs.length; i < len; i++) {
var x = xs[i];
if (pred(x, i)) {
return Option.some(i);
}
}
return Option.none();
};
var flatten = function (xs) {
var r = [];
for (var i = 0, len = xs.length; i < len; ++i) {
if (!isArray(xs[i])) {
throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
}
nativePush.apply(r, xs[i]);
}
return r;
};
var bind = function (xs, f) {
return flatten(map(xs, f));
};
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 reverse = function (xs) {
var r = nativeSlice.call(xs, 0);
r.reverse();
return r;
};
var last = function (xs) {
return xs.length === 0 ? Option.none() : Option.some(xs[xs.length - 1]);
};
var findMap = function (arr, f) {
for (var i = 0; i < arr.length; i++) {
var r = f(arr[i], i);
if (r.isSome()) {
return r;
}
}
return Option.none();
};
var keys = Object.keys;
var hasOwnProperty = Object.hasOwnProperty;
var each$1 = function (obj, f) {
var props = keys(obj);
for (var k = 0, len = props.length; k < len; k++) {
var i = props[k];
var x = obj[i];
f(x, i);
}
};
var map$1 = function (obj, f) {
return tupleMap(obj, function (x, i) {
return {
k: i,
v: f(x, i)
};
});
};
var tupleMap = function (obj, f) {
var r = {};
each$1(obj, function (x, i) {
var tuple = f(x, i);
r[tuple.k] = tuple.v;
});
return r;
};
var get = function (obj, key) {
return has(obj, key) ? Option.from(obj[key]) : Option.none();
};
var has = function (obj, key) {
return hasOwnProperty.call(obj, key);
};
var Global = typeof domGlobals.window !== 'undefined' ? domGlobals.window : Function('return this;')();
var COMMENT = 8;
var DOCUMENT = 9;
var ELEMENT = 1;
var TEXT = 3;
var name = function (element) {
var r = element.dom().nodeName;
return r.toLowerCase();
};
var type = function (element) {
return element.dom().nodeType;
};
var isType$1 = function (t) {
return function (element) {
return type(element) === t;
};
};
var isComment = function (element) {
return type(element) === COMMENT || name(element) === '#comment';
};
var isElement = isType$1(ELEMENT);
var isText = isType$1(TEXT);
var rawSet = function (dom, key, value) {
if (isString(value) || isBoolean(value) || isNumber(value)) {
dom.setAttribute(key, value + '');
} else {
domGlobals.console.error('Invalid call to Attr.set. Key ', key, ':: Value ', value, ':: Element ', dom);
throw new Error('Attribute value was not simple');
}
};
var set = function (element, key, value) {
rawSet(element.dom(), key, value);
};
var setAll = function (element, attrs) {
var dom = element.dom();
each$1(attrs, function (v, k) {
rawSet(dom, k, v);
});
};
var get$1 = function (element, key) {
var v = element.dom().getAttribute(key);
return v === null ? undefined : v;
};
var getOpt = function (element, key) {
return Option.from(get$1(element, key));
};
var has$1 = function (element, key) {
var dom = element.dom();
return dom && dom.hasAttribute ? dom.hasAttribute(key) : false;
};
var remove = function (element, key) {
element.dom().removeAttribute(key);
};
var clone = function (element) {
return foldl(element.dom().attributes, function (acc, attr) {
acc[attr.name] = attr.value;
return acc;
}, {});
};
var checkRange = function (str, substr, start) {
return substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
};
var contains$1 = function (str, substr) {
return str.indexOf(substr) !== -1;
};
var startsWith = function (str, prefix) {
return checkRange(str, prefix, 0);
};
var endsWith = function (str, suffix) {
return checkRange(str, suffix, str.length - suffix.length);
};
var blank = function (r) {
return function (s) {
return s.replace(r, '');
};
};
var trim = blank(/^\s+|\s+$/g);
var isSupported = function (dom) {
return dom.style !== undefined && isFunction(dom.style.getPropertyValue);
};
var fromHtml = function (html, scope) {
var doc = scope || domGlobals.document;
var div = doc.createElement('div');
div.innerHTML = html;
if (!div.hasChildNodes() || div.childNodes.length > 1) {
domGlobals.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 || domGlobals.document;
var node = doc.createElement(tag);
return fromDom(node);
};
var fromText = function (text, scope) {
var doc = scope || domGlobals.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: constant(node) };
};
var fromPoint = function (docElm, x, y) {
var doc = docElm.dom();
return Option.from(doc.elementFromPoint(x, y)).map(fromDom);
};
var Element = {
fromHtml: fromHtml,
fromTag: fromTag,
fromText: fromText,
fromDom: fromDom,
fromPoint: fromPoint
};
var inBody = function (element) {
var dom = isText(element) ? element.dom().parentNode : element.dom();
return dom !== undefined && dom !== null && dom.ownerDocument.body.contains(dom);
};
var body = function () {
return getBody(Element.fromDom(domGlobals.document));
};
var getBody = function (doc) {
var b = doc.dom().body;
if (b === null || b === undefined) {
throw new Error('Body is not available yet');
}
return Element.fromDom(b);
};
var internalSet = function (dom, property, value) {
if (!isString(value)) {
domGlobals.console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom);
throw new Error('CSS value must be a string: ' + value);
}
if (isSupported(dom)) {
dom.style.setProperty(property, value);
}
};
var internalRemove = function (dom, property) {
if (isSupported(dom)) {
dom.style.removeProperty(property);
}
};
var set$1 = function (element, property, value) {
var dom = element.dom();
internalSet(dom, property, value);
};
var setAll$1 = function (element, css) {
var dom = element.dom();
each$1(css, function (v, k) {
internalSet(dom, k, v);
});
};
var get$2 = function (element, property) {
var dom = element.dom();
var styles = domGlobals.window.getComputedStyle(dom);
var r = styles.getPropertyValue(property);
return r === '' && !inBody(element) ? getUnsafeProperty(dom, property) : r;
};
var getUnsafeProperty = function (dom, property) {
return isSupported(dom) ? dom.style.getPropertyValue(property) : '';
};
var getRaw = function (element, property) {
var dom = element.dom();
var raw = getUnsafeProperty(dom, property);
return Option.from(raw).filter(function (r) {
return r.length > 0;
});
};
var remove$1 = function (element, property) {
var dom = element.dom();
internalRemove(dom, property);
if (getOpt(element, 'style').map(trim).is('')) {
remove(element, 'style');
}
};
var copy = function (source, target) {
var sourceDom = source.dom();
var targetDom = target.dom();
if (isSupported(sourceDom) && isSupported(targetDom)) {
targetDom.style.cssText = sourceDom.style.cssText;
}
};
var compareDocumentPosition = function (a, b, match) {
return (a.compareDocumentPosition(b) & match) !== 0;
};
var documentPositionContainedBy = function (a, b) {
return compareDocumentPosition(a, b, domGlobals.Node.DOCUMENT_POSITION_CONTAINED_BY);
};
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);
};
var cached = function (f) {
var called = false;
var r;
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (!called) {
called = true;
r = f.apply(null, args);
}
return r;
};
};
var firstMatch = function (regexes, s) {
for (var i = 0; i < regexes.length; i++) {
var x = regexes[i];
if (x.test(s)) {
return x;
}
}
return undefined;
};
var find$1 = function (regexes, agent) {
var r = firstMatch(regexes, agent);
if (!r) {
return {
major: 0,
minor: 0
};
}
var group = function (i) {
return Number(agent.replace(r, '$' + i));
};
return nu(group(1), group(2));
};
var detect = function (versionRegexes, agent) {
var cleanedAgent = String(agent).toLowerCase();
if (versionRegexes.length === 0) {
return unknown();
}
return find$1(versionRegexes, cleanedAgent);
};
var unknown = function () {
return nu(0, 0);
};
var nu = function (major, minor) {
return {
major: major,
minor: minor
};
};
var Version = {
nu: nu,
detect: detect,
unknown: unknown
};
var edge = 'Edge';
var chrome = 'Chrome';
var ie = 'IE';
var opera = 'Opera';
var firefox = 'Firefox';
var safari = 'Safari';
var unknown$1 = function () {
return nu$1({
current: undefined,
version: Version.unknown()
});
};
var nu$1 = function (info) {
var current = info.current;
var version = info.version;
var isBrowser = function (name) {
return function () {
return current === name;
};
};
return {
current: current,
version: version,
isEdge: isBrowser(edge),
isChrome: isBrowser(chrome),
isIE: isBrowser(ie),
isOpera: isBrowser(opera),
isFirefox: isBrowser(firefox),
isSafari: isBrowser(safari)
};
};
var Browser = {
unknown: unknown$1,
nu: nu$1,
edge: constant(edge),
chrome: constant(chrome),
ie: constant(ie),
opera: constant(opera),
firefox: constant(firefox),
safari: constant(safari)
};
var windows = 'Windows';
var ios = 'iOS';
var android = 'Android';
var linux = 'Linux';
var osx = 'OSX';
var solaris = 'Solaris';
var freebsd = 'FreeBSD';
var chromeos = 'ChromeOS';
var unknown$2 = function () {
return nu$2({
current: undefined,
version: Version.unknown()
});
};
var nu$2 = function (info) {
var current = info.current;
var version = info.version;
var isOS = function (name) {
return function () {
return current === name;
};
};
return {
current: current,
version: version,
isWindows: isOS(windows),
isiOS: isOS(ios),
isAndroid: isOS(android),
isOSX: isOS(osx),
isLinux: isOS(linux),
isSolaris: isOS(solaris),
isFreeBSD: isOS(freebsd),
isChromeOS: isOS(chromeos)
};
};
var OperatingSystem = {
unknown: unknown$2,
nu: nu$2,
windows: constant(windows),
ios: constant(ios),
android: constant(android),
linux: constant(linux),
osx: constant(osx),
solaris: constant(solaris),
freebsd: constant(freebsd),
chromeos: constant(chromeos)
};
var DeviceType = function (os, browser, userAgent, mediaMatch) {
var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
var isiPhone = os.isiOS() && !isiPad;
var isMobile = os.isiOS() || os.isAndroid();
var isTouch = isMobile || mediaMatch('(pointer:coarse)');
var isTablet = isiPad || !isiPhone && isMobile && mediaMatch('(min-device-width:768px)');
var isPhone = isiPhone || isMobile && !isTablet;
var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
var isDesktop = !isPhone && !isTablet && !iOSwebview;
return {
isiPad: constant(isiPad),
isiPhone: constant(isiPhone),
isTablet: constant(isTablet),
isPhone: constant(isPhone),
isTouch: constant(isTouch),
isAndroid: os.isAndroid,
isiOS: os.isiOS,
isWebView: constant(iOSwebview),
isDesktop: constant(isDesktop)
};
};
var detect$1 = function (candidates, userAgent) {
var agent = String(userAgent).toLowerCase();
return find(candidates, function (candidate) {
return candidate.search(agent);
});
};
var detectBrowser = function (browsers, userAgent) {
return detect$1(browsers, userAgent).map(function (browser) {
var version = Version.detect(browser.versionRegexes, userAgent);
return {
current: browser.name,
version: version
};
});
};
var detectOs = function (oses, userAgent) {
return detect$1(oses, userAgent).map(function (os) {
var version = Version.detect(os.versionRegexes, userAgent);
return {
current: os.name,
version: version
};
});
};
var UaString = {
detectBrowser: detectBrowser,
detectOs: detectOs
};
var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
var checkContains = function (target) {
return function (uastring) {
return contains$1(uastring, target);
};
};
var browsers = [
{
name: 'Edge',
versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
search: function (uastring) {
return contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit');
}
},
{
name: 'Chrome',
versionRegexes: [
/.*?chrome\/([0-9]+)\.([0-9]+).*/,
normalVersionRegex
],
search: function (uastring) {
return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe');
}
},
{
name: 'IE',
versionRegexes: [
/.*?msie\ ?([0-9]+)\.([0-9]+).*/,
/.*?rv:([0-9]+)\.([0-9]+).*/
],
search: function (uastring) {
return contains$1(uastring, 'msie') || contains$1(uastring, 'trident');
}
},
{
name: 'Opera',
versionRegexes: [
normalVersionRegex,
/.*?opera\/([0-9]+)\.([0-9]+).*/
],
search: checkContains('opera')
},
{
name: 'Firefox',
versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
search: checkContains('firefox')
},
{
name: 'Safari',
versionRegexes: [
normalVersionRegex,
/.*?cpu os ([0-9]+)_([0-9]+).*/
],
search: function (uastring) {
return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit');
}
}
];
var oses = [
{
name: 'Windows',
search: checkContains('win'),
versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
},
{
name: 'iOS',
search: function (uastring) {
return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad');
},
versionRegexes: [
/.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
/.*cpu os ([0-9]+)_([0-9]+).*/,
/.*cpu iphone os ([0-9]+)_([0-9]+).*/
]
},
{
name: 'Android',
search: checkContains('android'),
versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
},
{
name: 'OSX',
search: checkContains('mac os x'),
versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]
},
{
name: 'Linux',
search: checkContains('linux'),
versionRegexes: []
},
{
name: 'Solaris',
search: checkContains('sunos'),
versionRegexes: []
},
{
name: 'FreeBSD',
search: checkContains('freebsd'),
versionRegexes: []
},
{
name: 'ChromeOS',
search: checkContains('cros'),
versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/]
}
];
var PlatformInfo = {
browsers: constant(browsers),
oses: constant(oses)
};
var detect$2 = function (userAgent, mediaMatch) {
var browsers = PlatformInfo.browsers();
var oses = PlatformInfo.oses();
var browser = UaString.detectBrowser(browsers, userAgent).fold(Browser.unknown, Browser.nu);
var os = UaString.detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
var deviceType = DeviceType(os, browser, userAgent, mediaMatch);
return {
browser: browser,
os: os,
deviceType: deviceType
};
};
var PlatformDetection = { detect: detect$2 };
var mediaMatch = function (query) {
return domGlobals.window.matchMedia(query).matches;
};
var platform = cached(function () {
return PlatformDetection.detect(domGlobals.navigator.userAgent, mediaMatch);
});
var detect$3 = function () {
return platform();
};
var ELEMENT$1 = ELEMENT;
var DOCUMENT$1 = DOCUMENT;
var is = function (element, selector) {
var dom = element.dom();
if (dom.nodeType !== ELEMENT$1) {
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');
}
}
};
var bypassSelector = function (dom) {
return dom.nodeType !== ELEMENT$1 && dom.nodeType !== DOCUMENT$1 || dom.childElementCount === 0;
};
var all = function (selector, scope) {
var base = scope === undefined ? domGlobals.document : scope.dom();
return bypassSelector(base) ? [] : map(base.querySelectorAll(selector), Element.fromDom);
};
var one = function (selector, scope) {
var base = scope === undefined ? domGlobals.document : scope.dom();
return bypassSelector(base) ? Option.none() : Option.from(base.querySelector(selector)).map(Element.fromDom);
};
var eq = function (e1, e2) {
return e1.dom() === e2.dom();
};
var regularContains = function (e1, e2) {
var d1 = e1.dom();
var d2 = e2.dom();
return d1 === d2 ? false : d1.contains(d2);
};
var ieContains = function (e1, e2) {
return documentPositionContainedBy(e1.dom(), e2.dom());
};
var contains$2 = function (e1, e2) {
return detect$3().browser.isIE() ? ieContains(e1, e2) : regularContains(e1, e2);
};
var is$1 = is;
var owner = function (element) {
return Element.fromDom(element.dom().ownerDocument);
};
var defaultView = function (element) {
return Element.fromDom(element.dom().ownerDocument.defaultView);
};
var parent = function (element) {
return Option.from(element.dom().parentNode).map(Element.fromDom);
};
var parents = function (element, isRoot) {
var stop = isFunction(isRoot) ? isRoot : never;
var dom = element.dom();
var ret = [];
while (dom.parentNode !== null && dom.parentNode !== undefined) {
var rawParent = dom.parentNode;
var p = Element.fromDom(rawParent);
ret.push(p);
if (stop(p) === true) {
break;
} else {
dom = rawParent;
}
}
return ret;
};
var prevSibling = function (element) {
return Option.from(element.dom().previousSibling).map(Element.fromDom);
};
var nextSibling = function (element) {
return Option.from(element.dom().nextSibling).map(Element.fromDom);
};
var children = function (element) {
return map(element.dom().childNodes, Element.fromDom);
};
var child = function (element, index) {
var cs = element.dom().childNodes;
return Option.from(cs[index]).map(Element.fromDom);
};
var firstChild = function (element) {
return child(element, 0);
};
var before = function (marker, element) {
var parent$1 = parent(marker);
parent$1.each(function (v) {
v.dom().insertBefore(element.dom(), marker.dom());
});
};
var after = function (marker, element) {
var sibling = nextSibling(marker);
sibling.fold(function () {
var parent$1 = parent(marker);
parent$1.each(function (v) {
append(v, element);
});
}, function (v) {
before(v, element);
});
};
var prepend = function (parent, element) {
var firstChild$1 = firstChild(parent);
firstChild$1.fold(function () {
append(parent, element);
}, function (v) {
parent.dom().insertBefore(element.dom(), v.dom());
});
};
var append = function (parent, element) {
parent.dom().appendChild(element.dom());
};
var wrap = function (element, wrapper) {
before(element, wrapper);
append(wrapper, element);
};
var before$1 = function (marker, elements) {
each(elements, function (x) {
before(marker, x);
});
};
var after$1 = function (marker, elements) {
each(elements, function (x, i) {
var e = i === 0 ? marker : elements[i - 1];
after(e, x);
});
};
var append$1 = function (parent, elements) {
each(elements, function (x) {
append(parent, x);
});
};
var empty = function (element) {
element.dom().textContent = '';
each(children(element), function (rogue) {
remove$2(rogue);
});
};
var remove$2 = function (element) {
var dom = element.dom();
if (dom.parentNode !== null) {
dom.parentNode.removeChild(dom);
}
};
var unwrap = function (wrapper) {
var children$1 = children(wrapper);
if (children$1.length > 0) {
before$1(wrapper, children$1);
}
remove$2(wrapper);
};
var grid = function (rows, columns) {
return {
rows: constant(rows),
columns: constant(columns)
};
};
var address = function (row, column) {
return {
row: constant(row),
column: constant(column)
};
};
var detail = function (element, rowspan, colspan) {
return {
element: constant(element),
rowspan: constant(rowspan),
colspan: constant(colspan)
};
};
var detailnew = function (element, rowspan, colspan, isNew) {
return {
element: constant(element),
rowspan: constant(rowspan),
colspan: constant(colspan),
isNew: constant(isNew)
};
};
var extended = function (element, rowspan, colspan, row, column) {
return {
element: constant(element),
rowspan: constant(rowspan),
colspan: constant(colspan),
row: constant(row),
column: constant(column)
};
};
var rowdata = function (element, cells, section) {
return {
element: constant(element),
cells: constant(cells),
section: constant(section)
};
};
var elementnew = function (element, isNew) {
return {
element: constant(element),
isNew: constant(isNew)
};
};
var rowdatanew = function (element, cells, section, isNew) {
return {
element: constant(element),
cells: constant(cells),
section: constant(section),
isNew: constant(isNew)
};
};
var rowcells = function (cells, section) {
return {
cells: constant(cells),
section: constant(section)
};
};
var rowdetails = function (details, section) {
return {
details: constant(details),
section: constant(section)
};
};
var bounds = function (startRow, startCol, finishRow, finishCol) {
return {
startRow: constant(startRow),
startCol: constant(startCol),
finishRow: constant(finishRow),
finishCol: constant(finishCol)
};
};
var ancestors = function (scope, predicate, isRoot) {
return filter(parents(scope, isRoot), predicate);
};
var children$1 = function (scope, predicate) {
return filter(children(scope), predicate);
};
var descendants = function (scope, predicate) {
var result = [];
each(children(scope), function (x) {
if (predicate(x)) {
result = result.concat([x]);
}
result = result.concat(descendants(x, predicate));
});
return result;
};
var ancestors$1 = function (scope, selector, isRoot) {
return ancestors(scope, function (e) {
return is(e, selector);
}, isRoot);
};
var children$2 = function (scope, selector) {
return children$1(scope, function (e) {
return is(e, selector);
});
};
var descendants$1 = function (scope, selector) {
return all(selector, scope);
};
function ClosestOrAncestor (is, ancestor, scope, a, isRoot) {
return is(scope, a) ? Option.some(scope) : isFunction(isRoot) && isRoot(scope) ? Option.none() : ancestor(scope, a, isRoot);
}
var ancestor = function (scope, predicate, isRoot) {
var element = scope.dom();
var stop = isFunction(isRoot) ? isRoot : constant(false);
while (element.parentNode) {
element = element.parentNode;
var el = Element.fromDom(element);
if (predicate(el)) {
return Option.some(el);
} else if (stop(el)) {
break;
}
}
return Option.none();
};
var closest = function (scope, predicate, isRoot) {
var is = function (s, test) {
return test(s);
};
return ClosestOrAncestor(is, ancestor, scope, predicate, isRoot);
};
var child$1 = function (scope, predicate) {
var pred = function (node) {
return predicate(Element.fromDom(node));
};
var result = find(scope.dom().childNodes, pred);
return result.map(Element.fromDom);
};
var descendant = function (scope, predicate) {
var descend = function (node) {
for (var i = 0; i < node.childNodes.length; i++) {
var child_1 = Element.fromDom(node.childNodes[i]);
if (predicate(child_1)) {
return Option.some(child_1);
}
var res = descend(node.childNodes[i]);
if (res.isSome()) {
return res;
}
}
return Option.none();
};
return descend(scope.dom());
};
var ancestor$1 = function (scope, selector, isRoot) {
return ancestor(scope, function (e) {
return is(e, selector);
}, isRoot);
};
var child$2 = function (scope, selector) {
return child$1(scope, function (e) {
return is(e, selector);
});
};
var descendant$1 = function (scope, selector) {
return one(selector, scope);
};
var closest$1 = function (scope, selector, isRoot) {
var is$1 = function (element, selector) {
return is(element, selector);
};
return ClosestOrAncestor(is$1, ancestor$1, scope, selector, isRoot);
};
var getAttrValue = function (cell, name, fallback) {
if (fallback === void 0) {
fallback = 0;
}
return getOpt(cell, name).map(function (value) {
return parseInt(value, 10);
}).getOr(fallback);
};
var getSpan = function (cell, type) {
return getAttrValue(cell, type, 1);
};
var hasColspan = function (cell) {
return getSpan(cell, 'colspan') > 1;
};
var hasRowspan = function (cell) {
return getSpan(cell, 'rowspan') > 1;
};
var getCssValue = function (element, property) {
return parseInt(get$2(element, property), 10);
};
var minWidth = constant(10);
var minHeight = constant(10);
var firstLayer = function (scope, selector) {
return filterFirstLayer(scope, selector, constant(true));
};
var filterFirstLayer = function (scope, selector, predicate) {
return bind(children(scope), function (x) {
return is(x, selector) ? predicate(x) ? [x] : [] : filterFirstLayer(x, selector, predicate);
});
};
var lookup = function (tags, element, isRoot) {
if (isRoot === void 0) {
isRoot = never;
}
if (isRoot(element)) {
return Option.none();
}
if (contains(tags, name(element))) {
return Option.some(element);
}
var isRootOrUpperTable = function (elm) {
return is(elm, 'table') || isRoot(elm);
};
return ancestor$1(element, tags.join(','), isRootOrUpperTable);
};
var cell = function (element, isRoot) {
return lookup([
'td',
'th'
], element, isRoot);
};
var cells = function (ancestor) {
return firstLayer(ancestor, 'th,td');
};
var neighbours = function (selector, element) {
return parent(element).map(function (parent) {
return children$2(parent, selector);
});
};
var neighbourCells = curry(neighbours, 'th,td');
var neighbourRows = curry(neighbours, 'tr');
var table = function (element, isRoot) {
return closest$1(element, 'table', isRoot);
};
var rows = function (ancestor) {
return firstLayer(ancestor, 'tr');
};
var fromTable = function (table) {
var rows$1 = rows(table);
return map(rows$1, function (row) {
var element = row;
var parent$1 = parent(element);
var parentSection = parent$1.map(function (p) {
var parentName = name(p);
return parentName === 'tfoot' || parentName === 'thead' || parentName === 'tbody' ? parentName : 'tbody';
}).getOr('tbody');
var cells$1 = map(cells(row), function (cell) {
var rowspan = getAttrValue(cell, 'rowspan', 1);
var colspan = getAttrValue(cell, 'colspan', 1);
return detail(cell, rowspan, colspan);
});
return rowdata(element, cells$1, parentSection);
});
};
var fromPastedRows = function (rows, example) {
return map(rows, function (row) {
var cells$1 = map(cells(row), function (cell) {
var rowspan = getAttrValue(cell, 'rowspan', 1);
var colspan = getAttrValue(cell, 'colspan', 1);
return detail(cell, rowspan, colspan);
});
return rowdata(row, cells$1, example.section());
});
};
var key = function (row, column) {
return row + ',' + column;
};
var getAt = function (warehouse, row, column) {
var raw = warehouse.access[key(row, column)];
return raw !== undefined ? Option.some(raw) : Option.none();
};
var findItem = function (warehouse, item, comparator) {
var filtered = filterItems(warehouse, function (detail) {
return comparator(item, detail.element());
});
return filtered.length > 0 ? Option.some(filtered[0]) : Option.none();
};
var filterItems = function (warehouse, predicate) {
var all = bind(warehouse.all, function (r) {
return r.cells();
});
return filter(all, predicate);
};
var generate = function (list) {
var access = {};
var cells = [];
var maxRows = list.length;
var maxColumns = 0;
each(list, function (details, r) {
var currentRow = [];
each(details.cells(), function (detail) {
var start = 0;
while (access[key(r, start)] !== undefined) {
start++;
}
var current = extended(detail.element(), detail.rowspan(), detail.colspan(), r, start);
for (var i = 0; i < detail.colspan(); i++) {
for (var j = 0; j < detail.rowspan(); j++) {
var cr = r + j;
var cc = start + i;
var newpos = key(cr, cc);
access[newpos] = current;
maxColumns = Math.max(maxColumns, cc + 1);
}
}
currentRow.push(current);
});
cells.push(rowdata(details.element(), currentRow, details.section()));
});
var grid$1 = grid(maxRows, maxColumns);
return {
grid: grid$1,
access: access,
all: cells
};
};
var justCells = function (warehouse) {
var rows = map(warehouse.all, function (w) {
return w.cells();
});
return flatten(rows);
};
var Warehouse = {
generate: generate,
getAt: getAt,
findItem: findItem,
filterItems: filterItems,
justCells: justCells
};
var statsStruct = function (minRow, minCol, maxRow, maxCol) {
return {
minRow: minRow,
minCol: minCol,
maxRow: maxRow,
maxCol: maxCol
};
};
var findSelectedStats = function (house, isSelected) {
var totalColumns = house.grid.columns();
var totalRows = house.grid.rows();
var minRow = totalRows;
var minCol = totalColumns;
var maxRow = 0;
var maxCol = 0;
each$1(house.access, function (detail) {
if (isSelected(detail)) {
var startRow = detail.row();
var endRow = startRow + detail.rowspan() - 1;
var startCol = detail.column();
var endCol = startCol + detail.colspan() - 1;
if (startRow < minRow) {
minRow = startRow;
} else if (endRow > maxRow) {
maxRow = endRow;
}
if (startCol < minCol) {
minCol = startCol;
} else if (endCol > maxCol) {
maxCol = endCol;
}
}
});
return statsStruct(minRow, minCol, maxRow, maxCol);
};
var makeCell = function (list, seenSelected, rowIndex) {
var row = list[rowIndex].element();
var td = Element.fromTag('td');
append(td, Element.fromTag('br'));
var f = seenSelected ? append : prepend;
f(row, td);
};
var fillInGaps = function (list, house, stats, isSelected) {
var totalColumns = house.grid.columns();
var totalRows = house.grid.rows();
for (var i = 0; i < totalRows; i++) {
var seenSelected = false;
for (var j = 0; j < totalColumns; j++) {
if (!(i < stats.minRow || i > stats.maxRow || j < stats.minCol || j > stats.maxCol)) {
var needCell = Warehouse.getAt(house, i, j).filter(isSelected).isNone();
if (needCell) {
makeCell(list, seenSelected, i);
} else {
seenSelected = true;
}
}
}
}
};
var clean = function (table, stats) {
var emptyRows = filter(firstLayer(table, 'tr'), function (row) {
return row.dom().childElementCount === 0;
});
each(emptyRows, remove$2);
if (stats.minCol === stats.maxCol || stats.minRow === stats.maxRow) {
each(firstLayer(table, 'th,td'), function (cell) {
remove(cell, 'rowspan');
remove(cell, 'colspan');
});
}
remove(table, 'width');
remove(table, 'height');
remove$1(table, 'width');
remove$1(table, 'height');
};
var extract = function (table, selectedSelector) {
var isSelected = function (detail) {
return is(detail.element(), selectedSelector);
};
var list = fromTable(table);
var house = Warehouse.generate(list);
var stats = findSelectedStats(house, isSelected);
var selector = 'th:not(' + selectedSelector + ')' + ',td:not(' + selectedSelector + ')';
var unselectedCells = filterFirstLayer(table, 'th,td', function (cell) {
return is(cell, selector);
});
each(unselectedCells, remove$2);
fillInGaps(list, house, stats, isSelected);
clean(table, stats);
return table;
};
var nbsp = '\xA0';
function NodeValue (is, name) {
var get = function (element) {
if (!is(element)) {
throw new Error('Can only get ' + name + ' value of a ' + name + ' node');
}
return getOption(element).getOr('');
};
var getOption = function (element) {
return is(element) ? Option.from(element.dom().nodeValue) : Option.none();
};
var set = function (element, value) {
if (!is(element)) {
throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node');
}
element.dom().nodeValue = value;
};
return {
get: get,
getOption: getOption,
set: set
};
}
var api = NodeValue(isText, 'text');
var get$3 = function (element) {
return api.get(element);
};
var getOption = function (element) {
return api.getOption(element);
};
var set$2 = function (element, value) {
return api.set(element, value);
};
var getEnd = function (element) {
return name(element) === 'img' ? 1 : getOption(element).fold(function () {
return children(element).length;
}, function (v) {
return v.length;
});
};
var isTextNodeWithCursorPosition = function (el) {
return getOption(el).filter(function (text) {
return text.trim().length !== 0 || text.indexOf(nbsp) > -1;
}).isSome();
};
var elementsWithCursorPosition = [
'img',
'br'
];
var isCursorPosition = function (elem) {
var hasCursorPosition = isTextNodeWithCursorPosition(elem);
return hasCursorPosition || contains(elementsWithCursorPosition, name(elem));
};
var first = function (element) {
return descendant(element, isCursorPosition);
};
var last$1 = function (element) {
return descendantRtl(element, isCursorPosition);
};
var descendantRtl = function (scope, predicate) {
var descend = function (element) {
var children$1 = children(element);
for (var i = children$1.length - 1; i >= 0; i--) {
var child = children$1[i];
if (predicate(child)) {
return Option.some(child);
}
var res = descend(child);
if (res.isSome()) {
return res;
}
}
return Option.none();
};
return descend(scope);
};
var clone$1 = function (original, isDeep) {
return Element.fromDom(original.dom().cloneNode(isDeep));
};
var shallow = function (original) {
return clone$1(original, false);
};
var deep = function (original) {
return clone$1(original, true);
};
var shallowAs = function (original, tag) {
var nu = Element.fromTag(tag);
var attributes = clone(original);
setAll(nu, attributes);
return nu;
};
var copy$1 = function (original, tag) {
var nu = shallowAs(original, tag);
var cloneChildren = children(deep(original));
append$1(nu, cloneChildren);
return nu;
};
var createCell = function () {
var td = Element.fromTag('td');
append(td, Element.fromTag('br'));
return td;
};
var replace = function (cell, tag, attrs) {
var replica = copy$1(cell, tag);
each$1(attrs, function (v, k) {
if (v === null) {
remove(replica, k);
} else {
set(replica, k, v);
}
});
return replica;
};
var pasteReplace = function (cell) {
return cell;
};
var newRow = function (doc) {
return function () {
return Element.fromTag('tr', doc.dom());
};
};
var cloneFormats = function (oldCell, newCell, formats) {
var first$1 = first(oldCell);
return first$1.map(function (firstText) {
var formatSelector = formats.join(',');
var parents = ancestors$1(firstText, formatSelector, function (element) {
return eq(element, oldCell);
});
return foldr(parents, function (last, parent) {
var clonedFormat = shallow(parent);
remove(clonedFormat, 'contenteditable');
append(last, clonedFormat);
return clonedFormat;
}, newCell);
}).getOr(newCell);
};
var cellOperations = function (mutate, doc, formatsToClone) {
var newCell = function (prev) {
var docu = owner(prev.element());
var td = Element.fromTag(name(prev.element()), docu.dom());
var formats = formatsToClone.getOr([
'strong',
'em',
'b',
'i',
'span',
'font',
'h1',
'h2',
'h3',
'h4',
'h5',
'h6',
'p',
'div'
]);
var lastNode = formats.length > 0 ? cloneFormats(prev.element(), td, formats) : td;
append(lastNode, Element.fromTag('br'));
copy(prev.element(), td);
remove$1(td, 'height');
if (prev.colspan() !== 1) {
remove$1(prev.element(), 'width');
}
mutate(prev.element(), td);
return td;
};
return {
row: newRow(doc),
cell: newCell,