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 9	177826044cd9
parent 7	cf61fcea0001
child 16	a86126ab1dd4

equal deleted inserted replaced

-:c7c34916027a
+:177826044cd9
 (function () {
-var lists = (function () {
+var lists = (function (domGlobals) {
 'use strict';
 var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
 var global$1 = tinymce.util.Tools.resolve('tinymce.dom.RangeUtils');
 var global$2 = tinymce.util.Tools.resolve('tinymce.dom.TreeWalker');
 var global$3 = tinymce.util.Tools.resolve('tinymce.util.VK');
 var global$4 = tinymce.util.Tools.resolve('tinymce.dom.BookmarkManager');
 var global$5 = tinymce.util.Tools.resolve('tinymce.util.Tools');
 var global$6 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
 var isTextNode = function (node) {
 return node && node.nodeType === 3;
 };
 var isListNode = function (node) {
 return node && /^(OL|UL|DL)$/.test(node.nodeName);
 };
-var isListItemNode = function (node) {
+var isOlUlNode = function (node) {
-return node && /^(LI|DT|DD)$/.test(node.nodeName);
+return node && /^(OL|UL)$/.test(node.nodeName);
 };
-var isTableCellNode = function (node) {
+var isListItemNode = function (node) {
-return node && /^(TH|TD)$/.test(node.nodeName);
+return node && /^(LI|DT|DD)$/.test(node.nodeName);
 };
-var isBr = function (node) {
+var isDlItemNode = function (node) {
-return node && node.nodeName === 'BR';
+return node && /^(DT|DD)$/.test(node.nodeName);
 };
-var isFirstChild = function (node) {
+var isTableCellNode = function (node) {
-return node.parentNode.firstChild === node;
+return node && /^(TH|TD)$/.test(node.nodeName);
 };
-var isLastChild = function (node) {
+var isBr = function (node) {
-return node.parentNode.lastChild === node;
+return node && node.nodeName === 'BR';
 };
-var isTextBlock = function (editor, node) {
+var isFirstChild = function (node) {
-return node && !!editor.schema.getTextBlockElements()[node.nodeName];
+return node.parentNode.firstChild === node;
 };
-var isBlock = function (node, blockElements) {
+var isLastChild = function (node) {
-return node && node.nodeName in blockElements;
+return node.parentNode.lastChild === node;
 };
-var isBogusBr = function (dom, node) {
+var isTextBlock = function (editor, node) {
-if (!isBr(node)) {
+return node && !!editor.schema.getTextBlockElements()[node.nodeName];
+};
+var isBlock = function (node, blockElements) {
+return node && node.nodeName in blockElements;
+};
+var isBogusBr = function (dom, node) {
+if (!isBr(node)) {
+return false;
+}
+if (dom.isBlock(node.nextSibling) && !isBr(node.previousSibling)) {
+return true;
+}
 return false;
-}
+};
-if (dom.isBlock(node.nextSibling) && !isBr(node.previousSibling)) {
+var isEmpty = function (dom, elm, keepBookmarks) {
-return true;
+var empty = dom.isEmpty(elm);
-}
+if (keepBookmarks && dom.select('span[data-mce-type=bookmark]', elm).length > 0) {
 return false;
-};
+}
-var isEmpty = function (dom, elm, keepBookmarks) {
+return empty;
-var empty = dom.isEmpty(elm);
+};
-if (keepBookmarks && dom.select('span[data-mce-type=bookmark]', elm).length > 0) {
+var isChildOfBody = function (dom, elm) {
-return false;
+return dom.isChildOf(elm, dom.getRoot());
-}
+};
-return empty;
+var NodeType = {
-};
+isTextNode: isTextNode,
-var isChildOfBody = function (dom, elm) {
+isListNode: isListNode,
-return dom.isChildOf(elm, dom.getRoot());
+isOlUlNode: isOlUlNode,
-};
+isDlItemNode: isDlItemNode,
-var $_okk1ogljjgweckx = {
+isListItemNode: isListItemNode,
-isTextNode: isTextNode,
+isTableCellNode: isTableCellNode,
-isListNode: isListNode,
+isBr: isBr,
-isListItemNode: isListItemNode,
+isFirstChild: isFirstChild,
-isTableCellNode: isTableCellNode,
+isLastChild: isLastChild,
-isBr: isBr,
+isTextBlock: isTextBlock,
-isFirstChild: isFirstChild,
+isBlock: isBlock,
-isLastChild: isLastChild,
+isBogusBr: isBogusBr,
-isTextBlock: isTextBlock,
+isEmpty: isEmpty,
-isBlock: isBlock,
+isChildOfBody: isChildOfBody
-isBogusBr: isBogusBr,
+};
-isEmpty: isEmpty,
-isChildOfBody: isChildOfBody
+var getNormalizedPoint = function (container, offset) {
-};
+if (NodeType.isTextNode(container)) {
+return {
-var getNormalizedEndPoint = function (container, offset) {
+container: container,
-var node = global$1.getNode(container, offset);
+offset: offset
-if ($_okk1ogljjgweckx.isListItemNode(container) && $_okk1ogljjgweckx.isTextNode(node)) {
+};
-var textNodeOffset = offset >= container.childNodes.length ? node.data.length : 0;
+}
+var node = global$1.getNode(container, offset);
+if (NodeType.isTextNode(node)) {
+return {
+container: node,
+offset: offset >= container.childNodes.length ? node.data.length : 0
+};
+} else if (node.previousSibling && NodeType.isTextNode(node.previousSibling)) {
+return {
+container: node.previousSibling,
+offset: node.previousSibling.data.length
+};
+} else if (node.nextSibling && NodeType.isTextNode(node.nextSibling)) {
+return {
+container: node.nextSibling,
+offset: 0
+};
+}
 return {
-container: node,
+container: container,
-offset: textNodeOffset
+offset: offset
 };
-}
+};
-return {
+var normalizeRange = function (rng) {
-container: container,
+var outRng = rng.cloneRange();
-offset: offset
+var rangeStart = getNormalizedPoint(rng.startContainer, rng.startOffset);
-};
+outRng.setStart(rangeStart.container, rangeStart.offset);
-};
+var rangeEnd = getNormalizedPoint(rng.endContainer, rng.endOffset);
-var normalizeRange = function (rng) {
+outRng.setEnd(rangeEnd.container, rangeEnd.offset);
-var outRng = rng.cloneRange();
+return outRng;
-var rangeStart = getNormalizedEndPoint(rng.startContainer, rng.startOffset);
+};
-outRng.setStart(rangeStart.container, rangeStart.offset);
+var Range = {
-var rangeEnd = getNormalizedEndPoint(rng.endContainer, rng.endOffset);
+getNormalizedPoint: getNormalizedPoint,
-outRng.setEnd(rangeEnd.container, rangeEnd.offset);
+normalizeRange: normalizeRange
-return outRng;
+};
-};
-var $_a9cyhvgkjjgweckv = {
+var DOM = global$6.DOM;
-getNormalizedEndPoint: getNormalizedEndPoint,
+var createBookmark = function (rng) {
-normalizeRange: normalizeRange
+var bookmark = {};
-};
+var setupEndPoint = function (start) {
+var offsetNode, container, offset;
-var DOM = global$6.DOM;
+container = rng[start ? 'startContainer' : 'endContainer'];
-var createBookmark = function (rng) {
+offset = rng[start ? 'startOffset' : 'endOffset'];
-var bookmark = {};
+if (container.nodeType === 1) {
-var setupEndPoint = function (start) {
+offsetNode = DOM.create('span', { 'data-mce-type': 'bookmark' });
-var offsetNode, container, offset;
+if (container.hasChildNodes()) {
+offset = Math.min(offset, container.childNodes.length - 1);
+if (start) {
+container.insertBefore(offsetNode, container.childNodes[offset]);
+} else {
+DOM.insertAfter(offsetNode, container.childNodes[offset]);
+}
+} else {
+container.appendChild(offsetNode);
+}
+container = offsetNode;
+offset = 0;
+}
+bookmark[start ? 'startContainer' : 'endContainer'] = container;
+bookmark[start ? 'startOffset' : 'endOffset'] = offset;
+};
+setupEndPoint(true);
+if (!rng.collapsed) {
+setupEndPoint();
+}
+return bookmark;
+};
+var resolveBookmark = function (bookmark) {
+function restoreEndPoint(start) {
+var container, offset, node;
+var nodeIndex = function (container) {
+var node = container.parentNode.firstChild, idx = 0;
+while (node) {
+if (node === container) {
+return idx;
+}
+if (node.nodeType !== 1 || node.getAttribute('data-mce-type') !== 'bookmark') {
+idx++;
+}
+node = node.nextSibling;
+}
+return -1;
+};
+container = node = bookmark[start ? 'startContainer' : 'endContainer'];
+offset = bookmark[start ? 'startOffset' : 'endOffset'];
+if (!container) {
+return;
+}
+if (container.nodeType === 1) {
+offset = nodeIndex(container);
+container = container.parentNode;
+DOM.remove(node);
+if (!container.hasChildNodes() && DOM.isBlock(container)) {
+container.appendChild(DOM.create('br'));
+}
+}
+bookmark[start ? 'startContainer' : 'endContainer'] = container;
+bookmark[start ? 'startOffset' : 'endOffset'] = offset;
+}
+restoreEndPoint(true);
+restoreEndPoint();
+var rng = DOM.createRng();
+rng.setStart(bookmark.startContainer, bookmark.startOffset);
+if (bookmark.endContainer) {
+rng.setEnd(bookmark.endContainer, bookmark.endOffset);
+}
+return Range.normalizeRange(rng);
+};
+var Bookmark = {
+createBookmark: createBookmark,
+resolveBookmark: resolveBookmark
+};
+var constant = function (value) {
+return function () {
+return value;
+};
+};
+var not = function (f) {
+return function () {
+var args = [];
+for (var _i = 0; _i < arguments.length; _i++) {
+args[_i] = arguments[_i];
+}
+return !f.apply(null, args);
+};
+};
+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) {
+return o.isNone();
+};
+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,
+isSome: never$1,
+isNone: always$1,
+getOr: id,
+getOrThunk: call,
+getOrDie: function (msg) {
+throw new Error(msg || 'error: getOrDie called on none.');
+},
+getOrNull: nul,
+getOrUndefined: undef,
+or: id,
+orThunk: call,
+map: none,
+ap: none,
+each: noop,
+bind: none,
+flatten: none,
+exists: never$1,
+forall: always$1,
+filter: none,
+equals: eq,
+equals_: eq,
+toArray: function () {
+return [];
+},
+toString: constant('none()')
+};
+if (Object.freeze)
+Object.freeze(me);
+return me;
+}();
+var some = function (a) {
+var constant_a = function () {
+return a;
+};
+var self = function () {
+return me;
+};
+var map = function (f) {
+return some(f(a));
+};
+var bind = function (f) {
+return f(a);
+};
+var me = {
+fold: function (n, s) {
+return s(a);
+},
+is: function (v) {
+return a === v;
+},
+isSome: always$1,
+isNone: never$1,
+getOr: constant_a,
+getOrThunk: constant_a,
+getOrDie: constant_a,
+getOrNull: constant_a,
+getOrUndefined: constant_a,
+or: self,
+orThunk: self,
+map: map,
+ap: function (optfab) {
+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 + ')';
+}
+};
+return me;
+};
+var from = function (value) {
+return value === null || value === undefined ? NONE : some(value);
+};
+var Option = {
+some: some,
+none: none,
+from: from
+};
+var typeOf = function (x) {
+if (x === null)
+return 'null';
+var t = typeof x;
+if (t === 'object' && Array.prototype.isPrototypeOf(x))
+return 'array';
+if (t === 'object' && String.prototype.isPrototypeOf(x))
+return 'string';
+return t;
+};
+var isType = function (type) {
+return function (value) {
+return typeOf(value) === type;
+};
+};
+var isString = isType('string');
+var isBoolean = isType('boolean');
+var isFunction = isType('function');
+var isNumber = isType('number');
+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);
+}
+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);
+}
+};
+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)) {
+r.push(x);
+}
+}
+return r;
+};
+var groupBy = function (xs, f) {
+if (xs.length === 0) {
+return [];
+} else {
+var wasType = f(xs[0]);
+var r = [];
+var group = [];
+for (var i = 0, len = xs.length; i < len; i++) {
+var x = xs[i];
+var type = f(x);
+if (type !== wasType) {
+r.push(group);
+group = [];
+}
+wasType = type;
+group.push(x);
+}
+if (group.length !== 0) {
+r.push(group);
+}
+return r;
+}
+};
+var foldl = function (xs, f, acc) {
+each(xs, function (x) {
+acc = f(acc, x);
+});
+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)) {
+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]))
+throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
+push.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);
+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);
+};
+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 htmlElement = function (scope) {
+return Global$1.getOrDie('HTMLElement', scope);
+};
+var isPrototypeOf = function (x) {
+var scope = resolve('ownerDocument.defaultView', x);
+return htmlElement(scope).prototype.isPrototypeOf(x);
+};
+var HTMLElement = { isPrototypeOf: isPrototypeOf };
+var global$7 = tinymce.util.Tools.resolve('tinymce.dom.DomQuery');
+var getParentList = function (editor) {
+var selectionStart = editor.selection.getStart(true);
+return editor.dom.getParent(selectionStart, 'OL,UL,DL', getClosestListRootElm(editor, selectionStart));
+};
+var isParentListSelected = function (parentList, selectedBlocks) {
+return parentList && selectedBlocks.length === 1 && selectedBlocks[0] === parentList;
+};
+var findSubLists = function (parentList) {
+return global$5.grep(parentList.querySelectorAll('ol,ul,dl'), function (elm) {
+return NodeType.isListNode(elm);
+});
+};
+var getSelectedSubLists = function (editor) {
+var parentList = getParentList(editor);
+var selectedBlocks = editor.selection.getSelectedBlocks();
+if (isParentListSelected(parentList, selectedBlocks)) {
+return findSubLists(parentList);
+} else {
+return global$5.grep(selectedBlocks, function (elm) {
+return NodeType.isListNode(elm) && parentList !== elm;
+});
+}
+};
+var findParentListItemsNodes = function (editor, elms) {
+var listItemsElms = global$5.map(elms, function (elm) {
+var parentLi = editor.dom.getParent(elm, 'li,dd,dt', getClosestListRootElm(editor, elm));
+return parentLi ? parentLi : elm;
+});
+return global$7.unique(listItemsElms);
+};
+var getSelectedListItems = function (editor) {
+var selectedBlocks = editor.selection.getSelectedBlocks();
+return global$5.grep(findParentListItemsNodes(editor, selectedBlocks), function (block) {
+return NodeType.isListItemNode(block);
+});
+};
+var getSelectedDlItems = function (editor) {
+return filter(getSelectedListItems(editor), NodeType.isDlItemNode);
+};
+var getClosestListRootElm = function (editor, elm) {
+var parentTableCell = editor.dom.getParents(elm, 'TD,TH');
+var root = parentTableCell.length > 0 ? parentTableCell[0] : editor.getBody();
+return root;
+};
+var findLastParentListNode = function (editor, elm) {
+var parentLists = editor.dom.getParents(elm, 'ol,ul', getClosestListRootElm(editor, elm));
+return last(parentLists);
+};
+var getSelectedLists = function (editor) {
+var firstList = findLastParentListNode(editor, editor.selection.getStart());
+var subsequentLists = filter(editor.selection.getSelectedBlocks(), NodeType.isOlUlNode);
+return firstList.toArray().concat(subsequentLists);
+};
+var getSelectedListRoots = function (editor) {
+var selectedLists = getSelectedLists(editor);
+return getUniqueListRoots(editor, selectedLists);
+};
+var getUniqueListRoots = function (editor, lists) {
+var listRoots = map(lists, function (list) {
+return findLastParentListNode(editor, list).getOr(list);
+});
+return global$7.unique(listRoots);
+};
+var isList = function (editor) {
+var list = getParentList(editor);
+return HTMLElement.isPrototypeOf(list);
+};
+var Selection = {
+isList: isList,
+getParentList: getParentList,
+getSelectedSubLists: getSelectedSubLists,
+getSelectedListItems: getSelectedListItems,
+getClosestListRootElm: getClosestListRootElm,
+getSelectedDlItems: getSelectedDlItems,
+getSelectedListRoots: getSelectedListRoots
+};
+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 liftN = function (arr, f) {
+var r = [];
+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();
+each(elements, function (element) {
+fragment.appendChild(element.dom());
+});
+return Element.fromDom(fragment);
+};
+var Immutable = function () {
+var fields = [];
+for (var _i = 0; _i < arguments.length; _i++) {
+fields[_i] = arguments[_i];
+}
+return function () {
+var values = [];
+for (var _i = 0; _i < arguments.length; _i++) {
+values[_i] = arguments[_i];
+}
+if (fields.length !== values.length) {
+throw new Error('Wrong number of arguments to struct. Expected "[' + fields.length + ']", got ' + values.length + ' arguments');
+}
+var struct = {};
+each(fields, function (name, i) {
+struct[name] = constant(values[i]);
+});
+return struct;
+};
+};
+var keys = Object.keys;
+var each$1 = function (obj, f) {
+var props = keys(obj);
+for (var k = 0, len = props.length; k < len; k++) {
+var i = props[k];
+var x = obj[i];
+f(x, i, obj);
+}
+};
+var node = function () {
+var f = Global$1.getOrDie('Node');
+return f;
+};
+var compareDocumentPosition = function (a, b, match) {
+return (a.compareDocumentPosition(b) & match) !== 0;
+};
+var documentPositionPreceding = function (a, b) {
+return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_PRECEDING);
+};
+var documentPositionContainedBy = function (a, b) {
+return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_CONTAINED_BY);
+};
+var Node = {
+documentPositionPreceding: documentPositionPreceding,
+documentPositionContainedBy: documentPositionContainedBy
+};
+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 isBrowser = function (name, current) {
+return function () {
+return current === name;
+};
+};
+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;
+return {
+current: current,
+version: version,
+isEdge: isBrowser(edge, current),
+isChrome: isBrowser(chrome, current),
+isIE: isBrowser(ie, current),
+isOpera: isBrowser(opera, current),
+isFirefox: isBrowser(firefox, current),
+isSafari: isBrowser(safari, current)
+};
+};
+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 isOS = function (name, current) {
+return function () {
+return current === name;
+};
+};
+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;
+return {
+current: current,
+version: version,
+isWindows: isOS(windows, current),
+isiOS: isOS(ios, current),
+isAndroid: isOS(android, current),
+isOSX: isOS(osx, current),
+isLinux: isOS(linux, current),
+isSolaris: isOS(solaris, current),
+isFreeBSD: isOS(freebsd, current)
+};
+};
+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)
+};
+var DeviceType = function (os, browser, userAgent) {
+var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
+var isiPhone = os.isiOS() && !isiPad;
+var isAndroid3 = os.isAndroid() && os.version.major === 3;
+var isAndroid4 = os.isAndroid() && os.version.major === 4;
+var isTablet = isiPad || isAndroid3 || isAndroid4 && /mobile/i.test(userAgent) === true;
+var isTouch = os.isiOS() || os.isAndroid();
+var isPhone = isTouch && !isTablet;
+var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
+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)
+};
+};
+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 contains = function (str, substr) {
+return str.indexOf(substr) !== -1;
+};
+var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
+var checkContains = function (target) {
+return function (uastring) {
+return contains(uastring, target);
+};
+};
+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 monstrosity;
+}
+},
+{
+name: 'Chrome',
+versionRegexes: [
+/.*?chrome\/([0-9]+)\.([0-9]+).*/,
+normalVersionRegex
+],
+search: function (uastring) {
+return contains(uastring, 'chrome') && !contains(uastring, 'chromeframe');
+}
+},
+{
+name: 'IE',
+versionRegexes: [
+/.*?msie\ ?([0-9]+)\.([0-9]+).*/,
+/.*?rv:([0-9]+)\.([0-9]+).*/
+],
+search: function (uastring) {
+return contains(uastring, 'msie') || contains(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(uastring, 'safari') || contains(uastring, 'mobile/')) && contains(uastring, 'applewebkit');
+}
+}
+];
+var oses = [
+{
+name: 'Windows',
+search: checkContains('win'),
+versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
+},
+{
+name: 'iOS',
+search: function (uastring) {
+return contains(uastring, 'iphone') || contains(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('os x'),
+versionRegexes: [/.*?os\ x\ ?([0-9]+)_([0-9]+).*/]
+},
+{
+name: 'Linux',
+search: checkContains('linux'),
+versionRegexes: []
+},
+{
+name: 'Solaris',
+search: checkContains('sunos'),
+versionRegexes: []
+},
+{
+name: 'FreeBSD',
+search: checkContains('freebsd'),
+versionRegexes: []
+}
+];
+var PlatformInfo = {
+browsers: constant(browsers),
+oses: constant(oses)
+};
+var detect$2 = function (userAgent) {
+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);
+return {
+browser: browser,
+os: os,
+deviceType: deviceType
+};
+};
+var PlatformDetection = { detect: detect$2 };
+var detect$3 = cached(function () {
+var userAgent = domGlobals.navigator.userAgent;
+return PlatformDetection.detect(userAgent);
+});
+var PlatformDetection$1 = { detect: detect$3 };
+var ATTRIBUTE = domGlobals.Node.ATTRIBUTE_NODE;
+var CDATA_SECTION = domGlobals.Node.CDATA_SECTION_NODE;
+var COMMENT = domGlobals.Node.COMMENT_NODE;
+var DOCUMENT = domGlobals.Node.DOCUMENT_NODE;
+var DOCUMENT_TYPE = domGlobals.Node.DOCUMENT_TYPE_NODE;
+var DOCUMENT_FRAGMENT = domGlobals.Node.DOCUMENT_FRAGMENT_NODE;
+var ELEMENT = domGlobals.Node.ELEMENT_NODE;
+var TEXT = domGlobals.Node.TEXT_NODE;
+var PROCESSING_INSTRUCTION = domGlobals.Node.PROCESSING_INSTRUCTION_NODE;
+var ENTITY_REFERENCE = domGlobals.Node.ENTITY_REFERENCE_NODE;
+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();
+if (elem.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 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 Node.documentPositionContainedBy(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(dom.parentNode).map(Element.fromDom);
+};
+var children = function (element) {
+var dom = element.dom();
+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 firstChild = function (element) {
+return child(element, 0);
+};
+var lastChild = function (element) {
+return child(element, element.dom().childNodes.length - 1);
+};
+var spot = Immutable('element', 'offset');
+var before = function (marker, element) {
+var parent$1 = parent(marker);
+parent$1.each(function (v) {
+v.dom().insertBefore(element.dom(), marker.dom());
+});
+};
+var append = function (parent, element) {
+parent.dom().appendChild(element.dom());
+};
+var before$1 = function (marker, elements) {
+each(elements, function (x) {
+before(marker, x);
+});
+};
+var append$1 = function (parent, elements) {
+each(elements, function (x) {
+append(parent, x);
+});
+};
+var remove = function (element) {
+var dom = element.dom();
+if (dom.parentNode !== null) {
+dom.parentNode.removeChild(dom);
+}
+};
+var name = function (element) {
+var r = element.dom().nodeName;
+return r.toLowerCase();
+};
+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 setAll = function (element, attrs) {
+var dom = element.dom();
+each$1(attrs, function (v, k) {
+rawSet(dom, k, v);
+});
+};
+var clone = function (element) {
+return foldl(element.dom().attributes, function (acc, attr) {
+acc[attr.name] = attr.value;
+return acc;
+}, {});
+};
+var isSupported = function (dom) {
+return dom.style !== undefined;
+};
+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 set = function (element, property, value) {
+var dom = element.dom();
+internalSet(dom, property, value);
+};
+var clone$1 = function (original, isDeep) {
+return Element.fromDom(original.dom().cloneNode(isDeep));
+};
+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 mutate = function (original, tag) {
+var nu = shallowAs(original, tag);
+before(original, nu);
+var children$1 = children(original);
+append$1(nu, children$1);
+remove(original);
+return nu;
+};
+var joinSegment = function (parent, child) {
+append(parent.item, child.list);
+};
+var joinSegments = function (segments) {
+for (var i = 1; i < segments.length; i++) {
+joinSegment(segments[i - 1], segments[i]);
+}
+};
+var appendSegments = function (head$1, tail) {
+liftN([
+last(head$1),
+head(tail)
+], joinSegment);
+};
+var createSegment = function (scope, listType) {
+var segment = {
+list: Element.fromTag(listType, scope),
+item: Element.fromTag('li', scope)
+};
+append(segment.list, segment.item);
+return segment;
+};
+var createSegments = function (scope, entry, size) {
+var segments = [];
+for (var i = 0; i < size; i++) {
+segments.push(createSegment(scope, entry.listType));
+}
+return segments;
+};
+var populateSegments = function (segments, entry) {
+for (var i = 0; i < segments.length - 1; i++) {
+set(segments[i].item, 'list-style-type', 'none');
+}
+last(segments).each(function (segment) {
+setAll(segment.list, entry.listAttributes);
+setAll(segment.item, entry.itemAttributes);
+append$1(segment.item, entry.content);
+});
+};
+var normalizeSegment = function (segment, entry) {
+if (name(segment.list) !== entry.listType) {
+segment.list = mutate(segment.list, entry.listType);
+}
+setAll(segment.list, entry.listAttributes);
+};
+var createItem = function (scope, attr, content) {
+var item = Element.fromTag('li', scope);
+setAll(item, attr);
+append$1(item, content);
+return item;
+};
+var appendItem = function (segment, item) {
+append(segment.list, item);
+segment.item = item;
+};
+var writeShallow = function (scope, cast, entry) {
+var newCast = cast.slice(0, entry.depth);
+last(newCast).each(function (segment) {
+var item = createItem(scope, entry.itemAttributes, entry.content);
+appendItem(segment, item);
+normalizeSegment(segment, entry);
+});
+return newCast;
+};
+var writeDeep = function (scope, cast, entry) {
+var segments = createSegments(scope, entry, entry.depth - cast.length);
+joinSegments(segments);
+populateSegments(segments, entry);
+appendSegments(cast, segments);
+return cast.concat(segments);
+};
+var composeList = function (scope, entries) {
+var cast = foldl(entries, function (cast, entry) {
+return entry.depth > cast.length ? writeDeep(scope, cast, entry) : writeShallow(scope, cast, entry);
+}, []);
+return head(cast).map(function (segment) {
+return segment.list;
+});
+};
+var isList$1 = function (el) {
+return is$1(el, 'OL,UL');
+};
+var hasFirstChildList = function (el) {
+return firstChild(el).map(isList$1).getOr(false);
+};
+var hasLastChildList = function (el) {
+return lastChild(el).map(isList$1).getOr(false);
+};
+var isIndented = function (entry) {
+return entry.depth > 0;
+};
+var isSelected = function (entry) {
+return entry.isSelected;
+};
+var cloneItemContent = function (li) {
+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 {
+depth: depth,
+isSelected: isSelected,
+content: cloneItemContent(li),
+itemAttributes: clone(li),
+listAttributes: clone(list),
+listType: name(list)
+};
+});
+};
+var indentEntry = function (indentation, entry) {
+switch (indentation) {
+case 'Indent':
+entry.depth++;
+break;
+case 'Outdent':
+entry.depth--;
+break;
+case 'Flatten':
+entry.depth = 0;
+}
+};
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var shallow = function (old, nu) {
+return nu;
+};
+var baseMerge = function (merger) {
+return function () {
+var objects = new Array(arguments.length);
+for (var i = 0; i < objects.length; i++)
+objects[i] = arguments[i];
+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)
+if (hasOwnProperty.call(curObject, key)) {
+ret[key] = merger(ret[key], curObject[key]);
+}
+}
+return ret;
+};
+};
+var merge = baseMerge(shallow);
+var cloneListProperties = function (target, source) {
+target.listType = source.listType;
+target.listAttributes = merge({}, source.listAttributes);
+};
+var previousSiblingEntry = function (entries, start) {
+var depth = entries[start].depth;
+for (var i = start - 1; i >= 0; i--) {
+if (entries[i].depth === depth) {
+return Option.some(entries[i]);
+}
+if (entries[i].depth < depth) {
+break;
+}
+}
+return Option.none();
+};
+var normalizeEntries = function (entries) {
+each(entries, function (entry, i) {
+previousSiblingEntry(entries, i).each(function (matchingEntry) {
+cloneListProperties(entry, matchingEntry);
+});
+});
+};
+var Cell = function (initial) {
+var value = initial;
+var get = function () {
+return value;
+};
+var set = function (v) {
+value = v;
+};
+var clone = function () {
+return Cell(get());
+};
+return {
+get: get,
+set: set,
+clone: clone
+};
+};
+var parseItem = function (depth, itemSelection, selectionState, item) {
+return firstChild(item).filter(isList$1).fold(function () {
+itemSelection.each(function (selection) {
+if (eq(selection.start, item)) {
+selectionState.set(true);
+}
+});
+var currentItemEntry = createEntry(item, depth, selectionState.get());
+itemSelection.each(function (selection) {
+if (eq(selection.end, item)) {
+selectionState.set(false);
+}
+});
+var childListEntries = lastChild(item).filter(isList$1).map(function (list) {
+return parseList(depth, itemSelection, selectionState, list);
+}).getOr([]);
+return currentItemEntry.toArray().concat(childListEntries);
+}, function (list) {
+return parseList(depth, itemSelection, selectionState, list);
+});
+};
+var parseList = function (depth, itemSelection, selectionState, list) {
+return bind(children(list), function (element) {
+var parser = isList$1(element) ? parseList : parseItem;
+var newDepth = depth + 1;
+return parser(newDepth, itemSelection, selectionState, element);
+});
+};
+var parseLists = function (lists, itemSelection) {
+var selectionState = Cell(false);
+var initialDepth = 0;
+return map(lists, function (list) {
+return {
+sourceList: list,
+entries: parseList(initialDepth, itemSelection, selectionState, list)
+};
+});
+};
+var global$8 = tinymce.util.Tools.resolve('tinymce.Env');
+var createTextBlock = function (editor, contentNode) {
+var dom = editor.dom;
+var blockElements = editor.schema.getBlockElements();
+var fragment = dom.createFragment();
+var node, textBlock, blockName, hasContentNode;
+if (editor.settings.forced_root_block) {
+blockName = editor.settings.forced_root_block;
+}
+if (blockName) {
+textBlock = dom.create(blockName);
+if (textBlock.tagName === editor.settings.forced_root_block) {
+dom.setAttribs(textBlock, editor.settings.forced_root_block_attrs);
+}
+if (!NodeType.isBlock(contentNode.firstChild, blockElements)) {
+fragment.appendChild(textBlock);
+}
+}
+if (contentNode) {
+while (node = contentNode.firstChild) {
+var nodeName = node.nodeName;
+if (!hasContentNode && (nodeName !== 'SPAN' || node.getAttribute('data-mce-type') !== 'bookmark')) {
+hasContentNode = true;
+}
+if (NodeType.isBlock(node, blockElements)) {
+fragment.appendChild(node);
+textBlock = null;
+} else {
+if (blockName) {
+if (!textBlock) {
+textBlock = dom.create(blockName);
+fragment.appendChild(textBlock);
+}
+textBlock.appendChild(node);
+} else {
+fragment.appendChild(node);
+}
+}
+}
+}
+if (!editor.settings.forced_root_block) {
+fragment.appendChild(dom.create('br'));
+} else {
+if (!hasContentNode && (!global$8.ie || global$8.ie > 10)) {
+textBlock.appendChild(dom.create('br', { 'data-mce-bogus': '1' }));
+}
+}
+return fragment;
+};
+var outdentedComposer = function (editor, entries) {
+return map(entries, function (entry) {
+var content = fromElements(entry.content);
+return Element.fromDom(createTextBlock(editor, content.dom()));
+});
+};
+var indentedComposer = function (editor, entries) {
+normalizeEntries(entries);
+return composeList(editor.contentDocument, entries).toArray();
+};
+var composeEntries = function (editor, entries) {
+return bind(groupBy(entries, isIndented), function (entries) {
+var groupIsIndented = head(entries).map(isIndented).getOr(false);
+return groupIsIndented ? indentedComposer(editor, entries) : outdentedComposer(editor, entries);
+});
+};
+var indentSelectedEntries = function (entries, indentation) {
+each(filter(entries, isSelected), function (entry) {
+return indentEntry(indentation, entry);
+});
+};
+var getItemSelection = function (editor) {
+var selectedListItems = map(Selection.getSelectedListItems(editor), Element.fromDom);
+return liftN([
+find(selectedListItems, not(hasFirstChildList)),
+find(reverse(selectedListItems), not(hasFirstChildList))
+], function (start, end) {
+return {
+start: start,
+end: end
+};
+});
+};
+var listsIndentation = function (editor, lists, indentation) {
+var entrySets = parseLists(lists, getItemSelection(editor));
+each(entrySets, function (entrySet) {
+indentSelectedEntries(entrySet.entries, indentation);
+before$1(entrySet.sourceList, composeEntries(editor, entrySet.entries));
+remove(entrySet.sourceList);
+});
+};
+var DOM$1 = global$6.DOM;
+var splitList = function (editor, ul, li) {
+var tmpRng, fragment, bookmarks, node, newBlock;
+var removeAndKeepBookmarks = function (targetNode) {
+global$5.each(bookmarks, function (node) {
+targetNode.parentNode.insertBefore(node, li.parentNode);
+});
+DOM$1.remove(targetNode);
+};
+bookmarks = DOM$1.select('span[data-mce-type="bookmark"]', ul);
+newBlock = createTextBlock(editor, li);
+tmpRng = DOM$1.createRng();
+tmpRng.setStartAfter(li);
+tmpRng.setEndAfter(ul);
+fragment = tmpRng.extractContents();
+for (node = fragment.firstChild; node; node = node.firstChild) {
+if (node.nodeName === 'LI' && editor.dom.isEmpty(node)) {
+DOM$1.remove(node);
+break;
+}
+}
+if (!editor.dom.isEmpty(fragment)) {
+DOM$1.insertAfter(fragment, ul);
+}
+DOM$1.insertAfter(newBlock, ul);
+if (NodeType.isEmpty(editor.dom, li.parentNode)) {
+removeAndKeepBookmarks(li.parentNode);
+}
+DOM$1.remove(li);
+if (NodeType.isEmpty(editor.dom, ul)) {
+DOM$1.remove(ul);
+}
+};
+var SplitList = { splitList: splitList };
+var outdentDlItem = function (editor, item) {
+if (is$1(item, 'DD')) {
+mutate(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')) {
+mutate(item, 'DD');
+}
+};
+var dlIndentation = function (editor, indentation, dlItems) {
+if (indentation === 'Indent') {
+each(dlItems, indentDlItem);
+} else {
+each(dlItems, function (item) {
+return outdentDlItem(editor, item);
+});
+}
+};
+var selectionIndentation = function (editor, indentation) {
+var lists = map(Selection.getSelectedListRoots(editor), Element.fromDom);
+var dlItems = map(Selection.getSelectedDlItems(editor), Element.fromDom);
+var isHandled = false;
+if (lists.length || dlItems.length) {
+var bookmark = editor.selection.getBookmark();
+listsIndentation(editor, lists, indentation);
+dlIndentation(editor, indentation, dlItems);
+editor.selection.moveToBookmark(bookmark);
+editor.selection.setRng(Range.normalizeRange(editor.selection.getRng()));
+editor.nodeChanged();
+isHandled = true;
+}
+return isHandled;
+};
+var indentListSelection = function (editor) {
+return selectionIndentation(editor, 'Indent');
+};
+var outdentListSelection = function (editor) {
+return selectionIndentation(editor, 'Outdent');
+};
+var flattenListSelection = function (editor) {
+return selectionIndentation(editor, 'Flatten');
+};
+var updateListStyle = function (dom, el, detail) {
+var type = detail['list-style-type'] ? detail['list-style-type'] : null;
+dom.setStyle(el, 'list-style-type', type);
+};
+var setAttribs = function (elm, attrs) {
+global$5.each(attrs, function (value, key) {
+elm.setAttribute(key, value);
+});
+};
+var updateListAttrs = function (dom, el, detail) {
+setAttribs(el, detail['list-attributes']);
+global$5.each(dom.select('li', el), function (li) {
+setAttribs(li, detail['list-item-attributes']);
+});
+};
+var updateListWithDetails = function (dom, el, detail) {
+updateListStyle(dom, el, detail);
+updateListAttrs(dom, el, detail);
+};
+var removeStyles = function (dom, element, styles) {
+global$5.each(styles, function (style) {
+var _a;
+return dom.setStyle(element, (_a = {}, _a[style] = '', _a));
+});
+};
+var getEndPointNode = function (editor, rng, start, root) {
+var container, offset;
 container = rng[start ? 'startContainer' : 'endContainer'];
 offset = rng[start ? 'startOffset' : 'endOffset'];
 if (container.nodeType === 1) {
-offsetNode = DOM.create('span', { 'data-mce-type': 'bookmark' });
+container = container.childNodes[Math.min(offset, container.childNodes.length - 1)] || container;
-if (container.hasChildNodes()) {
+}
-offset = Math.min(offset, container.childNodes.length - 1);
+if (!start && NodeType.isBr(container.nextSibling)) {
-if (start) {
+container = container.nextSibling;
-container.insertBefore(offsetNode, container.childNodes[offset]);
+}
-} else {
+while (container.parentNode !== root) {
-DOM.insertAfter(offsetNode, container.childNodes[offset]);
+if (NodeType.isTextBlock(editor, container)) {
+return container;
+}
+if (/^(TD|TH)$/.test(container.parentNode.nodeName)) {
+return container;
+}
+container = container.parentNode;
+}
+return container;
+};
+var getSelectedTextBlocks = function (editor, rng, root) {
+var textBlocks = [], dom = editor.dom;
+var startNode = getEndPointNode(editor, rng, true, root);
+var endNode = getEndPointNode(editor, rng, false, root);
+var block;
+var siblings = [];
+for (var node = startNode; node; node = node.nextSibling) {
+siblings.push(node);
+if (node === endNode) {
+break;
+}
+}
+global$5.each(siblings, function (node) {
+if (NodeType.isTextBlock(editor, node)) {
+textBlocks.push(node);
+block = null;
+return;
+}
+if (dom.isBlock(node) || NodeType.isBr(node)) {
+if (NodeType.isBr(node)) {
+dom.remove(node);
+}
+block = null;
+return;
+}
+var nextSibling = node.nextSibling;
+if (global$4.isBookmarkNode(node)) {
+if (NodeType.isTextBlock(editor, nextSibling) || !nextSibling && node.parentNode === root) {
+block = null;
+return;
+}
+}
+if (!block) {
+block = dom.create('p');
+node.parentNode.insertBefore(block, node);
+textBlocks.push(block);
+}
+block.appendChild(node);
+});
+return textBlocks;
+};
+var hasCompatibleStyle = function (dom, sib, detail) {
+var sibStyle = dom.getStyle(sib, 'list-style-type');
+var detailStyle = detail ? detail['list-style-type'] : '';
+detailStyle = detailStyle === null ? '' : detailStyle;
+return sibStyle === detailStyle;
+};
+var applyList = function (editor, listName, detail) {
+if (detail === void 0) {
+detail = {};
+}
+var rng = editor.selection.getRng(true);
+var bookmark;
+var listItemName = 'LI';
+var root = Selection.getClosestListRootElm(editor, editor.selection.getStart(true));
+var dom = editor.dom;
+if (dom.getContentEditable(editor.selection.getNode()) === 'false') {
+return;
+}
+listName = listName.toUpperCase();
+if (listName === 'DL') {
+listItemName = 'DT';
+}
+bookmark = Bookmark.createBookmark(rng);
+global$5.each(getSelectedTextBlocks(editor, rng, root), function (block) {
+var listBlock, sibling;
+sibling = block.previousSibling;
+if (sibling && NodeType.isListNode(sibling) && sibling.nodeName === listName && hasCompatibleStyle(dom, sibling, detail)) {
+listBlock = sibling;
+block = dom.rename(block, listItemName);
+sibling.appendChild(block);
+} else {
+listBlock = dom.create(listName);
+block.parentNode.insertBefore(listBlock, block);
+listBlock.appendChild(block);
+block = dom.rename(block, listItemName);
+}
+removeStyles(dom, block, [
+'margin',
+'margin-right',
+'margin-bottom',
+'margin-left',
+'margin-top',
+'padding',
+'padding-right',
+'padding-bottom',
+'padding-left',
+'padding-top'
+]);
+updateListWithDetails(dom, listBlock, detail);
+mergeWithAdjacentLists(editor.dom, listBlock);
+});
+editor.selection.setRng(Bookmark.resolveBookmark(bookmark));
+};
+var isValidLists = function (list1, list2) {
+return list1 && list2 && NodeType.isListNode(list1) && list1.nodeName === list2.nodeName;
+};
+var hasSameListStyle = function (dom, list1, list2) {
+var targetStyle = dom.getStyle(list1, 'list-style-type', true);
+var style = dom.getStyle(list2, 'list-style-type', true);
+return targetStyle === style;
+};
+var hasSameClasses = function (elm1, elm2) {
+return elm1.className === elm2.className;
+};
+var shouldMerge = function (dom, list1, list2) {
+return isValidLists(list1, list2) && hasSameListStyle(dom, list1, list2) && hasSameClasses(list1, list2);
+};
+var mergeWithAdjacentLists = function (dom, listBlock) {
+var sibling, node;
+sibling = listBlock.nextSibling;
+if (shouldMerge(dom, listBlock, sibling)) {
+while (node = sibling.firstChild) {
+listBlock.appendChild(node);
+}
+dom.remove(sibling);
+}
+sibling = listBlock.previousSibling;
+if (shouldMerge(dom, listBlock, sibling)) {
+while (node = sibling.lastChild) {
+listBlock.insertBefore(node, listBlock.firstChild);
+}
+dom.remove(sibling);
+}
+};
+var updateList = function (dom, list, listName, detail) {
+if (list.nodeName !== listName) {
+var newList = dom.rename(list, listName);
+updateListWithDetails(dom, newList, detail);
+} else {
+updateListWithDetails(dom, list, detail);
+}
+};
+var toggleMultipleLists = function (editor, parentList, lists, listName, detail) {
+if (parentList.nodeName === listName && !hasListStyleDetail(detail)) {
+flattenListSelection(editor);
+} else {
+var bookmark = Bookmark.createBookmark(editor.selection.getRng(true));
+global$5.each([parentList].concat(lists), function (elm) {
+updateList(editor.dom, elm, listName, detail);
+});
+editor.selection.setRng(Bookmark.resolveBookmark(bookmark));
+}
+};
+var hasListStyleDetail = function (detail) {
+return 'list-style-type' in detail;
+};
+var toggleSingleList = function (editor, parentList, listName, detail) {
+if (parentList === editor.getBody()) {
+return;
+}
+if (parentList) {
+if (parentList.nodeName === listName && !hasListStyleDetail(detail)) {
+flattenListSelection(editor);
+} else {
+var bookmark = Bookmark.createBookmark(editor.selection.getRng(true));
+updateListWithDetails(editor.dom, parentList, detail);
+mergeWithAdjacentLists(editor.dom, editor.dom.rename(parentList, listName));
+editor.selection.setRng(Bookmark.resolveBookmark(bookmark));
+}
+} else {
+applyList(editor, listName, detail);
+}
+};
+var toggleList = function (editor, listName, detail) {
+var parentList = Selection.getParentList(editor);
+var selectedSubLists = Selection.getSelectedSubLists(editor);
+detail = detail ? detail : {};
+if (parentList && selectedSubLists.length > 0) {
+toggleMultipleLists(editor, parentList, selectedSubLists, listName, detail);
+} else {
+toggleSingleList(editor, parentList, listName, detail);
+}
+};
+var ToggleList = {
+toggleList: toggleList,
+mergeWithAdjacentLists: mergeWithAdjacentLists
+};
+var DOM$2 = global$6.DOM;
+var normalizeList = function (dom, ul) {
+var sibling;
+var parentNode = ul.parentNode;
+if (parentNode.nodeName === 'LI' && parentNode.firstChild === ul) {
+sibling = parentNode.previousSibling;
+if (sibling && sibling.nodeName === 'LI') {
+sibling.appendChild(ul);
+if (NodeType.isEmpty(dom, parentNode)) {
+DOM$2.remove(parentNode);
 }
 } else {
-container.appendChild(offsetNode);
+DOM$2.setStyle(parentNode, 'listStyleType', 'none');
 }
-container = offsetNode;
+}
-offset = 0;
+if (NodeType.isListNode(parentNode)) {
-}
+sibling = parentNode.previousSibling;
-bookmark[start ? 'startContainer' : 'endContainer'] = container;
+if (sibling && sibling.nodeName === 'LI') {
-bookmark[start ? 'startOffset' : 'endOffset'] = offset;
+sibling.appendChild(ul);
-};
+}
-setupEndPoint(true);
+}
-if (!rng.collapsed) {
+};
-setupEndPoint();
+var normalizeLists = function (dom, element) {
-}
+global$5.each(global$5.grep(dom.select('ol,ul', element)), function (ul) {
-return bookmark;
+normalizeList(dom, ul);
-};
+});
-var resolveBookmark = function (bookmark) {
+};
-function restoreEndPoint(start) {
+var NormalizeLists = {
-var container, offset, node;
+normalizeList: normalizeList,
-var nodeIndex = function (container) {
+normalizeLists: normalizeLists
-var node = container.parentNode.firstChild, idx = 0;
+};
-while (node) {
-if (node === container) {
+var findNextCaretContainer = function (editor, rng, isForward, root) {
-return idx;
+var node = rng.startContainer;
+var offset = rng.startOffset;
+var nonEmptyBlocks, walker;
+if (node.nodeType === 3 && (isForward ? offset < node.data.length : offset > 0)) {
+return node;
+}
+nonEmptyBlocks = editor.schema.getNonEmptyElements();
+if (node.nodeType === 1) {
+node = global$1.getNode(node, offset);
+}
+walker = new global$2(node, root);
+if (isForward) {
+if (NodeType.isBogusBr(editor.dom, node)) {
+walker.next();
+}
+}
+while (node = walker[isForward ? 'next' : 'prev2']()) {
+if (node.nodeName === 'LI' && !node.hasChildNodes()) {
+return node;
+}
+if (nonEmptyBlocks[node.nodeName]) {
+return node;
+}
+if (node.nodeType === 3 && node.data.length > 0) {
+return node;
+}
+}
+};
+var hasOnlyOneBlockChild = function (dom, elm) {
+var childNodes = elm.childNodes;
+return childNodes.length === 1 && !NodeType.isListNode(childNodes[0]) && dom.isBlock(childNodes[0]);
+};
+var unwrapSingleBlockChild = function (dom, elm) {
+if (hasOnlyOneBlockChild(dom, elm)) {
+dom.remove(elm.firstChild, true);
+}
+};
+var moveChildren = function (dom, fromElm, toElm) {
+var node, targetElm;
+targetElm = hasOnlyOneBlockChild(dom, toElm) ? toElm.firstChild : toElm;
+unwrapSingleBlockChild(dom, fromElm);
+if (!NodeType.isEmpty(dom, fromElm, true)) {
+while (node = fromElm.firstChild) {
+targetElm.appendChild(node);
+}
+}
+};
+var mergeLiElements = function (dom, fromElm, toElm) {
+var node, listNode;
+var ul = fromElm.parentNode;
+if (!NodeType.isChildOfBody(dom, fromElm) || !NodeType.isChildOfBody(dom, toElm)) {
+return;
+}
+if (NodeType.isListNode(toElm.lastChild)) {
+listNode = toElm.lastChild;
+}
+if (ul === toElm.lastChild) {
+if (NodeType.isBr(ul.previousSibling)) {
+dom.remove(ul.previousSibling);
+}
+}
+node = toElm.lastChild;
+if (node && NodeType.isBr(node) && fromElm.hasChildNodes()) {
+dom.remove(node);
+}
+if (NodeType.isEmpty(dom, toElm, true)) {
+dom.$(toElm).empty();
+}
+moveChildren(dom, fromElm, toElm);
+if (listNode) {
+toElm.appendChild(listNode);
+}
+var contains = contains$1(Element.fromDom(toElm), Element.fromDom(fromElm));
+var nestedLists = contains ? dom.getParents(fromElm, NodeType.isListNode, toElm) : [];
+dom.remove(fromElm);
+each(nestedLists, function (list) {
+if (NodeType.isEmpty(dom, list) && list !== dom.getRoot()) {
+dom.remove(list);
+}
+});
+};
+var mergeIntoEmptyLi = function (editor, fromLi, toLi) {
+editor.dom.$(toLi).empty();
+mergeLiElements(editor.dom, fromLi, toLi);
+editor.selection.setCursorLocation(toLi);
+};
+var mergeForward = function (editor, rng, fromLi, toLi) {
+var dom = editor.dom;
+if (dom.isEmpty(toLi)) {
+mergeIntoEmptyLi(editor, fromLi, toLi);
+} else {
+var bookmark = Bookmark.createBookmark(rng);
+mergeLiElements(dom, fromLi, toLi);
+editor.selection.setRng(Bookmark.resolveBookmark(bookmark));
+}
+};
+var mergeBackward = function (editor, rng, fromLi, toLi) {
+var bookmark = Bookmark.createBookmark(rng);
+mergeLiElements(editor.dom, fromLi, toLi);
+var resolvedBookmark = Bookmark.resolveBookmark(bookmark);
+editor.selection.setRng(resolvedBookmark);
+};
+var backspaceDeleteFromListToListCaret = function (editor, isForward) {
+var dom = editor.dom, selection = editor.selection;
+var selectionStartElm = selection.getStart();
+var root = Selection.getClosestListRootElm(editor, selectionStartElm);
+var li = dom.getParent(selection.getStart(), 'LI', root);
+var ul, rng, otherLi;
+if (li) {
+ul = li.parentNode;
+if (ul === editor.getBody() && NodeType.isEmpty(dom, ul)) {
+return true;
+}
+rng = Range.normalizeRange(selection.getRng(true));
+otherLi = dom.getParent(findNextCaretContainer(editor, rng, isForward, root), 'LI', root);
+if (otherLi && otherLi !== li) {
+if (isForward) {
+mergeForward(editor, rng, otherLi, li);
+} else {
+mergeBackward(editor, rng, li, otherLi);
 }
-if (node.nodeType !== 1 || node.getAttribute('data-mce-type') !== 'bookmark') {
+return true;
-idx++;
+} else if (!otherLi) {
+if (!isForward) {
+flattenListSelection(editor);
+return true;
 }
-node = node.nextSibling;
+}
 }
-return -1;
+return false;
 };
-container = node = bookmark[start ? 'startContainer' : 'endContainer'];
+var removeBlock = function (dom, block, root) {
-offset = bookmark[start ? 'startOffset' : 'endOffset'];
+var parentBlock = dom.getParent(block.parentNode, dom.isBlock, root);
-if (!container) {
+dom.remove(block);
-return;
+if (parentBlock && dom.isEmpty(parentBlock)) {
-}
+dom.remove(parentBlock);
-if (container.nodeType === 1) {
+}
-offset = nodeIndex(container);
+};
-container = container.parentNode;
+var backspaceDeleteIntoListCaret = function (editor, isForward) {
-DOM.remove(node);
+var dom = editor.dom;
-if (!container.hasChildNodes() && DOM.isBlock(container)) {
+var selectionStartElm = editor.selection.getStart();
-container.appendChild(DOM.create('br'));
+var root = Selection.getClosestListRootElm(editor, selectionStartElm);
-}
+var block = dom.getParent(selectionStartElm, dom.isBlock, root);
-}
+if (block && dom.isEmpty(block)) {
-bookmark[start ? 'startContainer' : 'endContainer'] = container;
+var rng = Range.normalizeRange(editor.selection.getRng(true));
-bookmark[start ? 'startOffset' : 'endOffset'] = offset;
+var otherLi_1 = dom.getParent(findNextCaretContainer(editor, rng, isForward, root), 'LI', root);
-}
+if (otherLi_1) {
-restoreEndPoint(true);
+editor.undoManager.transact(function () {
-restoreEndPoint();
+removeBlock(dom, block, root);
-var rng = DOM.createRng();
+ToggleList.mergeWithAdjacentLists(dom, otherLi_1.parentNode);
-rng.setStart(bookmark.startContainer, bookmark.startOffset);
+editor.selection.select(otherLi_1, true);
-if (bookmark.endContainer) {
+editor.selection.collapse(isForward);
-rng.setEnd(bookmark.endContainer, bookmark.endOffset);
+});
-}
-return $_a9cyhvgkjjgweckv.normalizeRange(rng);
-};
-var $_2nx1i4gjjjgweckt = {
-createBookmark: createBookmark,
-resolveBookmark: resolveBookmark
-};
-var DOM$1 = global$6.DOM;
-var normalizeList = function (dom, ul) {
-var sibling;
-var parentNode = ul.parentNode;
-if (parentNode.nodeName === 'LI' && parentNode.firstChild === ul) {
-sibling = parentNode.previousSibling;
-if (sibling && sibling.nodeName === 'LI') {
-sibling.appendChild(ul);
-if ($_okk1ogljjgweckx.isEmpty(dom, parentNode)) {
-DOM$1.remove(parentNode);
-}
-} else {
-DOM$1.setStyle(parentNode, 'listStyleType', 'none');
-}
-}
-if ($_okk1ogljjgweckx.isListNode(parentNode)) {
-sibling = parentNode.previousSibling;
-if (sibling && sibling.nodeName === 'LI') {
-sibling.appendChild(ul);
-}
-}
-};
-var normalizeLists = function (dom, element) {
-global$5.each(global$5.grep(dom.select('ol,ul', element)), function (ul) {
-normalizeList(dom, ul);
-});
-};
-var $_ekd4wzgmjjgwecl1 = {
-normalizeList: normalizeList,
-normalizeLists: normalizeLists
-};
-var global$7 = tinymce.util.Tools.resolve('tinymce.dom.DomQuery');
-var getParentList = function (editor) {
-var selectionStart = editor.selection.getStart(true);
-return editor.dom.getParent(selectionStart, 'OL,UL,DL', getClosestListRootElm(editor, selectionStart));
-};
-var isParentListSelected = function (parentList, selectedBlocks) {
-return parentList && selectedBlocks.length === 1 && selectedBlocks[0] === parentList;
-};
-var findSubLists = function (parentList) {
-return global$5.grep(parentList.querySelectorAll('ol,ul,dl'), function (elm) {
-return $_okk1ogljjgweckx.isListNode(elm);
-});
-};
-var getSelectedSubLists = function (editor) {
-var parentList = getParentList(editor);
-var selectedBlocks = editor.selection.getSelectedBlocks();
-if (isParentListSelected(parentList, selectedBlocks)) {
-return findSubLists(parentList);
-} else {
-return global$5.grep(selectedBlocks, function (elm) {
-return $_okk1ogljjgweckx.isListNode(elm) && parentList !== elm;
-});
-}
-};
-var findParentListItemsNodes = function (editor, elms) {
-var listItemsElms = global$5.map(elms, function (elm) {
-var parentLi = editor.dom.getParent(elm, 'li,dd,dt', getClosestListRootElm(editor, elm));
-return parentLi ? parentLi : elm;
-});
-return global$7.unique(listItemsElms);
-};
-var getSelectedListItems = function (editor) {
-var selectedBlocks = editor.selection.getSelectedBlocks();
-return global$5.grep(findParentListItemsNodes(editor, selectedBlocks), function (block) {
-return $_okk1ogljjgweckx.isListItemNode(block);
-});
-};
-var getClosestListRootElm = function (editor, elm) {
-var parentTableCell = editor.dom.getParents(elm, 'TD,TH');
-var root = parentTableCell.length > 0 ? parentTableCell[0] : editor.getBody();
-return root;
-};
-var $_3xb1cggnjjgwecl3 = {
-getParentList: getParentList,
-getSelectedSubLists: getSelectedSubLists,
-getSelectedListItems: getSelectedListItems,
-getClosestListRootElm: getClosestListRootElm
-};
-var global$8 = tinymce.util.Tools.resolve('tinymce.Env');
-var DOM$2 = global$6.DOM;
-var createNewTextBlock = function (editor, contentNode, blockName) {
-var node, textBlock;
-var fragment = DOM$2.createFragment();
-var hasContentNode;
-var blockElements = editor.schema.getBlockElements();
-if (editor.settings.forced_root_block) {
-blockName = blockName || editor.settings.forced_root_block;
-}
-if (blockName) {
-textBlock = DOM$2.create(blockName);
-if (textBlock.tagName === editor.settings.forced_root_block) {
-DOM$2.setAttribs(textBlock, editor.settings.forced_root_block_attrs);
-}
-if (!$_okk1ogljjgweckx.isBlock(contentNode.firstChild, blockElements)) {
-fragment.appendChild(textBlock);
-}
-}
-if (contentNode) {
-while (node = contentNode.firstChild) {
-var nodeName = node.nodeName;
-if (!hasContentNode && (nodeName !== 'SPAN' || node.getAttribute('data-mce-type') !== 'bookmark')) {
-hasContentNode = true;
-}
-if ($_okk1ogljjgweckx.isBlock(node, blockElements)) {
-fragment.appendChild(node);
-textBlock = null;
-} else {
-if (blockName) {
-if (!textBlock) {
-textBlock = DOM$2.create(blockName);
-fragment.appendChild(textBlock);
-}
-textBlock.appendChild(node);
-} else {
-fragment.appendChild(node);
-}
-}
-}
-}
-if (!editor.settings.forced_root_block) {
-fragment.appendChild(DOM$2.create('br'));
-} else {
-if (!hasContentNode && (!global$8.ie || global$8.ie > 10)) {
-textBlock.appendChild(DOM$2.create('br', { 'data-mce-bogus': '1' }));
-}
-}
-return fragment;
-};
-var $_kbc02gqjjgwecl9 = { createNewTextBlock: createNewTextBlock };
-var DOM$3 = global$6.DOM;
-var splitList = function (editor, ul, li, newBlock) {
-var tmpRng, fragment, bookmarks, node;
-var removeAndKeepBookmarks = function (targetNode) {
-global$5.each(bookmarks, function (node) {
-targetNode.parentNode.insertBefore(node, li.parentNode);
-});
-DOM$3.remove(targetNode);
-};
-bookmarks = DOM$3.select('span[data-mce-type="bookmark"]', ul);
-newBlock = newBlock || $_kbc02gqjjgwecl9.createNewTextBlock(editor, li);
-tmpRng = DOM$3.createRng();
-tmpRng.setStartAfter(li);
-tmpRng.setEndAfter(ul);
-fragment = tmpRng.extractContents();
-for (node = fragment.firstChild; node; node = node.firstChild) {
-if (node.nodeName === 'LI' && editor.dom.isEmpty(node)) {
-DOM$3.remove(node);
-break;
-}
-}
-if (!editor.dom.isEmpty(fragment)) {
-DOM$3.insertAfter(fragment, ul);
-}
-DOM$3.insertAfter(newBlock, ul);
-if ($_okk1ogljjgweckx.isEmpty(editor.dom, li.parentNode)) {
-removeAndKeepBookmarks(li.parentNode);
-}
-DOM$3.remove(li);
-if ($_okk1ogljjgweckx.isEmpty(editor.dom, ul)) {
-DOM$3.remove(ul);
-}
-};
-var $_fikiq7gpjjgwecl5 = { splitList: splitList };
-var DOM$4 = global$6.DOM;
-var removeEmptyLi = function (dom, li) {
-if ($_okk1ogljjgweckx.isEmpty(dom, li)) {
-DOM$4.remove(li);
-}
-};
-var outdent = function (editor, li) {
-var ul = li.parentNode;
-var ulParent, newBlock;
-if (ul) {
-ulParent = ul.parentNode;
-} else {
-removeEmptyLi(editor.dom, li);
-return true;
-}
-if (ul === editor.getBody()) {
-return true;
-}
-if (li.nodeName === 'DD') {
-DOM$4.rename(li, 'DT');
-return true;
-}
-if ($_okk1ogljjgweckx.isFirstChild(li) && $_okk1ogljjgweckx.isLastChild(li)) {
-if (ulParent.nodeName === 'LI') {
-DOM$4.insertAfter(li, ulParent);
-removeEmptyLi(editor.dom, ulParent);
-DOM$4.remove(ul);
-} else if ($_okk1ogljjgweckx.isListNode(ulParent)) {
-DOM$4.remove(ul, true);
-} else {
-ulParent.insertBefore($_kbc02gqjjgwecl9.createNewTextBlock(editor, li), ul);
-DOM$4.remove(ul);
-}
-return true;
-} else if ($_okk1ogljjgweckx.isFirstChild(li)) {
-if (ulParent.nodeName === 'LI') {
-DOM$4.insertAfter(li, ulParent);
-li.appendChild(ul);
-removeEmptyLi(editor.dom, ulParent);
-} else if ($_okk1ogljjgweckx.isListNode(ulParent)) {
-ulParent.insertBefore(li, ul);
-} else {
-ulParent.insertBefore($_kbc02gqjjgwecl9.createNewTextBlock(editor, li), ul);
-DOM$4.remove(li);
-}
-return true;
-} else if ($_okk1ogljjgweckx.isLastChild(li)) {
-if (ulParent.nodeName === 'LI') {
-DOM$4.insertAfter(li, ulParent);
-} else if ($_okk1ogljjgweckx.isListNode(ulParent)) {
-DOM$4.insertAfter(li, ul);
-} else {
-DOM$4.insertAfter($_kbc02gqjjgwecl9.createNewTextBlock(editor, li), ul);
-DOM$4.remove(li);
-}
-return true;
-}
-if (ulParent.nodeName === 'LI') {
-ul = ulParent;
-newBlock = $_kbc02gqjjgwecl9.createNewTextBlock(editor, li, 'LI');
-} else if ($_okk1ogljjgweckx.isListNode(ulParent)) {
-newBlock = $_kbc02gqjjgwecl9.createNewTextBlock(editor, li, 'LI');
-} else {
-newBlock = $_kbc02gqjjgwecl9.createNewTextBlock(editor, li);
-}
-$_fikiq7gpjjgwecl5.splitList(editor, ul, li, newBlock);
-$_ekd4wzgmjjgwecl1.normalizeLists(editor.dom, ul.parentNode);
-return true;
-};
-var outdentSelection = function (editor) {
-var listElements = $_3xb1cggnjjgwecl3.getSelectedListItems(editor);
-if (listElements.length) {
-var bookmark = $_2nx1i4gjjjgweckt.createBookmark(editor.selection.getRng());
-var i = void 0, y = void 0;
-var root = $_3xb1cggnjjgwecl3.getClosestListRootElm(editor, editor.selection.getStart(true));
-i = listElements.length;
-while (i--) {
-var node = listElements[i].parentNode;
-while (node && node !== root) {
-y = listElements.length;
-while (y--) {
-if (listElements[y] === node) {
-listElements.splice(i, 1);
-break;
-}
-}
-node = node.parentNode;
-}
-}
-for (i = 0; i < listElements.length; i++) {
-if (!outdent(editor, listElements[i]) && i === 0) {
-break;
-}
-}
-editor.selection.setRng($_2nx1i4gjjjgweckt.resolveBookmark(bookmark));
-editor.nodeChanged();
-return true;
-}
-};
-var $_6pbactghjjgweckp = {
-outdent: outdent,
-outdentSelection: outdentSelection
-};
-var updateListStyle = function (dom, el, detail) {
-var type = detail['list-style-type'] ? detail['list-style-type'] : null;
-dom.setStyle(el, 'list-style-type', type);
-};
-var setAttribs = function (elm, attrs) {
-global$5.each(attrs, function (value, key) {
-elm.setAttribute(key, value);
-});
-};
-var updateListAttrs = function (dom, el, detail) {
-setAttribs(el, detail['list-attributes']);
-global$5.each(dom.select('li', el), function (li) {
-setAttribs(li, detail['list-item-attributes']);
-});
-};
-var updateListWithDetails = function (dom, el, detail) {
-updateListStyle(dom, el, detail);
-updateListAttrs(dom, el, detail);
-};
-var removeStyles = function (dom, element, styles) {
-global$5.each(styles, function (style) {
-var _a;
-return dom.setStyle(element, (_a = {}, _a[style] = '', _a));
-});
-};
-var getEndPointNode = function (editor, rng, start, root) {
-var container, offset;
-container = rng[start ? 'startContainer' : 'endContainer'];
-offset = rng[start ? 'startOffset' : 'endOffset'];
-if (container.nodeType === 1) {
-container = container.childNodes[Math.min(offset, container.childNodes.length - 1)] || container;
-}
-if (!start && $_okk1ogljjgweckx.isBr(container.nextSibling)) {
-container = container.nextSibling;
-}
-while (container.parentNode !== root) {
-if ($_okk1ogljjgweckx.isTextBlock(editor, container)) {
-return container;
-}
-if (/^(TD|TH)$/.test(container.parentNode.nodeName)) {
-return container;
-}
-container = container.parentNode;
-}
-return container;
-};
-var getSelectedTextBlocks = function (editor, rng, root) {
-var textBlocks = [], dom = editor.dom;
-var startNode = getEndPointNode(editor, rng, true, root);
-var endNode = getEndPointNode(editor, rng, false, root);
-var block;
-var siblings = [];
-for (var node = startNode; node; node = node.nextSibling) {
-siblings.push(node);
-if (node === endNode) {
-break;
-}
-}
-global$5.each(siblings, function (node) {
-if ($_okk1ogljjgweckx.isTextBlock(editor, node)) {
-textBlocks.push(node);
-block = null;
-return;
-}
-if (dom.isBlock(node) || $_okk1ogljjgweckx.isBr(node)) {
-if ($_okk1ogljjgweckx.isBr(node)) {
-dom.remove(node);
-}
-block = null;
-return;
-}
-var nextSibling = node.nextSibling;
-if (global$4.isBookmarkNode(node)) {
-if ($_okk1ogljjgweckx.isTextBlock(editor, nextSibling) || !nextSibling && node.parentNode === root) {
-block = null;
-return;
-}
-}
-if (!block) {
-block = dom.create('p');
-node.parentNode.insertBefore(block, node);
-textBlocks.push(block);
-}
-block.appendChild(node);
-});
-return textBlocks;
-};
-var hasCompatibleStyle = function (dom, sib, detail) {
-var sibStyle = dom.getStyle(sib, 'list-style-type');
-var detailStyle = detail ? detail['list-style-type'] : '';
-detailStyle = detailStyle === null ? '' : detailStyle;
-return sibStyle === detailStyle;
-};
-var applyList = function (editor, listName, detail) {
-if (detail === void 0) {
-detail = {};
-}
-var rng = editor.selection.getRng(true);
-var bookmark;
-var listItemName = 'LI';
-var root = $_3xb1cggnjjgwecl3.getClosestListRootElm(editor, editor.selection.getStart(true));
-var dom = editor.dom;
-if (dom.getContentEditable(editor.selection.getNode()) === 'false') {
-return;
-}
-listName = listName.toUpperCase();
-if (listName === 'DL') {
-listItemName = 'DT';
-}
-bookmark = $_2nx1i4gjjjgweckt.createBookmark(rng);
-global$5.each(getSelectedTextBlocks(editor, rng, root), function (block) {
-var listBlock, sibling;
-sibling = block.previousSibling;
-if (sibling && $_okk1ogljjgweckx.isListNode(sibling) && sibling.nodeName === listName && hasCompatibleStyle(dom, sibling, detail)) {
-listBlock = sibling;
-block = dom.rename(block, listItemName);
-sibling.appendChild(block);
-} else {
-listBlock = dom.create(listName);
-block.parentNode.insertBefore(listBlock, block);
-listBlock.appendChild(block);
-block = dom.rename(block, listItemName);
-}
-removeStyles(dom, block, [
-'margin',
-'margin-right',
-'margin-bottom',
-'margin-left',
-'margin-top',
-'padding',
-'padding-right',
-'padding-bottom',
-'padding-left',
-'padding-top'
-]);
-updateListWithDetails(dom, listBlock, detail);
-mergeWithAdjacentLists(editor.dom, listBlock);
-});
-editor.selection.setRng($_2nx1i4gjjjgweckt.resolveBookmark(bookmark));
-};
-var removeList = function (editor) {
-var bookmark = $_2nx1i4gjjjgweckt.createBookmark(editor.selection.getRng(true));
-var root = $_3xb1cggnjjgwecl3.getClosestListRootElm(editor, editor.selection.getStart(true));
-var listItems = $_3xb1cggnjjgwecl3.getSelectedListItems(editor);
-var emptyListItems = global$5.grep(listItems, function (li) {
-return editor.dom.isEmpty(li);
-});
-listItems = global$5.grep(listItems, function (li) {
-return !editor.dom.isEmpty(li);
-});
-global$5.each(emptyListItems, function (li) {
-if ($_okk1ogljjgweckx.isEmpty(editor.dom, li)) {
-$_6pbactghjjgweckp.outdent(editor, li);
-return;
-}
-});
-global$5.each(listItems, function (li) {
-var node, rootList;
-if (li.parentNode === editor.getBody()) {
-return;
-}
-for (node = li; node && node !== root; node = node.parentNode) {
-if ($_okk1ogljjgweckx.isListNode(node)) {
-rootList = node;
-}
-}
-$_fikiq7gpjjgwecl5.splitList(editor, rootList, li);
-$_ekd4wzgmjjgwecl1.normalizeLists(editor.dom, rootList.parentNode);
-});
-editor.selection.setRng($_2nx1i4gjjjgweckt.resolveBookmark(bookmark));
-};
-var isValidLists = function (list1, list2) {
-return list1 && list2 && $_okk1ogljjgweckx.isListNode(list1) && list1.nodeName === list2.nodeName;
-};
-var hasSameListStyle = function (dom, list1, list2) {
-var targetStyle = dom.getStyle(list1, 'list-style-type', true);
-var style = dom.getStyle(list2, 'list-style-type', true);
-return targetStyle === style;
-};
-var hasSameClasses = function (elm1, elm2) {
-return elm1.className === elm2.className;
-};
-var shouldMerge = function (dom, list1, list2) {
-return isValidLists(list1, list2) && hasSameListStyle(dom, list1, list2) && hasSameClasses(list1, list2);
-};
-var mergeWithAdjacentLists = function (dom, listBlock) {
-var sibling, node;
-sibling = listBlock.nextSibling;
-if (shouldMerge(dom, listBlock, sibling)) {
-while (node = sibling.firstChild) {
-listBlock.appendChild(node);
-}
-dom.remove(sibling);
-}
-sibling = listBlock.previousSibling;
-if (shouldMerge(dom, listBlock, sibling)) {
-while (node = sibling.lastChild) {
-listBlock.insertBefore(node, listBlock.firstChild);
-}
-dom.remove(sibling);
-}
-};
-var updateList = function (dom, list, listName, detail) {
-if (list.nodeName !== listName) {
-var newList = dom.rename(list, listName);
-updateListWithDetails(dom, newList, detail);
-} else {
-updateListWithDetails(dom, list, detail);
-}
-};
-var toggleMultipleLists = function (editor, parentList, lists, listName, detail) {
-if (parentList.nodeName === listName && !hasListStyleDetail(detail)) {
-removeList(editor);
-} else {
-var bookmark = $_2nx1i4gjjjgweckt.createBookmark(editor.selection.getRng(true));
-global$5.each([parentList].concat(lists), function (elm) {
-updateList(editor.dom, elm, listName, detail);
-});
-editor.selection.setRng($_2nx1i4gjjjgweckt.resolveBookmark(bookmark));
-}
-};
-var hasListStyleDetail = function (detail) {
-return 'list-style-type' in detail;
-};
-var toggleSingleList = function (editor, parentList, listName, detail) {
-if (parentList === editor.getBody()) {
-return;
-}
-if (parentList) {
-if (parentList.nodeName === listName && !hasListStyleDetail(detail)) {
-removeList(editor);
-} else {
-var bookmark = $_2nx1i4gjjjgweckt.createBookmark(editor.selection.getRng(true));
-updateListWithDetails(editor.dom, parentList, detail);
-mergeWithAdjacentLists(editor.dom, editor.dom.rename(parentList, listName));
-editor.selection.setRng($_2nx1i4gjjjgweckt.resolveBookmark(bookmark));
-}
-} else {
-applyList(editor, listName, detail);
-}
-};
-var toggleList = function (editor, listName, detail) {
-var parentList = $_3xb1cggnjjgwecl3.getParentList(editor);
-var selectedSubLists = $_3xb1cggnjjgwecl3.getSelectedSubLists(editor);
-detail = detail ? detail : {};
-if (parentList && selectedSubLists.length > 0) {
-toggleMultipleLists(editor, parentList, selectedSubLists, listName, detail);
-} else {
-toggleSingleList(editor, parentList, listName, detail);
-}
-};
-var $_aek3i3gejjgwecki = {
-toggleList: toggleList,
-removeList: removeList,
-mergeWithAdjacentLists: mergeWithAdjacentLists
-};
-var findNextCaretContainer = function (editor, rng, isForward, root) {
-var node = rng.startContainer;
-var offset = rng.startOffset;
-var nonEmptyBlocks, walker;
-if (node.nodeType === 3 && (isForward ? offset < node.data.length : offset > 0)) {
-return node;
-}
-nonEmptyBlocks = editor.schema.getNonEmptyElements();
-if (node.nodeType === 1) {
-node = global$1.getNode(node, offset);
-}
-walker = new global$2(node, root);
-if (isForward) {
-if ($_okk1ogljjgweckx.isBogusBr(editor.dom, node)) {
-walker.next();
-}
-}
-while (node = walker[isForward ? 'next' : 'prev2']()) {
-if (node.nodeName === 'LI' && !node.hasChildNodes()) {
-return node;
-}
-if (nonEmptyBlocks[node.nodeName]) {
-return node;
-}
-if (node.nodeType === 3 && node.data.length > 0) {
-return node;
-}
-}
-};
-var hasOnlyOneBlockChild = function (dom, elm) {
-var childNodes = elm.childNodes;
-return childNodes.length === 1 && !$_okk1ogljjgweckx.isListNode(childNodes[0]) && dom.isBlock(childNodes[0]);
-};
-var unwrapSingleBlockChild = function (dom, elm) {
-if (hasOnlyOneBlockChild(dom, elm)) {
-dom.remove(elm.firstChild, true);
-}
-};
-var moveChildren = function (dom, fromElm, toElm) {
-var node, targetElm;
-targetElm = hasOnlyOneBlockChild(dom, toElm) ? toElm.firstChild : toElm;
-unwrapSingleBlockChild(dom, fromElm);
-if (!$_okk1ogljjgweckx.isEmpty(dom, fromElm, true)) {
-while (node = fromElm.firstChild) {
-targetElm.appendChild(node);
-}
-}
-};
-var mergeLiElements = function (dom, fromElm, toElm) {
-var node, listNode;
-var ul = fromElm.parentNode;
-if (!$_okk1ogljjgweckx.isChildOfBody(dom, fromElm) || !$_okk1ogljjgweckx.isChildOfBody(dom, toElm)) {
-return;
-}
-if ($_okk1ogljjgweckx.isListNode(toElm.lastChild)) {
-listNode = toElm.lastChild;
-}
-if (ul === toElm.lastChild) {
-if ($_okk1ogljjgweckx.isBr(ul.previousSibling)) {
-dom.remove(ul.previousSibling);
-}
-}
-node = toElm.lastChild;
-if (node && $_okk1ogljjgweckx.isBr(node) && fromElm.hasChildNodes()) {
-dom.remove(node);
-}
-if ($_okk1ogljjgweckx.isEmpty(dom, toElm, true)) {
-dom.$(toElm).empty();
-}
-moveChildren(dom, fromElm, toElm);
-if (listNode) {
-toElm.appendChild(listNode);
-}
-dom.remove(fromElm);
-if ($_okk1ogljjgweckx.isEmpty(dom, ul) && ul !== dom.getRoot()) {
-dom.remove(ul);
-}
-};
-var mergeIntoEmptyLi = function (editor, fromLi, toLi) {
-editor.dom.$(toLi).empty();
-mergeLiElements(editor.dom, fromLi, toLi);
-editor.selection.setCursorLocation(toLi);
-};
-var mergeForward = function (editor, rng, fromLi, toLi) {
-var dom = editor.dom;
-if (dom.isEmpty(toLi)) {
-mergeIntoEmptyLi(editor, fromLi, toLi);
-} else {
-var bookmark = $_2nx1i4gjjjgweckt.createBookmark(rng);
-mergeLiElements(dom, fromLi, toLi);
-editor.selection.setRng($_2nx1i4gjjjgweckt.resolveBookmark(bookmark));
-}
-};
-var mergeBackward = function (editor, rng, fromLi, toLi) {
-var bookmark = $_2nx1i4gjjjgweckt.createBookmark(rng);
-mergeLiElements(editor.dom, fromLi, toLi);
-var resolvedBookmark = $_2nx1i4gjjjgweckt.resolveBookmark(bookmark);
-editor.selection.setRng(resolvedBookmark);
-};
-var backspaceDeleteFromListToListCaret = function (editor, isForward) {
-var dom = editor.dom, selection = editor.selection;
-var selectionStartElm = selection.getStart();
-var root = $_3xb1cggnjjgwecl3.getClosestListRootElm(editor, selectionStartElm);
-var li = dom.getParent(selection.getStart(), 'LI', root);
-var ul, rng, otherLi;
-if (li) {
-ul = li.parentNode;
-if (ul === editor.getBody() && $_okk1ogljjgweckx.isEmpty(dom, ul)) {
-return true;
-}
-rng = $_a9cyhvgkjjgweckv.normalizeRange(selection.getRng(true));
-otherLi = dom.getParent(findNextCaretContainer(editor, rng, isForward, root), 'LI', root);
-if (otherLi && otherLi !== li) {
-if (isForward) {
-mergeForward(editor, rng, otherLi, li);
-} else {
-mergeBackward(editor, rng, li, otherLi);
-}
-return true;
-} else if (!otherLi) {
-if (!isForward && $_aek3i3gejjgwecki.removeList(editor)) {
 return true;
 }
 }
-}
+return false;
-return false;
+};
-};
+var backspaceDeleteCaret = function (editor, isForward) {
-var removeBlock = function (dom, block, root) {
+return backspaceDeleteFromListToListCaret(editor, isForward) || backspaceDeleteIntoListCaret(editor, isForward);
-var parentBlock = dom.getParent(block.parentNode, dom.isBlock, root);
+};
-dom.remove(block);
+var backspaceDeleteRange = function (editor) {
-if (parentBlock && dom.isEmpty(parentBlock)) {
+var selectionStartElm = editor.selection.getStart();
-dom.remove(parentBlock);
+var root = Selection.getClosestListRootElm(editor, selectionStartElm);
-}
+var startListParent = editor.dom.getParent(selectionStartElm, 'LI,DT,DD', root);
-};
+if (startListParent || Selection.getSelectedListItems(editor).length > 0) {
-var backspaceDeleteIntoListCaret = function (editor, isForward) {
-var dom = editor.dom;
-var selectionStartElm = editor.selection.getStart();
-var root = $_3xb1cggnjjgwecl3.getClosestListRootElm(editor, selectionStartElm);
-var block = dom.getParent(selectionStartElm, dom.isBlock, root);
-if (block && dom.isEmpty(block)) {
-var rng = $_a9cyhvgkjjgweckv.normalizeRange(editor.selection.getRng(true));
-var otherLi_1 = dom.getParent(findNextCaretContainer(editor, rng, isForward, root), 'LI', root);
-if (otherLi_1) {
 editor.undoManager.transact(function () {
-removeBlock(dom, block, root);
+editor.execCommand('Delete');
-$_aek3i3gejjgwecki.mergeWithAdjacentLists(dom, otherLi_1.parentNode);
+NormalizeLists.normalizeLists(editor.dom, editor.getBody());
-editor.selection.select(otherLi_1, true);
-editor.selection.collapse(isForward);
 });
 return true;
 }
+return false;
+};
+var backspaceDelete = function (editor, isForward) {
+return editor.selection.isCollapsed() ? backspaceDeleteCaret(editor, isForward) : backspaceDeleteRange(editor);
+};
+var setup = function (editor) {
+editor.on('keydown', function (e) {
+if (e.keyCode === global$3.BACKSPACE) {
+if (backspaceDelete(editor, false)) {
+e.preventDefault();
+}
+} else if (e.keyCode === global$3.DELETE) {
+if (backspaceDelete(editor, true)) {
+e.preventDefault();
+}
+}
+});
+};
+var Delete = {
+setup: setup,
+backspaceDelete: backspaceDelete
+};
+var get = function (editor) {
+return {
+backspaceDelete: function (isForward) {
+Delete.backspaceDelete(editor, isForward);
+}
+};
+};
+var Api = { get: get };
+var queryListCommandState = function (editor, listName) {
+return function () {
+var parentList = editor.dom.getParent(editor.selection.getStart(), 'UL,OL,DL');
+return parentList && parentList.nodeName === listName;
+};
+};
+var register = function (editor) {
+editor.on('BeforeExecCommand', function (e) {
+var cmd = e.command.toLowerCase();
+if (cmd === 'indent') {
+indentListSelection(editor);
+} else if (cmd === 'outdent') {
+outdentListSelection(editor);
+}
+});
+editor.addCommand('InsertUnorderedList', function (ui, detail) {
+ToggleList.toggleList(editor, 'UL', detail);
+});
+editor.addCommand('InsertOrderedList', function (ui, detail) {
+ToggleList.toggleList(editor, 'OL', detail);
+});
+editor.addCommand('InsertDefinitionList', function (ui, detail) {
+ToggleList.toggleList(editor, 'DL', detail);
+});
+editor.addCommand('RemoveList', function () {
+flattenListSelection(editor);
+});
+editor.addQueryStateHandler('InsertUnorderedList', queryListCommandState(editor, 'UL'));
+editor.addQueryStateHandler('InsertOrderedList', queryListCommandState(editor, 'OL'));
+editor.addQueryStateHandler('InsertDefinitionList', queryListCommandState(editor, 'DL'));
+};
+var Commands = { register: register };
+var shouldIndentOnTab = function (editor) {
+return editor.getParam('lists_indent_on_tab', true);
+};
+var Settings = { shouldIndentOnTab: shouldIndentOnTab };
+var setupTabKey = function (editor) {
+editor.on('keydown', function (e) {
+if (e.keyCode !== global$3.TAB || global$3.metaKeyPressed(e)) {
+return;
+}
+editor.undoManager.transact(function () {
+if (e.shiftKey ? outdentListSelection(editor) : indentListSelection(editor)) {
+e.preventDefault();
+}
+});
+});
+};
+var setup$1 = function (editor) {
+if (Settings.shouldIndentOnTab(editor)) {
+setupTabKey(editor);
+}
+Delete.setup(editor);
+};
+var Keyboard = { setup: setup$1 };
+var findIndex = function (list, predicate) {
+for (var index = 0; index < list.length; index++) {
+var element = list[index];
+if (predicate(element)) {
+return index;
+}
+}
+return -1;
+};
+var listState = function (editor, listName) {
+return function (e) {
+var ctrl = e.control;
+editor.on('NodeChange', function (e) {
+var tableCellIndex = findIndex(e.parents, NodeType.isTableCellNode);
+var parents = tableCellIndex !== -1 ? e.parents.slice(0, tableCellIndex) : e.parents;
+var lists = global$5.grep(parents, NodeType.isListNode);
+ctrl.active(lists.length > 0 && lists[0].nodeName === listName);
+});
+};
+};
+var register$1 = function (editor) {
+var hasPlugin = function (editor, plugin) {
+var plugins = editor.settings.plugins ? editor.settings.plugins : '';
+return global$5.inArray(plugins.split(/[ ,]/), plugin) !== -1;
+};
+if (!hasPlugin(editor, 'advlist')) {
+editor.addButton('numlist', {
+active: false,
+title: 'Numbered list',
+cmd: 'InsertOrderedList',
+onPostRender: listState(editor, 'OL')
+});
+editor.addButton('bullist', {
+active: false,
+title: 'Bullet list',
+cmd: 'InsertUnorderedList',
+onPostRender: listState(editor, 'UL')
+});
+}
+editor.addButton('indent', {
+icon: 'indent',
+title: 'Increase indent',
+cmd: 'Indent'
+});
+};
+var Buttons = { register: register$1 };
+global.add('lists', function (editor) {
+Keyboard.setup(editor);
+Buttons.register(editor);
+Commands.register(editor);
+return Api.get(editor);
+});
+function Plugin () {
 }
-return false;
-};
+return Plugin;
-var backspaceDeleteCaret = function (editor, isForward) {
-return backspaceDeleteFromListToListCaret(editor, isForward) || backspaceDeleteIntoListCaret(editor, isForward);
+}(window));
-};
-var backspaceDeleteRange = function (editor) {
-var selectionStartElm = editor.selection.getStart();
-var root = $_3xb1cggnjjgwecl3.getClosestListRootElm(editor, selectionStartElm);
-var startListParent = editor.dom.getParent(selectionStartElm, 'LI,DT,DD', root);
-if (startListParent || $_3xb1cggnjjgwecl3.getSelectedListItems(editor).length > 0) {
-editor.undoManager.transact(function () {
-editor.execCommand('Delete');
-$_ekd4wzgmjjgwecl1.normalizeLists(editor.dom, editor.getBody());
-});
-return true;
-}
-return false;
-};
-var backspaceDelete = function (editor, isForward) {
-return editor.selection.isCollapsed() ? backspaceDeleteCaret(editor, isForward) : backspaceDeleteRange(editor);
-};
-var setup = function (editor) {
-editor.on('keydown', function (e) {
-if (e.keyCode === global$3.BACKSPACE) {
-if (backspaceDelete(editor, false)) {
-e.preventDefault();
-}
-} else if (e.keyCode === global$3.DELETE) {
-if (backspaceDelete(editor, true)) {
-e.preventDefault();
-}
-}
-});
-};
-var $_brhyezgajjgweck7 = {
-setup: setup,
-backspaceDelete: backspaceDelete
-};
-var get = function (editor) {
-return {
-backspaceDelete: function (isForward) {
-$_brhyezgajjgweck7.backspaceDelete(editor, isForward);
-}
-};
-};
-var $_nb3yvg9jjgweck5 = { get: get };
-var DOM$5 = global$6.DOM;
-var mergeLists = function (from, to) {
-var node;
-if ($_okk1ogljjgweckx.isListNode(from)) {
-while (node = from.firstChild) {
-to.appendChild(node);
-}
-DOM$5.remove(from);
-}
-};
-var indent = function (li) {
-var sibling, newList, listStyle;
-if (li.nodeName === 'DT') {
-DOM$5.rename(li, 'DD');
-return true;
-}
-sibling = li.previousSibling;
-if (sibling && $_okk1ogljjgweckx.isListNode(sibling)) {
-sibling.appendChild(li);
-return true;
-}
-if (sibling && sibling.nodeName === 'LI' && $_okk1ogljjgweckx.isListNode(sibling.lastChild)) {
-sibling.lastChild.appendChild(li);
-mergeLists(li.lastChild, sibling.lastChild);
-return true;
-}
-sibling = li.nextSibling;
-if (sibling && $_okk1ogljjgweckx.isListNode(sibling)) {
-sibling.insertBefore(li, sibling.firstChild);
-return true;
-}
-sibling = li.previousSibling;
-if (sibling && sibling.nodeName === 'LI') {
-newList = DOM$5.create(li.parentNode.nodeName);
-listStyle = DOM$5.getStyle(li.parentNode, 'listStyleType');
-if (listStyle) {
-DOM$5.setStyle(newList, 'listStyleType', listStyle);
-}
-sibling.appendChild(newList);
-newList.appendChild(li);
-mergeLists(li.lastChild, newList);
-return true;
-}
-return false;
-};
-var indentSelection = function (editor) {
-var listElements = $_3xb1cggnjjgwecl3.getSelectedListItems(editor);
-if (listElements.length) {
-var bookmark = $_2nx1i4gjjjgweckt.createBookmark(editor.selection.getRng(true));
-for (var i = 0; i < listElements.length; i++) {
-if (!indent(listElements[i]) && i === 0) {
-break;
-}
-}
-editor.selection.setRng($_2nx1i4gjjjgweckt.resolveBookmark(bookmark));
-editor.nodeChanged();
-return true;
-}
-};
-var $_3rkwagtjjgweclf = { indentSelection: indentSelection };
-var queryListCommandState = function (editor, listName) {
-return function () {
-var parentList = editor.dom.getParent(editor.selection.getStart(), 'UL,OL,DL');
-return parentList && parentList.nodeName === listName;
-};
-};
-var register = function (editor) {
-editor.on('BeforeExecCommand', function (e) {
-var cmd = e.command.toLowerCase();
-var isHandled;
-if (cmd === 'indent') {
-if ($_3rkwagtjjgweclf.indentSelection(editor)) {
-isHandled = true;
-}
-} else if (cmd === 'outdent') {
-if ($_6pbactghjjgweckp.outdentSelection(editor)) {
-isHandled = true;
-}
-}
-if (isHandled) {
-editor.fire('ExecCommand', { command: e.command });
-e.preventDefault();
-return true;
-}
-});
-editor.addCommand('InsertUnorderedList', function (ui, detail) {
-$_aek3i3gejjgwecki.toggleList(editor, 'UL', detail);
-});
-editor.addCommand('InsertOrderedList', function (ui, detail) {
-$_aek3i3gejjgwecki.toggleList(editor, 'OL', detail);
-});
-editor.addCommand('InsertDefinitionList', function (ui, detail) {
-$_aek3i3gejjgwecki.toggleList(editor, 'DL', detail);
-});
-editor.addQueryStateHandler('InsertUnorderedList', queryListCommandState(editor, 'UL'));
-editor.addQueryStateHandler('InsertOrderedList', queryListCommandState(editor, 'OL'));
-editor.addQueryStateHandler('InsertDefinitionList', queryListCommandState(editor, 'DL'));
-};
-var $_blnfs1gsjjgwecld = { register: register };
-var shouldIndentOnTab = function (editor) {
-return editor.getParam('lists_indent_on_tab', true);
-};
-var $_8obsbgvjjgweclk = { shouldIndentOnTab: shouldIndentOnTab };
-var setupTabKey = function (editor) {
-editor.on('keydown', function (e) {
-if (e.keyCode !== global$3.TAB || global$3.metaKeyPressed(e)) {
-return;
-}
-if (editor.dom.getParent(editor.selection.getStart(), 'LI,DT,DD')) {
-e.preventDefault();
-if (e.shiftKey) {
-$_6pbactghjjgweckp.outdentSelection(editor);
-} else {
-$_3rkwagtjjgweclf.indentSelection(editor);
-}
-}
-});
-};
-var setup$1 = function (editor) {
-if ($_8obsbgvjjgweclk.shouldIndentOnTab(editor)) {
-setupTabKey(editor);
-}
-$_brhyezgajjgweck7.setup(editor);
-};
-var $_ees9z9gujjgwecli = { setup: setup$1 };
-var findIndex = function (list, predicate) {
-for (var index = 0; index < list.length; index++) {
-var element = list[index];
-if (predicate(element)) {
-return index;
-}
-}
-return -1;
-};
-var listState = function (editor, listName) {
-return function (e) {
-var ctrl = e.control;
-editor.on('NodeChange', function (e) {
-var tableCellIndex = findIndex(e.parents, $_okk1ogljjgweckx.isTableCellNode);
-var parents = tableCellIndex !== -1 ? e.parents.slice(0, tableCellIndex) : e.parents;
-var lists = global$5.grep(parents, $_okk1ogljjgweckx.isListNode);
-ctrl.active(lists.length > 0 && lists[0].nodeName === listName);
-});
-};
-};
-var indentPostRender = function (editor) {
-return function (e) {
-var ctrl = e.control;
-editor.on('nodechange', function () {
-var listItemBlocks = $_3xb1cggnjjgwecl3.getSelectedListItems(editor);
-var disable = listItemBlocks.length > 0 && $_okk1ogljjgweckx.isFirstChild(listItemBlocks[0]);
-ctrl.disabled(disable);
-});
-};
-};
-var register$1 = function (editor) {
-var hasPlugin = function (editor, plugin) {
-var plugins = editor.settings.plugins ? editor.settings.plugins : '';
-return global$5.inArray(plugins.split(/[ ,]/), plugin) !== -1;
-};
-if (!hasPlugin(editor, 'advlist')) {
-editor.addButton('numlist', {
-active: false,
-title: 'Numbered list',
-cmd: 'InsertOrderedList',
-onPostRender: listState(editor, 'OL')
-});
-editor.addButton('bullist', {
-active: false,
-title: 'Bullet list',
-cmd: 'InsertUnorderedList',
-onPostRender: listState(editor, 'UL')
-});
-}
-editor.addButton('indent', {
-icon: 'indent',
-title: 'Increase indent',
-cmd: 'Indent',
-onPostRender: indentPostRender(editor)
-});
-};
-var $_s7o0sgwjjgweclm = { register: register$1 };
-global.add('lists', function (editor) {
-$_ees9z9gujjgwecli.setup(editor);
-$_s7o0sgwjjgweclm.register(editor);
-$_blnfs1gsjjgwecld.register(editor);
-return $_nb3yvg9jjgweck5.get(editor);
-});
-function Plugin () {
-}
-return Plugin;
-}());
 })();

enmi-conf.org