1(function () {
2var lists = (function (domGlobals) {
3 'use strict';
4
5 var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
6
7 var global$1 = tinymce.util.Tools.resolve('tinymce.dom.RangeUtils');
8
9 var global$2 = tinymce.util.Tools.resolve('tinymce.dom.TreeWalker');
10
11 var global$3 = tinymce.util.Tools.resolve('tinymce.util.VK');
12
13 var global$4 = tinymce.util.Tools.resolve('tinymce.dom.BookmarkManager');
14
15 var global$5 = tinymce.util.Tools.resolve('tinymce.util.Tools');
16
17 var global$6 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
18
19 var isTextNode = function (node) {
20 return node && node.nodeType === 3;
21 };
22 var isListNode = function (node) {
23 return node && /^(OL|UL|DL)$/.test(node.nodeName);
24 };
25 var isOlUlNode = function (node) {
26 return node && /^(OL|UL)$/.test(node.nodeName);
27 };
28 var isListItemNode = function (node) {
29 return node && /^(LI|DT|DD)$/.test(node.nodeName);
30 };
31 var isDlItemNode = function (node) {
32 return node && /^(DT|DD)$/.test(node.nodeName);
33 };
34 var isTableCellNode = function (node) {
35 return node && /^(TH|TD)$/.test(node.nodeName);
36 };
37 var isBr = function (node) {
38 return node && node.nodeName === 'BR';
39 };
40 var isFirstChild = function (node) {
41 return node.parentNode.firstChild === node;
42 };
43 var isLastChild = function (node) {
44 return node.parentNode.lastChild === node;
45 };
46 var isTextBlock = function (editor, node) {
47 return node && !!editor.schema.getTextBlockElements()[node.nodeName];
48 };
49 var isBlock = function (node, blockElements) {
50 return node && node.nodeName in blockElements;
51 };
52 var isBogusBr = function (dom, node) {
53 if (!isBr(node)) {
54 return false;
55 }
56 if (dom.isBlock(node.nextSibling) && !isBr(node.previousSibling)) {
57 return true;
58 }
59 return false;
60 };
61 var isEmpty = function (dom, elm, keepBookmarks) {
62 var empty = dom.isEmpty(elm);
63 if (keepBookmarks && dom.select('span[data-mce-type=bookmark]', elm).length > 0) {
64 return false;
65 }
66 return empty;
67 };
68 var isChildOfBody = function (dom, elm) {
69 return dom.isChildOf(elm, dom.getRoot());
70 };
71 var NodeType = {
72 isTextNode: isTextNode,
73 isListNode: isListNode,
74 isOlUlNode: isOlUlNode,
75 isDlItemNode: isDlItemNode,
76 isListItemNode: isListItemNode,
77 isTableCellNode: isTableCellNode,
78 isBr: isBr,
79 isFirstChild: isFirstChild,
80 isLastChild: isLastChild,
81 isTextBlock: isTextBlock,
82 isBlock: isBlock,
83 isBogusBr: isBogusBr,
84 isEmpty: isEmpty,
85 isChildOfBody: isChildOfBody
86 };
87
88 var getNormalizedPoint = function (container, offset) {
89 if (NodeType.isTextNode(container)) {
90 return {
91 container: container,
92 offset: offset
93 };
94 }
95 var node = global$1.getNode(container, offset);
96 if (NodeType.isTextNode(node)) {
97 return {
98 container: node,
99 offset: offset >= container.childNodes.length ? node.data.length : 0
100 };
101 } else if (node.previousSibling && NodeType.isTextNode(node.previousSibling)) {
102 return {
103 container: node.previousSibling,
104 offset: node.previousSibling.data.length
105 };
106 } else if (node.nextSibling && NodeType.isTextNode(node.nextSibling)) {
107 return {
108 container: node.nextSibling,
109 offset: 0
110 };
111 }
112 return {
113 container: container,
114 offset: offset
115 };
116 };
117 var normalizeRange = function (rng) {
118 var outRng = rng.cloneRange();
119 var rangeStart = getNormalizedPoint(rng.startContainer, rng.startOffset);
120 outRng.setStart(rangeStart.container, rangeStart.offset);
121 var rangeEnd = getNormalizedPoint(rng.endContainer, rng.endOffset);
122 outRng.setEnd(rangeEnd.container, rangeEnd.offset);
123 return outRng;
124 };
125 var Range = {
126 getNormalizedPoint: getNormalizedPoint,
127 normalizeRange: normalizeRange
128 };
129
130 var DOM = global$6.DOM;
131 var createBookmark = function (rng) {
132 var bookmark = {};
133 var setupEndPoint = function (start) {
134 var offsetNode, container, offset;
135 container = rng[start ? 'startContainer' : 'endContainer'];
136 offset = rng[start ? 'startOffset' : 'endOffset'];
137 if (container.nodeType === 1) {
138 offsetNode = DOM.create('span', { 'data-mce-type': 'bookmark' });
139 if (container.hasChildNodes()) {
140 offset = Math.min(offset, container.childNodes.length - 1);
141 if (start) {
142 container.insertBefore(offsetNode, container.childNodes[offset]);
143 } else {
144 DOM.insertAfter(offsetNode, container.childNodes[offset]);
145 }
146 } else {
147 container.appendChild(offsetNode);
148 }
149 container = offsetNode;
150 offset = 0;
151 }
152 bookmark[start ? 'startContainer' : 'endContainer'] = container;
153 bookmark[start ? 'startOffset' : 'endOffset'] = offset;
154 };
155 setupEndPoint(true);
156 if (!rng.collapsed) {
157 setupEndPoint();
158 }
159 return bookmark;
160 };
161 var resolveBookmark = function (bookmark) {
162 function restoreEndPoint(start) {
163 var container, offset, node;
164 var nodeIndex = function (container) {
165 var node = container.parentNode.firstChild, idx = 0;
166 while (node) {
167 if (node === container) {
168 return idx;
169 }
170 if (node.nodeType !== 1 || node.getAttribute('data-mce-type') !== 'bookmark') {
171 idx++;
172 }
173 node = node.nextSibling;
174 }
175 return -1;
176 };
177 container = node = bookmark[start ? 'startContainer' : 'endContainer'];
178 offset = bookmark[start ? 'startOffset' : 'endOffset'];
179 if (!container) {
180 return;
181 }
182 if (container.nodeType === 1) {
183 offset = nodeIndex(container);
184 container = container.parentNode;
185 DOM.remove(node);
186 if (!container.hasChildNodes() && DOM.isBlock(container)) {
187 container.appendChild(DOM.create('br'));
188 }
189 }
190 bookmark[start ? 'startContainer' : 'endContainer'] = container;
191 bookmark[start ? 'startOffset' : 'endOffset'] = offset;
192 }
193 restoreEndPoint(true);
194 restoreEndPoint();
195 var rng = DOM.createRng();
196 rng.setStart(bookmark.startContainer, bookmark.startOffset);
197 if (bookmark.endContainer) {
198 rng.setEnd(bookmark.endContainer, bookmark.endOffset);
199 }
200 return Range.normalizeRange(rng);
201 };
202 var Bookmark = {
203 createBookmark: createBookmark,
204 resolveBookmark: resolveBookmark
205 };
206
207 var noop = function () {
208 };
209 var constant = function (value) {
210 return function () {
211 return value;
212 };
213 };
214 var not = function (f) {
215 return function () {
216 var args = [];
217 for (var _i = 0; _i < arguments.length; _i++) {
218 args[_i] = arguments[_i];
219 }
220 return !f.apply(null, args);
221 };
222 };
223 var never = constant(false);
224 var always = constant(true);
225
226 var none = function () {
227 return NONE;
228 };
229 var NONE = function () {
230 var eq = function (o) {
231 return o.isNone();
232 };
233 var call = function (thunk) {
234 return thunk();
235 };
236 var id = function (n) {
237 return n;
238 };
239 var me = {
240 fold: function (n, s) {
241 return n();
242 },
243 is: never,
244 isSome: never,
245 isNone: always,
246 getOr: id,
247 getOrThunk: call,
248 getOrDie: function (msg) {
249 throw new Error(msg || 'error: getOrDie called on none.');
250 },
251 getOrNull: constant(null),
252 getOrUndefined: constant(undefined),
253 or: id,
254 orThunk: call,
255 map: none,
256 each: noop,
257 bind: none,
258 exists: never,
259 forall: always,
260 filter: none,
261 equals: eq,
262 equals_: eq,
263 toArray: function () {
264 return [];
265 },
266 toString: constant('none()')
267 };
268 if (Object.freeze) {
269 Object.freeze(me);
270 }
271 return me;
272 }();
273 var some = function (a) {
274 var constant_a = constant(a);
275 var self = function () {
276 return me;
277 };
278 var bind = function (f) {
279 return f(a);
280 };
281 var me = {
282 fold: function (n, s) {
283 return s(a);
284 },
285 is: function (v) {
286 return a === v;
287 },
288 isSome: always,
289 isNone: never,
290 getOr: constant_a,
291 getOrThunk: constant_a,
292 getOrDie: constant_a,
293 getOrNull: constant_a,
294 getOrUndefined: constant_a,
295 or: self,
296 orThunk: self,
297 map: function (f) {
298 return some(f(a));
299 },
300 each: function (f) {
301 f(a);
302 },
303 bind: bind,
304 exists: bind,
305 forall: bind,
306 filter: function (f) {
307 return f(a) ? me : NONE;
308 },
309 toArray: function () {
310 return [a];
311 },
312 toString: function () {
313 return 'some(' + a + ')';
314 },
315 equals: function (o) {
316 return o.is(a);
317 },
318 equals_: function (o, elementEq) {
319 return o.fold(never, function (b) {
320 return elementEq(a, b);
321 });
322 }
323 };
324 return me;
325 };
326 var from = function (value) {
327 return value === null || value === undefined ? NONE : some(value);
328 };
329 var Option = {
330 some: some,
331 none: none,
332 from: from
333 };
334
335 var typeOf = function (x) {
336 if (x === null) {
337 return 'null';
338 }
339 var t = typeof x;
340 if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
341 return 'array';
342 }
343 if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
344 return 'string';
345 }
346 return t;
347 };
348 var isType = function (type) {
349 return function (value) {
350 return typeOf(value) === type;
351 };
352 };
353 var isString = isType('string');
354 var isArray = isType('array');
355 var isBoolean = isType('boolean');
356 var isFunction = isType('function');
357 var isNumber = isType('number');
358
359 var nativeSlice = Array.prototype.slice;
360 var nativePush = Array.prototype.push;
361 var map = function (xs, f) {
362 var len = xs.length;
363 var r = new Array(len);
364 for (var i = 0; i < len; i++) {
365 var x = xs[i];
366 r[i] = f(x, i);
367 }
368 return r;
369 };
370 var each = function (xs, f) {
371 for (var i = 0, len = xs.length; i < len; i++) {
372 var x = xs[i];
373 f(x, i);
374 }
375 };
376 var filter = function (xs, pred) {
377 var r = [];
378 for (var i = 0, len = xs.length; i < len; i++) {
379 var x = xs[i];
380 if (pred(x, i)) {
381 r.push(x);
382 }
383 }
384 return r;
385 };
386 var groupBy = function (xs, f) {
387 if (xs.length === 0) {
388 return [];
389 } else {
390 var wasType = f(xs[0]);
391 var r = [];
392 var group = [];
393 for (var i = 0, len = xs.length; i < len; i++) {
394 var x = xs[i];
395 var type = f(x);
396 if (type !== wasType) {
397 r.push(group);
398 group = [];
399 }
400 wasType = type;
401 group.push(x);
402 }
403 if (group.length !== 0) {
404 r.push(group);
405 }
406 return r;
407 }
408 };
409 var foldl = function (xs, f, acc) {
410 each(xs, function (x) {
411 acc = f(acc, x);
412 });
413 return acc;
414 };
415 var find = function (xs, pred) {
416 for (var i = 0, len = xs.length; i < len; i++) {
417 var x = xs[i];
418 if (pred(x, i)) {
419 return Option.some(x);
420 }
421 }
422 return Option.none();
423 };
424 var flatten = function (xs) {
425 var r = [];
426 for (var i = 0, len = xs.length; i < len; ++i) {
427 if (!isArray(xs[i])) {
428 throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
429 }
430 nativePush.apply(r, xs[i]);
431 }
432 return r;
433 };
434 var bind = function (xs, f) {
435 var output = map(xs, f);
436 return flatten(output);
437 };
438 var reverse = function (xs) {
439 var r = nativeSlice.call(xs, 0);
440 r.reverse();
441 return r;
442 };
443 var head = function (xs) {
444 return xs.length === 0 ? Option.none() : Option.some(xs[0]);
445 };
446 var last = function (xs) {
447 return xs.length === 0 ? Option.none() : Option.some(xs[xs.length - 1]);
448 };
449 var from$1 = isFunction(Array.from) ? Array.from : function (x) {
450 return nativeSlice.call(x);
451 };
452
453 var Global = typeof domGlobals.window !== 'undefined' ? domGlobals.window : Function('return this;')();
454
455 var path = function (parts, scope) {
456 var o = scope !== undefined && scope !== null ? scope : Global;
457 for (var i = 0; i < parts.length && o !== undefined && o !== null; ++i) {
458 o = o[parts[i]];
459 }
460 return o;
461 };
462 var resolve = function (p, scope) {
463 var parts = p.split('.');
464 return path(parts, scope);
465 };
466
467 var unsafe = function (name, scope) {
468 return resolve(name, scope);
469 };
470 var getOrDie = function (name, scope) {
471 var actual = unsafe(name, scope);
472 if (actual === undefined || actual === null) {
473 throw new Error(name + ' not available on this browser');
474 }
475 return actual;
476 };
477 var Global$1 = { getOrDie: getOrDie };
478
479 var htmlElement = function (scope) {
480 return Global$1.getOrDie('HTMLElement', scope);
481 };
482 var isPrototypeOf = function (x) {
483 var scope = resolve('ownerDocument.defaultView', x);
484 return htmlElement(scope).prototype.isPrototypeOf(x);
485 };
486 var HTMLElement = { isPrototypeOf: isPrototypeOf };
487
488 var global$7 = tinymce.util.Tools.resolve('tinymce.dom.DomQuery');
489
490 var getParentList = function (editor) {
491 var selectionStart = editor.selection.getStart(true);
492 return editor.dom.getParent(selectionStart, 'OL,UL,DL', getClosestListRootElm(editor, selectionStart));
493 };
494 var isParentListSelected = function (parentList, selectedBlocks) {
495 return parentList && selectedBlocks.length === 1 && selectedBlocks[0] === parentList;
496 };
497 var findSubLists = function (parentList) {
498 return global$5.grep(parentList.querySelectorAll('ol,ul,dl'), function (elm) {
499 return NodeType.isListNode(elm);
500 });
501 };
502 var getSelectedSubLists = function (editor) {
503 var parentList = getParentList(editor);
504 var selectedBlocks = editor.selection.getSelectedBlocks();
505 if (isParentListSelected(parentList, selectedBlocks)) {
506 return findSubLists(parentList);
507 } else {
508 return global$5.grep(selectedBlocks, function (elm) {
509 return NodeType.isListNode(elm) && parentList !== elm;
510 });
511 }
512 };
513 var findParentListItemsNodes = function (editor, elms) {
514 var listItemsElms = global$5.map(elms, function (elm) {
515 var parentLi = editor.dom.getParent(elm, 'li,dd,dt', getClosestListRootElm(editor, elm));
516 return parentLi ? parentLi : elm;
517 });
518 return global$7.unique(listItemsElms);
519 };
520 var getSelectedListItems = function (editor) {
521 var selectedBlocks = editor.selection.getSelectedBlocks();
522 return global$5.grep(findParentListItemsNodes(editor, selectedBlocks), function (block) {
523 return NodeType.isListItemNode(block);
524 });
525 };
526 var getSelectedDlItems = function (editor) {
527 return filter(getSelectedListItems(editor), NodeType.isDlItemNode);
528 };
529 var getClosestListRootElm = function (editor, elm) {
530 var parentTableCell = editor.dom.getParents(elm, 'TD,TH');
531 var root = parentTableCell.length > 0 ? parentTableCell[0] : editor.getBody();
532 return root;
533 };
534 var findLastParentListNode = function (editor, elm) {
535 var parentLists = editor.dom.getParents(elm, 'ol,ul', getClosestListRootElm(editor, elm));
536 return last(parentLists);
537 };
538 var getSelectedLists = function (editor) {
539 var firstList = findLastParentListNode(editor, editor.selection.getStart());
540 var subsequentLists = filter(editor.selection.getSelectedBlocks(), NodeType.isOlUlNode);
541 return firstList.toArray().concat(subsequentLists);
542 };
543 var getSelectedListRoots = function (editor) {
544 var selectedLists = getSelectedLists(editor);
545 return getUniqueListRoots(editor, selectedLists);
546 };
547 var getUniqueListRoots = function (editor, lists) {
548 var listRoots = map(lists, function (list) {
549 return findLastParentListNode(editor, list).getOr(list);
550 });
551 return global$7.unique(listRoots);
552 };
553 var isList = function (editor) {
554 var list = getParentList(editor);
555 return HTMLElement.isPrototypeOf(list);
556 };
557 var Selection = {
558 isList: isList,
559 getParentList: getParentList,
560 getSelectedSubLists: getSelectedSubLists,
561 getSelectedListItems: getSelectedListItems,
562 getClosestListRootElm: getClosestListRootElm,
563 getSelectedDlItems: getSelectedDlItems,
564 getSelectedListRoots: getSelectedListRoots
565 };
566
567 var fromHtml = function (html, scope) {
568 var doc = scope || domGlobals.document;
569 var div = doc.createElement('div');
570 div.innerHTML = html;
571 if (!div.hasChildNodes() || div.childNodes.length > 1) {
572 domGlobals.console.error('HTML does not have a single root node', html);
573 throw new Error('HTML must have a single root node');
574 }
575 return fromDom(div.childNodes[0]);
576 };
577 var fromTag = function (tag, scope) {
578 var doc = scope || domGlobals.document;
579 var node = doc.createElement(tag);
580 return fromDom(node);
581 };
582 var fromText = function (text, scope) {
583 var doc = scope || domGlobals.document;
584 var node = doc.createTextNode(text);
585 return fromDom(node);
586 };
587 var fromDom = function (node) {
588 if (node === null || node === undefined) {
589 throw new Error('Node cannot be null or undefined');
590 }
591 return { dom: constant(node) };
592 };
593 var fromPoint = function (docElm, x, y) {
594 var doc = docElm.dom();
595 return Option.from(doc.elementFromPoint(x, y)).map(fromDom);
596 };
597 var Element = {
598 fromHtml: fromHtml,
599 fromTag: fromTag,
600 fromText: fromText,
601 fromDom: fromDom,
602 fromPoint: fromPoint
603 };
604
605 var lift2 = function (oa, ob, f) {
606 return oa.isSome() && ob.isSome() ? Option.some(f(oa.getOrDie(), ob.getOrDie())) : Option.none();
607 };
608
609 var fromElements = function (elements, scope) {
610 var doc = scope || domGlobals.document;
611 var fragment = doc.createDocumentFragment();
612 each(elements, function (element) {
613 fragment.appendChild(element.dom());
614 });
615 return Element.fromDom(fragment);
616 };
617
618 var Immutable = function () {
619 var fields = [];
620 for (var _i = 0; _i < arguments.length; _i++) {
621 fields[_i] = arguments[_i];
622 }
623 return function () {
624 var values = [];
625 for (var _i = 0; _i < arguments.length; _i++) {
626 values[_i] = arguments[_i];
627 }
628 if (fields.length !== values.length) {
629 throw new Error('Wrong number of arguments to struct. Expected "[' + fields.length + ']", got ' + values.length + ' arguments');
630 }
631 var struct = {};
632 each(fields, function (name, i) {
633 struct[name] = constant(values[i]);
634 });
635 return struct;
636 };
637 };
638
639 var keys = Object.keys;
640 var each$1 = function (obj, f) {
641 var props = keys(obj);
642 for (var k = 0, len = props.length; k < len; k++) {
643 var i = props[k];
644 var x = obj[i];
645 f(x, i);
646 }
647 };
648
649 var node = function () {
650 var f = Global$1.getOrDie('Node');
651 return f;
652 };
653 var compareDocumentPosition = function (a, b, match) {
654 return (a.compareDocumentPosition(b) & match) !== 0;
655 };
656 var documentPositionPreceding = function (a, b) {
657 return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_PRECEDING);
658 };
659 var documentPositionContainedBy = function (a, b) {
660 return compareDocumentPosition(a, b, node().DOCUMENT_POSITION_CONTAINED_BY);
661 };
662 var Node = {
663 documentPositionPreceding: documentPositionPreceding,
664 documentPositionContainedBy: documentPositionContainedBy
665 };
666
667 var cached = function (f) {
668 var called = false;
669 var r;
670 return function () {
671 var args = [];
672 for (var _i = 0; _i < arguments.length; _i++) {
673 args[_i] = arguments[_i];
674 }
675 if (!called) {
676 called = true;
677 r = f.apply(null, args);
678 }
679 return r;
680 };
681 };
682
683 var firstMatch = function (regexes, s) {
684 for (var i = 0; i < regexes.length; i++) {
685 var x = regexes[i];
686 if (x.test(s)) {
687 return x;
688 }
689 }
690 return undefined;
691 };
692 var find$1 = function (regexes, agent) {
693 var r = firstMatch(regexes, agent);
694 if (!r) {
695 return {
696 major: 0,
697 minor: 0
698 };
699 }
700 var group = function (i) {
701 return Number(agent.replace(r, '$' + i));
702 };
703 return nu(group(1), group(2));
704 };
705 var detect = function (versionRegexes, agent) {
706 var cleanedAgent = String(agent).toLowerCase();
707 if (versionRegexes.length === 0) {
708 return unknown();
709 }
710 return find$1(versionRegexes, cleanedAgent);
711 };
712 var unknown = function () {
713 return nu(0, 0);
714 };
715 var nu = function (major, minor) {
716 return {
717 major: major,
718 minor: minor
719 };
720 };
721 var Version = {
722 nu: nu,
723 detect: detect,
724 unknown: unknown
725 };
726
727 var edge = 'Edge';
728 var chrome = 'Chrome';
729 var ie = 'IE';
730 var opera = 'Opera';
731 var firefox = 'Firefox';
732 var safari = 'Safari';
733 var isBrowser = function (name, current) {
734 return function () {
735 return current === name;
736 };
737 };
738 var unknown$1 = function () {
739 return nu$1({
740 current: undefined,
741 version: Version.unknown()
742 });
743 };
744 var nu$1 = function (info) {
745 var current = info.current;
746 var version = info.version;
747 return {
748 current: current,
749 version: version,
750 isEdge: isBrowser(edge, current),
751 isChrome: isBrowser(chrome, current),
752 isIE: isBrowser(ie, current),
753 isOpera: isBrowser(opera, current),
754 isFirefox: isBrowser(firefox, current),
755 isSafari: isBrowser(safari, current)
756 };
757 };
758 var Browser = {
759 unknown: unknown$1,
760 nu: nu$1,
761 edge: constant(edge),
762 chrome: constant(chrome),
763 ie: constant(ie),
764 opera: constant(opera),
765 firefox: constant(firefox),
766 safari: constant(safari)
767 };
768
769 var windows = 'Windows';
770 var ios = 'iOS';
771 var android = 'Android';
772 var linux = 'Linux';
773 var osx = 'OSX';
774 var solaris = 'Solaris';
775 var freebsd = 'FreeBSD';
776 var isOS = function (name, current) {
777 return function () {
778 return current === name;
779 };
780 };
781 var unknown$2 = function () {
782 return nu$2({
783 current: undefined,
784 version: Version.unknown()
785 });
786 };
787 var nu$2 = function (info) {
788 var current = info.current;
789 var version = info.version;
790 return {
791 current: current,
792 version: version,
793 isWindows: isOS(windows, current),
794 isiOS: isOS(ios, current),
795 isAndroid: isOS(android, current),
796 isOSX: isOS(osx, current),
797 isLinux: isOS(linux, current),
798 isSolaris: isOS(solaris, current),
799 isFreeBSD: isOS(freebsd, current)
800 };
801 };
802 var OperatingSystem = {
803 unknown: unknown$2,
804 nu: nu$2,
805 windows: constant(windows),
806 ios: constant(ios),
807 android: constant(android),
808 linux: constant(linux),
809 osx: constant(osx),
810 solaris: constant(solaris),
811 freebsd: constant(freebsd)
812 };
813
814 var DeviceType = function (os, browser, userAgent) {
815 var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
816 var isiPhone = os.isiOS() && !isiPad;
817 var isAndroid3 = os.isAndroid() && os.version.major === 3;
818 var isAndroid4 = os.isAndroid() && os.version.major === 4;
819 var isTablet = isiPad || isAndroid3 || isAndroid4 && /mobile/i.test(userAgent) === true;
820 var isTouch = os.isiOS() || os.isAndroid();
821 var isPhone = isTouch && !isTablet;
822 var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
823 return {
824 isiPad: constant(isiPad),
825 isiPhone: constant(isiPhone),
826 isTablet: constant(isTablet),
827 isPhone: constant(isPhone),
828 isTouch: constant(isTouch),
829 isAndroid: os.isAndroid,
830 isiOS: os.isiOS,
831 isWebView: constant(iOSwebview)
832 };
833 };
834
835 var detect$1 = function (candidates, userAgent) {
836 var agent = String(userAgent).toLowerCase();
837 return find(candidates, function (candidate) {
838 return candidate.search(agent);
839 });
840 };
841 var detectBrowser = function (browsers, userAgent) {
842 return detect$1(browsers, userAgent).map(function (browser) {
843 var version = Version.detect(browser.versionRegexes, userAgent);
844 return {
845 current: browser.name,
846 version: version
847 };
848 });
849 };
850 var detectOs = function (oses, userAgent) {
851 return detect$1(oses, userAgent).map(function (os) {
852 var version = Version.detect(os.versionRegexes, userAgent);
853 return {
854 current: os.name,
855 version: version
856 };
857 });
858 };
859 var UaString = {
860 detectBrowser: detectBrowser,
861 detectOs: detectOs
862 };
863
864 var contains = function (str, substr) {
865 return str.indexOf(substr) !== -1;
866 };
867
868 var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
869 var checkContains = function (target) {
870 return function (uastring) {
871 return contains(uastring, target);
872 };
873 };
874 var browsers = [
875 {
876 name: 'Edge',
877 versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
878 search: function (uastring) {
879 return contains(uastring, 'edge/') && contains(uastring, 'chrome') && contains(uastring, 'safari') && contains(uastring, 'applewebkit');
880 }
881 },
882 {
883 name: 'Chrome',
884 versionRegexes: [
885 /.*?chrome\/([0-9]+)\.([0-9]+).*/,
886 normalVersionRegex
887 ],
888 search: function (uastring) {
889 return contains(uastring, 'chrome') && !contains(uastring, 'chromeframe');
890 }
891 },
892 {
893 name: 'IE',
894 versionRegexes: [
895 /.*?msie\ ?([0-9]+)\.([0-9]+).*/,
896 /.*?rv:([0-9]+)\.([0-9]+).*/
897 ],
898 search: function (uastring) {
899 return contains(uastring, 'msie') || contains(uastring, 'trident');
900 }
901 },
902 {
903 name: 'Opera',
904 versionRegexes: [
905 normalVersionRegex,
906 /.*?opera\/([0-9]+)\.([0-9]+).*/
907 ],
908 search: checkContains('opera')
909 },
910 {
911 name: 'Firefox',
912 versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
913 search: checkContains('firefox')
914 },
915 {
916 name: 'Safari',
917 versionRegexes: [
918 normalVersionRegex,
919 /.*?cpu os ([0-9]+)_([0-9]+).*/
920 ],
921 search: function (uastring) {
922 return (contains(uastring, 'safari') || contains(uastring, 'mobile/')) && contains(uastring, 'applewebkit');
923 }
924 }
925 ];
926 var oses = [
927 {
928 name: 'Windows',
929 search: checkContains('win'),
930 versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
931 },
932 {
933 name: 'iOS',
934 search: function (uastring) {
935 return contains(uastring, 'iphone') || contains(uastring, 'ipad');
936 },
937 versionRegexes: [
938 /.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
939 /.*cpu os ([0-9]+)_([0-9]+).*/,
940 /.*cpu iphone os ([0-9]+)_([0-9]+).*/
941 ]
942 },
943 {
944 name: 'Android',
945 search: checkContains('android'),
946 versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
947 },
948 {
949 name: 'OSX',
950 search: checkContains('os x'),
951 versionRegexes: [/.*?os\ x\ ?([0-9]+)_([0-9]+).*/]
952 },
953 {
954 name: 'Linux',
955 search: checkContains('linux'),
956 versionRegexes: []
957 },
958 {
959 name: 'Solaris',
960 search: checkContains('sunos'),
961 versionRegexes: []
962 },
963 {
964 name: 'FreeBSD',
965 search: checkContains('freebsd'),
966 versionRegexes: []
967 }
968 ];
969 var PlatformInfo = {
970 browsers: constant(browsers),
971 oses: constant(oses)
972 };
973
974 var detect$2 = function (userAgent) {
975 var browsers = PlatformInfo.browsers();
976 var oses = PlatformInfo.oses();
977 var browser = UaString.detectBrowser(browsers, userAgent).fold(Browser.unknown, Browser.nu);
978 var os = UaString.detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
979 var deviceType = DeviceType(os, browser, userAgent);
980 return {
981 browser: browser,
982 os: os,
983 deviceType: deviceType
984 };
985 };
986 var PlatformDetection = { detect: detect$2 };
987
988 var detect$3 = cached(function () {
989 var userAgent = domGlobals.navigator.userAgent;
990 return PlatformDetection.detect(userAgent);
991 });
992 var PlatformDetection$1 = { detect: detect$3 };
993
994 var ATTRIBUTE = domGlobals.Node.ATTRIBUTE_NODE;
995 var CDATA_SECTION = domGlobals.Node.CDATA_SECTION_NODE;
996 var COMMENT = domGlobals.Node.COMMENT_NODE;
997 var DOCUMENT = domGlobals.Node.DOCUMENT_NODE;
998 var DOCUMENT_TYPE = domGlobals.Node.DOCUMENT_TYPE_NODE;
999 var DOCUMENT_FRAGMENT = domGlobals.Node.DOCUMENT_FRAGMENT_NODE;
1000 var ELEMENT = domGlobals.Node.ELEMENT_NODE;
1001 var TEXT = domGlobals.Node.TEXT_NODE;
1002 var PROCESSING_INSTRUCTION = domGlobals.Node.PROCESSING_INSTRUCTION_NODE;
1003 var ENTITY_REFERENCE = domGlobals.Node.ENTITY_REFERENCE_NODE;
1004 var ENTITY = domGlobals.Node.ENTITY_NODE;
1005 var NOTATION = domGlobals.Node.NOTATION_NODE;
1006
1007 var ELEMENT$1 = ELEMENT;
1008 var is = function (element, selector) {
1009 var dom = element.dom();
1010 if (dom.nodeType !== ELEMENT$1) {
1011 return false;
1012 } else {
1013 var elem = dom;
1014 if (elem.matches !== undefined) {
1015 return elem.matches(selector);
1016 } else if (elem.msMatchesSelector !== undefined) {
1017 return elem.msMatchesSelector(selector);
1018 } else if (elem.webkitMatchesSelector !== undefined) {
1019 return elem.webkitMatchesSelector(selector);
1020 } else if (elem.mozMatchesSelector !== undefined) {
1021 return elem.mozMatchesSelector(selector);
1022 } else {
1023 throw new Error('Browser lacks native selectors');
1024 }
1025 }
1026 };
1027
1028 var eq = function (e1, e2) {
1029 return e1.dom() === e2.dom();
1030 };
1031 var regularContains = function (e1, e2) {
1032 var d1 = e1.dom();
1033 var d2 = e2.dom();
1034 return d1 === d2 ? false : d1.contains(d2);
1035 };
1036 var ieContains = function (e1, e2) {
1037 return Node.documentPositionContainedBy(e1.dom(), e2.dom());
1038 };
1039 var browser = PlatformDetection$1.detect().browser;
1040 var contains$1 = browser.isIE() ? ieContains : regularContains;
1041 var is$1 = is;
1042
1043 var parent = function (element) {
1044 return Option.from(element.dom().parentNode).map(Element.fromDom);
1045 };
1046 var children = function (element) {
1047 return map(element.dom().childNodes, Element.fromDom);
1048 };
1049 var child = function (element, index) {
1050 var cs = element.dom().childNodes;
1051 return Option.from(cs[index]).map(Element.fromDom);
1052 };
1053 var firstChild = function (element) {
1054 return child(element, 0);
1055 };
1056 var lastChild = function (element) {
1057 return child(element, element.dom().childNodes.length - 1);
1058 };
1059 var spot = Immutable('element', 'offset');
1060
1061 var before = function (marker, element) {
1062 var parent$1 = parent(marker);
1063 parent$1.each(function (v) {
1064 v.dom().insertBefore(element.dom(), marker.dom());
1065 });
1066 };
1067 var append = function (parent, element) {
1068 parent.dom().appendChild(element.dom());
1069 };
1070
1071 var before$1 = function (marker, elements) {
1072 each(elements, function (x) {
1073 before(marker, x);
1074 });
1075 };
1076 var append$1 = function (parent, elements) {
1077 each(elements, function (x) {
1078 append(parent, x);
1079 });
1080 };
1081
1082 var remove = function (element) {
1083 var dom = element.dom();
1084 if (dom.parentNode !== null) {
1085 dom.parentNode.removeChild(dom);
1086 }
1087 };
1088
1089 var name = function (element) {
1090 var r = element.dom().nodeName;
1091 return r.toLowerCase();
1092 };
1093 var type = function (element) {
1094 return element.dom().nodeType;
1095 };
1096 var isType$1 = function (t) {
1097 return function (element) {
1098 return type(element) === t;
1099 };
1100 };
1101 var isElement = isType$1(ELEMENT);
1102
1103 var rawSet = function (dom, key, value) {
1104 if (isString(value) || isBoolean(value) || isNumber(value)) {
1105 dom.setAttribute(key, value + '');
1106 } else {
1107 domGlobals.console.error('Invalid call to Attr.set. Key ', key, ':: Value ', value, ':: Element ', dom);
1108 throw new Error('Attribute value was not simple');
1109 }
1110 };
1111 var setAll = function (element, attrs) {
1112 var dom = element.dom();
1113 each$1(attrs, function (v, k) {
1114 rawSet(dom, k, v);
1115 });
1116 };
1117 var clone = function (element) {
1118 return foldl(element.dom().attributes, function (acc, attr) {
1119 acc[attr.name] = attr.value;
1120 return acc;
1121 }, {});
1122 };
1123
1124 var isSupported = function (dom) {
1125 return dom.style !== undefined && isFunction(dom.style.getPropertyValue);
1126 };
1127
1128 var internalSet = function (dom, property, value) {
1129 if (!isString(value)) {
1130 domGlobals.console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom);
1131 throw new Error('CSS value must be a string: ' + value);
1132 }
1133 if (isSupported(dom)) {
1134 dom.style.setProperty(property, value);
1135 }
1136 };
1137 var set = function (element, property, value) {
1138 var dom = element.dom();
1139 internalSet(dom, property, value);
1140 };
1141
1142 var clone$1 = function (original, isDeep) {
1143 return Element.fromDom(original.dom().cloneNode(isDeep));
1144 };
1145 var deep = function (original) {
1146 return clone$1(original, true);
1147 };
1148 var shallowAs = function (original, tag) {
1149 var nu = Element.fromTag(tag);
1150 var attributes = clone(original);
1151 setAll(nu, attributes);
1152 return nu;
1153 };
1154 var mutate = function (original, tag) {
1155 var nu = shallowAs(original, tag);
1156 before(original, nu);
1157 var children$1 = children(original);
1158 append$1(nu, children$1);
1159 remove(original);
1160 return nu;
1161 };
1162
1163 var joinSegment = function (parent, child) {
1164 append(parent.item, child.list);
1165 };
1166 var joinSegments = function (segments) {
1167 for (var i = 1; i < segments.length; i++) {
1168 joinSegment(segments[i - 1], segments[i]);
1169 }
1170 };
1171 var appendSegments = function (head$1, tail) {
1172 lift2(last(head$1), head(tail), joinSegment);
1173 };
1174 var createSegment = function (scope, listType) {
1175 var segment = {
1176 list: Element.fromTag(listType, scope),
1177 item: Element.fromTag('li', scope)
1178 };
1179 append(segment.list, segment.item);
1180 return segment;
1181 };
1182 var createSegments = function (scope, entry, size) {
1183 var segments = [];
1184 for (var i = 0; i < size; i++) {
1185 segments.push(createSegment(scope, entry.listType));
1186 }
1187 return segments;
1188 };
1189 var populateSegments = function (segments, entry) {
1190 for (var i = 0; i < segments.length - 1; i++) {
1191 set(segments[i].item, 'list-style-type', 'none');
1192 }
1193 last(segments).each(function (segment) {
1194 setAll(segment.list, entry.listAttributes);
1195 setAll(segment.item, entry.itemAttributes);
1196 append$1(segment.item, entry.content);
1197 });
1198 };
1199 var normalizeSegment = function (segment, entry) {
1200 if (name(segment.list) !== entry.listType) {
1201 segment.list = mutate(segment.list, entry.listType);
1202 }
1203 setAll(segment.list, entry.listAttributes);
1204 };
1205 var createItem = function (scope, attr, content) {
1206 var item = Element.fromTag('li', scope);
1207 setAll(item, attr);
1208 append$1(item, content);
1209 return item;
1210 };
1211 var appendItem = function (segment, item) {
1212 append(segment.list, item);
1213 segment.item = item;
1214 };
1215 var writeShallow = function (scope, cast, entry) {
1216 var newCast = cast.slice(0, entry.depth);
1217 last(newCast).each(function (segment) {
1218 var item = createItem(scope, entry.itemAttributes, entry.content);
1219 appendItem(segment, item);
1220 normalizeSegment(segment, entry);
1221 });
1222 return newCast;
1223 };
1224 var writeDeep = function (scope, cast, entry) {
1225 var segments = createSegments(scope, entry, entry.depth - cast.length);
1226 joinSegments(segments);
1227 populateSegments(segments, entry);
1228 appendSegments(cast, segments);
1229 return cast.concat(segments);
1230 };
1231 var composeList = function (scope, entries) {
1232 var cast = foldl(entries, function (cast, entry) {
1233 return entry.depth > cast.length ? writeDeep(scope, cast, entry) : writeShallow(scope, cast, entry);
1234 }, []);
1235 return head(cast).map(function (segment) {
1236 return segment.list;
1237 });
1238 };
1239
1240 var isList$1 = function (el) {
1241 return is$1(el, 'OL,UL');
1242 };
1243 var hasFirstChildList = function (el) {
1244 return firstChild(el).map(isList$1).getOr(false);
1245 };
1246 var hasLastChildList = function (el) {
1247 return lastChild(el).map(isList$1).getOr(false);
1248 };
1249
1250 var isIndented = function (entry) {
1251 return entry.depth > 0;
1252 };
1253 var isSelected = function (entry) {
1254 return entry.isSelected;
1255 };
1256 var cloneItemContent = function (li) {
1257 var children$1 = children(li);
1258 var content = hasLastChildList(li) ? children$1.slice(0, -1) : children$1;
1259 return map(content, deep);
1260 };
1261 var createEntry = function (li, depth, isSelected) {
1262 return parent(li).filter(isElement).map(function (list) {
1263 return {
1264 depth: depth,
1265 isSelected: isSelected,
1266 content: cloneItemContent(li),
1267 itemAttributes: clone(li),
1268 listAttributes: clone(list),
1269 listType: name(list)
1270 };
1271 });
1272 };
1273
1274 var indentEntry = function (indentation, entry) {
1275 switch (indentation) {
1276 case 'Indent':
1277 entry.depth++;
1278 break;
1279 case 'Outdent':
1280 entry.depth--;
1281 break;
1282 case 'Flatten':
1283 entry.depth = 0;
1284 }
1285 };
1286
1287 var hasOwnProperty = Object.prototype.hasOwnProperty;
1288 var shallow = function (old, nu) {
1289 return nu;
1290 };
1291 var baseMerge = function (merger) {
1292 return function () {
1293 var objects = new Array(arguments.length);
1294 for (var i = 0; i < objects.length; i++) {
1295 objects[i] = arguments[i];
1296 }
1297 if (objects.length === 0) {
1298 throw new Error('Can\'t merge zero objects');
1299 }
1300 var ret = {};
1301 for (var j = 0; j < objects.length; j++) {
1302 var curObject = objects[j];
1303 for (var key in curObject) {
1304 if (hasOwnProperty.call(curObject, key)) {
1305 ret[key] = merger(ret[key], curObject[key]);
1306 }
1307 }
1308 }
1309 return ret;
1310 };
1311 };
1312 var merge = baseMerge(shallow);
1313
1314 var cloneListProperties = function (target, source) {
1315 target.listType = source.listType;
1316 target.listAttributes = merge({}, source.listAttributes);
1317 };
1318 var previousSiblingEntry = function (entries, start) {
1319 var depth = entries[start].depth;
1320 for (var i = start - 1; i >= 0; i--) {
1321 if (entries[i].depth === depth) {
1322 return Option.some(entries[i]);
1323 }
1324 if (entries[i].depth < depth) {
1325 break;
1326 }
1327 }
1328 return Option.none();
1329 };
1330 var normalizeEntries = function (entries) {
1331 each(entries, function (entry, i) {
1332 previousSiblingEntry(entries, i).each(function (matchingEntry) {
1333 cloneListProperties(entry, matchingEntry);
1334 });
1335 });
1336 };
1337
1338 var Cell = function (initial) {
1339 var value = initial;
1340 var get = function () {
1341 return value;
1342 };
1343 var set = function (v) {
1344 value = v;
1345 };
1346 var clone = function () {
1347 return Cell(get());
1348 };
1349 return {
1350 get: get,
1351 set: set,
1352 clone: clone
1353 };
1354 };
1355
1356 var parseItem = function (depth, itemSelection, selectionState, item) {
1357 return firstChild(item).filter(isList$1).fold(function () {
1358 itemSelection.each(function (selection) {
1359 if (eq(selection.start, item)) {
1360 selectionState.set(true);
1361 }
1362 });
1363 var currentItemEntry = createEntry(item, depth, selectionState.get());
1364 itemSelection.each(function (selection) {
1365 if (eq(selection.end, item)) {
1366 selectionState.set(false);
1367 }
1368 });
1369 var childListEntries = lastChild(item).filter(isList$1).map(function (list) {
1370 return parseList(depth, itemSelection, selectionState, list);
1371 }).getOr([]);
1372 return currentItemEntry.toArray().concat(childListEntries);
1373 }, function (list) {
1374 return parseList(depth, itemSelection, selectionState, list);
1375 });
1376 };
1377 var parseList = function (depth, itemSelection, selectionState, list) {
1378 return bind(children(list), function (element) {
1379 var parser = isList$1(element) ? parseList : parseItem;
1380 var newDepth = depth + 1;
1381 return parser(newDepth, itemSelection, selectionState, element);
1382 });
1383 };
1384 var parseLists = function (lists, itemSelection) {
1385 var selectionState = Cell(false);
1386 var initialDepth = 0;
1387 return map(lists, function (list) {
1388 return {
1389 sourceList: list,
1390 entries: parseList(initialDepth, itemSelection, selectionState, list)
1391 };
1392 });
1393 };
1394
1395 var global$8 = tinymce.util.Tools.resolve('tinymce.Env');
1396
1397 var createTextBlock = function (editor, contentNode) {
1398 var dom = editor.dom;
1399 var blockElements = editor.schema.getBlockElements();
1400 var fragment = dom.createFragment();
1401 var node, textBlock, blockName, hasContentNode;
1402 if (editor.settings.forced_root_block) {
1403 blockName = editor.settings.forced_root_block;
1404 }
1405 if (blockName) {
1406 textBlock = dom.create(blockName);
1407 if (textBlock.tagName === editor.settings.forced_root_block) {
1408 dom.setAttribs(textBlock, editor.settings.forced_root_block_attrs);
1409 }
1410 if (!NodeType.isBlock(contentNode.firstChild, blockElements)) {
1411 fragment.appendChild(textBlock);
1412 }
1413 }
1414 if (contentNode) {
1415 while (node = contentNode.firstChild) {
1416 var nodeName = node.nodeName;
1417 if (!hasContentNode && (nodeName !== 'SPAN' || node.getAttribute('data-mce-type') !== 'bookmark')) {
1418 hasContentNode = true;
1419 }
1420 if (NodeType.isBlock(node, blockElements)) {
1421 fragment.appendChild(node);
1422 textBlock = null;
1423 } else {
1424 if (blockName) {
1425 if (!textBlock) {
1426 textBlock = dom.create(blockName);
1427 fragment.appendChild(textBlock);
1428 }
1429 textBlock.appendChild(node);
1430 } else {
1431 fragment.appendChild(node);
1432 }
1433 }
1434 }
1435 }
1436 if (!editor.settings.forced_root_block) {
1437 fragment.appendChild(dom.create('br'));
1438 } else {
1439 if (!hasContentNode && (!global$8.ie || global$8.ie > 10)) {
1440 textBlock.appendChild(dom.create('br', { 'data-mce-bogus': '1' }));
1441 }
1442 }
1443 return fragment;
1444 };
1445
1446 var outdentedComposer = function (editor, entries) {
1447 return map(entries, function (entry) {
1448 var content = fromElements(entry.content);
1449 return Element.fromDom(createTextBlock(editor, content.dom()));
1450 });
1451 };
1452 var indentedComposer = function (editor, entries) {
1453 normalizeEntries(entries);
1454 return composeList(editor.contentDocument, entries).toArray();
1455 };
1456 var composeEntries = function (editor, entries) {
1457 return bind(groupBy(entries, isIndented), function (entries) {
1458 var groupIsIndented = head(entries).map(isIndented).getOr(false);
1459 return groupIsIndented ? indentedComposer(editor, entries) : outdentedComposer(editor, entries);
1460 });
1461 };
1462 var indentSelectedEntries = function (entries, indentation) {
1463 each(filter(entries, isSelected), function (entry) {
1464 return indentEntry(indentation, entry);
1465 });
1466 };
1467 var getItemSelection = function (editor) {
1468 var selectedListItems = map(Selection.getSelectedListItems(editor), Element.fromDom);
1469 return lift2(find(selectedListItems, not(hasFirstChildList)), find(reverse(selectedListItems), not(hasFirstChildList)), function (start, end) {
1470 return {
1471 start: start,
1472 end: end
1473 };
1474 });
1475 };
1476 var listsIndentation = function (editor, lists, indentation) {
1477 var entrySets = parseLists(lists, getItemSelection(editor));
1478 each(entrySets, function (entrySet) {
1479 indentSelectedEntries(entrySet.entries, indentation);
1480 before$1(entrySet.sourceList, composeEntries(editor, entrySet.entries));
1481 remove(entrySet.sourceList);
1482 });
1483 };
1484
1485 var DOM$1 = global$6.DOM;
1486 var splitList = function (editor, ul, li) {
1487 var tmpRng, fragment, bookmarks, node, newBlock;
1488 var removeAndKeepBookmarks = function (targetNode) {
1489 global$5.each(bookmarks, function (node) {
1490 targetNode.parentNode.insertBefore(node, li.parentNode);
1491 });
1492 DOM$1.remove(targetNode);
1493 };
1494 bookmarks = DOM$1.select('span[data-mce-type="bookmark"]', ul);
1495 newBlock = createTextBlock(editor, li);
1496 tmpRng = DOM$1.createRng();
1497 tmpRng.setStartAfter(li);
1498 tmpRng.setEndAfter(ul);
1499 fragment = tmpRng.extractContents();
1500 for (node = fragment.firstChild; node; node = node.firstChild) {
1501 if (node.nodeName === 'LI' && editor.dom.isEmpty(node)) {
1502 DOM$1.remove(node);
1503 break;
1504 }
1505 }
1506 if (!editor.dom.isEmpty(fragment)) {
1507 DOM$1.insertAfter(fragment, ul);
1508 }
1509 DOM$1.insertAfter(newBlock, ul);
1510 if (NodeType.isEmpty(editor.dom, li.parentNode)) {
1511 removeAndKeepBookmarks(li.parentNode);
1512 }
1513 DOM$1.remove(li);
1514 if (NodeType.isEmpty(editor.dom, ul)) {
1515 DOM$1.remove(ul);
1516 }
1517 };
1518 var SplitList = { splitList: splitList };
1519
1520 var outdentDlItem = function (editor, item) {
1521 if (is$1(item, 'dd')) {
1522 mutate(item, 'dt');
1523 } else if (is$1(item, 'dt')) {
1524 parent(item).each(function (dl) {
1525 return SplitList.splitList(editor, dl.dom(), item.dom());
1526 });
1527 }
1528 };
1529 var indentDlItem = function (item) {
1530 if (is$1(item, 'dt')) {
1531 mutate(item, 'dd');
1532 }
1533 };
1534 var dlIndentation = function (editor, indentation, dlItems) {
1535 if (indentation === 'Indent') {
1536 each(dlItems, indentDlItem);
1537 } else {
1538 each(dlItems, function (item) {
1539 return outdentDlItem(editor, item);
1540 });
1541 }
1542 };
1543
1544 var selectionIndentation = function (editor, indentation) {
1545 var lists = map(Selection.getSelectedListRoots(editor), Element.fromDom);
1546 var dlItems = map(Selection.getSelectedDlItems(editor), Element.fromDom);
1547 var isHandled = false;
1548 if (lists.length || dlItems.length) {
1549 var bookmark = editor.selection.getBookmark();
1550 listsIndentation(editor, lists, indentation);
1551 dlIndentation(editor, indentation, dlItems);
1552 editor.selection.moveToBookmark(bookmark);
1553 editor.selection.setRng(Range.normalizeRange(editor.selection.getRng()));
1554 editor.nodeChanged();
1555 isHandled = true;
1556 }
1557 return isHandled;
1558 };
1559 var indentListSelection = function (editor) {
1560 return selectionIndentation(editor, 'Indent');
1561 };
1562 var outdentListSelection = function (editor) {
1563 return selectionIndentation(editor, 'Outdent');
1564 };
1565 var flattenListSelection = function (editor) {
1566 return selectionIndentation(editor, 'Flatten');
1567 };
1568
1569 var updateListStyle = function (dom, el, detail) {
1570 var type = detail['list-style-type'] ? detail['list-style-type'] : null;
1571 dom.setStyle(el, 'list-style-type', type);
1572 };
1573 var setAttribs = function (elm, attrs) {
1574 global$5.each(attrs, function (value, key) {
1575 elm.setAttribute(key, value);
1576 });
1577 };
1578 var updateListAttrs = function (dom, el, detail) {
1579 setAttribs(el, detail['list-attributes']);
1580 global$5.each(dom.select('li', el), function (li) {
1581 setAttribs(li, detail['list-item-attributes']);
1582 });
1583 };
1584 var updateListWithDetails = function (dom, el, detail) {
1585 updateListStyle(dom, el, detail);
1586 updateListAttrs(dom, el, detail);
1587 };
1588 var removeStyles = function (dom, element, styles) {
1589 global$5.each(styles, function (style) {
1590 var _a;
1591 return dom.setStyle(element, (_a = {}, _a[style] = '', _a));
1592 });
1593 };
1594 var getEndPointNode = function (editor, rng, start, root) {
1595 var container, offset;
1596 container = rng[start ? 'startContainer' : 'endContainer'];
1597 offset = rng[start ? 'startOffset' : 'endOffset'];
1598 if (container.nodeType === 1) {
1599 container = container.childNodes[Math.min(offset, container.childNodes.length - 1)] || container;
1600 }
1601 if (!start && NodeType.isBr(container.nextSibling)) {
1602 container = container.nextSibling;
1603 }
1604 while (container.parentNode !== root) {
1605 if (NodeType.isTextBlock(editor, container)) {
1606 return container;
1607 }
1608 if (/^(TD|TH)$/.test(container.parentNode.nodeName)) {
1609 return container;
1610 }
1611 container = container.parentNode;
1612 }
1613 return container;
1614 };
1615 var getSelectedTextBlocks = function (editor, rng, root) {
1616 var textBlocks = [], dom = editor.dom;
1617 var startNode = getEndPointNode(editor, rng, true, root);
1618 var endNode = getEndPointNode(editor, rng, false, root);
1619 var block;
1620 var siblings = [];
1621 for (var node = startNode; node; node = node.nextSibling) {
1622 siblings.push(node);
1623 if (node === endNode) {
1624 break;
1625 }
1626 }
1627 global$5.each(siblings, function (node) {
1628 if (NodeType.isTextBlock(editor, node)) {
1629 textBlocks.push(node);
1630 block = null;
1631 return;
1632 }
1633 if (dom.isBlock(node) || NodeType.isBr(node)) {
1634 if (NodeType.isBr(node)) {
1635 dom.remove(node);
1636 }
1637 block = null;
1638 return;
1639 }
1640 var nextSibling = node.nextSibling;
1641 if (global$4.isBookmarkNode(node)) {
1642 if (NodeType.isTextBlock(editor, nextSibling) || !nextSibling && node.parentNode === root) {
1643 block = null;
1644 return;
1645 }
1646 }
1647 if (!block) {
1648 block = dom.create('p');
1649 node.parentNode.insertBefore(block, node);
1650 textBlocks.push(block);
1651 }
1652 block.appendChild(node);
1653 });
1654 return textBlocks;
1655 };
1656 var hasCompatibleStyle = function (dom, sib, detail) {
1657 var sibStyle = dom.getStyle(sib, 'list-style-type');
1658 var detailStyle = detail ? detail['list-style-type'] : '';
1659 detailStyle = detailStyle === null ? '' : detailStyle;
1660 return sibStyle === detailStyle;
1661 };
1662 var applyList = function (editor, listName, detail) {
1663 if (detail === void 0) {
1664 detail = {};
1665 }
1666 var rng = editor.selection.getRng(true);
1667 var bookmark;
1668 var listItemName = 'LI';
1669 var root = Selection.getClosestListRootElm(editor, editor.selection.getStart(true));
1670 var dom = editor.dom;
1671 if (dom.getContentEditable(editor.selection.getNode()) === 'false') {
1672 return;
1673 }
1674 listName = listName.toUpperCase();
1675 if (listName === 'DL') {
1676 listItemName = 'DT';
1677 }
1678 bookmark = Bookmark.createBookmark(rng);
1679 global$5.each(getSelectedTextBlocks(editor, rng, root), function (block) {
1680 var listBlock, sibling;
1681 sibling = block.previousSibling;
1682 if (sibling && NodeType.isListNode(sibling) && sibling.nodeName === listName && hasCompatibleStyle(dom, sibling, detail)) {
1683 listBlock = sibling;
1684 block = dom.rename(block, listItemName);
1685 sibling.appendChild(block);
1686 } else {
1687 listBlock = dom.create(listName);
1688 block.parentNode.insertBefore(listBlock, block);
1689 listBlock.appendChild(block);
1690 block = dom.rename(block, listItemName);
1691 }
1692 removeStyles(dom, block, [
1693 'margin',
1694 'margin-right',
1695 'margin-bottom',
1696 'margin-left',
1697 'margin-top',
1698 'padding',
1699 'padding-right',
1700 'padding-bottom',
1701 'padding-left',
1702 'padding-top'
1703 ]);
1704 updateListWithDetails(dom, listBlock, detail);
1705 mergeWithAdjacentLists(editor.dom, listBlock);
1706 });
1707 editor.selection.setRng(Bookmark.resolveBookmark(bookmark));
1708 };
1709 var isValidLists = function (list1, list2) {
1710 return list1 && list2 && NodeType.isListNode(list1) && list1.nodeName === list2.nodeName;
1711 };
1712 var hasSameListStyle = function (dom, list1, list2) {
1713 var targetStyle = dom.getStyle(list1, 'list-style-type', true);
1714 var style = dom.getStyle(list2, 'list-style-type', true);
1715 return targetStyle === style;
1716 };
1717 var hasSameClasses = function (elm1, elm2) {
1718 return elm1.className === elm2.className;
1719 };
1720 var shouldMerge = function (dom, list1, list2) {
1721 return isValidLists(list1, list2) && hasSameListStyle(dom, list1, list2) && hasSameClasses(list1, list2);
1722 };
1723 var mergeWithAdjacentLists = function (dom, listBlock) {
1724 var sibling, node;
1725 sibling = listBlock.nextSibling;
1726 if (shouldMerge(dom, listBlock, sibling)) {
1727 while (node = sibling.firstChild) {
1728 listBlock.appendChild(node);
1729 }
1730 dom.remove(sibling);
1731 }
1732 sibling = listBlock.previousSibling;
1733 if (shouldMerge(dom, listBlock, sibling)) {
1734 while (node = sibling.lastChild) {
1735 listBlock.insertBefore(node, listBlock.firstChild);
1736 }
1737 dom.remove(sibling);
1738 }
1739 };
1740 var updateList = function (dom, list, listName, detail) {
1741 if (list.nodeName !== listName) {
1742 var newList = dom.rename(list, listName);
1743 updateListWithDetails(dom, newList, detail);
1744 } else {
1745 updateListWithDetails(dom, list, detail);
1746 }
1747 };
1748 var toggleMultipleLists = function (editor, parentList, lists, listName, detail) {
1749 if (parentList.nodeName === listName && !hasListStyleDetail(detail)) {
1750 flattenListSelection(editor);
1751 } else {
1752 var bookmark = Bookmark.createBookmark(editor.selection.getRng(true));
1753 global$5.each([parentList].concat(lists), function (elm) {
1754 updateList(editor.dom, elm, listName, detail);
1755 });
1756 editor.selection.setRng(Bookmark.resolveBookmark(bookmark));
1757 }
1758 };
1759 var hasListStyleDetail = function (detail) {
1760 return 'list-style-type' in detail;
1761 };
1762 var toggleSingleList = function (editor, parentList, listName, detail) {
1763 if (parentList === editor.getBody()) {
1764 return;
1765 }
1766 if (parentList) {
1767 if (parentList.nodeName === listName && !hasListStyleDetail(detail)) {
1768 flattenListSelection(editor);
1769 } else {
1770 var bookmark = Bookmark.createBookmark(editor.selection.getRng(true));
1771 updateListWithDetails(editor.dom, parentList, detail);
1772 mergeWithAdjacentLists(editor.dom, editor.dom.rename(parentList, listName));
1773 editor.selection.setRng(Bookmark.resolveBookmark(bookmark));
1774 }
1775 } else {
1776 applyList(editor, listName, detail);
1777 }
1778 };
1779 var toggleList = function (editor, listName, detail) {
1780 var parentList = Selection.getParentList(editor);
1781 var selectedSubLists = Selection.getSelectedSubLists(editor);
1782 detail = detail ? detail : {};
1783 if (parentList && selectedSubLists.length > 0) {
1784 toggleMultipleLists(editor, parentList, selectedSubLists, listName, detail);
1785 } else {
1786 toggleSingleList(editor, parentList, listName, detail);
1787 }
1788 };
1789 var ToggleList = {
1790 toggleList: toggleList,
1791 mergeWithAdjacentLists: mergeWithAdjacentLists
1792 };
1793
1794 var DOM$2 = global$6.DOM;
1795 var normalizeList = function (dom, ul) {
1796 var sibling;
1797 var parentNode = ul.parentNode;
1798 if (parentNode.nodeName === 'LI' && parentNode.firstChild === ul) {
1799 sibling = parentNode.previousSibling;
1800 if (sibling && sibling.nodeName === 'LI') {
1801 sibling.appendChild(ul);
1802 if (NodeType.isEmpty(dom, parentNode)) {
1803 DOM$2.remove(parentNode);
1804 }
1805 } else {
1806 DOM$2.setStyle(parentNode, 'listStyleType', 'none');
1807 }
1808 }
1809 if (NodeType.isListNode(parentNode)) {
1810 sibling = parentNode.previousSibling;
1811 if (sibling && sibling.nodeName === 'LI') {
1812 sibling.appendChild(ul);
1813 }
1814 }
1815 };
1816 var normalizeLists = function (dom, element) {
1817 global$5.each(global$5.grep(dom.select('ol,ul', element)), function (ul) {
1818 normalizeList(dom, ul);
1819 });
1820 };
1821 var NormalizeLists = {
1822 normalizeList: normalizeList,
1823 normalizeLists: normalizeLists
1824 };
1825
1826 var findNextCaretContainer = function (editor, rng, isForward, root) {
1827 var node = rng.startContainer;
1828 var offset = rng.startOffset;
1829 var nonEmptyBlocks, walker;
1830 if (node.nodeType === 3 && (isForward ? offset < node.data.length : offset > 0)) {
1831 return node;
1832 }
1833 nonEmptyBlocks = editor.schema.getNonEmptyElements();
1834 if (node.nodeType === 1) {
1835 node = global$1.getNode(node, offset);
1836 }
1837 walker = new global$2(node, root);
1838 if (isForward) {
1839 if (NodeType.isBogusBr(editor.dom, node)) {
1840 walker.next();
1841 }
1842 }
1843 while (node = walker[isForward ? 'next' : 'prev2']()) {
1844 if (node.nodeName === 'LI' && !node.hasChildNodes()) {
1845 return node;
1846 }
1847 if (nonEmptyBlocks[node.nodeName]) {
1848 return node;
1849 }
1850 if (node.nodeType === 3 && node.data.length > 0) {
1851 return node;
1852 }
1853 }
1854 };
1855 var hasOnlyOneBlockChild = function (dom, elm) {
1856 var childNodes = elm.childNodes;
1857 return childNodes.length === 1 && !NodeType.isListNode(childNodes[0]) && dom.isBlock(childNodes[0]);
1858 };
1859 var unwrapSingleBlockChild = function (dom, elm) {
1860 if (hasOnlyOneBlockChild(dom, elm)) {
1861 dom.remove(elm.firstChild, true);
1862 }
1863 };
1864 var moveChildren = function (dom, fromElm, toElm) {
1865 var node, targetElm;
1866 targetElm = hasOnlyOneBlockChild(dom, toElm) ? toElm.firstChild : toElm;
1867 unwrapSingleBlockChild(dom, fromElm);
1868 if (!NodeType.isEmpty(dom, fromElm, true)) {
1869 while (node = fromElm.firstChild) {
1870 targetElm.appendChild(node);
1871 }
1872 }
1873 };
1874 var mergeLiElements = function (dom, fromElm, toElm) {
1875 var node, listNode;
1876 var ul = fromElm.parentNode;
1877 if (!NodeType.isChildOfBody(dom, fromElm) || !NodeType.isChildOfBody(dom, toElm)) {
1878 return;
1879 }
1880 if (NodeType.isListNode(toElm.lastChild)) {
1881 listNode = toElm.lastChild;
1882 }
1883 if (ul === toElm.lastChild) {
1884 if (NodeType.isBr(ul.previousSibling)) {
1885 dom.remove(ul.previousSibling);
1886 }
1887 }
1888 node = toElm.lastChild;
1889 if (node && NodeType.isBr(node) && fromElm.hasChildNodes()) {
1890 dom.remove(node);
1891 }
1892 if (NodeType.isEmpty(dom, toElm, true)) {
1893 dom.$(toElm).empty();
1894 }
1895 moveChildren(dom, fromElm, toElm);
1896 if (listNode) {
1897 toElm.appendChild(listNode);
1898 }
1899 var contains = contains$1(Element.fromDom(toElm), Element.fromDom(fromElm));
1900 var nestedLists = contains ? dom.getParents(fromElm, NodeType.isListNode, toElm) : [];
1901 dom.remove(fromElm);
1902 each(nestedLists, function (list) {
1903 if (NodeType.isEmpty(dom, list) && list !== dom.getRoot()) {
1904 dom.remove(list);
1905 }
1906 });
1907 };
1908 var mergeIntoEmptyLi = function (editor, fromLi, toLi) {
1909 editor.dom.$(toLi).empty();
1910 mergeLiElements(editor.dom, fromLi, toLi);
1911 editor.selection.setCursorLocation(toLi);
1912 };
1913 var mergeForward = function (editor, rng, fromLi, toLi) {
1914 var dom = editor.dom;
1915 if (dom.isEmpty(toLi)) {
1916 mergeIntoEmptyLi(editor, fromLi, toLi);
1917 } else {
1918 var bookmark = Bookmark.createBookmark(rng);
1919 mergeLiElements(dom, fromLi, toLi);
1920 editor.selection.setRng(Bookmark.resolveBookmark(bookmark));
1921 }
1922 };
1923 var mergeBackward = function (editor, rng, fromLi, toLi) {
1924 var bookmark = Bookmark.createBookmark(rng);
1925 mergeLiElements(editor.dom, fromLi, toLi);
1926 var resolvedBookmark = Bookmark.resolveBookmark(bookmark);
1927 editor.selection.setRng(resolvedBookmark);
1928 };
1929 var backspaceDeleteFromListToListCaret = function (editor, isForward) {
1930 var dom = editor.dom, selection = editor.selection;
1931 var selectionStartElm = selection.getStart();
1932 var root = Selection.getClosestListRootElm(editor, selectionStartElm);
1933 var li = dom.getParent(selection.getStart(), 'LI', root);
1934 var ul, rng, otherLi;
1935 if (li) {
1936 ul = li.parentNode;
1937 if (ul === editor.getBody() && NodeType.isEmpty(dom, ul)) {
1938 return true;
1939 }
1940 rng = Range.normalizeRange(selection.getRng(true));
1941 otherLi = dom.getParent(findNextCaretContainer(editor, rng, isForward, root), 'LI', root);
1942 if (otherLi && otherLi !== li) {
1943 if (isForward) {
1944 mergeForward(editor, rng, otherLi, li);
1945 } else {
1946 mergeBackward(editor, rng, li, otherLi);
1947 }
1948 return true;
1949 } else if (!otherLi) {
1950 if (!isForward) {
1951 flattenListSelection(editor);
1952 return true;
1953 }
1954 }
1955 }
1956 return false;
1957 };
1958 var removeBlock = function (dom, block, root) {
1959 var parentBlock = dom.getParent(block.parentNode, dom.isBlock, root);
1960 dom.remove(block);
1961 if (parentBlock && dom.isEmpty(parentBlock)) {
1962 dom.remove(parentBlock);
1963 }
1964 };
1965 var backspaceDeleteIntoListCaret = function (editor, isForward) {
1966 var dom = editor.dom;
1967 var selectionStartElm = editor.selection.getStart();
1968 var root = Selection.getClosestListRootElm(editor, selectionStartElm);
1969 var block = dom.getParent(selectionStartElm, dom.isBlock, root);
1970 if (block && dom.isEmpty(block)) {
1971 var rng = Range.normalizeRange(editor.selection.getRng(true));
1972 var otherLi_1 = dom.getParent(findNextCaretContainer(editor, rng, isForward, root), 'LI', root);
1973 if (otherLi_1) {
1974 editor.undoManager.transact(function () {
1975 removeBlock(dom, block, root);
1976 ToggleList.mergeWithAdjacentLists(dom, otherLi_1.parentNode);
1977 editor.selection.select(otherLi_1, true);
1978 editor.selection.collapse(isForward);
1979 });
1980 return true;
1981 }
1982 }
1983 return false;
1984 };
1985 var backspaceDeleteCaret = function (editor, isForward) {
1986 return backspaceDeleteFromListToListCaret(editor, isForward) || backspaceDeleteIntoListCaret(editor, isForward);
1987 };
1988 var backspaceDeleteRange = function (editor) {
1989 var selectionStartElm = editor.selection.getStart();
1990 var root = Selection.getClosestListRootElm(editor, selectionStartElm);
1991 var startListParent = editor.dom.getParent(selectionStartElm, 'LI,DT,DD', root);
1992 if (startListParent || Selection.getSelectedListItems(editor).length > 0) {
1993 editor.undoManager.transact(function () {
1994 editor.execCommand('Delete');
1995 NormalizeLists.normalizeLists(editor.dom, editor.getBody());
1996 });
1997 return true;
1998 }
1999 return false;
2000 };
2001 var backspaceDelete = function (editor, isForward) {
2002 return editor.selection.isCollapsed() ? backspaceDeleteCaret(editor, isForward) : backspaceDeleteRange(editor);
2003 };
2004 var setup = function (editor) {
2005 editor.on('keydown', function (e) {
2006 if (e.keyCode === global$3.BACKSPACE) {
2007 if (backspaceDelete(editor, false)) {
2008 e.preventDefault();
2009 }
2010 } else if (e.keyCode === global$3.DELETE) {
2011 if (backspaceDelete(editor, true)) {
2012 e.preventDefault();
2013 }
2014 }
2015 });
2016 };
2017 var Delete = {
2018 setup: setup,
2019 backspaceDelete: backspaceDelete
2020 };
2021
2022 var get = function (editor) {
2023 return {
2024 backspaceDelete: function (isForward) {
2025 Delete.backspaceDelete(editor, isForward);
2026 }
2027 };
2028 };
2029 var Api = { get: get };
2030
2031 var queryListCommandState = function (editor, listName) {
2032 return function () {
2033 var parentList = editor.dom.getParent(editor.selection.getStart(), 'UL,OL,DL');
2034 return parentList && parentList.nodeName === listName;
2035 };
2036 };
2037 var register = function (editor) {
2038 editor.on('BeforeExecCommand', function (e) {
2039 var cmd = e.command.toLowerCase();
2040 if (cmd === 'indent') {
2041 indentListSelection(editor);
2042 } else if (cmd === 'outdent') {
2043 outdentListSelection(editor);
2044 }
2045 });
2046 editor.addCommand('InsertUnorderedList', function (ui, detail) {
2047 ToggleList.toggleList(editor, 'UL', detail);
2048 });
2049 editor.addCommand('InsertOrderedList', function (ui, detail) {
2050 ToggleList.toggleList(editor, 'OL', detail);
2051 });
2052 editor.addCommand('InsertDefinitionList', function (ui, detail) {
2053 ToggleList.toggleList(editor, 'DL', detail);
2054 });
2055 editor.addCommand('RemoveList', function () {
2056 flattenListSelection(editor);
2057 });
2058 editor.addQueryStateHandler('InsertUnorderedList', queryListCommandState(editor, 'UL'));
2059 editor.addQueryStateHandler('InsertOrderedList', queryListCommandState(editor, 'OL'));
2060 editor.addQueryStateHandler('InsertDefinitionList', queryListCommandState(editor, 'DL'));
2061 };
2062 var Commands = { register: register };
2063
2064 var shouldIndentOnTab = function (editor) {
2065 return editor.getParam('lists_indent_on_tab', true);
2066 };
2067 var Settings = { shouldIndentOnTab: shouldIndentOnTab };
2068
2069 var setupTabKey = function (editor) {
2070 editor.on('keydown', function (e) {
2071 if (e.keyCode !== global$3.TAB || global$3.metaKeyPressed(e)) {
2072 return;
2073 }
2074 editor.undoManager.transact(function () {
2075 if (e.shiftKey ? outdentListSelection(editor) : indentListSelection(editor)) {
2076 e.preventDefault();
2077 }
2078 });
2079 });
2080 };
2081 var setup$1 = function (editor) {
2082 if (Settings.shouldIndentOnTab(editor)) {
2083 setupTabKey(editor);
2084 }
2085 Delete.setup(editor);
2086 };
2087 var Keyboard = { setup: setup$1 };
2088
2089 var findIndex = function (list, predicate) {
2090 for (var index = 0; index < list.length; index++) {
2091 var element = list[index];
2092 if (predicate(element)) {
2093 return index;
2094 }
2095 }
2096 return -1;
2097 };
2098 var listState = function (editor, listName) {
2099 return function (e) {
2100 var ctrl = e.control;
2101 editor.on('NodeChange', function (e) {
2102 var tableCellIndex = findIndex(e.parents, NodeType.isTableCellNode);
2103 var parents = tableCellIndex !== -1 ? e.parents.slice(0, tableCellIndex) : e.parents;
2104 var lists = global$5.grep(parents, NodeType.isListNode);
2105 ctrl.active(lists.length > 0 && lists[0].nodeName === listName);
2106 });
2107 };
2108 };
2109 var register$1 = function (editor) {
2110 var hasPlugin = function (editor, plugin) {
2111 var plugins = editor.settings.plugins ? editor.settings.plugins : '';
2112 return global$5.inArray(plugins.split(/[ ,]/), plugin) !== -1;
2113 };
2114 if (!hasPlugin(editor, 'advlist')) {
2115 editor.addButton('numlist', {
2116 active: false,
2117 title: 'Numbered list',
2118 cmd: 'InsertOrderedList',
2119 onPostRender: listState(editor, 'OL')
2120 });
2121 editor.addButton('bullist', {
2122 active: false,
2123 title: 'Bullet list',
2124 cmd: 'InsertUnorderedList',
2125 onPostRender: listState(editor, 'UL')
2126 });
2127 }
2128 editor.addButton('indent', {
2129 icon: 'indent',
2130 title: 'Increase indent',
2131 cmd: 'Indent'
2132 });
2133 };
2134 var Buttons = { register: register$1 };
2135
2136 global.add('lists', function (editor) {
2137 Keyboard.setup(editor);
2138 Buttons.register(editor);
2139 Commands.register(editor);
2140 return Api.get(editor);
2141 });
2142 function Plugin () {
2143 }
2144
2145 return Plugin;
2146
2147}(window));
2148})();
2149