@syncfusion/ej2-richtexteditor 19.2.57 → 19.3.43

package/dist/global/index.d.ts

@@ -1,6 +1,6 @@
 /*!
 *  filename: index.d.ts
-*  version : 19.2.57
+*  version : 19.3.43
 *  Copyright Syncfusion Inc. 2001 - 2020. All rights reserved.
 *  Use of this code is subject to the terms of our license.
 *  A copy of the current license can be obtained at any time by e-mailing

package/package.json

@@ -1,8 +1,8 @@
 {
   "_from": "@syncfusion/ej2-richtexteditor@*",
-  "_id": "@syncfusion/ej2-richtexteditor@19.2.56",
+  "_id": "@syncfusion/ej2-richtexteditor@18.56.3",
   "_inBundle": false,
-  "_integrity": "sha512-+Skv+q7ge+Yj5iVAPly+Qn7cuw3Fywk51jVWRQSmu1mC3+ms2F6VsZ/IKYG7Pe9wdYkTK3CANPMXwTPlqgcuhw==",
+  "_integrity": "sha512-A4SCmlOjvTVUxWapX9kGMVSNNLBAtftqknMvjF8zGq6hZL43VGLW2UpoMJqfWIw84dVOhEsuMuyl0Jpvt+8k4Q==",
   "_location": "/@syncfusion/ej2-richtexteditor",
   "_phantomChildren": {},
   "_requested": {
@@ -26,8 +26,8 @@
     "/@syncfusion/ej2-react-richtexteditor",
     "/@syncfusion/ej2-vue-richtexteditor"
   ],
-  "_resolved": "http://nexus.syncfusion.com/repository/ej2-hotfix/@syncfusion/ej2-richtexteditor/-/ej2-richtexteditor-19.2.56.tgz",
-  "_shasum": "1366d0bf1c1a692290dbcec2daff61fbdb64ee0a",
+  "_resolved": "http://nexus.syncfusion.com/repository/ej2-release/@syncfusion/ej2-richtexteditor/-/ej2-richtexteditor-18.56.3.tgz",
+  "_shasum": "826e64146698b4573f40bc66de6a6b253b2e3272",
   "_spec": "@syncfusion/ej2-richtexteditor@*",
   "_where": "/jenkins/workspace/automation_release_19.1.0.1-ZPMUBNQ6AUYH6YGEFBPVYMEQLRRW2SLD4XCZ6GATNZJFYJ3RIAOA/packages/included",
   "author": {
@@ -38,13 +38,13 @@
   },
   "bundleDependencies": false,
   "dependencies": {
-    "@syncfusion/ej2-base": "~19.2.55",
-    "@syncfusion/ej2-buttons": "~19.2.55",
-    "@syncfusion/ej2-filemanager": "~19.2.56",
-    "@syncfusion/ej2-inputs": "~19.2.55",
-    "@syncfusion/ej2-navigations": "~19.2.56",
-    "@syncfusion/ej2-popups": "~19.2.56",
-    "@syncfusion/ej2-splitbuttons": "~19.2.55"
+    "@syncfusion/ej2-base": "~19.3.43",
+    "@syncfusion/ej2-buttons": "~19.3.43",
+    "@syncfusion/ej2-filemanager": "~19.3.43",
+    "@syncfusion/ej2-inputs": "~19.3.43",
+    "@syncfusion/ej2-navigations": "~19.3.43",
+    "@syncfusion/ej2-popups": "~19.3.43",
+    "@syncfusion/ej2-splitbuttons": "~19.3.43"
   },
   "deprecated": false,
   "description": "Essential JS 2 RichTextEditor component",
@@ -70,6 +70,6 @@
     "url": "git+https://github.com/syncfusion/ej2-javascript-ui-controls.git"
   },
   "typings": "index.d.ts",
-  "version": "19.2.57",
+  "version": "19.3.43",
   "sideEffects": false
 }

package/src/common/types.d.ts

@@ -6,3 +6,11 @@ export declare type EditorMode = 'HTML' | 'Markdown';
  * Defines types to be used to save the image.
  */
 export declare type SaveFormat = 'Base64' | 'Blob';
+/**
+ * Defines tag to be used when enter key is pressed.
+ */
+export declare type EnterKey = 'P' | 'DIV' | 'BR';
+/**
+ * Defines tag to be used when shift + enter key is pressed.
+ */
+export declare type ShiftEnterKey = 'P' | 'DIV' | 'BR';

package/src/editor-manager/base/editor-manager.d.ts

@@ -71,5 +71,5 @@ export declare class EditorManager {
      * @hidden
 
      */
-    execCommand<T>(command: ExecCommand, value: T, event?: Event, callBack?: Function, text?: string | Node, exeValue?: T, selector?: string): void;
+    execCommand<T>(command: ExecCommand, value: T, event?: Event, callBack?: Function, text?: string | Node, exeValue?: T, selector?: string, enterAction?: string): void;
 }

package/src/editor-manager/base/editor-manager.js

@@ -92,15 +92,15 @@ var EditorManager = /** @class */ (function () {
 
      */
     /* eslint-enable */
-    EditorManager.prototype.execCommand = function (command, value, event, callBack, text, exeValue, selector) {
+    EditorManager.prototype.execCommand = function (command, value, event, callBack, text, exeValue, selector, enterAction) {
         switch (command.toLocaleLowerCase()) {
             case 'lists':
                 this.observer.notify(EVENTS.LIST_TYPE, { subCommand: value, event: event, callBack: callBack,
-                    selector: selector, item: exeValue });
+                    selector: selector, item: exeValue, enterAction: enterAction });
                 break;
             case 'formats':
                 this.observer.notify(EVENTS.FORMAT_TYPE, { subCommand: value, event: event, callBack: callBack,
-                    selector: selector, exeValue: exeValue
+                    selector: selector, exeValue: exeValue, enterAction: enterAction
                 });
                 break;
             case 'alignments':
@@ -129,7 +129,7 @@ var EditorManager = /** @class */ (function () {
             case 'table':
                 switch (value.toString().toLocaleLowerCase()) {
                     case 'createtable':
-                        this.observer.notify(CONSTANT.TABLE, { item: exeValue, event: event, callBack: callBack });
+                        this.observer.notify(CONSTANT.TABLE, { item: exeValue, event: event, callBack: callBack, enterAction: enterAction });
                         break;
                     case 'insertrowbefore':
                     case 'insertrowafter':
@@ -171,7 +171,7 @@ var EditorManager = /** @class */ (function () {
             case 'style':
             case 'effects':
             case 'casing':
-                this.observer.notify(CONSTANT.SELECTION_TYPE, { subCommand: value, event: event, callBack: callBack, value: text, selector: selector });
+                this.observer.notify(CONSTANT.SELECTION_TYPE, { subCommand: value, event: event, callBack: callBack, value: text, selector: selector, enterAction: enterAction });
                 break;
             case 'inserthtml':
                 this.observer.notify(CONSTANT.INSERTHTML_TYPE, { subCommand: value, callBack: callBack, value: text });
@@ -180,7 +180,7 @@ var EditorManager = /** @class */ (function () {
                 this.observer.notify(CONSTANT.INSERT_TEXT_TYPE, { subCommand: value, callBack: callBack, value: text });
                 break;
             case 'clear':
-                this.observer.notify(CONSTANT.CLEAR_TYPE, { subCommand: value, event: event, callBack: callBack, selector: selector });
+                this.observer.notify(CONSTANT.CLEAR_TYPE, { subCommand: value, event: event, callBack: callBack, selector: selector, enterAction: enterAction });
                 break;
             case 'actions':
                 this.observer.notify(EVENTS.ACTION, { subCommand: value, event: event, callBack: callBack, selector: selector });

package/src/editor-manager/base/interface.d.ts

@@ -57,6 +57,7 @@ export interface IHtmlSubCommands {
     exeValue?: {
         [key: string]: string;
     };
+    enterAction?: string;
 }
 /**
  * Specifies  IKeyboardActionArgs interfaces for command line.
@@ -85,6 +86,7 @@ export interface IHtmlItem {
     value: string;
     selector: string;
     callBack(args: IHtmlFormatterCallBack): () => void;
+    enterAction?: string;
 }
 /**
 
@@ -109,7 +111,7 @@ export interface IHtmlItemArgs {
         height?: string | number;
     };
     altText?: string;
-    row?: number;
+    rows?: number;
     columns?: number;
     subCommand?: string;
     tableCell?: HTMLElement;
@@ -148,4 +150,8 @@ export interface IHtmlKeyboardEvent {
      * Specifies the notifier name.
      */
     name?: string;
+    /**
+     * Specifies the enter key configuration.
+     */
+    enterAction?: string;
 }

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

@@ -27,14 +27,14 @@ var ClearFormatExec = /** @class */ (function () {
     ClearFormatExec.prototype.onKeyDown = function (e) {
         switch (e.event.action) {
             case 'clear-format':
-                this.applyClear({ subCommand: 'ClearFormat', callBack: e.callBack });
+                this.applyClear({ subCommand: 'ClearFormat', callBack: e.callBack, enterAction: e.enterAction });
                 e.event.preventDefault();
                 break;
         }
     };
     ClearFormatExec.prototype.applyClear = function (e) {
         if (e.subCommand === 'ClearFormat') {
-            ClearFormat.clear(this.parent.currentDocument, this.parent.editableElement, e.selector);
+            ClearFormat.clear(this.parent.currentDocument, this.parent.editableElement, e.enterAction, e.selector);
             if (e.callBack) {
                 e.callBack({
                     requestType: e.subCommand,

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

@@ -3,6 +3,8 @@ export declare class ClearFormat {
     private static NONVALID_PARENT_TAGS;
     private static IGNORE_PARENT_TAGS;
     private static NONVALID_TAGS;
+    private static defaultTag;
+    private static domNode;
     /**
      * clear method
      *
@@ -13,7 +15,7 @@ export declare class ClearFormat {
      * @hidden
 
      */
-    static clear(docElement: Document, endNode: Node, selector?: string): void;
+    static clear(docElement: Document, endNode: Node, enterAction: string, selector?: string): void;
     private static reSelection;
     private static clearBlocks;
     private static spliceParent;

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

@@ -4,6 +4,7 @@
 import { closest } from '@syncfusion/ej2-base';
 import { NodeSelection } from './../../selection/index';
 import { NodeCutter } from './nodecutter';
+import { DOMNode } from './dom-node';
 import { InsertMethods } from './insert-methods';
 import { IsFormatted } from './isformatted';
 import { isIDevice, setEditFrameFocus } from '../../common/util';
@@ -20,7 +21,9 @@ var ClearFormat = /** @class */ (function () {
      * @hidden
 
      */
-    ClearFormat.clear = function (docElement, endNode, selector) {
+    ClearFormat.clear = function (docElement, endNode, enterAction, selector) {
+        this.domNode = new DOMNode(endNode, docElement);
+        this.defaultTag = enterAction === 'P' ? this.defaultTag : 'div';
         var nodeSelection = new NodeSelection();
         var nodeCutter = new NodeCutter();
         var range = nodeSelection.getRange(docElement);
@@ -165,12 +168,12 @@ var ClearFormat = /** @class */ (function () {
                         && this.IGNORE_PARENT_TAGS.indexOf(parentNodes[index1].childNodes[0].nodeName.toLocaleLowerCase()) > -1)
                     && !(parentNodes[index1].childNodes.length === 1
                         && parentNodes[index1].childNodes[0].nodeName.toLocaleLowerCase() === 'p')) {
-                    InsertMethods.Wrap(parentNodes[index1], docElement.createElement('p'));
+                    InsertMethods.Wrap(parentNodes[index1], docElement.createElement(this.defaultTag));
                 }
                 var childNodes = InsertMethods.unwrap(parentNodes[index1]);
                 if (childNodes.length === 1
                     && childNodes[0].parentNode.nodeName.toLocaleLowerCase() === 'p') {
-                    InsertMethods.Wrap(parentNodes[index1], docElement.createElement('p'));
+                    InsertMethods.Wrap(parentNodes[index1], docElement.createElement(this.defaultTag));
                     InsertMethods.unwrap(parentNodes[index1]);
                 }
                 for (var index2 = 0; index2 < childNodes.length; index2++) {
@@ -188,13 +191,13 @@ var ClearFormat = /** @class */ (function () {
                     }
                     else if (this.BLOCK_TAGS.indexOf(childNodes[index2].nodeName.toLocaleLowerCase()) > -1 &&
                         childNodes[index2].nodeName.toLocaleLowerCase() === 'p') {
-                        InsertMethods.Wrap(childNodes[index2], docElement.createElement('p'));
+                        InsertMethods.Wrap(childNodes[index2], docElement.createElement(this.defaultTag));
                         InsertMethods.unwrap(childNodes[index2]);
                     }
                 }
             }
             else {
-                InsertMethods.Wrap(parentNodes[index1], docElement.createElement('p'));
+                InsertMethods.Wrap(parentNodes[index1], docElement.createElement(this.defaultTag));
                 InsertMethods.unwrap(parentNodes[index1]);
             }
         }
@@ -203,10 +206,16 @@ var ClearFormat = /** @class */ (function () {
     // eslint-disable-next-line
     endNode) {
         for (var index = 0; index < textNodes.length; index++) {
-            if (textNodes[index].parentNode &&
-                IsFormatted.inlineTags.indexOf(textNodes[index].parentNode.nodeName.toLocaleLowerCase()) > -1) {
-                nodeCutter.GetSpliceNode(range, textNodes[index].parentNode);
-                this.removeInlineParent(textNodes[index].parentNode);
+            var currentInlineNode = textNodes[index];
+            var currentNode = void 0;
+            while (!this.domNode.isBlockNode(currentInlineNode)) {
+                currentNode = currentInlineNode;
+                currentInlineNode = currentInlineNode.parentElement;
+            }
+            if (currentNode &&
+                IsFormatted.inlineTags.indexOf(currentNode.nodeName.toLocaleLowerCase()) > -1) {
+                nodeCutter.GetSpliceNode(range, currentNode);
+                this.removeInlineParent(currentNode);
             }
         }
     };
@@ -229,6 +238,7 @@ var ClearFormat = /** @class */ (function () {
     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;
 }());
 export { ClearFormat };

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

@@ -573,8 +573,8 @@ var DOMNode = /** @class */ (function () {
             this.replaceWith(start, this.marker(className, this.encode(start.textContent)));
         }
         else if (start.tagName === 'BR') {
-            this.replaceWith(start, this.marker(markerClassName.startSelection, this.encode(start.textContent)));
-            var markerStart = range.startContainer.querySelector('.' + markerClassName.startSelection);
+            this.replaceWith(start, this.marker(className, this.encode(start.textContent)));
+            var markerStart = range.startContainer.querySelector('.' + className);
             markerStart.appendChild(start);
         }
         else {

package/src/editor-manager/plugin/formats.d.ts

@@ -27,6 +27,7 @@ export declare class Formats {
     private focusSelectionParent;
     private insertMarker;
     private applyFormats;
+    private setSelectionBRConfig;
     private preFormatMerge;
     private cleanFormats;
 }

package/src/editor-manager/plugin/formats.js

@@ -39,7 +39,7 @@ var Formats = /** @class */ (function () {
         if (e.event.which === 13 && range.startContainer === endCon && endCon.nodeType !== 3) {
             var pTag = createElement('p');
             pTag.innerHTML = '<br>';
-            if (lastChild && lastChild.nodeName === 'BR' && (lastChild.previousSibling && lastChild.previousSibling.nodeName === 'TABLE')) {
+            if (!isNOU(lastChild) && lastChild && lastChild.nodeName === 'BR' && (lastChild.previousSibling && lastChild.previousSibling.nodeName === 'TABLE')) {
                 endCon.replaceChild(pTag, lastChild);
                 this.parent.nodeSelection.setCursorPoint(this.parent.currentDocument, pTag, 0);
             }
@@ -82,7 +82,7 @@ var Formats = /** @class */ (function () {
                 var startParent = range.startContainer;
                 if (!isNOU(lastEmpty) && !isNOU(lastBeforeBr) && isNOU(lastEmpty.nextSibling) &&
                     lastEmpty.nodeName === 'BR' && lastBeforeBr.nodeName === 'BR') {
-                    this.paraFocus(range.startContainer);
+                    this.paraFocus(range.startContainer, e.enterAction);
                 }
                 else if ((startParent.textContent.charCodeAt(0) === 8203 &&
                     startParent.textContent.length === 1) || startParent.textContent.length === 0) {
@@ -125,11 +125,21 @@ var Formats = /** @class */ (function () {
             range.deleteContents();
         }
     };
-    Formats.prototype.paraFocus = function (referNode) {
-        var pTag = createElement('p');
-        pTag.innerHTML = '<br>';
-        this.parent.domNode.insertAfter(pTag, referNode);
-        this.parent.nodeSelection.setCursorPoint(this.parent.currentDocument, pTag, 0);
+    Formats.prototype.paraFocus = function (referNode, enterAction) {
+        var insertTag;
+        if (enterAction === 'DIV') {
+            insertTag = createElement('div');
+            insertTag.innerHTML = '<br>';
+        }
+        else if (enterAction === 'BR') {
+            insertTag = createElement('br');
+        }
+        else {
+            insertTag = createElement('p');
+            insertTag.innerHTML = '<br>';
+        }
+        this.parent.domNode.insertAfter(insertTag, referNode);
+        this.parent.nodeSelection.setCursorPoint(this.parent.currentDocument, insertTag, 0);
         detach(referNode.lastChild);
     };
     Formats.prototype.isNotEndCursor = function (preElem, range) {
@@ -211,6 +221,66 @@ var Formats = /** @class */ (function () {
         var save = this.parent.nodeSelection.save(range, this.parent.currentDocument);
         this.parent.domNode.setMarker(save);
         var formatsNodes = this.parent.domNode.blockNodes();
+        if (e.enterAction === 'BR') {
+            this.setSelectionBRConfig();
+            var allSelectedNode = this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument);
+            var selectedNodes = this.parent.nodeSelection.getSelectionNodes(allSelectedNode);
+            var currentFormatNodes = [];
+            if (selectedNodes.length === 0) {
+                selectedNodes.push(formatsNodes[0]);
+            }
+            for (var i = 0; i < selectedNodes.length; i++) {
+                var currentNode = selectedNodes[i];
+                var previousCurrentNode = void 0;
+                while (!this.parent.domNode.isBlockNode(currentNode) && currentNode !== this.parent.editableElement) {
+                    previousCurrentNode = currentNode;
+                    currentNode = currentNode.parentElement;
+                }
+                if (this.parent.domNode.isBlockNode(currentNode) && currentNode === this.parent.editableElement) {
+                    currentFormatNodes.push(previousCurrentNode);
+                }
+            }
+            for (var i = 0; i < currentFormatNodes.length; i++) {
+                if (!this.parent.domNode.isBlockNode(currentFormatNodes[i])) {
+                    var currentNode = currentFormatNodes[i];
+                    var previousNode = currentNode;
+                    while (currentNode === this.parent.editableElement) {
+                        previousNode = currentNode;
+                        currentNode = currentNode.parentElement;
+                    }
+                    var tempElem = void 0;
+                    if (this.parent.domNode.isBlockNode(previousNode.parentElement) &&
+                        previousNode.parentElement === this.parent.editableElement) {
+                        tempElem = createElement('div');
+                        previousNode.parentElement.insertBefore(tempElem, previousNode);
+                        tempElem.appendChild(previousNode);
+                    }
+                    else {
+                        tempElem = previousNode;
+                    }
+                    var preNode = tempElem.previousSibling;
+                    while (!isNOU(preNode) && preNode.nodeName !== 'BR' &&
+                        !this.parent.domNode.isBlockNode(preNode)) {
+                        tempElem.firstChild.parentElement.insertBefore(preNode, tempElem.firstChild);
+                        preNode = tempElem.previousSibling;
+                    }
+                    if (!isNOU(preNode) && preNode.nodeName === 'BR') {
+                        detach(preNode);
+                    }
+                    var postNode = tempElem.nextSibling;
+                    while (!isNOU(postNode) && postNode.nodeName !== 'BR' &&
+                        !this.parent.domNode.isBlockNode(postNode)) {
+                        tempElem.appendChild(postNode);
+                        postNode = tempElem.nextSibling;
+                    }
+                    if (!isNOU(postNode) && postNode.nodeName === 'BR') {
+                        detach(postNode);
+                    }
+                }
+            }
+            this.setSelectionBRConfig();
+            formatsNodes = this.parent.domNode.blockNodes();
+        }
         for (var i = 0; i < formatsNodes.length; i++) {
             var parentNode = void 0;
             var replaceHTML = void 0;
@@ -269,6 +339,16 @@ var Formats = /** @class */ (function () {
             });
         }
     };
+    Formats.prototype.setSelectionBRConfig = function () {
+        var startElem = this.parent.editableElement.querySelector('.' + markerClassName.startSelection);
+        var endElem = this.parent.editableElement.querySelector('.' + markerClassName.endSelection);
+        if (isNOU(endElem)) {
+            this.parent.nodeSelection.setCursorPoint(this.parent.currentDocument, startElem, 0);
+        }
+        else {
+            this.parent.nodeSelection.setSelectionText(this.parent.currentDocument, startElem, endElem, 0, 0);
+        }
+    };
     Formats.prototype.preFormatMerge = function () {
         var preNodes = this.parent.editableElement.querySelectorAll('PRE');
         if (!isNOU(preNodes)) {

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

@@ -1,4 +1,4 @@
-import { createElement, isNullOrUndefined as isNOU, detach, closest, addClass, removeClass, select, Browser } from '@syncfusion/ej2-base';
+import { createElement, isNullOrUndefined as isNOU, detach, closest, addClass, removeClass, select, Browser, formatUnit } from '@syncfusion/ej2-base';
 import * as CONSTANT from './../base/constant';
 import * as classes from './../base/classes';
 import { InsertHtml } from './inserthtml';
@@ -109,14 +109,29 @@ var ImageCommand = /** @class */ (function () {
             var selectedNode = this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument)[0];
             var imgElm_1 = (e.value === 'Replace' || isReplaced) ? e.item.selectParent[0] :
                 (Browser.isIE ? selectedNode.previousSibling : selectedNode.previousElementSibling);
+            var preventLoadCall_1 = false;
             imgElm_1.addEventListener('load', function () {
-                e.callBack({
-                    requestType: 'Images',
-                    editorMode: 'HTML',
-                    event: e.event,
-                    range: _this.parent.nodeSelection.getRange(_this.parent.currentDocument),
-                    elements: [imgElm_1]
-                });
+                if (e.value === 'Replace' || isReplaced) {
+                    if (!preventLoadCall_1) {
+                        e.callBack({
+                            requestType: 'Images',
+                            editorMode: 'HTML',
+                            event: e.event,
+                            range: _this.parent.nodeSelection.getRange(_this.parent.currentDocument),
+                            elements: [imgElm_1]
+                        });
+                        preventLoadCall_1 = true;
+                    }
+                }
+                else {
+                    e.callBack({
+                        requestType: 'Images',
+                        editorMode: 'HTML',
+                        event: e.event,
+                        range: _this.parent.nodeSelection.getRange(_this.parent.currentDocument),
+                        elements: [imgElm_1]
+                    });
+                }
             });
         }
     };
@@ -238,8 +253,10 @@ var ImageCommand = /** @class */ (function () {
         var selectNode = e.item.selectNode[0];
         selectNode.style.height = '';
         selectNode.style.width = '';
-        selectNode.width = e.item.width;
-        selectNode.height = e.item.height;
+        e.item.width !== 'auto' ? selectNode.style.width = formatUnit(e.item.width) :
+            selectNode.removeAttribute('width');
+        e.item.height !== 'auto' ? selectNode.style.height = formatUnit(e.item.height) :
+            selectNode.removeAttribute('height');
         this.callBack(e);
     };
     ImageCommand.prototype.imageCaption = function (e) {
@@ -248,59 +265,65 @@ var ImageCommand = /** @class */ (function () {
     };
     ImageCommand.prototype.imageJustifyLeft = function (e) {
         var selectNode = e.item.selectNode[0];
-        selectNode.removeAttribute('class');
-        addClass([selectNode], 'e-rte-image');
-        if (!isNOU(closest(selectNode, '.' + classes.CLASS_CAPTION))) {
-            removeClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
-            addClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
-        }
-        if (selectNode.parentElement.nodeName === 'A') {
-            removeClass([selectNode.parentElement], classes.CLASS_IMAGE_RIGHT);
-            addClass([selectNode.parentElement], classes.CLASS_IMAGE_LEFT);
-            addClass([selectNode], classes.CLASS_IMAGE_LEFT);
-        }
-        else {
-            addClass([selectNode], classes.CLASS_IMAGE_LEFT);
+        if (!isNOU(selectNode)) {
+            selectNode.removeAttribute('class');
+            addClass([selectNode], 'e-rte-image');
+            if (!isNOU(closest(selectNode, '.' + classes.CLASS_CAPTION))) {
+                removeClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
+                addClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
+            }
+            if (selectNode.parentElement.nodeName === 'A') {
+                removeClass([selectNode.parentElement], classes.CLASS_IMAGE_RIGHT);
+                addClass([selectNode.parentElement], classes.CLASS_IMAGE_LEFT);
+                addClass([selectNode], classes.CLASS_IMAGE_LEFT);
+            }
+            else {
+                addClass([selectNode], classes.CLASS_IMAGE_LEFT);
+            }
+            this.callBack(e);
         }
-        this.callBack(e);
     };
     ImageCommand.prototype.imageJustifyCenter = function (e) {
         var selectNode = e.item.selectNode[0];
-        selectNode.removeAttribute('class');
-        addClass([selectNode], 'e-rte-image');
-        if (!isNOU(closest(selectNode, '.' + classes.CLASS_CAPTION))) {
-            removeClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
-            removeClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
-            addClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_CENTER);
-        }
-        if (selectNode.parentElement.nodeName === 'A') {
-            removeClass([selectNode.parentElement], classes.CLASS_IMAGE_LEFT);
-            removeClass([selectNode.parentElement], classes.CLASS_IMAGE_RIGHT);
-            addClass([selectNode.parentElement], classes.CLASS_IMAGE_CENTER);
-            addClass([selectNode], classes.CLASS_IMAGE_CENTER);
-        }
-        else {
-            addClass([selectNode], classes.CLASS_IMAGE_CENTER);
+        if (!isNOU(selectNode)) {
+            selectNode.removeAttribute('class');
+            addClass([selectNode], 'e-rte-image');
+            if (!isNOU(closest(selectNode, '.' + classes.CLASS_CAPTION))) {
+                removeClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
+                removeClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
+                addClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_CENTER);
+            }
+            if (selectNode.parentElement.nodeName === 'A') {
+                removeClass([selectNode.parentElement], classes.CLASS_IMAGE_LEFT);
+                removeClass([selectNode.parentElement], classes.CLASS_IMAGE_RIGHT);
+                addClass([selectNode.parentElement], classes.CLASS_IMAGE_CENTER);
+                addClass([selectNode], classes.CLASS_IMAGE_CENTER);
+            }
+            else {
+                addClass([selectNode], classes.CLASS_IMAGE_CENTER);
+            }
+            this.callBack(e);
         }
-        this.callBack(e);
     };
     ImageCommand.prototype.imageJustifyRight = function (e) {
         var selectNode = e.item.selectNode[0];
-        selectNode.removeAttribute('class');
-        addClass([selectNode], 'e-rte-image');
-        if (!isNOU(closest(selectNode, '.' + classes.CLASS_CAPTION))) {
-            removeClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
-            addClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
-        }
-        if (selectNode.parentElement.nodeName === 'A') {
-            removeClass([selectNode.parentElement], classes.CLASS_IMAGE_LEFT);
-            addClass([selectNode.parentElement], classes.CLASS_IMAGE_RIGHT);
-            addClass([selectNode], classes.CLASS_IMAGE_RIGHT);
-        }
-        else {
-            addClass([selectNode], classes.CLASS_IMAGE_RIGHT);
+        if (!isNOU(selectNode)) {
+            selectNode.removeAttribute('class');
+            addClass([selectNode], 'e-rte-image');
+            if (!isNOU(closest(selectNode, '.' + classes.CLASS_CAPTION))) {
+                removeClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_LEFT);
+                addClass([closest(selectNode, '.' + classes.CLASS_CAPTION)], classes.CLASS_IMAGE_RIGHT);
+            }
+            if (selectNode.parentElement.nodeName === 'A') {
+                removeClass([selectNode.parentElement], classes.CLASS_IMAGE_LEFT);
+                addClass([selectNode.parentElement], classes.CLASS_IMAGE_RIGHT);
+                addClass([selectNode], classes.CLASS_IMAGE_RIGHT);
+            }
+            else {
+                addClass([selectNode], classes.CLASS_IMAGE_RIGHT);
+            }
+            this.callBack(e);
         }
-        this.callBack(e);
     };
     ImageCommand.prototype.imageInline = function (e) {
         var selectNode = e.item.selectNode[0];

package/src/editor-manager/plugin/inserthtml.js

@@ -115,7 +115,7 @@ var InsertHtml = /** @class */ (function () {
         }
         else {
             range.deleteContents();
-            if (isCursor && range.startContainer.textContent === '') {
+            if (isCursor && range.startContainer.textContent === '' && range.startContainer.nodeName !== 'BR') {
                 range.startContainer.innerHTML = '';
             }
             if (Browser.isIE) {
@@ -123,8 +123,23 @@ var InsertHtml = /** @class */ (function () {
                 frag.appendChild(node);
                 range.insertNode(frag);
             }
+            else if (range.startContainer.nodeType === 1 && range.startContainer.nodeName.toLowerCase() === 'hr'
+                && range.endContainer.nodeName.toLowerCase() === 'hr') {
+                var paraElem = range.startContainer.nextElementSibling;
+                if (paraElem) {
+                    if (paraElem.querySelector('br')) {
+                        detach(paraElem.querySelector('br'));
+                    }
+                    paraElem.appendChild(node);
+                }
+            }
             else {
-                range.insertNode(node);
+                if (range.startContainer.nodeName === 'BR') {
+                    range.startContainer.parentElement.insertBefore(node, range.startContainer);
+                }
+                else {
+                    range.insertNode(node);
+                }
             }
             if (node.nodeType !== 3 && node.childNodes.length > 0) {
                 nodeSelection.setSelectionText(docElement, node, node, 1, 1);
@@ -336,6 +351,9 @@ var InsertHtml = /** @class */ (function () {
                 range.setStart(editNode.firstElementChild, editNode.firstElementChild.textContent.length);
                 range.setEnd(editNode.firstElementChild, editNode.firstElementChild.textContent.length);
             }
+            if (blockNode.nodeName === 'BODY' && range.startContainer === range.endContainer && range.startContainer.nodeType === 1) {
+                blockNode = range.startContainer;
+            }
             if (blockNode.nodeName === 'TD' || blockNode.nodeName === 'TH') {
                 var tempSpan = createElement('span', { className: 'tempSpan' });
                 range.insertNode(tempSpan);