@jacobbubu/md-to-lark 1.7.1 → 1.8.0

package/README.md

@@ -88,6 +88,18 @@ Progress logs and exceptions are written to stderr.
 
 Relative local assets such as `./img-001.png` still resolve against the Markdown file directory by default. If your caller generates a temporary Markdown file elsewhere, use `--resource-base-dir` to keep local asset resolution pinned to the original content directory.
 
+## Markdown Syntax Notes
+
+Inline `<mark>text</mark>` is supported as a controlled HTML shorthand for Feishu yellow text background highlight.
+
+Example:
+
+```md
+This is <mark>important text</mark>.
+```
+
+Nested Markdown marks inside `<mark>...</mark>`, such as `**bold**` and links, are preserved. This does not enable arbitrary raw HTML rendering; unsupported HTML keeps the existing parser behavior.
+
 ## Common Commands
 
 Basic publish:
@@ -182,6 +194,7 @@ Guardrails:
 - Mermaid `text-drawing` and `board` output paths
 - Opt-in single-dollar inline math parsing for LaTeX-heavy papers
 - Table width heuristics and numeric-column right alignment
+- Inline `<mark>text</mark>` mapped to Feishu yellow text background
 - Chinese Markdown formatting preset (`zh-format`)
 - Ordered preset composition from CLI and programmatic usage
 - Legacy stage cache output from `00-source` to `05-publish`; protocol mode adds contract and semantic stages through `07-publish`

package/dist/pipeline/hast-to-last.js

@@ -511,6 +511,9 @@ function parseInlineNodes(ctx, nodes, marks = createDefaultMarks()) {
         if (node.tagName === 'u') {
             nextMarks.underline = true;
         }
+        if (node.tagName === 'mark') {
+            nextMarks.backgroundColor = 'light_yellow';
+        }
         if (node.tagName === 'a' || node.tagName === 'm2l-footnote-reference') {
             const href = getStringProp(node, 'href');
             nextMarks.link = href ? { url: href } : null;

package/dist/pipeline/markdown/md-to-hast.js

@@ -4,12 +4,14 @@ import remarkGfm from 'remark-gfm';
 import remarkMath from 'remark-math';
 import remarkRehype from 'remark-rehype';
 import { normalizeMarkdownBeforeParse } from './normalize-markdown.js';
+import { remarkMarkToHast } from './remark-mark.js';
 export async function markdownToHast(markdown, options = {}) {
     const content = normalizeMarkdownBeforeParse(markdown);
     const processor = unified()
         .use(remarkParse)
         .use(remarkGfm)
         .use(remarkMath, { singleDollarTextMath: options.singleDollarTextMath ?? false })
+        .use(remarkMarkToHast)
         .use(remarkRehype, { allowDangerousHtml: false });
     const mdast = processor.parse(content);
     const hast = await processor.run(mdast);

package/dist/pipeline/markdown/remark-mark.js

@@ -0,0 +1,83 @@
+const MARK_OPEN_RE = /^<mark(?:\s[^>]*)?>$/i;
+const MARK_CLOSE_RE = /^<\/mark\s*>$/i;
+function isHtmlNode(node) {
+    return node?.type === 'html' && typeof node.value === 'string';
+}
+function isMarkOpen(node) {
+    return isHtmlNode(node) && MARK_OPEN_RE.test(node.value.trim());
+}
+function isMarkClose(node) {
+    return isHtmlNode(node) && MARK_CLOSE_RE.test(node.value.trim());
+}
+function toMarkNode(open, close, children) {
+    const markNode = {
+        type: 'mark',
+        children,
+        data: {
+            hName: 'mark',
+        },
+    };
+    if (open.position?.start && close.position?.end) {
+        markNode.position = {
+            start: open.position.start,
+            end: close.position.end,
+        };
+    }
+    return markNode;
+}
+function rewriteMarkPairs(children) {
+    const rewritten = [];
+    let cursor = 0;
+    while (cursor < children.length) {
+        const node = children[cursor];
+        if (!node) {
+            cursor += 1;
+            continue;
+        }
+        if (!isMarkOpen(node)) {
+            rewritten.push(node);
+            cursor += 1;
+            continue;
+        }
+        const markChildren = [];
+        let depth = 1;
+        let closeIndex = -1;
+        for (let index = cursor + 1; index < children.length; index += 1) {
+            const child = children[index];
+            if (!child)
+                continue;
+            if (isMarkOpen(child)) {
+                depth += 1;
+            }
+            if (isMarkClose(child)) {
+                depth -= 1;
+                if (depth === 0) {
+                    closeIndex = index;
+                    break;
+                }
+            }
+            markChildren.push(child);
+        }
+        if (closeIndex === -1) {
+            rewritten.push(node);
+            cursor += 1;
+            continue;
+        }
+        rewritten.push(toMarkNode(node, children[closeIndex], rewriteMarkPairs(markChildren)));
+        cursor = closeIndex + 1;
+    }
+    return rewritten;
+}
+function visit(node) {
+    if (!Array.isArray(node.children))
+        return;
+    for (const child of node.children) {
+        visit(child);
+    }
+    node.children = rewriteMarkPairs(node.children);
+}
+export const remarkMarkToHast = function remarkMarkToHast() {
+    return (tree) => {
+        visit(tree);
+    };
+};

package/package.json

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