tree-sitter-beancount 2.2.0 → 2.3.1

package/.gitattributes

@@ -0,0 +1,6 @@
+/src/** linguist-vendored
+/examples/* linguist-vendored
+
+src/grammar.json -diff
+src/node-types.json -diff
+src/parser.c -diff

package/.github/workflows/cicd.yml

@@ -15,7 +15,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup Node
-        uses: actions/setup-node@v3.8.1
+        uses: actions/setup-node@v4.0.2
         with:
           node-version: '18'
 

package/.github/workflows/release.yml

@@ -9,7 +9,7 @@ jobs:
     outputs:
       release_created: ${{ steps.release.outputs.release_created }}
     steps:
-      - uses: google-github-actions/release-please-action@v3
+      - uses: google-github-actions/release-please-action@v4
         id: release
         with:
           release-type: node
@@ -34,7 +34,7 @@ jobs:
       - name: Checking out sources
         uses: actions/checkout@v4
       - name: Cache Cargo
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             ~/.cargo/registry
@@ -59,7 +59,7 @@ jobs:
       - name: Checking out sources
         uses: actions/checkout@v4
       - name: Set up Node
-        uses: actions/setup-node@v3.8.1
+        uses: actions/setup-node@v4.0.2
         with:
           node-version: '16'
           registry-url: 'https://registry.npmjs.org'

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [2.3.1](https://github.com/polarmutex/tree-sitter-beancount/compare/v2.3.0...v2.3.1) (2024-02-29)
+
+
+### Bug Fixes
+
+* cargo version ([01cc2ca](https://github.com/polarmutex/tree-sitter-beancount/commit/01cc2ca9073b1dab75e6d7996f48331b0c3f9057))
+
+## [2.3.0](https://github.com/polarmutex/tree-sitter-beancount/compare/v2.2.0...v2.3.0) (2024-02-29)
+
+
+### Features
+
+* Add swift bindings ([0e08ee4](https://github.com/polarmutex/tree-sitter-beancount/commit/0e08ee4212edef5088bb3dd93ab0ba01f94792b0))
+
+
+### Bug Fixes
+
+* remove unneeded excludes ([cd08aef](https://github.com/polarmutex/tree-sitter-beancount/commit/cd08aefa20dc0f3d5984b08b5d468f75bf4fd096))
+
 ## [2.2.0](https://github.com/polarmutex/tree-sitter-beancount/compare/v2.1.3...v2.2.0) (2023-10-10)
 
 

package/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "tree-sitter-beancount"
 description = "beancount grammar for the tree-sitter parsing library"
-version = "2.2.0" # {x-release-please-version}
+version = "2.3.1" # {x-release-please-version}
 keywords = ["incremental", "parsing", "beancount", "tree-sitter"]
 categories = ["parsing", "text-editors"]
 repository = "https://github.com/polarmutex/tree-sitter-beancount"

package/Package.swift

@@ -0,0 +1,20 @@
+// swift-tools-version:5.3
+import PackageDescription
+
+let package = Package(
+    name: "TreeSitterBeancount",
+    products: [
+        .library(name: "TreeSitterBeancount", targets: ["TreeSitterBeancount"]),
+    ],
+    dependencies: [],
+    targets: [
+        .target(name: "TreeSitterBeancount",
+                path: ".",
+                sources: [
+                    "src/parser.c",
+                    "src/scanner.cc",
+                ],
+                publicHeadersPath: "bindings/swift",
+                cSettings: [.headerSearchPath("src")])
+    ]
+)

package/binding.gyp

@@ -8,8 +8,8 @@
       ],
       "sources": [
         "bindings/node/binding.cc",
-        "src/parser.c",
         # If your language uses an external scanner, add it here.
+        "src/parser.c",
       ],
       "cflags_c": [
         "-std=c99",

package/bindings/rust/build.rs

@@ -25,6 +25,7 @@ fn main() {
     // If your language uses an external scanner written in C++,
     // then include this block of code:
 
+    /*
     let mut cpp_config = cc::Build::new();
     cpp_config.cpp(true);
     cpp_config.include(&src_dir);
@@ -35,4 +36,5 @@ fn main() {
     cpp_config.file(&scanner_path);
     cpp_config.compile("scanner");
     println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
+    */
 }

package/flake.lock

@@ -3,11 +3,11 @@
     "flake-compat": {
       "flake": false,
       "locked": {
-        "lastModified": 1673956053,
-        "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
+        "lastModified": 1696426674,
+        "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=",
         "owner": "edolstra",
         "repo": "flake-compat",
-        "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
+        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
         "type": "github"
       },
       "original": {
@@ -21,11 +21,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1694529238,
-        "narHash": "sha256-zsNZZGTGnMOf9YpHKJqMSsa0dXbfmxeoJ7xHlrt+xmY=",
+        "lastModified": 1709126324,
+        "narHash": "sha256-q6EQdSeUZOG26WelxqkmR7kArjgWCdw5sfJVHPH/7j8=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "ff7b65b44d01cf9ba6a71320833626af21126384",
+        "rev": "d465f4819400de7c8d874d50b982301f28a84605",
         "type": "github"
       },
       "original": {
@@ -42,11 +42,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1660459072,
-        "narHash": "sha256-8DFJjXG8zqoONA1vXtgeKXy68KdJL5UaXR8NtVMUbx8=",
+        "lastModified": 1703887061,
+        "narHash": "sha256-gGPa9qWNc6eCXT/+Z5/zMkyYOuRZqeFZBDbopNZQkuY=",
         "owner": "hercules-ci",
         "repo": "gitignore.nix",
-        "rev": "a20de23b925fd8264fd7fad6454652e142fd7f73",
+        "rev": "43e1aa1308018f37118e34d3a9cb4f5e75dc11d5",
         "type": "github"
       },
       "original": {
@@ -57,11 +57,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1696604326,
-        "narHash": "sha256-YXUNI0kLEcI5g8lqGMb0nh67fY9f2YoJsILafh6zlMo=",
+        "lastModified": 1708984720,
+        "narHash": "sha256-gJctErLbXx4QZBBbGp78PxtOOzsDaQ+yw1ylNQBuSUY=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "87828a0e03d1418e848d3dd3f3014a632e4a4f64",
+        "rev": "13aff9b34cc32e59d35c62ac9356e4a41198a538",
         "type": "github"
       },
       "original": {
@@ -73,16 +73,16 @@
     },
     "nixpkgs-stable": {
       "locked": {
-        "lastModified": 1685801374,
-        "narHash": "sha256-otaSUoFEMM+LjBI1XL/xGB5ao6IwnZOXc47qhIgJe8U=",
+        "lastModified": 1704874635,
+        "narHash": "sha256-YWuCrtsty5vVZvu+7BchAxmcYzTMfolSPP5io8+WYCg=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "c37ca420157f4abc31e26f436c1145f8951ff373",
+        "rev": "3dc440faeee9e889fe2d1b4d25ad0f430d449356",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-23.05",
+        "ref": "nixos-23.11",
         "repo": "nixpkgs",
         "type": "github"
       }
@@ -100,11 +100,11 @@
         "nixpkgs-stable": "nixpkgs-stable"
       },
       "locked": {
-        "lastModified": 1696846637,
-        "narHash": "sha256-0hv4kbXxci2+pxhuXlVgftj/Jq79VSmtAyvfabCCtYk=",
+        "lastModified": 1708018599,
+        "narHash": "sha256-M+Ng6+SePmA8g06CmUZWi1AjG2tFBX9WCXElBHEKnyM=",
         "owner": "cachix",
         "repo": "pre-commit-hooks.nix",
-        "rev": "42e1b6095ef80a51f79595d9951eb38e91c4e6ca",
+        "rev": "5df5a70ad7575f6601d91f0efec95dd9bc619431",
         "type": "github"
       },
       "original": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-beancount",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "a tree-sitter parser for the beancount syntax",
   "main": "bindings/node",
   "scripts": {

package/src/parser.c

@@ -1,4 +1,4 @@
-#include <tree_sitter/parser.h>
+#include "tree_sitter/parser.h"
 
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic push
@@ -16,7 +16,7 @@
 #define MAX_ALIAS_SEQUENCE_LENGTH 9
 #define PRODUCTION_ID_COUNT 88
 
-enum {
+enum ts_symbol_identifiers {
   sym_identifier = 1,
   anon_sym_LF = 2,
   anon_sym_CR = 3,
@@ -974,7 +974,7 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
   },
 };
 
-enum {
+enum ts_field_identifiers {
   field_account = 1,
   field_amount = 2,
   field_comment = 3,
@@ -5715,33 +5715,6 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = {
   [615] = {.lex_state = 0},
 };
 
-enum {
-  ts_external_token__stars = 0,
-  ts_external_token__sectionend = 1,
-  ts_external_token__eof = 2,
-};
-
-static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = {
-  [ts_external_token__stars] = sym__stars,
-  [ts_external_token__sectionend] = sym__sectionend,
-  [ts_external_token__eof] = sym__eof,
-};
-
-static const bool ts_external_scanner_states[4][EXTERNAL_TOKEN_COUNT] = {
-  [1] = {
-    [ts_external_token__stars] = true,
-    [ts_external_token__sectionend] = true,
-    [ts_external_token__eof] = true,
-  },
-  [2] = {
-    [ts_external_token__stars] = true,
-  },
-  [3] = {
-    [ts_external_token__stars] = true,
-    [ts_external_token__sectionend] = true,
-  },
-};
-
 static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
   [0] = {
     [ts_builtin_sym_end] = ACTIONS(1),
@@ -16333,6 +16306,33 @@ static const TSParseActionEntry ts_parse_actions[] = {
   [1609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448),
 };
 
+enum ts_external_scanner_symbol_identifiers {
+  ts_external_token__stars = 0,
+  ts_external_token__sectionend = 1,
+  ts_external_token__eof = 2,
+};
+
+static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = {
+  [ts_external_token__stars] = sym__stars,
+  [ts_external_token__sectionend] = sym__sectionend,
+  [ts_external_token__eof] = sym__eof,
+};
+
+static const bool ts_external_scanner_states[4][EXTERNAL_TOKEN_COUNT] = {
+  [1] = {
+    [ts_external_token__stars] = true,
+    [ts_external_token__sectionend] = true,
+    [ts_external_token__eof] = true,
+  },
+  [2] = {
+    [ts_external_token__stars] = true,
+  },
+  [3] = {
+    [ts_external_token__stars] = true,
+    [ts_external_token__sectionend] = true,
+  },
+};
+
 #ifdef __cplusplus
 extern "C" {
 #endif

package/src/scanner.c

@@ -0,0 +1,208 @@
+#include <stdio.h> // test
+#include <tree_sitter/parser.h>
+#include <wctype.h>
+
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+typedef struct {
+    uint32_t length;
+    uint32_t capacity;
+    int16_t *data;
+} vec;
+
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+#define VEC_RESIZE(vec, _cap)                                                  \
+    void *tmp = realloc((vec).data, (_cap) * sizeof((vec).data[0]));           \
+    (vec).data = tmp;                                                          \
+    (vec).capacity = (_cap);
+
+#define VEC_GROW(vec, _cap)                                                    \
+    if ((vec).capacity < (_cap)) {                                             \
+        VEC_RESIZE((vec), (_cap));                                             \
+    }
+
+#define VEC_PUSH(vec, el)                                                      \
+    if ((vec).capacity == (vec).length) {                                      \
+        VEC_RESIZE((vec), MAX(16, (vec).length * 2));                          \
+    }                                                                          \
+    (vec).data[(vec).length++] = (el);
+
+#define VEC_POP(vec) (vec).length--;
+
+#define VEC_NEW                                                                \
+    { .len = 0, .capacity = 0, .data = NULL }
+
+#define VEC_BACK(vec) ((vec).data[(vec).length - 1])
+
+#define VEC_FREE(vec)                                                          \
+    {                                                                          \
+        if ((vec).data != NULL)                                                \
+            free((vec).data);                                                  \
+    }
+
+#define VEC_CLEAR(vec) (vec).length = 0;
+
+enum TokenType {
+    SECTION,
+    SECTIONEND,
+    END_OF_FILE,
+};
+
+typedef struct {
+    vec indent_length_stack;
+    vec org_section_stack;
+} Scanner;
+
+unsigned serialize(Scanner *scanner, char *buffer) {
+    size_t i = 0;
+
+    size_t indent_count = scanner->indent_length_stack.length - 1;
+    if (indent_count > UINT8_MAX)
+        indent_count = UINT8_MAX;
+    buffer[i++] = (char)indent_count;
+
+    int iter = 1;
+    for (; iter < scanner->indent_length_stack.length
+           && i < TREE_SITTER_SERIALIZATION_BUFFER_SIZE;
+         ++iter) {
+        buffer[i++] = (char)scanner->indent_length_stack.data[iter];
+    }
+
+    size_t org_section_count = scanner->org_section_stack.length - 1;
+    if (org_section_count > UINT8_MAX)
+        org_section_count = UINT8_MAX;
+    buffer[i++] = (char)org_section_count;
+
+    iter = 1;
+    for (; iter < scanner->org_section_stack.length
+           && i < TREE_SITTER_SERIALIZATION_BUFFER_SIZE;
+         ++iter) {
+        buffer[i++] = (char)scanner->org_section_stack.data[iter];
+    }
+
+    return i;
+}
+
+void deserialize(Scanner *scanner, const char *buffer, unsigned length) {
+    VEC_CLEAR(scanner->org_section_stack);
+    VEC_PUSH(scanner->org_section_stack, 0);
+    VEC_CLEAR(scanner->indent_length_stack);
+    VEC_PUSH(scanner->indent_length_stack, 0);
+
+    if (length == 0)
+        return;
+
+    size_t i = 0;
+
+    size_t indent_count = (unsigned char)buffer[i++];
+    for (; i <= indent_count; i++) {
+        VEC_PUSH(scanner->indent_length_stack, (unsigned char)buffer[i]);
+    }
+
+    size_t org_section_count = (unsigned char)buffer[i++];
+    for (; i < length; i++) {
+        VEC_PUSH(scanner->org_section_stack, (unsigned char)buffer[i]);
+    }
+}
+
+void advance(TSLexer *lexer) {
+    lexer->advance(lexer, false);
+}
+
+void skip(TSLexer *lexer) {
+    lexer->advance(lexer, true);
+}
+
+static bool in_error_recovery(const bool *valid_symbols) {
+    return (valid_symbols[SECTION] && valid_symbols[SECTIONEND]
+            && valid_symbols[END_OF_FILE]);
+}
+
+bool scan(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols) {
+
+    if (in_error_recovery(valid_symbols))
+        return false;
+
+    // - Section ends
+    int16_t indent_length = 0;
+    lexer->mark_end(lexer);
+    for (;;) {
+        if (lexer->lookahead == ' ') {
+            indent_length++;
+        } else if (lexer->lookahead == '\t') {
+            indent_length += 8;
+        } else if (lexer->lookahead == '\0') {
+
+            if (valid_symbols[SECTIONEND]) {
+                lexer->result_symbol = SECTIONEND;
+            } else if (valid_symbols[END_OF_FILE]) {
+                lexer->result_symbol = END_OF_FILE;
+            } else {
+                return false;
+            }
+
+            return true;
+        } else {
+            break;
+        }
+        skip(lexer);
+    }
+
+    if (indent_length == 0 && lexer->lookahead == '*') {
+        lexer->mark_end(lexer);
+        int16_t stars = 1;
+        skip(lexer);
+        while (lexer->lookahead == '*') {
+            stars++;
+            skip(lexer);
+        }
+
+        if (valid_symbols[SECTIONEND] && iswspace(lexer->lookahead) && stars > 0
+            && stars <= VEC_BACK(scanner->org_section_stack)) {
+            VEC_POP(scanner->org_section_stack);
+            lexer->result_symbol = SECTIONEND;
+            return true;
+        } else if (valid_symbols[SECTION] && iswspace(lexer->lookahead)) {
+            VEC_PUSH(scanner->org_section_stack, stars);
+            lexer->result_symbol = SECTION;
+            return true;
+        }
+        return false;
+    }
+
+    return false; // default
+}
+
+void *tree_sitter_beancount_external_scanner_create() {
+    Scanner *scanner = (Scanner *)calloc(1, sizeof(Scanner));
+    deserialize(scanner, NULL, 0);
+    return scanner;
+}
+
+bool tree_sitter_beancount_external_scanner_scan(void *payload,
+                                                 TSLexer *lexer,
+                                                 const bool *valid_symbols) {
+    Scanner *scanner = (Scanner *)payload;
+    return scan(scanner, lexer, valid_symbols);
+}
+
+unsigned tree_sitter_beancount_external_scanner_serialize(void *payload,
+                                                          char *buffer) {
+    Scanner *scanner = (Scanner *)payload;
+    return serialize(scanner, buffer);
+}
+
+void tree_sitter_beancount_external_scanner_deserialize(void *payload,
+                                                        const char *buffer,
+                                                        unsigned length) {
+    Scanner *scanner = (Scanner *)payload;
+    deserialize(scanner, buffer, length);
+}
+
+void tree_sitter_beancount_external_scanner_destroy(void *payload) {
+    Scanner *scanner = (Scanner *)payload;
+    VEC_FREE(scanner->indent_length_stack);
+    VEC_FREE(scanner->org_section_stack);
+    free(scanner);
+}

package/src/tree_sitter/parser.h

@@ -13,9 +13,8 @@ extern "C" {
 #define ts_builtin_sym_end 0
 #define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
 
-typedef uint16_t TSStateId;
-
 #ifndef TREE_SITTER_API_H_
+typedef uint16_t TSStateId;
 typedef uint16_t TSSymbol;
 typedef uint16_t TSFieldId;
 typedef struct TSLanguage TSLanguage;
@@ -130,9 +129,16 @@ struct TSLanguage {
  *  Lexer Macros
  */
 
+#ifdef _MSC_VER
+#define UNUSED __pragma(warning(suppress : 4101))
+#else
+#define UNUSED __attribute__((unused))
+#endif
+
 #define START_LEXER()           \
   bool result = false;          \
   bool skip = false;            \
+  UNUSED                        \
   bool eof = false;             \
   int32_t lookahead;            \
   goto start;                   \
@@ -166,7 +172,7 @@ struct TSLanguage {
  *  Parse Table Macros
  */
 
-#define SMALL_STATE(id) id - LARGE_STATE_COUNT
+#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT)
 
 #define STATE(id) id
 
@@ -176,7 +182,7 @@ struct TSLanguage {
   {{                                  \
     .shift = {                        \
       .type = TSParseActionTypeShift, \
-      .state = state_value            \
+      .state = (state_value)          \
     }                                 \
   }}
 
@@ -184,7 +190,7 @@ struct TSLanguage {
   {{                                  \
     .shift = {                        \
       .type = TSParseActionTypeShift, \
-      .state = state_value,           \
+      .state = (state_value),         \
       .repetition = true              \
     }                                 \
   }}

package/src/scanner.cc

@@ -1,171 +0,0 @@
-#include <cwctype>
-#include <tree_sitter/parser.h>
-#include <vector>
-
-namespace {
-
-using std::iswspace;
-using std::vector;
-
-enum TokenType {
-    SECTION,
-    SECTIONEND,
-    END_OF_FILE,
-};
-
-struct Scanner {
-    vector<int16_t> indent_length_stack;
-    vector<int16_t> org_section_stack;
-
-    Scanner() {
-        deserialize(NULL, 0);
-    }
-
-    unsigned serialize(char *buffer) {
-        size_t i = 0;
-
-        size_t indent_count = indent_length_stack.size() - 1;
-        if (indent_count > UINT8_MAX)
-            indent_count = UINT8_MAX;
-        buffer[i++] = indent_count;
-
-        vector<int16_t>::iterator iter = indent_length_stack.begin() + 1,
-                                  end = indent_length_stack.end();
-
-        for (; iter != end && i < TREE_SITTER_SERIALIZATION_BUFFER_SIZE;
-             ++iter) {
-            buffer[i++] = *iter;
-        }
-
-        iter = org_section_stack.begin() + 1;
-        end = org_section_stack.end();
-
-        for (; iter != end && i < TREE_SITTER_SERIALIZATION_BUFFER_SIZE;
-             ++iter) {
-            buffer[i++] = *iter;
-        }
-
-        return i;
-    }
-
-    void deserialize(const char *buffer, unsigned length) {
-        org_section_stack.clear();
-        org_section_stack.push_back(0);
-        indent_length_stack.clear();
-        indent_length_stack.push_back(-1);
-
-        if (length == 0)
-            return;
-
-        size_t i = 0;
-
-        size_t indent_count = (uint8_t)buffer[i++];
-
-        for (; i <= indent_count; i++)
-            indent_length_stack.push_back(buffer[i]);
-        for (; i < length; i++)
-            org_section_stack.push_back(buffer[i]);
-    }
-
-    void advance(TSLexer *lexer) {
-        lexer->advance(lexer, false);
-    }
-
-    void skip(TSLexer *lexer) {
-        lexer->advance(lexer, true);
-    }
-
-    static bool in_error_recovery(const bool *valid_symbols) {
-        return (valid_symbols[SECTION] && valid_symbols[SECTIONEND]
-                && valid_symbols[END_OF_FILE]);
-    }
-
-    bool scan(TSLexer *lexer, const bool *valid_symbols) {
-
-        if (in_error_recovery(valid_symbols))
-            return false;
-
-        // - Section ends
-        int16_t indent_length = 0;
-        lexer->mark_end(lexer);
-        for (;;) {
-            if (lexer->lookahead == ' ') {
-                indent_length++;
-            } else if (lexer->lookahead == '\t') {
-                indent_length += 8;
-            } else if (lexer->lookahead == '\0') {
-
-                if (valid_symbols[SECTIONEND]) {
-                    lexer->result_symbol = SECTIONEND;
-                } else if (valid_symbols[END_OF_FILE]) {
-                    lexer->result_symbol = END_OF_FILE;
-                } else {
-                    return false;
-                }
-
-                return true;
-            } else {
-                break;
-            }
-            skip(lexer);
-        }
-
-        if (indent_length == 0 && lexer->lookahead == '*') {
-            lexer->mark_end(lexer);
-            int16_t stars = 1;
-            skip(lexer);
-            while (lexer->lookahead == '*') {
-                stars++;
-                skip(lexer);
-            }
-
-            if (valid_symbols[SECTIONEND] && iswspace(lexer->lookahead)
-                && stars > 0 && stars <= org_section_stack.back()) {
-                org_section_stack.pop_back();
-                lexer->result_symbol = SECTIONEND;
-                return true;
-            } else if (valid_symbols[SECTION] && iswspace(lexer->lookahead)) {
-                org_section_stack.push_back(stars);
-                lexer->result_symbol = SECTION;
-                return true;
-            }
-            return false;
-        }
-
-        return false; // default
-    }
-};
-
-} // namespace
-
-extern "C" {
-
-void *tree_sitter_beancount_external_scanner_create() {
-    return new Scanner();
-}
-
-bool tree_sitter_beancount_external_scanner_scan(void *payload,
-                                                 TSLexer *lexer,
-                                                 const bool *valid_symbols) {
-    Scanner *scanner = static_cast<Scanner *>(payload);
-    return scanner->scan(lexer, valid_symbols);
-}
-
-unsigned tree_sitter_beancount_external_scanner_serialize(void *payload,
-                                                          char *buffer) {
-    Scanner *scanner = static_cast<Scanner *>(payload);
-    return scanner->serialize(buffer);
-}
-
-void tree_sitter_beancount_external_scanner_deserialize(void *payload,
-                                                        const char *buffer,
-                                                        unsigned length) {
-    Scanner *scanner = static_cast<Scanner *>(payload);
-    scanner->deserialize(buffer, length);
-}
-
-void tree_sitter_beancount_external_scanner_destroy(void *payload) {
-    Scanner *scanner = static_cast<Scanner *>(payload);
-    delete scanner;
-}
-}