semantifold 0.1.1 → 0.3.0

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

@@ -0,0 +1,316 @@
+#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

@@ -0,0 +1,45 @@
+#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

@@ -0,0 +1,213 @@
+#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

@@ -0,0 +1,52 @@
+#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_