chevrotain vs jison vs nearley vs peggy
JavaScript Parser Generators
Search packages..
chevrotainjisonnearleypeggySimilar Packages:

JavaScript Parser Generators

Parser generators are tools that automatically generate parsers from a formal grammar specification. They are used to analyze and process structured text, such as programming languages, data formats, or domain-specific languages. Parser generators take a grammar definition as input and produce code that can parse input text according to the specified rules. This process is known as parsing, and the generated parsers can be used for tasks such as syntax analysis, code compilation, data validation, and transformation. Parser generators are widely used in compiler construction, interpreters, and various applications that require structured text processing. They help automate the creation of parsers, ensuring correctness and efficiency while reducing the manual effort required to implement parsing logic. chevrotain is a modern, fast, and feature-rich parser-building toolkit for JavaScript that allows developers to create custom parsers with fine-grained control over the parsing process. It is designed for performance and flexibility, making it suitable for complex parsing tasks and language implementations. jison is a parser generator for JavaScript that takes a grammar specification (similar to Yacc/Bison) and generates a parser in JavaScript. It is useful for creating parsers for domain-specific languages, interpreters, or compilers directly in JavaScript. nearley is a simple, fast, and powerful parser generator for JavaScript that supports ambiguous grammars and allows for more flexible parsing strategies. It is designed to be easy to use and is particularly well-suited for parsing complex or non-deterministic grammars. peggy is a modern parser generator for JavaScript based on the Parsing Expression Grammar (PEG) formalism. It is a fork of the popular PEG.js project, offering improved performance, better error handling, and additional features. Peggy allows developers to define grammars using a clear and concise syntax, making it easy to create parsers for a wide range of applications.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
chevrotain02,7831.23 MB314 months agoApache-2.0
jison04,386-1629 years agoMIT
nearley03,741-1986 years agoMIT
peggy01,170592 kB364 months agoMIT

Feature Comparison: chevrotain vs jison vs nearley vs peggy

Parsing Strategy

  • chevrotain:

    chevrotain uses a top-down parsing approach with support for recursive descent and custom parsing strategies. It allows developers to implement their own parsing logic while providing tools for building efficient parsers.

  • jison:

    jison uses a bottom-up parsing approach (LALR(1)) similar to Yacc/Bison. It generates parsers based on the grammar specification, making it suitable for deterministic context-free grammars.

  • nearley:

    nearley uses the Earley parsing algorithm, which can handle all context-free grammars, including ambiguous ones. This makes it more flexible than traditional parsers, especially for complex or non-deterministic grammars.

  • peggy:

    peggy uses the Parsing Expression Grammar (PEG) formalism, which is a top-down parsing approach with backtracking. PEGs are deterministic, meaning they do not allow ambiguity, which can lead to more predictable parsing behavior.

Grammar Specification

  • chevrotain:

    chevrotain allows grammar to be defined programmatically using JavaScript, providing flexibility and control over the parsing process. This approach enables dynamic grammar construction and customization.

  • jison:

    jison uses a BNF-like syntax for grammar specification, similar to Yacc/Bison. This makes it familiar to developers with experience in traditional parser generators.

  • nearley:

    nearley uses a simple and intuitive syntax for defining grammars, which supports both deterministic and ambiguous rules. It also allows for the inclusion of custom JavaScript code within the grammar.

  • peggy:

    peggy uses a PEG-based syntax for grammar definition, which is clear and concise. PEGs are designed to be easy to read and write, making peggy a good choice for developers who prefer this formalism.

Error Handling

  • chevrotain:

    chevrotain provides tools for implementing custom error handling and recovery strategies. It allows developers to create detailed error messages and handle parsing errors in a way that best suits their application.

  • jison:

    jison generates parsers with basic error handling capabilities, including the ability to define custom error messages and recovery rules. However, error handling is limited compared to more modern tools.

  • nearley:

    nearley has limited built-in error handling, but it allows developers to implement their own error reporting and recovery mechanisms. The flexibility of the Earley algorithm can make error handling more complex.

  • peggy:

    peggy offers improved error handling compared to its predecessor, PEG.js, with better support for reporting syntax errors and providing meaningful messages. It also allows for custom error handling within the grammar.

Performance

  • chevrotain:

    chevrotain is designed for high performance, especially for large and complex grammars. Its architecture allows for efficient parsing with minimal overhead, making it suitable for real-time applications.

  • jison:

    jison generates efficient parsers based on the LALR(1) algorithm, which is well-suited for deterministic grammars. However, performance can vary depending on the complexity of the grammar and the generated code.

  • nearley:

    nearley is generally slower than LALR parsers due to the Earley algorithm's complexity, especially for ambiguous grammars. However, it offers greater flexibility and can handle a wider range of grammars.

  • peggy:

    peggy is optimized for performance within the constraints of PEG parsing. While PEG parsers can be slower than LALR parsers for certain grammars, peggy is designed to generate efficient code that minimizes backtracking.

Ease of Use: Code Examples

  • chevrotain:

    chevrotain Example

    const { createToken, Lexer, Parser } = require('chevrotain');

// Define tokens
const NumberLiteral = createToken({ name: 'NumberLiteral', pattern: /\d+/ });
const Plus = createToken({ name: 'Plus', pattern: /\+/ });
const WhiteSpace = createToken({ name: 'WhiteSpace', pattern: /\s+/, group: Lexer.SKIPPED });

// Create a lexer
const allTokens = [WhiteSpace, Plus, NumberLiteral];
const SimpleLexer = new Lexer(allTokens);

// Create a parser
class SimpleParser extends Parser {
  constructor() {
    super(allTokens);
    const $ = this;
    $.RULE('expression', () => {
      $.CONSUME(NumberLiteral);
      $.CONSUME(Plus);
      $.CONSUME(NumberLiteral);
    });
    this.performSelfAnalysis();
  }
}

const parser = new SimpleParser();
const input = '3 + 4';
const lexingResult = SimpleLexer.tokenize(input);
parser.input = lexingResult.tokens;
parser.expression();
console.log('Parsing completed successfully');
  • jison:

    jison Example

    const jison = require('jison');

// Define grammar
const grammar = {
  lex: {
    rules: [
      ['\s+', ''],
      ['\d+', 'return "NUMBER";'],
      ['\+', 'return "+";'],
      ['$end', 'return "EOF";'],
    ],
  },
  bnf: {
    expression: [
      ['expression + term', 'return $1 + $3;'],
      ['term', 'return $1;'],
    ],
    term: [['NUMBER', 'return Number(yytext);']],
  },
};

// Create parser
const parser = new jison.Parser(grammar);

// Parse input
const result = parser.parse('3 + 4');
console.log('Result:', result);
  • nearley:

    nearley Example

    const nearley = require('nearley');
const grammar = require('./simple-grammar.js'); // Assume grammar is compiled

// Create parser
const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));

// Parse input
parser.feed('3 + 4');
console.log('Parse results:', parser.results);
  • peggy:

    peggy Example

    const peggy = require('peggy');

// Define grammar
const grammar = `
  Expression
    = head:Term tail:(_ "+" _ Term)* {
        return tail.reduce((result, element) => result + element[3], head);
      }
  Term
    = [0-9]+ { return parseInt(text(), 10); }
  _
    = [ \t\n\r]*
`;

// Generate parser
const parser = peggy.generate(grammar);

// Parse input
const result = parser.parse('3 + 4');
console.log('Result:', result);

How to Choose: chevrotain vs jison vs nearley vs peggy

  • chevrotain:

    Choose chevrotain if you need a highly performant and customizable parser with support for complex grammars. It is ideal for projects that require fine-grained control over the parsing process and need to handle large inputs efficiently.

  • jison:

    Choose jison if you are familiar with traditional parser generator tools like Yacc/Bison and need to create parsers using a similar grammar specification format. It is suitable for projects that require a more formal approach to grammar definition and parsing.

  • nearley:

    Choose nearley if you need to parse ambiguous or non-deterministic grammars and want a simple, easy-to-use tool that supports flexible parsing strategies. It is great for projects that require more flexibility in grammar design and can handle multiple interpretations of the input.

  • peggy:

    Choose peggy if you prefer using Parsing Expression Grammars (PEG) and want a modern, efficient parser generator with a clean syntax. It is ideal for projects that benefit from the PEG formalism and need a tool with good performance and error handling.

Similar Npm Packages to chevrotain

chevrotain is a powerful parsing library for JavaScript that allows developers to create parsers for custom languages and domain-specific languages (DSLs). It is designed to be fast and efficient, providing a simple API for defining grammars and parsing input text. Chevrotain is particularly useful for applications that require complex parsing capabilities, such as compilers, interpreters, or any tool that needs to process structured text. Its flexibility and performance make it a popular choice among developers looking to implement custom parsing solutions.

There are several alternatives to chevrotain that also provide parsing capabilities:

  • jison is a parser generator that can create parsers from a formal grammar specification. It is inspired by Bison and Yacc, two well-known parser generators in the C/C++ ecosystem. Jison allows developers to define grammars in a concise way and generates JavaScript code that can parse input according to those grammars. If you are familiar with traditional parser generators and prefer a similar approach in JavaScript, jison is a solid choice.
  • nearley is a simple, powerful, and flexible parsing library that uses a parsing technique called Earley parsing. It allows developers to define grammars in a straightforward way and can handle ambiguous grammars, making it suitable for a wide range of parsing tasks. Nearley is particularly useful for applications that require the ability to parse complex or ambiguous input, and its ease of use makes it a popular choice for developers looking for a robust parsing solution.
  • pegjs is another parser generator that creates parsers from a formal grammar defined in a PEG (Parsing Expression Grammar) format. PEGs are a powerful way to define grammars, and pegjs provides a simple syntax for writing them. The generated parsers are efficient and can be used for a variety of parsing tasks. If you prefer the PEG approach and want a straightforward way to create parsers in JavaScript, pegjs is an excellent option.

To see how chevrotain compares with jison, nearley, and pegjs, check out the comparison: Comparing chevrotain vs jison vs nearley vs pegjs.

Similar Npm Packages to jison

jison is a parser generator for JavaScript that allows developers to create parsers from a formal grammar. It is inspired by the popular yacc parser generator and provides a simple way to define grammars using a syntax that is easy to understand. With jison, you can generate parsers that can process and interpret structured text, making it useful for applications like compilers, interpreters, and data format parsers. Its flexibility and ease of use make it a popular choice for developers looking to implement custom parsing solutions in their JavaScript applications.

While jison is a powerful tool for parsing, there are alternatives available that may better suit specific needs:

  • nearley is a versatile parser generator that is designed to handle a wide range of grammars, including ambiguous ones. It uses a different approach than traditional parser generators, allowing for more flexibility in grammar definitions. Nearley is particularly useful for complex parsing tasks and supports features like context-free grammars and custom actions. If you need a parser that can handle intricate language constructs or if you want to work with ambiguous grammars, nearley is an excellent choice.
  • pegjs is another parser generator that focuses on simplicity and ease of use. It allows developers to define grammars using a PEG (Parsing Expression Grammar) syntax, which is intuitive and straightforward. PEGs provide a way to describe syntax without ambiguity, making pegjs a great option for parsing tasks where clarity is essential. If you are looking for a parser generator that emphasizes simplicity and a clear grammar definition, pegjs is worth considering.

To see how jison compares with nearley and pegjs, check out the comparison: Comparing jison vs nearley vs pegjs.

Similar Npm Packages to nearley

nearley is a powerful parser generator for JavaScript that allows developers to create parsers for context-free grammars. It is particularly useful for applications that require custom parsing of languages or data formats. Nearley is designed to be simple to use while providing the flexibility needed for complex parsing tasks. It supports a variety of features, such as grammar composition, allowing developers to build upon existing grammars easily. While nearley is a robust choice for parsing needs, there are several alternatives available in the ecosystem. Here are a few notable ones:

  • antlr4 is a popular parser generator that can be used to build parsers for a wide range of languages. ANTLR (Another Tool for Language Recognition) provides a powerful framework for defining grammars and generating parsers in multiple programming languages, including JavaScript. It is well-suited for complex parsing tasks and offers features such as syntax tree generation and error handling. If you need a comprehensive solution for building parsers for complex languages or DSLs (Domain-Specific Languages), ANTLR4 is an excellent choice.
  • jison is a parser generator that is similar to yacc/bison but designed for JavaScript. It allows developers to define grammars in a straightforward way and generates parsers that can be used in web applications. Jison is particularly useful for creating parsers for simple programming languages or data formats. If you are looking for a lightweight and easy-to-use parser generator for JavaScript, Jison is a solid option.
  • pegjs is another parser generator for JavaScript that uses Parsing Expression Grammar (PEG) to define grammars. PEG is a formal grammar framework that allows for more expressive grammars compared to traditional context-free grammars. PEG.js is designed to be easy to use and integrates well with JavaScript applications. If you prefer a parser generator that leverages PEG and offers a straightforward API, PEG.js is worth considering.

To see how nearley compares with antlr4, jison, and pegjs, check out the comparison: Comparing antlr4 vs jison vs nearley vs pegjs.

Similar Npm Packages to peggy

peggy is a powerful and flexible parser generator for JavaScript. It allows developers to define grammars in a concise and readable way, enabling the creation of parsers for various languages or data formats. Peggy is particularly well-suited for projects that require custom parsing logic, such as compilers, interpreters, or data transformation tools. Its ability to generate efficient parsers from EBNF (Extended Backus-Naur Form) grammars makes it a popular choice among developers looking for a robust parsing solution.

While Peggy is a strong option for parsing tasks, there are several alternatives in the JavaScript ecosystem that also provide parsing capabilities. Here are a few notable ones:

  • chevrotain is a fast and efficient parser library that focuses on performance and flexibility. It allows developers to create parsers using a simple API and supports both lexical and syntactical analysis. Chevrotain is particularly useful for applications that require high-performance parsing, such as IDEs or code analysis tools. Its ability to handle complex grammars and provide detailed error reporting makes it a strong alternative to Peggy for certain use cases.

  • jison is a parser generator that is inspired by Bison and Yacc. It allows developers to define grammars in a straightforward manner and generates JavaScript parsers from those definitions. Jison is well-suited for projects that require a traditional parser generator approach, and it can be a good choice for those who are familiar with Bison or Yacc. Its simplicity and ease of use make it a viable alternative to Peggy for many parsing tasks.

  • nearley is a versatile parser toolkit that supports a wide range of parsing techniques, including context-free grammars and PEG (Parsing Expression Grammar). Nearley allows developers to define grammars in a clear and concise way, and it can handle complex parsing scenarios with ease. Its flexibility and support for various parsing strategies make it a strong candidate for projects that require advanced parsing capabilities.

To explore how Peggy compares with Chevrotain, Jison, and Nearley, check out the comparison: Comparing chevrotain vs jison vs nearley vs peggy.

README for chevrotain

Chevrotain

For details see:

Install

Using npm:

npm install chevrotain

or using yarn:

yarn add chevrotain
npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.