markdown 0.0.1-preview.1
CommonMark and GFM Markdown parser, AST, plugin system, and HTML renderer
Markdown (@zena-lang/markdown)#
A CommonMark and GitHub Flavored Markdown (GFM) parser, syntax tree, plugin
system, and HTML renderer written in Zena (zena-lang:markdown/<library>).
See docs/design/markdown.md for the design.
Usage#
Add it with zena pkg add zena-lang:markdown, then import its main
library:
import {
parse, renderHtml, markdownToHtml, gfmExtensions
} from 'zena-lang:markdown';
// Render CommonMark + GFM to safe HTML (raw HTML stripped, unsafe URLs blocked)
let html = markdownToHtml('# Hello\n\nSome ~~old~~ **new** text.', {
extensions: gfmExtensions(),
safe: true,
});
// Or parse to an AST first
let doc = parse('# Heading\n\nParagraph.', gfmExtensions());
let out = renderHtml(doc, {safe: true, extensions: gfmExtensions()});
Running Tests#
npm test -w @zena-lang/markdown
npm run test:quick -- packages/markdown/test
11.5 KiB
Raw
/**
* GFM pipe tables extension (`| a | b |\n| --- | :---: |`).
*/
import {Array, GrowableArray} from 'zena:core';
import {StringBuilder, StringReader, isSpaceOrTab} from 'zena:string';
import {Block, CustomBlock, CustomInline, Inline, Span} from '../ast.zena';
import {AstTransformer, BlockContinue, BlockLineState, BlockParserFactory, CustomBlockParser, CustomBlockStart, DelimiterProcessor, HtmlRenderContext, InlineContentParser, InlineParserRunner, MarkdownExtension, MatchedBlockInfo, NodeRenderer} from '../plugin.zena';
import {trimSpaces} from '../scanner.zena';
/**
* Column alignment in a GFM pipe table.
*/
export enum TableAlignment {
None,
Left,
Center,
Right
}
/**
* A single cell in a GFM table header or body row.
*/
export final class TableCell(var inlines: GrowableArray<Inline>, alignment: TableAlignment, isHeader: boolean, span: Span)
/**
* A row of cells in a GFM table.
*/
export final class TableRow(var cells: GrowableArray<TableCell>, span: Span)
/**
* AST block node representing a GFM pipe table.
*/
export final class TableBlock extends CustomBlock {
alignments: GrowableArray<TableAlignment>;
var head: TableRow;
var rows: GrowableArray<TableRow>;
new(this.alignments, this.head, this.rows, span: Span) : super(span) {}
}
final class TableBlockParser implements CustomBlockParser {
#alignments: GrowableArray<TableAlignment>;
#headerRawCells: GrowableArray<String>;
#startOffset: i32;
#rawBodyLines = new GrowableArray<String>(4);
#rawBodyOffsets = new GrowableArray<i32>(4);
var #builtTable: TableBlock | null = null;
new(alignments: GrowableArray<TableAlignment>, headerRawCells: GrowableArray<String>, startOffset: i32) : #alignments = alignments, #headerRawCells = headerRawCells, #startOffset = startOffset {}
acceptsLines(): boolean {
return true;
}
tryContinue(state: BlockLineState): BlockContinue {
if (state.isBlank) {
return BlockContinue.none();
}
let r = new StringReader(state.line);
r.reset(state.nextNonSpaceIndex);
let b = r.peek();
let slice = r.readToEnd();
if (trimSpaces(slice) == '|') {
return BlockContinue.none();
}
if (state.indent <= 3) {
// Interrupting block starters: `#`, `>`, ```, `~~~`, thematic break, list marker
if (b == 0x23 || b == 0x3E || b == 0x60 || b == 0x7E) {
return BlockContinue.none();
}
if ((b == 0x2A || b == 0x2D || b == 0x5F)
&& isTableInterruptingBreakOrList(slice)) {
return BlockContinue.none();
}
}
return BlockContinue.atIndex(state.nextNonSpaceIndex);
}
addLine(line: String, startOffset: i32): void {
this.#rawBodyLines.push(line);
this.#rawBodyOffsets.push(startOffset);
}
parseInlines(inlineParser: InlineParserRunner): void {
let table = this.#builtTable;
if (table == null) {
return;
}
let colCount = this.#alignments.length;
// Parse header cells
let headCells = new GrowableArray<TableCell>(colCount);
var c = 0;
while (c < colCount) {
let rawText = if (c
< this.#headerRawCells.length) unescapePipes(
this.#headerRawCells[c]
) else '';
let inlines = inlineParser.parse(rawText, this.#startOffset);
headCells.push(
new TableCell(
inlines,
this.#alignments[c],
true,
new Span(this.#startOffset, this.#startOffset)
)
);
c += 1;
}
table.head = new TableRow(
headCells,
new Span(this.#startOffset, table.span.end)
);
// Parse body rows
var r = 0;
while (r < this.#rawBodyLines.length) {
let rowLine = this.#rawBodyLines[r];
let rowOffset = this.#rawBodyOffsets[r];
let rawCells = splitTableCells(rowLine);
let cells = new GrowableArray<TableCell>(colCount);
var col = 0;
while (col < colCount) {
let cellText = if (col
< rawCells.length) unescapePipes(rawCells[col]) else '';
let inlines = inlineParser.parse(cellText, rowOffset);
cells.push(
new TableCell(
inlines,
this.#alignments[col],
false,
new Span(rowOffset, rowOffset)
)
);
col += 1;
}
table.rows.push(new TableRow(cells, new Span(rowOffset, table.span.end)));
r += 1;
}
}
closeBlock(endOffset: i32): Block {
let span = new Span(this.#startOffset, endOffset);
let emptyHead = new TableRow(new GrowableArray<TableCell>(0), span);
let table = new TableBlock(
this.#alignments,
emptyHead,
new GrowableArray<TableRow>(this.#rawBodyLines.length),
span
);
this.#builtTable = table;
return table;
}
}
final class TableBlockParserFactory implements BlockParserFactory {
triggerBytes(): Array<i32> {
return [0x7C, 0x2D, 0x3A]; // '|', '-', ':'
}
tryStart(state: BlockLineState, matched: MatchedBlockInfo): CustomBlockStart | null {
if (state.indent >= 4 || !matched.isParagraph) {
return null;
}
let paraLines = matched.paragraphLines;
if (paraLines == null || paraLines.length == 0) {
return null;
}
let r = new StringReader(state.line);
let lineEnd = r.remaining;
r.reset(state.nextNonSpaceIndex);
let delimLine = r.readToEnd();
let headerLine = paraLines[paraLines.length - 1];
if (!containsUnescapedPipe(delimLine)
|| !containsUnescapedPipe(headerLine)) {
return null;
}
let alignments = parseDelimiterRow(delimLine);
if (alignments == null || alignments.length == 0) {
return null;
}
let headerCells = splitTableCells(headerLine);
if (headerCells.length != alignments.length) {
return null;
}
let parser = new TableBlockParser(
alignments,
headerCells,
matched.paragraphStartOffset
);
return CustomBlockStart.of(parser).atIndex(lineEnd).replacingParagraph();
}
}
function isTableInterruptingBreakOrList(slice: String): boolean {
if (containsUnescapedPipe(slice)) {
return false;
}
let r = new StringReader(slice);
let b = r.advance();
if ((b == 0x2D || b == 0x2B || b == 0x2A) && isSpaceOrTab(r.peek())) {
return true;
}
if (b == 0x2A || b == 0x2D || b == 0x5F) {
var count = 1;
var allSameOrSpace = true;
while (!r.isAtEnd) {
let c = r.advance();
if (c == b) {
count += 1;
} else if (!isSpaceOrTab(c)) {
allSameOrSpace = false;
break;
}
}
if (allSameOrSpace && count >= 3) {
return true;
}
}
return false;
}
function containsUnescapedPipe(s: String): boolean {
let r = new StringReader(s);
while (!r.isAtEnd) {
let cp = r.advance();
if (cp == 0x5C && r.peek() == 0x7C) {
r.advance();
continue;
}
if (cp == 0x7C) {
// '|'
return true;
}
}
return false;
}
/**
* Splits a table row into trimmed cell strings, respecting `\|` escapes and
* stripping optional leading and trailing `|` delimiters.
*/
function splitTableCells(line: String): GrowableArray<String> {
let trimmed = trimSpaces(line);
let r = new StringReader(trimmed);
r.matchCodePoint(0x7C); // optional leading '|'
let cells = new GrowableArray<String>(4);
var cellStart = r.mark();
var lastPipePos = -1;
while (!r.isAtEnd) {
let pos = r.mark();
let cp = r.advance();
if (cp == 0x5C && r.peek() == 0x7C) {
r.advance();
continue;
}
if (cp == 0x7C) {
if (r.isAtEnd) {
// Trailing unescaped '|' at end of line: stop before it
lastPipePos = pos;
break;
}
cells.push(trimSpaces(r.sliceRange(cellStart, pos)));
cellStart = r.mark();
}
}
let finalEnd = if (lastPipePos >= 0) lastPipePos else r.mark();
cells.push(trimSpaces(r.sliceRange(cellStart, finalEnd)));
return cells;
}
function unescapePipes(s: String): String {
if (!s.contains('\\|')) {
return s;
}
let r = new StringReader(s);
let sb = new StringBuilder();
var last = r.mark();
while (!r.isAtEnd) {
let pos = r.mark();
let cp = r.advance();
if (cp == 0x5C && r.matchCodePoint(0x7C)) {
if (pos > last) {
sb.append(r.sliceRange(last, pos));
}
sb.appendByte(0x7C);
last = r.mark();
}
}
if (last < r.mark()) {
sb.append(r.sliceFrom(last));
}
return sb.toString();
}
function parseDelimiterRow(line: String): GrowableArray<TableAlignment> | null {
let rawCells = splitTableCells(line);
if (rawCells.length == 0) {
return null;
}
let alignments = new GrowableArray<TableAlignment>(rawCells.length);
for (let cell in rawCells) {
if (cell.isEmpty) {
return null;
}
let r = new StringReader(cell);
let left = r.matchCodePoint(0x3A); // ':'
var dashCount = 0;
while (r.matchCodePoint(0x2D)) {
// '-'
dashCount += 1;
}
if (dashCount == 0) {
return null;
}
let right = r.matchCodePoint(0x3A); // ':'
if (!r.isAtEnd) {
return null;
}
let align = if (left
&& right) TableAlignment.Center else if (left) TableAlignment.Left else if (right) TableAlignment.Right else TableAlignment.None;
alignments.push(align);
}
return alignments;
}
final class TableRenderer implements NodeRenderer {
renderBlock(block: CustomBlock, ctx: HtmlRenderContext): boolean {
if (block is TableBlock) {
ctx.writeIndent();
ctx.sb.append('<table>\n');
ctx.pushIndent();
ctx.writeIndent();
ctx.sb.append('<thead>\n');
ctx.pushIndent();
ctx.writeIndent();
ctx.sb.append('<tr>\n');
ctx.pushIndent();
for (let cell in block.head.cells) {
this.#renderCell(cell, 'th', ctx);
}
ctx.popIndent();
ctx.writeIndent();
ctx.sb.append('</tr>\n');
ctx.popIndent();
ctx.writeIndent();
ctx.sb.append('</thead>\n');
if (block.rows.length > 0) {
ctx.writeIndent();
ctx.sb.append('<tbody>\n');
ctx.pushIndent();
for (let row in block.rows) {
ctx.writeIndent();
ctx.sb.append('<tr>\n');
ctx.pushIndent();
for (let cell in row.cells) {
this.#renderCell(cell, 'td', ctx);
}
ctx.popIndent();
ctx.writeIndent();
ctx.sb.append('</tr>\n');
}
ctx.popIndent();
ctx.writeIndent();
ctx.sb.append('</tbody>\n');
}
ctx.popIndent();
ctx.writeIndent();
ctx.sb.append('</table>\n');
return true;
}
return false;
}
#renderCell(cell: TableCell, tag: String, ctx: HtmlRenderContext): void {
ctx.writeIndent();
ctx.sb.append('<');
ctx.sb.append(tag);
match (cell.alignment) {
case TableAlignment.Left: {
ctx.sb.append(' align="left"');
}
case TableAlignment.Center: {
ctx.sb.append(' align="center"');
}
case TableAlignment.Right: {
ctx.sb.append(' align="right"');
}
case TableAlignment.None: {}
};
ctx.sb.append('>');
ctx.renderInlines(cell.inlines);
ctx.sb.append('</');
ctx.sb.append(tag);
ctx.sb.append('>\n');
}
renderInline(node: CustomInline, ctx: HtmlRenderContext): boolean {
return false;
}
}
/**
* Returns the `MarkdownExtension` for GFM pipe tables.
*/
export function tablesExtension(): MarkdownExtension {
let factories = new GrowableArray<BlockParserFactory>(1);
factories.push(new TableBlockParserFactory());
let renderers = new GrowableArray<NodeRenderer>(1);
renderers.push(new TableRenderer());
return new MarkdownExtension(
factories,
new GrowableArray<DelimiterProcessor>(0),
new GrowableArray<InlineContentParser>(0),
new GrowableArray<AstTransformer>(0),
renderers
);
}
| Version | Published | Dependencies | Approved by |
|---|---|---|---|
| 0.0.1-preview.1 | 2026-11-19 | none |
|