@traqula/core 0.0.1-alpha.143 → 0.0.1-alpha.148

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

@@ -1 +1 @@
-{"version":3,"file":"ruleDefTypes.js","sourceRoot":"","sources":["ruleDefTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type {\n  AtLeastOneSepMethodOpts,\n  DSLMethodOpts,\n  DSLMethodOptsWithErr,\n  GrammarAction,\n  IOrAlt,\n  ManySepMethodOpts,\n  OrMethodOpts,\n} from '@chevrotain/types';\nimport type * as RDF from '@rdfjs/types';\nimport type { ConsumeMethodOpts, IToken, TokenType } from 'chevrotain';\nimport type { DataFactory } from 'rdf-data-factory';\n\nexport type RuleDef<\n  NameType extends string = string,\n  ReturnType = unknown,\n  ParamType extends unknown[] = unknown[],\n> = {\n  name: NameType;\n  impl: (def: ImplArgs) => (...args: ArrayElementsUndefinable<ParamType>) => ReturnType;\n};\n\nexport type RuleDefReturn<T> = T extends RuleDef<any, infer Ret, any> ? Ret : never;\n\ntype ArrayElementsUndefinable<ArrayType extends any[]> =\n  ArrayType extends [infer First, ...infer Rest] ? [First | undefined, ...ArrayElementsUndefinable<Rest>] : [];\n\nexport interface ImplArgs extends CstDef {\n  cache: WeakMap<RuleDef, unknown>;\n  context: {\n    dataFactory: DataFactory<RDF.BaseQuad>;\n    /**\n     * Current scoped prefixes. Used for resolving prefixed names.\n     */\n    prefixes: Record<string, string>;\n    /**\n     * The base IRI for the query. Used for resolving relative IRIs.\n     */\n    baseIRI: string | undefined;\n    /**\n     * Can be used to disable the validation that used variables in a select clause are in scope.\n     */\n    skipValidation: boolean;\n    /**\n     * Set of queryModes. Primarily used for note 8, 14.\n     */\n    parseMode: Set<symbol>;\n  };\n}\n\ntype SubRuleFunc = <T extends string, U = unknown, ARGS extends any[] = []>(\n  cstDef: RuleDef<T, U, ARGS>,\n  ...argument: ARGS\n) => U;\ntype BacktrackFunc = <T extends string, U = unknown, ARGS extends any[] = []>(\n  cstDef: RuleDef<T, U, ARGS>,\n  ...argument: ARGS\n) => () => boolean;\n\nexport interface CstDef {\n  /**\n   *\n   * A Parsing DSL method use to consume a single Token.\n   * In EBNF terms this is equivalent to a Terminal.\n   *\n   * A Token will be consumed, IFF the next token in the token vector matches `tokType`.\n   * otherwise the parser may attempt to perform error recovery (if enabled).\n   *\n   * The index in the method name indicates the unique occurrence of a terminal consumption\n   * inside a the top level rule. What this means is that if a terminal appears\n   * more than once in a single rule, each appearance must have a **different** index.\n   *\n   * For example:\n   * ```\n   *   this.RULE(\"qualifiedName\", () => {\n   *   this.CONSUME1(Identifier);\n   *     this.MANY(() => {\n   *       this.CONSUME1(Dot);\n   *       // here we use CONSUME2 because the terminal\n   *       // 'Identifier' has already appeared previously in the\n   *       // the rule 'parseQualifiedName'\n   *       this.CONSUME2(Identifier);\n   *     });\n   *   })\n   * ```\n   *\n   * - See more details on the [unique suffixes requirement](http://chevrotain.io/docs/FAQ.html#NUMERICAL_SUFFIXES).\n   *\n   * @param tokType - The Type of the token to be consumed.\n   * @param options - optional properties to modify the behavior of CONSUME.\n   */\n  CONSUME: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME1: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME2: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME3: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME4: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME5: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME6: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME7: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME8: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME9: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  /**\n   * Parsing DSL Method that Indicates an Optional production.\n   * in EBNF notation this is equivalent to: \"[...]\".\n   *\n   * Note that there are two syntax forms:\n   * - Passing the grammar action directly:\n   *   ```\n   *     this.OPTION(() => {\n   *       this.CONSUME(Digit)}\n   *     );\n   *   ```\n   *\n   * - using an \"options\" object:\n   *   ```\n   *     this.OPTION({\n   *       GATE:predicateFunc,\n   *       DEF: () => {\n   *         this.CONSUME(Digit)\n   *     }});\n   *   ```\n   *\n   * The optional 'GATE' property in \"options\" object form can be used to add constraints\n   * to invoking the grammar action.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the optional production in it's top rule.\n   *\n   * @param  actionORMethodDef - The grammar action to optionally invoke once\n   *                             or an \"OPTIONS\" object describing the grammar action and optional properties.\n   *\n   * @returns The `GrammarAction` return value (OUT) if the optional syntax is encountered\n   *          or `undefined` if not.\n   */\n  OPTION: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION1: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION2: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION3: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION4: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION5: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION6: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION7: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION8: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION9: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  /**\n   * Parsing DSL method that indicates a choice between a set of alternatives must be made.\n   * This is equivalent to an EBNF alternation (A | B | C | D ...), except\n   * that the alternatives are ordered like in a PEG grammar.\n   * This means that the **first** matching alternative is always chosen.\n   *\n   * There are several forms for the inner alternatives array:\n   *\n   * - Passing alternatives array directly:\n   *   ```\n   *     this.OR([\n   *       { ALT:() => { this.CONSUME(One) }},\n   *       { ALT:() => { this.CONSUME(Two) }},\n   *       { ALT:() => { this.CONSUME(Three) }}\n   *     ])\n   *   ```\n   *\n   * - Passing alternative array directly with predicates (GATE):\n   *   ```\n   *     this.OR([\n   *       { GATE: predicateFunc1, ALT:() => { this.CONSUME(One) }},\n   *       { GATE: predicateFuncX, ALT:() => { this.CONSUME(Two) }},\n   *       { GATE: predicateFuncX, ALT:() => { this.CONSUME(Three) }}\n   *     ])\n   *   ```\n   *\n   * - These syntax forms can also be mixed:\n   *   ```\n   *     this.OR([\n   *       {\n   *         GATE: predicateFunc1,\n   *         ALT:() => { this.CONSUME(One) }\n   *       },\n   *       { ALT:() => { this.CONSUME(Two) }},\n   *       { ALT:() => { this.CONSUME(Three) }}\n   *     ])\n   *   ```\n   *\n   * - Additionally an \"options\" object may be used:\n   *   ```\n   *     this.OR({\n   *       DEF:[\n   *         { ALT:() => { this.CONSUME(One) }},\n   *         { ALT:() => { this.CONSUME(Two) }},\n   *         { ALT:() => { this.CONSUME(Three) }}\n   *       ],\n   *       // OPTIONAL property\n   *       ERR_MSG: \"A Number\"\n   *     })\n   *   ```\n   *\n   * The 'predicateFuncX' in the long form can be used to add constraints to choosing the alternative.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the alternation production in it's top rule.\n   *\n   * @param altsOrOpts - A set of alternatives or an \"OPTIONS\" object describing the alternatives\n   * and optional properties.\n   *\n   * @returns The result of invoking the chosen alternative.\n   */\n  OR: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR1: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR2: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR3: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR4: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR5: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR6: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR7: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR8: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR9: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  /**\n   * Parsing DSL method, that indicates a repetition of zero or more.\n   * This is equivalent to EBNF repetition \\{...\\}.\n   *\n   * Note that there are two syntax forms:\n   * - Passing the grammar action directly:\n   *   ```\n   *     this.MANY(() => {\n   *       this.CONSUME(Comma)\n   *       this.CONSUME(Digit)\n   *      })\n   *   ```\n   *\n   * - using an \"options\" object:\n   *   ```\n   *     this.MANY({\n   *       GATE: predicateFunc,\n   *       DEF: () => {\n   *              this.CONSUME(Comma)\n   *              this.CONSUME(Digit)\n   *            }\n   *     });\n   *   ```\n   *\n   * The optional 'GATE' property in \"options\" object form can be used to add constraints\n   * to invoking the grammar action.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the repetition production in it's top rule.\n   *\n   * @param actionORMethodDef - The grammar action to optionally invoke multiple times\n   *                             or an \"OPTIONS\" object describing the grammar action and optional properties.\n   *\n   */\n  MANY: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY1: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY2: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY3: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY4: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY5: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY6: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY7: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY8: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY9: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  /**\n   * Parsing DSL method, that indicates a repetition of zero or more with a separator\n   * Token between the repetitions.\n   *\n   * Example:\n   *\n   * ```\n   *     this.MANY_SEP({\n   *         SEP:Comma,\n   *         DEF: () => {\n   *             this.CONSUME(Number};\n   *             // ...\n   *         })\n   * ```\n   *\n   * Note that because this DSL method always requires more than one argument the options object is always required\n   * and it is not possible to use a shorter form like in the MANY DSL method.\n   *\n   * Note that for the purposes of deciding on whether or not another iteration exists\n   * Only a single Token is examined (The separator). Therefore if the grammar being implemented is\n   * so \"crazy\" to require multiple tokens to identify an item separator please use the more basic DSL methods\n   * to implement it.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the repetition production in it's top rule.\n   *\n   * @param options - An object defining the grammar of each iteration and the separator between iterations\n   *\n   */\n  MANY_SEP: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP1: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP2: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP3: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP4: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP5: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP6: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP7: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP8: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP9: (options: ManySepMethodOpts<any>) => void;\n  /**\n   * Convenience method, same as MANY but the repetition is of one or more.\n   * failing to match at least one repetition will result in a parsing error and\n   * cause a parsing error.\n   *\n   * @see MANY\n   *\n   * @param actionORMethodDef  - The grammar action to optionally invoke multiple times\n   *                             or an \"OPTIONS\" object describing the grammar action and optional properties.\n   *\n   */\n  AT_LEAST_ONE: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE1: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE2: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE3: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE4: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE5: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE6: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE7: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE8: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE9: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  /**\n   * Convenience method, same as MANY_SEP but the repetition is of one or more.\n   * failing to match at least one repetition will result in a parsing error and\n   * cause the parser to attempt error recovery.\n   *\n   * Note that an additional optional property ERR_MSG can be used to provide custom error messages.\n   *\n   * @see MANY_SEP\n   *\n   * @param options - An object defining the grammar of each iteration and the separator between iterations\n   *\n   * @return {ISeparatedIterationResult<OUT>}\n   */\n  AT_LEAST_ONE_SEP: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP1: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP2: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP3: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP4: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP5: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP6: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP7: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP8: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP9: (options: AtLeastOneSepMethodOpts<any>) => void;\n  ACTION: <T>(impl: () => T) => T;\n  BACKTRACK: BacktrackFunc;\n  SUBRULE: SubRuleFunc;\n  SUBRULE1: SubRuleFunc;\n  SUBRULE2: SubRuleFunc;\n  SUBRULE3: SubRuleFunc;\n  SUBRULE4: SubRuleFunc;\n  SUBRULE5: SubRuleFunc;\n  SUBRULE6: SubRuleFunc;\n  SUBRULE7: SubRuleFunc;\n  SUBRULE8: SubRuleFunc;\n  SUBRULE9: SubRuleFunc;\n}\n"]}
+{"version":3,"file":"ruleDefTypes.js","sourceRoot":"","sources":["ruleDefTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type {\n  AtLeastOneSepMethodOpts,\n  DSLMethodOpts,\n  DSLMethodOptsWithErr,\n  EmbeddedActionsParser,\n  GrammarAction,\n  IOrAlt,\n  ManySepMethodOpts,\n  OrMethodOpts,\n} from '@chevrotain/types';\nimport type {ConsumeMethodOpts, IToken, TokenType} from 'chevrotain';\n\n/**\n * Get the return-type of a RuleDef\n */\nexport type RuleDefReturn<T extends RuleDef> = T extends RuleDef<any, string, infer Ret> ? Ret : never;\n\n/**\n * Type used to declare grammar rules.\n */\nexport type RuleDef<\n  /**\n   * Context object available in rule implementation.\n   */\n  Context = any,\n  /**\n   * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.\n   */\n  NameType extends string = string,\n  /**\n   * Type that will be returned after a correct parse of this rule.\n   * This type will be the return type of calling SUBRULE with this grammar rule.\n   */\n  ReturnType = unknown,\n  /**\n   * Function arguments that can be given to convey the state of the current parse operation.\n   */\n  ParamType = any,\n> = {\n  name: NameType;\n  impl: (def: ImplArgs) => (context: Context, params: ParamType) => ReturnType;\n};\n\n/**\n * Type expected by grammar rules in the main `impl` function.\n */\nexport interface ImplArgs extends CstDef {\n  cache: WeakMap<RuleDef, unknown>;\n}\n\n/**\n * Type definition used by {@link CstDef.SUBRULE} and family.\n */\ntype SubRuleFunc = <T extends string, U = unknown, ARGS = any>(\n  cstDef: RuleDef<any, T, U, ARGS>,\n  argument: ARGS\n) => U;\n/**\n * Type definition used by {@link CstDef.BACKTRACK}.\n */\ntype BacktrackFunc = <T extends string, U = unknown, ARGS = any>(\n  cstDef: RuleDef<any, T, U, ARGS>,\n  argument: ARGS\n) => () => boolean;\n\n/**\n * Mainly a repetition of the functions exposed by the {@link EmbeddedActionsParser},\n * with some small adjustments that allow for the API changes made by traqula.\n * Specifically changes are made to the {@link CstDef.SUBRULE} (and family) interface,\n * and to the {@link CstDef.BACKTRACK} interface.\n */\nexport interface CstDef {\n  /**\n   *\n   * A Parsing DSL method use to consume a single Token.\n   * In EBNF terms this is equivalent to a Terminal.\n   *\n   * A Token will be consumed, IFF the next token in the token vector matches `tokType`.\n   * otherwise the parser may attempt to perform error recovery (if enabled).\n   *\n   * The index in the method name indicates the unique occurrence of a terminal consumption\n   * inside a the top level rule. What this means is that if a terminal appears\n   * more than once in a single rule, each appearance must have a **different** index.\n   *\n   * For example:\n   * ```\n   *   this.RULE(\"qualifiedName\", () => {\n   *   this.CONSUME1(Identifier);\n   *     this.MANY(() => {\n   *       this.CONSUME1(Dot);\n   *       // here we use CONSUME2 because the terminal\n   *       // 'Identifier' has already appeared previously in the\n   *       // the rule 'parseQualifiedName'\n   *       this.CONSUME2(Identifier);\n   *     });\n   *   })\n   * ```\n   *\n   * - See more details on the [unique suffixes requirement](http://chevrotain.io/docs/FAQ.html#NUMERICAL_SUFFIXES).\n   *\n   * @param tokType - The Type of the token to be consumed.\n   * @param options - optional properties to modify the behavior of CONSUME.\n   */\n  CONSUME: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME1: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME2: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME3: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME4: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME5: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME6: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME7: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME8: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME9: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  /**\n   * Parsing DSL Method that Indicates an Optional production.\n   * in EBNF notation this is equivalent to: \"[...]\".\n   *\n   * Note that there are two syntax forms:\n   * - Passing the grammar action directly:\n   *   ```\n   *     this.OPTION(() => {\n   *       this.CONSUME(Digit)}\n   *     );\n   *   ```\n   *\n   * - using an \"options\" object:\n   *   ```\n   *     this.OPTION({\n   *       GATE:predicateFunc,\n   *       DEF: () => {\n   *         this.CONSUME(Digit)\n   *     }});\n   *   ```\n   *\n   * The optional 'GATE' property in \"options\" object form can be used to add constraints\n   * to invoking the grammar action.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the optional production in it's top rule.\n   *\n   * @param  actionORMethodDef - The grammar action to optionally invoke once\n   *                             or an \"OPTIONS\" object describing the grammar action and optional properties.\n   *\n   * @returns The `GrammarAction` return value (OUT) if the optional syntax is encountered\n   *          or `undefined` if not.\n   */\n  OPTION: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION1: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION2: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION3: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION4: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION5: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION6: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION7: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION8: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION9: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  /**\n   * Parsing DSL method that indicates a choice between a set of alternatives must be made.\n   * This is equivalent to an EBNF alternation (A | B | C | D ...), except\n   * that the alternatives are ordered like in a PEG grammar.\n   * This means that the **first** matching alternative is always chosen.\n   *\n   * There are several forms for the inner alternatives array:\n   *\n   * - Passing alternatives array directly:\n   *   ```\n   *     this.OR([\n   *       { ALT:() => { this.CONSUME(One) }},\n   *       { ALT:() => { this.CONSUME(Two) }},\n   *       { ALT:() => { this.CONSUME(Three) }}\n   *     ])\n   *   ```\n   *\n   * - Passing alternative array directly with predicates (GATE):\n   *   ```\n   *     this.OR([\n   *       { GATE: predicateFunc1, ALT:() => { this.CONSUME(One) }},\n   *       { GATE: predicateFuncX, ALT:() => { this.CONSUME(Two) }},\n   *       { GATE: predicateFuncX, ALT:() => { this.CONSUME(Three) }}\n   *     ])\n   *   ```\n   *\n   * - These syntax forms can also be mixed:\n   *   ```\n   *     this.OR([\n   *       {\n   *         GATE: predicateFunc1,\n   *         ALT:() => { this.CONSUME(One) }\n   *       },\n   *       { ALT:() => { this.CONSUME(Two) }},\n   *       { ALT:() => { this.CONSUME(Three) }}\n   *     ])\n   *   ```\n   *\n   * - Additionally an \"options\" object may be used:\n   *   ```\n   *     this.OR({\n   *       DEF:[\n   *         { ALT:() => { this.CONSUME(One) }},\n   *         { ALT:() => { this.CONSUME(Two) }},\n   *         { ALT:() => { this.CONSUME(Three) }}\n   *       ],\n   *       // OPTIONAL property\n   *       ERR_MSG: \"A Number\"\n   *     })\n   *   ```\n   *\n   * The 'predicateFuncX' in the long form can be used to add constraints to choosing the alternative.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the alternation production in it's top rule.\n   *\n   * @param altsOrOpts - A set of alternatives or an \"OPTIONS\" object describing the alternatives\n   * and optional properties.\n   *\n   * @returns The result of invoking the chosen alternative.\n   */\n  OR: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR1: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR2: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR3: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR4: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR5: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR6: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR7: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR8: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR9: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  /**\n   * Parsing DSL method, that indicates a repetition of zero or more.\n   * This is equivalent to EBNF repetition \\{...\\}.\n   *\n   * Note that there are two syntax forms:\n   * - Passing the grammar action directly:\n   *   ```\n   *     this.MANY(() => {\n   *       this.CONSUME(Comma)\n   *       this.CONSUME(Digit)\n   *      })\n   *   ```\n   *\n   * - using an \"options\" object:\n   *   ```\n   *     this.MANY({\n   *       GATE: predicateFunc,\n   *       DEF: () => {\n   *              this.CONSUME(Comma)\n   *              this.CONSUME(Digit)\n   *            }\n   *     });\n   *   ```\n   *\n   * The optional 'GATE' property in \"options\" object form can be used to add constraints\n   * to invoking the grammar action.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the repetition production in it's top rule.\n   *\n   * @param actionORMethodDef - The grammar action to optionally invoke multiple times\n   *                             or an \"OPTIONS\" object describing the grammar action and optional properties.\n   *\n   */\n  MANY: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY1: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY2: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY3: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY4: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY5: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY6: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY7: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY8: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY9: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  /**\n   * Parsing DSL method, that indicates a repetition of zero or more with a separator\n   * Token between the repetitions.\n   *\n   * Example:\n   *\n   * ```\n   *     this.MANY_SEP({\n   *         SEP:Comma,\n   *         DEF: () => {\n   *             this.CONSUME(Number};\n   *             // ...\n   *         })\n   * ```\n   *\n   * Note that because this DSL method always requires more than one argument the options object is always required\n   * and it is not possible to use a shorter form like in the MANY DSL method.\n   *\n   * Note that for the purposes of deciding on whether or not another iteration exists\n   * Only a single Token is examined (The separator). Therefore if the grammar being implemented is\n   * so \"crazy\" to require multiple tokens to identify an item separator please use the more basic DSL methods\n   * to implement it.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the repetition production in it's top rule.\n   *\n   * @param options - An object defining the grammar of each iteration and the separator between iterations\n   *\n   */\n  MANY_SEP: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP1: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP2: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP3: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP4: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP5: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP6: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP7: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP8: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP9: (options: ManySepMethodOpts<any>) => void;\n  /**\n   * Convenience method, same as MANY but the repetition is of one or more.\n   * failing to match at least one repetition will result in a parsing error and\n   * cause a parsing error.\n   *\n   * @see MANY\n   *\n   * @param actionORMethodDef  - The grammar action to optionally invoke multiple times\n   *                             or an \"OPTIONS\" object describing the grammar action and optional properties.\n   *\n   */\n  AT_LEAST_ONE: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE1: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE2: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE3: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE4: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE5: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE6: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE7: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE8: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE9: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  /**\n   * Convenience method, same as MANY_SEP but the repetition is of one or more.\n   * failing to match at least one repetition will result in a parsing error and\n   * cause the parser to attempt error recovery.\n   *\n   * Note that an additional optional property ERR_MSG can be used to provide custom error messages.\n   *\n   * @see MANY_SEP\n   *\n   * @param options - An object defining the grammar of each iteration and the separator between iterations\n   *\n   * @return ISeparatedIterationResult<OUT>\n   */\n  AT_LEAST_ONE_SEP: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP1: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP2: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP3: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP4: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP5: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP6: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP7: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP8: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP9: (options: AtLeastOneSepMethodOpts<any>) => void;\n  ACTION: <T>(impl: () => T) => T;\n  BACKTRACK: BacktrackFunc;\n  SUBRULE: SubRuleFunc;\n  SUBRULE1: SubRuleFunc;\n  SUBRULE2: SubRuleFunc;\n  SUBRULE3: SubRuleFunc;\n  SUBRULE4: SubRuleFunc;\n  SUBRULE5: SubRuleFunc;\n  SUBRULE6: SubRuleFunc;\n  SUBRULE7: SubRuleFunc;\n  SUBRULE8: SubRuleFunc;\n  SUBRULE9: SubRuleFunc;\n}\n"]}

package/lib/index.cjs

@@ -1,13 +1,8 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -20,314 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/rdf-data-factory/lib/BlankNode.js
-var require_BlankNode = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/BlankNode.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.BlankNode = void 0;
-    var BlankNode = class {
-      constructor(value) {
-        this.termType = "BlankNode";
-        this.value = value;
-      }
-      equals(other) {
-        return !!other && other.termType === "BlankNode" && other.value === this.value;
-      }
-    };
-    exports2.BlankNode = BlankNode;
-  }
-});
-
-// ../../node_modules/rdf-data-factory/lib/DefaultGraph.js
-var require_DefaultGraph = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/DefaultGraph.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.DefaultGraph = void 0;
-    var DefaultGraph = class {
-      constructor() {
-        this.termType = "DefaultGraph";
-        this.value = "";
-      }
-      equals(other) {
-        return !!other && other.termType === "DefaultGraph";
-      }
-    };
-    exports2.DefaultGraph = DefaultGraph;
-    DefaultGraph.INSTANCE = new DefaultGraph();
-  }
-});
-
-// ../../node_modules/rdf-data-factory/lib/NamedNode.js
-var require_NamedNode = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/NamedNode.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.NamedNode = void 0;
-    var NamedNode = class {
-      constructor(value) {
-        this.termType = "NamedNode";
-        this.value = value;
-      }
-      equals(other) {
-        return !!other && other.termType === "NamedNode" && other.value === this.value;
-      }
-    };
-    exports2.NamedNode = NamedNode;
-  }
-});
-
-// ../../node_modules/rdf-data-factory/lib/Literal.js
-var require_Literal = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/Literal.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Literal = void 0;
-    var NamedNode_1 = require_NamedNode();
-    var Literal = class _Literal {
-      constructor(value, languageOrDatatype) {
-        this.termType = "Literal";
-        this.value = value;
-        if (typeof languageOrDatatype === "string") {
-          this.language = languageOrDatatype;
-          this.datatype = _Literal.RDF_LANGUAGE_STRING;
-          this.direction = "";
-        } else if (languageOrDatatype) {
-          if ("termType" in languageOrDatatype) {
-            this.language = "";
-            this.datatype = languageOrDatatype;
-            this.direction = "";
-          } else {
-            this.language = languageOrDatatype.language;
-            this.datatype = languageOrDatatype.direction ? _Literal.RDF_DIRECTIONAL_LANGUAGE_STRING : _Literal.RDF_LANGUAGE_STRING;
-            this.direction = languageOrDatatype.direction || "";
-          }
-        } else {
-          this.language = "";
-          this.datatype = _Literal.XSD_STRING;
-          this.direction = "";
-        }
-      }
-      equals(other) {
-        return !!other && other.termType === "Literal" && other.value === this.value && other.language === this.language && (other.direction === this.direction || !other.direction && this.direction === "") && this.datatype.equals(other.datatype);
-      }
-    };
-    exports2.Literal = Literal;
-    Literal.RDF_LANGUAGE_STRING = new NamedNode_1.NamedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString");
-    Literal.RDF_DIRECTIONAL_LANGUAGE_STRING = new NamedNode_1.NamedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString");
-    Literal.XSD_STRING = new NamedNode_1.NamedNode("http://www.w3.org/2001/XMLSchema#string");
-  }
-});
-
-// ../../node_modules/rdf-data-factory/lib/Quad.js
-var require_Quad = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/Quad.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Quad = void 0;
-    var Quad = class {
-      constructor(subject, predicate, object, graph) {
-        this.termType = "Quad";
-        this.value = "";
-        this.subject = subject;
-        this.predicate = predicate;
-        this.object = object;
-        this.graph = graph;
-      }
-      equals(other) {
-        return !!other && (other.termType === "Quad" || !other.termType) && this.subject.equals(other.subject) && this.predicate.equals(other.predicate) && this.object.equals(other.object) && this.graph.equals(other.graph);
-      }
-    };
-    exports2.Quad = Quad;
-  }
-});
-
-// ../../node_modules/rdf-data-factory/lib/Variable.js
-var require_Variable = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/Variable.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Variable = void 0;
-    var Variable = class {
-      constructor(value) {
-        this.termType = "Variable";
-        this.value = value;
-      }
-      equals(other) {
-        return !!other && other.termType === "Variable" && other.value === this.value;
-      }
-    };
-    exports2.Variable = Variable;
-  }
-});
-
-// ../../node_modules/rdf-data-factory/lib/DataFactory.js
-var require_DataFactory = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/DataFactory.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.DataFactory = void 0;
-    var BlankNode_1 = require_BlankNode();
-    var DefaultGraph_1 = require_DefaultGraph();
-    var Literal_1 = require_Literal();
-    var NamedNode_1 = require_NamedNode();
-    var Quad_1 = require_Quad();
-    var Variable_1 = require_Variable();
-    var dataFactoryCounter = 0;
-    var DataFactory2 = class {
-      constructor(options) {
-        this.blankNodeCounter = 0;
-        options = options || {};
-        this.blankNodePrefix = options.blankNodePrefix || `df_${dataFactoryCounter++}_`;
-      }
-      /**
-       * @param value The IRI for the named node.
-       * @return A new instance of NamedNode.
-       * @see NamedNode
-       */
-      namedNode(value) {
-        return new NamedNode_1.NamedNode(value);
-      }
-      /**
-       * @param value The optional blank node identifier.
-       * @return A new instance of BlankNode.
-       *         If the `value` parameter is undefined a new identifier
-       *         for the blank node is generated for each call.
-       * @see BlankNode
-       */
-      blankNode(value) {
-        return new BlankNode_1.BlankNode(value || `${this.blankNodePrefix}${this.blankNodeCounter++}`);
-      }
-      /**
-       * @param value              The literal value.
-       * @param languageOrDatatype The optional language, datatype, or directional language.
-       *                           If `languageOrDatatype` is a NamedNode,
-       *                           then it is used for the value of `NamedNode.datatype`.
-       *                           If `languageOrDatatype` is a NamedNode, it is used for the value
-       *                           of `NamedNode.language`.
-       *                           Otherwise, it is used as a directional language,
-       *                           from which the language is set to `languageOrDatatype.language`
-       *                           and the direction to `languageOrDatatype.direction`.
-       * @return A new instance of Literal.
-       * @see Literal
-       */
-      literal(value, languageOrDatatype) {
-        return new Literal_1.Literal(value, languageOrDatatype);
-      }
-      /**
-       * This method is optional.
-       * @param value The variable name
-       * @return A new instance of Variable.
-       * @see Variable
-       */
-      variable(value) {
-        return new Variable_1.Variable(value);
-      }
-      /**
-       * @return An instance of DefaultGraph.
-       */
-      defaultGraph() {
-        return DefaultGraph_1.DefaultGraph.INSTANCE;
-      }
-      /**
-       * @param subject   The quad subject term.
-       * @param predicate The quad predicate term.
-       * @param object    The quad object term.
-       * @param graph     The quad graph term.
-       * @return A new instance of Quad.
-       * @see Quad
-       */
-      quad(subject, predicate, object, graph) {
-        return new Quad_1.Quad(subject, predicate, object, graph || this.defaultGraph());
-      }
-      /**
-       * Create a deep copy of the given term using this data factory.
-       * @param original An RDF term.
-       * @return A deep copy of the given term.
-       */
-      fromTerm(original) {
-        switch (original.termType) {
-          case "NamedNode":
-            return this.namedNode(original.value);
-          case "BlankNode":
-            return this.blankNode(original.value);
-          case "Literal":
-            if (original.language) {
-              return this.literal(original.value, original.language);
-            }
-            if (!original.datatype.equals(Literal_1.Literal.XSD_STRING)) {
-              return this.literal(original.value, this.fromTerm(original.datatype));
-            }
-            return this.literal(original.value);
-          case "Variable":
-            return this.variable(original.value);
-          case "DefaultGraph":
-            return this.defaultGraph();
-          case "Quad":
-            return this.quad(this.fromTerm(original.subject), this.fromTerm(original.predicate), this.fromTerm(original.object), this.fromTerm(original.graph));
-        }
-      }
-      /**
-       * Create a deep copy of the given quad using this data factory.
-       * @param original An RDF quad.
-       * @return A deep copy of the given quad.
-       */
-      fromQuad(original) {
-        return this.fromTerm(original);
-      }
-      /**
-       * Reset the internal blank node counter.
-       */
-      resetBlankNodeCounter() {
-        this.blankNodeCounter = 0;
-      }
-    };
-    exports2.DataFactory = DataFactory2;
-  }
-});
-
-// ../../node_modules/rdf-data-factory/index.js
-var require_rdf_data_factory = __commonJS({
-  "../../node_modules/rdf-data-factory/index.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    });
-    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
-      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    __exportStar(require_BlankNode(), exports2);
-    __exportStar(require_DataFactory(), exports2);
-    __exportStar(require_DefaultGraph(), exports2);
-    __exportStar(require_Literal(), exports2);
-    __exportStar(require_NamedNode(), exports2);
-    __exportStar(require_Quad(), exports2);
-    __exportStar(require_Variable(), exports2);
-  }
-});
-
 // lib/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -1706,8 +1395,8 @@ var Promise2 = getNative_default(root_default, "Promise");
 var Promise_default = Promise2;
 
 // ../../node_modules/lodash-es/_Set.js
-var Set2 = getNative_default(root_default, "Set");
-var Set_default = Set2;
+var Set = getNative_default(root_default, "Set");
+var Set_default = Set;
 
 // ../../node_modules/lodash-es/_getTag.js
 var mapTag2 = "[object Map]";
@@ -9560,7 +9249,6 @@ var EmbeddedActionsParser = class extends Parser {
 };
 
 // lib/grammar-builder/parserBuilder.ts
-var import_rdf_data_factory = __toESM(require_rdf_data_factory(), 1);
 function listToRuleDefMap(rules) {
   const newRules = {};
   for (const rule of rules) {
@@ -9570,7 +9258,7 @@ function listToRuleDefMap(rules) {
 }
 var Builder = class _Builder {
   /**
-   * Create a builder with from some initial grammar rules or an existing builder.
+   * Create a builder from some initial grammar rules or an existing builder.
    * If a builder is provided, a new copy will be created.
    */
   static createBuilder(start) {
@@ -9612,10 +9300,20 @@ var Builder = class _Builder {
     this.rules = { ...this.rules, ...listToRuleDefMap(rules) };
     return this;
   }
+  /**
+   * Delete a grammar rule by its name.
+   */
   deleteRule(ruleName) {
     delete this.rules[ruleName];
     return this;
   }
+  /**
+   * Merge this grammar builder with another.
+   * It is best to merge the bigger grammar with the smaller one.
+   * If the two builders both have a grammar rule with the same name, no error will be thrown case they map to the same ruledef object.
+   * If they map to a different object, an error will be thrown.
+   * To fix this problem, the overridingRules array should contain a rule with the same conflicting name, this rule implementation will be used.
+   */
   merge(builder, overridingRules) {
     const otherRules = { ...builder.rules };
     const myRules = this.rules;
@@ -9637,7 +9335,7 @@ var Builder = class _Builder {
     this.rules = otherRules;
     return this;
   }
-  consumeToParser({ tokenVocabulary, parserConfig = {}, lexerConfig = {} }, context = {}) {
+  consumeToParser({ tokenVocabulary, parserConfig = {}, lexerConfig = {} }) {
     const lexer = new Lexer(tokenVocabulary, {
       positionTracking: "onlyStart",
       recoveryEnabled: false,
@@ -9646,10 +9344,10 @@ var Builder = class _Builder {
       ensureOptimizations: true,
       ...lexerConfig
     });
-    const parser = this.consume({ tokenVocabulary, config: parserConfig }, context);
+    const parser = this.consume({ tokenVocabulary, config: parserConfig });
     const selfSufficientParser = {};
     for (const rule of Object.values(this.rules)) {
-      selfSufficientParser[rule.name] = (input, ...args) => {
+      selfSufficientParser[rule.name] = (input, context, arg) => {
         input = input.replaceAll(
           /\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{8})/gu,
           (_, unicode4, unicode8) => {
@@ -9669,9 +9367,9 @@ var Builder = class _Builder {
           throw new Error(`Invalid unicode codepoint of surrogate pair without corresponding codepoint`);
         }
         const lexResult = lexer.tokenize(input);
-        parser.reset();
         parser.input = lexResult.tokens;
-        const result = parser[rule.name](...args);
+        parser.setContext(context);
+        const result = parser[rule.name](context, arg);
         if (parser.errors.length > 0) {
           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")}`);
@@ -9681,9 +9379,18 @@ ${parser.errors.map((x) => `${x.token.startLine}: ${x.message}`).join("\n")}`);
     }
     return selfSufficientParser;
   }
-  consume({ tokenVocabulary, config = {} }, context = {}) {
+  consume({ tokenVocabulary, config = {} }) {
     const rules = this.rules;
     class MyParser extends EmbeddedActionsParser {
+      getSafeContext() {
+        if (this.context === void 0) {
+          throw new Error("context was not correctly set");
+        }
+        return this.context;
+      }
+      setContext(context) {
+        this.context = context;
+      }
       constructor() {
         super(tokenVocabulary, {
           // RecoveryEnabled: true,
@@ -9691,39 +9398,23 @@ ${parser.errors.map((x) => `${x.token.startLine}: ${x.message}`).join("\n")}`);
           // SkipValidations: true,
           ...config
         });
+        this.context = void 0;
         const selfRef = this.getSelfRef();
-        this.initialParseContext = {
-          dataFactory: new import_rdf_data_factory.DataFactory({ blankNodePrefix: "g_" }),
-          baseIRI: void 0,
-          parseMode: /* @__PURE__ */ 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: /* @__PURE__ */ new WeakMap(),
-          context: this.runningContext
+          cache: /* @__PURE__ */ new WeakMap()
         };
         for (const rule of Object.values(rules)) {
           this[rule.name] = this.RULE(rule.name, rule.impl(implArgs));
         }
         this.performSelfAnalysis();
       }
-      reset() {
-        super.reset();
-        Object.assign(this.runningContext, {
-          ...this.initialParseContext
-        });
-        this.runningContext.prefixes = { ...this.initialParseContext.prefixes };
-        this.runningContext.parseMode = new Set(this.initialParseContext.parseMode);
-      }
       getSelfRef() {
+        const subRuleImpl = (chevrotainSubrule) => {
+          return (cstDef, arg) => {
+            return chevrotainSubrule(this[cstDef.name], { ARGS: [this.context, arg] });
+          };
+        };
         return {
           CONSUME: (tokenType, option) => this.CONSUME(tokenType, option),
           CONSUME1: (tokenType, option) => this.CONSUME1(tokenType, option),
@@ -9803,76 +9494,16 @@ ${parser.errors.map((x) => `${x.token.startLine}: ${x.message}`).join("\n")}`);
               throw error;
             }
           },
-          SUBRULE: (cstDef, ...args) => {
-            try {
-              return this.SUBRULE(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          },
-          SUBRULE1: (cstDef, ...args) => {
-            try {
-              return this.SUBRULE1(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          },
-          SUBRULE2: (cstDef, ...args) => {
-            try {
-              return this.SUBRULE2(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          },
-          SUBRULE3: (cstDef, ...args) => {
-            try {
-              return this.SUBRULE3(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          },
-          SUBRULE4: (cstDef, ...args) => {
-            try {
-              return this.SUBRULE4(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          },
-          SUBRULE5: (cstDef, ...args) => {
-            try {
-              return this.SUBRULE5(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          },
-          SUBRULE6: (cstDef, ...args) => {
-            try {
-              return this.SUBRULE6(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          },
-          SUBRULE7: (cstDef, ...args) => {
-            try {
-              return this.SUBRULE7(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          },
-          SUBRULE8: (cstDef, ...args) => {
-            try {
-              return this.SUBRULE8(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          },
-          SUBRULE9: (cstDef, ...args) => {
-            try {
-              return this.SUBRULE9(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          }
+          SUBRULE: subRuleImpl((rule, args) => this.SUBRULE(rule, args)),
+          SUBRULE1: subRuleImpl((rule, args) => this.SUBRULE1(rule, args)),
+          SUBRULE2: subRuleImpl((rule, args) => this.SUBRULE2(rule, args)),
+          SUBRULE3: subRuleImpl((rule, args) => this.SUBRULE3(rule, args)),
+          SUBRULE4: subRuleImpl((rule, args) => this.SUBRULE4(rule, args)),
+          SUBRULE5: subRuleImpl((rule, args) => this.SUBRULE5(rule, args)),
+          SUBRULE6: subRuleImpl((rule, args) => this.SUBRULE6(rule, args)),
+          SUBRULE7: subRuleImpl((rule, args) => this.SUBRULE7(rule, args)),
+          SUBRULE8: subRuleImpl((rule, args) => this.SUBRULE8(rule, args)),
+          SUBRULE9: subRuleImpl((rule, args) => this.SUBRULE9(rule, args))
         };
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@traqula/core",
-  "version": "0.0.1-alpha.143+7e8a4c4",
+  "version": "0.0.1-alpha.148+1455821",
   "description": "Core components of TRAQULA",
   "lsd:module": true,
   "license": "MIT",
@@ -38,12 +38,10 @@
     "build:transpile": "node \"../../node_modules/esbuild/bin/esbuild\" --format=cjs --bundle --log-level=error --outfile=lib/index.cjs lib/index.ts"
   },
   "dependencies": {
-    "chevrotain": "^11.0.3",
-    "rdf-data-factory": "^2.0.1"
+    "chevrotain": "^11.0.3"
   },
   "devDependencies": {
-    "@chevrotain/types": "^11.0.3",
-    "@rdfjs/types": "^2.0.0"
+    "@chevrotain/types": "^11.0.3"
   },
-  "gitHead": "7e8a4c4897f112e7291b733121a83726bacfdd0b"
+  "gitHead": "14558218b5c59739a791015d2bfbb466c5da9e62"
 }