@jianwen-lang/parser 0.1.1

package/dist/html/render/blocks.js

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderBlocksToHtml = renderBlocksToHtml;
+exports.renderBlockToHtml = renderBlockToHtml;
+const utils_1 = require("./utils");
+const inlines_1 = require("./inlines");
+function renderBlocksToHtml(blocks, options = {}) {
+    const result = [];
+    let i = 0;
+    function wrapBlock(html) {
+        if (!html || !html.trim())
+            return '';
+        if (options.suppressBlockWrapper)
+            return html;
+        return `<div class="jw-block">${html}</div>`;
+    }
+    while (i < blocks.length) {
+        const block = blocks[i];
+        if (!block) {
+            i++;
+            continue;
+        }
+        if (block.type === 'heading' && block.foldable) {
+            const headingHtml = renderHeadingBlock(block, options);
+            const foldedBlocks = [];
+            let j = i + 1;
+            while (j < blocks.length) {
+                const nextBlock = blocks[j];
+                if (!nextBlock) {
+                    j++;
+                    continue;
+                }
+                const nextAttrs = 'blockAttrs' in nextBlock ? nextBlock.blockAttrs : undefined;
+                if (nextAttrs?.fold) {
+                    foldedBlocks.push(wrapBlock(renderBlockToHtml(nextBlock, options)));
+                    j++;
+                }
+                else {
+                    break;
+                }
+            }
+            const detailsContent = foldedBlocks.join('');
+            const detailsHtml = `<details class="jw-foldable-section">${headingHtml}${detailsContent}</details>`;
+            result.push(wrapBlock(detailsHtml));
+            i = j;
+            continue;
+        }
+        const blockAttrs = 'blockAttrs' in block ? block.blockAttrs : undefined;
+        if (!blockAttrs?.sameLine) {
+            result.push(wrapBlock(renderBlockToHtml(block, options)));
+            i++;
+            continue;
+        }
+        const rowBlocks = [];
+        let rowStartIndex = i;
+        if (i > 0) {
+            const prevBlock = blocks[i - 1];
+            if (prevBlock) {
+                const prevAttrs = 'blockAttrs' in prevBlock ? prevBlock.blockAttrs : undefined;
+                if (!prevAttrs?.sameLine) {
+                    rowStartIndex = i - 1;
+                    result.pop();
+                }
+            }
+        }
+        for (let j = rowStartIndex; j < blocks.length; j++) {
+            const currentBlock = blocks[j];
+            if (!currentBlock) {
+                continue;
+            }
+            rowBlocks.push(currentBlock);
+            if (j + 1 >= blocks.length) {
+                break;
+            }
+            const nextBlock = blocks[j + 1];
+            if (nextBlock) {
+                const nextAttrs = 'blockAttrs' in nextBlock ? nextBlock.blockAttrs : undefined;
+                if (!nextAttrs?.sameLine) {
+                    break;
+                }
+            }
+        }
+        const rowHtml = rowBlocks.map((b) => renderBlockToHtml(b, options)).join('');
+        result.push(wrapBlock(`<div class="jw-same-line-row">${rowHtml}</div>`));
+        i = rowStartIndex + rowBlocks.length;
+    }
+    return result.join('');
+}
+function renderBlockToHtml(block, options) {
+    switch (block.type) {
+        case 'paragraph':
+            return renderParagraphBlock(block, options);
+        case 'heading':
+            return renderHeadingBlock(block, options);
+        case 'contentTitle':
+            return renderContentTitleBlock(block, options);
+        case 'quote':
+            return renderQuoteBlock(block, options);
+        case 'list':
+            return renderListBlock(block, options);
+        case 'listItem':
+            return renderListItemBlock(block, options);
+        case 'code':
+            return renderCodeBlock(block, options);
+        case 'table':
+            return renderTableBlock(block, options);
+        case 'hr':
+            return renderHorizontalRuleBlock(block, options);
+        case 'image':
+            return renderImageBlock(block, options);
+        case 'html':
+            return renderHtmlBlock(block, options);
+        case 'footnotes':
+            return renderFootnotesBlock(block, options);
+        case 'footnoteDef':
+            return renderFootnoteDefBlock(block, options);
+        case 'commentBlock':
+            return options.includeComments ? renderCommentBlock(block, options) : '';
+        case 'disabledBlock':
+            return renderDisabledBlock(block, options);
+        case 'include':
+            return renderIncludeBlock(block, options);
+        case 'taggedBlock':
+            return renderTaggedBlock(block, options);
+        case 'raw':
+            return renderRawBlock(block, options);
+        default:
+            return '';
+    }
+}
+function renderParagraphBlock(block, options) {
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs);
+    const inner = (0, inlines_1.renderInlinesToHtml)(block.children, options);
+    const hasBlockElements = inner.includes('<div');
+    if (hasBlockElements) {
+        const trimmedInner = inner.trim();
+        return `<div class="jw-paragraph jw-paragraph-block"${attrs}>${trimmedInner}</div>`;
+    }
+    return `<p class="jw-paragraph"${attrs}>${inner}</p>`;
+}
+function renderHeadingBlock(block, options) {
+    const level = block.level;
+    const tag = level >= 1 && level <= 5 ? `h${level}` : 'h1';
+    const headingText = block.children.map((node) => extractTextFromInlineNode(node)).join('');
+    const headingId = (0, utils_1.buildHeadingIdFromText)(headingText);
+    const inner = (0, inlines_1.renderInlinesToHtml)(block.children, options);
+    if (block.foldable) {
+        const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs);
+        const heading = `<${tag} id="${(0, utils_1.escapeAttr)(headingId)}" class="jw-heading level-${level}"${attrs}>${inner}</${tag}>`;
+        return `<summary class="jw-heading-summary">${heading}</summary>`;
+    }
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs);
+    return `<${tag} id="${(0, utils_1.escapeAttr)(headingId)}" class="jw-heading level-${level}"${attrs}>${inner}</${tag}>`;
+}
+function hasInlineChildren(node) {
+    return 'children' in node && Array.isArray(node.children);
+}
+function extractTextFromInlineNode(node) {
+    if (node.type === 'text') {
+        return node.value;
+    }
+    if (hasInlineChildren(node)) {
+        return node.children.map((child) => extractTextFromInlineNode(child)).join('');
+    }
+    return '';
+}
+function renderContentTitleBlock(block, options) {
+    const inner = (0, inlines_1.renderInlinesToHtml)(block.children, options);
+    const spacer = '<div class="jw-content-title-gap" aria-hidden="true"></div>';
+    return `<div class="jw-content-title">${inner}</div>${spacer}`;
+}
+function renderQuoteBlock(block, options) {
+    const inner = renderBlocksToHtml(block.children, options);
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+        extraData: { 'data-jw-level': String(block.level) },
+    });
+    return `<blockquote class="jw-quote"${attrs}>${inner}</blockquote>`;
+}
+function renderListBlock(block, options) {
+    const isOrdered = block.kind === 'ordered';
+    const tag = isOrdered ? 'ol' : 'ul';
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+        extraData: {
+            'data-jw-list-kind': block.kind,
+            ...(block.orderedStyle ? { 'data-jw-ordered-style': block.orderedStyle } : {}),
+        },
+    });
+    const inner = block.children.map((child) => renderListItemBlock(child, options)).join('');
+    return `<${tag} class="jw-list"${attrs}>${inner}</${tag}>`;
+}
+function renderListItemBlock(block, options) {
+    const attrsParts = [];
+    attrsParts.push(`data-jw-list-kind="${(0, utils_1.escapeAttr)(block.kind)}"`);
+    attrsParts.push(`data-jw-indent="${block.indent}"`);
+    if (block.ordinal) {
+        attrsParts.push(`data-jw-ordinal="${(0, utils_1.escapeAttr)(block.ordinal)}"`);
+    }
+    if (block.taskStatus) {
+        attrsParts.push(`data-jw-task-status="${(0, utils_1.escapeAttr)(block.taskStatus)}"`);
+    }
+    const blockAttrStr = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+        rawAttrs: attrsParts,
+    });
+    let prefix = '';
+    if (block.kind === 'ordered' && block.ordinal) {
+        prefix += `<span class="jw-list-ordinal">${(0, utils_1.escapeHtml)(block.ordinal)}.</span>`;
+    }
+    if (block.taskStatus) {
+        prefix += `<span class="jw-list-task-marker" data-jw-task-status="${(0, utils_1.escapeAttr)(block.taskStatus)}"></span>`;
+    }
+    const inner = renderBlocksToHtml(block.children, {
+        ...options,
+        suppressBlockWrapper: true,
+    });
+    if (block.kind === 'foldable') {
+        const firstChild = block.children[0];
+        if (firstChild && firstChild.type === 'paragraph') {
+            const summaryContent = renderBlockToHtml(firstChild, {
+                ...options,
+                suppressBlockWrapper: true,
+            });
+            const remainingChildren = block.children.slice(1);
+            const detailsContent = remainingChildren.length > 0
+                ? renderBlocksToHtml(remainingChildren, {
+                    ...options,
+                    suppressBlockWrapper: true,
+                })
+                : '';
+            return `<li class="jw-list-item"${blockAttrStr}><details class="jw-foldable-list-item"><summary class="jw-list-summary">${prefix}${summaryContent}</summary>${detailsContent}</details></li>`;
+        }
+    }
+    return `<li class="jw-list-item"${blockAttrStr}>${prefix}${inner}</li>`;
+}
+function renderCodeBlock(block, _options) {
+    if (block.htmlLike) {
+        const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+            extraData: { 'data-jw-html-like': 'true' },
+        });
+        const value = block.value ?? '';
+        return `<div class="jw-html-like"${attrs}><template shadowrootmode="open">${value}</template></div>`;
+    }
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+        extraData: block.language ? { 'data-jw-language': block.language } : undefined,
+    });
+    const langClass = block.language ? ` language-${(0, utils_1.escapeAttr)(block.language)}` : '';
+    const normalized = (block.value ?? '').replace(/\r\n?/g, '\n');
+    const lines = normalized.split('\n');
+    if (lines.length === 0) {
+        lines.push('');
+    }
+    // Generate line numbers HTML
+    const lineNumbersHtml = lines
+        .map((_, index) => `<span class="jw-line-number">${index + 1}</span>`)
+        .join('');
+    // Generate code lines HTML
+    const linesHtml = lines
+        .map((line) => {
+        const escapedLine = (0, utils_1.escapeHtml)(line);
+        const contentWithSpaces = escapedLine
+            .replace(/\t/g, '&nbsp;&nbsp;&nbsp;&nbsp;')
+            .replace(/ /g, '&nbsp;');
+        const content = line.length === 0 ? '&nbsp;' : contentWithSpaces;
+        return `<span class="jw-code-line">${content}</span>`;
+    })
+        .join('');
+    // Build header with language label and copy button
+    const languageLabel = block.language
+        ? `<span class="jw-code-lang">${(0, utils_1.escapeHtml)(block.language)}</span>`
+        : '<span></span>';
+    const copyButton = `<button class="jw-code-copy" onclick="navigator.clipboard.writeText([...this.closest('.jw-code-block').querySelectorAll('.jw-code-line')].map(l=>l.textContent).join('\\n')).then(()=>{this.textContent='已复制';setTimeout(()=>this.textContent='复制',1500)})">复制</button>`;
+    const header = `<div class="jw-code-header">${languageLabel}${copyButton}</div>`;
+    const content = `<div class="jw-code-content"><span class="jw-line-numbers">${lineNumbersHtml}</span><code class="jw-code${langClass}">${linesHtml}</code></div>`;
+    return `<pre class="jw-code-block"${attrs}>${header}${content}</pre>`;
+}
+function renderTableBlock(block, options) {
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs);
+    if (!block.rows || block.rows.length === 0) {
+        return `<table class="jw-table"${attrs}></table>`;
+    }
+    const headerRow = block.rows[0];
+    if (!headerRow) {
+        return `<table class="jw-table"${attrs}></table>`;
+    }
+    const bodyRows = block.rows.slice(1);
+    const thead = `<thead>${renderTableRow(headerRow, block, options, true)}</thead>`;
+    const tbody = bodyRows.length
+        ? `<tbody>${bodyRows.map((row) => renderTableRow(row, block, options, false)).join('')}</tbody>`
+        : '';
+    return `<table class="jw-table"${attrs}>${thead}${tbody}</table>`;
+}
+function renderTableRow(row, table, options, isHeader) {
+    const cellTag = isHeader ? 'th' : 'td';
+    const cellsHtml = row.cells
+        .map((cell, index) => renderTableCell(cell, table, options, index, cellTag))
+        .join('');
+    return `<tr class="jw-table-row">${cellsHtml}</tr>`;
+}
+function renderTableCell(cell, table, options, columnIndex, tag) {
+    const align = cell.align ?? table.align?.[columnIndex];
+    const styleParts = [];
+    if (align) {
+        styleParts.push(`text-align:${align}`);
+    }
+    const styleAttr = styleParts.length > 0 ? ` style="${(0, utils_1.escapeAttr)(styleParts.join(';'))}"` : '';
+    const inner = (0, inlines_1.renderInlinesToHtml)(cell.children, options);
+    return `<${tag} class="jw-table-cell"${styleAttr}>${inner}</${tag}>`;
+}
+function renderHorizontalRuleBlock(block, _options) {
+    const attrsParts = [`data-jw-hr-style="${(0, utils_1.escapeAttr)(block.style)}"`];
+    const color = (0, utils_1.colorAttributeToCssColor)(block.colorAttr);
+    const extraStyle = [];
+    if (color) {
+        extraStyle.push(`color:${color}`);
+        extraStyle.push(`border-color:${color}`);
+    }
+    const attrStr = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+        rawAttrs: attrsParts,
+        extraStyle: extraStyle.length > 0 ? extraStyle : undefined,
+    });
+    return `<hr class="jw-hr"${attrStr} />`;
+}
+function renderImageBlock(block, options) {
+    const extraData = {};
+    if (block.shape) {
+        extraData['data-jw-shape'] = block.shape;
+    }
+    if (block.roundedRadius !== undefined) {
+        extraData['data-jw-rounded-radius'] = String(block.roundedRadius);
+    }
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+        extraData: Object.keys(extraData).length > 0 ? extraData : undefined,
+    });
+    let url = block.url;
+    if (options.resolveAssetPath) {
+        const resolved = options.resolveAssetPath(block.url);
+        if (resolved !== undefined) {
+            url = resolved;
+        }
+    }
+    const src = (0, utils_1.escapeAttr)(url);
+    const alt = block.title ? (0, utils_1.escapeAttr)(block.title) : '';
+    let imgStyle = '';
+    if (block.shape === 'rounded' && block.roundedRadius !== undefined) {
+        const radius = block.roundedRadius * 8;
+        imgStyle = ` style="border-radius:${radius}px"`;
+    }
+    const img = `<img class="jw-image" src="${src}" alt="${alt}"${imgStyle} />`;
+    if (!block.title) {
+        return `<figure class="jw-image-figure"${attrs}>${img}</figure>`;
+    }
+    const caption = `<figcaption class="jw-image-caption">${(0, utils_1.escapeHtml)(block.title)}</figcaption>`;
+    return `<figure class="jw-image-figure"${attrs}>${img}${caption}</figure>`;
+}
+function renderHtmlBlock(block, options) {
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs);
+    if (block.value) {
+        return `<div class="jw-html-block"${attrs}>${block.value}</div>`;
+    }
+    if (block.source) {
+        const resolved = options.resolveHtmlSource
+            ? options.resolveHtmlSource(block.source)
+            : undefined;
+        if (resolved !== undefined) {
+            return `<div class="jw-html-block"${attrs}>${resolved}</div>`;
+        }
+        let source = block.source;
+        if (options.resolveAssetPath) {
+            const resolvedPath = options.resolveAssetPath(block.source);
+            if (resolvedPath !== undefined) {
+                source = resolvedPath;
+            }
+        }
+        const dataAttrs = attrs.length > 0
+            ? `${attrs} data-jw-html-source="${(0, utils_1.escapeAttr)(source)}"`
+            : ` data-jw-html-source="${(0, utils_1.escapeAttr)(source)}"`;
+        return `<div class="jw-html-block"${dataAttrs}></div>`;
+    }
+    return `<div class="jw-html-block"${attrs}></div>`;
+}
+function renderFootnotesBlock(block, options) {
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs);
+    const items = block.children.map((def) => renderFootnoteDefBlock(def, options)).join('');
+    return `<section class="jw-footnotes"${attrs}><ol class="jw-footnote-list">${items}</ol></section>`;
+}
+function renderFootnoteDefBlock(block, options) {
+    const inner = renderBlocksToHtml(block.children, options);
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+        extraData: { 'data-jw-footnote-id': block.id },
+    });
+    return `<li class="jw-footnote-def"${attrs}>${inner}</li>`;
+}
+function renderCommentBlock(block, options) {
+    const inner = renderBlocksToHtml(block.children, options);
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+        extraData: { 'data-jw-comment': 'true' },
+    });
+    return `<aside class="jw-comment-block"${attrs}>${inner}</aside>`;
+}
+function renderDisabledBlock(block, _options) {
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs);
+    const text = (0, utils_1.escapeHtml)(block.raw ?? '');
+    return `<pre class="jw-disabled-block"${attrs}>${text}</pre>`;
+}
+function renderIncludeBlock(block, options) {
+    const attrsParts = [
+        `data-jw-include-mode="${(0, utils_1.escapeAttr)(block.mode)}"`,
+        `data-jw-include-target="${(0, utils_1.escapeAttr)(block.target)}"`,
+    ];
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+        rawAttrs: attrsParts,
+    });
+    if (options.resolveInclude) {
+        const resolved = options.resolveInclude(block.mode, block.target);
+        if (resolved !== undefined) {
+            return `<div class="jw-include"${attrs}>${resolved}</div>`;
+        }
+    }
+    return `<div class="jw-include"${attrs}></div>`;
+}
+function renderTaggedBlock(block, options) {
+    const id = (0, utils_1.buildTagIdFromName)(block.name);
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs, {
+        extraData: { 'data-jw-tag': block.name },
+        rawAttrs: [`id="${(0, utils_1.escapeAttr)(id)}"`],
+    });
+    const inner = renderBlockToHtml(block.child, options);
+    return `<div class="jw-tagged-block"${attrs}>${inner}</div>`;
+}
+function renderRawBlock(block, _options) {
+    const attrs = (0, utils_1.buildBlockAttributes)(block.blockAttrs);
+    const text = (0, utils_1.escapeHtml)(block.value ?? '');
+    return `<pre class="jw-raw-block"${attrs}>${text}</pre>`;
+}

package/dist/html/render/html.d.ts

@@ -0,0 +1,8 @@
+import { JianwenDocument } from '../../core/ast';
+import { RenderHtmlOptions } from './utils';
+export { RenderHtmlOptions } from './utils';
+export { DocumentTheme } from '../theme/theme';
+export { renderBlocksToHtml } from './blocks';
+export { renderInlinesToHtml } from './inlines';
+export declare function createDefaultAssetPathResolver(sourceFilePath: string, outputFilePath: string): (assetPath: string) => string | undefined;
+export declare function renderDocumentToHtml(doc: JianwenDocument, options?: RenderHtmlOptions): string;

package/dist/html/render/html.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderInlinesToHtml = exports.renderBlocksToHtml = void 0;
+exports.createDefaultAssetPathResolver = createDefaultAssetPathResolver;
+exports.renderDocumentToHtml = renderDocumentToHtml;
+const path = __importStar(require("path"));
+const format_1 = require("../format");
+const utils_1 = require("./utils");
+const meta_1 = require("./meta");
+const blocks_1 = require("./blocks");
+var blocks_2 = require("./blocks");
+Object.defineProperty(exports, "renderBlocksToHtml", { enumerable: true, get: function () { return blocks_2.renderBlocksToHtml; } });
+var inlines_1 = require("./inlines");
+Object.defineProperty(exports, "renderInlinesToHtml", { enumerable: true, get: function () { return inlines_1.renderInlinesToHtml; } });
+function createDefaultAssetPathResolver(sourceFilePath, outputFilePath) {
+    const sourceDir = path.dirname(sourceFilePath);
+    const outputDir = path.dirname(outputFilePath);
+    return (assetPath) => {
+        if (path.isAbsolute(assetPath) || /^https?:\/\//i.test(assetPath)) {
+            return assetPath;
+        }
+        const absoluteAssetPath = path.resolve(sourceDir, assetPath);
+        const relativeToOutput = path.relative(outputDir, absoluteAssetPath);
+        return relativeToOutput.replace(/\\/g, '/');
+    };
+}
+function renderDocumentToHtml(doc, options = {}) {
+    const wrapperTag = options.documentWrapperTag === undefined ? 'article' : options.documentWrapperTag;
+    const finalOptions = { ...options };
+    if (options.sourceFilePath && options.outputFilePath && !options.resolveAssetPath) {
+        finalOptions.resolveAssetPath = createDefaultAssetPathResolver(options.sourceFilePath, options.outputFilePath);
+    }
+    const innerParts = [];
+    if (finalOptions.includeMeta) {
+        innerParts.push((0, meta_1.renderMetaToHtml)(doc.meta));
+    }
+    if (!wrapperTag) {
+        innerParts.push((0, blocks_1.renderBlocksToHtml)(doc.children, {
+            ...finalOptions,
+            suppressBlockWrapper: true,
+        }));
+    }
+    else {
+        innerParts.push((0, blocks_1.renderBlocksToHtml)(doc.children, finalOptions));
+    }
+    const innerHtml = innerParts.join('');
+    if (!wrapperTag) {
+        return innerHtml;
+    }
+    const wrapperAttrs = (0, meta_1.buildDocumentWrapperAttributes)(doc.meta);
+    const themeAttr = finalOptions.documentTheme
+        ? ` data-jw-theme="${(0, utils_1.escapeAttr)(finalOptions.documentTheme)}"`
+        : '';
+    const html = `<${wrapperTag} class="jw-root"${wrapperAttrs}${themeAttr}>${innerHtml}</${wrapperTag}>`;
+    return finalOptions.format ? (0, format_1.formatHtml)(html) : html;
+}

package/dist/html/render/inlines.d.ts

@@ -0,0 +1,4 @@
+import { InlineNode } from '../../core/ast';
+import { RenderHtmlOptions } from './utils';
+export declare function renderInlinesToHtml(nodes: InlineNode[], options?: RenderHtmlOptions): string;
+export declare function renderInlineToHtml(node: InlineNode, options: RenderHtmlOptions): string;

package/dist/html/render/inlines.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderInlinesToHtml = renderInlinesToHtml;
+exports.renderInlineToHtml = renderInlineToHtml;
+const utils_1 = require("./utils");
+function renderInlinesToHtml(nodes, options = {}) {
+    return nodes.map((node) => renderInlineToHtml(node, options)).join('');
+}
+function renderInlineToHtml(node, options) {
+    switch (node.type) {
+        case 'text': {
+            const escaped = (0, utils_1.escapeHtml)(node.value);
+            return escaped.replace(/\n/g, '<br/>');
+        }
+        case 'codeSpan':
+            return `<code class="jw-code-span">${(0, utils_1.escapeHtml)(node.value)}</code>`;
+        case 'em':
+            return `<em>${renderInlinesToHtml(node.children, options)}</em>`;
+        case 'strong':
+            return `<strong>${renderInlinesToHtml(node.children, options)}</strong>`;
+        case 'underline':
+            return `<span class="jw-underline">${renderInlinesToHtml(node.children, options)}</span>`;
+        case 'strike':
+            return `<span class="jw-strike">${renderInlinesToHtml(node.children, options)}</span>`;
+        case 'wave':
+            return `<span class="jw-wave">${renderInlinesToHtml(node.children, options)}</span>`;
+        case 'sup':
+            return `<sup>${renderInlinesToHtml(node.children, options)}</sup>`;
+        case 'sub':
+            return `<sub>${renderInlinesToHtml(node.children, options)}</sub>`;
+        case 'highlight':
+            return renderHighlightInline(node, options);
+        case 'link':
+            return renderLinkInline(node, options);
+        case 'footnoteRef':
+            return renderFootnoteRefInline(node);
+        case 'commentInline':
+            return options.includeComments
+                ? `<span class="jw-comment-inline" data-jw-comment="true">${renderInlinesToHtml(node.children, options)}</span>`
+                : '';
+        case 'inlineAttrs':
+            return renderInlineAttrsInline(node, options);
+        default:
+            return '';
+    }
+}
+function renderHighlightInline(node, options) {
+    const cssColor = (0, utils_1.colorAttributeToCssColor)(node.colorAttr);
+    const cssFillColor = (0, utils_1.colorAttributeToCssColor)(node.fillColorAttr);
+    const classes = ['jw-highlight', `jw-highlight-${node.mode}`];
+    const styleParts = [];
+    if (node.mode === 'marker') {
+        if (cssColor) {
+            styleParts.push(`background-color:${cssColor}`);
+        }
+        if (cssFillColor) {
+            styleParts.push(`border-color:${cssFillColor}`);
+        }
+    }
+    else {
+        if (cssColor) {
+            styleParts.push(`border-color:${cssColor}`);
+        }
+        if (cssFillColor) {
+            styleParts.push(`background-color:${cssFillColor}`);
+        }
+    }
+    if (node.shape === 'square') {
+        styleParts.push('border-radius:0');
+    }
+    else if (node.shape === 'rounded') {
+        const radius = node.roundedRadius ?? 1;
+        styleParts.push(`border-radius:${radius * 0.35}em`);
+    }
+    const styleAttr = styleParts.length > 0 ? ` style="${(0, utils_1.escapeAttr)(styleParts.join(';'))}"` : '';
+    const inner = renderInlinesToHtml(node.children, options);
+    const hasLineBreaks = inner.includes('<br/>');
+    if (hasLineBreaks) {
+        classes.push('jw-highlight-block');
+        const trimmedInner = inner.replace(/^(<br\/>)+|(<br\/>)+$/g, '');
+        return `<div class="${classes.join(' ')}"${styleAttr}>${trimmedInner}</div>`;
+    }
+    return `<span class="${classes.join(' ')}"${styleAttr}>${inner}</span>`;
+}
+function renderLinkInline(node, options) {
+    const resolvedHref = (0, utils_1.resolveLinkHref)(node.href);
+    const href = (0, utils_1.escapeAttr)(resolvedHref);
+    const styleParts = [];
+    const color = (0, utils_1.colorAttributeToCssColor)(node.colorAttr);
+    const underlineColor = (0, utils_1.colorAttributeToCssColor)(node.underlineColorAttr);
+    if (color) {
+        styleParts.push(`color:${color}`);
+    }
+    if (underlineColor) {
+        styleParts.push(`text-decoration-color:${underlineColor}`);
+    }
+    const styleAttr = styleParts.length > 0 ? ` style="${(0, utils_1.escapeAttr)(styleParts.join(';'))}"` : '';
+    const inner = renderInlinesToHtml(node.children, options);
+    return `<a href="${href}" class="jw-link"${styleAttr}>${inner}</a>`;
+}
+function renderFootnoteRefInline(node) {
+    const id = (0, utils_1.escapeAttr)(node.id);
+    return `<sup class="jw-footnote-ref" data-jw-footnote-id="${id}">[${id}]</sup>`;
+}
+function renderInlineAttrsInline(node, options) {
+    const style = (0, utils_1.buildInlineStyleFromInlineAttributes)(node.attrs);
+    const styleAttr = style ? ` style="${(0, utils_1.escapeAttr)(style)}"` : '';
+    const inner = renderInlinesToHtml(node.children, options);
+    return `<span class="jw-inline-attrs"${styleAttr}>${inner}</span>`;
+}

package/dist/html/render/meta.d.ts

@@ -0,0 +1,3 @@
+import { JianwenMeta } from '../../core/ast';
+export declare function renderMetaToHtml(meta: JianwenMeta | undefined): string;
+export declare function buildDocumentWrapperAttributes(meta: JianwenMeta | undefined): string;