plugin.js - balmet.com - Unnamed repository; edit this file 'description' to name the repository.

plugin.js (70415B)
      1 (function () {
      2 var 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 })();
	balmet.com Unnamed repository; edit this file 'description' to name the repository.
	Log \| Files \| Refs