@apexdevtools/apex-parser 4.3.1 → 5.0.0-beta.1

package/CHANGELOG.md

@@ -0,0 +1,110 @@
+# apex-parser - Changelog
+
+## 5.0.0
+
+## General
+
+- **(BREAKING)** Updated to ANTLR runtime `4.13.2`, using the ANTLR tool to generate both target languages.
+
+- Enabled `caseInsensitive` option for lexers (added in ANTLR 4.10).
+  - As a result, `CaseInsensitiveInputStream` is deprecated and should no longer be required.
+
+- Added `ApexParserFactory` class to create parsers, token streams, and lexers.
+  - Primarily for TS to avoid directly creating `antlr4` class instances.
+  - In Java, it still requires passing a `CharStream` or `CommonTokenStream` to create parsers.
+
+- Added abstract class `ApexErrorListener`:
+  - Implement method `apexSyntaxError(line, column, message)` to avoid antlr specific types.
+
+- Added support for parsing Anonymous Apex via `anonymousUnit` (.apex files) and `anonymousBlock` parser rules.
+
+### Java
+
+- Added `Check.run` to programmatically run syntax check operation on a path.
+
+### TypeScript/NPM
+
+- **(BREAKING)** Migrated from `antlr4ts` to official `antlr4` runtime package.
+  - Some lesser used methods are missing in the type definitions, refer to the [antlr4 Javascript code](https://github.com/antlr/antlr4/tree/dev/runtime/JavaScript/src/antlr4) if you need to cast types.
+  - Generated `Listener`/`Visitor` interfaces are now abstract classes.
+    - Introduced `Base` classes to extend instead, following pattern of Java classes of the same name. Change:
+      - `implements ApexParserListener` to `extends ApexParserBaseListener`
+      - `implements ApexParserVisitor<T>` to `extends ApexParserBaseVisitor<T>`
+  - Parser rule contexts now have `_list()` methods for multi rules.
+    - A rule `expr*` generates `expr_list()` and `expr(number)`.
+    - By contrast Java would have overloads of `expr()`/`expr(int)` returning list or value.
+
+- **(BREAKING)** Re-exported antlr classes `CommonTokenStream` and `ParseTreeWalker` removed.
+  - Added type aliases like `ApexTokenStream`, `ApexParseTree`, and more to use with listener/visitor/walker.
+  - For the walker, use `ApexParseTreeWalker.DEFAULT`. Same instance but typed for `ApexParserListener` and `ApexParseTree`.
+  - It should no longer be required to depend on `antlr4` package directly.
+    - Can still add the package as a dependency, but remember to match the version `apex-parser` uses.
+
+- **(BREAKING)** Updated output to `ES2020` and increased min node version to 16.
+
+- `CaseInsensitiveInputStream` (deprecated) type now extends `CharStream` and can be constructed from `string`.
+  - Constructor passing in `CharStream` retained to match Java version.
+
+- Removed `node-dir` dependency - replaced with node fs api.
+
+## 4.4.0 - 2024-12-14
+
+- Support `TimeLiteral` for `Time` fields, e.g. `WHERE TimeField__c = 01:00:00.000Z` for SOQL queries
+
+## 4.3.1 - 2024-11-12
+
+- Fix Lexer support for uppercase Hex
+- Fix parser `whenValue` to support type refs
+
+## 4.3.0 - 2024-09-26
+
+- Add `convertCurrency` and `FORMAT` SOQL/SOSL functions
+- Support nested functions in `FORMAT`
+- Support aliases on SOSL functions
+
+## 4.2.0 - 2024-09-02
+
+- Add support for multiple nested SOQL sub queries
+- Add support for `GROUPING` in SOQL query
+- Add support for `toLabel` in SOSL query
+
+## 4.1.0 - 2024-05-12
+
+- Allow WITH USER_MODE or SYSTEM_MODE on SOSL queries
+
+## 4.0.0 - 2024-03-28
+
+- Correct trigger body parsing to allow member declarations
+- Add support for TYPEOF in SOQL subqueries
+- Change com.nawforce.apexparser packages to io.github.apexdevtools.apexparser
+
+## 3.6.0 - 2024-02-15
+
+- Add null coalesce operator and expression
+
+## 3.5.0 - 2023-10-15
+
+- Correct do-while to require block rather than statement
+
+## 3.4.0 - 2023-08-22
+
+- Support +/- sequences on numeric literals in switch 'when' expressions
+
+## 3.3.0 - 2023-04-30
+
+- Update to ANTLR 4.9.1
+
+## 3.2.0 - 2023-01-24
+
+- Adds user/system mode on DML and within SOQL queries
+
+## 3.1.0 - 2022-11-17
+
+- Adds DISTANCE and GEOLOCATION literals for SOQL.
+- Removes support for modulus operator to match apex.
+- Use of `void.class` no longer causes syntax error.
+- Now supports newer Date literals from API 55.
+
+## 3.0.0 - 2022-06-14
+
+- Initial github release.

package/README.md

@@ -1,79 +1,135 @@
 # apex-parser
 
-Parser for Salesforce Apex (including Triggers & inline SOQL/SOQL). This is based on an [ANTLR4](https://www.antlr.org/) grammar, see antlr/ApexParser.g4.
+Parser for Salesforce Apex (including Triggers & inline SOQL/SOQL). This is based on an [ANTLR4](https://www.antlr.org/) grammar, see [`antlr/BaseApexParser.g4`](./antlr/BaseApexParser.g4). Currently packaged for Java and JavaScript/TypeScript targets.
 
-There are two builds of the parser available, a NPM module for use with Node and a Maven package for use on JVMs.
+The packages include ANTLR4 generated types plus optional extras for convenience. The TypeScript package exports type aliases for ANTLR types, while both packages have abstractions like `ApexParserFactory` and `ApexErrorListener`. There are minimal examples below and in the test classes.
 
-These builds just contain the Parser & Lexer and provides no further support for analysing the generated parse trees beyond what is provided by ANTLR4.
+## Installation
 
-As Apex & SOQL/SOQL are case-insenstive languages you need to use the provided CaseInsensitiveInputStream for the parser to function correctly. When parsing Apex, inline SOQL/SOSL is automtaically parsed, but you can also parse SOQL/SOQL directly. You can find some minimal examples in the test classes.
+### Maven
 
-## Example
+```xml
+<dependency>
+    <groupId>io.github.apex-dev-tools</groupId>
+    <artifactId>apex-parser</artifactId>
+    <version><!-- version --></version>
+</dependency>
+```
 
-To parse a class file (NPM version):
+### NPM
 
-    let lexer = new ApexLexer(new CaseInsensitiveInputStream("public class Hello {}"))
-    let tokens  = new CommonTokenStream(lexer);
+```sh
+# Optionally install `antlr4` to use runtime types
+npm i @apexdevtools/apex-parser
+```
 
-    let parser = new ApexParser(tokens)
-    let context = parser.compilationUnit()
+## Usage
 
-The 'context' is a CompilationUnitContext object which is the root of the parsed representation of the class. You can access the parse tree via functions on it.
+`ApexParser` entry points to access tree:
 
-## Unicode handling
+- `compilationUnit()`, a class file.
+- `triggerUnit()`, a trigger file.
+- `anonymousUnit()`, an apex script file.
+- `query()`, a raw SOQL query.
 
-Prior to 2.12.0 the use of ANTLRInputStream for reading data in CaseInsensitiveStream would result character positions being given for UTF-16. The switch to CharStream input in 2.12.0 for JVM and 2.14.0 for node results in character positions reflecting Unicode code points.
+### Explore Parse Tree (TypeScript)
 
-## antlr4ts versions
+```typescript
+import { ApexParserFactory, ApexParserBaseVisitor } from "@apexdevtools/apex-parser";
 
-The npm module uses antlr4ts 0.5.0-alpha.4, this was updated from 0.5.0-alpha.3 in the 2.9.1 version. You should make
-sure that if you are using a matching versions of this dependency if you use it directly. To avoid issues you can
-import 'CommonTokenStream' & 'ParseTreeWalker' from 'apex-parser' instead of from antlr4ts.
+const parser = ApexParserFactory.createParser("public class Hello {}");
 
-    import { CommonTokenStream} from "apex-parser";
-    import { ParseTreeWalker } from "apex-parser";
+/*
+ * Use a visitor. Return value and manual control.
+ */
+class Visitor extends ApexParserBaseVisitor<any> {}
 
-## SOSL FIND quoting
+const visitor = new Visitor();
+visitor.visit(parser.compilationUnit());
+
+
+/*
+ * Or walk with listener. Enter/exit operations - for whole tree.
+ */
+class Listener extends ApexParserBaseListener {}
+
+const listener = new Listener();
+ApexParseTreeWalker.DEFAULT.walk(listener, parser.compilationUnit());
+```
+
+### SOSL FIND quoting
 
 SOSL FIND uses ' as a quoting character when embedded in Apex, in the API braces are used:
 
-    Find {something} RETURNING Account
+```sosl
+Find {something} RETURNING Account
+```
+
+To parse the API format there is an alternative parser rule, `soslLiteralAlt`, that you can use instead of `soslLiteral`. See `SOSLParserTest` for some examples of how these differ.
+
+## Development
+
+### Prerequisites
+
+- JDK 11+ (for ANTLR tool)
+- Maven
+- NodeJS LTS
+
+### Building
+
+The outer package contains scripts to build both distributions:
+
+```shell
+# Run once - prepare for dev (installs deps, runs antlr gen)
+npm run init
 
-To parse the API format there is an alternative parser rule, soslLiteralAlt, that you can use instead of soslLiteral. See SOSLParserTest for some examples of how these differ.
+# Run antlr gen, compile and test
+npm run build
+```
 
-## Packages
+Or you can setup and later build each distribution separately:
 
-Maven
+```shell
+npm run init:npm
+npm run build:npm
 
-    <dependency>
-        <groupId>io.github.apex-dev-tools</groupId>
-        <artifactId>apex-parser</artifactId>
-        <version>4.3.1</version>
-    </dependency>
+npm run init:jvm
+npm run build:jvm
+```
 
-NPM
+### Testing
 
-    "@apexdevtools/apex-parser": "^4.3.1"
+#### Unit Tests
 
-## Building
+More options for testing:
 
-To build both distributions:
+```shell
+# From ./npm
+npm run build
+npm test
+# File and test name regex filtering
+npm test -- ApexParserTest -t Expression
 
-    npm run build
+# From ./jvm
+mvn test
+```
 
-## Testing
+#### System Tests
 
-Unit tests are executed during the respective package builds. The system tests require both packages to be built, as the js test also spawns the jar version. They use a collection of sample projects located in the [apex-samples](https://github.com/apex-dev-tools/apex-samples) repository. Follow the README instructions in apex-samples to checkout the submodules. To run the tests:
+The system tests use a collection of sample projects located in the [`apex-samples`](https://github.com/apex-dev-tools/apex-samples) repository. Follow the README instructions in `apex-samples` to checkout the submodules at the version tag used by the [build workflow](.github/workflows/Build.yml). Both packages must be built beforehand, as the js system test spawns the jar as well.
 
-    # Set SAMPLES env var to samples repo location
-    export SAMPLES=<abs path to apex-samples>
+To run the tests:
 
-    # Exec test script
-    npm run test-samples
+```shell
+# Set SAMPLES env var to samples repo location
+export SAMPLES=<abs path to apex-samples>
 
-System test failures relating to the snapshots may highlight regressions. Though if an error is expected or the samples have changed, instead use `npm run test-snapshot` to update the snapshots, then commit the changes.
+# From root dir
+npm run build
+npm run systest
+```
 
-The tag version of apex-samples used by builds is set in the [build file](.github/workflows/Build.yml).
+System test failures relating to the snapshots may highlight regressions. Though if an error is expected or the samples have changed, instead use `npm run systest:update` to update the snapshots, then commit the changes.
 
 ## Source & Licenses
 

package/lib/ApexErrorListener.d.ts

@@ -0,0 +1,25 @@
+import { ErrorListener, RecognitionException, Recognizer, Token } from "antlr4";
+/**
+ * Base `ErrorListener` for Apex parsers.
+ *
+ * Implement `apexSyntaxError()` to set behaviour.
+ */
+export declare abstract class ApexErrorListener extends ErrorListener<Token> {
+    abstract apexSyntaxError(line: number, column: number, msg: string): void;
+    syntaxError(recognizer: Recognizer<Token>, offendingSymbol: Token, line: number, column: number, msg: string, e: RecognitionException | undefined): void;
+}
+export declare class ApexSyntaxError extends Error {
+    line: number;
+    column: number;
+    message: string;
+    constructor(line: number, column: number, message: string);
+}
+/**
+ * `ApexErrorListener` that throws an `ApexSyntaxError` on first reported error.
+ *
+ * Use ThrowingErrorListener.INSTANCE to share across parsers.
+ */
+export declare class ThrowingErrorListener extends ApexErrorListener {
+    static readonly INSTANCE: ThrowingErrorListener;
+    apexSyntaxError(line: number, column: number, msg: string): void;
+}

package/lib/ApexErrorListener.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThrowingErrorListener = exports.ApexSyntaxError = exports.ApexErrorListener = void 0;
+/*
+ [The "BSD licence"]
+ Copyright (c) 2025 Kevin Jones, Certinia Inc.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+const antlr4_1 = require("antlr4");
+/**
+ * Base `ErrorListener` for Apex parsers.
+ *
+ * Implement `apexSyntaxError()` to set behaviour.
+ */
+class ApexErrorListener extends antlr4_1.ErrorListener {
+    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+        this.apexSyntaxError(line, column, msg);
+    }
+}
+exports.ApexErrorListener = ApexErrorListener;
+class ApexSyntaxError extends Error {
+    constructor(line, column, message) {
+        super(message);
+        this.line = line;
+        this.column = column;
+        this.name = this.constructor.name;
+    }
+}
+exports.ApexSyntaxError = ApexSyntaxError;
+/**
+ * `ApexErrorListener` that throws an `ApexSyntaxError` on first reported error.
+ *
+ * Use ThrowingErrorListener.INSTANCE to share across parsers.
+ */
+class ThrowingErrorListener extends ApexErrorListener {
+    apexSyntaxError(line, column, msg) {
+        throw new ApexSyntaxError(line, column, msg);
+    }
+}
+exports.ThrowingErrorListener = ThrowingErrorListener;
+ThrowingErrorListener.INSTANCE = new ThrowingErrorListener();
+//# sourceMappingURL=ApexErrorListener.js.map

package/lib/ApexErrorListener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApexErrorListener.js","sourceRoot":"","sources":["../src/ApexErrorListener.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BE;AACF,mCAAgF;AAEhF;;;;GAIG;AACH,MAAsB,iBAAkB,SAAQ,sBAAoB;IAGlE,WAAW,CACT,UAA6B,EAC7B,eAAsB,EACtB,IAAY,EACZ,MAAc,EACd,GAAW,EACX,CAAmC;QAEnC,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1C,CAAC;CACF;AAbD,8CAaC;AAED,MAAa,eAAgB,SAAQ,KAAK;IAKxC,YAAY,IAAY,EAAE,MAAc,EAAE,OAAe;QACvD,KAAK,CAAC,OAAO,CAAC,CAAC;QAEf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;IACpC,CAAC;CACF;AAZD,0CAYC;AAED;;;;GAIG;AACH,MAAa,qBAAsB,SAAQ,iBAAiB;IAG1D,eAAe,CAAC,IAAY,EAAE,MAAc,EAAE,GAAW;QACvD,MAAM,IAAI,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IAC/C,CAAC;;AALH,sDAMC;AALiB,8BAAQ,GAAG,IAAI,qBAAqB,EAAE,CAAC"}

package/lib/ApexParserFactory.d.ts

@@ -0,0 +1,69 @@
+import { CommonTokenStream, ErrorNode, ParserRuleContext, ParseTree, ParseTreeListener, ParseTreeVisitor, ParseTreeWalker, RuleNode, TerminalNode, Token } from "antlr4";
+import ApexParserListener from "./antlr/ApexParserListener";
+import ApexParserVisitor from "./antlr/ApexParserVisitor";
+import ApexLexer from "./antlr/ApexLexer";
+import ApexParser from "./antlr/ApexParser";
+export type ApexParserRuleContext = ParserRuleContext;
+export type ApexErrorNode = ErrorNode;
+export type ApexParseTree = ParseTree;
+export type ApexRuleNode = RuleNode;
+export type ApexTerminalNode = TerminalNode;
+export type ApexTokenStream = CommonTokenStream;
+export type ApexToken = Token;
+/**
+ * A factory for `ApexParser` and its components. Abstracts interaction
+ * with core ANTLR types like `CommonTokenStream`.
+ */
+export declare class ApexParserFactory {
+    private constructor();
+    static createParser(source: string | ApexTokenStream, throwOnFirstError?: boolean): ApexParser;
+    static createTokenStream(source: string | ApexLexer): ApexTokenStream;
+    static createLexer(source: string): ApexLexer;
+}
+/**
+ * A base visitor for an Apex parse tree produced by `ApexParser`. Extend this
+ * class to define a subset of visitor operations.
+ *
+ * @see ApexParserVisitor for tree context visit operations.
+ * @param Result The return type of the visit operation. Use `void` for
+ * operations with no return type.
+ * @example
+ * // Implementations can be property or method styles.
+ * visitCompilationUnit = (ctx: CompilationUnitContext) => { return result; }
+ * visitCompilationUnit(ctx: CompilationUnitContext) { return result; }
+ */
+export declare class ApexParserBaseVisitor<Result> extends ParseTreeVisitor<Result> implements ApexParserVisitor<Result> {
+    visit(tree: ApexParseTree): Result;
+    visitChildren(node: ApexRuleNode): Result;
+    visitTerminal(node: ApexTerminalNode): Result;
+    visitErrorNode(node: ApexErrorNode): Result;
+}
+/**
+ * A base listener for an Apex parse tree produced by `ApexParser`. Extend this
+ * class to define a subset of listener operations.
+ *
+ * @see ApexParserListener for tree context listen operations.
+ * @example
+ * // Implementations can be property or method styles.
+ * enterCompilationUnit = (ctx: CompilationUnitContext) => {}
+ * enterCompilationUnit(ctx: CompilationUnitContext) {}
+ */
+export declare class ApexParserBaseListener extends ParseTreeListener implements ApexParserListener {
+    visitTerminal(node: ApexTerminalNode): void;
+    visitErrorNode(node: ApexErrorNode): void;
+    enterEveryRule(ctx: ApexParserRuleContext): void;
+    exitEveryRule(ctx: ApexParserRuleContext): void;
+}
+/**
+ * Walker for a parse tree starting at the root and going down recursively
+ * with depth-first search.
+ *
+ * @example
+ * const parser = ApexParserFactory.createParser("public class Foo {}");
+ * const listener = new MyListener(); // extends ApexParseTreeListener
+ * ApexParseTreeWalker.DEFAULT.walk(listener, parser.compilationUnit());
+ */
+export declare class ApexParseTreeWalker extends ParseTreeWalker {
+    static DEFAULT: ApexParseTreeWalker;
+    walk<T extends ApexParserListener>(listener: T, t: ApexParseTree): void;
+}

package/lib/ApexParserFactory.js

@@ -0,0 +1,125 @@
+"use strict";
+/*
+ [The "BSD licence"]
+ Copyright (c) 2025 Kevin Jones, Certinia Inc.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApexParseTreeWalker = exports.ApexParserBaseListener = exports.ApexParserBaseVisitor = exports.ApexParserFactory = void 0;
+const antlr4_1 = require("antlr4");
+const ApexLexer_1 = require("./antlr/ApexLexer");
+const ApexParser_1 = require("./antlr/ApexParser");
+const ApexErrorListener_1 = require("./ApexErrorListener");
+/**
+ * A factory for `ApexParser` and its components. Abstracts interaction
+ * with core ANTLR types like `CommonTokenStream`.
+ */
+class ApexParserFactory {
+    constructor() { }
+    static createParser(source, throwOnFirstError = false) {
+        const parser = new ApexParser_1.default(typeof source === "string"
+            ? new antlr4_1.CommonTokenStream(this.createLexer(source))
+            : source);
+        // always remove default console listener
+        parser.removeErrorListeners();
+        if (throwOnFirstError) {
+            parser.addErrorListener(ApexErrorListener_1.ThrowingErrorListener.INSTANCE);
+        }
+        return parser;
+    }
+    static createTokenStream(source) {
+        return new antlr4_1.CommonTokenStream(typeof source === "string" ? this.createLexer(source) : source);
+    }
+    static createLexer(source) {
+        const lexer = new ApexLexer_1.default(antlr4_1.CharStreams.fromString(source));
+        // always remove default console listener
+        lexer.removeErrorListeners();
+        return lexer;
+    }
+}
+exports.ApexParserFactory = ApexParserFactory;
+/**
+ * A base visitor for an Apex parse tree produced by `ApexParser`. Extend this
+ * class to define a subset of visitor operations.
+ *
+ * @see ApexParserVisitor for tree context visit operations.
+ * @param Result The return type of the visit operation. Use `void` for
+ * operations with no return type.
+ * @example
+ * // Implementations can be property or method styles.
+ * visitCompilationUnit = (ctx: CompilationUnitContext) => { return result; }
+ * visitCompilationUnit(ctx: CompilationUnitContext) { return result; }
+ */
+class ApexParserBaseVisitor extends antlr4_1.ParseTreeVisitor {
+    visit(tree) {
+        return super.visit(tree);
+    }
+    visitChildren(node) {
+        return super.visitChildren(node);
+    }
+    visitTerminal(node) {
+        return super.visitTerminal(node);
+    }
+    visitErrorNode(node) {
+        return super.visitErrorNode(node);
+    }
+}
+exports.ApexParserBaseVisitor = ApexParserBaseVisitor;
+/**
+ * A base listener for an Apex parse tree produced by `ApexParser`. Extend this
+ * class to define a subset of listener operations.
+ *
+ * @see ApexParserListener for tree context listen operations.
+ * @example
+ * // Implementations can be property or method styles.
+ * enterCompilationUnit = (ctx: CompilationUnitContext) => {}
+ * enterCompilationUnit(ctx: CompilationUnitContext) {}
+ */
+class ApexParserBaseListener extends antlr4_1.ParseTreeListener {
+    visitTerminal(node) { }
+    visitErrorNode(node) { }
+    enterEveryRule(ctx) { }
+    exitEveryRule(ctx) { }
+}
+exports.ApexParserBaseListener = ApexParserBaseListener;
+/**
+ * Walker for a parse tree starting at the root and going down recursively
+ * with depth-first search.
+ *
+ * @example
+ * const parser = ApexParserFactory.createParser("public class Foo {}");
+ * const listener = new MyListener(); // extends ApexParseTreeListener
+ * ApexParseTreeWalker.DEFAULT.walk(listener, parser.compilationUnit());
+ */
+class ApexParseTreeWalker extends (_b = antlr4_1.ParseTreeWalker) {
+    walk(listener, t) {
+        super.walk(listener, t);
+    }
+}
+exports.ApexParseTreeWalker = ApexParseTreeWalker;
+_a = ApexParseTreeWalker;
+ApexParseTreeWalker.DEFAULT = Reflect.get(_b, "DEFAULT", _a);
+//# sourceMappingURL=ApexParserFactory.js.map

package/lib/ApexParserFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApexParserFactory.js","sourceRoot":"","sources":["../src/ApexParserFactory.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BE;;;;AAEF,mCAYgB;AAGhB,iDAA0C;AAC1C,mDAA4C;AAC5C,2DAA4D;AAU5D;;;GAGG;AACH,MAAa,iBAAiB;IAC5B,gBAAuB,CAAC;IAExB,MAAM,CAAC,YAAY,CACjB,MAAgC,EAChC,oBAA6B,KAAK;QAElC,MAAM,MAAM,GAAG,IAAI,oBAAU,CAC3B,OAAO,MAAM,KAAK,QAAQ;YACxB,CAAC,CAAC,IAAI,0BAAiB,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YACjD,CAAC,CAAC,MAAM,CACX,CAAC;QAEF,yCAAyC;QACzC,MAAM,CAAC,oBAAoB,EAAE,CAAC;QAC9B,IAAI,iBAAiB,EAAE;YACrB,MAAM,CAAC,gBAAgB,CAAC,yCAAqB,CAAC,QAAQ,CAAC,CAAC;SACzD;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,CAAC,iBAAiB,CAAC,MAA0B;QACjD,OAAO,IAAI,0BAAiB,CAC1B,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAC/D,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,WAAW,CAAC,MAAc;QAC/B,MAAM,KAAK,GAAG,IAAI,mBAAS,CAAC,oBAAW,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;QAE5D,yCAAyC;QACzC,KAAK,CAAC,oBAAoB,EAAE,CAAC;QAC7B,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AAlCD,8CAkCC;AAED;;;;;;;;;;;GAWG;AACH,MAAa,qBACX,SAAQ,yBAAwB;IAGhC,KAAK,CAAC,IAAmB;QACvB,OAAO,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED,aAAa,CAAC,IAAkB;QAC9B,OAAO,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,aAAa,CAAC,IAAsB;QAClC,OAAO,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,cAAc,CAAC,IAAmB;QAChC,OAAO,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;CACF;AAnBD,sDAmBC;AAED;;;;;;;;;GASG;AACH,MAAa,sBACX,SAAQ,0BAAiB;IAGzB,aAAa,CAAC,IAAsB,IAAS,CAAC;IAC9C,cAAc,CAAC,IAAmB,IAAS,CAAC;IAC5C,cAAc,CAAC,GAA0B,IAAS,CAAC;IACnD,aAAa,CAAC,GAA0B,IAAS,CAAC;CACnD;AARD,wDAQC;AAED;;;;;;;;GAQG;AACH,MAAa,mBAAoB,SAAQ,MAAA,wBAAe,CAAA;IAGtD,IAAI,CAA+B,QAAW,EAAE,CAAgB;QAC9D,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IAC1B,CAAC;;AALH,kDAMC;;AALQ,2BAAO,GAAG,8BAAoC,CAAC"}

package/lib/CaseInsensitiveInputStream.d.ts

@@ -1,16 +1,14 @@
-import { CharStream } from "antlr4ts";
-import { Interval } from "antlr4ts/misc/Interval";
-export declare class CaseInsensitiveInputStream implements CharStream {
-    private src;
-    constructor(src: CharStream);
-    getText(interval: Interval): string;
-    consume(): void;
+import { CharStream } from "antlr4";
+/**
+ * Converts char stream to lower case for case insensitive usage.
+ *
+ * @deprecated since 5.0.0. ApexLexer is generated with ANTLR 4.10
+ * `caseInsensitive` option enabled.
+ */
+export declare class CaseInsensitiveInputStream extends CharStream {
+    constructor(data: string, decodeToUnicodeCodePoints?: boolean);
+    constructor(stream: CharStream, decodeToUnicodeCodePoints?: boolean);
     LA(i: number): number;
-    mark(): number;
-    release(marker: number): void;
-    get index(): number;
-    seek(index: number): void;
-    get size(): number;
-    get sourceName(): string;
+    LT(offset: number): number;
     private toLower;
 }