@yalehwang/archguard 0.1.31 → 0.1.33

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

@@ -1,316 +0,0 @@
-#include "./tree.h"
-#include "./addon_data.h"
-#include "./conversions.h"
-#include "./node.h"
-
-#include <napi.h>
-
-using namespace Napi;
-
-namespace node_tree_sitter {
-
-/*
-  tstag() {
-    b2sum -l64 <(printf tree-sitter) <(printf "$1") | \
-    awk '{printf "0x" toupper($1) (NR == 1 ? ", " : "\n")}'
-  }
-  tstag tree # => 0x8AF2E5212AD58ABF, 0x7FA28BFC1966AC2D
-*/
-const napi_type_tag TREE_TYPE_TAG = {
-  0x8AF2E5212AD58ABF, 0x7FA28BFC1966AC2D
-};
-
-using node_methods::UnmarshalNodeId;
-
-void Tree::Init(Napi::Env env, Napi::Object exports) {
-  auto *data = env.GetInstanceData<AddonData>();
-
-  Function ctor = DefineClass(env, "Tree", {
-    InstanceMethod("edit", &Tree::Edit, napi_default_method),
-    InstanceMethod("rootNode", &Tree::RootNode, napi_default_method),
-    InstanceMethod("rootNodeWithOffset", &Tree::RootNodeWithOffset, napi_default_method),
-    InstanceMethod("printDotGraph", &Tree::PrintDotGraph, napi_default_method),
-    InstanceMethod("getChangedRanges", &Tree::GetChangedRanges, napi_default_method),
-    InstanceMethod("getIncludedRanges", &Tree::GetIncludedRanges, napi_default_method),
-    InstanceMethod("getEditedRange", &Tree::GetEditedRange, napi_default_method),
-    InstanceMethod("_cacheNode", &Tree::CacheNode, napi_default_method),
-    InstanceMethod("_cacheNodes", &Tree::CacheNodes, napi_default_method),
-  });
-
-  data->tree_constructor = Napi::Persistent(ctor);
-  exports["Tree"] = ctor;
-}
-
-Tree::Tree(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Tree>(info), tree_(nullptr) {
-  Value().TypeTag(&TREE_TYPE_TAG);
-}
-
-Tree::~Tree() {
-  ts_tree_delete(tree_);
-  for (auto &entry : cached_nodes_) {
-    entry.second->tree = nullptr;
-  }
-}
-
-Napi::Value Tree::NewInstance(Napi::Env env, TSTree *tree) {
-  auto *data = env.GetInstanceData<AddonData>();
-  if (tree != nullptr) {
-    Object self = data->tree_constructor.New({});
-    Tree::Unwrap(self)->tree_ = tree;
-    return self;
-  }
-
-  return env.Null();
-}
-
-const Tree *Tree::UnwrapTree(const Napi::Value &value) {
-  if (!value.IsObject()) {
-    return nullptr;
-  }
-  auto js_tree = value.As<Object>();
-  if (!js_tree.CheckTypeTag(&TREE_TYPE_TAG)) {
-    return nullptr;
-  }
-  return Tree::Unwrap(js_tree);
-}
-
-#define read_number_from_js(out, value, name)                                \
-  if (!(value).IsNumber()) {                                                   \
-    throw TypeError::New(env, name " must be an integer");                   \
-    return env.Undefined();                                                  \
-  }                                                                          \
-  *(out) = (value).As<Number>().Uint32Value();
-
-#define read_byte_count_from_js(out, value, name)   \
-  read_number_from_js(out, value, name);            \
-  (*(out)) *= 2
-
-Napi::Value Tree::Edit(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  TSInputEdit edit;
-  read_number_from_js(&edit.start_point.row, info[0], "startPosition.row");
-  read_byte_count_from_js(&edit.start_point.column, info[1], "startPosition.column");
-  read_number_from_js(&edit.old_end_point.row, info[2], "oldEndPosition.row");
-  read_byte_count_from_js(&edit.old_end_point.column, info[3], "oldEndPosition.column");
-  read_number_from_js(&edit.new_end_point.row, info[4], "newEndPosition.row");
-  read_byte_count_from_js(&edit.new_end_point.column, info[5], "newEndPosition.column");
-  read_byte_count_from_js(&edit.start_byte, info[6], "startIndex");
-  read_byte_count_from_js(&edit.old_end_byte, info[7], "oldEndIndex");
-  read_byte_count_from_js(&edit.new_end_byte, info[8], "newEndIndex");
-
-  ts_tree_edit(tree_, &edit);
-
-  for (auto &entry : cached_nodes_) {
-    Object js_node = entry.second->node.Value();
-    if (js_node.IsEmpty()) {
-      continue;
-    }
-    TSNode node;
-    node.id = entry.first;
-    for (unsigned i = 0; i < 4; i++) {
-      Napi::Value node_field = js_node[i + 2];
-      if (node_field.IsNumber()) {
-        node.context[i] = node_field.As<Number>().Uint32Value();
-      }
-    }
-
-    ts_node_edit(&node, &edit);
-
-    for (unsigned i = 0; i < 4; i++) {
-      js_node[i + 2U] = Number::New(env, node.context[i]);
-    }
-  }
-
-  return info.This();
-}
-
-Napi::Value Tree::RootNode(const Napi::CallbackInfo &info) {
-  return node_methods::MarshalNode(info, this, ts_tree_root_node(tree_));
-}
-
-Napi::Value Tree::RootNodeWithOffset(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  uint32_t offset_bytes = 0;
-  TSPoint offset_extent = {0, UINT32_MAX};
-
-  read_byte_count_from_js(&offset_bytes, info[0], "offsetBytes");
-  read_number_from_js(&offset_extent.row, info[1], "offsetExtent.row");
-  read_byte_count_from_js(&offset_extent.column, info[2], "offsetExtent.column");
-
-  return node_methods::MarshalNode(info, this, ts_tree_root_node_with_offset(tree_, offset_bytes, offset_extent));
-}
-
-Napi::Value Tree::GetChangedRanges(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  const Tree *other_tree = UnwrapTree(info[0]);
-  if (other_tree == nullptr) {
-    throw TypeError::New(env, "Argument must be a tree");
-  }
-
-  uint32_t range_count;
-  TSRange *ranges = ts_tree_get_changed_ranges(tree_, other_tree->tree_, &range_count);
-
-  Array result = Array::New(env);
-  for (size_t i = 0; i < range_count; i++) {
-    result[i] = RangeToJS(env, ranges[i]);
-  }
-
-  free(ranges);
-
-  return result;
-}
-
-Napi::Value Tree::GetIncludedRanges(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  uint32_t range_count;
-  TSRange *ranges = ts_tree_included_ranges(tree_, &range_count);
-
-  Array result = Array::New(env);
-  for (size_t i = 0; i < range_count; i++) {
-    result[i] = RangeToJS(env, ranges[i]);
-  }
-
-  free(ranges);
-
-  return result;
-}
-
-Napi::Value Tree::GetEditedRange(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  TSNode root = ts_tree_root_node(tree_);
-  if (!ts_node_has_changes(root)) {
-    return env.Undefined();
-  }
-  TSRange result = {
-    ts_node_start_point(root),
-    ts_node_end_point(root),
-    ts_node_start_byte(root),
-    ts_node_end_byte(root),
-  };
-
-  TSTreeCursor cursor = ts_tree_cursor_new(root);
-
-  while (true) {
-    if (!ts_tree_cursor_goto_first_child(&cursor)) {
-      break;
-    }
-    while (true) {
-      TSNode node = ts_tree_cursor_current_node(&cursor);
-      if (ts_node_has_changes(node)) {
-        result.start_byte = ts_node_start_byte(node);
-        result.start_point = ts_node_start_point(node);
-        break;
-      }
-      if (!ts_tree_cursor_goto_next_sibling(&cursor)) {
-        break;
-      }
-    }
-  }
-
-  while (ts_tree_cursor_goto_parent(&cursor)) {}
-
-  while (true) {
-    if (!ts_tree_cursor_goto_first_child(&cursor)) {
-      break;
-    }
-    while (true) {
-      TSNode node = ts_tree_cursor_current_node(&cursor);
-      if (ts_node_has_changes(node)) {
-        result.end_byte = ts_node_end_byte(node);
-        result.end_point = ts_node_end_point(node);
-      }
-
-      if (!ts_tree_cursor_goto_next_sibling(&cursor)) {
-        break;
-      }
-    }
-  }
-
-  ts_tree_cursor_delete(&cursor);
-  return RangeToJS(env, result);
-}
-
-Napi::Value Tree::PrintDotGraph(const Napi::CallbackInfo &info) {
-  int fd = fileno(stderr);
-
-  if (info.Length() > 0) {
-    if (!info[0].IsNumber()) {
-      throw TypeError::New(info.Env(), "First argument must be a number");
-    }
-    fd = info[0].As<Number>().Int32Value();
-  }
-
-  ts_tree_print_dot_graph(tree_, fd);
-  return info.This();
-}
-
-namespace {
-
-void FinalizeNode(Napi::Env _env, Tree::NodeCacheEntry *cache_entry) {
-  assert(!cache_entry->node.IsEmpty());
-  cache_entry->node.Reset();
-  if (cache_entry->tree != nullptr) {
-    assert(cache_entry->tree->cached_nodes_.count(cache_entry->key));
-    cache_entry->tree->cached_nodes_.erase(cache_entry->key);
-  }
-  delete cache_entry;
-}
-
-void CacheNodeForTree(Tree *tree, Napi::Env _env, Object js_node) {
-  Value js_node_field1 = js_node[0U];
-  Value js_node_field2 = js_node[1U];
-  if (!js_node_field1.IsNumber() || !js_node_field2.IsNumber()) {
-    return;
-  }
-  uint32_t key_parts[2] = {
-    js_node_field1.As<Number>().Uint32Value(),
-    js_node_field2.As<Number>().Uint32Value(),
-  };
-  const void *key = UnmarshalNodeId(key_parts);
-
-  // A Node could have been garbage collected but the finalizer has not yet run to remove its cache entry
-  if (tree->cached_nodes_.count(key)) {
-    return;
-  }
-
-  auto *cache_entry = new Tree::NodeCacheEntry{tree, key, {}};
-  cache_entry->node = Napi::Weak(js_node);
-  js_node.AddFinalizer(&FinalizeNode, cache_entry);
-
-  tree->cached_nodes_[key] = cache_entry;
-}
-
-} // namespace
-
-Napi::Value Tree::CacheNode(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-
-  if (!info[0].IsObject()) {
-    throw TypeError::New(env, "not an object");
-  }
-
-  CacheNodeForTree(this, env, info[0].As<Object>());
-  return env.Undefined();
-}
-
-Napi::Value Tree::CacheNodes(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-
-  if (!info[0].IsArray()) {
-    throw TypeError::New(env, "not an array");
-  }
-  auto js_nodes = info[0].As<Array>();
-  uint32_t length = js_nodes.Length();
-
-  for (uint32_t i = 0; i < length; ++i) {
-    Napi::Value js_node = js_nodes[i];
-    if (!js_node.IsObject()) {
-      throw TypeError::New(env, "not an object");
-    }
-    CacheNodeForTree(this, env, js_node.As<Object>());
-  }
-
-  return env.Undefined();
-}
-
-} // namespace node_tree_sitter

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

@@ -1,45 +0,0 @@
-#ifndef NODE_TREE_SITTER_TREE_H_
-#define NODE_TREE_SITTER_TREE_H_
-
-#include "./addon_data.h"
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-#include <node_object_wrap.h>
-#include <unordered_map>
-
-namespace node_tree_sitter {
-
-class Tree final : public Napi::ObjectWrap<Tree> {
- public:
-  static void Init(Napi::Env env, Napi::Object exports);
-  static Napi::Value NewInstance(Napi::Env env, TSTree *tree);
-  static const Tree *UnwrapTree(const Napi::Value &value);
-
-  explicit Tree(const Napi::CallbackInfo &);
-  ~Tree() final;
-
-  struct NodeCacheEntry {
-    Tree *tree;
-    const void *key;
-    Napi::ObjectReference node;
-  };
-
-  TSTree *tree_;
-  std::unordered_map<const void *, NodeCacheEntry *> cached_nodes_;
-
- private:
-  Napi::Value Edit(const Napi::CallbackInfo &info);
-  Napi::Value RootNode(const Napi::CallbackInfo &info);
-  Napi::Value RootNodeWithOffset(const Napi::CallbackInfo &info);
-  Napi::Value PrintDotGraph(const Napi::CallbackInfo &info);
-  Napi::Value GetEditedRange(const Napi::CallbackInfo &info);
-  Napi::Value GetChangedRanges(const Napi::CallbackInfo &info);
-  Napi::Value GetIncludedRanges(const Napi::CallbackInfo &info);
-  Napi::Value CacheNode(const Napi::CallbackInfo &info);
-  Napi::Value CacheNodes(const Napi::CallbackInfo &info);
-};
-
-} // namespace node_tree_sitter
-
-#endif // NODE_TREE_SITTER_TREE_H_

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

@@ -1,213 +0,0 @@
-#include "./conversions.h"
-#include "./node.h"
-#include "./tree.h"
-#include "./tree_cursor.h"
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-
-using namespace Napi;
-
-namespace node_tree_sitter {
-
-void TreeCursor::Init(Napi::Env env, Napi::Object exports) {
-  auto *data = env.GetInstanceData<AddonData>();
-
-  Function ctor = DefineClass(env, "TreeCursor", {
-    InstanceAccessor("startIndex", &TreeCursor::StartIndex, nullptr, napi_default_method),
-    InstanceAccessor("endIndex", &TreeCursor::EndIndex, nullptr, napi_default_method),
-    InstanceAccessor("nodeType", &TreeCursor::NodeType, nullptr, napi_default_method),
-    InstanceAccessor("nodeTypeId", &TreeCursor::NodeTypeId, nullptr, napi_default_method),
-    InstanceAccessor("nodeStateId", &TreeCursor::NodeStateId, nullptr, napi_default_method),
-    InstanceAccessor("nodeIsNamed", &TreeCursor::NodeIsNamed, nullptr, napi_default_method),
-    InstanceAccessor("nodeIsMissing", &TreeCursor::NodeIsMissing, nullptr, napi_default_method),
-    InstanceAccessor("currentFieldId", &TreeCursor::CurrentFieldId, nullptr, napi_default_method),
-    InstanceAccessor("currentFieldName", &TreeCursor::CurrentFieldName, nullptr, napi_default_method),
-    InstanceAccessor("currentDepth", &TreeCursor::CurrentDepth, nullptr, napi_default_method),
-    InstanceAccessor("currentDescendantIndex", &TreeCursor::CurrentDescendantIndex, nullptr, napi_default_method),
-
-    InstanceMethod("gotoFirstChild", &TreeCursor::GotoFirstChild, napi_default_method),
-    InstanceMethod("gotoLastChild", &TreeCursor::GotoLastChild, napi_default_method),
-    InstanceMethod("gotoParent", &TreeCursor::GotoParent, napi_default_method),
-    InstanceMethod("gotoNextSibling", &TreeCursor::GotoNextSibling, napi_default_method),
-    InstanceMethod("gotoPreviousSibling", &TreeCursor::GotoPreviousSibling, napi_default_method),
-    InstanceMethod("gotoDescendant", &TreeCursor::GotoDescendant, napi_default_method),
-    InstanceMethod("gotoFirstChildForIndex", &TreeCursor::GotoFirstChildForIndex, napi_default_method),
-    InstanceMethod("gotoFirstChildForPosition", &TreeCursor::GotoFirstChildForPosition, napi_default_method),
-    InstanceMethod("startPosition", &TreeCursor::StartPosition, napi_default_method),
-    InstanceMethod("endPosition", &TreeCursor::EndPosition, napi_default_method),
-    InstanceMethod("currentNode", &TreeCursor::CurrentNode, napi_default_method),
-    InstanceMethod("reset", &TreeCursor::Reset, napi_default_method),
-    InstanceMethod("resetTo", &TreeCursor::ResetTo, napi_default_method),
-  });
-
-  exports["TreeCursor"] = ctor;
-  data->tree_cursor_constructor = Napi::Persistent(ctor);
-}
-
-Napi::Value TreeCursor::NewInstance(Napi::Env env, TSTreeCursor cursor) {
-  auto *data = env.GetInstanceData<AddonData>();
-
-  Object self = data->tree_cursor_constructor.New({});
-  TreeCursor::Unwrap(self)->cursor_ = cursor;
-  return self;
-}
-
-TreeCursor::TreeCursor(const Napi::CallbackInfo& info) : Napi::ObjectWrap<TreeCursor>(info), cursor_() {}
-
-TreeCursor::~TreeCursor() { ts_tree_cursor_delete(&cursor_); }
-
-Napi::Value TreeCursor::GotoFirstChild(const Napi::CallbackInfo &info) {
-  bool result = ts_tree_cursor_goto_first_child(&cursor_);
-  return Boolean::New(info.Env(), result);
-}
-
-Napi::Value TreeCursor::GotoLastChild(const Napi::CallbackInfo &info) {
-  bool result = ts_tree_cursor_goto_last_child(&cursor_);
-  return Boolean::New(info.Env(), result);
-}
-
-Napi::Value TreeCursor::GotoParent(const Napi::CallbackInfo &info) {
-  bool result = ts_tree_cursor_goto_parent(&cursor_);
-  return Boolean::New(info.Env(), result);
-}
-
-Napi::Value TreeCursor::GotoNextSibling(const Napi::CallbackInfo &info) {
-  bool result = ts_tree_cursor_goto_next_sibling(&cursor_);
-  return Boolean::New(info.Env(), result);
-}
-
-Napi::Value TreeCursor::GotoPreviousSibling(const Napi::CallbackInfo &info) {
-  bool result = ts_tree_cursor_goto_previous_sibling(&cursor_);
-  return Boolean::New(info.Env(), result);
-}
-
-Napi::Value TreeCursor::GotoDescendant(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  if (!info[0].IsNumber()) {
-    throw TypeError::New(env, "First argument must be an integer");
-  }
-  int64_t goal_descendant_index = info[0].As<Number>().Uint32Value();
-  ts_tree_cursor_goto_descendant(&cursor_, goal_descendant_index);
-  return env.Undefined();
-}
-
-Napi::Value TreeCursor::GotoFirstChildForIndex(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  if (!info[0].IsNumber()) {
-    throw TypeError::New(env, "First argument must be an integer");
-  }
-  auto index = info[0].As<Number>();
-  uint32_t goal_byte = index.Uint32Value() * 2;
-  int64_t child_index = ts_tree_cursor_goto_first_child_for_byte(&cursor_, goal_byte);
-  if (child_index < 0) {
-    return env.Null();
-  }
-  return Number::New(env, static_cast<double>(child_index));
- 
-}
-
-Napi::Value TreeCursor::GotoFirstChildForPosition(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  Napi::Maybe<TSPoint> goal_point = PointFromJS(info[0].As<Object>());
-  if (goal_point.IsNothing()) {
-    throw TypeError::New(env, "First argument must be a Point object");
-  }
-  int64_t child_index = ts_tree_cursor_goto_first_child_for_point(&cursor_, goal_point.Unwrap());
-  if (child_index < 0) {
-    return env.Null();
-  }
-  return Number::New(env, static_cast<double>(child_index));
-}
-
-Napi::Value TreeCursor::StartPosition(const Napi::CallbackInfo &info) {
-  TSNode node = ts_tree_cursor_current_node(&cursor_);
-  TransferPoint(info.Env(), ts_node_start_point(node));
-  return info.Env().Undefined();
-}
-
-Napi::Value TreeCursor::EndPosition(const Napi::CallbackInfo &info) {
-  TSNode node = ts_tree_cursor_current_node(&cursor_);
-  TransferPoint(info.Env(), ts_node_end_point(node));
-  return info.Env().Undefined();
-}
-
-Napi::Value TreeCursor::CurrentNode(const Napi::CallbackInfo &info) {
-  const Tree *tree = Tree::UnwrapTree(info.This().As<Object>()["tree"]);
-  TSNode node = ts_tree_cursor_current_node(&cursor_);
-  return node_methods::MarshalNode(info, tree, node);
-}
-
-Napi::Value TreeCursor::Reset(const Napi::CallbackInfo &info) {
-  const Tree *tree = Tree::UnwrapTree(info.This().As<Object>()["tree"]);
-  TSNode node = node_methods::UnmarshalNode(info.Env(), tree);
-  ts_tree_cursor_reset(&cursor_, node);
-  return info.Env().Undefined();
-}
-
-Napi::Value TreeCursor::ResetTo(const Napi::CallbackInfo &info) {
-  TSTreeCursor other_cursor = TreeCursor::Unwrap(info[0].As<Object>())->cursor_;
-  ts_tree_cursor_reset_to(&cursor_, &other_cursor);
-  return info.Env().Undefined();
-}
-
-Napi::Value TreeCursor::NodeType(const Napi::CallbackInfo &info) {
-  TSNode node = ts_tree_cursor_current_node(&cursor_);
-  return String::New(info.Env(), ts_node_type(node));;
-}
-
-Napi::Value TreeCursor::NodeTypeId(const Napi::CallbackInfo &info) {
-  TSNode node = ts_tree_cursor_current_node(&cursor_);
-  return Number::New(info.Env(), static_cast<double>(ts_node_symbol(node)));
-}
-
-Napi::Value TreeCursor::NodeStateId(const Napi::CallbackInfo &info) {
-  TSNode node = ts_tree_cursor_current_node(&cursor_);
-  return Number::New(info.Env(), static_cast<double>(ts_node_parse_state(node)));
-}
-
-Napi::Value TreeCursor::NodeIsNamed(const Napi::CallbackInfo &info) {
-  TSNode node = ts_tree_cursor_current_node(&cursor_);
-  return Boolean::New(info.Env(), ts_node_is_named(node));
-}
-
-Napi::Value TreeCursor::NodeIsMissing(const Napi::CallbackInfo &info) {
-  TSNode node = ts_tree_cursor_current_node(&cursor_);
-  return Boolean::New(info.Env(), ts_node_is_missing(node));
-}
-
-Napi::Value TreeCursor::CurrentFieldId(const Napi::CallbackInfo &info) {
-  TSFieldId field_id = ts_tree_cursor_current_field_id(&cursor_);
-  if (field_id != 0) {
-    return Number::New(info.Env(), static_cast<double>(field_id));
-  }
-  return info.Env().Undefined();
-}
-
-Napi::Value TreeCursor::CurrentFieldName(const Napi::CallbackInfo &info) {
-  const char *field_name = ts_tree_cursor_current_field_name(&cursor_);
-  if (field_name != nullptr) {
-    return String::New(info.Env(), field_name);
-  }
-  return info.Env().Undefined();
-}
-
-Napi::Value TreeCursor::CurrentDepth(const Napi::CallbackInfo &info) {
-  return Number::New(info.Env(), static_cast<double>(ts_tree_cursor_current_depth(&cursor_)));
-}
-
-Napi::Value TreeCursor::CurrentDescendantIndex(const Napi::CallbackInfo &info) {
-  return Number::New(info.Env(), static_cast<double>(ts_tree_cursor_current_descendant_index(&cursor_)));
-}
-
-Napi::Value TreeCursor::StartIndex(const Napi::CallbackInfo &info) {
-  TSNode node = ts_tree_cursor_current_node(&cursor_);
-  return ByteCountToJS(info.Env(), ts_node_start_byte(node));
-}
-
-Napi::Value TreeCursor::EndIndex(const Napi::CallbackInfo &info) {
-  TSNode node = ts_tree_cursor_current_node(&cursor_);
-  return ByteCountToJS(info.Env(), ts_node_end_byte(node));
-}
-
-} // namespace node_tree_sitter

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

@@ -1,52 +0,0 @@
-#ifndef NODE_TREE_SITTER_TREE_CURSOR_H_
-#define NODE_TREE_SITTER_TREE_CURSOR_H_
-
-#include "./addon_data.h"
-#include "tree_sitter/api.h"
-
-#include <napi.h>
-#include <node_object_wrap.h>
-
-namespace node_tree_sitter {
-
-class TreeCursor final : public Napi::ObjectWrap<TreeCursor> {
- public:
-  static void Init(Napi::Env env, Napi::Object exports);
-  static Napi::Value NewInstance(Napi::Env Env, TSTreeCursor);
-
-  explicit TreeCursor(const Napi::CallbackInfo &);
-  ~TreeCursor() final;
-
-  TSTreeCursor cursor_;
-
- private:
-  Napi::Value GotoFirstChild(const Napi::CallbackInfo &);
-  Napi::Value GotoLastChild(const Napi::CallbackInfo &);
-  Napi::Value GotoParent(const Napi::CallbackInfo &);
-  Napi::Value GotoNextSibling(const Napi::CallbackInfo &);
-  Napi::Value GotoPreviousSibling(const Napi::CallbackInfo &);
-  Napi::Value GotoDescendant(const Napi::CallbackInfo &);
-  Napi::Value GotoFirstChildForIndex(const Napi::CallbackInfo &);
-  Napi::Value GotoFirstChildForPosition(const Napi::CallbackInfo &);
-  Napi::Value StartPosition(const Napi::CallbackInfo &);
-  Napi::Value EndPosition(const Napi::CallbackInfo &);
-  Napi::Value CurrentNode(const Napi::CallbackInfo &);
-  Napi::Value Reset(const Napi::CallbackInfo &);
-  Napi::Value ResetTo(const Napi::CallbackInfo &);
-
-  Napi::Value NodeType(const Napi::CallbackInfo &);
-  Napi::Value NodeTypeId(const Napi::CallbackInfo &);
-  Napi::Value NodeStateId(const Napi::CallbackInfo &);
-  Napi::Value NodeIsNamed(const Napi::CallbackInfo &);
-  Napi::Value NodeIsMissing(const Napi::CallbackInfo &);
-  Napi::Value CurrentFieldId(const Napi::CallbackInfo &);
-  Napi::Value CurrentFieldName(const Napi::CallbackInfo &);
-  Napi::Value CurrentDepth(const Napi::CallbackInfo &);
-  Napi::Value CurrentDescendantIndex(const Napi::CallbackInfo &);
-  Napi::Value StartIndex(const Napi::CallbackInfo &);
-  Napi::Value EndIndex(const Napi::CallbackInfo &);
-};
-
-} // namespace node_tree_sitter
-
-#endif // NODE_TREE_SITTER_TREE_CURSOR_H_