@jacobbubu/md-to-lark 1.0.0

package/dist/last/index.js

@@ -0,0 +1,3 @@
+export * from './api.js';
+export { renderLASTToTerminal } from './preview-terminal.js';
+export { serializeLASTToMarkdown } from './to-markdown.js';

package/dist/last/preview-terminal.js

@@ -0,0 +1,296 @@
+import { LAST_TEXTUAL_BLOCK_TYPE_SET } from './textual-block-types.js';
+const ANSI = {
+    reset: '\u001b[0m',
+    bold: '\u001b[1m',
+    italic: '\u001b[3m',
+    underline: '\u001b[4m',
+    strike: '\u001b[9m',
+    inverse: '\u001b[7m',
+    dim: '\u001b[2m',
+    blue: '\u001b[34m',
+    cyan: '\u001b[36m',
+    magenta: '\u001b[35m',
+    yellow: '\u001b[33m',
+    red: '\u001b[31m',
+    green: '\u001b[32m',
+    gray: '\u001b[90m',
+};
+const INLINE_COLOR_TO_ANSI = {
+    light_pink: ANSI.magenta,
+    light_orange: ANSI.yellow,
+    light_yellow: ANSI.yellow,
+    light_green: ANSI.green,
+    light_blue: ANSI.blue,
+    light_purple: ANSI.magenta,
+    light_gray: ANSI.gray,
+    dark_pink: ANSI.magenta,
+    dark_orange: ANSI.yellow,
+    dark_yellow: ANSI.yellow,
+    dark_green: ANSI.green,
+    dark_blue: ANSI.blue,
+    dark_purple: ANSI.magenta,
+    dark_gray: ANSI.gray,
+    dark_silver_gray: ANSI.gray,
+};
+function isTextualBlock(block) {
+    return LAST_TEXTUAL_BLOCK_TYPE_SET.has(block.type);
+}
+function withAnsi(enabled, text, ...codes) {
+    if (!enabled || text.length === 0)
+        return text;
+    const starts = codes.filter((x) => Boolean(x));
+    if (starts.length === 0)
+        return text;
+    return `${starts.join('')}${text}${ANSI.reset}`;
+}
+function blockTypeTag(ctx, block) {
+    if (!ctx.options.showTypeTag)
+        return '';
+    return withAnsi(ctx.options.color, `[${block.type}]`, ANSI.dim);
+}
+function blockIdTag(ctx, block) {
+    if (!ctx.options.showBlockId)
+        return '';
+    return withAnsi(ctx.options.color, `(${block.id})`, ANSI.gray);
+}
+function inlineToText(ctx, inline) {
+    const colorEnabled = ctx.options.color;
+    const applyTextRunStyle = (text) => {
+        const marks = inline.marks;
+        const textColor = marks.textColor ? INLINE_COLOR_TO_ANSI[marks.textColor] : undefined;
+        const decorated = withAnsi(colorEnabled, text, marks.bold ? ANSI.bold : undefined, marks.italic ? ANSI.italic : undefined, marks.underline ? ANSI.underline : undefined, marks.strikethrough ? ANSI.strike : undefined, marks.inlineCode ? ANSI.inverse : undefined, textColor);
+        if (marks.link?.url) {
+            return `${decorated}${withAnsi(colorEnabled, `(${marks.link.url})`, ANSI.blue, ANSI.underline)}`;
+        }
+        return decorated;
+    };
+    switch (inline.kind) {
+        case 'text_run':
+            return applyTextRunStyle(inline.text ?? '');
+        case 'mention_user':
+            return withAnsi(colorEnabled, `@${inline.userId ?? 'unknown'}`, ANSI.cyan);
+        case 'equation':
+            return withAnsi(colorEnabled, `$${inline.latex ?? ''}$`, ANSI.magenta);
+        case 'mention_doc': {
+            const title = inline.title ?? inline.token ?? 'doc';
+            const suffix = inline.url ? `(${inline.url})` : '';
+            return withAnsi(colorEnabled, `[doc:${title}]${suffix}`, ANSI.blue, ANSI.underline);
+        }
+        case 'reminder': {
+            const expire = inline.expireTime ? `@${inline.expireTime}` : '';
+            return withAnsi(colorEnabled, `[reminder${expire}]`, ANSI.yellow);
+        }
+        case 'inline_block':
+            return withAnsi(colorEnabled, `[inline:${inline.blockId ?? 'block'}]`, ANSI.dim);
+        case 'inline_file':
+            return withAnsi(colorEnabled, `[file:${inline.fileToken ?? 'token'}]`, ANSI.dim);
+        case 'link_preview': {
+            const text = inline.title ?? inline.url ?? 'link_preview';
+            return withAnsi(colorEnabled, `[link:${text}]`, ANSI.blue, ANSI.underline);
+        }
+        default:
+            return '';
+    }
+}
+function textualBlockText(ctx, block) {
+    return block.payload.inlines.map((inline) => inlineToText(ctx, inline)).join('');
+}
+function indent(depth) {
+    return '  '.repeat(Math.max(0, depth));
+}
+function pushLine(ctx, line = '') {
+    ctx.lines.push(line);
+}
+function renderTextualBlock(ctx, block, meta) {
+    const gap = `${blockTypeTag(ctx, block)} ${blockIdTag(ctx, block)}`.trim();
+    const suffix = gap.length > 0 ? ` ${gap}` : '';
+    const text = textualBlockText(ctx, block);
+    const baseIndent = indent(meta.depth);
+    const headingLevelMap = {
+        heading1: 1,
+        heading2: 2,
+        heading3: 3,
+        heading4: 4,
+        heading5: 5,
+        heading6: 6,
+        heading7: 7,
+        heading8: 8,
+        heading9: 9,
+    };
+    if (block.type === 'page') {
+        if (text.trim().length > 0) {
+            pushLine(ctx, `${withAnsi(ctx.options.color, text, ANSI.bold)}${suffix}`);
+            if (ctx.options.sectionGapLines > 0) {
+                for (let i = 0; i < ctx.options.sectionGapLines; i += 1) {
+                    pushLine(ctx, '');
+                }
+            }
+        }
+        return;
+    }
+    if (block.type === 'text') {
+        pushLine(ctx, `${baseIndent}${text}${suffix}`);
+        return;
+    }
+    const headingLevel = headingLevelMap[block.type];
+    if (headingLevel) {
+        const hashes = '#'.repeat(headingLevel);
+        pushLine(ctx, `${baseIndent}${withAnsi(ctx.options.color, `${hashes} ${text}`, ANSI.bold)}${suffix}`);
+        return;
+    }
+    if (block.type === 'bullet') {
+        pushLine(ctx, `${baseIndent}• ${text}${suffix}`);
+        return;
+    }
+    if (block.type === 'ordered') {
+        const n = meta.orderedNumber ?? 1;
+        pushLine(ctx, `${baseIndent}${n}. ${text}${suffix}`);
+        return;
+    }
+    if (block.type === 'quote') {
+        pushLine(ctx, `${baseIndent}> ${text}${suffix}`);
+        return;
+    }
+    if (block.type === 'todo') {
+        const done = block.payload.style.done === true;
+        const marker = done ? '[x]' : '[ ]';
+        pushLine(ctx, `${baseIndent}${marker} ${text}${suffix}`);
+        return;
+    }
+    if (block.type === 'code') {
+        const lang = block.payload.style.language ?? 'text';
+        const header = withAnsi(ctx.options.color, `\`\`\`${lang}`, ANSI.dim);
+        pushLine(ctx, `${baseIndent}${header}${suffix}`);
+        pushLine(ctx, `${baseIndent}${text}`);
+        pushLine(ctx, `${baseIndent}${withAnsi(ctx.options.color, '\`\`\`', ANSI.dim)}`);
+        return;
+    }
+    pushLine(ctx, `${baseIndent}${text}${suffix}`);
+}
+function renderContainerPlaceholder(ctx, block, depth) {
+    const prefix = indent(depth);
+    const info = [`[${block.type}]`];
+    if ('payload' in block) {
+        if (block.type === 'image' || block.type === 'board') {
+            const token = block.payload.token ?? 'no-token';
+            const width = block.payload.width ?? 0;
+            const height = block.payload.height ?? 0;
+            info.push(`token=${token}`);
+            if (width > 0 && height > 0) {
+                info.push(`${width}x${height}`);
+            }
+        }
+        if (block.type === 'table') {
+            const rows = block.payload.rowSize ?? 0;
+            const cols = block.payload.columnSize ?? 0;
+            info.push(`rows=${rows}`);
+            info.push(`cols=${cols}`);
+        }
+        if (block.type === 'grid') {
+            info.push(`columns=${block.payload.columnSize ?? 0}`);
+        }
+        if (block.type === 'grid_column') {
+            info.push(`widthRatio=${block.payload.widthRatio ?? 0}`);
+        }
+    }
+    const tags = [blockTypeTag(ctx, block), blockIdTag(ctx, block)].filter((x) => x.length > 0).join(' ');
+    const tail = tags.length > 0 ? ` ${tags}` : '';
+    pushLine(ctx, `${prefix}${withAnsi(ctx.options.color, info.join(' '), ANSI.dim)}${tail}`);
+}
+function renderBlock(ctx, blockId, meta) {
+    const block = ctx.model.blocks[blockId];
+    if (!block) {
+        pushLine(ctx, `${indent(meta.depth)}${withAnsi(ctx.options.color, `[missing:${blockId}]`, ANSI.red)}`);
+        return;
+    }
+    if (isTextualBlock(block)) {
+        renderTextualBlock(ctx, block, meta);
+    }
+    else {
+        renderContainerPlaceholder(ctx, block, meta.depth);
+    }
+    if (block.children.length === 0) {
+        return;
+    }
+    let orderedCounter = 1;
+    for (const childId of block.children) {
+        const child = ctx.model.blocks[childId];
+        let orderedNumber;
+        if (child?.type === 'ordered') {
+            orderedNumber = orderedCounter;
+            orderedCounter += 1;
+        }
+        else {
+            orderedCounter = 1;
+        }
+        const childDepth = block.type === 'bullet' || block.type === 'ordered' ? meta.depth + 1 : meta.depth;
+        renderBlock(ctx, childId, {
+            depth: childDepth,
+            ...(orderedNumber !== undefined ? { orderedNumber } : {}),
+        });
+    }
+}
+function topLevelIds(model) {
+    if ('mode' in model && model.mode === 'fragment') {
+        return [...model.topLevel];
+    }
+    const root = model.blocks[model.rootId];
+    if (!root)
+        return [];
+    return [...root.children];
+}
+export function renderLASTToTerminal(model, options = {}) {
+    const ctx = {
+        model,
+        options: {
+            color: options.color ?? true,
+            showTypeTag: options.showTypeTag ?? false,
+            showBlockId: options.showBlockId ?? false,
+            sectionGapLines: options.sectionGapLines ?? 1,
+        },
+        lines: [],
+    };
+    const headerMode = 'mode' in model && model.mode === 'fragment' ? 'fragment' : 'document';
+    const rootLabel = headerMode === 'document'
+        ? `root=${model.rootId}`
+        : `topLevel=${model.topLevel.length}`;
+    pushLine(ctx, withAnsi(ctx.options.color, `LAST Terminal Preview | ${headerMode} | blocks=${Object.keys(model.blocks).length} | ${rootLabel}`, ANSI.dim));
+    pushLine(ctx, '');
+    if (headerMode === 'document') {
+        const doc = model;
+        const root = doc.blocks[doc.rootId];
+        if (root && isTextualBlock(root)) {
+            renderTextualBlock(ctx, root, { depth: 0 });
+            if (ctx.options.sectionGapLines > 0) {
+                for (let i = 0; i < ctx.options.sectionGapLines; i += 1) {
+                    pushLine(ctx, '');
+                }
+            }
+        }
+    }
+    let orderedCounter = 1;
+    for (const blockId of topLevelIds(model)) {
+        const block = model.blocks[blockId];
+        let orderedNumber;
+        if (block?.type === 'ordered') {
+            orderedNumber = orderedCounter;
+            orderedCounter += 1;
+        }
+        else {
+            orderedCounter = 1;
+        }
+        renderBlock(ctx, blockId, {
+            depth: 0,
+            ...(orderedNumber !== undefined ? { orderedNumber } : {}),
+        });
+        if (ctx.options.sectionGapLines > 0) {
+            for (let i = 0; i < ctx.options.sectionGapLines; i += 1) {
+                pushLine(ctx, '');
+            }
+        }
+    }
+    while (ctx.lines.length > 0 && ctx.lines[ctx.lines.length - 1]?.trim() === '') {
+        ctx.lines.pop();
+    }
+    return `${ctx.lines.join('\n')}\n`;
+}

package/dist/last/textual-block-types.js

@@ -0,0 +1,19 @@
+export const LAST_TEXTUAL_BLOCK_TYPES = [
+    'page',
+    'text',
+    'heading1',
+    'heading2',
+    'heading3',
+    'heading4',
+    'heading5',
+    'heading6',
+    'heading7',
+    'heading8',
+    'heading9',
+    'bullet',
+    'ordered',
+    'code',
+    'quote',
+    'todo',
+];
+export const LAST_TEXTUAL_BLOCK_TYPE_SET = new Set(LAST_TEXTUAL_BLOCK_TYPES);

package/dist/last/to-markdown.js

@@ -0,0 +1,303 @@
+import { LAST_TEXTUAL_BLOCK_TYPE_SET } from './textual-block-types.js';
+function isTextual(block) {
+    return LAST_TEXTUAL_BLOCK_TYPE_SET.has(block.type);
+}
+function topLevelIds(model) {
+    if ('mode' in model && model.mode === 'fragment') {
+        return [...model.topLevel];
+    }
+    const root = model.blocks[model.rootId];
+    if (!root)
+        return [];
+    return [...root.children];
+}
+function escapeTextForMarkdown(text) {
+    return text.replace(/\\/g, '\\\\').replace(/([*_\[\]~`])/g, '\\$1');
+}
+function escapeCodeInline(text) {
+    return text.replace(/`/g, '\\`');
+}
+function applyInlineMarks(inline, base) {
+    let value = base;
+    const marks = inline.marks;
+    if (marks.inlineCode) {
+        value = `\`${escapeCodeInline(value)}\``;
+    }
+    else {
+        if (marks.strikethrough) {
+            value = `~~${value}~~`;
+        }
+        if (marks.bold) {
+            value = `**${value}**`;
+        }
+        if (marks.italic) {
+            value = `*${value}*`;
+        }
+        if (marks.underline) {
+            value = `<u>${value}</u>`;
+        }
+    }
+    if (marks.link?.url) {
+        const label = value.length > 0 ? value : marks.link.url;
+        value = `[${label}](${marks.link.url})`;
+    }
+    return value;
+}
+function inlineToMarkdown(inline) {
+    switch (inline.kind) {
+        case 'text_run': {
+            const text = inline.text ?? '';
+            return applyInlineMarks(inline, escapeTextForMarkdown(text));
+        }
+        case 'mention_user': {
+            return applyInlineMarks(inline, `@${inline.userId ?? 'user'}`);
+        }
+        case 'equation': {
+            return applyInlineMarks(inline, `$${inline.latex ?? ''}$`);
+        }
+        case 'mention_doc': {
+            const title = inline.title ?? inline.token ?? 'doc';
+            const text = inline.url ? `[${title}](${inline.url})` : `[doc:${title}]`;
+            return applyInlineMarks(inline, text);
+        }
+        case 'reminder': {
+            const part = inline.expireTime ? `@${inline.expireTime}` : '';
+            return applyInlineMarks(inline, `[reminder${part}]`);
+        }
+        case 'inline_block': {
+            return applyInlineMarks(inline, `[inline:${inline.blockId ?? 'block'}]`);
+        }
+        case 'inline_file': {
+            return applyInlineMarks(inline, `[file:${inline.fileToken ?? 'token'}]`);
+        }
+        case 'link_preview': {
+            const text = inline.title ?? inline.url ?? 'link_preview';
+            return applyInlineMarks(inline, inline.url ? `[${text}](${inline.url})` : text);
+        }
+        default:
+            return '';
+    }
+}
+function textualInlinesToMarkdown(block) {
+    return block.payload.inlines.map((inline) => inlineToMarkdown(inline)).join('');
+}
+function renderCodeBlock(block, indent) {
+    const lang = block.payload.style.language ?? 'text';
+    const raw = block.payload.inlines
+        .map((inline) => {
+        if (inline.kind === 'text_run') {
+            return inline.text ?? '';
+        }
+        return '';
+    })
+        .join('');
+    const lines = raw.replace(/\n$/, '').split('\n');
+    const out = [];
+    out.push(`${indent}\`\`\`${lang}`);
+    for (const line of lines) {
+        out.push(`${indent}${line}`);
+    }
+    out.push(`${indent}\`\`\``);
+    return out;
+}
+function tableCellText(ctx, cellId) {
+    const cell = ctx.model.blocks[cellId];
+    if (!cell)
+        return '';
+    const firstTextual = cell.children
+        .map((childId) => ctx.model.blocks[childId])
+        .find((child) => Boolean(child && isTextual(child)));
+    if (!firstTextual) {
+        return '';
+    }
+    return textualInlinesToMarkdown(firstTextual).replace(/\n+/g, ' ').trim();
+}
+function renderTable(ctx, block, indent) {
+    const rowSize = block.payload.rowSize ?? 0;
+    const columnSize = block.payload.columnSize ?? 0;
+    if (rowSize <= 0 || columnSize <= 0) {
+        return [`${indent}| table |`, `${indent}| --- |`];
+    }
+    const cells = block.payload.cells && block.payload.cells.length > 0 ? block.payload.cells : block.children;
+    const matrix = [];
+    for (let r = 0; r < rowSize; r += 1) {
+        const row = [];
+        for (let c = 0; c < columnSize; c += 1) {
+            const index = r * columnSize + c;
+            const cellId = cells[index];
+            row.push(cellId ? tableCellText(ctx, cellId) : '');
+        }
+        matrix.push(row);
+    }
+    if (matrix.length === 0) {
+        return [`${indent}| table |`, `${indent}| --- |`];
+    }
+    const out = [];
+    out.push(`${indent}| ${(matrix[0] ?? []).join(' | ')} |`);
+    out.push(`${indent}| ${new Array(columnSize).fill('---').join(' | ')} |`);
+    for (let i = 1; i < matrix.length; i += 1) {
+        const row = matrix[i];
+        if (!row)
+            continue;
+        out.push(`${indent}| ${row.join(' | ')} |`);
+    }
+    return out;
+}
+function renderUnsupportedBlock(block, indent, includeUnsupportedComment) {
+    if (!includeUnsupportedComment) {
+        return [];
+    }
+    return [`${indent}<!-- unsupported:${block.type}:${block.id} -->`];
+}
+function renderNestedChildren(ctx, block, depth, inListItem) {
+    const lines = [];
+    let orderedCounter = 1;
+    for (const childId of block.children) {
+        const child = ctx.model.blocks[childId];
+        if (!child)
+            continue;
+        let number;
+        if (child.type === 'ordered') {
+            number = orderedCounter;
+            orderedCounter += 1;
+        }
+        else {
+            orderedCounter = 1;
+        }
+        const childDepth = inListItem ? depth + 1 : depth;
+        lines.push(...renderBlock(ctx, child, childDepth, number));
+    }
+    return lines;
+}
+function renderTextualBlock(ctx, block, depth, orderedNumber) {
+    const indent = '  '.repeat(Math.max(0, depth));
+    const text = textualInlinesToMarkdown(block);
+    switch (block.type) {
+        case 'page':
+            return text.trim().length > 0 ? [`${text}`] : [];
+        case 'text': {
+            const lines = text.split('\n');
+            return lines.map((line) => `${indent}${line}`);
+        }
+        case 'heading1':
+        case 'heading2':
+        case 'heading3':
+        case 'heading4':
+        case 'heading5':
+        case 'heading6':
+        case 'heading7':
+        case 'heading8':
+        case 'heading9': {
+            const levelRaw = Number(block.type.replace('heading', ''));
+            const level = Number.isFinite(levelRaw) ? Math.max(1, Math.min(6, levelRaw)) : 1;
+            return [`${indent}${'#'.repeat(level)} ${text}`.trimEnd()];
+        }
+        case 'bullet': {
+            const first = `${indent}- ${text}`.trimEnd();
+            const children = renderNestedChildren(ctx, block, depth, true);
+            return [first, ...children];
+        }
+        case 'ordered': {
+            const number = orderedNumber ?? 1;
+            const first = `${indent}${number}. ${text}`.trimEnd();
+            const children = renderNestedChildren(ctx, block, depth, true);
+            return [first, ...children];
+        }
+        case 'todo': {
+            const done = block.payload.style.done === true ? 'x' : ' ';
+            const first = `${indent}- [${done}] ${text}`.trimEnd();
+            const children = renderNestedChildren(ctx, block, depth, true);
+            return [first, ...children];
+        }
+        case 'quote': {
+            const quoteLines = text.split('\n').map((line) => `${indent}> ${line}`.trimEnd());
+            const childLines = renderNestedChildren(ctx, block, depth, false).map((line) => `${indent}> ${line}`);
+            return [...quoteLines, ...childLines];
+        }
+        case 'code': {
+            return renderCodeBlock(block, indent);
+        }
+        default:
+            return [`${indent}${text}`.trimEnd()];
+    }
+}
+function renderBlock(ctx, block, depth, orderedNumber) {
+    if (ctx.stack.has(block.id)) {
+        return [`${'  '.repeat(Math.max(0, depth))}<!-- cycle:${block.id} -->`];
+    }
+    ctx.stack.add(block.id);
+    let lines = [];
+    if (isTextual(block)) {
+        lines = renderTextualBlock(ctx, block, depth, orderedNumber);
+    }
+    else if (block.type === 'table') {
+        lines = renderTable(ctx, block, '  '.repeat(Math.max(0, depth)));
+    }
+    else if (block.type === 'divider') {
+        lines = [`${'  '.repeat(Math.max(0, depth))}---`];
+    }
+    else if (block.type === 'quote_container') {
+        lines = renderNestedChildren(ctx, block, depth, false).map((line) => `${'  '.repeat(Math.max(0, depth))}> ${line}`);
+    }
+    else {
+        lines = renderUnsupportedBlock(block, '  '.repeat(Math.max(0, depth)), ctx.options.includeUnsupportedComment);
+        const childLines = renderNestedChildren(ctx, block, depth, false);
+        if (childLines.length > 0) {
+            lines.push(...childLines);
+        }
+    }
+    ctx.stack.delete(block.id);
+    return lines;
+}
+function normalizeBlankLines(lines) {
+    const out = [];
+    let prevBlank = true;
+    for (const line of lines) {
+        const isBlank = line.trim().length === 0;
+        if (isBlank && prevBlank) {
+            continue;
+        }
+        out.push(line);
+        prevBlank = isBlank;
+    }
+    while (out.length > 0 && out[0]?.trim().length === 0) {
+        out.shift();
+    }
+    while (out.length > 0 && out[out.length - 1]?.trim().length === 0) {
+        out.pop();
+    }
+    return out;
+}
+export function serializeLASTToMarkdown(model, options = {}) {
+    const ctx = {
+        model,
+        options: {
+            includeUnsupportedComment: options.includeUnsupportedComment ?? true,
+        },
+        stack: new Set(),
+    };
+    const lines = [];
+    let orderedCounter = 1;
+    for (const blockId of topLevelIds(model)) {
+        const block = model.blocks[blockId];
+        if (!block)
+            continue;
+        let number;
+        if (block.type === 'ordered') {
+            number = orderedCounter;
+            orderedCounter += 1;
+        }
+        else {
+            orderedCounter = 1;
+        }
+        const chunk = renderBlock(ctx, block, 0, number);
+        if (chunk.length > 0) {
+            if (lines.length > 0) {
+                lines.push('');
+            }
+            lines.push(...chunk);
+        }
+    }
+    const normalized = normalizeBlankLines(lines);
+    return `${normalized.join('\n')}\n`;
+}

package/dist/last/types.js

@@ -0,0 +1,11 @@
+/**
+ * LAST (Lark AST) schema for the pipeline:
+ *   Markdown (GFM) -> HAST -> LAST -> Feishu Docx
+ *
+ * Design goals:
+ * 1) Unambiguous rendering to Feishu docx blocks.
+ * 2) Regex-capable find/replace in top-level text block scopes.
+ * 3) Future selector-based rewrite support.
+ */
+export const LAST_SCHEMA = 'LAST';
+export const LAST_VERSION = '1.0.0';