@traqula/core 0.0.1-alpha.10

package/lib/parser-builder/ruleDefTypes.d.ts

@@ -0,0 +1,347 @@
+import type { AtLeastOneSepMethodOpts, DSLMethodOpts, DSLMethodOptsWithErr, GrammarAction, IOrAlt, ManySepMethodOpts, OrMethodOpts } from '@chevrotain/types';
+import type { ConsumeMethodOpts, IToken, TokenType } from 'chevrotain';
+/**
+ * Get the return-type of a RuleDef
+ */
+export type RuleDefReturn<T extends ParserRule> = T extends ParserRule<any, string, infer Ret> ? Ret : never;
+/**
+ * Type used to declare grammar rules.
+ */
+export type ParserRule<
+/**
+ * Context object available in rule implementation.
+ */
+Context = any, 
+/**
+ * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.
+ */
+NameType extends string = string, 
+/**
+ * Type that will be returned after a correct parse of this rule.
+ * This type will be the return type of calling SUBRULE with this grammar rule.
+ */
+ReturnType = unknown, 
+/**
+ * Function arguments that can be given to convey the state of the current parse operation.
+ */
+ParamType = any> = {
+    name: NameType;
+    impl: (def: ImplArgs) => (context: Context, params: ParamType) => ReturnType;
+};
+/**
+ * Type expected by grammar rules in the main `impl` function.
+ */
+export interface ImplArgs extends CstDef {
+    cache: WeakMap<ParserRule, unknown>;
+}
+/**
+ * Type definition used by {@link CstDef.SUBRULE} and family.
+ */
+type SubRuleFunc = <T extends string, U = unknown, ARGS = any>(cstDef: ParserRule<any, T, U, ARGS>, argument: ARGS) => U;
+/**
+ * Type definition used by {@link CstDef.BACKTRACK}.
+ */
+type BacktrackFunc = <T extends string, U = unknown, ARGS = any>(cstDef: ParserRule<any, T, U, ARGS>, argument: ARGS) => () => boolean;
+/**
+ * Mainly a repetition of the functions exposed by the {@link EmbeddedActionsParser},
+ * with some small adjustments that allow for the API changes made by traqula.
+ * Specifically changes are made to the {@link CstDef.SUBRULE} (and family) interface,
+ * and to the {@link CstDef.BACKTRACK} interface.
+ */
+export interface CstDef {
+    /**
+     *
+     * 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://chevrotain.io/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.
+     */
+    CONSUME: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;
+    CONSUME1: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;
+    CONSUME2: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;
+    CONSUME3: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;
+    CONSUME4: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;
+    CONSUME5: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;
+    CONSUME6: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;
+    CONSUME7: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;
+    CONSUME8: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;
+    CONSUME9: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;
+    /**
+     * 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.
+     *
+     * @returns The `GrammarAction` return value (OUT) if the optional syntax is encountered
+     *          or `undefined` if not.
+     */
+    OPTION: <OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>) => OUT | undefined;
+    OPTION1: <OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>) => OUT | undefined;
+    OPTION2: <OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>) => OUT | undefined;
+    OPTION3: <OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>) => OUT | undefined;
+    OPTION4: <OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>) => OUT | undefined;
+    OPTION5: <OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>) => OUT | undefined;
+    OPTION6: <OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>) => OUT | undefined;
+    OPTION7: <OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>) => OUT | undefined;
+    OPTION8: <OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>) => OUT | undefined;
+    OPTION9: <OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>) => OUT | undefined;
+    /**
+     * 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.
+     */
+    OR: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;
+    OR1: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;
+    OR2: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;
+    OR3: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;
+    OR4: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;
+    OR5: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;
+    OR6: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;
+    OR7: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;
+    OR8: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;
+    OR9: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;
+    /**
+     * 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.
+     *
+     */
+    MANY: (actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>) => void;
+    MANY1: (actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>) => void;
+    MANY2: (actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>) => void;
+    MANY3: (actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>) => void;
+    MANY4: (actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>) => void;
+    MANY5: (actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>) => void;
+    MANY6: (actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>) => void;
+    MANY7: (actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>) => void;
+    MANY8: (actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>) => void;
+    MANY9: (actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>) => void;
+    /**
+     * 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
+     *
+     */
+    MANY_SEP: (options: ManySepMethodOpts<any>) => void;
+    MANY_SEP1: (options: ManySepMethodOpts<any>) => void;
+    MANY_SEP2: (options: ManySepMethodOpts<any>) => void;
+    MANY_SEP3: (options: ManySepMethodOpts<any>) => void;
+    MANY_SEP4: (options: ManySepMethodOpts<any>) => void;
+    MANY_SEP5: (options: ManySepMethodOpts<any>) => void;
+    MANY_SEP6: (options: ManySepMethodOpts<any>) => void;
+    MANY_SEP7: (options: ManySepMethodOpts<any>) => void;
+    MANY_SEP8: (options: ManySepMethodOpts<any>) => void;
+    MANY_SEP9: (options: ManySepMethodOpts<any>) => void;
+    /**
+     * 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.
+     *
+     */
+    AT_LEAST_ONE: (actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>) => void;
+    AT_LEAST_ONE1: (actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>) => void;
+    AT_LEAST_ONE2: (actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>) => void;
+    AT_LEAST_ONE3: (actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>) => void;
+    AT_LEAST_ONE4: (actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>) => void;
+    AT_LEAST_ONE5: (actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>) => void;
+    AT_LEAST_ONE6: (actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>) => void;
+    AT_LEAST_ONE7: (actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>) => void;
+    AT_LEAST_ONE8: (actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>) => void;
+    AT_LEAST_ONE9: (actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>) => void;
+    /**
+     * 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>
+     */
+    AT_LEAST_ONE_SEP: (options: AtLeastOneSepMethodOpts<any>) => void;
+    AT_LEAST_ONE_SEP1: (options: AtLeastOneSepMethodOpts<any>) => void;
+    AT_LEAST_ONE_SEP2: (options: AtLeastOneSepMethodOpts<any>) => void;
+    AT_LEAST_ONE_SEP3: (options: AtLeastOneSepMethodOpts<any>) => void;
+    AT_LEAST_ONE_SEP4: (options: AtLeastOneSepMethodOpts<any>) => void;
+    AT_LEAST_ONE_SEP5: (options: AtLeastOneSepMethodOpts<any>) => void;
+    AT_LEAST_ONE_SEP6: (options: AtLeastOneSepMethodOpts<any>) => void;
+    AT_LEAST_ONE_SEP7: (options: AtLeastOneSepMethodOpts<any>) => void;
+    AT_LEAST_ONE_SEP8: (options: AtLeastOneSepMethodOpts<any>) => void;
+    AT_LEAST_ONE_SEP9: (options: AtLeastOneSepMethodOpts<any>) => void;
+    ACTION: <T>(impl: () => T) => T;
+    BACKTRACK: BacktrackFunc;
+    SUBRULE: SubRuleFunc;
+    SUBRULE1: SubRuleFunc;
+    SUBRULE2: SubRuleFunc;
+    SUBRULE3: SubRuleFunc;
+    SUBRULE4: SubRuleFunc;
+    SUBRULE5: SubRuleFunc;
+    SUBRULE6: SubRuleFunc;
+    SUBRULE7: SubRuleFunc;
+    SUBRULE8: SubRuleFunc;
+    SUBRULE9: SubRuleFunc;
+}
+export {};

package/lib/parser-builder/ruleDefTypes.js

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

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

@@ -0,0 +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 { ConsumeMethodOpts, IToken, TokenType } from 'chevrotain';\n\n/**\n * Get the return-type of a RuleDef\n */\nexport type RuleDefReturn<T extends ParserRule> = T extends ParserRule<any, string, infer Ret> ? Ret : never;\n\n/**\n * Type used to declare grammar rules.\n */\nexport type ParserRule<\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<ParserRule, 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: ParserRule<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: ParserRule<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/utils.d.ts

@@ -0,0 +1,17 @@
+import type { ITokenConfig, TokenType } from '@chevrotain/types';
+/**
+ * Check whether the first two types overlap, if no, return the 3th argument, else the 4th.
+ */
+export type CheckOverlap<T, U, V, W = never> = T & U extends never ? V : W;
+export declare function unCapitalize<T extends string>(str: T): Uncapitalize<T>;
+export type NamedToken<Name extends string> = TokenType & {
+    name: Name;
+};
+export declare function createToken<Name extends string>(config: ITokenConfig & {
+    name: Name;
+}): NamedToken<Name>;
+export type Patch<T extends object, Patch extends {
+    [Key in keyof T]?: unknown;
+}> = {
+    [Key in keyof T]: Key extends keyof Patch ? Patch[Key] : T[Key];
+};

package/lib/utils.js

@@ -0,0 +1,8 @@
+import { createToken as chevcT } from 'chevrotain';
+export function unCapitalize(str) {
+    return (str.charAt(0).toLowerCase() + str.slice(1));
+}
+export function createToken(config) {
+    return chevcT(config);
+}
+//# sourceMappingURL=utils.js.map

package/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,IAAI,MAAM,EAAE,MAAM,YAAY,CAAC;AAOnD,MAAM,UAAU,YAAY,CAAmB,GAAM;IACnD,OAAyB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACxE,CAAC;AAID,MAAM,UAAU,WAAW,CAAsB,MAAqC;IACpF,OAAoC,MAAM,CAAC,MAAM,CAAC,CAAC;AACrD,CAAC","sourcesContent":["import type { ITokenConfig, TokenType } from '@chevrotain/types';\nimport { createToken as chevcT } from 'chevrotain';\n\n/**\n * Check whether the first two types overlap, if no, return the 3th argument, else the 4th.\n */\nexport type CheckOverlap<T, U, V, W = never> = T & U extends never ? V : W;\n\nexport function unCapitalize<T extends string>(str: T): Uncapitalize<T> {\n  return <Uncapitalize<T>> (str.charAt(0).toLowerCase() + str.slice(1));\n}\n\nexport type NamedToken<Name extends string> = TokenType & { name: Name };\n\nexport function createToken<Name extends string>(config: ITokenConfig & { name: Name }): NamedToken<Name> {\n  return <TokenType & { name: Name }> chevcT(config);\n}\n\nexport type Patch<T extends object, Patch extends {[Key in keyof T ]?: unknown }> =\n  {[Key in keyof T]: Key extends keyof Patch ? Patch[Key] : T[Key] };\n"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@traqula/core",
+  "type": "module",
+  "version": "0.0.1-alpha.10+6cb01a3",
+  "description": "Core components of Traqula",
+  "lsd:module": true,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/comunica/traqula.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/comunica/traqula/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    "import": "./lib/index.js",
+    "require": "./lib/index.cjs"
+  },
+  "main": "lib/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib/**/*.cjs",
+    "lib/**/*.d.ts",
+    "lib/**/*.js",
+    "lib/**/*.js.map"
+  ],
+  "engines": {
+    "node": ">=18.0"
+  },
+  "typings": "lib/index",
+  "scripts": {
+    "build": "yarn build:ts && yarn build:transpile",
+    "build:ts": "node \"../../node_modules/typescript/bin/tsc\"",
+    "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"
+  },
+  "devDependencies": {
+    "@chevrotain/types": "^11.0.3"
+  },
+  "gitHead": "6cb01a3af7ea01e7bcd5aaba638cf74fb45db76b"
+}