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

package/blazorGlobalSrc/editor-manager/plugin/alignments.d.ts

@@ -0,0 +1,26 @@
+import { EditorManager } from './../base/editor-manager';
+/**
+ * Formats internal component
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class Alignments {
+    private parent;
+    private alignments;
+    /**
+     * Constructor for creating the Formats plugin
+     *
+     * @param {EditorManager} parent - specifies the parent element.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    constructor(parent: EditorManager);
+    private addEventListener;
+    private removeEventListener;
+    private onKeyDown;
+    private getTableNode;
+    private applyAlignment;
+    destroy(): void;
+}

package/blazorGlobalSrc/editor-manager/plugin/alignments.js

@@ -0,0 +1,105 @@
+define(["require", "exports", "./../base/constant", "@syncfusion/ej2-base", "./../../common/constant", "../../common/util"], function (require, exports, CONSTANT, ej2_base_1, EVENTS, util_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var Alignments = (function () {
+        function Alignments(parent) {
+            this.alignments = {
+                'JustifyLeft': 'left',
+                'JustifyCenter': 'center',
+                'JustifyRight': 'right',
+                'JustifyFull': 'justify'
+            };
+            this.parent = parent;
+            this.addEventListener();
+        }
+        Alignments.prototype.addEventListener = function () {
+            this.parent.observer.on(CONSTANT.ALIGNMENT_TYPE, this.applyAlignment, this);
+            this.parent.observer.on(EVENTS.KEY_DOWN_HANDLER, this.onKeyDown, this);
+            this.parent.observer.on(EVENTS.INTERNAL_DESTROY, this.destroy, this);
+        };
+        Alignments.prototype.removeEventListener = function () {
+            this.parent.observer.off(CONSTANT.ALIGNMENT_TYPE, this.applyAlignment);
+            this.parent.observer.off(EVENTS.KEY_DOWN_HANDLER, this.onKeyDown);
+            this.parent.observer.off(EVENTS.INTERNAL_DESTROY, this.destroy);
+        };
+        Alignments.prototype.onKeyDown = function (e) {
+            switch (e.event.action) {
+                case 'justify-center':
+                    this.applyAlignment({ subCommand: 'JustifyCenter', callBack: e.callBack });
+                    e.event.preventDefault();
+                    break;
+                case 'justify-full':
+                    this.applyAlignment({ subCommand: 'JustifyFull', callBack: e.callBack });
+                    e.event.preventDefault();
+                    break;
+                case 'justify-left':
+                    this.applyAlignment({ subCommand: 'JustifyLeft', callBack: e.callBack });
+                    e.event.preventDefault();
+                    break;
+                case 'justify-right':
+                    this.applyAlignment({ subCommand: 'JustifyRight', callBack: e.callBack });
+                    e.event.preventDefault();
+                    break;
+            }
+        };
+        Alignments.prototype.getTableNode = function (range) {
+            var startNode = range.startContainer.nodeType === Node.ELEMENT_NODE
+                ? range.startContainer : range.startContainer.parentNode;
+            var cellNode = ej2_base_1.closest(startNode, 'td,th');
+            return [cellNode];
+        };
+        Alignments.prototype.applyAlignment = function (e) {
+            var isTableAlign = e.value === 'Table' ? true : false;
+            var range = this.parent.nodeSelection.getRange(this.parent.currentDocument);
+            var save = this.parent.nodeSelection.save(range, this.parent.currentDocument);
+            if (!isTableAlign) {
+                this.parent.domNode.setMarker(save);
+                var alignmentNodes = this.parent.domNode.blockNodes();
+                if (e.enterAction === 'BR') {
+                    alignmentNodes = this.parent.domNode.convertToBlockNodes(alignmentNodes, false);
+                }
+                for (var i = 0; i < alignmentNodes.length; i++) {
+                    var parentNode = alignmentNodes[i];
+                    ej2_base_1.setStyleAttribute(parentNode, { 'text-align': this.alignments[e.subCommand] });
+                }
+                var imageTags = this.parent.domNode.getImageTagInSelection();
+                for (var i = 0; i < imageTags.length; i++) {
+                    var elementNode = [];
+                    elementNode.push(imageTags[i]);
+                    this.parent.imgObj.imageCommand({
+                        item: {
+                            selectNode: elementNode
+                        },
+                        subCommand: e.subCommand,
+                        value: e.subCommand,
+                        callBack: e.callBack,
+                        selector: e.selector
+                    });
+                }
+                this.parent.editableElement.focus({ preventScroll: true });
+                save = this.parent.domNode.saveMarker(save);
+                if (util_1.isIDevice()) {
+                    util_1.setEditFrameFocus(this.parent.editableElement, e.selector);
+                }
+                save.restore();
+            }
+            else {
+                ej2_base_1.setStyleAttribute(this.getTableNode(range)[0], { 'text-align': this.alignments[e.subCommand] });
+            }
+            if (e.callBack) {
+                e.callBack({
+                    requestType: e.subCommand,
+                    editorMode: 'HTML',
+                    event: e.event,
+                    range: this.parent.nodeSelection.getRange(this.parent.currentDocument),
+                    elements: (isTableAlign ? this.getTableNode(range) : this.parent.domNode.blockNodes())
+                });
+            }
+        };
+        Alignments.prototype.destroy = function () {
+            this.removeEventListener();
+        };
+        return Alignments;
+    }());
+    exports.Alignments = Alignments;
+});

package/blazorGlobalSrc/editor-manager/plugin/audio.d.ts

@@ -0,0 +1,34 @@
+import { EditorManager } from './../base/editor-manager';
+import { IHtmlItem } from './../base/interface';
+/**
+ * Audio internal component
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class AudioCommand {
+    private parent;
+    /**
+     * Constructor for creating the Audio plugin
+     *
+     * @param {EditorManager} parent - specifies the parent element
+     * @hidden
+     * @deprecated
+     */
+    constructor(parent: EditorManager);
+    private addEventListener;
+    private removeEventListener;
+    /**
+     * audioCommand method
+     *
+     * @param {IHtmlItem} e - specifies the element
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    audioCommand(e: IHtmlItem): void;
+    private createAudio;
+    private setStyle;
+    private callBack;
+    destroy(): void;
+}

package/blazorGlobalSrc/editor-manager/plugin/audio.js

@@ -0,0 +1,145 @@
+define(["require", "exports", "@syncfusion/ej2-base", "./../base/constant", "./../base/classes", "./inserthtml", "./../../common/constant", "../../common/util"], function (require, exports, ej2_base_1, CONSTANT, classes, inserthtml_1, EVENTS, util_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var AudioCommand = (function () {
+        function AudioCommand(parent) {
+            this.parent = parent;
+            this.addEventListener();
+        }
+        AudioCommand.prototype.addEventListener = function () {
+            this.parent.observer.on(CONSTANT.AUDIO, this.audioCommand, this);
+            this.parent.observer.on(EVENTS.INTERNAL_DESTROY, this.destroy, this);
+        };
+        AudioCommand.prototype.removeEventListener = function () {
+            this.parent.observer.off(CONSTANT.AUDIO, this.audioCommand);
+            this.parent.observer.off(EVENTS.INTERNAL_DESTROY, this.destroy);
+        };
+        AudioCommand.prototype.audioCommand = function (e) {
+            var selectNode;
+            var audiowrapper;
+            var value = e.value.toString().toLowerCase();
+            if (value === 'inline' || value === 'break' || value === 'audioremove') {
+                selectNode = e.item.selectNode[0];
+                audiowrapper = selectNode.closest('.' + classes.CLASS_AUDIO_WRAP);
+            }
+            switch (value) {
+                case 'audio':
+                case 'audioreplace':
+                    this.createAudio(e);
+                    break;
+                case 'inline':
+                    selectNode.removeAttribute('class');
+                    audiowrapper.style.display = 'inline-block';
+                    ej2_base_1.addClass([selectNode], [classes.CLASS_AUDIO, classes.CLASS_AUDIO_INLINE, classes.CLASS_AUDIO_FOCUS]);
+                    this.callBack(e);
+                    break;
+                case 'break':
+                    selectNode.removeAttribute('class');
+                    audiowrapper.style.display = 'block';
+                    ej2_base_1.addClass([selectNode], [classes.CLASS_AUDIO_BREAK, classes.CLASS_AUDIO, classes.CLASS_AUDIO_FOCUS]);
+                    this.callBack(e);
+                    break;
+                case 'audioremove':
+                    if (audiowrapper) {
+                        ej2_base_1.detach(audiowrapper);
+                    }
+                    else {
+                        ej2_base_1.detach(selectNode);
+                    }
+                    this.callBack(e);
+                    break;
+            }
+        };
+        AudioCommand.prototype.createAudio = function (e) {
+            var _this = this;
+            var isReplaced = false;
+            var wrapElement;
+            if (!ej2_base_1.isNullOrUndefined(e.item.selectParent) && e.item.selectParent[0].classList &&
+                (e.item.selectParent[0].classList.contains(classes.CLASS_CLICK_ELEM) ||
+                    e.item.selectParent[0].classList.contains(classes.CLASS_AUDIO_WRAP) || e.item.selectParent[0].tagName === 'AUDIO')) {
+                var audioEle = e.item.selectParent[0].querySelector('source');
+                this.setStyle(audioEle, e);
+                isReplaced = true;
+            }
+            else {
+                wrapElement = ej2_base_1.createElement('span', { className: classes.CLASS_AUDIO_WRAP, attrs: { contentEditable: 'false', title: ((!ej2_base_1.isNullOrUndefined(e.item.title)) ? e.item.title : (!ej2_base_1.isNullOrUndefined(e.item.fileName) ? e.item.fileName : '')) } });
+                var audElement = ej2_base_1.createElement('audio', { className: classes.CLASS_AUDIO + ' ' + classes.CLASS_AUDIO_INLINE, attrs: { controls: '' } });
+                var sourceElement = ej2_base_1.createElement('source');
+                var clickElement = ej2_base_1.createElement('span', { className: classes.CLASS_CLICK_ELEM });
+                this.setStyle(sourceElement, e);
+                audElement.appendChild(sourceElement);
+                clickElement.appendChild(audElement);
+                wrapElement.appendChild(clickElement);
+                if (!ej2_base_1.isNullOrUndefined(e.item.selection)) {
+                    e.item.selection.restore();
+                }
+                inserthtml_1.InsertHtml.Insert(this.parent.currentDocument, wrapElement, this.parent.editableElement);
+                if (!ej2_base_1.isNullOrUndefined(e.item.selection)) {
+                    var range = e.item.selection.getRange(this.parent.currentDocument);
+                    var focusNode = document.createTextNode(' ');
+                    var node = this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument)[0];
+                    wrapElement.parentNode.insertBefore(focusNode, node.nextSibling);
+                    var save = e.item.selection.save(range, this.parent.currentDocument);
+                }
+            }
+            if (e.callBack && (ej2_base_1.isNullOrUndefined(e.selector) || !ej2_base_1.isNullOrUndefined(e.selector) && e.selector !== 'pasteCleanupModule')) {
+                var selectedNode = this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument)[0];
+                var audioElm_1 = (e.value === 'AudioReplace' || isReplaced) ? ((e.item.selectParent[0].tagName.toLowerCase() === 'audio') ? e.item.selectParent[0] : e.item.selectParent[0].querySelector('audio'))
+                    : (ej2_base_1.Browser.isIE ? selectedNode : selectedNode.querySelector('audio'));
+                audioElm_1.addEventListener('loadeddata', function () {
+                    if (e.value !== 'AudioReplace' || !isReplaced) {
+                        if (!ej2_base_1.isNullOrUndefined(_this.parent.currentDocument)) {
+                            if (_this.parent.userAgentData.isSafari()) {
+                                util_1.scrollToCursor(_this.parent.currentDocument, _this.parent.editableElement);
+                            }
+                            e.callBack({
+                                requestType: 'Audios',
+                                editorMode: 'HTML',
+                                event: e.event,
+                                range: _this.parent.nodeSelection.getRange(_this.parent.currentDocument),
+                                elements: [audioElm_1]
+                            });
+                        }
+                    }
+                });
+                if (isReplaced) {
+                    audioElm_1.load();
+                }
+            }
+        };
+        AudioCommand.prototype.setStyle = function (sourceElement, e) {
+            if (!ej2_base_1.isNullOrUndefined(e.item.url)) {
+                sourceElement.setAttribute('src', e.item.url);
+            }
+            var fileExtension = e.item.fileName ? e.item.fileName.split('.').pop().toLowerCase() :
+                e.item.url ? e.item.url.split('.').pop().toLowerCase() : '';
+            if (fileExtension === 'opus') {
+                sourceElement.type = 'audio/ogg';
+            }
+            else if (fileExtension === 'm4a') {
+                sourceElement.type = 'audio/mp4';
+            }
+            else {
+                sourceElement.type = e.item.fileName && e.item.fileName.split('.').length > 0 ?
+                    'audio/' + e.item.fileName.split('.')[e.item.fileName.split('.').length - 1] :
+                    e.item.url && e.item.url.split('.').length > 0 ? 'audio/' + e.item.url.split('.')[e.item.url.split('.').length - 1] : '';
+            }
+        };
+        AudioCommand.prototype.callBack = function (e) {
+            if (e.callBack) {
+                e.callBack({
+                    requestType: e.item.subCommand,
+                    editorMode: 'HTML',
+                    event: e.event,
+                    range: this.parent.nodeSelection.getRange(this.parent.currentDocument),
+                    elements: this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument)
+                });
+            }
+        };
+        AudioCommand.prototype.destroy = function () {
+            this.removeEventListener();
+        };
+        return AudioCommand;
+    }());
+    exports.AudioCommand = AudioCommand;
+});

package/blazorGlobalSrc/editor-manager/plugin/clearformat-exec.d.ts

@@ -0,0 +1,24 @@
+import { EditorManager } from './../base/editor-manager';
+/**
+ * Clear Format EXEC internal component
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class ClearFormatExec {
+    private parent;
+    /**
+     * Constructor for creating the Formats plugin
+     *
+     * @param {EditorManager} parent - specifies the parent element.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    constructor(parent: EditorManager);
+    private addEventListener;
+    private removeEventListener;
+    private onKeyDown;
+    private applyClear;
+    destroy(): void;
+}

package/blazorGlobalSrc/editor-manager/plugin/clearformat-exec.js

@@ -0,0 +1,47 @@
+define(["require", "exports", "./../base/constant", "./clearformat", "./../../common/constant"], function (require, exports, CONSTANT, clearformat_1, EVENTS) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ClearFormatExec = (function () {
+        function ClearFormatExec(parent) {
+            this.parent = parent;
+            this.addEventListener();
+        }
+        ClearFormatExec.prototype.addEventListener = function () {
+            this.parent.observer.on(CONSTANT.CLEAR_TYPE, this.applyClear, this);
+            this.parent.observer.on(EVENTS.KEY_DOWN_HANDLER, this.onKeyDown, this);
+            this.parent.observer.on(EVENTS.INTERNAL_DESTROY, this.destroy, this);
+        };
+        ClearFormatExec.prototype.removeEventListener = function () {
+            this.parent.observer.off(CONSTANT.CLEAR_TYPE, this.applyClear);
+            this.parent.observer.off(EVENTS.KEY_DOWN_HANDLER, this.onKeyDown);
+            this.parent.observer.off(EVENTS.INTERNAL_DESTROY, this.destroy);
+        };
+        ClearFormatExec.prototype.onKeyDown = function (e) {
+            switch (e.event.action) {
+                case 'clear-format':
+                    this.applyClear({ subCommand: 'ClearFormat', callBack: e.callBack, enterAction: e.enterAction });
+                    e.event.preventDefault();
+                    break;
+            }
+        };
+        ClearFormatExec.prototype.applyClear = function (e) {
+            if (e.subCommand === 'ClearFormat') {
+                clearformat_1.ClearFormat.clear(this.parent.currentDocument, this.parent.editableElement, e.enterAction, e.selector, e.subCommand);
+                if (e.callBack) {
+                    e.callBack({
+                        requestType: e.subCommand,
+                        event: e.event,
+                        editorMode: 'HTML',
+                        range: this.parent.nodeSelection.getRange(this.parent.currentDocument),
+                        elements: this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument)
+                    });
+                }
+            }
+        };
+        ClearFormatExec.prototype.destroy = function () {
+            this.removeEventListener();
+        };
+        return ClearFormatExec;
+    }());
+    exports.ClearFormatExec = ClearFormatExec;
+});

package/blazorGlobalSrc/editor-manager/plugin/clearformat.d.ts

@@ -0,0 +1,29 @@
+export declare class ClearFormat {
+    private static BLOCK_TAGS;
+    private static NONVALID_PARENT_TAGS;
+    private static IGNORE_PARENT_TAGS;
+    private static NONVALID_TAGS;
+    private static defaultTag;
+    private static domNode;
+    /**
+     * clear method
+     *
+     * @param {Document} docElement - specifies the document element.
+     * @param {Node} endNode - specifies the end node
+     * @param {string} enterAction - specifies the enter key action
+     * @param {string} selector - specifies the string value
+     * @param {string} command - specifies the command value
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    static clear(docElement: Document, endNode: Node, enterAction: string, selector?: string, command?: string): void;
+    private static reSelection;
+    private static clearBlocks;
+    private static spliceParent;
+    private static removeChild;
+    private static removeParent;
+    private static unWrap;
+    private static clearInlines;
+    private static removeInlineParent;
+}

package/blazorGlobalSrc/editor-manager/plugin/clearformat.js

@@ -0,0 +1,249 @@
+define(["require", "exports", "@syncfusion/ej2-base", "./../../selection/index", "./nodecutter", "./dom-node", "./insert-methods", "./isformatted", "../../common/util"], function (require, exports, ej2_base_1, index_1, nodecutter_1, dom_node_1, insert_methods_1, isformatted_1, util_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ClearFormat = (function () {
+        function ClearFormat() {
+        }
+        ClearFormat.clear = function (docElement, endNode, enterAction, selector, command) {
+            this.domNode = new dom_node_1.DOMNode(endNode, docElement);
+            this.defaultTag = enterAction === 'P' ? 'p' : 'div';
+            var nodeSelection = new index_1.NodeSelection(endNode);
+            var nodeCutter = new nodecutter_1.NodeCutter();
+            var range = nodeSelection.getRange(docElement);
+            var nodes = range.collapsed ? nodeSelection.getSelectionNodeCollection(range) :
+                nodeSelection.getSelectionNodeCollectionBr(range);
+            var save = nodeSelection.save(range, docElement);
+            var cursorRange = false;
+            if (range.collapsed && command !== 'ClearFormat') {
+                cursorRange = true;
+                range = nodeCutter.GetCursorRange(docElement, range, nodes[0]);
+            }
+            var isCollapsed = range.collapsed;
+            if (!isCollapsed) {
+                var preNode = void 0;
+                if (nodes.length > 0 && nodes[0].nodeName === 'BR' && ej2_base_1.closest(nodes[0], 'table')) {
+                    preNode = nodeCutter.GetSpliceNode(range, ej2_base_1.closest(nodes[0], 'table'));
+                }
+                else {
+                    preNode = nodeCutter.GetSpliceNode(range, nodes[nodes.length > 1 && nodes[0].nodeName === 'IMG' ? 1 : 0]);
+                }
+                if (nodes.length === 1) {
+                    nodeSelection.setSelectionContents(docElement, preNode);
+                    range = nodeSelection.getRange(docElement);
+                }
+                else if (nodes.length > 1) {
+                    var i = 1;
+                    var lastText = nodes[nodes.length - i];
+                    while (nodes.length <= i && nodes[nodes.length - i].nodeName === 'BR') {
+                        i++;
+                        lastText = nodes[nodes.length - i];
+                    }
+                    var lasNode = nodeCutter.GetSpliceNode(range, lastText);
+                    if (lasNode) {
+                        nodeSelection.setSelectionText(docElement, preNode, lasNode, 0, (lasNode.nodeType === 3) ?
+                            lasNode.textContent.length : lasNode.childNodes.length);
+                    }
+                    range = nodeSelection.getRange(docElement);
+                }
+                var exactNodes = nodeSelection.getNodeCollection(range);
+                var cloneSelectNodes = exactNodes.slice();
+                this.clearInlines(nodeSelection.getSelectionNodes(cloneSelectNodes), cloneSelectNodes, nodeSelection.getRange(docElement), nodeCutter, endNode);
+                this.reSelection(docElement, save, exactNodes);
+                range = nodeSelection.getRange(docElement);
+                exactNodes = nodeSelection.getNodeCollection(range);
+                var cloneParentNodes = exactNodes.slice();
+                this.clearBlocks(docElement, cloneParentNodes, endNode, nodeCutter, nodeSelection);
+                if (util_1.isIDevice()) {
+                    util_1.setEditFrameFocus(endNode, selector);
+                }
+                this.reSelection(docElement, save, exactNodes);
+            }
+            if (cursorRange) {
+                nodeSelection.setCursorPoint(docElement, range.endContainer, range.endOffset);
+            }
+        };
+        ClearFormat.reSelection = function (docElement, save, exactNodes) {
+            var selectionNodes = save.getInsertNodes(exactNodes);
+            save.startContainer = save.getNodeArray(selectionNodes[0], true, docElement);
+            save.startOffset = 0;
+            save.endContainer = save.getNodeArray(selectionNodes[selectionNodes.length - 1], false, docElement);
+            var endIndexNode = selectionNodes[selectionNodes.length - 1];
+            save.endOffset = (endIndexNode.nodeType === 3) ? endIndexNode.textContent.length
+                : endIndexNode.childNodes.length;
+            save.restore();
+        };
+        ClearFormat.clearBlocks = function (docElement, nodes, endNode, nodeCutter, nodeSelection) {
+            var parentNodes = [];
+            for (var index = 0; index < nodes.length; index++) {
+                if (this.BLOCK_TAGS.indexOf(nodes[index].nodeName.toLocaleLowerCase()) > -1
+                    && parentNodes.indexOf(nodes[index]) === -1) {
+                    parentNodes.push(nodes[index]);
+                }
+                else if ((this.BLOCK_TAGS.indexOf(nodes[index].parentNode.nodeName.toLocaleLowerCase()) > -1)
+                    && parentNodes.indexOf(nodes[index].parentNode) === -1
+                    && endNode !== nodes[index].parentNode) {
+                    parentNodes.push(nodes[index].parentNode);
+                }
+            }
+            parentNodes = this.spliceParent(parentNodes, nodes)[0];
+            parentNodes = this.removeParent(parentNodes);
+            this.unWrap(docElement, parentNodes, nodeCutter, nodeSelection);
+        };
+        ClearFormat.spliceParent = function (parentNodes, nodes) {
+            for (var index1 = 0; index1 < parentNodes.length; index1++) {
+                var len = parentNodes[index1].childNodes.length;
+                for (var index2 = 0; index2 < len; index2++) {
+                    if ((nodes.indexOf(parentNodes[index1].childNodes[index2]) > 0)
+                        && (parentNodes[index1].childNodes[index2].childNodes.length > 0)) {
+                        nodes = this.spliceParent([parentNodes[index1].childNodes[index2]], nodes)[1];
+                    }
+                    if ((nodes.indexOf(parentNodes[index1].childNodes[index2]) <= -1) &&
+                        (parentNodes[index1].childNodes[index2].textContent.trim() !== '')) {
+                        for (var index3 = 0; index3 < len; index3++) {
+                            if (nodes.indexOf(parentNodes[index1].childNodes[index3]) > -1) {
+                                nodes.splice(nodes.indexOf(parentNodes[index1].childNodes[index3]), 1);
+                            }
+                        }
+                        index2 = parentNodes[index1].childNodes.length;
+                        var parentIndex = parentNodes.indexOf(parentNodes[index1].parentNode);
+                        var nodeIndex = nodes.indexOf(parentNodes[index1].parentNode);
+                        if (parentIndex > -1) {
+                            parentNodes.splice(parentIndex, 1);
+                        }
+                        if (nodeIndex > -1) {
+                            nodes.splice(nodeIndex, 1);
+                        }
+                        var elementIndex = nodes.indexOf(parentNodes[index1]);
+                        if (elementIndex > -1) {
+                            nodes.splice(elementIndex, 1);
+                        }
+                        parentNodes.splice(index1, 1);
+                        index1--;
+                    }
+                }
+            }
+            return [parentNodes, nodes];
+        };
+        ClearFormat.removeChild = function (parentNodes, parentNode) {
+            var count = parentNode.childNodes.length;
+            if (count > 0) {
+                for (var index = 0; index < count; index++) {
+                    if (parentNodes.indexOf(parentNode.childNodes[index]) > -1) {
+                        parentNodes = this.removeChild(parentNodes, parentNode.childNodes[index]);
+                        parentNodes.splice(parentNodes.indexOf(parentNode.childNodes[index]), 1);
+                    }
+                }
+            }
+            return parentNodes;
+        };
+        ClearFormat.removeParent = function (parentNodes) {
+            for (var index = 0; index < parentNodes.length; index++) {
+                if (parentNodes.indexOf(parentNodes[index].parentNode) > -1) {
+                    parentNodes = this.removeChild(parentNodes, parentNodes[index]);
+                    parentNodes.splice(index, 1);
+                    index--;
+                }
+            }
+            return parentNodes;
+        };
+        ClearFormat.unWrap = function (docElement, parentNodes, nodeCutter, nodeSelection) {
+            for (var index1 = 0; index1 < parentNodes.length; index1++) {
+                parentNodes[index1] = (ej2_base_1.closest(parentNodes[index1], 'li') && parentNodes[index1].nodeName !== 'UL' && parentNodes[index1].nodeName !== 'OL')
+                    ? ej2_base_1.closest(parentNodes[index1], 'li')
+                    : parentNodes[index1];
+                if (this.NONVALID_TAGS.indexOf(parentNodes[index1].nodeName.toLowerCase()) > -1
+                    && parentNodes[index1].parentNode
+                    && this.NONVALID_PARENT_TAGS.indexOf(parentNodes[index1].parentNode.nodeName.toLowerCase()) > -1) {
+                    nodeSelection.setSelectionText(docElement, parentNodes[index1], parentNodes[index1], 0, parentNodes[index1].childNodes.length);
+                    insert_methods_1.InsertMethods.unwrap(nodeCutter.GetSpliceNode(nodeSelection.getRange(docElement), parentNodes[index1].parentNode));
+                }
+                var blockquoteNode = ej2_base_1.closest(parentNodes[index1], 'blockquote');
+                if (parentNodes[index1].nodeName.toLocaleLowerCase() !== 'blockquote' && !ej2_base_1.isNullOrUndefined(blockquoteNode) && blockquoteNode.textContent === parentNodes[index1].textContent) {
+                    var blockNodes = this.removeParent([blockquoteNode]);
+                    this.unWrap(docElement, blockNodes, nodeCutter, nodeSelection);
+                }
+                if (parentNodes[index1].nodeName.toLocaleLowerCase() !== 'p') {
+                    if (this.NONVALID_PARENT_TAGS.indexOf(parentNodes[index1].nodeName.toLowerCase()) < 0
+                        && !((parentNodes[index1].nodeName.toLocaleLowerCase() === 'blockquote'
+                            || parentNodes[index1].nodeName.toLocaleLowerCase() === 'li')
+                            && this.IGNORE_PARENT_TAGS.indexOf(parentNodes[index1].childNodes[0].nodeName.toLocaleLowerCase()) > -1)
+                        && !(parentNodes[index1].childNodes.length === 1
+                            && parentNodes[index1].childNodes[0].nodeName.toLocaleLowerCase() === 'p')) {
+                        insert_methods_1.InsertMethods.Wrap(parentNodes[index1], docElement.createElement(this.defaultTag));
+                    }
+                    var childNodes = insert_methods_1.InsertMethods.unwrap(parentNodes[index1]);
+                    if (childNodes.length === 1
+                        && childNodes[0].parentNode.nodeName.toLocaleLowerCase() === 'p') {
+                        insert_methods_1.InsertMethods.Wrap(parentNodes[index1], docElement.createElement(this.defaultTag));
+                        insert_methods_1.InsertMethods.unwrap(parentNodes[index1]);
+                    }
+                    for (var index2 = 0; index2 < childNodes.length; index2++) {
+                        if (this.NONVALID_TAGS.indexOf(childNodes[index2].nodeName.toLowerCase()) > -1) {
+                            this.unWrap(docElement, [childNodes[index2]], nodeCutter, nodeSelection);
+                        }
+                        else if (this.BLOCK_TAGS.indexOf(childNodes[index2].nodeName.toLocaleLowerCase()) > -1 &&
+                            childNodes[index2].nodeName.toLocaleLowerCase() !== 'p') {
+                            var blockNodes = this.removeParent([childNodes[index2]]);
+                            this.unWrap(docElement, blockNodes, nodeCutter, nodeSelection);
+                        }
+                        else if (this.BLOCK_TAGS.indexOf(childNodes[index2].nodeName.toLocaleLowerCase()) > -1 &&
+                            childNodes[index2].nodeName.toLocaleLowerCase() === 'p') {
+                            if (childNodes[index2].parentNode.nodeName.toLocaleLowerCase() === 'p') {
+                                insert_methods_1.InsertMethods.unwrap(childNodes[index2].parentNode);
+                            }
+                            insert_methods_1.InsertMethods.Wrap(childNodes[index2], docElement.createElement(this.defaultTag));
+                            insert_methods_1.InsertMethods.unwrap(childNodes[index2]);
+                        }
+                        else if (this.BLOCK_TAGS.indexOf(childNodes[index2].nodeName.toLocaleLowerCase()) > -1 &&
+                            childNodes[index2].parentNode.nodeName.toLocaleLowerCase() ===
+                                childNodes[index2].nodeName.toLocaleLowerCase()) {
+                            insert_methods_1.InsertMethods.unwrap(childNodes[index2]);
+                        }
+                    }
+                }
+                else {
+                    insert_methods_1.InsertMethods.Wrap(parentNodes[index1], docElement.createElement(this.defaultTag));
+                    insert_methods_1.InsertMethods.unwrap(parentNodes[index1]);
+                }
+            }
+        };
+        ClearFormat.clearInlines = function (textNodes, nodes, range, nodeCutter, endNode) {
+            for (var index = 0; index < textNodes.length; index++) {
+                var currentInlineNode = textNodes[index];
+                var currentNode = void 0;
+                while (!this.domNode.isBlockNode(currentInlineNode) &&
+                    (currentInlineNode.parentElement && !currentInlineNode.parentElement.classList.contains('e-img-inner'))) {
+                    currentNode = currentInlineNode;
+                    currentInlineNode = currentInlineNode.parentElement;
+                }
+                if (currentNode &&
+                    isformatted_1.IsFormatted.inlineTags.indexOf(currentNode.nodeName.toLocaleLowerCase()) > -1) {
+                    nodeCutter.GetSpliceNode(range, currentNode);
+                    this.removeInlineParent(currentNode);
+                }
+            }
+        };
+        ClearFormat.removeInlineParent = function (textNodes) {
+            var nodes = insert_methods_1.InsertMethods.unwrap(textNodes);
+            for (var index = 0; index < nodes.length; index++) {
+                if (nodes[index].parentNode.childNodes.length === 1 && !nodes[index].parentNode.classList.contains('e-img-inner')
+                    && isformatted_1.IsFormatted.inlineTags.indexOf(nodes[index].parentNode.nodeName.toLocaleLowerCase()) > -1) {
+                    this.removeInlineParent(nodes[index].parentNode);
+                }
+                else if (isformatted_1.IsFormatted.inlineTags.indexOf(nodes[index].nodeName.toLocaleLowerCase()) > -1) {
+                    this.removeInlineParent(nodes[index]);
+                }
+            }
+        };
+        ClearFormat.BLOCK_TAGS = ['address', 'article', 'aside', 'blockquote',
+            'details', 'dd', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer',
+            'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'li', 'main', 'nav',
+            'noscript', 'ol', 'p', 'pre', 'section', 'ul'];
+        ClearFormat.NONVALID_PARENT_TAGS = ['thead', 'tbody', 'ul', 'ol', 'table', 'tfoot', 'tr'];
+        ClearFormat.IGNORE_PARENT_TAGS = ['ul', 'ol', 'table'];
+        ClearFormat.NONVALID_TAGS = ['thead', 'tbody', 'figcaption', 'td', 'tr', 'th', 'tfoot', 'figcaption', 'li'];
+        ClearFormat.defaultTag = 'p';
+        return ClearFormat;
+    }());
+    exports.ClearFormat = ClearFormat;
+});