enmi-conf.org: comparison wp/wp-includes/js/tinymce/plugins/lists/plugin.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-includes/js/tinymce/plugins/lists/plugin.js

changeset 16	a86126ab1dd4
parent 9	177826044cd9

equal deleted inserted replaced

-:3d4e9c994f10
+:a86126ab1dd4
 var Bookmark = {
 createBookmark: createBookmark,
 resolveBookmark: resolveBookmark
 };
+var noop = function () {
+};
 var constant = function (value) {
 return function () {
 return value;
 };
 };
 };
 };
 var never = constant(false);
 var always = constant(true);
-var never$1 = never;
-var always$1 = always;
 var none = function () {
 return NONE;
 };
 var NONE = function () {
 var eq = function (o) {
 var call = function (thunk) {
 return thunk();
 };
 var id = function (n) {
 return n;
-};
-var noop = function () {
-};
-var nul = function () {
-return null;
-};
-var undef = function () {
-return undefined;
 };
 var me = {
 fold: function (n, s) {
 return n();
 },
-is: never$1,
+is: never,
-isSome: never$1,
+isSome: never,
-isNone: always$1,
+isNone: always,
 getOr: id,
 getOrThunk: call,
 getOrDie: function (msg) {
 throw new Error(msg || 'error: getOrDie called on none.');
 },
-getOrNull: nul,
+getOrNull: constant(null),
-getOrUndefined: undef,
+getOrUndefined: constant(undefined),
 or: id,
 orThunk: call,
 map: none,
-ap: none,
 each: noop,
 bind: none,
-flatten: none,
+exists: never,
-exists: never$1,
+forall: always,
-forall: always$1,
 filter: none,
 equals: eq,
 equals_: eq,
 toArray: function () {
 return [];
 },
 toString: constant('none()')
 };
-if (Object.freeze)
+if (Object.freeze) {
 Object.freeze(me);
+}
 return me;
 }();
 var some = function (a) {
-var constant_a = function () {
+var constant_a = constant(a);
-return a;
-};
 var self = function () {
 return me;
-};
-var map = function (f) {
-return some(f(a));
 };
 var bind = function (f) {
 return f(a);
 };
 var me = {
 return s(a);
 },
 is: function (v) {
 return a === v;
 },
-isSome: always$1,
+isSome: always,
-isNone: never$1,
+isNone: never,
 getOr: constant_a,
 getOrThunk: constant_a,
 getOrDie: constant_a,
 getOrNull: constant_a,
 getOrUndefined: constant_a,
 or: self,
 orThunk: self,
-map: map,
+map: function (f) {
-ap: function (optfab) {
+return some(f(a));
-return optfab.fold(none, function (fab) {
-return some(fab(a));
-});
 },
 each: function (f) {
 f(a);
 },
 bind: bind,
-flatten: constant_a,
 exists: bind,
 forall: bind,
 filter: function (f) {
 return f(a) ? me : NONE;
-},
-equals: function (o) {
-return o.is(a);
-},
-equals_: function (o, elementEq) {
-return o.fold(never$1, function (b) {
-return elementEq(a, b);
-});
 },
 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) {
 none: none,
 from: from
 };
 var typeOf = function (x) {
-if (x === null)
+if (x === null) {
 return 'null';
+}
 var t = typeof x;
-if (t === 'object' && Array.prototype.isPrototypeOf(x))
+if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
 return 'array';
-if (t === 'object' && String.prototype.isPrototypeOf(x))
+}
+if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
 return 'string';
+}
 return t;
 };
 var isType = function (type) {
 return function (value) {
 return typeOf(value) === type;
 };
 };
 var isString = isType('string');
+var isArray = isType('array');
 var isBoolean = isType('boolean');
 var isFunction = isType('function');
 var isNumber = isType('number');
+var nativeSlice = Array.prototype.slice;
+var nativePush = Array.prototype.push;
 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, xs);
+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, xs);
+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, xs)) {
+if (pred(x, i)) {
 r.push(x);
 }
 }
 return r;
 };
 return acc;
 };
 var find = function (xs, pred) {
 for (var i = 0, len = xs.length; i < len; i++) {
 var x = xs[i];
-if (pred(x, i, xs)) {
+if (pred(x, i)) {
 return Option.some(x);
 }
 }
 return Option.none();
 };
-var push = Array.prototype.push;
 var flatten = function (xs) {
 var r = [];
 for (var i = 0, len = xs.length; i < len; ++i) {
-if (!Array.prototype.isPrototypeOf(xs[i]))
+if (!isArray(xs[i])) {
 throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
-push.apply(r, xs[i]);
+}
+nativePush.apply(r, xs[i]);
 }
 return r;
 };
 var bind = function (xs, f) {
 var output = map(xs, f);
 return flatten(output);
 };
-var slice = Array.prototype.slice;
 var reverse = function (xs) {
-var r = slice.call(xs, 0);
+var r = nativeSlice.call(xs, 0);
 r.reverse();
 return r;
 };
 var head = function (xs) {
 return xs.length === 0 ? Option.none() : Option.some(xs[0]);
 };
 var last = function (xs) {
 return xs.length === 0 ? Option.none() : Option.some(xs[xs.length - 1]);
 };
 var from$1 = isFunction(Array.from) ? Array.from : function (x) {
-return slice.call(x);
+return nativeSlice.call(x);
 };
 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)
+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)
+if (actual === undefined || actual === null) {
-throw name + ' not available on this browser';
+throw new Error(name + ' not available on this browser');
+}
 return actual;
 };
 var Global$1 = { getOrDie: getOrDie };
 var htmlElement = function (scope) {
 fromText: fromText,
 fromDom: fromDom,
 fromPoint: fromPoint
 };
-var liftN = function (arr, f) {
+var lift2 = function (oa, ob, f) {
-var r = [];
+return oa.isSome() && ob.isSome() ? Option.some(f(oa.getOrDie(), ob.getOrDie())) : Option.none();
-for (var i = 0; i < arr.length; i++) {
-var x = arr[i];
-if (x.isSome()) {
-r.push(x.getOrDie());
-} else {
-return Option.none();
-}
-}
-return Option.some(f.apply(null, r));
 };
 var fromElements = function (elements, scope) {
 var doc = scope || domGlobals.document;
 var fragment = doc.createDocumentFragment();
 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, obj);
+f(x, i);
 }
 };
 var node = function () {
 var f = Global$1.getOrDie('Node');
 };
 var firstMatch = function (regexes, s) {
 for (var i = 0; i < regexes.length; i++) {
 var x = regexes[i];
-if (x.test(s))
+if (x.test(s)) {
 return x;
+}
 }
 return undefined;
 };
 var find$1 = function (regexes, agent) {
 var r = firstMatch(regexes, agent);
-if (!r)
+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)
+if (versionRegexes.length === 0) {
 return unknown();
+}
 return find$1(versionRegexes, cleanedAgent);
 };
 var unknown = function () {
 return nu(0, 0);
 };
 var browsers = [
 {
 name: 'Edge',
 versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
 search: function (uastring) {
-var monstrosity = contains(uastring, 'edge/') && contains(uastring, 'chrome') && contains(uastring, 'safari') && contains(uastring, 'applewebkit');
+return contains(uastring, 'edge/') && contains(uastring, 'chrome') && contains(uastring, 'safari') && contains(uastring, 'applewebkit');
-return monstrosity;
 }
 },
 {
 name: 'Chrome',
 versionRegexes: [
 var ENTITY = domGlobals.Node.ENTITY_NODE;
 var NOTATION = domGlobals.Node.NOTATION_NODE;
 var ELEMENT$1 = ELEMENT;
 var is = function (element, selector) {
-var elem = element.dom();
+var dom = element.dom();
-if (elem.nodeType !== ELEMENT$1) {
+if (dom.nodeType !== ELEMENT$1) {
 return false;
-} else 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 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 eq = function (e1, e2) {
 return e1.dom() === e2.dom();
 var browser = PlatformDetection$1.detect().browser;
 var contains$1 = browser.isIE() ? ieContains : regularContains;
 var is$1 = is;
 var parent = function (element) {
-var dom = element.dom();
+return Option.from(element.dom().parentNode).map(Element.fromDom);
-return Option.from(dom.parentNode).map(Element.fromDom);
 };
 var children = function (element) {
-var dom = element.dom();
+return map(element.dom().childNodes, Element.fromDom);
-return map(dom.childNodes, Element.fromDom);
 };
 var child = function (element, index) {
 var cs = element.dom().childNodes;
 return Option.from(cs[index]).map(Element.fromDom);
 };
 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 isElement = isType$1(ELEMENT);
 var rawSet = function (dom, key, value) {
 if (isString(value) || isBoolean(value) || isNumber(value)) {
 dom.setAttribute(key, value + '');
 } else {
 return acc;
 }, {});
 };
 var isSupported = function (dom) {
-return dom.style !== undefined;
+return dom.style !== undefined && isFunction(dom.style.getPropertyValue);
 };
 var internalSet = function (dom, property, value) {
 if (!isString(value)) {
 domGlobals.console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom);
 for (var i = 1; i < segments.length; i++) {
 joinSegment(segments[i - 1], segments[i]);
 }
 };
 var appendSegments = function (head$1, tail) {
-liftN([
+lift2(last(head$1), head(tail), joinSegment);
-last(head$1),
-head(tail)
-], joinSegment);
 };
 var createSegment = function (scope, listType) {
 var segment = {
 list: Element.fromTag(listType, scope),
 item: Element.fromTag('li', scope)
 var children$1 = children(li);
 var content = hasLastChildList(li) ? children$1.slice(0, -1) : children$1;
 return map(content, deep);
 };
 var createEntry = function (li, depth, isSelected) {
-return parent(li).map(function (list) {
+return parent(li).filter(isElement).map(function (list) {
 return {
 depth: depth,
 isSelected: isSelected,
 content: cloneItemContent(li),
 itemAttributes: clone(li),
 return nu;
 };
 var baseMerge = function (merger) {
 return function () {
 var objects = new Array(arguments.length);
-for (var i = 0; i < objects.length; i++)
+for (var i = 0; i < objects.length; i++) {
 objects[i] = arguments[i];
-if (objects.length === 0)
+}
+if (objects.length === 0) {
 throw new Error('Can\'t merge zero objects');
+}
 var ret = {};
 for (var j = 0; j < objects.length; j++) {
 var curObject = objects[j];
-for (var key in curObject)
+for (var key in curObject) {
 if (hasOwnProperty.call(curObject, key)) {
 ret[key] = merger(ret[key], curObject[key]);
 }
+}
 }
 return ret;
 };
 };
 var merge = baseMerge(shallow);
 return indentEntry(indentation, entry);
 });
 };
 var getItemSelection = function (editor) {
 var selectedListItems = map(Selection.getSelectedListItems(editor), Element.fromDom);
-return liftN([
+return lift2(find(selectedListItems, not(hasFirstChildList)), find(reverse(selectedListItems), not(hasFirstChildList)), function (start, end) {
-find(selectedListItems, not(hasFirstChildList)),
-find(reverse(selectedListItems), not(hasFirstChildList))
-], function (start, end) {
 return {
 start: start,
 end: end
 };
 });
 }
 };
 var SplitList = { splitList: splitList };
 var outdentDlItem = function (editor, item) {
-if (is$1(item, 'DD')) {
+if (is$1(item, 'dd')) {
-mutate(item, 'DT');
+mutate(item, 'dt');
-} else if (is$1(item, 'DT')) {
+} else if (is$1(item, 'dt')) {
 parent(item).each(function (dl) {
 return SplitList.splitList(editor, dl.dom(), item.dom());
 });
 }
 };
 var indentDlItem = function (item) {
-if (is$1(item, 'DT')) {
+if (is$1(item, 'dt')) {
-mutate(item, 'DD');
+mutate(item, 'dd');
 }
 };
 var dlIndentation = function (editor, indentation, dlItems) {
 if (indentation === 'Indent') {
 each(dlItems, indentDlItem);

enmi-conf.org