semantifold 0.1.1 → 0.3.0

package/node_modules/tree-sitter/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "tree-sitter",
+  "version": "0.25.1",
+  "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.5.0",
+    "node-gyp-build": "^4.8.4"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "@types/tmp": "^0.2.6",
+    "glob": "^13.0.0",
+    "node-gyp": "^12.1.0",
+    "prebuildify": "^6.0.1",
+    "tmp": "^0.2.5",
+    "tree-sitter-c": "^0.24.1",
+    "tree-sitter-embedded-template": "^0.25.0",
+    "tree-sitter-html": "^0.23.2",
+    "tree-sitter-java": "^0.23.5",
+    "tree-sitter-javascript": "^0.25.0",
+    "tree-sitter-json": "^0.24.8",
+    "tree-sitter-python": "^0.25.0",
+    "tree-sitter-ruby": "^0.23.1",
+    "tree-sitter-rust": "^0.24.0",
+    "typedoc": "^0.28.15",
+    "typedoc-plugin-rename-defaults": "^0.7.3",
+    "typescript": "^5.9.3"
+  },
+  "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

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

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

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

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

@@ -0,0 +1,105 @@
+#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_abi_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_abi_version(language));
+        throw RangeError::New(env, message.c_str());
+      }
+      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

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

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

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

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