@worktile/theia 2.4.1 → 2.4.2

package/fesm2015/worktile-theia.js

@@ -8,14 +8,14 @@ import * as i1 from 'slate-angular';
 import { BaseTextComponent, BaseElementComponent, AngularEditor, NODE_TO_PARENT, NODE_TO_INDEX, IS_SAFARI, hotkeys, getPlainText as getPlainText$1, hasBlockCard, isCardLeft, FAKE_RIGHT_BLOCK_CARD_OFFSET, ELEMENT_TO_COMPONENT, EDITOR_TO_ELEMENT, isComponentType, withAngular, SlateModule } from 'slate-angular';
 import { mixinUnsubscribe, MixinBase } from 'ngx-tethys/core';
 import isHotkey, { isKeyHotkey } from 'is-hotkey';
-import { Element as Element$1, Editor, Range, Node, Span, Path, Text, Point, Transforms, Operation, createEditor } from 'slate';
+import { Transforms, Text, Range, Editor, Element as Element$1, Node, Span, Path, Point, Operation, createEditor } from 'slate';
 import { HistoryEditor, withHistory } from 'slate-history';
-import { __rest, __awaiter } from 'tslib';
-import * as _lodash from 'lodash';
 import marked from 'marked';
 import { TheiaConverter } from '@atinc/selene';
 import * as i1$3 from 'ngx-tethys/popover';
 import { ThyPopover } from 'ngx-tethys/popover';
+import { __rest, __awaiter } from 'tslib';
+import * as _lodash from 'lodash';
 import * as i2 from '@angular/cdk/overlay';
 import { Overlay, OverlayModule } from '@angular/cdk/overlay';
 import * as i1$1 from 'ngx-tethys/alert';
@@ -522,6 +522,61 @@ function idCreator(length = 5) {
     return key;
 }
 
+const UNDOING = new WeakMap();
+const REDOING = new WeakMap();
+const withTheHistory = (editor) => {
+    const { undo, redo } = editor;
+    editor.undo = () => {
+        UNDOING.set(editor, true);
+        undo();
+        UNDOING.set(editor, false);
+    };
+    editor.redo = () => {
+        REDOING.set(editor, true);
+        redo();
+        REDOING.set(editor, false);
+    };
+    return editor;
+};
+const TheHistoryEditor = {
+    isUndoing(editor) {
+        return UNDOING.get(editor);
+    },
+    isRedoing(editor) {
+        return REDOING.get(editor);
+    }
+};
+
+const setMarks = (editor, marks, at) => {
+    Transforms.setNodes(editor, marks, {
+        at,
+        match: Text.isText,
+        split: true
+    });
+};
+
+const clearMarks = (editor) => {
+    const { selection } = editor;
+    if (!selection) {
+        return;
+    }
+    if (Range.isCollapsed(selection)) {
+        const marks = Editor.marks(editor);
+        for (const key in marks) {
+            Editor.removeMark(editor, key);
+        }
+    }
+    else {
+        const unsetMarks = {};
+        MarkProps.forEach(key => {
+            unsetMarks[key] = null;
+        });
+        setMarks(editor, unsetMarks);
+    }
+};
+
+const insertElement = (editor, element) => editor.insertElement(element);
+
 const isAncestor = (node) => Element$1.isElement(node) || Editor.isEditor(node);
 
 const getLastChild$1 = (node, level) => {
@@ -1321,36 +1376,6 @@ var index$1 = /*#__PURE__*/Object.freeze({
     someNode: someNode
 });
 
-const setMarks = (editor, marks, at) => {
-    Transforms.setNodes(editor, marks, {
-        at,
-        match: Text.isText,
-        split: true
-    });
-};
-
-const clearMarks = (editor) => {
-    const { selection } = editor;
-    if (!selection) {
-        return;
-    }
-    if (Range.isCollapsed(selection)) {
-        const marks = Editor.marks(editor);
-        for (const key in marks) {
-            Editor.removeMark(editor, key);
-        }
-    }
-    else {
-        const unsetMarks = {};
-        MarkProps.forEach(key => {
-            unsetMarks[key] = null;
-        });
-        setMarks(editor, unsetMarks);
-    }
-};
-
-const insertElement = (editor, element) => editor.insertElement(element);
-
 const insertElementNext = (editor, node) => {
     if (Range.isExpanded(editor.selection)) {
         Editor.deleteFragment(editor);
@@ -1586,439 +1611,19 @@ var index = /*#__PURE__*/Object.freeze({
     handleContinualInsertBreak: handleContinualInsertBreak
 });
 
-const isNodeTypeList = (n) => {
-    return [ElementKinds.bulletedList, ElementKinds.numberedList].includes(n.type);
-};
-
-const ListEditor = {
-    isList(editor, element, type) {
-        return Editor.isBlock(editor, element) && element.type === type;
-    },
-    toggleList(editor, type, startIndex) {
-        if (!editor.selection) {
-            return;
-        }
-        if (!startIndex) {
-            startIndex = 1;
-        }
-        const types = [ElementKinds.bulletedList, ElementKinds.numberedList];
-        Editor.withoutNormalizing(editor, () => {
-            const [...listItems] = Editor.nodes(editor, {
-                match: node => Element$1.isElement(node) && node.type === ElementKinds.listItem,
-                mode: 'lowest'
-            });
-            const firstListItemPath = listItems.length && listItems[0][1];
-            const activeListPath = listItems.length && Path.parent(firstListItemPath);
-            const activeListNode = listItems.length && Node.get(editor, activeListPath);
-            // 同级且类型相同：unwrap
-            const isLowestActive = listItems.length &&
-                listItems.every(([, path]) => activeListNode.type === type && (Path.isSibling(firstListItemPath, path) || Path.equals(firstListItemPath, path)));
-            if (isLowestActive) {
-                const upListItem = Path.parent(activeListPath);
-                Transforms.unwrapNodes(editor, {
-                    at: editor.selection,
-                    match: node => node === activeListNode,
-                    split: true,
-                    mode: 'lowest'
-                });
-                if (upListItem && Node.get(editor, upListItem).type === ElementKinds.listItem) {
-                    Transforms.moveNodes(editor, {
-                        at: editor.selection,
-                        to: Path.next(upListItem),
-                        match: node => Element$1.isElement(node) && node.type === ElementKinds.listItem
-                    });
-                }
-                else {
-                    Transforms.unwrapNodes(editor, {
-                        match: node => Element$1.isElement(node) && node.type === ElementKinds.listItem
-                    });
-                }
-                return;
-            }
-            // 跨级、同级且类型不同
-            if (activeListNode && types.includes(activeListNode.type)) {
-                Transforms.setNodes(editor, { type }, { match: node => Element$1.isElement(node) && node.type !== type && types.includes(node.type) });
-                return;
-            }
-            // wrap
-            this.buildListItem(editor);
-            // Todo: types
-            Transforms.wrapNodes(editor, { type, children: [], start: startIndex }, {
-                at: editor.selection,
-                match: node => Element$1.isElement(node) && node.type === ElementKinds.listItem
-            });
-        });
-    },
-    unwrapList(editor) {
-        Editor.withoutNormalizing(editor, () => {
-            unwrapNodesByType(editor, [ElementKinds.bulletedList, ElementKinds.numberedList], { split: true, mode: 'all' });
-            unwrapNodesByType(editor, [ElementKinds.listItem], { split: true, mode: 'all' });
-        });
-    },
-    wrapList(editor, type) {
-        Editor.withoutNormalizing(editor, () => {
-            const listItem = {
-                type: ElementKinds.listItem,
-                children: []
-            };
-            const list = {
-                type,
-                children: []
-            };
-            Transforms.wrapNodes(editor, list, { split: true });
-            Transforms.wrapNodes(editor, listItem, { split: true });
-        });
-    },
-    isActive(editor, type) {
-        const [match] = getNodesByType(editor, type);
-        return !!match;
-    },
-    getActiveList(editor) {
-        const [match] = getNodesByType(editor, LIST_BLOCK_TYPES);
-        return match;
-    },
-    buildListItem(editor) {
-        const nodes = Editor.nodes(editor, {
-            match: node => Editor.isBlock(editor, node),
-            mode: 'lowest'
-        });
-        for (const [node, path] of nodes) {
-            if (!Editor.isVoid(editor, node) && Element$1.isElement(node) && node.type !== ElementKinds.paragraph) {
-                Transforms.setNodes(editor, { type: ElementKinds.paragraph, checked: undefined }, // todo remove checked
-                { at: path });
-            }
-            else if (Element$1.isElement(node) && node.type === ElementKinds.paragraph) {
-                let { textIndent } = node;
-                if (textIndent) {
-                    Transforms.setNodes(editor, { textIndent: undefined, indent: undefined }, // remove indent
-                    { at: path });
-                }
-            }
-            if (Node.parent(editor, path).type !== ElementKinds.listItem) {
-                Transforms.wrapNodes(editor, { type: ElementKinds.listItem, children: [] }, {
-                    at: path,
-                    split: true
-                });
-            }
-        }
-    },
-    buildInsertDataChildren(node) {
-        const { children } = node;
-        const listItem = children[0];
-        if (isNodeTypeList(node) && Element$1.isElement(listItem) && listItem.children[0].type === ElementKinds.paragraph) {
-            return node;
-        }
-        return this.buildInsertDataChildren(listItem);
+class TheConversionHintComponent {
+    constructor() {
+        this.duration = 10000;
+        this.pauseOnHover = true;
     }
-};
-
-const TodoItemEditor = {
-    isActive(editor) {
-        const [match] = getNodesByType(editor, ElementKinds.checkItem);
-        return !!match;
-    },
-    insertTodoItem(editor) {
-        if (!editor.selection) {
-            return;
-        }
-        const isActive = this.isActive(editor);
-        const isNumberedList = ListEditor.isActive(editor, ElementKinds.numberedList);
-        const isBulletedList = ListEditor.isActive(editor, ElementKinds.bulletedList);
-        if (isActive) {
-            Transforms.setNodes(editor, {
-                type: ElementKinds.paragraph
-            });
+    mouseenter() {
+        if (this.pauseOnHover) {
+            this.clearCloseTimer();
         }
-        else {
-            if (isNumberedList || isBulletedList) {
-                ListEditor.unwrapList(editor);
-            }
-            Transforms.setNodes(editor, {
-                type: ElementKinds.checkItem
-            });
-        }
-    }
-};
-
-const BlockquoteEditor = {
-    toggleBlockquote(editor) {
-        if (!isParagraph(editor)) {
-            Transforms.insertNodes(editor, {
-                type: ElementKinds.paragraph,
-                mode: 'text',
-                children: [
-                    {
-                        text: ''
-                    }
-                ]
-            });
-        }
-        const isActive = isBlockActive(editor, ElementKinds.blockquote);
-        if (!isActive) {
-            Transforms.wrapNodes(editor, { type: ElementKinds.blockquote, children: [] }, {
-                mode: 'lowest'
-            });
-        }
-        else {
-            Transforms.unwrapNodes(editor, { match: n => Element$1.isElement(n) && n.type === ElementKinds.blockquote });
-        }
-    }
-};
-
-const InlineCodeEditor = {
-    toggleInlineCode(editor, text) {
-        const isActive = InlineCodeEditor.isInlineCodeActive(editor);
-        if (isActive) {
-            InlineCodeEditor.unwrapInlineCode(editor);
-            return;
-        }
-        if (Range.isCollapsed(editor.selection)) {
-            InlineCodeEditor.wrapInlineCode(editor, text);
-        }
-        else {
-            const fragment = Node.fragment(editor, editor.selection)[0];
-            const selectNode = Node.get(fragment, []);
-            const selectText = Node.string(selectNode);
-            InlineCodeEditor.wrapInlineCode(editor, selectText);
-        }
-    },
-    wrapInlineCode(editor, text = '') {
-        if (InlineCodeEditor.isInlineCodeActive(editor)) {
-            InlineCodeEditor.unwrapInlineCode(editor);
-        }
-        const { selection } = editor;
-        const isCollapsed = selection && Range.isCollapsed(selection);
-        const inlineCode = {
-            type: ElementKinds.inlineCode,
-            children: isCollapsed ? [{ text: text ? text : ZERO_WIDTH_CHAR }] : []
-        };
-        if (isCollapsed) {
-            Transforms.insertNodes(editor, inlineCode);
-        }
-        else {
-            Transforms.wrapNodes(editor, inlineCode, { split: true });
-        }
-    },
-    unwrapInlineCode(editor) {
-        Transforms.unwrapNodes(editor, { match: n => Element$1.isElement(n) && n.type === ElementKinds.inlineCode });
-    },
-    isInlineCodeActive(editor, path) {
-        var _a;
-        const [inlineCode] = Editor.nodes(editor, {
-            at: path ? path : (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.anchor.path,
-            match: n => Element$1.isElement(n) && n.type === ElementKinds.inlineCode
-        });
-        return !!inlineCode;
-    }
-};
-
-const HeadingEditor = {
-    setHeading(editor, heading) {
-        Editor.withoutNormalizing(editor, () => {
-            const types = [ElementKinds.bulletedList, ElementKinds.numberedList, ElementKinds.listItem];
-            Transforms.unwrapNodes(editor, {
-                at: editor.selection,
-                match: n => Element$1.isElement(n) && types.includes(n.type),
-                mode: 'all',
-                split: true
-            });
-            Transforms.setNodes(editor, { type: heading });
-            const entry = anchorBlockEntry(editor);
-            const unMarks = {
-                [MarkTypes.fontSize]: null
-            };
-            if (entry) {
-                setMarks(editor, unMarks, entry[1]);
-                return;
-            }
-            setMarks(editor, unMarks, editor.selection);
-        });
-    },
-    isHeadingActive(editor, heading) {
-        const [match] = Editor.nodes(editor, {
-            match: n => Element$1.isElement(n) && n.type === heading,
-            universal: true
-        });
-        return !!match;
-    }
-};
-
-const autoFormatRules = [
-    {
-        type: ElementKinds.heading_1,
-        markup: '#',
-        format: (editor) => {
-            HeadingEditor.setHeading(editor, ElementKinds.heading_1);
-        }
-    },
-    {
-        type: ElementKinds.heading_2,
-        markup: '##',
-        format: (editor) => {
-            HeadingEditor.setHeading(editor, ElementKinds.heading_2);
-        }
-    },
-    {
-        type: ElementKinds.heading_3,
-        markup: '###',
-        format: (editor) => {
-            HeadingEditor.setHeading(editor, ElementKinds.heading_3);
-        }
-    },
-    {
-        type: ElementKinds.heading_4,
-        markup: '####',
-        format: (editor) => {
-            HeadingEditor.setHeading(editor, ElementKinds.heading_4);
-        }
-    },
-    {
-        type: ElementKinds.heading_5,
-        markup: '#####',
-        format: (editor) => {
-            HeadingEditor.setHeading(editor, ElementKinds.heading_5);
-        }
-    },
-    {
-        type: ElementKinds.heading_6,
-        markup: '######',
-        format: (editor) => {
-            HeadingEditor.setHeading(editor, ElementKinds.heading_6);
-        }
-    },
-    {
-        type: ElementKinds.blockquote,
-        markup: ['>'],
-        format: (editor) => {
-            BlockquoteEditor.toggleBlockquote(editor);
-        }
-    },
-    {
-        type: MarkTypes.bold,
-        between: ['**', '**'],
-        mode: 'inline',
-        insertTrigger: true
-    },
-    {
-        type: MarkTypes.bold,
-        between: ['__', '__'],
-        mode: 'inline',
-        insertTrigger: true
-    },
-    {
-        type: MarkTypes.italic,
-        between: ['*', '*'],
-        mode: 'inline',
-        insertTrigger: true
-    },
-    {
-        type: MarkTypes.italic,
-        between: ['_', '_'],
-        mode: 'inline',
-        insertTrigger: true
-    },
-    {
-        type: ElementKinds.inlineCode,
-        between: ['`', '`'],
-        mode: 'inline',
-        format: (editor, text) => {
-            InlineCodeEditor.toggleInlineCode(editor, text);
-            Transforms.select(editor, Editor.after(editor, editor.selection));
-        }
-    },
-    {
-        type: MarkTypes.strike,
-        between: ['~~', '~~'],
-        mode: 'inline',
-        insertTrigger: true
-    },
-    {
-        type: ElementKinds.code,
-        markup: '```',
-        insertTrigger: true
-    },
-    {
-        type: ElementKinds.listItem,
-        markup: [],
-        match: (editor) => {
-            return isParagraph(editor) ? ['*', '-', '+'] : [];
-        },
-        format: (editor) => {
-            ListEditor.toggleList(editor, ElementKinds.bulletedList);
-        }
-    },
-    {
-        type: ElementKinds.listItem,
-        markup: [],
-        match: (editor, textFromBlockStart) => {
-            return isParagraph(editor) && /^-?\d+(\.|\))$/.test(textFromBlockStart) ? [textFromBlockStart] : [];
-        },
-        format: (editor, markup) => {
-            let startIndex = 1;
-            if (markup) {
-                startIndex = markup[0].split('.')[0];
-                if (startIndex === 0) {
-                    startIndex = 1;
-                }
-            }
-            ListEditor.toggleList(editor, ElementKinds.numberedList, startIndex);
-        }
-    },
-    {
-        type: ElementKinds.checkItem,
-        markup: [],
-        match: (editor) => {
-            return isParagraph(editor) ? ['[]'] : [];
-        },
-        format: (editor) => {
-            TodoItemEditor.insertTodoItem(editor);
-        }
-    },
-    {
-        type: ElementKinds.hr,
-        markup: '---',
-        insertTrigger: true
-    }
-];
-
-const UNDOING = new WeakMap();
-const REDOING = new WeakMap();
-const withTheHistory = (editor) => {
-    const { undo, redo } = editor;
-    editor.undo = () => {
-        UNDOING.set(editor, true);
-        undo();
-        UNDOING.set(editor, false);
-    };
-    editor.redo = () => {
-        REDOING.set(editor, true);
-        redo();
-        REDOING.set(editor, false);
-    };
-    return editor;
-};
-const TheHistoryEditor = {
-    isUndoing(editor) {
-        return UNDOING.get(editor);
-    },
-    isRedoing(editor) {
-        return REDOING.get(editor);
-    }
-};
-
-class TheConversionHintComponent {
-    constructor() {
-        this.duration = 10000;
-        this.pauseOnHover = true;
-    }
-    mouseenter() {
-        if (this.pauseOnHover) {
-            this.clearCloseTimer();
-        }
-    }
-    mouseleave() {
-        if (this.pauseOnHover) {
-            this.creatCloseTimer();
+    }
+    mouseleave() {
+        if (this.pauseOnHover) {
+            this.creatCloseTimer();
         }
     }
     ngOnInit() {
@@ -3053,6 +2658,10 @@ const hasStableListItem = (listItemNode) => {
     return listItemNode.children.length === 1 && type === ElementKinds.paragraph;
 };
 
+const isNodeTypeList = (n) => {
+    return [ElementKinds.bulletedList, ElementKinds.numberedList].includes(n.type);
+};
+
 /**
  * list 中 是否是单个listItem，且listItem没有子列表
  */
@@ -4251,79 +3860,476 @@ const autoFormatInline = (editor, { type, between, markup, ignoreTrim, format })
         if (!endMarkupPointBefore) {
             return false;
         }
-    }
-    const startMarkupPointAfter = getPointBefore(editor, endMarkupPointBefore, {
-        matchString: startMarkup,
-        skipInvalid: true,
-        afterMatch: true
-    });
-    if (!startMarkupPointAfter) {
-        return false;
-    }
-    // found
-    const markupRange = {
-        anchor: startMarkupPointAfter,
-        focus: endMarkupPointBefore
-    };
-    if (!ignoreTrim) {
-        const markupText = getText(editor, markupRange);
-        if (markupText.trim() !== markupText) {
-            return false;
+    }
+    const startMarkupPointAfter = getPointBefore(editor, endMarkupPointBefore, {
+        matchString: startMarkup,
+        skipInvalid: true,
+        afterMatch: true
+    });
+    if (!startMarkupPointAfter) {
+        return false;
+    }
+    // found
+    const markupRange = {
+        anchor: startMarkupPointAfter,
+        focus: endMarkupPointBefore
+    };
+    if (!ignoreTrim) {
+        const markupText = getText(editor, markupRange);
+        if (markupText.trim() !== markupText) {
+            return false;
+        }
+    }
+    // delete end markup
+    if (endMarkup) {
+        endMarkupPointBefore = getPointBefore(editor, selection, {
+            matchString: endMarkup
+        });
+        Transforms.delete(editor, {
+            at: {
+                anchor: endMarkupPointBefore,
+                focus: selection.anchor
+            }
+        });
+    }
+    const startMarkupPointBefore = getPointBefore(editor, selection, {
+        matchString: startMarkup,
+        skipInvalid: true
+    });
+    if (format) {
+        const markupText = getText(editor, markupRange);
+        format(editor, markupText);
+        // delete start to end selection
+        Transforms.delete(editor, {
+            at: {
+                anchor: startMarkupPointBefore,
+                focus: selection.anchor
+            }
+        });
+    }
+    else {
+        // add mark to the text between the markups
+        Transforms.select(editor, markupRange);
+        editor.addMark(type, true);
+        Transforms.collapse(editor, { edge: 'end' });
+        editor.removeMark(type, false);
+        // delete start markup
+        Transforms.delete(editor, {
+            at: {
+                anchor: startMarkupPointBefore,
+                focus: startMarkupPointAfter
+            }
+        });
+    }
+    return true;
+};
+
+const ListEditor = {
+    isList(editor, element, type) {
+        return Editor.isBlock(editor, element) && element.type === type;
+    },
+    toggleList(editor, type, startIndex) {
+        if (!editor.selection) {
+            return;
+        }
+        if (!startIndex) {
+            startIndex = 1;
+        }
+        const types = [ElementKinds.bulletedList, ElementKinds.numberedList];
+        Editor.withoutNormalizing(editor, () => {
+            const [...listItems] = Editor.nodes(editor, {
+                match: node => Element$1.isElement(node) && node.type === ElementKinds.listItem,
+                mode: 'lowest'
+            });
+            const firstListItemPath = listItems.length && listItems[0][1];
+            const activeListPath = listItems.length && Path.parent(firstListItemPath);
+            const activeListNode = listItems.length && Node.get(editor, activeListPath);
+            // 同级且类型相同：unwrap
+            const isLowestActive = listItems.length &&
+                listItems.every(([, path]) => activeListNode.type === type && (Path.isSibling(firstListItemPath, path) || Path.equals(firstListItemPath, path)));
+            if (isLowestActive) {
+                const upListItem = Path.parent(activeListPath);
+                Transforms.unwrapNodes(editor, {
+                    at: editor.selection,
+                    match: node => node === activeListNode,
+                    split: true,
+                    mode: 'lowest'
+                });
+                if (upListItem && Node.get(editor, upListItem).type === ElementKinds.listItem) {
+                    Transforms.moveNodes(editor, {
+                        at: editor.selection,
+                        to: Path.next(upListItem),
+                        match: node => Element$1.isElement(node) && node.type === ElementKinds.listItem
+                    });
+                }
+                else {
+                    Transforms.unwrapNodes(editor, {
+                        match: node => Element$1.isElement(node) && node.type === ElementKinds.listItem
+                    });
+                }
+                return;
+            }
+            // 跨级、同级且类型不同
+            if (activeListNode && types.includes(activeListNode.type)) {
+                Transforms.setNodes(editor, { type }, { match: node => Element$1.isElement(node) && node.type !== type && types.includes(node.type) });
+                return;
+            }
+            // wrap
+            this.buildListItem(editor);
+            // Todo: types
+            Transforms.wrapNodes(editor, { type, children: [], start: startIndex }, {
+                at: editor.selection,
+                match: node => Element$1.isElement(node) && node.type === ElementKinds.listItem
+            });
+        });
+    },
+    unwrapList(editor) {
+        Editor.withoutNormalizing(editor, () => {
+            unwrapNodesByType(editor, [ElementKinds.bulletedList, ElementKinds.numberedList], { split: true, mode: 'all' });
+            unwrapNodesByType(editor, [ElementKinds.listItem], { split: true, mode: 'all' });
+        });
+    },
+    wrapList(editor, type) {
+        Editor.withoutNormalizing(editor, () => {
+            const listItem = {
+                type: ElementKinds.listItem,
+                children: []
+            };
+            const list = {
+                type,
+                children: []
+            };
+            Transforms.wrapNodes(editor, list, { split: true });
+            Transforms.wrapNodes(editor, listItem, { split: true });
+        });
+    },
+    isActive(editor, type) {
+        const [match] = getNodesByType(editor, type);
+        return !!match;
+    },
+    getActiveList(editor) {
+        const [match] = getNodesByType(editor, LIST_BLOCK_TYPES);
+        return match;
+    },
+    buildListItem(editor) {
+        const nodes = Editor.nodes(editor, {
+            match: node => Editor.isBlock(editor, node),
+            mode: 'lowest'
+        });
+        for (const [node, path] of nodes) {
+            if (!Editor.isVoid(editor, node) && Element$1.isElement(node) && node.type !== ElementKinds.paragraph) {
+                Transforms.setNodes(editor, { type: ElementKinds.paragraph, checked: undefined }, // todo remove checked
+                { at: path });
+            }
+            else if (Element$1.isElement(node) && node.type === ElementKinds.paragraph) {
+                let { textIndent } = node;
+                if (textIndent) {
+                    Transforms.setNodes(editor, { textIndent: undefined, indent: undefined }, // remove indent
+                    { at: path });
+                }
+            }
+            if (Node.parent(editor, path).type !== ElementKinds.listItem) {
+                Transforms.wrapNodes(editor, { type: ElementKinds.listItem, children: [] }, {
+                    at: path,
+                    split: true
+                });
+            }
+        }
+    },
+    buildInsertDataChildren(node) {
+        const { children } = node;
+        const listItem = children[0];
+        if (isNodeTypeList(node) && Element$1.isElement(listItem) && listItem.children[0].type === ElementKinds.paragraph) {
+            return node;
+        }
+        return this.buildInsertDataChildren(listItem);
+    }
+};
+
+const TodoItemEditor = {
+    isActive(editor) {
+        const [match] = getNodesByType(editor, ElementKinds.checkItem);
+        return !!match;
+    },
+    insertTodoItem(editor) {
+        if (!editor.selection) {
+            return;
+        }
+        const isActive = this.isActive(editor);
+        const isNumberedList = ListEditor.isActive(editor, ElementKinds.numberedList);
+        const isBulletedList = ListEditor.isActive(editor, ElementKinds.bulletedList);
+        if (isActive) {
+            Transforms.setNodes(editor, {
+                type: ElementKinds.paragraph
+            });
+        }
+        else {
+            if (isNumberedList || isBulletedList) {
+                ListEditor.unwrapList(editor);
+            }
+            Transforms.setNodes(editor, {
+                type: ElementKinds.checkItem
+            });
+        }
+    }
+};
+
+const BlockquoteEditor = {
+    toggleBlockquote(editor) {
+        if (!isParagraph(editor)) {
+            Transforms.insertNodes(editor, {
+                type: ElementKinds.paragraph,
+                mode: 'text',
+                children: [
+                    {
+                        text: ''
+                    }
+                ]
+            });
+        }
+        const isActive = isBlockActive(editor, ElementKinds.blockquote);
+        if (!isActive) {
+            Transforms.wrapNodes(editor, { type: ElementKinds.blockquote, children: [] }, {
+                mode: 'lowest'
+            });
+        }
+        else {
+            Transforms.unwrapNodes(editor, { match: n => Element$1.isElement(n) && n.type === ElementKinds.blockquote });
+        }
+    }
+};
+
+const InlineCodeEditor = {
+    toggleInlineCode(editor, text) {
+        const isActive = InlineCodeEditor.isInlineCodeActive(editor);
+        if (isActive) {
+            InlineCodeEditor.unwrapInlineCode(editor);
+            return;
+        }
+        if (Range.isCollapsed(editor.selection)) {
+            InlineCodeEditor.wrapInlineCode(editor, text);
+        }
+        else {
+            const fragment = Node.fragment(editor, editor.selection)[0];
+            const selectNode = Node.get(fragment, []);
+            const selectText = Node.string(selectNode);
+            InlineCodeEditor.wrapInlineCode(editor, selectText);
+        }
+    },
+    wrapInlineCode(editor, text = '') {
+        if (InlineCodeEditor.isInlineCodeActive(editor)) {
+            InlineCodeEditor.unwrapInlineCode(editor);
+        }
+        const { selection } = editor;
+        const isCollapsed = selection && Range.isCollapsed(selection);
+        const inlineCode = {
+            type: ElementKinds.inlineCode,
+            children: isCollapsed ? [{ text: text ? text : ZERO_WIDTH_CHAR }] : []
+        };
+        if (isCollapsed) {
+            Transforms.insertNodes(editor, inlineCode);
         }
-    }
-    // delete end markup
-    if (endMarkup) {
-        endMarkupPointBefore = getPointBefore(editor, selection, {
-            matchString: endMarkup
-        });
-        Transforms.delete(editor, {
-            at: {
-                anchor: endMarkupPointBefore,
-                focus: selection.anchor
-            }
+        else {
+            Transforms.wrapNodes(editor, inlineCode, { split: true });
+        }
+    },
+    unwrapInlineCode(editor) {
+        Transforms.unwrapNodes(editor, { match: n => Element$1.isElement(n) && n.type === ElementKinds.inlineCode });
+    },
+    isInlineCodeActive(editor, path) {
+        var _a;
+        const [inlineCode] = Editor.nodes(editor, {
+            at: path ? path : (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.anchor.path,
+            match: n => Element$1.isElement(n) && n.type === ElementKinds.inlineCode
         });
+        return !!inlineCode;
     }
-    const startMarkupPointBefore = getPointBefore(editor, selection, {
-        matchString: startMarkup,
-        skipInvalid: true
-    });
-    if (format) {
-        const markupText = getText(editor, markupRange);
-        format(editor, markupText);
-        // delete start to end selection
-        Transforms.delete(editor, {
-            at: {
-                anchor: startMarkupPointBefore,
-                focus: selection.anchor
+};
+
+const HeadingEditor = {
+    setHeading(editor, heading) {
+        Editor.withoutNormalizing(editor, () => {
+            const types = [ElementKinds.bulletedList, ElementKinds.numberedList, ElementKinds.listItem];
+            Transforms.unwrapNodes(editor, {
+                at: editor.selection,
+                match: n => Element$1.isElement(n) && types.includes(n.type),
+                mode: 'all',
+                split: true
+            });
+            Transforms.setNodes(editor, { type: heading });
+            const entry = anchorBlockEntry(editor);
+            const unMarks = {
+                [MarkTypes.fontSize]: null
+            };
+            if (entry) {
+                setMarks(editor, unMarks, entry[1]);
+                return;
             }
+            setMarks(editor, unMarks, editor.selection);
         });
-    }
-    else {
-        // add mark to the text between the markups
-        Transforms.select(editor, markupRange);
-        editor.addMark(type, true);
-        Transforms.collapse(editor, { edge: 'end' });
-        editor.removeMark(type, false);
-        // delete start markup
-        Transforms.delete(editor, {
-            at: {
-                anchor: startMarkupPointBefore,
-                focus: startMarkupPointAfter
-            }
+    },
+    isHeadingActive(editor, heading) {
+        const [match] = Editor.nodes(editor, {
+            match: n => Element$1.isElement(n) && n.type === heading,
+            universal: true
         });
+        return !!match;
     }
-    return true;
 };
 
-const withAutoFormat = ({ rules }) => (editor) => {
+const defaultAutoFormatRules = [
+    {
+        type: ElementKinds.heading_1,
+        markup: '#',
+        format: (editor) => {
+            HeadingEditor.setHeading(editor, ElementKinds.heading_1);
+        }
+    },
+    {
+        type: ElementKinds.heading_2,
+        markup: '##',
+        format: (editor) => {
+            HeadingEditor.setHeading(editor, ElementKinds.heading_2);
+        }
+    },
+    {
+        type: ElementKinds.heading_3,
+        markup: '###',
+        format: (editor) => {
+            HeadingEditor.setHeading(editor, ElementKinds.heading_3);
+        }
+    },
+    {
+        type: ElementKinds.heading_4,
+        markup: '####',
+        format: (editor) => {
+            HeadingEditor.setHeading(editor, ElementKinds.heading_4);
+        }
+    },
+    {
+        type: ElementKinds.heading_5,
+        markup: '#####',
+        format: (editor) => {
+            HeadingEditor.setHeading(editor, ElementKinds.heading_5);
+        }
+    },
+    {
+        type: ElementKinds.heading_6,
+        markup: '######',
+        format: (editor) => {
+            HeadingEditor.setHeading(editor, ElementKinds.heading_6);
+        }
+    },
+    {
+        type: ElementKinds.blockquote,
+        markup: ['>'],
+        format: (editor) => {
+            BlockquoteEditor.toggleBlockquote(editor);
+        }
+    },
+    {
+        type: MarkTypes.bold,
+        between: ['**', '**'],
+        mode: 'inline',
+        insertTrigger: true
+    },
+    {
+        type: MarkTypes.bold,
+        between: ['__', '__'],
+        mode: 'inline',
+        insertTrigger: true
+    },
+    {
+        type: MarkTypes.italic,
+        between: ['*', '*'],
+        mode: 'inline',
+        insertTrigger: true
+    },
+    {
+        type: MarkTypes.italic,
+        between: ['_', '_'],
+        mode: 'inline',
+        insertTrigger: true
+    },
+    {
+        type: ElementKinds.inlineCode,
+        between: ['`', '`'],
+        mode: 'inline',
+        format: (editor, text) => {
+            InlineCodeEditor.toggleInlineCode(editor, text);
+            Transforms.select(editor, Editor.after(editor, editor.selection));
+        }
+    },
+    {
+        type: MarkTypes.strike,
+        between: ['~~', '~~'],
+        mode: 'inline',
+        insertTrigger: true
+    },
+    {
+        type: ElementKinds.code,
+        markup: '```',
+        insertTrigger: true
+    },
+    {
+        type: ElementKinds.listItem,
+        markup: [],
+        match: (editor) => {
+            return isParagraph(editor) ? ['*', '-', '+'] : [];
+        },
+        format: (editor) => {
+            ListEditor.toggleList(editor, ElementKinds.bulletedList);
+        }
+    },
+    {
+        type: ElementKinds.listItem,
+        key: ElementKinds.numberedList,
+        markup: [],
+        match: (editor, textFromBlockStart) => {
+            return isParagraph(editor) && /^-?\d+(\.|\))$/.test(textFromBlockStart) ? [textFromBlockStart] : [];
+        },
+        format: (editor, markup) => {
+            let startIndex = 1;
+            if (markup) {
+                startIndex = markup[0].split('.')[0];
+                if (startIndex === 0) {
+                    startIndex = 1;
+                }
+            }
+            ListEditor.toggleList(editor, ElementKinds.numberedList, startIndex);
+        }
+    },
+    {
+        type: ElementKinds.checkItem,
+        markup: [],
+        match: (editor) => {
+            return isParagraph(editor) ? ['[]'] : [];
+        },
+        format: (editor) => {
+            TodoItemEditor.insertTodoItem(editor);
+        }
+    },
+    {
+        type: ElementKinds.hr,
+        markup: '---',
+        insertTrigger: true
+    }
+];
+
+const withAutoFormat = () => (editor) => {
     const { insertText } = editor;
     editor.insertText = text => {
-        var _a;
+        var _a, _b;
+        let autoFormatRules = defaultAutoFormatRules;
+        if ((_a = editor.extraAutoFormatRules) === null || _a === void 0 ? void 0 : _a.length) {
+            const extraRules = mergAutoFormateRules(editor.extraAutoFormatRules);
+            autoFormatRules = Object.values(extraRules);
+        }
         if (!isCollapsed(editor.selection)) {
             return insertText(text);
         }
-        for (let _b of rules) {
-            const { query } = _b, rule = __rest(_b, ["query"]);
+        for (let _c of autoFormatRules) {
+            const { query } = _c, rule = __rest(_c, ["query"]);
             const { trigger = ' ', mode = 'block', type, markup, preFormat, format, match, between, ignoreTrim, insertTrigger, allowSameTypeAbove = false, triggerAtBlockStart = true } = rule;
             if (query && !query(editor, rule))
                 continue;
@@ -4358,7 +4364,7 @@ const withAutoFormat = ({ rules }) => (editor) => {
                     });
                     if (!markupRange)
                         continue;
-                    const blockAbovePath = (_a = getBlockAbove(editor)) === null || _a === void 0 ? void 0 : _a[1];
+                    const blockAbovePath = (_b = getBlockAbove(editor)) === null || _b === void 0 ? void 0 : _b[1];
                     if (!blockAbovePath)
                         continue;
                     // If the markup is not at the start, insert break before autoformatting.
@@ -4395,6 +4401,17 @@ const withAutoFormat = ({ rules }) => (editor) => {
     };
     return editor;
 };
+const mergAutoFormateRules = (extraAutoFormatRules) => {
+    const combinationData = [...defaultAutoFormatRules, ...extraAutoFormatRules];
+    const dataInfo = {};
+    combinationData.forEach(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;
+};
 
 const withTransforms = () => (editor) => {
     const e = editor;
@@ -11891,7 +11908,7 @@ const internalPlugins = [
     }),
     withBlockquote,
     withNodeID({ idKey: ELEMENT_UNIQUE_ID, idCreator }),
-    withAutoFormat({ rules: autoFormatRules }),
+    withAutoFormat(),
     withTransforms(),
     withTrailingNode({ type: ElementKinds.paragraph, level: 0 }),
     withMoveSelection,
@@ -12756,11 +12773,12 @@ class TheEditorComponent extends mixinUnsubscribe(MixinBase) {
         super.ngOnDestroy();
     }
     initialize() {
-        var _a, _b;
+        var _a, _b, _c;
         this.editor = withTheEditor(this.thePlugins, withHistory(withAngular(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,