re2 1.20.12 → 1.21.0

package/README.md

@@ -353,6 +353,7 @@ console.log('re2_res : ' + re2_res); // prints: re2_res : abc,a,b,c
 
 ## Release history
 
+- 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.*
 - 1.20.11 *Updated deps. Added support for Node 22 (thx, [Elton Leong](https://github.com/eltonkl)).*
 - 1.20.10 *Updated deps. Removed files the pack used for development (thx, [Haruaki OTAKE](https://github.com/aaharu)). Added arm64 Linux prebilds (thx, [Christopher M](https://github.com/cmanou)). Fixed non-`npm` `corepack` problem (thx, [Steven](https://github.com/styfle)).*

package/binding.gyp

@@ -3,6 +3,7 @@
     {
       "target_name": "re2",
       "sources": [
+        "lib/str-val.cc",
         "lib/addon.cc",
         "lib/new.cc",
         "lib/exec.cc",
@@ -14,6 +15,7 @@
         "lib/to_string.cc",
         "lib/accessors.cc",
         "lib/util.cc",
+        "lib/str-val.cc",
         "vendor/re2/re2/bitmap256.cc",
         "vendor/re2/re2/bitstate.cc",
         "vendor/re2/re2/compile.cc",

package/lib/addon.cc

@@ -1,6 +1,6 @@
 #include "./wrapped_re2.h"
 
-#include <node_buffer.h>
+#include "./str-val.h"
 
 static NAN_METHOD(GetUtf8Length)
 {
@@ -91,3 +91,56 @@ NODE_MODULE_INIT()
 	Nan::HandleScope scope;
 	Nan::Set(module->ToObject(context).ToLocalChecked(), Nan::New("exports").ToLocalChecked(), WrappedRE2::Init());
 }
+
+// private methods
+
+void WrappedRE2::dropLastString()
+{
+	lastString.Reset();
+	if (lastStringValue)
+	{
+		delete lastStringValue;
+		lastStringValue = nullptr;
+	}
+}
+
+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;
+}
+
+void WrappedRE2::prepareLastString(const v8::Local<v8::Value> &arg, bool ignoreLastIndex)
+{
+	size_t startFrom = ignoreLastIndex ? 0 : lastIndex;
+
+	if (node::Buffer::HasInstance(arg))
+	{
+		dropLastString();
+		lastStringValue = new StrValBuffer(arg, startFrom);
+		return;
+	}
+
+	// String
+
+	// check if the same string is already in the cache
+	if (lastString == arg && lastStringValue)
+	{
+		if (!global && !sticky)
+			return; // we are good
+		lastStringValue->setIndex(startFrom);
+		return;
+	}
+
+	dropLastString();
+	lastString.Reset(arg);
+	static_cast<v8::PersistentBase<v8::Value>&>(lastString).SetWeak();
+	lastStringValue = new StrValString(arg, startFrom);
+};

package/lib/exec.cc

@@ -1,10 +1,8 @@
 #include "./wrapped_re2.h"
-#include "./util.h"
+#include "./str-val.h"
 
 #include <vector>
 
-#include <node_buffer.h>
-
 NAN_METHOD(WrappedRE2::Exec)
 {
 
@@ -17,45 +15,17 @@ NAN_METHOD(WrappedRE2::Exec)
 		return;
 	}
 
-	StrVal str(info[0]);
-	if (!str.data)
-	{
-		return;
-	}
+	re2->prepareLastString(info[0]);
+	StrValBase &str = *re2->lastStringValue;
+	if (str.isBad) return; // throws an exception
 
-	size_t lastIndex = 0;
-
-	if (str.isBuffer)
-	{
-		if ((re2->global || re2->sticky) && re2->lastIndex)
-		{
-			if (re2->lastIndex > str.size)
-			{
-				re2->lastIndex = 0;
-				info.GetReturnValue().SetNull();
-				return;
-			}
-			lastIndex = re2->lastIndex;
-		}
-	}
-	else
+	if (re2->global || re2->sticky)
 	{
-		if ((re2->global || re2->sticky) && re2->lastIndex)
+		if (!str.isIndexValid)
 		{
-			if (re2->lastIndex > str.length)
-			{
-				re2->lastIndex = 0;
-				info.GetReturnValue().SetNull();
-				return;
-			}
-			for (size_t n = re2->lastIndex; n; --n)
-			{
-				size_t s = getUtf8CharSize(str.data[lastIndex]);
-				lastIndex += 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
-			}
+			re2->lastIndex = 0;
+			info.GetReturnValue().SetNull();
+			return;
 		}
 	}
 
@@ -63,7 +33,7 @@ NAN_METHOD(WrappedRE2::Exec)
 
 	std::vector<re2::StringPiece> groups(re2->regexp.NumberOfCapturingGroups() + 1);
 
-	if (!re2->regexp.Match(str, lastIndex, str.size, re2->sticky ? re2::RE2::ANCHOR_START : re2::RE2::UNANCHORED, &groups[0], groups.size()))
+	if (!re2->regexp.Match(str, str.byteIndex, str.size, re2->sticky ? re2::RE2::ANCHOR_START : re2::RE2::UNANCHORED, &groups[0], groups.size()))
 	{
 		if (re2->global || re2->sticky)
 		{
@@ -87,9 +57,10 @@ NAN_METHOD(WrappedRE2::Exec)
 			if (data)
 			{
 				Nan::Set(result, i, Nan::CopyBuffer(data, item.size()).ToLocalChecked());
-				if (re2->hasIndices) {
+				if (re2->hasIndices)
+				{
 					auto pair = Nan::New<v8::Array>();
-					auto offset = data - str.data - lastIndex;
+					auto offset = data - str.data - str.byteIndex;
 					auto length = item.size();
 					Nan::Set(pair, 0, Nan::New<v8::Integer>(indexOffset + static_cast<int>(offset)));
 					Nan::Set(pair, 1, Nan::New<v8::Integer>(indexOffset + static_cast<int>(offset + length)));
@@ -99,12 +70,13 @@ NAN_METHOD(WrappedRE2::Exec)
 			else
 			{
 				Nan::Set(result, i, Nan::Undefined());
-				if (re2->hasIndices) {
+				if (re2->hasIndices)
+				{
 					Nan::Set(indices, i, Nan::Undefined());
 				}
 			}
 		}
-		Nan::Set(result, Nan::New("index").ToLocalChecked(), Nan::New<v8::Integer>(indexOffset + static_cast<int>(groups[0].data() - str.data - lastIndex)));
+		Nan::Set(result, Nan::New("index").ToLocalChecked(), Nan::New<v8::Integer>(indexOffset + static_cast<int>(groups[0].data() - str.data - str.byteIndex)));
 	}
 	else
 	{
@@ -115,9 +87,10 @@ NAN_METHOD(WrappedRE2::Exec)
 			if (data)
 			{
 				Nan::Set(result, i, Nan::New(data, item.size()).ToLocalChecked());
-				if (re2->hasIndices) {
+				if (re2->hasIndices)
+				{
 					auto pair = Nan::New<v8::Array>();
-					auto offset = getUtf16Length(str.data + lastIndex, data);
+					auto offset = getUtf16Length(str.data + str.byteIndex, data);
 					auto length = getUtf16Length(data, data + item.size());
 					Nan::Set(pair, 0, Nan::New<v8::Integer>(indexOffset + static_cast<int>(offset)));
 					Nan::Set(pair, 1, Nan::New<v8::Integer>(indexOffset + static_cast<int>(offset + length)));
@@ -127,17 +100,23 @@ NAN_METHOD(WrappedRE2::Exec)
 			else
 			{
 				Nan::Set(result, i, Nan::Undefined());
-				if (re2->hasIndices) {
+				if (re2->hasIndices)
+				{
 					Nan::Set(indices, i, Nan::Undefined());
 				}
 			}
 		}
-		Nan::Set(result, Nan::New("index").ToLocalChecked(), Nan::New<v8::Integer>(indexOffset + static_cast<int>(getUtf16Length(str.data + lastIndex, groups[0].data()))));
+		Nan::Set(
+			result,
+			Nan::New("index").ToLocalChecked(),
+			Nan::New<v8::Integer>(indexOffset +
+								  static_cast<int>(getUtf16Length(str.data + str.byteIndex, groups[0].data()))));
 	}
 
 	if (re2->global || re2->sticky)
 	{
-		re2->lastIndex += str.isBuffer ? groups[0].data() - str.data + groups[0].size() - lastIndex : getUtf16Length(str.data + lastIndex, groups[0].data() + groups[0].size());
+		re2->lastIndex +=
+			str.isBuffer ? groups[0].data() - str.data + groups[0].size() - str.byteIndex : getUtf16Length(str.data + str.byteIndex, groups[0].data() + groups[0].size());
 	}
 
 	Nan::Set(result, Nan::New("input").ToLocalChecked(), info[0]);
@@ -159,7 +138,8 @@ NAN_METHOD(WrappedRE2::Exec)
 
 		Nan::Set(result, Nan::New("groups").ToLocalChecked(), groups);
 
-		if (re2->hasIndices) {
+		if (re2->hasIndices)
+		{
 			auto indexGroups = Nan::New<v8::Object>();
 			Nan::SetPrototype(indexGroups, Nan::Null());
 
@@ -178,12 +158,14 @@ NAN_METHOD(WrappedRE2::Exec)
 	else
 	{
 		Nan::Set(result, Nan::New("groups").ToLocalChecked(), Nan::Undefined());
-		if (re2->hasIndices) {
+		if (re2->hasIndices)
+		{
 			Nan::Set(indices, Nan::New("groups").ToLocalChecked(), Nan::Undefined());
 		}
 	}
 
-	if (re2->hasIndices) {
+	if (re2->hasIndices)
+	{
 		Nan::Set(result, Nan::New("indices").ToLocalChecked(), indices);
 	}
 

package/lib/match.cc

@@ -1,5 +1,5 @@
 #include "./wrapped_re2.h"
-#include "./util.h"
+#include "./str-val.h"
 
 #include <vector>
 
@@ -15,15 +15,19 @@ NAN_METHOD(WrappedRE2::Match)
 		return;
 	}
 
-	StrVal a(info[0]);
-	if (!a.data)
+	re2->prepareLastString(info[0], re2->global);
+	StrValBase &str = *re2->lastStringValue;
+	if (str.isBad) return; // throws an exception
+
+	if (!str.isIndexValid)
 	{
+		re2->lastIndex = 0;
+		info.GetReturnValue().SetNull();
 		return;
 	}
 
 	std::vector<re2::StringPiece> groups;
-	re2::StringPiece str(a);
-	size_t lastIndex = 0;
+	size_t byteIndex = 0;
 	auto anchor = re2::RE2::UNANCHORED;
 
 	// actual work
@@ -39,10 +43,10 @@ NAN_METHOD(WrappedRE2::Match)
 			anchor = re2::RE2::ANCHOR_START;
 		}
 
-		while (re2->regexp.Match(str, lastIndex, a.size, anchor, &match, 1))
+		while (re2->regexp.Match(str, byteIndex, str.size, anchor, &match, 1))
 		{
 			groups.push_back(match);
-			lastIndex = match.data() - a.data + match.size();
+			byteIndex = match.data() - str.data + match.size();
 		}
 
 		if (groups.empty())
@@ -57,24 +61,15 @@ NAN_METHOD(WrappedRE2::Match)
 
 		if (re2->sticky)
 		{
-			for (size_t n = re2->lastIndex; n; --n)
-			{
-				size_t s = getUtf8CharSize(a.data[lastIndex]);
-				lastIndex += 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
-			}
+			byteIndex = str.byteIndex;
 			anchor = RE2::ANCHOR_START;
 		}
 
 		groups.resize(re2->regexp.NumberOfCapturingGroups() + 1);
-		if (!re2->regexp.Match(str, lastIndex, a.size, anchor, &groups[0], groups.size()))
+		if (!re2->regexp.Match(str, byteIndex, str.size, anchor, &groups[0], groups.size()))
 		{
 			if (re2->sticky)
-			{
 				re2->lastIndex = 0;
-			}
 			info.GetReturnValue().SetNull();
 			return;
 		}
@@ -84,7 +79,7 @@ NAN_METHOD(WrappedRE2::Match)
 
 	auto result = Nan::New<v8::Array>(), indices = Nan::New<v8::Array>();
 
-	if (a.isBuffer)
+	if (str.isBuffer)
 	{
 		for (size_t i = 0, n = groups.size(); i < n; ++i)
 		{
@@ -96,7 +91,7 @@ NAN_METHOD(WrappedRE2::Match)
 				if (!re2->global && re2->hasIndices)
 				{
 					auto pair = Nan::New<v8::Array>();
-					auto offset = data - a.data - lastIndex;
+					auto offset = data - str.data - byteIndex;
 					auto length = item.size();
 					Nan::Set(pair, 0, Nan::New<v8::Integer>(static_cast<int>(offset)));
 					Nan::Set(pair, 1, Nan::New<v8::Integer>(static_cast<int>(offset + length)));
@@ -107,14 +102,12 @@ NAN_METHOD(WrappedRE2::Match)
 			{
 				Nan::Set(result, i, Nan::Undefined());
 				if (!re2->global && re2->hasIndices)
-				{
 					Nan::Set(indices, i, Nan::Undefined());
-				}
 			}
 		}
 		if (!re2->global)
 		{
-			Nan::Set(result, Nan::New("index").ToLocalChecked(), Nan::New<v8::Integer>(static_cast<int>(groups[0].data() - a.data)));
+			Nan::Set(result, Nan::New("index").ToLocalChecked(), Nan::New<v8::Integer>(static_cast<int>(groups[0].data() - str.data)));
 			Nan::Set(result, Nan::New("input").ToLocalChecked(), info[0]);
 		}
 	}
@@ -130,7 +123,7 @@ NAN_METHOD(WrappedRE2::Match)
 				if (!re2->global && re2->hasIndices)
 				{
 					auto pair = Nan::New<v8::Array>();
-					auto offset = getUtf16Length(a.data + lastIndex, data);
+					auto offset = getUtf16Length(str.data + byteIndex, data);
 					auto length = getUtf16Length(data, data + item.size());
 					Nan::Set(pair, 0, Nan::New<v8::Integer>(static_cast<int>(offset)));
 					Nan::Set(pair, 1, Nan::New<v8::Integer>(static_cast<int>(offset + length)));
@@ -148,7 +141,7 @@ NAN_METHOD(WrappedRE2::Match)
 		}
 		if (!re2->global)
 		{
-			Nan::Set(result, Nan::New("index").ToLocalChecked(), Nan::New<v8::Integer>(static_cast<int>(getUtf16Length(a.data, groups[0].data()))));
+			Nan::Set(result, Nan::New("index").ToLocalChecked(), Nan::New<v8::Integer>(static_cast<int>(getUtf16Length(str.data, groups[0].data()))));
 			Nan::Set(result, Nan::New("input").ToLocalChecked(), info[0]);
 		}
 	}
@@ -159,7 +152,8 @@ NAN_METHOD(WrappedRE2::Match)
 	}
 	else if (re2->sticky)
 	{
-		re2->lastIndex += a.isBuffer ? groups[0].data() - a.data + groups[0].size() - lastIndex : getUtf16Length(a.data + lastIndex, groups[0].data() + groups[0].size());
+		re2->lastIndex +=
+			str.isBuffer ? groups[0].data() - str.data + groups[0].size() - byteIndex : getUtf16Length(str.data + byteIndex, groups[0].data() + groups[0].size());
 	}
 
 	if (!re2->global)

package/lib/replace.cc

@@ -1,14 +1,15 @@
 #include "./wrapped_re2.h"
-#include "./util.h"
+#include "./str-val.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
 
-#include <node_buffer.h>
-
-inline int getMaxSubmatch(const char *data, size_t size, const std::map<std::string, int> &namedGroups)
+inline int getMaxSubmatch(
+	const char *data,
+	size_t size,
+	const std::map<std::string, int> &namedGroups)
 {
 	int maxSubmatch = 0, index, index2;
 	const char *nameBegin;
@@ -86,7 +87,12 @@ inline int getMaxSubmatch(const char *data, size_t size, const std::map<std::str
 	return maxSubmatch;
 }
 
-inline std::string replace(const char *data, size_t size, const std::vector<re2::StringPiece> &groups, const re2::StringPiece &str, const std::map<std::string, int> &namedGroups)
+inline std::string replace(
+	const char *data,
+	size_t size,
+	const std::vector<re2::StringPiece> &groups,
+	const re2::StringPiece &str,
+	const std::map<std::string, int> &namedGroups)
 {
 	std::string result;
 	size_t index, index2;
@@ -205,7 +211,11 @@ inline std::string replace(const char *data, size_t size, const std::vector<re2:
 	return result;
 }
 
-static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee, const char *replacer, size_t replacer_size)
+static Nan::Maybe<std::string> replace(
+	WrappedRE2 *re2,
+	const StrValBase &replacee,
+	const char *replacer,
+	size_t replacer_size)
 {
 	const re2::StringPiece str = replacee;
 	const char *data = str.data();
@@ -216,67 +226,50 @@ static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee,
 	std::vector<re2::StringPiece> groups(std::min(re2->regexp.NumberOfCapturingGroups(), getMaxSubmatch(replacer, replacer_size, namedGroups)) + 1);
 	const auto &match = groups[0];
 
-	size_t lastIndex = 0;
+	size_t byteIndex = 0;
 	std::string result;
 	auto anchor = re2::RE2::UNANCHORED;
 
 	if (re2->sticky)
 	{
 		if (!re2->global)
-		{
-			if (replacee.isBuffer)
-			{
-				lastIndex = re2->lastIndex;
-			}
-			else
-			{
-				for (size_t n = re2->lastIndex; n; --n)
-				{
-					size_t s = getUtf8CharSize(data[lastIndex]);
-					lastIndex += 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
-				}
-			}
-		}
+			byteIndex = replacee.byteIndex;
 		anchor = re2::RE2::ANCHOR_START;
 	}
 
-	if (lastIndex)
+	if (byteIndex)
 	{
-		result = std::string(data, lastIndex);
+		result = std::string(data, byteIndex);
 	}
 
 	bool noMatch = true;
-	while (lastIndex <= size && re2->regexp.Match(str, lastIndex, size, anchor, &groups[0], groups.size()))
+	while (byteIndex <= size && re2->regexp.Match(str, byteIndex, size, anchor, &groups[0], groups.size()))
 	{
 		noMatch = false;
 		auto offset = match.data() - data;
 		if (!re2->global && re2->sticky)
 		{
-			re2->lastIndex += replacee.isBuffer ? offset + match.size() - lastIndex : getUtf16Length(data + lastIndex, match.data() + match.size());
+			re2->lastIndex +=
+				replacee.isBuffer ? offset + match.size() - byteIndex : getUtf16Length(data + byteIndex, match.data() + match.size());
 		}
-		if (match.data() == data || offset > static_cast<long>(lastIndex))
+		if (match.data() == data || offset > static_cast<long>(byteIndex))
 		{
-			result += std::string(data + lastIndex, offset - lastIndex);
+			result += std::string(data + byteIndex, offset - byteIndex);
 		}
 		result += replace(replacer, replacer_size, groups, str, namedGroups);
 		if (match.size())
 		{
-			lastIndex = offset + match.size();
+			byteIndex = offset + match.size();
 		}
 		else if ((size_t)offset < size)
 		{
 			auto sym_size = getUtf8CharSize(data[offset]);
 			result.append(data + offset, sym_size);
-			lastIndex = offset + sym_size;
+			byteIndex = offset + sym_size;
 		}
 		else
 		{
-			lastIndex = size;
+			byteIndex = size;
 			break;
 		}
 		if (!re2->global)
@@ -284,9 +277,9 @@ static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee,
 			break;
 		}
 	}
-	if (lastIndex < size)
+	if (byteIndex < size)
 	{
-		result += std::string(data + lastIndex, size - lastIndex);
+		result += std::string(data + byteIndex, size - byteIndex);
 	}
 
 	if (re2->global)
@@ -296,15 +289,19 @@ static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee,
 	else if (re2->sticky)
 	{
 		if (noMatch)
-		{
 			re2->lastIndex = 0;
-		}
 	}
 
 	return Nan::Just(result);
 }
 
-inline Nan::Maybe<std::string> replace(const Nan::Callback *replacer, const std::vector<re2::StringPiece> &groups, const re2::StringPiece &str, const v8::Local<v8::Value> &input, bool useBuffers, const std::map<std::string, int> &namedGroups)
+inline Nan::Maybe<std::string> replace(
+	const Nan::Callback *replacer,
+	const std::vector<re2::StringPiece> &groups,
+	const re2::StringPiece &str,
+	const v8::Local<v8::Value> &input,
+	bool useBuffers,
+	const std::map<std::string, int> &namedGroups)
 {
 	std::vector<v8::Local<v8::Value>> argv;
 
@@ -373,11 +370,16 @@ inline Nan::Maybe<std::string> replace(const Nan::Callback *replacer, const std:
 		return Nan::Just(std::string(node::Buffer::Data(result), node::Buffer::Length(result)));
 	}
 
-	StrVal val = result;
+	StrValString val(result);
 	return Nan::Just(std::string(val.data, val.size));
 }
 
-static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee, const Nan::Callback *replacer, const v8::Local<v8::Value> &input, bool useBuffers)
+static Nan::Maybe<std::string> replace(
+	WrappedRE2 *re2,
+	const StrValBase &replacee,
+	const Nan::Callback *replacer,
+	const v8::Local<v8::Value> &input,
+	bool useBuffers)
 {
 	const re2::StringPiece str = replacee;
 	const char *data = str.data();
@@ -386,54 +388,36 @@ static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee,
 	std::vector<re2::StringPiece> groups(re2->regexp.NumberOfCapturingGroups() + 1);
 	const auto &match = groups[0];
 
-	size_t lastIndex = 0;
+	size_t byteIndex = 0;
 	std::string result;
 	auto anchor = re2::RE2::UNANCHORED;
 
 	if (re2->sticky)
 	{
 		if (!re2->global)
-		{
-			if (replacee.isBuffer)
-			{
-				lastIndex = re2->lastIndex;
-			}
-			else
-			{
-				for (size_t n = re2->lastIndex; n; --n)
-				{
-					size_t s = getUtf8CharSize(data[lastIndex]);
-					lastIndex += 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
-				}
-			}
-		}
+			byteIndex = replacee.byteIndex;
 		anchor = RE2::ANCHOR_START;
 	}
 
-	if (lastIndex)
+	if (byteIndex)
 	{
-		result = std::string(data, lastIndex);
+		result = std::string(data, byteIndex);
 	}
 
 	const auto &namedGroups = re2->regexp.NamedCapturingGroups();
 
 	bool noMatch = true;
-	while (lastIndex <= size && re2->regexp.Match(str, lastIndex, size, anchor, &groups[0], groups.size()))
+	while (byteIndex <= size && re2->regexp.Match(str, byteIndex, size, anchor, &groups[0], groups.size()))
 	{
 		noMatch = false;
 		auto offset = match.data() - data;
 		if (!re2->global && re2->sticky)
 		{
-			re2->lastIndex += replacee.isBuffer ? offset + match.size() - lastIndex : getUtf16Length(data + lastIndex, match.data() + match.size());
+			re2->lastIndex += replacee.isBuffer ? offset + match.size() - byteIndex : getUtf16Length(data + byteIndex, match.data() + match.size());
 		}
-		if (match.data() == data || offset > static_cast<long>(lastIndex))
+		if (match.data() == data || offset > static_cast<long>(byteIndex))
 		{
-			result += std::string(data + lastIndex, offset - lastIndex);
+			result += std::string(data + byteIndex, offset - byteIndex);
 		}
 		const auto part = replace(replacer, groups, str, input, useBuffers, namedGroups);
 		if (part.IsNothing())
@@ -443,17 +427,17 @@ static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee,
 		result += part.FromJust();
 		if (match.size())
 		{
-			lastIndex = offset + match.size();
+			byteIndex = offset + match.size();
 		}
 		else if ((size_t)offset < size)
 		{
 			auto sym_size = getUtf8CharSize(data[offset]);
 			result.append(data + offset, sym_size);
-			lastIndex = offset + sym_size;
+			byteIndex = offset + sym_size;
 		}
 		else
 		{
-			lastIndex = size;
+			byteIndex = size;
 			break;
 		}
 		if (!re2->global)
@@ -461,9 +445,9 @@ static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee,
 			break;
 		}
 	}
-	if (lastIndex < size)
+	if (byteIndex < size)
 	{
-		result += std::string(data + lastIndex, size - lastIndex);
+		result += std::string(data + byteIndex, size - byteIndex);
 	}
 
 	if (re2->global)
@@ -508,8 +492,11 @@ NAN_METHOD(WrappedRE2::Replace)
 		return;
 	}
 
-	StrVal replacee = info[0];
-	if (!replacee.data)
+	re2->prepareLastString(info[0]);
+	StrValBase &replacee = *re2->lastStringValue;
+	if (replacee.isBad) return; // throws an exception
+
+	if (!replacee.isIndexValid)
 	{
 		info.GetReturnValue().Set(info[0]);
 		return;
@@ -531,13 +518,15 @@ NAN_METHOD(WrappedRE2::Replace)
 	}
 	else
 	{
-		StrVal replacer = info[1];
-		if (!replacer.data)
+		StrValBase *replacer = StrValBase::New(info[1]);
+		if (replacer->isBad) return; // throws an exception
+
+		if (!replacer->data)
 		{
 			info.GetReturnValue().Set(info[0]);
 			return;
 		}
-		const auto replaced = replace(re2, replacee, replacer.data, replacer.size);
+		const auto replaced = replace(re2, replacee, replacer->data, replacer->size);
 		if (replaced.IsNothing())
 		{
 			info.GetReturnValue().Set(info[0]);

package/lib/search.cc

@@ -1,5 +1,5 @@
 #include "./wrapped_re2.h"
-#include "./util.h"
+#include "./str-val.h"
 
 NAN_METHOD(WrappedRE2::Search)
 {
@@ -13,19 +13,20 @@ NAN_METHOD(WrappedRE2::Search)
 		return;
 	}
 
-	StrVal a = info[0];
-	if (!a.data)
-	{
+	re2->prepareLastString(info[0], true);
+	StrValBase &str = *re2->lastStringValue;
+	if (str.isBad) return; // throws an exception
+
+	if (!str.data)
 		return;
-	}
 
 	// actual work
 
 	re2::StringPiece match;
 
-	if (re2->regexp.Match(a, 0, a.size, re2->sticky ? re2::RE2::ANCHOR_START : re2::RE2::UNANCHORED, &match, 1))
+	if (re2->regexp.Match(str, 0, str.size, re2->sticky ? re2::RE2::ANCHOR_START : re2::RE2::UNANCHORED, &match, 1))
 	{
-		info.GetReturnValue().Set(static_cast<int>(a.isBuffer ? match.data() - a.data : getUtf16Length(a.data, match.data())));
+		info.GetReturnValue().Set(static_cast<int>(str.isBuffer ? match.data() - str.data : getUtf16Length(str.data, match.data())));
 		return;
 	}
 

package/lib/split.cc

@@ -1,5 +1,5 @@
 #include "./wrapped_re2.h"
-#include "./util.h"
+#include "./str-val.h"
 
 #include <algorithm>
 #include <limits>
@@ -20,13 +20,9 @@ NAN_METHOD(WrappedRE2::Split)
 		return;
 	}
 
-	StrVal a = info[0];
-	if (!a.data)
-	{
-		return;
-	}
-
-	re2::StringPiece str = a;
+	re2->prepareLastString(info[0], true);
+	StrValBase &str = *re2->lastStringValue;
+	if (str.isBad) return; // throws an exception
 
 	size_t limit = std::numeric_limits<size_t>::max();
 	if (info.Length() > 1 && info[1]->IsNumber())
@@ -42,30 +38,30 @@ NAN_METHOD(WrappedRE2::Split)
 
 	std::vector<re2::StringPiece> groups(re2->regexp.NumberOfCapturingGroups() + 1), pieces;
 	const auto &match = groups[0];
-	size_t lastIndex = 0;
+	size_t byteIndex = 0;
 
-	while (lastIndex < a.size && re2->regexp.Match(str, lastIndex, a.size, RE2::UNANCHORED, &groups[0], groups.size()))
+	while (byteIndex < str.size && re2->regexp.Match(str, byteIndex, str.size, RE2::UNANCHORED, &groups[0], groups.size()))
 	{
 		if (match.size())
 		{
-			pieces.push_back(re2::StringPiece(a.data + lastIndex, match.data() - a.data - lastIndex));
-			lastIndex = match.data() - a.data + match.size();
+			pieces.push_back(re2::StringPiece(str.data + byteIndex, match.data() - str.data - byteIndex));
+			byteIndex = match.data() - str.data + match.size();
 			pieces.insert(pieces.end(), groups.begin() + 1, groups.end());
 		}
 		else
 		{
-			size_t sym_size = getUtf8CharSize(a.data[lastIndex]);
-			pieces.push_back(re2::StringPiece(a.data + lastIndex, sym_size));
-			lastIndex += sym_size;
+			size_t sym_size = getUtf8CharSize(str.data[byteIndex]);
+			pieces.push_back(re2::StringPiece(str.data + byteIndex, sym_size));
+			byteIndex += sym_size;
 		}
 		if (pieces.size() >= limit)
 		{
 			break;
 		}
 	}
-	if (pieces.size() < limit && (lastIndex < a.size || (lastIndex == a.size && match.size())))
+	if (pieces.size() < limit && (byteIndex < str.size || (byteIndex == str.size && match.size())))
 	{
-		pieces.push_back(re2::StringPiece(a.data + lastIndex, a.size - lastIndex));
+		pieces.push_back(re2::StringPiece(str.data + byteIndex, str.size - byteIndex));
 	}
 
 	if (pieces.empty())
@@ -77,7 +73,7 @@ NAN_METHOD(WrappedRE2::Split)
 
 	// form a result
 
-	if (a.isBuffer)
+	if (str.isBuffer)
 	{
 		for (size_t i = 0, n = std::min(pieces.size(), limit); i < n; ++i)
 		{

package/lib/str-val.cc

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

@@ -0,0 +1,32 @@
+#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) {}
+
+	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;
+};

package/lib/test.cc

@@ -1,10 +1,8 @@
 #include "./wrapped_re2.h"
-#include "./util.h"
+#include "./str-val.h"
 
 #include <vector>
 
-#include <node_buffer.h>
-
 NAN_METHOD(WrappedRE2::Test)
 {
 
@@ -17,62 +15,33 @@ NAN_METHOD(WrappedRE2::Test)
 		return;
 	}
 
-	StrVal str = info[0];
-	if (!str.data)
+	re2->prepareLastString(info[0]);
+	StrValBase &str = *re2->lastStringValue;
+	if (str.isBad) return; // throws an exception
+
+	if (!re2->global && !re2->sticky)
 	{
+		info.GetReturnValue().Set(re2->regexp.Match(str, 0, str.size, re2::RE2::UNANCHORED, NULL, 0));
 		return;
 	}
 
-	size_t lastIndex = 0;
-
-	if (str.isBuffer)
-	{
-		if ((re2->global || re2->sticky) && re2->lastIndex)
-		{
-			if (re2->lastIndex > str.size)
-			{
-				re2->lastIndex = 0;
-				info.GetReturnValue().Set(false);
-				return;
-			}
-			lastIndex = re2->lastIndex;
-		}
-	}
-	else
+	if (!str.isIndexValid)
 	{
-		if ((re2->global || re2->sticky) && re2->lastIndex)
-		{
-			if (re2->lastIndex > str.length)
-			{
-				re2->lastIndex = 0;
-				info.GetReturnValue().Set(false);
-				return;
-			}
-			for (size_t n = re2->lastIndex; n; --n)
-			{
-				size_t s = getUtf8CharSize(str.data[lastIndex]);
-				lastIndex += 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
-			}
-		}
+		re2->lastIndex = 0;
+		info.GetReturnValue().SetNull();
+		return;
 	}
 
 	// actual work
 
-	if (re2->global || re2->sticky)
+	re2::StringPiece match;
+	if (re2->regexp.Match(str, str.byteIndex, str.size, re2->sticky ? re2::RE2::ANCHOR_START : re2::RE2::UNANCHORED, &match, 1))
 	{
-		re2::StringPiece match;
-		if (re2->regexp.Match(str, lastIndex, str.size, re2->sticky ? re2::RE2::ANCHOR_START : re2::RE2::UNANCHORED, &match, 1))
-		{
-			re2->lastIndex += str.isBuffer ? match.data() - str.data + match.size() - lastIndex : getUtf16Length(str.data + lastIndex, match.data() + match.size());
-			info.GetReturnValue().Set(true);
-			return;
-		}
-		re2->lastIndex = 0;
-		info.GetReturnValue().Set(false);
+		re2->lastIndex +=
+			str.isBuffer ? match.data() - str.data + match.size() - str.byteIndex : getUtf16Length(str.data + str.byteIndex, match.data() + match.size());
+		info.GetReturnValue().Set(true);
 		return;
 	}
-
-	info.GetReturnValue().Set(re2->regexp.Match(str, lastIndex, str.size, re2::RE2::UNANCHORED, NULL, 0));
+	re2->lastIndex = 0;
+	info.GetReturnValue().Set(false);
 }

package/lib/util.cc

@@ -1,34 +1,5 @@
 #include "./util.h"
 
-#include <sys/types.h>
-#include <string>
-
-#include <node_buffer.h>
-
-StrVal::StrVal(const v8::Local<v8::Value> &arg) : data(NULL), size(0), isBuffer(false)
-{
-	if (node::Buffer::HasInstance(arg))
-	{
-		isBuffer = true;
-		size = length = node::Buffer::Length(arg);
-		data = node::Buffer::Data(arg);
-	}
-	else
-	{
-		auto t = arg->ToString(Nan::GetCurrentContext());
-		if (!t.IsEmpty())
-		{
-			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';
-		}
-	}
-}
-
 void consoleCall(const v8::Local<v8::String> &methodName, v8::Local<v8::Value> text)
 {
 	auto context = Nan::GetCurrentContext();

package/lib/util.h

@@ -3,21 +3,6 @@
 
 #include "./wrapped_re2.h"
 
-#include <vector>
-
-struct StrVal
-{
-	std::vector<char> buffer;
-	char *data;
-	size_t size, length;
-	bool isBuffer;
-
-	StrVal() : data(NULL), size(0), length(0), isBuffer(false) {}
-	StrVal(const v8::Local<v8::Value> &arg);
-
-	operator re2::StringPiece() const { return re2::StringPiece(data, size); }
-};
-
 template <typename R, typename P, typename L>
 inline v8::MaybeLocal<R> bind(v8::MaybeLocal<P> param, L lambda)
 {

package/lib/wrapped_re2.h

@@ -7,12 +7,30 @@
 
 #include <string>
 
+struct StrValBase;
+
 class WrappedRE2 : public Nan::ObjectWrap
 {
 private:
-	WrappedRE2(const re2::StringPiece &pattern, const re2::RE2::Options &options, const std::string &src,
-			   const bool &g, const bool &i, const bool &m, const bool &s, const bool &y, const bool &d) : regexp(pattern, options),
-																										   source(src), global(g), ignoreCase(i), multiline(m), dotAll(s), sticky(y), hasIndices(d), lastIndex(0) {}
+	WrappedRE2(
+		const re2::StringPiece &pattern,
+		const re2::RE2::Options &options,
+		const std::string &src,
+		const bool &g,
+		const bool &i,
+		const bool &m,
+		const bool &s,
+		const bool &y,
+		const bool &d) : regexp(pattern, options),
+						 source(src),
+						 global(g),
+						 ignoreCase(i),
+						 multiline(m),
+						 dotAll(s),
+						 sticky(y),
+						 hasIndices(d),
+						 lastIndex(0),
+						 lastStringValue(nullptr) {}
 
 	static NAN_METHOD(New);
 	static NAN_METHOD(ToString);
@@ -45,6 +63,11 @@ private:
 	static NAN_SETTER(SetUnicodeWarningLevel);
 
 public:
+	~WrappedRE2()
+	{
+		dropLastString();
+	}
+
 	static v8::Local<v8::Function> Init();
 
 	static inline bool HasInstance(v8::Local<v8::Object> object)
@@ -73,6 +96,13 @@ public:
 	bool sticky;
 	bool hasIndices;
 	size_t lastIndex;
+
+private:
+	Nan::Persistent<v8::Value> lastString; // weak pointer
+	StrValBase *lastStringValue;
+
+	void dropLastString();
+	void prepareLastString(const v8::Local<v8::Value> &arg, bool ignoreLastIndex = false);
 };
 
 // utilities

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "re2",
-  "version": "1.20.12",
+  "version": "1.21.0",
   "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",