less 3.10.1 → 3.11.1

package/packages/css-parser/node_modules/chevrotain/lib_esm/src/parse/parser/traits/lexer_adapter.js

@@ -0,0 +1,74 @@
+import { END_OF_FILE } from "../parser";
+/**
+ * Trait responsible abstracting over the interaction with Lexer output (Token vector).
+ *
+ * This could be generalized to support other kinds of lexers, e.g.
+ * - Just in Time Lexing / Lexer-Less parsing.
+ * - Streaming Lexer.
+ */
+var LexerAdapter = /** @class */ (function () {
+    function LexerAdapter() {
+    }
+    LexerAdapter.prototype.initLexerAdapter = function () {
+        this.tokVector = [];
+        this.tokVectorLength = 0;
+        this.currIdx = -1;
+    };
+    Object.defineProperty(LexerAdapter.prototype, "input", {
+        get: function () {
+            return this.tokVector;
+        },
+        set: function (newInput) {
+            if (this.selfAnalysisDone !== true) {
+                throw Error("Missing <performSelfAnalysis> invocation at the end of the Parser's constructor.");
+            }
+            this.reset();
+            this.tokVector = newInput;
+            this.tokVectorLength = newInput.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    // skips a token and returns the next token
+    LexerAdapter.prototype.SKIP_TOKEN = function () {
+        if (this.currIdx <= this.tokVector.length - 2) {
+            this.consumeToken();
+            return this.LA(1);
+        }
+        else {
+            return END_OF_FILE;
+        }
+    };
+    // Lexer (accessing Token vector) related methods which can be overridden to implement lazy lexers
+    // or lexers dependent on parser context.
+    LexerAdapter.prototype.LA = function (howMuch) {
+        var soughtIdx = this.currIdx + howMuch;
+        if (soughtIdx < 0 || this.tokVectorLength <= soughtIdx) {
+            return END_OF_FILE;
+        }
+        else {
+            return this.tokVector[soughtIdx];
+        }
+    };
+    LexerAdapter.prototype.consumeToken = function () {
+        this.currIdx++;
+    };
+    LexerAdapter.prototype.exportLexerState = function () {
+        return this.currIdx;
+    };
+    LexerAdapter.prototype.importLexerState = function (newState) {
+        this.currIdx = newState;
+    };
+    LexerAdapter.prototype.resetLexerState = function () {
+        this.currIdx = -1;
+    };
+    LexerAdapter.prototype.moveToTerminatedState = function () {
+        this.currIdx = this.tokVector.length - 1;
+    };
+    LexerAdapter.prototype.getLexerPosition = function () {
+        return this.exportLexerState();
+    };
+    return LexerAdapter;
+}());
+export { LexerAdapter };
+//# sourceMappingURL=lexer_adapter.js.map

package/packages/css-parser/node_modules/chevrotain/lib_esm/src/parse/parser/traits/looksahead.js

@@ -0,0 +1,106 @@
+import { buildAlternativesLookAheadFunc, buildLookaheadFuncForOptionalProd, buildLookaheadFuncForOr, buildSingleAlternativeLookaheadFunction, PROD_TYPE } from "../../grammar/lookahead";
+import { forEach, has, isES2015MapSupported } from "../../../utils/utils";
+import { DEFAULT_PARSER_CONFIG } from "../parser";
+import { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, getKeyForAutomaticLookahead, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX } from "../../grammar/keys";
+import { collectMethods, getProductionDslName } from "../../grammar/gast/gast";
+/**
+ * Trait responsible for the lookahead related utilities and optimizations.
+ */
+var LooksAhead = /** @class */ (function () {
+    function LooksAhead() {
+    }
+    LooksAhead.prototype.initLooksAhead = function (config) {
+        this.dynamicTokensEnabled = has(config, "dynamicTokensEnabled")
+            ? config.dynamicTokensEnabled
+            : DEFAULT_PARSER_CONFIG.dynamicTokensEnabled;
+        this.maxLookahead = has(config, "maxLookahead")
+            ? config.maxLookahead
+            : DEFAULT_PARSER_CONFIG.maxLookahead;
+        /* istanbul ignore next - Using plain array as dictionary will be tested on older node.js versions and IE11 */
+        this.lookAheadFuncsCache = isES2015MapSupported() ? new Map() : [];
+        // Performance optimization on newer engines that support ES6 Map
+        // For larger Maps this is slightly faster than using a plain object (array in our case).
+        /* istanbul ignore else - The else branch will be tested on older node.js versions and IE11 */
+        if (isES2015MapSupported()) {
+            this.getLaFuncFromCache = this.getLaFuncFromMap;
+            this.setLaFuncCache = this.setLaFuncCacheUsingMap;
+        }
+        else {
+            this.getLaFuncFromCache = this.getLaFuncFromObj;
+            this.setLaFuncCache = this.setLaFuncUsingObj;
+        }
+    };
+    LooksAhead.prototype.preComputeLookaheadFunctions = function (rules) {
+        var _this = this;
+        forEach(rules, function (currRule) {
+            _this.TRACE_INIT(currRule.name + " Rule Lookahead", function () {
+                var _a = collectMethods(currRule), alternation = _a.alternation, repetition = _a.repetition, option = _a.option, repetitionMandatory = _a.repetitionMandatory, repetitionMandatoryWithSeparator = _a.repetitionMandatoryWithSeparator, repetitionWithSeparator = _a.repetitionWithSeparator;
+                forEach(alternation, function (currProd) {
+                    var prodIdx = currProd.idx === 0 ? "" : currProd.idx;
+                    _this.TRACE_INIT("" + getProductionDslName(currProd) + prodIdx, function () {
+                        var laFunc = buildLookaheadFuncForOr(currProd.idx, currRule, currProd.maxLookahead || _this.maxLookahead, currProd.hasPredicates, _this.dynamicTokensEnabled, _this.lookAheadBuilderForAlternatives);
+                        var key = getKeyForAutomaticLookahead(_this.fullRuleNameToShort[currRule.name], OR_IDX, currProd.idx);
+                        _this.setLaFuncCache(key, laFunc);
+                    });
+                });
+                forEach(repetition, function (currProd) {
+                    _this.computeLookaheadFunc(currRule, currProd.idx, MANY_IDX, PROD_TYPE.REPETITION, currProd.maxLookahead, getProductionDslName(currProd));
+                });
+                forEach(option, function (currProd) {
+                    _this.computeLookaheadFunc(currRule, currProd.idx, OPTION_IDX, PROD_TYPE.OPTION, currProd.maxLookahead, getProductionDslName(currProd));
+                });
+                forEach(repetitionMandatory, function (currProd) {
+                    _this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_IDX, PROD_TYPE.REPETITION_MANDATORY, currProd.maxLookahead, getProductionDslName(currProd));
+                });
+                forEach(repetitionMandatoryWithSeparator, function (currProd) {
+                    _this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_SEP_IDX, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, currProd.maxLookahead, getProductionDslName(currProd));
+                });
+                forEach(repetitionWithSeparator, function (currProd) {
+                    _this.computeLookaheadFunc(currRule, currProd.idx, MANY_SEP_IDX, PROD_TYPE.REPETITION_WITH_SEPARATOR, currProd.maxLookahead, getProductionDslName(currProd));
+                });
+            });
+        });
+    };
+    LooksAhead.prototype.computeLookaheadFunc = function (rule, prodOccurrence, prodKey, prodType, prodMaxLookahead, dslMethodName) {
+        var _this = this;
+        this.TRACE_INIT("" + dslMethodName + (prodOccurrence === 0 ? "" : prodOccurrence), function () {
+            var laFunc = buildLookaheadFuncForOptionalProd(prodOccurrence, rule, prodMaxLookahead || _this.maxLookahead, _this.dynamicTokensEnabled, prodType, _this.lookAheadBuilderForOptional);
+            var key = getKeyForAutomaticLookahead(_this.fullRuleNameToShort[rule.name], prodKey, prodOccurrence);
+            _this.setLaFuncCache(key, laFunc);
+        });
+    };
+    LooksAhead.prototype.lookAheadBuilderForOptional = function (alt, tokenMatcher, dynamicTokensEnabled) {
+        return buildSingleAlternativeLookaheadFunction(alt, tokenMatcher, dynamicTokensEnabled);
+    };
+    LooksAhead.prototype.lookAheadBuilderForAlternatives = function (alts, hasPredicates, tokenMatcher, dynamicTokensEnabled) {
+        return buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynamicTokensEnabled);
+    };
+    // this actually returns a number, but it is always used as a string (object prop key)
+    LooksAhead.prototype.getKeyForAutomaticLookahead = function (dslMethodIdx, occurrence) {
+        var currRuleShortName = this.getLastExplicitRuleShortName();
+        return getKeyForAutomaticLookahead(currRuleShortName, dslMethodIdx, occurrence);
+    };
+    /* istanbul ignore next */
+    LooksAhead.prototype.getLaFuncFromCache = function (key) {
+        return undefined;
+    };
+    LooksAhead.prototype.getLaFuncFromMap = function (key) {
+        return this.lookAheadFuncsCache.get(key);
+    };
+    /* istanbul ignore next - Using plain array as dictionary will be tested on older node.js versions and IE11 */
+    LooksAhead.prototype.getLaFuncFromObj = function (key) {
+        return this.lookAheadFuncsCache[key];
+    };
+    /* istanbul ignore next */
+    LooksAhead.prototype.setLaFuncCache = function (key, value) { };
+    LooksAhead.prototype.setLaFuncCacheUsingMap = function (key, value) {
+        this.lookAheadFuncsCache.set(key, value);
+    };
+    /* istanbul ignore next - Using plain array as dictionary will be tested on older node.js versions and IE11 */
+    LooksAhead.prototype.setLaFuncUsingObj = function (key, value) {
+        this.lookAheadFuncsCache[key] = value;
+    };
+    return LooksAhead;
+}());
+export { LooksAhead };
+//# sourceMappingURL=looksahead.js.map

package/packages/css-parser/node_modules/chevrotain/lib_esm/src/parse/parser/traits/parser_traits.js

@@ -0,0 +1,5 @@
+import { Parser as ParserConstructorImpel, CstParser as CstParserConstructorImpel, EmbeddedActionsParser as EmbeddedActionsParserConstructorImpel } from "../parser";
+export var Parser = ParserConstructorImpel;
+export var CstParser = (CstParserConstructorImpel);
+export var EmbeddedActionsParser = EmbeddedActionsParserConstructorImpel;
+//# sourceMappingURL=parser_traits.js.map

package/packages/css-parser/node_modules/chevrotain/lib_esm/src/parse/parser/traits/perf_tracer.js

@@ -0,0 +1,51 @@
+import { has, timer } from "../../../utils/utils";
+import { DEFAULT_PARSER_CONFIG } from "../parser";
+/**
+ * Trait responsible for runtime parsing errors.
+ */
+var PerformanceTracer = /** @class */ (function () {
+    function PerformanceTracer() {
+    }
+    PerformanceTracer.prototype.initPerformanceTracer = function (config) {
+        if (has(config, "traceInitPerf")) {
+            var userTraceInitPerf = config.traceInitPerf;
+            var traceIsNumber = typeof userTraceInitPerf === "number";
+            this.traceInitMaxIdent = traceIsNumber
+                ? userTraceInitPerf
+                : Infinity;
+            this.traceInitPerf = traceIsNumber
+                ? userTraceInitPerf > 0
+                : userTraceInitPerf;
+        }
+        else {
+            this.traceInitMaxIdent = 0;
+            this.traceInitPerf = DEFAULT_PARSER_CONFIG.traceInitPerf;
+        }
+        this.traceInitIndent = -1;
+    };
+    PerformanceTracer.prototype.TRACE_INIT = function (phaseDesc, phaseImpl) {
+        // No need to optimize this using NOOP pattern because
+        // It is not called in a hot spot...
+        if (this.traceInitPerf === true) {
+            this.traceInitIndent++;
+            var indent = new Array(this.traceInitIndent + 1).join("\t");
+            if (this.traceInitIndent < this.traceInitMaxIdent) {
+                console.log(indent + "--> <" + phaseDesc + ">");
+            }
+            var _a = timer(phaseImpl), time = _a.time, value = _a.value;
+            /* istanbul ignore next - Difficult to reproduce specific performance behavior (>10ms) in tests */
+            var traceMethod = time > 10 ? console.warn : console.log;
+            if (this.traceInitIndent < this.traceInitMaxIdent) {
+                traceMethod(indent + "<-- <" + phaseDesc + "> time: " + time + "ms");
+            }
+            this.traceInitIndent--;
+            return value;
+        }
+        else {
+            return phaseImpl();
+        }
+    };
+    return PerformanceTracer;
+}());
+export { PerformanceTracer };
+//# sourceMappingURL=perf_tracer.js.map

package/packages/css-parser/node_modules/chevrotain/lib_esm/src/parse/parser/traits/recognizer_api.js

@@ -0,0 +1,341 @@
+import { contains, values } from "../../../utils/utils";
+import { isRecognitionException } from "../../exceptions_public";
+import { DEFAULT_RULE_CONFIG, ParserDefinitionErrorType } from "../parser";
+import { defaultGrammarValidatorErrorProvider } from "../../errors_public";
+import { validateRuleIsOverridden } from "../../grammar/checks";
+import { serializeGrammar } from "../../grammar/gast/gast_public";
+/**
+ * This trait is responsible for implementing the public API
+ * for defining Chevrotain parsers, i.e:
+ * - CONSUME
+ * - RULE
+ * - OPTION
+ * - ...
+ */
+var RecognizerApi = /** @class */ (function () {
+    function RecognizerApi() {
+    }
+    RecognizerApi.prototype.ACTION = function (impl) {
+        return impl.call(this);
+    };
+    RecognizerApi.prototype.consume = function (idx, tokType, options) {
+        return this.consumeInternal(tokType, idx, options);
+    };
+    RecognizerApi.prototype.subrule = function (idx, ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, idx, options);
+    };
+    RecognizerApi.prototype.option = function (idx, actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, idx);
+    };
+    RecognizerApi.prototype.or = function (idx, altsOrOpts) {
+        return this.orInternal(altsOrOpts, idx);
+    };
+    RecognizerApi.prototype.many = function (idx, actionORMethodDef) {
+        return this.manyInternal(idx, actionORMethodDef);
+    };
+    RecognizerApi.prototype.atLeastOne = function (idx, actionORMethodDef) {
+        return this.atLeastOneInternal(idx, actionORMethodDef);
+    };
+    RecognizerApi.prototype.CONSUME = function (tokType, options) {
+        return this.consumeInternal(tokType, 0, options);
+    };
+    RecognizerApi.prototype.CONSUME1 = function (tokType, options) {
+        return this.consumeInternal(tokType, 1, options);
+    };
+    RecognizerApi.prototype.CONSUME2 = function (tokType, options) {
+        return this.consumeInternal(tokType, 2, options);
+    };
+    RecognizerApi.prototype.CONSUME3 = function (tokType, options) {
+        return this.consumeInternal(tokType, 3, options);
+    };
+    RecognizerApi.prototype.CONSUME4 = function (tokType, options) {
+        return this.consumeInternal(tokType, 4, options);
+    };
+    RecognizerApi.prototype.CONSUME5 = function (tokType, options) {
+        return this.consumeInternal(tokType, 5, options);
+    };
+    RecognizerApi.prototype.CONSUME6 = function (tokType, options) {
+        return this.consumeInternal(tokType, 6, options);
+    };
+    RecognizerApi.prototype.CONSUME7 = function (tokType, options) {
+        return this.consumeInternal(tokType, 7, options);
+    };
+    RecognizerApi.prototype.CONSUME8 = function (tokType, options) {
+        return this.consumeInternal(tokType, 8, options);
+    };
+    RecognizerApi.prototype.CONSUME9 = function (tokType, options) {
+        return this.consumeInternal(tokType, 9, options);
+    };
+    RecognizerApi.prototype.SUBRULE = function (ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 0, options);
+    };
+    RecognizerApi.prototype.SUBRULE1 = function (ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 1, options);
+    };
+    RecognizerApi.prototype.SUBRULE2 = function (ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 2, options);
+    };
+    RecognizerApi.prototype.SUBRULE3 = function (ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 3, options);
+    };
+    RecognizerApi.prototype.SUBRULE4 = function (ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 4, options);
+    };
+    RecognizerApi.prototype.SUBRULE5 = function (ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 5, options);
+    };
+    RecognizerApi.prototype.SUBRULE6 = function (ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 6, options);
+    };
+    RecognizerApi.prototype.SUBRULE7 = function (ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 7, options);
+    };
+    RecognizerApi.prototype.SUBRULE8 = function (ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 8, options);
+    };
+    RecognizerApi.prototype.SUBRULE9 = function (ruleToCall, options) {
+        return this.subruleInternal(ruleToCall, 9, options);
+    };
+    RecognizerApi.prototype.OPTION = function (actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 0);
+    };
+    RecognizerApi.prototype.OPTION1 = function (actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 1);
+    };
+    RecognizerApi.prototype.OPTION2 = function (actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 2);
+    };
+    RecognizerApi.prototype.OPTION3 = function (actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 3);
+    };
+    RecognizerApi.prototype.OPTION4 = function (actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 4);
+    };
+    RecognizerApi.prototype.OPTION5 = function (actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 5);
+    };
+    RecognizerApi.prototype.OPTION6 = function (actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 6);
+    };
+    RecognizerApi.prototype.OPTION7 = function (actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 7);
+    };
+    RecognizerApi.prototype.OPTION8 = function (actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 8);
+    };
+    RecognizerApi.prototype.OPTION9 = function (actionORMethodDef) {
+        return this.optionInternal(actionORMethodDef, 9);
+    };
+    RecognizerApi.prototype.OR = function (altsOrOpts) {
+        return this.orInternal(altsOrOpts, 0);
+    };
+    RecognizerApi.prototype.OR1 = function (altsOrOpts) {
+        return this.orInternal(altsOrOpts, 1);
+    };
+    RecognizerApi.prototype.OR2 = function (altsOrOpts) {
+        return this.orInternal(altsOrOpts, 2);
+    };
+    RecognizerApi.prototype.OR3 = function (altsOrOpts) {
+        return this.orInternal(altsOrOpts, 3);
+    };
+    RecognizerApi.prototype.OR4 = function (altsOrOpts) {
+        return this.orInternal(altsOrOpts, 4);
+    };
+    RecognizerApi.prototype.OR5 = function (altsOrOpts) {
+        return this.orInternal(altsOrOpts, 5);
+    };
+    RecognizerApi.prototype.OR6 = function (altsOrOpts) {
+        return this.orInternal(altsOrOpts, 6);
+    };
+    RecognizerApi.prototype.OR7 = function (altsOrOpts) {
+        return this.orInternal(altsOrOpts, 7);
+    };
+    RecognizerApi.prototype.OR8 = function (altsOrOpts) {
+        return this.orInternal(altsOrOpts, 8);
+    };
+    RecognizerApi.prototype.OR9 = function (altsOrOpts) {
+        return this.orInternal(altsOrOpts, 9);
+    };
+    RecognizerApi.prototype.MANY = function (actionORMethodDef) {
+        this.manyInternal(0, actionORMethodDef);
+    };
+    RecognizerApi.prototype.MANY1 = function (actionORMethodDef) {
+        this.manyInternal(1, actionORMethodDef);
+    };
+    RecognizerApi.prototype.MANY2 = function (actionORMethodDef) {
+        this.manyInternal(2, actionORMethodDef);
+    };
+    RecognizerApi.prototype.MANY3 = function (actionORMethodDef) {
+        this.manyInternal(3, actionORMethodDef);
+    };
+    RecognizerApi.prototype.MANY4 = function (actionORMethodDef) {
+        this.manyInternal(4, actionORMethodDef);
+    };
+    RecognizerApi.prototype.MANY5 = function (actionORMethodDef) {
+        this.manyInternal(5, actionORMethodDef);
+    };
+    RecognizerApi.prototype.MANY6 = function (actionORMethodDef) {
+        this.manyInternal(6, actionORMethodDef);
+    };
+    RecognizerApi.prototype.MANY7 = function (actionORMethodDef) {
+        this.manyInternal(7, actionORMethodDef);
+    };
+    RecognizerApi.prototype.MANY8 = function (actionORMethodDef) {
+        this.manyInternal(8, actionORMethodDef);
+    };
+    RecognizerApi.prototype.MANY9 = function (actionORMethodDef) {
+        this.manyInternal(9, actionORMethodDef);
+    };
+    RecognizerApi.prototype.MANY_SEP = function (options) {
+        this.manySepFirstInternal(0, options);
+    };
+    RecognizerApi.prototype.MANY_SEP1 = function (options) {
+        this.manySepFirstInternal(1, options);
+    };
+    RecognizerApi.prototype.MANY_SEP2 = function (options) {
+        this.manySepFirstInternal(2, options);
+    };
+    RecognizerApi.prototype.MANY_SEP3 = function (options) {
+        this.manySepFirstInternal(3, options);
+    };
+    RecognizerApi.prototype.MANY_SEP4 = function (options) {
+        this.manySepFirstInternal(4, options);
+    };
+    RecognizerApi.prototype.MANY_SEP5 = function (options) {
+        this.manySepFirstInternal(5, options);
+    };
+    RecognizerApi.prototype.MANY_SEP6 = function (options) {
+        this.manySepFirstInternal(6, options);
+    };
+    RecognizerApi.prototype.MANY_SEP7 = function (options) {
+        this.manySepFirstInternal(7, options);
+    };
+    RecognizerApi.prototype.MANY_SEP8 = function (options) {
+        this.manySepFirstInternal(8, options);
+    };
+    RecognizerApi.prototype.MANY_SEP9 = function (options) {
+        this.manySepFirstInternal(9, options);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE = function (actionORMethodDef) {
+        this.atLeastOneInternal(0, actionORMethodDef);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE1 = function (actionORMethodDef) {
+        return this.atLeastOneInternal(1, actionORMethodDef);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE2 = function (actionORMethodDef) {
+        this.atLeastOneInternal(2, actionORMethodDef);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE3 = function (actionORMethodDef) {
+        this.atLeastOneInternal(3, actionORMethodDef);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE4 = function (actionORMethodDef) {
+        this.atLeastOneInternal(4, actionORMethodDef);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE5 = function (actionORMethodDef) {
+        this.atLeastOneInternal(5, actionORMethodDef);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE6 = function (actionORMethodDef) {
+        this.atLeastOneInternal(6, actionORMethodDef);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE7 = function (actionORMethodDef) {
+        this.atLeastOneInternal(7, actionORMethodDef);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE8 = function (actionORMethodDef) {
+        this.atLeastOneInternal(8, actionORMethodDef);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE9 = function (actionORMethodDef) {
+        this.atLeastOneInternal(9, actionORMethodDef);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE_SEP = function (options) {
+        this.atLeastOneSepFirstInternal(0, options);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE_SEP1 = function (options) {
+        this.atLeastOneSepFirstInternal(1, options);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE_SEP2 = function (options) {
+        this.atLeastOneSepFirstInternal(2, options);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE_SEP3 = function (options) {
+        this.atLeastOneSepFirstInternal(3, options);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE_SEP4 = function (options) {
+        this.atLeastOneSepFirstInternal(4, options);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE_SEP5 = function (options) {
+        this.atLeastOneSepFirstInternal(5, options);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE_SEP6 = function (options) {
+        this.atLeastOneSepFirstInternal(6, options);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE_SEP7 = function (options) {
+        this.atLeastOneSepFirstInternal(7, options);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE_SEP8 = function (options) {
+        this.atLeastOneSepFirstInternal(8, options);
+    };
+    RecognizerApi.prototype.AT_LEAST_ONE_SEP9 = function (options) {
+        this.atLeastOneSepFirstInternal(9, options);
+    };
+    RecognizerApi.prototype.RULE = function (name, implementation, config) {
+        if (config === void 0) { config = DEFAULT_RULE_CONFIG; }
+        if (contains(this.definedRulesNames, name)) {
+            var errMsg = defaultGrammarValidatorErrorProvider.buildDuplicateRuleNameError({
+                topLevelRule: name,
+                grammarName: this.className
+            });
+            var error = {
+                message: errMsg,
+                type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
+                ruleName: name
+            };
+            this.definitionErrors.push(error);
+        }
+        this.definedRulesNames.push(name);
+        var ruleImplementation = this.defineRule(name, implementation, config);
+        this[name] = ruleImplementation;
+        return ruleImplementation;
+    };
+    RecognizerApi.prototype.OVERRIDE_RULE = function (name, impl, config) {
+        if (config === void 0) { config = DEFAULT_RULE_CONFIG; }
+        var ruleErrors = [];
+        ruleErrors = ruleErrors.concat(validateRuleIsOverridden(name, this.definedRulesNames, this.className));
+        this.definitionErrors.push.apply(this.definitionErrors, ruleErrors); // mutability for the win
+        var ruleImplementation = this.defineRule(name, impl, config);
+        this[name] = ruleImplementation;
+        return ruleImplementation;
+    };
+    RecognizerApi.prototype.BACKTRACK = function (grammarRule, args) {
+        return function () {
+            // save org state
+            this.isBackTrackingStack.push(1);
+            var orgState = this.saveRecogState();
+            try {
+                grammarRule.apply(this, args);
+                // if no exception was thrown we have succeed parsing the rule.
+                return true;
+            }
+            catch (e) {
+                if (isRecognitionException(e)) {
+                    return false;
+                }
+                else {
+                    throw e;
+                }
+            }
+            finally {
+                this.reloadRecogState(orgState);
+                this.isBackTrackingStack.pop();
+            }
+        };
+    };
+    // GAST export APIs
+    RecognizerApi.prototype.getGAstProductions = function () {
+        return this.gastProductionsCache;
+    };
+    RecognizerApi.prototype.getSerializedGastProductions = function () {
+        return serializeGrammar(values(this.gastProductionsCache));
+    };
+    return RecognizerApi;
+}());
+export { RecognizerApi };
+//# sourceMappingURL=recognizer_api.js.map