less 3.10.1 → 3.11.1

package/packages/less/node_modules/chevrotain/lib/src/parse/parser/parser.js

@@ -0,0 +1,235 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../utils/utils");
+var follow_1 = require("../grammar/follow");
+var tokens_public_1 = require("../../scan/tokens_public");
+var cst_1 = require("../cst/cst");
+var errors_public_1 = require("../errors_public");
+var gast_resolver_public_1 = require("../grammar/gast/gast_resolver_public");
+var recoverable_1 = require("./traits/recoverable");
+var looksahead_1 = require("./traits/looksahead");
+var tree_builder_1 = require("./traits/tree_builder");
+var lexer_adapter_1 = require("./traits/lexer_adapter");
+var recognizer_api_1 = require("./traits/recognizer_api");
+var recognizer_engine_1 = require("./traits/recognizer_engine");
+var error_handler_1 = require("./traits/error_handler");
+var context_assist_1 = require("./traits/context_assist");
+var gast_recorder_1 = require("./traits/gast_recorder");
+var perf_tracer_1 = require("./traits/perf_tracer");
+exports.END_OF_FILE = tokens_public_1.createTokenInstance(tokens_public_1.EOF, "", NaN, NaN, NaN, NaN, NaN, NaN);
+Object.freeze(exports.END_OF_FILE);
+exports.DEFAULT_PARSER_CONFIG = Object.freeze({
+    recoveryEnabled: false,
+    maxLookahead: 4,
+    ignoredIssues: {},
+    dynamicTokensEnabled: false,
+    outputCst: true,
+    errorMessageProvider: errors_public_1.defaultParserErrorProvider,
+    nodeLocationTracking: "none",
+    traceInitPerf: false,
+    skipValidations: false
+});
+exports.DEFAULT_RULE_CONFIG = Object.freeze({
+    recoveryValueFunc: function () { return undefined; },
+    resyncEnabled: true
+});
+var ParserDefinitionErrorType;
+(function (ParserDefinitionErrorType) {
+    ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_RULE_NAME"] = 0] = "INVALID_RULE_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["DUPLICATE_RULE_NAME"] = 1] = "DUPLICATE_RULE_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_RULE_OVERRIDE"] = 2] = "INVALID_RULE_OVERRIDE";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["DUPLICATE_PRODUCTIONS"] = 3] = "DUPLICATE_PRODUCTIONS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["UNRESOLVED_SUBRULE_REF"] = 4] = "UNRESOLVED_SUBRULE_REF";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["LEFT_RECURSION"] = 5] = "LEFT_RECURSION";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["NONE_LAST_EMPTY_ALT"] = 6] = "NONE_LAST_EMPTY_ALT";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["AMBIGUOUS_ALTS"] = 7] = "AMBIGUOUS_ALTS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["CONFLICT_TOKENS_RULES_NAMESPACE"] = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_TOKEN_NAME"] = 9] = "INVALID_TOKEN_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_NESTED_RULE_NAME"] = 10] = "INVALID_NESTED_RULE_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["DUPLICATE_NESTED_NAME"] = 11] = "DUPLICATE_NESTED_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["NO_NON_EMPTY_LOOKAHEAD"] = 12] = "NO_NON_EMPTY_LOOKAHEAD";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["AMBIGUOUS_PREFIX_ALTS"] = 13] = "AMBIGUOUS_PREFIX_ALTS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["TOO_MANY_ALTS"] = 14] = "TOO_MANY_ALTS";
+})(ParserDefinitionErrorType = exports.ParserDefinitionErrorType || (exports.ParserDefinitionErrorType = {}));
+function EMPTY_ALT(value) {
+    if (value === void 0) { value = undefined; }
+    return function () {
+        return value;
+    };
+}
+exports.EMPTY_ALT = EMPTY_ALT;
+var Parser = /** @class */ (function () {
+    function Parser(tokenVocabulary, config) {
+        if (config === void 0) { config = exports.DEFAULT_PARSER_CONFIG; }
+        this.ignoredIssues = exports.DEFAULT_PARSER_CONFIG.ignoredIssues;
+        this.definitionErrors = [];
+        this.selfAnalysisDone = false;
+        var that = this;
+        that.initErrorHandler(config);
+        that.initLexerAdapter();
+        that.initLooksAhead(config);
+        that.initRecognizerEngine(tokenVocabulary, config);
+        that.initRecoverable(config);
+        that.initTreeBuilder(config);
+        that.initContentAssist();
+        that.initGastRecorder(config);
+        that.initPerformanceTracer(config);
+        /* istanbul ignore if - complete over-kill to test this, we should only add a test when we actually hard deprecate it and throw an error... */
+        if (utils_1.has(config, "ignoredIssues") &&
+            config.ignoredIssues !== exports.DEFAULT_PARSER_CONFIG.ignoredIssues) {
+            utils_1.PRINT_WARNING("The <ignoredIssues> IParserConfig property is soft-deprecated and will be removed in future versions.\n\t" +
+                "Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.");
+        }
+        this.ignoredIssues = utils_1.has(config, "ignoredIssues")
+            ? config.ignoredIssues
+            : exports.DEFAULT_PARSER_CONFIG.ignoredIssues;
+        this.skipValidations = utils_1.has(config, "skipValidations")
+            ? config.skipValidations
+            : exports.DEFAULT_PARSER_CONFIG.skipValidations;
+    }
+    /**
+     *  @deprecated use the **instance** method with the same name instead
+     */
+    Parser.performSelfAnalysis = function (parserInstance) {
+        ;
+        parserInstance.performSelfAnalysis();
+    };
+    Parser.prototype.performSelfAnalysis = function () {
+        var _this = this;
+        this.TRACE_INIT("performSelfAnalysis", function () {
+            var defErrorsMsgs;
+            _this.selfAnalysisDone = true;
+            var className = _this.className;
+            _this.TRACE_INIT("toFastProps", function () {
+                // Without this voodoo magic the parser would be x3-x4 slower
+                // It seems it is better to invoke `toFastProperties` **before**
+                // Any manipulations of the `this` object done during the recording phase.
+                utils_1.toFastProperties(_this);
+            });
+            _this.TRACE_INIT("Grammar Recording", function () {
+                try {
+                    _this.enableRecording();
+                    // Building the GAST
+                    utils_1.forEach(_this.definedRulesNames, function (currRuleName) {
+                        var wrappedRule = _this[currRuleName];
+                        var originalGrammarAction = wrappedRule["originalGrammarAction"];
+                        var recordedRuleGast = undefined;
+                        _this.TRACE_INIT(currRuleName + " Rule", function () {
+                            recordedRuleGast = _this.topLevelRuleRecord(currRuleName, originalGrammarAction);
+                        });
+                        _this.gastProductionsCache[currRuleName] = recordedRuleGast;
+                    });
+                }
+                finally {
+                    _this.disableRecording();
+                }
+            });
+            var resolverErrors = [];
+            _this.TRACE_INIT("Grammar Resolving", function () {
+                resolverErrors = gast_resolver_public_1.resolveGrammar({
+                    rules: utils_1.values(_this.gastProductionsCache)
+                });
+                _this.definitionErrors.push.apply(_this.definitionErrors, resolverErrors); // mutability for the win?
+            });
+            _this.TRACE_INIT("Grammar Validations", function () {
+                // only perform additional grammar validations IFF no resolving errors have occurred.
+                // as unresolved grammar may lead to unhandled runtime exceptions in the follow up validations.
+                if (utils_1.isEmpty(resolverErrors) && _this.skipValidations === false) {
+                    var validationErrors = gast_resolver_public_1.validateGrammar({
+                        rules: utils_1.values(_this.gastProductionsCache),
+                        maxLookahead: _this.maxLookahead,
+                        tokenTypes: utils_1.values(_this.tokensMap),
+                        ignoredIssues: _this.ignoredIssues,
+                        errMsgProvider: errors_public_1.defaultGrammarValidatorErrorProvider,
+                        grammarName: className
+                    });
+                    _this.definitionErrors.push.apply(_this.definitionErrors, validationErrors); // mutability for the win?
+                }
+            });
+            // this analysis may fail if the grammar is not perfectly valid
+            if (utils_1.isEmpty(_this.definitionErrors)) {
+                // The results of these computations are not needed unless error recovery is enabled.
+                if (_this.recoveryEnabled) {
+                    _this.TRACE_INIT("computeAllProdsFollows", function () {
+                        var allFollows = follow_1.computeAllProdsFollows(utils_1.values(_this.gastProductionsCache));
+                        _this.resyncFollows = allFollows;
+                    });
+                }
+                _this.TRACE_INIT("ComputeLookaheadFunctions", function () {
+                    _this.preComputeLookaheadFunctions(utils_1.values(_this.gastProductionsCache));
+                });
+            }
+            _this.TRACE_INIT("expandAllNestedRuleNames", function () {
+                // TODO: is this needed for EmbeddedActionsParser?
+                var cstAnalysisResult = cst_1.expandAllNestedRuleNames(utils_1.values(_this.gastProductionsCache), _this.fullRuleNameToShort);
+                _this.allRuleNames = cstAnalysisResult.allRuleNames;
+            });
+            if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING &&
+                !utils_1.isEmpty(_this.definitionErrors)) {
+                defErrorsMsgs = utils_1.map(_this.definitionErrors, function (defError) { return defError.message; });
+                throw new Error("Parser Definition Errors detected:\n " + defErrorsMsgs.join("\n-------------------------------\n"));
+            }
+        });
+    };
+    // Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.
+    // (normally during the parser's constructor).
+    // This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,
+    // for example: duplicate rule names, referencing an unresolved subrule, ect...
+    // This flag should not be enabled during normal usage, it is used in special situations, for example when
+    // needing to display the parser definition errors in some GUI(online playground).
+    Parser.DEFER_DEFINITION_ERRORS_HANDLING = false;
+    return Parser;
+}());
+exports.Parser = Parser;
+utils_1.applyMixins(Parser, [
+    recoverable_1.Recoverable,
+    looksahead_1.LooksAhead,
+    tree_builder_1.TreeBuilder,
+    lexer_adapter_1.LexerAdapter,
+    recognizer_engine_1.RecognizerEngine,
+    recognizer_api_1.RecognizerApi,
+    error_handler_1.ErrorHandler,
+    context_assist_1.ContentAssist,
+    gast_recorder_1.GastRecorder,
+    perf_tracer_1.PerformanceTracer
+]);
+var CstParser = /** @class */ (function (_super) {
+    __extends(CstParser, _super);
+    function CstParser(tokenVocabulary, config) {
+        if (config === void 0) { config = exports.DEFAULT_PARSER_CONFIG; }
+        var _this = this;
+        var configClone = utils_1.cloneObj(config);
+        configClone.outputCst = true;
+        _this = _super.call(this, tokenVocabulary, configClone) || this;
+        return _this;
+    }
+    return CstParser;
+}(Parser));
+exports.CstParser = CstParser;
+var EmbeddedActionsParser = /** @class */ (function (_super) {
+    __extends(EmbeddedActionsParser, _super);
+    function EmbeddedActionsParser(tokenVocabulary, config) {
+        if (config === void 0) { config = exports.DEFAULT_PARSER_CONFIG; }
+        var _this = this;
+        var configClone = utils_1.cloneObj(config);
+        configClone.outputCst = false;
+        _this = _super.call(this, tokenVocabulary, configClone) || this;
+        return _this;
+    }
+    return EmbeddedActionsParser;
+}(Parser));
+exports.EmbeddedActionsParser = EmbeddedActionsParser;
+//# sourceMappingURL=parser.js.map

package/packages/less/node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var interpreter_1 = require("../../grammar/interpreter");
+var utils_1 = require("../../../utils/utils");
+var ContentAssist = /** @class */ (function () {
+    function ContentAssist() {
+    }
+    ContentAssist.prototype.initContentAssist = function () { };
+    ContentAssist.prototype.computeContentAssist = function (startRuleName, precedingInput) {
+        var startRuleGast = this.gastProductionsCache[startRuleName];
+        if (utils_1.isUndefined(startRuleGast)) {
+            throw Error("Rule ->" + startRuleName + "<- does not exist in this grammar.");
+        }
+        return interpreter_1.nextPossibleTokensAfter([startRuleGast], precedingInput, this.tokenMatcher, this.maxLookahead);
+    };
+    // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'...
+    // TODO: should this be more explicitly part of the public API?
+    ContentAssist.prototype.getNextPossibleTokenTypes = function (grammarPath) {
+        var topRuleName = utils_1.first(grammarPath.ruleStack);
+        var gastProductions = this.getGAstProductions();
+        var topProduction = gastProductions[topRuleName];
+        var nextPossibleTokenTypes = new interpreter_1.NextAfterTokenWalker(topProduction, grammarPath).startWalking();
+        return nextPossibleTokenTypes;
+    };
+    return ContentAssist;
+}());
+exports.ContentAssist = ContentAssist;
+//# sourceMappingURL=context_assist.js.map

package/packages/less/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var exceptions_public_1 = require("../../exceptions_public");
+var utils_1 = require("../../../utils/utils");
+var lookahead_1 = require("../../grammar/lookahead");
+var parser_1 = require("../parser");
+/**
+ * Trait responsible for runtime parsing errors.
+ */
+var ErrorHandler = /** @class */ (function () {
+    function ErrorHandler() {
+    }
+    ErrorHandler.prototype.initErrorHandler = function (config) {
+        this._errors = [];
+        this.errorMessageProvider = utils_1.defaults(config.errorMessageProvider, parser_1.DEFAULT_PARSER_CONFIG.errorMessageProvider);
+    };
+    ErrorHandler.prototype.SAVE_ERROR = function (error) {
+        if (exceptions_public_1.isRecognitionException(error)) {
+            error.context = {
+                ruleStack: this.getHumanReadableRuleStack(),
+                ruleOccurrenceStack: utils_1.cloneArr(this.RULE_OCCURRENCE_STACK)
+            };
+            this._errors.push(error);
+            return error;
+        }
+        else {
+            throw Error("Trying to save an Error which is not a RecognitionException");
+        }
+    };
+    Object.defineProperty(ErrorHandler.prototype, "errors", {
+        // TODO: extract these methods to ErrorHandler Trait?
+        get: function () {
+            return utils_1.cloneArr(this._errors);
+        },
+        set: function (newErrors) {
+            this._errors = newErrors;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    // TODO: consider caching the error message computed information
+    ErrorHandler.prototype.raiseEarlyExitException = function (occurrence, prodType, userDefinedErrMsg) {
+        var ruleName = this.getCurrRuleFullName();
+        var ruleGrammar = this.getGAstProductions()[ruleName];
+        var lookAheadPathsPerAlternative = lookahead_1.getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, this.maxLookahead);
+        var insideProdPaths = lookAheadPathsPerAlternative[0];
+        var actualTokens = [];
+        for (var i = 1; i <= this.maxLookahead; i++) {
+            actualTokens.push(this.LA(i));
+        }
+        var msg = this.errorMessageProvider.buildEarlyExitMessage({
+            expectedIterationPaths: insideProdPaths,
+            actual: actualTokens,
+            previous: this.LA(0),
+            customUserDescription: userDefinedErrMsg,
+            ruleName: ruleName
+        });
+        throw this.SAVE_ERROR(new exceptions_public_1.EarlyExitException(msg, this.LA(1), this.LA(0)));
+    };
+    // TODO: consider caching the error message computed information
+    ErrorHandler.prototype.raiseNoAltException = function (occurrence, errMsgTypes) {
+        var ruleName = this.getCurrRuleFullName();
+        var ruleGrammar = this.getGAstProductions()[ruleName];
+        // TODO: getLookaheadPathsForOr can be slow for large enough maxLookahead and certain grammars, consider caching ?
+        var lookAheadPathsPerAlternative = lookahead_1.getLookaheadPathsForOr(occurrence, ruleGrammar, this.maxLookahead);
+        var actualTokens = [];
+        for (var i = 1; i <= this.maxLookahead; i++) {
+            actualTokens.push(this.LA(i));
+        }
+        var previousToken = this.LA(0);
+        var errMsg = this.errorMessageProvider.buildNoViableAltMessage({
+            expectedPathsPerAlt: lookAheadPathsPerAlternative,
+            actual: actualTokens,
+            previous: previousToken,
+            customUserDescription: errMsgTypes,
+            ruleName: this.getCurrRuleFullName()
+        });
+        throw this.SAVE_ERROR(new exceptions_public_1.NoViableAltException(errMsg, this.LA(1), previousToken));
+    };
+    return ErrorHandler;
+}());
+exports.ErrorHandler = ErrorHandler;
+//# sourceMappingURL=error_handler.js.map

package/packages/less/node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../../utils/utils");
+var gast_public_1 = require("../../grammar/gast/gast_public");
+var lexer_public_1 = require("../../../scan/lexer_public");
+var tokens_1 = require("../../../scan/tokens");
+var tokens_public_1 = require("../../../scan/tokens_public");
+var parser_1 = require("../parser");
+var keys_1 = require("../../grammar/keys");
+var RECORDING_NULL_OBJECT = {
+    description: "This Object indicates the Parser is during Recording Phase"
+};
+Object.freeze(RECORDING_NULL_OBJECT);
+var HANDLE_SEPARATOR = true;
+var MAX_METHOD_IDX = Math.pow(2, keys_1.BITS_FOR_OCCURRENCE_IDX) - 1;
+var RFT = tokens_public_1.createToken({ name: "RECORDING_PHASE_TOKEN", pattern: lexer_public_1.Lexer.NA });
+tokens_1.augmentTokenTypes([RFT]);
+var RECORDING_PHASE_TOKEN = tokens_public_1.createTokenInstance(RFT, "This IToken indicates the Parser is in Recording Phase\n\t" +
+    "" +
+    "See: https://sap.github.io/chevrotain/docs/guide/internals.html#grammar-recording for details", 
+// Using "-1" instead of NaN (as in EOF) because an actual number is less likely to
+// cause errors if the output of LA or CONSUME would be (incorrectly) used during the recording phase.
+-1, -1, -1, -1, -1, -1);
+Object.freeze(RECORDING_PHASE_TOKEN);
+var RECORDING_PHASE_CSTNODE = {
+    name: "This CSTNode indicates the Parser is in Recording Phase\n\t" +
+        "See: https://sap.github.io/chevrotain/docs/guide/internals.html#grammar-recording for details",
+    children: {}
+};
+/**
+ * This trait handles the creation of the GAST structure for Chevrotain Grammars
+ */
+var GastRecorder = /** @class */ (function () {
+    function GastRecorder() {
+    }
+    GastRecorder.prototype.initGastRecorder = function (config) {
+        this.recordingProdStack = [];
+        this.RECORDING_PHASE = false;
+    };
+    GastRecorder.prototype.enableRecording = function () {
+        var _this = this;
+        this.RECORDING_PHASE = true;
+        this.TRACE_INIT("Enable Recording", function () {
+            var _loop_1 = function (i) {
+                var idx = i > 0 ? i : "";
+                _this["CONSUME" + idx] = function (arg1, arg2) {
+                    return this.consumeInternalRecord(arg1, i, arg2);
+                };
+                _this["SUBRULE" + idx] = function (arg1, arg2) {
+                    return this.subruleInternalRecord(arg1, i, arg2);
+                };
+                _this["OPTION" + idx] = function (arg1) {
+                    return this.optionInternalRecord(arg1, i);
+                };
+                _this["OR" + idx] = function (arg1) {
+                    return this.orInternalRecord(arg1, i);
+                };
+                _this["MANY" + idx] = function (arg1) {
+                    this.manyInternalRecord(i, arg1);
+                };
+                _this["MANY_SEP" + idx] = function (arg1) {
+                    this.manySepFirstInternalRecord(i, arg1);
+                };
+                _this["AT_LEAST_ONE" + idx] = function (arg1) {
+                    this.atLeastOneInternalRecord(i, arg1);
+                };
+                _this["AT_LEAST_ONE_SEP" + idx] = function (arg1) {
+                    this.atLeastOneSepFirstInternalRecord(i, arg1);
+                };
+            };
+            /**
+             * Warning Dark Voodoo Magic upcoming!
+             * We are "replacing" the public parsing DSL methods API
+             * With **new** alternative implementations on the Parser **instance**
+             *
+             * So far this is the only way I've found to avoid performance regressions during parsing time.
+             * - Approx 30% performance regression was measured on Chrome 75 Canary when attempting to replace the "internal"
+             *   implementations directly instead.
+             */
+            for (var i = 0; i < 10; i++) {
+                _loop_1(i);
+            }
+            // DSL methods with the idx(suffix) as an argument
+            _this["consume"] = function (idx, arg1, arg2) {
+                return this.consumeInternalRecord(arg1, idx, arg2);
+            };
+            _this["subrule"] = function (idx, arg1, arg2) {
+                return this.subruleInternalRecord(arg1, idx, arg2);
+            };
+            _this["option"] = function (idx, arg1) {
+                return this.optionInternalRecord(arg1, idx);
+            };
+            _this["or"] = function (idx, arg1) {
+                return this.orInternalRecord(arg1, idx);
+            };
+            _this["many"] = function (idx, arg1) {
+                this.manyInternalRecord(idx, arg1);
+            };
+            _this["atLeastOne"] = function (idx, arg1) {
+                this.atLeastOneInternalRecord(idx, arg1);
+            };
+            _this.ACTION = _this.ACTION_RECORD;
+            _this.BACKTRACK = _this.BACKTRACK_RECORD;
+            _this.LA = _this.LA_RECORD;
+        });
+    };
+    GastRecorder.prototype.disableRecording = function () {
+        var _this = this;
+        this.RECORDING_PHASE = false;
+        // By deleting these **instance** properties, any future invocation
+        // will be deferred to the original methods on the **prototype** object
+        // This seems to get rid of any incorrect optimizations that V8 may
+        // do during the recording phase.
+        this.TRACE_INIT("Deleting Recording methods", function () {
+            for (var i = 0; i < 10; i++) {
+                var idx = i > 0 ? i : "";
+                delete _this["CONSUME" + idx];
+                delete _this["SUBRULE" + idx];
+                delete _this["OPTION" + idx];
+                delete _this["OR" + idx];
+                delete _this["MANY" + idx];
+                delete _this["MANY_SEP" + idx];
+                delete _this["AT_LEAST_ONE" + idx];
+                delete _this["AT_LEAST_ONE_SEP" + idx];
+            }
+            delete _this["consume"];
+            delete _this["subrule"];
+            delete _this["option"];
+            delete _this["or"];
+            delete _this["many"];
+            delete _this["atLeastOne"];
+            delete _this.ACTION;
+            delete _this.BACKTRACK;
+            delete _this.LA;
+        });
+    };
+    // TODO: is there any way to use this method to check no
+    //   Parser methods are called inside an ACTION?
+    //   Maybe try/catch/finally on ACTIONS while disabling the recorders state changes?
+    GastRecorder.prototype.ACTION_RECORD = function (impl) {
+        // NO-OP during recording
+        return;
+    };
+    // Executing backtracking logic will break our recording logic assumptions
+    GastRecorder.prototype.BACKTRACK_RECORD = function (grammarRule, args) {
+        return function () { return true; };
+    };
+    // LA is part of the official API and may be used for custom lookahead logic
+    // by end users who may forget to wrap it in ACTION or inside a GATE
+    GastRecorder.prototype.LA_RECORD = function (howMuch) {
+        // We cannot use the RECORD_PHASE_TOKEN here because someone may depend
+        // On LA return EOF at the end of the input so an infinite loop may occur.
+        return parser_1.END_OF_FILE;
+    };
+    GastRecorder.prototype.topLevelRuleRecord = function (name, def) {
+        try {
+            var newTopLevelRule = new gast_public_1.Rule({ definition: [], name: name });
+            newTopLevelRule.name = name;
+            this.recordingProdStack.push(newTopLevelRule);
+            def.call(this);
+            this.recordingProdStack.pop();
+            return newTopLevelRule;
+        }
+        catch (originalError) {
+            if (originalError.KNOWN_RECORDER_ERROR !== true) {
+                try {
+                    originalError.message =
+                        originalError.message +
+                            '\n\t This error was thrown during the "grammar recording phase" For more info see:\n\t' +
+                            "https://sap.github.io/chevrotain/docs/guide/internals.html#grammar-recording";
+                }
+                catch (mutabilityError) {
+                    // We may not be able to modify the original error object
+                    throw originalError;
+                }
+            }
+            throw originalError;
+        }
+    };
+    // Implementation of parsing DSL
+    GastRecorder.prototype.optionInternalRecord = function (actionORMethodDef, occurrence) {
+        return recordProd.call(this, gast_public_1.Option, actionORMethodDef, occurrence);
+    };
+    GastRecorder.prototype.atLeastOneInternalRecord = function (occurrence, actionORMethodDef) {
+        recordProd.call(this, gast_public_1.RepetitionMandatory, actionORMethodDef, occurrence);
+    };
+    GastRecorder.prototype.atLeastOneSepFirstInternalRecord = function (occurrence, options) {
+        recordProd.call(this, gast_public_1.RepetitionMandatoryWithSeparator, options, occurrence, HANDLE_SEPARATOR);
+    };
+    GastRecorder.prototype.manyInternalRecord = function (occurrence, actionORMethodDef) {
+        recordProd.call(this, gast_public_1.Repetition, actionORMethodDef, occurrence);
+    };
+    GastRecorder.prototype.manySepFirstInternalRecord = function (occurrence, options) {
+        recordProd.call(this, gast_public_1.RepetitionWithSeparator, options, occurrence, HANDLE_SEPARATOR);
+    };
+    GastRecorder.prototype.orInternalRecord = function (altsOrOpts, occurrence) {
+        return recordOrProd.call(this, altsOrOpts, occurrence);
+    };
+    GastRecorder.prototype.subruleInternalRecord = function (ruleToCall, occurrence, options) {
+        assertMethodIdxIsValid(occurrence);
+        if (!ruleToCall || utils_1.has(ruleToCall, "ruleName") === false) {
+            var error = new Error("<SUBRULE" + getIdxSuffix(occurrence) + "> argument is invalid" +
+                (" expecting a Parser method reference but got: <" + JSON.stringify(ruleToCall) + ">") +
+                ("\n inside top level rule: <" + this.recordingProdStack[0].name + ">"));
+            error.KNOWN_RECORDER_ERROR = true;
+            throw error;
+        }
+        var prevProd = utils_1.peek(this.recordingProdStack);
+        var ruleName = ruleToCall["ruleName"];
+        var newNoneTerminal = new gast_public_1.NonTerminal({
+            idx: occurrence,
+            nonTerminalName: ruleName,
+            // The resolving of the `referencedRule` property will be done once all the Rule's GASTs have been created
+            referencedRule: undefined
+        });
+        prevProd.definition.push(newNoneTerminal);
+        return this.outputCst
+            ? RECORDING_PHASE_CSTNODE
+            : RECORDING_NULL_OBJECT;
+    };
+    GastRecorder.prototype.consumeInternalRecord = function (tokType, occurrence, options) {
+        assertMethodIdxIsValid(occurrence);
+        if (!tokens_1.hasShortKeyProperty(tokType)) {
+            var error = new Error("<CONSUME" + getIdxSuffix(occurrence) + "> argument is invalid" +
+                (" expecting a TokenType reference but got: <" + JSON.stringify(tokType) + ">") +
+                ("\n inside top level rule: <" + this.recordingProdStack[0].name + ">"));
+            error.KNOWN_RECORDER_ERROR = true;
+            throw error;
+        }
+        var prevProd = utils_1.peek(this.recordingProdStack);
+        var newNoneTerminal = new gast_public_1.Terminal({
+            idx: occurrence,
+            terminalType: tokType
+        });
+        prevProd.definition.push(newNoneTerminal);
+        return RECORDING_PHASE_TOKEN;
+    };
+    return GastRecorder;
+}());
+exports.GastRecorder = GastRecorder;
+function recordProd(prodConstructor, mainProdArg, occurrence, handleSep) {
+    if (handleSep === void 0) { handleSep = false; }
+    assertMethodIdxIsValid(occurrence);
+    var prevProd = utils_1.peek(this.recordingProdStack);
+    var grammarAction = utils_1.isFunction(mainProdArg)
+        ? mainProdArg
+        : mainProdArg.DEF;
+    var newProd = new prodConstructor({ definition: [], idx: occurrence });
+    if (utils_1.has(mainProdArg, "NAME")) {
+        newProd.name = mainProdArg.NAME;
+    }
+    if (handleSep) {
+        newProd.separator = mainProdArg.SEP;
+    }
+    if (utils_1.has(mainProdArg, "MAX_LOOKAHEAD")) {
+        newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
+    }
+    this.recordingProdStack.push(newProd);
+    grammarAction.call(this);
+    prevProd.definition.push(newProd);
+    this.recordingProdStack.pop();
+    return RECORDING_NULL_OBJECT;
+}
+function recordOrProd(mainProdArg, occurrence) {
+    var _this = this;
+    assertMethodIdxIsValid(occurrence);
+    var prevProd = utils_1.peek(this.recordingProdStack);
+    // Only an array of alternatives
+    var hasOptions = utils_1.isArray(mainProdArg) === false;
+    var alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;
+    var newOrProd = new gast_public_1.Alternation({
+        definition: [],
+        idx: occurrence,
+        ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true
+    });
+    if (utils_1.has(mainProdArg, "NAME")) {
+        newOrProd.name = mainProdArg.NAME;
+    }
+    if (utils_1.has(mainProdArg, "MAX_LOOKAHEAD")) {
+        newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
+    }
+    var hasPredicates = utils_1.some(alts, function (currAlt) { return utils_1.isFunction(currAlt.GATE); });
+    newOrProd.hasPredicates = hasPredicates;
+    prevProd.definition.push(newOrProd);
+    utils_1.forEach(alts, function (currAlt) {
+        var currAltFlat = new gast_public_1.Flat({ definition: [] });
+        newOrProd.definition.push(currAltFlat);
+        if (utils_1.has(currAlt, "NAME")) {
+            currAltFlat.name = currAlt.NAME;
+        }
+        if (utils_1.has(currAlt, "IGNORE_AMBIGUITIES")) {
+            currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES;
+        }
+        // **implicit** ignoreAmbiguities due to usage of gate
+        else if (utils_1.has(currAlt, "GATE")) {
+            currAltFlat.ignoreAmbiguities = true;
+        }
+        _this.recordingProdStack.push(currAltFlat);
+        currAlt.ALT.call(_this);
+        _this.recordingProdStack.pop();
+    });
+    return RECORDING_NULL_OBJECT;
+}
+function getIdxSuffix(idx) {
+    return idx === 0 ? "" : "" + idx;
+}
+function assertMethodIdxIsValid(idx) {
+    if (idx < 0 || idx > MAX_METHOD_IDX) {
+        var error = new Error(
+        // The stack trace will contain all the needed details
+        "Invalid DSL Method idx value: <" + idx + ">\n\t" +
+            ("Idx value must be a none negative value smaller than " + (MAX_METHOD_IDX +
+                1)));
+        error.KNOWN_RECORDER_ERROR = true;
+        throw error;
+    }
+}
+//# sourceMappingURL=gast_recorder.js.map