re2 1.21.0 → 1.21.2

package/LICENSE

@@ -7,7 +7,7 @@ The text of the BSD license is reproduced below.
 The "New" BSD License:
 **********************
 
-Copyright (c) 2005-2020, Eugene Lazutkin
+Copyright (c) 2005-2024, Eugene Lazutkin
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

package/README.md

@@ -353,6 +353,8 @@ 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.*
 - 1.20.11 *Updated deps. Added support for Node 22 (thx, [Elton Leong](https://github.com/eltonkl)).*
@@ -367,16 +369,9 @@ console.log('re2_res : ' + re2_res); // prints: re2_res : abc,a,b,c
 - 1.20.2 *Fix: added a missing C++ file, which caused a bug on Alpine Linux. Thx, [rbitanga-manticore](https://github.com/rbitanga-manticore).*
 - 1.20.1 *Fix: files included in the npm package to build the C++ code.*
 - 1.20.0 *Updated RE2. New version uses `abseil-cpp` and required the adaptation work. Thx, [Stefano Rivera](https://github.com/stefanor).*
-- 1.19.2 *Bugfix: infinite loop in matchAll() with empty matches. Thx, [ziyunfei](https://github.com/ziyunfei).*
-- 1.19.1 *Bugfix: indices for the `d` flag when `lastIndex` is non zero. Bugfix: the match result. Thx, [teebu](https://github.com/teebu).*
-- 1.19.0 *Added `hasIndices` AKA the `d` flag. Thx, [teebu](https://github.com/teebu).*
-- 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)).*
 
 The rest can be consulted in the project's wiki [Release history](https://github.com/uhop/node-re2/wiki/Release-history).
 
 ## License
 
-BSD
+BSD-3-Clause

package/binding.gyp

@@ -3,8 +3,9 @@
     {
       "target_name": "re2",
       "sources": [
-        "lib/str-val.cc",
         "lib/addon.cc",
+        "lib/accessors.cc",
+        "lib/util.cc",
         "lib/new.cc",
         "lib/exec.cc",
         "lib/test.cc",
@@ -13,9 +14,6 @@
         "lib/search.cc",
         "lib/split.cc",
         "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",
@@ -44,6 +42,7 @@
         "vendor/abseil-cpp/absl/base/internal/raw_logging.cc",
         "vendor/abseil-cpp/absl/base/internal/spinlock.cc",
         "vendor/abseil-cpp/absl/base/internal/spinlock_wait.cc",
+        "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",
@@ -52,6 +51,7 @@
         "vendor/abseil-cpp/absl/container/internal/raw_hash_set.cc",
         "vendor/abseil-cpp/absl/debugging/internal/address_is_readable.cc",
         "vendor/abseil-cpp/absl/debugging/internal/elf_mem_image.cc",
+        "vendor/abseil-cpp/absl/debugging/internal/examine_stack.cc",
         "vendor/abseil-cpp/absl/debugging/internal/vdso_support.cc",
         "vendor/abseil-cpp/absl/debugging/stacktrace.cc",
         "vendor/abseil-cpp/absl/debugging/symbolize.cc",
@@ -66,6 +66,14 @@
         "vendor/abseil-cpp/absl/hash/internal/city.cc",
         "vendor/abseil-cpp/absl/hash/internal/hash.cc",
         "vendor/abseil-cpp/absl/hash/internal/low_level_hash.cc",
+        "vendor/abseil-cpp/absl/log/internal/globals.cc",
+        "vendor/abseil-cpp/absl/log/internal/log_format.cc",
+        "vendor/abseil-cpp/absl/log/internal/log_message.cc",
+        "vendor/abseil-cpp/absl/log/internal/log_sink_set.cc",
+        "vendor/abseil-cpp/absl/log/internal/nullguard.cc",
+        "vendor/abseil-cpp/absl/log/internal/proto.cc",
+        "vendor/abseil-cpp/absl/log/globals.cc",
+        "vendor/abseil-cpp/absl/log/log_sink.cc",
         "vendor/abseil-cpp/absl/numeric/int128.cc",
         "vendor/abseil-cpp/absl/strings/ascii.cc",
         "vendor/abseil-cpp/absl/strings/charconv.cc",

package/lib/accessors.cc

@@ -41,7 +41,7 @@ NAN_GETTER(WrappedRE2::GetFlags)
 	std::string flags;
 	if (re2->hasIndices)
 	{
-		flags = "d";
+		flags += "d";
 	}
 	if (re2->global)
 	{

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());
@@ -92,55 +90,126 @@ NODE_MODULE_INIT()
 	Nan::Set(module->ToObject(context).ToLocalChecked(), Nan::New("exports").ToLocalChecked(), WrappedRE2::Init());
 }
 
+WrappedRE2::~WrappedRE2()
+{
+	dropCache();
+}
+
 // private methods
 
-void WrappedRE2::dropLastString()
+void WrappedRE2::dropCache()
 {
-	lastString.Reset();
-	if (lastStringValue)
+	if (!lastString.IsEmpty())
 	{
-		delete lastStringValue;
-		lastStringValue = nullptr;
+		// lastString.ClearWeak();
+		lastString.Reset();
 	}
-}
-
-inline size_t countBytes(const char *data, size_t from, size_t n)
-{
-	for (; n > 0; --n)
+	if (!lastCache.IsEmpty())
 	{
-		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
+		// lastCache.ClearWeak();
+		lastCache.Reset();
 	}
-	return from;
+	lastStringValue.clear();
 }
 
-void WrappedRE2::prepareLastString(const v8::Local<v8::Value> &arg, bool ignoreLastIndex)
+const StrVal& WrappedRE2::prepareArgument(const v8::Local<v8::Value> &arg, bool ignoreLastIndex)
 {
 	size_t startFrom = ignoreLastIndex ? 0 : lastIndex;
 
+	if (lastString == arg && !node::Buffer::HasInstance(arg) && !lastCache.IsEmpty())
+	{
+		// we have a properly cached string
+		lastStringValue.setIndex(startFrom);
+		return lastStringValue;
+	}
+
+	dropCache();
+
 	if (node::Buffer::HasInstance(arg))
 	{
-		dropLastString();
-		lastStringValue = new StrValBuffer(arg, startFrom);
+		// 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;
+	}
+
+	// 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)
+{
+	isValidIndex = newIndex <= length;
+	if (!isValidIndex)
+	{
+		index = newIndex;
+		byteIndex = 0;
+		return;
+	}
+
+	if (newIndex == index)
+		return;
+
+	if (isBuffer)
+	{
+		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();
-	lastStringValue = new StrValString(arg, startFrom);
-};
+	if (newIndex == length)
+	{
+		byteIndex = size;
+		index = length;
+		return;
+	}
+
+	byteIndex = index < newIndex ? getUtf16PositionByCounter(data, byteIndex, newIndex - index) : getUtf16PositionByCounter(data, 0, newIndex);
+	index = newIndex;
+}
+
+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;
 	}
 
-	re2->prepareLastString(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;
 	}
 
-	re2->prepareLastString(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/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;
 	}
 
-	re2->prepareLastString(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;
 	}
 
-	re2->prepareLastString(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;
 	}
 
-	re2->prepareLastString(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;
 	}
 
-	re2->prepareLastString(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/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,13 +1,30 @@
-#ifndef WRAPPED_RE2_H_
-#define WRAPPED_RE2_H_
+#pragma once
 
+#include <string>
 #include <nan.h>
-
 #include <re2/re2.h>
 
-#include <string>
+struct StrVal
+{
+	char *data;
+	size_t size, length;
+	size_t index, byteIndex;
+	bool isBuffer, isValidIndex, isBad;
+
+	StrVal() : data(NULL), size(0), length(0), index(0), byteIndex(0), isBuffer(false), isValidIndex(false), isBad(false) {}
 
-struct StrValBase;
+	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
 {
@@ -29,8 +46,7 @@ private:
 						 dotAll(s),
 						 sticky(y),
 						 hasIndices(d),
-						 lastIndex(0),
-						 lastStringValue(nullptr) {}
+						 lastIndex(0) {}
 
 	static NAN_METHOD(New);
 	static NAN_METHOD(ToString);
@@ -63,10 +79,7 @@ private:
 	static NAN_SETTER(SetUnicodeWarningLevel);
 
 public:
-	~WrappedRE2()
-	{
-		dropLastString();
-	}
+	~WrappedRE2();
 
 	static v8::Local<v8::Function> Init();
 
@@ -97,12 +110,15 @@ public:
 	bool hasIndices;
 	size_t lastIndex;
 
+	friend struct PrepareLastString;
+
 private:
 	Nan::Persistent<v8::Value> lastString; // weak pointer
-	StrValBase *lastStringValue;
+	Nan::Persistent<v8::Object> lastCache; // weak pointer
+	StrVal lastStringValue;
 
-	void dropLastString();
-	void prepareLastString(const v8::Local<v8::Value> &arg, bool ignoreLastIndex = false);
+	void dropCache();
+	const StrVal &prepareArgument(const v8::Local<v8::Value> &arg, bool ignoreLastIndex = false);
 };
 
 // utilities
@@ -183,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.0",
+  "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",
@@ -20,7 +20,7 @@
     "node-gyp": "^10.1.0"
   },
   "devDependencies": {
-    "@types/node": "^20.12.12",
+    "@types/node": "^20.14.2",
     "heya-unit": "^0.3.0",
     "typescript": "^5.4.5"
   },
@@ -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);
-      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/vendor/re2/.github/workflows/ci-bazel.yml

@@ -14,8 +14,8 @@ jobs:
     env:
       BAZELISK_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@v4.1.4
-      - uses: bazel-contrib/setup-bazel@0.8.2
+      - uses: actions/checkout@v4.1.6
+      - uses: bazel-contrib/setup-bazel@0.8.4
         with:
           bazelisk-version: '1.x'
       - run: .github/bazel.sh