re2 1.18.2 → 1.18.3

package/.prettierrc

@@ -1,5 +1,5 @@
 {
-  "printWidth": 120,
+  "printWidth": 80,
   "singleQuote": true,
   "bracketSpacing": false,
   "arrowParens": "avoid",

package/README.md

@@ -352,6 +352,7 @@ console.log('re2_res : ' + re2_res); // prints: re2_res : abc,a,b,c
 
 ## Release history
 
+- 1.18.3 *Fixed bug with non-matched groups. Thx, [Dan Setterquist](https://github.com/dset).*
 - 1.18.2 *Reference to the binary module by its full name.*
 - 1.18.1 *Support for Node 16, 18, 20 + Darwin arm64 precompiled binaries.*
 - 1.18.0 *Modified TS bindings, added a type test (thx, [Kenichi Kamiya](https://github.com/kachick) and [Jamie Magee](https://github.com/JamieMagee)).*

package/lib/accessors.cc

@@ -39,9 +39,13 @@ NAN_GETTER(WrappedRE2::GetFlags)
 	auto re2 = Nan::ObjectWrap::Unwrap<WrappedRE2>(info.This());
 
 	std::string flags;
+	if (re2->hasIndices)
+	{
+		flags = "d";
+	}
 	if (re2->global)
 	{
-		flags = "g";
+		flags += "g";
 	}
 	if (re2->ignoreCase)
 	{
@@ -135,6 +139,18 @@ NAN_GETTER(WrappedRE2::GetSticky)
 	info.GetReturnValue().Set(re2->sticky);
 }
 
+NAN_GETTER(WrappedRE2::GetHasIndices)
+{
+	if (!WrappedRE2::HasInstance(info.This()))
+	{
+		info.GetReturnValue().SetUndefined();
+		return;
+	}
+
+	auto re2 = Nan::ObjectWrap::Unwrap<WrappedRE2>(info.This());
+	info.GetReturnValue().Set(re2->hasIndices);
+}
+
 NAN_GETTER(WrappedRE2::GetLastIndex)
 {
 	if (!WrappedRE2::HasInstance(info.This()))

package/lib/addon.cc

@@ -23,9 +23,9 @@ static NAN_METHOD(GetUtf16Length)
 	info.GetReturnValue().Set(-1);
 }
 
-static void cleanup(void* p)
+static void cleanup(void *p)
 {
-	v8::Isolate* isolate = static_cast<v8::Isolate*>(p);
+	v8::Isolate *isolate = static_cast<v8::Isolate *>(p);
 	auto p_tpl = Nan::GetIsolateData<Nan::Persistent<v8::FunctionTemplate>>(isolate);
 	delete p_tpl;
 }
@@ -71,6 +71,7 @@ v8::Local<v8::Function> WrappedRE2::Init()
 	Nan::SetAccessor(instanceTemplate, Nan::New("dotAll").ToLocalChecked(), GetDotAll);
 	Nan::SetAccessor(instanceTemplate, Nan::New("unicode").ToLocalChecked(), GetUnicode);
 	Nan::SetAccessor(instanceTemplate, Nan::New("sticky").ToLocalChecked(), GetSticky);
+	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);
 

package/lib/exec.cc

@@ -52,8 +52,9 @@ NAN_METHOD(WrappedRE2::Exec)
 			{
 				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
+				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
 			}
 		}
 	}
@@ -74,7 +75,7 @@ NAN_METHOD(WrappedRE2::Exec)
 
 	// form a result
 
-	auto result = Nan::New<v8::Array>();
+	auto result = Nan::New<v8::Array>(), indices = Nan::New<v8::Array>();
 	int indexOffset = re2->global || re2->sticky ? re2->lastIndex : 0;
 
 	if (str.isBuffer)
@@ -82,13 +83,24 @@ NAN_METHOD(WrappedRE2::Exec)
 		for (size_t i = 0, n = groups.size(); i < n; ++i)
 		{
 			const auto &item = groups[i];
-			if (item.data() != NULL)
+			const auto data = item.data();
+			if (data)
 			{
-				Nan::Set(result, i, Nan::CopyBuffer(item.data(), item.size()).ToLocalChecked());
+				Nan::Set(result, i, Nan::CopyBuffer(data, item.size()).ToLocalChecked());
+				if (re2->hasIndices) {
+					auto pair = Nan::New<v8::Array>();
+					auto offset = data - str.data;
+					Nan::Set(pair, 0, Nan::New<v8::Integer>(static_cast<int>(offset)));
+					Nan::Set(pair, 1, Nan::New<v8::Integer>(static_cast<int>(offset + item.size())));
+					Nan::Set(indices, i, pair);
+				}
 			}
 			else
 			{
 				Nan::Set(result, i, Nan::Undefined());
+				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)));
@@ -98,18 +110,35 @@ NAN_METHOD(WrappedRE2::Exec)
 		for (size_t i = 0, n = groups.size(); i < n; ++i)
 		{
 			const auto &item = groups[i];
-			if (item.data() != NULL)
+			const auto data = item.data();
+			if (data)
 			{
-				Nan::Set(result, i, Nan::New(item.data(), item.size()).ToLocalChecked());
+				Nan::Set(result, i, Nan::New(data, item.size()).ToLocalChecked());
+				if (re2->hasIndices) {
+					auto pair = Nan::New<v8::Array>();
+					auto offset = getUtf16Length(str.data + lastIndex, 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)));
+					Nan::Set(indices, i, pair);
+				}
 			}
 			else
 			{
 				Nan::Set(result, i, Nan::Undefined());
+				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()))));
 	}
 
+	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());
+	}
+
 	Nan::Set(result, Nan::New("input").ToLocalChecked(), info[0]);
 
 	const auto &groupNames = re2->regexp.CapturingGroupNames();
@@ -128,15 +157,21 @@ NAN_METHOD(WrappedRE2::Exec)
 		}
 
 		Nan::Set(result, Nan::New("groups").ToLocalChecked(), groups);
+
+		if (re2->hasIndices) {
+			Nan::Set(indices, Nan::New("groups").ToLocalChecked(), groups);
+		}
 	}
 	else
 	{
 		Nan::Set(result, Nan::New("groups").ToLocalChecked(), Nan::Undefined());
+		if (re2->hasIndices) {
+			Nan::Set(indices, Nan::New("groups").ToLocalChecked(), Nan::Undefined());
+		}
 	}
 
-	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());
+	if (re2->hasIndices) {
+		Nan::Set(result, Nan::New("indices").ToLocalChecked(), indices);
 	}
 
 	info.GetReturnValue().Set(result);

package/lib/match.cc

@@ -61,8 +61,9 @@ NAN_METHOD(WrappedRE2::Match)
 			{
 				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
+				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
 			}
 			anchor = RE2::ANCHOR_START;
 		}
@@ -88,9 +89,10 @@ NAN_METHOD(WrappedRE2::Match)
 		for (size_t i = 0, n = groups.size(); i < n; ++i)
 		{
 			const auto &item = groups[i];
-			if (item.data() != NULL)
+			const auto data = item.data();
+			if (data)
 			{
-				Nan::Set(result, i, Nan::CopyBuffer(item.data(), item.size()).ToLocalChecked());
+				Nan::Set(result, i, Nan::CopyBuffer(data, item.size()).ToLocalChecked());
 			}
 		}
 		if (!re2->global)
@@ -104,9 +106,10 @@ NAN_METHOD(WrappedRE2::Match)
 		for (size_t i = 0, n = groups.size(); i < n; ++i)
 		{
 			const auto &item = groups[i];
-			if (item.data() != NULL)
+			const auto data = item.data();
+			if (data)
 			{
-				Nan::Set(result, i, Nan::New(item.data(), item.size()).ToLocalChecked());
+				Nan::Set(result, i, Nan::New(data, item.size()).ToLocalChecked());
 			}
 		}
 		if (!re2->global)

package/lib/new.cc

@@ -232,6 +232,7 @@ NAN_METHOD(WrappedRE2::New)
 	bool dotAll = false;
 	bool unicode = false;
 	bool sticky = false;
+	bool hasIndices = false;
 
 	auto context = Nan::GetCurrentContext();
 
@@ -272,6 +273,9 @@ NAN_METHOD(WrappedRE2::New)
 			case 'y':
 				sticky = true;
 				break;
+			case 'd':
+				hasIndices = true;
+				break;
 			}
 		}
 		size = 0;
@@ -306,6 +310,7 @@ NAN_METHOD(WrappedRE2::New)
 		dotAll = bool(flags & v8::RegExp::kDotAll);
 		unicode = bool(flags & v8::RegExp::kUnicode);
 		sticky = bool(flags & v8::RegExp::kSticky);
+		hasIndices = bool(flags & v8::RegExp::kHasIndices);
 	}
 	else if (info[0]->IsObject() && !info[0]->IsString())
 	{
@@ -332,6 +337,7 @@ NAN_METHOD(WrappedRE2::New)
 			dotAll = re2->dotAll;
 			unicode = true;
 			sticky = re2->sticky;
+			hasIndices = re2->hasIndices;
 		}
 	}
 	else if (info[0]->IsString())
@@ -385,7 +391,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, global, ignoreCase, multiline, dotAll, sticky));
+	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

@@ -228,7 +228,8 @@ static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee,
 				{
 					size_t s = getUtf8CharSize(data[lastIndex]);
 					lastIndex += s;
-					if (s == 4 && n >= 2) {
+					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
@@ -299,7 +300,7 @@ static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee,
 
 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;
+	std::vector<v8::Local<v8::Value>> argv;
 
 	auto context = Nan::GetCurrentContext();
 
@@ -308,7 +309,15 @@ inline Nan::Maybe<std::string> replace(const Nan::Callback *replacer, const std:
 		for (size_t i = 0, n = groups.size(); i < n; ++i)
 		{
 			const auto &item = groups[i];
-			argv.push_back(Nan::CopyBuffer(item.data(), item.size()).ToLocalChecked());
+			const auto data = item.data();
+			if (data)
+			{
+				argv.push_back(Nan::CopyBuffer(data, item.size()).ToLocalChecked());
+			}
+			else
+			{
+				argv.push_back(Nan::Undefined());
+			}
 		}
 		argv.push_back(Nan::New(static_cast<int>(groups[0].data() - str.data())));
 	}
@@ -317,7 +326,15 @@ inline Nan::Maybe<std::string> replace(const Nan::Callback *replacer, const std:
 		for (size_t i = 0, n = groups.size(); i < n; ++i)
 		{
 			const auto &item = groups[i];
-			argv.push_back(Nan::New(item.data(), item.size()).ToLocalChecked());
+			const auto data = item.data();
+			if (data)
+			{
+				argv.push_back(Nan::New(data, item.size()).ToLocalChecked());
+			}
+			else
+			{
+				argv.push_back(Nan::Undefined());
+			}
 		}
 		argv.push_back(Nan::New(static_cast<int>(getUtf16Length(str.data(), groups[0].data()))));
 	}
@@ -381,7 +398,8 @@ static Nan::Maybe<std::string> replace(WrappedRE2 *re2, const StrVal &replacee,
 				{
 					size_t s = getUtf8CharSize(data[lastIndex]);
 					lastIndex += s;
-					if (s == 4 && n >= 2) {
+					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

package/lib/wrapped_re2.h

@@ -11,8 +11,8 @@ 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) : regexp(pattern, options),
-																							source(src), global(g), ignoreCase(i), multiline(m), dotAll(s), sticky(y), lastIndex(0) {}
+			   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) {}
 
 	static NAN_METHOD(New);
 	static NAN_METHOD(ToString);
@@ -25,6 +25,7 @@ private:
 	static NAN_GETTER(GetDotAll);
 	static NAN_GETTER(GetUnicode);
 	static NAN_GETTER(GetSticky);
+	static NAN_GETTER(GetHasIndices);
 	static NAN_GETTER(GetLastIndex);
 	static NAN_SETTER(SetLastIndex);
 	static NAN_GETTER(GetInternalSource);
@@ -70,6 +71,7 @@ public:
 	bool multiline;
 	bool dotAll;
 	bool sticky;
+	bool hasIndices;
 	size_t lastIndex;
 };
 

package/package.json

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

package/tests/test_replace.js

@@ -280,5 +280,43 @@ unit.add(module, [
 
     eval(t.TEST("re2.replace('ABCDEFABCDEF', '!') === '!!!!!FABCDEF'"));
     eval(t.TEST('re2.lastIndex === 0'));
+  },
+
+  // Non-matches
+
+  function test_ReplaceOneNonMatch(t) {
+    'use strict';
+
+    function replacer(match, capture, offset, string) {
+      t.test(typeof offset == 'number');
+      t.test(typeof match == 'string');
+      t.test(typeof string == 'string');
+      t.test(typeof capture == 'undefined');
+      t.test(offset === 0);
+      t.test(string === 'hello ');
+      return '';
+    }
+
+    var re = new RE2(/hello (world)?/);
+    re.replace('hello ', replacer);
+  },
+  function test_ReplaceTwoNonMatches(t) {
+    'use strict';
+
+    function replacer(match, capture1, capture2, offset, string) {
+      t.test(typeof offset == 'number');
+      t.test(typeof match == 'string');
+      t.test(typeof string == 'string');
+      t.test(typeof capture1 == 'undefined');
+      t.test(typeof capture2 == 'undefined');
+      t.test(offset === 1);
+      t.test(match === 'b & y');
+      t.test(string === 'ab & yz');
+      return '';
+    }
+
+    var re = new RE2(/b(1)? & (2)?y/);
+    var result = re.replace('ab & yz', replacer);
+    eval(t.TEST("result === 'az'"));
   }
 ]);