cline 1.0.0-nightly.19 → 1.0.0-nightly.20

package/node_modules/better-sqlite3/src/util/binder.cpp

@@ -0,0 +1,193 @@
+class Binder {
+public:
+
+	explicit Binder(sqlite3_stmt* _handle) {
+		handle = _handle;
+		param_count = sqlite3_bind_parameter_count(_handle);
+		anon_index = 0;
+		success = true;
+	}
+
+	bool Bind(NODE_ARGUMENTS info, int argc, Statement* stmt) {
+		assert(anon_index == 0);
+		Result result = BindArgs(info, argc, stmt);
+		if (success && result.count != param_count) {
+			if (result.count < param_count) {
+				if (!result.bound_object && stmt->GetBindMap(OnlyIsolate)->GetSize()) {
+					Fail(ThrowTypeError, "Missing named parameters");
+				} else {
+					Fail(ThrowRangeError, "Too few parameter values were provided");
+				}
+			} else {
+				Fail(ThrowRangeError, "Too many parameter values were provided");
+			}
+		}
+		return success;
+	}
+
+private:
+
+	struct Result {
+		int count;
+		bool bound_object;
+	};
+
+	static bool IsPlainObject(v8::Isolate* isolate, v8::Local<v8::Object> obj) {
+		v8::Local<v8::Value> proto = obj->GetPrototype();
+		v8::Local<v8::Context> ctx = obj->GetCreationContext().ToLocalChecked();
+		ctx->Enter();
+		v8::Local<v8::Value> baseProto = v8::Object::New(isolate)->GetPrototype();
+		ctx->Exit();
+		return proto->StrictEquals(baseProto) || proto->StrictEquals(v8::Null(isolate));
+	}
+
+	void Fail(void (*Throw)(const char* _), const char* message) {
+		assert(success == true);
+		assert((Throw == NULL) == (message == NULL));
+		assert(Throw == ThrowError || Throw == ThrowTypeError || Throw == ThrowRangeError || Throw == NULL);
+		if (Throw) Throw(message);
+		success = false;
+	}
+
+	int NextAnonIndex() {
+		while (sqlite3_bind_parameter_name(handle, ++anon_index) != NULL) {}
+		return anon_index;
+	}
+
+	// Binds the value at the given index or throws an appropriate error.
+	void BindValue(v8::Isolate* isolate, v8::Local<v8::Value> value, int index) {
+		int status = Data::BindValueFromJS(isolate, handle, index, value);
+		if (status != SQLITE_OK) {
+			switch (status) {
+				case -1:
+					return Fail(ThrowTypeError, "SQLite3 can only bind numbers, strings, bigints, buffers, and null");
+				case SQLITE_TOOBIG:
+					return Fail(ThrowRangeError, "The bound string, buffer, or bigint is too big");
+				case SQLITE_RANGE:
+					return Fail(ThrowRangeError, "Too many parameter values were provided");
+				case SQLITE_NOMEM:
+					return Fail(ThrowError, "Out of memory");
+				default:
+					return Fail(ThrowError, "An unexpected error occured while trying to bind parameters");
+			}
+			assert(false);
+		}
+	}
+
+	// Binds each value in the array or throws an appropriate error.
+	// The number of successfully bound parameters is returned.
+	int BindArray(v8::Isolate* isolate, v8::Local<v8::Array> arr) {
+		UseContext;
+		uint32_t length = arr->Length();
+		if (length > INT_MAX) {
+			Fail(ThrowRangeError, "Too many parameter values were provided");
+			return 0;
+		}
+		int len = static_cast<int>(length);
+		for (int i = 0; i < len; ++i) {
+			v8::MaybeLocal<v8::Value> maybeValue = arr->Get(ctx, i);
+			if (maybeValue.IsEmpty()) {
+				Fail(NULL, NULL);
+				return i;
+			}
+			BindValue(isolate, maybeValue.ToLocalChecked(), NextAnonIndex());
+			if (!success) {
+				return i;
+			}
+		}
+		return len;
+	}
+
+	// Binds all named parameters using the values found in the given object.
+	// The number of successfully bound parameters is returned.
+	// If a named parameter is missing from the object, an error is thrown.
+	// This should only be invoked once per instance.
+	int BindObject(v8::Isolate* isolate, v8::Local<v8::Object> obj, Statement* stmt) {
+		UseContext;
+		BindMap* bind_map = stmt->GetBindMap(isolate);
+		BindMap::Pair* pairs = bind_map->GetPairs();
+		int len = bind_map->GetSize();
+
+		for (int i = 0; i < len; ++i) {
+			v8::Local<v8::String> key = pairs[i].GetName(isolate);
+
+			// Check if the named parameter was provided.
+			v8::Maybe<bool> has_property = obj->HasOwnProperty(ctx, key);
+			if (has_property.IsNothing()) {
+				Fail(NULL, NULL);
+				return i;
+			}
+			if (!has_property.FromJust()) {
+				v8::String::Utf8Value param_name(isolate, key);
+				Fail(ThrowRangeError, (std::string("Missing named parameter \"") + *param_name + "\"").c_str());
+				return i;
+			}
+
+			// Get the current property value.
+			v8::MaybeLocal<v8::Value> maybeValue = obj->Get(ctx, key);
+			if (maybeValue.IsEmpty()) {
+				Fail(NULL, NULL);
+				return i;
+			}
+
+			BindValue(isolate, maybeValue.ToLocalChecked(), pairs[i].GetIndex());
+			if (!success) {
+				return i;
+			}
+		}
+
+		return len;
+	}
+
+	// Binds all parameters using the values found in the arguments object.
+	// Anonymous parameter values can be directly in the arguments object or in an Array.
+	// Named parameter values can be provided in a plain Object argument.
+	// Only one plain Object argument may be provided.
+	// If an error occurs, an appropriate error is thrown.
+	// The return value is a struct indicating how many parameters were successfully bound
+	// and whether or not it tried to bind an object.
+	Result BindArgs(NODE_ARGUMENTS info, int argc, Statement* stmt) {
+		UseIsolate;
+		int count = 0;
+		bool bound_object = false;
+
+		for (int i = 0; i < argc; ++i) {
+			v8::Local<v8::Value> arg = info[i];
+
+			if (arg->IsArray()) {
+				count += BindArray(isolate, arg.As<v8::Array>());
+				if (!success) break;
+				continue;
+			}
+
+			if (arg->IsObject() && !node::Buffer::HasInstance(arg)) {
+				v8::Local<v8::Object> obj = arg.As<v8::Object>();
+				if (IsPlainObject(isolate, obj)) {
+					if (bound_object) {
+						Fail(ThrowTypeError, "You cannot specify named parameters in two different objects");
+						break;
+					}
+					bound_object = true;
+
+					count += BindObject(isolate, obj, stmt);
+					if (!success) break;
+					continue;
+				} else if (stmt->GetBindMap(isolate)->GetSize()) {
+					Fail(ThrowTypeError, "Named parameters can only be passed within plain objects");
+					break;
+				}
+			}
+
+			BindValue(isolate, arg, NextAnonIndex());
+			if (!success) break;
+			count += 1;
+		}
+
+		return { count, bound_object };
+	}
+
+	sqlite3_stmt* handle;
+	int param_count;
+	int anon_index; // This value should only be used by NextAnonIndex()
+	bool success; // This value should only be set by Fail()
+};

package/node_modules/better-sqlite3/src/util/constants.cpp

@@ -0,0 +1,172 @@
+class CS {
+public:
+
+	v8::Local<v8::String> Code(v8::Isolate* isolate, int code) {
+		auto element = codes.find(code);
+		if (element != codes.end()) return element->second.Get(isolate);
+		return StringFromUtf8(isolate, (std::string("UNKNOWN_SQLITE_ERROR_") + std::to_string(code)).c_str(), -1);
+	}
+
+	explicit CS(v8::Isolate* isolate) {
+		SetString(isolate, database, "database");
+		SetString(isolate, reader, "reader");
+		SetString(isolate, source, "source");
+		SetString(isolate, memory, "memory");
+		SetString(isolate, readonly, "readonly");
+		SetString(isolate, name, "name");
+		SetString(isolate, next, "next");
+		SetString(isolate, length, "length");
+		SetString(isolate, done, "done");
+		SetString(isolate, value, "value");
+		SetString(isolate, changes, "changes");
+		SetString(isolate, lastInsertRowid, "lastInsertRowid");
+		SetString(isolate, statement, "statement");
+		SetString(isolate, column, "column");
+		SetString(isolate, table, "table");
+		SetString(isolate, type, "type");
+		SetString(isolate, totalPages, "totalPages");
+		SetString(isolate, remainingPages, "remainingPages");
+
+		SetCode(isolate, SQLITE_OK, "SQLITE_OK");
+		SetCode(isolate, SQLITE_ERROR, "SQLITE_ERROR");
+		SetCode(isolate, SQLITE_INTERNAL, "SQLITE_INTERNAL");
+		SetCode(isolate, SQLITE_PERM, "SQLITE_PERM");
+		SetCode(isolate, SQLITE_ABORT, "SQLITE_ABORT");
+		SetCode(isolate, SQLITE_BUSY, "SQLITE_BUSY");
+		SetCode(isolate, SQLITE_LOCKED, "SQLITE_LOCKED");
+		SetCode(isolate, SQLITE_NOMEM, "SQLITE_NOMEM");
+		SetCode(isolate, SQLITE_READONLY, "SQLITE_READONLY");
+		SetCode(isolate, SQLITE_INTERRUPT, "SQLITE_INTERRUPT");
+		SetCode(isolate, SQLITE_IOERR, "SQLITE_IOERR");
+		SetCode(isolate, SQLITE_CORRUPT, "SQLITE_CORRUPT");
+		SetCode(isolate, SQLITE_NOTFOUND, "SQLITE_NOTFOUND");
+		SetCode(isolate, SQLITE_FULL, "SQLITE_FULL");
+		SetCode(isolate, SQLITE_CANTOPEN, "SQLITE_CANTOPEN");
+		SetCode(isolate, SQLITE_PROTOCOL, "SQLITE_PROTOCOL");
+		SetCode(isolate, SQLITE_EMPTY, "SQLITE_EMPTY");
+		SetCode(isolate, SQLITE_SCHEMA, "SQLITE_SCHEMA");
+		SetCode(isolate, SQLITE_TOOBIG, "SQLITE_TOOBIG");
+		SetCode(isolate, SQLITE_CONSTRAINT, "SQLITE_CONSTRAINT");
+		SetCode(isolate, SQLITE_MISMATCH, "SQLITE_MISMATCH");
+		SetCode(isolate, SQLITE_MISUSE, "SQLITE_MISUSE");
+		SetCode(isolate, SQLITE_NOLFS, "SQLITE_NOLFS");
+		SetCode(isolate, SQLITE_AUTH, "SQLITE_AUTH");
+		SetCode(isolate, SQLITE_FORMAT, "SQLITE_FORMAT");
+		SetCode(isolate, SQLITE_RANGE, "SQLITE_RANGE");
+		SetCode(isolate, SQLITE_NOTADB, "SQLITE_NOTADB");
+		SetCode(isolate, SQLITE_NOTICE, "SQLITE_NOTICE");
+		SetCode(isolate, SQLITE_WARNING, "SQLITE_WARNING");
+		SetCode(isolate, SQLITE_ROW, "SQLITE_ROW");
+		SetCode(isolate, SQLITE_DONE, "SQLITE_DONE");
+
+		SetCode(isolate, SQLITE_ERROR_MISSING_COLLSEQ, "SQLITE_ERROR_MISSING_COLLSEQ");
+		SetCode(isolate, SQLITE_ERROR_RETRY, "SQLITE_ERROR_RETRY");
+		SetCode(isolate, SQLITE_ERROR_SNAPSHOT, "SQLITE_ERROR_SNAPSHOT");
+		SetCode(isolate, SQLITE_IOERR_READ, "SQLITE_IOERR_READ");
+		SetCode(isolate, SQLITE_IOERR_SHORT_READ, "SQLITE_IOERR_SHORT_READ");
+		SetCode(isolate, SQLITE_IOERR_WRITE, "SQLITE_IOERR_WRITE");
+		SetCode(isolate, SQLITE_IOERR_FSYNC, "SQLITE_IOERR_FSYNC");
+		SetCode(isolate, SQLITE_IOERR_DIR_FSYNC, "SQLITE_IOERR_DIR_FSYNC");
+		SetCode(isolate, SQLITE_IOERR_TRUNCATE, "SQLITE_IOERR_TRUNCATE");
+		SetCode(isolate, SQLITE_IOERR_FSTAT, "SQLITE_IOERR_FSTAT");
+		SetCode(isolate, SQLITE_IOERR_UNLOCK, "SQLITE_IOERR_UNLOCK");
+		SetCode(isolate, SQLITE_IOERR_RDLOCK, "SQLITE_IOERR_RDLOCK");
+		SetCode(isolate, SQLITE_IOERR_DELETE, "SQLITE_IOERR_DELETE");
+		SetCode(isolate, SQLITE_IOERR_BLOCKED, "SQLITE_IOERR_BLOCKED");
+		SetCode(isolate, SQLITE_IOERR_NOMEM, "SQLITE_IOERR_NOMEM");
+		SetCode(isolate, SQLITE_IOERR_ACCESS, "SQLITE_IOERR_ACCESS");
+		SetCode(isolate, SQLITE_IOERR_CHECKRESERVEDLOCK, "SQLITE_IOERR_CHECKRESERVEDLOCK");
+		SetCode(isolate, SQLITE_IOERR_LOCK, "SQLITE_IOERR_LOCK");
+		SetCode(isolate, SQLITE_IOERR_CLOSE, "SQLITE_IOERR_CLOSE");
+		SetCode(isolate, SQLITE_IOERR_DIR_CLOSE, "SQLITE_IOERR_DIR_CLOSE");
+		SetCode(isolate, SQLITE_IOERR_SHMOPEN, "SQLITE_IOERR_SHMOPEN");
+		SetCode(isolate, SQLITE_IOERR_SHMSIZE, "SQLITE_IOERR_SHMSIZE");
+		SetCode(isolate, SQLITE_IOERR_SHMLOCK, "SQLITE_IOERR_SHMLOCK");
+		SetCode(isolate, SQLITE_IOERR_SHMMAP, "SQLITE_IOERR_SHMMAP");
+		SetCode(isolate, SQLITE_IOERR_SEEK, "SQLITE_IOERR_SEEK");
+		SetCode(isolate, SQLITE_IOERR_DELETE_NOENT, "SQLITE_IOERR_DELETE_NOENT");
+		SetCode(isolate, SQLITE_IOERR_MMAP, "SQLITE_IOERR_MMAP");
+		SetCode(isolate, SQLITE_IOERR_GETTEMPPATH, "SQLITE_IOERR_GETTEMPPATH");
+		SetCode(isolate, SQLITE_IOERR_CONVPATH, "SQLITE_IOERR_CONVPATH");
+		SetCode(isolate, SQLITE_IOERR_VNODE, "SQLITE_IOERR_VNODE");
+		SetCode(isolate, SQLITE_IOERR_AUTH, "SQLITE_IOERR_AUTH");
+		SetCode(isolate, SQLITE_IOERR_BEGIN_ATOMIC, "SQLITE_IOERR_BEGIN_ATOMIC");
+		SetCode(isolate, SQLITE_IOERR_COMMIT_ATOMIC, "SQLITE_IOERR_COMMIT_ATOMIC");
+		SetCode(isolate, SQLITE_IOERR_ROLLBACK_ATOMIC, "SQLITE_IOERR_ROLLBACK_ATOMIC");
+		SetCode(isolate, SQLITE_IOERR_DATA, "SQLITE_IOERR_DATA");
+		SetCode(isolate, SQLITE_IOERR_CORRUPTFS, "SQLITE_IOERR_CORRUPTFS");
+		SetCode(isolate, SQLITE_IOERR_IN_PAGE, "SQLITE_IOERR_IN_PAGE");
+		SetCode(isolate, SQLITE_LOCKED_SHAREDCACHE, "SQLITE_LOCKED_SHAREDCACHE");
+		SetCode(isolate, SQLITE_LOCKED_VTAB, "SQLITE_LOCKED_VTAB");
+		SetCode(isolate, SQLITE_BUSY_RECOVERY, "SQLITE_BUSY_RECOVERY");
+		SetCode(isolate, SQLITE_BUSY_SNAPSHOT, "SQLITE_BUSY_SNAPSHOT");
+		SetCode(isolate, SQLITE_CANTOPEN_NOTEMPDIR, "SQLITE_CANTOPEN_NOTEMPDIR");
+		SetCode(isolate, SQLITE_CANTOPEN_ISDIR, "SQLITE_CANTOPEN_ISDIR");
+		SetCode(isolate, SQLITE_CANTOPEN_FULLPATH, "SQLITE_CANTOPEN_FULLPATH");
+		SetCode(isolate, SQLITE_CANTOPEN_CONVPATH, "SQLITE_CANTOPEN_CONVPATH");
+		SetCode(isolate, SQLITE_CANTOPEN_DIRTYWAL, "SQLITE_CANTOPEN_DIRTYWAL");
+		SetCode(isolate, SQLITE_CANTOPEN_SYMLINK, "SQLITE_CANTOPEN_SYMLINK");
+		SetCode(isolate, SQLITE_CORRUPT_VTAB, "SQLITE_CORRUPT_VTAB");
+		SetCode(isolate, SQLITE_CORRUPT_SEQUENCE, "SQLITE_CORRUPT_SEQUENCE");
+		SetCode(isolate, SQLITE_CORRUPT_INDEX, "SQLITE_CORRUPT_INDEX");
+		SetCode(isolate, SQLITE_READONLY_RECOVERY, "SQLITE_READONLY_RECOVERY");
+		SetCode(isolate, SQLITE_READONLY_CANTLOCK, "SQLITE_READONLY_CANTLOCK");
+		SetCode(isolate, SQLITE_READONLY_ROLLBACK, "SQLITE_READONLY_ROLLBACK");
+		SetCode(isolate, SQLITE_READONLY_DBMOVED, "SQLITE_READONLY_DBMOVED");
+		SetCode(isolate, SQLITE_READONLY_CANTINIT, "SQLITE_READONLY_CANTINIT");
+		SetCode(isolate, SQLITE_READONLY_DIRECTORY, "SQLITE_READONLY_DIRECTORY");
+		SetCode(isolate, SQLITE_ABORT_ROLLBACK, "SQLITE_ABORT_ROLLBACK");
+		SetCode(isolate, SQLITE_CONSTRAINT_CHECK, "SQLITE_CONSTRAINT_CHECK");
+		SetCode(isolate, SQLITE_CONSTRAINT_COMMITHOOK, "SQLITE_CONSTRAINT_COMMITHOOK");
+		SetCode(isolate, SQLITE_CONSTRAINT_FOREIGNKEY, "SQLITE_CONSTRAINT_FOREIGNKEY");
+		SetCode(isolate, SQLITE_CONSTRAINT_FUNCTION, "SQLITE_CONSTRAINT_FUNCTION");
+		SetCode(isolate, SQLITE_CONSTRAINT_NOTNULL, "SQLITE_CONSTRAINT_NOTNULL");
+		SetCode(isolate, SQLITE_CONSTRAINT_PRIMARYKEY, "SQLITE_CONSTRAINT_PRIMARYKEY");
+		SetCode(isolate, SQLITE_CONSTRAINT_TRIGGER, "SQLITE_CONSTRAINT_TRIGGER");
+		SetCode(isolate, SQLITE_CONSTRAINT_UNIQUE, "SQLITE_CONSTRAINT_UNIQUE");
+		SetCode(isolate, SQLITE_CONSTRAINT_VTAB, "SQLITE_CONSTRAINT_VTAB");
+		SetCode(isolate, SQLITE_CONSTRAINT_ROWID, "SQLITE_CONSTRAINT_ROWID");
+		SetCode(isolate, SQLITE_CONSTRAINT_PINNED, "SQLITE_CONSTRAINT_PINNED");
+		SetCode(isolate, SQLITE_CONSTRAINT_DATATYPE, "SQLITE_CONSTRAINT_DATATYPE");
+		SetCode(isolate, SQLITE_NOTICE_RECOVER_WAL, "SQLITE_NOTICE_RECOVER_WAL");
+		SetCode(isolate, SQLITE_NOTICE_RECOVER_ROLLBACK, "SQLITE_NOTICE_RECOVER_ROLLBACK");
+		SetCode(isolate, SQLITE_NOTICE_RBU, "SQLITE_NOTICE_RBU");
+		SetCode(isolate, SQLITE_WARNING_AUTOINDEX, "SQLITE_WARNING_AUTOINDEX");
+		SetCode(isolate, SQLITE_AUTH_USER, "SQLITE_AUTH_USER");
+		SetCode(isolate, SQLITE_OK_LOAD_PERMANENTLY, "SQLITE_OK_LOAD_PERMANENTLY");
+		SetCode(isolate, SQLITE_OK_SYMLINK, "SQLITE_OK_SYMLINK");
+	}
+
+	v8::Global<v8::String> database;
+	v8::Global<v8::String> reader;
+	v8::Global<v8::String> source;
+	v8::Global<v8::String> memory;
+	v8::Global<v8::String> readonly;
+	v8::Global<v8::String> name;
+	v8::Global<v8::String> next;
+	v8::Global<v8::String> length;
+	v8::Global<v8::String> done;
+	v8::Global<v8::String> value;
+	v8::Global<v8::String> changes;
+	v8::Global<v8::String> lastInsertRowid;
+	v8::Global<v8::String> statement;
+	v8::Global<v8::String> column;
+	v8::Global<v8::String> table;
+	v8::Global<v8::String> type;
+	v8::Global<v8::String> totalPages;
+	v8::Global<v8::String> remainingPages;
+
+private:
+
+	static void SetString(v8::Isolate* isolate, v8::Global<v8::String>& constant, const char* str) {
+		constant.Reset(isolate, InternalizedFromLatin1(isolate, str));
+	}
+
+	void SetCode(v8::Isolate* isolate, int code, const char* str) {
+		codes.emplace(std::piecewise_construct,
+			std::forward_as_tuple(code),
+			std::forward_as_tuple(isolate, InternalizedFromLatin1(isolate, str)));
+	}
+
+	std::unordered_map<int, v8::Global<v8::String> > codes;
+};

package/node_modules/better-sqlite3/src/util/custom-aggregate.cpp

@@ -0,0 +1,121 @@
+class CustomAggregate : public CustomFunction {
+public:
+
+	explicit CustomAggregate(
+		v8::Isolate* isolate,
+		Database* db,
+		const char* name,
+		v8::Local<v8::Value> start,
+		v8::Local<v8::Function> step,
+		v8::Local<v8::Value> inverse,
+		v8::Local<v8::Value> result,
+		bool safe_ints
+	) :
+		CustomFunction(isolate, db, name, step, safe_ints),
+		invoke_result(result->IsFunction()),
+		invoke_start(start->IsFunction()),
+		inverse(isolate, inverse->IsFunction() ? inverse.As<v8::Function>() : v8::Local<v8::Function>()),
+		result(isolate, result->IsFunction() ? result.As<v8::Function>() : v8::Local<v8::Function>()),
+		start(isolate, start) {}
+
+	static void xStep(sqlite3_context* invocation, int argc, sqlite3_value** argv) {
+		xStepBase(invocation, argc, argv, &CustomAggregate::fn);
+	}
+
+	static void xInverse(sqlite3_context* invocation, int argc, sqlite3_value** argv) {
+		xStepBase(invocation, argc, argv, &CustomAggregate::inverse);
+	}
+
+	static void xValue(sqlite3_context* invocation) {
+		xValueBase(invocation, false);
+	}
+
+	static void xFinal(sqlite3_context* invocation) {
+		xValueBase(invocation, true);
+	}
+
+private:
+
+	static inline void xStepBase(sqlite3_context* invocation, int argc, sqlite3_value** argv, const v8::Global<v8::Function> CustomAggregate::*ptrtm) {
+		AGGREGATE_START();
+
+		v8::Local<v8::Value> args_fast[5];
+		v8::Local<v8::Value>* args = argc <= 4 ? args_fast : ALLOC_ARRAY<v8::Local<v8::Value>>(argc + 1);
+		args[0] = acc->value.Get(isolate);
+		if (argc != 0) Data::GetArgumentsJS(isolate, args + 1, argv, argc, self->safe_ints);
+
+		v8::MaybeLocal<v8::Value> maybeReturnValue = (self->*ptrtm).Get(isolate)->Call(OnlyContext, v8::Undefined(isolate), argc + 1, args);
+		if (args != args_fast) delete[] args;
+
+		if (maybeReturnValue.IsEmpty()) {
+			self->PropagateJSError(invocation);
+		} else {
+			v8::Local<v8::Value> returnValue = maybeReturnValue.ToLocalChecked();
+			if (!returnValue->IsUndefined()) acc->value.Reset(isolate, returnValue);
+		}
+	}
+
+	static inline void xValueBase(sqlite3_context* invocation, bool is_final) {
+		AGGREGATE_START();
+
+		if (!is_final) {
+			acc->is_window = true;
+		} else if (acc->is_window) {
+			DestroyAccumulator(invocation);
+			return;
+		}
+
+		v8::Local<v8::Value> result = acc->value.Get(isolate);
+		if (self->invoke_result) {
+			v8::MaybeLocal<v8::Value> maybeResult = self->result.Get(isolate)->Call(OnlyContext, v8::Undefined(isolate), 1, &result);
+			if (maybeResult.IsEmpty()) {
+				self->PropagateJSError(invocation);
+				return;
+			}
+			result = maybeResult.ToLocalChecked();
+		}
+
+		Data::ResultValueFromJS(isolate, invocation, result, self);
+		if (is_final) DestroyAccumulator(invocation);
+	}
+
+	struct Accumulator { public:
+		v8::Global<v8::Value> value;
+		bool initialized;
+		bool is_window;
+	};
+
+	Accumulator* GetAccumulator(sqlite3_context* invocation) {
+		Accumulator* acc = static_cast<Accumulator*>(sqlite3_aggregate_context(invocation, sizeof(Accumulator)));
+		if (!acc->initialized) {
+			assert(acc->value.IsEmpty());
+			acc->initialized = true;
+			if (invoke_start) {
+				v8::MaybeLocal<v8::Value> maybeSeed = start.Get(isolate).As<v8::Function>()->Call(OnlyContext, v8::Undefined(isolate), 0, NULL);
+				if (maybeSeed.IsEmpty()) PropagateJSError(invocation);
+				else acc->value.Reset(isolate, maybeSeed.ToLocalChecked());
+			} else {
+				assert(!start.IsEmpty());
+				acc->value.Reset(isolate, start);
+			}
+		}
+		return acc;
+	}
+
+	static void DestroyAccumulator(sqlite3_context* invocation) {
+		Accumulator* acc = static_cast<Accumulator*>(sqlite3_aggregate_context(invocation, sizeof(Accumulator)));
+		assert(acc->initialized);
+		acc->value.Reset();
+	}
+
+	void PropagateJSError(sqlite3_context* invocation) {
+		DestroyAccumulator(invocation);
+		CustomFunction::PropagateJSError(invocation);
+	}
+
+	const bool invoke_result;
+	const bool invoke_start;
+	const v8::Global<v8::Function> inverse;
+	const v8::Global<v8::Function> result;
+	const v8::Global<v8::Value> start;
+};

package/node_modules/better-sqlite3/src/util/custom-function.cpp

@@ -0,0 +1,59 @@
+class CustomFunction : protected DataConverter {
+public:
+
+	explicit CustomFunction(
+		v8::Isolate* isolate,
+		Database* db,
+		const char* name,
+		v8::Local<v8::Function> fn,
+		bool safe_ints
+	) :
+		name(name),
+		db(db),
+		isolate(isolate),
+		fn(isolate, fn),
+		safe_ints(safe_ints) {}
+
+	virtual ~CustomFunction() {}
+
+	static void xDestroy(void* self) {
+		delete static_cast<CustomFunction*>(self);
+	}
+
+	static void xFunc(sqlite3_context* invocation, int argc, sqlite3_value** argv) {
+		FUNCTION_START();
+
+		v8::Local<v8::Value> args_fast[4];
+		v8::Local<v8::Value>* args = NULL;
+		if (argc != 0) {
+			args = argc <= 4 ? args_fast : ALLOC_ARRAY<v8::Local<v8::Value>>(argc);
+			Data::GetArgumentsJS(isolate, args, argv, argc, self->safe_ints);
+		}
+
+		v8::MaybeLocal<v8::Value> maybeReturnValue = self->fn.Get(isolate)->Call(OnlyContext, v8::Undefined(isolate), argc, args);
+		if (args != args_fast) delete[] args;
+
+		if (maybeReturnValue.IsEmpty()) self->PropagateJSError(invocation);
+		else Data::ResultValueFromJS(isolate, invocation, maybeReturnValue.ToLocalChecked(), self);
+	}
+
+protected:
+
+	void PropagateJSError(sqlite3_context* invocation) {
+		assert(db->GetState()->was_js_error == false);
+		db->GetState()->was_js_error = true;
+		sqlite3_result_error(invocation, "", 0);
+	}
+
+	std::string GetDataErrorPrefix() {
+		return std::string("User-defined function ") + name + "() returned";
+	}
+
+private:
+	const std::string name;
+	Database* const db;
+protected:
+	v8::Isolate* const isolate;
+	const v8::Global<v8::Function> fn;
+	const bool safe_ints;
+};