pi-para 0.7.7 → 0.7.9

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

@@ -0,0 +1,190 @@
+inline Napi::String StringFromUtf8(Napi::Env env, const char* data, int length) {
+	if (length < 0) return Napi::String::New(env, data);
+	return Napi::String::New(env, data, length);
+}
+
+// Node-API has no equivalent of V8's internalized strings, so these are simple
+// aliases of StringFromUtf8; the names are kept to preserve the intent of call
+// sites (strings that are used repeatedly as property keys). If Node-API ever
+// gains this functionality, we can easily restore it here.
+inline Napi::String InternalizedFromUtf8(Napi::Env env, const char* data, int length) {
+	return StringFromUtf8(env, data, length);
+}
+
+inline Napi::Value InternalizedFromUtf8OrNull(Napi::Env env, const char* data, int length) {
+	if (data == NULL) return env.Null();
+	return InternalizedFromUtf8(env, data, length);
+}
+
+inline Napi::String InternalizedFromLatin1(Napi::Env env, const char* str) {
+	return Napi::String::New(env, str);
+}
+
+// Replicates the semantics of v8::Value::IsInt32() (an integral number within
+// the range of a 32-bit signed integer, excluding -0), which has no direct
+// Node-API equivalent.
+inline bool IsInt32(Napi::Value value) {
+	if (!value.IsNumber()) return false;
+	double num = value.As<Napi::Number>().DoubleValue();
+	if (!(num >= INT_MIN && num <= INT_MAX)) return false;
+	if (num == 0) return !std::signbit(num);
+	return static_cast<double>(static_cast<int32_t>(num)) == num;
+}
+
+inline void SetFrozen(Napi::Env env, Napi::Object obj, const Napi::Reference<Napi::String>& key, Napi::Value value) {
+	obj.DefineProperty(Napi::PropertyDescriptor::Value(key.Value(), value, napi_enumerable));
+}
+
+// The following helpers perform JavaScript operations that can execute
+// arbitrary user code (functions, proxies, getters). If the user code throws,
+// the exception is left pending in the environment and an empty value is
+// returned. The node-addon-api equivalents (Napi::Function::Call,
+// Napi::Object::Get, etc.) must NOT be used for such operations, because their
+// failure paths re-throw the pending exception through Napi::Error, which
+// aborts the process when the thrown value is null or undefined (a
+// node-addon-api bug, present as of v8.9.0, triggered by Node-API version 10).
+
+inline Napi::Value SafeCall(Napi::Env env, Napi::Function fn, napi_value recv, size_t argc, const napi_value* args) {
+	napi_value result;
+	if (napi_call_function(env, recv, fn, argc, args, &result) != napi_ok) return Napi::Value();
+	return Napi::Value(env, result);
+}
+
+inline Napi::Object SafeConstruct(Napi::Env env, Napi::Function constructor) {
+	napi_value result;
+	if (napi_new_instance(env, constructor, 0, NULL, &result) != napi_ok) return Napi::Object();
+	return Napi::Object(env, result);
+}
+
+inline Napi::Value SafeGet(Napi::Env env, Napi::Object obj, napi_value key) {
+	napi_value result;
+	if (napi_get_property(env, obj, key, &result) != napi_ok) return Napi::Value();
+	return Napi::Value(env, result);
+}
+
+inline Napi::Value SafeGetElement(Napi::Env env, Napi::Object obj, uint32_t index) {
+	napi_value result;
+	if (napi_get_element(env, obj, index, &result) != napi_ok) return Napi::Value();
+	return Napi::Value(env, result);
+}
+
+// Returns false if the check itself failed (leaving an exception pending).
+inline bool SafeHasOwnProperty(Napi::Env env, Napi::Object obj, napi_value key, bool* result) {
+	return napi_has_own_property(env, obj, key, result) == napi_ok;
+}
+
+Napi::Value ThrowError(Napi::Env env, const char* message) {
+	Napi::Error::New(env, message).ThrowAsJavaScriptException();
+	return env.Undefined();
+}
+Napi::Value ThrowTypeError(Napi::Env env, const char* message) {
+	Napi::TypeError::New(env, message).ThrowAsJavaScriptException();
+	return env.Undefined();
+}
+Napi::Value ThrowRangeError(Napi::Env env, const char* message) {
+	Napi::RangeError::New(env, message).ThrowAsJavaScriptException();
+	return env.Undefined();
+}
+
+// Unwraps a native-backed object into its associated C++ instance. This must
+// only be used on values that are already known to be backed by the given
+// class (e.g., a receiver that was validated by TypeSafeCallback below, or a
+// value produced by our own code), because napi_unwrap does not check the
+// object's type. Returns NULL if the environment can no longer run JavaScript
+// (e.g., worker.terminate()), so callers should use UNWRAP_OR_RETURN, which
+// checks for that case.
+template <typename T> inline T* Unwrap(Napi::Value value) {
+	return T::Unwrap(value.As<Napi::Object>());
+}
+
+// Generates a random type tag when the addon is loaded. Type tags must not be
+// hardcoded, because multiple copies (or even different versions) of the addon
+// can be loaded into a single process (see the "nativeBinding" option), and
+// objects created by one copy must not be accepted by another copy's methods,
+// whose class layouts may differ.
+inline napi_type_tag RandomTypeTag() {
+	std::random_device rd;
+	auto random64 = [&rd]() {
+		return (static_cast<uint64_t>(rd()) << 32) | static_cast<uint64_t>(rd());
+	};
+	return { random64(), random64() };
+}
+
+// Determines whether the given value is an object that is backed by the given
+// native class. Each native class is identified by a unique type tag, which
+// gets applied to each of its instances upon construction.
+template <typename T> inline bool IsInstanceOf(Napi::Env env, Napi::Value value) {
+	bool result = false;
+	napi_status status = napi_check_object_type_tag(env, value.As<Napi::Object>(), &T::TYPE_TAG, &result);
+	return status == napi_ok && result;
+}
+
+// Wraps a native method so that it can only be invoked on a receiver that is
+// backed by the expected native class. Node-API has no equivalent of
+// v8::Signature, and napi_unwrap alone does not check the object's type, so
+// without this check, a method borrowed onto a foreign wrapped object (e.g.,
+// db.exec.call(stmt)) would reinterpret the wrapped pointer as the wrong type.
+template <typename T, Napi::Value (*method)(const Napi::CallbackInfo&)>
+napi_value TypeSafeCallback(napi_env env, napi_callback_info info) {
+	Napi::CallbackInfo cbinfo(env, info);
+	if (!IsInstanceOf<T>(env, cbinfo.This())) {
+		Napi::TypeError::New(env, "Illegal invocation").ThrowAsJavaScriptException();
+		return NULL;
+	}
+	return method(cbinfo);
+}
+
+// These match the default attributes of properties created by a V8 template.
+constexpr napi_property_attributes DEFAULT_ATTRIBUTES =
+	static_cast<napi_property_attributes>(napi_writable | napi_enumerable | napi_configurable);
+
+template <typename T, Napi::Value (*method)(const Napi::CallbackInfo&)>
+napi_property_descriptor PrototypeMethod(const char* name, Addon* addon) {
+	napi_property_descriptor desc = {};
+	desc.utf8name = name;
+	desc.method = TypeSafeCallback<T, method>;
+	desc.attributes = DEFAULT_ATTRIBUTES;
+	desc.data = addon;
+	return desc;
+}
+
+template <typename T, Napi::Value (*method)(const Napi::CallbackInfo&)>
+napi_property_descriptor PrototypeSymbolMethod(Napi::Symbol symbol, Addon* addon) {
+	napi_property_descriptor desc = {};
+	desc.name = symbol;
+	desc.method = TypeSafeCallback<T, method>;
+	desc.attributes = DEFAULT_ATTRIBUTES;
+	desc.data = addon;
+	return desc;
+}
+
+// Defines a getter as an own property of the given object. V8 exposed these
+// getters as native data properties on each instance, which made them visible
+// to console.log(); Node-API has no native data properties, so an own accessor
+// property is the closest equivalent (unlike a prototype accessor, it is still
+// displayed by console.log(), albeit as [Getter]).
+template <typename T, Napi::Value (*method)(const Napi::CallbackInfo&)>
+void SetInstanceGetter(Napi::Object obj, const char* name, Addon* addon) {
+	napi_property_descriptor desc = {};
+	desc.utf8name = name;
+	desc.getter = TypeSafeCallback<T, method>;
+	desc.attributes = napi_enumerable;
+	desc.data = addon;
+	napi_status status = napi_define_properties(obj.Env(), obj, 1, &desc);
+	assert(status == napi_ok || status == napi_cannot_run_js); ((void)status);
+}
+
+// Determines whether to skip the given character at the start of an SQL string.
+inline bool IS_SKIPPED(char c) {
+	return c == ' ' || c == ';' || (c >= '\t' && c <= '\r');
+}
+
+// Allocates an empty array, without calling constructors/initializers.
+template<class T> inline T* ALLOC_ARRAY(size_t count) {
+	return static_cast<T*>(::operator new[](count * sizeof(T)));
+}
+
+// Deallocates an array, without calling destructors.
+template<class T> inline void FREE_ARRAY(T* array_pointer) {
+	::operator delete[](array_pointer);
+}

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

@@ -0,0 +1,74 @@
+#define NODE_ARGUMENTS const Napi::CallbackInfo&
+#define NODE_ARGUMENTS_POINTER const Napi::CallbackInfo*
+#define NODE_METHOD(name) Napi::Value name(const Napi::CallbackInfo& info)
+#define NODE_GETTER(name) Napi::Value name(const Napi::CallbackInfo& info)
+#define INIT(name) Napi::Function name(Napi::Env env, Addon* addon)
+
+#define OnlyAddon (static_cast<Addon*>(info.Data()))
+#define UseIsolate Napi::Env env = info.Env()
+#define UseAddon Addon* addon = static_cast<Addon*>(info.Data())
+
+// Type-tag an object, but bail if the thread is terminating, to avoid
+// undesirable side-effects in the subsequent JS_new call (e.g, sqlite3_open()).
+#define TYPE_TAG_CONSTRUCTOR(info)                                             \
+	napi_status status =                                                       \
+		napi_type_tag_object((info).Env(), (info).This(), &TYPE_TAG);          \
+	assert(status == napi_ok || status == napi_cannot_run_js);                 \
+	if (status != napi_ok) return
+
+// Unwrap a native-backed object (see ::Unwrap in helpers.cpp), but bail if the
+// the unwrap fails (which should only happen if the thread is terminating).
+#define UNWRAP_OR_RETURN(T, var, value)                                        \
+	T* var = ::Unwrap<T>(value);                                               \
+	if (var == NULL) return info.Env().Undefined()
+
+#define REQUIRE_ARGUMENT_ANY(at, var)                                          \
+	if (info.Length() <= (at()))                                               \
+		return ThrowTypeError(info.Env(), "Expected a "#at" argument");        \
+	var = info[at()]
+
+#define _REQUIRE_ARGUMENT(at, var, Type, message, ...)                         \
+	if (info.Length() <= (at()) || !info[at()].Is##Type())                     \
+		return ThrowTypeError(info.Env(), "Expected "#at" argument to be "#message); \
+	var = (info[at()].As<Napi::Type>())__VA_ARGS__
+
+#define REQUIRE_ARGUMENT_INT32(at, var)                                        \
+	if (info.Length() <= (at()) || !IsInt32(info[at()]))                       \
+		return ThrowTypeError(info.Env(), "Expected "#at" argument to be a 32-bit signed integer"); \
+	var = info[at()].As<Napi::Number>().Int32Value()
+#define REQUIRE_ARGUMENT_BOOLEAN(at, var)                                      \
+	_REQUIRE_ARGUMENT(at, var, Boolean, a boolean, .Value())
+#define REQUIRE_ARGUMENT_STRING(at, var)                                       \
+	_REQUIRE_ARGUMENT(at, var, String, a string)
+#define REQUIRE_ARGUMENT_OBJECT(at, var)                                       \
+	_REQUIRE_ARGUMENT(at, var, Object, an object)
+#define REQUIRE_ARGUMENT_FUNCTION(at, var)                                     \
+	_REQUIRE_ARGUMENT(at, var, Function, a function)
+
+#define REQUIRE_DATABASE_OPEN(db)                                              \
+	if (!db->open)                                                             \
+		return ThrowTypeError(info.Env(), "The database connection is not open")
+#define REQUIRE_DATABASE_NOT_BUSY(db)                                          \
+	if (db->busy)                                                              \
+		return ThrowTypeError(info.Env(), "This database connection is busy executing a query")
+#define REQUIRE_DATABASE_NO_ITERATORS(db)                                      \
+	if (db->iterators)                                                         \
+		return ThrowTypeError(info.Env(), "This database connection is busy executing a query")
+#define REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db)                        \
+	if (!db->unsafe_mode) {                                                    \
+		REQUIRE_DATABASE_NO_ITERATORS(db);                                     \
+	} ((void)0)
+#define REQUIRE_STATEMENT_NOT_LOCKED(stmt)                                     \
+	if (stmt->locked)                                                          \
+		return ThrowTypeError(info.Env(), "This statement is busy executing a query")
+
+#define first() 0
+#define second() 1
+#define third() 2
+#define fourth() 3
+#define fifth() 4
+#define sixth() 5
+#define seventh() 6
+#define eighth() 7
+#define ninth() 8
+#define tenth() 9

package/node_modules/better-sqlite3/src/util/query-macros.cpp

@@ -0,0 +1,71 @@
+#define STATEMENT_BIND(handle)                                                 \
+	Binder binder(handle);                                                     \
+	if (!binder.Bind(info, info.Length(), stmt)) {                             \
+		sqlite3_clear_bindings(handle);                                        \
+		return info.Env().Undefined();                                         \
+	} ((void)0)
+
+#define STATEMENT_THROW_LOGIC()                                                \
+	db->ThrowDatabaseError(env);                                               \
+	if (!bound) { sqlite3_clear_bindings(handle); }                            \
+	return env.Undefined()
+
+#define STATEMENT_RETURN_LOGIC(return_value)                                   \
+	Napi::Value _return_value = (return_value);                                \
+	if (!bound) { sqlite3_clear_bindings(handle); }                            \
+	return _return_value
+
+#define STATEMENT_START_LOGIC(RETURNS_DATA_CHECK, MUTATE_CHECK)                \
+	UNWRAP_OR_RETURN(Statement, stmt, info.This());                            \
+	RETURNS_DATA_CHECK();                                                      \
+	sqlite3_stmt* handle = stmt->handle;                                       \
+	Database* db = stmt->db;                                                   \
+	REQUIRE_DATABASE_OPEN(db->GetState());                                     \
+	REQUIRE_DATABASE_NOT_BUSY(db->GetState());                                 \
+	MUTATE_CHECK();                                                            \
+	const bool bound = stmt->bound;                                            \
+	if (!bound) {                                                              \
+		STATEMENT_BIND(handle);                                                \
+	} else if (info.Length() > 0) {                                            \
+		return ThrowTypeError(info.Env(), "This statement already has bound parameters"); \
+	} ((void)0)
+
+
+#define STATEMENT_THROW() db->GetState()->busy = false; STATEMENT_THROW_LOGIC()
+#define STATEMENT_RETURN(x) db->GetState()->busy = false; STATEMENT_RETURN_LOGIC(x)
+#define STATEMENT_START(x, y)                                                  \
+	STATEMENT_START_LOGIC(x, y);                                               \
+	db->GetState()->busy = true;                                               \
+	UseIsolate;                                                                \
+	if (db->Log(env, handle)) {                                                \
+		STATEMENT_THROW();                                                     \
+	} ((void)0)
+
+
+#define DOES_NOT_MUTATE() REQUIRE_STATEMENT_NOT_LOCKED(stmt)
+#define DOES_MUTATE()                                                          \
+	REQUIRE_STATEMENT_NOT_LOCKED(stmt);                                        \
+	REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db->GetState())
+#define DOES_ADD_ITERATOR()                                                    \
+	DOES_NOT_MUTATE();                                                         \
+	if (db->GetState()->iterators == USHRT_MAX)                                \
+		return ThrowRangeError(info.Env(), "Too many active database iterators")
+#define REQUIRE_STATEMENT_RETURNS_DATA()                                       \
+	if (!stmt->returns_data)                                                   \
+		return ThrowTypeError(info.Env(), "This statement does not return data. Use run() instead")
+#define ALLOW_ANY_STATEMENT()                                                  \
+	((void)0)
+
+
+#define _FUNCTION_START(type)                                                  \
+	type* self = static_cast<type*>(sqlite3_user_data(invocation));            \
+	Napi::Env env = self->env;                                                 \
+	Napi::HandleScope scope(env)
+
+#define FUNCTION_START()                                                       \
+	_FUNCTION_START(CustomFunction)
+
+#define AGGREGATE_START()                                                      \
+	_FUNCTION_START(CustomAggregate);                                          \
+	Accumulator* acc = self->GetAccumulator(invocation);                       \
+	if (acc->value.IsEmpty()) return

package/node_modules/better-sqlite3/src/util/row-builder.cpp

@@ -0,0 +1,53 @@
+RowBuilder::RowBuilder(
+	Napi::Env env,
+	Napi::Function row_factory,
+	Napi::Function array_factory
+) :
+	row_factory(Napi::Persistent(row_factory)),
+	array_factory(Napi::Persistent(array_factory)),
+	column_count(-1),
+	reprepare_count(-1) {}
+
+Napi::Value RowBuilder::GetRowJS(Napi::Env env, sqlite3_stmt* handle, bool safe_ints) {
+	int current_reprepare_count = sqlite3_stmt_status(handle, SQLITE_STMTSTATUS_REPREPARE, false);
+	if (current_reprepare_count != reprepare_count) {
+		column_count = sqlite3_column_count(handle);
+		std::vector<napi_value> keys(column_count);
+		for (int i = 0; i < column_count; ++i) {
+			keys[i] = InternalizedFromUtf8(env, sqlite3_column_name(handle, i), -1);
+		}
+		create_row = Napi::Persistent(
+			SafeCall(env, row_factory.Value(), env.Undefined(), column_count, keys.data())
+				.As<Napi::Function>()
+		);
+		reprepare_count = current_reprepare_count;
+	}
+
+	napi_value value_storage[16];
+	std::vector<napi_value> extra_values;
+	napi_value* values = value_storage;
+	if (column_count > 16) {
+		extra_values.resize(column_count);
+		values = extra_values.data();
+	}
+	for (int i = 0; i < column_count; ++i) {
+		values[i] = Data::GetValueJS(env, handle, i, safe_ints);
+	}
+
+	return SafeCall(env, create_row.Value(), env.Undefined(), column_count, values);
+}
+
+Napi::Value RowBuilder::GetRawRowJS(Napi::Env env, sqlite3_stmt* handle, bool safe_ints) {
+	column_count = sqlite3_column_count(handle);
+	napi_value arg_storage[16];
+	std::vector<napi_value> extra_args;
+	napi_value* args = arg_storage;
+	if (column_count > 16) {
+		extra_args.resize(column_count);
+		args = extra_args.data();
+	}
+	for (int i = 0; i < column_count; ++i) {
+		args[i] = Data::GetValueJS(env, handle, i, safe_ints);
+	}
+	return SafeCall(env, array_factory.Value(), env.Undefined(), column_count, args);
+}

package/node_modules/better-sqlite3/src/util/row-builder.hpp

@@ -0,0 +1,22 @@
+// Builds row objects efficiently by utilizing a factory function in JS land.
+// The column names are initialized only once and reused for every row/query.
+// The cache is rebuilt if SQLite reparses the statement after a schema change.
+class RowBuilder {
+public:
+
+	explicit RowBuilder(
+		Napi::Env env,
+		Napi::Function row_factory,
+		Napi::Function array_factory
+	);
+
+	Napi::Value GetRowJS(Napi::Env env, sqlite3_stmt* handle, bool safe_ints);
+	Napi::Value GetRawRowJS(Napi::Env env, sqlite3_stmt* handle, bool safe_ints);
+
+private:
+	Napi::FunctionReference row_factory;
+	Napi::FunctionReference create_row;
+	Napi::FunctionReference array_factory;
+	int column_count;
+	int reprepare_count;
+};

package/node_modules/node-addon-api/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 [Node.js API collaborators](https://github.com/nodejs/node-addon-api#collaborators)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/node-addon-api/README.md

@@ -0,0 +1,95 @@
+# **node-addon-api module**
+
+[![codecov](https://codecov.io/gh/nodejs/node-addon-api/branch/main/graph/badge.svg)](https://app.codecov.io/gh/nodejs/node-addon-api/tree/main)
+
+[![NPM](https://nodei.co/npm/node-addon-api.png?downloads=true&downloadRank=true)](https://nodei.co/npm/node-addon-api/) [![NPM](https://nodei.co/npm-dl/node-addon-api.png?months=6&height=1)](https://nodei.co/npm/node-addon-api/)
+
+This module contains  **header-only C++ wrapper classes** which simplify
+the use of the C based [Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)
+provided by Node.js when using C++. It provides a C++ object model
+and exception handling semantics with low overhead.
+
+- [API References](doc/README.md)
+- [Badges](#badges)
+- [Contributing](#contributing)
+- [License](#license)
+
+## API References
+
+API references are available in the [doc](doc/README.md) directory.
+
+<!-- x-release-please-start-version -->
+## Current version: 8.7.0
+<!-- x-release-please-end -->
+
+(See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)
+
+node-addon-api is based on [Node-API](https://nodejs.org/api/n-api.html) and supports using different Node-API versions.
+This allows addons built with it to run with Node.js versions which support the targeted Node-API version.
+**However** the node-addon-api support model is to support only the active LTS Node.js versions. This means that
+every year there will be a new major which drops support for the Node.js LTS version which has gone out of service.
+
+The oldest Node.js version supported by the current version of node-addon-api is Node.js 18.x.
+
+## Badges
+
+The use of badges is recommended to indicate the minimum version of Node-API
+required for the module. This helps to determine which Node.js major versions are
+supported. Addon maintainers can consult the [Node-API support matrix][] to determine
+which Node.js versions provide a given Node-API version. The following badges are
+available:
+
+![Node-API v1 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v1%20Badge.svg)
+![Node-API v2 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v2%20Badge.svg)
+![Node-API v3 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v3%20Badge.svg)
+![Node-API v4 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v4%20Badge.svg)
+![Node-API v5 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v5%20Badge.svg)
+![Node-API v6 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v6%20Badge.svg)
+![Node-API v7 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v7%20Badge.svg)
+![Node-API v8 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v8%20Badge.svg)
+![Node-API v9 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v9%20Badge.svg)
+![Node-API Experimental Version Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20Experimental%20Version%20Badge.svg)
+
+## Contributing
+
+We love contributions from the community to **node-addon-api**!
+See [CONTRIBUTING.md](CONTRIBUTING.md) for more details on our philosophy around extending this module.
+
+## Team members
+
+### Active
+
+| Name                | GitHub Link                                           |
+| ------------------- | ----------------------------------------------------- |
+| Anna Henningsen     | [addaleax](https://github.com/addaleax)               |
+| Chengzhong Wu       | [legendecas](https://github.com/legendecas)           |
+| Jack Xia            | [JckXia](https://github.com/JckXia)                   |
+| Kevin Eady          | [KevinEady](https://github.com/KevinEady)             |
+| Michael Dawson      | [mhdawson](https://github.com/mhdawson)               |
+| Nicola Del Gobbo    | [NickNaso](https://github.com/NickNaso)               |
+| Vladimir Morozov    | [vmoroz](https://github.com/vmoroz)                   |
+
+<details>
+
+<summary>Emeritus</summary>
+
+### Emeritus
+
+| Name                | GitHub Link                                           |
+| ------------------- | ----------------------------------------------------- |
+| Arunesh Chandra     | [aruneshchandra](https://github.com/aruneshchandra)   |
+| Benjamin Byholm     | [kkoopa](https://github.com/kkoopa)                   |
+| Gabriel Schulhof    | [gabrielschulhof](https://github.com/gabrielschulhof) |
+| Hitesh Kanwathirtha | [digitalinfinity](https://github.com/digitalinfinity) |
+| Jason Ginchereau    | [jasongin](https://github.com/jasongin)               |
+| Jim Schlight        | [jschlight](https://github.com/jschlight)             |
+| Sampson Gao         | [sampsongao](https://github.com/sampsongao)           |
+| Taylor Woll         | [boingoing](https://github.com/boingoing)             |
+
+</details>
+
+## License
+
+Licensed under [MIT](./LICENSE.md)
+
+[Node-API support matrix]: https://nodejs.org/dist/latest/docs/api/n-api.html#node-api-version-matrix

package/node_modules/node-addon-api/common.gypi

@@ -0,0 +1,21 @@
+{
+  'variables': {
+    'NAPI_VERSION%': "<!(node -p \"process.env.NAPI_VERSION || process.versions.napi\")",
+    'disable_deprecated': "<!(node -p \"process.env['npm_config_disable_deprecated']\")"
+  },
+  'conditions': [
+    ['NAPI_VERSION!=""', { 'defines': ['NAPI_VERSION=<@(NAPI_VERSION)'] } ],
+    ['NAPI_VERSION==2147483647', { 'defines': ['NAPI_EXPERIMENTAL', 'NODE_API_EXPERIMENTAL_NO_WARNING'] } ],
+    ['disable_deprecated=="true"', {
+      'defines': ['NODE_ADDON_API_DISABLE_DEPRECATED']
+    }],
+    ['OS=="mac"', {
+      'cflags+': ['-fvisibility=hidden'],
+      'xcode_settings': {
+        'OTHER_CFLAGS': ['-fvisibility=hidden']
+      }
+    }]
+  ],
+  'cflags': [ '-Werror', '-Wall', '-Wextra', '-Wpedantic', '-Wunused-parameter' ],
+  'cflags_cc': [ '-Werror', '-Wall', '-Wextra', '-Wpedantic', '-Wunused-parameter' ]
+}

package/node_modules/node-addon-api/except.gypi

@@ -0,0 +1,25 @@
+{
+  'defines': [ 'NAPI_CPP_EXCEPTIONS' ],
+  'cflags!': [ '-fno-exceptions' ],
+  'cflags_cc!': [ '-fno-exceptions' ],
+  'conditions': [
+    ["OS=='win'", {
+      "defines": [
+        "_HAS_EXCEPTIONS=1"
+      ],
+      "msvs_settings": {
+        "VCCLCompilerTool": {
+          "ExceptionHandling": 1,
+          'EnablePREfast': 'true',
+        },
+      },
+    }],
+    ["OS=='mac'", {
+      'xcode_settings': {
+        'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+        'CLANG_CXX_LIBRARY': 'libc++',
+        'MACOSX_DEPLOYMENT_TARGET': '10.7',
+      },
+    }],
+  ],
+}

package/node_modules/node-addon-api/index.js

@@ -0,0 +1,14 @@
+const path = require('path');
+const { version } = require('./package.json');
+
+const includeDir = path.relative('.', __dirname);
+
+module.exports = {
+  include: `"${__dirname}"`, // deprecated, can be removed as part of 4.0.0
+  include_dir: includeDir,
+  gyp: path.join(includeDir, 'node_api.gyp:nothing'), // deprecated.
+  targets: path.join(includeDir, 'node_addon_api.gyp'),
+  version,
+  isNodeApiBuiltin: true,
+  needsFlag: false
+};