@ctzhian/tiptap 1.5.2 → 1.5.3

package/dist/util/fileHandler.js

@@ -0,0 +1,79 @@
+// 判断文件类型
+export var getFileType = function getFileType(file) {
+  var type = file.type;
+  if (type.startsWith('image/')) {
+    return 'image';
+  }
+  if (type.startsWith('video/')) {
+    return 'video';
+  }
+  return 'other';
+};
+
+// 格式化文件大小
+export var formatFileSize = function formatFileSize(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  var k = 1024;
+  var sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  var i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+};
+
+// 获取文件图标
+export var getFileIcon = function getFileIcon(fileName) {
+  var _fileName$split$pop;
+  var extension = (_fileName$split$pop = fileName.split('.').pop()) === null || _fileName$split$pop === void 0 ? void 0 : _fileName$split$pop.toLowerCase();
+  switch (extension) {
+    case 'pdf':
+      return '📄';
+    case 'doc':
+    case 'docx':
+      return '📝';
+    case 'xls':
+    case 'xlsx':
+      return '📊';
+    case 'ppt':
+    case 'pptx':
+      return '📋';
+    case 'zip':
+    case 'rar':
+    case '7z':
+      return '🗜️';
+    case 'txt':
+      return '📄';
+    case 'mp3':
+    case 'wav':
+    case 'flac':
+      return '🎵';
+    default:
+      return '📎';
+  }
+};
+
+// 插入图片内容
+export var insertImageContent = function insertImageContent(editor, url, pos) {
+  editor.chain().focus().insertContentAt(pos, {
+    type: 'image',
+    attrs: {
+      src: url
+    }
+  }).run();
+};
+
+// 插入视频内容
+export var insertVideoContent = function insertVideoContent(editor, url, pos) {
+  editor.chain().focus().insertContentAt(pos, {
+    type: 'video',
+    attrs: {
+      src: url
+    }
+  }).run();
+};
+
+// 插入附件内容
+export var insertAttachmentContent = function insertAttachmentContent(editor, url, fileName, fileSize, pos) {
+  var icon = getFileIcon(fileName);
+  var size = formatFileSize(fileSize);
+  var attachmentHtml = "\n    <div style=\"border: 1px solid #e1e5e9; border-radius: 8px; padding: 12px; margin: 8px 0; background-color: #f8f9fa; display: flex; align-items: center; gap: 12px; max-width: 400px;\">\n      <span style=\"font-size: 24px;\">".concat(icon, "</span>\n      <div style=\"flex: 1; min-width: 0;\">\n        <div style=\"font-weight: 500; color: #1f2937; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;\">\n          <a href=\"").concat(url, "\" target=\"_blank\" style=\"color: #3b82f6; text-decoration: none;\">").concat(fileName, "</a>\n        </div>\n        <div style=\"font-size: 12px; color: #6b7280; margin-top: 2px;\">").concat(size, "</div>\n      </div>\n      <div style=\"color: #6b7280;\">\n        <svg width=\"16\" height=\"16\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\">\n          <path d=\"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4\"></path>\n          <polyline points=\"7,10 12,15 17,10\"></polyline>\n          <line x1=\"12\" y1=\"15\" x2=\"12\" y2=\"3\"></line>\n        </svg>\n      </div>\n    </div>\n  ");
+  editor.chain().focus().insertContentAt(pos, attachmentHtml).run();
+};

package/dist/util/floating.d.ts

@@ -0,0 +1,3 @@
+import { Strategy } from "@floating-ui/dom";
+import { Editor } from "@tiptap/core";
+export declare const updatePosition: (editor: Editor, element: HTMLElement, strategy?: Strategy) => void;

package/dist/util/floating.js

@@ -0,0 +1,23 @@
+import { computePosition, flip, shift } from "@floating-ui/dom";
+import { posToDOMRect } from "@tiptap/core";
+export var updatePosition = function updatePosition(editor, element) {
+  var strategy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'absolute';
+  var virtualElement = {
+    getBoundingClientRect: function getBoundingClientRect() {
+      return posToDOMRect(editor.view, editor.state.selection.from, editor.state.selection.to);
+    }
+  };
+  computePosition(virtualElement, element, {
+    placement: 'bottom-start',
+    strategy: strategy,
+    middleware: [shift(), flip()]
+  }).then(function (_ref) {
+    var x = _ref.x,
+      y = _ref.y,
+      strategy = _ref.strategy;
+    element.style.width = 'max-content';
+    element.style.position = strategy;
+    element.style.left = "".concat(x, "px");
+    element.style.top = "".concat(y, "px");
+  });
+};

package/dist/util/index.d.ts

@@ -0,0 +1,12 @@
+export * from './fileDownload';
+export * from './fileHandler';
+export * from './floating';
+export * from './linewiseConvert';
+export * from './migrateMathStrings';
+export * from './resourceExtractor';
+export * from './shortcutKey';
+import { Editor } from '@tiptap/react';
+export declare const formatFileSize: (bytes: number) => string;
+export declare const insertNodeAfterPosition: (editor: Editor, pos: number, nodeContent: any) => void;
+export declare function addOpacityToColor(color: string, opacity: number): string;
+export declare const getLinkTitle: (href: string) => string;

package/dist/util/index.js

@@ -0,0 +1,40 @@
+export * from "./fileDownload";
+export * from "./fileHandler";
+export * from "./floating";
+export * from "./linewiseConvert";
+export * from "./migrateMathStrings";
+export * from "./resourceExtractor";
+export * from "./shortcutKey";
+export var formatFileSize = function formatFileSize(bytes) {
+  if (bytes === 0) return '0 B';
+  var k = 1024;
+  var sizes = ['B', 'KB', 'MB', 'GB'];
+  var i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+};
+export var insertNodeAfterPosition = function insertNodeAfterPosition(editor, pos, nodeContent) {
+  editor.chain().focus().insertContentAt(pos, nodeContent).run();
+};
+export function addOpacityToColor(color, opacity) {
+  var red, green, blue;
+  if (color.startsWith("#")) {
+    red = parseInt(color.slice(1, 3), 16);
+    green = parseInt(color.slice(3, 5), 16);
+    blue = parseInt(color.slice(5, 7), 16);
+  } else if (color.startsWith("rgb")) {
+    var matches = color.match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+    red = parseInt(matches[1], 10);
+    green = parseInt(matches[2], 10);
+    blue = parseInt(matches[3], 10);
+  } else {
+    return "";
+  }
+  var alpha = opacity;
+  return "rgba(".concat(red, ", ").concat(green, ", ").concat(blue, ", ").concat(alpha, ")");
+}
+export var getLinkTitle = function getLinkTitle(href) {
+  var paths = href.split('/').filter(function (it) {
+    return it.trim().length > 0;
+  });
+  return paths[paths.length - 1];
+};

package/dist/util/linewiseConvert.d.ts

@@ -0,0 +1,40 @@
+import { Fragment, Node as PMNode } from '@tiptap/pm/model';
+import { Editor } from '@tiptap/react';
+export type LinewiseTarget = {
+    type: 'paragraph';
+} | {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+} | {
+    type: 'orderedList';
+} | {
+    type: 'bulletList';
+} | {
+    type: 'taskList';
+} | {
+    type: 'blockquote';
+} | {
+    type: 'alert';
+    attrs?: {
+        variant?: string;
+        type?: 'icon' | 'text';
+    };
+};
+/**
+ * 提取节点的“行”文本：
+ * - paragraph/heading：单行
+ * - blockquote：子块逐段（按段）
+ * - codeBlock：按换行
+ * - alert：按换行
+ * - list（ordered/bullet/task）：每个 listItem 作为一行（包含其文本内容）
+ * - 其他：作为单行处理
+ */
+export declare function extractLinesFromNode(node: PMNode): string[];
+/**
+ * 根据目标类型，构造对应的节点或片段。
+ */
+export declare function buildNodeFromLines(editor: Editor, lines: string[], target: LinewiseTarget): PMNode | Fragment;
+/**
+ * 将给定位置的节点转换为目标类型（按行规则）。
+ */
+export declare function convertNodeAt(editor: Editor, pos: number, node: PMNode, target: LinewiseTarget): void;

package/dist/util/linewiseConvert.js

@@ -0,0 +1,221 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { Fragment } from '@tiptap/pm/model';
+/**
+ * 提取节点的“行”文本：
+ * - paragraph/heading：单行
+ * - blockquote：子块逐段（按段）
+ * - codeBlock：按换行
+ * - alert：按换行
+ * - list（ordered/bullet/task）：每个 listItem 作为一行（包含其文本内容）
+ * - 其他：作为单行处理
+ */
+export function extractLinesFromNode(node) {
+  var type = node.type.name;
+
+  // Helper: split textContent by \n and去除首尾空白但保留空行的结构
+  var splitByNewline = function splitByNewline(text) {
+    return text.split('\n');
+  };
+  if (type === 'paragraph' || type === 'heading') {
+    return [node.textContent];
+  }
+  if (type === 'blockquote') {
+    var lines = [];
+    node.forEach(function (child) {
+      var text = child.textContent;
+      if (text.includes('\n')) {
+        lines.push.apply(lines, _toConsumableArray(splitByNewline(text)));
+      } else {
+        lines.push(text);
+      }
+    });
+    return lines;
+  }
+  if (type === 'codeBlock') {
+    return splitByNewline(node.textContent);
+  }
+  if (type === 'alert') {
+    return splitByNewline(node.textContent);
+  }
+  if (type === 'orderedList' || type === 'bulletList' || type === 'taskList') {
+    var _lines = [];
+    node.forEach(function (listItem) {
+      var text = listItem.textContent;
+      if (text.includes('\n')) {
+        _lines.push.apply(_lines, _toConsumableArray(splitByNewline(text)));
+      } else {
+        _lines.push(text);
+      }
+    });
+    return _lines;
+  }
+  return [node.textContent];
+}
+
+/**
+ * 根据目标类型，构造对应的节点或片段。
+ */
+export function buildNodeFromLines(editor, lines, target) {
+  var schema = editor.schema;
+  var createParagraph = function createParagraph(text) {
+    return schema.nodes.paragraph.create(undefined, text ? schema.text(text) : undefined);
+  };
+  var createHeading = function createHeading(text, level) {
+    return schema.nodes.heading.create({
+      level: level
+    }, text ? schema.text(text) : undefined);
+  };
+  var createListItem = function createListItem(text) {
+    return schema.nodes.listItem.create(undefined, createParagraph(text));
+  };
+  var createTaskItem = function createTaskItem(text) {
+    return schema.nodes.taskItem ? schema.nodes.taskItem.create({
+      checked: false
+    }, createParagraph(text)) : createListItem(text);
+  };
+  switch (target.type) {
+    case 'paragraph':
+      {
+        var nodes = lines.map(function (l) {
+          return createParagraph(l);
+        });
+        return Fragment.fromArray(nodes);
+      }
+    case 'heading':
+      {
+        var _nodes = lines.map(function (l) {
+          return createHeading(l, target.level);
+        });
+        return Fragment.fromArray(_nodes);
+      }
+    case 'orderedList':
+      {
+        var items = lines.map(function (l) {
+          return createListItem(l);
+        });
+        return schema.nodes.orderedList.create(undefined, Fragment.fromArray(items));
+      }
+    case 'bulletList':
+      {
+        var _items = lines.map(function (l) {
+          return createListItem(l);
+        });
+        return schema.nodes.bulletList.create(undefined, Fragment.fromArray(_items));
+      }
+    case 'taskList':
+      {
+        var _items2 = lines.map(function (l) {
+          return createTaskItem(l);
+        });
+        if (schema.nodes.taskList) {
+          return schema.nodes.taskList.create(undefined, Fragment.fromArray(_items2));
+        }
+        return schema.nodes.bulletList.create(undefined, Fragment.fromArray(_items2));
+      }
+    case 'blockquote':
+      {
+        var paragraphs = lines.map(function (l) {
+          return createParagraph(l);
+        });
+        return schema.nodes.blockquote.create(undefined, Fragment.fromArray(paragraphs));
+      }
+    case 'alert':
+      {
+        var attrs = target.attrs || {
+          variant: 'info',
+          type: 'icon'
+        };
+        // 使用 hardBreak 分隔行
+        var pieces = [];
+        lines.forEach(function (l, i) {
+          if (l) pieces.push(schema.text(l));
+          if (i < lines.length - 1) {
+            if (schema.nodes.hardBreak) {
+              pieces.push(schema.nodes.hardBreak.create());
+            } else {
+              // 退化：用文本换行符
+              pieces.push(schema.text('\n'));
+            }
+          }
+        });
+        var content = pieces.length > 0 ? Fragment.fromArray(pieces) : undefined;
+        return schema.nodes.alert.create(attrs, content);
+      }
+  }
+}
+
+/**
+ * 通用替换与派发
+ */
+function replaceRange(editor, from, to, content) {
+  var tr = editor.state.tr;
+  tr.replaceWith(from, to, content);
+  editor.view.dispatch(tr);
+  editor.view.focus();
+}
+function isContainerNode(node) {
+  var name = node.type.name;
+  return name === 'blockquote' || name === 'alert';
+}
+function isContainerTarget(target) {
+  return target.type === 'blockquote' || target.type === 'alert';
+}
+function createContainerWithContent(editor, target, content) {
+  var schema = editor.schema;
+  if (target.type === 'blockquote') {
+    return schema.nodes.blockquote.create(undefined, content);
+  }
+  if (target.type === 'alert') {
+    var attrs = target.attrs || {
+      variant: 'info',
+      type: 'icon'
+    };
+    return schema.nodes.alert.create(attrs, content);
+  }
+  throw new Error('createContainerWithContent: invalid container target');
+}
+
+/**
+ * 将给定位置的节点转换为目标类型（按行规则）。
+ */
+export function convertNodeAt(editor, pos, node, target) {
+  var from = pos;
+  var to = pos + node.nodeSize;
+  var nodeType = node.type.name;
+
+  // 规则 1：目标为容器（blockquote/alert）
+  if (isContainerTarget(target)) {
+    // 再次点击同容器 -> 拆包
+    if (target.type === 'blockquote' && nodeType === 'blockquote' || target.type === 'alert' && nodeType === 'alert') {
+      replaceRange(editor, from, to, node.content);
+      return;
+    }
+    // 容器互转：用内部内容构造目标容器，避免嵌套
+    var content = isContainerNode(node) ? node.content : Fragment.from(node);
+    var wrapper = createContainerWithContent(editor, target, content);
+    replaceRange(editor, from, to, wrapper);
+    return;
+  }
+
+  // 规则 2：当前为容器，且目标为非容器 -> 子节点逐个转换
+  if (isContainerNode(node)) {
+    var nodesToInsert = [];
+    node.forEach(function (child) {
+      var built = buildNodeFromLines(editor, extractLinesFromNode(child), target);
+      Fragment.from(built).forEach(function (n) {
+        nodesToInsert.push(n);
+      });
+    });
+    replaceRange(editor, from, to, Fragment.fromArray(nodesToInsert));
+    return;
+  }
+
+  // 其他：按行构建单节点替换
+  var replacement = buildNodeFromLines(editor, extractLinesFromNode(node), target);
+  replaceRange(editor, from, to, replacement);
+}

package/dist/util/migrateMathStrings.d.ts

@@ -0,0 +1,73 @@
+import type { Editor } from '@tiptap/core';
+import type { Transaction } from '@tiptap/pm/state';
+/**
+ * Regular expression to match LaTeX math strings wrapped in single dollar signs.
+ * This should not catch dollar signs which are not part of a math expression,
+ * like those used for currency or other purposes.
+ * It ensures that the dollar signs are not preceded or followed by digits,
+ * allowing for proper identification of inline math expressions.
+ *
+ * - `$x^2 + y^2 = z^2$` will match
+ * - `This is $inline math$ in text.` will match
+ * - `This is $100$ dollars.` will not match (as it is not a math expression)
+ * - `This is $x^2 + y^2 = z^2$ and $100$ dollars.` will match both math expressions
+ * - `$$\frac{a}{b}$$` will NOT match (block math should be handled separately)
+ */
+export declare const mathMigrationRegex: RegExp;
+/**
+ * Regular expression to match LaTeX math strings wrapped in double dollar signs.
+ * This matches block-level math expressions that should be displayed on their own line.
+ *
+ * - `$$\frac{a}{b}$$` will match
+ * - `$$\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}$$` will match
+ * - `$$100$$ dollars` will not match (as it is not a math expression)
+ */
+export declare const blockMathMigrationRegex: RegExp;
+/**
+ * Alternative approach: First find all math patterns, then classify them
+ * This is more reliable than trying to use complex regex patterns
+ */
+export declare const allMathPatternsRegex: RegExp;
+/**
+ * Creates a transaction that migrates existing math strings in the document to new math nodes.
+ * This function traverses the document and replaces LaTeX math syntax with proper math nodes,
+ * preserving the mathematical content. It handles both inline and block math expressions.
+ *
+ * Note: Math formulas inside <pre> and <code> tags are ignored to preserve code formatting.
+ *
+ * @param editor - The editor instance containing the schema and configuration
+ * @param tr - The transaction to modify with the migration operations
+ * @returns The modified transaction with math string replacements
+ *
+ * @example
+ * ```typescript
+ * const editor = new Editor({ ... })
+ * const tr = editor.state.tr
+ * const updatedTr = createMathMigrateTransaction(editor, tr)
+ * editor.view.dispatch(updatedTr)
+ * ```
+ */
+export declare function createMathMigrateTransaction(editor: Editor, tr: Transaction): Transaction;
+/**
+ * Migrates existing math strings in the editor document to math nodes.
+ * This function creates and dispatches a transaction that converts LaTeX math syntax
+ * into proper math nodes. It handles both inline math (single dollar signs) and
+ * block math (double dollar signs). The migration happens immediately and is not
+ * added to the editor's history.
+ *
+ * Note: Math formulas inside <pre> and <code> tags are ignored to preserve code formatting.
+ *
+ * @param editor - The editor instance to perform the migration on
+ *
+ * @example
+ * ```typescript
+ * const editor = new Editor({
+ *   extensions: [Mathematics],
+ *   content: 'This is inline math: $x^2 + y^2 = z^2$ and block math: $$\frac{a}{b}$$'
+ * })
+ *
+ * // Math strings will be automatically migrated to math nodes
+ * migrateMathStrings(editor)
+ * ```
+ */
+export declare function migrateMathStrings(editor: Editor): void;

package/dist/util/migrateMathStrings.js

@@ -0,0 +1,192 @@
+/**
+ * Regular expression to match LaTeX math strings wrapped in single dollar signs.
+ * This should not catch dollar signs which are not part of a math expression,
+ * like those used for currency or other purposes.
+ * It ensures that the dollar signs are not preceded or followed by digits,
+ * allowing for proper identification of inline math expressions.
+ *
+ * - `$x^2 + y^2 = z^2$` will match
+ * - `This is $inline math$ in text.` will match
+ * - `This is $100$ dollars.` will not match (as it is not a math expression)
+ * - `This is $x^2 + y^2 = z^2$ and $100$ dollars.` will match both math expressions
+ * - `$$\frac{a}{b}$$` will NOT match (block math should be handled separately)
+ */
+export var mathMigrationRegex = /\$(?!\d+\$)(?!\$)(.+?)(?<!\$)\$(?!\d)(?!\$)/g;
+
+/**
+ * Regular expression to match LaTeX math strings wrapped in double dollar signs.
+ * This matches block-level math expressions that should be displayed on their own line.
+ *
+ * - `$$\frac{a}{b}$$` will match
+ * - `$$\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}$$` will match
+ * - `$$100$$ dollars` will not match (as it is not a math expression)
+ */
+export var blockMathMigrationRegex = /\$\$([^$]+)\$\$/g;
+
+/**
+ * Alternative approach: First find all math patterns, then classify them
+ * This is more reliable than trying to use complex regex patterns
+ */
+export var allMathPatternsRegex = /\$\$?[^$]*\$\$?/g;
+
+/**
+ * Creates a transaction that migrates existing math strings in the document to new math nodes.
+ * This function traverses the document and replaces LaTeX math syntax with proper math nodes,
+ * preserving the mathematical content. It handles both inline and block math expressions.
+ * 
+ * Note: Math formulas inside <pre> and <code> tags are ignored to preserve code formatting.
+ *
+ * @param editor - The editor instance containing the schema and configuration
+ * @param tr - The transaction to modify with the migration operations
+ * @returns The modified transaction with math string replacements
+ *
+ * @example
+ * ```typescript
+ * const editor = new Editor({ ... })
+ * const tr = editor.state.tr
+ * const updatedTr = createMathMigrateTransaction(editor, tr)
+ * editor.view.dispatch(updatedTr)
+ * ```
+ */
+export function createMathMigrateTransaction(editor, tr) {
+  var inlineMathNode = editor.schema.nodes.inlineMath;
+  var blockMathNode = editor.schema.nodes.blockMath;
+
+  // 收集所有需要处理的数学公式，按位置排序
+  var allMathReplacements = [];
+
+  // 第一遍：收集所有数学公式信息
+  tr.doc.descendants(function (node, pos) {
+    // 跳过代码块和预格式化文本
+    if (node.marks.some(function (mark) {
+      return mark.type.name === 'codeBlock' || mark.type.name === 'code';
+    })) {
+      return;
+    }
+    if (!node.isText || !node.text || !node.text.includes('$')) {
+      return;
+    }
+    var text = node.text;
+
+    // 使用更可靠的方法：先找到所有可能的数学模式，然后分类
+    var allMatches = text.match(allMathPatternsRegex);
+    if (!allMatches) {
+      return;
+    }
+
+    // 按位置排序，从后往前处理，避免位置偏移问题
+    var sortedMatches = allMatches.map(function (match) {
+      var isBlock = match.startsWith('$$') && match.endsWith('$$');
+      var type = isBlock ? 'block' : 'inline';
+      return {
+        match: match,
+        start: text.indexOf(match),
+        end: text.indexOf(match) + match.length,
+        type: type
+      };
+    }).sort(function (a, b) {
+      return b.start - a.start;
+    }); // 从后往前排序
+
+    sortedMatches.forEach(function (_ref) {
+      var match = _ref.match,
+        start = _ref.start,
+        end = _ref.end,
+        type = _ref.type;
+      var from = tr.mapping.map(pos + start);
+      var to = tr.mapping.map(pos + end);
+      var $from = tr.doc.resolve(from);
+      var parent = $from.parent;
+      var index = $from.index();
+      var latex;
+      if (type === 'block') {
+        latex = match.slice(2, -2); // 移除 $$ 符号
+      } else {
+        latex = match.slice(1, -1); // 移除 $ 符号
+      }
+      allMathReplacements.push({
+        pos: from,
+        match: match,
+        type: type,
+        latex: latex,
+        parent: parent,
+        index: index
+      });
+    });
+  });
+
+  // 按位置从后往前排序，避免位置偏移问题
+  allMathReplacements.sort(function (a, b) {
+    return b.pos - a.pos;
+  });
+
+  // 第二遍：执行替换
+  allMathReplacements.forEach(function (_ref2) {
+    var pos = _ref2.pos,
+      match = _ref2.match,
+      type = _ref2.type,
+      latex = _ref2.latex,
+      parent = _ref2.parent,
+      index = _ref2.index;
+    var mathNode;
+    if (type === 'block') {
+      // 块级数学公式
+      mathNode = blockMathNode;
+    } else {
+      // 行内数学公式
+      mathNode = inlineMathNode;
+    }
+    if (type === 'block') {
+      // 对于块级数学公式，需要特殊处理
+      // 1. 先删除原始文本
+      var endPos = pos + match.length;
+      tr.delete(pos, endPos);
+
+      // 2. 在删除位置插入块级数学节点
+      tr.insert(pos, mathNode.create({
+        latex: latex
+      }));
+    } else {
+      // 对于行内数学公式，在段落内部替换
+      if (!parent.canReplaceWith(index, index + 1, mathNode)) {
+        console.warn("\u65E0\u6CD5\u66FF\u6362\u884C\u5185\u6570\u5B66\u516C\u5F0F:", match);
+        return;
+      }
+      var _endPos = pos + match.length;
+      tr.replaceWith(pos, _endPos, mathNode.create({
+        latex: latex
+      }));
+    }
+  });
+
+  // don't add to history
+  tr.setMeta('addToHistory', false);
+  return tr;
+}
+
+/**
+ * Migrates existing math strings in the editor document to math nodes.
+ * This function creates and dispatches a transaction that converts LaTeX math syntax
+ * into proper math nodes. It handles both inline math (single dollar signs) and
+ * block math (double dollar signs). The migration happens immediately and is not
+ * added to the editor's history.
+ * 
+ * Note: Math formulas inside <pre> and <code> tags are ignored to preserve code formatting.
+ *
+ * @param editor - The editor instance to perform the migration on
+ *
+ * @example
+ * ```typescript
+ * const editor = new Editor({
+ *   extensions: [Mathematics],
+ *   content: 'This is inline math: $x^2 + y^2 = z^2$ and block math: $$\frac{a}{b}$$'
+ * })
+ *
+ * // Math strings will be automatically migrated to math nodes
+ * migrateMathStrings(editor)
+ * ```
+ */
+export function migrateMathStrings(editor) {
+  var tr = createMathMigrateTransaction(editor, editor.state.tr);
+  editor.view.dispatch(tr);
+}