@apexdevtools/apex-parser 5.0.0-beta.4 → 5.0.0-beta.5

package/node_modules/antlr4/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "antlr4",
+  "version": "4.13.2",
+  "type": "module",
+  "description": "JavaScript runtime for ANTLR4",
+  "browser": "dist/antlr4.web.mjs",
+  "main": "dist/antlr4.node.cjs",
+  "module": "dist/antlr4.node.mjs",
+  "types": "src/antlr4/index.d.cts",
+  "repository": "antlr/antlr4.git",
+  "keywords": [
+    "lexer",
+    "parser",
+    "antlr",
+    "antlr4",
+    "grammar"
+  ],
+  "files": [
+    "dist",
+    "src/**/*.d.cts",
+    "src/**/*.d.ts"
+  ],
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/antlr/antlr4/issues"
+  },
+  "homepage": "https://github.com/antlr/antlr4",
+  "devDependencies": {
+    "@babel/core": "^7.19.1",
+    "@babel/eslint-parser": "^7.19.1",
+    "@babel/preset-env": "^7.19.4",
+    "@types/node": "^18.7.23",
+    "babel-loader": "^8.2.5",
+    "c8": "^7.12.0",
+    "compression-webpack-plugin": "^10.0.0",
+    "eslint": "^8.23.1",
+    "eslint-webpack-plugin": "^3.2.0",
+    "glob-parent": "^6.0.2",
+    "jasmine": "^4.0.2",
+    "jasmine-spec-reporter": "^7.0.0",
+    "minimist": "^1.2.6",
+    "source-map-support": "^0.5.21",
+    "terser-webpack-plugin": "^5.3.6",
+    "typescript": "^4.8.3",
+    "webpack": "^5.76.0",
+    "webpack-cli": "^4.10.0"
+  },
+  "scripts": {
+    "build": "webpack",
+    "test": "jasmine",
+    "coverage": "c8 jasmine",
+    "lint": "eslint src/antlr4/"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/antlr4/index.d.cts",
+      "node": {
+        "import": "./dist/antlr4.node.mjs",
+        "require": "./dist/antlr4.node.cjs",
+        "default": "./dist/antlr4.node.mjs"
+      },
+      "browser": {
+        "import": "./dist/antlr4.web.mjs",
+        "require": "./dist/antlr4.web.cjs",
+        "default": "./dist/antlr4.web.mjs"
+      }
+    }
+  }
+}

package/node_modules/antlr4/src/antlr4/BufferedTokenStream.d.ts

@@ -0,0 +1,8 @@
+import { TokenStream } from './TokenStream.js';
+import { Lexer } from "./Lexer.js";
+
+export declare class BufferedTokenStream extends TokenStream {
+
+    tokenSource: Lexer;
+
+}

package/node_modules/antlr4/src/antlr4/CharStream.d.ts

@@ -0,0 +1,17 @@
+export declare class CharStream {
+
+    index: number; // defined as property
+    size: number;// defined as property
+
+    constructor(data: string);
+    constructor(data: string, decodeToUnicodeCodePoints: boolean);
+    reset(): void;
+    consume(): void;
+    LA(offset: number): number;
+    LT(offset: number): number;
+    mark(): number;
+    release(marker: number): void;
+    seek(index: number): void;
+    getText(start: number, stop: number): string;
+    toString(): string;
+}

package/node_modules/antlr4/src/antlr4/CharStreams.d.ts

@@ -0,0 +1,9 @@
+import {CharStream} from "./CharStream.js";
+
+export declare class CharStreams {
+    static fromString(data: string, decodeToUnicodeCodePoints?: boolean): CharStream;
+    static fromBuffer(buffer: Buffer, encoding?: string): CharStream;
+    static fromBlob(blob: Blob, encoding: string, onLoad: (stream: CharStream) => void, onError: (error: Error) => void): void;
+    static fromPath(path: string, encoding: string, callback: (err: Error, stream: CharStream) => void): void;
+    static fromPathSync(path: string, encoding: string): CharStream;
+}

package/node_modules/antlr4/src/antlr4/CommonToken.d.ts

@@ -0,0 +1,10 @@
+import { Token } from "./Token.js";
+import {InputStream} from "./InputStream.js";
+import {TokenSource} from "./TokenSource.js";
+
+export declare class CommonToken extends Token {
+    constructor(source: [ TokenSource, InputStream ], type: number, channel: number, start: number, stop: number);
+    clone(): CommonToken;
+    cloneWithType(type: number): CommonToken;
+    toString(): string;
+}

package/node_modules/antlr4/src/antlr4/CommonTokenStream.d.ts

@@ -0,0 +1,12 @@
+import {Lexer} from "./Lexer.js";
+import {BufferedTokenStream} from "./BufferedTokenStream.js";
+import {Token} from "./Token.js";
+
+export declare class CommonTokenStream extends BufferedTokenStream {
+    // properties
+    tokens: Token[];
+    // methods
+    constructor(lexer: Lexer);
+    constructor(lexer: Lexer, channel: number);
+    fill(): void;
+}

package/node_modules/antlr4/src/antlr4/FileStream.d.ts

@@ -0,0 +1,9 @@
+import {CharStream} from "./CharStream.js";
+
+export declare class FileStream extends CharStream {
+
+    fileName: string;
+
+    constructor(fileName: string, encoding?: string, decodeToUnicodeCodePoints?: boolean);
+
+}

package/node_modules/antlr4/src/antlr4/InputStream.d.ts

@@ -0,0 +1,4 @@
+export declare class InputStream {
+    constructor(data: string);
+    constructor(data: string, decodeToUnicodeCodePoints: boolean);
+}

package/node_modules/antlr4/src/antlr4/Lexer.d.ts

@@ -0,0 +1,34 @@
+import {Recognizer} from "./Recognizer.js";
+import {LexerATNSimulator} from "./atn/index.js";
+import {CharStream} from "./CharStream.js";
+import {Token} from "./Token.js";
+
+export declare class Lexer extends Recognizer<number> {
+
+    static DEFAULT_MODE: number;
+
+    _input: CharStream;
+    _interp: LexerATNSimulator;
+    text: string;
+    line: number;
+    column: number;
+    _tokenStartCharIndex: number;
+    _tokenStartLine: number;
+    _tokenStartColumn: number;
+    _type: number;
+
+    constructor(input: CharStream);
+    reset(): void;
+    nextToken(): Token;
+    skip(): void;
+    more(): void;
+    setMode(m: number): void;
+    getMode(): number;
+    getModeStack(): number[];
+    pushMode(m: number): void;
+    popMode(): number;
+    emitToken(token: Token): void;
+    emit(): Token;
+    emitEOF(): Token;
+    getAllTokens(): Token[];
+}

package/node_modules/antlr4/src/antlr4/Parser.d.ts

@@ -0,0 +1,50 @@
+import {TokenStream} from "./TokenStream.js";
+import {Recognizer} from "./Recognizer.js";
+import {ErrorStrategy, RecognitionException} from "./error/index.js";
+import {IntervalSet} from "./misc/index.js";
+import {ParserATNSimulator} from "./atn/index.js";
+import {Token} from "./Token.js";
+import {ParserRuleContext} from "./context/index.js";
+import {Printer} from "./utils/index.js";
+import {ParseTreeListener} from "./tree/index.js";
+
+export declare class Parser extends Recognizer<Token> {
+
+    static EOF: number;
+
+    _input: TokenStream;
+    _ctx: ParserRuleContext;
+    _interp: ParserATNSimulator;
+    _errHandler: ErrorStrategy;
+    _parseListeners?: any[];
+    matchedEOF: boolean;
+    buildParseTrees: boolean;
+    printer?: Printer;
+    syntaxErrorsCount: number;
+
+    constructor(input: TokenStream);
+    match(ttype: number): Token;
+    matchWildcard(): Token;
+    getParseListeners(): ParseTreeListener[];
+    addParseListener(listener: ParseTreeListener): void;
+    removeParseListener(listener: ParseTreeListener): void;
+    removeParseListeners(): void;
+    consume(): Token;
+    enterRule(localctx: ParserRuleContext, state: number, ruleIndex: number): void;
+    exitRule() : void;
+    triggerExitRuleEvent() : void;
+    enterOuterAlt(localctx: ParserRuleContext, altNum: number): void;
+    enterRecursionRule(localctx: ParserRuleContext, state: number, ruleIndex: number, precedence: number): void;
+    pushNewRecursionContext(localctx: ParserRuleContext, state: number, ruleIndex: number): void;
+    unrollRecursionContexts(parentCtx: ParserRuleContext): void;
+    precpred(localctx: ParserRuleContext, precedence: number): boolean;
+    getRuleInvocationStack(): string[];
+    dumpDFA(): void;
+    getExpectedTokens(): IntervalSet;
+    getTokenStream(): TokenStream;
+    reset(): void;
+    setTokenStream(input: TokenStream): void;
+    notifyErrorListeners(msg: string, offendingToken: Token, err: RecognitionException | undefined): void;
+    getCurrentToken(): Token;
+    
+}

package/node_modules/antlr4/src/antlr4/Recognizer.d.ts

@@ -0,0 +1,12 @@
+import {ErrorListener} from "./error/index.js";
+
+export declare class Recognizer<TSymbol> {
+
+    state: number;
+
+    removeErrorListeners(): void;
+    addErrorListener(listener: ErrorListener<TSymbol>): void;
+    getErrorListener(): ErrorListener<TSymbol>;
+    getLiteralNames(): string[];
+    getSymbolicNames(): string[];
+}

package/node_modules/antlr4/src/antlr4/Token.d.ts

@@ -0,0 +1,24 @@
+import { TokenSource } from "./TokenSource.js";
+import { CharStream } from "./CharStream.js";
+
+export declare class Token {
+
+    static INVALID_TYPE: number;
+    static EOF: number;
+    static DEFAULT_CHANNEL: number;
+    static HIDDEN_CHANNEL: number;
+
+    tokenIndex: number;
+    line: number;
+    column: number;
+    channel: number;
+    text: string;
+    type: number;
+    start : number;
+    stop: number;
+
+    clone(): Token;
+    cloneWithType(type: number): Token;
+    getTokenSource(): TokenSource;
+    getInputStream(): CharStream;
+}

package/node_modules/antlr4/src/antlr4/TokenSource.d.ts

@@ -0,0 +1,3 @@
+export declare class TokenSource {
+
+}

package/node_modules/antlr4/src/antlr4/TokenStream.d.ts

@@ -0,0 +1,16 @@
+import {Interval} from "./misc/index.js";
+import {Token} from "./Token.js";
+
+export declare class TokenStream {
+
+    index: number;
+    size: number;
+
+    LA(i: number): number;
+    LT(k: number): Token;
+    getText(interval?: Interval): string;
+    // channelIndex can be retrieved using: lexer.channelNames().findIndex(channelName)
+    getHiddenTokensToLeft(tokenIndex: number, channelIndex?: number): Token[];
+    getHiddenTokensToRight(tokenIndex: number, channelIndex?: number): Token[];
+    get(idx: number): Token;
+}

package/node_modules/antlr4/src/antlr4/TokenStreamRewriter.d.ts

@@ -0,0 +1,38 @@
+import { CommonTokenStream } from "./CommonTokenStream.js";
+import { Token } from "./Token.js";
+import { Interval } from "./misc/Interval.js";
+
+type Rewrites = Array<RewriteOperation | undefined>;
+type Text = unknown;
+
+export declare class TokenStreamRewriter {
+    static DEFAULT_PROGRAM_NAME: string;
+    constructor(tokens: CommonTokenStream);
+    getTokenStream(): CommonTokenStream;
+    insertAfter(token: Token, text: Text, programName?: string): void;
+    insertAfter(index: number, text: Text, programName?: string): void;
+    insertBefore(token: Token, text: Text, programName?: string): void;
+    insertBefore(index: number, text: Text, programName?: string): void;
+    replaceSingle(token: Token, text: Text, programName?: string): void;
+    replaceSingle(index: number, text: Text, programName?: string): void;
+    replace(from: Token | number, to: Token | number, text: Text, programName?: string): void;
+    delete(from: number | Token, to: number | Token, programName?: string): void;
+    getProgram(name: string): Rewrites;
+    initializeProgram(name: string): Rewrites;
+    getText(): string;
+    getText(program: string): string;
+    getText(interval: Interval, programName?: string): string;
+    reduceToSingleOperationPerIndex(rewrites: Rewrites): Map<number, RewriteOperation>;
+    catOpText(a: Text, b: Text): string;
+    getKindOfOps(rewrites: Rewrites, kind: any, before: number): RewriteOperation[];
+}
+
+
+declare class RewriteOperation {
+    constructor(tokens: CommonTokenStream, index: number, instructionIndex: number, text: Text);
+    tokens: CommonTokenStream;
+    instructionIndex: number;
+    index: number;
+    text: Text;
+    toString(): string;
+}

package/node_modules/antlr4/src/antlr4/atn/ATN.d.ts

@@ -0,0 +1,17 @@
+import {IntervalSet} from "../misc/index.js";
+import {RuleContext} from "../context/index.js";
+import {ATNState, DecisionState, RuleStartState, RuleStopState} from "../state/index.js";
+
+export declare class ATN {
+
+    static INVALID_ALT_NUMBER: number;
+
+    states: ATNState[];
+    decisionToState: DecisionState[];
+    ruleToStartState: RuleStartState[];
+    ruleToStopState: RuleStopState[];
+
+    getExpectedTokens(stateNumber: number, ctx: RuleContext ): IntervalSet;
+    nextTokens(atnState: ATNState, ctx?: RuleContext): IntervalSet;
+
+}

package/node_modules/antlr4/src/antlr4/atn/ATNConfig.d.ts

@@ -0,0 +1,5 @@
+import { ATNState } from "../state/index.js";
+
+export declare class ATNConfig {
+    state: ATNState;
+}

package/node_modules/antlr4/src/antlr4/atn/ATNConfigSet.d.ts

@@ -0,0 +1,5 @@
+import {ATNConfig} from "./ATNConfig.js";
+
+export declare class ATNConfigSet {
+    configs: ATNConfig[];
+}

package/node_modules/antlr4/src/antlr4/atn/ATNDeserializationOptions.d.ts

@@ -0,0 +1,6 @@
+export declare class ATNDeserializationOptions {
+    readOnly?: boolean;
+    verifyATN?: boolean;
+    generateRuleBypassTransitions?: boolean;
+
+}

package/node_modules/antlr4/src/antlr4/atn/ATNDeserializer.d.ts

@@ -0,0 +1,7 @@
+import {ATNDeserializationOptions} from "./ATNDeserializationOptions.js";
+import {ATN} from "./ATN.js";
+
+export declare class ATNDeserializer {
+    constructor(options?: ATNDeserializationOptions);
+    deserialize(data:  number[]) : ATN;
+}

package/node_modules/antlr4/src/antlr4/atn/ATNSimulator.d.ts

@@ -0,0 +1,3 @@
+export declare class ATNSimulator {
+
+}

package/node_modules/antlr4/src/antlr4/atn/LexerATNSimulator.d.ts

@@ -0,0 +1,15 @@
+import {Recognizer} from "../Recognizer.js";
+import {ATNSimulator} from "./ATNSimulator.js";
+import {ATN} from "./ATN.js";
+import {PredictionContextCache} from "./PredictionContextCache.js";
+import {DFA} from "../dfa/index.js";
+import {CharStream} from "../CharStream.js";
+
+export declare class LexerATNSimulator implements ATNSimulator {
+
+    decisionToDFA: DFA[];
+
+    constructor(recog: Recognizer<number>, atn: ATN, decisionToDFA: DFA[], sharedContextCache: PredictionContextCache);
+    consume(input: CharStream) : void;
+
+}

package/node_modules/antlr4/src/antlr4/atn/ParserATNSimulator.d.ts

@@ -0,0 +1,21 @@
+import {ATNSimulator} from "./ATNSimulator.js";
+import {ParserRuleContext} from "../context/index.js";
+import {TokenStream} from "../TokenStream.js";
+import {Recognizer} from "../Recognizer.js";
+import {ATN} from "./ATN.js";
+import {PredictionContextCache} from "./PredictionContextCache.js";
+import {DFA} from "../dfa/index.js";
+import {PredictionMode} from "./PredictionMode.js";
+import {Token} from "../Token.js";
+
+export declare class ParserATNSimulator extends ATNSimulator {
+
+    predictionMode: PredictionMode;
+    decisionToDFA: DFA[];
+    atn: ATN;
+    debug?: boolean;
+    trace_atn_sim?: boolean;
+
+    constructor(recog: Recognizer<Token>, atn: ATN, decisionToDFA: DFA[], sharedContextCache: PredictionContextCache);
+    adaptivePredict(input: TokenStream, decision: number, outerContext: ParserRuleContext) : number;
+}

package/node_modules/antlr4/src/antlr4/atn/PredictionContextCache.d.ts

@@ -0,0 +1,3 @@
+export declare class PredictionContextCache {
+
+}

package/node_modules/antlr4/src/antlr4/atn/PredictionMode.d.ts

@@ -0,0 +1,5 @@
+export declare class PredictionMode {
+    static SLL: number;
+    static LL: number;
+    static LL_EXACT_AMBIG_DETECTION: number;
+}

package/node_modules/antlr4/src/antlr4/atn/index.d.ts

@@ -0,0 +1,9 @@
+export * from './ATN.js';
+export * from './ATNConfig.js';
+export * from './ATNConfigSet.js';
+export * from './ATNDeserializer.js';
+export * from './LexerATNSimulator.js';
+export * from './ParserATNSimulator.js';
+export * from './PredictionMode.js';
+export * from './PredictionContextCache.js';
+

package/node_modules/antlr4/src/antlr4/context/ParserRuleContext.d.ts

@@ -0,0 +1,23 @@
+import {RuleContext} from "./RuleContext.js";
+import {ParseTree, TerminalNode} from "../tree/index.js";
+import {RecognitionException} from "../error/index.js";
+import {Token} from "../Token.js";
+import {Parser} from "../Parser.js";
+
+export declare class ParserRuleContext extends RuleContext {
+    start: Token;
+    stop: Token | undefined;
+    children: ParseTree[] | null;
+    parentCtx: ParserRuleContext | undefined;
+    exception?: RecognitionException;
+    parser?: Parser;
+
+    constructor(parent?: ParserRuleContext, invokingStateNumber?: number);
+    copyFrom(ctx: ParserRuleContext): void;
+    getChildCount() : number;
+    getChild(i: number) : ParseTree;
+    getToken(ttype: number, i: number): TerminalNode;
+    getTokens(ttype: number): TerminalNode[];
+    getTypedRuleContext<T extends ParserRuleContext, P extends Parser>(ctxType: { new (parser?: P, parent?: ParserRuleContext, invokingState?: number, ...args: any[]) : T}, i: number): T;
+    getTypedRuleContexts<T extends ParserRuleContext, P extends Parser>(ctxType: { new (parser?: P, parent?: ParserRuleContext, invokingState?: number, ...args: any[]) : T}): T[];
+}

package/node_modules/antlr4/src/antlr4/context/RuleContext.d.ts

@@ -0,0 +1,10 @@
+import {RuleNode} from "../tree/index.js";
+import {Parser} from "../Parser.js";
+
+export declare class RuleContext extends RuleNode {
+    parentCtx: RuleContext | undefined;
+    invokingState: number;
+
+    get ruleContext() : RuleContext;
+    toStringTree(ruleNames: string[] | null, recog: Parser) : string;
+}

package/node_modules/antlr4/src/antlr4/context/index.d.ts

@@ -0,0 +1,3 @@
+export * from './RuleContext.js';
+export * from './ParserRuleContext.js';
+

package/node_modules/antlr4/src/antlr4/dfa/DFA.d.ts

@@ -0,0 +1,5 @@
+export declare class DFA {
+    constructor(ds: any, index: number);
+    toLexerString(): string;
+}
+

package/node_modules/antlr4/src/antlr4/dfa/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DFA.js';
+

package/node_modules/antlr4/src/antlr4/error/BailErrorStrategy.d.ts

@@ -0,0 +1,7 @@
+import {DefaultErrorStrategy} from "./DefaultErrorStrategy.js";
+
+export declare class BailErrorStrategy extends DefaultErrorStrategy {
+
+    constructor();
+
+}

package/node_modules/antlr4/src/antlr4/error/DefaultErrorStrategy.d.ts

@@ -0,0 +1,24 @@
+import {ErrorStrategy} from "./ErrorStrategy.js";
+import {RecognitionException} from "./RecognitionException.js";
+import {Parser} from "../Parser.js";
+import {Token} from "../Token.js";
+
+export declare class DefaultErrorStrategy implements ErrorStrategy {
+    recover(recognizer: Parser, e: RecognitionException): void;
+
+    recoverInline(recognizer: Parser): Token;
+
+    reportError(recognizer: Parser, e: RecognitionException): void;
+
+    reportMatch(recognizer: Parser): void;
+
+    reset(recognizer: Parser): void;
+
+    sync(recognizer: Parser): void;
+
+    inErrorRecoveryMode(recognizer: Parser): boolean;
+
+    beginErrorCondition(recognizer: Parser): void;
+
+    getMissingSymbol(recognizer: Parser): Token;
+}

package/node_modules/antlr4/src/antlr4/error/DiagnosticErrorListener.d.ts

@@ -0,0 +1,9 @@
+import {ErrorListener} from "./ErrorListener.js";
+import {Recognizer} from "../Recognizer.js";
+import {RecognitionException} from "./RecognitionException.js";
+
+export declare class DiagnosticErrorListener<TSymbol> implements ErrorListener<TSymbol> {
+
+    syntaxError(recognizer: Recognizer<TSymbol>, offendingSymbol: TSymbol, line: number, column: number, msg: string, e: RecognitionException | undefined): void;
+
+}

package/node_modules/antlr4/src/antlr4/error/ErrorListener.d.ts

@@ -0,0 +1,6 @@
+import {Recognizer} from "../Recognizer.js";
+import {RecognitionException} from "./RecognitionException.js";
+
+export declare class ErrorListener<TSymbol> {
+    syntaxError(recognizer: Recognizer<TSymbol>, offendingSymbol: TSymbol, line: number, column: number, msg: string, e: RecognitionException | undefined): void;
+}

package/node_modules/antlr4/src/antlr4/error/ErrorStrategy.d.ts

@@ -0,0 +1,12 @@
+import {RecognitionException} from "./RecognitionException.js";
+import {Parser} from "../Parser.js";
+import {Token} from "../Token.js";
+
+export declare class ErrorStrategy {
+    reset(recognizer: Parser): void;
+    sync(recognizer: Parser): void;
+    recover(recognizer: Parser, e: RecognitionException): void;
+    recoverInline(recognizer: Parser): Token;
+    reportMatch(recognizer: Parser): void;
+    reportError(recognizer: Parser, e: RecognitionException): void;
+}

package/node_modules/antlr4/src/antlr4/error/FailedPredicateException.d.ts

@@ -0,0 +1,7 @@
+import {RecognitionException} from "./RecognitionException.js";
+import {Parser} from "../Parser.js";
+
+export declare class FailedPredicateException extends RecognitionException {
+
+    constructor(recognizer: Parser, predicate: string | undefined, message: string | undefined);
+}

package/node_modules/antlr4/src/antlr4/error/InputMismatchException.d.ts

@@ -0,0 +1,6 @@
+import {RecognitionException} from "./RecognitionException.js";
+import {Parser} from "../Parser.js";
+
+export declare class InputMismatchException extends RecognitionException {
+    constructor(recognizer: Parser);
+}

package/node_modules/antlr4/src/antlr4/error/NoViableAltException.d.ts

@@ -0,0 +1,13 @@
+import {ATNConfigSet} from "../atn/index.js";
+import {Recognizer} from "../Recognizer.js";
+import { Token } from "../Token.js";
+import {RecognitionException} from "./RecognitionException.js";
+
+export declare class NoViableAltException extends RecognitionException {
+
+    deadEndConfigs: ATNConfigSet;
+
+    constructor(recognizer: Recognizer<any>);
+
+    startToken: Token;
+}

package/node_modules/antlr4/src/antlr4/error/RecognitionException.d.ts

@@ -0,0 +1,19 @@
+import {ParserRuleContext, RuleContext} from "../context/index.js";
+import {TokenStream} from "../TokenStream.js";
+import {Recognizer} from "../Recognizer.js";
+import {CharStream} from "../CharStream.js";
+import {Token} from "../Token.js";
+
+export interface ExceptionParams {
+    message: string;
+    recognizer?: Recognizer<never>;
+    input?: CharStream | TokenStream;
+    ctx?: ParserRuleContext;
+
+}
+
+export declare class RecognitionException extends Error {
+    ctx: RuleContext;
+    offendingToken: Token | null;
+    constructor(params: ExceptionParams);
+}

package/node_modules/antlr4/src/antlr4/error/index.d.ts

@@ -0,0 +1,9 @@
+export * from './RecognitionException.js';
+export * from './NoViableAltException.js';
+export * from './FailedPredicateException.js';
+export * from './InputMismatchException.js';
+export * from './ErrorStrategy.js';
+export * from './BailErrorStrategy.js';
+export * from './DefaultErrorStrategy.js';
+export * from './ErrorListener.js';
+export * from './DiagnosticErrorListener.js';