@md-lark-converter/core 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1517 @@
+// src/utils/idGenerator.ts
+var ID_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+function generateBlockId() {
+  let id = "";
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      id += ID_CHARS[Math.floor(Math.random() * ID_CHARS.length)];
+    }
+    if (i < 3) id += "_";
+  }
+  return `docx${id}`;
+}
+function generateRecordId() {
+  let id = "";
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      id += ID_CHARS[Math.floor(Math.random() * ID_CHARS.length)];
+    }
+    if (i < 3) id += "_";
+  }
+  return `doxcn${id}`;
+}
+function generatePageId() {
+  let id = "";
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      id += ID_CHARS[Math.floor(Math.random() * ID_CHARS.length)];
+    }
+    if (i < 3) id += "_";
+  }
+  return `Wqf${id}`;
+}
+
+// src/converter/markdownToLark.ts
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkMath from "remark-math";
+import remarkGfm from "remark-gfm";
+import { visit, SKIP } from "unist-util-visit";
+var MarkdownToLarkConverter = class {
+  rootId;
+  authorId;
+  recordMap;
+  blockIds;
+  recordIds;
+  payloadMap;
+  apoolNextNum;
+  apoolNumToAttrib;
+  constructor() {
+    this.rootId = null;
+    this.authorId = "7092639913849389057";
+    this.recordMap = {};
+    this.blockIds = [];
+    this.recordIds = [];
+    this.payloadMap = {};
+    this.apoolNextNum = 0;
+    this.apoolNumToAttrib = {};
+  }
+  async convert(markdown) {
+    this.rootId = generatePageId();
+    this.recordMap = {};
+    this.blockIds = [];
+    this.recordIds = [];
+    this.payloadMap = {};
+    this.apoolNextNum = 0;
+    this.apoolNumToAttrib = {};
+    const normalizedMarkdown = this.normalizeMathBlocks(markdown);
+    const tree = await unified().use(remarkParse).use(remarkGfm).use(remarkMath).parse(normalizedMarkdown);
+    this.createPageBlock(this.rootId);
+    this.convertTree(tree);
+    return this.buildClipboardData();
+  }
+  normalizeMathBlocks(markdown) {
+    return markdown.replace(/\$\$([^\n]+?)\$\$/g, (_, content) => {
+      return `$$
+${content.trim()}
+$$`;
+    });
+  }
+  createPageBlock(pageId) {
+    this.recordMap[pageId] = {
+      id: pageId,
+      snapshot: {
+        type: "page",
+        parent_id: "",
+        comments: null,
+        revisions: null,
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        children: [],
+        text: this.createTextData(""),
+        align: "",
+        page_style: {},
+        title: {
+          apool: { nextNum: 0, numToAttrib: {} },
+          initialAttributedTexts: {
+            attribs: {},
+            text: { "0": "\u65E0\u6807\u9898" }
+          }
+        }
+      }
+    };
+  }
+  convertTree(tree) {
+    const topLevelRecordIds = [];
+    visit(tree, (node, index, parent) => {
+      if (parent?.type === "listItem") {
+        return SKIP;
+      }
+      if (node.type === "heading") {
+        const recordId = generateRecordId();
+        this.recordMap[recordId] = this.createHeadingBlock(recordId, node);
+        this.recordIds.push(recordId);
+        this.blockIds.push(this.blockIds.length + 1);
+        topLevelRecordIds.push(recordId);
+      } else if (node.type === "paragraph") {
+        const recordId = generateRecordId();
+        this.recordMap[recordId] = this.createTextBlock(recordId, node);
+        this.recordIds.push(recordId);
+        this.blockIds.push(this.blockIds.length + 1);
+        topLevelRecordIds.push(recordId);
+      } else if (node.type === "blockquote") {
+        const recordId = generateRecordId();
+        this.recordMap[recordId] = this.createQuoteBlock(recordId, node);
+        this.recordIds.push(recordId);
+        this.blockIds.push(this.blockIds.length + 1);
+        topLevelRecordIds.push(recordId);
+        return SKIP;
+      } else if (node.type === "code") {
+        const recordId = generateRecordId();
+        const codeNode = node;
+        if (codeNode.lang && codeNode.lang.toLowerCase() === "mermaid") {
+          this.recordMap[recordId] = this.createMermaidBlock(recordId, codeNode.value);
+        } else {
+          this.recordMap[recordId] = this.createCodeBlock(recordId, codeNode.value, codeNode.lang ?? void 0);
+        }
+        this.recordIds.push(recordId);
+        this.blockIds.push(this.blockIds.length + 1);
+        topLevelRecordIds.push(recordId);
+      } else if (node.type === "thematicBreak") {
+        const recordId = generateRecordId();
+        this.recordMap[recordId] = this.createDividerBlock(recordId);
+        this.recordIds.push(recordId);
+        this.blockIds.push(this.blockIds.length + 1);
+        topLevelRecordIds.push(recordId);
+      } else if (node.type === "math") {
+        const mathNode = node;
+        const recordId = generateRecordId();
+        const equation = mathNode.value ?? "";
+        this.recordMap[recordId] = this.createEquationParagraphBlock(recordId, equation);
+        this.recordIds.push(recordId);
+        this.blockIds.push(this.blockIds.length + 1);
+        topLevelRecordIds.push(recordId);
+      } else if (node.type === "table") {
+        const tableRecordIds = this.convertTable(node);
+        topLevelRecordIds.push(tableRecordIds.tableId);
+      }
+    });
+    const processedLists = /* @__PURE__ */ new Set();
+    visit(tree, "list", (node, index, parent) => {
+      if (processedLists.has(node)) {
+        return SKIP;
+      }
+      processedLists.add(node);
+      if (parent?.type === "listItem") {
+        return SKIP;
+      }
+      const listRecordIds = this.convertList(node);
+      topLevelRecordIds.push(...listRecordIds);
+    });
+    if (this.rootId && this.recordMap[this.rootId]) {
+      this.recordMap[this.rootId].snapshot.children = topLevelRecordIds;
+    }
+  }
+  convertList(listNode) {
+    const ordered = listNode.ordered || false;
+    return this.convertListItems(listNode.children, ordered, null, 0, true);
+  }
+  convertListItems(items, ordered, parentId = null, level = 0, isTopLevel = false) {
+    const childRecordIds = [];
+    const topLevelIds = [];
+    let index = 1;
+    for (const item of items) {
+      const recordId = generateRecordId();
+      const blockId = this.blockIds.length + 1;
+      let blockType = ordered ? "ordered" : "bullet";
+      const isTaskItem = item.checked !== void 0 && item.checked !== null;
+      if (isTaskItem) {
+        blockType = "todo";
+      }
+      const listContent = item.children;
+      const segments = listContent.length > 0 && listContent[0].type === "paragraph" ? this.parseInlineContent(listContent[0].children) : this.parseInlineContent(listContent);
+      if (isTopLevel && level === 0) {
+        this.recordIds.push(recordId);
+      }
+      const snapshot = {
+        type: blockType,
+        parent_id: parentId || this.rootId,
+        comments: [],
+        revisions: [],
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        children: [],
+        text: ordered ? this.createListItemTextData(segments) : this.createTextData(segments),
+        align: "",
+        folded: false
+      };
+      if (isTaskItem) {
+        snapshot.done = item.checked || false;
+      }
+      if (ordered) {
+        snapshot.level = level + 1;
+        snapshot.seq = index === 1 ? "1" : "auto";
+        index++;
+      } else {
+        snapshot.level = level + 1;
+      }
+      for (const child of item.children) {
+        if (child.type === "list") {
+          const nestedChildIds = this.convertListItems(
+            child.children,
+            child.ordered || false,
+            recordId,
+            level + 1,
+            false
+          );
+          snapshot.children.push(...nestedChildIds);
+        }
+      }
+      this.recordMap[recordId] = {
+        id: recordId,
+        snapshot
+      };
+      this.blockIds.push(blockId);
+      childRecordIds.push(recordId);
+      if (isTopLevel && level === 0) {
+        topLevelIds.push(recordId);
+      }
+    }
+    return isTopLevel ? topLevelIds : childRecordIds;
+  }
+  parseInlineContent(children) {
+    const segments = [];
+    for (const child of children) {
+      if (child.type === "text") {
+        segments.push({ text: child.value });
+      } else if (child.type === "strong") {
+        const text = this.extractTextContent(child);
+        segments.push({ text, bold: true });
+      } else if (child.type === "emphasis") {
+        const text = this.extractTextContent(child);
+        segments.push({ text, italic: true });
+      } else if (child.type === "delete") {
+        const text = this.extractTextContent(child);
+        segments.push({ text, strikethrough: true });
+      } else if (child.type === "inlineCode") {
+        segments.push({ text: child.value });
+      } else if (child.type === "link") {
+        const linkNode = child;
+        const text = this.extractTextContent(linkNode);
+        segments.push({ text, linkUrl: linkNode.url });
+      } else if (child.type === "image") {
+        segments.push({ text: " [markdown-to-lark \u6682\u65E0\u6CD5\u652F\u6301\u56FE\u7247\u8F6C\u6362] " });
+      } else if (child.type === "inlineMath") {
+        const mathNode = child;
+        segments.push({ text: "E", equation: mathNode.value ?? "" });
+      } else if (child.type === "break") {
+        segments.push({ text: "\n" });
+      }
+    }
+    return segments;
+  }
+  extractTextContent(node) {
+    let text = "";
+    if (node.type === "text") {
+      text = node.value;
+    } else if (node.children) {
+      for (const child of node.children) {
+        text += this.extractTextContent(child);
+      }
+    }
+    return text;
+  }
+  createHeadingBlock(recordId, node) {
+    const depth = node.depth;
+    const segments = this.parseInlineContent(node.children);
+    return {
+      id: recordId,
+      snapshot: {
+        type: `heading${depth}`,
+        parent_id: this.rootId,
+        comments: [],
+        revisions: [],
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        children: [],
+        text: this.createTextData(segments),
+        level: depth,
+        folded: false
+      }
+    };
+  }
+  createTextBlock(recordId, node) {
+    const segments = this.parseInlineContent(node.children);
+    return {
+      id: recordId,
+      snapshot: {
+        type: "text",
+        parent_id: this.rootId,
+        comments: [],
+        revisions: [],
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        children: [],
+        text: this.createTextData(segments),
+        align: "",
+        folded: false
+      }
+    };
+  }
+  createQuoteBlock(recordId, node) {
+    const flattenedContent = this.flattenNestedBlockquotes(node.children);
+    const segments = this.parseInlineContent(flattenedContent);
+    return {
+      id: recordId,
+      snapshot: {
+        type: "quote",
+        parent_id: this.rootId,
+        comments: [],
+        revisions: [],
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        children: [],
+        text: this.createTextData(segments),
+        folded: false
+      }
+    };
+  }
+  flattenNestedBlockquotes(children) {
+    const result = [];
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.type === "blockquote") {
+        const nestedContent = this.flattenNestedBlockquotes(child.children);
+        if (result.length > 0) {
+          result.push({ type: "text", value: "\n\n" });
+        }
+        result.push(...nestedContent);
+      } else if (child.type === "paragraph") {
+        if (result.length > 0) {
+          result.push({ type: "text", value: "\n\n" });
+        }
+        result.push(...child.children);
+      } else {
+        result.push(child);
+      }
+    }
+    return result;
+  }
+  createEquationBlock(recordId, equation) {
+    const segments = [{ text: "E", equation }];
+    return {
+      id: recordId,
+      snapshot: {
+        type: "equation",
+        parent_id: this.rootId,
+        comments: [],
+        revisions: [],
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        children: [],
+        elements: [{
+          equation: {
+            latex: equation
+          }
+        }],
+        text: this.createTextData(segments),
+        folded: false
+      }
+    };
+  }
+  createEquationParagraphBlock(recordId, equation) {
+    const segments = [{ text: "E", equation: equation + "_display" }];
+    return {
+      id: recordId,
+      snapshot: {
+        type: "text",
+        parent_id: this.rootId,
+        comments: [],
+        revisions: [],
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        children: [],
+        text: this.createTextData(segments),
+        align: "",
+        folded: false
+      }
+    };
+  }
+  createCodeBlock(recordId, code, lang) {
+    return {
+      id: recordId,
+      snapshot: {
+        type: "code",
+        parent_id: this.rootId,
+        comments: [],
+        revisions: [],
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        children: [],
+        language: lang || "plaintext",
+        code,
+        text: this.createTextData(code),
+        is_language_picked: true,
+        caption: {
+          text: {
+            initialAttributedTexts: {
+              text: { "0": "\n" },
+              attribs: { "0": "|1+1" }
+            },
+            apool: { numToAttrib: {}, nextNum: 0 }
+          }
+        },
+        wrap: false,
+        folded: false
+      }
+    };
+  }
+  createDividerBlock(recordId) {
+    return {
+      id: recordId,
+      snapshot: {
+        type: "divider",
+        parent_id: this.rootId,
+        comments: [],
+        revisions: [],
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        folded: false
+      }
+    };
+  }
+  createMermaidBlock(recordId, code) {
+    const blockId = generateBlockId();
+    return {
+      id: recordId,
+      snapshot: {
+        type: "isv",
+        parent_id: this.rootId,
+        comments: null,
+        revisions: null,
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        children: [],
+        data: {
+          data: code,
+          theme: "default",
+          view: "codeChart"
+        },
+        app_block_id: "",
+        block_type_id: "blk_631fefbbae02400430b8f9f4",
+        manifest: {
+          view_type: "block_h5",
+          app_version: "0.0.112"
+        },
+        comment_details: {},
+        interaction_data_token: this.generateRandomId()
+      }
+    };
+  }
+  createTextData(segments) {
+    if (typeof segments === "string") {
+      segments = [{ text: segments }];
+    }
+    if (!segments || segments.length === 0) {
+      return {
+        apool: { nextNum: 0, numToAttrib: {} },
+        initialAttributedTexts: {
+          attribs: "",
+          text: { "0": "" },
+          rows: {},
+          cols: {}
+        }
+      };
+    }
+    const apoolNumToAttrib = {
+      "0": ["author", this.authorId]
+    };
+    const attribToNum = {
+      [`author,${this.authorId}`]: 0
+    };
+    let apoolNextNum = 1;
+    const attribParts = [];
+    const textParts = [];
+    for (const segment of segments) {
+      const text = segment.text || "";
+      const length = text.length;
+      if (length === 0) continue;
+      textParts.push(text);
+      const activeAttrs = ["0"];
+      if (segment.linkUrl) {
+        const linkAttrNum = apoolNextNum.toString();
+        apoolNextNum++;
+        const encodedUrl = encodeURIComponent(segment.linkUrl);
+        apoolNumToAttrib[linkAttrNum] = ["link", encodedUrl];
+        attribToNum[`link,${encodedUrl}`] = parseInt(linkAttrNum);
+        activeAttrs.push(linkAttrNum);
+      }
+      if (segment.bold) {
+        const boldAttrKey = "bold,true";
+        let boldAttrNum = attribToNum[boldAttrKey];
+        if (boldAttrNum === void 0) {
+          boldAttrNum = apoolNextNum;
+          apoolNextNum++;
+          apoolNumToAttrib[boldAttrNum.toString()] = ["bold", "true"];
+          attribToNum[boldAttrKey] = boldAttrNum;
+        }
+        activeAttrs.push(boldAttrNum.toString());
+      }
+      if (segment.italic) {
+        const italicAttrKey = "italic,true";
+        let italicAttrNum = attribToNum[italicAttrKey];
+        if (italicAttrNum === void 0) {
+          italicAttrNum = apoolNextNum;
+          apoolNextNum++;
+          apoolNumToAttrib[italicAttrNum.toString()] = ["italic", "true"];
+          attribToNum[italicAttrKey] = italicAttrNum;
+        }
+        activeAttrs.push(italicAttrNum.toString());
+      }
+      if (segment.underline) {
+        const underlineAttrKey = "underline,true";
+        let underlineAttrNum = attribToNum[underlineAttrKey];
+        if (underlineAttrNum === void 0) {
+          underlineAttrNum = apoolNextNum;
+          apoolNextNum++;
+          apoolNumToAttrib[underlineAttrNum.toString()] = ["underline", "true"];
+          attribToNum[underlineAttrKey] = underlineAttrNum;
+        }
+        activeAttrs.push(underlineAttrNum.toString());
+      }
+      if (segment.strikethrough) {
+        const strikeAttrKey = "strikethrough,true";
+        let strikeAttrNum = attribToNum[strikeAttrKey];
+        if (strikeAttrNum === void 0) {
+          strikeAttrNum = apoolNextNum;
+          apoolNextNum++;
+          apoolNumToAttrib[strikeAttrNum.toString()] = ["strikethrough", "true"];
+          attribToNum[strikeAttrKey] = strikeAttrNum;
+        }
+        activeAttrs.push(strikeAttrNum.toString());
+      }
+      if (segment.equation) {
+        const eqAttrNum = apoolNextNum.toString();
+        apoolNextNum++;
+        apoolNumToAttrib[eqAttrNum] = ["equation", segment.equation];
+        attribToNum[`equation,${segment.equation}`] = parseInt(eqAttrNum);
+        activeAttrs.push(eqAttrNum);
+      }
+      const attrsPart = activeAttrs.join("*");
+      attribParts.push(`*${attrsPart}+${length}`);
+    }
+    const fullText = textParts.join("");
+    const attribsStr = attribParts.join("");
+    return {
+      apool: {
+        nextNum: apoolNextNum,
+        numToAttrib: apoolNumToAttrib,
+        attribToNum
+      },
+      initialAttributedTexts: {
+        attribs: { "0": attribsStr },
+        text: { "0": fullText },
+        rows: {},
+        cols: {}
+      }
+    };
+  }
+  createListItemTextData(segments) {
+    if (!segments || segments.length === 0) {
+      return {
+        apool: { nextNum: 0, numToAttrib: {} },
+        initialAttributedTexts: {
+          attribs: "",
+          text: { "0": "" },
+          rows: {},
+          cols: {}
+        }
+      };
+    }
+    const apoolNumToAttrib = {
+      "0": ["author", this.authorId]
+    };
+    const attribToNum = {
+      [`author,${this.authorId}`]: 0
+    };
+    let apoolNextNum = 1;
+    const attribParts = [];
+    const textParts = [];
+    for (const segment of segments) {
+      const text = segment.text || "";
+      const length = text.length;
+      if (length === 0) continue;
+      textParts.push(text);
+      const activeAttrs = ["0"];
+      if (segment.linkUrl) {
+        const linkAttrNum = apoolNextNum.toString();
+        apoolNextNum++;
+        const encodedUrl = encodeURIComponent(segment.linkUrl);
+        apoolNumToAttrib[linkAttrNum] = ["link", encodedUrl];
+        attribToNum[`link,${encodedUrl}`] = parseInt(linkAttrNum);
+        activeAttrs.push(linkAttrNum);
+      }
+      if (segment.bold) {
+        const boldAttrKey = "bold,true";
+        let boldAttrNum = attribToNum[boldAttrKey];
+        if (boldAttrNum === void 0) {
+          boldAttrNum = apoolNextNum;
+          apoolNextNum++;
+          apoolNumToAttrib[boldAttrNum.toString()] = ["bold", "true"];
+          attribToNum[boldAttrKey] = boldAttrNum;
+        }
+        activeAttrs.push(boldAttrNum.toString());
+      }
+      if (segment.italic) {
+        const italicAttrKey = "italic,true";
+        let italicAttrNum = attribToNum[italicAttrKey];
+        if (italicAttrNum === void 0) {
+          italicAttrNum = apoolNextNum;
+          apoolNextNum++;
+          apoolNumToAttrib[italicAttrNum.toString()] = ["italic", "true"];
+          attribToNum[italicAttrKey] = italicAttrNum;
+        }
+        activeAttrs.push(italicAttrNum.toString());
+      }
+      if (segment.underline) {
+        const underlineAttrKey = "underline,true";
+        let underlineAttrNum = attribToNum[underlineAttrKey];
+        if (underlineAttrNum === void 0) {
+          underlineAttrNum = apoolNextNum;
+          apoolNextNum++;
+          apoolNumToAttrib[underlineAttrNum.toString()] = ["underline", "true"];
+          attribToNum[underlineAttrKey] = underlineAttrNum;
+        }
+        activeAttrs.push(underlineAttrNum.toString());
+      }
+      if (segment.strikethrough) {
+        const strikeAttrKey = "strikethrough,true";
+        let strikeAttrNum = attribToNum[strikeAttrKey];
+        if (strikeAttrNum === void 0) {
+          strikeAttrNum = apoolNextNum;
+          apoolNextNum++;
+          apoolNumToAttrib[strikeAttrNum.toString()] = ["strikethrough", "true"];
+          attribToNum[strikeAttrKey] = strikeAttrNum;
+        }
+        activeAttrs.push(strikeAttrNum.toString());
+      }
+      if (segment.equation) {
+        const eqAttrNum = apoolNextNum.toString();
+        apoolNextNum++;
+        apoolNumToAttrib[eqAttrNum] = ["equation", segment.equation];
+        attribToNum[`equation,${segment.equation}`] = parseInt(eqAttrNum);
+        activeAttrs.push(eqAttrNum);
+      }
+      const attrsPart = activeAttrs.join("*");
+      attribParts.push(`*${attrsPart}+${length}`);
+    }
+    const fullText = textParts.join("");
+    const attribsStr = attribParts.join("");
+    return {
+      apool: {
+        nextNum: apoolNextNum,
+        numToAttrib: apoolNumToAttrib,
+        attribToNum
+      },
+      initialAttributedTexts: {
+        attribs: { "0": attribsStr },
+        text: { "0": fullText },
+        rows: {},
+        cols: {}
+      }
+    };
+  }
+  buildClipboardData() {
+    const data = {
+      isCut: false,
+      rootId: this.rootId,
+      parentId: this.rootId,
+      blockIds: this.blockIds,
+      recordIds: this.recordIds,
+      recordMap: this.recordMap,
+      payloadMap: {},
+      selection: [],
+      extra: {
+        channel: "saas",
+        pasteRandomId: this.generateRandomId(),
+        mention_page_title: {},
+        external_mention_url: {},
+        isEqualBlockSelection: true
+      },
+      isKeepQuoteContainer: false,
+      pasteFlag: this.generateRandomId()
+    };
+    return data;
+  }
+  generateRandomId() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  convertTable(tableNode) {
+    const tableRecordId = generateRecordId();
+    const children = tableNode.children;
+    if (!children || children.length === 0) {
+      return { tableId: tableRecordId };
+    }
+    const alignments = tableNode.align || [];
+    const rows = children;
+    const columnIds = [];
+    const rowIds = [];
+    const columnSet = {};
+    const cellSet = {};
+    const tableCellIds = [];
+    const numCols = alignments.length || rows[0]?.children?.length || 0;
+    const numRows = rows.length;
+    for (let i = 0; i < numCols; i++) {
+      const colId = `col${this.generateRandomId().replace(/-/g, "")}`;
+      columnIds.push(colId);
+      columnSet[colId] = { column_width: 200 };
+    }
+    for (let i = 0; i < numRows; i++) {
+      const rowId = `row${this.generateRandomId().replace(/-/g, "")}`;
+      rowIds.push(rowId);
+    }
+    const processRow = (rowIndex, rowCells) => {
+      const rowId = rowIds[rowIndex];
+      for (let colIndex = 0; colIndex < rowCells.length && colIndex < numCols; colIndex++) {
+        const colId = columnIds[colIndex];
+        const cellNode = rowCells[colIndex];
+        const cellRecordId = generateRecordId();
+        const cellTextSegments = this.parseInlineContent(cellNode.children || []);
+        const align = alignments[colIndex] || "left";
+        this.recordMap[cellRecordId] = {
+          id: cellRecordId,
+          snapshot: {
+            type: "table_cell",
+            parent_id: tableRecordId,
+            comments: [],
+            revisions: [],
+            locked: false,
+            hidden: false,
+            author: this.authorId,
+            children: [],
+            text: this.createTextData(cellTextSegments)
+          }
+        };
+        const textRecordId = generateRecordId();
+        this.recordMap[textRecordId] = {
+          id: textRecordId,
+          snapshot: {
+            type: "text",
+            parent_id: cellRecordId,
+            comments: [],
+            revisions: [],
+            locked: false,
+            hidden: false,
+            author: this.authorId,
+            children: [],
+            text: this.createTextData(cellTextSegments),
+            folded: false,
+            align
+          }
+        };
+        this.recordMap[cellRecordId].snapshot.children.push(textRecordId);
+        const cellKey = `${rowId}${colId}`;
+        cellSet[cellKey] = {
+          block_id: cellRecordId,
+          merge_info: { row_span: 1, col_span: 1 }
+        };
+        tableCellIds.push(cellRecordId);
+      }
+    };
+    for (let i = 0; i < rows.length; i++) {
+      processRow(i, rows[i].children);
+    }
+    this.recordMap[tableRecordId] = {
+      id: tableRecordId,
+      snapshot: {
+        type: "table",
+        parent_id: this.rootId,
+        comments: [],
+        revisions: [],
+        locked: false,
+        hidden: false,
+        author: this.authorId,
+        children: tableCellIds,
+        columns_id: columnIds,
+        rows_id: rowIds,
+        column_set: columnSet,
+        cell_set: cellSet
+      }
+    };
+    this.recordIds.push(tableRecordId);
+    this.blockIds.push(this.blockIds.length + 1);
+    return { tableId: tableRecordId };
+  }
+};
+
+// src/parser/markdownParser.ts
+import { marked } from "marked";
+function parseMarkdown(markdown) {
+  const tokens = marked.lexer(markdown);
+  return convertTokens(tokens);
+}
+function convertTokens(tokens, parentType = null) {
+  const blocks = [];
+  for (const token of tokens) {
+    const block = convertToken(token, parentType);
+    if (Array.isArray(block)) {
+      blocks.push(...block);
+    } else if (block) {
+      blocks.push(block);
+    }
+  }
+  return blocks;
+}
+function convertToken(token, parentType) {
+  const { type, raw, text, depth, items, code, lang } = token;
+  switch (type) {
+    case "heading":
+      return {
+        type: `heading${depth}`,
+        text: parseInlineText(text)
+      };
+    case "paragraph":
+      return {
+        type: "text",
+        text: parseInlineText(text)
+      };
+    case "blockquote":
+      return {
+        type: "quote",
+        text: parseInlineText(text)
+      };
+    case "list":
+      return {
+        type: "list",
+        ordered: token.ordered,
+        items: items.map((item) => ({
+          text: parseInlineText(item.text),
+          task: item.checked !== void 0,
+          checked: item.checked
+        }))
+      };
+    case "code":
+      return {
+        type: "code",
+        language: lang || "plaintext",
+        text: code
+      };
+    case "hr":
+      return {
+        type: "divider"
+      };
+    case "space":
+      return null;
+    default:
+      return null;
+  }
+}
+function parseInlineText(text) {
+  if (!text) return "";
+  const inlineTokens = marked.lexerInline(text);
+  return convertInlineTokens(inlineTokens);
+}
+function convertInlineTokens(tokens) {
+  let result = "";
+  for (const token of tokens) {
+    switch (token.type) {
+      case "text":
+        result += token.raw;
+        break;
+      case "strong":
+        result += `**${token.text}**`;
+        break;
+      case "em":
+        result += `*${token.text}*`;
+        break;
+      case "del":
+        result += `~~${token.text}~~`;
+        break;
+      case "codespan":
+        result += `\`${token.text}\``;
+        break;
+      case "link":
+        result += `[$(token as any).text}](${token.href})`;
+        break;
+      case "image":
+        result += `![${token.text}](${token.href})`;
+        break;
+      default:
+        result += token.raw || "";
+    }
+  }
+  return result;
+}
+
+// src/clipboard/browserClipboard.ts
+async function writeToClipboard(html, jsonData) {
+  try {
+    const plainText = extractPlainTextFromData(jsonData);
+    const clipboardItem = new ClipboardItem({
+      "text/html": new Blob([html], { type: "text/html" }),
+      "text/plain": new Blob([plainText], { type: "text/plain" })
+    });
+    await navigator.clipboard.write([clipboardItem]);
+    return true;
+  } catch (error) {
+    console.error("Failed to write to clipboard:", error);
+    throw new Error(`\u5199\u5165\u526A\u8D34\u677F\u5931\u8D25: ${error.message}`);
+  }
+}
+function extractPlainTextFromData(data) {
+  let text = "";
+  for (const recordId of data.recordIds) {
+    const record = data.recordMap[recordId];
+    if (!record) continue;
+    const snapshot = record.snapshot;
+    const type = snapshot.type;
+    if (type === "isv") {
+      text += "[Mermaid \u56FE\u8868]\n";
+    } else if (type === "code") {
+      text += `\`\`\`${snapshot.language || "text"}
+${snapshot.code}
+\`\`\`
+`;
+    } else if (type === "divider") {
+      text += "---\n";
+    } else if (type.startsWith("heading")) {
+      const level = parseInt(type.replace("heading", ""));
+      text += `${"#".repeat(level)} ${getTextContent(snapshot.text)}
+
+`;
+    } else if (type === "text" || type === "quote") {
+      text += `${getTextContent(snapshot.text)}
+
+`;
+    } else if (type === "bullet" || type === "ordered" || type === "todo") {
+      const marker = type === "bullet" ? "-" : type === "ordered" ? "1." : snapshot.checked ? "- [x]" : "- [ ]";
+      text += `${marker} ${getTextContent(snapshot.text)}
+`;
+    }
+  }
+  return text.trim();
+}
+function getTextContent(textData) {
+  if (!textData || !textData.initialAttributedTexts) {
+    return "";
+  }
+  const texts = textData.initialAttributedTexts.text;
+  return Object.values(texts).join("");
+}
+async function readClipboard() {
+  try {
+    const clipboardItems = await navigator.clipboard.read();
+    const results = {};
+    for (const item of clipboardItems) {
+      for (const type of item.types) {
+        const blob = await item.getType(type);
+        if (type.startsWith("text/")) {
+          const text = await blob.text();
+          results[type] = text;
+        }
+      }
+    }
+    return results;
+  } catch (error) {
+    console.error("Failed to read clipboard:", error);
+    throw new Error(`\u8BFB\u53D6\u526A\u8D34\u677F\u5931\u8D25: ${error.message}`);
+  }
+}
+
+// src/htmlGenerator.ts
+function generateHtml(data) {
+  if (!data || !data.recordIds || !data.recordMap) {
+    console.error("Invalid data structure:", data);
+    return "";
+  }
+  const jsonStr = JSON.stringify(data);
+  const encodedJson = jsonStr.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  let html = `<meta charset="utf-8"><div data-page-id="${data.rootId}" data-lark-html-role="root" data-docx-has-block-data="true">`;
+  for (const recordId of data.recordIds) {
+    const record = data.recordMap[recordId];
+    if (!record) continue;
+    const snapshot = record.snapshot;
+    const blockHtml = generateBlockHtml(snapshot, recordId);
+    html += blockHtml;
+  }
+  html += `</div><span data-lark-record-data="${encodedJson}" data-lark-record-format="docx/record" class="lark-record-clipboard"></span>`;
+  return html;
+}
+function generateBlockHtml(snapshot, recordId) {
+  const { type, text, code, language, level, data, checked, children } = snapshot;
+  switch (type) {
+    case "page":
+      return "";
+    case "isv":
+      const mermaidCode = data && data.data ? data.data : "";
+      return `<div class="ace-line old-record-id-${recordId}">
+<span class="block-paste-placeholder">${mermaidCode || "\u6682\u65F6\u65E0\u6CD5\u5728\u98DE\u4E66\u6587\u6863\u5916\u5C55\u793A\u6B64\u5185\u5BB9"}</span>
+</div>`;
+    case "heading1":
+      const text1 = getTextContent2(text);
+      return `<h1 class="heading-1 ace-line old-record-id-${recordId}">${escapeHtml(text1)}</h1>`;
+    case "heading2":
+      const text2 = getTextContent2(text);
+      return `<h2 class="heading-2 ace-line old-record-id-${recordId}">${escapeHtml(text2)}</h2>`;
+    case "heading3":
+      const text3 = getTextContent2(text);
+      return `<h3 class="heading-3 ace-line old-record-id-${recordId}">${escapeHtml(text3)}</h3>`;
+    case "heading4":
+      const text4 = getTextContent2(text);
+      return `<h4 class="heading-4 ace-line old-record-id-${recordId}">${escapeHtml(text4)}</h4>`;
+    case "heading5":
+      const text5 = getTextContent2(text);
+      return `<h5 class="heading-5 ace-line old-record-id-${recordId}">${escapeHtml(text5)}</h5>`;
+    case "heading6":
+      const text6 = getTextContent2(text);
+      return `<h6 class="heading-6 ace-line old-record-id-${recordId}">${escapeHtml(text6)}</h6>`;
+    case "text":
+      const textContent = getTextContent2(text);
+      return `<div class="ace-line old-record-id-${recordId}">${escapeHtml(textContent)}</div>`;
+    case "quote":
+      const quoteText = getTextContent2(text);
+      return `<blockquote class="ace-line old-record-id-${recordId}">${escapeHtml(quoteText)}</blockquote>`;
+    case "code":
+      const codeContent = code || getTextContent2(text) || "";
+      const escapedCode = escapeHtml(codeContent);
+      return `<pre style="white-space:pre;" class="ace-line old-record-id-${recordId}"><code class="language-${language || "plaintext"}" data-lark-language="${language || "plaintext"}" data-wrap="false"><div>${escapedCode}</div></code></pre>`;
+    case "divider":
+      return `<div data-type="divider" class="old-record-id-${recordId}"><hr></div>`;
+    case "bullet":
+      const bulletText = getTextContent2(text);
+      return `<ul class="list-bullet1"><li class="ace-line old-record-id-${recordId}" data-list="bullet"><div>${escapeHtml(bulletText)}</div></li></ul>`;
+    case "ordered":
+      const orderedText = getTextContent2(text);
+      return `<ol class="list-number1"><li class="ace-line old-record-id-${recordId}" data-list="number"><div>${escapeHtml(orderedText)}</div></li></ol>`;
+    case "todo":
+      const todoText = getTextContent2(text);
+      const isChecked = snapshot.done || false;
+      const listClass = isChecked ? "list-done1" : "list-check";
+      return `<ul class="${listClass}"><li class="ace-line old-record-id-${recordId}" data-list="${isChecked ? "done" : "check"}"><div>${escapeHtml(todoText)}</div></li></ul>`;
+    case "image":
+      return `<div class="ace-line old-record-id-${recordId}">[markdown-to-lark \u6682\u65E0\u6CD5\u652F\u6301\u56FE\u7247\u8F6C\u6362]</div>`;
+    default:
+      return "";
+  }
+}
+function getTextContent2(textData) {
+  if (!textData || !textData.initialAttributedTexts) {
+    return "";
+  }
+  const texts = textData.initialAttributedTexts.text;
+  if (!texts) return "";
+  return Object.values(texts).join("");
+}
+function escapeHtml(text) {
+  if (typeof text !== "string" || !text) return "";
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+
+// src/index.ts
+async function markdownToLark(markdown) {
+  const converter = new MarkdownToLarkConverter();
+  return converter.convert(markdown);
+}
+function larkToMarkdown(data) {
+  if (!data || !data.recordMap) {
+    return "";
+  }
+  const result = [];
+  let lastType = "";
+  function processRecord(recordId, depth = 0) {
+    const record = data.recordMap[recordId];
+    if (!record || !record.snapshot) return;
+    const snapshot = record.snapshot;
+    if (snapshot.type === "page") {
+      if (snapshot.children && snapshot.children.length > 0) {
+        for (const childId of snapshot.children) {
+          processRecord(childId);
+        }
+      }
+      return;
+    }
+    const isList = ["bullet", "ordered", "todo"].includes(snapshot.type);
+    if (result.length > 0) {
+      if (lastType !== snapshot.type && lastType !== "list" && !isList) {
+        result.push("");
+      } else if (lastType === "text" && snapshot.type === "text") {
+        result.push("");
+      } else if (lastType === "list" && !isList) {
+        result.push("");
+      } else if (!isList && lastType !== "list" && !isList) {
+        result.push("");
+      }
+    }
+    switch (snapshot.type) {
+      case "heading1":
+      case "heading2":
+      case "heading3":
+      case "heading4":
+      case "heading5":
+      case "heading6": {
+        const level = parseInt(snapshot.type.replace("heading", ""));
+        const headingText = getTextContent3(snapshot.text);
+        result.push(`${"#".repeat(level)} ${headingText}`);
+        break;
+      }
+      case "text": {
+        const textContent = getTextContent3(snapshot.text);
+        if (textContent.trim()) {
+          result.push(textContent);
+        }
+        break;
+      }
+      case "quote": {
+        const quoteText = getTextContent3(snapshot.text);
+        result.push(`> ${quoteText}`);
+        break;
+      }
+      case "bullet": {
+        const bulletText = getTextContent3(snapshot.text);
+        const level = snapshot.level || 1;
+        const indent = "  ".repeat(level - 1);
+        result.push(`${indent}- ${bulletText}`);
+        break;
+      }
+      case "ordered": {
+        const orderedText = getTextContent3(snapshot.text);
+        const level = snapshot.level || 1;
+        const indent = "  ".repeat(level - 1);
+        result.push(`${indent}1. ${orderedText}`);
+        break;
+      }
+      case "todo": {
+        const todoText = getTextContent3(snapshot.text);
+        const isChecked = snapshot.done || false;
+        const level = snapshot.level || 1;
+        const indent = "  ".repeat(level - 1);
+        result.push(`${indent}- [${isChecked ? "x" : " "}] ${todoText}`);
+        break;
+      }
+      case "code": {
+        const language = snapshot.language || "";
+        const code = snapshot.code || getTextContent3(snapshot.text) || "";
+        result.push(`\`\`\`${language}`);
+        result.push(code);
+        result.push(`\`\`\``);
+        break;
+      }
+      case "divider": {
+        result.push("---");
+        break;
+      }
+      case "isv": {
+        const mermaidCode = snapshot.data?.data || "";
+        result.push(`\`\`\`mermaid`);
+        result.push(mermaidCode);
+        result.push(`\`\`\``);
+        break;
+      }
+      case "equation": {
+        result.push(`$$${getTextContent3(snapshot.text)}$$`);
+        break;
+      }
+      case "image": {
+        result.push("[lark-to-markdown \u6682\u65E0\u6CD5\u652F\u6301\u56FE\u7247\u8F6C\u6362]");
+        break;
+      }
+      case "table": {
+        const tableMarkdown = convertTableToMarkdown(recordId, data.recordMap);
+        result.push(tableMarkdown);
+        break;
+      }
+      case "table_cell": {
+        return;
+      }
+      default:
+        break;
+    }
+    lastType = isList ? "list" : snapshot.type;
+    if (snapshot.children && snapshot.children.length > 0) {
+      for (const childId of snapshot.children) {
+        processRecord(childId);
+      }
+    }
+  }
+  if (data.rootId) {
+    processRecord(data.rootId);
+  }
+  return result.join("\n").trim();
+}
+function getTextContent3(textData) {
+  if (!textData || !textData.initialAttributedTexts) {
+    return "";
+  }
+  const texts = textData.initialAttributedTexts.text;
+  const attribs = textData.initialAttributedTexts.attribs;
+  if (!texts) return "";
+  if (!attribs || typeof attribs === "string" && attribs === "" || !textData.apool || !textData.apool.numToAttrib) {
+    const content = Object.values(texts).join("");
+    const placeholders = [];
+    let result = content.replace(
+      /\[([^\]]+)\]\(([^)]+)\)/g,
+      (match, text, url) => {
+        placeholders.push(match);
+        return `__LINK_PLACEHOLDER_${placeholders.length - 1}__`;
+      }
+    );
+    result = result.replace(
+      /(https?:\/\/[^\s<>"{}|\\^`\[\]]+)/g,
+      "[$1]($1)"
+    );
+    result = result.replace(
+      /__LINK_PLACEHOLDER_(\d+)__/g,
+      (_, index) => placeholders[parseInt(index)]
+    );
+    return result;
+  }
+  let attribsStr = "";
+  if (typeof attribs === "string") {
+    attribsStr = attribs;
+  } else if (attribs && typeof attribs === "object") {
+    const values = Object.values(attribs);
+    if (values.length > 0 && typeof values[0] === "string") {
+      attribsStr = values[0];
+    }
+  }
+  return parseAttributedText(texts, attribsStr, textData.apool.numToAttrib);
+}
+function convertTableToMarkdown(tableRecordId, recordMap) {
+  const tableRecord = recordMap[tableRecordId];
+  if (!tableRecord || !tableRecord.snapshot) {
+    return "";
+  }
+  const snapshot = tableRecord.snapshot;
+  const { columns_id, rows_id, cell_set } = snapshot;
+  if (!columns_id || !rows_id || !cell_set) {
+    return "";
+  }
+  const rows = [];
+  for (const rowId of rows_id) {
+    const row = [];
+    for (const colId of columns_id) {
+      const cellKey = `${rowId}${colId}`;
+      const cell = cell_set[cellKey];
+      if (cell && cell.block_id) {
+        const cellRecord = recordMap[cell.block_id];
+        if (cellRecord && cellRecord.snapshot) {
+          const cellSnapshot = cellRecord.snapshot;
+          const childId = cellSnapshot.children && cellSnapshot.children.length > 0 ? cellSnapshot.children[0] : null;
+          if (childId) {
+            const textRecord = recordMap[childId];
+            if (textRecord && textRecord.snapshot) {
+              const cellText = getTextContent3(textRecord.snapshot.text);
+              row.push(cellText);
+            } else {
+              row.push("");
+            }
+          } else {
+            row.push("");
+          }
+        } else {
+          row.push("");
+        }
+      } else {
+        row.push("");
+      }
+    }
+    rows.push(row);
+  }
+  if (rows.length === 0) {
+    return "";
+  }
+  const colCount = columns_id.length;
+  const alignments = [];
+  for (const colId of columns_id) {
+    const cellKey = `${rows_id[0]}${colId}`;
+    const cell = cell_set[cellKey];
+    if (cell && cell.block_id) {
+      const cellRecord = recordMap[cell.block_id];
+      if (cellRecord && cellRecord.snapshot) {
+        const cellSnapshot = cellRecord.snapshot;
+        const childId = cellSnapshot.children && cellSnapshot.children.length > 0 ? cellSnapshot.children[0] : null;
+        if (childId) {
+          const textRecord = recordMap[childId];
+          if (textRecord && textRecord.snapshot && textRecord.snapshot.align) {
+            const align = textRecord.snapshot.align;
+            alignments.push(align);
+          } else {
+            alignments.push("left");
+          }
+        } else {
+          alignments.push("left");
+        }
+      } else {
+        alignments.push("left");
+      }
+    } else {
+      alignments.push("left");
+    }
+  }
+  const separatorRow = alignments.map((align) => {
+    switch (align) {
+      case "center":
+        return ":--:";
+      case "right":
+        return "---:";
+      case "left":
+      default:
+        return ":---";
+    }
+  });
+  const markdownRows = [];
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    const formattedRow = row.map((cell) => {
+      return cell.includes("|") ? `"${cell.replace(/"/g, '""')}"` : cell;
+    }).join(" | ");
+    markdownRows.push(`| ${formattedRow} |`);
+    if (i === 0) {
+      markdownRows.push(`| ${separatorRow.join(" | ")} |`);
+    }
+  }
+  return markdownRows.join("\n");
+}
+function parseAttributedText(texts, attribsStr, numToAttrib) {
+  let content = Object.values(texts).join("");
+  const segments = [];
+  let pos = 0;
+  while (pos < attribsStr.length) {
+    if (attribsStr[pos] === "*") {
+      pos++;
+      const attrNums = [];
+      while (pos < attribsStr.length && /[0-9]/.test(attribsStr[pos])) {
+        let numStr = "";
+        while (pos < attribsStr.length && /[0-9]/.test(attribsStr[pos])) {
+          numStr += attribsStr[pos];
+          pos++;
+        }
+        attrNums.push(numStr);
+        if (pos < attribsStr.length && attribsStr[pos] === "*") {
+          pos++;
+        } else {
+          break;
+        }
+      }
+      if (pos >= attribsStr.length || attribsStr[pos] !== "+") break;
+      pos++;
+      let lengthStr = "";
+      while (pos < attribsStr.length) {
+        const char = attribsStr[pos];
+        if (/[0-9]/.test(char)) {
+          lengthStr += char;
+          pos++;
+        } else {
+          break;
+        }
+      }
+      if (!lengthStr) {
+        continue;
+      }
+      const length = parseInt(lengthStr, 10) || 0;
+      const text = content.substring(0, length);
+      content = content.substring(length);
+      const attrs = {};
+      for (const num of attrNums) {
+        const attrValue = numToAttrib[num];
+        if (attrValue && Array.isArray(attrValue) && attrValue.length >= 2) {
+          attrs[String(attrValue[0])] = attrValue[1];
+        }
+      }
+      if (text) {
+        segments.push({ text, attrs });
+      }
+    } else {
+      pos++;
+    }
+  }
+  if (content) {
+    segments.push({ text: content, attrs: {} });
+  }
+  let result = "";
+  for (const segment of segments) {
+    const { text, attrs } = segment;
+    if (attrs.link) {
+      const url = decodeURIComponent(String(attrs.link));
+      result += `[${text}](${url})`;
+    } else if (attrs.equation) {
+      const equation = String(attrs.equation).trim();
+      const isDisplay = equation.endsWith("_display");
+      const cleanEquation = isDisplay ? equation.slice(0, -8) : equation;
+      result += isDisplay ? `$$${cleanEquation}$$` : `$${cleanEquation}$`;
+    } else {
+      let formattedText = text;
+      if (attrs.strikethrough === "true") {
+        formattedText = `~~${formattedText}~~`;
+      }
+      if (attrs.bold === "true") {
+        formattedText = `**${formattedText}**`;
+      }
+      if (attrs.italic === "true") {
+        formattedText = `*${formattedText}*`;
+      }
+      result += formattedText;
+    }
+  }
+  return result;
+}
+var TEST_CASES = {
+  heading: `# \u4E00\u7EA7\u6807\u9898
+## \u4E8C\u7EA7\u6807\u9898
+### \u4E09\u7EA7\u6807\u9898
+`,
+  paragraph: `\u8FD9\u662F\u666E\u901A\u6587\u672C\u6BB5\u843D\u3002
+
+\u8FD9\u662F\u7B2C\u4E8C\u6BB5\u3002`,
+  list: `- \u9879\u76EE 1
+- \u9879\u76EE 2
+- \u9879\u76EE 3
+`,
+  ordered: `1. \u7B2C\u4E00\u9879
+2. \u7B2C\u4E8C\u9879
+3. \u7B2C\u4E09\u9879
+`,
+  todo: `- [ ] \u672A\u5B8C\u6210\u4EFB\u52A1
+- [x] \u5DF2\u5B8C\u6210\u4EFB\u52A1
+`,
+  quote: `> \u8FD9\u662F\u4E00\u6BB5\u5F15\u7528\u6587\u672C\u3002
+
+> \u591A\u884C\u5F15\u7528\u3002`,
+  code: `\`\`\`javascript
+function hello() {
+  console.log('Hello');
+}
+\`\`\``,
+  divider: `---
+`,
+  link: `\u8FD9\u662F\u4E00\u4E2A [\u94FE\u63A5](https://feishu.cn)\u3002
+`,
+  image: `![\u56FE\u7247](https://example.com/img.png)
+`,
+  mermaid: `\`\`\`mermaid
+graph TD
+    A[\u5F00\u59CB] --> B[\u7ED3\u675F]
+\`\`\``,
+  nested: `- \u4E00\u7EA7\u9879\u76EE
+  - \u4E8C\u7EA7\u9879\u76EE
+    - \u4E09\u7EA7\u9879\u76EE
+`,
+  mixed: `# \u6807\u9898
+
+\u8FD9\u662F\u6BB5\u843D\uFF0C\u5305\u542B**\u7C97\u4F53**\u548C*\u659C\u4F53*\u3002
+
+- \u5217\u8868\u9879
+- \u53E6\u4E00\u9879
+
+\`\`\`\u4EE3\u7801\`\`\``,
+  complex: `# \u5B8C\u6574\u6587\u6863
+
+## \u7AE0\u8282
+
+\u8FD9\u662F\u6BB5\u843D\u3002
+
+- \u5217\u8868\u9879 1
+- \u5217\u8868\u9879 2
+
+
+> \u5F15\u7528\u5757
+
+\`\`\`javascript
+const a = 1;
+\`\`\`
+
+---
+
+## \u4E0B\u4E00\u4E2A\u7AE0\u8282
+
+\u5185\u5BB9\u3002`
+};
+export {
+  MarkdownToLarkConverter,
+  TEST_CASES,
+  generateBlockHtml,
+  generateBlockId,
+  generateHtml,
+  generatePageId,
+  generateRecordId,
+  larkToMarkdown,
+  markdownToLark,
+  parseMarkdown,
+  readClipboard,
+  writeToClipboard
+};
+//# sourceMappingURL=index.mjs.map