Genese complexity report

<- chevrotain.d.ts
Methods : 184
Complexity index : 125.3
Cyclomatic complexity : 168
Cognitive complexity
100 % Correct 184/184
0 % Warning 0/184 (threshold : 10)
0 % Error 0/184 (threshold : 20)
Cyclomatic complexity
100 % Correct 184/184
0 % Warning 0/184 (threshold : 5)
0 % Error 0/184 (threshold : 10)
Methods of chevrotain.d.ts
performSelfAnalysis Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /**
                 * This must be called at the end of a Parser constructor.
                 * See: http://sap.github.io/chevrotain/docs/tutorial/step2_parsing.html#under-the-hood
                 */
                protected performSelfAnalysis(): void // --------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0.4 Cyclomatic complexity 0
                            
                                
                
            
                /**
                 * It is recommended to reuse the same Parser instance
                 * by passing an empty array to the input argument
                 * and only later setting the input by using the input property.
                 * See: http://sap.github.io/chevrotain/docs/FAQ.html#major-performance-benefits
                 *
                 * @param tokenVocabulary - A data structure containing all the Tokens used by the Parser.
                 * @param config - The Parser's configuration.
                 */
                constructor(tokenVocabulary: TokenVocabulary, config?: IParserConfig) // ---------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
reset Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Resets the parser state, should be overridden for custom parsers which "carry" additional state.
                 * When overriding, remember to also invoke the super implementation!
                 */
                reset(): void // --------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getBaseCstVisitorConstructor Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                getBaseCstVisitorConstructor(): { // --------------------- +0.1 Complexity index (+0.1 atomic)
                    new (...args: any[]): ICstVisitor<any, any> // ------- +0.6 Complexity index (+0.6 atomic)
                }
            
                            
                        
getBaseCstVisitorConstructorWithDefaults Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                getBaseCstVisitorConstructorWithDefaults(): { // --------- +0.1 Complexity index (+0.1 atomic)
                    new (...args: any[]): ICstVisitor<any, any> // ------- +0.6 Complexity index (+0.6 atomic)
                }
            
                            
                        
getGAstProductions Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                getGAstProductions(): Record<string, Rule> // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getSerializedGastProductions Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
            
                getSerializedGastProductions(): ISerializedGast[] // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
computeContentAssist Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @param startRuleName
                 * @param precedingInput - The token vector up to (not including) the content assist point
                 */
                computeContentAssist( // ---------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    startRuleName: string, // ----------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    precedingInput: IToken[] // --------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                ): ISyntacticContentAssistPath[] // ----------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
BACKTRACK Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @param grammarRule - The rule to try and parse in backtracking mode.
                 * @param args - argumens to be passed to the grammar rule execution
                 *
                 * @return a lookahead function that will try to parse the given grammarRule and will return true if succeed.
                 */
                protected BACKTRACK<T>( // --------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    grammarRule: (...args: any[]) => T, // ----------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
                    args?: any[] // ---------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                ): () => boolean
            
                            
                        
ACTION Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * The Semantic Actions wrapper.
                 * Should be used to wrap semantic actions that either:
                 * - May fail when executing in "recording phase".
                 * - Have global side effects that should be avoided during "recording phase".
                 *
                 * For more information see:
                 *   - https://sap.github.io/chevrotain/docs/guide/internals.html#grammar-recording
                 */
                protected ACTION<T>(impl: () => T): T // ----------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
consume Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Like `CONSUME` with the numerical suffix as a parameter, e.g:
                 * consume(0, X) === CONSUME(X)
                 * consume(1, X) === CONSUME1(X)
                 * consume(2, X) === CONSUME2(X)
                 * ...
                 * @see CONSUME
                 */
                protected consume( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    idx: number, // ------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // ------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ---------------------------------------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // -------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
option Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Like `OPTION` with the numerical suffix as a parameter, e.g:
                 * option(0, X) === OPTION(X)
                 * option(1, X) === OPTION1(X)
                 * option(2, X) === OPTION2(X)
                 * ...
                 * @see SUBRULE
                 */
                protected option<OUT>( // ------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                    idx: number, // ------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // -------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // ---------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
or Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Like `OR` with the numerical suffix as a parameter, e.g:
                 * or(0, X) === OR(X)
                 * or(1, X) === OR1(X)
                 * or(2, X) === OR2(X)
                 * ...
                 * @see OR
                 */
                protected or(idx: number, altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
many Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Like `MANY` with the numerical suffix as a parameter, e.g:
                 * many(0, X) === MANY(X)
                 * many(1, X) === MANY1(X)
                 * many(2, X) === MANY2(X)
                 * ...
                 * @see MANY
                 */
                protected many( // ----------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    idx: number, // ---------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ------------ +0.6 Complexity index (+0.6 atomic)
                ): void // ------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
atLeastOne Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Like `AT_LEAST_ONE` with the numerical suffix as a parameter, e.g:
                 * atLeastOne(0, X) === AT_LEAST_ONE(X)
                 * atLeastOne(1, X) === AT_LEAST_ONE1(X)
                 * atLeastOne(2, X) === AT_LEAST_ONE2(X)
                 * ...
                 * @see AT_LEAST_ONE
                 */
                protected atLeastOne( // ------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    idx: number, // ------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // --------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
CONSUME Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 *
                 * A Parsing DSL method use to consume a single Token.
                 * In EBNF terms this is equivalent to a Terminal.
                 *
                 * A Token will be consumed, IFF the next token in the token vector matches <tokType>.
                 * otherwise the parser may attempt to perform error recovery (if enabled).
                 *
                 * The index in the method name indicates the unique occurrence of a terminal consumption
                 * inside a the top level rule. What this means is that if a terminal appears
                 * more than once in a single rule, each appearance must have a **different** index.
                 *
                 * For example:
                 * ```
                 *   this.RULE("qualifiedName", () => {
                 *   this.CONSUME1(Identifier);
                 *     this.MANY(() => {
                 *       this.CONSUME1(Dot);
                 *       // here we use CONSUME2 because the terminal
                 *       // 'Identifier' has already appeared previously in the
                 *       // the rule 'parseQualifiedName'
                 *       this.CONSUME2(Identifier);
                 *     });
                 *   })
                 * ```
                 *
                 * - See more details on the [unique suffixes requirement](http://sap.github.io/chevrotain/docs/FAQ.html#NUMERICAL_SUFFIXES).
                 *
                 * @param tokType - The Type of the token to be consumed.
                 * @param options - optional properties to modify the behavior of CONSUME.
                 */
                protected CONSUME( // ------------------------------------------------------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // ------------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ----------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // --------------------------------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
CONSUME1 Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see CONSUME
                 * @hidden
                 */
                protected CONSUME1( // ------------------- +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // --------------- +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
CONSUME2 Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see CONSUME
                 * @hidden
                 */
                protected CONSUME2( // ------------------- +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // --------------- +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
CONSUME3 Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see CONSUME
                 * @hidden
                 */
                protected CONSUME3( // ------------------- +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // --------------- +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
CONSUME4 Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see CONSUME
                 * @hidden
                 */
                protected CONSUME4( // ------------------- +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // --------------- +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
CONSUME5 Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see CONSUME
                 * @hidden
                 */
                protected CONSUME5( // ------------------- +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // --------------- +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
CONSUME6 Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see CONSUME
                 * @hidden
                 */
                protected CONSUME6( // ------------------- +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // --------------- +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
CONSUME7 Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see CONSUME
                 * @hidden
                 */
                protected CONSUME7( // ------------------- +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // --------------- +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
CONSUME8 Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see CONSUME
                 * @hidden
                 */
                protected CONSUME8( // ------------------- +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // --------------- +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
CONSUME9 Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see CONSUME
                 * @hidden
                 */
                protected CONSUME9( // ------------------- +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType, // --------------- +0.2 Complexity index (+0.2 atomic)
                    options?: ConsumeMethodOpts // ------- +0.2 Complexity index (+0.2 atomic)
                ): IToken // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OPTION Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Parsing DSL Method that Indicates an Optional production.
                 * in EBNF notation this is equivalent to: "[...]".
                 *
                 * Note that there are two syntax forms:
                 * - Passing the grammar action directly:
                 *   ```
                 *     this.OPTION(() => {
                 *       this.CONSUME(Digit)}
                 *     );
                 *   ```
                 *
                 * - using an "options" object:
                 *   ```
                 *     this.OPTION({
                 *       GATE:predicateFunc,
                 *       DEF: () => {
                 *         this.CONSUME(Digit)
                 *     }});
                 *   ```
                 *
                 * The optional 'GATE' property in "options" object form can be used to add constraints
                 * to invoking the grammar action.
                 *
                 * As in CONSUME the index in the method name indicates the occurrence
                 * of the optional production in it's top rule.
                 *
                 * @param  actionORMethodDef - The grammar action to optionally invoke once
                 *                             or an "OPTIONS" object describing the grammar action and optional properties.
                 */
                // TODO: return `OUT | undefined` explicitly
                protected OPTION<OUT>( // --------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // ----------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // ------------------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OPTION1 Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OPTION
                 * @hidden
                 */
                protected OPTION1<OUT>( // ---------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // ------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // --------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OPTION2 Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OPTION
                 * @hidden
                 */
                protected OPTION2<OUT>( // ---------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // ------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // --------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OPTION3 Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OPTION
                 * @hidden
                 */
                protected OPTION3<OUT>( // ---------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // ------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // --------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OPTION4 Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OPTION
                 * @hidden
                 */
                protected OPTION4<OUT>( // ---------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // ------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // --------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OPTION5 Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OPTION
                 * @hidden
                 */
                protected OPTION5<OUT>( // ---------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // ------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // --------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OPTION6 Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OPTION
                 * @hidden
                 */
                protected OPTION6<OUT>( // ---------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // ------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // --------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OPTION7 Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OPTION
                 * @hidden
                 */
                protected OPTION7<OUT>( // ---------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // ------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // --------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OPTION8 Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OPTION
                 * @hidden
                 */
                protected OPTION8<OUT>( // ---------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // ------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // --------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OPTION9 Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OPTION
                 * @hidden
                 */
                protected OPTION9<OUT>( // ---------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT> // ------- +0.6 Complexity index (+0.6 atomic)
                ): OUT // --------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
OR Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Parsing DSL method that indicates a choice between a set of alternatives must be made.
                 * This is equivalent to an EBNF alternation (A | B | C | D ...), except
                 * that the alternatives are ordered like in a PEG grammar.
                 * This means that the **first** matching alternative is always chosen.
                 *
                 * There are several forms for the inner alternatives array:
                 *
                 * - Passing alternatives array directly:
                 *   ```
                 *     this.OR([
                 *       { ALT:() => { this.CONSUME(One) }},
                 *       { ALT:() => { this.CONSUME(Two) }},
                 *       { ALT:() => { this.CONSUME(Three) }}
                 *     ])
                 *   ```
                 *
                 * - Passing alternative array directly with predicates (GATE):
                 *   ```
                 *     this.OR([
                 *       { GATE: predicateFunc1, ALT:() => { this.CONSUME(One) }},
                 *       { GATE: predicateFuncX, ALT:() => { this.CONSUME(Two) }},
                 *       { GATE: predicateFuncX, ALT:() => { this.CONSUME(Three) }}
                 *     ])
                 *   ```
                 *
                 * - These syntax forms can also be mixed:
                 *   ```
                 *     this.OR([
                 *       {
                 *         GATE: predicateFunc1,
                 *         ALT:() => { this.CONSUME(One) }
                 *       },
                 *       { ALT:() => { this.CONSUME(Two) }},
                 *       { ALT:() => { this.CONSUME(Three) }}
                 *     ])
                 *   ```
                 *
                 * - Additionally an "options" object may be used:
                 *   ```
                 *     this.OR({
                 *       DEF:[
                 *         { ALT:() => { this.CONSUME(One) }},
                 *         { ALT:() => { this.CONSUME(Two) }},
                 *         { ALT:() => { this.CONSUME(Three) }}
                 *       ],
                 *       // OPTIONAL property
                 *       ERR_MSG: "A Number"
                 *     })
                 *   ```
                 *
                 * The 'predicateFuncX' in the long form can be used to add constraints to choosing the alternative.
                 *
                 * As in CONSUME the index in the method name indicates the occurrence
                 * of the alternation production in it's top rule.
                 *
                 * @param altsOrOpts - A set of alternatives or an "OPTIONS" object describing the alternatives and optional properties.
                 *
                 * @returns The result of invoking the chosen alternative.
                 */
                protected OR(altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------------------------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
OR1 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OR
                 * @hidden
                 */
                protected OR1(altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
OR2 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OR
                 * @hidden
                 */
                protected OR2(altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
OR3 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OR
                 * @hidden
                 */
                protected OR3(altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
OR4 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OR
                 * @hidden
                 */
                protected OR4(altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
OR5 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OR
                 * @hidden
                 */
                protected OR5(altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
OR6 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OR
                 * @hidden
                 */
                protected OR6(altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
OR7 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OR
                 * @hidden
                 */
                protected OR7(altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
OR8 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OR
                 * @hidden
                 */
                protected OR8(altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
OR9 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see OR
                 * @hidden
                 */
                protected OR9(altsOrOpts: IOrAlt[] | OrMethodOpts): any // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
MANY Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Parsing DSL method, that indicates a repetition of zero or more.
                 * This is equivalent to EBNF repetition {...}.
                 *
                 * Note that there are two syntax forms:
                 * - Passing the grammar action directly:
                 *   ```
                 *     this.MANY(() => {
                 *       this.CONSUME(Comma)
                 *       this.CONSUME(Digit)
                 *      })
                 *   ```
                 *
                 * - using an "options" object:
                 *   ```
                 *     this.MANY({
                 *       GATE: predicateFunc,
                 *       DEF: () => {
                 *              this.CONSUME(Comma)
                 *              this.CONSUME(Digit)
                 *            }
                 *     });
                 *   ```
                 *
                 * The optional 'GATE' property in "options" object form can be used to add constraints
                 * to invoking the grammar action.
                 *
                 * As in CONSUME the index in the method name indicates the occurrence
                 * of the repetition production in it's top rule.
                 *
                 * @param actionORMethodDef - The grammar action to optionally invoke multiple times
                 *                             or an "OPTIONS" object describing the grammar action and optional properties.
                 *
                 */
                protected MANY( // ---------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ----------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
                ): void // ------------------------------------------------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
MANY1 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY
                 * @hidden
                 */
                protected MANY1( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // -------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
MANY2 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY
                 * @hidden
                 */
                protected MANY2( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // -------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
MANY3 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY
                 * @hidden
                 */
                protected MANY3( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // -------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
MANY4 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY
                 * @hidden
                 */
                protected MANY4( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // -------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
MANY5 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY
                 * @hidden
                 */
                protected MANY5( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // -------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
MANY6 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY
                 * @hidden
                 */
                protected MANY6( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // -------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
MANY7 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY
                 * @hidden
                 */
                protected MANY7( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // -------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
MANY8 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY
                 * @hidden
                 */
                protected MANY8( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // -------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
MANY9 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY
                 * @hidden
                 */
                protected MANY9( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // -------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
MANY_SEP Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Parsing DSL method, that indicates a repetition of zero or more with a separator
                 * Token between the repetitions.
                 *
                 * Example:
                 *
                 * ```
                 *     this.MANY_SEP({
                 *         SEP:Comma,
                 *         DEF: () => {
                 *             this.CONSUME(Number};
                 *             // ...
                 *         })
                 * ```
                 *
                 * Note that because this DSL method always requires more than one argument the options object is always required
                 * and it is not possible to use a shorter form like in the MANY DSL method.
                 *
                 * Note that for the purposes of deciding on whether or not another iteration exists
                 * Only a single Token is examined (The separator). Therefore if the grammar being implemented is
                 * so "crazy" to require multiple tokens to identify an item separator please use the more basic DSL methods
                 * to implement it.
                 *
                 * As in CONSUME the index in the method name indicates the occurrence
                 * of the repetition production in it's top rule.
                 *
                 * @param options - An object defining the grammar of each iteration and the separator between iterations
                 *
                 */
                protected MANY_SEP(options: ManySepMethodOpts<any>): void // --------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
MANY_SEP1 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY_SEP
                 * @hidden
                 */
                protected MANY_SEP1(options: ManySepMethodOpts<any>): void // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
MANY_SEP2 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY_SEP
                 * @hidden
                 */
                protected MANY_SEP2(options: ManySepMethodOpts<any>): void // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
MANY_SEP3 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY_SEP
                 * @hidden
                 */
                protected MANY_SEP3(options: ManySepMethodOpts<any>): void // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
MANY_SEP4 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY_SEP
                 * @hidden
                 */
                protected MANY_SEP4(options: ManySepMethodOpts<any>): void // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
MANY_SEP5 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY_SEP
                 * @hidden
                 */
                protected MANY_SEP5(options: ManySepMethodOpts<any>): void // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
MANY_SEP6 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY_SEP
                 * @hidden
                 */
                protected MANY_SEP6(options: ManySepMethodOpts<any>): void // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
MANY_SEP7 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY_SEP
                 * @hidden
                 */
                protected MANY_SEP7(options: ManySepMethodOpts<any>): void // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
MANY_SEP8 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY_SEP
                 * @hidden
                 */
                protected MANY_SEP8(options: ManySepMethodOpts<any>): void // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
MANY_SEP9 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see MANY_SEP
                 * @hidden
                 */
                protected MANY_SEP9(options: ManySepMethodOpts<any>): void // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
AT_LEAST_ONE Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Convenience method, same as MANY but the repetition is of one or more.
                 * failing to match at least one repetition will result in a parsing error and
                 * cause a parsing error.
                 *
                 * @see MANY
                 *
                 * @param actionORMethodDef  - The grammar action to optionally invoke multiple times
                 *                             or an "OPTIONS" object describing the grammar action and optional properties.
                 *
                 */
                protected AT_LEAST_ONE( // -------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ---------------------------------------------- +0.6 Complexity index (+0.6 atomic)
                ): void // ------------------------------------------------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE1 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE
                 * @hidden
                 */
                protected AT_LEAST_ONE1( // ---------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // --------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE2 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE
                 * @hidden
                 */
                protected AT_LEAST_ONE2( // ---------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // --------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE3 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE
                 * @hidden
                 */
                protected AT_LEAST_ONE3( // ---------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // --------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE4 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE
                 * @hidden
                 */
                protected AT_LEAST_ONE4( // ---------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // --------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE5 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE
                 * @hidden
                 */
                protected AT_LEAST_ONE5( // ---------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // --------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE6 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE
                 * @hidden
                 */
                protected AT_LEAST_ONE6( // ---------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // --------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE7 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE
                 * @hidden
                 */
                protected AT_LEAST_ONE7( // ---------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // --------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE8 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE
                 * @hidden
                 */
                protected AT_LEAST_ONE8( // ---------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // --------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE9 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE
                 * @hidden
                 */
                protected AT_LEAST_ONE9( // ---------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any> // ------- +0.6 Complexity index (+0.6 atomic)
                ): void // --------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE_SEP Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Convenience method, same as MANY_SEP but the repetition is of one or more.
                 * failing to match at least one repetition will result in a parsing error and
                 * cause the parser to attempt error recovery.
                 *
                 * Note that an additional optional property ERR_MSG can be used to provide custom error messages.
                 *
                 * @see MANY_SEP
                 *
                 * @param options - An object defining the grammar of each iteration and the separator between iterations
                 *
                 * @return {ISeparatedIterationResult<OUT>}
                 */
                protected AT_LEAST_ONE_SEP( // ------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    options: AtLeastOneSepMethodOpts<any> // ----------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                ): void // --------------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE_SEP1 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE_SEP
                 * @hidden
                 */
                protected AT_LEAST_ONE_SEP1( // -------------------- +0.1 Complexity index (+0.1 atomic)
                    options: AtLeastOneSepMethodOpts<any> // ------- +0.3 Complexity index (+0.3 atomic)
                ): void // ----------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE_SEP2 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE_SEP
                 * @hidden
                 */
                protected AT_LEAST_ONE_SEP2( // -------------------- +0.1 Complexity index (+0.1 atomic)
                    options: AtLeastOneSepMethodOpts<any> // ------- +0.3 Complexity index (+0.3 atomic)
                ): void // ----------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE_SEP3 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE_SEP
                 * @hidden
                 */
                protected AT_LEAST_ONE_SEP3( // -------------------- +0.1 Complexity index (+0.1 atomic)
                    options: AtLeastOneSepMethodOpts<any> // ------- +0.3 Complexity index (+0.3 atomic)
                ): void // ----------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE_SEP4 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE_SEP
                 * @hidden
                 */
                protected AT_LEAST_ONE_SEP4( // -------------------- +0.1 Complexity index (+0.1 atomic)
                    options: AtLeastOneSepMethodOpts<any> // ------- +0.3 Complexity index (+0.3 atomic)
                ): void // ----------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE_SEP5 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE_SEP
                 * @hidden
                 */
                protected AT_LEAST_ONE_SEP5( // -------------------- +0.1 Complexity index (+0.1 atomic)
                    options: AtLeastOneSepMethodOpts<any> // ------- +0.3 Complexity index (+0.3 atomic)
                ): void // ----------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE_SEP6 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE_SEP
                 * @hidden
                 */
                protected AT_LEAST_ONE_SEP6( // -------------------- +0.1 Complexity index (+0.1 atomic)
                    options: AtLeastOneSepMethodOpts<any> // ------- +0.3 Complexity index (+0.3 atomic)
                ): void // ----------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE_SEP7 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE_SEP
                 * @hidden
                 */
                protected AT_LEAST_ONE_SEP7( // -------------------- +0.1 Complexity index (+0.1 atomic)
                    options: AtLeastOneSepMethodOpts<any> // ------- +0.3 Complexity index (+0.3 atomic)
                ): void // ----------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE_SEP8 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE_SEP
                 * @hidden
                 */
                protected AT_LEAST_ONE_SEP8( // -------------------- +0.1 Complexity index (+0.1 atomic)
                    options: AtLeastOneSepMethodOpts<any> // ------- +0.3 Complexity index (+0.3 atomic)
                ): void // ----------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
AT_LEAST_ONE_SEP9 Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see AT_LEAST_ONE_SEP
                 * @hidden
                 */
                protected AT_LEAST_ONE_SEP9( // -------------------- +0.1 Complexity index (+0.1 atomic)
                    options: AtLeastOneSepMethodOpts<any> // ------- +0.3 Complexity index (+0.3 atomic)
                ): void // ----------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getTokenToInsert Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Returns an "imaginary" Token to insert when Single Token Insertion is done
                 * Override this if you require special behavior in your grammar.
                 * For example if an IntegerToken is required provide one with the image '0' so it would be valid syntactically.
                 */
                protected getTokenToInsert(tokType: TokenType): IToken // ----------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
canTokenTypeBeInsertedInRecovery Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * By default all tokens type may be inserted. This behavior may be overridden in inheriting Recognizers
                 * for example: One may decide that only punctuation tokens may be inserted automatically as they have no additional
                 * semantic value. (A mandatory semicolon has no additional semantic meaning, but an Integer may have additional meaning
                 * depending on its int value and context (Inserting an integer 0 in cardinality: "[1..]" will cause semantic issues
                 * as the max of the cardinality will be greater than the min value (and this is a false error!).
                 */
                protected canTokenTypeBeInsertedInRecovery( // ------------------------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
                    tokType: TokenType // --------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                ): boolean
            
                            
                        
getNextPossibleTokenTypes Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @deprecated - will be removed in the future
                 */
                protected getNextPossibleTokenTypes( // ----------------- +0.1 Complexity index (+0.1 atomic)
                    grammarPath: ITokenGrammarPath // ------------------- +0.2 Complexity index (+0.2 atomic)
                ): TokenType[] // --------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
SKIP_TOKEN Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
            
                protected SKIP_TOKEN(): IToken // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
LA Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Look-Ahead for the Token Vector
                 * LA(1) is the next Token ahead.
                 * LA(n) is the nth Token ahead.
                 * LA(0) is the previously consumed Token.
                 *
                 * Looking beyond the end of the Token Vector or before its begining
                 * will return in an IToken of type EOF {@link EOF}.
                 * This behavior can be used to avoid infinite loops.
                 *
                 * This is often used to implement custom lookahead logic for GATES.
                 * https://sap.github.io/chevrotain/docs/features/gates.html
                 */
                protected LA(howMuch: number): IToken // -------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
performSelfAnalysis Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * @deprecated use {@link Parser.performSelfAnalysis} **instance** method instead.
                 */
                protected static performSelfAnalysis(parserInstance: Parser): void // ----------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
RULE Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 *
                 * @param name - The name of the rule.
                 * @param implementation - The implementation of the rule.
                 * @param [config] - The rule's optional configuration.
                 *
                 * @returns - The parsing rule which is the production implementation wrapped with the parsing logic that handles
                 *                     Parser state / error recovery&reporting/ ...
                 */
                protected RULE<T>( // ------------------------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                    name: string, // ------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    implementation: (...implArgs: any[]) => T, // -------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
                    config?: IRuleConfig<T> // --------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                ): (idxInCallingRule?: number, ...args: any[]) => T | any // --------------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
OVERRIDE_RULE Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Same as {@link Parser.RULE}, but should only be used in
                 * "extending" grammars to override rules/productions from the super grammar.
                 * See [Parser Inheritance Example](https://github.com/SAP/chevrotain/tree/master/examples/parser/inheritance).
                 */
                protected OVERRIDE_RULE<T>( // ------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    name: string, // ----------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    impl: (...implArgs: any[]) => T, // ---------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
                    config?: IRuleConfig<T> // ------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                ): (idxInCallingRule?: number, ...args: any[]) => T | any // ------------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
SUBRULE Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                protected SUBRULE<T>( // ------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ----------------------------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // --------------------------------- +0.2 Complexity index (+0.2 atomic)
                ): T // ------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE1 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE1<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE2 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE2<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE3 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE3<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE4 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE4<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE5 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE5<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE6 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE6<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE7 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE7<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE8 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE8<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE9 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE9<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
performSelfAnalysis Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                // TODO: remove `outputCST` from the config options in the constructor
                /**
                 * @deprecated use {@link Parser.performSelfAnalysis} **instance** method instead.
                 */
                protected static performSelfAnalysis(parserInstance: Parser): void // ----------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
RULE Complexity Index 1.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Creates a Grammar Rule
                 */
                protected RULE( // ---------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    name: string, // -------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    implementation: (...implArgs: any[]) => any, // ------------------------- +0.5 Complexity index (+0.5 atomic)
                    config?: IRuleConfig<CstNode> // ---------------------------------------- +0.3 Complexity index (+0.3 atomic)
                ): (idxInCallingRule?: number, ...args: any[]) => CstNode // ---------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
OVERRIDE_RULE Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Overrides a Grammar Rule
                 * See usage example in: https://github.com/SAP/chevrotain/blob/master/examples/parser/versioning/versioning.js
                 */
                protected OVERRIDE_RULE<T>( // ------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    name: string, // ----------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    implementation: (...implArgs: any[]) => any, // ---------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
                    config?: IRuleConfig<CstNode> // ------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                ): (idxInCallingRule?: number, ...args: any[]) => CstNode // ------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
subrule Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Like `SUBRULE` with the numerical suffix as a parameter, e.g:
                 * subrule(0, X) === SUBRULE(X)
                 * subrule(1, X) === SUBRULE1(X)
                 * subrule(2, X) === SUBRULE2(X)
                 * ...
                 * @see SUBRULE
                 */
                protected subrule( // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    idx: number, // ------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // ------------------------------ +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ---------------------------------------- +0.2 Complexity index (+0.2 atomic)
                ): CstNode // ------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * The Parsing DSL Method is used by one rule to call another.
                 * It is equivalent to a non-Terminal in EBNF notation.
                 *
                 * This may seem redundant as it does not actually do much.
                 * However using it is **mandatory** for all sub rule invocations.
                 *
                 * Calling another rule without wrapping in SUBRULE(...)
                 * will cause errors/mistakes in the Parser's self analysis phase,
                 * which will lead to errors in error recovery/automatic lookahead calculation
                 * and any other functionality relying on the Parser's self analysis
                 * output.
                 *
                 * As in CONSUME the index in the method name indicates the occurrence
                 * of the sub rule invocation in its rule.
                 *
                 */
                protected SUBRULE( // ------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // -------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                ): CstNode // --------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE1 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE1( // ----------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------------- +0.2 Complexity index (+0.2 atomic)
                ): CstNode // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE2 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE2( // ----------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------------- +0.2 Complexity index (+0.2 atomic)
                ): CstNode // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE3 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE3( // ----------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------------- +0.2 Complexity index (+0.2 atomic)
                ): CstNode // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE4 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE4( // ----------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------------- +0.2 Complexity index (+0.2 atomic)
                ): CstNode // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE5 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE5( // ----------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------------- +0.2 Complexity index (+0.2 atomic)
                ): CstNode // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE6 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE6( // ----------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------------- +0.2 Complexity index (+0.2 atomic)
                ): CstNode // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE7 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE7( // ----------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------------- +0.2 Complexity index (+0.2 atomic)
                ): CstNode // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE8 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE8( // ----------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------------- +0.2 Complexity index (+0.2 atomic)
                ): CstNode // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE9 Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE9( // ----------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => CstNode, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------------- +0.2 Complexity index (+0.2 atomic)
                ): CstNode // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
performSelfAnalysis Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * @deprecated use {@link Parser.performSelfAnalysis} **instance** method instead.
                 */
                protected static performSelfAnalysis(parserInstance: Parser): void // ----------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
RULE Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
                
            
                // TODO: remove `outputCST` from the config options in the constructor
            
                /**
                 * Creates a Grammar Rule
                 */
                protected RULE<T>( // ----------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    name: string, // ------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                    implementation: (...implArgs: any[]) => T, // ------------------------------- +0.5 Complexity index (+0.5 atomic)
                    config?: IRuleConfig<T> // -------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                ): (idxInCallingRule?: number, ...args: any[]) => T // -------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
OVERRIDE_RULE Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Overrides a Grammar Rule
                 * See usage example in: https://github.com/SAP/chevrotain/blob/master/examples/parser/versioning/versioning.js
                 */
                protected OVERRIDE_RULE<T>( // ------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    name: string, // ----------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    impl: (...implArgs: any[]) => T, // ---------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
                    config?: IRuleConfig<T> // ------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                ): (idxInCallingRule?: number, ...args: any[]) => T // ------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
subrule Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Like `SUBRULE` with the numerical suffix as a parameter, e.g:
                 * subrule(0, X) === SUBRULE(X)
                 * subrule(1, X) === SUBRULE1(X)
                 * subrule(2, X) === SUBRULE2(X)
                 * ...
                 * @see SUBRULE
                 */
                protected subrule<T>( // -------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    idx: number, // ------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    ruleToCall: (idx: number) => T, // ------------------------------------ +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ---------------------------------------- +0.2 Complexity index (+0.2 atomic)
                ): T // ------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * The Parsing DSL Method is used by one rule to call another.
                 * It is equivalent to a non-Terminal in EBNF notation.
                 *
                 * This may seem redundant as it does not actually do much.
                 * However using it is **mandatory** for all sub rule invocations.
                 *
                 * Calling another rule without wrapping in SUBRULE(...)
                 * will cause errors/mistakes in the Parser's self analysis phase,
                 * which will lead to errors in error recovery/automatic lookahead calculation
                 * and any other functionality relying on the Parser's self analysis
                 * output.
                 *
                 * As in CONSUME the index in the method name indicates the occurrence
                 * of the sub rule invocation in its rule.
                 *
                 */
                protected SUBRULE<T>( // ---------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // -------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                ): T // --------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE1 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE1<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE2 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE2<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE3 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE3<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE4 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE4<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE5 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE5<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE6 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE6<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE7 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE7<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE8 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE8<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
SUBRULE9 Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * @see SUBRULE
                 * @hidden
                 */
                protected SUBRULE9<T>( // -------------------- +0.2 Complexity index (+0.2 atomic)
                    ruleToCall: (idx: number) => T, // ------- +0.3 Complexity index (+0.3 atomic)
                    options?: SubruleMethodOpts // ----------- +0.2 Complexity index (+0.2 atomic)
                ): T // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
Complexity Index 0.7 Cyclomatic complexity 0
                            
                                
                
            
                /**
                 * @param lexerDefinition -
                 *  Structure composed of Tokens Types this lexer will identify.
                 *
                 *  In the simple case the structure is an array of TokenTypes.
                 *  In the case of {@link IMultiModeLexerDefinition} the structure is an object with two properties:
                 *    1. a "modes" property where each value is an array of TokenTypes.
                 *    2. a "defaultMode" property specifying the initial lexer mode.
                 *
                 *  for example:
                 *
                 *  ```
                 *    {
                 *        modes : {
                 *          modeX : [Token1, Token2],
                 *          modeY : [Token3, Token4]
                 *        },
                 *
                 *        defaultMode : "modeY"
                 *    }
                 *  ```
                 *
                 *  A lexer with {@link MultiModesDefinition} is simply multiple Lexers where only one Lexer(mode) can be active at the same time.
                 *  This is useful for lexing languages where there are different lexing rules depending on context.
                 *
                 *  The current lexing mode is selected via a "mode stack".
                 *  The last (peek) value in the stack will be the current mode of the lexer.
                 *  Defining entering and exiting lexer modes is done using the "push_mode" and "pop_mode" properites
                 *  of the {@link createToken.config} parameter.
                 *
                 *  - The Lexer will match the **first** pattern that matches, Therefor the order of Token Types is significant.
                 *    For example when one pattern may match a prefix of another pattern.
                 *
                 *    Note that there are situations in which we may wish to order the longer pattern after the shorter one.
                 *    For example: [keywords vs Identifiers](https://github.com/SAP/chevrotain/tree/master/examples/lexer/keywords_vs_identifiers).
                 */
                constructor(
                    lexerDefinition: TokenType[] | IMultiModeLexerDefinition, // ----------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
                    config?: ILexerConfig // ----------------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                )
            
                            
                        
tokenize Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Will lex(Tokenize) a string.
                 * Note that this can be called repeatedly on different strings as this method
                 * does not modify the state of the Lexer.
                 *
                 * @param text - The string to lex
                 * @param [initialMode] - The initial Lexer Mode to start with, by default this will be the first mode in the lexer's
                 *                                 definition. If the lexer has no explicit modes it will be the implicit single 'default_mode' mode.
                 */
                tokenize(text: string, initialMode?: string): ILexingResult // --------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
createToken Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Creates a new TokenType which can then be used
             * to define a Lexer and Parser
             */
            export declare function createToken(config: ITokenConfig): TokenType // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
createTokenInstance Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Utility to create Chevrotain IToken "instances"
             * Note that Chevrotain tokens are not real TokenTypes instances
             * and thus the instanceOf cannot be used with them.
             */
            export declare function createTokenInstance( // ------------------------------- +0.1 Complexity index (+0.1 atomic)
                tokType: TokenType, // ---------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                image: string, // --------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                startOffset: number, // --------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                endOffset: number, // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                startLine: number, // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                endLine: number, // ------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                startColumn: number, // --------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                endColumn: number // ------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            ): IToken // ------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
tokenName Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
            
            export declare function tokenName(tokType: TokenType): string // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
tokenLabel Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
            
            /**
             *  Returns a human readable label for a TokenType if such exists,
             *  otherwise will return the TokenType's name.
             *
             *  Labels are useful in improving the readability of error messages and syntax diagrams.
             *  To define labels provide the label property in the {@link createToken} config parameter.
             */
            export declare function tokenLabel(tokType: TokenType): string // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
tokenMatcher Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * A Utility method to check if a token is of the type of the argument Token class.
             * This utility is needed because Chevrotain tokens support "categories" which means
             * A TokenType may have multiple categories.
             *
             * This means a simple comparison using the {@link IToken.tokenType} property may not suffice.
             * For example:
             *
             * ```
             *   import { createToken, tokenMatcher, Lexer } from "chevrotain"
             *
             *   // An "abstract" Token used only for categorization purposes.
             *   const NumberTokType = createToken({ name: "NumberTokType", pattern: Lexer.NA })
             *
             *   const IntegerTokType = createToken({
             *     name: "IntegerTokType",
             *     pattern: /\d+/,
             *     // Integer "Is A" Number
             *     categories: [NumberTokType]
             *   })
             *
             *   const DecimalTokType = createToken({
             *     name: "DecimalTokType",
             *     pattern: /\d+\.\d+/,
             *     // Double "Is A" Number
             *     categories: [NumberTokType]
             *   })
             *
             *   // Will always be false as the tokenType property can only
             *   // be Integer or Double Token Types as the Number TokenType is "abstract".
             *   if (myToken.tokenType === NumberTokType) { /* ... *\/ }
             *
             *   // Will be true when myToken is of Type Integer or Double.
             *   // Because the hierarchy defined by the categories is taken into account.
             *   if (tokenMatcher(myToken, NumberTokType) { /* ... *\/ }
             * ```
             *
             * @returns true iff the token matches the TokenType.
             */
            export function tokenMatcher(token: IToken, tokType: TokenType): boolean // ----------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
EMPTY_ALT Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Convenience used to express an **empty** alternative in an OR (alternation).
             * can be used to more clearly describe the intent in a case of empty alternation.
             *
             * For example:
             *
             * 1. without using EMPTY_ALT:
             *  ```
             *    this.OR([
             *      {ALT: () => {
             *        this.CONSUME1(OneTok)
             *        return "1"
             *      }},
             *      {ALT: () => {
             *        this.CONSUME1(TwoTok)
             *        return "2"
             *      }},
             *      // implicitly empty because there are no invoked grammar
             *      // rules (OR/MANY/CONSUME...) inside this alternative.
             *      {ALT: () => {
             *        return "666"
             *      }},
             *    ])
             *  ```
             *
             * 2. using EMPTY_ALT:
             *  ```
             *    this.OR([
             *      {ALT: () => {
             *        this.CONSUME1(OneTok)
             *        return "1"
             *      }},
             *      {ALT: () => {
             *        this.CONSUME1(TwoTok)
             *        return "2"
             *      }},
             *      // explicitly empty, clearer intent
             *      {ALT: EMPTY_ALT("666")},
             *    ])
             *  ```
             */
            export declare function EMPTY_ALT<T>(value?: T): () => T // --------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isRecognitionException Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * A utility to detect if an Error is a Chevrotain Parser's runtime exception.
             */
            export declare function isRecognitionException(error: Error): boolean // ---------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0.6 Cyclomatic complexity 0
                            
                                
            
                constructor(message: string, token: IToken, previousToken: IToken) // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
Complexity Index 0.6 Cyclomatic complexity 0
                            
                                
            
                constructor(message: string, token: IToken, previousToken: IToken) // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
Complexity Index 0.4 Cyclomatic complexity 0
                            
                                
            
                constructor(message: string, token: IToken) // ----------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.6 Cyclomatic complexity 0
                            
                                
            
                constructor(message: string, token: IToken, previousToken: IToken) // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
visit Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                visit(node: IProduction): any // --------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
visitNonTerminal Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                abstract visitNonTerminal(node: NonTerminal): any // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
visitFlat Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                abstract visitFlat(node: Flat): any // --------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
visitOption Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                abstract visitOption(node: Option): any // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
visitRepetition Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                abstract visitRepetition(node: Repetition): any // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
visitRepetitionMandatory Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                abstract visitRepetitionMandatory(node: RepetitionMandatory): any // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
visitRepetitionMandatoryWithSeparator Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                abstract visitRepetitionMandatoryWithSeparator( // ------------------------- +0.1 Complexity index (+0.1 atomic)
                    node: RepetitionMandatoryWithSeparator // ------------------------------ +0.2 Complexity index (+0.2 atomic)
                ): any // ------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
visitRepetitionWithSeparator Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                abstract visitRepetitionWithSeparator(node: RepetitionWithSeparator): any // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
visitAlternation Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                abstract visitAlternation(node: Alternation): any // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
visitTerminal Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                abstract visitTerminal(node: Terminal): any // ------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
visitRule Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                abstract visitRule(node: Rule): any // --------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.8 Cyclomatic complexity 0
                            
                                
                
            
                constructor(options: { // -------------- +0.1 Complexity index (+0.1 atomic)
                    name: string // -------------------- +0.2 Complexity index (+0.2 atomic)
                    definition: IProduction[] // ------- +0.3 Complexity index (+0.3 atomic)
                    orgText?: string // ---------------- +0.2 Complexity index (+0.2 atomic)
                })
            
                            
                        
accept Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                accept(visitor: IGASTVisitor): void // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.6 Cyclomatic complexity 0
                            
                                
                
                constructor(options: { // ------------ +0.1 Complexity index (+0.1 atomic)
                    nonTerminalName: string // ------- +0.2 Complexity index (+0.2 atomic)
                    referencedRule?: Rule // --------- +0.2 Complexity index (+0.2 atomic)
                    idx?: number // ------------------ +0.1 Complexity index (+0.1 atomic)
                })
            
                            
                        
accept Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                accept(visitor: IGASTVisitor): void // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.6 Cyclomatic complexity 0
                            
                                
                
            
                constructor(options: { definition: IProduction[]; name?: string }) // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
accept Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                accept(visitor: IGASTVisitor): void // -------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.7 Cyclomatic complexity 0
                            
                                
                
            
                constructor(options: { // -------------- +0.1 Complexity index (+0.1 atomic)
                    definition: IProduction[] // ------- +0.3 Complexity index (+0.3 atomic)
                    idx?: number // -------------------- +0.1 Complexity index (+0.1 atomic)
                    name?: string // ------------------- +0.2 Complexity index (+0.2 atomic)
                })
            
                            
                        
accept Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                accept(visitor: IGASTVisitor): void // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.7 Cyclomatic complexity 0
                            
                                
                
            
                constructor(options: { // -------------- +0.1 Complexity index (+0.1 atomic)
                    definition: IProduction[] // ------- +0.3 Complexity index (+0.3 atomic)
                    idx?: number // -------------------- +0.1 Complexity index (+0.1 atomic)
                    name?: string // ------------------- +0.2 Complexity index (+0.2 atomic)
                })
            
                            
                        
accept Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                accept(visitor: IGASTVisitor): void // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.9 Cyclomatic complexity 0
                            
                                
                
            
                constructor(options: { // -------------- +0.1 Complexity index (+0.1 atomic)
                    definition: IProduction[] // ------- +0.3 Complexity index (+0.3 atomic)
                    separator: TokenType // ------------ +0.2 Complexity index (+0.2 atomic)
                    idx?: number // -------------------- +0.1 Complexity index (+0.1 atomic)
                    name?: string // ------------------- +0.2 Complexity index (+0.2 atomic)
                })
            
                            
                        
accept Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                accept(visitor: IGASTVisitor): void // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.7 Cyclomatic complexity 0
                            
                                
                
            
                constructor(options: { // -------------- +0.1 Complexity index (+0.1 atomic)
                    definition: IProduction[] // ------- +0.3 Complexity index (+0.3 atomic)
                    idx?: number // -------------------- +0.1 Complexity index (+0.1 atomic)
                    name?: string // ------------------- +0.2 Complexity index (+0.2 atomic)
                })
            
                            
                        
accept Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                accept(visitor: IGASTVisitor): void // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.9 Cyclomatic complexity 0
                            
                                
                
            
                constructor(options: { // -------------- +0.1 Complexity index (+0.1 atomic)
                    definition: IProduction[] // ------- +0.3 Complexity index (+0.3 atomic)
                    separator: TokenType // ------------ +0.2 Complexity index (+0.2 atomic)
                    idx?: number // -------------------- +0.1 Complexity index (+0.1 atomic)
                    name?: string // ------------------- +0.2 Complexity index (+0.2 atomic)
                })
            
                            
                        
accept Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                accept(visitor: IGASTVisitor): void // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.7 Cyclomatic complexity 0
                            
                                
                
            
                constructor(options: { // -------------- +0.1 Complexity index (+0.1 atomic)
                    definition: IProduction[] // ------- +0.3 Complexity index (+0.3 atomic)
                    idx?: number // -------------------- +0.1 Complexity index (+0.1 atomic)
                    name?: string // ------------------- +0.2 Complexity index (+0.2 atomic)
                })
            
                            
                        
accept Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
            
                accept(visitor: IGASTVisitor): void // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.4 Cyclomatic complexity 0
                            
                                
                
                constructor(options: { terminalType: TokenType; idx?: number }) // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
accept Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                accept(visitor: IGASTVisitor): void // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
serializeGrammar Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Serialize a Grammar to a JSON Object.
             *
             * This can be useful for scenarios requiring exporting the grammar structure
             * for example drawing syntax diagrams.
             */
            export declare function serializeGrammar(topRules: Rule[]): ISerializedGast[] // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
serializeProduction Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Like {@link serializeGrammar} but for a single GAST Production instead of a set of Rules.
             */
            export declare function serializeProduction(node: IProduction): ISerializedGast // -------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
resolveGrammar Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * A utility to resolve a grammar AST (rules parameter).
             * "Resolving" means assigning the appropiate value for all {@link NonTerminal.referencedRule}
             * properties in the grammar AST.
             *
             * - See detailed docs for [Custom APIs](http://sap.github.io/chevrotain/docs/guide/custom_apis.html)
             */
            export declare function resolveGrammar(options: { // ----------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                rules: Rule[] // ------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                errMsgProvider?: IGrammarResolverErrorMessageProvider // --------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            }): IParserDefinitionError[] // -------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
validateGrammar Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * A utility to validate a grammar AST (rules parameter).
             * For example: left recursion detection, ambiguity detection, ...
             *
             * - See detailed docs for [Custom APIs](http://sap.github.io/chevrotain/docs/guide/custom_apis.html)
             */
            export declare function validateGrammar(options: { // ---------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                rules: Rule[] // ------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                /**
                 * The maximum lookahead used in the grammar.
                 * This number is needed to perform ambiguity detection.
                 */
                maxLookahead: number // ------------------------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
                /**
                 * The Token Types used by the grammar.
                 */
                tokenTypes: TokenType[] // --------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                grammarName: string // ------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                errMsgProvider: IGrammarValidatorErrorMessageProvider // --------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                ignoredIssues?: IgnoredParserIssues // --------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            }): IParserDefinitionError[] // -------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
assignOccurrenceIndices Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * A utility for assigning unique occurence indices to a grammar AST (rules parameter).
             * This can be useful when using Chevrotain to create custom APIs.
             *
             * - FAQ: [Why are these unique occurences needed](http://sap.github.io/chevrotain/docs/FAQ.html#NUMERICAL_SUFFIXES)
             * - See detailed docs for [Custom APIs](http://sap.github.io/chevrotain/docs/guide/custom_apis.html)
             */
            export declare function assignOccurrenceIndices(options: { // ----------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                rules: Rule[] // ---------------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            }): void // ------------------------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
clearCache Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * @deprecated
             * This function no longer does anything, Avoid using this function
             * As it will be removed in future versions.
             */
            export declare function clearCache(): void // -------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
createSyntaxDiagramsCode Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Will generate an html source code (text).
             * This html text will render syntax diagrams for the provided grammar.
             *
             * - See detailed docs for [Syntax Diagrams](http://sap.github.io/chevrotain/docs/guide/generating_syntax_diagrams.html).
             */
            export declare function createSyntaxDiagramsCode( // ------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                grammar: ISerializedGast[], // ------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                config?: ICreateSyntaxDiagramsConfig // ---------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            ): string // ----------------------------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
generateParserFactory Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Generate A Parser factory from a set of Rules.
             *
             * This variant will Create a factory function that once invoked with a IParserConfig will return
             * a Parser Object.
             *
             * - Note that this happens using the Function constructor (a type of "eval") so it will not work in environments
             *   where content security policy is enabled, such as certain websites, Chrome extensions ect...
             *
             *   This means this function is best used for development flows to reduce the feedback loops
             *   or for productive flows targeting node.js only.
             *
             *   For productive flows targeting a browser runtime see {@link generateParserModule}.
             *
             * - See detailed docs for [Custom APIs](http://sap.github.io/chevrotain/docs/guide/custom_apis.html).
             */
            export declare function generateParserFactory(options: { // ---------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                name: string // -------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                rules: Rule[] // ------------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                tokenVocabulary: TokenVocabulary // ------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            }): (config?: IParserConfig) => Parser // ---------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
generateParserModule Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Generate A Parser's text from a set of Rules.
             *
             * This variant will generate the **string literal** for a UMD module https://github.com/umdjs/umd
             * That exports a Parser Constructor.
             *
             * - Note that the constructor exposed by the generated module must receive the TokenVocabulary as the first
             *   argument, the IParser config can be passed as the second argument.
             *
             * - See detailed docs for [Custom APIs](http://sap.github.io/chevrotain/docs/guide/custom_apis.html).
             */
            export declare function generateParserModule(options: { // ------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                name: string // --------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                rules: Rule[] // -------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            }): string // --------------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)