re2 1.24.1 → 1.25.0

package/LICENSE

@@ -1,11 +1,4 @@
-This library is available under the terms of the modified BSD license. No external contributions
-are allowed under licenses which are fundamentally incompatible with the BSD license that this library is distributed under.
-
-The text of the BSD license is reproduced below.
-
--------------------------------------------------------------------------------
-The "New" BSD License:
-**********************
+BSD 3-Clause License
 
 Copyright (c) 2005-2026, Eugene Lazutkin
 All rights reserved.
@@ -13,19 +6,21 @@ All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
-  * Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
-  * Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-  * Neither the name of Eugene Lazutkin nor the names of other contributors
-    may be used to endorse or promote products derived from this software
-    without specific prior written permission.
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

package/README.md

@@ -172,6 +172,7 @@ While `test()` can be simulated by combining patterns with `|`, `match()` return
   * `patterns` is any iterable of strings, `Buffer`s, `RegExp`, or `RE2` instances; flags (if provided) apply to the whole set.
   * `flagsOrOptions` can be a string/`Buffer` with standard flags (`i`, `m`, `s`, `u`, `g`, `y`, `d`).
   * `options.anchor` can be `'unanchored'` (default), `'start'`, or `'both'`.
+  * `options.maxMem` is the DFA memory budget in bytes (positive integer). Default is 8 MiB — raise it to compile sets that would otherwise fail with `"RE2.Set could not be compiled."`.
 * `set.test(str)` returns `true` if any pattern matches and `false` otherwise.
 * `set.match(str)` returns an array of indexes of matching patterns.
   * This is an array of integer indices of patterns that matched sorted in ascending order.
@@ -179,6 +180,7 @@ While `test()` can be simulated by combining patterns with `|`, `match()` return
 * Read-only properties:
   * `set.size` (number of patterns), `set.flags` (`RegExp` flags as a string), `set.anchor` (anchor mode as a string)
   * `set.source` (all patterns joined with `|` as a string), `set.sources` (individual pattern sources as an array of strings)
+  * `set.maxMem` (number) — effective DFA memory budget in bytes
 
 It is based on [RE2::Set](https://github.com/google/re2/blob/main/re2/set.h).
 
@@ -247,6 +249,45 @@ npm install re2
 The project works with other package managers but is not tested with them.
 See the wiki for notes on [yarn](https://github.com/uhop/node-re2/wiki/Using-with-yarn) and [pnpm](https://github.com/uhop/node-re2/wiki/Using-with-pnpm).
 
+### Supported Node.js versions
+
+`re2` supports the Node.js versions declared in its `engines` field:
+
+```
+^22.22.2 || ^24.15.0 || >=26.0.0
+```
+
+As of 1.25.0 this range was narrowed to mirror [`node-gyp`](https://github.com/nodejs/node-gyp) 13, which `re2` builds with (and which fixes a Node 26 build on Windows): **Node 25.x and the older 22.0–22.22.1 / 24.0–24.14 patch ranges are no longer supported.** Use a current release of an active line — Node 22 (≥ 22.22.2), 24 (≥ 24.15.0), or 26 and later.
+
+### Install scripts (npm 12+)
+
+`re2` downloads or builds its native binary in an `install` script. Starting with npm 12
+(July 2026), npm does not run dependency install scripts unless the package is listed in the
+`allowScripts` field of your project's `package.json` — without it, `npm install re2`
+fails with `ESTRICTALLOWSCRIPTS`. npm 11.16+ still runs the scripts but prints a warning.
+
+Allow `re2` before installing:
+
+```bash
+npm pkg set allowScripts.re2=true --json
+npm install re2
+```
+
+Or use npm's approval tooling — note that `npm approve-scripts` only matches installed
+packages, so under npm 12 the package has to be installed with scripts skipped first:
+
+```bash
+npm install re2 --ignore-scripts
+npm approve-scripts re2
+npm rebuild re2
+```
+
+`npm approve-scripts` pins the approval to the installed version, so version updates ask again;
+pass `--no-allow-scripts-pin` (or use the `allowScripts.re2=true` form above) to allow all
+versions. No other package in `re2`'s dependency tree runs install scripts. For the full story see
+[NPM 12 and install scripts](https://github.com/uhop/install-artifact-from-github/wiki/NPM-12-and-install-scripts)
+and GitHub's official [announcement of the npm v12 breaking changes](https://github.blog/changelog/2026-06-09-upcoming-breaking-changes-for-npm-v12/).
+
 ### Precompiled artifacts
 
 The [install script](https://github.com/uhop/install-artifact-from-github/blob/master/bin/install-from-cache.js) attempts to download a prebuilt artifact from GitHub Releases. Override the download location with the `RE2_DOWNLOAD_MIRROR` environment variable.
@@ -377,14 +418,31 @@ console.log('re2_res : ' + re2_res); // prints: re2_res : abc,a,b,c
 
 #### Unicode classes `\p{...}` and `\P{...}`
 
-`RE2` supports a subset of Unicode classes as defined in [RE2 Syntax](https://github.com/google/re2/wiki/Syntax). Google RE2 natively supports only short names (e.g., `L` for `Letter`). Like `RegExp`, node-re2 also accepts long names by translating them to short names.
+node-re2 follows [MDN's Unicode character class escape reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Unicode_character_class_escape) — the same set of property escapes that JavaScript's native `RegExp` accepts with the `u` flag.
+
+Supported categories:
+
+- **General_Category** — both short names (e.g., `\p{L}`, `\p{Lu}`) and long names (e.g., `\p{Letter}`, `\p{Uppercase_Letter}`). The `gc=` and `General_Category=` prefixes also work: `\p{gc=Letter}`, `\p{General_Category=Letter}`.
+- **Script** — e.g., `\p{Script=Latin}`, `\p{sc=Cyrillic}`. ISO 15924 four-letter codes are accepted as well: `\p{sc=Latn}`.
+- **Script_Extensions** — e.g., `\p{Script_Extensions=Hani}`, `\p{scx=Latn}`. Matches characters whose Script_Extensions list includes the named script (a superset of `Script=`).
+- **Binary properties** — the full ECMAScript set of binary properties, including:
+  - `Alphabetic`, `ASCII`, `ASCII_Hex_Digit`, `Hex_Digit`, `White_Space`, `Math`, `Dash`, `Diacritic`, `Quotation_Mark`, `Bidi_Mirrored`, `Bidi_Control`, `Default_Ignorable_Code_Point`
+  - `Lowercase`, `Uppercase`, `Cased`, `Case_Ignorable`, `Changes_When_Lowercased`, `Changes_When_Uppercased`, `Changes_When_Casefolded`, `Changes_When_Casemapped`, `Changes_When_Titlecased`, `Changes_When_NFKC_Casefolded`
+  - `ID_Start`, `ID_Continue`, `XID_Start`, `XID_Continue`, `Pattern_Syntax`, `Pattern_White_Space`
+  - `Emoji`, `Emoji_Presentation`, `Emoji_Modifier`, `Emoji_Modifier_Base`, `Emoji_Component`, `Extended_Pictographic`, `Regional_Indicator`
+  - `Grapheme_Base`, `Grapheme_Extend`, `Extender`, `Variation_Selector`, `Join_Control`, `Logical_Order_Exception`, `Sentence_Terminal`, `Terminal_Punctuation`, `Soft_Dotted`, `Radical`, `Unified_Ideograph`, `Ideographic`, `IDS_Binary_Operator`, `IDS_Trinary_Operator`, `Noncharacter_Code_Point`, `Deprecated`, `Any`, `Assigned`
+
+  Short aliases listed in [PropertyAliases.txt](https://www.unicode.org/Public/UCD/latest/ucd/PropertyAliases.txt) are accepted alongside the canonical names: `\p{Alpha}` ≡ `\p{Alphabetic}`, `\p{Hex}` ≡ `\p{Hex_Digit}`, `\p{Lower}` ≡ `\p{Lowercase}`, etc.
+
+The negated form `\P{...}` and use inside character classes (`[\p{L}\p{Emoji}]`, `[^\p{ASCII}]`) work for every category.
+
+**Not supported:** *Properties of Strings* (`\p{Basic_Emoji}`, `\p{RGI_Emoji}`, etc.). These match multi-codepoint sequences and require the `v` flag, which RE2 does not model.
 
-Only the `\p{name}` form is supported, not `\p{name=value}` in general.
-The exception is `Script` and `sc`, e.g., `\p{Script=Latin}` and `\p{sc=Cyrillic}`.
-The same applies to `\P{...}`.
+Tables are baked in at build time from Unicode 17.0. To target a newer Unicode version, bump `@unicode/unicode-XX.X.X` in `devDependencies` and run `node scripts/gen-unicode-properties.mjs`.
 
 ## Release history
 
+- 1.25.0 *Full Unicode 17.0.0 property classes (Fixes #226). New `maxMem` option for `RE2.Set`. Faster matching on pure-ASCII inputs. Narrowed Node support — drops Node 25.x and older patch releases.*
 - 1.24.1 *Support for Node 22, 24, 26 + precompiled binaries.*
 - 1.24.0 *Fixed multi-threaded crash in worker threads (#235). Added named import: `import {RE2} from 're2'`. Added CJS test. Updated docs and dependencies.*
 - 1.23.3 *Updated Abseil and dev dependencies.*

package/binding.gyp

@@ -47,12 +47,11 @@
         "vendor/abseil-cpp/absl/base/internal/strerror.cc",
         "vendor/abseil-cpp/absl/base/internal/sysinfo.cc",
         "vendor/abseil-cpp/absl/base/internal/thread_identity.cc",
-        "vendor/abseil-cpp/absl/base/internal/throw_delegate.cc",
+        "vendor/abseil-cpp/absl/base/throw_delegate.cc",
         "vendor/abseil-cpp/absl/base/internal/unscaledcycleclock.cc",
         "vendor/abseil-cpp/absl/container/internal/hashtablez_sampler.cc",
         "vendor/abseil-cpp/absl/container/internal/hashtablez_sampler_force_weak_definition.cc",
         "vendor/abseil-cpp/absl/container/internal/raw_hash_set.cc",
-        "vendor/abseil-cpp/absl/debugging/internal/borrowed_fixup_buffer.cc",
         "vendor/abseil-cpp/absl/debugging/internal/decode_rust_punycode.cc",
         "vendor/abseil-cpp/absl/debugging/internal/demangle.cc",
         "vendor/abseil-cpp/absl/debugging/internal/demangle_rust.cc",

package/lib/addon.cc

@@ -198,12 +198,15 @@ const StrVal &WrappedRE2::prepareArgument(const v8::Local<v8::Value> &arg, bool
 
 	auto s = t.ToLocalChecked();
 	auto argLength = utf8Length(s, isolate);
+	// Pure ASCII iff the UTF-16 length (s->Length(), O(1)) equals the UTF-8
+	// byte length: any non-ASCII char makes the byte count strictly larger.
+	bool isAscii = static_cast<size_t>(s->Length()) == argLength;
 
 	auto buffer = node::Buffer::New(isolate, s).ToLocalChecked();
 	lastCache.Reset(buffer);
 
 	auto argSize = node::Buffer::Length(buffer);
-	lastStringValue.reset(buffer, argSize, argLength, startFrom);
+	lastStringValue.reset(buffer, argSize, argLength, startFrom, false, isAscii);
 
 	return lastStringValue;
 };
@@ -236,7 +239,7 @@ void StrVal::setIndex(size_t newIndex)
 	if (newIndex == index)
 		return;
 
-	if (isBuffer)
+	if (isBuffer || isAscii)
 	{
 		byteIndex = index = newIndex;
 		return;
@@ -263,10 +266,11 @@ void StrVal::setIndex(size_t newIndex)
 
 static char null_buffer[] = {'\0'};
 
-void StrVal::reset(const v8::Local<v8::Value> &arg, size_t argSize, size_t argLength, size_t newIndex, bool buffer)
+void StrVal::reset(const v8::Local<v8::Value> &arg, size_t argSize, size_t argLength, size_t newIndex, bool buffer, bool ascii)
 {
 	clear();
 	isBuffer = buffer;
+	isAscii = ascii;
 	size = argSize;
 	length = argLength;
 	data = size ? node::Buffer::Data(arg) : null_buffer;

package/lib/exec.cc

@@ -89,8 +89,8 @@ NAN_METHOD(WrappedRE2::Exec)
 				if (re2->hasIndices)
 				{
 					auto pair = Nan::New<v8::Array>();
-					auto offset = getUtf16Length(str.data + str.byteIndex, data);
-					auto length = getUtf16Length(data, data + item.size());
+					auto offset = toUtf16Index(str.isAscii, str.data + str.byteIndex, data);
+					auto length = toUtf16Index(str.isAscii, 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)));
 					Nan::Set(indices, i, pair);
@@ -109,13 +109,13 @@ NAN_METHOD(WrappedRE2::Exec)
 			result,
 			Nan::New("index").ToLocalChecked(),
 			Nan::New<v8::Integer>(indexOffset +
-								  static_cast<int>(getUtf16Length(str.data + str.byteIndex, groups[0].data()))));
+								  static_cast<int>(toUtf16Index(str.isAscii, str.data + str.byteIndex, groups[0].data()))));
 	}
 
 	if (re2->global || re2->sticky)
 	{
 		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());
+			str.isBuffer ? groups[0].data() - str.data + groups[0].size() - str.byteIndex : toUtf16Index(str.isAscii, str.data + str.byteIndex, groups[0].data() + groups[0].size());
 	}
 
 	Nan::Set(result, Nan::New("input").ToLocalChecked(), info[0]);

package/lib/match.cc

@@ -122,8 +122,8 @@ NAN_METHOD(WrappedRE2::Match)
 				if (!re2->global && re2->hasIndices)
 				{
 					auto pair = Nan::New<v8::Array>();
-					auto offset = getUtf16Length(str.data + byteIndex, data);
-					auto length = getUtf16Length(data, data + item.size());
+					auto offset = toUtf16Index(str.isAscii, str.data + byteIndex, data);
+					auto length = toUtf16Index(str.isAscii, 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);
@@ -140,7 +140,7 @@ NAN_METHOD(WrappedRE2::Match)
 		}
 		if (!re2->global)
 		{
-			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("index").ToLocalChecked(), Nan::New<v8::Integer>(static_cast<int>(toUtf16Index(str.isAscii, str.data, groups[0].data()))));
 			Nan::Set(result, Nan::New("input").ToLocalChecked(), info[0]);
 		}
 	}
@@ -152,7 +152,7 @@ NAN_METHOD(WrappedRE2::Match)
 	else if (re2->sticky)
 	{
 		re2->lastIndex +=
-			str.isBuffer ? groups[0].data() - str.data + groups[0].size() - byteIndex : getUtf16Length(str.data + byteIndex, groups[0].data() + groups[0].size());
+			str.isBuffer ? groups[0].data() - str.data + groups[0].size() - byteIndex : toUtf16Index(str.isAscii, str.data + byteIndex, groups[0].data() + groups[0].size());
 	}
 
 	if (!re2->global)

package/lib/pattern.cc

@@ -1,6 +1,9 @@
 #include "./pattern.h"
+#include "./unicode_properties.h"
 #include "./wrapped_re2.h"
 
+#include <cstdint>
+#include <cstdio>
 #include <cstring>
 #include <map>
 #include <string>
@@ -58,10 +61,107 @@ static std::map<std::string, std::string> unicodeClasses = {
 	{"Other", "C"},
 };
 
+static const UnicodePropertyTable *lookupTable(const UnicodePropertyTable *table, size_t count, const std::string &name)
+{
+	for (size_t i = 0; i < count; ++i)
+	{
+		if (name == table[i].name)
+		{
+			return &table[i];
+		}
+	}
+	return nullptr;
+}
+
+static const UnicodePropertyTable *findBinaryProperty(const std::string &name)
+{
+	return lookupTable(kBinaryProperties, kBinaryPropertiesCount, name);
+}
+
+static const UnicodePropertyTable *findScriptExtension(const std::string &name)
+{
+	return lookupTable(kScriptExtensions, kScriptExtensionsCount, name);
+}
+
+static void appendHexRange(std::string &out, uint32_t lo, uint32_t hi)
+{
+	char buf[32];
+	if (lo == hi)
+	{
+		std::snprintf(buf, sizeof(buf), "\\x{%X}", lo);
+	}
+	else
+	{
+		std::snprintf(buf, sizeof(buf), "\\x{%X}-\\x{%X}", lo, hi);
+	}
+	out += buf;
+}
+
+static void appendPropertyRanges(std::string &out, const UnicodePropertyTable *table)
+{
+	for (size_t i = 0; i < table->count; ++i)
+	{
+		appendHexRange(out, table->ranges[i].lo, table->ranges[i].hi);
+	}
+}
+
+static void appendPropertyComplementRanges(std::string &out, const UnicodePropertyTable *table)
+{
+	const uint32_t kMaxCp = 0x10FFFFu;
+	uint32_t cursor = 0;
+	for (size_t i = 0; i < table->count; ++i)
+	{
+		uint32_t lo = table->ranges[i].lo;
+		uint32_t hi = table->ranges[i].hi;
+		if (cursor < lo)
+		{
+			appendHexRange(out, cursor, lo - 1);
+		}
+		cursor = hi + 1;
+	}
+	if (cursor <= kMaxCp)
+	{
+		appendHexRange(out, cursor, kMaxCp);
+	}
+}
+
+static void emitProperty(std::string &out, const UnicodePropertyTable *table, bool negate, bool inCharClass)
+{
+	if (inCharClass)
+	{
+		if (negate)
+		{
+			appendPropertyComplementRanges(out, table);
+		}
+		else
+		{
+			appendPropertyRanges(out, table);
+		}
+	}
+	else
+	{
+		out += negate ? "[^" : "[";
+		appendPropertyRanges(out, table);
+		out += "]";
+	}
+}
+
+static bool stripPrefix(const std::string &name, const char *prefix, std::string &out)
+{
+	size_t n = std::strlen(prefix);
+	if (name.size() > n && !std::strncmp(name.c_str(), prefix, n))
+	{
+		out = name.substr(n);
+		return true;
+	}
+	return false;
+}
+
 bool translateRegExp(const char *data, size_t size, bool multiline, std::vector<char> &buffer)
 {
 	std::string result;
 	bool changed = false;
+	bool inCharClass = false;
 
 	if (!size)
 	{
@@ -145,9 +245,48 @@ bool translateRegExp(const char *data, size_t size, bool multiline, std::vector<
 							size_t j = i + 3;
 							while (j < size && data[j] != '}') ++j;
 							if (j < size) {
+								std::string name(data + i + 3, j - i - 3);
+								bool negate = data[i + 1] == 'P';
+								std::string stripped;
+
+								// Script_Extensions=Hani / scx=Hani — RE2 has no native scx;
+								// expand to a codepoint-range character class.
+								const UnicodePropertyTable *scx = nullptr;
+								if (stripPrefix(name, "Script_Extensions=", stripped) || stripPrefix(name, "scx=", stripped))
+								{
+									scx = findScriptExtension(stripped);
+								}
+								if (scx)
+								{
+									emitProperty(result, scx, negate, inCharClass);
+									i = j + 1;
+									changed = true;
+									continue;
+								}
+
+								// General_Category=Letter / gc=Letter — strip prefix so the
+								// existing long-name → short-name map can resolve it.
+								if (stripPrefix(name, "General_Category=", stripped) || stripPrefix(name, "gc=", stripped))
+								{
+									name = stripped;
+								}
+
+								// Binary property — expand into a codepoint-range character
+								// class. Covers Emoji, Alphabetic, ASCII, ID_Start, etc.
+								const UnicodePropertyTable *binary = findBinaryProperty(name);
+								if (binary)
+								{
+									emitProperty(result, binary, negate, inCharClass);
+									i = j + 1;
+									changed = true;
+									continue;
+								}
+
+								// Otherwise, fall through to RE2 (handles General_Category
+								// short names and Script names natively). Long GC names get
+								// translated to the short form via the existing map.
 								result += "\\";
 								result += data[i + 1];
-								std::string name(data + i + 3, j - i - 3);
 								if (unicodeClasses.find(name) != unicodeClasses.end()) {
 									name = unicodeClasses[name];
 								} else if (name.size() > 7 && !strncmp(name.c_str(), "Script=", 7)) {
@@ -198,6 +337,14 @@ bool translateRegExp(const char *data, size_t size, bool multiline, std::vector<
 				continue;
 			}
 		}
+		else if (ch == '[' && !inCharClass)
+		{
+			inCharClass = true;
+		}
+		else if (ch == ']' && inCharClass)
+		{
+			inCharClass = false;
+		}
 		size_t sym_size = getUtf8CharSize(ch);
 		result.append(data + i, sym_size);
 		i += sym_size;

package/lib/replace.cc

@@ -249,7 +249,7 @@ static Nan::Maybe<std::string> replace(
 		if (!re2->global && re2->sticky)
 		{
 			re2->lastIndex +=
-				replacee.isBuffer ? offset + match.size() - byteIndex : getUtf16Length(data + byteIndex, match.data() + match.size());
+				replacee.isBuffer ? offset + match.size() - byteIndex : toUtf16Index(replacee.isAscii, data + byteIndex, match.data() + match.size());
 		}
 		if (match.data() == data || offset > static_cast<long>(byteIndex))
 		{
@@ -300,6 +300,7 @@ inline Nan::Maybe<std::string> replace(
 	const re2::StringPiece &str,
 	const v8::Local<v8::Value> &input,
 	bool useBuffers,
+	bool isAscii,
 	const std::map<std::string, int> &namedGroups)
 {
 	std::vector<v8::Local<v8::Value>> argv;
@@ -338,7 +339,7 @@ inline Nan::Maybe<std::string> replace(
 				argv.push_back(Nan::Undefined());
 			}
 		}
-		argv.push_back(Nan::New(static_cast<int>(getUtf16Length(str.data(), groups[0].data()))));
+		argv.push_back(Nan::New(static_cast<int>(toUtf16Index(isAscii, str.data(), groups[0].data()))));
 	}
 	argv.push_back(input);
 
@@ -418,13 +419,13 @@ static Nan::Maybe<std::string> replace(
 		auto offset = match.data() - data;
 		if (!re2->global && re2->sticky)
 		{
-			re2->lastIndex += replacee.isBuffer ? offset + match.size() - byteIndex : getUtf16Length(data + byteIndex, match.data() + match.size());
+			re2->lastIndex += replacee.isBuffer ? offset + match.size() - byteIndex : toUtf16Index(replacee.isAscii, data + byteIndex, match.data() + match.size());
 		}
 		if (match.data() == data || offset > static_cast<long>(byteIndex))
 		{
 			result += std::string(data + byteIndex, offset - byteIndex);
 		}
-		const auto part = replace(replacer, groups, str, input, useBuffers, namedGroups);
+		const auto part = replace(replacer, groups, str, input, useBuffers, replacee.isAscii, namedGroups);
 		if (part.IsNothing())
 		{
 			return part;

package/lib/search.cc

@@ -25,7 +25,7 @@ NAN_METHOD(WrappedRE2::Search)
 
 	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>(str.isBuffer ? match.data() - str.data : getUtf16Length(str.data, match.data())));
+		info.GetReturnValue().Set(static_cast<int>(str.isBuffer ? match.data() - str.data : toUtf16Index(str.isAscii, str.data, match.data())));
 		return;
 	}
 

package/lib/set.cc

@@ -4,6 +4,7 @@
 #include "./wrapped_re2.h"
 
 #include <algorithm>
+#include <cmath>
 #include <memory>
 #include <string>
 #include <vector>
@@ -270,6 +271,58 @@ static bool parseAnchor(const v8::Local<v8::Value> &arg, re2::RE2::Anchor &ancho
 	return false;
 }
 
+static bool parseMaxMem(const v8::Local<v8::Value> &arg, int64_t &maxMem, bool &assigned)
+{
+	assigned = false;
+
+	if (arg.IsEmpty() || arg->IsUndefined() || arg->IsNull())
+	{
+		return true;
+	}
+	if (!arg->IsObject() || arg->IsString())
+	{
+		return true; // string-only form: anchor; no maxMem possible
+	}
+
+	auto context = Nan::GetCurrentContext();
+	auto object = arg->ToObject(context).ToLocalChecked();
+	auto maybe = Nan::Get(object, Nan::New("maxMem").ToLocalChecked());
+	if (maybe.IsEmpty())
+	{
+		return false;
+	}
+	auto value = maybe.ToLocalChecked();
+	if (value->IsUndefined() || value->IsNull())
+	{
+		return true;
+	}
+	if (!value->IsNumber())
+	{
+		return false;
+	}
+
+	auto maybeNum = value->NumberValue(context);
+	if (maybeNum.IsNothing())
+	{
+		return false;
+	}
+	double num = maybeNum.FromJust();
+	if (!std::isfinite(num) || num < 1.0 || std::floor(num) != num)
+	{
+		return false;
+	}
+	// Keep within safe integer range; RE2's max_mem is int64_t but JS Number
+	// can only represent integers exactly up to 2^53 - 1.
+	if (num > 9007199254740991.0)
+	{
+		return false;
+	}
+
+	maxMem = static_cast<int64_t>(num);
+	assigned = true;
+	return true;
+}
+
 static bool fillInput(const v8::Local<v8::Value> &arg, StrVal &str, v8::Local<v8::Object> &keepAlive)
 {
 	if (node::Buffer::HasInstance(arg))
@@ -389,12 +442,18 @@ NAN_METHOD(WrappedRE2Set::New)
 	}
 
 	re2::RE2::Anchor anchor = re2::RE2::UNANCHORED;
+	int64_t maxMem = 0;
+	bool maxMemAssigned = false;
 	if (!optionsArg.IsEmpty())
 	{
 		if (!parseAnchor(optionsArg, anchor))
 		{
 			return Nan::ThrowTypeError("Invalid anchor option for RE2.Set.");
 		}
+		if (!parseMaxMem(optionsArg, maxMem, maxMemAssigned))
+		{
+			return Nan::ThrowTypeError("Invalid maxMem option for RE2.Set: must be a positive integer.");
+		}
 	}
 
 	std::vector<v8::Local<v8::Value>> patterns;
@@ -488,6 +547,10 @@ NAN_METHOD(WrappedRE2Set::New)
 	options.set_one_line(!flags.multiline);
 	options.set_dot_nl(flags.dotAll);
 	options.set_log_errors(false);
+	if (maxMemAssigned)
+	{
+		options.set_max_mem(maxMem);
+	}
 
 	std::unique_ptr<WrappedRE2Set> set(new WrappedRE2Set(options, anchor, flagsToString(flags)));
 	std::vector<char> buffer;
@@ -754,6 +817,17 @@ NAN_GETTER(WrappedRE2Set::GetAnchor)
 	info.GetReturnValue().Set(Nan::New(anchorToString(re2set->anchor)).ToLocalChecked());
 }
 
+NAN_GETTER(WrappedRE2Set::GetMaxMem)
+{
+	auto re2set = Nan::ObjectWrap::Unwrap<WrappedRE2Set>(info.This());
+	if (!re2set)
+	{
+		info.GetReturnValue().Set(0);
+		return;
+	}
+	info.GetReturnValue().Set(Nan::New<v8::Number>(static_cast<double>(re2set->maxMem)));
+}
+
 v8::Local<v8::Function> WrappedRE2Set::Init()
 {
 	Nan::EscapableHandleScope scope;
@@ -772,6 +846,7 @@ v8::Local<v8::Function> WrappedRE2Set::Init()
 	Nan::SetAccessor(instanceTemplate, Nan::New("source").ToLocalChecked(), GetSource);
 	Nan::SetAccessor(instanceTemplate, Nan::New("size").ToLocalChecked(), GetSize);
 	Nan::SetAccessor(instanceTemplate, Nan::New("anchor").ToLocalChecked(), GetAnchor);
+	Nan::SetAccessor(instanceTemplate, Nan::New("maxMem").ToLocalChecked(), GetMaxMem);
 
 	auto isolate = v8::Isolate::GetCurrent();
 	auto data = getAddonData(isolate);

package/lib/test.cc

@@ -37,7 +37,7 @@ NAN_METHOD(WrappedRE2::Test)
 	if (re2->regexp.Match(str, str.byteIndex, str.size, re2->sticky ? re2::RE2::ANCHOR_START : re2::RE2::UNANCHORED, &match, 1))
 	{
 		re2->lastIndex +=
-			str.isBuffer ? match.data() - str.data + match.size() - str.byteIndex : getUtf16Length(str.data + str.byteIndex, match.data() + match.size());
+			str.isBuffer ? match.data() - str.data + match.size() - str.byteIndex : toUtf16Index(str.isAscii, str.data + str.byteIndex, match.data() + match.size());
 		info.GetReturnValue().Set(true);
 		return;
 	}