@jacobbubu/md-to-lark 1.4.9 → 1.4.10

package/dist/pipeline/markdown/normalize-markdown.js

@@ -3,6 +3,9 @@ import remarkParse from 'remark-parse';
 const CJK_BOLD_TRAILING_PUNCTUATION = new Set(['，', '。', '；', '：', '！', '？', '、', '）', '》', '】', '」', '』']);
 const NORMALIZATION_NEXT_CHAR_RE = /[\p{Script=Han}\p{Letter}\p{Number}\[]/u;
 const PROTECTED_NODE_TYPES = new Set(['code', 'inlineCode', 'html']);
+function parseMarkdown(markdown) {
+    return unified().use(remarkParse).parse(markdown);
+}
 function mergeProtectedRanges(ranges) {
     const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
     const merged = [];
@@ -19,7 +22,7 @@ function mergeProtectedRanges(ranges) {
     return merged;
 }
 function collectProtectedRanges(markdown) {
-    const tree = unified().use(remarkParse).parse(markdown);
+    const tree = parseMarkdown(markdown);
     const ranges = [];
     const visit = (node) => {
         if (!node || typeof node !== 'object')
@@ -42,19 +45,84 @@ function collectProtectedRanges(markdown) {
     visit(tree);
     return mergeProtectedRanges(ranges);
 }
-function collectCjkBoldNormalizationEdits(segment, baseOffset) {
+function collectParsedStrongRanges(markdown) {
+    const tree = parseMarkdown(markdown);
+    const ranges = [];
+    const visit = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        const record = node;
+        const start = record.position?.start?.offset;
+        const end = record.position?.end?.offset;
+        if (record.type === 'strong' && typeof start === 'number' && typeof end === 'number' && end > start) {
+            const raw = markdown.slice(start, end);
+            if (raw.startsWith('**') && raw.endsWith('**')) {
+                ranges.push({ start, end });
+            }
+        }
+        for (const child of record.children ?? []) {
+            visit(child);
+        }
+    };
+    visit(tree);
+    return ranges.sort((a, b) => a.start - b.start || a.end - b.end);
+}
+function canDelimiterCloseCjkBoldCandidate(markdown, close, blockedOpeningOffsets) {
+    const punctuation = markdown[close - 1] ?? '';
+    const nextChar = markdown[close + 2] ?? '';
+    if (!CJK_BOLD_TRAILING_PUNCTUATION.has(punctuation) || !NORMALIZATION_NEXT_CHAR_RE.test(nextChar)) {
+        return false;
+    }
+    let searchFrom = close - 1;
+    while (searchFrom >= 0) {
+        const open = markdown.lastIndexOf('**', searchFrom);
+        if (open === -1)
+            return false;
+        if (blockedOpeningOffsets.has(open) || (open > 0 && markdown[open - 1] === '*')) {
+            searchFrom = open - 1;
+            continue;
+        }
+        const rawContent = markdown.slice(open + 2, close);
+        if (rawContent.includes('\n')) {
+            return false;
+        }
+        if (rawContent.includes('**')) {
+            searchFrom = open - 1;
+            continue;
+        }
+        const firstContentChar = markdown[open + 2] ?? '';
+        const content = markdown.slice(open + 2, close - 1);
+        return Boolean(content &&
+            firstContentChar &&
+            !/\s/u.test(firstContentChar) &&
+            !CJK_BOLD_TRAILING_PUNCTUATION.has(firstContentChar));
+    }
+    return false;
+}
+function collectTrustedStrongClosingDelimiters(markdown) {
+    const trustedClosingDelimiters = new Set();
+    for (const range of collectParsedStrongRanges(markdown)) {
+        if (canDelimiterCloseCjkBoldCandidate(markdown, range.start, trustedClosingDelimiters)) {
+            continue;
+        }
+        trustedClosingDelimiters.add(range.end - 2);
+    }
+    return trustedClosingDelimiters;
+}
+function collectCjkBoldNormalizationEdits(segment, baseOffset, blockedOpeningOffsets) {
     const edits = [];
     let cursor = 0;
     while (cursor < segment.length - 1) {
         const open = segment.indexOf('**', cursor);
         if (open === -1)
             break;
-        if (open > 0 && segment[open - 1] === '*') {
+        const absoluteOpen = baseOffset + open;
+        if (blockedOpeningOffsets.has(absoluteOpen) || (open > 0 && segment[open - 1] === '*')) {
             cursor = open + 2;
             continue;
         }
         const firstContentChar = segment[open + 2] ?? '';
-        if (!firstContentChar || /\s/u.test(firstContentChar)) {
+        if (!firstContentChar || /\s/u.test(firstContentChar) || CJK_BOLD_TRAILING_PUNCTUATION.has(firstContentChar)) {
             cursor = open + 2;
             continue;
         }
@@ -120,16 +188,17 @@ export function rewriteLeadingFrontmatterAsCodeFence(markdown) {
 }
 export function normalizeChineseBoldClosingPunctuation(markdown) {
     const protectedRanges = collectProtectedRanges(markdown);
+    const trustedStrongClosingDelimiters = collectTrustedStrongClosingDelimiters(markdown);
     const edits = [];
     let cursor = 0;
     for (const range of protectedRanges) {
         if (cursor < range.start) {
-            edits.push(...collectCjkBoldNormalizationEdits(markdown.slice(cursor, range.start), cursor));
+            edits.push(...collectCjkBoldNormalizationEdits(markdown.slice(cursor, range.start), cursor, trustedStrongClosingDelimiters));
         }
         cursor = Math.max(cursor, range.end);
     }
     if (cursor < markdown.length) {
-        edits.push(...collectCjkBoldNormalizationEdits(markdown.slice(cursor), cursor));
+        edits.push(...collectCjkBoldNormalizationEdits(markdown.slice(cursor), cursor, trustedStrongClosingDelimiters));
     }
     return applyTextEdits(markdown, edits);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacobbubu/md-to-lark",
-  "version": "1.4.9",
+  "version": "1.4.10",
   "description": "Publish Markdown to Feishu docs with a stable pipeline.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",