@loopstack/loopstack-studio 0.20.3 → 0.21.0-rc.0

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

@@ -0,0 +1,172 @@
+import isFunction_default from "../../../../../../lodash-es/isFunction.js";
+import isArray_default from "../../../../../../lodash-es/isArray.js";
+import last_default from "../../../../../../lodash-es/last.js";
+import forEach_default from "../../../../../../lodash-es/forEach.js";
+import has_default from "../../../../../../lodash-es/has.js";
+import some_default from "../../../../../../lodash-es/some.js";
+import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal } from "../../../../../../@chevrotain/gast/lib/src/model.js";
+import { augmentTokenTypes, hasShortKeyProperty } from "../../../scan/tokens.js";
+import { Lexer } from "../../../scan/lexer_public.js";
+import { createToken, createTokenInstance } from "../../../scan/tokens_public.js";
+import { BITS_FOR_OCCURRENCE_IDX } from "../../grammar/keys.js";
+import { END_OF_FILE } from "../parser.js";
+var RECORDING_NULL_OBJECT = { description: "This Object indicates the Parser is during Recording Phase" };
+Object.freeze(RECORDING_NULL_OBJECT);
+var HANDLE_SEPARATOR = !0, MAX_METHOD_IDX = 2 ** 8 - 1, RFT = createToken({
+	name: "RECORDING_PHASE_TOKEN",
+	pattern: Lexer.NA
+});
+augmentTokenTypes([RFT]);
+var RECORDING_PHASE_TOKEN = createTokenInstance(RFT, "This IToken indicates the Parser is in Recording Phase\n	See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details", -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	See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
+	children: {}
+}, GastRecorder = class {
+	initGastRecorder(i) {
+		this.recordingProdStack = [], this.RECORDING_PHASE = !1;
+	}
+	enableRecording() {
+		this.RECORDING_PHASE = !0, this.TRACE_INIT("Enable Recording", () => {
+			for (let i = 0; i < 10; i++) {
+				let x = i > 0 ? i : "";
+				this[`CONSUME${x}`] = function(x, S) {
+					return this.consumeInternalRecord(x, i, S);
+				}, this[`SUBRULE${x}`] = function(x, S) {
+					return this.subruleInternalRecord(x, i, S);
+				}, this[`OPTION${x}`] = function(x) {
+					return this.optionInternalRecord(x, i);
+				}, this[`OR${x}`] = function(x) {
+					return this.orInternalRecord(x, i);
+				}, this[`MANY${x}`] = function(x) {
+					this.manyInternalRecord(i, x);
+				}, this[`MANY_SEP${x}`] = function(x) {
+					this.manySepFirstInternalRecord(i, x);
+				}, this[`AT_LEAST_ONE${x}`] = function(x) {
+					this.atLeastOneInternalRecord(i, x);
+				}, this[`AT_LEAST_ONE_SEP${x}`] = function(x) {
+					this.atLeastOneSepFirstInternalRecord(i, x);
+				};
+			}
+			this.consume = function(i, x, S) {
+				return this.consumeInternalRecord(x, i, S);
+			}, this.subrule = function(i, x, S) {
+				return this.subruleInternalRecord(x, i, S);
+			}, this.option = function(i, x) {
+				return this.optionInternalRecord(x, i);
+			}, this.or = function(i, x) {
+				return this.orInternalRecord(x, i);
+			}, this.many = function(i, x) {
+				this.manyInternalRecord(i, x);
+			}, this.atLeastOne = function(i, x) {
+				this.atLeastOneInternalRecord(i, x);
+			}, this.ACTION = this.ACTION_RECORD, this.BACKTRACK = this.BACKTRACK_RECORD, this.LA = this.LA_RECORD;
+		});
+	}
+	disableRecording() {
+		this.RECORDING_PHASE = !1, this.TRACE_INIT("Deleting Recording methods", () => {
+			let i = this;
+			for (let x = 0; x < 10; x++) {
+				let S = x > 0 ? x : "";
+				delete i[`CONSUME${S}`], delete i[`SUBRULE${S}`], delete i[`OPTION${S}`], delete i[`OR${S}`], delete i[`MANY${S}`], delete i[`MANY_SEP${S}`], delete i[`AT_LEAST_ONE${S}`], delete i[`AT_LEAST_ONE_SEP${S}`];
+			}
+			delete i.consume, delete i.subrule, delete i.option, delete i.or, delete i.many, delete i.atLeastOne, delete i.ACTION, delete i.BACKTRACK, delete i.LA;
+		});
+	}
+	ACTION_RECORD(i) {}
+	BACKTRACK_RECORD(i, x) {
+		return () => !0;
+	}
+	LA_RECORD(i) {
+		return END_OF_FILE;
+	}
+	topLevelRuleRecord(i, x) {
+		try {
+			let S = new Rule({
+				definition: [],
+				name: i
+			});
+			return S.name = i, this.recordingProdStack.push(S), x.call(this), this.recordingProdStack.pop(), S;
+		} catch (i) {
+			if (i.KNOWN_RECORDER_ERROR !== !0) try {
+				i.message += "\n	 This error was thrown during the \"grammar recording phase\" For more info see:\n	https://chevrotain.io/docs/guide/internals.html#grammar-recording";
+			} catch {
+				throw i;
+			}
+			throw i;
+		}
+	}
+	optionInternalRecord(i, x) {
+		return recordProd.call(this, Option, i, x);
+	}
+	atLeastOneInternalRecord(i, x) {
+		recordProd.call(this, RepetitionMandatory, x, i);
+	}
+	atLeastOneSepFirstInternalRecord(i, x) {
+		recordProd.call(this, RepetitionMandatoryWithSeparator, x, i, HANDLE_SEPARATOR);
+	}
+	manyInternalRecord(i, x) {
+		recordProd.call(this, Repetition, x, i);
+	}
+	manySepFirstInternalRecord(i, x) {
+		recordProd.call(this, RepetitionWithSeparator, x, i, HANDLE_SEPARATOR);
+	}
+	orInternalRecord(i, x) {
+		return recordOrProd.call(this, i, x);
+	}
+	subruleInternalRecord(i, x, C) {
+		if (assertMethodIdxIsValid(x), !i || has_default(i, "ruleName") === !1) {
+			let S = /* @__PURE__ */ Error(`<SUBRULE${getIdxSuffix(x)}> argument is invalid expecting a Parser method reference but got: <${JSON.stringify(i)}>\n inside top level rule: <${this.recordingProdStack[0].name}>`);
+			throw S.KNOWN_RECORDER_ERROR = !0, S;
+		}
+		let T = last_default(this.recordingProdStack), E = i.ruleName, D = new NonTerminal({
+			idx: x,
+			nonTerminalName: E,
+			label: C?.LABEL,
+			referencedRule: void 0
+		});
+		return T.definition.push(D), this.outputCst ? RECORDING_PHASE_CSTNODE : RECORDING_NULL_OBJECT;
+	}
+	consumeInternalRecord(i, x, C) {
+		if (assertMethodIdxIsValid(x), !hasShortKeyProperty(i)) {
+			let S = /* @__PURE__ */ Error(`<CONSUME${getIdxSuffix(x)}> argument is invalid expecting a TokenType reference but got: <${JSON.stringify(i)}>\n inside top level rule: <${this.recordingProdStack[0].name}>`);
+			throw S.KNOWN_RECORDER_ERROR = !0, S;
+		}
+		let w = last_default(this.recordingProdStack), T = new Terminal({
+			idx: x,
+			terminalType: i,
+			label: C?.LABEL
+		});
+		return w.definition.push(T), RECORDING_PHASE_TOKEN;
+	}
+};
+function recordProd(x, C, T, E = !1) {
+	assertMethodIdxIsValid(T);
+	let D = last_default(this.recordingProdStack), O = isFunction_default(C) ? C : C.DEF, k = new x({
+		definition: [],
+		idx: T
+	});
+	return E && (k.separator = C.SEP), has_default(C, "MAX_LOOKAHEAD") && (k.maxLookahead = C.MAX_LOOKAHEAD), this.recordingProdStack.push(k), O.call(this), D.definition.push(k), this.recordingProdStack.pop(), RECORDING_NULL_OBJECT;
+}
+function recordOrProd(O, k) {
+	assertMethodIdxIsValid(k);
+	let A = last_default(this.recordingProdStack), j = isArray_default(O) === !1, M = j === !1 ? O : O.DEF, N = new Alternation({
+		definition: [],
+		idx: k,
+		ignoreAmbiguities: j && O.IGNORE_AMBIGUITIES === !0
+	});
+	return has_default(O, "MAX_LOOKAHEAD") && (N.maxLookahead = O.MAX_LOOKAHEAD), N.hasPredicates = some_default(M, (x) => isFunction_default(x.GATE)), A.definition.push(N), forEach_default(M, (i) => {
+		let x = new Alternative({ definition: [] });
+		N.definition.push(x), has_default(i, "IGNORE_AMBIGUITIES") ? x.ignoreAmbiguities = i.IGNORE_AMBIGUITIES : has_default(i, "GATE") && (x.ignoreAmbiguities = !0), this.recordingProdStack.push(x), i.ALT.call(this), this.recordingProdStack.pop();
+	}), RECORDING_NULL_OBJECT;
+}
+function getIdxSuffix(i) {
+	return i === 0 ? "" : `${i}`;
+}
+function assertMethodIdxIsValid(i) {
+	if (i < 0 || i > MAX_METHOD_IDX) {
+		let x = /* @__PURE__ */ Error(`Invalid DSL Method idx value: <${i}>\n\tIdx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`);
+		throw x.KNOWN_RECORDER_ERROR = !0, x;
+	}
+}
+export { GastRecorder };

package/dist/node_modules/chevrotain/lib/src/parse/parser/traits/lexer_adapter.js

@@ -0,0 +1,39 @@
+import { END_OF_FILE } from "../parser.js";
+var LexerAdapter = class {
+	initLexerAdapter() {
+		this.tokVector = [], this.tokVectorLength = 0, this.currIdx = -1;
+	}
+	set input(e) {
+		if (this.selfAnalysisDone !== !0) throw Error("Missing <performSelfAnalysis> invocation at the end of the Parser's constructor.");
+		this.reset(), this.tokVector = e, this.tokVectorLength = e.length;
+	}
+	get input() {
+		return this.tokVector;
+	}
+	SKIP_TOKEN() {
+		return this.currIdx <= this.tokVector.length - 2 ? (this.consumeToken(), this.LA(1)) : END_OF_FILE;
+	}
+	LA(t) {
+		let n = this.currIdx + t;
+		return n < 0 || this.tokVectorLength <= n ? END_OF_FILE : this.tokVector[n];
+	}
+	consumeToken() {
+		this.currIdx++;
+	}
+	exportLexerState() {
+		return this.currIdx;
+	}
+	importLexerState(e) {
+		this.currIdx = e;
+	}
+	resetLexerState() {
+		this.currIdx = -1;
+	}
+	moveToTerminatedState() {
+		this.currIdx = this.tokVector.length - 1;
+	}
+	getLexerPosition() {
+		return this.exportLexerState();
+	}
+};
+export { LexerAdapter };

package/dist/node_modules/chevrotain/lib/src/parse/parser/traits/looksahead.js

@@ -0,0 +1,109 @@
+import forEach_default from "../../../../../../lodash-es/forEach.js";
+import has_default from "../../../../../../lodash-es/has.js";
+import { GAstVisitor } from "../../../../../../@chevrotain/gast/lib/src/visitor.js";
+import { getProductionDslName } from "../../../../../../@chevrotain/gast/lib/src/helpers.js";
+import { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX, getKeyForAutomaticLookahead } from "../../grammar/keys.js";
+import { LLkLookaheadStrategy } from "../../grammar/llk_lookahead.js";
+import { DEFAULT_PARSER_CONFIG } from "../parser.js";
+var LooksAhead = class {
+	initLooksAhead(e) {
+		this.dynamicTokensEnabled = has_default(e, "dynamicTokensEnabled") ? e.dynamicTokensEnabled : DEFAULT_PARSER_CONFIG.dynamicTokensEnabled, this.maxLookahead = has_default(e, "maxLookahead") ? e.maxLookahead : DEFAULT_PARSER_CONFIG.maxLookahead, this.lookaheadStrategy = has_default(e, "lookaheadStrategy") ? e.lookaheadStrategy : new LLkLookaheadStrategy({ maxLookahead: this.maxLookahead }), this.lookAheadFuncsCache = /* @__PURE__ */ new Map();
+	}
+	preComputeLookaheadFunctions(o) {
+		forEach_default(o, (o) => {
+			this.TRACE_INIT(`${o.name} Rule Lookahead`, () => {
+				let { alternation: s, repetition: d, option: f, repetitionMandatory: p, repetitionMandatoryWithSeparator: m, repetitionWithSeparator: h } = collectMethods(o);
+				forEach_default(s, (e) => {
+					let s = e.idx === 0 ? "" : e.idx;
+					this.TRACE_INIT(`${getProductionDslName(e)}${s}`, () => {
+						let s = this.lookaheadStrategy.buildLookaheadForAlternation({
+							prodOccurrence: e.idx,
+							rule: o,
+							maxLookahead: e.maxLookahead || this.maxLookahead,
+							hasPredicates: e.hasPredicates,
+							dynamicTokensEnabled: this.dynamicTokensEnabled
+						}), c = getKeyForAutomaticLookahead(this.fullRuleNameToShort[o.name], 256, e.idx);
+						this.setLaFuncCache(c, s);
+					});
+				}), forEach_default(d, (e) => {
+					this.computeLookaheadFunc(o, e.idx, 768, "Repetition", e.maxLookahead, getProductionDslName(e));
+				}), forEach_default(f, (e) => {
+					this.computeLookaheadFunc(o, e.idx, 512, "Option", e.maxLookahead, getProductionDslName(e));
+				}), forEach_default(p, (e) => {
+					this.computeLookaheadFunc(o, e.idx, AT_LEAST_ONE_IDX, "RepetitionMandatory", e.maxLookahead, getProductionDslName(e));
+				}), forEach_default(m, (e) => {
+					this.computeLookaheadFunc(o, e.idx, AT_LEAST_ONE_SEP_IDX, "RepetitionMandatoryWithSeparator", e.maxLookahead, getProductionDslName(e));
+				}), forEach_default(h, (e) => {
+					this.computeLookaheadFunc(o, e.idx, MANY_SEP_IDX, "RepetitionWithSeparator", e.maxLookahead, getProductionDslName(e));
+				});
+			});
+		});
+	}
+	computeLookaheadFunc(e, o, s, c, l, u) {
+		this.TRACE_INIT(`${u}${o === 0 ? "" : o}`, () => {
+			let u = this.lookaheadStrategy.buildLookaheadForOptional({
+				prodOccurrence: o,
+				rule: e,
+				maxLookahead: l || this.maxLookahead,
+				dynamicTokensEnabled: this.dynamicTokensEnabled,
+				prodType: c
+			}), d = getKeyForAutomaticLookahead(this.fullRuleNameToShort[e.name], s, o);
+			this.setLaFuncCache(d, u);
+		});
+	}
+	getKeyForAutomaticLookahead(e, o) {
+		return getKeyForAutomaticLookahead(this.getLastExplicitRuleShortName(), e, o);
+	}
+	getLaFuncFromCache(e) {
+		return this.lookAheadFuncsCache.get(e);
+	}
+	/* istanbul ignore next */
+	setLaFuncCache(e, o) {
+		this.lookAheadFuncsCache.set(e, o);
+	}
+}, collectorVisitor = new class extends GAstVisitor {
+	constructor() {
+		super(...arguments), this.dslMethods = {
+			option: [],
+			alternation: [],
+			repetition: [],
+			repetitionWithSeparator: [],
+			repetitionMandatory: [],
+			repetitionMandatoryWithSeparator: []
+		};
+	}
+	reset() {
+		this.dslMethods = {
+			option: [],
+			alternation: [],
+			repetition: [],
+			repetitionWithSeparator: [],
+			repetitionMandatory: [],
+			repetitionMandatoryWithSeparator: []
+		};
+	}
+	visitOption(e) {
+		this.dslMethods.option.push(e);
+	}
+	visitRepetitionWithSeparator(e) {
+		this.dslMethods.repetitionWithSeparator.push(e);
+	}
+	visitRepetitionMandatory(e) {
+		this.dslMethods.repetitionMandatory.push(e);
+	}
+	visitRepetitionMandatoryWithSeparator(e) {
+		this.dslMethods.repetitionMandatoryWithSeparator.push(e);
+	}
+	visitRepetition(e) {
+		this.dslMethods.repetition.push(e);
+	}
+	visitAlternation(e) {
+		this.dslMethods.alternation.push(e);
+	}
+}();
+function collectMethods(e) {
+	collectorVisitor.reset(), e.accept(collectorVisitor);
+	let o = collectorVisitor.dslMethods;
+	return collectorVisitor.reset(), o;
+}
+export { LooksAhead };

package/dist/node_modules/chevrotain/lib/src/parse/parser/traits/perf_tracer.js

@@ -0,0 +1,22 @@
+import has_default from "../../../../../../lodash-es/has.js";
+import { timer } from "../../../../../../@chevrotain/utils/lib/src/timer.js";
+import { DEFAULT_PARSER_CONFIG } from "../parser.js";
+var PerformanceTracer = class {
+	initPerformanceTracer(t) {
+		if (has_default(t, "traceInitPerf")) {
+			let e = t.traceInitPerf, n = typeof e == "number";
+			this.traceInitMaxIdent = n ? e : Infinity, this.traceInitPerf = n ? e > 0 : e;
+		} else this.traceInitMaxIdent = 0, this.traceInitPerf = DEFAULT_PARSER_CONFIG.traceInitPerf;
+		this.traceInitIndent = -1;
+	}
+	TRACE_INIT(e, n) {
+		if (this.traceInitPerf === !0) {
+			this.traceInitIndent++;
+			let r = Array(this.traceInitIndent + 1).join("	");
+			this.traceInitIndent < this.traceInitMaxIdent && console.log(`${r}--> <${e}>`);
+			let { time: i, value: a } = timer(n), o = i > 10 ? console.warn : console.log;
+			return this.traceInitIndent < this.traceInitMaxIdent && o(`${r}<-- <${e}> time: ${i}ms`), this.traceInitIndent--, a;
+		} else return n();
+	}
+};
+export { PerformanceTracer };

package/dist/node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_api.js

@@ -0,0 +1,313 @@
+import values_default from "../../../../../../lodash-es/values.js";
+import includes_default from "../../../../../../lodash-es/includes.js";
+import { serializeGrammar } from "../../../../../../@chevrotain/gast/lib/src/model.js";
+import { defaultGrammarValidatorErrorProvider } from "../../errors_public.js";
+import { validateRuleIsOverridden } from "../../grammar/checks.js";
+import { isRecognitionException } from "../../exceptions_public.js";
+import { DEFAULT_RULE_CONFIG, ParserDefinitionErrorType } from "../parser.js";
+var RecognizerApi = class {
+	ACTION(e) {
+		return e.call(this);
+	}
+	consume(e, i, a) {
+		return this.consumeInternal(i, e, a);
+	}
+	subrule(e, i, a) {
+		return this.subruleInternal(i, e, a);
+	}
+	option(e, i) {
+		return this.optionInternal(i, e);
+	}
+	or(e, i) {
+		return this.orInternal(i, e);
+	}
+	many(e, i) {
+		return this.manyInternal(e, i);
+	}
+	atLeastOne(e, i) {
+		return this.atLeastOneInternal(e, i);
+	}
+	CONSUME(e, i) {
+		return this.consumeInternal(e, 0, i);
+	}
+	CONSUME1(e, i) {
+		return this.consumeInternal(e, 1, i);
+	}
+	CONSUME2(e, i) {
+		return this.consumeInternal(e, 2, i);
+	}
+	CONSUME3(e, i) {
+		return this.consumeInternal(e, 3, i);
+	}
+	CONSUME4(e, i) {
+		return this.consumeInternal(e, 4, i);
+	}
+	CONSUME5(e, i) {
+		return this.consumeInternal(e, 5, i);
+	}
+	CONSUME6(e, i) {
+		return this.consumeInternal(e, 6, i);
+	}
+	CONSUME7(e, i) {
+		return this.consumeInternal(e, 7, i);
+	}
+	CONSUME8(e, i) {
+		return this.consumeInternal(e, 8, i);
+	}
+	CONSUME9(e, i) {
+		return this.consumeInternal(e, 9, i);
+	}
+	SUBRULE(e, i) {
+		return this.subruleInternal(e, 0, i);
+	}
+	SUBRULE1(e, i) {
+		return this.subruleInternal(e, 1, i);
+	}
+	SUBRULE2(e, i) {
+		return this.subruleInternal(e, 2, i);
+	}
+	SUBRULE3(e, i) {
+		return this.subruleInternal(e, 3, i);
+	}
+	SUBRULE4(e, i) {
+		return this.subruleInternal(e, 4, i);
+	}
+	SUBRULE5(e, i) {
+		return this.subruleInternal(e, 5, i);
+	}
+	SUBRULE6(e, i) {
+		return this.subruleInternal(e, 6, i);
+	}
+	SUBRULE7(e, i) {
+		return this.subruleInternal(e, 7, i);
+	}
+	SUBRULE8(e, i) {
+		return this.subruleInternal(e, 8, i);
+	}
+	SUBRULE9(e, i) {
+		return this.subruleInternal(e, 9, i);
+	}
+	OPTION(e) {
+		return this.optionInternal(e, 0);
+	}
+	OPTION1(e) {
+		return this.optionInternal(e, 1);
+	}
+	OPTION2(e) {
+		return this.optionInternal(e, 2);
+	}
+	OPTION3(e) {
+		return this.optionInternal(e, 3);
+	}
+	OPTION4(e) {
+		return this.optionInternal(e, 4);
+	}
+	OPTION5(e) {
+		return this.optionInternal(e, 5);
+	}
+	OPTION6(e) {
+		return this.optionInternal(e, 6);
+	}
+	OPTION7(e) {
+		return this.optionInternal(e, 7);
+	}
+	OPTION8(e) {
+		return this.optionInternal(e, 8);
+	}
+	OPTION9(e) {
+		return this.optionInternal(e, 9);
+	}
+	OR(e) {
+		return this.orInternal(e, 0);
+	}
+	OR1(e) {
+		return this.orInternal(e, 1);
+	}
+	OR2(e) {
+		return this.orInternal(e, 2);
+	}
+	OR3(e) {
+		return this.orInternal(e, 3);
+	}
+	OR4(e) {
+		return this.orInternal(e, 4);
+	}
+	OR5(e) {
+		return this.orInternal(e, 5);
+	}
+	OR6(e) {
+		return this.orInternal(e, 6);
+	}
+	OR7(e) {
+		return this.orInternal(e, 7);
+	}
+	OR8(e) {
+		return this.orInternal(e, 8);
+	}
+	OR9(e) {
+		return this.orInternal(e, 9);
+	}
+	MANY(e) {
+		this.manyInternal(0, e);
+	}
+	MANY1(e) {
+		this.manyInternal(1, e);
+	}
+	MANY2(e) {
+		this.manyInternal(2, e);
+	}
+	MANY3(e) {
+		this.manyInternal(3, e);
+	}
+	MANY4(e) {
+		this.manyInternal(4, e);
+	}
+	MANY5(e) {
+		this.manyInternal(5, e);
+	}
+	MANY6(e) {
+		this.manyInternal(6, e);
+	}
+	MANY7(e) {
+		this.manyInternal(7, e);
+	}
+	MANY8(e) {
+		this.manyInternal(8, e);
+	}
+	MANY9(e) {
+		this.manyInternal(9, e);
+	}
+	MANY_SEP(e) {
+		this.manySepFirstInternal(0, e);
+	}
+	MANY_SEP1(e) {
+		this.manySepFirstInternal(1, e);
+	}
+	MANY_SEP2(e) {
+		this.manySepFirstInternal(2, e);
+	}
+	MANY_SEP3(e) {
+		this.manySepFirstInternal(3, e);
+	}
+	MANY_SEP4(e) {
+		this.manySepFirstInternal(4, e);
+	}
+	MANY_SEP5(e) {
+		this.manySepFirstInternal(5, e);
+	}
+	MANY_SEP6(e) {
+		this.manySepFirstInternal(6, e);
+	}
+	MANY_SEP7(e) {
+		this.manySepFirstInternal(7, e);
+	}
+	MANY_SEP8(e) {
+		this.manySepFirstInternal(8, e);
+	}
+	MANY_SEP9(e) {
+		this.manySepFirstInternal(9, e);
+	}
+	AT_LEAST_ONE(e) {
+		this.atLeastOneInternal(0, e);
+	}
+	AT_LEAST_ONE1(e) {
+		return this.atLeastOneInternal(1, e);
+	}
+	AT_LEAST_ONE2(e) {
+		this.atLeastOneInternal(2, e);
+	}
+	AT_LEAST_ONE3(e) {
+		this.atLeastOneInternal(3, e);
+	}
+	AT_LEAST_ONE4(e) {
+		this.atLeastOneInternal(4, e);
+	}
+	AT_LEAST_ONE5(e) {
+		this.atLeastOneInternal(5, e);
+	}
+	AT_LEAST_ONE6(e) {
+		this.atLeastOneInternal(6, e);
+	}
+	AT_LEAST_ONE7(e) {
+		this.atLeastOneInternal(7, e);
+	}
+	AT_LEAST_ONE8(e) {
+		this.atLeastOneInternal(8, e);
+	}
+	AT_LEAST_ONE9(e) {
+		this.atLeastOneInternal(9, e);
+	}
+	AT_LEAST_ONE_SEP(e) {
+		this.atLeastOneSepFirstInternal(0, e);
+	}
+	AT_LEAST_ONE_SEP1(e) {
+		this.atLeastOneSepFirstInternal(1, e);
+	}
+	AT_LEAST_ONE_SEP2(e) {
+		this.atLeastOneSepFirstInternal(2, e);
+	}
+	AT_LEAST_ONE_SEP3(e) {
+		this.atLeastOneSepFirstInternal(3, e);
+	}
+	AT_LEAST_ONE_SEP4(e) {
+		this.atLeastOneSepFirstInternal(4, e);
+	}
+	AT_LEAST_ONE_SEP5(e) {
+		this.atLeastOneSepFirstInternal(5, e);
+	}
+	AT_LEAST_ONE_SEP6(e) {
+		this.atLeastOneSepFirstInternal(6, e);
+	}
+	AT_LEAST_ONE_SEP7(e) {
+		this.atLeastOneSepFirstInternal(7, e);
+	}
+	AT_LEAST_ONE_SEP8(e) {
+		this.atLeastOneSepFirstInternal(8, e);
+	}
+	AT_LEAST_ONE_SEP9(e) {
+		this.atLeastOneSepFirstInternal(9, e);
+	}
+	RULE(e, a, s = DEFAULT_RULE_CONFIG) {
+		if (includes_default(this.definedRulesNames, e)) {
+			let i = {
+				message: defaultGrammarValidatorErrorProvider.buildDuplicateRuleNameError({
+					topLevelRule: e,
+					grammarName: this.className
+				}),
+				type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
+				ruleName: e
+			};
+			this.definitionErrors.push(i);
+		}
+		this.definedRulesNames.push(e);
+		let c = this.defineRule(e, a, s);
+		return this[e] = c, c;
+	}
+	OVERRIDE_RULE(e, i, a = DEFAULT_RULE_CONFIG) {
+		let o = validateRuleIsOverridden(e, this.definedRulesNames, this.className);
+		this.definitionErrors = this.definitionErrors.concat(o);
+		let c = this.defineRule(e, i, a);
+		return this[e] = c, c;
+	}
+	BACKTRACK(e, i) {
+		return function() {
+			this.isBackTrackingStack.push(1);
+			let a = this.saveRecogState();
+			try {
+				return e.apply(this, i), !0;
+			} catch (e) {
+				if (isRecognitionException(e)) return !1;
+				throw e;
+			} finally {
+				this.reloadRecogState(a), this.isBackTrackingStack.pop();
+			}
+		};
+	}
+	getGAstProductions() {
+		return this.gastProductionsCache;
+	}
+	getSerializedGastProductions() {
+		return serializeGrammar(values_default(this.gastProductionsCache));
+	}
+};
+export { RecognizerApi };