@ant-design/agentic-ui 2.0.0

package/dist/MarkdownEditor/editor/plugins/handlePaste.js

@@ -0,0 +1,332 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var __forAwait = (obj, it, method) => {
+  it = obj[Symbol.asyncIterator];
+  method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((resolve, reject, done) => {
+    arg = fn.call(obj, arg);
+    done = arg.done;
+    return Promise.resolve(arg.value).then((value) => resolve({ value, done }), reject);
+  }));
+  return it ? it.call(obj) : (obj = obj[Symbol.iterator](), it = {}, method("next"), method("return"), it);
+};
+
+// src/MarkdownEditor/editor/plugins/handlePaste.ts
+import { message } from "antd";
+import { Editor, Node, Path, Transforms } from "slate";
+import { isMarkdown } from "../utils";
+import { getMediaType } from "../utils/dom";
+import { EditorUtils } from "../utils/editorUtils";
+import { isHtml } from "../utils/htmlToMarkdown";
+import { toUnixPath } from "../utils/path";
+import { insertParsedHtmlNodes } from "./insertParsedHtmlNodes";
+import { parseMarkdownToNodesAndInsert } from "./parseMarkdownToNodesAndInsert";
+var handleSlateMarkdownFragment = (editor, clipboardData, currentTextSelection) => {
+  try {
+    const encoded = clipboardData.getData("application/x-slate-md-fragment");
+    const fragment = JSON.parse(encoded || "[]").map((node) => {
+      if (node.type === "card") {
+        return __spreadProps(__spreadValues({}, node), {
+          children: [
+            {
+              type: "card-before",
+              children: [{ text: "" }]
+            },
+            ...node.children,
+            {
+              type: "card-after",
+              children: [{ text: "" }]
+            }
+          ]
+        });
+      }
+      return node;
+    });
+    if (fragment.length === 1 && (fragment == null ? void 0 : fragment.at(0).type) === "paragraph" && currentTextSelection) {
+      const text = Node.string(fragment.at(0));
+      if (text) {
+        Transforms.insertText(editor, text, {
+          at: currentTextSelection.focus
+        });
+        return true;
+      }
+      return true;
+    }
+    if (fragment.length === 0)
+      return true;
+    EditorUtils.replaceSelectedNode(editor, fragment);
+    return true;
+  } catch (error) {
+    console.log("error", error);
+    return false;
+  }
+};
+var handleHtmlPaste = (editor, clipboardData, editorProps) => __async(void 0, null, function* () {
+  try {
+    const html = yield clipboardData.getData("text/html");
+    const rtf = yield clipboardData.getData("text/rtf");
+    if (html) {
+      return yield insertParsedHtmlNodes(editor, html, editorProps, rtf);
+    }
+    return false;
+  } catch (error) {
+    console.log("error", error);
+    return false;
+  }
+});
+var handleFilesPaste = (editor, clipboardData, editorProps) => __async(void 0, null, function* () {
+  var _a, _b, _c, _d;
+  try {
+    const fileList = clipboardData.files;
+    if (fileList.length > 0 && ((_a = editorProps.image) == null ? void 0 : _a.upload)) {
+      const hideLoading = message.loading("上传中...");
+      try {
+        const url = [];
+        try {
+          for (var iter = __forAwait(fileList), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
+            const file = temp.value;
+            if ((_b = editorProps.image) == null ? void 0 : _b.upload) {
+              const serverUrl = yield editorProps.image.upload([file]);
+              url.push(serverUrl);
+            }
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield temp.call(iter));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+        const selection = (_d = (_c = editor == null ? void 0 : editor.selection) == null ? void 0 : _c.focus) == null ? void 0 : _d.path;
+        const node = selection ? Node.get(editor, Path.parent(selection)) : null;
+        const at = selection ? EditorUtils.findNext(editor, selection) : void 0;
+        [url].flat(2).forEach((u) => {
+          if (!u)
+            return null;
+          Transforms.insertNodes(
+            editor,
+            EditorUtils.createMediaNode(u, "image"),
+            {
+              at: [
+                ...node && node.type === "table-cell" ? selection : at ? at : [editor.children.length - 1]
+              ]
+            }
+          );
+        });
+        message.success("上传成功");
+        hideLoading();
+        return true;
+      } catch (error2) {
+        console.log("error", error2);
+        hideLoading();
+        return false;
+      }
+    }
+    return false;
+  } catch (error2) {
+    console.log("error", error2);
+    return false;
+  }
+});
+var handleSpecialTextPaste = (editor, text, selection) => {
+  if (text.startsWith("media://") || text.startsWith("attach://")) {
+    const path = EditorUtils.findMediaInsertPath(editor);
+    const urlObject = new URL(text);
+    let url = urlObject.searchParams.get("url");
+    if (url && !url.startsWith("http") && !url.startsWith("blob:http")) {
+      url = toUnixPath(url);
+    }
+    if (path && url) {
+      if (text.startsWith("media://")) {
+        Transforms.insertNodes(
+          editor,
+          EditorUtils.createMediaNode(url, "image"),
+          { select: true, at: path }
+        );
+        const next = Editor.next(editor, { at: path });
+        if (next && next[0].type === "paragraph" && !Node.string(next[0])) {
+          Transforms.delete(editor, { at: selection });
+        }
+        return true;
+      }
+      if (text.startsWith("attach://")) {
+        Transforms.insertNodes(
+          editor,
+          {
+            type: "attach",
+            name: urlObject.searchParams.get("name"),
+            size: Number(urlObject.searchParams.get("size") || 0),
+            url: url || void 0,
+            children: [{ text: "" }]
+          },
+          { select: true, at: path }
+        );
+        const next = Editor.next(editor, { at: path });
+        if (next && next[0].type === "paragraph" && !Node.string(next[0])) {
+          Transforms.delete(editor, { at: selection });
+        }
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var handleHttpLinkPaste = (editor, text, selection, store) => {
+  if (text.startsWith("http")) {
+    const mediaType = getMediaType(text);
+    if (["image", "video", "audio"].includes(mediaType)) {
+      const isValidMediaUrl = (url, type) => {
+        if (!url)
+          return false;
+        if (url.startsWith("blob:") || url.startsWith("data:")) {
+          return true;
+        }
+        const mediaExtensions = {
+          image: [
+            ".jpg",
+            ".jpeg",
+            ".png",
+            ".gif",
+            ".svg",
+            ".webp",
+            ".bmp",
+            ".ico"
+          ],
+          video: [".mp4", ".webm", ".ogg", ".avi", ".mov", ".wmv", ".flv"],
+          audio: [".mp3", ".wav", ".ogg", ".aac", ".m4a", ".flac"]
+        };
+        const extensions = mediaExtensions[type] || [];
+        const hasValidExtension = extensions.some(
+          (ext) => url.toLowerCase().includes(ext)
+        );
+        const mediaPaths = {
+          image: ["/image", "/img", "/photo", "/picture", "/avatar", "/icon"],
+          video: ["/video", "/media", "/movie", "/clip"],
+          audio: ["/audio", "/music", "/sound", "/voice"]
+        };
+        const paths = mediaPaths[type] || [];
+        const hasMediaPath = paths.some(
+          (path) => url.toLowerCase().includes(path)
+        );
+        return hasValidExtension || hasMediaPath;
+      };
+      if (isValidMediaUrl(text, mediaType)) {
+        const path = EditorUtils.findMediaInsertPath(editor);
+        if (!path)
+          return false;
+        Transforms.insertNodes(
+          editor,
+          EditorUtils.createMediaNode(text, "image"),
+          {
+            select: true,
+            at: selection
+          }
+        );
+        return true;
+      }
+    }
+    store.insertLink(text);
+    return true;
+  }
+  return false;
+};
+var handlePlainTextPaste = (editor, text, selection, plugins) => __async(void 0, null, function* () {
+  if (isMarkdown(text)) {
+    yield parseMarkdownToNodesAndInsert(editor, text, plugins);
+    return true;
+  }
+  if (isHtml(text)) {
+    const success = yield insertParsedHtmlNodes(editor, text, plugins, "");
+    if (success)
+      return true;
+  }
+  if (selection) {
+    Transforms.insertText(editor, text, { at: selection });
+  } else {
+    Transforms.insertNodes(editor, [
+      {
+        type: "paragraph",
+        children: [{ text }]
+      }
+    ]);
+  }
+  return true;
+});
+var shouldInsertTextDirectly = (editor, selection) => {
+  var _a;
+  if (!(selection == null ? void 0 : selection.focus))
+    return false;
+  const rangeNodes = (_a = Editor) == null ? void 0 : _a.node(editor, [selection.focus.path.at(0)]);
+  if (!rangeNodes)
+    return false;
+  const rangeNode = rangeNodes.at(0);
+  return [
+    "table-cell",
+    "table-row",
+    "table",
+    "code",
+    "schema",
+    "apaasify"
+  ].includes(rangeNode.type);
+};
+var handleTagNodePaste = (editor, currentTextSelection, clipboardData, curNode) => {
+  if (curNode == null ? void 0 : curNode.tag) {
+    const text = clipboardData.getData("text/plain");
+    if (text) {
+      Transforms.insertText(editor, text, {
+        at: currentTextSelection.focus
+      });
+      return true;
+    }
+  }
+  return false;
+};
+export {
+  handleFilesPaste,
+  handleHtmlPaste,
+  handleHttpLinkPaste,
+  handlePlainTextPaste,
+  handleSlateMarkdownFragment,
+  handleSpecialTextPaste,
+  handleTagNodePaste,
+  shouldInsertTextDirectly
+};

package/dist/MarkdownEditor/editor/plugins/hotKeyCommands/arrow.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { EditorStore } from '../../store';
+/**
+ * 处理编辑器中的箭头键相关操作
+ *
+ * @param store - 编辑器存储对象
+ * @param e - 键盘事件对象
+ *
+ * 功能包括:
+ * - Mod+左箭头: 在代码行中移动到行首或前一个非空白字符
+ * - 左箭头:
+ *   - 处理media/attach元素前的光标移动
+ *   - 处理空白节点前的光标移动
+ *   - 处理void节点前的光标移动
+ * - 右箭头:
+ *   - 处理media/attach元素后的光标移动
+ *   - 处理空白节点后的光标移动
+ *   - 处理void节点后的光标移动
+ * - 上箭头:
+ *   - 处理表格、代码块等特殊块的上方导航
+ *   - 在表格首行和代码块首行上方插入段落
+ *   - 处理media/attach元素的向上移动
+ * - 下箭头:
+ *   - 处理表格、代码块等特殊块的下方导航
+ *   - 在表格末行和代码块末行下方插入段落
+ *   - 处理media/attach元素的向下移动
+ *   - 处理空段落的导航
+ */
+export declare const keyArrow: (store: EditorStore, e: React.KeyboardEvent | KeyboardEvent) => void;

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

@@ -0,0 +1,141 @@
+// src/MarkdownEditor/editor/plugins/hotKeyCommands/arrow.ts
+import isHotkey from "is-hotkey";
+import { Editor, Element, Node, Path, Range, Transforms } from "slate";
+import { isMod } from "../../utils";
+import { EditorUtils } from "../../utils/editorUtils";
+var keyArrow = (store, e) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const editor = store == null ? void 0 : store.editor;
+  const sel = editor.selection;
+  if (sel && Range.isCollapsed(sel)) {
+    if (isHotkey("mod+left", e)) {
+      return;
+    }
+    if (isHotkey("left", e)) {
+      e.preventDefault();
+      e.stopPropagation();
+      const leaf = Node.leaf(editor, sel.focus.path);
+      const dirt = EditorUtils.isDirtLeaf(leaf);
+      const pre = Editor.previous(editor, { at: sel.focus.path });
+      if (sel.focus.offset === 0 && pre && (pre[0].type === "media" || pre[0].type === "attach")) {
+        Transforms.select(editor, pre[1]);
+      } else if (sel.focus.offset === 0 && dirt) {
+        EditorUtils.moveBeforeSpace(editor, sel.focus.path);
+      } else {
+        if (sel.focus.offset === 0 && Path.hasPrevious(sel.focus.path) && Editor.isVoid(editor, Node.get(editor, Path.previous(sel.focus.path)))) {
+          if (Path.hasPrevious(Path.previous(sel.focus.path))) {
+            Transforms.select(
+              editor,
+              Editor.end(editor, Path.previous(Path.previous(sel.focus.path)))
+            );
+          }
+        } else {
+          Transforms.move(editor, { unit: "offset", reverse: true });
+        }
+      }
+      return;
+    }
+    if (isHotkey("right", e)) {
+      e.preventDefault();
+      e.stopPropagation();
+      if (!isMod(e)) {
+        const leaf = Node.leaf(editor, sel.focus.path);
+        const dirt = EditorUtils.isDirtLeaf(leaf);
+        const next = Editor.next(editor, { at: sel.focus.path });
+        const [node] = Editor.nodes(editor, {
+          match: (n) => n.type === "media" || n.type === "attach"
+        });
+        if (node) {
+          if (((_a = node == null ? void 0 : node[0]) == null ? void 0 : _a.type) === "media" || ((_b = node == null ? void 0 : node[0]) == null ? void 0 : _b.type) === "attach") {
+            Transforms.select(editor, Editor.start(editor, Path.next(node[1])));
+          } else {
+            EditorUtils.moveAfterSpace(editor, node[1]);
+          }
+        } else if (sel.focus.offset === ((_c = leaf.text) == null ? void 0 : _c.length) && next && next[0].type === "media") {
+          Transforms.select(editor, next[1]);
+        } else if (sel.focus.offset === ((_d = leaf.text) == null ? void 0 : _d.length) && dirt && !Editor.next(editor, { at: sel.focus.path })) {
+          EditorUtils.moveAfterSpace(editor, sel.focus.path);
+        } else {
+          const leaf2 = Node.leaf(editor, sel.focus.path);
+          if (sel.focus.offset === ((_e = leaf2.text) == null ? void 0 : _e.length) && Editor.hasPath(editor, Path.next(sel.focus.path)) && Editor.isVoid(editor, Node.get(editor, Path.next(sel.focus.path)))) {
+            if (Editor.hasPath(editor, Path.next(Path.next(sel.focus.path)))) {
+              Transforms.select(
+                editor,
+                Editor.start(editor, Path.next(Path.next(sel.focus.path)))
+              );
+            }
+          } else {
+            Transforms.move(editor, { unit: "offset" });
+          }
+        }
+      } else {
+        Transforms.select(
+          editor,
+          Editor.end(editor, Path.parent(sel.focus.path))
+        );
+      }
+      return;
+    }
+    if (isHotkey("up", e)) {
+      const [node] = Editor.nodes(editor, {
+        match: (n) => Element.isElement(n),
+        mode: "lowest"
+      });
+      const [el, path] = node;
+      const pre = (_f = Editor) == null ? void 0 : _f.node(editor, EditorUtils.findPrev(editor, path));
+      if ((pre == null ? void 0 : pre[0].type) === "media" || (pre == null ? void 0 : pre[0].type) === "attach") {
+        e.preventDefault();
+        e.stopPropagation();
+        Transforms.select(editor, pre[1]);
+        return;
+      }
+      if (el.type === "media" || el.type === "attach") {
+        e.preventDefault();
+        const pre2 = EditorUtils.findPrev(editor, path);
+        Transforms.select(editor, Editor.end(editor, pre2));
+      }
+    }
+    if (isHotkey("down", e)) {
+      const [node] = Editor.nodes(editor, {
+        match: (n) => Element.isElement(n),
+        mode: "lowest"
+      });
+      const [el, path] = node;
+      if (!EditorUtils.findNext(editor, path))
+        return;
+      const next = (_g = Editor) == null ? void 0 : _g.node(editor, EditorUtils.findNext(editor, path));
+      if ((next == null ? void 0 : next[0].type) === "media" || (next == null ? void 0 : next[0].type) === "attach") {
+        e.preventDefault();
+        e.stopPropagation();
+        Transforms.select(editor, next[1]);
+        return;
+      }
+      if (el.type === "media" || el.type === "attach") {
+        const next2 = EditorUtils.findNext(editor, path);
+        e.preventDefault();
+        if (next2) {
+          Transforms.select(editor, Editor.start(editor, next2));
+        }
+      }
+      if (el.type === "paragraph") {
+        if (path[0] === 0 && !Node.string(el) && Editor.isEditor(Node.get(editor, Path.parent(path))) && Editor.hasPath(editor, Path.next(path))) {
+          const next2 = (_h = Editor) == null ? void 0 : _h.node(editor, Path.next(path));
+          if (["table", "code", "blockquote"].includes(next2[0].type)) {
+            e.preventDefault();
+            Transforms.select(editor, Editor.start(editor, Path.next(path)));
+            Transforms.delete(editor, { at: path });
+          }
+        }
+        if ((Node.string(el) || el.children.length > 1 || el.children[0].type === "media") && EditorUtils.checkSelEnd(editor, path)) {
+          Transforms.insertNodes(editor, EditorUtils.p, {
+            at: [editor.children.length],
+            select: true
+          });
+        }
+      }
+    }
+  }
+};
+export {
+  keyArrow
+};

package/dist/MarkdownEditor/editor/plugins/hotKeyCommands/backspace.d.ts

@@ -0,0 +1,8 @@
+import { Editor } from 'slate';
+export declare class BackspaceKey {
+    private readonly editor;
+    constructor(editor: Editor);
+    range(): boolean | undefined;
+    private clearStyle;
+    run(): boolean | undefined;
+}

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

@@ -0,0 +1,191 @@
+// src/MarkdownEditor/editor/plugins/hotKeyCommands/backspace.ts
+import { Editor, Element, Node, Path, Point, Range, Transforms } from "slate";
+import { EditorUtils } from "../../utils/editorUtils";
+var BackspaceKey = class {
+  constructor(editor) {
+    this.editor = editor;
+  }
+  range() {
+    const sel = this.editor.selection;
+    if (!sel)
+      return;
+    let [start, end] = Range.edges(sel);
+    if (Point.equals(start, Editor.start(this.editor, [])) && Point.equals(end, Editor.end(this.editor, []))) {
+      EditorUtils.deleteAll(this.editor);
+      Transforms.select(this.editor, Editor.end(this.editor, []));
+      return true;
+    }
+    return false;
+  }
+  clearStyle(sel) {
+    var _a;
+    const start = Range.start(sel);
+    const leaf = Node.leaf(this.editor, start.path);
+    if (((_a = leaf.text) == null ? void 0 : _a.length) === 1 && EditorUtils.isDirtLeaf(leaf)) {
+      EditorUtils.clearMarks(this.editor);
+    }
+  }
+  run() {
+    var _a, _b, _c;
+    const sel = this.editor.selection;
+    if (!sel)
+      return;
+    const nodes = Array.from(
+      Editor.nodes(this.editor, {
+        mode: "lowest",
+        match: (n) => Element.isElement(n)
+      })
+    );
+    const [node] = nodes;
+    const [el, path] = node;
+    const parent = Editor.parent(this.editor, path);
+    if (el.type !== "paragraph" && ((_a = parent == null ? void 0 : parent[0]) == null ? void 0 : _a.type) !== "list-item") {
+      this.clearStyle(sel);
+    }
+    if (el.type === "head") {
+      const str = Node.string(el);
+      if (!str) {
+        Transforms.setNodes(
+          this.editor,
+          {
+            type: "paragraph"
+          },
+          { at: path }
+        );
+        return true;
+      }
+    }
+    if (el.type === "media" || el.type === "attach") {
+      Transforms.removeNodes(this.editor, { at: path });
+      Transforms.insertNodes(this.editor, EditorUtils.p, {
+        at: node[1],
+        select: true
+      });
+      return true;
+    }
+    if (el.type === "paragraph") {
+      const parent2 = Editor.parent(this.editor, path);
+      if (((_b = parent2 == null ? void 0 : parent2[0]) == null ? void 0 : _b.type) === "list-item") {
+        if (Node.string(parent2[0]) !== "") {
+          return false;
+        }
+        if (Node.string(parent2[0]) === "") {
+          const listPath = Path.parent(parent2[1]);
+          const listNode = Editor.node(this.editor, listPath);
+          const currentItemIndex = parent2[1][parent2[1].length - 1];
+          const isLastItem = currentItemIndex === listNode[0].children.length - 1;
+          if (isLastItem) {
+            Transforms.delete(this.editor, { at: parent2[1] });
+            Transforms.insertNodes(
+              this.editor,
+              { type: "paragraph", children: [{ text: "" }] },
+              { at: parent2[1], select: true }
+            );
+          } else {
+            const remainingItems = listNode[0].children.slice(
+              currentItemIndex + 1
+            );
+            for (let i = listNode[0].children.length - 1; i > currentItemIndex; i--) {
+              Transforms.delete(this.editor, { at: [...listPath, i] });
+            }
+            Transforms.delete(this.editor, { at: parent2[1] });
+            const insertPath = Path.next(listPath);
+            Transforms.insertNodes(
+              this.editor,
+              { type: "paragraph", children: [{ text: "" }] },
+              { at: insertPath, select: true }
+            );
+            if (remainingItems.length > 0) {
+              const newListPath = Path.next(insertPath);
+              Transforms.insertNodes(
+                this.editor,
+                {
+                  type: listNode[0].type,
+                  // 保持原列表类型 (ordered/unordered)
+                  children: remainingItems
+                },
+                { at: newListPath }
+              );
+            }
+          }
+          return true;
+        }
+      }
+    }
+    if (el.type === "table-cell" && sel.anchor.offset === 0) {
+      const start = Range.start(sel);
+      if (!Path.hasPrevious(start.path)) {
+        return true;
+      }
+    }
+    if (sel.anchor.offset === 0) {
+      const preInline = Editor.previous(this.editor, {
+        at: sel.focus.path
+      });
+      if (preInline && preInline[0].type === "break") {
+        Transforms.delete(this.editor, { at: preInline[1] });
+        return true;
+      }
+      if (el.type === "paragraph") {
+        const pre = Editor.previous(this.editor, { at: path });
+        if (pre) {
+          if (["table", "code"].includes(pre[0].type)) {
+            const end = Editor.end(this.editor, pre[1]);
+            if (!Node.string(Node.get(this.editor, end.path))) {
+              Transforms.delete(this.editor, { at: path });
+              const text = Node.string(el);
+              if (text) {
+                Transforms.insertNodes(
+                  this.editor,
+                  pre[0].type === "code" ? [{ text }] : el.children,
+                  {
+                    at: end
+                  }
+                );
+              }
+              Transforms.select(this.editor, end);
+              return true;
+            }
+          }
+          if (pre[0].type === "media" || pre[0].type === "attach") {
+            if (!Node.string(el)) {
+              Transforms.delete(this.editor, { at: path });
+            }
+            Transforms.select(this.editor, pre[1]);
+            return true;
+          }
+        }
+        if (!pre && !Editor.previous(this.editor, { at: sel.anchor.path })) {
+          const parent2 = Editor.parent(this.editor, path);
+          if (parent2[0].type === "blockquote") {
+            if (Editor.hasPath(this.editor, Path.next(path))) {
+              Transforms.delete(this.editor, { at: path });
+            } else {
+              Transforms.delete(this.editor, { at: parent2[1] });
+            }
+            Transforms.insertNodes(
+              this.editor,
+              { type: "paragraph", children: el.children },
+              { at: parent2[1] }
+            );
+            Transforms.select(
+              this.editor,
+              Editor.start(this.editor, parent2[1])
+            );
+            return true;
+          }
+          const next = Editor.hasPath(this.editor, Path.next(path));
+          if (Editor.isEditor(parent2[0]) && next && ((_c = Editor) == null ? void 0 : _c.node(this.editor, Path.next(path))[0].type) !== "hr") {
+            Transforms.delete(this.editor, { at: path });
+            return true;
+          }
+        }
+        return false;
+      }
+    }
+    return false;
+  }
+};
+export {
+  BackspaceKey
+};