@irrelon/battlescript 3.2.1 → 3.2.2

package/bin/index.js

@@ -3,6 +3,7 @@ import { writeFile, readFile } from 'fs/promises';
 import { join, dirname, basename, extname } from 'path';
 import require$$0 from 'assert';
 import require$$0$1 from 'util';
+import { CharStreams as CharStreams$1, CommonTokenStream as CommonTokenStream$1 } from 'antlr4ts';
 import { readFileSync } from 'fs';
 import 'node:fs';
 
@@ -30393,7 +30394,7 @@ function miniAstFromBinaryBuffer(data) {
     };
 }
 
-var version = "3.2.1";
+var version = "3.2.2";
 var binaryVersion = 7;
 
 function miniAstToBinary$1(json, options = {}) {
@@ -30554,1351 +30555,6 @@ var EnumOpCode;
     EnumOpCode[EnumOpCode["OPCODE_MOD"] = 22] = "OPCODE_MOD";
 })(EnumOpCode || (EnumOpCode = {}));
 
-var antlr4ts = {};
-
-var ANTLRErrorListener = {};
-
-var hasRequiredANTLRErrorListener;
-
-function requireANTLRErrorListener () {
-	if (hasRequiredANTLRErrorListener) return ANTLRErrorListener;
-	hasRequiredANTLRErrorListener = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(ANTLRErrorListener, "__esModule", { value: true });
-	
-	return ANTLRErrorListener;
-}
-
-var ANTLRErrorStrategy = {};
-
-var hasRequiredANTLRErrorStrategy;
-
-function requireANTLRErrorStrategy () {
-	if (hasRequiredANTLRErrorStrategy) return ANTLRErrorStrategy;
-	hasRequiredANTLRErrorStrategy = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(ANTLRErrorStrategy, "__esModule", { value: true });
-	
-	return ANTLRErrorStrategy;
-}
-
-var ANTLRInputStream = {};
-
-var hasRequiredANTLRInputStream;
-
-function requireANTLRInputStream () {
-	if (hasRequiredANTLRInputStream) return ANTLRInputStream;
-	hasRequiredANTLRInputStream = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	// ConvertTo-TS run at 2016-10-04T11:26:49.0828748-07:00
-	var __decorate = (ANTLRInputStream && ANTLRInputStream.__decorate) || function (decorators, target, key, desc) {
-	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	    return c > 3 && r && Object.defineProperty(target, key, r), r;
-	};
-	Object.defineProperty(ANTLRInputStream, "__esModule", { value: true });
-	ANTLRInputStream.ANTLRInputStream = void 0;
-	const assert = require$$0;
-	const Decorators_1 = requireDecorators();
-	const IntStream_1 = requireIntStream();
-	/**
-	 * Vacuum all input from a {@link Reader}/{@link InputStream} and then treat it
-	 * like a `char[]` buffer. Can also pass in a {@link String} or
-	 * `char[]` to use.
-	 *
-	 * If you need encoding, pass in stream/reader with correct encoding.
-	 *
-	 * @deprecated as of 4.7, please use `CharStreams` interface.
-	 */
-	let ANTLRInputStream$1 = class ANTLRInputStream {
-	    /** Copy data in string to a local char array */
-	    constructor(input) {
-	        /** 0..n-1 index into string of next char */
-	        this.p = 0;
-	        this.data = input;
-	        this.n = input.length;
-	    }
-	    /** Reset the stream so that it's in the same state it was
-	     *  when the object was created *except* the data array is not
-	     *  touched.
-	     */
-	    reset() {
-	        this.p = 0;
-	    }
-	    consume() {
-	        if (this.p >= this.n) {
-	            assert(this.LA(1) === IntStream_1.IntStream.EOF);
-	            throw new Error("cannot consume EOF");
-	        }
-	        //System.out.println("prev p="+p+", c="+(char)data[p]);
-	        if (this.p < this.n) {
-	            this.p++;
-	            //System.out.println("p moves to "+p+" (c='"+(char)data[p]+"')");
-	        }
-	    }
-	    LA(i) {
-	        if (i === 0) {
-	            return 0; // undefined
-	        }
-	        if (i < 0) {
-	            i++; // e.g., translate LA(-1) to use offset i=0; then data[p+0-1]
-	            if ((this.p + i - 1) < 0) {
-	                return IntStream_1.IntStream.EOF; // invalid; no char before first char
-	            }
-	        }
-	        if ((this.p + i - 1) >= this.n) {
-	            //System.out.println("char LA("+i+")=EOF; p="+p);
-	            return IntStream_1.IntStream.EOF;
-	        }
-	        //System.out.println("char LA("+i+")="+(char)data[p+i-1]+"; p="+p);
-	        //System.out.println("LA("+i+"); p="+p+" n="+n+" data.length="+data.length);
-	        return this.data.charCodeAt(this.p + i - 1);
-	    }
-	    LT(i) {
-	        return this.LA(i);
-	    }
-	    /** Return the current input symbol index 0..n where n indicates the
-	     *  last symbol has been read.  The index is the index of char to
-	     *  be returned from LA(1).
-	     */
-	    get index() {
-	        return this.p;
-	    }
-	    get size() {
-	        return this.n;
-	    }
-	    /** mark/release do nothing; we have entire buffer */
-	    mark() {
-	        return -1;
-	    }
-	    release(marker) {
-	        // No default implementation since this stream buffers the entire input
-	    }
-	    /** consume() ahead until p==index; can't just set p=index as we must
-	     *  update line and charPositionInLine. If we seek backwards, just set p
-	     */
-	    seek(index) {
-	        if (index <= this.p) {
-	            this.p = index; // just jump; don't update stream state (line, ...)
-	            return;
-	        }
-	        // seek forward, consume until p hits index or n (whichever comes first)
-	        index = Math.min(index, this.n);
-	        while (this.p < index) {
-	            this.consume();
-	        }
-	    }
-	    getText(interval) {
-	        let start = interval.a;
-	        let stop = interval.b;
-	        if (stop >= this.n) {
-	            stop = this.n - 1;
-	        }
-	        let count = stop - start + 1;
-	        if (start >= this.n) {
-	            return "";
-	        }
-	        // System.err.println("data: "+Arrays.toString(data)+", n="+n+
-	        // 				   ", start="+start+
-	        // 				   ", stop="+stop);
-	        return this.data.substr(start, count);
-	    }
-	    get sourceName() {
-	        if (!this.name) {
-	            return IntStream_1.IntStream.UNKNOWN_SOURCE_NAME;
-	        }
-	        return this.name;
-	    }
-	    toString() { return this.data; }
-	};
-	__decorate([
-	    Decorators_1.Override
-	], ANTLRInputStream$1.prototype, "consume", null);
-	__decorate([
-	    Decorators_1.Override
-	], ANTLRInputStream$1.prototype, "LA", null);
-	__decorate([
-	    Decorators_1.Override
-	], ANTLRInputStream$1.prototype, "index", null);
-	__decorate([
-	    Decorators_1.Override
-	], ANTLRInputStream$1.prototype, "size", null);
-	__decorate([
-	    Decorators_1.Override
-	], ANTLRInputStream$1.prototype, "mark", null);
-	__decorate([
-	    Decorators_1.Override
-	], ANTLRInputStream$1.prototype, "release", null);
-	__decorate([
-	    Decorators_1.Override
-	], ANTLRInputStream$1.prototype, "seek", null);
-	__decorate([
-	    Decorators_1.Override
-	], ANTLRInputStream$1.prototype, "getText", null);
-	__decorate([
-	    Decorators_1.Override
-	], ANTLRInputStream$1.prototype, "sourceName", null);
-	__decorate([
-	    Decorators_1.Override
-	], ANTLRInputStream$1.prototype, "toString", null);
-	ANTLRInputStream.ANTLRInputStream = ANTLRInputStream$1;
-	
-	return ANTLRInputStream;
-}
-
-var CharStream = {};
-
-var hasRequiredCharStream;
-
-function requireCharStream () {
-	if (hasRequiredCharStream) return CharStream;
-	hasRequiredCharStream = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(CharStream, "__esModule", { value: true });
-	
-	return CharStream;
-}
-
-var Dependents = {};
-
-var hasRequiredDependents;
-
-function requireDependents () {
-	if (hasRequiredDependents) return Dependents;
-	hasRequiredDependents = 1;
-	(function (exports) {
-		/*!
-		 * Copyright 2016 The ANTLR Project. All rights reserved.
-		 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-		 */
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.Dependents = void 0;
-		(function (Dependents) {
-		    /**
-		     * The element is dependent upon the specified rule.
-		     */
-		    Dependents[Dependents["SELF"] = 0] = "SELF";
-		    /**
-		     * The element is dependent upon the set of the specified rule's parents
-		     * (rules which directly reference it).
-		     */
-		    Dependents[Dependents["PARENTS"] = 1] = "PARENTS";
-		    /**
-		     * The element is dependent upon the set of the specified rule's children
-		     * (rules which it directly references).
-		     */
-		    Dependents[Dependents["CHILDREN"] = 2] = "CHILDREN";
-		    /**
-		     * The element is dependent upon the set of the specified rule's ancestors
-		     * (the transitive closure of `PARENTS` rules).
-		     */
-		    Dependents[Dependents["ANCESTORS"] = 3] = "ANCESTORS";
-		    /**
-		     * The element is dependent upon the set of the specified rule's descendants
-		     * (the transitive closure of `CHILDREN` rules).
-		     */
-		    Dependents[Dependents["DESCENDANTS"] = 4] = "DESCENDANTS";
-		    /**
-		     * The element is dependent upon the set of the specified rule's siblings
-		     * (the union of `CHILDREN` of its `PARENTS`).
-		     */
-		    Dependents[Dependents["SIBLINGS"] = 5] = "SIBLINGS";
-		    /**
-		     * The element is dependent upon the set of the specified rule's preceeding
-		     * siblings (the union of `CHILDREN` of its `PARENTS` which
-		     * appear before a reference to the rule).
-		     */
-		    Dependents[Dependents["PRECEEDING_SIBLINGS"] = 6] = "PRECEEDING_SIBLINGS";
-		    /**
-		     * The element is dependent upon the set of the specified rule's following
-		     * siblings (the union of `CHILDREN` of its `PARENTS` which
-		     * appear after a reference to the rule).
-		     */
-		    Dependents[Dependents["FOLLOWING_SIBLINGS"] = 7] = "FOLLOWING_SIBLINGS";
-		    /**
-		     * The element is dependent upon the set of the specified rule's preceeding
-		     * elements (rules which might end before the start of the specified rule
-		     * while parsing). This is calculated by taking the
-		     * `PRECEEDING_SIBLINGS` of the rule and each of its
-		     * `ANCESTORS`, along with the `DESCENDANTS` of those
-		     * elements.
-		     */
-		    Dependents[Dependents["PRECEEDING"] = 8] = "PRECEEDING";
-		    /**
-		     * The element is dependent upon the set of the specified rule's following
-		     * elements (rules which might start after the end of the specified rule
-		     * while parsing). This is calculated by taking the
-		     * `FOLLOWING_SIBLINGS` of the rule and each of its
-		     * `ANCESTORS`, along with the `DESCENDANTS` of those
-		     * elements.
-		     */
-		    Dependents[Dependents["FOLLOWING"] = 9] = "FOLLOWING";
-		})(exports.Dependents || (exports.Dependents = {}));
-		
-	} (Dependents));
-	return Dependents;
-}
-
-var DiagnosticErrorListener = {};
-
-var hasRequiredDiagnosticErrorListener;
-
-function requireDiagnosticErrorListener () {
-	if (hasRequiredDiagnosticErrorListener) return DiagnosticErrorListener;
-	hasRequiredDiagnosticErrorListener = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	var __decorate = (DiagnosticErrorListener && DiagnosticErrorListener.__decorate) || function (decorators, target, key, desc) {
-	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	    return c > 3 && r && Object.defineProperty(target, key, r), r;
-	};
-	var __param = (DiagnosticErrorListener && DiagnosticErrorListener.__param) || function (paramIndex, decorator) {
-	    return function (target, key) { decorator(target, key, paramIndex); }
-	};
-	Object.defineProperty(DiagnosticErrorListener, "__esModule", { value: true });
-	DiagnosticErrorListener.DiagnosticErrorListener = void 0;
-	const BitSet_1 = requireBitSet();
-	const Decorators_1 = requireDecorators();
-	const Interval_1 = requireInterval();
-	/**
-	 * This implementation of {@link ANTLRErrorListener} can be used to identify
-	 * certain potential correctness and performance problems in grammars. "Reports"
-	 * are made by calling {@link Parser#notifyErrorListeners} with the appropriate
-	 * message.
-	 *
-	 * * **Ambiguities**: These are cases where more than one path through the
-	 *   grammar can match the input.
-	 * * **Weak context sensitivity**: These are cases where full-context
-	 *   prediction resolved an SLL conflict to a unique alternative which equaled the
-	 *   minimum alternative of the SLL conflict.
-	 * * **Strong (forced) context sensitivity**: These are cases where the
-	 *   full-context prediction resolved an SLL conflict to a unique alternative,
-	 *   *and* the minimum alternative of the SLL conflict was found to not be
-	 *   a truly viable alternative. Two-stage parsing cannot be used for inputs where
-	 *   this situation occurs.
-	 *
-	 * @author Sam Harwell
-	 */
-	let DiagnosticErrorListener$1 = class DiagnosticErrorListener {
-	    /**
-	     * Initializes a new instance of {@link DiagnosticErrorListener}, specifying
-	     * whether all ambiguities or only exact ambiguities are reported.
-	     *
-	     * @param exactOnly `true` to report only exact ambiguities, otherwise
-	     * `false` to report all ambiguities.  Defaults to true.
-	     */
-	    constructor(exactOnly = true) {
-	        this.exactOnly = exactOnly;
-	        this.exactOnly = exactOnly;
-	    }
-	    syntaxError(
-	    /*@NotNull*/
-	    recognizer, offendingSymbol, line, charPositionInLine, 
-	    /*@NotNull*/
-	    msg, e) {
-	        // intentionally empty
-	    }
-	    reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
-	        if (this.exactOnly && !exact) {
-	            return;
-	        }
-	        let decision = this.getDecisionDescription(recognizer, dfa);
-	        let conflictingAlts = this.getConflictingAlts(ambigAlts, configs);
-	        let text = recognizer.inputStream.getText(Interval_1.Interval.of(startIndex, stopIndex));
-	        let message = `reportAmbiguity d=${decision}: ambigAlts=${conflictingAlts}, input='${text}'`;
-	        recognizer.notifyErrorListeners(message);
-	    }
-	    reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, conflictState) {
-	        let decision = this.getDecisionDescription(recognizer, dfa);
-	        let text = recognizer.inputStream.getText(Interval_1.Interval.of(startIndex, stopIndex));
-	        let message = `reportAttemptingFullContext d=${decision}, input='${text}'`;
-	        recognizer.notifyErrorListeners(message);
-	    }
-	    reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, acceptState) {
-	        let decision = this.getDecisionDescription(recognizer, dfa);
-	        let text = recognizer.inputStream.getText(Interval_1.Interval.of(startIndex, stopIndex));
-	        let message = `reportContextSensitivity d=${decision}, input='${text}'`;
-	        recognizer.notifyErrorListeners(message);
-	    }
-	    getDecisionDescription(recognizer, dfa) {
-	        let decision = dfa.decision;
-	        let ruleIndex = dfa.atnStartState.ruleIndex;
-	        let ruleNames = recognizer.ruleNames;
-	        if (ruleIndex < 0 || ruleIndex >= ruleNames.length) {
-	            return decision.toString();
-	        }
-	        let ruleName = ruleNames[ruleIndex];
-	        if (!ruleName) {
-	            return decision.toString();
-	        }
-	        return `${decision} (${ruleName})`;
-	    }
-	    /**
-	     * Computes the set of conflicting or ambiguous alternatives from a
-	     * configuration set, if that information was not already provided by the
-	     * parser.
-	     *
-	     * @param reportedAlts The set of conflicting or ambiguous alternatives, as
-	     * reported by the parser.
-	     * @param configs The conflicting or ambiguous configuration set.
-	     * @returns Returns `reportedAlts` if it is not `undefined`, otherwise
-	     * returns the set of alternatives represented in `configs`.
-	     */
-	    getConflictingAlts(reportedAlts, configs) {
-	        if (reportedAlts != null) {
-	            return reportedAlts;
-	        }
-	        let result = new BitSet_1.BitSet();
-	        for (let config of configs) {
-	            result.set(config.alt);
-	        }
-	        return result;
-	    }
-	};
-	__decorate([
-	    Decorators_1.Override
-	], DiagnosticErrorListener$1.prototype, "syntaxError", null);
-	__decorate([
-	    Decorators_1.Override,
-	    __param(0, Decorators_1.NotNull),
-	    __param(1, Decorators_1.NotNull),
-	    __param(6, Decorators_1.NotNull)
-	], DiagnosticErrorListener$1.prototype, "reportAmbiguity", null);
-	__decorate([
-	    Decorators_1.Override,
-	    __param(0, Decorators_1.NotNull),
-	    __param(1, Decorators_1.NotNull),
-	    __param(5, Decorators_1.NotNull)
-	], DiagnosticErrorListener$1.prototype, "reportAttemptingFullContext", null);
-	__decorate([
-	    Decorators_1.Override,
-	    __param(0, Decorators_1.NotNull),
-	    __param(1, Decorators_1.NotNull),
-	    __param(5, Decorators_1.NotNull)
-	], DiagnosticErrorListener$1.prototype, "reportContextSensitivity", null);
-	__decorate([
-	    __param(0, Decorators_1.NotNull),
-	    __param(1, Decorators_1.NotNull)
-	], DiagnosticErrorListener$1.prototype, "getDecisionDescription", null);
-	__decorate([
-	    Decorators_1.NotNull,
-	    __param(1, Decorators_1.NotNull)
-	], DiagnosticErrorListener$1.prototype, "getConflictingAlts", null);
-	DiagnosticErrorListener.DiagnosticErrorListener = DiagnosticErrorListener$1;
-	
-	return DiagnosticErrorListener;
-}
-
-var LexerInterpreter = {};
-
-var hasRequiredLexerInterpreter;
-
-function requireLexerInterpreter () {
-	if (hasRequiredLexerInterpreter) return LexerInterpreter;
-	hasRequiredLexerInterpreter = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	var __decorate = (LexerInterpreter && LexerInterpreter.__decorate) || function (decorators, target, key, desc) {
-	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	    return c > 3 && r && Object.defineProperty(target, key, r), r;
-	};
-	var __param = (LexerInterpreter && LexerInterpreter.__param) || function (paramIndex, decorator) {
-	    return function (target, key) { decorator(target, key, paramIndex); }
-	};
-	Object.defineProperty(LexerInterpreter, "__esModule", { value: true });
-	LexerInterpreter.LexerInterpreter = void 0;
-	const Lexer_1 = requireLexer();
-	const LexerATNSimulator_1 = requireLexerATNSimulator();
-	const Decorators_1 = requireDecorators();
-	const Decorators_2 = requireDecorators();
-	let LexerInterpreter$1 = class LexerInterpreter extends Lexer_1.Lexer {
-	    constructor(grammarFileName, vocabulary, ruleNames, channelNames, modeNames, atn, input) {
-	        super(input);
-	        if (atn.grammarType !== 0 /* LEXER */) {
-	            throw new Error("IllegalArgumentException: The ATN must be a lexer ATN.");
-	        }
-	        this._grammarFileName = grammarFileName;
-	        this._atn = atn;
-	        this._ruleNames = ruleNames.slice(0);
-	        this._channelNames = channelNames.slice(0);
-	        this._modeNames = modeNames.slice(0);
-	        this._vocabulary = vocabulary;
-	        this._interp = new LexerATNSimulator_1.LexerATNSimulator(atn, this);
-	    }
-	    get atn() {
-	        return this._atn;
-	    }
-	    get grammarFileName() {
-	        return this._grammarFileName;
-	    }
-	    get ruleNames() {
-	        return this._ruleNames;
-	    }
-	    get channelNames() {
-	        return this._channelNames;
-	    }
-	    get modeNames() {
-	        return this._modeNames;
-	    }
-	    get vocabulary() {
-	        return this._vocabulary;
-	    }
-	};
-	__decorate([
-	    Decorators_1.NotNull
-	], LexerInterpreter$1.prototype, "_vocabulary", void 0);
-	__decorate([
-	    Decorators_2.Override
-	], LexerInterpreter$1.prototype, "atn", null);
-	__decorate([
-	    Decorators_2.Override
-	], LexerInterpreter$1.prototype, "grammarFileName", null);
-	__decorate([
-	    Decorators_2.Override
-	], LexerInterpreter$1.prototype, "ruleNames", null);
-	__decorate([
-	    Decorators_2.Override
-	], LexerInterpreter$1.prototype, "channelNames", null);
-	__decorate([
-	    Decorators_2.Override
-	], LexerInterpreter$1.prototype, "modeNames", null);
-	__decorate([
-	    Decorators_2.Override
-	], LexerInterpreter$1.prototype, "vocabulary", null);
-	LexerInterpreter$1 = __decorate([
-	    __param(1, Decorators_1.NotNull)
-	], LexerInterpreter$1);
-	LexerInterpreter.LexerInterpreter = LexerInterpreter$1;
-	
-	return LexerInterpreter;
-}
-
-var ParserErrorListener = {};
-
-var hasRequiredParserErrorListener;
-
-function requireParserErrorListener () {
-	if (hasRequiredParserErrorListener) return ParserErrorListener;
-	hasRequiredParserErrorListener = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(ParserErrorListener, "__esModule", { value: true });
-	
-	return ParserErrorListener;
-}
-
-var RuleContextWithAltNum = {};
-
-var hasRequiredRuleContextWithAltNum;
-
-function requireRuleContextWithAltNum () {
-	if (hasRequiredRuleContextWithAltNum) return RuleContextWithAltNum;
-	hasRequiredRuleContextWithAltNum = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	var __decorate = (RuleContextWithAltNum && RuleContextWithAltNum.__decorate) || function (decorators, target, key, desc) {
-	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	    return c > 3 && r && Object.defineProperty(target, key, r), r;
-	};
-	Object.defineProperty(RuleContextWithAltNum, "__esModule", { value: true });
-	RuleContextWithAltNum.RuleContextWithAltNum = void 0;
-	// ConvertTo-TS run at 2016-10-04T11:26:57.4741196-07:00
-	const ATN_1 = requireATN();
-	const Decorators_1 = requireDecorators();
-	const ParserRuleContext_1 = requireParserRuleContext();
-	/** A handy class for use with
-	 *
-	 *  options {contextSuperClass=org.antlr.v4.runtime.RuleContextWithAltNum;}
-	 *
-	 *  that provides a backing field / impl for the outer alternative number
-	 *  matched for an internal parse tree node.
-	 *
-	 *  I'm only putting into Java runtime as I'm certain I'm the only one that
-	 *  will really every use this.
-	 */
-	let RuleContextWithAltNum$1 = class RuleContextWithAltNum extends ParserRuleContext_1.ParserRuleContext {
-	    constructor(parent, invokingStateNumber) {
-	        if (invokingStateNumber !== undefined) {
-	            super(parent, invokingStateNumber);
-	        }
-	        else {
-	            super();
-	        }
-	        this._altNumber = ATN_1.ATN.INVALID_ALT_NUMBER;
-	    }
-	    get altNumber() {
-	        return this._altNumber;
-	    }
-	    // @Override
-	    set altNumber(altNum) {
-	        this._altNumber = altNum;
-	    }
-	};
-	__decorate([
-	    Decorators_1.Override
-	], RuleContextWithAltNum$1.prototype, "altNumber", null);
-	RuleContextWithAltNum.RuleContextWithAltNum = RuleContextWithAltNum$1;
-	
-	return RuleContextWithAltNum;
-}
-
-var RuleDependency = {};
-
-var hasRequiredRuleDependency;
-
-function requireRuleDependency () {
-	if (hasRequiredRuleDependency) return RuleDependency;
-	hasRequiredRuleDependency = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(RuleDependency, "__esModule", { value: true });
-	RuleDependency.RuleDependency = void 0;
-	/**
-	 * Declares a dependency upon a grammar rule, along with a set of zero or more dependent rules.
-	 *
-	 * Version numbers within a grammar should be assigned on a monotonically increasing basis to allow for accurate
-	 * tracking of dependent rules.
-	 *
-	 * @author Sam Harwell
-	 */
-	function RuleDependency$1(dependency) {
-	    return (target, propertyKey, propertyDescriptor) => {
-	        // intentionally empty
-	    };
-	}
-	RuleDependency.RuleDependency = RuleDependency$1;
-	
-	return RuleDependency;
-}
-
-var RuleVersion = {};
-
-var hasRequiredRuleVersion;
-
-function requireRuleVersion () {
-	if (hasRequiredRuleVersion) return RuleVersion;
-	hasRequiredRuleVersion = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(RuleVersion, "__esModule", { value: true });
-	RuleVersion.RuleVersion = void 0;
-	/**
-	 *
-	 * @author Sam Harwell
-	 */
-	function RuleVersion$1(version) {
-	    return (target, propertyKey, propertyDescriptor) => {
-	        // intentionally empty
-	    };
-	}
-	RuleVersion.RuleVersion = RuleVersion$1;
-	
-	return RuleVersion;
-}
-
-var TokenFactory = {};
-
-var hasRequiredTokenFactory;
-
-function requireTokenFactory () {
-	if (hasRequiredTokenFactory) return TokenFactory;
-	hasRequiredTokenFactory = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(TokenFactory, "__esModule", { value: true });
-	
-	return TokenFactory;
-}
-
-var TokenSource = {};
-
-var hasRequiredTokenSource;
-
-function requireTokenSource () {
-	if (hasRequiredTokenSource) return TokenSource;
-	hasRequiredTokenSource = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(TokenSource, "__esModule", { value: true });
-	
-	return TokenSource;
-}
-
-var TokenStream = {};
-
-var hasRequiredTokenStream;
-
-function requireTokenStream () {
-	if (hasRequiredTokenStream) return TokenStream;
-	hasRequiredTokenStream = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(TokenStream, "__esModule", { value: true });
-	
-	return TokenStream;
-}
-
-var TokenStreamRewriter = {};
-
-var hasRequiredTokenStreamRewriter;
-
-function requireTokenStreamRewriter () {
-	if (hasRequiredTokenStreamRewriter) return TokenStreamRewriter;
-	hasRequiredTokenStreamRewriter = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	var __decorate = (TokenStreamRewriter && TokenStreamRewriter.__decorate) || function (decorators, target, key, desc) {
-	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	    return c > 3 && r && Object.defineProperty(target, key, r), r;
-	};
-	Object.defineProperty(TokenStreamRewriter, "__esModule", { value: true });
-	TokenStreamRewriter.RewriteOperation = TokenStreamRewriter.TokenStreamRewriter = void 0;
-	// ConvertTo-TS run at 2016-10-04T11:26:58.1768850-07:00
-	const Interval_1 = requireInterval();
-	const Decorators_1 = requireDecorators();
-	const Token_1 = requireToken();
-	/**
-	 * Useful for rewriting out a buffered input token stream after doing some
-	 * augmentation or other manipulations on it.
-	 *
-	 * You can insert stuff, replace, and delete chunks. Note that the operations
-	 * are done lazily--only if you convert the buffer to a {@link String} with
-	 * {@link TokenStream#getText()}. This is very efficient because you are not
-	 * moving data around all the time. As the buffer of tokens is converted to
-	 * strings, the {@link #getText()} method(s) scan the input token stream and
-	 * check to see if there is an operation at the current index. If so, the
-	 * operation is done and then normal {@link String} rendering continues on the
-	 * buffer. This is like having multiple Turing machine instruction streams
-	 * (programs) operating on a single input tape. :)
-	 *
-	 * This rewriter makes no modifications to the token stream. It does not ask the
-	 * stream to fill itself up nor does it advance the input cursor. The token
-	 * stream `TokenStream.index` will return the same value before and
-	 * after any {@link #getText()} call.
-	 *
-	 * The rewriter only works on tokens that you have in the buffer and ignores the
-	 * current input cursor. If you are buffering tokens on-demand, calling
-	 * {@link #getText()} halfway through the input will only do rewrites for those
-	 * tokens in the first half of the file.
-	 *
-	 * Since the operations are done lazily at {@link #getText}-time, operations do
-	 * not screw up the token index values. That is, an insert operation at token
-	 * index `i` does not change the index values for tokens
-	 * `i`+1..n-1.
-	 *
-	 * Because operations never actually alter the buffer, you may always get the
-	 * original token stream back without undoing anything. Since the instructions
-	 * are queued up, you can easily simulate transactions and roll back any changes
-	 * if there is an error just by removing instructions. For example,
-	 *
-	 * ```
-	 * CharStream input = new ANTLRFileStream("input");
-	 * TLexer lex = new TLexer(input);
-	 * CommonTokenStream tokens = new CommonTokenStream(lex);
-	 * T parser = new T(tokens);
-	 * TokenStreamRewriter rewriter = new TokenStreamRewriter(tokens);
-	 * parser.startRule();
-	 * ```
-	 *
-	 * Then in the rules, you can execute (assuming rewriter is visible):
-	 *
-	 * ```
-	 * Token t,u;
-	 * ...
-	 * rewriter.insertAfter(t, "text to put after t");}
-	 * rewriter.insertAfter(u, "text after u");}
-	 * System.out.println(rewriter.getText());
-	 * ```
-	 *
-	 * You can also have multiple "instruction streams" and get multiple rewrites
-	 * from a single pass over the input. Just name the instruction streams and use
-	 * that name again when printing the buffer. This could be useful for generating
-	 * a C file and also its header file--all from the same buffer:
-	 *
-	 * ```
-	 * rewriter.insertAfter("pass1", t, "text to put after t");}
-	 * rewriter.insertAfter("pass2", u, "text after u");}
-	 * System.out.println(rewriter.getText("pass1"));
-	 * System.out.println(rewriter.getText("pass2"));
-	 * ```
-	 *
-	 * If you don't use named rewrite streams, a "default" stream is used as the
-	 * first example shows.
-	 */
-	let TokenStreamRewriter$1 = class TokenStreamRewriter {
-	    constructor(tokens) {
-	        this.tokens = tokens;
-	        this.programs = new Map();
-	        this.programs.set(TokenStreamRewriter.DEFAULT_PROGRAM_NAME, []);
-	        this.lastRewriteTokenIndexes = new Map();
-	    }
-	    getTokenStream() {
-	        return this.tokens;
-	    }
-	    rollback(instructionIndex, programName = TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
-	        let is = this.programs.get(programName);
-	        if (is != null) {
-	            this.programs.set(programName, is.slice(TokenStreamRewriter.MIN_TOKEN_INDEX, instructionIndex));
-	        }
-	    }
-	    deleteProgram(programName = TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
-	        this.rollback(TokenStreamRewriter.MIN_TOKEN_INDEX, programName);
-	    }
-	    insertAfter(tokenOrIndex, text, programName = TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
-	        let index;
-	        if (typeof tokenOrIndex === "number") {
-	            index = tokenOrIndex;
-	        }
-	        else {
-	            index = tokenOrIndex.tokenIndex;
-	        }
-	        // to insert after, just insert before next index (even if past end)
-	        let rewrites = this.getProgram(programName);
-	        let op = new InsertAfterOp(this.tokens, index, rewrites.length, text);
-	        rewrites.push(op);
-	    }
-	    insertBefore(tokenOrIndex, text, programName = TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
-	        let index;
-	        if (typeof tokenOrIndex === "number") {
-	            index = tokenOrIndex;
-	        }
-	        else {
-	            index = tokenOrIndex.tokenIndex;
-	        }
-	        let rewrites = this.getProgram(programName);
-	        let op = new InsertBeforeOp(this.tokens, index, rewrites.length, text);
-	        rewrites.push(op);
-	    }
-	    replaceSingle(index, text) {
-	        if (typeof index === "number") {
-	            this.replace(index, index, text);
-	        }
-	        else {
-	            this.replace(index, index, text);
-	        }
-	    }
-	    replace(from, to, text, programName = TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
-	        if (typeof from !== "number") {
-	            from = from.tokenIndex;
-	        }
-	        if (typeof to !== "number") {
-	            to = to.tokenIndex;
-	        }
-	        if (from > to || from < 0 || to < 0 || to >= this.tokens.size) {
-	            throw new RangeError(`replace: range invalid: ${from}..${to}(size=${this.tokens.size})`);
-	        }
-	        let rewrites = this.getProgram(programName);
-	        let op = new ReplaceOp(this.tokens, from, to, rewrites.length, text);
-	        rewrites.push(op);
-	    }
-	    delete(from, to, programName = TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
-	        if (to === undefined) {
-	            to = from;
-	        }
-	        if (typeof from === "number") {
-	            this.replace(from, to, "", programName);
-	        }
-	        else {
-	            this.replace(from, to, "", programName);
-	        }
-	    }
-	    getLastRewriteTokenIndex(programName = TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
-	        let I = this.lastRewriteTokenIndexes.get(programName);
-	        if (I == null) {
-	            return -1;
-	        }
-	        return I;
-	    }
-	    setLastRewriteTokenIndex(programName, i) {
-	        this.lastRewriteTokenIndexes.set(programName, i);
-	    }
-	    getProgram(name) {
-	        let is = this.programs.get(name);
-	        if (is == null) {
-	            is = this.initializeProgram(name);
-	        }
-	        return is;
-	    }
-	    initializeProgram(name) {
-	        let is = [];
-	        this.programs.set(name, is);
-	        return is;
-	    }
-	    getText(intervalOrProgram, programName = TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
-	        let interval;
-	        if (intervalOrProgram instanceof Interval_1.Interval) {
-	            interval = intervalOrProgram;
-	        }
-	        else {
-	            interval = Interval_1.Interval.of(0, this.tokens.size - 1);
-	        }
-	        if (typeof intervalOrProgram === "string") {
-	            programName = intervalOrProgram;
-	        }
-	        let rewrites = this.programs.get(programName);
-	        let start = interval.a;
-	        let stop = interval.b;
-	        // ensure start/end are in range
-	        if (stop > this.tokens.size - 1) {
-	            stop = this.tokens.size - 1;
-	        }
-	        if (start < 0) {
-	            start = 0;
-	        }
-	        if (rewrites == null || rewrites.length === 0) {
-	            return this.tokens.getText(interval); // no instructions to execute
-	        }
-	        let buf = [];
-	        // First, optimize instruction stream
-	        let indexToOp = this.reduceToSingleOperationPerIndex(rewrites);
-	        // Walk buffer, executing instructions and emitting tokens
-	        let i = start;
-	        while (i <= stop && i < this.tokens.size) {
-	            let op = indexToOp.get(i);
-	            indexToOp.delete(i); // remove so any left have index size-1
-	            let t = this.tokens.get(i);
-	            if (op == null) {
-	                // no operation at that index, just dump token
-	                if (t.type !== Token_1.Token.EOF) {
-	                    buf.push(String(t.text));
-	                }
-	                i++; // move to next token
-	            }
-	            else {
-	                i = op.execute(buf); // execute operation and skip
-	            }
-	        }
-	        // include stuff after end if it's last index in buffer
-	        // So, if they did an insertAfter(lastValidIndex, "foo"), include
-	        // foo if end==lastValidIndex.
-	        if (stop === this.tokens.size - 1) {
-	            // Scan any remaining operations after last token
-	            // should be included (they will be inserts).
-	            for (let op of indexToOp.values()) {
-	                if (op.index >= this.tokens.size - 1) {
-	                    buf.push(op.text.toString());
-	                }
-	            }
-	        }
-	        return buf.join("");
-	    }
-	    /** We need to combine operations and report invalid operations (like
-	     *  overlapping replaces that are not completed nested). Inserts to
-	     *  same index need to be combined etc...  Here are the cases:
-	     *
-	     *  I.i.u I.j.v								leave alone, nonoverlapping
-	     *  I.i.u I.i.v								combine: Iivu
-	     *
-	     *  R.i-j.u R.x-y.v	| i-j in x-y			delete first R
-	     *  R.i-j.u R.i-j.v							delete first R
-	     *  R.i-j.u R.x-y.v	| x-y in i-j			ERROR
-	     *  R.i-j.u R.x-y.v	| boundaries overlap	ERROR
-	     *
-	     *  Delete special case of replace (text==undefined):
-	     *  D.i-j.u D.x-y.v	| boundaries overlap	combine to max(min)..max(right)
-	     *
-	     *  I.i.u R.x-y.v | i in (x+1)-y			delete I (since insert before
-	     * 											we're not deleting i)
-	     *  I.i.u R.x-y.v | i not in (x+1)-y		leave alone, nonoverlapping
-	     *  R.x-y.v I.i.u | i in x-y				ERROR
-	     *  R.x-y.v I.x.u 							R.x-y.uv (combine, delete I)
-	     *  R.x-y.v I.i.u | i not in x-y			leave alone, nonoverlapping
-	     *
-	     *  I.i.u = insert u before op @ index i
-	     *  R.x-y.u = replace x-y indexed tokens with u
-	     *
-	     *  First we need to examine replaces. For any replace op:
-	     *
-	     * 		1. wipe out any insertions before op within that range.
-	     * 		2. Drop any replace op before that is contained completely within
-	     * 	 that range.
-	     * 		3. Throw exception upon boundary overlap with any previous replace.
-	     *
-	     *  Then we can deal with inserts:
-	     *
-	     * 		1. for any inserts to same index, combine even if not adjacent.
-	     * 		2. for any prior replace with same left boundary, combine this
-	     * 	 insert with replace and delete this replace.
-	     * 		3. throw exception if index in same range as previous replace
-	     *
-	     *  Don't actually delete; make op undefined in list. Easier to walk list.
-	     *  Later we can throw as we add to index &rarr; op map.
-	     *
-	     *  Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
-	     *  inserted stuff would be before the replace range. But, if you
-	     *  add tokens in front of a method body '{' and then delete the method
-	     *  body, I think the stuff before the '{' you added should disappear too.
-	     *
-	     *  Return a map from token index to operation.
-	     */
-	    reduceToSingleOperationPerIndex(rewrites) {
-	        // console.log(`rewrites=[${Utils.join(rewrites, ", ")}]`);
-	        // WALK REPLACES
-	        for (let i = 0; i < rewrites.length; i++) {
-	            let op = rewrites[i];
-	            if (op == null) {
-	                continue;
-	            }
-	            if (!(op instanceof ReplaceOp)) {
-	                continue;
-	            }
-	            let rop = op;
-	            // Wipe prior inserts within range
-	            let inserts = this.getKindOfOps(rewrites, InsertBeforeOp, i);
-	            for (let iop of inserts) {
-	                if (iop.index === rop.index) {
-	                    // E.g., insert before 2, delete 2..2; update replace
-	                    // text to include insert before, kill insert
-	                    rewrites[iop.instructionIndex] = undefined;
-	                    rop.text = iop.text.toString() + (rop.text != null ? rop.text.toString() : "");
-	                }
-	                else if (iop.index > rop.index && iop.index <= rop.lastIndex) {
-	                    // delete insert as it's a no-op.
-	                    rewrites[iop.instructionIndex] = undefined;
-	                }
-	            }
-	            // Drop any prior replaces contained within
-	            let prevReplaces = this.getKindOfOps(rewrites, ReplaceOp, i);
-	            for (let prevRop of prevReplaces) {
-	                if (prevRop.index >= rop.index && prevRop.lastIndex <= rop.lastIndex) {
-	                    // delete replace as it's a no-op.
-	                    rewrites[prevRop.instructionIndex] = undefined;
-	                    continue;
-	                }
-	                // throw exception unless disjoint or identical
-	                let disjoint = prevRop.lastIndex < rop.index || prevRop.index > rop.lastIndex;
-	                // Delete special case of replace (text==null):
-	                // D.i-j.u D.x-y.v	| boundaries overlap	combine to max(min)..max(right)
-	                if (prevRop.text == null && rop.text == null && !disjoint) {
-	                    // console.log(`overlapping deletes: ${prevRop}, ${rop}`);
-	                    rewrites[prevRop.instructionIndex] = undefined; // kill first delete
-	                    rop.index = Math.min(prevRop.index, rop.index);
-	                    rop.lastIndex = Math.max(prevRop.lastIndex, rop.lastIndex);
-	                    // console.log(`new rop ${rop}`);
-	                }
-	                else if (!disjoint) {
-	                    throw new Error(`replace op boundaries of ${rop} overlap with previous ${prevRop}`);
-	                }
-	            }
-	        }
-	        // WALK INSERTS
-	        for (let i = 0; i < rewrites.length; i++) {
-	            let op = rewrites[i];
-	            if (op == null) {
-	                continue;
-	            }
-	            if (!(op instanceof InsertBeforeOp)) {
-	                continue;
-	            }
-	            let iop = op;
-	            // combine current insert with prior if any at same index
-	            let prevInserts = this.getKindOfOps(rewrites, InsertBeforeOp, i);
-	            for (let prevIop of prevInserts) {
-	                if (prevIop.index === iop.index) {
-	                    if (prevIop instanceof InsertAfterOp) {
-	                        iop.text = this.catOpText(prevIop.text, iop.text);
-	                        rewrites[prevIop.instructionIndex] = undefined;
-	                    }
-	                    else if (prevIop instanceof InsertBeforeOp) { // combine objects
-	                        // convert to strings...we're in process of toString'ing
-	                        // whole token buffer so no lazy eval issue with any templates
-	                        iop.text = this.catOpText(iop.text, prevIop.text);
-	                        // delete redundant prior insert
-	                        rewrites[prevIop.instructionIndex] = undefined;
-	                    }
-	                }
-	            }
-	            // look for replaces where iop.index is in range; error
-	            let prevReplaces = this.getKindOfOps(rewrites, ReplaceOp, i);
-	            for (let rop of prevReplaces) {
-	                if (iop.index === rop.index) {
-	                    rop.text = this.catOpText(iop.text, rop.text);
-	                    rewrites[i] = undefined; // delete current insert
-	                    continue;
-	                }
-	                if (iop.index >= rop.index && iop.index <= rop.lastIndex) {
-	                    throw new Error(`insert op ${iop} within boundaries of previous ${rop}`);
-	                }
-	            }
-	        }
-	        // console.log(`rewrites after=[${Utils.join(rewrites, ", ")}]`);
-	        let m = new Map();
-	        for (let op of rewrites) {
-	            if (op == null) {
-	                // ignore deleted ops
-	                continue;
-	            }
-	            if (m.get(op.index) != null) {
-	                throw new Error("should only be one op per index");
-	            }
-	            m.set(op.index, op);
-	        }
-	        // console.log(`index to op: ${m}`);
-	        return m;
-	    }
-	    catOpText(a, b) {
-	        let x = "";
-	        let y = "";
-	        if (a != null) {
-	            x = a.toString();
-	        }
-	        if (b != null) {
-	            y = b.toString();
-	        }
-	        return x + y;
-	    }
-	    /** Get all operations before an index of a particular kind */
-	    getKindOfOps(rewrites, kind, before) {
-	        let ops = [];
-	        for (let i = 0; i < before && i < rewrites.length; i++) {
-	            let op = rewrites[i];
-	            if (op == null) {
-	                // ignore deleted
-	                continue;
-	            }
-	            if (op instanceof kind) {
-	                ops.push(op);
-	            }
-	        }
-	        return ops;
-	    }
-	};
-	TokenStreamRewriter.TokenStreamRewriter = TokenStreamRewriter$1;
-	TokenStreamRewriter$1.DEFAULT_PROGRAM_NAME = "default";
-	TokenStreamRewriter$1.PROGRAM_INIT_SIZE = 100;
-	TokenStreamRewriter$1.MIN_TOKEN_INDEX = 0;
-	// Define the rewrite operation hierarchy
-	class RewriteOperation {
-	    constructor(tokens, index, instructionIndex, text) {
-	        this.tokens = tokens;
-	        this.instructionIndex = instructionIndex;
-	        this.index = index;
-	        this.text = text === undefined ? "" : text;
-	    }
-	    /** Execute the rewrite operation by possibly adding to the buffer.
-	     *  Return the index of the next token to operate on.
-	     */
-	    execute(buf) {
-	        return this.index;
-	    }
-	    toString() {
-	        let opName = this.constructor.name;
-	        let $index = opName.indexOf("$");
-	        opName = opName.substring($index + 1, opName.length);
-	        return "<" + opName + "@" + this.tokens.get(this.index) +
-	            ":\"" + this.text + "\">";
-	    }
-	}
-	__decorate([
-	    Decorators_1.Override
-	], RewriteOperation.prototype, "toString", null);
-	TokenStreamRewriter.RewriteOperation = RewriteOperation;
-	class InsertBeforeOp extends RewriteOperation {
-	    constructor(tokens, index, instructionIndex, text) {
-	        super(tokens, index, instructionIndex, text);
-	    }
-	    execute(buf) {
-	        buf.push(this.text.toString());
-	        if (this.tokens.get(this.index).type !== Token_1.Token.EOF) {
-	            buf.push(String(this.tokens.get(this.index).text));
-	        }
-	        return this.index + 1;
-	    }
-	}
-	__decorate([
-	    Decorators_1.Override
-	], InsertBeforeOp.prototype, "execute", null);
-	/** Distinguish between insert after/before to do the "insert afters"
-	 *  first and then the "insert befores" at same index. Implementation
-	 *  of "insert after" is "insert before index+1".
-	 */
-	class InsertAfterOp extends InsertBeforeOp {
-	    constructor(tokens, index, instructionIndex, text) {
-	        super(tokens, index + 1, instructionIndex, text); // insert after is insert before index+1
-	    }
-	}
-	/** I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
-	 *  instructions.
-	 */
-	class ReplaceOp extends RewriteOperation {
-	    constructor(tokens, from, to, instructionIndex, text) {
-	        super(tokens, from, instructionIndex, text);
-	        this.lastIndex = to;
-	    }
-	    execute(buf) {
-	        if (this.text != null) {
-	            buf.push(this.text.toString());
-	        }
-	        return this.lastIndex + 1;
-	    }
-	    toString() {
-	        if (this.text == null) {
-	            return "<DeleteOp@" + this.tokens.get(this.index) +
-	                ".." + this.tokens.get(this.lastIndex) + ">";
-	        }
-	        return "<ReplaceOp@" + this.tokens.get(this.index) +
-	            ".." + this.tokens.get(this.lastIndex) + ":\"" + this.text + "\">";
-	    }
-	}
-	__decorate([
-	    Decorators_1.Override
-	], ReplaceOp.prototype, "execute", null);
-	__decorate([
-	    Decorators_1.Override
-	], ReplaceOp.prototype, "toString", null);
-	
-	return TokenStreamRewriter;
-}
-
-var Vocabulary = {};
-
-var hasRequiredVocabulary;
-
-function requireVocabulary () {
-	if (hasRequiredVocabulary) return Vocabulary;
-	hasRequiredVocabulary = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(Vocabulary, "__esModule", { value: true });
-	
-	return Vocabulary;
-}
-
-var WritableToken = {};
-
-var hasRequiredWritableToken;
-
-function requireWritableToken () {
-	if (hasRequiredWritableToken) return WritableToken;
-	hasRequiredWritableToken = 1;
-	/*!
-	 * Copyright 2016 The ANTLR Project. All rights reserved.
-	 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-	 */
-	Object.defineProperty(WritableToken, "__esModule", { value: true });
-	
-	return WritableToken;
-}
-
-var hasRequiredAntlr4ts;
-
-function requireAntlr4ts () {
-	if (hasRequiredAntlr4ts) return antlr4ts;
-	hasRequiredAntlr4ts = 1;
-	(function (exports) {
-		/*!
-		 * Copyright 2016 The ANTLR Project. All rights reserved.
-		 * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
-		 */
-		var __createBinding = (antlr4ts && antlr4ts.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-		    if (k2 === undefined) k2 = k;
-		    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-		}) : (function(o, m, k, k2) {
-		    if (k2 === undefined) k2 = k;
-		    o[k2] = m[k];
-		}));
-		var __exportStar = (antlr4ts && antlr4ts.__exportStar) || function(m, exports) {
-		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-		};
-		Object.defineProperty(exports, "__esModule", { value: true });
-		__exportStar(requireANTLRErrorListener(), exports);
-		__exportStar(requireANTLRErrorStrategy(), exports);
-		// export * from "./ANTLRFileStream";
-		__exportStar(requireANTLRInputStream(), exports);
-		__exportStar(requireBailErrorStrategy(), exports);
-		__exportStar(requireBufferedTokenStream(), exports);
-		__exportStar(requireCharStream(), exports);
-		__exportStar(requireCharStreams(), exports);
-		__exportStar(requireCodePointBuffer(), exports);
-		__exportStar(requireCodePointCharStream(), exports);
-		__exportStar(requireCommonToken(), exports);
-		__exportStar(requireCommonTokenFactory(), exports);
-		__exportStar(requireCommonTokenStream(), exports);
-		__exportStar(requireConsoleErrorListener(), exports);
-		__exportStar(requireDefaultErrorStrategy(), exports);
-		__exportStar(requireDependents(), exports);
-		__exportStar(requireDiagnosticErrorListener(), exports);
-		__exportStar(requireFailedPredicateException(), exports);
-		__exportStar(requireInputMismatchException(), exports);
-		__exportStar(requireInterpreterRuleContext(), exports);
-		__exportStar(requireIntStream(), exports);
-		__exportStar(requireLexer(), exports);
-		__exportStar(requireLexerInterpreter(), exports);
-		__exportStar(requireLexerNoViableAltException(), exports);
-		__exportStar(requireListTokenSource(), exports);
-		__exportStar(requireNoViableAltException(), exports);
-		__exportStar(requireParser(), exports);
-		__exportStar(requireParserErrorListener(), exports);
-		__exportStar(requireParserInterpreter(), exports);
-		__exportStar(requireParserRuleContext(), exports);
-		__exportStar(requireProxyErrorListener(), exports);
-		__exportStar(requireProxyParserErrorListener(), exports);
-		__exportStar(requireRecognitionException(), exports);
-		__exportStar(requireRecognizer(), exports);
-		__exportStar(requireRuleContext(), exports);
-		__exportStar(requireRuleContextWithAltNum(), exports);
-		__exportStar(requireRuleDependency(), exports);
-		__exportStar(requireRuleVersion(), exports);
-		__exportStar(requireToken(), exports);
-		__exportStar(requireTokenFactory(), exports);
-		__exportStar(requireTokenSource(), exports);
-		__exportStar(requireTokenStream(), exports);
-		__exportStar(requireTokenStreamRewriter(), exports);
-		// export * from "./UnbufferedCharStream";
-		// export * from "./UnbufferedTokenStream";
-		__exportStar(requireVocabulary(), exports);
-		__exportStar(requireVocabularyImpl(), exports);
-		__exportStar(requireWritableToken(), exports);
-		
-	} (antlr4ts));
-	return antlr4ts;
-}
-
-var antlr4tsExports = requireAntlr4ts();
-
 var ATNExports = requireATN();
 
 var FailedPredicateExceptionExports = requireFailedPredicateException();
@@ -40613,9 +39269,9 @@ class IdentifierContext extends ParserRuleContextExports.ParserRuleContext {
 }
 
 function getParser(inputText) {
-    const inputStream = antlr4tsExports.CharStreams.fromString(inputText);
+    const inputStream = CharStreams$1.fromString(inputText);
     const lexer = new BattleScriptLexer(inputStream);
-    const tokenStream = new antlr4tsExports.CommonTokenStream(lexer);
+    const tokenStream = new CommonTokenStream$1(lexer);
     return new BattleScriptParser(tokenStream);
 }
 // Function to Parse and Convert BattleScript to JSON