Personal fork of @rocket.chat/message-parser — converts chat messages into structured AST. Dual-engine design: a PEG grammar reference and a fast handwritten parser. Written in TypeScript, tree-shakable, 814 passing tests.

Disclaimer: This is a personal fork of the Rocket.Chat message-parser. Not affiliated with Rocket.Chat.

npm install @rocket.chat/message-parser

import { parse } from '@rocket.chat/message-parser';

const ast = parse('Hello **world**!');

const ast = parse('Hello **world**!', {
  colors: true,
  emoticons: true,
  katex: true,
  customDomains: ['intranet.example.com'],
});

// Use the PEG grammar as the parser engine (default is handwritten)
const ast = parse('Hello **world**!', { engine: 'peggy' });

• isNodeOfType(node, kind) — type guard for AST nodes
• Token, TokenKind — token type definitions
• tokenize(message) — lexer-only pass (returns token stream)
• Lexer, Parser, TokenStream — internal classes

parser (function) and MarkdownAST (type) are deprecated aliases for parse and Root.

Accepts Unix timestamps, ISO 8601 dates, and time-only values:

• <t:1234567890> — Unix timestamp
• <t:2025-07-22T10:00:00.000Z> — ISO 8601
• <t:10:00:t> — time-only (HH:MM or HH:MM:SS)

Optional format modifier:

Two parser implementations:

• PEG grammar (engine: 'peggy') — the reference implementation, a formal grammar in grammar.pegjs. Comprehensive but slower.
• Handwritten (engine: 'handwritten', default) — hand-coded recursive descent parser. Faster, designed for real-time rendering.

Both produce identical ASTs (verified by 814 tests across both engines). Use 'peggy' when you need strict spec compliance; use 'handwritten' for performance-sensitive rendering.

The handwritten parser includes fixes and improvements not present in the original PEG grammar:

• CommonMark intraword underscore rule — _ does not open emphasis when preceded by a word character. text_hello_ and some_snake_case_text remain plain text rather than being parsed as italic.
• Deterministic strike/italic ordering — when ~ and _ compete at the same nesting level, strike wins predictably. PEG's backtracking can produce inconsistent results depending on input length and token positions.
• Performance — ~45x faster on average (5.6x–265x range depending on message type). The handwritten parser avoids PEG's backtracking overhead, especially on emoji, mentions, and code blocks.

Run yarn bench:compare to see the full per-category breakdown.

yarn bench        # full suite
yarn bench:parser # parser throughput
yarn bench:lexer  # lexer throughput
yarn bench:compare # handwritten vs PEG comparison
yarn bench:size   # bundle size

• Grammar bugs: edit grammar.pegjs, then regenerate with yarn build:grammar
• Parser bugs: edit src/parser/Parser.ts
• Lexer bugs: edit files in src/lexer/
• Tests go in tests/; run with yarn test

Before submitting a PR, ensure no regressions against the reference grammar:

yarn test

• Nested lists are unsupported
• URL rule doesn't allow whitespace, (, or ) in bare URLs