@syncfusion/ej2-richtexteditor 29.2.4-738301 → 29.2.4-760237

package/blazorGlobalSrc/editor-manager/plugin/dom-node.js

@@ -0,0 +1,737 @@
+define(["require", "exports", "./../base/constant", "@syncfusion/ej2-base", "./../../selection/index", "../../common/config", "../../common/util", "./table-selection"], function (require, exports, CONSTANT, ej2_base_1, index_1, config_1, util_1, table_selection_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.markerClassName = {
+        startSelection: 'e-editor-select-start',
+        endSelection: 'e-editor-select-end'
+    };
+    var DOMNode = (function () {
+        function DOMNode(parent, currentDocument) {
+            this.parent = parent;
+            this.nodeSelection = new index_1.NodeSelection(parent);
+            this.currentDocument = currentDocument;
+            this.tableSelection = new table_selection_1.TableSelection(parent, currentDocument);
+        }
+        DOMNode.prototype.contents = function (element) {
+            return (element && 'IFRAME' !== element.tagName ? Array.prototype.slice.call(element.childNodes || []) : []);
+        };
+        DOMNode.prototype.isBlockNode = function (element) {
+            return (!!element && (element.nodeType === Node.ELEMENT_NODE && CONSTANT.BLOCK_TAGS.indexOf(element.tagName.toLowerCase()) >= 0));
+        };
+        DOMNode.prototype.isLink = function (element) {
+            return (!!element && (element.nodeType === Node.ELEMENT_NODE && 'a' === element.tagName.toLowerCase()));
+        };
+        DOMNode.prototype.blockParentNode = function (element) {
+            for (; element && element.parentNode !== this.parent && ((!element.parentNode ||
+                !this.hasClass(element.parentNode, 'e-node-inner'))); null) {
+                element = element.parentNode;
+                if (this.isBlockNode(element)) {
+                    return element;
+                }
+            }
+            return element;
+        };
+        DOMNode.prototype.rawAttributes = function (element) {
+            var rawAttr = {};
+            var attributes = element.attributes;
+            if (attributes.length > 0) {
+                for (var d = 0; d < attributes.length; d++) {
+                    var e = attributes[d];
+                    rawAttr[e.nodeName] = e.value;
+                }
+            }
+            return rawAttr;
+        };
+        DOMNode.prototype.attributes = function (element) {
+            if (!element) {
+                return '';
+            }
+            var attr = '';
+            var rawAttr = this.rawAttributes(element);
+            var orderRawAttr = Object.keys(rawAttr).sort();
+            for (var e = 0; e < orderRawAttr.length; e++) {
+                var attrKey = orderRawAttr[e];
+                var attrValue = rawAttr["" + attrKey];
+                if (attrValue.indexOf("'") < 0 && attrValue.indexOf('"') >= 0) {
+                    attr += ' ' + attrKey + "='" + attrValue + "'";
+                }
+                else if (attrValue.indexOf('"') >= 0 && attrValue.indexOf("'") >= 0) {
+                    attrValue = attrValue.replace(/"/g, '&quot;');
+                    attr += ' ' + attrKey + '="' + attrValue + '"';
+                }
+                else {
+                    attr += ' ' + attrKey + '="' + attrValue + '"';
+                }
+            }
+            return attr;
+        };
+        DOMNode.prototype.clearAttributes = function (element) {
+            for (var attr = element.attributes, c = attr.length - 1; c >= 0; c--) {
+                var key = attr[c];
+                element.removeAttribute(key.nodeName);
+            }
+        };
+        DOMNode.prototype.openTagString = function (element) {
+            return '<' + element.tagName.toLowerCase() + this.attributes(element) + '>';
+        };
+        DOMNode.prototype.closeTagString = function (element) {
+            return '</' + element.tagName.toLowerCase() + '>';
+        };
+        DOMNode.prototype.createTagString = function (tagName, relativeElement, innerHTML) {
+            return '<' + tagName.toLowerCase() + this.attributes(relativeElement) + '>' + innerHTML + '</' + tagName.toLowerCase() + '>';
+        };
+        DOMNode.prototype.isList = function (element) {
+            return !!element && ['UL', 'OL'].indexOf(element.tagName) >= 0;
+        };
+        DOMNode.prototype.isElement = function (element) {
+            return element === this.parent;
+        };
+        DOMNode.prototype.isEditable = function (element) {
+            return ((!element.getAttribute || element.getAttribute('contenteditable') === 'true')
+                && ['STYLE', 'SCRIPT'].indexOf(element.tagName) < 0);
+        };
+        DOMNode.prototype.hasClass = function (element, className) {
+            return element && element.classList && element.classList.contains(className);
+        };
+        DOMNode.prototype.replaceWith = function (element, value) {
+            var parentNode = element.parentNode;
+            parentNode.insertBefore(this.parseHTMLFragment(value), element);
+            ej2_base_1.detach(element);
+        };
+        DOMNode.prototype.parseHTMLFragment = function (value) {
+            var temp = ej2_base_1.createElement('template');
+            temp.innerHTML = value;
+            if (temp.content instanceof DocumentFragment) {
+                return temp.content;
+            }
+            else {
+                return document.createRange().createContextualFragment(value);
+            }
+        };
+        DOMNode.prototype.wrap = function (element, wrapper) {
+            element.parentNode.insertBefore(wrapper, element);
+            wrapper = element.previousSibling;
+            wrapper.appendChild(element);
+            return wrapper;
+        };
+        DOMNode.prototype.insertAfter = function (newNode, referenceNode) {
+            referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
+        };
+        DOMNode.prototype.wrapInner = function (parent, wrapper) {
+            parent.appendChild(wrapper);
+            wrapper = parent.querySelector('.e-rte-wrap-inner');
+            wrapper.classList.remove('e-rte-wrap-inner');
+            if (wrapper.classList.length === 0) {
+                wrapper.removeAttribute('class');
+            }
+            while (parent.firstChild !== wrapper) {
+                wrapper.appendChild(parent.firstChild);
+            }
+            return wrapper;
+        };
+        DOMNode.prototype.unWrap = function (element) {
+            var parent = element && element.parentNode;
+            if (!parent) {
+                return [];
+            }
+            var unWrapNode = [];
+            while (element.firstChild && (element.textContent !== ' ')) {
+                unWrapNode.push(element.firstChild);
+                parent.insertBefore(element.firstChild, element);
+            }
+            unWrapNode = unWrapNode.length > 0 ? unWrapNode : [element.parentNode];
+            parent.removeChild(element);
+            return unWrapNode;
+        };
+        DOMNode.prototype.getSelectedNode = function (element, index) {
+            if (element.nodeType === Node.ELEMENT_NODE && element.childNodes.length > 0 &&
+                element.childNodes[index - 1] && element.childNodes[index - 1].nodeType === Node.ELEMENT_NODE &&
+                (element.childNodes[index - 1].classList.contains(exports.markerClassName.startSelection) ||
+                    element.childNodes[index - 1].classList.contains(exports.markerClassName.endSelection))) {
+                element = element.childNodes[index - 1];
+            }
+            else if (element.nodeType === Node.ELEMENT_NODE && element.childNodes.length > 0 && element.childNodes[index]) {
+                element = element.childNodes[index];
+            }
+            if (element.nodeType === Node.TEXT_NODE) {
+                element = element.parentNode;
+            }
+            return element;
+        };
+        DOMNode.prototype.nodeFinds = function (element, elements) {
+            var existNodes = [];
+            for (var i = 0; i < elements.length; i++) {
+                if (element.contains(elements[i]) && element !== elements[i]) {
+                    existNodes.push(elements[i]);
+                }
+            }
+            return existNodes;
+        };
+        DOMNode.prototype.isEditorArea = function () {
+            var range = this.getRangePoint(0);
+            var element;
+            for (element = range.commonAncestorContainer; element && !this.isElement(element); null) {
+                element = element.parentNode;
+            }
+            return !!this.isElement(element);
+        };
+        DOMNode.prototype.getRangePoint = function (point) {
+            var selection = this.getSelection();
+            var ranges = [];
+            if (selection && selection.getRangeAt && selection.rangeCount) {
+                ranges = [];
+                for (var f = 0; f < selection.rangeCount; f++) {
+                    ranges.push(selection.getRangeAt(f));
+                }
+            }
+            else {
+                ranges = [this.currentDocument.createRange()];
+            }
+            return 'undefined' !== typeof point ? ranges[point] : ranges;
+        };
+        DOMNode.prototype.getSelection = function () {
+            return this.nodeSelection.get(this.currentDocument);
+        };
+        DOMNode.prototype.getPreviousNode = function (element) {
+            element = element.previousElementSibling;
+            for (; element && element.textContent === '\n'; null) {
+                element = element.previousElementSibling;
+            }
+            return element;
+        };
+        DOMNode.prototype.encode = function (value) {
+            var divNode = document.createElement('div');
+            divNode.innerText = value;
+            return divNode.innerHTML.replace(/<br\s*[\/]?>/gi, '\n');
+        };
+        DOMNode.prototype.saveMarker = function (save) {
+            var start = this.parent.querySelector('.' + exports.markerClassName.startSelection);
+            var end = this.parent.querySelector('.' + exports.markerClassName.endSelection);
+            var startTextNode;
+            var endTextNode;
+            if (this.hasClass(start, exports.markerClassName.startSelection) && start.classList.length > 1) {
+                var replace = this.createTagString(CONSTANT.DEFAULT_TAG, start, this.encode(start.textContent));
+                this.replaceWith(start, replace);
+                start = this.parent.querySelector('.' + exports.markerClassName.startSelection);
+                start.classList.remove(exports.markerClassName.startSelection);
+                startTextNode = start.childNodes[0];
+            }
+            else {
+                startTextNode = this.unWrap(start)[0];
+            }
+            if (this.hasClass(end, exports.markerClassName.endSelection) && end.classList.length > 1) {
+                var replace = this.createTagString(CONSTANT.DEFAULT_TAG, end, this.encode(end.textContent));
+                this.replaceWith(end, replace);
+                end = this.parent.querySelector('.' + exports.markerClassName.endSelection);
+                end.classList.remove(exports.markerClassName.endSelection);
+                endTextNode = end.childNodes[0];
+            }
+            else {
+                endTextNode = end ? this.unWrap(end)[0] : startTextNode;
+            }
+            save.startContainer = save.getNodeArray(startTextNode, true);
+            save.endContainer = save.getNodeArray(endTextNode, false);
+            return save;
+        };
+        DOMNode.prototype.marker = function (className, textContent) {
+            return '<span class="' + className + '">' + textContent + '</span>';
+        };
+        DOMNode.prototype.setMarker = function (save) {
+            var range = save.range;
+            var startChildNodes = range.startContainer.childNodes;
+            var isTableStart = startChildNodes.length > 1 && startChildNodes[0].nodeName === 'TABLE' && range.startOffset === 0;
+            var isImgOnlySelected = startChildNodes.length > 1 && startChildNodes[0].nodeName === 'IMAGE' &&
+                range.endOffset === 1 && range.endContainer.nodeName === '#text' && range.endContainer.textContent.length === 0;
+            var start = ((isTableStart ? util_1.getLastTextNode(startChildNodes[range.startOffset + 1]) :
+                startChildNodes[(range.startOffset > 0) ? (range.startOffset - 1) : range.startOffset]) || range.startContainer);
+            var end = (range.endContainer.childNodes[(range.endOffset > 0) ? (isImgOnlySelected ? range.endOffset :
+                (range.endOffset - 1)) : range.endOffset] || range.endContainer);
+            if ((start.nodeType === Node.ELEMENT_NODE && end.nodeType === Node.ELEMENT_NODE) && (start.contains(end) || end.contains(start))) {
+                var existNode = start.contains(end) ? start : end;
+                var isElement = existNode.nodeType !== Node.TEXT_NODE;
+                if (isElement) {
+                    var nodes = [];
+                    var textNodes = [];
+                    for (var node = existNode; existNode.contains(node); null) {
+                        if (nodes.indexOf(node) < 0 && node.childNodes && node.childNodes.length) {
+                            nodes.push(node);
+                            node = node.childNodes[0];
+                        }
+                        else if (node.nextSibling) {
+                            node = node.nextSibling;
+                        }
+                        else if (node.parentNode) {
+                            node = node.parentNode;
+                            nodes.push(node);
+                        }
+                        if (textNodes.indexOf(node) < 0 && (node.nodeType === Node.TEXT_NODE ||
+                            (CONSTANT.IGNORE_BLOCK_TAGS.indexOf(node.parentNode.tagName.toLocaleLowerCase()) >= 0
+                                && (node.tagName === 'BR' || node.tagName === 'IMG')))) {
+                            textNodes.push(node);
+                        }
+                    }
+                    if (textNodes.length) {
+                        start = start.contains(end) ? textNodes[0] : start;
+                        end = textNodes[textNodes.length - 1];
+                    }
+                }
+            }
+            if (start !== end) {
+                if (start.nodeType !== Node.TEXT_NODE && ((start.tagName === 'BR' &&
+                    CONSTANT.IGNORE_BLOCK_TAGS.indexOf(start.parentNode.tagName.toLocaleLowerCase()) >= 0) ||
+                    start.tagName === 'IMG')) {
+                    this.replaceWith(start, this.marker(exports.markerClassName.startSelection, this.encode(start.textContent)));
+                    var markerStart = range.startContainer.querySelector('.' + exports.markerClassName.startSelection);
+                    markerStart.appendChild(start);
+                }
+                else {
+                    if (start.nodeType !== 3 && start.nodeName !== '#text' && start.nodeName !== 'BR') {
+                        var marker = this.marker(exports.markerClassName.startSelection, '');
+                        ej2_base_1.append([this.parseHTMLFragment(marker)], start);
+                    }
+                    else {
+                        this.replaceWith(start, this.marker(exports.markerClassName.startSelection, this.encode(start.textContent)));
+                    }
+                }
+                if (end.nodeType !== Node.TEXT_NODE && end.tagName === 'BR' &&
+                    CONSTANT.IGNORE_BLOCK_TAGS.indexOf(end.parentNode.tagName.toLocaleLowerCase()) >= 0) {
+                    this.replaceWith(end, this.marker(exports.markerClassName.endSelection, this.encode(end.textContent)));
+                    var markerEnd = range.endContainer.querySelector('.' + exports.markerClassName.endSelection);
+                    markerEnd.appendChild(end);
+                }
+                else {
+                    this.ensureSelfClosingTag(end, exports.markerClassName.endSelection, range);
+                }
+            }
+            else {
+                this.ensureSelfClosingTag(start, exports.markerClassName.startSelection, range);
+            }
+        };
+        DOMNode.prototype.ensureSelfClosingTag = function (start, className, range) {
+            var isTable = false;
+            if (start.nodeType === 3) {
+                this.replaceWith(start, this.marker(className, this.encode(start.textContent)));
+            }
+            else if (start.tagName === 'BR') {
+                this.replaceWith(start, this.marker(className, this.encode(start.textContent)));
+                var markerStart = range.startContainer.querySelector('.' + className);
+                if (markerStart) {
+                    markerStart.parentElement.appendChild(start);
+                }
+            }
+            else {
+                var tagName = !ej2_base_1.isNullOrUndefined(start.parentElement) ? start.parentElement.tagName.toLocaleLowerCase() : '';
+                if (start.tagName === 'IMG' && tagName !== 'p' && tagName !== 'div') {
+                    var parNode = document.createElement('p');
+                    start.parentElement.insertBefore(parNode, start);
+                    parNode.appendChild(start);
+                    start = parNode.children[0];
+                }
+                if (start.tagName === 'TABLE') {
+                    isTable = true;
+                    if (start.textContent === '') {
+                        var tdNode = start.querySelectorAll('td');
+                        start = tdNode[tdNode.length - 1];
+                        start = !ej2_base_1.isNullOrUndefined(start.childNodes[0]) ? start.childNodes[0] : start;
+                    }
+                    else {
+                        var lastNode = start.lastChild;
+                        while (lastNode.nodeType !== 3 && lastNode.nodeName !== '#text' &&
+                            lastNode.nodeName !== 'BR') {
+                            lastNode = lastNode.lastChild;
+                        }
+                        start = lastNode;
+                    }
+                }
+                for (var i = 0; i < config_1.selfClosingTags.length; i++) {
+                    start = (start.tagName === config_1.selfClosingTags[i] && !isTable) ? start.parentNode : start;
+                }
+                if (start.nodeType === 3 && start.nodeName === '#text') {
+                    this.replaceWith(start, this.marker(className, this.encode(start.textContent)));
+                }
+                else if (start.nodeName === 'BR') {
+                    this.replaceWith(start, this.marker(exports.markerClassName.endSelection, this.encode(start.textContent)));
+                    var markerEnd = range.endContainer.querySelector('.' + exports.markerClassName.endSelection);
+                    markerEnd.appendChild(start);
+                }
+                else {
+                    var marker = this.marker(className, '');
+                    ej2_base_1.append([this.parseHTMLFragment(marker)], start);
+                }
+            }
+        };
+        DOMNode.prototype.createTempNode = function (element) {
+            var textContent = element.textContent;
+            if (element.tagName === 'BR') {
+                var wrapper = '<' + CONSTANT.DEFAULT_TAG + '></' + CONSTANT.DEFAULT_TAG + '>';
+                var node = element.parentNode;
+                if (CONSTANT.IGNORE_BLOCK_TAGS.indexOf(node.tagName.toLocaleLowerCase()) >= 0) {
+                    element = this.wrap(element, this.parseHTMLFragment(wrapper));
+                }
+            }
+            else if (((element.nodeType !== Node.TEXT_NODE &&
+                (element.classList.contains(exports.markerClassName.startSelection) ||
+                    element.classList.contains(exports.markerClassName.endSelection))) ||
+                textContent.replace(/\n/g, '').replace(/(^ *)|( *$)/g, '').length > 0 ||
+                textContent.length && textContent.indexOf('\n') < 0)) {
+                var wrapper = '<' + CONSTANT.DEFAULT_TAG + '></' + CONSTANT.DEFAULT_TAG + '>';
+                var target = element;
+                element = this.wrap(element, this.parseHTMLFragment(wrapper));
+                var ignoreBr = target.nodeType === Node.ELEMENT_NODE && target.firstChild && target.firstChild.nodeName === 'BR'
+                    && (target.classList.contains(exports.markerClassName.startSelection) ||
+                        target.classList.contains(exports.markerClassName.endSelection));
+                if (!ignoreBr && element.nextElementSibling && element.nextElementSibling.tagName === 'BR') {
+                    element.appendChild(element.nextElementSibling);
+                }
+            }
+            return element;
+        };
+        DOMNode.prototype.getImageTagInSelection = function () {
+            var selection = this.getSelection();
+            if (this.isEditorArea() && selection.rangeCount) {
+                return selection.focusNode.querySelectorAll('img');
+            }
+            return null;
+        };
+        DOMNode.prototype.gatherElementsAround = function (node, wrapperElement) {
+            var newWrapElem = ej2_base_1.createElement(wrapperElement);
+            var currentNode = node.previousSibling;
+            var currentNodeParent = node.parentElement;
+            if (currentNodeParent.className === 'e-editor-select-start') {
+                currentNodeParent.parentNode.insertBefore(newWrapElem, currentNodeParent);
+            }
+            else if (currentNodeParent) {
+                currentNodeParent.insertBefore(newWrapElem, node);
+            }
+            var i = 0;
+            while (currentNode !== null && currentNode.nodeName !== 'BR' &&
+                !this.isBlockNode(currentNode)) {
+                var prevSibling = currentNode.previousSibling;
+                if (currentNode.nodeType === 3 || currentNode.nodeType === 1) {
+                    if (i === 0) {
+                        newWrapElem.appendChild(currentNode);
+                    }
+                    else {
+                        newWrapElem.insertBefore(currentNode, newWrapElem.firstChild);
+                    }
+                }
+                currentNode = prevSibling;
+                i++;
+            }
+            newWrapElem.appendChild(node);
+            currentNode = newWrapElem.nextSibling ? newWrapElem.nextSibling :
+                newWrapElem.parentElement.nextSibling;
+            while (currentNode !== null && currentNode.nodeName !== 'BR' &&
+                !this.isBlockNode(currentNode)) {
+                var nextSibling = currentNode.nextSibling ?
+                    currentNode.nextSibling : currentNode.parentElement.nextSibling;
+                if (currentNode.nodeType === 3 || currentNode.nodeType === 1) {
+                    newWrapElem.appendChild(currentNode);
+                }
+                currentNode = nextSibling;
+            }
+            return newWrapElem;
+        };
+        DOMNode.prototype.convertToBlockNodes = function (selectedNodes, fromList) {
+            if (selectedNodes.length > 1) {
+                var i = 0;
+                var currentSelectedNode = selectedNodes[0];
+                while (!ej2_base_1.isNullOrUndefined(currentSelectedNode)) {
+                    if (currentSelectedNode.nodeName === 'BR') {
+                        var nextNode = currentSelectedNode.nextSibling;
+                        ej2_base_1.detach(currentSelectedNode);
+                        currentSelectedNode = nextNode;
+                    }
+                    if (!ej2_base_1.isNullOrUndefined(currentSelectedNode)) {
+                        if (fromList) {
+                            selectedNodes[i] = currentSelectedNode.nodeName === 'LI' || this.isBlockNode(currentSelectedNode) ?
+                                currentSelectedNode :
+                                this.gatherElementsAround(currentSelectedNode, (fromList ? 'p' : 'div'));
+                        }
+                        else {
+                            selectedNodes[i] = !this.isBlockNode(selectedNodes[i]) ?
+                                this.gatherElementsAround(currentSelectedNode, (fromList ? 'p' : 'div')) :
+                                selectedNodes[i];
+                        }
+                        var currentProcessNode = selectedNodes[i].nodeName === 'LI' ? selectedNodes[i].parentElement : selectedNodes[i];
+                        var currentElementCheckNode = currentProcessNode.nodeName === '#text' ? currentProcessNode.parentElement : currentProcessNode;
+                        currentSelectedNode = !ej2_base_1.isNullOrUndefined(currentElementCheckNode.querySelector('.e-editor-select-end')) ||
+                            !ej2_base_1.isNullOrUndefined(ej2_base_1.closest(currentSelectedNode, '.e-editor-select-end')) ?
+                            null : currentProcessNode.nextSibling;
+                        if (currentSelectedNode === null && !ej2_base_1.isNullOrUndefined(currentProcessNode.nextSibling) && currentProcessNode.nextSibling.nodeName === 'BR') {
+                            ej2_base_1.detach(currentProcessNode.nextSibling);
+                        }
+                    }
+                    i++;
+                }
+            }
+            else {
+                if (!this.isBlockNode(selectedNodes[0])) {
+                    selectedNodes[0] = this.gatherElementsAround(selectedNodes[0], (fromList ? 'p' : 'div'));
+                    if (!ej2_base_1.isNullOrUndefined(selectedNodes[0].nextSibling) && (selectedNodes[0].nextSibling.nodeName === 'BR')) {
+                        ej2_base_1.detach(selectedNodes[0].nextSibling);
+                    }
+                }
+            }
+            return selectedNodes;
+        };
+        DOMNode.prototype.blockNodes = function (action) {
+            var collectionNodes = [];
+            var selection = this.getSelection();
+            var tableBlockNodes = this.tableSelection.getBlockNodes();
+            if (tableBlockNodes.length > 0) {
+                return tableBlockNodes;
+            }
+            if (this.isEditorArea() && selection.rangeCount) {
+                var ranges = this.getRangePoint();
+                var _loop_1 = function (j) {
+                    var parentNode = void 0;
+                    var range = ranges[j];
+                    var startNode = this_1.getSelectedNode(range.startContainer, range.startOffset);
+                    var endNode = this_1.getSelectedNode(range.endContainer, range.endOffset);
+                    if (this_1.isBlockNode(startNode) && collectionNodes.indexOf(startNode) < 0) {
+                        collectionNodes.push(startNode);
+                    }
+                    parentNode = this_1.blockParentNode(startNode);
+                    var endParentNode = this_1.blockParentNode(endNode);
+                    if (parentNode && collectionNodes.indexOf(parentNode) < 0) {
+                        if (!ej2_base_1.isNullOrUndefined(action) && action) {
+                            var tableCellNodeNames_1 = ['TD', 'TH'];
+                            var nodesToCheck = [range.commonAncestorContainer, parentNode, endParentNode];
+                            if (nodesToCheck.some(function (node) { return tableCellNodeNames_1.indexOf(node.nodeName) !== -1; })) {
+                                var processedNodes = this_1.getPreBlockNodeCollection(range);
+                                if (processedNodes.length > 1) {
+                                    this_1.wrapWithBlockNode(processedNodes, collectionNodes);
+                                }
+                                else if (processedNodes.length > 0) {
+                                    if (startNode !== endNode && startNode.nodeName !== 'BR') {
+                                        collectionNodes.push(this_1.createTempNode(startNode));
+                                    }
+                                    else if (startNode === endNode && startNode.nodeName === 'SPAN' && (startNode.classList.contains(exports.markerClassName.startSelection)
+                                        || startNode.classList.contains(exports.markerClassName.endSelection))) {
+                                        collectionNodes.push(this_1.createTempNode(startNode));
+                                    }
+                                }
+                            }
+                            else {
+                                collectionNodes.push(parentNode);
+                            }
+                        }
+                        else {
+                            if (CONSTANT.IGNORE_BLOCK_TAGS.indexOf(parentNode.tagName.toLocaleLowerCase()) >= 0 && (startNode.tagName === 'BR' ||
+                                startNode.nodeType === Node.TEXT_NODE ||
+                                startNode.classList.contains(exports.markerClassName.startSelection) ||
+                                startNode.classList.contains(exports.markerClassName.endSelection))) {
+                                var tempNode = startNode.previousSibling &&
+                                    startNode.previousSibling.nodeType === Node.TEXT_NODE ?
+                                    startNode.previousSibling : startNode;
+                                if (!startNode.nextSibling && !startNode.previousSibling && startNode.tagName === 'BR') {
+                                    collectionNodes.push(tempNode);
+                                }
+                                else {
+                                    collectionNodes.push(this_1.createTempNode(tempNode));
+                                }
+                            }
+                            else {
+                                collectionNodes.push(parentNode);
+                            }
+                        }
+                    }
+                    var nodes = [];
+                    for (var node = startNode; node !== endNode && node !== this_1.parent; null) {
+                        if (nodes.indexOf(node) < 0 && node.childNodes && node.childNodes.length) {
+                            nodes.push(node);
+                            node = node.childNodes[0];
+                        }
+                        else if (node && node.nodeType !== 8 && (node.tagName === 'BR' || (node.nodeType === Node.TEXT_NODE &&
+                            node.textContent.trim() !== '') || (node.nodeType !== Node.TEXT_NODE &&
+                            (node.classList.contains(exports.markerClassName.startSelection) ||
+                                node.classList.contains(exports.markerClassName.endSelection)))) &&
+                            CONSTANT.IGNORE_BLOCK_TAGS.indexOf(node.parentNode.tagName.toLocaleLowerCase()) >= 0) {
+                            node = this_1.createTempNode(node);
+                        }
+                        else if (node.nextSibling && node.nextSibling.nodeType !== 8 &&
+                            (node.nextSibling.tagName === 'BR' ||
+                                node.nextSibling.nodeType === Node.TEXT_NODE ||
+                                node.nextSibling.classList.contains(exports.markerClassName.startSelection) ||
+                                node.nextSibling.classList.contains(exports.markerClassName.endSelection)) &&
+                            CONSTANT.IGNORE_BLOCK_TAGS.indexOf(node.nextSibling.parentNode.tagName.toLocaleLowerCase()) >= 0) {
+                            node = this_1.createTempNode(node.nextSibling);
+                        }
+                        else if (node.nextSibling) {
+                            node = node.nextSibling;
+                        }
+                        else if (node.parentNode) {
+                            node = node.parentNode;
+                            nodes.push(node);
+                        }
+                        if (collectionNodes.indexOf(node) < 0 && node.nodeType === Node.ELEMENT_NODE &&
+                            CONSTANT.IGNORE_BLOCK_TAGS.indexOf(node.parentNode.tagName.toLocaleLowerCase()) >= 0 &&
+                            (node.classList.contains(exports.markerClassName.startSelection) ||
+                                node.classList.contains(exports.markerClassName.endSelection))) {
+                            collectionNodes.push(this_1.createTempNode(node));
+                        }
+                        if (this_1.isBlockNode(node) && this_1.ignoreTableTag(node) && nodes.indexOf(node) < 0 &&
+                            collectionNodes.indexOf(node) < 0 && (node !== endNode || range.endOffset > 0)) {
+                            collectionNodes.push(node);
+                        }
+                        if (node.nodeName === 'IMG' && node.parentElement.contentEditable === 'true') {
+                            collectionNodes.push(node);
+                        }
+                    }
+                    parentNode = this_1.blockParentNode(endNode);
+                    if (parentNode && this_1.ignoreTableTag(parentNode) && collectionNodes.indexOf(parentNode) < 0 &&
+                        (!ej2_base_1.isNullOrUndefined(parentNode.previousElementSibling) && parentNode.previousElementSibling.tagName !== 'IMG')) {
+                        collectionNodes.push(parentNode);
+                    }
+                };
+                var this_1 = this;
+                for (var j = 0; j < ranges.length; j++) {
+                    _loop_1(j);
+                }
+            }
+            for (var i = collectionNodes.length - 1; i > 0; i--) {
+                var nodes = this.nodeFinds(collectionNodes[i], collectionNodes);
+                if (nodes.length) {
+                    var listNodes = collectionNodes[i].querySelectorAll('ul, ol');
+                    if (collectionNodes[i].tagName === 'LI' && listNodes.length > 0) {
+                        continue;
+                    }
+                    else {
+                        collectionNodes.splice(i, 1);
+                    }
+                }
+            }
+            return collectionNodes;
+        };
+        DOMNode.prototype.ignoreTableTag = function (element) {
+            return !(CONSTANT.TABLE_BLOCK_TAGS.indexOf(element.tagName.toLocaleLowerCase()) >= 0);
+        };
+        DOMNode.prototype.getPreBlockNodeCollection = function (range) {
+            var startNode = this.getSelectedNode(range.startContainer, range.startOffset);
+            var endNode = this.getSelectedNode(range.endContainer, range.endOffset);
+            var nodes = [];
+            var rootNode = startNode.closest('td, th');
+            if (ej2_base_1.isNullOrUndefined(rootNode)) {
+                return nodes;
+            }
+            var rootChildNode = Array.from(rootNode.childNodes);
+            var isContinue = true;
+            var processedStart = this.getClosestInlineParent(startNode, rootNode, true);
+            var processedEnd = this.getClosestInlineParent(endNode, rootNode, false);
+            for (var i = 0; i < rootChildNode.length; i++) {
+                var child = rootChildNode[i];
+                if (processedStart === processedEnd && child === processedStart) {
+                    nodes.push(child);
+                    isContinue = true;
+                }
+                else if (child === processedStart) {
+                    isContinue = false;
+                }
+                else if (child === processedEnd) {
+                    nodes.push(child);
+                    isContinue = true;
+                }
+                if (isContinue) {
+                    continue;
+                }
+                else {
+                    nodes.push(child);
+                }
+            }
+            return nodes;
+        };
+        DOMNode.prototype.getClosestInlineParent = function (node, rootNode, isStart) {
+            if (node.nodeType === Node.TEXT_NODE) {
+                return node;
+            }
+            if (this.isBlockNode(node)) {
+                return node;
+            }
+            var currentNode = node;
+            var rootFlag = false;
+            while (currentNode) {
+                var previousNode = currentNode;
+                if (rootFlag) {
+                    if (this.isBlockNode(currentNode)) {
+                        return previousNode;
+                    }
+                    if (isStart && currentNode.previousSibling) {
+                        if (this.isBlockNode(currentNode.previousSibling) || currentNode.previousSibling.nodeName === 'BR') {
+                            return previousNode;
+                        }
+                        else {
+                            currentNode = currentNode.previousSibling;
+                        }
+                    }
+                    else if (!isStart && currentNode.nextSibling) {
+                        if (this.isBlockNode(currentNode.nextSibling) || currentNode.nextSibling.nodeName === 'BR') {
+                            return previousNode;
+                        }
+                        else {
+                            currentNode = currentNode.nextSibling;
+                        }
+                    }
+                    else {
+                        return currentNode;
+                    }
+                }
+                else {
+                    currentNode = currentNode.parentElement;
+                    if (currentNode === rootNode) {
+                        currentNode = previousNode;
+                        rootFlag = true;
+                    }
+                }
+            }
+            return null;
+        };
+        DOMNode.prototype.wrapWithBlockNode = function (nodes, collectionNodes) {
+            var wrapperElement = ej2_base_1.createElement('p');
+            for (var i = 0; i < nodes.length; i++) {
+                var child = nodes[i];
+                if (child.nodeName === 'BR') {
+                    child.parentNode.insertBefore(wrapperElement, child);
+                    wrapperElement.appendChild(child);
+                    if (wrapperElement.childNodes.length > 0) {
+                        collectionNodes.push(wrapperElement);
+                    }
+                    wrapperElement = ej2_base_1.createElement('p');
+                }
+                else {
+                    if (!this.isBlockNode(child)) {
+                        if (child.nodeName === '#text' && child.textContent.trim() === '') {
+                            continue;
+                        }
+                        if (wrapperElement.childElementCount === 0) {
+                            child.parentNode.insertBefore(wrapperElement, child);
+                            wrapperElement.appendChild(child);
+                        }
+                        else {
+                            wrapperElement.appendChild(child);
+                        }
+                    }
+                    else {
+                        collectionNodes.push(child);
+                    }
+                    if ((i === nodes.length - 1) && wrapperElement.nextElementSibling &&
+                        wrapperElement.querySelectorAll('br').length === 0 &&
+                        wrapperElement.nextElementSibling.nodeName === 'BR') {
+                        wrapperElement.appendChild(wrapperElement.nextElementSibling);
+                    }
+                }
+            }
+            if (wrapperElement.childNodes.length > 0 && collectionNodes.indexOf(wrapperElement) < 0) {
+                collectionNodes.push(wrapperElement);
+            }
+        };
+        DOMNode.prototype.getImmediateBlockNode = function (node) {
+            while (node && CONSTANT.BLOCK_TAGS.indexOf(node.nodeName.toLocaleLowerCase()) < 0) {
+                node = node.parentNode;
+            }
+            return node;
+        };
+        return DOMNode;
+    }());
+    exports.DOMNode = DOMNode;
+});