@traqula/core 0.0.1-alpha.137

package/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © 2024–now Jitse De Smet
+Comunica Association and Ghent University – imec, Belgium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+# TRAQULA core package
+
+TRAQULA core contains core components of traqula.
+Most importantly, its `lexer-builder` and `grammar-builder`.
+This library heavily relies on the amazing [chevrotain package](https://chevrotain.io/docs/).
+Knowing the basics of that package will allow you to quickly generate your own grammars
+
+## Installation
+
+```bash
+npm install @traqula/core
+```
+
+or
+
+```bash
+yarn add @traqula/core
+```
+
+## Usage
+
+Each parser contains two steps: 
+1. a lexer
+2. a grammar + abstract syntax tree generation step.
+
+Sometimes grammar definitions and abstract syntax tree generation is split into separate steps. 
+In this library, we choose to keep the two together.
+
+### Lexer Builder
+
+To tackle the first step, a lexer should be created.
+This is a system that separates different groups of characters into annotated groups.
+In human language for example the sentence 'I eat apples' is lexed into different groups called **tokens** namely `words` and `spaces`:
+`I`, ` `, `eat`, ` `, `apples`.
+
+To create a token definition, you use the provided function `createToken` like:
+```typescript
+const select = createToken({ name: 'Select', pattern: /select/i, label: 'SELECT' });
+```
+
+Lexer definitions are then put in a list and when a lexer is build, the lexer will match a string to the first token in the list that matches.
+Note that the order of definitions in the list is thus essential.
+
+We therefore use a `lexer-builder` which allows you to easily:
+1. change the order of lexer rules,
+2. and create a new lexer staring from an existing one.
+
+Creating a builder is as easy as:
+
+```typescript
+const sparql11Tokens = LexerBuilder.create(<const> [select, describe]);
+```
+
+A new lexer can be created from an existing one by calling:
+```typescript
+const sparql11AdjustTokens = sparql11Tokens.addBefore(select, BuiltInAdjust);
+```
+
+### Grammar Builder
+
+The grammar builder is used to link together grammar rules such that they can be converted into a parser.
+Grammar rule definitions come in the form of `RuleDef` objects.
+Each `RuleDef` object contains its name and its returnType.
+Optionally, it can also contain arguments that should be provided to the SUBRULE calls.
+A simple example of a grammar rule is the rule bellow that allows you to parse booleanLiterals.
+
+```typescript
+/**
+ * Parses a boolean literal.
+ * [[134]](https://www.w3.org/TR/sparql11-query/#rBooleanLiteral)
+ */
+export const booleanLiteral: RuleDef<'booleanLiteral', LiteralTerm> = <const> {
+    name: 'booleanLiteral',
+    impl: ({ CONSUME, OR, context }) => () => OR([
+      { ALT: () => context.dataFactory.literal(
+          CONSUME(l.true_).image.toLowerCase(),
+          context.dataFactory.namedNode(CommonIRIs.BOOLEAN),
+        ) },
+      { ALT: () => context.dataFactory.literal(
+          CONSUME(l.false_).image.toLowerCase(),
+          context.dataFactory.namedNode(CommonIRIs.BOOLEAN),
+        ) },
+    ]),
+  };
+```
+
+The `impl` member of `RuleDef` is a function that receives:
+1. essential functions to create a grammar rule (capitalized members),
+2. a context object that can be used by the rules,
+3. a cache object ([WeakMap](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap)) that can be used to cache the creation of long lists in the parser. 
+
+As a warning, we advise against unpacking the context entry in the function definition itself.
+Doing so will cause the unpacked entries to be captured in the closure which will cause unwanted behaviour since the context entry can be reset between runs.
+
+The result of an `impl` call is a function called a `rule`.
+Rules can be [parameterized](https://chevrotain.io/docs/features/parameterized_rules.html), although I have not found a scenario where that is usefully.
+Personally I create a function that can be used to create multiple `RuleDef` objects.  
+The result of a rule should match the type provided in the `RuleDef` definition, and is the result of a call of `SUBRULE` with that rule.
+
+### Patching rules
+
+When a rule definition calls to a subrule using `SUBRULE(mySub)`, the implementation itself is not necessarily called.
+That is because the SUBRULE function will call the function with the same name as `mySub` that is present in the current grammarBuilder.
+
+A builder is thus free to override definitions as it pleases. Doing so does however **break the types** and should thus only be done with care.
+An example patch is:
+
+```typescript
+const myBuilder = Builder
+  .createBuilder(<const> [selectOrDescribe, selectRule, describeRule])
+  .patchRule(selectRuleAlternative);
+```
+
+When `selectOrDescribe` calls what it thinks to be `selectRule`,
+it will instead call `selectRuleAlternative` since it overwrote the function `selectRule` with the same name. 

package/lib/Wildcard.d.ts

@@ -0,0 +1,9 @@
+export declare class Wildcard {
+    value: "*";
+    termType: "Wildcard";
+    constructor();
+    equals(other: {
+        termType: unknown;
+    } | undefined | null): boolean;
+    toJSON(): object;
+}

package/lib/Wildcard.js

@@ -0,0 +1,19 @@
+export class Wildcard {
+    constructor() {
+        this.value = '*';
+        this.termType = 'Wildcard';
+        // eslint-disable-next-line no-constructor-return
+        return WILDCARD ?? this;
+    }
+    equals(other) {
+        return Boolean(other && (this.termType === other.termType));
+    }
+    toJSON() {
+        // eslint-disable-next-line unused-imports/no-unused-vars
+        const { value, ...rest } = this;
+        return rest;
+    }
+}
+let WILDCARD;
+WILDCARD = new Wildcard();
+//# sourceMappingURL=Wildcard.js.map

package/lib/Wildcard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wildcard.js","sourceRoot":"","sources":["Wildcard.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,QAAQ;IAGnB;QAFO,UAAK,GAAW,GAAG,CAAC;QACpB,aAAQ,GAAW,UAAU,CAAC;QAEnC,iDAAiD;QACjD,OAAO,QAAQ,IAAI,IAAI,CAAC;IAC1B,CAAC;IAEM,MAAM,CAAC,KAA+C;QAC3D,OAAO,OAAO,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC9D,CAAC;IAEM,MAAM;QACX,yDAAyD;QACzD,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAED,IAAI,QAA8B,CAAC;AACnC,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC","sourcesContent":["export class Wildcard {\n  public value = <const> '*';\n  public termType = <const> 'Wildcard';\n  public constructor() {\n    // eslint-disable-next-line no-constructor-return\n    return WILDCARD ?? this;\n  }\n\n  public equals(other: { termType: unknown } | undefined | null): boolean {\n    return Boolean(other && (this.termType === other.termType));\n  }\n\n  public toJSON(): object {\n    // eslint-disable-next-line unused-imports/no-unused-vars\n    const { value, ...rest } = this;\n    return rest;\n  }\n}\n\nlet WILDCARD: Wildcard | undefined;\nWILDCARD = new Wildcard();\n"]}

package/lib/grammar-builder/builderTypes.d.ts

@@ -0,0 +1,19 @@
+import type { ParserMethod } from 'chevrotain';
+import type { RuleDef } from './ruleDefTypes';
+export type RuleNamesFromList<T extends readonly RuleDef[]> = T[number]['name'];
+export type RuleDefMap<RuleNames extends string> = {
+    [Key in RuleNames]: RuleDef<Key>;
+};
+export type CheckOverlap<T, U, V, W = never> = T & U extends never ? V : W;
+/**
+ * Convert a list of RuleDefs to a Record with the name of the RuleDef as the key, matching the RuleDefMap type.
+ */
+export type RuleListToObject<T extends readonly RuleDef[], Agg extends Record<string, RuleDef> = Record<never, never>> = T extends readonly [infer First, ...infer Rest] ? (First extends RuleDef ? (Rest extends readonly RuleDef[] ? (RuleListToObject<Rest, {
+    [K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K];
+}>) : never) : never) : Agg;
+export type ParserFromRules<Names extends string, RuleDefs extends RuleDefMap<Names>> = {
+    [K in Names]: RuleDefs[K] extends RuleDef<K, infer RET, infer ARGS> ? (...args: ARGS) => RET : never;
+};
+export type ParseMethodsFromRules<Names extends string, RuleDefs extends RuleDefMap<Names>> = {
+    [K in Names]: RuleDefs[K] extends RuleDef<K, infer RET, infer ARGS> ? ParserMethod<ARGS, RET> : never;
+};

package/lib/grammar-builder/builderTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=builderTypes.js.map

package/lib/grammar-builder/builderTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builderTypes.js","sourceRoot":"","sources":["builderTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { ParserMethod } from 'chevrotain';\nimport type { RuleDef } from './ruleDefTypes';\n\nexport type RuleNamesFromList<T extends readonly RuleDef[]> = T[number]['name'];\n\nexport type RuleDefMap<RuleNames extends string> = {[Key in RuleNames]: RuleDef<Key> };\n\nexport type CheckOverlap<T, U, V, W = never> = T & U extends never ? V : W;\n\n/**\n * Convert a list of RuleDefs to a Record with the name of the RuleDef as the key, matching the RuleDefMap type.\n */\nexport type RuleListToObject<\n  T extends readonly RuleDef[],\n  Agg extends Record<string, RuleDef> = Record<never, never>,\n> = T extends readonly [infer First, ...infer Rest] ? (\n  First extends RuleDef ? (\n    Rest extends readonly RuleDef[] ? (\n      RuleListToObject<Rest, {[K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K] }>\n    ) : never\n  ) : never\n) : Agg;\n\nexport type ParserFromRules<Names extends string, RuleDefs extends RuleDefMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends RuleDef<K, infer RET, infer ARGS> ? (...args: ARGS) => RET : never\n};\n\nexport type ParseMethodsFromRules<Names extends string, RuleDefs extends RuleDefMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends RuleDef<K, infer RET, infer ARGS> ? ParserMethod<ARGS, RET> : never\n};\n"]}

package/lib/grammar-builder/parserBuilder.d.ts

@@ -0,0 +1,33 @@
+import type { ILexerConfig, IParserConfig } from '@chevrotain/types';
+import type { TokenType, TokenVocabulary } from 'chevrotain';
+import { EmbeddedActionsParser } from 'chevrotain';
+import type { CheckOverlap, RuleDefMap, ParserFromRules, RuleListToObject, RuleNamesFromList, ParseMethodsFromRules } from './builderTypes';
+import type { ImplArgs, RuleDef } from './ruleDefTypes';
+export declare class Builder<Names extends string, RuleDefs extends RuleDefMap<Names>> {
+    static createBuilder<Rules extends readonly RuleDef[] = RuleDef[], Names extends string = RuleNamesFromList<Rules>, RuleDefs extends RuleDefMap<Names> = RuleListToObject<Rules>>(start: Rules | Builder<Names, RuleDefs>): Builder<Names, RuleDefs>;
+    private rules;
+    private constructor();
+    patchRule<U extends Names, RET, ARGS extends unknown[]>(patch: RuleDef<U, RET, ARGS>): Builder<Names, {
+        [Key in Names]: Key extends U ? RuleDef<Key, RET, ARGS> : RuleDefs[Key];
+    }>;
+    addRuleRedundant<U extends string, RET, ARGS extends undefined[]>(rule: RuleDef<U, RET, ARGS>): Builder<Names | U, {
+        [K in Names | U]: K extends U ? RuleDef<K, RET, ARGS> : RuleDefs[K];
+    }>;
+    addRule<U extends string, RET, ARGS extends unknown[]>(rule: CheckOverlap<U, Names, RuleDef<U, RET, ARGS>>): Builder<Names | U, {
+        [K in Names | U]: K extends U ? RuleDef<K, RET, ARGS> : RuleDefs[K];
+    }>;
+    addMany<U extends RuleDef[]>(...rules: CheckOverlap<RuleNamesFromList<U>, Names, U>): Builder<Names | RuleNamesFromList<U>, RuleDefs & RuleListToObject<U>>;
+    deleteRule<U extends Names>(ruleName: U): Builder<Exclude<Names, U>, Omit<RuleDefs, U>>;
+    merge<OtherNames extends string, OtherRules extends RuleDefMap<OtherNames>, OW extends readonly RuleDef[]>(builder: Builder<OtherNames, OtherRules>, overridingRules: OW): Builder<Names | OtherNames | RuleNamesFromList<OW>, {
+        [K in Names | OtherNames | RuleNamesFromList<OW>]: K extends Names | OtherNames ? (K extends Names ? RuleDefs[K] : (K extends OtherNames ? OtherRules[K] : never)) : (K extends keyof RuleListToObject<OW> ? RuleListToObject<OW>[K] : never);
+    }>;
+    consumeToParser({ tokenVocabulary, parserConfig, lexerConfig }: {
+        tokenVocabulary: TokenType[];
+        parserConfig?: IParserConfig;
+        lexerConfig?: ILexerConfig;
+    }, context?: Partial<ImplArgs['context']>): ParserFromRules<Names, RuleDefs>;
+    consume({ tokenVocabulary, config }: {
+        tokenVocabulary: TokenVocabulary;
+        config?: IParserConfig;
+    }, context?: Partial<ImplArgs['context']>): EmbeddedActionsParser & ParseMethodsFromRules<Names, RuleDefs>;
+}

package/lib/grammar-builder/parserBuilder.js

@@ -0,0 +1,365 @@
+import { EmbeddedActionsParser, Lexer } from 'chevrotain';
+import { DataFactory } from 'rdf-data-factory';
+function listToRuleDefMap(rules) {
+    const newRules = {};
+    for (const rule of rules) {
+        newRules[rule.name] = rule;
+    }
+    return newRules;
+}
+export class Builder {
+    static createBuilder(start) {
+        if (start instanceof Builder) {
+            return new Builder({ ...start.rules });
+        }
+        // @ts-expect-error TS2344
+        return new Builder(listToRuleDefMap(start));
+    }
+    constructor(startRules) {
+        this.rules = startRules;
+    }
+    patchRule(patch) {
+        // @ts-expect-error TS2322
+        this.rules[patch.name] = patch;
+        // @ts-expect-error TS2344
+        return this;
+    }
+    addRuleRedundant(rule) {
+        const rules = this.rules;
+        if (rules[rule.name] !== undefined && rules[rule.name] !== rule) {
+            throw new Error(`Rule ${rule.name} already exists in the builder`);
+        }
+        // @ts-expect-error TS2536
+        this.rules[rule.name] = rule;
+        // @ts-expect-error TS2536
+        return this;
+    }
+    addRule(rule) {
+        return this.addRuleRedundant(rule);
+    }
+    addMany(...rules
+    // @ts-expect-error TS2536
+    ) {
+        this.rules = { ...this.rules, ...listToRuleDefMap(rules) };
+        // @ts-expect-error TS2536
+        return this;
+    }
+    deleteRule(ruleName) {
+        delete this.rules[ruleName];
+        // @ts-expect-error TS2536
+        return this;
+    }
+    merge(builder, overridingRules) {
+        // Assume the other grammar is bigger than yours. So start from that one and add this one
+        const otherRules = { ...builder.rules };
+        const myRules = this.rules;
+        for (const rule of Object.values(myRules)) {
+            if (otherRules[rule.name] === undefined) {
+                otherRules[rule.name] = rule;
+            }
+            else {
+                const existingRule = otherRules[rule.name];
+                // If same rule, no issue, move on. Else
+                if (existingRule !== rule) {
+                    const override = overridingRules.find(x => x.name === rule.name);
+                    // If override specified, take override, else, inform user that there is a conflict
+                    if (override) {
+                        otherRules[rule.name] = override;
+                    }
+                    else {
+                        throw new Error(`Rule with name "${rule.name}" already exists in the builder, specify an override to resolve conflict`);
+                    }
+                }
+            }
+        }
+        // @ts-expect-error TS2322
+        this.rules = otherRules;
+        // @ts-expect-error TS2322
+        return this;
+    }
+    consumeToParser({ tokenVocabulary, parserConfig = {}, lexerConfig = {} }, context = {}) {
+        const lexer = new Lexer(tokenVocabulary, {
+            positionTracking: 'onlyStart',
+            recoveryEnabled: false,
+            // SafeMode: true,
+            // SkipValidations: true,
+            ensureOptimizations: true,
+            ...lexerConfig,
+        });
+        const parser = this.consume({ tokenVocabulary, config: parserConfig }, context);
+        const selfSufficientParser = {};
+        // eslint-disable-next-line ts/no-unnecessary-type-assertion
+        for (const rule of Object.values(this.rules)) {
+            // @ts-expect-error TS7053
+            selfSufficientParser[rule.name] = (input, ...args) => {
+                // Transform input in accordance to 19.2
+                input = input.replaceAll(/\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{8})/gu, (_, unicode4, unicode8) => {
+                    if (unicode4) {
+                        const charCode = Number.parseInt(unicode4, 16);
+                        return String.fromCodePoint(charCode);
+                    }
+                    const charCode = Number.parseInt(unicode8, 16);
+                    if (charCode < 0xFFFF) {
+                        return String.fromCodePoint(charCode);
+                    }
+                    const substractedCharCode = charCode - 0x10000;
+                    return String.fromCodePoint(0xD800 + (substractedCharCode >> 10), 0xDC00 + (substractedCharCode & 0x3FF));
+                });
+                // Test for invalid unicode surrogate pairs
+                if (/[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/u.test(input)) {
+                    throw new Error(`Invalid unicode codepoint of surrogate pair without corresponding codepoint`);
+                }
+                const lexResult = lexer.tokenize(input);
+                // Console.log(lexResult.tokens);
+                parser.reset();
+                parser.input = lexResult.tokens;
+                const result = parser[rule.name](...args);
+                if (parser.errors.length > 0) {
+                    // Console.log(lexResult.tokens);
+                    throw new Error(`Parse error on line ${parser.errors.map(x => x.token.startLine).join(', ')}
+${parser.errors.map(x => `${x.token.startLine}: ${x.message}`).join('\n')}`);
+                }
+                return result;
+            };
+        }
+        return selfSufficientParser;
+    }
+    consume({ tokenVocabulary, config = {} }, context = {}) {
+        const rules = this.rules;
+        class MyParser extends EmbeddedActionsParser {
+            constructor() {
+                super(tokenVocabulary, {
+                    // RecoveryEnabled: true,
+                    maxLookahead: 2,
+                    // SkipValidations: true,
+                    ...config,
+                });
+                const selfRef = this.getSelfRef();
+                // Remember to change the reset function accordingly!
+                this.initialParseContext = {
+                    dataFactory: new DataFactory({ blankNodePrefix: 'g_' }),
+                    baseIRI: undefined,
+                    flushedBlankNodeLabels: new Set(),
+                    usedBlankNodeLabels: new Set(),
+                    parseMode: new Set(),
+                    skipValidation: false,
+                    ...context,
+                    prefixes: context.prefixes ? { ...context.prefixes } : {},
+                };
+                this.runningContext = {
+                    ...this.initialParseContext,
+                    prefixes: { ...this.initialParseContext.prefixes },
+                    parseMode: new Set(this.initialParseContext.parseMode),
+                };
+                const implArgs = {
+                    ...selfRef,
+                    cache: new WeakMap(),
+                    context: this.runningContext,
+                };
+                for (const rule of Object.values(rules)) {
+                    // @ts-expect-error TS7053
+                    this[rule.name] = this.RULE(rule.name, rule.impl(implArgs));
+                }
+                this.performSelfAnalysis();
+            }
+            reset() {
+                super.reset();
+                // We need to keep the original object reference.
+                Object.assign(this.runningContext, {
+                    ...this.initialParseContext,
+                });
+                this.runningContext.prefixes = { ...this.initialParseContext.prefixes };
+                this.runningContext.parseMode = new Set(this.initialParseContext.parseMode);
+                this.runningContext.usedBlankNodeLabels.clear();
+                this.runningContext.flushedBlankNodeLabels.clear();
+            }
+            getSelfRef() {
+                return {
+                    CONSUME: (tokenType, option) => this.CONSUME(tokenType, option),
+                    CONSUME1: (tokenType, option) => this.CONSUME1(tokenType, option),
+                    CONSUME2: (tokenType, option) => this.CONSUME2(tokenType, option),
+                    CONSUME3: (tokenType, option) => this.CONSUME3(tokenType, option),
+                    CONSUME4: (tokenType, option) => this.CONSUME4(tokenType, option),
+                    CONSUME5: (tokenType, option) => this.CONSUME5(tokenType, option),
+                    CONSUME6: (tokenType, option) => this.CONSUME6(tokenType, option),
+                    CONSUME7: (tokenType, option) => this.CONSUME7(tokenType, option),
+                    CONSUME8: (tokenType, option) => this.CONSUME8(tokenType, option),
+                    CONSUME9: (tokenType, option) => this.CONSUME9(tokenType, option),
+                    OPTION: actionORMethodDef => this.OPTION(actionORMethodDef),
+                    OPTION1: actionORMethodDef => this.OPTION1(actionORMethodDef),
+                    OPTION2: actionORMethodDef => this.OPTION2(actionORMethodDef),
+                    OPTION3: actionORMethodDef => this.OPTION3(actionORMethodDef),
+                    OPTION4: actionORMethodDef => this.OPTION4(actionORMethodDef),
+                    OPTION5: actionORMethodDef => this.OPTION5(actionORMethodDef),
+                    OPTION6: actionORMethodDef => this.OPTION6(actionORMethodDef),
+                    OPTION7: actionORMethodDef => this.OPTION7(actionORMethodDef),
+                    OPTION8: actionORMethodDef => this.OPTION8(actionORMethodDef),
+                    OPTION9: actionORMethodDef => this.OPTION9(actionORMethodDef),
+                    OR: altsOrOpts => this.OR(altsOrOpts),
+                    OR1: altsOrOpts => this.OR1(altsOrOpts),
+                    OR2: altsOrOpts => this.OR2(altsOrOpts),
+                    OR3: altsOrOpts => this.OR3(altsOrOpts),
+                    OR4: altsOrOpts => this.OR4(altsOrOpts),
+                    OR5: altsOrOpts => this.OR5(altsOrOpts),
+                    OR6: altsOrOpts => this.OR6(altsOrOpts),
+                    OR7: altsOrOpts => this.OR7(altsOrOpts),
+                    OR8: altsOrOpts => this.OR8(altsOrOpts),
+                    OR9: altsOrOpts => this.OR9(altsOrOpts),
+                    MANY: actionORMethodDef => this.MANY(actionORMethodDef),
+                    MANY1: actionORMethodDef => this.MANY1(actionORMethodDef),
+                    MANY2: actionORMethodDef => this.MANY2(actionORMethodDef),
+                    MANY3: actionORMethodDef => this.MANY3(actionORMethodDef),
+                    MANY4: actionORMethodDef => this.MANY4(actionORMethodDef),
+                    MANY5: actionORMethodDef => this.MANY5(actionORMethodDef),
+                    MANY6: actionORMethodDef => this.MANY6(actionORMethodDef),
+                    MANY7: actionORMethodDef => this.MANY7(actionORMethodDef),
+                    MANY8: actionORMethodDef => this.MANY8(actionORMethodDef),
+                    MANY9: actionORMethodDef => this.MANY9(actionORMethodDef),
+                    MANY_SEP: options => this.MANY_SEP(options),
+                    MANY_SEP1: options => this.MANY_SEP1(options),
+                    MANY_SEP2: options => this.MANY_SEP2(options),
+                    MANY_SEP3: options => this.MANY_SEP3(options),
+                    MANY_SEP4: options => this.MANY_SEP4(options),
+                    MANY_SEP5: options => this.MANY_SEP5(options),
+                    MANY_SEP6: options => this.MANY_SEP6(options),
+                    MANY_SEP7: options => this.MANY_SEP7(options),
+                    MANY_SEP8: options => this.MANY_SEP8(options),
+                    MANY_SEP9: options => this.MANY_SEP9(options),
+                    AT_LEAST_ONE: actionORMethodDef => this.AT_LEAST_ONE(actionORMethodDef),
+                    AT_LEAST_ONE1: actionORMethodDef => this.AT_LEAST_ONE1(actionORMethodDef),
+                    AT_LEAST_ONE2: actionORMethodDef => this.AT_LEAST_ONE2(actionORMethodDef),
+                    AT_LEAST_ONE3: actionORMethodDef => this.AT_LEAST_ONE3(actionORMethodDef),
+                    AT_LEAST_ONE4: actionORMethodDef => this.AT_LEAST_ONE4(actionORMethodDef),
+                    AT_LEAST_ONE5: actionORMethodDef => this.AT_LEAST_ONE5(actionORMethodDef),
+                    AT_LEAST_ONE6: actionORMethodDef => this.AT_LEAST_ONE6(actionORMethodDef),
+                    AT_LEAST_ONE7: actionORMethodDef => this.AT_LEAST_ONE7(actionORMethodDef),
+                    AT_LEAST_ONE8: actionORMethodDef => this.AT_LEAST_ONE8(actionORMethodDef),
+                    AT_LEAST_ONE9: actionORMethodDef => this.AT_LEAST_ONE9(actionORMethodDef),
+                    AT_LEAST_ONE_SEP: options => this.AT_LEAST_ONE_SEP(options),
+                    AT_LEAST_ONE_SEP1: options => this.AT_LEAST_ONE_SEP1(options),
+                    AT_LEAST_ONE_SEP2: options => this.AT_LEAST_ONE_SEP2(options),
+                    AT_LEAST_ONE_SEP3: options => this.AT_LEAST_ONE_SEP3(options),
+                    AT_LEAST_ONE_SEP4: options => this.AT_LEAST_ONE_SEP4(options),
+                    AT_LEAST_ONE_SEP5: options => this.AT_LEAST_ONE_SEP5(options),
+                    AT_LEAST_ONE_SEP6: options => this.AT_LEAST_ONE_SEP6(options),
+                    AT_LEAST_ONE_SEP7: options => this.AT_LEAST_ONE_SEP7(options),
+                    AT_LEAST_ONE_SEP8: options => this.AT_LEAST_ONE_SEP8(options),
+                    AT_LEAST_ONE_SEP9: options => this.AT_LEAST_ONE_SEP9(options),
+                    ACTION: func => this.ACTION(func),
+                    BACKTRACK: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.BACKTRACK(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                    SUBRULE: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.SUBRULE(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                    SUBRULE1: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.SUBRULE1(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                    SUBRULE2: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.SUBRULE2(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                    SUBRULE3: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.SUBRULE3(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                    SUBRULE4: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.SUBRULE4(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                    SUBRULE5: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.SUBRULE5(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                    SUBRULE6: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.SUBRULE6(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                    SUBRULE7: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.SUBRULE7(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                    SUBRULE8: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.SUBRULE8(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                    SUBRULE9: (cstDef, ...args) => {
+                        try {
+                            // @ts-expect-error TS7053
+                            // eslint-disable-next-line ts/no-unsafe-argument
+                            return this.SUBRULE9(this[cstDef.name], { ARGS: args });
+                        }
+                        catch (error) {
+                            throw error;
+                        }
+                    },
+                };
+            }
+        }
+        return new MyParser();
+    }
+}
+//# sourceMappingURL=parserBuilder.js.map