@yalehwang/archguard 0.1.23 → 0.1.32

package/node_modules/tree-sitter/package.json

@@ -1,76 +0,0 @@
-{
-  "name": "tree-sitter",
-  "version": "0.25.0",
-  "description": "Node.js bindings to the Tree-sitter parsing library",
-  "repository": "http://github.com/tree-sitter/node-tree-sitter",
-  "publishConfig": {
-    "access": "public"
-  },
-  "license": "MIT",
-  "author": {
-    "name": "Max Brunsfeld",
-    "email": "maxbrunsfeld@gmail.com"
-  },
-  "maintainers": [
-    {
-      "name": "Amaan Qureshi",
-      "email": "amaanq12@gmail.com"
-    }
-  ],
-  "contributors": [
-    {
-      "name": "Segev Finer",
-      "email": "segev208@gmail.com"
-    },
-    {
-      "name": "Boris Verkhovskiy",
-      "email": "boris.verk@gmail.com"
-    }
-  ],
-  "main": "index.js",
-  "types": "tree-sitter.d.ts",
-  "keywords": [
-    "incremental",
-    "parsing",
-    "tree-sitter"
-  ],
-  "files": [
-    "binding.gyp",
-    "tree-sitter.d.ts",
-    "prebuilds/*",
-    "src/*",
-    "vendor/tree-sitter/lib/include/*",
-    "vendor/tree-sitter/lib/src/*"
-  ],
-  "dependencies": {
-    "node-addon-api": "^8.3.0",
-    "node-gyp-build": "^4.8.4"
-  },
-  "devDependencies": {
-    "@types/node": "^22.10.2",
-    "@types/tmp": "^0.2.6",
-    "glob": "^11.0.0",
-    "node-gyp": "^11.0.0",
-    "prebuildify": "^6.0.1",
-    "tmp": "^0.2.3",
-    "tree-sitter-c": "^0.23.4",
-    "tree-sitter-embedded-template": "^0.23.2",
-    "tree-sitter-html": "^0.23.2",
-    "tree-sitter-java": "^0.23.5",
-    "tree-sitter-javascript": "^0.23.1",
-    "tree-sitter-json": "^0.24.8",
-    "tree-sitter-python": "^0.23.6",
-    "tree-sitter-ruby": "^0.23.1",
-    "tree-sitter-rust": "^0.23.2",
-    "typedoc": "^0.27.6",
-    "typedoc-plugin-rename-defaults": "^0.7.2",
-    "typescript": "^5.7.2"
-  },
-  "scripts": {
-    "docs": "typedoc --out docs/api tree-sitter.d.ts --readme README.md",
-    "install": "node-gyp-build",
-    "build": "prebuildify --napi --strip",
-    "rebuild": "node-gyp rebuild",
-    "test": "node -e \"require('child_process').spawnSync('node', ['--test', ...require('glob').sync('test/**/*.js')], {stdio:'inherit'})\""
-  }
-}

package/node_modules/tree-sitter/src/addon_data.h

@@ -1,47 +0,0 @@
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-
-#ifndef NODE_TREE_SITTER_ADDON_DATA_H_
-#define NODE_TREE_SITTER_ADDON_DATA_H_
-
-namespace node_tree_sitter {
-
-class AddonData final {
-public:
-  explicit AddonData(Napi::Env _env) {}
-
-  ~AddonData() {
-    ts_query_cursor_delete(ts_query_cursor);
-  }
-
-  // conversions
-  uint32_t *point_transfer_buffer = nullptr;
-
-  // node
-  uint32_t *transfer_buffer = nullptr;
-  uint32_t transfer_buffer_length = 0;
-  Napi::ObjectReference module_exports;
-  TSTreeCursor scratch_cursor = {nullptr, nullptr, {0, 0}};
-
-  // parser
-  Napi::FunctionReference parser_constructor;
-  Napi::FunctionReference string_slice;
-
-  // query
-  TSQueryCursor *ts_query_cursor = nullptr;
-  Napi::FunctionReference query_constructor;
-
-  // tree_cursor
-  Napi::FunctionReference tree_cursor_constructor;
-
-  // tree
-  Napi::FunctionReference tree_constructor;
-
-  // lookaheaditerator
-  Napi::FunctionReference lookahead_iterator_constructor;
-};
-
-} // namespace node_tree_sitter
-
-#endif // NODE_TREE_SITTER_ADDON_DATA_H_

package/node_modules/tree-sitter/src/binding.cc

@@ -1,35 +0,0 @@
-#include "./addon_data.h"
-#include "./conversions.h"
-#include "./language.h"
-#include "./lookaheaditerator.h"
-#include "./node.h"
-#include "./parser.h"
-#include "./query.h"
-#include "./tree.h"
-#include "./tree_cursor.h"
-
-#include <napi.h>
-
-using namespace Napi;
-
-namespace node_tree_sitter {
-
-Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
-  auto* data = new AddonData(env);
-  env.SetInstanceData(data);
-
-  InitConversions(env, exports);
-  node_methods::Init(env, exports);
-  language_methods::Init(env, exports);
-  LookaheadIterator::Init(env, exports);
-  Parser::Init(env, exports);
-  Query::Init(env, exports);
-  Tree::Init(env, exports);
-  TreeCursor::Init(env, exports);
-
-  return exports;
-}
-
-NODE_API_MODULE(tree_sitter_runtime_binding, InitAll)
-
-} // namespace node_tree_sitter

package/node_modules/tree-sitter/src/conversions.cc

@@ -1,140 +0,0 @@
-#include "./conversions.h"
-#include "./addon_data.h"
-#include "tree_sitter/api.h"
-
-#include <cmath>
-#include <napi.h>
-
-using namespace Napi;
-
-namespace node_tree_sitter {
-
-static const unsigned BYTES_PER_CHARACTER = 2;
-
-void InitConversions(Napi::Env env, Napi::Object exports) {
-  auto *data = env.GetInstanceData<AddonData>();
-
-  auto js_point_transfer_buffer = Uint32Array::New(env, 2);
-  data->point_transfer_buffer = js_point_transfer_buffer.Data();
-
-  exports["pointTransferArray"] = js_point_transfer_buffer;
-}
-
-void TransferPoint(Napi::Env env, const TSPoint &point) {
-  auto *data = env.GetInstanceData<AddonData>();
-  data->point_transfer_buffer[0] = point.row;
-  data->point_transfer_buffer[1] = point.column / 2;
-}
-
-Napi::Object RangeToJS(Napi::Env env, const TSRange &range) {
-  Object result = Object::New(env);
-  result.Set("startPosition", PointToJS(env, range.start_point));
-  result.Set("startIndex", ByteCountToJS(env, range.start_byte));
-  result.Set("endPosition", PointToJS(env, range.end_point));
-  result.Set("endIndex", ByteCountToJS(env, range.end_byte));
-  return result;
-}
-
-Napi::Maybe<TSRange> RangeFromJS(const Napi::Value& arg) {
-  Env env = arg.Env();
-  if (!arg.IsObject()) {
-    TypeError::New(env, "Range must be a {startPosition, endPosition, startIndex, endIndex} object").ThrowAsJavaScriptException();
-    return Napi::Nothing<TSRange>();
-  }
-
-  TSRange result;
-
-  auto js_range = arg.As<Object>();
-
-  #define INIT(field, key, Convert) { \
-    auto value = js_range.Get(key); \
-    if (value.IsEmpty()) { \
-      TypeError::New(env, "Range must be a {startPosition, endPosition, startIndex, endIndex} object").ThrowAsJavaScriptException(); \
-      return Napi::Nothing<TSRange>(); \
-    } \
-    auto field = Convert(value); \
-    if (field.IsJust()) { \
-      result.field = field.Unwrap(); \
-    } else { \
-      return Napi::Nothing<TSRange>(); \
-    } \
-  }
-
-  INIT(start_point, "startPosition", PointFromJS);
-  INIT(end_point, "endPosition", PointFromJS);
-  INIT(start_byte, "startIndex", ByteCountFromJS);
-  INIT(end_byte, "endIndex", ByteCountFromJS);
-
-  #undef INIT
-
-  return Napi::Just(result);
-}
-
-Napi::Object PointToJS(Napi::Env env, const TSPoint &point) {
-  Object result = Object::New(env);
-  result["row"] = Number::New(env, point.row);
-  result["column"] = ByteCountToJS(env, point.column);
-  return result;
-}
-
-Napi::Maybe<TSPoint> PointFromJS(const Napi::Value& arg) {
-  Env env = arg.Env();
-
-  if (!arg.IsObject()) {
-    TypeError::New(env, "Point must be a {row, column} object").ThrowAsJavaScriptException();
-    return Napi::Nothing<TSPoint>();
-  }
-  auto js_point = arg.As<Object>();
-
-  auto js_row = js_point.Get("row").As<Number>();
-  if (!js_row.IsNumber()) {
-    TypeError::New(env, "Point must be a {row, column} object").ThrowAsJavaScriptException();
-    return Napi::Nothing<TSPoint>();
-  }
-
-  auto js_column = js_point.Get("column").As<Number>();
-  if (!js_column.IsNumber()) {
-    TypeError::New(env, "Point must be a {row, column} object").ThrowAsJavaScriptException();
-    return Napi::Nothing<TSPoint>();
-  }
-
-  uint32_t row;
-  if (!std::isfinite(js_row.DoubleValue())) {
-    row = UINT32_MAX;
-  } else if (js_row.IsNumber()) {
-    row = js_row.Uint32Value();
-  } else {
-    TypeError::New(env, "Point.row must be a number").ThrowAsJavaScriptException();
-    return Napi::Nothing<TSPoint>();
-  }
-
-  uint32_t column;
-  if (!std::isfinite(js_column.DoubleValue())) {
-    column = UINT32_MAX;
-  } else if (js_column.IsNumber()) {
-    column = js_column.Uint32Value() * BYTES_PER_CHARACTER;
-  } else {
-    TypeError::New(env, "Point.column must be a number").ThrowAsJavaScriptException();
-    return Napi::Nothing<TSPoint>();
-  }
-
-  return Napi::Just<TSPoint>({row, column});
-}
-
-Napi::Number ByteCountToJS(Napi::Env env, uint32_t byte_count) {
-  return Number::New(env, byte_count / BYTES_PER_CHARACTER);
-}
-
-Napi::Maybe<uint32_t> ByteCountFromJS(const Napi::Value &arg) {
-  Napi::Env env = arg.Env();
-
-  if (!arg.IsNumber()) {
-    TypeError::New(env, "Character index must be a number").ThrowAsJavaScriptException();
-    return Napi::Nothing<uint32_t>();
-  }
-  auto result = arg.As<Number>();
-
-  return Napi::Just<uint32_t>(result.Uint32Value() * BYTES_PER_CHARACTER);
-}
-
-} // namespace node_tree_sitter

package/node_modules/tree-sitter/src/conversions.h

@@ -1,22 +0,0 @@
-#ifndef NODE_TREE_SITTER_CONVERSIONS_H_
-#define NODE_TREE_SITTER_CONVERSIONS_H_
-
-#include "./addon_data.h"
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-
-namespace node_tree_sitter {
-
-void InitConversions(Napi::Env env, Napi::Object exports);
-Napi::Object RangeToJS(Napi::Env env, const TSRange &);
-Napi::Object PointToJS(Napi::Env env, const TSPoint &);
-void TransferPoint(Napi::Env env, const TSPoint &);
-Napi::Number ByteCountToJS(Napi::Env env, uint32_t);
-Napi::Maybe<TSPoint> PointFromJS(const Napi::Value &);
-Napi::Maybe<uint32_t> ByteCountFromJS(const Napi::Value &);
-Napi::Maybe<TSRange> RangeFromJS(const Napi::Value&);
-
-} // namespace node_tree_sitter
-
-#endif // NODE_TREE_SITTER_CONVERSIONS_H_

package/node_modules/tree-sitter/src/language.cc

@@ -1,106 +0,0 @@
-#include "./language.h"
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-#include <string>
-
-using namespace Napi;
-
-namespace node_tree_sitter::language_methods {
-
-/*
-  tstag() {
-    b2sum -l64 <(printf tree-sitter) <(printf "$1") | \
-    awk '{printf "0x" toupper($1) (NR == 1 ? ", " : "\n")}'
-  }
-  tstag language # => 0x8AF2E5212AD58ABF, 0xD5006CAD83ABBA16
-*/
-const napi_type_tag LANGUAGE_TYPE_TAG = {
-  0x8AF2E5212AD58ABF, 0xD5006CAD83ABBA16
-};
-
-const TSLanguage *UnwrapLanguage(Napi::Value value) {
-  Napi::Env env = value.Env();
-
-  if (value.IsObject()) {
-    value = value.As<Object>()["language"];
-  }
-
-  auto arg = value.As<External<const TSLanguage>>();
-  if (arg.IsExternal() && arg.CheckTypeTag(&LANGUAGE_TYPE_TAG)) {
-    const TSLanguage *language = arg.Data();
-    if (language != nullptr) {
-      uint16_t version = ts_language_version(language);
-      if (
-        version < TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION ||
-        version > TREE_SITTER_LANGUAGE_VERSION
-      ) {
-        std::string message =
-          "Incompatible language version. Compatible range: " +
-          std::to_string(TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION) + " - " +
-          std::to_string(TREE_SITTER_LANGUAGE_VERSION) + ". Got: " +
-          std::to_string(ts_language_version(language));
-        RangeError::New(env, message.c_str());
-        return nullptr;
-      }
-      return language;
-    }
-  }
-  throw TypeError::New(env, "Invalid language object");
-}
-
-namespace {
-
-Napi::Value GetNodeTypeNamesById(const Napi::CallbackInfo &info) {
-  Env env = info.Env();
-
-  const TSLanguage *language = UnwrapLanguage(info[0]);
-  if (language == nullptr) {
-    return env.Undefined();
-  }
-
-  auto result = Array::New(env);
-  uint32_t length = ts_language_symbol_count(language);
-  for (uint32_t i = 0; i < length; i++) {
-    const char *name = ts_language_symbol_name(language, i);
-    TSSymbolType type = ts_language_symbol_type(language, i);
-    if (type == TSSymbolTypeRegular) {
-      result[i] = String::New(env, name);
-    } else {
-      result[i] = env.Null();
-    }
-  }
-
-  return result;
-}
-
-Napi::Value GetNodeFieldNamesById(const Napi::CallbackInfo &info) {
-  Env env = info.Env();
-
-  const TSLanguage *language = UnwrapLanguage(info[0]);
-  if (language == nullptr) {
-    return env.Undefined();
-  }
-
-  auto result = Array::New(env);
-  uint32_t length = ts_language_field_count(language);
-  for (uint32_t i = 0; i < length + 1; i++) {
-    const char *name = ts_language_field_name_for_id(language, i);
-    if (name != nullptr) {
-      result[i] = String::New(env, name);
-    } else {
-      result[i] = env.Null();
-    }
-  }
-
-  return result;
-}
-
-} // namespace
-
-void Init(Napi::Env env, Napi::Object exports) {
-  exports["getNodeTypeNamesById"] = Function::New(env, GetNodeTypeNamesById);
-  exports["getNodeFieldNamesById"] = Function::New(env, GetNodeFieldNamesById);
-}
-
-} // namespace node_tree_sitter::language_methods

package/node_modules/tree-sitter/src/language.h

@@ -1,17 +0,0 @@
-#ifndef NODE_TREE_SITTER_LANGUAGE_H_
-#define NODE_TREE_SITTER_LANGUAGE_H_
-
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-#include <node_object_wrap.h>
-
-namespace node_tree_sitter::language_methods {
-
-void Init(Napi::Env env, Napi::Object);
-
-const TSLanguage *UnwrapLanguage(Napi::Value);
-
-} // namespace node_tree_sitter::language_methods
-
-#endif // NODE_TREE_SITTER_LANGUAGE_H_

package/node_modules/tree-sitter/src/logger.cc

@@ -1,70 +0,0 @@
-#include "./logger.h"
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-#include <string>
-
-using namespace Napi;
-using std::string;
-
-namespace node_tree_sitter {
-
-void Logger::Log(void *payload, TSLogType type, const char *message_str) {
-  auto *debugger = static_cast<Logger *>(payload);
-  Env env = debugger->func.Env();
-
-  string message(message_str);
-  string param_sep = " ";
-  size_t param_sep_pos = message.find(param_sep, 0);
-
-  String type_name = String::New(env, (type == TSLogTypeParse) ? "parse" : "lex");;
-  String name = String::New(env, message.substr(0, param_sep_pos));
-  Object params = Object::New(env);
-
-  while (param_sep_pos != string::npos) {
-    size_t key_pos = param_sep_pos + param_sep.size();
-    size_t value_sep_pos = message.find(':', key_pos);
-
-    if (value_sep_pos == string::npos) {
-      break;
-    }
-
-    size_t val_pos = value_sep_pos + 1;
-    param_sep = ", ";
-    param_sep_pos = message.find(param_sep, value_sep_pos);
-
-    string key = message.substr(key_pos, (value_sep_pos - key_pos));
-    string value = message.substr(val_pos, (param_sep_pos - val_pos));
-    params[key] = String::New(env, value);
-  }
-
-  try {
-    debugger->func({ name, params, type_name });
-  } catch (const Error &error) {
-    Value console = env.Global()["console"];
-    if (!console.IsObject()) {
-      return;
-    }
-
-    Value error_fn = console.As<Object>()["error"];
-    if (!error_fn.IsFunction()) {
-      return;
-    }
-
-    error_fn.As<Function>()({
-      String::New(env, "Error in debug callback:"),
-      error.Value()
-    });
-  }
-}
-
-TSLogger Logger::Make(const Napi::Function &func) {
-  TSLogger result;
-  auto *logger = new Logger();
-  logger->func = Napi::Persistent(func);
-  result.payload = static_cast<void *>(logger);
-  result.log = Log;
-  return result;
-}
-
-} // namespace node_tree_sitter

package/node_modules/tree-sitter/src/logger.h

@@ -1,19 +0,0 @@
-#ifndef NODE_TREE_SITTER_LOGGER_H_
-#define NODE_TREE_SITTER_LOGGER_H_
-
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-
-namespace node_tree_sitter {
-
-class Logger final {
- public:
-  static TSLogger Make(const Napi::Function &);
-  Napi::FunctionReference func;
-  static void Log(void *, TSLogType, const char *);
-};
-
-} // namespace node_tree_sitter
-
-#endif // NODE_TREE_SITTER_LOGGER_H_

package/node_modules/tree-sitter/src/lookaheaditerator.cc

@@ -1,122 +0,0 @@
-#include "./conversions.h"
-#include "./language.h"
-#include "./lookaheaditerator.h"
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-
-using namespace Napi;
-
-namespace node_tree_sitter {
-
-void LookaheadIterator::Init(Napi::Env env, Napi::Object exports) {
-  auto *data = env.GetInstanceData<AddonData>();
-
-  Function ctor = DefineClass(env, "LookaheadIterator", {
-    InstanceAccessor("currentTypeId", &LookaheadIterator::CurrentTypeId, nullptr, napi_default_method),
-    InstanceAccessor("currentType", &LookaheadIterator::CurrentType, nullptr, napi_default_method),
-
-    InstanceMethod("reset", &LookaheadIterator::Reset, napi_default_method),
-    InstanceMethod("resetState", &LookaheadIterator::ResetState, napi_default_method),
-    InstanceMethod("_next", &LookaheadIterator::Next, napi_default_method),
-  });
-
-  exports["LookaheadIterator"] = ctor;
-  data->lookahead_iterator_constructor = Napi::Persistent(ctor);
-}
-
-LookaheadIterator::LookaheadIterator(const Napi::CallbackInfo &info) : Napi::ObjectWrap<LookaheadIterator>(info), iterator_(nullptr) {
-  Napi::Env env = info.Env();
-  const TSLanguage *language = language_methods::UnwrapLanguage(info[0]);
-
-  if (language == nullptr) {
-    Napi::Error::New(env, "Missing language argument").ThrowAsJavaScriptException();
-    return;
-  }
-  if (!info[1].IsNumber()) {
-    Napi::Error::New(env, "Missing state argument").ThrowAsJavaScriptException();
-    return;
-  }
-
-  TSStateId state = info[1].As<Napi::Number>().Uint32Value();
-  iterator_ = ts_lookahead_iterator_new(language, state);
-  if (iterator_ == nullptr) {
-    Napi::Error::New(env, "Invalid state argument").ThrowAsJavaScriptException();
-    return;
-  }
-}
-
-
-LookaheadIterator::~LookaheadIterator() {
-  ts_lookahead_iterator_delete(iterator_);
-}
-
-Napi::Value LookaheadIterator::NewInstance(Napi::Env env, TSLookaheadIterator *iterator) {
-  auto *data = env.GetInstanceData<AddonData>();
-  if (iterator != nullptr) {
-    Object self = data->lookahead_iterator_constructor.New({});
-    LookaheadIterator::Unwrap(self)->iterator_ = iterator;
-    return self;
-  }
-
-  return env.Null();
-}
-
-LookaheadIterator *LookaheadIterator::UnwrapLookaheadIterator(const Napi::Value &value) {
-  auto *data = value.Env().GetInstanceData<AddonData>();
-  if (!value.IsObject()) {
-    return nullptr;
-  }
-  auto js_iterator = value.As<Object>();
-  if (!js_iterator.InstanceOf(data->lookahead_iterator_constructor.Value())) {
-    return nullptr;
-  }
-  return LookaheadIterator::Unwrap(js_iterator);
-}
-
-Napi::Value LookaheadIterator::CurrentType(const Napi::CallbackInfo &info) {
-  LookaheadIterator *iterator = UnwrapLookaheadIterator(info.This());
-  return Napi::String::New(info.Env(), ts_lookahead_iterator_current_symbol_name(iterator->iterator_));
-}
-
-Napi::Value LookaheadIterator::CurrentTypeId(const Napi::CallbackInfo &info) {
-  LookaheadIterator *iterator = UnwrapLookaheadIterator(info.This());
-  return Napi::Number::New(info.Env(), ts_lookahead_iterator_current_symbol(iterator->iterator_));
-}
-
-Napi::Value LookaheadIterator::Reset(const Napi::CallbackInfo &info) {
-  LookaheadIterator *iterator = UnwrapLookaheadIterator(info.This());
-  const TSLanguage *language = language_methods::UnwrapLanguage(info[0]);
-
-  if (language == nullptr) {
-    Napi::Error::New(info.Env(), "Invalid language argument").ThrowAsJavaScriptException();
-    return info.Env().Undefined();
-  }
-  if (!info[1].IsNumber()) {
-    Napi::Error::New(info.Env(), "Missing state argument").ThrowAsJavaScriptException();
-    return info.Env().Undefined();
-  }
-
-  TSStateId state = info[1].As<Napi::Number>().Uint32Value();
-  return Napi::Boolean::New(info.Env(), ts_lookahead_iterator_reset(iterator->iterator_, language, state));
-}
-
-Napi::Value LookaheadIterator::ResetState(const Napi::CallbackInfo &info) { 
-  Napi::Env env = info.Env();
-  LookaheadIterator *iterator = UnwrapLookaheadIterator(info.This());
-
-  if (!info[0].IsNumber()) {
-    Napi::Error::New(env, "Missing state argument").ThrowAsJavaScriptException();
-    return env.Undefined();
-  }
-
-  TSStateId state = info[0].As<Napi::Number>().Uint32Value();
-  return Napi::Boolean::New(env, ts_lookahead_iterator_reset_state(iterator->iterator_, state));
-}
-
-Napi::Value LookaheadIterator::Next(const Napi::CallbackInfo &info) {
-  LookaheadIterator *iterator = UnwrapLookaheadIterator(info.This());
-  return Napi::Boolean::New(info.Env(), ts_lookahead_iterator_next(iterator->iterator_));
-}
-
-} // namespace node_tree_sitter

package/node_modules/tree-sitter/src/lookaheaditerator.h

@@ -1,33 +0,0 @@
-#ifndef NODE_TREE_SITTER_LOOKAHEAD_ITERATOR_H_
-#define NODE_TREE_SITTER_LOOKAHEAD_ITERATOR_H_
-
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-
-namespace node_tree_sitter {
-
-class LookaheadIterator final : public Napi::ObjectWrap<LookaheadIterator> {
- public:
-  static void Init(Napi::Env env, Napi::Object exports);
-  static Napi::Value NewInstance(Napi::Env env, TSLookaheadIterator *);
-  static LookaheadIterator *UnwrapLookaheadIterator(const Napi::Value &);
-
-  explicit LookaheadIterator(const Napi::CallbackInfo &);
-  ~LookaheadIterator() final;
-
- private:
-  TSLookaheadIterator *iterator_;
-
-  Napi::Value New(const Napi::CallbackInfo &);
-  Napi::Value Reset(const Napi::CallbackInfo &);
-  Napi::Value ResetState(const Napi::CallbackInfo &);
-  Napi::Value Next(const Napi::CallbackInfo &);
-
-  Napi::Value CurrentTypeId(const Napi::CallbackInfo &);
-  Napi::Value CurrentType(const Napi::CallbackInfo &);
-};
-
-} // namespace node_tree_sitter
-
-#endif // NODE_TREE_SITTER_LOOKAHEAD_ITERATOR_H_