or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

cli-tool.mdcompiler-system.mdgrammar-parsing.mdindex.mdparser-generation.mdutility-modules.md
tile.json

tessl/npm-pegjs

Parser generator for JavaScript that produces fast parsers with excellent error reporting

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/pegjs@0.10.x

To install, run

npx @tessl/cli install tessl/npm-pegjs@0.10.0

index.mddocs/

PEG.js

PEG.js is a simple parser generator for JavaScript that produces fast parsers with excellent error reporting. You can use it to process complex data or computer languages and build transformers, interpreters, compilers and other tools easily. It uses parsing expression grammar (PEG) formalism which is more powerful than traditional LL(k) and LR(k) parsers.

Package Information

  • Package Name: pegjs
  • Package Type: npm
  • Language: JavaScript
  • Installation: npm install pegjs
  • Global Installation: npm install -g pegjs

Core Imports

const peg = require("pegjs");

// Access individual modules
const { generate, GrammarError, parser, compiler } = require("pegjs");

For browser usage:

<script src="path/to/peg.js"></script>
<!-- PEG.js will be available as a global variable -->
<script>
  const parser = peg.generate(grammar);
</script>

Basic Usage

const peg = require("pegjs");

// Define a simple grammar
const grammar = `
start = additive

additive
  = left:multiplicative "+" right:additive { return left + right; }
  / multiplicative

multiplicative
  = left:primary "*" right:multiplicative { return left * right; }
  / primary

primary
  = integer
  / "(" additive:additive ")" { return additive; }

integer "integer"
  = digits:[0-9]+ { return parseInt(digits.join(""), 10); }
`;

// Generate parser from grammar
const parser = peg.generate(grammar);

// Use the generated parser
const result = parser.parse("2*(3+4)"); // Returns: 14

Architecture

PEG.js is organized around several key components:

  • Parser Generator: Main generate() function that creates parsers from grammars
  • Grammar Parser: Built-in parser for PEG grammar syntax that produces ASTs
  • Compiler System: Multi-pass compiler that transforms ASTs into executable parsers
  • Visitor Pattern: AST traversal system for compiler passes and plugins
  • CLI Tool: Command-line interface for generating parsers from grammar files
  • Utility Libraries: Helper functions for arrays, objects, and class inheritance

Capabilities

Parser Generation

Core functionality for generating JavaScript parsers from PEG grammar specifications. Supports various output formats and optimization options.

function generate(grammar, options);

Parser Generation

Grammar Parsing

Built-in parser for PEG grammar syntax that converts grammar strings into abstract syntax trees.

const parser = {
  parse: function(input, options),
  SyntaxError: function(message, expected, found, location)
};

Grammar Parsing

Compiler System

Multi-pass compiler architecture for transforming grammar ASTs into executable parser code with validation and optimization.

const compiler = {
  compile: function(ast, passes, options),
  visitor: { build: function(functions) },
  passes: {
    check: Object,
    transform: Object, 
    generate: Object
  }
};

Compiler System

CLI Tool

Command-line interface for generating parser files from grammar specifications with extensive configuration options.

pegjs [options] [input_file]

CLI Tool

Utility Modules

Internal utility modules for array operations, object manipulation, and class inheritance used throughout PEG.js.

const arrays = {
  range: function(start, stop),
  find: function(array, valueOrPredicate),
  indexOf: function(array, valueOrPredicate),
  contains: function(array, valueOrPredicate),
  each: function(array, iterator),
  map: function(array, iterator),
  pluck: function(array, key),
  every: function(array, predicate),
  some: function(array, predicate)
};

const objects = {
  keys: function(object),
  values: function(object), 
  clone: function(object),
  defaults: function(object, defaults)
};

const classes = {
  subclass: function(child, parent)
};

Utility Modules

Core Types

// Main module interface
interface PEG {
  VERSION: string;
  GrammarError: typeof GrammarError;
  parser: typeof parser;
  compiler: typeof compiler;
  generate: (grammar: string, options?: GenerateOptions) => any;
}

// Generation options
interface GenerateOptions {
  allowedStartRules?: string[];
  cache?: boolean;
  dependencies?: { [key: string]: string };
  exportVar?: string;
  format?: "amd" | "bare" | "commonjs" | "globals" | "umd";
  optimize?: "speed" | "size";
  output?: "parser" | "source";
  plugins?: any[];
  trace?: boolean;
}

// Grammar error class
class GrammarError extends Error {
  name: "GrammarError";
  message: string;
  location?: LocationRange;
}

// Parse options
interface ParseOptions {
  startRule?: string;
  tracer?: any;
}

// Location information
interface LocationRange {
  start: { offset: number; line: number; column: number };
  end: { offset: number; line: number; column: number };
}