@jacobbubu/md-to-lark 1.0.0

package/dist/preview/index.js

@@ -0,0 +1 @@
+export { renderHASTToTerminal, renderMarkdownToTerminal } from './markdown-terminal.js';

package/dist/preview/markdown-terminal.js

@@ -0,0 +1,350 @@
+import { markdownToHast } from '../pipeline/markdown/md-to-hast.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',
+    red: '\u001b[31m',
+};
+function withAnsi(enabled, text, ...codes) {
+    if (!enabled || text.length === 0)
+        return text;
+    const start = codes.filter((x) => Boolean(x));
+    if (start.length === 0)
+        return text;
+    return `${start.join('')}${text}${ANSI.reset}`;
+}
+function isElement(node, tagName) {
+    if (node.type !== 'element')
+        return false;
+    if (!tagName)
+        return true;
+    return node.tagName === tagName;
+}
+function asChildren(node) {
+    return [...node.children];
+}
+function toText(node) {
+    if (node.type === 'text') {
+        return node.value;
+    }
+    if (!isElement(node)) {
+        return '';
+    }
+    const children = asChildren(node);
+    return children.map((child) => toText(child)).join('');
+}
+function getClassNames(element) {
+    const raw = element.properties?.className;
+    if (Array.isArray(raw)) {
+        return raw.map((item) => String(item));
+    }
+    if (typeof raw === 'string') {
+        return raw.split(/\s+/).filter((x) => x.length > 0);
+    }
+    return [];
+}
+function parseCodeLanguage(codeElement) {
+    const classNames = getClassNames(codeElement);
+    for (const name of classNames) {
+        if (name.startsWith('language-') && name.length > 'language-'.length) {
+            return name.slice('language-'.length);
+        }
+    }
+    return 'text';
+}
+function renderInline(node, ctx) {
+    if (node.type === 'text') {
+        return node.value;
+    }
+    if (!isElement(node)) {
+        return '';
+    }
+    const childrenText = asChildren(node)
+        .map((child) => renderInline(child, ctx))
+        .join('');
+    if (node.tagName === 'strong') {
+        return withAnsi(ctx.options.color, childrenText, ANSI.bold);
+    }
+    if (node.tagName === 'em') {
+        return withAnsi(ctx.options.color, childrenText, ANSI.italic);
+    }
+    if (node.tagName === 'del') {
+        return withAnsi(ctx.options.color, childrenText, ANSI.strike);
+    }
+    if (node.tagName === 'code') {
+        return withAnsi(ctx.options.color, childrenText, ANSI.inverse);
+    }
+    if (node.tagName === 'a') {
+        const href = typeof node.properties?.href === 'string' ? node.properties.href : '';
+        const text = childrenText.length > 0 ? childrenText : href;
+        if (!href) {
+            return text;
+        }
+        return `${withAnsi(ctx.options.color, text, ANSI.blue, ANSI.underline)}(${href})`;
+    }
+    if (node.tagName === 'br') {
+        return '\n';
+    }
+    if (node.tagName === 'img') {
+        const alt = typeof node.properties?.alt === 'string' ? node.properties.alt : '';
+        const src = typeof node.properties?.src === 'string' ? node.properties.src : '';
+        return withAnsi(ctx.options.color, `![${alt}](${src})`, ANSI.dim);
+    }
+    return childrenText;
+}
+function renderInlineChildren(nodes, ctx) {
+    return nodes.map((node) => renderInline(node, ctx)).join('');
+}
+function pushLine(ctx, line = '') {
+    ctx.lines.push(line);
+}
+function indent(depth) {
+    return '  '.repeat(Math.max(0, depth));
+}
+function pushSectionGap(ctx) {
+    for (let i = 0; i < ctx.options.sectionGapLines; i += 1) {
+        pushLine(ctx, '');
+    }
+}
+function renderParagraph(element, ctx, depth) {
+    const text = renderInlineChildren(asChildren(element), ctx);
+    const prefix = indent(depth);
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? '';
+        pushLine(ctx, `${prefix}${line}`);
+    }
+}
+function renderHeading(element, ctx, depth) {
+    const level = Number(element.tagName.slice(1));
+    const marker = '#'.repeat(Math.max(1, Math.min(6, Number.isFinite(level) ? level : 1)));
+    const text = renderInlineChildren(asChildren(element), ctx);
+    pushLine(ctx, `${indent(depth)}${withAnsi(ctx.options.color, `${marker} ${text}`, ANSI.bold)}`);
+}
+function renderCodeBlock(element, ctx, depth) {
+    const prefix = indent(depth);
+    const code = asChildren(element).find((node) => isElement(node, 'code'));
+    const language = code ? parseCodeLanguage(code) : 'text';
+    const raw = code ? toText(code) : toText(element);
+    pushLine(ctx, `${prefix}${withAnsi(ctx.options.color, `\`\`\`${language}`, ANSI.dim)}`);
+    const lines = raw.replace(/\n$/, '').split('\n');
+    for (const line of lines) {
+        pushLine(ctx, `${prefix}${line}`);
+    }
+    pushLine(ctx, `${prefix}${withAnsi(ctx.options.color, '\`\`\`', ANSI.dim)}`);
+}
+function renderBlockquote(element, ctx, depth) {
+    const temp = {
+        options: ctx.options,
+        lines: [],
+    };
+    for (const child of asChildren(element)) {
+        renderBlock(child, temp, 0);
+    }
+    for (const line of temp.lines) {
+        const prefix = indent(depth);
+        if (line.trim().length === 0) {
+            pushLine(ctx, `${prefix}>`);
+        }
+        else {
+            pushLine(ctx, `${prefix}> ${line}`);
+        }
+    }
+}
+function renderTable(element, ctx, depth) {
+    const rows = [];
+    let headerRows = 0;
+    const appendRows = (container, isHeader) => {
+        const trNodes = asChildren(container).filter((child) => isElement(child, 'tr'));
+        for (const tr of trNodes) {
+            const cellNodes = asChildren(tr).filter((child) => isElement(child));
+            const cells = cellNodes
+                .filter((cell) => cell.tagName === 'th' || cell.tagName === 'td')
+                .map((cell) => renderInlineChildren(asChildren(cell), ctx));
+            rows.push(cells);
+            if (isHeader) {
+                headerRows += 1;
+            }
+        }
+    };
+    for (const child of asChildren(element)) {
+        if (!isElement(child))
+            continue;
+        if (child.tagName === 'thead') {
+            appendRows(child, true);
+            continue;
+        }
+        if (child.tagName === 'tbody' || child.tagName === 'tfoot') {
+            appendRows(child, false);
+            continue;
+        }
+        if (child.tagName === 'tr') {
+            appendRows({
+                type: 'element',
+                tagName: 'tbody',
+                properties: {},
+                children: [child],
+            }, false);
+        }
+    }
+    if (rows.length === 0) {
+        pushLine(ctx, `${indent(depth)}${withAnsi(ctx.options.color, '[table]', ANSI.dim)}`);
+        return;
+    }
+    const colCount = rows.reduce((max, row) => Math.max(max, row.length), 0);
+    const widths = new Array(colCount).fill(3);
+    for (const row of rows) {
+        for (let i = 0; i < colCount; i += 1) {
+            const cell = row[i] ?? '';
+            widths[i] = Math.max(widths[i] ?? 3, cell.length);
+        }
+    }
+    const formatRow = (row) => {
+        const cells = [];
+        for (let i = 0; i < colCount; i += 1) {
+            const content = row[i] ?? '';
+            const width = widths[i] ?? 3;
+            cells.push(content.padEnd(width, ' '));
+        }
+        return `| ${cells.join(' | ')} |`;
+    };
+    const prefix = indent(depth);
+    pushLine(ctx, `${prefix}${formatRow(rows[0] ?? [])}`);
+    if (headerRows > 0 || rows.length > 1) {
+        const separator = widths.map((width) => '-'.repeat(Math.max(3, width))).join(' | ');
+        pushLine(ctx, `${prefix}| ${separator} |`);
+    }
+    for (let i = 1; i < rows.length; i += 1) {
+        const row = rows[i];
+        if (!row)
+            continue;
+        pushLine(ctx, `${prefix}${formatRow(row)}`);
+    }
+}
+function renderListItem(li, ctx, depth, marker) {
+    const prefix = indent(depth);
+    const children = asChildren(li);
+    const nestedLists = children.filter((child) => isElement(child) && (child.tagName === 'ul' || child.tagName === 'ol'));
+    const nonNested = children.filter((child) => !(isElement(child) && (child.tagName === 'ul' || child.tagName === 'ol')));
+    const firstParagraph = nonNested.find((child) => isElement(child, 'p'));
+    const firstLine = firstParagraph
+        ? renderInlineChildren(asChildren(firstParagraph), ctx)
+        : renderInlineChildren(nonNested, ctx);
+    pushLine(ctx, `${prefix}${marker} ${firstLine}`.trimEnd());
+    const extraBlocks = nonNested.filter((child) => child !== firstParagraph);
+    for (const block of extraBlocks) {
+        if (!isElement(block))
+            continue;
+        if (block.tagName === 'p') {
+            renderParagraph(block, ctx, depth + 1);
+        }
+        else if (block.tagName === 'pre') {
+            renderCodeBlock(block, ctx, depth + 1);
+        }
+        else if (block.tagName === 'blockquote') {
+            renderBlockquote(block, ctx, depth + 1);
+        }
+    }
+    for (const list of nestedLists) {
+        renderList(list, ctx, depth + 1);
+    }
+}
+function renderList(element, ctx, depth) {
+    const isOrdered = element.tagName === 'ol';
+    const rawStart = element.properties?.start;
+    const start = typeof rawStart === 'number' ? rawStart : Number(rawStart ?? 1);
+    let counter = Number.isFinite(start) && start > 0 ? start : 1;
+    const items = asChildren(element).filter((child) => isElement(child, 'li'));
+    for (const item of items) {
+        const marker = isOrdered ? `${counter}.` : '•';
+        renderListItem(item, ctx, depth, marker);
+        if (isOrdered) {
+            counter += 1;
+        }
+    }
+}
+function renderBlock(node, ctx, depth) {
+    if (node.type === 'text') {
+        const text = node.value.trim();
+        if (text.length > 0) {
+            pushLine(ctx, `${indent(depth)}${text}`);
+        }
+        return;
+    }
+    if (!isElement(node)) {
+        return;
+    }
+    switch (node.tagName) {
+        case 'p':
+            renderParagraph(node, ctx, depth);
+            break;
+        case 'h1':
+        case 'h2':
+        case 'h3':
+        case 'h4':
+        case 'h5':
+        case 'h6':
+            renderHeading(node, ctx, depth);
+            break;
+        case 'ul':
+        case 'ol':
+            renderList(node, ctx, depth);
+            break;
+        case 'pre':
+            renderCodeBlock(node, ctx, depth);
+            break;
+        case 'blockquote':
+            renderBlockquote(node, ctx, depth);
+            break;
+        case 'hr':
+            pushLine(ctx, `${indent(depth)}${withAnsi(ctx.options.color, '---', ANSI.dim)}`);
+            break;
+        case 'table':
+            renderTable(node, ctx, depth);
+            break;
+        default: {
+            const inlineText = renderInlineChildren(asChildren(node), ctx);
+            if (inlineText.trim().length > 0) {
+                pushLine(ctx, `${indent(depth)}${inlineText}`);
+            }
+            break;
+        }
+    }
+}
+export function renderHASTToTerminal(root, options = {}) {
+    const ctx = {
+        options: {
+            color: options.color ?? true,
+            sectionGapLines: options.sectionGapLines ?? 1,
+            showHeader: options.showHeader ?? true,
+        },
+        lines: [],
+    };
+    if (ctx.options.showHeader) {
+        pushLine(ctx, withAnsi(ctx.options.color, 'Markdown Terminal Preview', ANSI.dim));
+        pushLine(ctx, '');
+    }
+    const blocks = asChildren(root);
+    for (let i = 0; i < blocks.length; i += 1) {
+        const block = blocks[i];
+        if (!block)
+            continue;
+        renderBlock(block, ctx, 0);
+        if (i !== blocks.length - 1) {
+            pushSectionGap(ctx);
+        }
+    }
+    while (ctx.lines.length > 0 && ctx.lines[ctx.lines.length - 1]?.trim() === '') {
+        ctx.lines.pop();
+    }
+    return `${ctx.lines.join('\n')}\n`;
+}
+export async function renderMarkdownToTerminal(markdown, options = {}) {
+    const hast = await markdownToHast(markdown);
+    return renderHASTToTerminal(hast, options);
+}

package/dist/publish/asset-adapter.js

@@ -0,0 +1,123 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { createDefaultMarks, extractTextFromInlines, firstInlineLinkUrl, getPathExtension, inferMediaKind, isTextualBlock, resolveLocalPathFromSource, shouldUsePreviewView, stripQueryAndHash, } from './common.js';
+export function applyStandaloneAttachmentTransforms(last, baseDir) {
+    const localAssetByBlockId = new Map();
+    for (const block of Object.values(last.blocks)) {
+        if (!isTextualBlock(block) || block.type !== 'text') {
+            continue;
+        }
+        if (block.children.length > 0) {
+            continue;
+        }
+        const linkUrl = firstInlineLinkUrl(block);
+        if (!linkUrl) {
+            continue;
+        }
+        const resolvedPath = resolveLocalPathFromSource(linkUrl, baseDir);
+        if (!resolvedPath) {
+            continue;
+        }
+        if (!existsSync(resolvedPath)) {
+            continue;
+        }
+        const extension = getPathExtension(linkUrl);
+        const mediaKind = inferMediaKind(extension);
+        const displayName = extractTextFromInlines(block.payload.inlines).trim();
+        const fileName = displayName.length > 0 ? displayName : path.basename(stripQueryAndHash(linkUrl));
+        if (mediaKind === 'image') {
+            const transformed = {
+                id: block.id,
+                ...(block.bttId ? { bttId: block.bttId } : {}),
+                type: 'image',
+                parentId: block.parentId,
+                children: [],
+                payload: {
+                    width: 0,
+                    height: 0,
+                    token: '',
+                    align: 'left',
+                },
+                selector: {
+                    attrs: {
+                        sourceUrl: linkUrl,
+                    },
+                },
+            };
+            last.blocks[block.id] = transformed;
+            localAssetByBlockId.set(block.id, {
+                kind: 'image',
+                absolutePath: resolvedPath,
+                fileName: path.basename(resolvedPath),
+                mediaKind,
+            });
+            continue;
+        }
+        const transformed = {
+            id: block.id,
+            ...(block.bttId ? { bttId: block.bttId } : {}),
+            type: 'file',
+            parentId: block.parentId,
+            children: [],
+            payload: {
+                name: fileName,
+                viewType: shouldUsePreviewView(extension, mediaKind) ? 2 : 1,
+            },
+            selector: {
+                attrs: {
+                    sourceUrl: linkUrl,
+                },
+            },
+        };
+        last.blocks[block.id] = transformed;
+        localAssetByBlockId.set(block.id, {
+            kind: 'file',
+            absolutePath: resolvedPath,
+            fileName: path.basename(resolvedPath),
+            mediaKind,
+        });
+    }
+    for (const block of Object.values(last.blocks)) {
+        if (block.type !== 'image')
+            continue;
+        const sourceUrl = block.selector && block.selector.attrs && typeof block.selector.attrs.sourceUrl === 'string'
+            ? String(block.selector.attrs.sourceUrl)
+            : '';
+        if (!sourceUrl)
+            continue;
+        const resolvedPath = resolveLocalPathFromSource(sourceUrl, baseDir);
+        if (!resolvedPath)
+            continue;
+        if (!existsSync(resolvedPath)) {
+            last.blocks[block.id] = {
+                id: block.id,
+                ...(block.bttId ? { bttId: block.bttId } : {}),
+                type: 'text',
+                parentId: block.parentId,
+                children: [],
+                payload: {
+                    style: {
+                        align: 'left',
+                        language: null,
+                    },
+                    inlines: [
+                        {
+                            id: `i_missing_${block.id}`,
+                            kind: 'text_run',
+                            marks: createDefaultMarks(),
+                            text: sourceUrl,
+                        },
+                    ],
+                },
+            };
+            continue;
+        }
+        localAssetByBlockId.set(block.id, {
+            kind: 'image',
+            absolutePath: resolvedPath,
+            fileName: path.basename(resolvedPath),
+            mediaKind: 'image',
+        });
+    }
+    return localAssetByBlockId;
+}

package/dist/publish/btt-patch.js

@@ -0,0 +1,65 @@
+import path from 'node:path';
+import { getLarkBlockTypeName } from '../lark/index.js';
+import { DEFAULT_MERMAID_RENDER_CONFIG, } from '../lark/docx/render-types.js';
+import { shouldUsePreviewView, toObjectRecord } from './common.js';
+const MERMAID_COMPONENT_TYPE_ID = 'blk_631fefbbae02400430b8f9f4';
+function applyRawBlockPatch(rawBlock, blockId, mermaidByBlockId, assetByBlockId, mermaidRenderConfig) {
+    const mermaid = mermaidByBlockId.get(blockId);
+    if (mermaid) {
+        rawBlock.block_type = mermaidRenderConfig.target === 'board' ? 43 : 40;
+        for (const key of Object.keys(rawBlock)) {
+            if (key === 'block_id' || key === 'parent_id' || key === 'children' || key === 'block_type')
+                continue;
+            delete rawBlock[key];
+        }
+        if (mermaidRenderConfig.target === 'board') {
+            rawBlock.board = {};
+        }
+        else {
+            rawBlock.add_ons = {
+                component_type_id: MERMAID_COMPONENT_TYPE_ID,
+                record: JSON.stringify({
+                    data: mermaid.code,
+                    theme: 'default',
+                    view: 'chart',
+                }),
+            };
+        }
+    }
+    const asset = assetByBlockId.get(blockId);
+    if (!asset)
+        return;
+    if (asset.kind === 'image') {
+        rawBlock.block_type = 27;
+        const image = toObjectRecord(rawBlock.image) ?? {};
+        image.local_path = asset.absolutePath;
+        rawBlock.image = image;
+        return;
+    }
+    rawBlock.block_type = 23;
+    const file = toObjectRecord(rawBlock.file) ?? {};
+    file.local_path = asset.absolutePath;
+    file.name = typeof file.name === 'string' && file.name.trim().length > 0 ? file.name : asset.fileName;
+    if (asset.mediaKind) {
+        file.media_kind = asset.mediaKind;
+    }
+    if (typeof file.view_type !== 'number') {
+        file.view_type = shouldUsePreviewView(path.extname(asset.fileName).toLowerCase(), asset.mediaKind ?? 'file') ? 2 : 1;
+    }
+    rawBlock.file = file;
+}
+export function patchBTTForMermaidAndAssets(btt, mermaidByBlockId, assetByBlockId, options) {
+    const mermaidRenderConfig = options?.mermaidRender ?? DEFAULT_MERMAID_RENDER_CONFIG;
+    const walk = (node) => {
+        applyRawBlockPatch(node.rawBlock, node.blockId, mermaidByBlockId, assetByBlockId, mermaidRenderConfig);
+        node.blockType = node.rawBlock.block_type;
+        node.blockTypeName = getLarkBlockTypeName(node.blockType);
+        for (const child of node.children) {
+            walk(child);
+        }
+    };
+    walk(btt.root);
+    for (const [blockId, rawBlock] of Object.entries(btt.flatBlocks)) {
+        applyRawBlockPatch(rawBlock, blockId, mermaidByBlockId, assetByBlockId, mermaidRenderConfig);
+    }
+}

package/dist/publish/common.js

@@ -0,0 +1,139 @@
+import path from 'node:path';
+import { LAST_TEXTUAL_BLOCK_TYPE_SET } from '../last/textual-block-types.js';
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg']);
+const VIDEO_EXTENSIONS = new Set(['.mp4', '.mov', '.m4v', '.avi', '.mkv', '.webm']);
+const AUDIO_EXTENSIONS = new Set(['.mp3', '.wav', '.aac', '.m4a', '.flac', '.ogg', '.oga', '.opus']);
+const PREVIEWABLE_FILE_EXTENSIONS = new Set([
+    '.pdf',
+    '.doc',
+    '.docx',
+    '.xls',
+    '.xlsx',
+    '.ppt',
+    '.pptx',
+    ...VIDEO_EXTENSIONS,
+    ...AUDIO_EXTENSIONS,
+]);
+export function toObjectRecord(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+export function isTextualBlock(block) {
+    return LAST_TEXTUAL_BLOCK_TYPE_SET.has(block.type);
+}
+export function stripQueryAndHash(url) {
+    return url.split('#', 1)[0]?.split('?', 1)[0] ?? url;
+}
+export function safeDecodeURIComponent(input) {
+    try {
+        return decodeURIComponent(input);
+    }
+    catch {
+        return input;
+    }
+}
+export function getPathExtension(url) {
+    const clean = safeDecodeURIComponent(stripQueryAndHash(url));
+    return path.extname(clean).toLowerCase();
+}
+export function isHttpLike(url) {
+    return /^[a-z][a-z0-9+.-]*:/i.test(url);
+}
+export function resolveLocalPathFromSource(sourceUrl, baseDir) {
+    const raw = sourceUrl.trim();
+    if (!raw)
+        return null;
+    if (isHttpLike(raw)) {
+        if (/^https?:/i.test(raw)) {
+            return null;
+        }
+        return null;
+    }
+    const decoded = safeDecodeURIComponent(stripQueryAndHash(raw));
+    const absolute = path.isAbsolute(decoded) ? decoded : path.resolve(baseDir, decoded);
+    return absolute;
+}
+export function inferMediaKind(extension) {
+    if (IMAGE_EXTENSIONS.has(extension))
+        return 'image';
+    if (VIDEO_EXTENSIONS.has(extension))
+        return 'video';
+    if (AUDIO_EXTENSIONS.has(extension))
+        return 'audio';
+    return 'file';
+}
+export function shouldUsePreviewView(extension, mediaKind) {
+    if (mediaKind === 'video' || mediaKind === 'audio')
+        return true;
+    return PREVIEWABLE_FILE_EXTENSIONS.has(extension);
+}
+export function createDefaultMarks() {
+    return {
+        bold: false,
+        italic: false,
+        strikethrough: false,
+        underline: false,
+        inlineCode: false,
+        textColor: null,
+        backgroundColor: null,
+        link: null,
+    };
+}
+export function extractTextFromInlines(inlines) {
+    let out = '';
+    for (const inline of inlines) {
+        if (inline.kind === 'text_run') {
+            out += inline.text ?? '';
+            continue;
+        }
+        if (inline.kind === 'mention_user') {
+            out += inline.userId ?? '';
+            continue;
+        }
+        if (inline.kind === 'equation') {
+            out += inline.latex ?? '';
+            continue;
+        }
+        if (inline.kind === 'mention_doc') {
+            out += inline.title ?? '';
+            continue;
+        }
+        if (inline.kind === 'link_preview') {
+            out += inline.title ?? inline.url ?? '';
+        }
+    }
+    return out;
+}
+export function firstInlineLinkUrl(block) {
+    if (block.payload.inlines.length === 0)
+        return null;
+    let resolvedUrl = '';
+    for (const inline of block.payload.inlines) {
+        if (inline.kind !== 'text_run')
+            return null;
+        const linkUrl = inline.marks.link?.url;
+        if (typeof linkUrl !== 'string' || linkUrl.trim().length === 0) {
+            return null;
+        }
+        const normalized = linkUrl.trim();
+        if (!resolvedUrl) {
+            resolvedUrl = normalized;
+            continue;
+        }
+        if (resolvedUrl !== normalized) {
+            return null;
+        }
+    }
+    return resolvedUrl || null;
+}
+export function toPlainTextFromInlineList(inlines) {
+    let out = '';
+    for (const inline of inlines) {
+        if (inline.kind === 'text_run') {
+            out += inline.text ?? '';
+        }
+        else {
+            out += extractTextFromInlines([inline]);
+        }
+    }
+    return out;
+}

package/dist/publish/ids.js

@@ -0,0 +1,9 @@
+import path from 'node:path';
+export function buildPipelineDocumentId(inputFile) {
+    const base = path.basename(inputFile, path.extname(inputFile));
+    const safe = base
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return safe ? `md-${safe}` : 'md-doc';
+}

package/dist/publish/index.js

@@ -0,0 +1,7 @@
+export { applyStandaloneAttachmentTransforms } from './asset-adapter.js';
+export { patchBTTForMermaidAndAssets } from './btt-patch.js';
+export { buildPipelineDocumentId } from './ids.js';
+export { applyTableColumnWidthHeuristics, collectMermaidPatches, ensureLastBlockBttIds } from './last-normalize.js';
+export { processSingleMarkdownFile } from './process-file.js';
+export { buildPublishRuntime, logPublishRuntimeSummary } from './runtime.js';
+export { buildPipelineStagePaths, ensureDir, writeJson, writeSourceStage, writePrepareStage, writePrepareLogFile, writeHastStage, writeLastStage, writeBttStage, writePublishStageArtifact, } from './stage-cache.js';