koffi 2.12.1 → 2.12.3

package/vendor/node-api-headers/include/node_api.h

@@ -1,11 +1,11 @@
 #ifndef SRC_NODE_API_H_
 #define SRC_NODE_API_H_
 
-#ifdef BUILDING_NODE_EXTENSION
+#if defined(BUILDING_NODE_EXTENSION) && !defined(NAPI_EXTERN)
 #ifdef _WIN32
 // Building native addon against node
 #define NAPI_EXTERN __declspec(dllimport)
-#elif defined(__wasm32__)
+#elif defined(__wasm__)
 #define NAPI_EXTERN __attribute__((__import_module__("napi")))
 #endif
 #endif
@@ -17,8 +17,13 @@ struct uv_loop_s;  // Forward declaration.
 #ifdef _WIN32
 #define NAPI_MODULE_EXPORT __declspec(dllexport)
 #else
+#ifdef __EMSCRIPTEN__
+#define NAPI_MODULE_EXPORT                                                     \
+  __attribute__((visibility("default"))) __attribute__((used))
+#else
 #define NAPI_MODULE_EXPORT __attribute__((visibility("default")))
 #endif
+#endif
 
 #if defined(__GNUC__)
 #define NAPI_NO_RETURN __attribute__((noreturn))
@@ -30,7 +35,7 @@ struct uv_loop_s;  // Forward declaration.
 
 typedef napi_value(NAPI_CDECL* napi_addon_register_func)(napi_env env,
                                                          napi_value exports);
-typedef int32_t(NAPI_CDECL* node_api_addon_get_api_version_func)();
+typedef int32_t(NAPI_CDECL* node_api_addon_get_api_version_func)(void);
 
 // Used by deprecated registration method napi_module_register.
 typedef struct napi_module {
@@ -49,7 +54,7 @@ typedef struct napi_module {
   NAPI_MODULE_INITIALIZER_X_HELPER(base, version)
 #define NAPI_MODULE_INITIALIZER_X_HELPER(base, version) base##version
 
-#ifdef __wasm32__
+#ifdef __wasm__
 #define NAPI_MODULE_INITIALIZER_BASE napi_register_wasm_v
 #else
 #define NAPI_MODULE_INITIALIZER_BASE napi_register_module_v
@@ -66,7 +71,7 @@ typedef struct napi_module {
 
 #define NAPI_MODULE_INIT()                                                     \
   EXTERN_C_START                                                               \
-  NAPI_MODULE_EXPORT int32_t NODE_API_MODULE_GET_API_VERSION() {               \
+  NAPI_MODULE_EXPORT int32_t NODE_API_MODULE_GET_API_VERSION(void) {           \
     return NAPI_VERSION;                                                       \
   }                                                                            \
   NAPI_MODULE_EXPORT napi_value NAPI_MODULE_INITIALIZER(napi_env env,          \
@@ -85,9 +90,6 @@ EXTERN_C_START
 
 // Deprecated. Replaced by symbol-based registration defined by NAPI_MODULE
 // and NAPI_MODULE_INIT macros.
-#if defined(__cplusplus) && __cplusplus >= 201402L
-[[deprecated]]
-#endif
 NAPI_EXTERN void NAPI_CDECL
 napi_module_register(napi_module* mod);
 
@@ -126,10 +128,21 @@ NAPI_EXTERN napi_status NAPI_CDECL
 napi_create_external_buffer(napi_env env,
                             size_t length,
                             void* data,
-                            napi_finalize finalize_cb,
+                            node_api_basic_finalize finalize_cb,
                             void* finalize_hint,
                             napi_value* result);
 #endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+
+#if NAPI_VERSION >= 10
+
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_create_buffer_from_arraybuffer(napi_env env,
+                                        napi_value arraybuffer,
+                                        size_t byte_offset,
+                                        size_t byte_length,
+                                        napi_value* result);
+#endif  // NAPI_VERSION >= 10
+
 NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer_copy(napi_env env,
                                                            size_t length,
                                                            const void* data,
@@ -143,7 +156,6 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_get_buffer_info(napi_env env,
                                                         void** data,
                                                         size_t* length);
 
-#ifndef __wasm32__
 // Methods to manage simple async operations
 NAPI_EXTERN napi_status NAPI_CDECL
 napi_create_async_work(napi_env env,
@@ -155,21 +167,20 @@ napi_create_async_work(napi_env env,
                        napi_async_work* result);
 NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(napi_env env,
                                                           napi_async_work work);
-NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(napi_env env,
+NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(node_api_basic_env env,
                                                          napi_async_work work);
-NAPI_EXTERN napi_status NAPI_CDECL napi_cancel_async_work(napi_env env,
-                                                          napi_async_work work);
-#endif  // __wasm32__
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_cancel_async_work(node_api_basic_env env, napi_async_work work);
 
 // version management
-NAPI_EXTERN napi_status NAPI_CDECL
-napi_get_node_version(napi_env env, const napi_node_version** version);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_node_version(
+    node_api_basic_env env, const napi_node_version** version);
 
 #if NAPI_VERSION >= 2
 
 // Return the current libuv event loop for a given environment
 NAPI_EXTERN napi_status NAPI_CDECL
-napi_get_uv_event_loop(napi_env env, struct uv_loop_s** loop);
+napi_get_uv_event_loop(node_api_basic_env env, struct uv_loop_s** loop);
 
 #endif  // NAPI_VERSION >= 2
 
@@ -178,11 +189,11 @@ napi_get_uv_event_loop(napi_env env, struct uv_loop_s** loop);
 NAPI_EXTERN napi_status NAPI_CDECL napi_fatal_exception(napi_env env,
                                                         napi_value err);
 
-NAPI_EXTERN napi_status NAPI_CDECL
-napi_add_env_cleanup_hook(napi_env env, napi_cleanup_hook fun, void* arg);
+NAPI_EXTERN napi_status NAPI_CDECL napi_add_env_cleanup_hook(
+    node_api_basic_env env, napi_cleanup_hook fun, void* arg);
 
-NAPI_EXTERN napi_status NAPI_CDECL
-napi_remove_env_cleanup_hook(napi_env env, napi_cleanup_hook fun, void* arg);
+NAPI_EXTERN napi_status NAPI_CDECL napi_remove_env_cleanup_hook(
+    node_api_basic_env env, napi_cleanup_hook fun, void* arg);
 
 NAPI_EXTERN napi_status NAPI_CDECL
 napi_open_callback_scope(napi_env env,
@@ -197,7 +208,6 @@ napi_close_callback_scope(napi_env env, napi_callback_scope scope);
 
 #if NAPI_VERSION >= 4
 
-#ifndef __wasm32__
 // Calling into JS from other threads
 NAPI_EXTERN napi_status NAPI_CDECL
 napi_create_threadsafe_function(napi_env env,
@@ -226,19 +236,18 @@ napi_acquire_threadsafe_function(napi_threadsafe_function func);
 NAPI_EXTERN napi_status NAPI_CDECL napi_release_threadsafe_function(
     napi_threadsafe_function func, napi_threadsafe_function_release_mode mode);
 
-NAPI_EXTERN napi_status NAPI_CDECL
-napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func);
+NAPI_EXTERN napi_status NAPI_CDECL napi_unref_threadsafe_function(
+    node_api_basic_env env, napi_threadsafe_function func);
 
-NAPI_EXTERN napi_status NAPI_CDECL
-napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func);
-#endif  // __wasm32__
+NAPI_EXTERN napi_status NAPI_CDECL napi_ref_threadsafe_function(
+    node_api_basic_env env, napi_threadsafe_function func);
 
 #endif  // NAPI_VERSION >= 4
 
 #if NAPI_VERSION >= 8
 
 NAPI_EXTERN napi_status NAPI_CDECL
-napi_add_async_cleanup_hook(napi_env env,
+napi_add_async_cleanup_hook(node_api_basic_env env,
                             napi_async_cleanup_hook hook,
                             void* arg,
                             napi_async_cleanup_hook_handle* remove_handle);
@@ -251,7 +260,7 @@ napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle);
 #if NAPI_VERSION >= 9
 
 NAPI_EXTERN napi_status NAPI_CDECL
-node_api_get_module_file_name(napi_env env, const char** result);
+node_api_get_module_file_name(node_api_basic_env env, const char** result);
 
 #endif  // NAPI_VERSION >= 9
 

package/vendor/node-api-headers/lib/parse-utils.js

@@ -0,0 +1,92 @@
+const parser = require("acorn");
+
+/**
+ * @param {string} text Code to evaluate
+ * @returns {boolean | undefined} The result of the evaluation, `undefined` if
+ * parsing failed or the result is unknown.
+ */
+function evaluate(text) {
+    try {
+        const ast = parser.parse(text, { ecmaVersion: 2020 });
+
+        const expressionStatement = ast.body[0];
+
+        if (expressionStatement.type !== "ExpressionStatement") {
+            throw new Error("Expected an ExpressionStatement");
+        }
+
+        return visitExpression(expressionStatement.expression);
+    } catch {
+        // Return an unknown result if parsing failed
+        return undefined;
+    }
+}
+
+/**
+ * @param {import("acorn").Expression} node
+ */
+const visitExpression = (node) => {
+    if (node.type === "LogicalExpression") {
+        return visitLogicalExpression(node);
+    } else if (node.type === "UnaryExpression") {
+        return visitUnaryExpression(node);
+    } else if (node.type === "CallExpression") {
+        return visitCallExpression(node);
+    } else {
+        throw new Error(`Unknown node type: ${node.type} ${JSON.stringify(node)}`);
+    }
+};
+
+/**
+ * @param {import("acorn").LogicalExpression} node
+ */
+const visitLogicalExpression = (node) => {
+    const left = visitExpression(node.left);
+    const right = visitExpression(node.right);
+
+    if (node.operator === "&&") {
+        // We can shortcircuit regardless of `unknown` if either are false.
+        if (left === false || right === false) {
+            return false;
+        } else if (left === undefined || right === undefined) {
+            return undefined;
+        } else {
+            return left && right;
+        }
+    } else if (node.operator === "||") {
+        if (left === undefined || right === undefined) {
+            return undefined;
+        } else {
+            return left || right;
+        }
+    }
+};
+
+/**
+ * @param {import("acorn").UnaryExpression} node
+ */
+const visitUnaryExpression = (node) => {
+    const argument = visitExpression(node.argument);
+    if (typeof argument === 'boolean') {
+        return !argument;
+    }
+};
+
+/**
+ * @param {import("acorn").CallExpression} node
+ */
+const visitCallExpression = (node) => {
+    const isDefinedExperimentalCall =
+        // is `defined(arg)` call
+        node.callee.type === 'Identifier' && node.callee.name === 'defined' && node.arguments.length == 1
+        // and that arg is `NAPI_EXPERIMENTAL`
+        && node.arguments[0].type === 'Identifier' && node.arguments[0].name === 'NAPI_EXPERIMENTAL';
+
+    if (isDefinedExperimentalCall) {
+        return false;
+    }
+};
+
+module.exports = {
+    evaluate
+};

package/vendor/node-api-headers/package.json

@@ -33,17 +33,16 @@
     }
   ],
   "description": "Node-API headers",
-  "dependencies": {},
-  "devDependencies": {},
+  "devDependencies": {
+    "acorn": "^8.12.1"
+  },
   "directories": {},
   "gypfile": false,
   "homepage": "https://github.com/nodejs/node-api-headers",
-  "keywords": [
-  ],
+  "keywords": [],
   "license": "MIT",
   "main": "index.js",
   "name": "node-api-headers",
-  "optionalDependencies": {},
   "readme": "README.md",
   "repository": {
     "type": "git",
@@ -52,8 +51,9 @@
   "scripts": {
     "update-headers": "node --no-warnings scripts/update-headers.js",
     "write-symbols": "node --no-warnings scripts/write-symbols.js",
-    "write-win32-def": "node --no-warnings scripts/write-win32-def.js"
+    "write-win32-def": "node --no-warnings scripts/write-win32-def.js",
+    "test": "node test/parse-utils.js "
   },
-  "version": "1.1.0",
+  "version": "1.5.0",
   "support": true
 }

package/vendor/node-api-headers/release-please-config.json

@@ -0,0 +1,12 @@
+{
+    "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+    "release-type": "node",
+    "pull-request-title-pattern": "chore: release v${version}",
+    "bootstrap-sha": "9d78c7da25c5f90617600e23d2a8e7a23288f1ae",
+    "packages": {
+        ".": {
+            "include-component-in-tag": false,
+            "changelog-path": "CHANGELOG.md"
+        }
+    }
+}

package/vendor/node-api-headers/scripts/update-headers.js

@@ -6,7 +6,8 @@ const { resolve } = require('path');
 const { parseArgs } = require('util')
 const { createInterface } = require('readline');
 const { inspect } = require('util');
-const { runClang } = require('./clang-utils');
+const { runClang } = require('../lib/clang-utils');
+const { evaluate } = require('../lib/parse-utils');
 
 /**
  * @returns {Promise<string>} Version string, eg. `'v19.6.0'`.
@@ -32,8 +33,11 @@ function removeExperimentals(stream, destination, verbose = false) {
         };
         const rl = createInterface(stream);
 
-        /** @type {Array<'write' | 'ignore'>} */
-        let mode = ['write'];
+        /** @type {Array<'write' | 'ignore' | 'preprocessor'>} */
+        const mode = ['write'];
+
+        /** @type {Array<string>} */
+        const preprocessor = [];
 
         /** @type {Array<string>} */
         const macroStack = [];
@@ -44,6 +48,22 @@ function removeExperimentals(stream, destination, verbose = false) {
         let lineNumber = 0;
         let toWrite = '';
 
+        const handlePreprocessor = (expression) => {
+            const result = evaluate(expression);
+
+            macroStack.push(expression);
+
+            if (result === false) {
+                debug(`Line ${lineNumber} Ignored '${expression}'`);
+                mode.push('ignore');
+                return false;
+            } else {
+                debug(`Line ${lineNumber} Pushed '${expression}'`);
+                mode.push('write');
+                return true;
+            }
+        };
+
         rl.on('line', function lineHandler(line) {
             ++lineNumber;
             if (matches = line.match(/^\s*#if(n)?def\s+([A-Za-z_][A-Za-z0-9_]*)/)) {
@@ -63,14 +83,23 @@ function removeExperimentals(stream, destination, verbose = false) {
                 } else {
                     mode.push('write');
                 }
-
             }
             else if (matches = line.match(/^\s*#if\s+(.+)$/)) {
-                const identifier = matches[1];
-                macroStack.push(identifier);
-                mode.push('write');
+                const expression = matches[1];
+                if (expression.endsWith('\\')) {
+                    if (preprocessor.length) {
+                        reject(new Error(`Unexpected preprocessor continuation on line ${lineNumber}`));
+                        return;
+                    }
+                    preprocessor.push(expression.substring(0, expression.length - 1));
 
-                debug(`Line ${lineNumber} Pushed ${identifier}`);
+                    mode.push('preprocessor');
+                    return;
+                } else {
+                    if (!handlePreprocessor(expression)) {
+                        return;
+                    }
+                }
             }
             else if (line.match(/^#else(?:\s+|$)/)) {
                 const identifier = macroStack[macroStack.length - 1];
@@ -83,7 +112,7 @@ function removeExperimentals(stream, destination, verbose = false) {
                     return;
                 }
 
-                if (identifier === 'NAPI_EXPERIMENTAL') {
+                if (identifier.indexOf('NAPI_EXPERIMENTAL') > -1) {
                     const lastMode = mode[mode.length - 1];
                     mode[mode.length - 1] = (lastMode === 'ignore') ? 'write' : 'ignore';
                     return;
@@ -98,9 +127,10 @@ function removeExperimentals(stream, destination, verbose = false) {
                 if (!identifier) {
                     rl.off('line', lineHandler);
                     reject(new Error(`Macro stack is empty handling #endif on line ${lineNumber}`));
+                    return;
                 }
 
-                if (identifier === 'NAPI_EXPERIMENTAL') {
+                if (identifier.indexOf('NAPI_EXPERIMENTAL') > -1) {
                     return;
                 }
             }
@@ -113,7 +143,28 @@ function removeExperimentals(stream, destination, verbose = false) {
 
             if (mode[mode.length - 1] === 'write') {
                 toWrite += `${line}\n`;
+            } else if (mode[mode.length - 1] === 'preprocessor') {
+                if (!preprocessor) {
+                    reject(new Error(`Preprocessor mode without preprocessor on line ${lineNumber}`));
+                    return;
+                }
+
+                if (line.endsWith('\\')) {
+                    preprocessor.push(line.substring(0, line.length - 1));
+                    return;
+                }
+
+                preprocessor.push(line);
+
+                const expression = preprocessor.join('');
+                preprocessor.length = 0;
+                mode.pop();
+
+                if (!handlePreprocessor(expression)) {
+                    return;
+                }
             }
+
         });
 
         rl.on('close', () => {
@@ -138,7 +189,7 @@ function removeExperimentals(stream, destination, verbose = false) {
  * @param {string} path Path for file to validate with clang.
  */
 async function validateSyntax(path) {
-    try { 
+    try {
         await runClang(['-fsyntax-only', path]);
     } catch (e) {
         throw new Error(`Syntax validation failed for ${path}: ${e}`);
@@ -160,7 +211,7 @@ async function main() {
         },
     });
 
-    console.log(`Update headers from nodejs/node tag ${tag}`);
+    console.log(`feat: update headers from nodejs/node tag ${tag}`);
 
     const files = ['js_native_api_types.h', 'js_native_api.h', 'node_api_types.h', 'node_api.h'];
 

package/vendor/node-api-headers/scripts/write-symbols.js

@@ -2,7 +2,7 @@
 
 const { resolve: resolvePath } = require('path');
 const { writeFile } = require('fs/promises');
-const { runClang } = require('./clang-utils');
+const { runClang } = require('../lib/clang-utils');
 
 /** @typedef {{ js_native_api_symbols: string[]; node_api_symbols: string[]; }} SymbolInfo */
 

package/vendor/node-api-headers/symbols.js

@@ -228,6 +228,21 @@ const v9 = {
     ]
 }
 
+const v10 = {
+    js_native_api_symbols: [
+        ...v9.js_native_api_symbols,
+        'node_api_create_external_string_latin1',
+        'node_api_create_external_string_utf16',
+        'node_api_create_property_key_latin1',
+        'node_api_create_property_key_utf16',
+        'node_api_create_property_key_utf8'
+    ],
+    node_api_symbols: [
+        ...v9.node_api_symbols,
+        'node_api_create_buffer_from_arraybuffer'
+    ]
+}
+
 module.exports = {
     v1,
     v2,
@@ -237,5 +252,6 @@ module.exports = {
     v6,
     v7,
     v8,
-    v9
+    v9,
+    v10
 }

package/vendor/node-api-headers/test/parse-utils.js

@@ -0,0 +1,21 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { evaluate } = require("../lib/parse-utils");
+
+/** @type {Array<[string, boolean | undefined]>} */
+const testCases = [
+    [`defined(NAPI_EXPERIMENTAL)`, false],
+    [`!defined(NAPI_EXPERIMENTAL)`, true],
+    [`defined(NAPI_EXPERIMENTAL) || defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT)`, undefined],
+    [`defined(NAPI_EXPERIMENTAL) && defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT)`, false],
+    [`!defined(NAPI_EXPERIMENTAL) || (defined(NAPI_EXPERIMENTAL) && (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) || defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))`, true],
+    [`NAPI_VERSION >= 9`, undefined],
+    [`!defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900)`, undefined], // parser error on `defined __cplusplus`
+];
+
+for (const [text, expected] of testCases) {
+    test(`${text} -> ${expected}`, (t) => {
+        const result = evaluate(text);
+        assert.strictEqual(result, expected);
+    });
+}

package/doc/flat/flat.css

@@ -1,27 +0,0 @@
-/* Copyright (C) 2024  Niels Martignène <niels.martignene@protonmail.com>
-
-   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. */
-
-@import url('../../../vendor/opensans/OpenSans.css');
-@import url('./reset.css');
-
-@import url('./normal.css');
-@import url('./small.css');
-@import url('./print.css');