nearley vs antlr4 vs pegjs vs jison vs shift-parser
JavaScript Parsing Libraries Comparison
Search packages..
1 Year
nearleyantlr4pegjsjisonshift-parser
What's JavaScript Parsing Libraries?

JavaScript parsing libraries are tools that help developers create parsers for processing and interpreting structured text, such as programming languages, data formats, or domain-specific languages. These libraries provide the necessary functionality to define grammars and generate parsers that can analyze and transform input text into a more manageable structure, such as an Abstract Syntax Tree (AST). This is essential for tasks like code analysis, transpilation, and building interpreters or compilers.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
nearley3,012,5433,682-1984 years agoMIT
antlr4825,59617,9133.09 MB1,0209 months agoBSD-3-Clause
pegjs533,5084,870-1169 years agoMIT
jison53,5104,371-1618 years agoMIT
shift-parser22,660256229 kB31-Apache-2.0
Feature Comparison: nearley vs antlr4 vs pegjs vs jison vs shift-parser

Grammar Definition

  • nearley:

    Nearley supports a flexible grammar definition that allows for ambiguous parsing. It uses a combination of parser combinators and can handle complex grammars that traditional parsers struggle with.

  • antlr4:

    ANTLR4 allows you to define complex grammars using a powerful syntax that supports features like semantic predicates and actions. It can generate parsers in multiple languages, making it versatile for cross-language projects.

  • pegjs:

    PEG.js allows you to define grammars using a clear and concise syntax based on Parsing Expression Grammar. This makes it easy to write and understand grammars, especially for domain-specific languages.

  • jison:

    Jison uses a simple syntax for grammar definitions, which is easy to learn and quick to implement. It is suitable for defining context-free grammars and can generate JavaScript parsers directly from the grammar files.

  • shift-parser:

    Shift Parser provides a grammar definition that closely mirrors the ECMAScript specification, making it ideal for parsing JavaScript code accurately. It focuses on providing a precise syntax tree for JavaScript.

Performance

  • nearley:

    Nearley is designed to handle ambiguous grammars, which can sometimes lead to slower parsing times compared to more deterministic parsers. However, it excels in scenarios where flexibility is required.

  • antlr4:

    ANTLR4 is optimized for performance and can handle large input files efficiently. Its generated parsers are fast and can be further optimized using various techniques provided by the framework.

  • pegjs:

    PEG.js offers good performance for most use cases, but its performance can degrade with very complex grammars due to backtracking. It is best suited for smaller to medium-sized grammars.

  • jison:

    Jison is lightweight and performs well for smaller grammars. However, it may not be as efficient for larger, more complex grammars compared to ANTLR4 or Nearley.

  • shift-parser:

    Shift Parser is highly optimized for parsing JavaScript and can handle large codebases efficiently. It is designed to provide fast parsing speeds while adhering to the ECMAScript specification.

Error Handling

  • nearley:

    Nearley offers flexible error handling, allowing for custom error messages and recovery strategies. Its ability to handle ambiguous grammars can also lead to more informative error reporting.

  • antlr4:

    ANTLR4 provides robust error handling mechanisms, allowing developers to customize error messages and recovery strategies. This is particularly useful for building tools that require precise feedback on syntax errors.

  • pegjs:

    PEG.js provides error handling features that allow developers to define custom error messages. However, its backtracking nature can sometimes complicate error recovery.

  • jison:

    Jison includes basic error handling capabilities, allowing developers to define custom error messages. However, it may not be as comprehensive as ANTLR4 in terms of recovery options.

  • shift-parser:

    Shift Parser focuses on accurate error reporting for JavaScript syntax. It provides detailed error messages that align with the ECMAScript specification, making it useful for debugging JavaScript code.

Community and Support

  • nearley:

    Nearley has a growing community and offers good documentation. Its flexibility and support for ambiguous grammars attract developers working on complex parsing tasks.

  • antlr4:

    ANTLR4 has a large and active community, with extensive documentation, tutorials, and examples available. This makes it easier for developers to find support and resources for their projects.

  • pegjs:

    PEG.js has a moderate community with sufficient documentation and examples. It is well-suited for developers looking for a clear and maintainable grammar definition approach.

  • jison:

    Jison has a smaller community compared to ANTLR4, but it still offers decent documentation and examples. It is suitable for developers looking for a straightforward solution without extensive support needs.

  • shift-parser:

    Shift Parser is more niche, focusing specifically on JavaScript parsing. Its community is smaller, but it provides targeted support for developers working with JavaScript syntax.

Ease of Use

  • nearley:

    Nearley offers a flexible approach that may require some learning, especially for those unfamiliar with parser combinators. However, its capabilities are worth the investment in learning.

  • antlr4:

    ANTLR4 has a steeper learning curve due to its extensive features and capabilities. However, once mastered, it provides powerful tools for building complex parsers.

  • pegjs:

    PEG.js is user-friendly and allows developers to define grammars in a clear and concise manner. Its syntax is easy to grasp, making it suitable for those new to parsing.

  • jison:

    Jison is easy to use and quick to get started with, making it ideal for beginners or those needing to implement simple parsers without much overhead.

  • shift-parser:

    Shift Parser is designed for JavaScript developers and is straightforward to use for those familiar with the language. Its focus on ECMAScript makes it accessible for JavaScript-specific projects.

How to Choose: nearley vs antlr4 vs pegjs vs jison vs shift-parser
  • nearley:

    Opt for Nearley if you need a parser generator that supports ambiguous grammars and offers a flexible approach to parsing. It is particularly useful for natural language processing or when dealing with complex input formats that require advanced parsing techniques.

  • antlr4:

    Choose ANTLR4 if you need a powerful parser generator that supports multiple programming languages and has a rich set of features for building complex grammars. It is suitable for large projects that require extensive parsing capabilities and has a strong community and documentation.

  • pegjs:

    Use PEG.js if you prefer a parser generator based on Parsing Expression Grammar (PEG) syntax. It is great for creating parsers that are easy to understand and maintain, especially for domain-specific languages or custom data formats.

  • jison:

    Select Jison if you are looking for a lightweight solution that is easy to integrate into JavaScript projects. It is particularly useful for simple parsing tasks and offers a straightforward syntax for defining grammars, making it ideal for smaller applications or quick prototypes.

  • shift-parser:

    Consider Shift Parser if you are working specifically with JavaScript and need a parser that adheres closely to the ECMAScript specification. It is designed for analyzing JavaScript code and is particularly useful for tools that require accurate syntax checking and code transformation.

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 antlr4

antlr4 is a powerful parser generator for reading, processing, and executing structured text or binary files. It is widely used for building domain-specific languages, interpreters, and compilers. ANTLR (ANother Tool for Language Recognition) provides a rich set of features, including support for multiple programming languages, automatic generation of parse trees, and robust error handling. While ANTLR4 is a popular choice for parsing tasks, there are several alternatives available that cater to different needs and preferences. Here are a few notable alternatives:

  • jison is a parser generator that allows developers to create parsers for JavaScript. It is inspired by Bison and Yacc and offers a simple syntax for defining grammars. Jison is particularly useful for projects that require a lightweight solution for parsing and compiling languages or data formats directly in JavaScript. If you are looking for a straightforward parser generator that integrates seamlessly with JavaScript, Jison is a solid option.
  • nearley is a fast and powerful parsing library for JavaScript that utilizes a parsing algorithm called Earley parsing. Nearley allows developers to define grammars in a simple and expressive way, supporting context-free grammars and even ambiguous grammars. It is particularly well-suited for projects that require flexibility in grammar definitions and the ability to parse complex languages. If you need a versatile and efficient parser, Nearley is worth considering.
  • pegjs is another parser generator for JavaScript that uses Parsing Expression Grammars (PEG). It allows developers to define grammars in a clear and concise manner and generates a parser that can be used in JavaScript applications. PEGs provide a more powerful and expressive way to define grammars compared to traditional context-free grammars. If you are looking for a parser generator that emphasizes simplicity and expressiveness, PEG.js is a great choice.

To see how ANTLR4 compares with Jison, Nearley, and PEG.js, check out the comparison: Comparing antlr4 vs jison vs nearley vs pegjs.

Similar Npm Packages to pegjs

pegjs is a parser generator for JavaScript that allows developers to create parsers for custom languages or data formats using a simple and expressive syntax. It generates efficient parsers that can be used in various applications, from compilers to interpreters and data processing tools. While pegjs is a powerful tool for building parsers, there are several alternatives available in the ecosystem. Here are a few notable ones:

  • antlr4 is a popular parser generator that supports multiple programming languages, including JavaScript. It is known for its powerful parsing capabilities and extensive feature set, including support for complex grammars, error handling, and tree construction. If you need a robust solution for building parsers for complex languages or require features like syntax highlighting and code completion, antlr4 is an excellent choice. It is widely used in both academic and industry projects, making it a reliable option for serious parser development.
  • jison is another parser generator that allows developers to create parsers using a syntax similar to BNF (Backus-Naur Form). It is designed to be easy to use and integrates well with JavaScript applications. jison is particularly useful for creating parsers for domain-specific languages (DSLs) or simple data formats. If you are looking for a straightforward and lightweight parser generator that can quickly produce parsers for less complex languages, jison is a solid option.
  • nearley is a fast and powerful parsing library that uses a parsing technique called Earley parsing. It is designed to handle ambiguous grammars and can parse any context-free grammar. nearley is particularly useful for projects that require flexibility in grammar design and the ability to parse complex languages. If you need a parser that can handle intricate grammar rules and provide advanced features like error recovery, nearley is a great choice.

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

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 shift-parser

shift-parser is a JavaScript library designed for parsing and analyzing JavaScript code. It provides a way to work with the Abstract Syntax Tree (AST) of JavaScript, enabling developers to manipulate and analyze code structures effectively. This makes it particularly useful for tools like linters, code analyzers, and transpilers. While shift-parser is a powerful tool for JavaScript parsing, there are several alternatives available in the ecosystem that cater to similar needs. Here are a few notable options:

  • antlr4 is a powerful parser generator that can be used to create parsers for various programming languages, including JavaScript. It allows developers to define grammars in a high-level syntax and generates parsers that can recognize and process input according to those grammars. ANTLR4 is particularly well-suited for complex parsing tasks and is widely used in various projects requiring robust parsing capabilities.

  • jison is a parser generator that allows developers to create parsers using a BNF-like syntax. It is designed to be easy to use and can generate parsers in JavaScript, making it a good choice for web applications. Jison is particularly useful for simpler parsing tasks and can be a great option for projects that require custom language parsing without the overhead of more complex libraries.

  • nearley is a simple, powerful, and fast parser 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 versatile for various parsing scenarios. Nearley is a great choice for projects that require flexibility in grammar definition and the ability to parse complex structures.

  • pegjs is another parser generator that uses Parsing Expression Grammar (PEG) to define grammars. It generates fast parsers that can be used in JavaScript applications. PEG allows for more expressive grammars compared to traditional context-free grammars, making pegjs suitable for a wide range of parsing tasks. It’s particularly useful when you need to create a parser for a custom language or data format.

To explore how shift-parser compares with these alternatives, check out the comparison: Comparing antlr4 vs jison vs nearley vs pegjs vs shift-parser.

README for nearley

nearley ↗️

JS.ORG npm version

nearley is a simple, fast and powerful parsing toolkit. It consists of:

  1. A powerful, modular DSL for describing languages
  2. An efficient, lightweight Earley parser
  3. Loads of tools, editor plug-ins, and other goodies!

nearley is a streaming parser with support for catching errors gracefully and providing all parsings for ambiguous grammars. It is compatible with a variety of lexers (we recommend moo). It comes with tools for creating tests, railroad diagrams and fuzzers from your grammars, and has support for a variety of editors and platforms. It works in both node and the browser.

Unlike most other parser generators, nearley can handle any grammar you can define in BNF (and more!). In particular, while most existing JS parsers such as PEGjs and Jison choke on certain grammars (e.g. left recursive ones), nearley handles them easily and efficiently by using the Earley parsing algorithm.

nearley is used by a wide variety of projects:

nearley is an npm staff pick.

Documentation

Please visit our website https://nearley.js.org to get started! You will find a tutorial, detailed reference documents, and links to several real-world examples to get inspired.

Contributing

Please read this document before working on nearley. If you are interested in contributing but unsure where to start, take a look at the issues labeled "up for grabs" on the issue tracker, or message a maintainer (@kach or @tjvr on Github).

nearley is MIT licensed.

A big thanks to Nathan Dinsmore for teaching me how to Earley, Aria Stewart for helping structure nearley into a mature module, and Robin Windels for bootstrapping the grammar. Additionally, Jacob Edelman wrote an experimental JavaScript parser with nearley and contributed ideas for EBNF support. Joshua T. Corbin refactored the compiler to be much, much prettier. Bojidar Marinov implemented postprocessors-in-other-languages. Shachar Itzhaky fixed a subtle bug with nullables.

Citing nearley

If you are citing nearley in academic work, please use the following BibTeX entry.

@misc{nearley,
    author = "Kartik Chandra and Tim Radvan",
    title  = "{nearley}: a parsing toolkit for {JavaScript}",
    year   = {2014},
    doi    = {10.5281/zenodo.3897993},
    url    = {https://github.com/kach/nearley}
}
npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.