@worktile/theia 2.4.1 → 2.4.2

package/bundles/worktile-theia.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('@angular/forms'), require('slate-angular'), require('ngx-tethys/core'), require('is-hotkey'), require('slate'), require('slate-history'), require('lodash'), require('marked'), require('@atinc/selene'), require('ngx-tethys/popover'), require('@angular/cdk/overlay'), require('ngx-tethys/alert'), require('rxjs/operators'), require('ngx-tethys/uploader'), require('rxjs'), require('@angular/platform-browser'), require('ngx-tethys/progress'), require('ngx-tethys/icon'), require('ngx-tethys/nav'), require('ngx-tethys/tooltip'), require('ngx-tethys/input'), require('ng-codemirror'), require('ngx-tethys/notify'), require('ngx-tethys/action-menu'), require('ngx-tethys/switch'), require('ngx-tethys/resizable'), require('is-url'), require('ngx-tethys/button'), require('ngx-tethys/form'), require('ngx-tethys/shared'), require('ngx-tethys'), require('@angular/cdk/coercion'), require('@angular/cdk/portal'), require('ngx-tethys/list'), require('ngx-tethys/autocomplete'), require('ngx-tethys/avatar'), require('ngx-tethys/select')) :
-    typeof define === 'function' && define.amd ? define('@worktile/theia', ['exports', '@angular/core', '@angular/common', '@angular/forms', 'slate-angular', 'ngx-tethys/core', 'is-hotkey', 'slate', 'slate-history', 'lodash', 'marked', '@atinc/selene', 'ngx-tethys/popover', '@angular/cdk/overlay', 'ngx-tethys/alert', 'rxjs/operators', 'ngx-tethys/uploader', 'rxjs', '@angular/platform-browser', 'ngx-tethys/progress', 'ngx-tethys/icon', 'ngx-tethys/nav', 'ngx-tethys/tooltip', 'ngx-tethys/input', 'ng-codemirror', 'ngx-tethys/notify', 'ngx-tethys/action-menu', 'ngx-tethys/switch', 'ngx-tethys/resizable', 'is-url', 'ngx-tethys/button', 'ngx-tethys/form', 'ngx-tethys/shared', 'ngx-tethys', '@angular/cdk/coercion', '@angular/cdk/portal', 'ngx-tethys/list', 'ngx-tethys/autocomplete', 'ngx-tethys/avatar', 'ngx-tethys/select'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.worktile = global.worktile || {}, global.worktile.theia = {}), global.ng.core, global.ng.common, global.ng.forms, global.i1, global.core, global.isHotkey, global.slate, global.slateHistory, global._lodash, global.marked, global.selene, global.i1$2, global.ng.cdk.overlay, global.i1$1, global.rxjs.operators, global.uploader, global.rxjs, global.ng.platformBrowser, global.i6, global.i3, global.i3$1, global.i5, global.i5$1, global.i8, global.i1$4, global.i2$1, global.i6$1, global.i9, global.isUrl, global.i1$5, global.i2$2, global.i5$2, global.i1$6, global.ng.cdk.coercion, global.ng.cdk.portal, global.i2$3, global.autocomplete, global.avatar, global.select));
-})(this, (function (exports, i0, i10, i4, i1, core, isHotkey, slate, slateHistory, _lodash, marked, selene, i1$2, i2, i1$1, operators, uploader, rxjs, i1$3, i6, i3, i3$1, i5, i5$1, i8, i1$4, i2$1, i6$1, i9, isUrl, i1$5, i2$2, i5$2, i1$6, coercion, portal, i2$3, autocomplete, avatar, select) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('@angular/forms'), require('slate-angular'), require('ngx-tethys/core'), require('is-hotkey'), require('slate'), require('slate-history'), require('marked'), require('@atinc/selene'), require('ngx-tethys/popover'), require('lodash'), require('@angular/cdk/overlay'), require('ngx-tethys/alert'), require('rxjs/operators'), require('ngx-tethys/uploader'), require('rxjs'), require('@angular/platform-browser'), require('ngx-tethys/progress'), require('ngx-tethys/icon'), require('ngx-tethys/nav'), require('ngx-tethys/tooltip'), require('ngx-tethys/input'), require('ng-codemirror'), require('ngx-tethys/notify'), require('ngx-tethys/action-menu'), require('ngx-tethys/switch'), require('ngx-tethys/resizable'), require('is-url'), require('ngx-tethys/button'), require('ngx-tethys/form'), require('ngx-tethys/shared'), require('ngx-tethys'), require('@angular/cdk/coercion'), require('@angular/cdk/portal'), require('ngx-tethys/list'), require('ngx-tethys/autocomplete'), require('ngx-tethys/avatar'), require('ngx-tethys/select')) :
+    typeof define === 'function' && define.amd ? define('@worktile/theia', ['exports', '@angular/core', '@angular/common', '@angular/forms', 'slate-angular', 'ngx-tethys/core', 'is-hotkey', 'slate', 'slate-history', 'marked', '@atinc/selene', 'ngx-tethys/popover', 'lodash', '@angular/cdk/overlay', 'ngx-tethys/alert', 'rxjs/operators', 'ngx-tethys/uploader', 'rxjs', '@angular/platform-browser', 'ngx-tethys/progress', 'ngx-tethys/icon', 'ngx-tethys/nav', 'ngx-tethys/tooltip', 'ngx-tethys/input', 'ng-codemirror', 'ngx-tethys/notify', 'ngx-tethys/action-menu', 'ngx-tethys/switch', 'ngx-tethys/resizable', 'is-url', 'ngx-tethys/button', 'ngx-tethys/form', 'ngx-tethys/shared', 'ngx-tethys', '@angular/cdk/coercion', '@angular/cdk/portal', 'ngx-tethys/list', 'ngx-tethys/autocomplete', 'ngx-tethys/avatar', 'ngx-tethys/select'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.worktile = global.worktile || {}, global.worktile.theia = {}), global.ng.core, global.ng.common, global.ng.forms, global.i1, global.core, global.isHotkey, global.slate, global.slateHistory, global.marked, global.selene, global.i1$2, global._lodash, global.ng.cdk.overlay, global.i1$1, global.rxjs.operators, global.uploader, global.rxjs, global.ng.platformBrowser, global.i6, global.i3, global.i3$1, global.i5, global.i5$1, global.i8, global.i1$4, global.i2$1, global.i6$1, global.i9, global.isUrl, global.i1$5, global.i2$2, global.i5$2, global.i1$6, global.ng.cdk.coercion, global.ng.cdk.portal, global.i2$3, global.autocomplete, global.avatar, global.select));
+})(this, (function (exports, i0, i10, i4, i1, core, isHotkey, slate, slateHistory, marked, selene, i1$2, _lodash, i2, i1$1, operators, uploader, rxjs, i1$3, i6, i3, i3$1, i5, i5$1, i8, i1$4, i2$1, i6$1, i9, isUrl, i1$5, i2$2, i5$2, i1$6, coercion, portal, i2$3, autocomplete, avatar, select) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -29,9 +29,9 @@
     var i4__namespace = /*#__PURE__*/_interopNamespace(i4);
     var i1__namespace = /*#__PURE__*/_interopNamespace(i1);
     var isHotkey__default = /*#__PURE__*/_interopDefaultLegacy(isHotkey);
-    var _lodash__namespace = /*#__PURE__*/_interopNamespace(_lodash);
     var marked__default = /*#__PURE__*/_interopDefaultLegacy(marked);
     var i1__namespace$3 = /*#__PURE__*/_interopNamespace(i1$2);
+    var _lodash__namespace = /*#__PURE__*/_interopNamespace(_lodash);
     var i2__namespace = /*#__PURE__*/_interopNamespace(i2);
     var i1__namespace$1 = /*#__PURE__*/_interopNamespace(i1$1);
     var i1__namespace$2 = /*#__PURE__*/_interopNamespace(i1$3);
@@ -853,6 +853,61 @@
         return key;
     }
 
+    var UNDOING = new WeakMap();
+    var REDOING = new WeakMap();
+    var withTheHistory = function (editor) {
+        var undo = editor.undo, redo = editor.redo;
+        editor.undo = function () {
+            UNDOING.set(editor, true);
+            undo();
+            UNDOING.set(editor, false);
+        };
+        editor.redo = function () {
+            REDOING.set(editor, true);
+            redo();
+            REDOING.set(editor, false);
+        };
+        return editor;
+    };
+    var TheHistoryEditor = {
+        isUndoing: function (editor) {
+            return UNDOING.get(editor);
+        },
+        isRedoing: function (editor) {
+            return REDOING.get(editor);
+        }
+    };
+
+    var setMarks = function (editor, marks, at) {
+        slate.Transforms.setNodes(editor, marks, {
+            at: at,
+            match: slate.Text.isText,
+            split: true
+        });
+    };
+
+    var clearMarks = function (editor) {
+        var selection = editor.selection;
+        if (!selection) {
+            return;
+        }
+        if (slate.Range.isCollapsed(selection)) {
+            var marks = slate.Editor.marks(editor);
+            for (var key in marks) {
+                slate.Editor.removeMark(editor, key);
+            }
+        }
+        else {
+            var unsetMarks_1 = {};
+            MarkProps.forEach(function (key) {
+                unsetMarks_1[key] = null;
+            });
+            setMarks(editor, unsetMarks_1);
+        }
+    };
+
+    var insertElement = function (editor, element) { return editor.insertElement(element); };
+
     var isAncestor = function (node) { return slate.Element.isElement(node) || slate.Editor.isEditor(node); };
 
     var getLastChild$1 = function (node, level) {
@@ -1720,36 +1775,6 @@
         someNode: someNode
     });
 
-    var setMarks = function (editor, marks, at) {
-        slate.Transforms.setNodes(editor, marks, {
-            at: at,
-            match: slate.Text.isText,
-            split: true
-        });
-    };
-
-    var clearMarks = function (editor) {
-        var selection = editor.selection;
-        if (!selection) {
-            return;
-        }
-        if (slate.Range.isCollapsed(selection)) {
-            var marks = slate.Editor.marks(editor);
-            for (var key in marks) {
-                slate.Editor.removeMark(editor, key);
-            }
-        }
-        else {
-            var unsetMarks_1 = {};
-            MarkProps.forEach(function (key) {
-                unsetMarks_1[key] = null;
-            });
-            setMarks(editor, unsetMarks_1);
-        }
-    };
-
-    var insertElement = function (editor, element) { return editor.insertElement(element); };
-
     var insertElementNext = function (editor, node) {
         if (slate.Range.isExpanded(editor.selection)) {
             slate.Editor.deleteFragment(editor);
@@ -1992,456 +2017,19 @@
         handleContinualInsertBreak: handleContinualInsertBreak
     });
 
-    var isNodeTypeList = function (n) {
-        return [exports.ElementKinds.bulletedList, exports.ElementKinds.numberedList].includes(n.type);
-    };
-
-    var ListEditor = {
-        isList: function (editor, element, type) {
-            return slate.Editor.isBlock(editor, element) && element.type === type;
-        },
-        toggleList: function (editor, type, startIndex) {
-            var _this = this;
-            if (!editor.selection) {
-                return;
-            }
-            if (!startIndex) {
-                startIndex = 1;
-            }
-            var types = [exports.ElementKinds.bulletedList, exports.ElementKinds.numberedList];
-            slate.Editor.withoutNormalizing(editor, function () {
-                var _a = __read(slate.Editor.nodes(editor, {
-                    match: function (node) { return slate.Element.isElement(node) && node.type === exports.ElementKinds.listItem; },
-                    mode: 'lowest'
-                })), listItems = _a.slice(0);
-                var firstListItemPath = listItems.length && listItems[0][1];
-                var activeListPath = listItems.length && slate.Path.parent(firstListItemPath);
-                var activeListNode = listItems.length && slate.Node.get(editor, activeListPath);
-                // 同级且类型相同：unwrap
-                var isLowestActive = listItems.length &&
-                    listItems.every(function (_a) {
-                        var _b = __read(_a, 2), path = _b[1];
-                        return activeListNode.type === type && (slate.Path.isSibling(firstListItemPath, path) || slate.Path.equals(firstListItemPath, path));
-                    });
-                if (isLowestActive) {
-                    var upListItem = slate.Path.parent(activeListPath);
-                    slate.Transforms.unwrapNodes(editor, {
-                        at: editor.selection,
-                        match: function (node) { return node === activeListNode; },
-                        split: true,
-                        mode: 'lowest'
-                    });
-                    if (upListItem && slate.Node.get(editor, upListItem).type === exports.ElementKinds.listItem) {
-                        slate.Transforms.moveNodes(editor, {
-                            at: editor.selection,
-                            to: slate.Path.next(upListItem),
-                            match: function (node) { return slate.Element.isElement(node) && node.type === exports.ElementKinds.listItem; }
-                        });
-                    }
-                    else {
-                        slate.Transforms.unwrapNodes(editor, {
-                            match: function (node) { return slate.Element.isElement(node) && node.type === exports.ElementKinds.listItem; }
-                        });
-                    }
-                    return;
-                }
-                // 跨级、同级且类型不同
-                if (activeListNode && types.includes(activeListNode.type)) {
-                    slate.Transforms.setNodes(editor, { type: type }, { match: function (node) { return slate.Element.isElement(node) && node.type !== type && types.includes(node.type); } });
-                    return;
-                }
-                // wrap
-                _this.buildListItem(editor);
-                // Todo: types
-                slate.Transforms.wrapNodes(editor, { type: type, children: [], start: startIndex }, {
-                    at: editor.selection,
-                    match: function (node) { return slate.Element.isElement(node) && node.type === exports.ElementKinds.listItem; }
-                });
-            });
-        },
-        unwrapList: function (editor) {
-            slate.Editor.withoutNormalizing(editor, function () {
-                unwrapNodesByType(editor, [exports.ElementKinds.bulletedList, exports.ElementKinds.numberedList], { split: true, mode: 'all' });
-                unwrapNodesByType(editor, [exports.ElementKinds.listItem], { split: true, mode: 'all' });
-            });
-        },
-        wrapList: function (editor, type) {
-            slate.Editor.withoutNormalizing(editor, function () {
-                var listItem = {
-                    type: exports.ElementKinds.listItem,
-                    children: []
-                };
-                var list = {
-                    type: type,
-                    children: []
-                };
-                slate.Transforms.wrapNodes(editor, list, { split: true });
-                slate.Transforms.wrapNodes(editor, listItem, { split: true });
-            });
-        },
-        isActive: function (editor, type) {
-            var _a = __read(getNodesByType(editor, type), 1), match = _a[0];
-            return !!match;
-        },
-        getActiveList: function (editor) {
-            var _a = __read(getNodesByType(editor, LIST_BLOCK_TYPES), 1), match = _a[0];
-            return match;
-        },
-        buildListItem: function (editor) {
-            var e_1, _a;
-            var nodes = slate.Editor.nodes(editor, {
-                match: function (node) { return slate.Editor.isBlock(editor, node); },
-                mode: 'lowest'
-            });
-            try {
-                for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
-                    var _b = __read(nodes_1_1.value, 2), node = _b[0], path = _b[1];
-                    if (!slate.Editor.isVoid(editor, node) && slate.Element.isElement(node) && node.type !== exports.ElementKinds.paragraph) {
-                        slate.Transforms.setNodes(editor, { type: exports.ElementKinds.paragraph, checked: undefined }, // todo remove checked
-                        { at: path });
-                    }
-                    else if (slate.Element.isElement(node) && node.type === exports.ElementKinds.paragraph) {
-                        var textIndent = node.textIndent;
-                        if (textIndent) {
-                            slate.Transforms.setNodes(editor, { textIndent: undefined, indent: undefined }, // remove indent
-                            { at: path });
-                        }
-                    }
-                    if (slate.Node.parent(editor, path).type !== exports.ElementKinds.listItem) {
-                        slate.Transforms.wrapNodes(editor, { type: exports.ElementKinds.listItem, children: [] }, {
-                            at: path,
-                            split: true
-                        });
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        },
-        buildInsertDataChildren: function (node) {
-            var children = node.children;
-            var listItem = children[0];
-            if (isNodeTypeList(node) && slate.Element.isElement(listItem) && listItem.children[0].type === exports.ElementKinds.paragraph) {
-                return node;
-            }
-            return this.buildInsertDataChildren(listItem);
+    var TheConversionHintComponent = /** @class */ (function () {
+        function TheConversionHintComponent() {
+            this.duration = 10000;
+            this.pauseOnHover = true;
         }
-    };
-
-    var TodoItemEditor = {
-        isActive: function (editor) {
-            var _a = __read(getNodesByType(editor, exports.ElementKinds.checkItem), 1), match = _a[0];
-            return !!match;
-        },
-        insertTodoItem: function (editor) {
-            if (!editor.selection) {
-                return;
+        TheConversionHintComponent.prototype.mouseenter = function () {
+            if (this.pauseOnHover) {
+                this.clearCloseTimer();
             }
-            var isActive = this.isActive(editor);
-            var isNumberedList = ListEditor.isActive(editor, exports.ElementKinds.numberedList);
-            var isBulletedList = ListEditor.isActive(editor, exports.ElementKinds.bulletedList);
-            if (isActive) {
-                slate.Transforms.setNodes(editor, {
-                    type: exports.ElementKinds.paragraph
-                });
-            }
-            else {
-                if (isNumberedList || isBulletedList) {
-                    ListEditor.unwrapList(editor);
-                }
-                slate.Transforms.setNodes(editor, {
-                    type: exports.ElementKinds.checkItem
-                });
-            }
-        }
-    };
-
-    var BlockquoteEditor = {
-        toggleBlockquote: function (editor) {
-            if (!isParagraph(editor)) {
-                slate.Transforms.insertNodes(editor, {
-                    type: exports.ElementKinds.paragraph,
-                    mode: 'text',
-                    children: [
-                        {
-                            text: ''
-                        }
-                    ]
-                });
-            }
-            var isActive = isBlockActive(editor, exports.ElementKinds.blockquote);
-            if (!isActive) {
-                slate.Transforms.wrapNodes(editor, { type: exports.ElementKinds.blockquote, children: [] }, {
-                    mode: 'lowest'
-                });
-            }
-            else {
-                slate.Transforms.unwrapNodes(editor, { match: function (n) { return slate.Element.isElement(n) && n.type === exports.ElementKinds.blockquote; } });
-            }
-        }
-    };
-
-    var InlineCodeEditor = {
-        toggleInlineCode: function (editor, text) {
-            var isActive = InlineCodeEditor.isInlineCodeActive(editor);
-            if (isActive) {
-                InlineCodeEditor.unwrapInlineCode(editor);
-                return;
-            }
-            if (slate.Range.isCollapsed(editor.selection)) {
-                InlineCodeEditor.wrapInlineCode(editor, text);
-            }
-            else {
-                var fragment = slate.Node.fragment(editor, editor.selection)[0];
-                var selectNode = slate.Node.get(fragment, []);
-                var selectText = slate.Node.string(selectNode);
-                InlineCodeEditor.wrapInlineCode(editor, selectText);
-            }
-        },
-        wrapInlineCode: function (editor, text) {
-            if (text === void 0) { text = ''; }
-            if (InlineCodeEditor.isInlineCodeActive(editor)) {
-                InlineCodeEditor.unwrapInlineCode(editor);
-            }
-            var selection = editor.selection;
-            var isCollapsed = selection && slate.Range.isCollapsed(selection);
-            var inlineCode = {
-                type: exports.ElementKinds.inlineCode,
-                children: isCollapsed ? [{ text: text ? text : ZERO_WIDTH_CHAR }] : []
-            };
-            if (isCollapsed) {
-                slate.Transforms.insertNodes(editor, inlineCode);
-            }
-            else {
-                slate.Transforms.wrapNodes(editor, inlineCode, { split: true });
-            }
-        },
-        unwrapInlineCode: function (editor) {
-            slate.Transforms.unwrapNodes(editor, { match: function (n) { return slate.Element.isElement(n) && n.type === exports.ElementKinds.inlineCode; } });
-        },
-        isInlineCodeActive: function (editor, path) {
-            var _a;
-            var _b = __read(slate.Editor.nodes(editor, {
-                at: path ? path : (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.anchor.path,
-                match: function (n) { return slate.Element.isElement(n) && n.type === exports.ElementKinds.inlineCode; }
-            }), 1), inlineCode = _b[0];
-            return !!inlineCode;
-        }
-    };
-
-    var HeadingEditor = {
-        setHeading: function (editor, heading) {
-            slate.Editor.withoutNormalizing(editor, function () {
-                var _a;
-                var types = [exports.ElementKinds.bulletedList, exports.ElementKinds.numberedList, exports.ElementKinds.listItem];
-                slate.Transforms.unwrapNodes(editor, {
-                    at: editor.selection,
-                    match: function (n) { return slate.Element.isElement(n) && types.includes(n.type); },
-                    mode: 'all',
-                    split: true
-                });
-                slate.Transforms.setNodes(editor, { type: heading });
-                var entry = anchorBlockEntry(editor);
-                var unMarks = (_a = {},
-                    _a[exports.MarkTypes.fontSize] = null,
-                    _a);
-                if (entry) {
-                    setMarks(editor, unMarks, entry[1]);
-                    return;
-                }
-                setMarks(editor, unMarks, editor.selection);
-            });
-        },
-        isHeadingActive: function (editor, heading) {
-            var _a = __read(slate.Editor.nodes(editor, {
-                match: function (n) { return slate.Element.isElement(n) && n.type === heading; },
-                universal: true
-            }), 1), match = _a[0];
-            return !!match;
-        }
-    };
-
-    var autoFormatRules = [
-        {
-            type: exports.ElementKinds.heading_1,
-            markup: '#',
-            format: function (editor) {
-                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_1);
-            }
-        },
-        {
-            type: exports.ElementKinds.heading_2,
-            markup: '##',
-            format: function (editor) {
-                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_2);
-            }
-        },
-        {
-            type: exports.ElementKinds.heading_3,
-            markup: '###',
-            format: function (editor) {
-                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_3);
-            }
-        },
-        {
-            type: exports.ElementKinds.heading_4,
-            markup: '####',
-            format: function (editor) {
-                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_4);
-            }
-        },
-        {
-            type: exports.ElementKinds.heading_5,
-            markup: '#####',
-            format: function (editor) {
-                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_5);
-            }
-        },
-        {
-            type: exports.ElementKinds.heading_6,
-            markup: '######',
-            format: function (editor) {
-                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_6);
-            }
-        },
-        {
-            type: exports.ElementKinds.blockquote,
-            markup: ['>'],
-            format: function (editor) {
-                BlockquoteEditor.toggleBlockquote(editor);
-            }
-        },
-        {
-            type: exports.MarkTypes.bold,
-            between: ['**', '**'],
-            mode: 'inline',
-            insertTrigger: true
-        },
-        {
-            type: exports.MarkTypes.bold,
-            between: ['__', '__'],
-            mode: 'inline',
-            insertTrigger: true
-        },
-        {
-            type: exports.MarkTypes.italic,
-            between: ['*', '*'],
-            mode: 'inline',
-            insertTrigger: true
-        },
-        {
-            type: exports.MarkTypes.italic,
-            between: ['_', '_'],
-            mode: 'inline',
-            insertTrigger: true
-        },
-        {
-            type: exports.ElementKinds.inlineCode,
-            between: ['`', '`'],
-            mode: 'inline',
-            format: function (editor, text) {
-                InlineCodeEditor.toggleInlineCode(editor, text);
-                slate.Transforms.select(editor, slate.Editor.after(editor, editor.selection));
-            }
-        },
-        {
-            type: exports.MarkTypes.strike,
-            between: ['~~', '~~'],
-            mode: 'inline',
-            insertTrigger: true
-        },
-        {
-            type: exports.ElementKinds.code,
-            markup: '```',
-            insertTrigger: true
-        },
-        {
-            type: exports.ElementKinds.listItem,
-            markup: [],
-            match: function (editor) {
-                return isParagraph(editor) ? ['*', '-', '+'] : [];
-            },
-            format: function (editor) {
-                ListEditor.toggleList(editor, exports.ElementKinds.bulletedList);
-            }
-        },
-        {
-            type: exports.ElementKinds.listItem,
-            markup: [],
-            match: function (editor, textFromBlockStart) {
-                return isParagraph(editor) && /^-?\d+(\.|\))$/.test(textFromBlockStart) ? [textFromBlockStart] : [];
-            },
-            format: function (editor, markup) {
-                var startIndex = 1;
-                if (markup) {
-                    startIndex = markup[0].split('.')[0];
-                    if (startIndex === 0) {
-                        startIndex = 1;
-                    }
-                }
-                ListEditor.toggleList(editor, exports.ElementKinds.numberedList, startIndex);
-            }
-        },
-        {
-            type: exports.ElementKinds.checkItem,
-            markup: [],
-            match: function (editor) {
-                return isParagraph(editor) ? ['[]'] : [];
-            },
-            format: function (editor) {
-                TodoItemEditor.insertTodoItem(editor);
-            }
-        },
-        {
-            type: exports.ElementKinds.hr,
-            markup: '---',
-            insertTrigger: true
-        }
-    ];
-
-    var UNDOING = new WeakMap();
-    var REDOING = new WeakMap();
-    var withTheHistory = function (editor) {
-        var undo = editor.undo, redo = editor.redo;
-        editor.undo = function () {
-            UNDOING.set(editor, true);
-            undo();
-            UNDOING.set(editor, false);
-        };
-        editor.redo = function () {
-            REDOING.set(editor, true);
-            redo();
-            REDOING.set(editor, false);
-        };
-        return editor;
-    };
-    var TheHistoryEditor = {
-        isUndoing: function (editor) {
-            return UNDOING.get(editor);
-        },
-        isRedoing: function (editor) {
-            return REDOING.get(editor);
-        }
-    };
-
-    var TheConversionHintComponent = /** @class */ (function () {
-        function TheConversionHintComponent() {
-            this.duration = 10000;
-            this.pauseOnHover = true;
-        }
-        TheConversionHintComponent.prototype.mouseenter = function () {
-            if (this.pauseOnHover) {
-                this.clearCloseTimer();
-            }
-        };
-        TheConversionHintComponent.prototype.mouseleave = function () {
-            if (this.pauseOnHover) {
-                this.creatCloseTimer();
+        };
+        TheConversionHintComponent.prototype.mouseleave = function () {
+            if (this.pauseOnHover) {
+                this.creatCloseTimer();
             }
         };
         TheConversionHintComponent.prototype.ngOnInit = function () {
@@ -3537,6 +3125,10 @@
         return listItemNode.children.length === 1 && type === exports.ElementKinds.paragraph;
     };
 
+    var isNodeTypeList = function (n) {
+        return [exports.ElementKinds.bulletedList, exports.ElementKinds.numberedList].includes(n.type);
+    };
+
     /**
      * list 中 是否是单个listItem，且listItem没有子列表
      */
@@ -4564,385 +4156,807 @@
                 if (blockCardElement) {
                     blockCardElement.classList.add("slate-block-card-" + _this.element.type);
                 }
-            });
+            });
+        };
+        return TheHrComponent;
+    }(TheBaseElementComponent));
+    TheHrComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: TheHrComponent, deps: [{ token: i0__namespace.ElementRef }, { token: i0__namespace.ChangeDetectorRef }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    TheHrComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.15", type: TheHrComponent, selector: "the-hr, [theHr]", usesInheritance: true, ngImport: i0__namespace, template: "\n        <div class=\"the-hr\" contenteditable=\"false\" [ngClass]=\"{ active: selection }\">\n            <hr class=\"the-hr\" />\n            <slate-children [children]=\"children\" [context]=\"childrenContext\" [viewContext]=\"viewContext\"></slate-children>\n        </div>\n    ", isInline: true, components: [{ type: i1__namespace.SlateChildrenComponent, selector: "slate-children", inputs: ["children", "context", "viewContext"] }], directives: [{ type: i10__namespace.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: TheHrComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'the-hr, [theHr]',
+                        template: "\n        <div class=\"the-hr\" contenteditable=\"false\" [ngClass]=\"{ active: selection }\">\n            <hr class=\"the-hr\" />\n            <slate-children [children]=\"children\" [context]=\"childrenContext\" [viewContext]=\"viewContext\"></slate-children>\n        </div>\n    "
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.ElementRef }, { type: i0__namespace.ChangeDetectorRef }]; } });
+
+    var withHr = function (editor) {
+        var isVoid = editor.isVoid, isBlockCard = editor.isBlockCard, renderElement = editor.renderElement;
+        editor.isVoid = function (element) {
+            return element.type === exports.ElementKinds.hr || isVoid(element);
+        };
+        editor.isBlockCard = function (element) {
+            if (element.type === exports.ElementKinds.hr) {
+                return true;
+            }
+            return isBlockCard(element);
+        };
+        editor.renderElement = function (element) {
+            if (element.type === exports.ElementKinds.hr) {
+                return TheHrComponent;
+            }
+            return renderElement(element);
+        };
+        return editor;
+    };
+
+    var withAlign = function (editor) {
+        var deleteBackward = editor.deleteBackward;
+        editor.deleteBackward = function (unit) {
+            var anchor = editor.selection.anchor;
+            var node = anchorBlock(editor);
+            var isVoid = slate.Editor.isVoid(editor, node);
+            var alignTypes = [exports.Alignment.center, exports.Alignment.right];
+            var startLine = slate.Editor.start(editor, anchor.path);
+            var startLineRange = { anchor: anchor, focus: startLine };
+            var beforeText = slate.Editor.string(editor, startLineRange);
+            if (!isVoid && node && node.align && alignTypes.includes(node.align) && beforeText === '') {
+                var align = alignTypes.indexOf(node.align) ? exports.Alignment.center : undefined;
+                return slate.Transforms.setNodes(editor, { align: align });
+            }
+            deleteBackward(unit);
+        };
+        return editor;
+    };
+
+    var withHeading = function (editor) {
+        var insertBreak = editor.insertBreak;
+        editor.insertBreak = function () {
+            var selection = editor.selection;
+            var anchorBlock = getAnchorBlockEntry(editor);
+            if (anchorBlock && slate.Range.isCollapsed(selection) && anchorBlock[0].type.startsWith('heading')) {
+                if (slate.Editor.isStart(editor, selection.anchor, anchorBlock[1])) {
+                    insertBreak();
+                    slate.Transforms.setNodes(editor, { type: exports.ElementKinds.paragraph }, {
+                        at: selection
+                    });
+                    return;
+                }
+                if (slate.Editor.isEnd(editor, selection.focus, anchorBlock[1])) {
+                    insertBreak();
+                    slate.Transforms.setNodes(editor, { type: exports.ElementKinds.paragraph });
+                    return;
+                }
+            }
+            insertBreak();
+        };
+        return editor;
+    };
+
+    var withMark = function () { return function (editor) {
+        var e = editor;
+        e.removeMark = function (key, shouldChange) {
+            if (shouldChange === void 0) { shouldChange = true; }
+            var selection = e.selection;
+            if (selection) {
+                if (slate.Range.isExpanded(selection)) {
+                    slate.Transforms.unsetNodes(e, key, {
+                        match: slate.Text.isText,
+                        split: true
+                    });
+                }
+                else {
+                    var marks = Object.assign({}, (slate.Editor.marks(e) || {}));
+                    delete marks[key];
+                    editor.marks = marks;
+                    var text = slate.Editor.string(e, selection.anchor.path);
+                    if (text !== '') {
+                        slate.Editor.setNormalizing(editor, false);
+                        e.insertText('');
+                        editor.marks = marks;
+                        slate.Editor.setNormalizing(editor, true);
+                    }
+                    else {
+                        slate.Transforms.unsetNodes(e, key, { at: selection.anchor.path });
+                    }
+                    if (shouldChange) {
+                        editor.onChange();
+                    }
+                }
+            }
+        };
+        e.addMark = function (key, value) {
+            var _a, _b, _c;
+            var selection = editor.selection;
+            if (selection) {
+                if (slate.Range.isExpanded(selection)) {
+                    slate.Transforms.setNodes(e, (_a = {}, _a[key] = value, _a), { match: slate.Text.isText, split: true });
+                }
+                else {
+                    var marks = Object.assign(Object.assign({}, (slate.Editor.marks(e) || {})), (_b = {}, _b[key] = value, _b));
+                    editor.marks = marks;
+                    var text = slate.Editor.string(e, selection.anchor.path);
+                    if (text !== '') {
+                        slate.Editor.setNormalizing(editor, false);
+                        e.insertText('');
+                        editor.marks = marks;
+                        slate.Editor.setNormalizing(editor, true);
+                    }
+                    else {
+                        slate.Transforms.setNodes(e, (_c = {}, _c[key] = value, _c), { at: selection.anchor.path });
+                    }
+                }
+            }
+        };
+        return e;
+    }; };
+
+    var withNodeID = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.idKey, idKey = _c === void 0 ? 'id' : _c, _d = _b.idCreator, idCreator = _d === void 0 ? function () { return Date.now(); } : _d, _e = _b.filterText, filterText = _e === void 0 ? true : _e, _f = _b.filter, filter = _f === void 0 ? function () { return true; } : _f;
+        return function (e) {
+            var editor = e;
+            var apply = editor.apply, getFragment = editor.getFragment;
+            var idPropsCreator = function () {
+                var _a;
+                return (_a = {}, _a[idKey] = idCreator(), _a);
+            };
+            editor.removedIDs = new Set();
+            editor.apply = function (operation) {
+                var _a;
+                if (operation.type === 'insert_node') {
+                    var newFilter = function (entry) {
+                        var _a = __read(entry, 1), _node = _a[0];
+                        return filter(entry) && filterText ? slate.Element.isElement(_node) : isDescendant(_node);
+                    };
+                    // fix can not find path by orign node
+                    var node = operation.node;
+                    if (!Object.isExtensible(node)) {
+                        node = _.cloneDeep(node);
+                    }
+                    // it will not overwrite ids once it's set as it's read-only
+                    mergeDeepToNodes({
+                        node: node,
+                        source: idPropsCreator,
+                        query: {
+                            filter: newFilter,
+                        }
+                    });
+                    return apply(Object.assign(Object.assign({}, operation), { node: node }));
+                }
+                if (operation.type === 'split_node' && (!filterText || operation.properties.type)) {
+                    var id = operation.properties[idKey];
+                    if (editor.removedIDs.has(id)) {
+                        editor.removedIDs.delete(id);
+                    }
+                    else {
+                        id = idCreator();
+                    }
+                    return apply(Object.assign(Object.assign({}, operation), { properties: Object.assign(Object.assign({}, operation.properties), (_a = {}, _a[idKey] = id, _a)) }));
+                }
+                if (operation.type === 'merge_node' && (!filterText || operation.properties.type)) {
+                    editor.removedIDs.add(operation.properties[idKey]);
+                }
+                return apply(operation);
+            };
+            editor.getFragment = function () {
+                var fragment = _.cloneDeep(getFragment());
+                return deleteElementKey(fragment, idKey);
+            };
+            return editor;
         };
-        return TheHrComponent;
-    }(TheBaseElementComponent));
-    TheHrComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: TheHrComponent, deps: [{ token: i0__namespace.ElementRef }, { token: i0__namespace.ChangeDetectorRef }], target: i0__namespace.ɵɵFactoryTarget.Component });
-    TheHrComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.15", type: TheHrComponent, selector: "the-hr, [theHr]", usesInheritance: true, ngImport: i0__namespace, template: "\n        <div class=\"the-hr\" contenteditable=\"false\" [ngClass]=\"{ active: selection }\">\n            <hr class=\"the-hr\" />\n            <slate-children [children]=\"children\" [context]=\"childrenContext\" [viewContext]=\"viewContext\"></slate-children>\n        </div>\n    ", isInline: true, components: [{ type: i1__namespace.SlateChildrenComponent, selector: "slate-children", inputs: ["children", "context", "viewContext"] }], directives: [{ type: i10__namespace.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: TheHrComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'the-hr, [theHr]',
-                        template: "\n        <div class=\"the-hr\" contenteditable=\"false\" [ngClass]=\"{ active: selection }\">\n            <hr class=\"the-hr\" />\n            <slate-children [children]=\"children\" [context]=\"childrenContext\" [viewContext]=\"viewContext\"></slate-children>\n        </div>\n    "
-                    }]
-            }], ctorParameters: function () { return [{ type: i0__namespace.ElementRef }, { type: i0__namespace.ChangeDetectorRef }]; } });
+    };
 
-    var withHr = function (editor) {
-        var isVoid = editor.isVoid, isBlockCard = editor.isBlockCard, renderElement = editor.renderElement;
-        editor.isVoid = function (element) {
-            return element.type === exports.ElementKinds.hr || isVoid(element);
-        };
-        editor.isBlockCard = function (element) {
-            if (element.type === exports.ElementKinds.hr) {
-                return true;
-            }
-            return isBlockCard(element);
-        };
-        editor.renderElement = function (element) {
-            if (element.type === exports.ElementKinds.hr) {
-                return TheHrComponent;
-            }
-            return renderElement(element);
-        };
-        return editor;
+    var autoFormatBlock = function (editor, type, at, _a, markups) {
+        var preFormat = _a.preFormat, format = _a.format;
+        slate.Transforms.delete(editor, { at: at });
+        if (preFormat) {
+            preFormat(editor);
+        }
+        if (!format) {
+            slate.Transforms.setNodes(editor, { type: type }, { match: function (n) { return slate.Editor.isBlock(editor, n); } });
+        }
+        else {
+            format(editor, markups);
+        }
     };
 
-    var withAlign = function (editor) {
-        var deleteBackward = editor.deleteBackward;
-        editor.deleteBackward = function (unit) {
-            var anchor = editor.selection.anchor;
-            var node = anchorBlock(editor);
-            var isVoid = slate.Editor.isVoid(editor, node);
-            var alignTypes = [exports.Alignment.center, exports.Alignment.right];
-            var startLine = slate.Editor.start(editor, anchor.path);
-            var startLineRange = { anchor: anchor, focus: startLine };
-            var beforeText = slate.Editor.string(editor, startLineRange);
-            if (!isVoid && node && node.align && alignTypes.includes(node.align) && beforeText === '') {
-                var align = alignTypes.indexOf(node.align) ? exports.Alignment.center : undefined;
-                return slate.Transforms.setNodes(editor, { align: align });
+    var autoFormatInline = function (editor, _a) {
+        var type = _a.type, between = _a.between, markup = _a.markup, ignoreTrim = _a.ignoreTrim, format = _a.format;
+        var selection = editor.selection;
+        var startMarkup = between ? between[0] : markup;
+        var endMarkup = between ? between[1] : '';
+        var endMarkupPointBefore = selection.anchor;
+        if (endMarkup) {
+            endMarkupPointBefore = getPointBefore(editor, selection, {
+                matchString: endMarkup
+            });
+            if (!endMarkupPointBefore) {
+                return false;
             }
-            deleteBackward(unit);
+        }
+        var startMarkupPointAfter = getPointBefore(editor, endMarkupPointBefore, {
+            matchString: startMarkup,
+            skipInvalid: true,
+            afterMatch: true
+        });
+        if (!startMarkupPointAfter) {
+            return false;
+        }
+        // found
+        var markupRange = {
+            anchor: startMarkupPointAfter,
+            focus: endMarkupPointBefore
         };
-        return editor;
+        if (!ignoreTrim) {
+            var markupText = getText(editor, markupRange);
+            if (markupText.trim() !== markupText) {
+                return false;
+            }
+        }
+        // delete end markup
+        if (endMarkup) {
+            endMarkupPointBefore = getPointBefore(editor, selection, {
+                matchString: endMarkup
+            });
+            slate.Transforms.delete(editor, {
+                at: {
+                    anchor: endMarkupPointBefore,
+                    focus: selection.anchor
+                }
+            });
+        }
+        var startMarkupPointBefore = getPointBefore(editor, selection, {
+            matchString: startMarkup,
+            skipInvalid: true
+        });
+        if (format) {
+            var markupText = getText(editor, markupRange);
+            format(editor, markupText);
+            // delete start to end selection
+            slate.Transforms.delete(editor, {
+                at: {
+                    anchor: startMarkupPointBefore,
+                    focus: selection.anchor
+                }
+            });
+        }
+        else {
+            // add mark to the text between the markups
+            slate.Transforms.select(editor, markupRange);
+            editor.addMark(type, true);
+            slate.Transforms.collapse(editor, { edge: 'end' });
+            editor.removeMark(type, false);
+            // delete start markup
+            slate.Transforms.delete(editor, {
+                at: {
+                    anchor: startMarkupPointBefore,
+                    focus: startMarkupPointAfter
+                }
+            });
+        }
+        return true;
     };
 
-    var withHeading = function (editor) {
-        var insertBreak = editor.insertBreak;
-        editor.insertBreak = function () {
-            var selection = editor.selection;
-            var anchorBlock = getAnchorBlockEntry(editor);
-            if (anchorBlock && slate.Range.isCollapsed(selection) && anchorBlock[0].type.startsWith('heading')) {
-                if (slate.Editor.isStart(editor, selection.anchor, anchorBlock[1])) {
-                    insertBreak();
-                    slate.Transforms.setNodes(editor, { type: exports.ElementKinds.paragraph }, {
-                        at: selection
+    var ListEditor = {
+        isList: function (editor, element, type) {
+            return slate.Editor.isBlock(editor, element) && element.type === type;
+        },
+        toggleList: function (editor, type, startIndex) {
+            var _this = this;
+            if (!editor.selection) {
+                return;
+            }
+            if (!startIndex) {
+                startIndex = 1;
+            }
+            var types = [exports.ElementKinds.bulletedList, exports.ElementKinds.numberedList];
+            slate.Editor.withoutNormalizing(editor, function () {
+                var _a = __read(slate.Editor.nodes(editor, {
+                    match: function (node) { return slate.Element.isElement(node) && node.type === exports.ElementKinds.listItem; },
+                    mode: 'lowest'
+                })), listItems = _a.slice(0);
+                var firstListItemPath = listItems.length && listItems[0][1];
+                var activeListPath = listItems.length && slate.Path.parent(firstListItemPath);
+                var activeListNode = listItems.length && slate.Node.get(editor, activeListPath);
+                // 同级且类型相同：unwrap
+                var isLowestActive = listItems.length &&
+                    listItems.every(function (_a) {
+                        var _b = __read(_a, 2), path = _b[1];
+                        return activeListNode.type === type && (slate.Path.isSibling(firstListItemPath, path) || slate.Path.equals(firstListItemPath, path));
+                    });
+                if (isLowestActive) {
+                    var upListItem = slate.Path.parent(activeListPath);
+                    slate.Transforms.unwrapNodes(editor, {
+                        at: editor.selection,
+                        match: function (node) { return node === activeListNode; },
+                        split: true,
+                        mode: 'lowest'
                     });
+                    if (upListItem && slate.Node.get(editor, upListItem).type === exports.ElementKinds.listItem) {
+                        slate.Transforms.moveNodes(editor, {
+                            at: editor.selection,
+                            to: slate.Path.next(upListItem),
+                            match: function (node) { return slate.Element.isElement(node) && node.type === exports.ElementKinds.listItem; }
+                        });
+                    }
+                    else {
+                        slate.Transforms.unwrapNodes(editor, {
+                            match: function (node) { return slate.Element.isElement(node) && node.type === exports.ElementKinds.listItem; }
+                        });
+                    }
                     return;
                 }
-                if (slate.Editor.isEnd(editor, selection.focus, anchorBlock[1])) {
-                    insertBreak();
-                    slate.Transforms.setNodes(editor, { type: exports.ElementKinds.paragraph });
+                // 跨级、同级且类型不同
+                if (activeListNode && types.includes(activeListNode.type)) {
+                    slate.Transforms.setNodes(editor, { type: type }, { match: function (node) { return slate.Element.isElement(node) && node.type !== type && types.includes(node.type); } });
                     return;
                 }
-            }
-            insertBreak();
-        };
-        return editor;
-    };
-
-    var withMark = function () { return function (editor) {
-        var e = editor;
-        e.removeMark = function (key, shouldChange) {
-            if (shouldChange === void 0) { shouldChange = true; }
-            var selection = e.selection;
-            if (selection) {
-                if (slate.Range.isExpanded(selection)) {
-                    slate.Transforms.unsetNodes(e, key, {
-                        match: slate.Text.isText,
-                        split: true
-                    });
-                }
-                else {
-                    var marks = Object.assign({}, (slate.Editor.marks(e) || {}));
-                    delete marks[key];
-                    editor.marks = marks;
-                    var text = slate.Editor.string(e, selection.anchor.path);
-                    if (text !== '') {
-                        slate.Editor.setNormalizing(editor, false);
-                        e.insertText('');
-                        editor.marks = marks;
-                        slate.Editor.setNormalizing(editor, true);
+                // wrap
+                _this.buildListItem(editor);
+                // Todo: types
+                slate.Transforms.wrapNodes(editor, { type: type, children: [], start: startIndex }, {
+                    at: editor.selection,
+                    match: function (node) { return slate.Element.isElement(node) && node.type === exports.ElementKinds.listItem; }
+                });
+            });
+        },
+        unwrapList: function (editor) {
+            slate.Editor.withoutNormalizing(editor, function () {
+                unwrapNodesByType(editor, [exports.ElementKinds.bulletedList, exports.ElementKinds.numberedList], { split: true, mode: 'all' });
+                unwrapNodesByType(editor, [exports.ElementKinds.listItem], { split: true, mode: 'all' });
+            });
+        },
+        wrapList: function (editor, type) {
+            slate.Editor.withoutNormalizing(editor, function () {
+                var listItem = {
+                    type: exports.ElementKinds.listItem,
+                    children: []
+                };
+                var list = {
+                    type: type,
+                    children: []
+                };
+                slate.Transforms.wrapNodes(editor, list, { split: true });
+                slate.Transforms.wrapNodes(editor, listItem, { split: true });
+            });
+        },
+        isActive: function (editor, type) {
+            var _a = __read(getNodesByType(editor, type), 1), match = _a[0];
+            return !!match;
+        },
+        getActiveList: function (editor) {
+            var _a = __read(getNodesByType(editor, LIST_BLOCK_TYPES), 1), match = _a[0];
+            return match;
+        },
+        buildListItem: function (editor) {
+            var e_1, _a;
+            var nodes = slate.Editor.nodes(editor, {
+                match: function (node) { return slate.Editor.isBlock(editor, node); },
+                mode: 'lowest'
+            });
+            try {
+                for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
+                    var _b = __read(nodes_1_1.value, 2), node = _b[0], path = _b[1];
+                    if (!slate.Editor.isVoid(editor, node) && slate.Element.isElement(node) && node.type !== exports.ElementKinds.paragraph) {
+                        slate.Transforms.setNodes(editor, { type: exports.ElementKinds.paragraph, checked: undefined }, // todo remove checked
+                        { at: path });
                     }
-                    else {
-                        slate.Transforms.unsetNodes(e, key, { at: selection.anchor.path });
+                    else if (slate.Element.isElement(node) && node.type === exports.ElementKinds.paragraph) {
+                        var textIndent = node.textIndent;
+                        if (textIndent) {
+                            slate.Transforms.setNodes(editor, { textIndent: undefined, indent: undefined }, // remove indent
+                            { at: path });
+                        }
                     }
-                    if (shouldChange) {
-                        editor.onChange();
+                    if (slate.Node.parent(editor, path).type !== exports.ElementKinds.listItem) {
+                        slate.Transforms.wrapNodes(editor, { type: exports.ElementKinds.listItem, children: [] }, {
+                            at: path,
+                            split: true
+                        });
                     }
                 }
             }
-        };
-        e.addMark = function (key, value) {
-            var _a, _b, _c;
-            var selection = editor.selection;
-            if (selection) {
-                if (slate.Range.isExpanded(selection)) {
-                    slate.Transforms.setNodes(e, (_a = {}, _a[key] = value, _a), { match: slate.Text.isText, split: true });
-                }
-                else {
-                    var marks = Object.assign(Object.assign({}, (slate.Editor.marks(e) || {})), (_b = {}, _b[key] = value, _b));
-                    editor.marks = marks;
-                    var text = slate.Editor.string(e, selection.anchor.path);
-                    if (text !== '') {
-                        slate.Editor.setNormalizing(editor, false);
-                        e.insertText('');
-                        editor.marks = marks;
-                        slate.Editor.setNormalizing(editor, true);
-                    }
-                    else {
-                        slate.Transforms.setNodes(e, (_c = {}, _c[key] = value, _c), { at: selection.anchor.path });
-                    }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
                 }
+                finally { if (e_1) throw e_1.error; }
             }
-        };
-        return e;
-    }; };
+        },
+        buildInsertDataChildren: function (node) {
+            var children = node.children;
+            var listItem = children[0];
+            if (isNodeTypeList(node) && slate.Element.isElement(listItem) && listItem.children[0].type === exports.ElementKinds.paragraph) {
+                return node;
+            }
+            return this.buildInsertDataChildren(listItem);
+        }
+    };
 
-    var withNodeID = function (_a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.idKey, idKey = _c === void 0 ? 'id' : _c, _d = _b.idCreator, idCreator = _d === void 0 ? function () { return Date.now(); } : _d, _e = _b.filterText, filterText = _e === void 0 ? true : _e, _f = _b.filter, filter = _f === void 0 ? function () { return true; } : _f;
-        return function (e) {
-            var editor = e;
-            var apply = editor.apply, getFragment = editor.getFragment;
-            var idPropsCreator = function () {
-                var _a;
-                return (_a = {}, _a[idKey] = idCreator(), _a);
-            };
-            editor.removedIDs = new Set();
-            editor.apply = function (operation) {
-                var _a;
-                if (operation.type === 'insert_node') {
-                    var newFilter = function (entry) {
-                        var _a = __read(entry, 1), _node = _a[0];
-                        return filter(entry) && filterText ? slate.Element.isElement(_node) : isDescendant(_node);
-                    };
-                    // fix can not find path by orign node
-                    var node = operation.node;
-                    if (!Object.isExtensible(node)) {
-                        node = _.cloneDeep(node);
-                    }
-                    // it will not overwrite ids once it's set as it's read-only
-                    mergeDeepToNodes({
-                        node: node,
-                        source: idPropsCreator,
-                        query: {
-                            filter: newFilter,
-                        }
-                    });
-                    return apply(Object.assign(Object.assign({}, operation), { node: node }));
-                }
-                if (operation.type === 'split_node' && (!filterText || operation.properties.type)) {
-                    var id = operation.properties[idKey];
-                    if (editor.removedIDs.has(id)) {
-                        editor.removedIDs.delete(id);
-                    }
-                    else {
-                        id = idCreator();
-                    }
-                    return apply(Object.assign(Object.assign({}, operation), { properties: Object.assign(Object.assign({}, operation.properties), (_a = {}, _a[idKey] = id, _a)) }));
-                }
-                if (operation.type === 'merge_node' && (!filterText || operation.properties.type)) {
-                    editor.removedIDs.add(operation.properties[idKey]);
+    var TodoItemEditor = {
+        isActive: function (editor) {
+            var _a = __read(getNodesByType(editor, exports.ElementKinds.checkItem), 1), match = _a[0];
+            return !!match;
+        },
+        insertTodoItem: function (editor) {
+            if (!editor.selection) {
+                return;
+            }
+            var isActive = this.isActive(editor);
+            var isNumberedList = ListEditor.isActive(editor, exports.ElementKinds.numberedList);
+            var isBulletedList = ListEditor.isActive(editor, exports.ElementKinds.bulletedList);
+            if (isActive) {
+                slate.Transforms.setNodes(editor, {
+                    type: exports.ElementKinds.paragraph
+                });
+            }
+            else {
+                if (isNumberedList || isBulletedList) {
+                    ListEditor.unwrapList(editor);
                 }
-                return apply(operation);
-            };
-            editor.getFragment = function () {
-                var fragment = _.cloneDeep(getFragment());
-                return deleteElementKey(fragment, idKey);
-            };
-            return editor;
-        };
+                slate.Transforms.setNodes(editor, {
+                    type: exports.ElementKinds.checkItem
+                });
+            }
+        }
     };
 
-    var autoFormatBlock = function (editor, type, at, _a, markups) {
-        var preFormat = _a.preFormat, format = _a.format;
-        slate.Transforms.delete(editor, { at: at });
-        if (preFormat) {
-            preFormat(editor);
+    var BlockquoteEditor = {
+        toggleBlockquote: function (editor) {
+            if (!isParagraph(editor)) {
+                slate.Transforms.insertNodes(editor, {
+                    type: exports.ElementKinds.paragraph,
+                    mode: 'text',
+                    children: [
+                        {
+                            text: ''
+                        }
+                    ]
+                });
+            }
+            var isActive = isBlockActive(editor, exports.ElementKinds.blockquote);
+            if (!isActive) {
+                slate.Transforms.wrapNodes(editor, { type: exports.ElementKinds.blockquote, children: [] }, {
+                    mode: 'lowest'
+                });
+            }
+            else {
+                slate.Transforms.unwrapNodes(editor, { match: function (n) { return slate.Element.isElement(n) && n.type === exports.ElementKinds.blockquote; } });
+            }
         }
-        if (!format) {
-            slate.Transforms.setNodes(editor, { type: type }, { match: function (n) { return slate.Editor.isBlock(editor, n); } });
+    };
+
+    var InlineCodeEditor = {
+        toggleInlineCode: function (editor, text) {
+            var isActive = InlineCodeEditor.isInlineCodeActive(editor);
+            if (isActive) {
+                InlineCodeEditor.unwrapInlineCode(editor);
+                return;
+            }
+            if (slate.Range.isCollapsed(editor.selection)) {
+                InlineCodeEditor.wrapInlineCode(editor, text);
+            }
+            else {
+                var fragment = slate.Node.fragment(editor, editor.selection)[0];
+                var selectNode = slate.Node.get(fragment, []);
+                var selectText = slate.Node.string(selectNode);
+                InlineCodeEditor.wrapInlineCode(editor, selectText);
+            }
+        },
+        wrapInlineCode: function (editor, text) {
+            if (text === void 0) { text = ''; }
+            if (InlineCodeEditor.isInlineCodeActive(editor)) {
+                InlineCodeEditor.unwrapInlineCode(editor);
+            }
+            var selection = editor.selection;
+            var isCollapsed = selection && slate.Range.isCollapsed(selection);
+            var inlineCode = {
+                type: exports.ElementKinds.inlineCode,
+                children: isCollapsed ? [{ text: text ? text : ZERO_WIDTH_CHAR }] : []
+            };
+            if (isCollapsed) {
+                slate.Transforms.insertNodes(editor, inlineCode);
+            }
+            else {
+                slate.Transforms.wrapNodes(editor, inlineCode, { split: true });
+            }
+        },
+        unwrapInlineCode: function (editor) {
+            slate.Transforms.unwrapNodes(editor, { match: function (n) { return slate.Element.isElement(n) && n.type === exports.ElementKinds.inlineCode; } });
+        },
+        isInlineCodeActive: function (editor, path) {
+            var _a;
+            var _b = __read(slate.Editor.nodes(editor, {
+                at: path ? path : (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.anchor.path,
+                match: function (n) { return slate.Element.isElement(n) && n.type === exports.ElementKinds.inlineCode; }
+            }), 1), inlineCode = _b[0];
+            return !!inlineCode;
         }
-        else {
-            format(editor, markups);
+    };
+
+    var HeadingEditor = {
+        setHeading: function (editor, heading) {
+            slate.Editor.withoutNormalizing(editor, function () {
+                var _a;
+                var types = [exports.ElementKinds.bulletedList, exports.ElementKinds.numberedList, exports.ElementKinds.listItem];
+                slate.Transforms.unwrapNodes(editor, {
+                    at: editor.selection,
+                    match: function (n) { return slate.Element.isElement(n) && types.includes(n.type); },
+                    mode: 'all',
+                    split: true
+                });
+                slate.Transforms.setNodes(editor, { type: heading });
+                var entry = anchorBlockEntry(editor);
+                var unMarks = (_a = {},
+                    _a[exports.MarkTypes.fontSize] = null,
+                    _a);
+                if (entry) {
+                    setMarks(editor, unMarks, entry[1]);
+                    return;
+                }
+                setMarks(editor, unMarks, editor.selection);
+            });
+        },
+        isHeadingActive: function (editor, heading) {
+            var _a = __read(slate.Editor.nodes(editor, {
+                match: function (n) { return slate.Element.isElement(n) && n.type === heading; },
+                universal: true
+            }), 1), match = _a[0];
+            return !!match;
         }
     };
 
-    var autoFormatInline = function (editor, _a) {
-        var type = _a.type, between = _a.between, markup = _a.markup, ignoreTrim = _a.ignoreTrim, format = _a.format;
-        var selection = editor.selection;
-        var startMarkup = between ? between[0] : markup;
-        var endMarkup = between ? between[1] : '';
-        var endMarkupPointBefore = selection.anchor;
-        if (endMarkup) {
-            endMarkupPointBefore = getPointBefore(editor, selection, {
-                matchString: endMarkup
-            });
-            if (!endMarkupPointBefore) {
-                return false;
+    var defaultAutoFormatRules = [
+        {
+            type: exports.ElementKinds.heading_1,
+            markup: '#',
+            format: function (editor) {
+                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_1);
             }
-        }
-        var startMarkupPointAfter = getPointBefore(editor, endMarkupPointBefore, {
-            matchString: startMarkup,
-            skipInvalid: true,
-            afterMatch: true
-        });
-        if (!startMarkupPointAfter) {
-            return false;
-        }
-        // found
-        var markupRange = {
-            anchor: startMarkupPointAfter,
-            focus: endMarkupPointBefore
-        };
-        if (!ignoreTrim) {
-            var markupText = getText(editor, markupRange);
-            if (markupText.trim() !== markupText) {
-                return false;
+        },
+        {
+            type: exports.ElementKinds.heading_2,
+            markup: '##',
+            format: function (editor) {
+                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_2);
             }
-        }
-        // delete end markup
-        if (endMarkup) {
-            endMarkupPointBefore = getPointBefore(editor, selection, {
-                matchString: endMarkup
-            });
-            slate.Transforms.delete(editor, {
-                at: {
-                    anchor: endMarkupPointBefore,
-                    focus: selection.anchor
-                }
-            });
-        }
-        var startMarkupPointBefore = getPointBefore(editor, selection, {
-            matchString: startMarkup,
-            skipInvalid: true
-        });
-        if (format) {
-            var markupText = getText(editor, markupRange);
-            format(editor, markupText);
-            // delete start to end selection
-            slate.Transforms.delete(editor, {
-                at: {
-                    anchor: startMarkupPointBefore,
-                    focus: selection.anchor
-                }
-            });
-        }
-        else {
-            // add mark to the text between the markups
-            slate.Transforms.select(editor, markupRange);
-            editor.addMark(type, true);
-            slate.Transforms.collapse(editor, { edge: 'end' });
-            editor.removeMark(type, false);
-            // delete start markup
-            slate.Transforms.delete(editor, {
-                at: {
-                    anchor: startMarkupPointBefore,
-                    focus: startMarkupPointAfter
+        },
+        {
+            type: exports.ElementKinds.heading_3,
+            markup: '###',
+            format: function (editor) {
+                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_3);
+            }
+        },
+        {
+            type: exports.ElementKinds.heading_4,
+            markup: '####',
+            format: function (editor) {
+                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_4);
+            }
+        },
+        {
+            type: exports.ElementKinds.heading_5,
+            markup: '#####',
+            format: function (editor) {
+                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_5);
+            }
+        },
+        {
+            type: exports.ElementKinds.heading_6,
+            markup: '######',
+            format: function (editor) {
+                HeadingEditor.setHeading(editor, exports.ElementKinds.heading_6);
+            }
+        },
+        {
+            type: exports.ElementKinds.blockquote,
+            markup: ['>'],
+            format: function (editor) {
+                BlockquoteEditor.toggleBlockquote(editor);
+            }
+        },
+        {
+            type: exports.MarkTypes.bold,
+            between: ['**', '**'],
+            mode: 'inline',
+            insertTrigger: true
+        },
+        {
+            type: exports.MarkTypes.bold,
+            between: ['__', '__'],
+            mode: 'inline',
+            insertTrigger: true
+        },
+        {
+            type: exports.MarkTypes.italic,
+            between: ['*', '*'],
+            mode: 'inline',
+            insertTrigger: true
+        },
+        {
+            type: exports.MarkTypes.italic,
+            between: ['_', '_'],
+            mode: 'inline',
+            insertTrigger: true
+        },
+        {
+            type: exports.ElementKinds.inlineCode,
+            between: ['`', '`'],
+            mode: 'inline',
+            format: function (editor, text) {
+                InlineCodeEditor.toggleInlineCode(editor, text);
+                slate.Transforms.select(editor, slate.Editor.after(editor, editor.selection));
+            }
+        },
+        {
+            type: exports.MarkTypes.strike,
+            between: ['~~', '~~'],
+            mode: 'inline',
+            insertTrigger: true
+        },
+        {
+            type: exports.ElementKinds.code,
+            markup: '```',
+            insertTrigger: true
+        },
+        {
+            type: exports.ElementKinds.listItem,
+            markup: [],
+            match: function (editor) {
+                return isParagraph(editor) ? ['*', '-', '+'] : [];
+            },
+            format: function (editor) {
+                ListEditor.toggleList(editor, exports.ElementKinds.bulletedList);
+            }
+        },
+        {
+            type: exports.ElementKinds.listItem,
+            key: exports.ElementKinds.numberedList,
+            markup: [],
+            match: function (editor, textFromBlockStart) {
+                return isParagraph(editor) && /^-?\d+(\.|\))$/.test(textFromBlockStart) ? [textFromBlockStart] : [];
+            },
+            format: function (editor, markup) {
+                var startIndex = 1;
+                if (markup) {
+                    startIndex = markup[0].split('.')[0];
+                    if (startIndex === 0) {
+                        startIndex = 1;
+                    }
                 }
-            });
+                ListEditor.toggleList(editor, exports.ElementKinds.numberedList, startIndex);
+            }
+        },
+        {
+            type: exports.ElementKinds.checkItem,
+            markup: [],
+            match: function (editor) {
+                return isParagraph(editor) ? ['[]'] : [];
+            },
+            format: function (editor) {
+                TodoItemEditor.insertTodoItem(editor);
+            }
+        },
+        {
+            type: exports.ElementKinds.hr,
+            markup: '---',
+            insertTrigger: true
         }
-        return true;
-    };
+    ];
 
-    var withAutoFormat = function (_c) {
-        var rules = _c.rules;
-        return function (editor) {
-            var insertText = editor.insertText;
-            editor.insertText = function (text) {
-                var e_1, _c;
-                var _a;
-                if (!isCollapsed(editor.selection)) {
-                    return insertText(text);
-                }
-                var _loop_1 = function (_b) {
-                    var query = _b.query, rule = __rest(_b, ["query"]);
-                    var _d = rule.trigger, trigger = _d === void 0 ? ' ' : _d, _e = rule.mode, mode = _e === void 0 ? 'block' : _e, type = rule.type, markup = rule.markup, preFormat = rule.preFormat, format = rule.format, match = rule.match, between = rule.between, ignoreTrim = rule.ignoreTrim, insertTrigger = rule.insertTrigger, _f = rule.allowSameTypeAbove, allowSameTypeAbove = _f === void 0 ? false : _f, _g = rule.triggerAtBlockStart, triggerAtBlockStart = _g === void 0 ? true : _g;
-                    if (query && !query(editor, rule))
-                        return "continue";
-                    var triggers = castArray(trigger);
-                    // Check trigger
-                    if (!triggers.includes(text))
-                        return "continue";
-                    var valid = function () { return insertTrigger && insertText(text); };
-                    if (mode === 'block') {
-                        var markups = castArray(markup);
-                        var markupRange = void 0;
-                        if (triggerAtBlockStart) {
-                            markupRange = getRangeFromBlockStart(editor);
-                            // Don't autoformat if there is void nodes.
-                            var hasVoidNode = someNode(editor, {
-                                at: markupRange,
-                                match: function (n) { return slate.Editor.isVoid(editor, n); }
-                            });
-                            if (hasVoidNode)
-                                return "continue";
-                            var textFromBlockStart = getText(editor, markupRange);
-                            if (match) {
-                                markups = match(editor, textFromBlockStart);
-                            }
-                            if (!markups.includes(textFromBlockStart))
-                                return "continue";
-                        }
-                        else {
-                            markupRange = getRangeBefore(editor, editor.selection, {
-                                matchString: markup,
-                                skipInvalid: true
-                            });
-                            if (!markupRange)
-                                return "continue";
-                            var blockAbovePath = (_a = getBlockAbove(editor)) === null || _a === void 0 ? void 0 : _a[1];
-                            if (!blockAbovePath)
-                                return "continue";
-                            // If the markup is not at the start, insert break before autoformatting.
-                            if (!slate.Editor.isStart(editor, markupRange.anchor, blockAbovePath)) {
-                                editor.insertBreak();
-                            }
-                        }
-                        if (!allowSameTypeAbove) {
-                            // Don't autoformat if already in a block of the same type.
-                            var isBelowSameBlockType = someNode(editor, { match: { type: type } });
-                            if (isBelowSameBlockType)
-                                return "continue";
+    var withAutoFormat = function () { return function (editor) {
+        var insertText = editor.insertText;
+        editor.insertText = function (text) {
+            var e_1, _d;
+            var _a, _b;
+            var autoFormatRules = defaultAutoFormatRules;
+            if ((_a = editor.extraAutoFormatRules) === null || _a === void 0 ? void 0 : _a.length) {
+                var extraRules = mergAutoFormateRules(editor.extraAutoFormatRules);
+                autoFormatRules = Object.values(extraRules);
+            }
+            if (!isCollapsed(editor.selection)) {
+                return insertText(text);
+            }
+            var _loop_1 = function (_c) {
+                var query = _c.query, rule = __rest(_c, ["query"]);
+                var _e = rule.trigger, trigger = _e === void 0 ? ' ' : _e, _f = rule.mode, mode = _f === void 0 ? 'block' : _f, type = rule.type, markup = rule.markup, preFormat = rule.preFormat, format = rule.format, match = rule.match, between = rule.between, ignoreTrim = rule.ignoreTrim, insertTrigger = rule.insertTrigger, _g = rule.allowSameTypeAbove, allowSameTypeAbove = _g === void 0 ? false : _g, _h = rule.triggerAtBlockStart, triggerAtBlockStart = _h === void 0 ? true : _h;
+                if (query && !query(editor, rule))
+                    return "continue";
+                var triggers = castArray(trigger);
+                // Check trigger
+                if (!triggers.includes(text))
+                    return "continue";
+                var valid = function () { return insertTrigger && insertText(text); };
+                if (mode === 'block') {
+                    var markups = castArray(markup);
+                    var markupRange = void 0;
+                    if (triggerAtBlockStart) {
+                        markupRange = getRangeFromBlockStart(editor);
+                        // Don't autoformat if there is void nodes.
+                        var hasVoidNode = someNode(editor, {
+                            at: markupRange,
+                            match: function (n) { return slate.Editor.isVoid(editor, n); }
+                        });
+                        if (hasVoidNode)
+                            return "continue";
+                        var textFromBlockStart = getText(editor, markupRange);
+                        if (match) {
+                            markups = match(editor, textFromBlockStart);
                         }
-                        // Start of the block
-                        autoFormatBlock(editor, type, markupRange, {
-                            preFormat: preFormat,
-                            format: format
-                        }, markups);
-                        return { value: valid() };
+                        if (!markups.includes(textFromBlockStart))
+                            return "continue";
                     }
-                    if (mode === 'inline') {
-                        if (autoFormatInline(editor, {
-                            type: type,
-                            between: between,
-                            ignoreTrim: ignoreTrim,
-                            format: format,
-                            markup: Array.isArray(markup) ? markup[0] : markup
-                        })) {
-                            return { value: valid() };
+                    else {
+                        markupRange = getRangeBefore(editor, editor.selection, {
+                            matchString: markup,
+                            skipInvalid: true
+                        });
+                        if (!markupRange)
+                            return "continue";
+                        var blockAbovePath = (_b = getBlockAbove(editor)) === null || _b === void 0 ? void 0 : _b[1];
+                        if (!blockAbovePath)
+                            return "continue";
+                        // If the markup is not at the start, insert break before autoformatting.
+                        if (!slate.Editor.isStart(editor, markupRange.anchor, blockAbovePath)) {
+                            editor.insertBreak();
                         }
                     }
-                };
-                try {
-                    for (var rules_1 = __values(rules), rules_1_1 = rules_1.next(); !rules_1_1.done; rules_1_1 = rules_1.next()) {
-                        var _b = rules_1_1.value;
-                        var state_1 = _loop_1(_b);
-                        if (typeof state_1 === "object")
-                            return state_1.value;
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (rules_1_1 && !rules_1_1.done && (_c = rules_1.return)) _c.call(rules_1);
+                    if (!allowSameTypeAbove) {
+                        // Don't autoformat if already in a block of the same type.
+                        var isBelowSameBlockType = someNode(editor, { match: { type: type } });
+                        if (isBelowSameBlockType)
+                            return "continue";
+                    }
+                    // Start of the block
+                    autoFormatBlock(editor, type, markupRange, {
+                        preFormat: preFormat,
+                        format: format
+                    }, markups);
+                    return { value: valid() };
+                }
+                if (mode === 'inline') {
+                    if (autoFormatInline(editor, {
+                        type: type,
+                        between: between,
+                        ignoreTrim: ignoreTrim,
+                        format: format,
+                        markup: Array.isArray(markup) ? markup[0] : markup
+                    })) {
+                        return { value: valid() };
                     }
-                    finally { if (e_1) throw e_1.error; }
                 }
-                insertText(text);
             };
-            return editor;
+            try {
+                for (var autoFormatRules_1 = __values(autoFormatRules), autoFormatRules_1_1 = autoFormatRules_1.next(); !autoFormatRules_1_1.done; autoFormatRules_1_1 = autoFormatRules_1.next()) {
+                    var _c = autoFormatRules_1_1.value;
+                    var state_1 = _loop_1(_c);
+                    if (typeof state_1 === "object")
+                        return state_1.value;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (autoFormatRules_1_1 && !autoFormatRules_1_1.done && (_d = autoFormatRules_1.return)) _d.call(autoFormatRules_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            insertText(text);
         };
+        return editor;
+    }; };
+    var mergAutoFormateRules = function (extraAutoFormatRules) {
+        var combinationData = __spreadArray(__spreadArray([], __read(defaultAutoFormatRules)), __read(extraAutoFormatRules));
+        var dataInfo = {};
+        combinationData.forEach(function (item) {
+            if (!dataInfo[item.type + item.key]) {
+                dataInfo[item.type + item.key] = Object.assign({}, item);
+            }
+            dataInfo[item.type + item.key] = Object.assign(Object.assign({}, dataInfo[item.type + item.key]), item);
+        });
+        return dataInfo;
     };
 
     var withTransforms = function () { return function (editor) {
@@ -12759,7 +12773,7 @@
         }),
         withBlockquote,
         withNodeID({ idKey: ELEMENT_UNIQUE_ID, idCreator: idCreator }),
-        withAutoFormat({ rules: autoFormatRules }),
+        withAutoFormat(),
         withTransforms(),
         withTrailingNode({ type: exports.ElementKinds.paragraph, level: 0 }),
         withMoveSelection,
@@ -13700,11 +13714,12 @@
         };
         TheEditorComponent.prototype.initialize = function () {
             var _this = this;
-            var _a, _b;
+            var _a, _b, _c;
             this.editor = withTheEditor(this.thePlugins, slateHistory.withHistory(i1.withAngular(slate.createEditor(), CLIPBOARD_FORMAT_KEY)));
             this.generateDecorate();
             this.editor.disabled = (_a = this.theOptions) === null || _a === void 0 ? void 0 : _a.disabled;
             this.editor.extraElementOptions = (_b = this.theOptions) === null || _b === void 0 ? void 0 : _b.extraElementOptions;
+            this.editor.extraAutoFormatRules = (_c = this.theOptions) === null || _c === void 0 ? void 0 : _c.extraAutoFormatRules;
             setEditorUUID(this.editor, idCreator());
             this.theContextService.initialize({
                 theOptions: this.theOptions,