re2 1.21.1 → 1.21.2

package/README.md

@@ -353,6 +353,7 @@ console.log('re2_res : ' + re2_res); // prints: re2_res : abc,a,b,c
 
 ## Release history
 
+- 1.21.2 *Fixed another memory regression reported by [matthewvalentine](https://github.com/matthewvalentine), thx! Updated deps. Added more tests and benchmarks.*
 - 1.21.1 *Fixed a memory regression reported by [matthewvalentine](https://github.com/matthewvalentine), thx! Updated deps.*
 - 1.21.0 *Fixed the performance problem reported by [matthewvalentine](https://github.com/matthewvalentine) (thx!). The change improves performance for multiple use cases.*
 - 1.20.12 *Updated deps. Maintenance chores. Fixes for buffer-related bugs: `exec()` index (reported by [matthewvalentine](https://github.com/matthewvalentine), thx) and `match()` index.*

package/binding.gyp

@@ -5,7 +5,6 @@
       "sources": [
         "lib/addon.cc",
         "lib/accessors.cc",
-        "lib/str-val.cc",
         "lib/util.cc",
         "lib/new.cc",
         "lib/exec.cc",

package/lib/accessors.cc

@@ -28,30 +28,6 @@ NAN_GETTER(WrappedRE2::GetInternalSource)
 	info.GetReturnValue().Set(Nan::New(re2->regexp.pattern()).ToLocalChecked());
 }
 
-NAN_GETTER(WrappedRE2::GetEnabledCache)
-{
-	if (!WrappedRE2::HasInstance(info.This()))
-	{
-		info.GetReturnValue().SetUndefined();
-		return;
-	}
-
-	auto re2 = Nan::ObjectWrap::Unwrap<WrappedRE2>(info.This());
-	info.GetReturnValue().Set(re2->enabledCache);
-}
-
-NAN_GETTER(WrappedRE2::GetIsCached)
-{
-	if (!WrappedRE2::HasInstance(info.This()))
-	{
-		info.GetReturnValue().SetUndefined();
-		return;
-	}
-
-	auto re2 = Nan::ObjectWrap::Unwrap<WrappedRE2>(info.This());
-	info.GetReturnValue().Set(!!re2->lastStringValue);
-}
-
 NAN_GETTER(WrappedRE2::GetFlags)
 {
 	if (!WrappedRE2::HasInstance(info.This()))
@@ -63,10 +39,6 @@ NAN_GETTER(WrappedRE2::GetFlags)
 	auto re2 = Nan::ObjectWrap::Unwrap<WrappedRE2>(info.This());
 
 	std::string flags;
-	if (re2->enabledCache)
-	{
-		flags += "\b";
-	}
 	if (re2->hasIndices)
 	{
 		flags += "d";

package/lib/addon.cc

@@ -1,7 +1,5 @@
 #include "./wrapped_re2.h"
 
-#include "./str-val.h"
-
 static NAN_METHOD(GetUtf8Length)
 {
 	auto t = info[0]->ToString(Nan::GetCurrentContext());
@@ -74,8 +72,6 @@ v8::Local<v8::Function> WrappedRE2::Init()
 	Nan::SetAccessor(instanceTemplate, Nan::New("hasIndices").ToLocalChecked(), GetHasIndices);
 	Nan::SetAccessor(instanceTemplate, Nan::New("lastIndex").ToLocalChecked(), GetLastIndex, SetLastIndex);
 	Nan::SetAccessor(instanceTemplate, Nan::New("internalSource").ToLocalChecked(), GetInternalSource);
-	Nan::SetAccessor(instanceTemplate, Nan::New("enabledCache").ToLocalChecked(), GetEnabledCache);
-	Nan::SetAccessor(instanceTemplate, Nan::New("isCached").ToLocalChecked(), GetIsCached);
 
 	auto ctr = Nan::GetFunction(tpl).ToLocalChecked();
 
@@ -96,77 +92,124 @@ NODE_MODULE_INIT()
 
 WrappedRE2::~WrappedRE2()
 {
-	for (auto ptr : callbackRegistry)
-	{
-		*ptr = nullptr;
-	}
-	dropLastString();
+	dropCache();
 }
 
 // private methods
 
-WrappedRE2::PtrWrappedRE2 *WrappedRE2::registerCallback()
+void WrappedRE2::dropCache()
 {
-	PtrWrappedRE2 *ptr = new PtrWrappedRE2(this);
-	callbackRegistry.insert(ptr);
-	return ptr;
+	if (!lastString.IsEmpty())
+	{
+		// lastString.ClearWeak();
+		lastString.Reset();
+	}
+	if (!lastCache.IsEmpty())
+	{
+		// lastCache.ClearWeak();
+		lastCache.Reset();
+	}
+	lastStringValue.clear();
 }
 
-void WrappedRE2::unregisterCallback(PtrWrappedRE2 *ptr)
+const StrVal& WrappedRE2::prepareArgument(const v8::Local<v8::Value> &arg, bool ignoreLastIndex)
 {
-	callbackRegistry.erase(ptr);
-}
+	size_t startFrom = ignoreLastIndex ? 0 : lastIndex;
 
-void WrappedRE2::dropLastString()
-{
-	lastString.Reset();
-	if (lastStringValue)
+	if (lastString == arg && !node::Buffer::HasInstance(arg) && !lastCache.IsEmpty())
 	{
-		delete lastStringValue;
-		lastStringValue = nullptr;
+		// we have a properly cached string
+		lastStringValue.setIndex(startFrom);
+		return lastStringValue;
 	}
-}
 
-void WrappedRE2::weakLastStringCallback(const Nan::WeakCallbackInfo<PtrWrappedRE2> &data)
-{
-	PtrWrappedRE2 *re2 = data.GetParameter();
-	if (*re2)
+	dropCache();
+
+	if (node::Buffer::HasInstance(arg))
 	{
-		(*re2)->unregisterCallback(re2);
-		(*re2)->dropLastString();
+		// no need to cache buffers
+
+		lastString.Reset(arg);
+		static_cast<v8::PersistentBase<v8::Value> &>(lastString).SetWeak();
+
+		auto argSize = node::Buffer::Length(arg);
+		lastStringValue.reset(arg, argSize, argSize, startFrom, true);
+
+		return lastStringValue;
 	}
-	delete re2;
-}
 
-void WrappedRE2::prepareLastString(const v8::Local<v8::Value> &arg, bool ignoreLastIndex)
+	// caching the string
+
+	auto t = arg->ToString(Nan::GetCurrentContext());
+	if (t.IsEmpty())
+	{
+		// do not process bad strings
+		lastStringValue.isBad = true;
+		return lastStringValue;
+	}
+
+	lastString.Reset(arg);
+	static_cast<v8::PersistentBase<v8::Value> &>(lastString).SetWeak();
+
+	auto s = t.ToLocalChecked();
+	auto argLength = Nan::DecodeBytes(s);
+
+	auto buffer = node::Buffer::New(v8::Isolate::GetCurrent(), s).ToLocalChecked();
+	lastCache.Reset(buffer);
+	static_cast<v8::PersistentBase<v8::Object> &>(lastCache).SetWeak();
+
+	auto argSize = node::Buffer::Length(buffer);
+	lastStringValue.reset(buffer, argSize, argLength, startFrom);
+
+	return lastStringValue;
+};
+
+// StrVal
+
+void StrVal::setIndex(size_t newIndex)
 {
-	size_t startFrom = ignoreLastIndex ? 0 : lastIndex;
+	isValidIndex = newIndex <= length;
+	if (!isValidIndex)
+	{
+		index = newIndex;
+		byteIndex = 0;
+		return;
+	}
 
-	if (node::Buffer::HasInstance(arg))
+	if (newIndex == index)
+		return;
+
+	if (isBuffer)
 	{
-		dropLastString();
-		lastStringValue = new StrValBuffer(arg, startFrom);
+		byteIndex = index = newIndex;
 		return;
 	}
 
 	// String
 
-	// check if the same string is already in the cache
-	if (lastString == arg && lastStringValue)
+	if (!newIndex)
 	{
-		if (!global && !sticky)
-			return; // we are good
-		lastStringValue->setIndex(startFrom);
+		byteIndex = index = 0;
 		return;
 	}
 
-	dropLastString();
-
-	lastString.Reset(arg);
-	static_cast<v8::PersistentBase<v8::Value> &>(lastString).SetWeak();
+	if (newIndex == length)
+	{
+		byteIndex = size;
+		index = length;
+		return;
+	}
 
-	Nan::Persistent<v8::Value> dummy(arg);
-	dummy.SetWeak(registerCallback(), weakLastStringCallback, Nan::WeakCallbackType::kParameter);
+	byteIndex = index < newIndex ? getUtf16PositionByCounter(data, byteIndex, newIndex - index) : getUtf16PositionByCounter(data, 0, newIndex);
+	index = newIndex;
+}
 
-	lastStringValue = new StrValString(arg, startFrom);
-};
+void StrVal::reset(const v8::Local<v8::Value> &arg, size_t argSize, size_t argLength, size_t newIndex, bool buffer)
+{
+	clear();
+	isBuffer = buffer;
+	size = argSize;
+	length = argLength;
+	data = node::Buffer::Data(arg);
+	setIndex(newIndex);
+}

package/lib/exec.cc

@@ -1,5 +1,4 @@
 #include "./wrapped_re2.h"
-#include "./str-val.h"
 
 #include <vector>
 
@@ -15,13 +14,12 @@ NAN_METHOD(WrappedRE2::Exec)
 		return;
 	}
 
-	PrepareLastString prepare(re2, info[0]);
-	StrValBase &str = *re2->lastStringValue;
+	auto str = re2->prepareArgument(info[0]);
 	if (str.isBad) return; // throws an exception
 
 	if (re2->global || re2->sticky)
 	{
-		if (!str.isIndexValid)
+		if (!str.isValidIndex)
 		{
 			re2->lastIndex = 0;
 			info.GetReturnValue().SetNull();

package/lib/match.cc

@@ -1,5 +1,4 @@
 #include "./wrapped_re2.h"
-#include "./str-val.h"
 
 #include <vector>
 
@@ -15,11 +14,10 @@ NAN_METHOD(WrappedRE2::Match)
 		return;
 	}
 
-	PrepareLastString prepare(re2, info[0], re2->global);
-	StrValBase &str = *re2->lastStringValue;
+	auto str = re2->prepareArgument(info[0], re2->global);
 	if (str.isBad) return; // throws an exception
 
-	if (!str.isIndexValid)
+	if (!str.isValidIndex)
 	{
 		re2->lastIndex = 0;
 		info.GetReturnValue().SetNull();

package/lib/new.cc

@@ -233,7 +233,6 @@ NAN_METHOD(WrappedRE2::New)
 	bool unicode = false;
 	bool sticky = false;
 	bool hasIndices = false;
-	bool enabledCache = false;
 
 	auto context = Nan::GetCurrentContext();
 	bool needFlags = true;
@@ -257,9 +256,6 @@ NAN_METHOD(WrappedRE2::New)
 		{
 			switch (data[i])
 			{
-			case '\b':
-				enabledCache = true;
-				break;
 			case 'g':
 				global = true;
 				break;
@@ -343,7 +339,6 @@ NAN_METHOD(WrappedRE2::New)
 
 			if (needFlags)
 			{
-				enabledCache = re2->enabledCache;
 				global = re2->global;
 				ignoreCase = re2->ignoreCase;
 				multiline = re2->multiline;
@@ -406,7 +401,7 @@ NAN_METHOD(WrappedRE2::New)
 	options.set_dot_nl(dotAll);
 	options.set_log_errors(false); // inappropriate when embedding
 
-	std::unique_ptr<WrappedRE2> re2(new WrappedRE2(re2::StringPiece(data, size), options, source, enabledCache, global, ignoreCase, multiline, dotAll, sticky, hasIndices));
+	std::unique_ptr<WrappedRE2> re2(new WrappedRE2(re2::StringPiece(data, size), options, source, global, ignoreCase, multiline, dotAll, sticky, hasIndices));
 	if (!re2->regexp.ok())
 	{
 		return Nan::ThrowSyntaxError(re2->regexp.error().c_str());

package/lib/replace.cc

@@ -1,5 +1,4 @@
 #include "./wrapped_re2.h"
-#include "./str-val.h"
 
 #include <algorithm>
 #include <memory>
@@ -213,7 +212,7 @@ inline std::string replace(
 
 static Nan::Maybe<std::string> replace(
 	WrappedRE2 *re2,
-	const StrValBase &replacee,
+	const StrVal &replacee,
 	const char *replacer,
 	size_t replacer_size)
 {
@@ -370,13 +369,19 @@ inline Nan::Maybe<std::string> replace(
 		return Nan::Just(std::string(node::Buffer::Data(result), node::Buffer::Length(result)));
 	}
 
-	StrValString val(result);
-	return Nan::Just(std::string(val.data, val.size));
+	auto t = result->ToString(Nan::GetCurrentContext());
+	if (t.IsEmpty())
+	{
+		return Nan::Nothing<std::string>();
+	}
+
+	v8::String::Utf8Value s(v8::Isolate::GetCurrent(), t.ToLocalChecked());
+	return Nan::Just(std::string(*s));
 }
 
 static Nan::Maybe<std::string> replace(
 	WrappedRE2 *re2,
-	const StrValBase &replacee,
+	const StrVal &replacee,
 	const Nan::Callback *replacer,
 	const v8::Local<v8::Value> &input,
 	bool useBuffers)
@@ -492,11 +497,10 @@ NAN_METHOD(WrappedRE2::Replace)
 		return;
 	}
 
-	PrepareLastString prepare(re2, info[0]);
-	StrValBase &replacee = *re2->lastStringValue;
+	auto replacee = re2->prepareArgument(info[0]);
 	if (replacee.isBad) return; // throws an exception
 
-	if (!replacee.isIndexValid)
+	if (!replacee.isValidIndex)
 	{
 		info.GetReturnValue().Set(info[0]);
 		return;
@@ -518,15 +522,23 @@ NAN_METHOD(WrappedRE2::Replace)
 	}
 	else
 	{
-		StrValBase *replacer = StrValBase::New(info[1]);
-		if (replacer->isBad) return; // throws an exception
-
-		if (!replacer->data)
+		v8::Local<v8::Object> replacer;
+		if (node::Buffer::HasInstance(info[1]))
 		{
-			info.GetReturnValue().Set(info[0]);
-			return;
+			replacer = info[1].As<v8::Object>();
+		}
+		else
+		{
+			auto t = info[1]->ToString(Nan::GetCurrentContext());
+			if (t.IsEmpty())
+				return; // throws an exception
+			replacer = node::Buffer::New(v8::Isolate::GetCurrent(), t.ToLocalChecked()).ToLocalChecked();
 		}
-		const auto replaced = replace(re2, replacee, replacer->data, replacer->size);
+
+		auto data = node::Buffer::Data(replacer);
+		auto size = node::Buffer::Length(replacer);
+
+		const auto replaced = replace(re2, replacee, data, size);
 		if (replaced.IsNothing())
 		{
 			info.GetReturnValue().Set(info[0]);

package/lib/search.cc

@@ -1,5 +1,4 @@
 #include "./wrapped_re2.h"
-#include "./str-val.h"
 
 NAN_METHOD(WrappedRE2::Search)
 {
@@ -13,8 +12,7 @@ NAN_METHOD(WrappedRE2::Search)
 		return;
 	}
 
-	PrepareLastString prepare(re2, info[0], true);
-	StrValBase &str = *re2->lastStringValue;
+	auto str = re2->prepareArgument(info[0], true);
 	if (str.isBad) return; // throws an exception
 
 	if (!str.data)

package/lib/split.cc

@@ -1,5 +1,4 @@
 #include "./wrapped_re2.h"
-#include "./str-val.h"
 
 #include <algorithm>
 #include <limits>
@@ -20,8 +19,7 @@ NAN_METHOD(WrappedRE2::Split)
 		return;
 	}
 
-	PrepareLastString prepare(re2, info[0], true);
-	StrValBase &str = *re2->lastStringValue;
+	auto str = re2->prepareArgument(info[0], true);
 	if (str.isBad) return; // throws an exception
 
 	size_t limit = std::numeric_limits<size_t>::max();

package/lib/test.cc

@@ -1,5 +1,4 @@
 #include "./wrapped_re2.h"
-#include "./str-val.h"
 
 #include <vector>
 
@@ -15,8 +14,7 @@ NAN_METHOD(WrappedRE2::Test)
 		return;
 	}
 
-	PrepareLastString prepare(re2, info[0]);
-	StrValBase &str = *re2->lastStringValue;
+	auto str = re2->prepareArgument(info[0]);
 	if (str.isBad) return; // throws an exception
 
 	if (!re2->global && !re2->sticky)
@@ -25,7 +23,7 @@ NAN_METHOD(WrappedRE2::Test)
 		return;
 	}
 
-	if (!str.isIndexValid)
+	if (!str.isValidIndex)
 	{
 		re2->lastIndex = 0;
 		info.GetReturnValue().SetNull();

package/lib/to_string.cc

@@ -20,10 +20,6 @@ NAN_METHOD(WrappedRE2::ToString)
 	buffer += re2->source;
 	buffer += "/";
 
-	if (re2->enabledCache)
-	{
-		buffer += "\b";
-	}
 	if (re2->global)
 	{
 		buffer += "g";

package/lib/util.h

@@ -1,5 +1,4 @@
-#ifndef UTIL_H_
-#define UTIL_H_
+#pragma once
 
 #include "./wrapped_re2.h"
 
@@ -13,5 +12,3 @@ void consoleCall(const v8::Local<v8::String> &methodName, v8::Local<v8::Value> t
 void printDeprecationWarning(const char *warning);
 
 v8::Local<v8::String> callToString(const v8::Local<v8::Object> &object);
-
-#endif

package/lib/wrapped_re2.h

@@ -1,14 +1,30 @@
-#ifndef WRAPPED_RE2_H_
-#define WRAPPED_RE2_H_
+#pragma once
 
+#include <string>
 #include <nan.h>
-
 #include <re2/re2.h>
 
-#include <string>
-#include <unordered_set>
+struct StrVal
+{
+	char *data;
+	size_t size, length;
+	size_t index, byteIndex;
+	bool isBuffer, isValidIndex, isBad;
 
-struct StrValBase;
+	StrVal() : data(NULL), size(0), length(0), index(0), byteIndex(0), isBuffer(false), isValidIndex(false), isBad(false) {}
+
+	operator re2::StringPiece() const { return re2::StringPiece(data, size); }
+
+	void setIndex(size_t newIndex = 0);
+	void reset(const v8::Local<v8::Value> &arg, size_t size, size_t length, size_t newIndex = 0, bool buffer = false);
+
+	void clear()
+	{
+		isBad = isBuffer = isValidIndex = false;
+		size = length = index = byteIndex = 0;
+		data = nullptr;
+	}
+};
 
 class WrappedRE2 : public Nan::ObjectWrap
 {
@@ -17,7 +33,6 @@ private:
 		const re2::StringPiece &pattern,
 		const re2::RE2::Options &options,
 		const std::string &src,
-		const bool &c,
 		const bool &g,
 		const bool &i,
 		const bool &m,
@@ -25,15 +40,13 @@ private:
 		const bool &y,
 		const bool &d) : regexp(pattern, options),
 						 source(src),
-						 enabledCache(c),
 						 global(g),
 						 ignoreCase(i),
 						 multiline(m),
 						 dotAll(s),
 						 sticky(y),
 						 hasIndices(d),
-						 lastIndex(0),
-						 lastStringValue(nullptr) {}
+						 lastIndex(0) {}
 
 	static NAN_METHOD(New);
 	static NAN_METHOD(ToString);
@@ -50,8 +63,6 @@ private:
 	static NAN_GETTER(GetLastIndex);
 	static NAN_SETTER(SetLastIndex);
 	static NAN_GETTER(GetInternalSource);
-	static NAN_GETTER(GetEnabledCache);
-	static NAN_GETTER(GetIsCached);
 
 	// RegExp methods
 	static NAN_METHOD(Exec);
@@ -91,7 +102,6 @@ public:
 
 	re2::RE2 regexp;
 	std::string source;
-	bool enabledCache;
 	bool global;
 	bool ignoreCase;
 	bool multiline;
@@ -100,38 +110,15 @@ public:
 	bool hasIndices;
 	size_t lastIndex;
 
-	friend class PrepareLastString;
+	friend struct PrepareLastString;
 
 private:
 	Nan::Persistent<v8::Value> lastString; // weak pointer
-	StrValBase *lastStringValue;
-
-	typedef WrappedRE2 *PtrWrappedRE2;
-
-	std::unordered_set<PtrWrappedRE2 *> callbackRegistry;
-	PtrWrappedRE2 *registerCallback();
-	void unregisterCallback(PtrWrappedRE2 *re2);
-
-	static void weakLastStringCallback(const Nan::WeakCallbackInfo<PtrWrappedRE2> &data);
+	Nan::Persistent<v8::Object> lastCache; // weak pointer
+	StrVal lastStringValue;
 
-	void dropLastString();
-	void prepareLastString(const v8::Local<v8::Value> &arg, bool ignoreLastIndex = false);
-};
-
-struct PrepareLastString
-{
-	PrepareLastString(WrappedRE2 *re2, const v8::Local<v8::Value> &arg, bool ignoreLastIndex = false) : re2(re2)
-	{
-		re2->prepareLastString(arg, ignoreLastIndex);
-	}
-
-	~PrepareLastString()
-	{
-		if (!re2->enabledCache || !(re2->global || re2->sticky))
-			re2->dropLastString();
-	}
-
-	WrappedRE2 *re2;
+	void dropCache();
+	const StrVal &prepareArgument(const v8::Local<v8::Value> &arg, bool ignoreLastIndex = false);
 };
 
 // utilities
@@ -212,4 +199,15 @@ inline size_t getUtf8CharSize(char ch)
 	return ((0xE5000000 >> ((ch >> 3) & 0x1E)) & 3) + 1;
 }
 
-#endif
+inline size_t getUtf16PositionByCounter(const char *data, size_t from, size_t n)
+{
+	for (; n > 0; --n)
+	{
+		size_t s = getUtf8CharSize(data[from]);
+		from += s;
+		if (s == 4 && n >= 2)
+			--n; // this utf8 character will take two utf16 characters
+				 // the decrement above is protected to avoid an overflow of an unsigned integer
+	}
+	return from;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "re2",
-  "version": "1.21.1",
+  "version": "1.21.2",
   "description": "Bindings for RE2: fast, safe alternative to backtracking regular expression engines.",
   "homepage": "https://github.com/uhop/node-re2",
   "bugs": "https://github.com/uhop/node-re2/issues",
@@ -28,9 +28,14 @@
     "test": "node tests/tests.js",
     "ts-test": "tsc",
     "save-to-github": "save-to-github-cache --artifact build/Release/re2.node",
-    "install": "install-from-cache --artifact build/Release/re2.node --host-var RE2_DOWNLOAD_MIRROR --skip-path-var RE2_DOWNLOAD_SKIP_PATH --skip-ver-var RE2_DOWNLOAD_SKIP_VER || node-gyp rebuild",
+    "install": "install-from-cache --artifact build/Release/re2.node --host-var RE2_DOWNLOAD_MIRROR --skip-path-var RE2_DOWNLOAD_SKIP_PATH --skip-ver-var RE2_DOWNLOAD_SKIP_VER || node-gyp -j max rebuild",
     "verify-build": "node scripts/verify-build.js",
-    "rebuild": "node-gyp rebuild"
+    "build:dev": "node-gyp -j max build --debug",
+    "build": "node-gyp -j max build",
+    "rebuild:dev": "node-gyp -j max rebuild --debug",
+    "rebuild": "node-gyp -j max rebuild",
+    "clean": "node-gyp clean",
+    "reconfigure": "node-gyp configure"
   },
   "github": "https://github.com/uhop/node-re2",
   "repository": {

package/re2.js

@@ -1,38 +1,39 @@
 'use strict';
 
 const RE2 = require('./build/Release/re2.node');
+// const RE2 = require('./build/Debug/re2.node');
 
-if (typeof Symbol != 'undefined') {
-  Symbol.match &&
-    (RE2.prototype[Symbol.match] = function (str) {
-      return this.match(str);
-    });
-  Symbol.search &&
-    (RE2.prototype[Symbol.search] = function (str) {
-      return this.search(str);
-    });
-  Symbol.replace &&
-    (RE2.prototype[Symbol.replace] = function (str, repl) {
-      return this.replace(str, repl);
-    });
-  Symbol.split &&
-    (RE2.prototype[Symbol.split] = function (str, limit) {
-      return this.split(str, limit);
-    });
-  Symbol.matchAll &&
-    (RE2.prototype[Symbol.matchAll] = function* (str) {
-      if (!this.global) {
-        throw TypeError('String.prototype.matchAll called with a non-global RE2 argument');
-      }
-      const re = new RE2(this, this.flags + '\b');
-      re.lastIndex = this.lastIndex;
-      for (;;) {
-        const result = re.exec(str);
-        if (!result) break;
-        if (result[0] === '') ++re.lastIndex;
-        yield result;
-      }
-    });
-}
+const setAliases = (object, dict) => {
+  for (let [name, alias] of Object.entries(dict)) {
+    Object.defineProperty(
+      object,
+      alias,
+      Object.getOwnPropertyDescriptor(object, name)
+    );
+  }
+};
+
+setAliases(RE2.prototype, {
+  match: Symbol.match,
+  search: Symbol.search,
+  replace: Symbol.replace,
+  split: Symbol.split
+});
+
+RE2.prototype[Symbol.matchAll] = function* (str) {
+  if (!this.global)
+    throw TypeError(
+      'String.prototype.matchAll() is called with a non-global RE2 argument'
+    );
+
+  const re = new RE2(this);
+  re.lastIndex = this.lastIndex;
+  for (;;) {
+    const result = re.exec(str);
+    if (!result) break;
+    if (result[0] === '') ++re.lastIndex;
+    yield result;
+  }
+};
 
 module.exports = RE2;

package/lib/str-val.cc

@@ -1,112 +0,0 @@
-#include "./str-val.h"
-
-StrValBuffer::StrValBuffer(const v8::Local<v8::Value> &arg, size_t newIndex) : StrValBase()
-{
-	if (!node::Buffer::HasInstance(arg))
-		return;
-
-	isBuffer = true;
-	size = length = node::Buffer::Length(arg);
-	data = node::Buffer::Data(arg);
-
-	byteIndex = index = newIndex;
-	isIndexValid = byteIndex < size;
-}
-
-inline size_t getUtf8CharSize(char ch)
-{
-	return ((0xE5000000 >> ((ch >> 3) & 0x1E)) & 3) + 1;
-}
-
-inline size_t countBytes(const char *data, size_t from, size_t n)
-{
-	for (; n > 0; --n)
-	{
-		size_t s = getUtf8CharSize(data[from]);
-		from += s;
-		if (s == 4 && n >= 2)
-			--n; // this utf8 character will take two utf16 characters
-				 // the decrement above is protected to avoid an overflow of an unsigned integer
-	}
-	return from;
-}
-
-StrValString::StrValString(const v8::Local<v8::Value> &arg, size_t newIndex) : StrValBase()
-{
-	if (node::Buffer::HasInstance(arg))
-		return;
-
-	auto t = arg->ToString(Nan::GetCurrentContext());
-	if (t.IsEmpty())
-	{
-		isBad = true;
-		return;
-	}
-
-	auto s = t.ToLocalChecked();
-	length = Nan::DecodeBytes(s);
-	size = Nan::DecodeBytes(s, Nan::UTF8);
-	buffer.resize(size + 1);
-	data = &buffer[0];
-	Nan::DecodeWrite(data, size, s, Nan::UTF8);
-	buffer[size] = '\0';
-
-	index = newIndex;
-	isIndexValid = index <= length;
-
-	if (!isIndexValid || !index)
-		return;
-
-	if (index == length)
-	{
-		byteIndex = size;
-		return;
-	}
-
-	byteIndex = countBytes(data, 0, index);
-}
-
-void StrValBase::setIndex(size_t newIndex)
-{
-	isIndexValid = newIndex <= length;
-	if (!isIndexValid)
-	{
-		index = newIndex;
-		byteIndex = 0;
-		return;
-	}
-
-	if (newIndex == index)
-		return;
-
-	if (isBuffer)
-	{
-		byteIndex = index = newIndex;
-		return;
-	}
-
-	// String
-
-	if (!newIndex)
-	{
-		byteIndex = index = 0;
-		return;
-	}
-
-	if (newIndex == length)
-	{
-		byteIndex = size;
-		index = length;
-		return;
-	}
-
-	byteIndex = index < newIndex ? countBytes(data, byteIndex, newIndex - index) : countBytes(data, 0, newIndex);
-	index = newIndex;
-}
-
-StrValBase *StrValBase::New(const v8::Local<v8::Value> &arg, size_t newIndex)
-{
-	if (node::Buffer::HasInstance(arg))
-		return new StrValBuffer(arg, newIndex);
-	return new StrValString(arg, newIndex);
-}

package/lib/str-val.h

@@ -1,33 +0,0 @@
-#pragma once
-#include <vector>
-#include <nan.h>
-#include <re2/re2.h>
-
-struct StrValBase
-{
-	char *data;
-	size_t size, length;
-	size_t index, byteIndex;
-	bool isBuffer, isIndexValid, isBad;
-
-	StrValBase() : data(NULL), size(0), length(0), index(0), byteIndex(0), isBuffer(false), isIndexValid(false), isBad(false) {}
-	virtual ~StrValBase() {}
-
-	operator re2::StringPiece() const { return re2::StringPiece(data, size); }
-
-	void setIndex(size_t newIndex = 0);
-
-	static StrValBase *New(const v8::Local<v8::Value> &arg, size_t newIndex = 0);
-};
-
-struct StrValBuffer : public StrValBase
-{
-	StrValBuffer(const v8::Local<v8::Value> &arg, size_t newIndex = 0);
-};
-
-struct StrValString : public StrValBase
-{
-	StrValString(const v8::Local<v8::Value> &arg, size_t newIndex = 0);
-
-	std::vector<char> buffer;
-};