@pulsar-edit/fuzzy-native 1.3.1 → 1.4.0

package/README.md

@@ -8,54 +8,7 @@ The scoring algorithm is heavily tuned for file paths, but should work for gener
 
 ## API
 
-```ts
-export type MatcherOptions = {
-  // Default: false
-  caseSensitive?: boolean,
-
-  // Default: infinite
-  maxResults?: number,
-
-  // Maximum gap to allow between consecutive letters in a match.
-  // Provide a smaller maxGap to speed up query results.
-  // Default: unlimited
-  maxGap?: number;
-
-  // Default: 1
-  numThreads?: number,
-
-  // Default: false
-  recordMatchIndexes?: boolean,
-
-  // can be either "fuzzaldrin" or anything else to use the file-based option
-  algorithm?: string
-}
-
-export type MatchResult = {
-  id: number,
-  value: string,
-
-  // A number in the range (0-1]. Higher scores are more relevant.
-  // 0 denotes "no match" and will never be returned.
-  score: number,
-
-  // Matching character index in `value` for each character in `query`.
-  // This can be costly, so this is only returned if `recordMatchIndexes` was set in `options`.
-  matchIndexes?: Array<number>,
-}
-
-export class Matcher {
-  constructor(candidates: Array<string>) {}
-
-  // Returns all matching candidates (subject to `options`).
-  // Will be ordered by score, descending.
-  match: (query: string, options?: MatcherOptions) => Array<MatchResult>;
-
-  addCandidates: (ids: Array<number>, candidates: Array<string>) => void;
-  removeCandidates: (ids: Array<number>) => void;
-  setCandidates: (ids: Array<number>, candidates: Array<string>) => void;
-}
-```
+Read `lib/main.d.ts` for the API of the `Matcher` class.
 
 See also the [spec](spec/fuzzy-native-spec.js) for basic usage.
 

package/binding.gyp

@@ -2,21 +2,24 @@
   'targets': [
     {
       'target_name': 'fuzzy-native',
-      'include_dirs': [ '<!(node -e "require(\'nan\')")' ],
+      'include_dirs': [
+        '<!@(node -p "require(\'node-addon-api\').include")'
+      ],
+      'defines': ['NAPI_DISABLE_CPP_EXCEPTIONS'],
       'cflags': [
-        '-std=c++17',
+        '-std=c++20',
         '-O3',
       ],
       'xcode_settings': {
         'OTHER_CPLUSPLUSFLAGS': [
-          '-std=c++17',
+          '-std=c++20',
           '-O3',
           '-stdlib=libc++',
         ],
         'MACOSX_DEPLOYMENT_TARGET': '10.7',
       },
       'sources': [
-        'src/binding.cpp',
+        'src/fuzzy-native.cpp',
         'src/fuzzaldrin_score.cpp',
         'src/score_match.cpp',
         'src/MatcherBase.cpp',

package/lib/main.d.ts

@@ -0,0 +1,119 @@
+
+/**
+ * The options that can be passed to {@link Matcher#match}.
+ */
+export type MatcherOptions = {
+  /** Whether matching is case-sensitive. Defaults to `false`. */
+  caseSensitive?: boolean;
+
+  /** How many results to return at the maximum. Defaults to no limit. */
+  maxResults?: number;
+
+  /**
+   * Maximum “gap” to allow between consecutive letters for a match candiate.
+   * Provide a smaller value to speed up query results. Defaults to no limit.
+   */
+  maxGap?: number;
+
+  /**
+   * How many threads to use while searching. Defaults to `1`.
+   */
+  numThreads?: number;
+
+  /**
+   * Whether to return metadata about the indices of the characters that
+   * matched in each returned max. Defaults to `false`.
+   */
+  recordMatchIndexes?: boolean;
+
+  /**
+   * The algorithm to use for fuzzy-matching. If `"fuzzaldrin"`, will use that
+   * algorithm for legacy support. Any other value, including the default of
+   * `undefined`, will trigger use of the default algorithm.
+   */
+  algorithm?: 'fuzzaldrin' | undefined;
+};
+
+/**
+ * A single result returned by {@link Matcher#match}.
+ */
+export type MatchResult = {
+  /** A unique identifier for the match. */
+  id: number;
+
+  /** The string value of the match. */
+  value: string;
+
+  /**
+   * A number in the range (0, 1] — i.e., the maximum value is `1` and the
+   * minimum value is the smallest possible positive value. Higher scores mean
+   * more relevant matches. `0` means “no match” and will never be returned.
+   */
+  score: number;
+
+  /**
+   * Matching charcter index in `value` for each character in `query`. This can
+   * be costly, so this information is returned only when
+   * {@link MatcherOptions.recordMatchIndexes} is `true`.
+   */
+  matchIndexes?: number[];
+}
+
+export class Matcher {
+  /**
+   * Construct a new {@link Matcher} object.
+   *
+   * You may specify candidates at instantiation time (with the same arguments
+   * used by {@link addCandidates} and {@link setCandidates}) or you may wait
+   * and add candidates later.
+   *
+   * @param ids A list of numeric IDs. Must correspond to the candidates
+   *  themselves.
+   * @param candidates A list of candidates against which we will be matching.
+   */
+  constructor();
+  constructor(ids: number[], candidates: string[]);
+
+  /**
+   * Find all candidates that match the given query.
+   *
+   * @param query The input against which candidates will be searched.
+   * @param options Any {@link MatcherOptions}.
+   */
+  match(query: string, options?: MatcherOptions): MatchResult[];
+
+  /**
+   * Add candidates to the list.
+   *
+   * You are responsible for ensuring that the IDs you use do not match the IDs
+   * of any candidates that are already present in the `Matcher`. Any
+   * candidates whose IDs already exist in the `Matcher` are silently ignored.
+   *
+   * @param ids A list of numeric IDs. Must correspond to the candidates
+   *  themselves.
+   * @param candidates A list of candidates against which we will be matching.
+   */
+  addCandidates(ids: number[], candidates: string[]): void;
+
+  /**
+   * Remove candidates from the list.
+   *
+   * @param ids The unique identifiers for each of the candidates you want to
+   *  remove. Must be an array; if you want to remove only one candidate, wrap
+   *  the value in an array first.
+   */
+  removeCandidates(ids: number[]): void;
+
+  /**
+   * Set a complete list of candidates, removing any candidate that may already
+   * be defined.
+   *
+   * If you want to add candidates instead without removing any that may
+   * already exist, use {@link addCandidates}.
+   *
+   * @param ids A list of numeric IDs. Must correspond to the candidates
+   *  themselves.
+   * @param candidates A list of candidates against which we will be matching.
+   */
+  setCandidates(ids: number[], candidates: string[]): void;
+}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@pulsar-edit/fuzzy-native",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Native C++ implementation of a fuzzy string matcher.",
   "main": "lib/main.js",
+  "types": "lib/main.d.ts",
   "scripts": {
     "test": "jasmine-node --captureExceptions spec"
   },
@@ -21,7 +22,7 @@
   "repository": "https://github.com/pulsar-edit/fuzzy-native",
   "license": "MIT",
   "dependencies": {
-    "nan": "^2.18.0"
+    "node-addon-api": "^8.8.0"
   },
   "devDependencies": {
     "jasmine-node": "^1.14.5",

package/src/MatcherBase.cpp

@@ -1,6 +1,6 @@
 #include "MatcherBase.h"
-#include "score_match.h"
 #include "fuzzaldrin_score.h"
+#include "score_match.h"
 
 #include <algorithm>
 #include <atomic>
@@ -34,7 +34,7 @@ inline uint64_t letter_bitmask(const std::string &str) {
 
 inline string str_to_lower(const std::string &s) {
   string lower(s);
-  for (auto& c : lower) {
+  for (auto &c : lower) {
     if (c >= 'A' && c <= 'Z') {
       c += 'a' - 'A';
     }
@@ -42,9 +42,7 @@ inline string str_to_lower(const std::string &s) {
   return lower;
 }
 
-bool is_slash(char c) {
-  return c == '/' || c == '\\';
-}
+bool is_slash(char c) { return c == '/' || c == '\\'; }
 
 int num_dirs(const std::string &path) {
   int num = 0;
@@ -86,12 +84,8 @@ int score_based_root_path(const MatchOptions &options,
 }
 
 // Push a new entry on the heap while ensuring size <= max_results.
-void push_heap(ResultHeap &heap,
-               float score,
-               int score_based_root_path,
-               uint32_t id,
-               const std::string *value,
-               size_t max_results) {
+void push_heap(ResultHeap &heap, float score, int score_based_root_path,
+               uint32_t id, const std::string *value, size_t max_results) {
   MatchResult result(score, score_based_root_path, id, value);
   if (heap.size() < max_results || result < heap.top()) {
     heap.push(std::move(result));
@@ -101,26 +95,17 @@ void push_heap(ResultHeap &heap,
   }
 }
 
-vector<MatchResult> finalize(const string &query,
-                             const string &query_case,
+vector<MatchResult> finalize(const string &query, const string &query_case,
                              const MatchOptions &options,
-                             bool record_match_indexes,
-                             ResultHeap &&heap) {
+                             bool record_match_indexes, ResultHeap &&heap) {
   vector<MatchResult> vec;
   while (heap.size()) {
     const MatchResult &result = heap.top();
     if (record_match_indexes) {
       result.matchIndexes.reset(new vector<int>(query.size()));
       string lower = str_to_lower(*result.value);
-      score_match(
-        result.value->c_str(),
-        lower.c_str(),
-        query.c_str(),
-        query_case.c_str(),
-        options,
-        0.0,
-        result.matchIndexes.get()
-      );
+      score_match(result.value->c_str(), lower.c_str(), query.c_str(),
+                  query_case.c_str(), options, 0.0, result.matchIndexes.get());
     }
     vec.push_back(result);
     heap.pop();
@@ -129,18 +114,11 @@ vector<MatchResult> finalize(const string &query,
   return vec;
 }
 
-void thread_worker(
-  const string &query,
-  const string &query_case,
-  const MatchOptions &options,
-  bool use_last_match,
-  std::atomic<float>* min_score,
-  size_t max_results,
-  vector<MatcherBase::CandidateData> &candidates,
-  size_t start,
-  size_t end,
-  ResultHeap &result
-) {
+void thread_worker(const string &query, const string &query_case,
+                   const MatchOptions &options, bool use_last_match,
+                   std::atomic<float> *min_score, size_t max_results,
+                   vector<MatcherBase::CandidateData> &candidates, size_t start,
+                   size_t end, ResultHeap &result) {
   uint64_t bitmask = letter_bitmask(query_case.c_str());
   for (size_t i = start; i < end; i++) {
     auto &candidate = candidates[i];
@@ -149,30 +127,19 @@ void thread_worker(
     }
     if ((bitmask & candidate.bitmask) == bitmask) {
       float score;
-      if(query == "") {
+      if (query == "") {
         score = 1;
-      } else if(options.fuzzaldrin) {
+      } else if (options.fuzzaldrin) {
         score = fuzzaldrin_score(candidate.value, query);
         score = fuzzaldrin_basename_score(candidate.value, query, score);
       } else {
-        score = score_match(
-          candidate.value.c_str(),
-          candidate.lowercase.c_str(),
-          query.c_str(),
-          query_case.c_str(),
-          options,
-          min_score->load()
-        );
+        score = score_match(candidate.value.c_str(),
+                            candidate.lowercase.c_str(), query.c_str(),
+                            query_case.c_str(), options, min_score->load());
       }
       if (score > 0) {
-        push_heap(
-          result,
-          score,
-          score_based_root_path(options, candidate),
-          candidate.id,
-          &candidate.value,
-          max_results
-        );
+        push_heap(result, score, score_based_root_path(options, candidate),
+                  candidate.id, &candidate.value, max_results);
         if (result.size() == max_results) {
           float current_max = result.top().score;
           float min_score_value = min_score->load();
@@ -232,8 +199,9 @@ vector<MatchResult> MatcherBase::findMatches(const std::string &query,
   ResultHeap combined;
   std::atomic<float> min_score(0);
   if (num_threads == 0 || candidates_.size() < 10000) {
-    thread_worker(new_query, query_case, matchOptions, use_last_match, &min_score,
-                  max_results, candidates_, 0, candidates_.size(), combined);
+    thread_worker(new_query, query_case, matchOptions, use_last_match,
+                  &min_score, max_results, candidates_, 0, candidates_.size(),
+                  combined);
   } else {
     vector<ResultHeap> thread_results(num_threads);
     vector<thread> threads;
@@ -244,19 +212,10 @@ vector<MatchResult> MatcherBase::findMatches(const std::string &query,
       if (i < candidates_.size() % num_threads) {
         chunk_size++;
       }
-      threads.emplace_back(
-        thread_worker,
-        ref(new_query),
-        ref(query_case),
-        ref(matchOptions),
-        use_last_match,
-        &min_score,
-        max_results,
-        ref(candidates_),
-        cur_start,
-        cur_start + chunk_size,
-        ref(thread_results[i])
-      );
+      threads.emplace_back(thread_worker, ref(new_query), ref(query_case),
+                           ref(matchOptions), use_last_match, &min_score,
+                           max_results, ref(candidates_), cur_start,
+                           cur_start + chunk_size, ref(thread_results[i]));
       cur_start += chunk_size;
     }
 
@@ -264,26 +223,15 @@ vector<MatchResult> MatcherBase::findMatches(const std::string &query,
       threads[i].join();
       while (thread_results[i].size()) {
         auto &top = thread_results[i].top();
-        push_heap(
-          combined,
-          top.score,
-          top.score_based_root_path,
-          top.id,
-          top.value,
-          max_results
-        );
+        push_heap(combined, top.score, top.score_based_root_path, top.id,
+                  top.value, max_results);
         thread_results[i].pop();
       }
     }
   }
 
-  return finalize(
-    new_query,
-    query_case,
-    matchOptions,
-    options.record_match_indexes,
-    move(combined)
-  );
+  return finalize(new_query, query_case, matchOptions,
+                  options.record_match_indexes, std::move(combined));
 }
 
 void MatcherBase::addCandidate(uint32_t id, const string &candidate) {
@@ -295,10 +243,10 @@ void MatcherBase::addCandidate(uint32_t id, const string &candidate) {
     data.id = id;
     data.value = candidate;
     data.bitmask = letter_bitmask(lowercase.c_str());
-    data.lowercase = move(lowercase);
+    data.lowercase = std::move(lowercase);
     data.last_match = true;
     data.num_dirs = num_dirs(candidate);
-    candidates_.emplace_back(move(data));
+    candidates_.emplace_back(std::move(data));
   }
 }
 
@@ -324,6 +272,4 @@ void MatcherBase::reserve(size_t n) {
   lookup_.reserve(n);
 }
 
-size_t MatcherBase::size() const {
-  return candidates_.size();
-}
+size_t MatcherBase::size() const { return candidates_.size(); }

package/src/fuzzy-native.cpp

@@ -0,0 +1,155 @@
+#include "fuzzy-native.h"
+
+#include <cmath>
+
+using namespace Napi;
+
+#define CHECK(env, cond, msg)                                    \
+    if (!(cond))                                                 \
+    {                                                            \
+        Napi::Error::New(env, msg).ThrowAsJavaScriptException(); \
+        return;                                                  \
+    }
+
+#define CHECK_OR_RETURN(env, cond, msg, retval)                  \
+    if (!(cond))                                                 \
+    {                                                            \
+        Napi::Error::New(env, msg).ThrowAsJavaScriptException(); \
+        return retval;                                           \
+    }
+
+Matcher::Matcher(const Napi::CallbackInfo &info) : ObjectWrap<Matcher>(info)
+{
+  if (info.Length() > 0) {
+    AddCandidates(info);
+  }
+}
+
+Napi::Value Matcher::Match(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    CHECK_OR_RETURN(env, info.Length() >= 1, "Wrong Number of arguments", env.Null());
+    CHECK_OR_RETURN(env, info[0].IsString(), "First argument should be a query string", env.Null());
+    auto query = info[0].As<Napi::String>().Utf8Value();
+    MatcherOptions options;
+    if (info.Length() > 1) {
+      CHECK_OR_RETURN(env, info[1].IsObject(), "Second argument should be an options object", env.Null());
+      Napi::Object options_obj = info[1].As<Napi::Object>();
+
+      options.case_sensitive = options_obj.Get("caseSensitive").ToBoolean();
+      options.smart_case = options_obj.Get("smartCase").ToBoolean();
+      options.num_threads = options_obj.Get("numThreads").ToNumber().Uint32Value();
+      options.max_results = options_obj.Get("maxResults").ToNumber().Uint32Value();
+      options.max_gap = options_obj.Get("maxGap").ToNumber().Uint32Value();
+      options.record_match_indexes = options_obj.Get("recordMatchIndexes");
+      options.fuzzaldrin = options_obj.Get("algorithm").ToString().Utf8Value() == "fuzzaldrin";
+      options.root_path = options_obj.Get("rootPath").ToString();
+    }
+  auto idKey = Napi::String::New(env, "id");
+  auto valueKey = Napi::String::New(env, "value");
+  auto scoreKey = Napi::String::New(env, "score");
+  auto matchIndexesKey = Napi::String::New(env, "matchIndexes");
+
+  std::vector<MatchResult> matches = this->_impl.findMatches(query, options);
+
+  auto result = Napi::Array::New(env);
+  size_t result_count = 0;
+
+  for (const auto &match : matches) {
+    auto obj = Napi::Object::New(env);
+    obj.Set(idKey, Napi::Number::New(env, match.id));
+    obj.Set(scoreKey, Napi::Number::New(env, match.score));
+    obj.Set(valueKey, Napi::String::New(env, *match.value));
+
+    if (match.matchIndexes != nullptr) {
+      Napi::Array array = Napi::Array::New(env, match.matchIndexes->size());
+      for (size_t i = 0; i < array.Length(); i++) {
+        array.Set(i, Napi::Number::New(env, match.matchIndexes->at(i)));
+      }
+      obj.Set(matchIndexesKey, array);
+    }
+    result.Set(result_count++, obj);
+  }
+  return result;
+}
+
+void Matcher::AddCandidates(const Napi::CallbackInfo &info)
+{
+  auto env = info.Env();
+  if (info.Length() > 0) {
+    CHECK(env, info[0].IsArray(), "Expected an array of unsigned 32-bit integer ids as the first argument");
+    CHECK(env, info[1].IsArray(), "Expected an array of strings as the second argument");
+
+    auto ids = info[0].As<Napi::Array>();
+    auto values = info[1].As<Napi::Array>();
+
+    CHECK(env, ids.Length() == values.Length(), "Expected ids array and values array to have the same length");
+
+    // Create a random permutation so that candidates are shuffled.
+    std::vector<size_t> indexes(ids.Length());
+    for (size_t i = 0; i < indexes.size(); i++)
+    {
+      indexes[i] = i;
+      if (i > 0)
+      {
+        std::swap(indexes[rand() % i], indexes[i]);
+      }
+    }
+    this->_impl.reserve(this->_impl.size() + ids.Length());
+    for (auto i : indexes) {
+      auto id_value = ids.Get(i);
+      double raw = id_value.As<Napi::Number>().DoubleValue();
+      CHECK(env, raw >= 0 && raw == std::floor(raw), "Expected first array to only contain unsigned 32-bit integer ids");
+      uint32_t id = id_value.As<Napi::Number>().Uint32Value();
+      auto value = values.Get(i).As<Napi::String>();
+      this->_impl.addCandidate(id, value.Utf8Value());
+    }
+  }
+}
+
+void Matcher::RemoveCandidates(const Napi::CallbackInfo &info)
+{
+  auto env = info.Env();
+  if (info.Length() > 0) {
+    CHECK(env, info[0].IsArray(), "Expected an array of unsigned 32-bit integer ids");
+    auto ids = info[0].As<Napi::Array>();
+    for (size_t i = 0; i < ids.Length(); i++) {
+      auto id_value = ids.Get(i);
+      double raw = id_value.As<Napi::Number>().DoubleValue();
+      CHECK(env, raw >= 0 && raw == std::floor(raw), "Expected array to only contain unsigned 32-bit integer ids");
+      uint32_t id = id_value.As<Napi::Number>().Uint32Value();
+      this->_impl.removeCandidate(id);
+    }
+  }
+}
+
+void Matcher::SetCandidates(const Napi::CallbackInfo &info)
+{
+  this->_impl.clear();
+  AddCandidates(info);
+}
+
+Napi::FunctionReference Matcher::constructor;
+
+Napi::Function Matcher::GetClass(Napi::Env env) {
+  Napi::Function func = DefineClass(
+      env, "Matcher",
+      {InstanceMethod("match", &Matcher::Match),
+       InstanceMethod("addCandidates", &Matcher::AddCandidates),
+       InstanceMethod("removeCandidates", &Matcher::RemoveCandidates),
+       InstanceMethod("setCandidates", &Matcher::SetCandidates)});
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  return func;
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+    Napi::String matcher = Napi::String::New(env, "Matcher");
+    exports.Set(matcher, Matcher::GetClass(env));
+
+    return exports;
+}
+
+NODE_API_MODULE(addon, Init)

package/src/fuzzy-native.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <napi.h>
+#include "MatcherBase.h"
+
+class Matcher : public Napi::ObjectWrap<Matcher>
+{
+private:
+    static Napi::FunctionReference constructor;
+    MatcherBase _impl;
+
+public:
+    Matcher(const Napi::CallbackInfo &info);
+    Napi::Value Match(const Napi::CallbackInfo &info);
+    void AddCandidates(const Napi::CallbackInfo &info);
+    void RemoveCandidates(const Napi::CallbackInfo &info);
+    void SetCandidates(const Napi::CallbackInfo &info);
+
+    static Napi::Function GetClass(Napi::Env);
+};

package/src/binding.cpp

@@ -1,233 +0,0 @@
-#include <nan.h>
-#include <vector>
-#include <unordered_map>
-#include <chrono>
-
-#include "MatcherBase.h"
-
-using namespace Nan;
-
-#define CHECK(cond, msg) \
-  if (!(cond))           \
-  {                      \
-    ThrowTypeError(msg); \
-    return;              \
-  }
-
-template <typename T>
-T get_property(const v8::Local<v8::Object> &object, const char *name)
-{
-  auto prop = Nan::Get(object, Nan::New(name).ToLocalChecked());
-  if (prop.IsEmpty())
-  {
-    return T();
-  }
-  Nan::Maybe<T> result = Nan::To<T>(prop.ToLocalChecked());
-  if (result.IsNothing())
-  {
-    return T();
-  }
-  return result.FromJust();
-}
-
-/**
- * This saves one string copy over using v8::String::Utf8Value.
- */
-std::string to_std_string(const v8::Local<v8::String> &v8str)
-{
-  v8::Isolate *isolate = v8::Isolate::GetCurrent();
-  std::string str(v8str->Utf8Length(isolate), ' ');
-  v8str->WriteUtf8(isolate, &str[0]);
-  return str;
-}
-
-std::string get_string_property(const v8::Local<v8::Object> &object,
-                                const char *name)
-{
-  auto prop =
-      Nan::Get(object, Nan::New(name).ToLocalChecked());
-  if (!prop.IsEmpty())
-  {
-    auto propLocal = prop.ToLocalChecked();
-    if (propLocal->IsNull() || propLocal->IsUndefined())
-    {
-      return std::string("");
-    }
-    if (!propLocal->IsString())
-    {
-      std::string msg =
-          std::string("property ") +
-          name +
-          std::string(" must be a string");
-      ThrowTypeError(msg.c_str());
-    }
-
-    return to_std_string(Nan::To<v8::String>(propLocal).ToLocalChecked());
-  }
-  return std::string("");
-}
-
-Persistent<v8::Function> MatcherConstructor;
-
-class Matcher : public ObjectWrap
-{
-public:
-  static void Init(v8::Local<v8::Object> exports)
-  {
-    // Prepare constructor template
-    v8::Local<v8::FunctionTemplate> tpl =
-        New<v8::FunctionTemplate>(Matcher::Create);
-    tpl->SetClassName(New("Matcher").ToLocalChecked());
-    tpl->InstanceTemplate()->SetInternalFieldCount(1);
-
-    // Prototype
-    SetPrototypeMethod(tpl, "match", Match);
-    SetPrototypeMethod(tpl, "addCandidates", AddCandidates);
-    SetPrototypeMethod(tpl, "removeCandidates", RemoveCandidates);
-    SetPrototypeMethod(tpl, "setCandidates", SetCandidates);
-
-    v8::Local<v8::Context> context = Nan::GetCurrentContext();
-
-    MatcherConstructor.Reset(tpl->GetFunction(context).ToLocalChecked());
-    Set(exports, Nan::New("Matcher").ToLocalChecked(), tpl->GetFunction(context).ToLocalChecked());
-  }
-
-  static void Create(const Nan::FunctionCallbackInfo<v8::Value> &info)
-  {
-    CHECK(info.IsConstructCall(), "Use 'new' to construct Matcher");
-    auto obj = new Matcher();
-    obj->Wrap(info.This());
-    AddCandidates(info);
-    info.GetReturnValue().Set(info.This());
-  }
-
-  static void Match(const FunctionCallbackInfo<v8::Value> &info)
-  {
-    if (info.Length() < 1)
-    {
-      Nan::ThrowTypeError("Wrong number of arguments");
-      return;
-    }
-
-    CHECK(info[0]->IsString(), "First argument should be a query string");
-    std::string query(to_std_string(Nan::To<v8::String>(info[0]).ToLocalChecked()));
-
-    MatcherOptions options;
-    if (info.Length() > 1)
-    {
-      CHECK(info[1]->IsObject(), "Second argument should be an options object");
-      auto options_obj = Nan::To<v8::Object>(info[1]).ToLocalChecked();
-      options.case_sensitive = get_property<bool>(options_obj, "caseSensitive");
-      options.smart_case = get_property<bool>(options_obj, "smartCase");
-      options.num_threads = get_property<int>(options_obj, "numThreads");
-      options.max_results = get_property<int>(options_obj, "maxResults");
-      options.max_gap = get_property<int>(options_obj, "maxGap");
-      options.record_match_indexes =
-          get_property<bool>(options_obj, "recordMatchIndexes");
-      options.fuzzaldrin =
-          get_string_property(options_obj, "algorithm") == "fuzzaldrin";
-      options.root_path = get_string_property(options_obj, "rootPath");
-    }
-
-    auto idKey = New("id").ToLocalChecked();
-    auto valueKey = New("value").ToLocalChecked();
-    auto scoreKey = New("score").ToLocalChecked();
-    auto matchIndexesKey = New("matchIndexes").ToLocalChecked();
-
-    auto matcher = Unwrap<Matcher>(info.This());
-    std::vector<MatchResult> matches =
-        matcher->impl_.findMatches(query, options);
-    auto result = New<v8::Array>();
-    size_t result_count = 0;
-    for (const auto &match : matches)
-    {
-      auto obj = New<v8::Object>();
-      Set(obj, idKey, New<v8::Uint32>(match.id));
-      Set(obj, scoreKey, New(match.score));
-      Set(obj, valueKey, New(*match.value).ToLocalChecked());
-
-      v8::Local<v8::Context> context = Nan::GetCurrentContext();
-      if (match.matchIndexes != nullptr)
-      {
-        auto array = New<v8::Array>(match.matchIndexes->size());
-        for (size_t i = 0; i < array->Length(); i++)
-        {
-          array->Set(context, i, New(match.matchIndexes->at(i)));
-        }
-        Set(obj, matchIndexesKey, array);
-      }
-      result->Set(context, result_count++, obj);
-    }
-    info.GetReturnValue().Set(result);
-  }
-
-  static void AddCandidates(const FunctionCallbackInfo<v8::Value> &info)
-  {
-    auto matcher = Unwrap<Matcher>(info.This());
-    if (info.Length() > 0)
-    {
-      CHECK(info[0]->IsArray(), "Expected an array of unsigned 32-bit integer ids as the first argument");
-      CHECK(info[1]->IsArray(), "Expected an array of strings as the second argument");
-
-      auto ids = v8::Local<v8::Array>::Cast(info[0]);
-      auto values = v8::Local<v8::Array>::Cast(info[1]);
-
-      CHECK(ids->Length() == values->Length(), "Expected ids array and values array to have the same length");
-
-      // Create a random permutation so that candidates are shuffled.
-      std::vector<size_t> indexes(ids->Length());
-      for (size_t i = 0; i < indexes.size(); i++)
-      {
-        indexes[i] = i;
-        if (i > 0)
-        {
-          std::swap(indexes[rand() % i], indexes[i]);
-        }
-      }
-      matcher->impl_.reserve(matcher->impl_.size() + ids->Length());
-
-      v8::Local<v8::Context> context = Nan::GetCurrentContext();
-      for (auto i : indexes)
-      {
-        auto id_value = ids->Get(context, i).ToLocalChecked();
-        CHECK(id_value->IsUint32(), "Expected first array to only contain unsigned 32-bit integer ids");
-        auto id = v8::Local<v8::Uint32>::Cast(id_value)->Value();
-        auto value = to_std_string(Nan::To<v8::String>(values->Get(context, i).ToLocalChecked()).ToLocalChecked());
-        matcher->impl_.addCandidate(id, value);
-      }
-    }
-  }
-
-  static void RemoveCandidates(const FunctionCallbackInfo<v8::Value> &info)
-  {
-    auto matcher = Unwrap<Matcher>(info.This());
-    if (info.Length() > 0)
-    {
-      CHECK(info[0]->IsArray(), "Expected an array of unsigned 32-bit integer ids");
-      auto ids = v8::Local<v8::Array>::Cast(info[0]);
-
-      v8::Local<v8::Context> context = Nan::GetCurrentContext();
-      for (size_t i = 0; i < ids->Length(); i++)
-      {
-        auto id_value = ids->Get(context, i).ToLocalChecked();
-        CHECK(id_value->IsUint32(), "Expected array to only contain unsigned 32-bit integer ids");
-        auto id = v8::Local<v8::Uint32>::Cast(id_value)->Value();
-        matcher->impl_.removeCandidate(id);
-      }
-    }
-  }
-
-  static void SetCandidates(const FunctionCallbackInfo<v8::Value> &info)
-  {
-    auto matcher = Unwrap<Matcher>(info.This());
-    matcher->impl_.clear();
-    AddCandidates(info);
-  }
-
-private:
-  MatcherBase impl_;
-};
-
-void Init(v8::Local<v8::Object> exports) { Matcher::Init(exports); }
-
-NAN_MODULE_WORKER_ENABLED(addon, Init)