markdown 0.0.1-preview.1

CommonMark and GFM Markdown parser, AST, plugin system, and HTML renderer

Readme Files Dependencies Versions

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
  );
}
none
VersionPublishedDependenciesApproved by
0.0.1-preview.1 2026-11-19 none