pi-para 0.7.8 → 0.7.10

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

@@ -0,0 +1,210 @@
+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);
+		Napi::Env env = info.Env();
+		Result result = BindArgs(info, argc, stmt);
+		if (success && result.count != param_count) {
+			if (result.count < param_count) {
+				if (!result.bound_object && stmt->GetBindMap(env).GetSize()) {
+					Fail(ThrowTypeError, env, "Missing named parameters");
+				} else {
+					Fail(ThrowRangeError, env, "Too few parameter values were provided");
+				}
+			} else {
+				Fail(ThrowRangeError, env, "Too many parameter values were provided");
+			}
+		}
+		return success;
+	}
+
+private:
+
+	struct Result {
+		int count;
+		bool bound_object;
+	};
+
+	static Napi::Value GetPrototype(Napi::Env env, Napi::Object obj) {
+		napi_value proto;
+		// This can fail (e.g., a Proxy whose getPrototypeOf trap throws), in
+		// which case an empty value is returned and an exception is pending.
+		if (napi_get_prototype(env, obj, &proto) != napi_ok) return Napi::Value();
+		return Napi::Value(env, proto);
+	}
+
+	// An object is "plain" if its prototype is null or a top-level prototype
+	// (i.e., some realm's Object.prototype). Rather than comparing against the
+	// current realm's Object.prototype -- which would reject plain objects from
+	// other contexts, such as the "vm" module -- we walk to the top of the
+	// prototype chain. A plain object's chain is exactly "obj -> proto -> null",
+	// so its immediate prototype must itself have a null prototype. This mirrors
+	// the cross-realm heuristic used by lodash's isPlainObject.
+	static bool IsPlainObject(Napi::Env env, Napi::Object obj) {
+		Napi::Value proto = GetPrototype(env, obj);
+		if (proto.IsEmpty()) return false;
+		if (proto.IsNull()) return true;
+		Napi::Value grandproto = GetPrototype(env, proto.As<Napi::Object>());
+		if (grandproto.IsEmpty()) return false;
+		return grandproto.IsNull();
+	}
+
+	void Fail(Napi::Value (*Throw)(Napi::Env, const char*), Napi::Env env, const char* message) {
+		assert(success == true);
+		assert((Throw == NULL) == (message == NULL));
+		assert(Throw == ThrowError || Throw == ThrowTypeError || Throw == ThrowRangeError || Throw == NULL);
+		if (Throw) Throw(env, 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(Napi::Env env, Napi::Value value, int index) {
+		int status = Data::BindValueFromJS(env, handle, index, value);
+		if (status != SQLITE_OK) {
+			switch (status) {
+				case -1:
+					return Fail(ThrowTypeError, env, "SQLite3 can only bind numbers, strings, bigints, buffers, and null");
+				case SQLITE_TOOBIG:
+					return Fail(ThrowRangeError, env, "The bound string, buffer, or bigint is too big");
+				case SQLITE_RANGE:
+					return Fail(ThrowRangeError, env, "Too many parameter values were provided");
+				case SQLITE_NOMEM:
+					return Fail(ThrowError, env, "Out of memory");
+				default:
+					return Fail(ThrowError, env, "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(Napi::Env env, Napi::Array arr) {
+		uint32_t length = arr.Length();
+		if (length > INT_MAX) {
+			Fail(ThrowRangeError, env, "Too many parameter values were provided");
+			return 0;
+		}
+		int len = static_cast<int>(length);
+		for (int i = 0; i < len; ++i) {
+			Napi::Value value = SafeGetElement(env, arr, static_cast<uint32_t>(i));
+			if (value.IsEmpty()) {
+				Fail(NULL, env, NULL);
+				return i;
+			}
+			BindValue(env, value, 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(Napi::Env env, Napi::Object obj, Statement* stmt) {
+		BindMap& bind_map = stmt->GetBindMap(env);
+		BindMap::Pair* pairs = bind_map.GetPairs();
+		int len = bind_map.GetSize();
+
+		for (int i = 0; i < len; ++i) {
+			Napi::String key = pairs[i].GetName(env);
+
+			// Check if the named parameter was provided.
+			bool has_property;
+			if (!SafeHasOwnProperty(env, obj, key, &has_property)) {
+				Fail(NULL, env, NULL);
+				return i;
+			}
+			if (!has_property) {
+				std::string param_name = key.Utf8Value();
+				Fail(ThrowRangeError, env, (std::string("Missing named parameter \"") + param_name + "\"").c_str());
+				return i;
+			}
+
+			// Get the current property value.
+			Napi::Value value = SafeGet(env, obj, key);
+			if (value.IsEmpty()) {
+				Fail(NULL, env, NULL);
+				return i;
+			}
+
+			BindValue(env, value, 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) {
+		Napi::Env env = info.Env();
+		int count = 0;
+		bool bound_object = false;
+
+		for (int i = 0; i < argc; ++i) {
+			Napi::Value arg = info[i];
+
+			if (arg.IsArray()) {
+				count += BindArray(env, arg.As<Napi::Array>());
+				if (!success) break;
+				continue;
+			}
+
+			if (arg.IsObject() && !arg.IsBuffer()) {
+				Napi::Object obj = arg.As<Napi::Object>();
+				if (IsPlainObject(env, obj)) {
+					if (bound_object) {
+						Fail(ThrowTypeError, env, "You cannot specify named parameters in two different objects");
+						break;
+					}
+					bound_object = true;
+
+					count += BindObject(env, obj, stmt);
+					if (!success) break;
+					continue;
+				} else if (env.IsExceptionPending()) {
+					Fail(NULL, env, NULL);
+					break;
+				} else if (stmt->GetBindMap(env).GetSize()) {
+					Fail(ThrowTypeError, env, "Named parameters can only be passed within plain objects");
+					break;
+				}
+			}
+
+			BindValue(env, 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 @@
+// Caches JavaScript strings that are used frequently as property keys or
+// error codes. Persistent references to strings require Node-API version 10.
+class CS {
+public:
+
+	Napi::String Code(Napi::Env env, int code) {
+		auto element = codes.find(code);
+		if (element != codes.end()) return element->second.Value();
+		return StringFromUtf8(env, (std::string("UNKNOWN_SQLITE_ERROR_") + std::to_string(code)).c_str(), -1);
+	}
+
+	explicit CS(Napi::Env env) {
+		SetString(env, database, "database");
+		SetString(env, reader, "reader");
+		SetString(env, source, "source");
+		SetString(env, memory, "memory");
+		SetString(env, readonly, "readonly");
+		SetString(env, name, "name");
+		SetString(env, next, "next");
+		SetString(env, length, "length");
+		SetString(env, done, "done");
+		SetString(env, value, "value");
+		SetString(env, changes, "changes");
+		SetString(env, lastInsertRowid, "lastInsertRowid");
+		SetString(env, statement, "statement");
+		SetString(env, column, "column");
+		SetString(env, table, "table");
+		SetString(env, type, "type");
+		SetString(env, totalPages, "totalPages");
+		SetString(env, remainingPages, "remainingPages");
+
+		SetCode(env, SQLITE_OK, "SQLITE_OK");
+		SetCode(env, SQLITE_ERROR, "SQLITE_ERROR");
+		SetCode(env, SQLITE_INTERNAL, "SQLITE_INTERNAL");
+		SetCode(env, SQLITE_PERM, "SQLITE_PERM");
+		SetCode(env, SQLITE_ABORT, "SQLITE_ABORT");
+		SetCode(env, SQLITE_BUSY, "SQLITE_BUSY");
+		SetCode(env, SQLITE_LOCKED, "SQLITE_LOCKED");
+		SetCode(env, SQLITE_NOMEM, "SQLITE_NOMEM");
+		SetCode(env, SQLITE_READONLY, "SQLITE_READONLY");
+		SetCode(env, SQLITE_INTERRUPT, "SQLITE_INTERRUPT");
+		SetCode(env, SQLITE_IOERR, "SQLITE_IOERR");
+		SetCode(env, SQLITE_CORRUPT, "SQLITE_CORRUPT");
+		SetCode(env, SQLITE_NOTFOUND, "SQLITE_NOTFOUND");
+		SetCode(env, SQLITE_FULL, "SQLITE_FULL");
+		SetCode(env, SQLITE_CANTOPEN, "SQLITE_CANTOPEN");
+		SetCode(env, SQLITE_PROTOCOL, "SQLITE_PROTOCOL");
+		SetCode(env, SQLITE_EMPTY, "SQLITE_EMPTY");
+		SetCode(env, SQLITE_SCHEMA, "SQLITE_SCHEMA");
+		SetCode(env, SQLITE_TOOBIG, "SQLITE_TOOBIG");
+		SetCode(env, SQLITE_CONSTRAINT, "SQLITE_CONSTRAINT");
+		SetCode(env, SQLITE_MISMATCH, "SQLITE_MISMATCH");
+		SetCode(env, SQLITE_MISUSE, "SQLITE_MISUSE");
+		SetCode(env, SQLITE_NOLFS, "SQLITE_NOLFS");
+		SetCode(env, SQLITE_AUTH, "SQLITE_AUTH");
+		SetCode(env, SQLITE_FORMAT, "SQLITE_FORMAT");
+		SetCode(env, SQLITE_RANGE, "SQLITE_RANGE");
+		SetCode(env, SQLITE_NOTADB, "SQLITE_NOTADB");
+		SetCode(env, SQLITE_NOTICE, "SQLITE_NOTICE");
+		SetCode(env, SQLITE_WARNING, "SQLITE_WARNING");
+		SetCode(env, SQLITE_ROW, "SQLITE_ROW");
+		SetCode(env, SQLITE_DONE, "SQLITE_DONE");
+
+		SetCode(env, SQLITE_ERROR_MISSING_COLLSEQ, "SQLITE_ERROR_MISSING_COLLSEQ");
+		SetCode(env, SQLITE_ERROR_RETRY, "SQLITE_ERROR_RETRY");
+		SetCode(env, SQLITE_ERROR_SNAPSHOT, "SQLITE_ERROR_SNAPSHOT");
+		SetCode(env, SQLITE_IOERR_READ, "SQLITE_IOERR_READ");
+		SetCode(env, SQLITE_IOERR_SHORT_READ, "SQLITE_IOERR_SHORT_READ");
+		SetCode(env, SQLITE_IOERR_WRITE, "SQLITE_IOERR_WRITE");
+		SetCode(env, SQLITE_IOERR_FSYNC, "SQLITE_IOERR_FSYNC");
+		SetCode(env, SQLITE_IOERR_DIR_FSYNC, "SQLITE_IOERR_DIR_FSYNC");
+		SetCode(env, SQLITE_IOERR_TRUNCATE, "SQLITE_IOERR_TRUNCATE");
+		SetCode(env, SQLITE_IOERR_FSTAT, "SQLITE_IOERR_FSTAT");
+		SetCode(env, SQLITE_IOERR_UNLOCK, "SQLITE_IOERR_UNLOCK");
+		SetCode(env, SQLITE_IOERR_RDLOCK, "SQLITE_IOERR_RDLOCK");
+		SetCode(env, SQLITE_IOERR_DELETE, "SQLITE_IOERR_DELETE");
+		SetCode(env, SQLITE_IOERR_BLOCKED, "SQLITE_IOERR_BLOCKED");
+		SetCode(env, SQLITE_IOERR_NOMEM, "SQLITE_IOERR_NOMEM");
+		SetCode(env, SQLITE_IOERR_ACCESS, "SQLITE_IOERR_ACCESS");
+		SetCode(env, SQLITE_IOERR_CHECKRESERVEDLOCK, "SQLITE_IOERR_CHECKRESERVEDLOCK");
+		SetCode(env, SQLITE_IOERR_LOCK, "SQLITE_IOERR_LOCK");
+		SetCode(env, SQLITE_IOERR_CLOSE, "SQLITE_IOERR_CLOSE");
+		SetCode(env, SQLITE_IOERR_DIR_CLOSE, "SQLITE_IOERR_DIR_CLOSE");
+		SetCode(env, SQLITE_IOERR_SHMOPEN, "SQLITE_IOERR_SHMOPEN");
+		SetCode(env, SQLITE_IOERR_SHMSIZE, "SQLITE_IOERR_SHMSIZE");
+		SetCode(env, SQLITE_IOERR_SHMLOCK, "SQLITE_IOERR_SHMLOCK");
+		SetCode(env, SQLITE_IOERR_SHMMAP, "SQLITE_IOERR_SHMMAP");
+		SetCode(env, SQLITE_IOERR_SEEK, "SQLITE_IOERR_SEEK");
+		SetCode(env, SQLITE_IOERR_DELETE_NOENT, "SQLITE_IOERR_DELETE_NOENT");
+		SetCode(env, SQLITE_IOERR_MMAP, "SQLITE_IOERR_MMAP");
+		SetCode(env, SQLITE_IOERR_GETTEMPPATH, "SQLITE_IOERR_GETTEMPPATH");
+		SetCode(env, SQLITE_IOERR_CONVPATH, "SQLITE_IOERR_CONVPATH");
+		SetCode(env, SQLITE_IOERR_VNODE, "SQLITE_IOERR_VNODE");
+		SetCode(env, SQLITE_IOERR_AUTH, "SQLITE_IOERR_AUTH");
+		SetCode(env, SQLITE_IOERR_BEGIN_ATOMIC, "SQLITE_IOERR_BEGIN_ATOMIC");
+		SetCode(env, SQLITE_IOERR_COMMIT_ATOMIC, "SQLITE_IOERR_COMMIT_ATOMIC");
+		SetCode(env, SQLITE_IOERR_ROLLBACK_ATOMIC, "SQLITE_IOERR_ROLLBACK_ATOMIC");
+		SetCode(env, SQLITE_IOERR_DATA, "SQLITE_IOERR_DATA");
+		SetCode(env, SQLITE_IOERR_CORRUPTFS, "SQLITE_IOERR_CORRUPTFS");
+		SetCode(env, SQLITE_IOERR_IN_PAGE, "SQLITE_IOERR_IN_PAGE");
+		SetCode(env, SQLITE_LOCKED_SHAREDCACHE, "SQLITE_LOCKED_SHAREDCACHE");
+		SetCode(env, SQLITE_LOCKED_VTAB, "SQLITE_LOCKED_VTAB");
+		SetCode(env, SQLITE_BUSY_RECOVERY, "SQLITE_BUSY_RECOVERY");
+		SetCode(env, SQLITE_BUSY_SNAPSHOT, "SQLITE_BUSY_SNAPSHOT");
+		SetCode(env, SQLITE_CANTOPEN_NOTEMPDIR, "SQLITE_CANTOPEN_NOTEMPDIR");
+		SetCode(env, SQLITE_CANTOPEN_ISDIR, "SQLITE_CANTOPEN_ISDIR");
+		SetCode(env, SQLITE_CANTOPEN_FULLPATH, "SQLITE_CANTOPEN_FULLPATH");
+		SetCode(env, SQLITE_CANTOPEN_CONVPATH, "SQLITE_CANTOPEN_CONVPATH");
+		SetCode(env, SQLITE_CANTOPEN_DIRTYWAL, "SQLITE_CANTOPEN_DIRTYWAL");
+		SetCode(env, SQLITE_CANTOPEN_SYMLINK, "SQLITE_CANTOPEN_SYMLINK");
+		SetCode(env, SQLITE_CORRUPT_VTAB, "SQLITE_CORRUPT_VTAB");
+		SetCode(env, SQLITE_CORRUPT_SEQUENCE, "SQLITE_CORRUPT_SEQUENCE");
+		SetCode(env, SQLITE_CORRUPT_INDEX, "SQLITE_CORRUPT_INDEX");
+		SetCode(env, SQLITE_READONLY_RECOVERY, "SQLITE_READONLY_RECOVERY");
+		SetCode(env, SQLITE_READONLY_CANTLOCK, "SQLITE_READONLY_CANTLOCK");
+		SetCode(env, SQLITE_READONLY_ROLLBACK, "SQLITE_READONLY_ROLLBACK");
+		SetCode(env, SQLITE_READONLY_DBMOVED, "SQLITE_READONLY_DBMOVED");
+		SetCode(env, SQLITE_READONLY_CANTINIT, "SQLITE_READONLY_CANTINIT");
+		SetCode(env, SQLITE_READONLY_DIRECTORY, "SQLITE_READONLY_DIRECTORY");
+		SetCode(env, SQLITE_ABORT_ROLLBACK, "SQLITE_ABORT_ROLLBACK");
+		SetCode(env, SQLITE_CONSTRAINT_CHECK, "SQLITE_CONSTRAINT_CHECK");
+		SetCode(env, SQLITE_CONSTRAINT_COMMITHOOK, "SQLITE_CONSTRAINT_COMMITHOOK");
+		SetCode(env, SQLITE_CONSTRAINT_FOREIGNKEY, "SQLITE_CONSTRAINT_FOREIGNKEY");
+		SetCode(env, SQLITE_CONSTRAINT_FUNCTION, "SQLITE_CONSTRAINT_FUNCTION");
+		SetCode(env, SQLITE_CONSTRAINT_NOTNULL, "SQLITE_CONSTRAINT_NOTNULL");
+		SetCode(env, SQLITE_CONSTRAINT_PRIMARYKEY, "SQLITE_CONSTRAINT_PRIMARYKEY");
+		SetCode(env, SQLITE_CONSTRAINT_TRIGGER, "SQLITE_CONSTRAINT_TRIGGER");
+		SetCode(env, SQLITE_CONSTRAINT_UNIQUE, "SQLITE_CONSTRAINT_UNIQUE");
+		SetCode(env, SQLITE_CONSTRAINT_VTAB, "SQLITE_CONSTRAINT_VTAB");
+		SetCode(env, SQLITE_CONSTRAINT_ROWID, "SQLITE_CONSTRAINT_ROWID");
+		SetCode(env, SQLITE_CONSTRAINT_PINNED, "SQLITE_CONSTRAINT_PINNED");
+		SetCode(env, SQLITE_CONSTRAINT_DATATYPE, "SQLITE_CONSTRAINT_DATATYPE");
+		SetCode(env, SQLITE_NOTICE_RECOVER_WAL, "SQLITE_NOTICE_RECOVER_WAL");
+		SetCode(env, SQLITE_NOTICE_RECOVER_ROLLBACK, "SQLITE_NOTICE_RECOVER_ROLLBACK");
+		SetCode(env, SQLITE_NOTICE_RBU, "SQLITE_NOTICE_RBU");
+		SetCode(env, SQLITE_WARNING_AUTOINDEX, "SQLITE_WARNING_AUTOINDEX");
+		SetCode(env, SQLITE_AUTH_USER, "SQLITE_AUTH_USER");
+		SetCode(env, SQLITE_OK_LOAD_PERMANENTLY, "SQLITE_OK_LOAD_PERMANENTLY");
+		SetCode(env, SQLITE_OK_SYMLINK, "SQLITE_OK_SYMLINK");
+	}
+
+	Napi::Reference<Napi::String> database;
+	Napi::Reference<Napi::String> reader;
+	Napi::Reference<Napi::String> source;
+	Napi::Reference<Napi::String> memory;
+	Napi::Reference<Napi::String> readonly;
+	Napi::Reference<Napi::String> name;
+	Napi::Reference<Napi::String> next;
+	Napi::Reference<Napi::String> length;
+	Napi::Reference<Napi::String> done;
+	Napi::Reference<Napi::String> value;
+	Napi::Reference<Napi::String> changes;
+	Napi::Reference<Napi::String> lastInsertRowid;
+	Napi::Reference<Napi::String> statement;
+	Napi::Reference<Napi::String> column;
+	Napi::Reference<Napi::String> table;
+	Napi::Reference<Napi::String> type;
+	Napi::Reference<Napi::String> totalPages;
+	Napi::Reference<Napi::String> remainingPages;
+
+private:
+
+	static void SetString(Napi::Env env, Napi::Reference<Napi::String>& constant, const char* str) {
+		constant = Napi::Persistent(InternalizedFromLatin1(env, str));
+	}
+
+	void SetCode(Napi::Env env, int code, const char* str) {
+		codes.emplace(code, Napi::Persistent(InternalizedFromLatin1(env, str)));
+	}
+
+	std::unordered_map<int, Napi::Reference<Napi::String>> codes;
+};

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

@@ -0,0 +1,121 @@
+class CustomAggregate : public CustomFunction {
+public:
+
+	explicit CustomAggregate(
+		Napi::Env env,
+		Database* db,
+		const char* name,
+		Napi::Value start,
+		Napi::Function step,
+		Napi::Value inverse,
+		Napi::Value result,
+		bool safe_ints
+	) :
+		CustomFunction(env, db, name, step, safe_ints),
+		invoke_result(result.IsFunction()),
+		invoke_start(start.IsFunction()),
+		inverse(inverse.IsFunction() ? Napi::Persistent(inverse.As<Napi::Function>()) : Napi::FunctionReference()),
+		result(result.IsFunction() ? Napi::Persistent(result.As<Napi::Function>()) : Napi::FunctionReference()),
+		start(Napi::Persistent(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 Napi::FunctionReference CustomAggregate::*ptrtm) {
+		AGGREGATE_START();
+
+		napi_value args_fast[5];
+		napi_value* args = argc <= 4 ? args_fast : ALLOC_ARRAY<napi_value>(argc + 1);
+		args[0] = acc->value.Value();
+		if (argc != 0) Data::GetArgumentsJS(env, args + 1, argv, argc, self->safe_ints);
+
+		Napi::Value returnValue = SafeCall(env, (self->*ptrtm).Value(), env.Undefined(), argc + 1, args);
+		if (args != args_fast) delete[] args;
+
+		if (env.IsExceptionPending()) {
+			self->PropagateJSError(invocation);
+		} else {
+			if (!returnValue.IsUndefined()) acc->value.Reset(returnValue, 1);
+		}
+	}
+
+	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;
+		}
+
+		Napi::Value result = acc->value.Value();
+		if (self->invoke_result) {
+			napi_value arg = result;
+			Napi::Value maybeResult = SafeCall(env, self->result.Value(), env.Undefined(), 1, &arg);
+			if (env.IsExceptionPending()) {
+				self->PropagateJSError(invocation);
+				return;
+			}
+			result = maybeResult;
+		}
+
+		Data::ResultValueFromJS(env, invocation, result, self);
+		if (is_final) DestroyAccumulator(invocation);
+	}
+
+	struct Accumulator { public:
+		Napi::Reference<Napi::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) {
+				Napi::Value maybeSeed = SafeCall(env, start.Value().As<Napi::Function>(), env.Undefined(), 0, NULL);
+				if (env.IsExceptionPending()) PropagateJSError(invocation);
+				else acc->value.Reset(maybeSeed, 1);
+			} else {
+				assert(!start.IsEmpty());
+				acc->value.Reset(start.Value(), 1);
+			}
+		}
+		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 Napi::FunctionReference inverse;
+	const Napi::FunctionReference result;
+	const Napi::Reference<Napi::Value> start;
+};

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

@@ -0,0 +1,59 @@
+class CustomFunction : protected DataConverter {
+public:
+
+	explicit CustomFunction(
+		Napi::Env env,
+		Database* db,
+		const char* name,
+		Napi::Function fn,
+		bool safe_ints
+	) :
+		name(name),
+		db(db),
+		env(env),
+		fn(Napi::Persistent(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();
+
+		napi_value args_fast[4];
+		napi_value* args = NULL;
+		if (argc != 0) {
+			args = argc <= 4 ? args_fast : ALLOC_ARRAY<napi_value>(argc);
+			Data::GetArgumentsJS(env, args, argv, argc, self->safe_ints);
+		}
+
+		Napi::Value returnValue = SafeCall(env, self->fn.Value(), env.Undefined(), argc, args);
+		if (args != args_fast) delete[] args;
+
+		if (env.IsExceptionPending()) self->PropagateJSError(invocation);
+		else Data::ResultValueFromJS(env, invocation, returnValue, 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:
+	const Napi::Env env;
+	const Napi::FunctionReference fn;
+	const bool safe_ints;
+};