Parséman100% Pure Parsing

Write parsers as ordinary TypeScript functions. Ship optimized table artifacts. The same grammar runs interpreted in your tests and macro-compiled in production — with no grammar file and nothing generated to check in.

Get started

View on GitHub

Compiles to compact tables

Add the bundler plugin and your combinator trees get evaluated at build time and replaced with a compact table program. The combinator and compiler imports disappear entirely; what ships shares one small runtime.

Macro mode

Just functions, all the way down

literal, choice, sequence, many, node… they're plain functions that compose. Nothing to learn beyond calling them, nothing to generate, nothing to commit.

Combinators

CST / AST with trivia capture

node() rules capture terminals and the offsets of every space and comment for you, so nothing has to be wrapped just to get its span back. Built for editors, formatters, and re-parsing on every keystroke.

Building trees

An editor backend, not just a parser

Tolerant recovery runs on the compiled parser, not just the interpreter, and a separate language-service layer adds completions and diagnostics keyed by node type. Recover, complete, diagnose — over a grammar that never learns the editor exists.

Editor integration

Measured for speed

Every release runs equivalent small, medium, and large workloads against the other parsers, on the artifact that actually ships. The numbers are in the docs, good and bad.

Benchmarks

Debuggable output

Interpreter mode runs your combinator source directly. The macro build compiles it away but keeps your breakpoints working through source maps, so you step through choice(...) and not a wall of charCode dispatch.

Debugging by mode

Scannerless, with routing

dispatch() parses a shared head once, then branches on the value it just read. You keep scannerless flexibility without turning every overlapping shape into a pile of backtracking.

Dispatch