ZeParser JavaScript Parser

Common errors

• SyntaxError: Unexpected token 'const'

  cause Attempting to parse JavaScript code containing `const`, `let`, arrow functions, classes, or other ES2015+ features.
  fix This parser is only compatible with ES5 (ECMAScript 5) and older syntax. It cannot parse modern JavaScript. Use a different, actively maintained parser.

• TypeError: ZeParser.parse is not a function

  cause Incorrectly importing the `ZeParser` module or attempting to call `parse` on a non-module object.
  fix Ensure you are using `const ZeParser = require('zeparser');` and then calling `ZeParser.parse(yourCode);`. This package is CommonJS, and its methods are accessed directly from the required module object.

• ReferenceError: require is not defined (in browser environments)

  cause Using `require('zeparser')` directly in a web browser without a CommonJS-compatible bundler.
  fix This package is intended for Node.js environments. For browser usage, you would need a tool like Webpack or Browserify to bundle it, but given its abandonment and lack of modern JS support, it's not recommended for new web projects.

Warnings

• breaking ZeParser is an abandoned package, last published in 2013 (v0.0.7). It does not support modern JavaScript syntax (ES2015+), including `const`/`let`, arrow functions, classes, modules, or other contemporary language features. Attempting to parse modern JS will result in parsing errors or incorrect trees.
  Fix: Use a modern JavaScript parser like Acorn, Babel Parser (@babel/parser), or Esprima for any code written post-ES5.
• gotcha The package is CommonJS-only and relies on `require()`. It does not provide ES Module exports (`import`). Using `import` statements directly will lead to module resolution errors in ESM-only environments.
  Fix: Always use `const ZeParser = require('zeparser');` for importing. If used in a modern ESM project, it might require a CommonJS wrapper or bundler configuration to work, but its primary limitation remains its inability to parse modern JS.
• gotcha The documentation mentions 'simple' and 'extended' parsing modes, with the extended mode being default (`.ast` property true). The structure of the parse tree and token objects, particularly meta-information, might be less intuitive or well-documented compared to contemporary AST standards like ESTree.
  Fix: Thoroughly inspect the outputted `parseTree`, `.wtree`, and `.btree` structures for specific token properties and array nesting. Expect a custom AST format rather than a standardized one.

Install

• npm install zeparser npm
• yarn add zeparser yarn
• pnpm add zeparser pnpm

Imports

• ZeParser
  wrong:

  import { ZeParser } from 'zeparser';

  correct:

  const ZeParser = require('zeparser');

  This package is CommonJS-only, as it was published in 2013 (v0.0.7) before the widespread adoption of ES Modules in Node.js. Direct ESM imports are not supported.
• parse
  wrong:

  import { parse } from 'zeparser';

  correct:

  const ZeParser = require('zeparser');
  const tree = ZeParser.parse('var a = 1;');

  The primary parsing function `parse` is a static method on the `ZeParser` object. Attempting to destructure it as a named import will fail.
• createParser
  wrong:

  const { createParser } = require('zeparser');

  correct:

  const ZeParser = require('zeparser');
  const parserInstance = ZeParser.createParser('var a = 1;');

  `createParser` is also a static method of the main `ZeParser` object and should be accessed directly from the imported module. Destructuring requires specific CommonJS patterns not typically used for methods.

Quickstart

This quickstart demonstrates how to use `ZeParser.parse()` to get a basic parse tree and `ZeParser.createParser()` to access detailed token streams (including and excluding whitespace/comments). It highlights the CommonJS `require` syntax.

const ZeParser = require('zeparser');

const inputCode = `
  function greet(name) {
    // A simple comment
    return 'Hello, ' + name + '!';
  }
  var message = greet('World');
`;

console.log('--- Parsing with ZeParser.parse() ---');
const parseTree = ZeParser.parse(inputCode);
// The parse tree is an array of arrays representing the AST structure.
// It includes tokens as leaf nodes.
console.log('Parse Tree (excerpt):', JSON.stringify(parseTree, null, 2).substring(0, 500) + '...');

console.log('\n--- Using ZeParser.createParser() for detailed token streams ---');
const parserInstance = ZeParser.createParser(inputCode);

// .wtree (white tree) includes all tokens, including whitespace and comments
console.log('White Tree (first 5 tokens):', parserInstance.wtree.slice(0, 5));

// .btree (black tree) is the token stream without whitespace, line terminators, or comments
console.log('Black Tree (first 5 tokens):', parserInstance.btree.slice(0, 5));

// Accessing a token's properties, e.g., the first token in the black tree
if (parserInstance.btree.length > 0) {
  const firstToken = parserInstance.btree[0];
  console.log('First token in black tree (type, value):', firstToken.type, firstToken.value);
}