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

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

@@ -0,0 +1,399 @@
+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 ImageCommand = (function () {
+        function ImageCommand(parent) {
+            this.parent = parent;
+            this.addEventListener();
+        }
+        ImageCommand.prototype.addEventListener = function () {
+            this.parent.observer.on(CONSTANT.IMAGE, this.imageCommand, this);
+            this.parent.observer.on(EVENTS.INTERNAL_DESTROY, this.destroy, this);
+        };
+        ImageCommand.prototype.removeEventListener = function () {
+            this.parent.observer.off(CONSTANT.IMAGE, this.imageCommand);
+            this.parent.observer.off(EVENTS.INTERNAL_DESTROY, this.destroy);
+        };
+        ImageCommand.prototype.imageCommand = function (e) {
+            switch (e.value.toString().toLowerCase()) {
+                case 'image':
+                case 'replace':
+                    this.createImage(e);
+                    break;
+                case 'insertlink':
+                    this.insertImageLink(e);
+                    break;
+                case 'openimagelink':
+                    this.openImageLink(e);
+                    break;
+                case 'editimagelink':
+                    this.editImageLink(e);
+                    break;
+                case 'removeimagelink':
+                    this.removeImageLink(e);
+                    break;
+                case 'remove':
+                    this.removeImage(e);
+                    break;
+                case 'alttext':
+                    this.insertAltTextImage(e);
+                    break;
+                case 'dimension':
+                    this.imageDimension(e);
+                    break;
+                case 'caption':
+                    this.imageCaption(e);
+                    break;
+                case 'justifyleft':
+                    this.imageJustifyLeft(e);
+                    break;
+                case 'justifycenter':
+                    this.imageJustifyCenter(e);
+                    break;
+                case 'justifyright':
+                    this.imageJustifyRight(e);
+                    break;
+                case 'inline':
+                    this.imageInline(e);
+                    break;
+                case 'break':
+                    this.imageBreak(e);
+                    break;
+            }
+        };
+        ImageCommand.prototype.createImage = function (e) {
+            var _this = this;
+            var isReplaced = false;
+            e.item.url = ej2_base_1.isNullOrUndefined(e.item.url) || e.item.url === 'undefined' ? e.item.src : e.item.url;
+            if (!ej2_base_1.isNullOrUndefined(e.item.selectParent) && e.item.selectParent[0].tagName === 'IMG') {
+                var imgEle = e.item.selectParent[0];
+                isReplaced = true;
+                this.setStyle(imgEle, e, isReplaced);
+            }
+            else {
+                var imgElement = ej2_base_1.createElement('img');
+                this.setStyle(imgElement, e);
+                if (!ej2_base_1.isNullOrUndefined(e.item.selection)) {
+                    e.item.selection.restore();
+                }
+                if (!ej2_base_1.isNullOrUndefined(e.selector) && e.selector === 'pasteCleanupModule') {
+                    if (!ej2_base_1.isNullOrUndefined(this.parent.currentDocument)) {
+                        e.callBack({ requestType: 'Images',
+                            editorMode: 'HTML',
+                            event: e.event,
+                            range: this.parent.nodeSelection.getRange(this.parent.currentDocument),
+                            elements: [imgElement]
+                        });
+                    }
+                }
+                else {
+                    inserthtml_1.InsertHtml.Insert(this.parent.currentDocument, imgElement, this.parent.editableElement);
+                }
+            }
+            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 imgElm_1 = (e.value === 'Replace' || isReplaced) ? e.item.selectParent[0] :
+                    (ej2_base_1.Browser.isIE ? selectedNode.previousSibling : selectedNode.previousElementSibling);
+                var onImageLoadEvent_1 = function () {
+                    if (!ej2_base_1.isNullOrUndefined(_this.parent.currentDocument)) {
+                        if (_this.parent.userAgentData.isSafari()) {
+                            util_1.scrollToCursor(_this.parent.currentDocument, _this.parent.editableElement);
+                        }
+                        var imgWidth = imgElm_1.getAttribute('width');
+                        var imgHeight = imgElm_1.getAttribute('height');
+                        if (ej2_base_1.isNullOrUndefined(imgWidth) || imgWidth === 'auto') {
+                            imgElm_1.setAttribute('width', imgElm_1.offsetWidth.toString());
+                        }
+                        if (ej2_base_1.isNullOrUndefined(imgHeight) || imgHeight === 'auto') {
+                            imgElm_1.setAttribute('height', imgElm_1.offsetHeight.toString());
+                        }
+                        e.callBack({
+                            requestType: (e.value === 'Replace') ? (e.item.subCommand = 'Replace', 'Replace') : 'Images',
+                            editorMode: 'HTML',
+                            event: e.event,
+                            range: _this.parent.nodeSelection.getRange(_this.parent.currentDocument),
+                            elements: [imgElm_1]
+                        });
+                    }
+                    imgElm_1.removeEventListener('load', onImageLoadEvent_1);
+                };
+                imgElm_1.addEventListener('load', onImageLoadEvent_1);
+            }
+        };
+        ImageCommand.prototype.setStyle = function (imgElement, e, imgReplace) {
+            if (!ej2_base_1.isNullOrUndefined(e.item.url)) {
+                imgElement.setAttribute('src', e.item.url);
+            }
+            var alignClassName;
+            if (imgReplace) {
+                var alignClass = {
+                    'e-imgcenter': 'e-imgcenter',
+                    'e-imgright': 'e-imgright',
+                    'e-imgleft': 'e-imgleft'
+                };
+                var imgClassList = imgElement.classList;
+                for (var i = 0; i < imgClassList.length; i++) {
+                    if (!ej2_base_1.isNullOrUndefined(alignClass[imgClassList[i]])) {
+                        alignClassName = alignClass[imgClassList[i]];
+                    }
+                }
+            }
+            imgElement.setAttribute('class', 'e-rte-image' + (ej2_base_1.isNullOrUndefined(e.item.cssClass) ? '' : ' ' + e.item.cssClass)
+                + (ej2_base_1.isNullOrUndefined(alignClassName) ? '' : ' ' + alignClassName));
+            if (!ej2_base_1.isNullOrUndefined(e.item.altText)) {
+                imgElement.setAttribute('alt', e.item.altText.replace(/\.[a-zA-Z0-9]+$/, ''));
+            }
+            if (!ej2_base_1.isNullOrUndefined(e.item.width) && !ej2_base_1.isNullOrUndefined(e.item.width.width)) {
+                imgElement.setAttribute('width', this.calculateStyleValue(e.item.width.width));
+            }
+            if (!ej2_base_1.isNullOrUndefined(e.item.height) && !ej2_base_1.isNullOrUndefined(e.item.height.height)) {
+                imgElement.setAttribute('height', this.calculateStyleValue(e.item.height.height));
+            }
+            if (!ej2_base_1.isNullOrUndefined(e.item.width) && !ej2_base_1.isNullOrUndefined(e.item.width.minWidth)) {
+                imgElement.style.minWidth = this.calculateStyleValue(e.item.width.minWidth);
+            }
+            if (!ej2_base_1.isNullOrUndefined(e.item.width) && !ej2_base_1.isNullOrUndefined(e.item.width.maxWidth)) {
+                imgElement.style.maxWidth = this.calculateStyleValue(e.item.width.maxWidth);
+            }
+            if (!ej2_base_1.isNullOrUndefined(e.item.height) && !ej2_base_1.isNullOrUndefined(e.item.height.minHeight)) {
+                imgElement.style.minHeight = this.calculateStyleValue(e.item.height.minHeight);
+            }
+            if (!ej2_base_1.isNullOrUndefined(e.item.height) && !ej2_base_1.isNullOrUndefined(e.item.height.maxHeight)) {
+                imgElement.style.maxHeight = this.calculateStyleValue(e.item.height.maxHeight);
+            }
+        };
+        ImageCommand.prototype.calculateStyleValue = function (value) {
+            var styleValue;
+            if (typeof (value) === 'string') {
+                if (value.indexOf('px') || value.indexOf('%') || value.indexOf('auto')) {
+                    styleValue = value;
+                }
+                else {
+                    styleValue = value + 'px';
+                }
+            }
+            else {
+                styleValue = value + 'px';
+            }
+            return styleValue;
+        };
+        ImageCommand.prototype.insertImageLink = function (e) {
+            var anchor = ej2_base_1.createElement('a', {
+                attrs: {
+                    href: e.item.url
+                }
+            });
+            if (e.item.selectNode[0].parentElement.classList.contains('e-img-wrap')) {
+                e.item.selection.restore();
+                anchor.setAttribute('contenteditable', 'true');
+            }
+            anchor.appendChild(e.item.selectNode[0]);
+            if (!ej2_base_1.isNullOrUndefined(e.item.target)) {
+                anchor.setAttribute('target', e.item.target);
+            }
+            if (!ej2_base_1.isNullOrUndefined(e.item.ariaLabel)) {
+                anchor.setAttribute('aria-label', e.item.ariaLabel);
+            }
+            inserthtml_1.InsertHtml.Insert(this.parent.currentDocument, anchor, this.parent.editableElement);
+            this.callBack(e);
+        };
+        ImageCommand.prototype.openImageLink = function (e) {
+            document.defaultView.open(e.item.url, e.item.target);
+            this.callBack(e);
+        };
+        ImageCommand.prototype.removeImageLink = function (e) {
+            var selectParent = e.item.selectParent[0];
+            if (selectParent.classList.contains('e-img-caption')) {
+                var capImgWrap = ej2_base_1.select('.e-img-wrap', selectParent);
+                var textEle = ej2_base_1.select('.e-img-inner', selectParent);
+                var newTextEle = textEle.cloneNode(true);
+                ej2_base_1.detach(ej2_base_1.select('a', selectParent));
+                ej2_base_1.detach(textEle);
+                capImgWrap.appendChild(e.item.insertElement);
+                capImgWrap.appendChild(newTextEle);
+            }
+            else {
+                ej2_base_1.detach(selectParent);
+                if (ej2_base_1.Browser.isIE && e.item.selection) {
+                    e.item.selection.restore();
+                }
+                inserthtml_1.InsertHtml.Insert(this.parent.currentDocument, e.item.insertElement, this.parent.editableElement);
+            }
+            this.callBack(e);
+        };
+        ImageCommand.prototype.editImageLink = function (e) {
+            e.item.selectNode[0].parentElement.href = e.item.url;
+            if (ej2_base_1.isNullOrUndefined(e.item.target)) {
+                e.item.selectNode[0].parentElement.removeAttribute('target');
+                e.item.selectNode[0].parentElement.removeAttribute('aria-label');
+            }
+            else {
+                e.item.selectNode[0].parentElement.target = e.item.target;
+                e.item.selectNode[0].parentElement.setAttribute('aria-label', e.item.ariaLabel);
+            }
+            this.callBack(e);
+        };
+        ImageCommand.prototype.removeImage = function (e) {
+            if (ej2_base_1.closest(e.item.selectNode[0], 'a')) {
+                if (e.item.selectNode[0].parentElement.nodeName === 'A' && !ej2_base_1.isNullOrUndefined(e.item.selectNode[0].parentElement.innerText)) {
+                    if (!ej2_base_1.isNullOrUndefined(ej2_base_1.closest(e.item.selectNode[0], '.' + classes.CLASS_CAPTION))) {
+                        ej2_base_1.detach(ej2_base_1.closest(e.item.selectNode[0], '.' + classes.CLASS_CAPTION));
+                    }
+                    else {
+                        ej2_base_1.detach(e.item.selectNode[0]);
+                    }
+                }
+                else {
+                    ej2_base_1.detach(ej2_base_1.closest(e.item.selectNode[0], 'a'));
+                }
+            }
+            else if (!ej2_base_1.isNullOrUndefined(ej2_base_1.closest(e.item.selectNode[0], '.' + classes.CLASS_CAPTION))) {
+                ej2_base_1.detach(ej2_base_1.closest(e.item.selectNode[0], '.' + classes.CLASS_CAPTION));
+            }
+            else {
+                ej2_base_1.detach(e.item.selectNode[0]);
+            }
+            this.callBack(e);
+        };
+        ImageCommand.prototype.insertAltTextImage = function (e) {
+            e.item.selectNode[0].setAttribute('alt', e.item.altText);
+            this.callBack(e);
+        };
+        ImageCommand.prototype.imageDimension = function (e) {
+            var selectNode = e.item.selectNode[0];
+            selectNode.style.height = '';
+            selectNode.style.width = '';
+            if (e.item.width !== 'auto') {
+                selectNode.style.width = ej2_base_1.formatUnit(e.item.width);
+            }
+            else {
+                selectNode.removeAttribute('width');
+            }
+            if (e.item.height !== 'auto') {
+                selectNode.style.height = ej2_base_1.formatUnit(e.item.height);
+            }
+            else {
+                selectNode.removeAttribute('height');
+            }
+            this.callBack(e);
+        };
+        ImageCommand.prototype.imageCaption = function (e) {
+            inserthtml_1.InsertHtml.Insert(this.parent.currentDocument, e.item.insertElement, this.parent.editableElement);
+            this.callBack(e);
+        };
+        ImageCommand.prototype.imageJustifyLeft = function (e) {
+            var selectNode = e.item.selectNode[0];
+            if (!ej2_base_1.isNullOrUndefined(selectNode)) {
+                selectNode.removeAttribute('class');
+                ej2_base_1.addClass([selectNode], 'e-rte-image');
+                if (!ej2_base_1.isNullOrUndefined(ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION))) {
+                    ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
+                    ej2_base_1.addClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
+                }
+                if (selectNode.parentElement.nodeName === 'A') {
+                    ej2_base_1.removeClass([selectNode.parentElement], classes.CLASS_IMAGE_RIGHT);
+                    ej2_base_1.addClass([selectNode.parentElement], classes.CLASS_IMAGE_LEFT);
+                    ej2_base_1.addClass([selectNode], classes.CLASS_IMAGE_LEFT);
+                }
+                else if (selectNode.parentElement.nextElementSibling != null) {
+                    ej2_base_1.addClass([selectNode], classes.CLASS_IMAGE_LEFT);
+                    selectNode.parentElement.nextElementSibling.style.clear = 'left';
+                }
+                else {
+                    ej2_base_1.addClass([selectNode], classes.CLASS_IMAGE_LEFT);
+                }
+                this.callBack(e);
+            }
+        };
+        ImageCommand.prototype.imageJustifyCenter = function (e) {
+            var selectNode = e.item.selectNode[0];
+            if (!ej2_base_1.isNullOrUndefined(selectNode)) {
+                selectNode.removeAttribute('class');
+                ej2_base_1.addClass([selectNode], 'e-rte-image');
+                if (!ej2_base_1.isNullOrUndefined(ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION))) {
+                    ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
+                    ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
+                    ej2_base_1.addClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_CENTER);
+                }
+                if (selectNode.parentElement.nodeName === 'A') {
+                    ej2_base_1.removeClass([selectNode.parentElement], classes.CLASS_IMAGE_LEFT);
+                    ej2_base_1.removeClass([selectNode.parentElement], classes.CLASS_IMAGE_RIGHT);
+                    ej2_base_1.addClass([selectNode.parentElement], classes.CLASS_IMAGE_CENTER);
+                    ej2_base_1.addClass([selectNode], classes.CLASS_IMAGE_CENTER);
+                }
+                else {
+                    ej2_base_1.addClass([selectNode], classes.CLASS_IMAGE_CENTER);
+                }
+                this.callBack(e);
+            }
+        };
+        ImageCommand.prototype.imageJustifyRight = function (e) {
+            var selectNode = e.item.selectNode[0];
+            if (!ej2_base_1.isNullOrUndefined(selectNode)) {
+                selectNode.removeAttribute('class');
+                ej2_base_1.addClass([selectNode], 'e-rte-image');
+                if (!ej2_base_1.isNullOrUndefined(ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION))) {
+                    ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
+                    ej2_base_1.addClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
+                }
+                if (selectNode.parentElement.nodeName === 'A') {
+                    ej2_base_1.removeClass([selectNode.parentElement], classes.CLASS_IMAGE_LEFT);
+                    ej2_base_1.addClass([selectNode.parentElement], classes.CLASS_IMAGE_RIGHT);
+                    ej2_base_1.addClass([selectNode], classes.CLASS_IMAGE_RIGHT);
+                }
+                else if (selectNode.parentElement.nextElementSibling != null) {
+                    ej2_base_1.addClass([selectNode], classes.CLASS_IMAGE_RIGHT);
+                    selectNode.parentElement.nextElementSibling.style.clear = 'right';
+                }
+                else {
+                    ej2_base_1.addClass([selectNode], classes.CLASS_IMAGE_RIGHT);
+                }
+                this.callBack(e);
+            }
+        };
+        ImageCommand.prototype.imageInline = function (e) {
+            var selectNode = e.item.selectNode[0];
+            selectNode.removeAttribute('class');
+            ej2_base_1.addClass([selectNode], 'e-rte-image');
+            ej2_base_1.addClass([selectNode], classes.CLASS_IMAGE_INLINE);
+            if (!ej2_base_1.isNullOrUndefined(ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION))) {
+                ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_BREAK);
+                ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_CENTER);
+                ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
+                ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
+                ej2_base_1.addClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_CAPTION_INLINE);
+            }
+            this.callBack(e);
+        };
+        ImageCommand.prototype.imageBreak = function (e) {
+            var selectNode = e.item.selectNode[0];
+            selectNode.removeAttribute('class');
+            ej2_base_1.addClass([selectNode], classes.CLASS_IMAGE_BREAK);
+            ej2_base_1.addClass([selectNode], 'e-rte-image');
+            if (!ej2_base_1.isNullOrUndefined(ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION))) {
+                ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_CAPTION_INLINE);
+                ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_CENTER);
+                ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
+                ej2_base_1.removeClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
+                ej2_base_1.addClass([ej2_base_1.closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_BREAK);
+            }
+            this.callBack(e);
+        };
+        ImageCommand.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)
+                });
+            }
+        };
+        ImageCommand.prototype.destroy = function () {
+            this.removeEventListener();
+        };
+        return ImageCommand;
+    }());
+    exports.ImageCommand = ImageCommand;
+});

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

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

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

@@ -0,0 +1,106 @@
+define(["require", "exports", "./../base/constant", "./../../common/constant", "../../common/util"], function (require, exports, CONSTANT, EVENTS, util_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var Indents = (function () {
+        function Indents(parent) {
+            this.indentValue = 20;
+            this.parent = parent;
+            this.addEventListener();
+        }
+        Indents.prototype.addEventListener = function () {
+            this.parent.observer.on(CONSTANT.INDENT_TYPE, this.applyIndents, this);
+            this.parent.observer.on(EVENTS.KEY_DOWN_HANDLER, this.onKeyDown, this);
+            this.parent.observer.on(EVENTS.INTERNAL_DESTROY, this.destroy, this);
+        };
+        Indents.prototype.removeEventListener = function () {
+            this.parent.observer.off(CONSTANT.INDENT_TYPE, this.applyIndents);
+            this.parent.observer.off(EVENTS.KEY_DOWN_HANDLER, this.onKeyDown);
+            this.parent.observer.off(EVENTS.INTERNAL_DESTROY, this.destroy);
+        };
+        Indents.prototype.onKeyDown = function (e) {
+            switch (e.event.action) {
+                case 'indents':
+                    this.applyIndents({ subCommand: 'Indent', callBack: e.callBack });
+                    e.event.preventDefault();
+                    break;
+                case 'outdents':
+                    this.applyIndents({ subCommand: 'Outdent', callBack: e.callBack });
+                    e.event.preventDefault();
+                    break;
+            }
+        };
+        Indents.prototype.applyIndents = function (e) {
+            var editEle = this.parent.editableElement;
+            var isRtl = editEle.classList.contains('e-rtl');
+            var range = this.parent.nodeSelection.getRange(this.parent.currentDocument);
+            var save = this.parent.nodeSelection.save(range, this.parent.currentDocument);
+            this.parent.domNode.setMarker(save);
+            var indentsNodes = this.parent.domNode.blockNodes();
+            if (e.enterAction === 'BR') {
+                indentsNodes = this.parent.domNode.convertToBlockNodes(indentsNodes, false);
+            }
+            var parentNodes = indentsNodes.slice();
+            var listsNodes = [];
+            for (var i = 0; i < parentNodes.length; i++) {
+                if (parentNodes[i].tagName !== 'LI' && 'LI' === parentNodes[i].parentNode.tagName) {
+                    indentsNodes.splice(indentsNodes.indexOf(parentNodes[i]), 1);
+                    listsNodes.push(parentNodes[i].parentNode);
+                }
+                else if (parentNodes[i].tagName === 'LI') {
+                    indentsNodes.splice(indentsNodes.indexOf(parentNodes[i]), 1);
+                    listsNodes.push(parentNodes[i]);
+                }
+            }
+            if (listsNodes.length > 0) {
+                this.parent.observer.notify(EVENTS.KEY_DOWN_HANDLER, {
+                    event: {
+                        preventDefault: function () {
+                            return;
+                        },
+                        stopPropagation: function () {
+                            return;
+                        },
+                        shiftKey: (e.subCommand === 'Indent' ? false : true),
+                        which: 9,
+                        action: 'indent'
+                    }
+                });
+            }
+            for (var i = 0; i < indentsNodes.length; i++) {
+                var parentNode = indentsNodes[i];
+                var marginLeftOrRight = isRtl ? parentNode.style.marginRight : parentNode.style.marginLeft;
+                var indentsValue = void 0;
+                if (e.subCommand === 'Indent') {
+                    indentsValue = marginLeftOrRight === '' ? this.indentValue + 'px' : parseInt(marginLeftOrRight, null) + this.indentValue + 'px';
+                    isRtl ? (parentNode.style.marginRight = indentsValue) : (parentNode.style.marginLeft = indentsValue);
+                }
+                else {
+                    indentsValue = (marginLeftOrRight === '' || marginLeftOrRight === '0px' || marginLeftOrRight === '0in') ? '' : (parseInt(marginLeftOrRight, null) - this.indentValue < 0) ? '0px' : (parseInt(marginLeftOrRight, null) - this.indentValue) + 'px';
+                    isRtl ? (parentNode.style.marginRight = indentsValue) : (parentNode.style.marginLeft = indentsValue);
+                }
+            }
+            editEle.focus({ preventScroll: true });
+            if (util_1.isIDevice()) {
+                util_1.setEditFrameFocus(editEle, e.selector);
+            }
+            if (indentsNodes.length === 0 || indentsNodes[0] && indentsNodes[0].nodeName !== 'TABLE') {
+                save = this.parent.domNode.saveMarker(save);
+                save.restore();
+            }
+            if (e.callBack) {
+                e.callBack({
+                    requestType: e.subCommand,
+                    editorMode: 'HTML',
+                    event: e.event,
+                    range: this.parent.nodeSelection.getRange(this.parent.currentDocument),
+                    elements: this.parent.domNode.blockNodes()
+                });
+            }
+        };
+        Indents.prototype.destroy = function () {
+            this.removeEventListener();
+        };
+        return Indents;
+    }());
+    exports.Indents = Indents;
+});

package/blazorGlobalSrc/editor-manager/plugin/insert-methods.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Node appending methods.
+ *
+ * @hidden
+ */
+export declare class InsertMethods {
+    /**
+     * WrapBefore method
+     *
+     * @param {Text} textNode - specifies the text node
+     * @param {HTMLElement} parentNode - specifies the parent node
+     * @param {boolean} isAfter - specifies the boolean value
+     * @returns {Text} - returns the text value
+     * @hidden
+     * @deprecated
+     */
+    static WrapBefore(textNode: Text, parentNode: HTMLElement, isAfter?: boolean): Text;
+    /**
+     * Wrap method
+     *
+     * @param {HTMLElement} childNode - specifies the child node
+     * @param {HTMLElement} parentNode - specifies the parent node.
+     * @returns {HTMLElement} - returns the element
+     * @hidden
+     * @deprecated
+     */
+    static Wrap(childNode: HTMLElement, parentNode: HTMLElement): HTMLElement;
+    /**
+     * unwrap method
+     *
+     * @param {Node} node - specifies the node element.
+     * @returns {Node[]} - returns the array of value
+     * @hidden
+     * @deprecated
+     */
+    static unwrap(node: Node | HTMLElement): Node[];
+    /**
+     * AppendBefore method
+     *
+     * @param {HTMLElement} textNode - specifies the element
+     * @param {HTMLElement} parentNode - specifies the parent node
+     * @param {boolean} isAfter - specifies the boolean value
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    static AppendBefore(textNode: HTMLElement | Text | DocumentFragment, parentNode: HTMLElement | Text | DocumentFragment, isAfter?: boolean): HTMLElement | Text | DocumentFragment;
+}

package/blazorGlobalSrc/editor-manager/plugin/insert-methods.js

@@ -0,0 +1,37 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var InsertMethods = (function () {
+        function InsertMethods() {
+        }
+        InsertMethods.WrapBefore = function (textNode, parentNode, isAfter) {
+            parentNode.innerText = textNode.textContent;
+            (!isAfter) ? this.AppendBefore(parentNode, textNode) : this.AppendBefore(parentNode, textNode, true);
+            if (textNode.parentNode) {
+                textNode.parentNode.removeChild(textNode);
+            }
+            return parentNode.childNodes[0];
+        };
+        InsertMethods.Wrap = function (childNode, parentNode) {
+            this.AppendBefore(parentNode, childNode);
+            parentNode.appendChild(childNode);
+            return childNode;
+        };
+        InsertMethods.unwrap = function (node) {
+            var parent = node.parentNode;
+            var child = [];
+            for (; node.firstChild; null) {
+                child.push(parent.insertBefore(node.firstChild, node));
+            }
+            parent.removeChild(node);
+            return child;
+        };
+        InsertMethods.AppendBefore = function (textNode, parentNode, isAfter) {
+            return (parentNode.parentNode) ? ((!isAfter) ? parentNode.parentNode.insertBefore(textNode, parentNode)
+                : parentNode.parentNode.insertBefore(textNode, parentNode.nextSibling)) :
+                parentNode;
+        };
+        return InsertMethods;
+    }());
+    exports.InsertMethods = InsertMethods;
+});

package/blazorGlobalSrc/editor-manager/plugin/insert-text.d.ts

@@ -0,0 +1,22 @@
+import { EditorManager } from '../base/editor-manager';
+/**
+ * Insert a Text Node or Text
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class InsertTextExec {
+    private parent;
+    /**
+     * Constructor for creating the InsertText plugin
+     *
+     * @param {EditorManager} parent - specifies the parent element
+     * @hidden
+     * @deprecated
+     */
+    constructor(parent: EditorManager);
+    private addEventListener;
+    private removeEventListener;
+    private insertText;
+    destroy(): void;
+}