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