@ant-design/agentic-ui 2.0.0

package/dist/MarkdownEditor/editor/store.js

@@ -0,0 +1,1446 @@
+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/store.ts
+import isEqual from "lodash-es/isEqual";
+import { parse } from "querystring";
+import * as React from "react";
+import {
+  Editor,
+  Element,
+  Node,
+  Path,
+  Range,
+  Text,
+  Transforms
+} from "slate";
+import { ReactEditor } from "slate-react";
+import { parserMdToSchema } from "./parser/parserMdToSchema";
+import { parserSlateNodeToMarkdown } from "./utils";
+import { getOffsetLeft, getOffsetTop } from "./utils/dom";
+import { EditorUtils, findByPathAndText } from "./utils/editorUtils";
+import { markdownToHtmlSync } from "./utils/markdownToHtml";
+var { createContext, useContext } = React;
+var EditorStoreContext = createContext(
+  null
+);
+var useEditorStore = () => {
+  return useContext(EditorStoreContext) || {
+    store: {},
+    readonly: true,
+    typewriter: false,
+    editorProps: {},
+    markdownEditorRef: {}
+  };
+};
+var SUPPORT_TYPING_TAG = ["table-cell", "paragraph", "head"];
+var EditorStore = class {
+  constructor(_editor, plugins) {
+    /** 高亮缓存映射表 */
+    this.highlightCache = /* @__PURE__ */ new Map();
+    /** 允许进入的元素类型集合 */
+    this.ableToEnter = /* @__PURE__ */ new Set([
+      "paragraph",
+      "head",
+      "blockquote",
+      "code",
+      "table",
+      "list",
+      "media",
+      "attach"
+    ]);
+    /** 当前拖拽的元素 */
+    this.draggedElement = null;
+    this.footnoteDefinitionMap = /* @__PURE__ */ new Map();
+    this.inputComposition = false;
+    this.domRect = null;
+    /** 当前 setMDContent 操作的 AbortController */
+    this._currentAbortController = null;
+    /**
+     * 移除节点
+     * @param options
+     */
+    this.removeNodes = (options) => {
+      Transforms.removeNodes(this._editor.current, options);
+    };
+    this.dragStart = this.dragStart.bind(this);
+    this._editor = _editor;
+    this.plugins = plugins;
+  }
+  /**
+   * 获取当前编辑器实例。
+   *
+   * @returns 当前的 Slate 编辑器实例。
+   */
+  get editor() {
+    return this._editor.current;
+  }
+  /**
+   * 聚焦到编辑器
+   */
+  focus() {
+    const editor = this._editor.current;
+    try {
+      setTimeout(() => ReactEditor.focus(editor), 0);
+      if (editor.children.length === 0) {
+        const defaultNode = { type: "paragraph", children: [{ text: "" }] };
+        Transforms.insertNodes(editor, defaultNode, { at: [0] });
+      }
+      const end = Editor.end(editor, []);
+      Transforms.select(editor, {
+        anchor: end,
+        focus: end
+      });
+    } catch (error) {
+      console.error("移动光标失败:", error);
+    }
+  }
+  /**
+   * 查找最新的节点索引。
+   *
+   * @param node - 当前节点。
+   * @param index - 当前索引路径。
+   * @returns 最新节点的索引路径。
+   */
+  findLatest(node, index) {
+    if (Array.isArray(node.children)) {
+      if (node.children.length === 1 && (SUPPORT_TYPING_TAG.includes(node.type) || !node.children[0].type)) {
+        return index;
+      }
+      return this.findLatest(
+        node.children[node.children.length - 1],
+        [...index, node.children.length - 1]
+      );
+    }
+    return index;
+  }
+  /**
+   * 检查给定节点是否是最新节点。用于展示 闪动光标
+   *
+   * @param node - 要检查的节点。
+   * @returns 如果节点是最新节点，则返回 true；否则返回 false。
+   */
+  isLatestNode(node) {
+    try {
+      return this.findLatest(this._editor.current.children.at(-1), [
+        this._editor.current.children.length - 1
+      ]).join("-").startsWith(ReactEditor.findPath(this._editor.current, node).join("-"));
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * 插入一个链接到编辑器中。
+   *
+   * @param filePath - 要插入的文件路径。如果路径以 'http' 开头，则链接文本为路径本身，否则为文件名。
+   *
+   * 该方法首先解析文件路径，并创建一个包含文本和 URL 的节点对象。
+   * 然后，它检查当前编辑器的选区是否存在且未折叠。如果选区不存在或已折叠，则方法返回。
+   *
+   * 接下来，它查找当前选区所在的最低层级的元素节点。如果节点类型是 'table-cell' 或 'paragraph'，
+   * 则在当前选区插入链接节点并选中它。
+   *
+   * 如果当前选区所在的元素节点类型不是 'table-cell' 或 'paragraph'，则查找包含当前选区的父级元素节点，
+   * 并在其后插入一个包含链接节点的新段落。
+   */
+  insertLink(filePath) {
+    const p = parse(filePath);
+    const insertPath = filePath;
+    let node = {
+      text: filePath.startsWith("http") ? filePath : p.name,
+      url: insertPath
+    };
+    const sel = this._editor.current.selection;
+    if (!sel || !Range.isCollapsed(sel))
+      return;
+    const [cur] = Editor.nodes(this._editor.current, {
+      match: (n) => Element.isElement(n),
+      mode: "lowest"
+    });
+    if (node.text && ["table-cell", "paragraph"].includes(cur[0].type)) {
+      Transforms.insertNodes(this._editor.current, node, { select: true });
+    } else {
+      const [par] = Editor.nodes(this._editor.current, {
+        match: (n) => Element.isElement(n) && ["table", "code", "head"].includes(n.type)
+      });
+      Transforms.insertNodes(
+        this._editor.current,
+        {
+          type: "paragraph",
+          children: [node]
+        },
+        { select: true, at: Path.next(par[1]) }
+      );
+    }
+  }
+  /**
+   * 插入节点到编辑器中。
+   *
+   * @param nodes - 要插入的节点，可以是单个节点或节点数组。
+   * @param options - 可选参数，用于指定插入节点的选项。
+   */
+  insertNodes(nodes, options) {
+    Transforms.insertNodes(this._editor.current, nodes, options);
+  }
+  /**
+   * Converts an HTML element to a Slate path and node.
+   *
+   * @param el - The HTML element to convert.
+   * @returns A tuple containing the path and the corresponding Slate node.
+   * @private
+   */
+  toPath(el) {
+    const node = ReactEditor.toSlateNode(this._editor.current, el);
+    const path = ReactEditor.findPath(this._editor.current, node);
+    return [path, node];
+  }
+  /**
+   * Clears all content from the editor, replacing it with an empty paragraph.
+   */
+  clearContent() {
+    this._editor.current.selection = null;
+    this._editor.current.children = [
+      {
+        type: "paragraph",
+        children: [{ text: "" }]
+      }
+    ];
+  }
+  /**
+   * 从 markdown 文本设置编辑器内容
+   *
+   * @param md - 要设置为编辑器内容的 Markdown 字符串
+   *             如果为 undefined，方法将直接返回不做任何更改
+   *             如果 markdown 与当前内容相同，则不做任何更改
+   * @param plugins - 可选的自定义 markdown 解析插件
+   * @param options - 可选的配置参数
+   *   - chunkSize: 分块大小阈值，默认 5000 字符。超过此大小会启用分批处理
+   *   - separator: 分隔符，默认为双换行符 '\n\n'，用于拆分长文本
+   *   - useRAF: 是否使用 requestAnimationFrame 优化，默认 true，避免长文本处理时卡顿
+   *   - batchSize: 每帧处理的节点数量，默认 50，仅在 useRAF=true 时生效
+   *   - onProgress: 进度回调函数，接收当前进度 (0-1) 作为参数
+   * @returns 如果使用 RAF，返回 Promise；否则同步执行
+   */
+  setMDContent(md, plugins, options) {
+    var _a, _b, _c, _d;
+    if (md === void 0)
+      return;
+    if (md === parserSlateNodeToMarkdown(this._editor.current.children))
+      return;
+    const chunkSize = (_a = options == null ? void 0 : options.chunkSize) != null ? _a : 5e3;
+    const separator = (_b = options == null ? void 0 : options.separator) != null ? _b : /\n\n/;
+    const useRAF = (_c = options == null ? void 0 : options.useRAF) != null ? _c : true;
+    const batchSize = (_d = options == null ? void 0 : options.batchSize) != null ? _d : 50;
+    const targetPlugins = plugins || this.plugins;
+    if (md.length <= chunkSize) {
+      const nodeList = parserMdToSchema(md, targetPlugins).schema;
+      this.setContent(nodeList);
+      this._editor.current.children = nodeList;
+      ReactEditor.deselect(this._editor.current);
+      if (options == null ? void 0 : options.onProgress) {
+        options.onProgress(1);
+      }
+      return;
+    }
+    if (!useRAF) {
+      const chunks2 = this._splitMarkdown(md, separator);
+      const allNodes = [];
+      for (const chunk of chunks2) {
+        if (chunk.trim()) {
+          const { schema } = parserMdToSchema(chunk, targetPlugins);
+          allNodes.push(...schema);
+        }
+      }
+      if (allNodes.length > 0) {
+        this.setContent(allNodes);
+        this._editor.current.children = allNodes;
+        ReactEditor.deselect(this._editor.current);
+      }
+      if (options == null ? void 0 : options.onProgress) {
+        options.onProgress(1);
+      }
+      return;
+    }
+    const chunks = this._splitMarkdown(md, separator);
+    if (useRAF && chunks.length > 10) {
+      this._currentAbortController = new AbortController();
+      return this._parseAndSetContentWithRAF(
+        chunks,
+        targetPlugins || [],
+        batchSize,
+        options == null ? void 0 : options.onProgress,
+        this._currentAbortController.signal
+      );
+    }
+  }
+  /**
+   * 取消当前正在进行的 setMDContent 操作
+   */
+  cancelSetMDContent() {
+    if (this._currentAbortController) {
+      this._currentAbortController.abort();
+      this._currentAbortController = null;
+    }
+  }
+  /**
+   * 使用 requestAnimationFrame 分批解析和设置内容
+   * 边解析边插入，实时显示内容
+   *
+   * @param chunks - markdown 分块数组
+   * @param plugins - 解析插件
+   * @param batchSize - 每帧处理的数量
+   * @param onProgress - 进度回调函数
+   * @returns Promise，在所有内容处理完成后 resolve
+   * @private
+   */
+  _parseAndSetContentWithRAF(chunks, plugins, batchSize, onProgress, signal) {
+    return new Promise((resolve, reject) => {
+      let currentChunkIndex = 0;
+      const totalChunks = chunks.length;
+      const parseChunksPerFrame = Math.max(1, Math.floor(batchSize / 10));
+      let isFirstBatch = true;
+      let rafId = null;
+      const parseAndInsertNextBatch = () => {
+        try {
+          if (signal == null ? void 0 : signal.aborted) {
+            if (rafId) {
+              cancelAnimationFrame(rafId);
+              rafId = null;
+            }
+            this._currentAbortController = null;
+            reject(new Error("Operation was cancelled"));
+            return;
+          }
+          const endIndex = Math.min(
+            currentChunkIndex + parseChunksPerFrame,
+            totalChunks
+          );
+          for (let i = currentChunkIndex; i < endIndex; i++) {
+            const chunk = chunks[i];
+            if (chunk.trim()) {
+              const { schema } = parserMdToSchema(chunk, plugins);
+              if (schema.length > 0) {
+                if (isFirstBatch) {
+                  this._editor.current.children = schema;
+                  this._editor.current.onChange();
+                  isFirstBatch = false;
+                } else {
+                  Transforms.insertNodes(this._editor.current, schema, {
+                    at: [this._editor.current.children.length]
+                  });
+                }
+              }
+            }
+          }
+          currentChunkIndex = endIndex;
+          const progress = currentChunkIndex / totalChunks;
+          if (onProgress) {
+            onProgress(progress);
+          }
+          if (currentChunkIndex < totalChunks) {
+            rafId = requestAnimationFrame(parseAndInsertNextBatch);
+          } else {
+            ReactEditor.deselect(this._editor.current);
+            rafId = null;
+            this._currentAbortController = null;
+            resolve();
+          }
+        } catch (error) {
+          if (rafId) {
+            cancelAnimationFrame(rafId);
+            rafId = null;
+          }
+          this._currentAbortController = null;
+          reject(error);
+        }
+      };
+      rafId = requestAnimationFrame(parseAndInsertNextBatch);
+    });
+  }
+  /**
+   * 使用 requestAnimationFrame 分批设置内容
+   * 每帧插入一批节点，避免长时间阻塞主线程
+   *
+   * @param allNodes - 所有要插入的节点
+   * @param batchSize - 每帧处理的节点数量
+   * @param onProgress - 进度回调函数
+   * @returns Promise，在所有节点插入完成后 resolve
+   * @private
+   */
+  _setContentWithRAF(allNodes, batchSize, onProgress) {
+    return new Promise((resolve, reject) => {
+      let currentIndex = 0;
+      const totalNodes = allNodes.length;
+      let rafId = null;
+      const insertBatch = () => {
+        try {
+          const endIndex = Math.min(currentIndex + batchSize, totalNodes);
+          const batch = allNodes.slice(currentIndex, endIndex);
+          if (currentIndex === 0) {
+            this._editor.current.children = batch;
+            this._editor.current.onChange();
+          } else {
+            this._editor.current.children.push(...batch);
+            this._editor.current.onChange();
+          }
+          currentIndex = endIndex;
+          const progress = currentIndex / totalNodes;
+          onProgress == null ? void 0 : onProgress(progress);
+          if (currentIndex < totalNodes) {
+            rafId = requestAnimationFrame(insertBatch);
+          } else {
+            ReactEditor.deselect(this._editor.current);
+            rafId = null;
+            resolve();
+          }
+        } catch (error) {
+          if (rafId) {
+            cancelAnimationFrame(rafId);
+            rafId = null;
+          }
+          reject(error);
+        }
+      };
+      rafId = requestAnimationFrame(insertBatch);
+    });
+  }
+  /**
+   * 按指定分隔符拆分 markdown 内容
+   * 保持内容结构的完整性
+   *
+   * @param md - 要拆分的 markdown 字符串
+   * @param separator - 分隔符，可以是字符串或正则表达式
+   * @returns 拆分后的字符串数组
+   * @private
+   */
+  _splitMarkdown(md, separator) {
+    return md.split(separator).filter(Boolean);
+  }
+  /**
+   * 获取当前编辑器内容作为节点列表
+   *
+   * @returns 当前编辑器内容的节点列表
+   */
+  getContent() {
+    const nodeList = this._editor.current.children;
+    return nodeList;
+  }
+  /**
+   * 获取当前编辑器内容作为 markdown 字符串
+   *
+   * @param plugins - 可选的自定义 markdown 转换插件
+   * @returns 转换为 markdown 的当前编辑器内容
+   */
+  getMDContent(plugins) {
+    const nodeList = this._editor.current.children;
+    const md = parserSlateNodeToMarkdown(
+      nodeList,
+      "",
+      [{ root: true }],
+      plugins || this.plugins
+    );
+    return md;
+  }
+  /**
+   * 获取当前编辑器内容作为 HTML 字符串
+   *
+   * @returns 转换为 HTML 的当前编辑器内容
+   */
+  getHtmlContent() {
+    const markdown = this.getMDContent();
+    return markdownToHtmlSync(markdown);
+  }
+  /**
+   * 使用节点列表设置编辑器内容
+   *
+   * @param nodeList - 要设置为编辑器内容的节点列表
+   */
+  setContent(nodeList) {
+    this._editor.current.children = nodeList;
+    this._editor.current.onChange();
+    const lastNode = nodeList[nodeList.length - 1];
+    if (lastNode && Text.isText(lastNode)) {
+      const text = Node.string(lastNode);
+      if (!text.endsWith("\n")) {
+        this._editor.current.insertText("\n", {
+          at: [nodeList.length - 1]
+        });
+      }
+    }
+  }
+  /**
+   * 使用差异检测和操作队列优化更新节点列表。
+   *
+   * @param nodeList - 新的节点列表
+   *
+   * 优化步骤：
+   * 1. 过滤无效节点
+   * 2. 生成差异操作
+   * 3. 执行优化后的操作
+   * 4. 处理可能的错误情况
+   *
+   * 过滤规则：
+   * - 移除空的段落节点
+   * - 移除空的列表节点
+   * - 移除空的列表项节点
+   * - 移除无效的代码块节点
+   * - 移除无源的图片节点
+   *
+   * 错误处理：
+   * - 如果优化更新失败，会回退到直接替换整个节点列表
+   * - 错误信息会被记录到控制台
+   */
+  updateNodeList(nodeList) {
+    if (!nodeList || !Array.isArray(nodeList))
+      return;
+    const filteredNodes = nodeList.filter((item) => {
+      if (!item)
+        return false;
+      if (item.type === "p" && (!item.children || item.children.length === 0))
+        return false;
+      if (item.type === "list" && (!item.children || item.children.length === 0))
+        return false;
+      if (item.type === "listItem" && (!item.children || item.children.length === 0))
+        return false;
+      if (item.type === "code" && item.language === "code" && (!item.otherProps || item.otherProps.length === 0))
+        return false;
+      if (item.type === "image" && !item.src)
+        return false;
+      return true;
+    });
+    try {
+      const operations = this.generateDiffOperations(
+        filteredNodes,
+        this._editor.current.children
+      );
+      if (operations.length > 0) {
+        this.executeOperations(operations);
+      }
+    } catch (error) {
+      console.error("Failed to update nodes with optimized method:", error);
+      this._editor.current.children = nodeList;
+    }
+  }
+  /**
+   * 生成两个节点列表之间的差异操作队列。
+   *
+   * @param newNodes - 新的节点列表
+   * @param oldNodes - 旧的节点列表
+   * @returns 包含所有需要执行的操作的队列
+   *
+   * 该方法通过以下步骤生成差异：
+   * 1. 处理节点数量不同的情况
+   * 2. 对共有节点进行深度比较
+   * 3. 生成最小化的操作序列
+   * 4. 根据优先级排序操作
+   */
+  generateDiffOperations(newNodes, oldNodes) {
+    if (!newNodes || !oldNodes)
+      return [];
+    const operations = [];
+    const lengthDiff = newNodes.length - oldNodes.length;
+    if (lengthDiff > 0) {
+      for (let i = oldNodes.length; i < newNodes.length; i++) {
+        operations.push({
+          type: "insert",
+          path: [i],
+          node: newNodes[i],
+          priority: 10
+          // 新增节点优先级较低
+        });
+      }
+    } else if (lengthDiff < 0) {
+      for (let i = oldNodes.length - 1; i >= newNodes.length; i--) {
+        operations.push({
+          type: "remove",
+          path: [i],
+          priority: 0
+          // 删除操作优先级最高
+        });
+      }
+    }
+    const minLength = Math.min(newNodes.length, oldNodes.length);
+    for (let i = 0; i < minLength; i++) {
+      const newNode = newNodes[i];
+      const oldNode = oldNodes[i];
+      this.compareNodes(newNode, oldNode, [i], operations);
+    }
+    return operations.sort((a, b) => a.priority - b.priority);
+  }
+  /**
+   * 递归比较两个节点及其子节点的差异。
+   *
+   * @param newNode - 新节点
+   * @param oldNode - 旧节点
+   * @param path - 当前节点的路径
+   * @param operations - 操作队列，用于存储发现的差异操作
+   *
+   * 比较过程包括：
+   * 1. 检查节点类型是否相同
+   * 2. 特殊处理表格节点
+   * 3. 比较文本节点内容
+   * 4. 比较节点属性
+   * 5. 递归比较子节点
+   * @private
+   */
+  compareNodes(newNode, oldNode, path, operations) {
+    if (newNode.type !== oldNode.type) {
+      operations.push({
+        type: "replace",
+        path,
+        node: newNode,
+        priority: 5
+      });
+      return;
+    }
+    if (newNode.type === "table") {
+      this.compareTableNodes(newNode, oldNode, path, operations);
+      return;
+    }
+    if (typeof newNode.text === "string" && typeof oldNode.text === "string") {
+      if (newNode.text !== oldNode.text) {
+        operations.push({
+          type: "text",
+          path,
+          text: newNode.text,
+          priority: 8
+        });
+      }
+      const newProps2 = __spreadValues({}, newNode);
+      const oldProps2 = __spreadValues({}, oldNode);
+      delete newProps2.text;
+      delete oldProps2.text;
+      if (!isEqual(newProps2, oldProps2)) {
+        operations.push({
+          type: "update",
+          path,
+          properties: newProps2,
+          priority: 7
+        });
+      }
+      return;
+    }
+    const newProps = __spreadProps(__spreadValues({}, newNode), { children: void 0 });
+    const oldProps = __spreadProps(__spreadValues({}, oldNode), { children: void 0 });
+    if (!isEqual(newProps, oldProps)) {
+      operations.push({
+        type: "update",
+        path,
+        properties: newProps,
+        priority: 7
+      });
+    }
+    if (newNode.children && oldNode.children) {
+      const childrenOps = this.generateDiffOperations(
+        newNode.children,
+        oldNode.children
+      );
+      childrenOps.forEach((op) => {
+        operations.push(__spreadProps(__spreadValues({}, op), {
+          path: [...path, ...op.path]
+        }));
+      });
+    }
+  }
+  /**
+   * 特殊处理表格节点的比较。
+   *
+   * @param newTable - 新的表格节点
+   * @param oldTable - 旧的表格节点
+   * @param path - 表格节点的路径
+   * @param operations - 操作队列
+   *
+   * 处理步骤：
+   * 1. 检查表格结构是否相同
+   * 2. 比较表格属性
+   * 3. 逐行比较和更新
+   * 4. 处理行数变化
+   * 5. 必要时进行整表替换
+   * @private
+   */
+  compareTableNodes(newTable, oldTable, path, operations) {
+    const newRows = newTable.children || [];
+    const oldRows = oldTable.children || [];
+    const isSameTableStructure = () => {
+      if (newTable.id && oldTable.id) {
+        return newTable.id === oldTable.id;
+      }
+      if (newRows.length === oldRows.length) {
+        for (let i = 0; i < newRows.length; i++) {
+          const newRow = newRows[i];
+          const oldRow = oldRows[i];
+          if (!newRow.children || !oldRow.children || newRow.children.length !== oldRow.children.length) {
+            return false;
+          }
+        }
+        return true;
+      }
+      return false;
+    };
+    const tablePropsChanged = () => {
+      const newProps = __spreadValues({}, newTable);
+      const oldProps = __spreadValues({}, oldTable);
+      delete newProps.children;
+      delete oldProps.children;
+      return !isEqual(newProps, oldProps);
+    };
+    if (isSameTableStructure()) {
+      if (tablePropsChanged()) {
+        const newTableProps = __spreadProps(__spreadValues({}, newTable), { children: void 0 });
+        operations.push({
+          type: "update",
+          path,
+          properties: newTableProps,
+          priority: 7
+        });
+      }
+      for (let rowIdx = 0; rowIdx < newRows.length; rowIdx++) {
+        const rowPath = [...path, rowIdx];
+        const newRow = newRows[rowIdx];
+        const oldRow = oldRows[rowIdx];
+        const newRowProps = __spreadProps(__spreadValues({}, newRow), { children: void 0 });
+        const oldRowProps = __spreadProps(__spreadValues({}, oldRow), { children: void 0 });
+        if (!isEqual(newRowProps, oldRowProps)) {
+          operations.push({
+            type: "update",
+            path: rowPath,
+            properties: newRowProps,
+            priority: 7
+          });
+        }
+        const newCells = newRow.children || [];
+        const oldCells = oldRow.children || [];
+        const minCellCount = Math.min(newCells.length, oldCells.length);
+        for (let cellIdx = 0; cellIdx < minCellCount; cellIdx++) {
+          const cellPath = [...rowPath, cellIdx];
+          const newCell = newCells[cellIdx];
+          const oldCell = oldCells[cellIdx];
+          this.compareCells(newCell, oldCell, cellPath, operations);
+        }
+        if (newCells.length > oldCells.length) {
+          for (let cellIdx = oldCells.length; cellIdx < newCells.length; cellIdx++) {
+            operations.push({
+              type: "insert",
+              path: [...rowPath, cellIdx],
+              node: newCells[cellIdx],
+              priority: 6
+            });
+          }
+        } else if (newCells.length < oldCells.length) {
+          for (let cellIdx = oldCells.length - 1; cellIdx >= newCells.length; cellIdx--) {
+            operations.push({
+              type: "remove",
+              path: [...rowPath, cellIdx],
+              priority: 1
+            });
+          }
+        }
+      }
+    } else {
+      if (Math.abs(newRows.length - oldRows.length) <= 2) {
+        if (tablePropsChanged()) {
+          operations.push({
+            type: "update",
+            path,
+            properties: __spreadProps(__spreadValues({}, newTable), { children: void 0 }),
+            priority: 7
+          });
+        }
+        const minRowCount = Math.min(newRows.length, oldRows.length);
+        for (let rowIdx = 0; rowIdx < minRowCount; rowIdx++) {
+          const rowPath = [...path, rowIdx];
+          this.compareNodes(
+            newRows[rowIdx],
+            oldRows[rowIdx],
+            rowPath,
+            operations
+          );
+        }
+        if (newRows.length > oldRows.length) {
+          for (let rowIdx = oldRows.length; rowIdx < newRows.length; rowIdx++) {
+            operations.push({
+              type: "insert",
+              path: [...path, rowIdx],
+              node: newRows[rowIdx],
+              priority: 5
+            });
+          }
+        } else if (newRows.length < oldRows.length) {
+          for (let rowIdx = oldRows.length - 1; rowIdx >= newRows.length; rowIdx--) {
+            operations.push({
+              type: "remove",
+              path: [...path, rowIdx],
+              priority: 1
+            });
+          }
+        }
+      } else {
+        operations.push({
+          type: "replace",
+          path,
+          node: newTable,
+          priority: 5
+        });
+      }
+    }
+  }
+  /**
+   * 比较和更新表格单元格。
+   *
+   * @param newCell - 新的单元格节点
+   * @param oldCell - 旧的单元格节点
+   * @param path - 单元格的路径
+   * @param operations - 操作队列
+   *
+   * 处理步骤：
+   * 1. 检查单元格属性变化
+   * 2. 处理简单文本单元格
+   * 3. 处理复杂单元格内容
+   * 4. 生成适当的更新操作
+   * @private
+   */
+  compareCells(newCell, oldCell, path, operations) {
+    const newCellProps = __spreadProps(__spreadValues({}, newCell), { children: void 0 });
+    const oldCellProps = __spreadProps(__spreadValues({}, oldCell), { children: void 0 });
+    if (!isEqual(newCellProps, oldCellProps)) {
+      operations.push({
+        type: "update",
+        path,
+        properties: newCellProps,
+        priority: 7
+      });
+    }
+    const newChildren = newCell.children || [];
+    const oldChildren = oldCell.children || [];
+    if (newChildren.length === 1 && oldChildren.length === 1 && typeof newChildren[0].text === "string" && typeof oldChildren[0].text === "string") {
+      if (newChildren[0].text !== oldChildren[0].text) {
+        operations.push({
+          type: "text",
+          path: [...path, 0],
+          text: newChildren[0].text,
+          priority: 8
+        });
+      }
+      const newTextProps = __spreadValues({}, newChildren[0]);
+      const oldTextProps = __spreadValues({}, oldChildren[0]);
+      delete newTextProps.text;
+      delete oldTextProps.text;
+      if (!isEqual(newTextProps, oldTextProps)) {
+        operations.push({
+          type: "update",
+          path: [...path, 0],
+          properties: newTextProps,
+          priority: 7
+        });
+      }
+    } else {
+      const structurallyDifferent = newChildren.length !== oldChildren.length || newChildren.some(
+        (n, i) => oldChildren[i] && n.type !== oldChildren[i].type
+      );
+      if (structurallyDifferent) {
+        const childOps = this.generateDiffOperations(newChildren, oldChildren);
+        childOps.forEach((op) => {
+          operations.push(__spreadProps(__spreadValues({}, op), {
+            path: [...path, ...op.path]
+          }));
+        });
+      } else {
+        for (let i = 0; i < Math.min(newChildren.length, oldChildren.length); i++) {
+          this.compareNodes(
+            newChildren[i],
+            oldChildren[i],
+            [...path, i],
+            operations
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 执行操作队列中的所有操作。
+   *
+   * @param operations - 要执行的操作队列
+   *
+   * 执行过程：
+   * 1. 使用批处理模式执行所有操作
+   * 2. 按照操作类型分别处理
+   * 3. 处理可能的错误情况
+   * 4. 保证操作的原子性
+   */
+  executeOperations(operations) {
+    const editor = this._editor.current;
+    if (!editor)
+      return;
+    Editor.withoutNormalizing(editor, () => {
+      for (const op of operations) {
+        try {
+          switch (op.type) {
+            case "insert":
+              if (op.node && editor.hasPath(Path.parent(op.path))) {
+                Transforms.insertNodes(editor, op.node, { at: op.path });
+              }
+              break;
+            case "remove":
+              if (editor.hasPath(op.path)) {
+                Transforms.removeNodes(editor, { at: op.path });
+              }
+              break;
+            case "update":
+              if (op.properties && editor.hasPath(op.path)) {
+                Transforms.setNodes(editor, op.properties, { at: op.path });
+              }
+              break;
+            case "replace":
+              if (op.node && editor.hasPath(op.path)) {
+                Transforms.removeNodes(editor, { at: op.path });
+                Transforms.insertNodes(editor, op.node, { at: op.path });
+              }
+              break;
+            case "text":
+              if (op.text !== void 0 && editor.hasPath(op.path)) {
+                Transforms.insertText(editor, op.text, {
+                  at: op.path,
+                  voids: true
+                });
+              }
+              break;
+          }
+        } catch (err) {
+          console.error(
+            `Error executing operation ${op.type} at path ${op.path}:`,
+            err
+          );
+        }
+      }
+    });
+  }
+  /**
+   * 处理拖拽开始事件。
+   *
+   * @param e - React 拖拽事件对象
+   * @param container - 容器 div 元素
+   *
+   * 此方法会在拖拽开始时调用，主要功能包括：
+   * 1. 阻止事件传播
+   * 2. 设置拖拽图像
+   * 3. 初始化拖拽相关的元素和位置数据
+   * 4. 添加拖拽过程中和拖拽结束时的事件监听器
+   * 5. 计算可拖拽目标的位置
+   * 6. 处理拖拽过程中的视觉反馈
+   * 7. 在拖拽结束时更新编辑器内容
+   */
+  dragStart(e, container) {
+    var _a, _b, _c;
+    e.stopPropagation();
+    const img = document.createElement("img");
+    img.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
+    e.dataTransfer.setDragImage(img, 1, 1);
+    const ableToEnter = ((_b = (_a = this.draggedElement) == null ? void 0 : _a.dataset) == null ? void 0 : _b.be) === "list-item" ? /* @__PURE__ */ new Set([
+      "paragraph",
+      "head",
+      "blockquote",
+      "code",
+      "table",
+      "list",
+      "list-item",
+      "media",
+      "attach"
+    ]) : this.ableToEnter;
+    let mark = null;
+    const els = document.querySelectorAll("[data-be]");
+    const points = [];
+    for (let el of els) {
+      if (!ableToEnter.has(el.dataset.be))
+        continue;
+      if (el.classList.contains("frontmatter"))
+        continue;
+      const pre = el.previousSibling;
+      if (el.dataset.be === "paragraph" && ((_c = this.draggedElement) == null ? void 0 : _c.dataset.be) === "list-item" && (!pre || pre.classList.contains("check-item"))) {
+        continue;
+      }
+      if (el === this.draggedElement)
+        continue;
+      const top = getOffsetTop(el, container);
+      const left = getOffsetLeft(el, container);
+      points.push({
+        el,
+        direction: "top",
+        left,
+        top
+      });
+      points.push({
+        el,
+        left,
+        direction: "bottom",
+        top: top + el.clientHeight + 2
+      });
+    }
+    let last = null;
+    const dragover = (e2) => {
+      e2.preventDefault();
+      const top = e2.clientY - 40 + container.scrollTop;
+      let distance = 1e6;
+      let cur = null;
+      for (let p of points) {
+        let curDistance = Math.abs(p.top - top);
+        if (curDistance < distance) {
+          cur = p;
+          distance = curDistance;
+        }
+      }
+      if (cur) {
+        const rect = container.getBoundingClientRect();
+        const scrollTop = container.scrollTop;
+        const scrollLeft = container.scrollLeft;
+        last = cur;
+        const width = last.el.dataset.be === "list-item" ? last.el.clientWidth + 20 + "px" : last.el.clientWidth + "px";
+        if (!mark) {
+          mark = document.createElement("div");
+          mark.classList.add("move-mark");
+          mark.style.width = width;
+          mark.style.height = "2px";
+          mark.style.transform = `translate(${last.left - rect.left - scrollLeft}px, ${last.top - rect.top - scrollTop}px)`;
+          container == null ? void 0 : container.parentElement.append(mark);
+        } else {
+          mark.style.width = width;
+          mark.style.transform = `translate(${last.left - rect.left - scrollLeft}px, ${last.top - rect.top - scrollTop}px)`;
+        }
+      }
+    };
+    window.addEventListener("dragover", dragover);
+    window.addEventListener(
+      "dragend",
+      () => {
+        var _a2, _b2;
+        try {
+          window.removeEventListener("dragover", dragover);
+          if (mark)
+            container == null ? void 0 : container.parentElement.removeChild(mark);
+          if (last && this.draggedElement) {
+            let [dragPath, dragNode] = this.toPath(this.draggedElement);
+            let [targetPath] = this.toPath(last.el);
+            let toPath = last.direction === "top" ? targetPath : Path.next(targetPath);
+            if (!Path.equals(targetPath, dragPath)) {
+              const parent = Node.parent(this._editor.current, dragPath);
+              if (Path.equals(Path.parent(targetPath), Path.parent(dragPath)) && Path.compare(dragPath, targetPath) === -1) {
+                toPath = Path.previous(toPath);
+              }
+              let delPath = Path.parent(dragPath);
+              const targetNode = Node.get(this._editor.current, targetPath);
+              if (dragNode.type === "list-item") {
+                if (targetNode.type !== "list-item") {
+                  Transforms.delete(this._editor.current, { at: dragPath });
+                  Transforms.insertNodes(
+                    this._editor.current,
+                    __spreadProps(__spreadValues({}, parent), {
+                      children: [EditorUtils.copy(dragNode)]
+                    }),
+                    { at: toPath, select: true }
+                  );
+                  if (((_a2 = parent.children) == null ? void 0 : _a2.length) === 1) {
+                    if (EditorUtils.isNextPath(Path.parent(dragPath), targetPath)) {
+                      delPath = Path.next(Path.parent(dragPath));
+                    } else {
+                      delPath = Path.parent(dragPath);
+                    }
+                  }
+                } else {
+                  Transforms.moveNodes(this._editor.current, {
+                    at: dragPath,
+                    to: toPath
+                  });
+                }
+              } else {
+                Transforms.moveNodes(this._editor.current, {
+                  at: dragPath,
+                  to: toPath
+                });
+              }
+              if (((_b2 = parent.children) == null ? void 0 : _b2.length) === 1) {
+                if (Path.equals(Path.parent(toPath), Path.parent(delPath)) && Path.compare(toPath, delPath) !== 1) {
+                  delPath = Path.next(delPath);
+                }
+                Transforms.delete(this._editor.current, { at: delPath });
+              }
+            }
+            if ((dragNode == null ? void 0 : dragNode.type) !== "media")
+              this.draggedElement.draggable = false;
+          }
+          this.draggedElement = null;
+        } catch (error) {
+          console.error(error);
+        }
+      },
+      { once: true }
+    );
+  }
+  /**
+   * 替换编辑器中的文本内容
+   *
+   * @param searchText - 要查找和替换的原始文本
+   * @param replaceText - 替换后的新文本
+   * @param options - 可选参数
+   * @param options.caseSensitive - 是否区分大小写，默认为 false
+   * @param options.wholeWord - 是否只匹配完整单词，默认为 false
+   * @param options.replaceAll - 是否替换所有匹配项，默认为 true
+   *
+   * @returns 替换操作的数量
+   *
+   * @example
+   * ```ts
+   * // 替换所有 "old" 为 "new"
+   * const count = store.replaceText("old", "new");
+   *
+   * // 只替换第一个匹配项，区分大小写
+   * const count = store.replaceText("Old", "New", {
+   *   caseSensitive: true,
+   *   replaceAll: false
+   * });
+   * ```
+   */
+  replaceText(searchText, replaceText, options = {}) {
+    const {
+      caseSensitive = false,
+      wholeWord = false,
+      replaceAll = true
+    } = options;
+    if (!searchText)
+      return 0;
+    const editor = this._editor.current;
+    let replaceCount = 0;
+    const textNodes = Array.from(
+      Editor.nodes(editor, {
+        at: [],
+        match: (n) => Text.isText(n) && typeof n.text === "string"
+      })
+    );
+    Editor.withoutNormalizing(editor, () => {
+      if (replaceAll) {
+        for (let i = textNodes.length - 1; i >= 0; i--) {
+          const [node, path] = textNodes[i];
+          const originalText = node.text;
+          let newText = originalText;
+          let nodeReplaceCount = 0;
+          if (caseSensitive) {
+            if (wholeWord) {
+              const regex = new RegExp(
+                `\\b${this.escapeRegExp(searchText)}\\b`,
+                "g"
+              );
+              newText = originalText.replace(regex, () => {
+                nodeReplaceCount++;
+                return replaceText;
+              });
+            } else {
+              newText = originalText.replace(
+                new RegExp(this.escapeRegExp(searchText), "g"),
+                () => {
+                  nodeReplaceCount++;
+                  return replaceText;
+                }
+              );
+            }
+          } else {
+            if (wholeWord) {
+              const regex = new RegExp(
+                `\\b${this.escapeRegExp(searchText)}\\b`,
+                "gi"
+              );
+              newText = originalText.replace(regex, () => {
+                nodeReplaceCount++;
+                return replaceText;
+              });
+            } else {
+              newText = originalText.replace(
+                new RegExp(this.escapeRegExp(searchText), "gi"),
+                () => {
+                  nodeReplaceCount++;
+                  return replaceText;
+                }
+              );
+            }
+          }
+          if (newText !== originalText) {
+            Transforms.insertText(editor, newText, {
+              at: path,
+              voids: true
+            });
+            replaceCount += nodeReplaceCount;
+          }
+        }
+      } else {
+        for (let i = 0; i < textNodes.length; i++) {
+          const [node, path] = textNodes[i];
+          const originalText = node.text;
+          let newText = originalText;
+          let nodeReplaceCount = 0;
+          if (caseSensitive) {
+            if (wholeWord) {
+              const regex = new RegExp(
+                `\\b${this.escapeRegExp(searchText)}\\b`,
+                ""
+              );
+              newText = originalText.replace(regex, () => {
+                nodeReplaceCount++;
+                return replaceText;
+              });
+            } else {
+              newText = originalText.replace(
+                new RegExp(this.escapeRegExp(searchText), ""),
+                () => {
+                  nodeReplaceCount++;
+                  return replaceText;
+                }
+              );
+            }
+          } else {
+            if (wholeWord) {
+              const regex = new RegExp(
+                `\\b${this.escapeRegExp(searchText)}\\b`,
+                "i"
+              );
+              newText = originalText.replace(regex, () => {
+                nodeReplaceCount++;
+                return replaceText;
+              });
+            } else {
+              newText = originalText.replace(
+                new RegExp(this.escapeRegExp(searchText), "i"),
+                () => {
+                  nodeReplaceCount++;
+                  return replaceText;
+                }
+              );
+            }
+          }
+          if (newText !== originalText) {
+            Transforms.insertText(editor, newText, {
+              at: path,
+              voids: true
+            });
+            replaceCount += nodeReplaceCount;
+            break;
+          }
+        }
+      }
+    });
+    return replaceCount;
+  }
+  /**
+   * 在选中的区域内替换文本
+   *
+   * @param searchText - 要查找和替换的原始文本
+   * @param replaceText - 替换后的新文本
+   * @param options - 可选参数
+   * @param options.caseSensitive - 是否区分大小写，默认为 false
+   * @param options.wholeWord - 是否只匹配完整单词，默认为 false
+   * @param options.replaceAll - 是否替换所有匹配项，默认为 true
+   *
+   * @returns 替换操作的数量，如果没有选中区域则返回 0
+   *
+   * @example
+   * ```ts
+   * // 在选中区域内替换文本
+   * const count = store.replaceTextInSelection("old", "new");
+   * ```
+   */
+  replaceTextInSelection(searchText, replaceText, options = {}) {
+    const editor = this._editor.current;
+    const selection = editor.selection;
+    if (!selection || Range.isCollapsed(selection)) {
+      return 0;
+    }
+    const {
+      caseSensitive = false,
+      wholeWord = false,
+      replaceAll = true
+    } = options;
+    if (!searchText)
+      return 0;
+    let replaceCount = 0;
+    const textNodes = Array.from(
+      Editor.nodes(editor, {
+        at: selection,
+        match: (n) => Text.isText(n) && typeof n.text === "string"
+      })
+    );
+    Editor.withoutNormalizing(editor, () => {
+      for (let i = textNodes.length - 1; i >= 0; i--) {
+        const [node, path] = textNodes[i];
+        const originalText = node.text;
+        let newText = originalText;
+        let nodeReplaceCount = 0;
+        if (caseSensitive) {
+          if (wholeWord) {
+            const regex = new RegExp(
+              `\\b${this.escapeRegExp(searchText)}\\b`,
+              "g"
+            );
+            newText = originalText.replace(regex, () => {
+              nodeReplaceCount++;
+              return replaceText;
+            });
+          } else {
+            newText = originalText.replace(
+              new RegExp(this.escapeRegExp(searchText), "g"),
+              () => {
+                nodeReplaceCount++;
+                return replaceText;
+              }
+            );
+          }
+        } else {
+          if (wholeWord) {
+            const regex = new RegExp(
+              `\\b${this.escapeRegExp(searchText)}\\b`,
+              "gi"
+            );
+            newText = originalText.replace(regex, () => {
+              nodeReplaceCount++;
+              return replaceText;
+            });
+          } else {
+            newText = originalText.replace(
+              new RegExp(this.escapeRegExp(searchText), "gi"),
+              () => {
+                nodeReplaceCount++;
+                return replaceText;
+              }
+            );
+          }
+        }
+        if (newText !== originalText) {
+          Transforms.insertText(editor, newText, {
+            at: path,
+            voids: true
+          });
+          replaceCount += nodeReplaceCount;
+          if (!replaceAll && nodeReplaceCount > 0) {
+            break;
+          }
+        }
+      }
+    });
+    return replaceCount;
+  }
+  /**
+   * 替换所有匹配的文本（replaceText 的简化版本）
+   *
+   * @param searchText - 要查找和替换的原始文本
+   * @param replaceText - 替换后的新文本
+   * @param caseSensitive - 是否区分大小写，默认为 false
+   *
+   * @returns 替换操作的数量
+   *
+   * @example
+   * ```ts
+   * // 替换所有 "old" 为 "new"
+   * const count = store.replaceAll("old", "new");
+   *
+   * // 区分大小写替换
+   * const count = store.replaceAll("Old", "New", true);
+   * ```
+   */
+  replaceAll(searchText, replaceText, caseSensitive = false) {
+    return this.replaceText(searchText, replaceText, {
+      caseSensitive,
+      replaceAll: true
+    });
+  }
+  /**
+   * 转义正则表达式特殊字符
+   *
+   * @param string - 需要转义的字符串
+   * @returns 转义后的字符串
+   * @private
+   */
+  escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * 在编辑器中根据路径描述和文本内容查找并选择匹配位置
+   *
+   * @param pathDescription - 路径描述，用于限制搜索范围。可以是：
+   *                         - 节点类型（如 "paragraph", "table", "list"）
+   *                         - 包含特定文本的节点区域
+   *                         - 空字符串表示在整个编辑器中搜索
+   * @param searchText - 要查找的文本内容
+   * @param options - 查找选项
+   * @returns 匹配结果数组
+   *
+   * @example
+   * ```ts
+   * // 查找所有包含 "focus" 的位置
+   * const results = store.findByPathAndText("", "focus");
+   */
+  findByPathAndText(pathDescription, searchText, options = {}) {
+    const {
+      caseSensitive = false,
+      wholeWord = false,
+      maxResults = 50
+    } = options;
+    if (!searchText.trim())
+      return [];
+    const editor = this._editor.current;
+    return findByPathAndText(editor, pathDescription, searchText, {
+      caseSensitive,
+      wholeWord,
+      maxResults
+    });
+  }
+  /**
+   * 更新编辑器的状态数据
+   *
+   * @param value - 状态更新器，可以是函数或对象
+   *
+   * 该方法提供两种更新状态的方式：
+   * 1. 函数式更新：传入一个函数，可以直接修改状态
+   * 2. 对象式更新：传入一个对象，直接覆盖对应的状态值
+   *
+   * @example
+   * ```ts
+   * // 函数式更新 - 可以访问当前状态
+   * setState((state) => {
+   *   state.focus = true;
+   *   state.manual = false;
+   * });
+   *
+   * // 对象式更新 - 直接设置新值
+   * setState({
+   *   focus: true,
+   *   manual: false
+   * });
+   * ```
+   */
+  setState(value) {
+    if (value instanceof Function) {
+      value(this);
+    } else {
+      for (let key of Object.keys(value)) {
+        this[key] = value[key];
+      }
+    }
+  }
+};
+export {
+  EditorStore,
+  EditorStoreContext,
+  useEditorStore
+};