@ant-design/agentic-ui 2.0.0

package/dist/MarkdownEditor/editor/utils/editorUtils.js

@@ -0,0 +1,1060 @@
+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));
+
+// src/MarkdownEditor/editor/utils/editorUtils.ts
+import {
+  Editor,
+  Element,
+  Node,
+  Path,
+  Point,
+  Range,
+  Text,
+  Transforms
+} from "slate";
+import { ReactEditor } from "slate-react";
+import { getMediaType } from "./dom";
+var _EditorUtils = class {
+  static get p() {
+    return { type: "paragraph", children: [{ text: "" }] };
+  }
+  static hasPath(editor, path) {
+    return Editor.hasPath(editor, path);
+  }
+  static focus(editor) {
+    try {
+      ReactEditor.focus(editor);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  static blur(editor) {
+    try {
+      ReactEditor.blur(editor);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  static isPrevious(firstPath, nextPath) {
+    return Path.equals(Path.parent(firstPath), Path.parent(nextPath)) && Path.compare(firstPath, nextPath) === -1;
+  }
+  static isNextPath(firstPath, nextPath) {
+    return Path.equals(Path.parent(firstPath), Path.parent(nextPath)) && Path.compare(firstPath, nextPath) === 1;
+  }
+  static isDirtLeaf(leaf) {
+    return leaf.bold || leaf.code || leaf.italic || leaf.strikethrough || !!(leaf == null ? void 0 : leaf.url) || leaf.fnd || leaf.fnc || leaf.html || leaf.highColor;
+  }
+  static isTop(editor, path) {
+    const p = Editor.parent(editor, path);
+    return Editor.isEditor(p[0]);
+  }
+  static findPrev(editor, path) {
+    var _a;
+    while (path.length) {
+      if (Path.hasPrevious(path)) {
+        if (((_a = Node.get(editor, Path.previous(path))) == null ? void 0 : _a.type) === "hr") {
+          path = Path.previous(path);
+        } else {
+          return Path.previous(path);
+        }
+      } else {
+        path = Path.parent(path);
+      }
+    }
+    return [];
+  }
+  static findMediaInsertPath(editor) {
+    var _a, _b, _c;
+    const [cur] = Editor.nodes(editor, {
+      match: (n) => Element.isElement(n),
+      mode: "lowest"
+    });
+    if (!cur)
+      return null;
+    let path = cur[1];
+    if (((_a = cur == null ? void 0 : cur[0]) == null ? void 0 : _a.type) === "table-cell") {
+      path = Path.next(Path.parent(Path.parent(cur[1])));
+    }
+    if (((_b = cur == null ? void 0 : cur[0]) == null ? void 0 : _b.type) === "head") {
+      path = Path.next(path);
+    }
+    if (((_c = cur == null ? void 0 : cur[0]) == null ? void 0 : _c.type) === "paragraph" && Node.string(cur[0])) {
+      path = Path.next(cur[1]);
+    }
+    return path;
+  }
+  static findNext(editor, path) {
+    while (path.length) {
+      if (Editor.hasPath(editor, Path.next(path))) {
+        return Path.next(path);
+      } else {
+        path = Path.parent(path);
+      }
+    }
+    return void 0;
+  }
+  static moveNodes(editor, from, to, index = 1) {
+    let count = 0;
+    while (Editor.hasPath(editor, from)) {
+      if (count > 100)
+        break;
+      Transforms.moveNodes(editor, {
+        at: from,
+        to: [...to, index]
+      });
+      index++;
+      count++;
+    }
+  }
+  static moveAfterSpace(editor, path) {
+    const next = Editor.next(editor, { at: path });
+    if (!next || !Text.isText(next[0])) {
+      Transforms.transform(editor, {
+        type: "insert_node",
+        path: Path.next(path),
+        node: { text: "" }
+      });
+      Transforms.select(editor, Path.next(path));
+    } else {
+      Transforms.move(editor, { unit: "offset" });
+    }
+  }
+  static moveBeforeSpace(editor, path) {
+    if (!Path.hasPrevious(path)) {
+      Transforms.transform(editor, {
+        type: "insert_node",
+        path,
+        node: { text: "" }
+      });
+    }
+    Transforms.move(editor, { unit: "offset", reverse: true });
+  }
+  /**
+   * 清除编辑器中选中的文本的所有标记
+   *
+   * @param editor - 编辑器实例
+   * @param split - 是否在格式边界处分割文本节点，默认为 false
+   *
+   * @description
+   * 该方法执行以下操作：
+   * 1. 移除选中文本的所有格式标记
+   * 2. 处理列表项的提升和转换
+   * 3. 将选中区域转换为段落格式
+   *
+   * 当 split=true 时，会在不同格式的边界处分割文本节点，
+   * 这允许对部分文本应用/移除格式而不影响相邻文本
+   */
+  static clearMarks(editor, split = false) {
+    if (!editor.selection)
+      return;
+    Transforms.unsetNodes(editor, _EditorUtils.CLEARABLE_MARKS, {
+      split,
+      match: Text.isText
+    });
+    const anchorPath = editor.selection.anchor.path;
+    const parentPath = Path.parent(anchorPath);
+    try {
+      let node = Node.get(editor, parentPath);
+      if (node.type === "paragraph" && Editor.hasPath(editor, Path.parent(parentPath))) {
+        node = Node.get(editor, Path.parent(parentPath));
+      }
+      if (node.type === "list-item") {
+        Transforms.liftNodes(editor, {
+          at: Path.parent(anchorPath),
+          mode: "highest"
+        });
+      }
+      const nodeEntries = Array.from(
+        Editor.nodes(editor, {
+          match: (n) => Element.isElement(n),
+          mode: "highest"
+        })
+      );
+      if (nodeEntries.length > 0) {
+        const [selectNodes, selectPath] = nodeEntries[0];
+        if (selectNodes.type === "list") {
+          Transforms.removeNodes(editor, {
+            at: selectPath,
+            voids: true
+          });
+          const paragraphNodes = _EditorUtils.listToParagraph(
+            editor,
+            selectNodes
+          );
+          if (paragraphNodes.length > 0) {
+            Transforms.insertNodes(editor, paragraphNodes, {
+              at: editor.selection
+            });
+          }
+          return;
+        }
+      }
+      Transforms.setNodes(editor, { type: "paragraph" }, { at: parentPath });
+    } catch (error) {
+      console.error("Error in clearMarks:", error);
+    }
+  }
+  /**
+   * 将列表节点转换为段落节点数组
+   *
+   * @param editor - 编辑器实例
+   * @param listNode - 要处理的列表节点
+   * @returns 从列表节点中提取的所有段落节点的数组
+   *
+   * @description
+   * 该方法通过递归遍历列表节点及其子节点，提取所有段落节点，
+   * 并将它们汇集成一个扁平化的数组。支持嵌套列表的处理。
+   */
+  static listToParagraph(editor, listNode) {
+    if (!listNode.children || listNode.children.length === 0) {
+      return [];
+    }
+    const paragraphNodes = [];
+    const extractParagraphs = (children) => {
+      children.forEach((item) => {
+        if (!(item == null ? void 0 : item.children))
+          return;
+        item.children.forEach((child) => {
+          if (child.type === "paragraph") {
+            paragraphNodes.push(child);
+          } else if (child.type === "list") {
+            const nestedParagraphs = _EditorUtils.listToParagraph(editor, child);
+            paragraphNodes.push(...nestedParagraphs);
+          }
+        });
+      });
+    };
+    extractParagraphs(listNode.children);
+    return paragraphNodes.flat();
+  }
+  /**
+   * 删除编辑器中的所有内容，并插入新的节点
+   *
+   * @param editor - 编辑器实例
+   * @param insertNodes - 要插入的新节点数组。如果未提供，将插入默认段落节点
+   */
+  static deleteAll(editor, insertNodes) {
+    const allNodes = Array.from(
+      Editor.nodes(editor, {
+        at: [],
+        match: (n) => Element.isElement(n),
+        mode: "highest",
+        reverse: true
+      })
+    );
+    if (allNodes.length > 0) {
+      const firstNode = allNodes[allNodes.length - 1];
+      const lastNode = allNodes[0];
+      Transforms.delete(editor, {
+        at: {
+          anchor: Editor.start(editor, firstNode[1]),
+          focus: Editor.end(editor, lastNode[1])
+        }
+      });
+      if (Editor.hasPath(editor, [0])) {
+        Transforms.delete(editor, { at: [0] });
+      }
+    }
+    const nodesToInsert = insertNodes || [_EditorUtils.p];
+    Transforms.insertNodes(editor, nodesToInsert, { at: [0] });
+  }
+  /**
+   * 重置编辑器的内容，并可选地插入新的节点和重置历史记录
+   *
+   * @param editor - 要重置的编辑器实例
+   * @param insertNodes - 可选的插入节点数组。如果未提供，则使用默认段落节点
+   * @param force - 可选的布尔值或历史记录对象。如果为布尔值，则强制重置历史记录；如果为历史记录对象，则使用提供的历史记录
+   */
+  static reset(editor, insertNodes, force) {
+    const nodesToInsert = insertNodes || [_EditorUtils.p];
+    editor.children = JSON.parse(JSON.stringify(nodesToInsert));
+    if (force) {
+      editor.history = typeof force === "boolean" ? { redos: [], undos: [] } : force;
+    }
+    editor.onChange();
+  }
+  /**
+   * 检查选区是否完全包含在指定节点路径中。
+   *
+   * @param editor - 编辑器实例。
+   * @param sel - 选区范围。
+   * @param nodePath - 节点路径。
+   * @returns 如果选区完全包含在节点路径中，则返回 true，否则返回 false。
+   */
+  static includeAll(editor, sel, nodePath) {
+    const [start, end] = Range.edges(sel);
+    return Point.compare(start, Editor.start(editor, nodePath)) !== 1 && Point.compare(end, Editor.end(editor, nodePath)) !== -1;
+  }
+  static copy(data) {
+    return JSON.parse(JSON.stringify(data));
+  }
+  /**
+   * 复制指定范围内的文本内容。
+   *
+   * @param editor - 编辑器实例。
+   * @param start - 文本复制的起始位置。
+   * @param end - （可选）文本复制的结束位置。如果未提供，则复制从起始位置到文档末尾的所有文本。
+   * @returns 返回指定范围内的文本内容。
+   */
+  static copyText(editor, start, end) {
+    var _a, _b;
+    let leaf = Node.leaf(editor, start.path);
+    let text = "";
+    text += ((_a = leaf.text) == null ? void 0 : _a.slice(start.offset)) || "";
+    let next = Editor.next(editor, { at: start.path });
+    while (next) {
+      if (end && Path.equals(next[1], end.path)) {
+        text += ((_b = next[0].text) == null ? void 0 : _b.slice(0, end.offset)) || "";
+        break;
+      } else {
+        text += next[0].text || "";
+        next = Editor.next(editor, { at: next[1] });
+      }
+    }
+    return text;
+  }
+  /**
+   * 从编辑器中剪切文本。
+   *
+   * @param editor - 编辑器实例。
+   * @param start - 开始位置的点。
+   * @param end - 结束位置的点（可选）。
+   * @returns 剪切的文本数组，每个元素为一个 CustomLeaf 对象。
+   */
+  static cutText(editor, start, end) {
+    var _a, _b;
+    let leaf = Node.leaf(editor, start.path);
+    let texts = [
+      __spreadProps(__spreadValues({}, leaf), { text: ((_a = leaf.text) == null ? void 0 : _a.slice(start.offset)) || "" })
+    ];
+    let next = Editor.next(editor, { at: start.path });
+    while (next) {
+      if (end && Path.equals(next[1], end.path)) {
+        texts.push(__spreadProps(__spreadValues({}, next[0]), {
+          text: ((_b = next[0].text) == null ? void 0 : _b.slice(0, end.offset)) || ""
+        }));
+        break;
+      } else {
+        texts.push(next[0]);
+        next = Editor.next(editor, { at: next[1] });
+      }
+    }
+    return texts;
+  }
+  /**
+   * 检查编辑器中是否有指定格式的活动节点
+   *
+   * @param editor - 编辑器实例
+   * @param format - 要检查的格式名称
+   * @param value - 可选的值，用于进一步验证格式是否匹配
+   * @returns 如果存在匹配的格式节点，则返回 true；否则返回 false
+   */
+  static isFormatActive(editor, format, value) {
+    try {
+      const nodeEntries = Array.from(
+        Editor.nodes(editor, {
+          match: (n) => !!n[format],
+          mode: "lowest"
+        })
+      );
+      if (nodeEntries.length === 0)
+        return false;
+      const [node] = nodeEntries[0];
+      return value ? node[format] === value : !!node[format];
+    } catch (error) {
+      console.error("Error checking format active:", error);
+      return false;
+    }
+  }
+  /**
+   * 获取编辑器中选中文本的URL
+   *
+   * @param editor - 编辑器实例
+   * @returns 返回选中文本的URL，如果没有则返回空字符串
+   */
+  static getUrl(editor) {
+    var _a;
+    try {
+      const nodeEntries = Array.from(
+        Editor.nodes(editor, {
+          match: (n) => Text.isText(n) && !!(n == null ? void 0 : n.url),
+          mode: "lowest"
+        })
+      );
+      return nodeEntries.length > 0 ? ((_a = nodeEntries[0][0]) == null ? void 0 : _a.url) || "" : "";
+    } catch (error) {
+      console.error("Error getting URL:", error);
+      return "";
+    }
+  }
+  /**
+   * 切换文本格式（加粗、斜体等）
+   *
+   * @param editor - 编辑器实例
+   * @param format - 要切换的格式类型
+   */
+  static toggleFormat(editor, format) {
+    if (!editor.selection)
+      return;
+    const selectedText = Editor.string(editor, editor.selection);
+    if (!selectedText)
+      return;
+    const isActive = _EditorUtils.isFormatActive(editor, format);
+    Transforms.setNodes(
+      editor,
+      { [format]: isActive ? null : true },
+      { match: Text.isText, split: true }
+    );
+  }
+  /**
+   * 为编辑器中的文本节点设置高亮颜色
+   *
+   * @param editor - 编辑器实例
+   * @param color - 可选的高亮颜色字符串。如果未提供，则移除高亮颜色
+   */
+  static highColor(editor, color) {
+    if (!editor.selection)
+      return;
+    Transforms.setNodes(
+      editor,
+      { highColor: color },
+      { match: Text.isText, split: true }
+    );
+  }
+  /**
+   * 设置文本对齐方式
+   *
+   * @param editor - 编辑器实例
+   * @param alignment - 对齐方式：'left', 'center', 或 'right'
+   */
+  static setAlignment(editor, alignment) {
+    if (!editor.selection)
+      return;
+    Transforms.setNodes(
+      editor,
+      { align: alignment },
+      { match: (n) => Element.isElement(n) && !Editor.isEditor(n) }
+    );
+  }
+  /**
+   * 检查当前选中块的对齐方式
+   *
+   * @param editor - 编辑器实例
+   * @param alignment - 要检查的对齐方式
+   * @returns 是否处于指定的对齐方式
+   */
+  static isAlignmentActive(editor, alignment) {
+    try {
+      const nodeEntries = Array.from(
+        Editor.nodes(editor, {
+          match: (n) => Element.isElement(n) && n.align === alignment
+        })
+      );
+      return nodeEntries.length > 0;
+    } catch (error) {
+      console.error("Error checking alignment active:", error);
+      return false;
+    }
+  }
+  /**
+   * 检查编辑器末尾是否需要添加段落节点
+   *
+   * @param editor - 编辑器实例
+   * @returns 如果添加了段落节点则返回 true，否则返回 false
+   */
+  static checkEnd(editor) {
+    var _a, _b;
+    try {
+      const nodeEntries = Array.from(
+        Editor.nodes(editor, {
+          at: [],
+          mode: "highest",
+          match: (n) => Element.isElement(n),
+          reverse: true
+        })
+      );
+      if (nodeEntries.length === 0)
+        return false;
+      const [node, path] = nodeEntries[0];
+      const nodeString = Node.string(node);
+      const hasMediaChild = ((_a = node == null ? void 0 : node.children) == null ? void 0 : _a.length) === 1 && ((_b = node == null ? void 0 : node.children[0]) == null ? void 0 : _b.type) === "media";
+      if ((node == null ? void 0 : node.type) !== "paragraph" || nodeString || hasMediaChild) {
+        Transforms.insertNodes(editor, _EditorUtils.p, {
+          at: Path.next(path)
+        });
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error("Error in checkEnd:", error);
+      return false;
+    }
+  }
+  /**
+   * 检查指定路径是否在编辑器末尾
+   *
+   * @param editor - 编辑器实例
+   * @param path - 要检查的路径
+   * @returns 如果路径在末尾则返回 true，否则返回 false
+   */
+  static checkSelEnd(editor, path) {
+    try {
+      let currentNode = Editor.node(editor, path);
+      while (!Editor.isEditor(currentNode[0])) {
+        if (Editor.hasPath(editor, Path.next(currentNode[1]))) {
+          return false;
+        }
+        currentNode = Editor.node(editor, Path.parent(currentNode[1]));
+      }
+      return true;
+    } catch (error) {
+      console.error("Error in checkSelEnd:", error);
+      return false;
+    }
+  }
+  /**
+   * 安全地查找元素对应的Slate路径
+   *
+   * @param editor - 编辑器实例
+   * @param el - DOM元素
+   * @returns 元素对应的路径，如果查找失败则返回编辑器起始路径
+   */
+  static findPath(editor, el) {
+    try {
+      return ReactEditor.findPath(editor, el);
+    } catch (error) {
+      console.error("find path error", error);
+      return Editor.start(editor, []).path;
+    }
+  }
+  /**
+   * 创建媒体节点（图片、视频等）
+   *
+   * @param src - 媒体资源URL
+   * @param type - 媒体类型
+   * @param extraPros - 额外属性
+   * @returns 创建的媒体节点
+   */
+  static createMediaNode(src, type, extraPros) {
+    if (!src) {
+      return { text: "" };
+    }
+    try {
+      const fullSrc = _EditorUtils.normalizeUrl(src);
+      const urlParams = _EditorUtils.parseUrlParams(fullSrc);
+      const altText = (extraPros == null ? void 0 : extraPros.alt) || urlParams.get("alt") || "";
+      if (type === "image" && _EditorUtils.isImageType(src, (extraPros == null ? void 0 : extraPros.alt) || type)) {
+        return _EditorUtils.createImageNode(src, altText, urlParams, extraPros);
+      }
+      return _EditorUtils.createGenericMediaNode(src, type, extraPros);
+    } catch (error) {
+      console.error("Error creating media node:", error, src);
+      return _EditorUtils.createGenericMediaNode(src, type, extraPros);
+    }
+  }
+  /**
+   * 标准化URL，添加协议前缀
+   */
+  static normalizeUrl(src) {
+    if (src.match(/^(https?:\/\/|data:|file:)/)) {
+      return src;
+    }
+    const origin = window.location.origin || "";
+    return src.startsWith("/") ? `${origin}${src}` : `${origin}/${src}`;
+  }
+  /**
+   * 解析URL参数
+   */
+  static parseUrlParams(url) {
+    try {
+      return new URL(url).searchParams;
+    } catch (e) {
+      return new URLSearchParams();
+    }
+  }
+  /**
+   * 检查是否为图片类型
+   */
+  static isImageType(src, alt) {
+    return ["image"].includes(getMediaType(src, alt));
+  }
+  /**
+   * 创建图片节点
+   */
+  static createImageNode(src, altText, urlParams, extraPros) {
+    return {
+      type: "card",
+      block: urlParams.get("block") || false,
+      children: [
+        {
+          type: "card-before",
+          children: [{ text: "" }]
+        },
+        __spreadProps(__spreadValues({}, extraPros || {}), {
+          block: urlParams.get("block") || false,
+          type: "image",
+          url: src,
+          mediaType: "image",
+          alt: altText,
+          width: urlParams.get("width") || void 0,
+          height: urlParams.get("height") || void 0,
+          children: [{ text: "" }]
+        }),
+        {
+          type: "card-after",
+          children: [{ text: "" }]
+        }
+      ]
+    };
+  }
+  /**
+   * 创建通用媒体节点
+   */
+  static createGenericMediaNode(src, type, extraPros) {
+    return {
+      type: "card",
+      children: [
+        {
+          type: "card-before",
+          children: [{ text: "" }]
+        },
+        __spreadProps(__spreadValues({}, extraPros || {}), {
+          type: "media",
+          url: src,
+          children: [{ text: "" }],
+          mediaType: type
+        }),
+        {
+          type: "card-after",
+          children: [{ text: "" }]
+        }
+      ]
+    };
+  }
+  /**
+   * 用卡片节点包装普通节点
+   *
+   * @param node - 要包装的节点
+   * @param props - 额外属性
+   * @returns 包装后的卡片节点
+   */
+  static wrapperCardNode(node, props = {}) {
+    return __spreadProps(__spreadValues({
+      type: "card"
+    }, props), {
+      children: [
+        {
+          type: "card-before",
+          children: [{ text: "" }]
+        },
+        node,
+        {
+          type: "card-after",
+          children: [{ text: "" }]
+        }
+      ]
+    });
+  }
+};
+var EditorUtils = _EditorUtils;
+// 可清除的文本格式属性
+EditorUtils.CLEARABLE_MARKS = [
+  "url",
+  "strikethrough",
+  "italic",
+  "code",
+  "bold",
+  "color",
+  "textColor",
+  "highColor"
+];
+/**
+ * 替换编辑器中当前选中的节点
+ *
+ * @param editor - 编辑器实例
+ * @param newNode - 要插入的新节点数组
+ *
+ * @description
+ * 该方法会查找当前选区中的最低块级节点，然后用新的节点替换它。
+ * 替换过程包括：查找最低块级节点，选中整个节点，插入新节点来替换原内容。
+ */
+EditorUtils.replaceSelectedNode = (editor, newNode) => {
+  const nodeEntries = Array.from(
+    Editor.nodes(editor, {
+      mode: "lowest"
+    })
+  );
+  if (nodeEntries.length === 0) {
+    Transforms.insertNodes(editor, newNode);
+    return;
+  }
+  const [node, path] = nodeEntries[0];
+  if (Text.isText(node) && node.text === "") {
+    const parentPath = Path.parent(path);
+    Transforms.removeNodes(editor, { at: parentPath });
+    Transforms.insertNodes(editor, newNode, {
+      at: parentPath,
+      select: true
+    });
+  } else {
+    Transforms.insertNodes(editor, newNode, {
+      select: true
+    });
+  }
+};
+var getDefaultView = (value) => {
+  return value && value.ownerDocument && value.ownerDocument.defaultView || null;
+};
+var isDOMNode = (value) => {
+  const window2 = getDefaultView(value);
+  return !!window2 && value instanceof window2.Node;
+};
+var isEventHandled = (event, handler) => {
+  if (!handler) {
+    return false;
+  }
+  handler(event);
+  return event.isDefaultPrevented() || event.isPropagationStopped();
+};
+var hasTarget = (editor, target) => {
+  return isDOMNode(target) && ReactEditor.hasDOMNode(editor, target);
+};
+function checkText(domPoint) {
+  var _a;
+  if (!isDOMNode(domPoint)) {
+    return false;
+  }
+  let leafNode = (_a = domPoint == null ? void 0 : domPoint.parentElement) == null ? void 0 : _a.closest("[data-slate-leaf]");
+  if (!leafNode) {
+    return false;
+  }
+  const textNode = leafNode.closest('[data-slate-node="text"]');
+  return !!textNode;
+}
+var isTargetInsideVoid = (editor, target) => {
+  const slateNode = hasTarget(editor, target) && ReactEditor.toSlateNode(editor, target);
+  return Editor.isVoid(editor, slateNode);
+};
+function createSelectionFromNodes(anchorNode, anchorOffset, focusNode, focusOffset) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  if (!anchorNode || !focusNode) {
+    return null;
+  }
+  try {
+    const selection = window.getSelection();
+    if (!selection) {
+      return null;
+    }
+    selection.removeAllRanges();
+    selection.setBaseAndExtent(
+      anchorNode,
+      anchorOffset,
+      focusNode,
+      focusOffset
+    );
+    return selection;
+  } catch (error) {
+    console.error("创建 Selection 对象失败:", error);
+    return null;
+  }
+}
+function createDomRangeFromNodes(anchorNode, anchorOffset, focusNode, focusOffset) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  if (!anchorNode || !focusNode) {
+    return null;
+  }
+  try {
+    const range = document.createRange();
+    range.setStart(anchorNode, anchorOffset);
+    range.setEnd(focusNode, focusOffset);
+    return range;
+  } catch (error) {
+    console.error("创建 DOM Range 对象失败:", error);
+    return null;
+  }
+}
+function isNodeSelectable(editor, node) {
+  if (!node)
+    return false;
+  return hasTarget(editor, node) || isTargetInsideVoid(editor, node);
+}
+function createAndConvertRange(editor, anchorNode, focusNode, originalRange) {
+  try {
+    const domRange = document.createRange();
+    domRange.setStart(anchorNode, originalRange.startOffset);
+    domRange.setEnd(focusNode, originalRange.endOffset);
+    return ReactEditor.toSlateRange(editor, domRange, {
+      exactMatch: true,
+      suppressThrow: false
+    });
+  } catch (error) {
+    console.error("创建并转换 Range 失败:", error);
+    return null;
+  }
+}
+function getSelectionFromDomSelection(editor, domSelection) {
+  if (!domSelection.rangeCount || domSelection.rangeCount === 0) {
+    return null;
+  }
+  try {
+    const range = domSelection.getRangeAt(0);
+    if (!range) {
+      return null;
+    }
+    const anchorNode = range.startContainer;
+    const focusNode = range.endContainer;
+    if (!isNodeSelectable(editor, anchorNode) || !isNodeSelectable(editor, focusNode)) {
+      return null;
+    }
+    if (!checkText(anchorNode) || !checkText(focusNode)) {
+      return null;
+    }
+    return createAndConvertRange(editor, anchorNode, focusNode, range);
+  } catch (error) {
+    console.error("getSelectionFromDomSelection error:", error);
+    return null;
+  }
+}
+var hasEditableTarget = (editor, target) => {
+  return isDOMNode(target) && ReactEditor.hasDOMNode(editor, target, { editable: true });
+};
+function getPointStrOffset(editor, point) {
+  const nodes = Node.fragment(editor, {
+    anchor: { path: Node.first(editor, point.path)[1], offset: 0 },
+    focus: point
+  });
+  const str = Node.string({
+    type: "",
+    children: nodes
+  });
+  return str.length;
+}
+function getRelativePath(path, anther) {
+  const newPath = [...path];
+  const newAnther = [...anther];
+  const relativeLen = path.length - anther.length;
+  if (relativeLen > 0) {
+    newAnther.unshift(new Array(relativeLen).fill(0));
+  } else if (relativeLen < 0) {
+    return new Array(anther.length).fill(0);
+    newPath.unshift(new Array(-relativeLen).fill(0));
+  }
+  const relativePath = [];
+  for (let i = 0; i < newPath.length; i++) {
+    if (newPath[i] !== newAnther[i]) {
+      relativePath.push(newPath[i] - newAnther[i]);
+    } else {
+      relativePath.push(0);
+    }
+  }
+  return relativePath;
+}
+function calcPath(path, anther) {
+  const newPath = [...path];
+  const newAnther = [...anther];
+  const relativeLen = path.length - anther.length;
+  if (relativeLen > 0) {
+    newAnther.unshift(new Array(relativeLen).fill(0));
+  } else if (relativeLen < 0) {
+    newPath.unshift(new Array(-relativeLen).fill(0));
+  }
+  const relativePath = [];
+  for (let i = 0; i < newPath.length; i++) {
+    relativePath.push(newPath[i] + newAnther[i]);
+  }
+  return relativePath;
+}
+function isPath(path) {
+  for (let i = 0; i < path.length; i++) {
+    const num = path[i];
+    if (!(isFinite(num) && num >= 0)) {
+      return false;
+    }
+  }
+  return true;
+}
+function findLeafPath(editor, path) {
+  const node = Editor.leaf(editor, path, {
+    edge: "end"
+  });
+  if (!node)
+    return path;
+  return node[1];
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeMarkdownSearchText(searchText) {
+  if (!searchText.trim())
+    return [];
+  const searchVariants = /* @__PURE__ */ new Set();
+  searchVariants.add(searchText.trim());
+  let cleanText = searchText.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*(.*?)\*\*/g, "$1").replace(/__(.*?)__/g, "$1").replace(/\*(.*?)\*/g, "$1").replace(/_(.*?)_/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/~~(.*?)~~/g, "$1").replace(/^#+\s+(.*)$/gm, "$1").replace(/^>\s*(.*)$/gm, "$1").replace(/^[\s]*[-*+]\s+(.*)$/gm, "$1").replace(/^\s*\d+\.\s+(.*)$/gm, "$1").trim();
+  if (cleanText && cleanText !== searchText.trim()) {
+    searchVariants.add(cleanText);
+  }
+  const words = cleanText.split(/\s+/).filter((word) => word.length > 1);
+  if (words.length > 1) {
+    words.forEach((word) => searchVariants.add(word));
+  }
+  return Array.from(searchVariants).filter((text) => text.length > 0);
+}
+function findByPathAndText(editor, pathDescription, searchText, options = {}) {
+  const {
+    caseSensitive = false,
+    wholeWord = false,
+    maxResults = 2,
+    includeMarkdownVariants = true
+  } = options;
+  if (!searchText.trim())
+    return [];
+  const results = [];
+  const searchVariants = includeMarkdownVariants ? normalizeMarkdownSearchText(searchText) : [searchText.trim()];
+  if (searchVariants.length === 0)
+    return [];
+  const flags = caseSensitive ? "g" : "gi";
+  const patterns = searchVariants.map((variant) => ({
+    variant,
+    pattern: wholeWord ? new RegExp(`\\b${escapeRegExp(variant)}\\b`, flags) : new RegExp(escapeRegExp(variant), flags)
+  }));
+  try {
+    let searchRange;
+    if (pathDescription && pathDescription.length > 0) {
+      try {
+        if (Editor.hasPath(editor, pathDescription)) {
+          searchRange = [pathDescription];
+        }
+      } catch (e) {
+        console.debug("无效的搜索路径:", pathDescription, e);
+        searchRange = void 0;
+      }
+    }
+    let textNodesGenerator;
+    if (searchRange && searchRange.length > 0) {
+      const allTextNodes = [];
+      for (const rangePath of searchRange) {
+        try {
+          const rangeNodes = Array.from(
+            Editor.nodes(editor, {
+              at: rangePath,
+              match: (n) => Text.isText(n) && typeof n.text === "string" && n.text.length > 0
+            })
+          );
+          allTextNodes.push(...rangeNodes);
+        } catch (e) {
+          continue;
+        }
+      }
+      textNodesGenerator = allTextNodes;
+    } else {
+      textNodesGenerator = Array.from(
+        Editor.nodes(editor, {
+          at: [],
+          match: (n) => Text.isText(n) && typeof n.text === "string" && n.text.length > 0
+        })
+      );
+    }
+    for (const [node, path] of textNodesGenerator) {
+      if (!Text.isText(node) || !node.text)
+        continue;
+      for (const { variant, pattern } of patterns) {
+        let match;
+        pattern.lastIndex = 0;
+        while ((match = pattern.exec(node.text)) !== null) {
+          let lineContent = node.text;
+          let nodeType = "text";
+          try {
+            const parentPath = Path.parent(path);
+            if (Editor.hasPath(editor, parentPath)) {
+              const parent = Node.get(editor, parentPath);
+              if (Element.isElement(parent)) {
+                lineContent = Node.string(parent);
+                nodeType = parent.type || "unknown";
+              }
+            }
+          } catch (e) {
+          }
+          const matchIndex = match.index;
+          const matchLength = match[0].length;
+          const matchText = match[0];
+          const range = {
+            anchor: { path, offset: matchIndex },
+            focus: { path, offset: matchIndex + matchLength }
+          };
+          const isDuplicate = results.some(
+            (result) => Path.equals(result.path, path) && result.offset.start === matchIndex && result.offset.end === matchIndex + matchLength
+          );
+          if (!isDuplicate) {
+            const isLink = Text.isText(node) && !!node.url;
+            const linkUrl = isLink ? node.url : void 0;
+            results.push({
+              path,
+              range,
+              node,
+              matchedText: matchText,
+              offset: {
+                start: matchIndex,
+                end: matchIndex + matchLength
+              },
+              lineContent: lineContent.trim(),
+              nodeType,
+              searchVariant: variant !== searchText.trim() ? variant : void 0,
+              isLink,
+              linkUrl
+            });
+          }
+          if (results.length >= maxResults)
+            break;
+        }
+        if (results.length >= maxResults)
+          break;
+      }
+      if (results.length >= maxResults)
+        break;
+    }
+  } catch (error) {
+    console.error("查找过程中出错:", error);
+  }
+  return results;
+}
+export {
+  EditorUtils,
+  calcPath,
+  createDomRangeFromNodes,
+  createSelectionFromNodes,
+  escapeRegExp,
+  findByPathAndText,
+  findLeafPath,
+  getDefaultView,
+  getPointStrOffset,
+  getRelativePath,
+  getSelectionFromDomSelection,
+  hasEditableTarget,
+  hasTarget,
+  isDOMNode,
+  isEventHandled,
+  isPath,
+  isTargetInsideVoid,
+  normalizeMarkdownSearchText
+};