npm - tree-sitter-clojure-orchard - Versions diffs - 0.2.4 → 0.2.8 - Mend

tree-sitter-clojure-orchard 0.2.4 → 0.2.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/README.md +21 -4
package/bindings/node/binding_test.js +7 -5
package/bindings/node/index.d.ts +36 -3
package/bindings/node/index.js +34 -8
package/grammar.js +1 -1
package/package.json +11 -7
package/src/parser.c +105 -102
package/src/tree_sitter/array.h +118 -73
package/tree-sitter-clojure_orchard.wasm +0 -0
package/tree-sitter.json +4 -3

package/README.md CHANGED Viewed

@@ -2,13 +2,30 @@
 [![crates][crates]](https://crates.io/crates/tree-sitter-clojure-orchard)
 [![pypi][pypi]](https://pypi.org/project/tree-sitter-clojure-orchard)
+[![npm][npm]](https://www.npmjs.com/package/tree-sitter-clojure-orchard)
-This is a fork of the [tree-sitter-clojure](https://github.com/sogaiu/tree-sitter-clojure) grammar.
+This is a tree-sitter grammar for Clojure.
-Note that unlike upstream, generated files are not checked into git, so you need to run `tree-sitter generate` after cloning this repository.
-Generated files are also available in the archives found in releases.
+### Using it
+You can obtain this parser in various formats:
+* as an archive from [the Releases page](/grammar-orchard/tree-sitter-clojure-orchard/releases), which contains all the generated files (bindings, parser code)
+* as a Rust crate: `cargo add tree-sitter-clojure-orchard`
+* as a Python package: `pip install tree-sitter-clojure-orchard`
+* as an NPM package: `npm install tree-sitter-clojure-orchard`
+### Contributing
 Contributions are welcome, so are co-maintainers.
-[crates]: https://img.shields.io/crates/v/tree-sitter-clojure-orchard?logo=clojure
+Unlike many grammar repositories, this one does not track generated files.
+After cloning this repository, you'll need to run `tree-sitter generate` to obtain the parser.
+If you want to use it via bindings, you'll also need to run `tree-sitter init`.
+### Origin
+This project was forked from https://github.com/sogaiu/tree-sitter-clojure, to [ease the use and collaboration](https://codeberg.org/grammar-orchard) on this grammar
+[crates]: https://img.shields.io/crates/v/tree-sitter-clojure-orchard?logo=rust
 [pypi]: https://img.shields.io/pypi/v/tree-sitter-clojure-orchard?logo=pypi&logoColor=ffd242
+[npm]: https://img.shields.io/npm/v/tree-sitter-clojure-orchard?logo=npm

package/bindings/node/binding_test.js CHANGED Viewed

@@ -1,9 +1,11 @@
-const assert = require("node:assert");
-const { test } = require("node:test");
-const Parser = require("tree-sitter");
+import assert from "node:assert";
+import { test } from "node:test";
+import Parser from "tree-sitter";
 test("can load grammar", () => {
   const parser = new Parser();
-  assert.doesNotThrow(() => parser.setLanguage(require(".")));
+  assert.doesNotReject(async () => {
+    const { default: language } = await import("./index.js");
+    parser.setLanguage(language);
+  });
 });

package/bindings/node/index.d.ts CHANGED Viewed

@@ -18,10 +18,43 @@ type NodeInfo =
       children: ChildNode[];
     });
-type Language = {
+/**
+ * The tree-sitter language object for this grammar.
+ *
+ * @see {@linkcode https://tree-sitter.github.io/node-tree-sitter/interfaces/Parser.Language.html Parser.Language}
+ *
+ * @example
+ * import Parser from "tree-sitter";
+ * import ClojureOrchard from "tree-sitter-clojure-orchard";
+ *
+ * const parser = new Parser();
+ * parser.setLanguage(ClojureOrchard);
+ */
+declare const binding: {
+  /**
+   * The inner language object.
+   * @private
+   */
   language: unknown;
+  /**
+   * The content of the `node-types.json` file for this grammar.
+   *
+   * @see {@linkplain https://tree-sitter.github.io/tree-sitter/using-parsers/6-static-node-types Static Node Types}
+   */
   nodeTypeInfo: NodeInfo[];
+  /** The syntax highlighting query for this grammar. */
+  HIGHLIGHTS_QUERY?: string;
+  /** The language injection query for this grammar. */
+  INJECTIONS_QUERY?: string;
+  /** The local variable query for this grammar. */
+  LOCALS_QUERY?: string;
+  /** The symbol tagging query for this grammar. */
+  TAGS_QUERY?: string;
 };
-declare const language: Language;
-export = language;
+export default binding;

package/bindings/node/index.js CHANGED Viewed

@@ -1,11 +1,37 @@
-const root = require("path").join(__dirname, "..", "..");
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
-module.exports =
-  typeof process.versions.bun === "string"
-    // Support `bun build --compile` by being statically analyzable enough to find the .node file at build-time
-    ? require(`../../prebuilds/${process.platform}-${process.arch}/tree-sitter-clojure-orchard.node`)
-    : require("node-gyp-build")(root);
+const root = fileURLToPath(new URL("../..", import.meta.url));
+const binding = typeof process.versions.bun === "string"
+  // Support `bun build --compile` by being statically analyzable enough to find the .node file at build-time
+  ? await import(`${root}/prebuilds/${process.platform}-${process.arch}/tree-sitter-clojure-orchard.node`)
+  : (await import("node-gyp-build")).default(root);
 try {
-  module.exports.nodeTypeInfo = require("../../src/node-types.json");
-} catch (_) {}
+  const nodeTypes = await import(`${root}/src/node-types.json`, { with: { type: "json" } });
+  binding.nodeTypeInfo = nodeTypes.default;
+} catch { }
+const queries = [
+  ["HIGHLIGHTS_QUERY", `${root}/queries/highlights.scm`],
+  ["INJECTIONS_QUERY", `${root}/queries/injections.scm`],
+  ["LOCALS_QUERY", `${root}/queries/locals.scm`],
+  ["TAGS_QUERY", `${root}/queries/tags.scm`],
+];
+for (const [prop, path] of queries) {
+  Object.defineProperty(binding, prop, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      delete binding[prop];
+      try {
+        binding[prop] = readFileSync(path, "utf8");
+      } catch { }
+      return binding[prop];
+    }
+  });
+}
+export default binding;

package/grammar.js CHANGED Viewed

@@ -227,7 +227,7 @@ const SYMBOL =
       token(seq(SYMBOL_HEAD,
                 repeat(SYMBOL_BODY)));
-module.exports = grammar({
+export default grammar({
   name: 'clojure_orchard',
   extras: $ =>

package/package.json CHANGED Viewed

@@ -1,11 +1,15 @@
 {
   "name": "tree-sitter-clojure-orchard",
-  "version": "0.2.4",
+  "version": "0.2.8",
   "description": "Parser for Clojure files",
-  "repository": "https://codeberg.org/grammar-orchard/tree-sitter-clojure-orchard",
-  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://codeberg.org/grammar-orchard/tree-sitter-clojure-orchard.git"
+  },
+  "license": "CC0-1.0",
   "author": {
-    "name": "a"
+    "name": "sogaiu"
   },
   "main": "bindings/node",
   "types": "bindings/node",
@@ -31,11 +35,11 @@
   },
   "devDependencies": {
     "prebuildify": "^6.0.1",
-    "tree-sitter": "^0.22.4",
-    "tree-sitter-cli": "^0.25.9"
+    "tree-sitter": "^0.25.0",
+    "tree-sitter-cli": "^0.26.11"
   },
   "peerDependencies": {
-    "tree-sitter": "^0.22.4"
+    "tree-sitter": "^0.25.0"
   },
   "peerDependenciesMeta": {
     "tree-sitter": {

package/src/parser.c CHANGED Viewed

@@ -1,4 +1,4 @@
-/* Automatically @generated by tree-sitter v0.25.10 */
+/* Automatically @generated by tree-sitter */
 #include "tree_sitter/parser.h"
@@ -6,7 +6,7 @@
 #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
 #endif
-#define LANGUAGE_VERSION 15
+#define LANGUAGE_VERSION 14
 #define STATE_COUNT 496
 #define LARGE_STATE_COUNT 213
 #define SYMBOL_COUNT 73
@@ -1334,26 +1334,26 @@ static const TSCharacterRange sym__ws_character_set_1[] = {
 static const TSCharacterRange aux_sym__kwd_leading_slash_token1_character_set_1[] = {
   {0, 0x08}, {0x0e, 0x1b}, {'!', '!'}, {'#', '\''}, {'*', '+'}, {'-', ':'}, {'<', '?'}, {'A', 'Z'},
-  {'_', '_'}, {'a', 'z'}, {'|', '|'}, {0x7f, 0x167f}, {0x1681, 0x1fff}, {0x2007, 0x2007}, {0x200b, 0x2027}, {0x202a, 0x205e},
-  {0x2060, 0x2fff}, {0x3001, 0x10ffff},
+  {'_', '_'}, {'a', 'z'}, {'|', '|'}, {0x7f, 0x17e}, {0x180, 0x167f}, {0x1681, 0x1fff}, {0x2007, 0x2007}, {0x200b, 0x2027},
+  {0x202a, 0x205e}, {0x2060, 0x2129}, {0x212b, 0x2fff}, {0x3001, 0x10ffff},
 };
 static const TSCharacterRange aux_sym__kwd_qualified_token1_character_set_1[] = {
   {0, 0x08}, {0x0e, 0x1b}, {'!', '!'}, {'#', '\''}, {'*', '+'}, {'-', '.'}, {'0', '9'}, {'<', '?'},
-  {'A', 'Z'}, {'_', '_'}, {'a', 'z'}, {'|', '|'}, {0x7f, 0x167f}, {0x1681, 0x1fff}, {0x2007, 0x2007}, {0x200b, 0x2027},
-  {0x202a, 0x205e}, {0x2060, 0x2fff}, {0x3001, 0x10ffff},
+  {'A', 'Z'}, {'_', '_'}, {'a', 'z'}, {'|', '|'}, {0x7f, 0x17e}, {0x180, 0x167f}, {0x1681, 0x1fff}, {0x2007, 0x2007},
+  {0x200b, 0x2027}, {0x202a, 0x205e}, {0x2060, 0x2129}, {0x212b, 0x2fff}, {0x3001, 0x10ffff},
 };
 static const TSCharacterRange aux_sym__kwd_qualified_token1_character_set_2[] = {
   {0, 0x08}, {0x0e, 0x1b}, {'!', '!'}, {'#', '\''}, {'*', '+'}, {'-', '.'}, {'0', ':'}, {'<', '?'},
-  {'A', 'Z'}, {'_', '_'}, {'a', 'z'}, {'|', '|'}, {0x7f, 0x167f}, {0x1681, 0x1fff}, {0x2007, 0x2007}, {0x200b, 0x2027},
-  {0x202a, 0x205e}, {0x2060, 0x2fff}, {0x3001, 0x10ffff},
+  {'A', 'Z'}, {'_', '_'}, {'a', 'z'}, {'|', '|'}, {0x7f, 0x17e}, {0x180, 0x167f}, {0x1681, 0x1fff}, {0x2007, 0x2007},
+  {0x200b, 0x2027}, {0x202a, 0x205e}, {0x2060, 0x2129}, {0x212b, 0x2fff}, {0x3001, 0x10ffff},
 };
 static const TSCharacterRange aux_sym__sym_qualified_token1_character_set_1[] = {
   {0, 0x08}, {0x0e, 0x1b}, {'!', '!'}, {'$', '&'}, {'*', '+'}, {'-', '.'}, {'<', '?'}, {'A', 'Z'},
-  {'_', '_'}, {'a', 'z'}, {'|', '|'}, {0x7f, 0x167f}, {0x1681, 0x1fff}, {0x2007, 0x2007}, {0x200b, 0x2027}, {0x202a, 0x205e},
-  {0x2060, 0x2fff}, {0x3001, 0x10ffff},
+  {'_', '_'}, {'a', 'z'}, {'|', '|'}, {0x7f, 0x17e}, {0x180, 0x167f}, {0x1681, 0x1fff}, {0x2007, 0x2007}, {0x200b, 0x2027},
+  {0x202a, 0x205e}, {0x2060, 0x2129}, {0x212b, 0x2fff}, {0x3001, 0x10ffff},
 };
 static bool ts_lex(TSLexer *lexer, TSStateId state) {
@@ -1389,7 +1389,9 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       );
       if (('1' <= lookahead && lookahead <= '9')) ADVANCE(57);
       if (set_contains(sym__ws_character_set_1, 9, lookahead)) ADVANCE(46);
-      if (lookahead != 0) ADVANCE(93);
+      if (lookahead != 0 &&
+          lookahead != 0x17f &&
+          lookahead != 0x212a) ADVANCE(93);
       END_STATE();
     case 1:
       ADVANCE_MAP(
@@ -1413,12 +1415,16 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
           (lookahead < '/' || ';' < lookahead) &&
           (lookahead < '[' || '^' < lookahead) &&
           lookahead != '}' &&
-          lookahead != '~') ADVANCE(134);
+          lookahead != '~' &&
+          lookahead != 0x17f &&
+          lookahead != 0x212a) ADVANCE(134);
       END_STATE();
     case 2:
       if (lookahead == '"') ADVANCE(106);
       if (lookahead == '\\') ADVANCE(43);
-      if (lookahead != 0) ADVANCE(2);
+      if (lookahead != 0 &&
+          lookahead != 0x17f &&
+          lookahead != 0x212a) ADVANCE(2);
       END_STATE();
     case 3:
       ADVANCE_MAP(
@@ -1433,7 +1439,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
         '{', 140,
         '~', 164,
       );
-      if ((!eof && set_contains(aux_sym__sym_qualified_token1_character_set_1, 18, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__sym_qualified_token1_character_set_1, 20, lookahead))) ADVANCE(134);
       END_STATE();
     case 4:
       ADVANCE_MAP(
@@ -1457,7 +1463,9 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
           (lookahead < '\'' || ')' < lookahead) &&
           (lookahead < '[' || '^' < lookahead) &&
           lookahead != '}' &&
-          lookahead != '~') ADVANCE(93);
+          lookahead != '~' &&
+          lookahead != 0x17f &&
+          lookahead != 0x212a) ADVANCE(93);
       END_STATE();
     case 5:
       if (lookahead == '#') ADVANCE(77);
@@ -1468,7 +1476,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       if (lookahead == '\'' ||
           ('0' <= lookahead && lookahead <= ':')) ADVANCE(99);
       if (set_contains(sym__ws_character_set_1, 9, lookahead)) ADVANCE(46);
-      if ((!eof && set_contains(aux_sym__sym_qualified_token1_character_set_1, 18, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__sym_qualified_token1_character_set_1, 20, lookahead))) ADVANCE(93);
       END_STATE();
     case 6:
       if (lookahead == '#') ADVANCE(78);
@@ -1478,7 +1486,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       if (lookahead == '\'' ||
           ('0' <= lookahead && lookahead <= ':')) ADVANCE(99);
       if (set_contains(sym__ws_character_set_1, 9, lookahead)) ADVANCE(46);
-      if ((!eof && set_contains(aux_sym__sym_qualified_token1_character_set_1, 18, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__sym_qualified_token1_character_set_1, 20, lookahead))) ADVANCE(93);
       END_STATE();
     case 7:
       if (lookahead == '#') ADVANCE(100);
@@ -1486,27 +1494,18 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       if (lookahead == ';') ADVANCE(50);
       if (lookahead == '{') ADVANCE(140);
       if (set_contains(sym__ws_character_set_1, 9, lookahead)) ADVANCE(46);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_1, 19, lookahead))) ADVANCE(101);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_1, 21, lookahead))) ADVANCE(101);
       END_STATE();
     case 8:
       if (lookahead == '#') ADVANCE(79);
       if (lookahead == ';') ADVANCE(50);
       if (lookahead == '{') ADVANCE(140);
       if (set_contains(sym__ws_character_set_1, 9, lookahead)) ADVANCE(46);
-      if (lookahead != 0 &&
-          lookahead != '"' &&
-          lookahead != '#' &&
-          lookahead != '(' &&
-          lookahead != ')' &&
-          lookahead != '@' &&
-          (lookahead < '[' || '^' < lookahead) &&
-          lookahead != '`' &&
-          lookahead != '}' &&
-          lookahead != '~') ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 9:
       if (lookahead == '/') ADVANCE(75);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_1, 19, lookahead))) ADVANCE(101);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_1, 21, lookahead))) ADVANCE(101);
       END_STATE();
     case 10:
       if (lookahead == 'a') ADVANCE(14);
@@ -1522,7 +1521,9 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
         't', 109,
         'u', 117,
       );
-      if (lookahead != 0) ADVANCE(107);
+      if (lookahead != 0 &&
+          lookahead != 0x17f &&
+          lookahead != 0x212a) ADVANCE(107);
       END_STATE();
     case 12:
       if (lookahead == 'b') ADVANCE(107);
@@ -1624,14 +1625,16 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
           ('a' <= lookahead && lookahead <= 'z')) ADVANCE(74);
       END_STATE();
     case 41:
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 42:
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(135);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(135);
       END_STATE();
     case 43:
       if (lookahead != 0 &&
-          lookahead != '\n') ADVANCE(2);
+          lookahead != '\n' &&
+          lookahead != 0x17f &&
+          lookahead != 0x212a) ADVANCE(2);
       END_STATE();
     case 44:
       if (eof) ADVANCE(45);
@@ -1662,7 +1665,9 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       );
       if (('1' <= lookahead && lookahead <= '9')) ADVANCE(63);
       if (set_contains(sym__ws_character_set_1, 9, lookahead)) ADVANCE(46);
-      if (lookahead != 0) ADVANCE(134);
+      if (lookahead != 0 &&
+          lookahead != 0x17f &&
+          lookahead != 0x212a) ADVANCE(134);
       END_STATE();
     case 45:
       ACCEPT_TOKEN(ts_builtin_sym_end);
@@ -1688,7 +1693,9 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
           lookahead == '{' ||
           lookahead == '}' ||
           lookahead == '~') ADVANCE(50);
-      if (lookahead != 0) ADVANCE(48);
+      if (lookahead != 0 &&
+          lookahead != 0x17f &&
+          lookahead != 0x212a) ADVANCE(48);
       END_STATE();
     case 49:
       ACCEPT_TOKEN(sym_comment);
@@ -1705,23 +1712,27 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
           lookahead == '{' ||
           lookahead == '}' ||
           lookahead == '~') ADVANCE(50);
-      if (lookahead != 0) ADVANCE(49);
+      if (lookahead != 0 &&
+          lookahead != 0x17f &&
+          lookahead != 0x212a) ADVANCE(49);
       END_STATE();
     case 50:
       ACCEPT_TOKEN(sym_comment);
       if (lookahead == '\n') ADVANCE(47);
-      if (lookahead != 0) ADVANCE(50);
+      if (lookahead != 0 &&
+          lookahead != 0x17f &&
+          lookahead != 0x212a) ADVANCE(50);
       END_STATE();
     case 51:
       ACCEPT_TOKEN(anon_sym_POUND_);
       END_STATE();
     case 52:
       ACCEPT_TOKEN(anon_sym_POUND_);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(101);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(101);
       END_STATE();
     case 53:
       ACCEPT_TOKEN(anon_sym_POUND_);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 54:
       ACCEPT_TOKEN(sym_num_lit);
@@ -1965,7 +1976,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       END_STATE();
     case 76:
       ACCEPT_TOKEN(anon_sym_SLASH);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 77:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
@@ -1973,75 +1984,75 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       if (lookahead == '?') ADVANCE(151);
       if (lookahead == '^') ADVANCE(137);
       if (lookahead == '_') ADVANCE(53);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 78:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '!') ADVANCE(48);
       if (lookahead == '^') ADVANCE(137);
       if (lookahead == '_') ADVANCE(53);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 79:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '!') ADVANCE(48);
       if (lookahead == '_') ADVANCE(53);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 80:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
       if (lookahead == '0') ADVANCE(58);
       if (('1' <= lookahead && lookahead <= '9')) ADVANCE(60);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 81:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
       if (lookahead == 'a') ADVANCE(84);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 82:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
       if (lookahead == 'e') ADVANCE(93);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 83:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
       if (lookahead == 'i') ADVANCE(85);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 84:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
       if (lookahead == 'l') ADVANCE(87);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 85:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
       if (lookahead == 'l') ADVANCE(118);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 86:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
       if (lookahead == 'r') ADVANCE(88);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 87:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
       if (lookahead == 's') ADVANCE(82);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 88:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
       if (lookahead == 'u') ADVANCE(82);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 89:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
@@ -2049,13 +2060,13 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       if (lookahead == '+' ||
           lookahead == '-') ADVANCE(90);
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(71);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 90:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(71);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 91:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
@@ -2063,7 +2074,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       if (('0' <= lookahead && lookahead <= '9') ||
           ('A' <= lookahead && lookahead <= 'F') ||
           ('a' <= lookahead && lookahead <= 'f')) ADVANCE(72);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 92:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
@@ -2071,62 +2082,62 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       if (('0' <= lookahead && lookahead <= '9') ||
           ('A' <= lookahead && lookahead <= 'Z') ||
           ('a' <= lookahead && lookahead <= 'z')) ADVANCE(74);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 93:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '/') ADVANCE(99);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 94:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (lookahead == '+' ||
           lookahead == '-') ADVANCE(96);
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(71);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 95:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(73);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 96:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(71);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 97:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (('0' <= lookahead && lookahead <= '9') ||
           ('A' <= lookahead && lookahead <= 'F') ||
           ('a' <= lookahead && lookahead <= 'f')) ADVANCE(72);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 98:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
       if (('0' <= lookahead && lookahead <= '9') ||
           ('A' <= lookahead && lookahead <= 'Z') ||
           ('a' <= lookahead && lookahead <= 'z')) ADVANCE(74);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 99:
       ACCEPT_TOKEN(aux_sym__kwd_leading_slash_token1);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 100:
       ACCEPT_TOKEN(aux_sym__kwd_qualified_token1);
       if (lookahead == '!') ADVANCE(49);
       if (lookahead == '_') ADVANCE(52);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(101);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(101);
       END_STATE();
     case 101:
       ACCEPT_TOKEN(aux_sym__kwd_qualified_token1);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(101);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(101);
       END_STATE();
     case 102:
       ACCEPT_TOKEN(anon_sym_COLON);
       if (lookahead == ':') ADVANCE(105);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 103:
       ACCEPT_TOKEN(anon_sym_COLON);
@@ -2137,7 +2148,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       END_STATE();
     case 105:
       ACCEPT_TOKEN(anon_sym_COLON_COLON);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 106:
       ACCEPT_TOKEN(aux_sym_str_lit_token1);
@@ -2190,95 +2201,95 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
     case 118:
       ACCEPT_TOKEN(sym_nil_lit);
       if (lookahead == '/') ADVANCE(99);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(93);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(93);
       END_STATE();
     case 119:
       ACCEPT_TOKEN(sym_nil_lit);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 120:
       ACCEPT_TOKEN(sym_bool_lit);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 121:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (lookahead == '0') ADVANCE(64);
       if (('1' <= lookahead && lookahead <= '9')) ADVANCE(66);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 122:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (lookahead == 'a') ADVANCE(125);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 123:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (lookahead == 'e') ADVANCE(120);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 124:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (lookahead == 'i') ADVANCE(126);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 125:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (lookahead == 'l') ADVANCE(128);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 126:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (lookahead == 'l') ADVANCE(119);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 127:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (lookahead == 'r') ADVANCE(129);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 128:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (lookahead == 's') ADVANCE(123);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 129:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (lookahead == 'u') ADVANCE(123);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 130:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (lookahead == '+' ||
           lookahead == '-') ADVANCE(131);
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(71);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 131:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(71);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 132:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (('0' <= lookahead && lookahead <= '9') ||
           ('A' <= lookahead && lookahead <= 'F') ||
           ('a' <= lookahead && lookahead <= 'f')) ADVANCE(72);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 133:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
       if (('0' <= lookahead && lookahead <= '9') ||
           ('A' <= lookahead && lookahead <= 'Z') ||
           ('a' <= lookahead && lookahead <= 'z')) ADVANCE(74);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 134:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token1);
-      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 19, lookahead))) ADVANCE(134);
+      if ((!eof && set_contains(aux_sym__kwd_qualified_token1_character_set_2, 21, lookahead))) ADVANCE(134);
       END_STATE();
     case 135:
       ACCEPT_TOKEN(aux_sym__sym_qualified_token2);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(135);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(135);
       END_STATE();
     case 136:
       ACCEPT_TOKEN(anon_sym_CARET);
@@ -2332,7 +2343,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       if (lookahead == '?') ADVANCE(150);
       if (lookahead == '^') ADVANCE(137);
       if (lookahead == '_') ADVANCE(53);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 147:
       ACCEPT_TOKEN(anon_sym_POUND);
@@ -2342,7 +2353,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       if (lookahead == '?') ADVANCE(150);
       if (lookahead == '^') ADVANCE(137);
       if (lookahead == '_') ADVANCE(53);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 148:
       ACCEPT_TOKEN(anon_sym_POUND);
@@ -2358,11 +2369,11 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
     case 150:
       ACCEPT_TOKEN(anon_sym_POUND_QMARK);
       if (lookahead == '@') ADVANCE(152);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 151:
       ACCEPT_TOKEN(anon_sym_POUND_QMARK);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 152:
       ACCEPT_TOKEN(anon_sym_POUND_QMARK_AT);
@@ -2372,21 +2383,21 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       END_STATE();
     case 154:
       ACCEPT_TOKEN(anon_sym_POUND_SQUOTE);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 155:
       ACCEPT_TOKEN(anon_sym_POUND_POUND);
       END_STATE();
     case 156:
       ACCEPT_TOKEN(anon_sym_POUND_POUND);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 157:
       ACCEPT_TOKEN(anon_sym_POUND_EQ);
       END_STATE();
     case 158:
       ACCEPT_TOKEN(anon_sym_POUND_EQ);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 159:
       ACCEPT_TOKEN(anon_sym_AT);
@@ -2396,7 +2407,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       END_STATE();
     case 161:
       ACCEPT_TOKEN(anon_sym_SQUOTE);
-      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 18, lookahead))) ADVANCE(99);
+      if ((!eof && set_contains(aux_sym__kwd_leading_slash_token1_character_set_1, 20, lookahead))) ADVANCE(99);
       END_STATE();
     case 162:
       ACCEPT_TOKEN(anon_sym_BQUOTE);
@@ -2413,7 +2424,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
   }
 }
-static const TSLexerMode ts_lex_modes[STATE_COUNT] = {
+static const TSLexMode ts_lex_modes[STATE_COUNT] = {
   [0] = {.lex_state = 0},
   [1] = {.lex_state = 44},
   [2] = {.lex_state = 44},
@@ -24784,7 +24795,6 @@ TS_PUBLIC const TSLanguage *tree_sitter_clojure_orchard(void) {
     .state_count = STATE_COUNT,
     .large_state_count = LARGE_STATE_COUNT,
     .production_id_count = PRODUCTION_ID_COUNT,
-    .supertype_count = SUPERTYPE_COUNT,
     .field_count = FIELD_COUNT,
     .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH,
     .parse_table = &ts_parse_table[0][0],
@@ -24802,13 +24812,6 @@ TS_PUBLIC const TSLanguage *tree_sitter_clojure_orchard(void) {
     .lex_modes = (const void*)ts_lex_modes,
     .lex_fn = ts_lex,
     .primary_state_ids = ts_primary_state_ids,
-    .name = "clojure_orchard",
-    .max_reserved_word_set_size = 0,
-    .metadata = {
-      .major_version = 0,
-      .minor_version = 2,
-      .patch_version = 2,
-    },
   };
   return &language;
 }

package/src/tree_sitter/array.h CHANGED Viewed

@@ -50,69 +50,104 @@ extern "C" {
 /// memory allocated for the array's contents.
 #define array_clear(self) ((self)->size = 0)
+#ifdef __cplusplus
+#define _array__cast(self, expr) (decltype((self)->contents))(expr)
+#else
+#define _array__cast(self, expr) (expr)
+#endif
 /// Reserve `new_capacity` elements of space in the array. If `new_capacity` is
 /// less than the array's current capacity, this function has no effect.
-#define array_reserve(self, new_capacity) \
-  _array__reserve((Array *)(self), array_elem_size(self), new_capacity)
+#define array_reserve(self, new_capacity)                 \
+  ((self)->contents = _array__cast(self, _array__reserve( \
+    (void *)(self)->contents, &(self)->capacity,          \
+    array_elem_size(self), new_capacity))                 \
+  )
 /// Free any memory allocated for this array. Note that this does not free any
 /// memory allocated for the array's contents.
-#define array_delete(self) _array__delete((Array *)(self))
+#define array_delete(self)                           \
+  do {                                               \
+    if ((self)->contents) ts_free((self)->contents); \
+    (self)->contents = NULL;                         \
+    (self)->size = 0;                                \
+    (self)->capacity = 0;                            \
+  } while (0)
 /// Push a new `element` onto the end of the array.
-#define array_push(self, element)                            \
-  (_array__grow((Array *)(self), 1, array_elem_size(self)), \
-   (self)->contents[(self)->size++] = (element))
+#define array_push(self, element)                                 \
+  do {                                                            \
+    (self)->contents = _array__cast(self, _array__grow(           \
+      (void *)(self)->contents, (self)->size, &(self)->capacity,  \
+      1, array_elem_size(self)                                    \
+    ));                                                           \
+   (self)->contents[(self)->size++] = (element);                  \
+  } while(0)
 /// Increase the array's size by `count` elements.
 /// New elements are zero-initialized.
-#define array_grow_by(self, count) \
-  do { \
-    if ((count) == 0) break; \
-    _array__grow((Array *)(self), count, array_elem_size(self)); \
+#define array_grow_by(self, count)                                               \
+  do {                                                                           \
+    if ((count) == 0) break;                                                     \
+    (self)->contents = _array__cast(self, _array__grow(                          \
+      (self)->contents, (self)->size, &(self)->capacity,                         \
+      count, array_elem_size(self)                                               \
+    ));                                                                          \
     memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
-    (self)->size += (count); \
+    (self)->size += (count);                                                     \
   } while (0)
 /// Append all elements from one array to the end of another.
-#define array_push_all(self, other)                                       \
+#define array_push_all(self, other) \
   array_extend((self), (other)->size, (other)->contents)
 /// Append `count` elements to the end of the array, reading their values from the
 /// `contents` pointer.
-#define array_extend(self, count, contents)                    \
-  _array__splice(                                               \
-    (Array *)(self), array_elem_size(self), (self)->size, \
-    0, count,  contents                                        \
-  )
+#define array_extend(self, count, other_contents)                 \
+  ((self)->contents = _array__cast(self, _array__splice(          \
+    (void*)(self)->contents, &(self)->size, &(self)->capacity,    \
+    array_elem_size(self), (self)->size, 0, count, other_contents \
+  )))
 /// Remove `old_count` elements from the array starting at the given `index`. At
 /// the same index, insert `new_count` new elements, reading their values from the
 /// `new_contents` pointer.
-#define array_splice(self, _index, old_count, new_count, new_contents)  \
-  _array__splice(                                                       \
-    (Array *)(self), array_elem_size(self), _index,                \
-    old_count, new_count, new_contents                                 \
-  )
+#define array_splice(self, _index, old_count, new_count, new_contents) \
+  ((self)->contents = _array__cast(self, _array__splice(              \
+    (void *)(self)->contents, &(self)->size, &(self)->capacity,        \
+    array_elem_size(self), _index, old_count, new_count, new_contents  \
+  )))
 /// Insert one `element` into the array at the given `index`.
-#define array_insert(self, _index, element) \
-  _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element))
+#define array_insert(self, _index, element)                     \
+  ((self)->contents = _array__cast(self, _array__splice(        \
+    (void *)(self)->contents, &(self)->size, &(self)->capacity, \
+    array_elem_size(self), _index, 0, 1, &(element)             \
+  )))
 /// Remove one element from the array at the given `index`.
 #define array_erase(self, _index) \
-  _array__erase((Array *)(self), array_elem_size(self), _index)
+  _array__erase((void *)(self)->contents, &(self)->size, array_elem_size(self), _index)
 /// Pop the last element off the array, returning the element by value.
 #define array_pop(self) ((self)->contents[--(self)->size])
 /// Assign the contents of one array to another, reallocating if necessary.
-#define array_assign(self, other) \
-  _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self))
+#define array_assign(self, other)                                   \
+  ((self)->contents = _array__cast(self, _array__assign(            \
+    (void *)(self)->contents, &(self)->size, &(self)->capacity,     \
+    (const void *)(other)->contents, (other)->size, array_elem_size(self) \
+  )))
 /// Swap one array with another
-#define array_swap(self, other) \
-  _array__swap((Array *)(self), (Array *)(other))
+#define array_swap(self, other)                                     \
+  do {                                                              \
+    void *_array_swap_tmp = (void *)(self)->contents;               \
+    (self)->contents = (other)->contents;                           \
+    (other)->contents = _array__cast(other, _array_swap_tmp);       \
+    _array__swap(&(self)->size, &(self)->capacity,                  \
+                 &(other)->size, &(other)->capacity);               \
+  } while (0)
 /// Get the size of the array contents
 #define array_elem_size(self) (sizeof *(self)->contents)
@@ -157,82 +192,90 @@ extern "C" {
 // Private
-typedef Array(void) Array;
-/// This is not what you're looking for, see `array_delete`.
-static inline void _array__delete(Array *self) {
-  if (self->contents) {
-    ts_free(self->contents);
-    self->contents = NULL;
-    self->size = 0;
-    self->capacity = 0;
-  }
-}
+// Pointers to individual `Array` fields (rather than the entire `Array` itself)
+// are passed to the various `_array__*` functions below to address strict aliasing
+// violations that arises when the _entire_ `Array` struct is passed as `Array(void)*`.
+//
+// The `Array` type itself was not altered as a solution in order to avoid breakage
+// with existing consumers (in particular, parsers with external scanners).
 /// This is not what you're looking for, see `array_erase`.
-static inline void _array__erase(Array *self, size_t element_size,
-                                uint32_t index) {
-  assert(index < self->size);
-  char *contents = (char *)self->contents;
+static inline void _array__erase(void* self_contents, uint32_t *size,
+                                size_t element_size, uint32_t index) {
+  assert(index < *size);
+  char *contents = (char *)self_contents;
   memmove(contents + index * element_size, contents + (index + 1) * element_size,
-          (self->size - index - 1) * element_size);
-  self->size--;
+          (*size - index - 1) * element_size);
+  (*size)--;
 }
 /// This is not what you're looking for, see `array_reserve`.
-static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) {
-  if (new_capacity > self->capacity) {
-    if (self->contents) {
-      self->contents = ts_realloc(self->contents, new_capacity * element_size);
+static inline void *_array__reserve(void *contents, uint32_t *capacity,
+                                  size_t element_size, uint32_t new_capacity) {
+  void *new_contents = contents;
+  if (new_capacity > *capacity) {
+    if (contents) {
+      new_contents = ts_realloc(contents, new_capacity * element_size);
     } else {
-      self->contents = ts_malloc(new_capacity * element_size);
+      new_contents = ts_malloc(new_capacity * element_size);
     }
-    self->capacity = new_capacity;
+    *capacity = new_capacity;
   }
+  return new_contents;
 }
 /// This is not what you're looking for, see `array_assign`.
-static inline void _array__assign(Array *self, const Array *other, size_t element_size) {
-  _array__reserve(self, element_size, other->size);
-  self->size = other->size;
-  memcpy(self->contents, other->contents, self->size * element_size);
+static inline void *_array__assign(void* self_contents, uint32_t *self_size, uint32_t *self_capacity,
+                                 const void *other_contents, uint32_t other_size, size_t element_size) {
+  void *new_contents = _array__reserve(self_contents, self_capacity, element_size, other_size);
+  *self_size = other_size;
+  memcpy(new_contents, other_contents, *self_size * element_size);
+  return new_contents;
 }
 /// This is not what you're looking for, see `array_swap`.
-static inline void _array__swap(Array *self, Array *other) {
-  Array swap = *other;
-  *other = *self;
-  *self = swap;
+static inline void _array__swap(uint32_t *self_size, uint32_t *self_capacity,
+                               uint32_t *other_size, uint32_t *other_capacity) {
+  uint32_t tmp_size = *self_size;
+  uint32_t tmp_capacity = *self_capacity;
+  *self_size = *other_size;
+  *self_capacity = *other_capacity;
+  *other_size = tmp_size;
+  *other_capacity = tmp_capacity;
 }
 /// This is not what you're looking for, see `array_push` or `array_grow_by`.
-static inline void _array__grow(Array *self, uint32_t count, size_t element_size) {
-  uint32_t new_size = self->size + count;
-  if (new_size > self->capacity) {
-    uint32_t new_capacity = self->capacity * 2;
+static inline void *_array__grow(void *contents, uint32_t size, uint32_t *capacity,
+                               uint32_t count, size_t element_size) {
+  void *new_contents = contents;
+  uint32_t new_size = size + count;
+  if (new_size > *capacity) {
+    uint32_t new_capacity = *capacity * 2;
     if (new_capacity < 8) new_capacity = 8;
     if (new_capacity < new_size) new_capacity = new_size;
-    _array__reserve(self, element_size, new_capacity);
+    new_contents = _array__reserve(contents, capacity, element_size, new_capacity);
   }
+  return new_contents;
 }
 /// This is not what you're looking for, see `array_splice`.
-static inline void _array__splice(Array *self, size_t element_size,
+static inline void *_array__splice(void *self_contents, uint32_t *size, uint32_t *capacity,
+                                 size_t element_size,
                                  uint32_t index, uint32_t old_count,
                                  uint32_t new_count, const void *elements) {
-  uint32_t new_size = self->size + new_count - old_count;
+  uint32_t new_size = *size + new_count - old_count;
   uint32_t old_end = index + old_count;
   uint32_t new_end = index + new_count;
-  assert(old_end <= self->size);
+  assert(old_end <= *size);
-  _array__reserve(self, element_size, new_size);
+  void *new_contents = _array__reserve(self_contents, capacity, element_size, new_size);
-  char *contents = (char *)self->contents;
-  if (self->size > old_end) {
+  char *contents = (char *)new_contents;
+  if (*size > old_end) {
     memmove(
       contents + new_end * element_size,
       contents + old_end * element_size,
-      (self->size - old_end) * element_size
+      (*size - old_end) * element_size
     );
   }
   if (new_count > 0) {
@@ -250,7 +293,9 @@ static inline void _array__splice(Array *self, size_t element_size,
       );
     }
   }
-  self->size += new_count - old_count;
+  *size += new_count - old_count;
+  return new_contents;
 }
 /// A binary search routine, based on Rust's `std::slice::binary_search_by`.

package/tree-sitter-clojure_orchard.wasm CHANGED Viewed

Binary file

package/tree-sitter.json CHANGED Viewed

@@ -14,8 +14,8 @@
     }
   ],
   "metadata": {
-    "version": "0.2.4",
-    "license": "CC0",
+    "version": "0.2.8",
+    "license": "CC0-1.0",
     "description": "Parser for Clojure files",
     "authors": [
       {
@@ -23,7 +23,8 @@
       }
     ],
     "links": {
-      "repository": "https://codeberg.org/grammar-orchard/tree-sitter-clojure-orchard"
+      "repository": "https://codeberg.org/grammar-orchard/tree-sitter-clojure-orchard",
+      "upstream": "https://github.com/sogaiu/tree-sitter-clojure"
     }
   },
   "bindings": {