@ant-design/agentic-ui 2.8.0 → 2.9.0

package/dist/MarkdownEditor/editor/plugins/hotKeyCommands/enter.js

@@ -1,431 +1,589 @@
-// src/MarkdownEditor/editor/plugins/hotKeyCommands/enter.ts
-import {
-  Editor,
-  Element,
-  Node,
-  Path,
-  Point,
-  Range,
-  Transforms
-} from "slate";
-import { isMod } from "../../utils";
-import { EditorUtils } from "../../utils/editorUtils";
-import { BlockMathNodes } from "../elements";
-var EnterKey = class {
-  constructor(store, backspace) {
-    this.store = store;
-    this.backspace = backspace;
-    this.bracketsMap = /* @__PURE__ */ new Map([
-      ["[", "]"],
-      ["{", "}"]
-    ]);
-  }
-  get editor() {
-    var _a;
-    return (_a = this.store) == null ? void 0 : _a.editor;
-  }
-  run(e) {
-    var _a;
-    let sel = this.editor.selection;
-    if (!sel || this.store.inputComposition)
-      return;
-    if (!Range.isCollapsed(sel)) {
-      e.preventDefault();
-      this.backspace.range();
-      return;
+/* eslint-disable no-case-declarations */ function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
     }
-    const [node] = Editor.nodes(this.editor, {
-      match: (n) => Element.isElement(n),
-      mode: "lowest"
-    });
-    if (node) {
-      let [el, path] = node;
-      if (el.type === "card-before") {
-        Transforms.insertNodes(this.editor, EditorUtils.p, {
-          at: Path.parent(path),
-          select: true
-        });
-        e.preventDefault();
-        return;
-      }
-      if (el.type === "card-after") {
-        Transforms.insertNodes(this.editor, EditorUtils.p, {
-          at: Path.next(Path.parent(path)),
-          select: true
-        });
-        e.preventDefault();
-        return;
-      }
-      if (el.type === "head") {
-        if (this.head(el, path, sel)) {
-          e.preventDefault();
-          return;
-        }
-      }
-      if (el.type === "paragraph") {
-        if (this.paragraph(e, node, sel)) {
-          e.preventDefault();
-          return;
-        }
-      }
-      if (el.type === "table-cell") {
-        const table = Editor.parent(this.editor, path);
-        if (table[0].type === "table-row") {
-          this.table(table, sel, e);
-          e.preventDefault();
-          return;
-        }
-      }
-      if (el.type === "blockquote" || el.type === "list-item") {
-        this.empty(e, path);
-        return;
-      }
-      if (el.type === "break") {
-        Transforms.insertNodes(this.editor, {
-          type: "paragraph",
-          children: [{ text: "" }]
-        });
-        e.preventDefault();
-      }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
     }
-    (_a = this.editor) == null ? void 0 : _a.insertBreak();
-  }
-  empty(e, path) {
-    const [parent, parentPath] = Editor.parent(this.editor, path);
-    if (parent.type === "blockquote") {
-      if (!Path.hasPrevious(path)) {
-        const hashNext = Editor.hasPath(this.editor, Path.next(path));
-        if (!hashNext) {
-          Transforms.delete(this.editor, {
-            at: parentPath
-          });
-          Transforms.insertNodes(
-            this.editor,
-            {
-              type: "paragraph",
-              children: [{ text: "" }]
-            },
-            { at: parentPath, select: true }
-          );
-          e.preventDefault();
-        }
-      }
-      if (!Editor.hasPath(this.editor, Path.next(path))) {
-        Transforms.delete(this.editor, {
-          at: path
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
         });
-        Transforms.insertNodes(
-          this.editor,
-          {
-            type: "paragraph",
-            children: [{ text: "" }]
-          },
-          { at: Path.next(parentPath), select: true }
-        );
-        e.preventDefault();
-      }
+    } else {
+        obj[key] = value;
     }
-    if (parent.type === "list-item") {
-      const [ul, ulPath] = Editor.parent(this.editor, parentPath);
-      const realEmpty = parent.children.length === 1;
-      if (ul.children.length === 1 && realEmpty) {
-        e.preventDefault();
-        Transforms.delete(this.editor, { at: ulPath });
-        Transforms.insertNodes(this.editor, EditorUtils.p, {
-          at: ulPath,
-          select: true
-        });
-        return;
-      }
-      if (realEmpty) {
-        e.preventDefault();
-        if (!Path.hasPrevious(parentPath)) {
-          Transforms.delete(this.editor, { at: parentPath });
-          Transforms.insertNodes(this.editor, EditorUtils.p, {
-            at: ulPath,
-            select: true
-          });
-        } else if (!Editor.hasPath(this.editor, Path.next(parentPath))) {
-          Transforms.delete(this.editor, { at: parentPath });
-          Transforms.insertNodes(this.editor, EditorUtils.p, {
-            at: Path.next(ulPath),
-            select: true
-          });
-        } else {
-          Transforms.liftNodes(this.editor, {
-            at: parentPath
-          });
-          Transforms.delete(this.editor, { at: Path.next(ulPath) });
-          Transforms.insertNodes(this.editor, EditorUtils.p, {
-            at: Path.next(ulPath),
-            select: true
-          });
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
         }
-      } else {
-        if (!Editor.hasPath(this.editor, Path.next(path))) {
-          e.preventDefault();
-          Transforms.delete(this.editor, { at: path });
-          Transforms.insertNodes(
-            this.editor,
-            {
-              type: "list-item",
-              checked: typeof parent.checked === "boolean" ? false : void 0,
-              children: [EditorUtils.p]
-            },
-            { at: Path.next(parentPath), select: true }
-          );
-        } else if (!Path.hasPrevious(path)) {
-          e.preventDefault();
-          Transforms.insertNodes(
-            this.editor,
-            {
-              type: "list-item",
-              checked: typeof parent.checked === "boolean" ? false : void 0,
-              children: [EditorUtils.p]
-            },
-            { at: Path.next(parentPath), select: true }
-          );
-          let cur = Path.next(path);
-          let index = 1;
-          EditorUtils.moveNodes(this.editor, cur, Path.next(parentPath), index);
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
         }
-      }
     }
-  }
-  table(node, sel, e) {
-    if (isMod(e)) {
-      if (e.shiftKey) {
-        Transforms.insertNodes(
-          this.editor,
-          [{ type: "break", children: [{ text: "" }] }, { text: "" }],
-          { select: true }
-        );
-        e.preventDefault();
-      } else {
-        const row = Editor.parent(this.editor, node[1]);
-        const insertRow = {
-          type: "table-row",
-          children: row[0].children.map(() => {
-            return {
-              type: "table-cell",
-              children: [
-                {
-                  type: "paragraph",
-                  children: [{ text: "" }]
-                }
-              ]
-            };
-          })
-        };
-        Transforms.insertNodes(this.editor, insertRow, {
-          at: Path.next(row[1])
-        });
-        Transforms.select(
-          this.editor,
-          Editor.start(this.editor, Path.next(row[1]))
-        );
-      }
-    } else {
-      const index = node[1][node[1].length - 1];
-      const nextRow = Path.next(Path.parent(node[1]));
-      if (Editor.hasPath(this.editor, nextRow)) {
-        Transforms.select(
-          this.editor,
-          Editor.end(this.editor, [...nextRow, index])
-        );
-      } else {
-        const tableNext = Path.next(Path.parent(Path.parent(node[1])));
-        if (Editor.hasPath(this.editor, tableNext)) {
-          Transforms.select(this.editor, Editor.start(this.editor, tableNext));
-        } else {
-          Transforms.insertNodes(this.editor, EditorUtils.p, {
-            at: tableNext,
-            select: true
-          });
-        }
-      }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import React from "react";
+import { Editor, Element, Node, Path, Point, Range, Transforms } from "slate";
+import { isMod } from "../../utils";
+import { EditorUtils } from "../../utils/editorUtils";
+import { BlockMathNodes } from "../elements";
+export var EnterKey = /*#__PURE__*/ function() {
+    "use strict";
+    function EnterKey(store, backspace) {
+        _class_call_check(this, EnterKey);
+        _define_property(this, "store", void 0);
+        _define_property(this, "backspace", void 0);
+        _define_property(this, "bracketsMap", void 0);
+        this.store = store;
+        this.backspace = backspace;
+        this.bracketsMap = new Map([
+            [
+                '[',
+                ']'
+            ],
+            [
+                '{',
+                '}'
+            ]
+        ]);
     }
-  }
-  head(el, path, sel) {
-    var _a;
-    const start = Range.start(sel);
-    const elStart = Editor.start(this.editor, path);
-    if (Point.equals(start, elStart)) {
-      Transforms.insertNodes(
-        this.editor,
+    _create_class(EnterKey, [
         {
-          type: "paragraph",
-          children: [{ text: "" }]
+            key: "editor",
+            get: function get() {
+                var _this_store;
+                return (_this_store = this.store) === null || _this_store === void 0 ? void 0 : _this_store.editor;
+            }
         },
-        { at: path }
-      );
-    } else {
-      const end = Range.end(sel);
-      const elEnd = Editor.end(this.editor, path);
-      if (Point.equals(end, elEnd)) {
-        Transforms.insertNodes(
-          this.editor,
-          {
-            type: "paragraph",
-            children: [{ text: "" }]
-          },
-          { at: Path.next(path), select: true }
-        );
-      } else {
-        const fragment = Node.fragment(this.editor, {
-          anchor: end,
-          focus: elEnd
-        });
-        Transforms.delete(this.editor, {
-          at: {
-            anchor: start,
-            focus: elEnd
-          }
-        });
-        Transforms.insertNodes(
-          this.editor,
-          {
-            type: "paragraph",
-            children: ((_a = fragment[0]) == null ? void 0 : _a.children) || [{ text: "" }]
-          },
-          { at: Path.next(path) }
-        );
-        Transforms.select(
-          this.editor,
-          Editor.start(this.editor, Path.next(path))
-        );
-      }
-    }
-    return true;
-  }
-  paragraph(e, node, sel) {
-    const parent = Editor.parent(this.editor, node[1]);
-    const end = Editor.end(this.editor, node[1]);
-    if (Point.equals(end, sel.focus)) {
-      if (parent[0].type !== "list-item" || Path.hasPrevious(node[1])) {
-        const str = Node.string(node[0]);
-        if (!str)
-          return;
-        for (let n of BlockMathNodes) {
-          if (n.checkAllow && !n.checkAllow({ editor: this.editor, node, sel }))
-            continue;
-          const m = str == null ? void 0 : str.match(n.reg);
-          if (m) {
-            n.run({
-              editor: this.editor,
-              path: node[1],
-              match: m,
-              el: node[0],
-              sel,
-              startText: m[0]
-            });
-            e.preventDefault();
-            return true;
-          }
-        }
-      }
-    }
-    if (parent[0].type === "list-item") {
-      if (isMod(e) || Path.hasPrevious(node[1])) {
-        const text = Point.equals(end, sel.focus) ? [{ text: "" }] : EditorUtils.cutText(this.editor, sel.focus);
-        Transforms.insertNodes(
-          this.editor,
-          {
-            type: "paragraph",
-            children: text || " "
-          },
-          { at: Path.next(node[1]) }
-        );
-        if (!Point.equals(end, sel.focus)) {
-          Transforms.delete(this.editor, {
-            at: {
-              anchor: sel.focus,
-              focus: end
+        {
+            key: "run",
+            value: function run(e) {
+                var _this_editor;
+                var sel = this.editor.selection;
+                if (!sel || this.store.inputComposition) return;
+                if (!Range.isCollapsed(sel)) {
+                    e.preventDefault();
+                    this.backspace.range();
+                    return;
+                }
+                var _Editor_nodes = _sliced_to_array(Editor.nodes(this.editor, {
+                    match: function(n) {
+                        return Element.isElement(n);
+                    },
+                    mode: 'lowest'
+                }), 1), node = _Editor_nodes[0];
+                if (node) {
+                    var _node = _sliced_to_array(node, 2), el = _node[0], path = _node[1];
+                    if (el.type === 'card-before') {
+                        Transforms.insertNodes(this.editor, EditorUtils.p, {
+                            at: Path.parent(path),
+                            select: true
+                        });
+                        e.preventDefault();
+                        return;
+                    }
+                    if (el.type === 'card-after') {
+                        Transforms.insertNodes(this.editor, EditorUtils.p, {
+                            at: Path.next(Path.parent(path)),
+                            select: true
+                        });
+                        e.preventDefault();
+                        return;
+                    }
+                    if (el.type === 'head') {
+                        if (this.head(el, path, sel)) {
+                            e.preventDefault();
+                            return;
+                        }
+                    }
+                    if (el.type === 'paragraph') {
+                        if (this.paragraph(e, node, sel)) {
+                            e.preventDefault();
+                            return;
+                        }
+                    }
+                    if (el.type === 'table-cell') {
+                        var table = Editor.parent(this.editor, path);
+                        if (table[0].type === 'table-row') {
+                            this.table(table, sel, e);
+                            e.preventDefault();
+                            return;
+                        }
+                    }
+                    if (el.type === 'blockquote' || el.type === 'list-item') {
+                        this.empty(e, path);
+                        return;
+                    }
+                    if (el.type === 'break') {
+                        Transforms.insertNodes(this.editor, {
+                            type: 'paragraph',
+                            children: [
+                                {
+                                    text: ''
+                                }
+                            ]
+                        });
+                        e.preventDefault();
+                    }
+                }
+                (_this_editor = this.editor) === null || _this_editor === void 0 ? void 0 : _this_editor.insertBreak();
             }
-          });
-        }
-        if (Editor.hasPath(this.editor, Path.next(node[1]))) {
-          Transforms.select(
-            this.editor,
-            Editor.start(this.editor, Path.next(node[1]))
-          );
-        } else {
-          Transforms.select(
-            this.editor,
-            Editor.start(this.editor, Path.next(node[1]))
-          );
-        }
-        e.preventDefault();
-        return true;
-      } else {
-        e.preventDefault();
-        let checked = void 0;
-        if (typeof parent[0].checked === "boolean") {
-          if (sel.anchor.offset === 0 && !Path.hasPrevious(sel.anchor.path) && !Path.hasPrevious(node[1])) {
-            checked = parent[0].checked;
-            Transforms.insertNodes(
-              this.editor,
-              {
-                type: "list-item",
-                children: [EditorUtils.p],
-                checked: typeof checked === "boolean" ? false : void 0
-              },
-              { at: parent[1] }
-            );
-            Transforms.select(
-              this.editor,
-              Editor.start(this.editor, Path.next(parent[1]))
-            );
-            return;
-          } else {
-            checked = false;
-          }
-        }
-        const text = Point.equals(Editor.end(this.editor, node[1]), sel.focus) ? [{ text: "" }] : EditorUtils.cutText(this.editor, sel.focus);
-        Transforms.insertNodes(
-          this.editor,
-          {
-            type: "list-item",
-            children: [
-              {
-                type: "paragraph",
-                children: text || [{ text: "" }]
-              }
-            ],
-            checked
-          },
-          { at: Path.next(parent[1]) }
-        );
-        if (!Point.equals(sel.anchor, Editor.end(this.editor, node[1]))) {
-          Transforms.delete(this.editor, {
-            at: {
-              anchor: sel.anchor,
-              focus: Editor.end(this.editor, node[1])
+        },
+        {
+            key: "empty",
+            value: function empty(e, path) {
+                var _Editor_parent = _sliced_to_array(Editor.parent(this.editor, path), 2), parent = _Editor_parent[0], parentPath = _Editor_parent[1];
+                if (parent.type === 'blockquote') {
+                    if (!Path.hasPrevious(path)) {
+                        var hashNext = Editor.hasPath(this.editor, Path.next(path));
+                        if (!hashNext) {
+                            Transforms.delete(this.editor, {
+                                at: parentPath
+                            });
+                            Transforms.insertNodes(this.editor, {
+                                type: 'paragraph',
+                                children: [
+                                    {
+                                        text: ''
+                                    }
+                                ]
+                            }, {
+                                at: parentPath,
+                                select: true
+                            });
+                            e.preventDefault();
+                        }
+                    }
+                    if (!Editor.hasPath(this.editor, Path.next(path))) {
+                        Transforms.delete(this.editor, {
+                            at: path
+                        });
+                        Transforms.insertNodes(this.editor, {
+                            type: 'paragraph',
+                            children: [
+                                {
+                                    text: ''
+                                }
+                            ]
+                        }, {
+                            at: Path.next(parentPath),
+                            select: true
+                        });
+                        e.preventDefault();
+                    }
+                }
+                if (parent.type === 'list-item') {
+                    var _Editor_parent1 = _sliced_to_array(Editor.parent(this.editor, parentPath), 2), ul = _Editor_parent1[0], ulPath = _Editor_parent1[1];
+                    var realEmpty = parent.children.length === 1;
+                    if (ul.children.length === 1 && realEmpty) {
+                        e.preventDefault();
+                        Transforms.delete(this.editor, {
+                            at: ulPath
+                        });
+                        Transforms.insertNodes(this.editor, EditorUtils.p, {
+                            at: ulPath,
+                            select: true
+                        });
+                        return;
+                    }
+                    if (realEmpty) {
+                        e.preventDefault();
+                        if (!Path.hasPrevious(parentPath)) {
+                            Transforms.delete(this.editor, {
+                                at: parentPath
+                            });
+                            Transforms.insertNodes(this.editor, EditorUtils.p, {
+                                at: ulPath,
+                                select: true
+                            });
+                        } else if (!Editor.hasPath(this.editor, Path.next(parentPath))) {
+                            Transforms.delete(this.editor, {
+                                at: parentPath
+                            });
+                            Transforms.insertNodes(this.editor, EditorUtils.p, {
+                                at: Path.next(ulPath),
+                                select: true
+                            });
+                        } else {
+                            Transforms.liftNodes(this.editor, {
+                                at: parentPath
+                            });
+                            Transforms.delete(this.editor, {
+                                at: Path.next(ulPath)
+                            });
+                            Transforms.insertNodes(this.editor, EditorUtils.p, {
+                                at: Path.next(ulPath),
+                                select: true
+                            });
+                        }
+                    } else {
+                        if (!Editor.hasPath(this.editor, Path.next(path))) {
+                            e.preventDefault();
+                            Transforms.delete(this.editor, {
+                                at: path
+                            });
+                            Transforms.insertNodes(this.editor, {
+                                type: 'list-item',
+                                checked: typeof parent.checked === 'boolean' ? false : undefined,
+                                children: [
+                                    EditorUtils.p
+                                ]
+                            }, {
+                                at: Path.next(parentPath),
+                                select: true
+                            });
+                        } else if (!Path.hasPrevious(path)) {
+                            e.preventDefault();
+                            Transforms.insertNodes(this.editor, {
+                                type: 'list-item',
+                                checked: typeof parent.checked === 'boolean' ? false : undefined,
+                                children: [
+                                    EditorUtils.p
+                                ]
+                            }, {
+                                at: Path.next(parentPath),
+                                select: true
+                            });
+                            var cur = Path.next(path);
+                            var index = 1;
+                            EditorUtils.moveNodes(this.editor, cur, Path.next(parentPath), index);
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "table",
+            value: function table(node, sel, e) {
+                if (isMod(e)) {
+                    if (e.shiftKey) {
+                        Transforms.insertNodes(this.editor, [
+                            {
+                                type: 'break',
+                                children: [
+                                    {
+                                        text: ''
+                                    }
+                                ]
+                            },
+                            {
+                                text: ''
+                            }
+                        ], {
+                            select: true
+                        });
+                        e.preventDefault();
+                    } else {
+                        var row = Editor.parent(this.editor, node[1]);
+                        var insertRow = {
+                            type: 'table-row',
+                            children: row[0].children.map(function() {
+                                return {
+                                    type: 'table-cell',
+                                    children: [
+                                        {
+                                            type: 'paragraph',
+                                            children: [
+                                                {
+                                                    text: ''
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                };
+                            })
+                        };
+                        Transforms.insertNodes(this.editor, insertRow, {
+                            at: Path.next(row[1])
+                        });
+                        Transforms.select(this.editor, Editor.start(this.editor, Path.next(row[1])));
+                    }
+                } else {
+                    var index = node[1][node[1].length - 1];
+                    var nextRow = Path.next(Path.parent(node[1]));
+                    if (Editor.hasPath(this.editor, nextRow)) {
+                        Transforms.select(this.editor, Editor.end(this.editor, _to_consumable_array(nextRow).concat([
+                            index
+                        ])));
+                    } else {
+                        var tableNext = Path.next(Path.parent(Path.parent(node[1])));
+                        if (Editor.hasPath(this.editor, tableNext)) {
+                            Transforms.select(this.editor, Editor.start(this.editor, tableNext));
+                        } else {
+                            Transforms.insertNodes(this.editor, EditorUtils.p, {
+                                at: tableNext,
+                                select: true
+                            });
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "head",
+            value: function head(el, path, sel) {
+                var start = Range.start(sel);
+                var elStart = Editor.start(this.editor, path);
+                if (Point.equals(start, elStart)) {
+                    Transforms.insertNodes(this.editor, {
+                        type: 'paragraph',
+                        children: [
+                            {
+                                text: ''
+                            }
+                        ]
+                    }, {
+                        at: path
+                    });
+                } else {
+                    var end = Range.end(sel);
+                    var elEnd = Editor.end(this.editor, path);
+                    if (Point.equals(end, elEnd)) {
+                        Transforms.insertNodes(this.editor, {
+                            type: 'paragraph',
+                            children: [
+                                {
+                                    text: ''
+                                }
+                            ]
+                        }, {
+                            at: Path.next(path),
+                            select: true
+                        });
+                    } else {
+                        var _fragment_;
+                        var fragment = Node.fragment(this.editor, {
+                            anchor: end,
+                            focus: elEnd
+                        });
+                        Transforms.delete(this.editor, {
+                            at: {
+                                anchor: start,
+                                focus: elEnd
+                            }
+                        });
+                        Transforms.insertNodes(this.editor, {
+                            type: 'paragraph',
+                            children: ((_fragment_ = fragment[0]) === null || _fragment_ === void 0 ? void 0 : _fragment_.children) || [
+                                {
+                                    text: ''
+                                }
+                            ]
+                        }, {
+                            at: Path.next(path)
+                        });
+                        Transforms.select(this.editor, Editor.start(this.editor, Path.next(path)));
+                    }
+                }
+                return true;
+            }
+        },
+        {
+            key: "paragraph",
+            value: function paragraph(e, node, sel) {
+                var parent = Editor.parent(this.editor, node[1]);
+                var end = Editor.end(this.editor, node[1]);
+                if (Point.equals(end, sel.focus)) {
+                    if (parent[0].type !== 'list-item' || Path.hasPrevious(node[1])) {
+                        var str = Node.string(node[0]);
+                        if (!str) return;
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = BlockMathNodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var n = _step.value;
+                                if (n.checkAllow && !n.checkAllow({
+                                    editor: this.editor,
+                                    node: node,
+                                    sel: sel
+                                })) continue;
+                                var m = str === null || str === void 0 ? void 0 : str.match(n.reg);
+                                if (m) {
+                                    n.run({
+                                        editor: this.editor,
+                                        path: node[1],
+                                        match: m,
+                                        el: node[0],
+                                        sel: sel,
+                                        startText: m[0]
+                                    });
+                                    e.preventDefault();
+                                    return true;
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (parent[0].type === 'list-item') {
+                    if (isMod(e) || Path.hasPrevious(node[1])) {
+                        var text = Point.equals(end, sel.focus) ? [
+                            {
+                                text: ''
+                            }
+                        ] : EditorUtils.cutText(this.editor, sel.focus);
+                        Transforms.insertNodes(this.editor, {
+                            type: 'paragraph',
+                            children: text || ' '
+                        }, {
+                            at: Path.next(node[1])
+                        });
+                        if (!Point.equals(end, sel.focus)) {
+                            Transforms.delete(this.editor, {
+                                at: {
+                                    anchor: sel.focus,
+                                    focus: end
+                                }
+                            });
+                        }
+                        if (Editor.hasPath(this.editor, Path.next(node[1]))) {
+                            Transforms.select(this.editor, Editor.start(this.editor, Path.next(node[1])));
+                        } else {
+                            Transforms.select(this.editor, Editor.start(this.editor, Path.next(node[1])));
+                        }
+                        e.preventDefault();
+                        return true;
+                    } else {
+                        e.preventDefault();
+                        var checked = undefined;
+                        if (typeof parent[0].checked === 'boolean') {
+                            if (sel.anchor.offset === 0 && !Path.hasPrevious(sel.anchor.path) && !Path.hasPrevious(node[1])) {
+                                checked = parent[0].checked;
+                                Transforms.insertNodes(this.editor, {
+                                    type: 'list-item',
+                                    children: [
+                                        EditorUtils.p
+                                    ],
+                                    checked: typeof checked === 'boolean' ? false : undefined
+                                }, {
+                                    at: parent[1]
+                                });
+                                Transforms.select(this.editor, Editor.start(this.editor, Path.next(parent[1])));
+                                return;
+                            } else {
+                                checked = false;
+                            }
+                        }
+                        var text1 = Point.equals(Editor.end(this.editor, node[1]), sel.focus) ? [
+                            {
+                                text: ''
+                            }
+                        ] : EditorUtils.cutText(this.editor, sel.focus);
+                        Transforms.insertNodes(this.editor, {
+                            type: 'list-item',
+                            children: [
+                                {
+                                    type: 'paragraph',
+                                    children: text1 || [
+                                        {
+                                            text: ''
+                                        }
+                                    ]
+                                }
+                            ],
+                            checked: checked
+                        }, {
+                            at: Path.next(parent[1])
+                        });
+                        if (!Point.equals(sel.anchor, Editor.end(this.editor, node[1]))) {
+                            Transforms.delete(this.editor, {
+                                at: {
+                                    anchor: sel.anchor,
+                                    focus: Editor.end(this.editor, node[1])
+                                }
+                            });
+                        }
+                        if (Point.equals(sel.anchor, Editor.start(this.editor, node[1])) && Node.string(Node.get(this.editor, node[1])) !== '') {
+                            EditorUtils.clearMarks(this.editor);
+                        }
+                        if (Editor.start(this.editor, Path.next(parent[1]))) {
+                            Transforms.select(this.editor, Editor.start(this.editor, Path.next(parent[1])));
+                        }
+                        if (Editor.hasPath(this.editor, Path.next(node[1]))) {
+                            EditorUtils.moveNodes(this.editor, Path.next(node[1]), Path.next(parent[1]), 1);
+                        }
+                        return true;
+                    }
+                }
             }
-          });
-        }
-        if (Point.equals(sel.anchor, Editor.start(this.editor, node[1])) && Node.string(Node.get(this.editor, node[1])) !== "") {
-          EditorUtils.clearMarks(this.editor);
-        }
-        if (Editor.start(this.editor, Path.next(parent[1]))) {
-          Transforms.select(
-            this.editor,
-            Editor.start(this.editor, Path.next(parent[1]))
-          );
-        }
-        if (Editor.hasPath(this.editor, Path.next(node[1]))) {
-          EditorUtils.moveNodes(
-            this.editor,
-            Path.next(node[1]),
-            Path.next(parent[1]),
-            1
-          );
         }
-        return true;
-      }
-    }
-  }
-};
-export {
-  EnterKey
-};
+    ]);
+    return EnterKey;
+}();