@willbooster/tree-sitter-c 1.1.6 → 1.1.7

package/grammar.js

@@ -5,9 +5,12 @@
  * @license MIT
  */
 
-/// <reference types="tree-sitter-cli/dsl" />
 // @ts-check
 
+// Tree-sitter injects its DSL before loading this CommonJS grammar.
+const { grammar, alias, choice, field, optional, prec, repeat, repeat1, seq, sym, token } =
+  /** @type {typeof globalThis & typeof import('./types/treeSitterDsl')} */ (globalThis);
+
 const PREC = {
   PAREN_DECLARATOR: -10,
   ASSIGNMENT: -2,
@@ -94,8 +97,8 @@ module.exports = Object.assign(
           $.attributed_statement,
           $.type_definition,
           $._empty_declaration,
-          $.preproc_if,
-          $.preproc_ifdef,
+          sym('preproc_if'),
+          sym('preproc_ifdef'),
           $.preproc_include,
           $.preproc_def,
           $.preproc_function_def,
@@ -112,8 +115,8 @@ module.exports = Object.assign(
           $.attributed_statement,
           $.type_definition,
           $._empty_declaration,
-          $.preproc_if,
-          $.preproc_ifdef,
+          sym('preproc_if'),
+          sym('preproc_ifdef'),
           $.preproc_include,
           $.preproc_def,
           $.preproc_function_def,
@@ -163,10 +166,10 @@ module.exports = Object.assign(
           token.immediate(/\r?\n/)
         ),
 
-      ...preprocIf('', ($) => $._block_item),
-      ...preprocIf('_in_field_declaration_list', ($) => $._field_declaration_list_item),
-      ...preprocIf('_in_enumerator_list', ($) => seq($.enumerator, ',')),
-      ...preprocIf('_in_enumerator_list_no_comma', ($) => $.enumerator, -1),
+      ...preprocIf('', () => sym('_block_item')),
+      ...preprocIf('_in_field_declaration_list', () => sym('_field_declaration_list_item')),
+      ...preprocIf('_in_enumerator_list', () => seq(sym('enumerator'), ',')),
+      ...preprocIf('_in_enumerator_list_no_comma', () => sym('enumerator'), -1),
 
       preproc_arg: () => token(prec(-1, /\S([^/\n]|\/[^*]|\\\r?\n)*/)),
       preproc_directive: () => /#[ \t]*[a-zA-Z0-9]\w*/,
@@ -203,6 +206,7 @@ module.exports = Object.assign(
       preproc_argument_list: ($) => seq('(', commaSep($._preproc_expression), ')'),
 
       preproc_binary_expression: ($) => {
+        /** @type {[string, number][]} */
         const table = [
           ['+', PREC.ADD],
           ['-', PREC.ADD],
@@ -230,7 +234,6 @@ module.exports = Object.assign(
               precedence,
               seq(
                 field('left', $._preproc_expression),
-                // @ts-ignore
                 field('operator', operator),
                 field('right', $._preproc_expression)
               )
@@ -646,8 +649,8 @@ module.exports = Object.assign(
           repeat(
             choice(
               seq($.enumerator, ','),
-              alias($.preproc_if_in_enumerator_list, $.preproc_if),
-              alias($.preproc_ifdef_in_enumerator_list, $.preproc_ifdef),
+              alias(sym('preproc_if_in_enumerator_list'), sym('preproc_if')),
+              alias(sym('preproc_ifdef_in_enumerator_list'), sym('preproc_ifdef')),
               seq($.preproc_call, ',')
             )
           ),
@@ -655,8 +658,8 @@ module.exports = Object.assign(
             seq(
               choice(
                 $.enumerator,
-                alias($.preproc_if_in_enumerator_list_no_comma, $.preproc_if),
-                alias($.preproc_ifdef_in_enumerator_list_no_comma, $.preproc_ifdef),
+                alias(sym('preproc_if_in_enumerator_list_no_comma'), sym('preproc_if')),
+                alias(sym('preproc_ifdef_in_enumerator_list_no_comma'), sym('preproc_ifdef')),
                 $.preproc_call
               )
             )
@@ -699,8 +702,8 @@ module.exports = Object.assign(
           $.preproc_def,
           $.preproc_function_def,
           $.preproc_call,
-          alias($.preproc_if_in_field_declaration_list, $.preproc_if),
-          alias($.preproc_ifdef_in_field_declaration_list, $.preproc_ifdef)
+          alias(sym('preproc_if_in_field_declaration_list'), sym('preproc_if')),
+          alias(sym('preproc_ifdef_in_field_declaration_list'), sym('preproc_ifdef'))
         ),
 
       field_declaration: ($) =>
@@ -911,6 +914,7 @@ module.exports = Object.assign(
         prec.left(PREC.UNARY, seq(field('operator', choice('!', '~', '-', '+')), field('argument', $.expression))),
 
       binary_expression: ($) => {
+        /** @type {[string, number][]} */
         const table = [
           ['+', PREC.ADD],
           ['-', PREC.ADD],
@@ -936,12 +940,7 @@ module.exports = Object.assign(
           ...table.map(([operator, precedence]) => {
             return prec.left(
               precedence,
-              seq(
-                field('left', $.expression),
-                // @ts-ignore
-                field('operator', operator),
-                field('right', $.expression)
-              )
+              seq(field('left', $.expression), field('operator', operator), field('right', $.expression))
             );
           })
         );
@@ -1124,7 +1123,7 @@ module.exports = Object.assign(
       char_literal: ($) =>
         seq(
           choice("L'", "u'", "U'", "u8'", "'"),
-          repeat1(choice($.escape_sequence, alias(token.immediate(/[^\n']/), $.character))),
+          repeat1(choice($.escape_sequence, alias(token.immediate(/[^\n']/), sym('character')))),
           "'"
         ),
 
@@ -1145,7 +1144,7 @@ module.exports = Object.assign(
       string_literal: ($) =>
         seq(
           choice('L"', 'u"', 'U"', 'u8"', '"'),
-          repeat(choice(alias(token.immediate(prec(1, /[^\\"\n]+/)), $.string_content), $.escape_sequence)),
+          repeat(choice(alias(token.immediate(prec(1, /[^\\"\n]+/)), sym('string_content')), $.escape_sequence)),
           '"'
         ),
 
@@ -1163,9 +1162,9 @@ module.exports = Object.assign(
       identifier: () =>
         /(\p{XID_Start}|\$|_|\\u[0-9A-Fa-f]{4}|\\U[0-9A-Fa-f]{8})(\p{XID_Continue}|\$|\\u[0-9A-Fa-f]{4}|\\U[0-9A-Fa-f]{8})*/u,
 
-      _type_identifier: ($) => alias($.identifier, $.type_identifier),
-      _field_identifier: ($) => alias($.identifier, $.field_identifier),
-      _statement_identifier: ($) => alias($.identifier, $.statement_identifier),
+      _type_identifier: ($) => alias($.identifier, sym('type_identifier')),
+      _field_identifier: ($) => alias($.identifier, sym('field_identifier')),
+      _statement_identifier: ($) => alias($.identifier, sym('statement_identifier')),
 
       _empty_declaration: ($) => seq($.type_specifier, ';'),
 
@@ -1183,24 +1182,18 @@ module.exports = Object.assign(
  *
  * @param {string} suffix
  *
- * @param {RuleBuilder<string>} content
+ * @param {import('./types/treeSitterDsl').RuleBuilder<string>} content
  *
  * @param {number} precedence
  *
- * @returns {RuleBuilders<string, string>}
+ * @returns {import('./types/treeSitterDsl').RuleBuilders<string, string>}
  */
 function preprocIf(suffix, content, precedence = 0) {
-  /**
-   *
-   * @param {GrammarSymbols<string>} $
-   *
-   * @returns {ChoiceRule}
-   */
-  function alternativeBlock($) {
+  function alternativeBlock() {
     return choice(
-      suffix ? alias($['preproc_else' + suffix], $.preproc_else) : $.preproc_else,
-      suffix ? alias($['preproc_elif' + suffix], $.preproc_elif) : $.preproc_elif,
-      suffix ? alias($['preproc_elifdef' + suffix], $.preproc_elifdef) : $.preproc_elifdef
+      suffix ? alias(sym('preproc_else' + suffix), sym('preproc_else')) : sym('preproc_else'),
+      suffix ? alias(sym('preproc_elif' + suffix), sym('preproc_elif')) : sym('preproc_elif'),
+      suffix ? alias(sym('preproc_elifdef' + suffix), sym('preproc_elifdef')) : sym('preproc_elifdef')
     );
   }
 
@@ -1210,10 +1203,10 @@ function preprocIf(suffix, content, precedence = 0) {
         precedence,
         seq(
           preprocessor('if'),
-          field('condition', $._preproc_expression),
+          field('condition', sym('_preproc_expression')),
           '\n',
           repeat(content($)),
-          field('alternative', optional(alternativeBlock($))),
+          field('alternative', optional(alternativeBlock())),
           preprocessor('endif')
         )
       ),
@@ -1223,9 +1216,9 @@ function preprocIf(suffix, content, precedence = 0) {
         precedence,
         seq(
           choice(preprocessor('ifdef'), preprocessor('ifndef')),
-          field('name', $.identifier),
+          field('name', sym('identifier')),
           repeat(content($)),
-          field('alternative', optional(alternativeBlock($))),
+          field('alternative', optional(alternativeBlock())),
           preprocessor('endif')
         )
       ),
@@ -1237,10 +1230,10 @@ function preprocIf(suffix, content, precedence = 0) {
         precedence,
         seq(
           preprocessor('elif'),
-          field('condition', $._preproc_expression),
+          field('condition', sym('_preproc_expression')),
           '\n',
           repeat(content($)),
-          field('alternative', optional(alternativeBlock($)))
+          field('alternative', optional(alternativeBlock()))
         )
       ),
 
@@ -1249,9 +1242,9 @@ function preprocIf(suffix, content, precedence = 0) {
         precedence,
         seq(
           choice(preprocessor('elifdef'), preprocessor('elifndef')),
-          field('name', $.identifier),
+          field('name', sym('identifier')),
           repeat(content($)),
-          field('alternative', optional(alternativeBlock($)))
+          field('alternative', optional(alternativeBlock()))
         )
       ),
   };
@@ -1262,7 +1255,7 @@ function preprocIf(suffix, content, precedence = 0) {
  *
  * @param {string} command
  *
- * @returns {AliasRule}
+ * @returns {import('./types/treeSitterDsl').AliasRule}
  */
 function preprocessor(command) {
   return alias(new RegExp('#[ \t]*' + command), '#' + command);
@@ -1271,9 +1264,9 @@ function preprocessor(command) {
 /**
  * Creates a rule to optionally match one or more of the rules separated by a comma
  *
- * @param {Rule} rule
+ * @param {import('./types/treeSitterDsl').Rule} rule
  *
- * @returns {ChoiceRule}
+ * @returns {import('./types/treeSitterDsl').ChoiceRule}
  */
 function commaSep(rule) {
   return optional(commaSep1(rule));
@@ -1282,9 +1275,9 @@ function commaSep(rule) {
 /**
  * Creates a rule to match one or more of the rules separated by a comma
  *
- * @param {Rule} rule
+ * @param {import('./types/treeSitterDsl').Rule} rule
  *
- * @returns {SeqRule}
+ * @returns {import('./types/treeSitterDsl').SeqRule}
  */
 function commaSep1(rule) {
   return seq(rule, repeat(seq(',', rule)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willbooster/tree-sitter-c",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "C grammar for tree-sitter",
   "keywords": [
     "incremental",
@@ -16,6 +16,7 @@
   "author": "WillBooster Inc.",
   "files": [
     "grammar.js",
+    "types/*",
     "queries/*.scm",
     "src/node-types.json",
     "tree-sitter.json",
@@ -55,7 +56,6 @@
     "playwright": "1.63.0",
     "semantic-release": "25.0.9",
     "sort-package-json": "4.0.0",
-    "tree-sitter-cli": "0.27.0",
     "typescript": "7.0.2",
     "vitest": "5.0.1",
     "wrangler": "4.136.1"

package/tree-sitter.json

@@ -16,7 +16,7 @@
     }
   ],
   "metadata": {
-    "version": "1.1.6",
+    "version": "1.1.7",
     "license": "MIT",
     "description": "C grammar for tree-sitter",
     "authors": [

package/types/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Max Brunsfeld
+
+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/types/treeSitterDsl.d.ts

@@ -0,0 +1,451 @@
+// DSL declarations from tree-sitter-cli 0.27.0, matching the fork CLI's upstream grammar API.
+export type AliasRule = { type: 'ALIAS'; named: boolean; content: Rule; value: string };
+export type BlankRule = { type: 'BLANK' };
+export type ChoiceRule = { type: 'CHOICE'; members: Rule[] };
+export type FieldRule = { type: 'FIELD'; name: string; content: Rule };
+export type ImmediateTokenRule = { type: 'IMMEDIATE_TOKEN'; content: Rule };
+export type PatternRule = { type: 'PATTERN'; value: string; flags?: string };
+export type PrecedenceValue = string | number;
+export type PrecDynamicRule = { type: 'PREC_DYNAMIC'; content: Rule; value: number };
+export type PrecLeftRule = { type: 'PREC_LEFT'; content: Rule; value: PrecedenceValue };
+export type PrecRightRule = { type: 'PREC_RIGHT'; content: Rule; value: PrecedenceValue };
+export type PrecRule = { type: 'PREC'; content: Rule; value: PrecedenceValue };
+export type Repeat1Rule = { type: 'REPEAT1'; content: Rule };
+export type RepeatRule = { type: 'REPEAT'; content: Rule };
+export type ReservedRule = { type: 'RESERVED'; content: Rule; context_name: string };
+export type SeqRule = { type: 'SEQ'; members: Rule[] };
+export type StringRule = { type: 'STRING'; value: string };
+export type SymbolRule<Name extends string> = { type: 'SYMBOL'; name: Name };
+export type PrecedenceEntry = StringRule | SymbolRule<string>;
+export type TokenRule = { type: 'TOKEN'; content: Rule };
+export type EOFRule = { type: 'EOF' };
+
+
+export type Rule =
+  | AliasRule
+  | BlankRule
+  | ChoiceRule
+  | FieldRule
+  | ImmediateTokenRule
+  | PatternRule
+  | PrecDynamicRule
+  | PrecLeftRule
+  | PrecRightRule
+  | PrecRule
+  | Repeat1Rule
+  | RepeatRule
+  | ReservedRule
+  | SeqRule
+  | StringRule
+  | SymbolRule<string>
+  | TokenRule
+  | EOFRule;
+
+export declare class RustRegex {
+  value: string;
+
+  constructor(pattern: string);
+}
+
+export type RuleOrLiteral = Rule | RegExp | RustRegex | string;
+
+export type GrammarSymbols<RuleName extends string> = {
+  [name in RuleName]: SymbolRule<name>;
+} &
+  Record<string, SymbolRule<string>>;
+
+export type RuleBuilder<RuleName extends string> = (
+  $: GrammarSymbols<RuleName>,
+  previous?: Rule,
+) => RuleOrLiteral;
+
+export type RuleBuilders<
+  RuleName extends string,
+  BaseGrammarRuleName extends string
+> = {
+    [name in RuleName]: RuleBuilder<RuleName | BaseGrammarRuleName>;
+  };
+
+export interface Grammar<
+  RuleName extends string,
+  BaseGrammarRuleName extends string = never,
+  Rules extends RuleBuilders<RuleName, BaseGrammarRuleName> = RuleBuilders<
+    RuleName,
+    BaseGrammarRuleName
+  >
+> {
+  /**
+   * Name of the grammar language.
+   */
+  name: string;
+
+  /** Mapping of grammar rule names to rule builder functions. */
+  rules: Rules;
+
+  /**
+   * An array of arrays of precedence names or rules. Each inner array represents
+   * a *descending* ordering. Names/rules listed earlier in one of these arrays
+   * have higher precedence than any names/rules listed later in the same array.
+   *
+   * Using rules is just a shorthand way for using a name then calling prec()
+   * with that name. It is just a convenience.
+   */
+  precedences?: (
+    $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+    previous: PrecedenceEntry[][],
+  ) => (string | PrecedenceEntry)[][],
+
+  /**
+   * An array of arrays of rule names. Each inner array represents a set of
+   * rules that's involved in an _LR(1) conflict_ that is _intended to exist_
+   * in the grammar. When these conflicts occur at runtime, Tree-sitter will
+   * use the GLR algorithm to explore all of the possible interpretations. If
+   * _multiple_ parses end up succeeding, Tree-sitter will pick the subtree
+   * whose corresponding rule has the highest total _dynamic precedence_.
+   *
+   * @param $ grammar rules
+   */
+  conflicts?: (
+    $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+    previous: SymbolRule<string>[][],
+  ) => SymbolRule<string>[][];
+
+  /**
+   * An array of token names which can be returned by an _external scanner_.
+   * External scanners allow you to write custom C code which runs during the
+   * lexing process in order to handle lexical rules (e.g. Python's indentation
+   * tokens) that cannot be described by regular expressions.
+   *
+   * @param $ grammar rules
+   * @param previous array of externals from the base schema, if any
+   *
+   * @see https://tree-sitter.github.io/tree-sitter/creating-parsers/4-external-scanners
+   */
+  externals?: (
+    $: Record<string, SymbolRule<string>>,
+    previous: Rule[],
+  ) => RuleOrLiteral[];
+
+  /**
+   * An array of tokens that may appear anywhere in the language. This
+   * is often used for whitespace and comments. The default value of
+   * extras is to accept whitespace. To control whitespace explicitly,
+   * specify extras: `$ => []` in your grammar.
+   *
+   *  @param $ grammar rules
+   *  @param previous array of extras from the base grammar
+   */
+  extras?: (
+    $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+    previous: Rule[],
+  ) => RuleOrLiteral[];
+
+  /**
+   * An array of rules that should be automatically removed from the
+   * grammar by replacing all of their usages with a copy of their definition.
+   * This is useful for rules that are used in multiple places but for which
+   * you don't want to create syntax tree nodes at runtime.
+   *
+   * @param $ grammar rules
+   */
+  inline?: (
+    $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+    previous: SymbolRule<string>[],
+  ) => SymbolRule<string>[];
+
+  /**
+   * A list of hidden rule names that should be considered supertypes in the
+   * generated node types file.
+   *
+   * @param $ grammar rules
+   *
+   * @see https://tree-sitter.github.io/tree-sitter/using-parsers/6-static-node-types
+   */
+  supertypes?: (
+    $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+    previous: SymbolRule<string>[],
+  ) => SymbolRule<string>[];
+
+  /**
+   * The name of a token that will match keywords for the purpose of the
+   * keyword extraction optimization.
+   *
+   * @param $ grammar rules
+   *
+   * @see https://tree-sitter.github.io/tree-sitter/creating-parsers/3-writing-the-grammar#keyword-extraction
+   */
+  word?: (
+    $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+  ) => SymbolRule<string>;
+
+
+  /**
+   * Mapping of names to reserved word sets. The first reserved word set is the
+   * global word set, meaning it applies to every rule in every parse state.
+   * The other word sets can be used with the `reserved` function. Each callback
+   * receives the base grammar's reserved word set of the same name as its second
+   * argument, or `undefined` if no matching set exists.
+   */
+  reserved?: Record<
+    string,
+    (
+      $: GrammarSymbols<RuleName | BaseGrammarRuleName>,
+      previous: Rule[] | undefined,
+    ) => RuleOrLiteral[]
+  >;
+}
+
+/**
+ * Return type of grammar(). The runtime evaluates and normalizes the grammar
+ * beneath a "grammar" key. Optional input fields become required output fields
+ * with default values when not provided.
+ */
+export type GrammarSchema<RuleName extends string> = {
+  grammar: {
+    name: string;
+    /** Base grammar name when extending; undefined for root grammars. */
+    inherits: string | undefined;
+    rules: Record<RuleName, Rule>;
+    precedences: PrecedenceEntry[][];
+    conflicts: string[][];
+    externals: Rule[];
+    extras: Rule[];
+    inline: string[];
+    supertypes: string[];
+    word: string | undefined;
+    reserved: Record<string, Rule[]>;
+  };
+};
+
+/**
+ * Causes the given rule to appear with an alternative name in the syntax tree.
+ * For instance with `alias($.foo, 'bar')`, the aliased rule will appear as an
+ * anonymous node, as if the rule had been written as the simple string.
+ *
+ * @param rule rule that will be aliased
+ * @param name target name for the alias
+ */
+export declare function alias(rule: RuleOrLiteral, name: string): AliasRule;
+
+/**
+ * Causes the given rule to appear as an alternative named node, for instance
+ * with `alias($.foo, $.bar)`, the aliased rule `foo` will appear as a named
+ * node called `bar`.
+ *
+ * @param rule rule that will be aliased
+ * @param symbol target symbol for the alias
+ */
+export declare function alias(
+  rule: RuleOrLiteral,
+  symbol: SymbolRule<string>,
+): AliasRule;
+
+/**
+ * Creates a blank rule, matching nothing.
+ */
+export declare function blank(): BlankRule;
+
+/**
+ * Assigns a field name to the child node(s) matched by the given rule.
+ * In the resulting syntax tree, you can then use that field name to
+ * access specific children.
+ *
+ * @param name name of the field
+ * @param rule rule the field should match
+ */
+export declare function field(name: string, rule: RuleOrLiteral): FieldRule;
+
+/**
+ * Creates a rule that matches one of a set of possible rules. The order
+ * of the arguments does not matter. This is analogous to the `|` (pipe)
+ * operator in EBNF notation.
+ *
+ * @param options possible rule choices
+ */
+export declare function choice(...options: RuleOrLiteral[]): ChoiceRule;
+
+/**
+ * Creates a rule that matches zero or one occurrence of a given rule.
+ * It is analogous to the `[x]` (square bracket) syntax in EBNF notation.
+ *
+ * @param value rule to be made optional
+ */
+export declare function optional(rule: RuleOrLiteral): ChoiceRule;
+
+/**
+ * Marks the given rule with a precedence which will be used to resolve LR(1)
+ * conflicts at parser-generation time. When two rules overlap in a way that
+ * represents either a true ambiguity or a _local_ ambiguity given one token
+ * of lookahead, Tree-sitter will try to resolve the conflict by matching the
+ * rule with the higher precedence.
+ *
+ * Precedence values can either be strings or numbers. When comparing rules
+ * with numerical precedence, higher numbers indicate higher precedences. To
+ * compare rules with string precedence, Tree-sitter uses the grammar's `precedences`
+ * field.
+ *
+ * The default precedence of all rules is zero. This works similarly to the precedence directives in Yacc grammars.
+ *
+ * @param value precedence weight
+ * @param rule rule being weighted
+ *
+ * @see https://en.wikipedia.org/wiki/LR_parser#Conflicts_in_the_constructed_tables
+ * @see https://docs.oracle.com/cd/E19504-01/802-5880/6i9k05dh3/index.html
+ */
+export declare const prec: {
+  (value: string | number, rule: RuleOrLiteral): PrecRule;
+
+  /**
+   * Marks the given rule as left-associative (and optionally applies a
+   * numerical precedence). When an LR(1) conflict arises in which all of the
+   * rules have the same numerical precedence, Tree-sitter will consult the
+   * rules' associativity. If there is a left-associative rule, Tree-sitter
+   * will prefer matching a rule that ends _earlier_. This works similarly to
+   * associativity directives in Yacc grammars.
+   *
+   * @param value (optional) precedence weight
+   * @param rule rule to mark as left-associative
+   *
+   * @see https://docs.oracle.com/cd/E19504-01/802-5880/6i9k05dh3/index.html
+   */
+  left(rule: RuleOrLiteral): PrecLeftRule;
+  left(value: string | number, rule: RuleOrLiteral): PrecLeftRule;
+
+  /**
+   * Marks the given rule as right-associative (and optionally applies a
+   * numerical precedence). When an LR(1) conflict arises in which all of the
+   * rules have the same numerical precedence, Tree-sitter will consult the
+   * rules' associativity. If there is a right-associative rule, Tree-sitter
+   * will prefer matching a rule that ends _later_. This works similarly to
+   * associativity directives in Yacc grammars.
+   *
+   * @param value (optional) precedence weight
+   * @param rule rule to mark as right-associative
+   *
+   * @see https://docs.oracle.com/cd/E19504-01/802-5880/6i9k05dh3/index.html
+   */
+  right(rule: RuleOrLiteral): PrecRightRule;
+  right(value: string | number, rule: RuleOrLiteral): PrecRightRule;
+
+  /**
+   * Marks the given rule with a numerical precedence which will be used to
+   * resolve LR(1) conflicts at _runtime_ instead of parser-generation time.
+   * This is only necessary when handling a conflict dynamically using the
+   * `conflicts` field in the grammar, and when there is a genuine _ambiguity_:
+   * multiple rules correctly match a given piece of code. In that event,
+   * Tree-sitter compares the total dynamic precedence associated with each
+   * rule, and selects the one with the highest total. This is similar to
+   * dynamic precedence directives in Bison grammars.
+   *
+   * @param value precedence weight
+   * @param rule rule being weighted
+   *
+   * @see https://www.gnu.org/software/bison/manual/html_node/Generalized-LR-Parsing.html
+   */
+  dynamic(value: number, rule: RuleOrLiteral): PrecDynamicRule;
+};
+
+/**
+ * Creates a rule that matches _zero-or-more_ occurrences of a given rule.
+ * It is analogous to the `{x}` (curly brace) syntax in EBNF notation. This
+ * rule is implemented in terms of `repeat1` but is included because it
+ * is very commonly used.
+ *
+ * @param rule rule to repeat, zero or more times
+ */
+export declare function repeat(rule: RuleOrLiteral): RepeatRule;
+
+/**
+ * Creates a rule that matches one-or-more occurrences of a given rule.
+ *
+ * @param rule rule to repeat, one or more times
+ */
+export declare function repeat1(rule: RuleOrLiteral): Repeat1Rule;
+
+/**
+ * Overrides the global reserved word set for a given rule. The word set name
+ * should be defined in the `reserved` field in the grammar.
+ *
+ * @param wordset name of the reserved word set
+ * @param rule rule that will use the reserved word set
+ */
+export declare function reserved(wordset: string, rule: RuleOrLiteral): ReservedRule;
+
+/**
+ * Creates a rule that matches any number of other rules, one after another.
+ * It is analogous to simply writing multiple symbols next to each other
+ * in EBNF notation.
+ *
+ * @param rules ordered rules that comprise the sequence
+ */
+export declare function seq(...rules: RuleOrLiteral[]): SeqRule;
+
+/**
+ * Creates a symbol rule, representing another rule in the grammar by name.
+ *
+ * @param name name of the target rule
+ */
+export declare function sym<Name extends string>(name: Name): SymbolRule<Name>;
+
+/**
+ * Marks the given rule as producing only a single token. Tree-sitter's
+ * default is to treat each string or RegExp literal in the grammar as a
+ * separate token. Each token is matched separately by the lexer and
+ * returned as its own leaf node in the tree. The token function allows
+ * you to express a complex rule using the DSL functions (rather
+ * than as a single regular expression) but still have Tree-sitter treat
+ * it as a single token.
+ *
+ * @param rule rule to represent as a single token
+ */
+export declare const token: {
+  (rule: RuleOrLiteral): TokenRule;
+
+  /**
+   * Marks the given rule as producing an immediate token. This allows
+   * the parser to produce a different token based on whether or not
+   * there are `extras` preceding the token's main content. When there
+   * are _no_ leading `extras`, an immediate token is preferred over a
+   * normal token which would otherwise match.
+   *
+   * @param rule rule to represent as an immediate token
+   */
+  immediate(rule: RuleOrLiteral): ImmediateTokenRule;
+};
+
+/**
+ * Matches the end of input. May only appear as the final symbol of a
+ * (possibly nested) sequence; a production ending in `eof()` reduces only
+ * when the lookahead is end-of-input, rather than shifting a token.
+ *
+ * Choice branches that continue past `eof()` are dropped as unreachable,
+ * and `eof()` is not allowed inside `token()`.
+ *
+ * Useful when a rule should match either an explicit terminator (e.g. a
+ * newline) or the end of the file.
+ */
+export declare function eof(): EOFRule;
+
+/**
+ * Creates a new language grammar with the provided schema.
+ *
+ * @param options grammar options
+ */
+export declare function grammar<RuleName extends string>(
+  options: Grammar<RuleName>,
+): GrammarSchema<RuleName>;
+
+/**
+ * Extends an existing language grammar with the provided options,
+ * creating a new language.
+ *
+ * @param baseGrammar base grammar schema to extend from
+ * @param options grammar options for the new extended language
+ */
+export declare function grammar<
+  BaseGrammarRuleName extends string,
+  RuleName extends string
+>(
+  baseGrammar: GrammarSchema<BaseGrammarRuleName>,
+  options: Grammar<RuleName, BaseGrammarRuleName>,
+): GrammarSchema<RuleName | BaseGrammarRuleName>;