Use cpcpplint util

.eslintrc.json

@@ -9,24 +9,6 @@
 	"parserOptions": {
 		"ecmaVersion": 2022
 	},
-	"overrides": [
-		{
-			"files": [
-				"**/*.test.js"
-			],
-			"env": {
-				"jest": true
-			},
-			"plugins": ["jest"],
-			"rules": {
-				"jest/no-disabled-tests": "warn",
-				"jest/no-focused-tests": "error",
-				"jest/no-identical-title": "error",
-				"jest/prefer-to-have-length": "warn",
-				"jest/valid-expect": "error"
-			}
-		}
-	],
 	"env": {
 		"node": true,
 		"es6": true
@@ -80,14 +62,8 @@
 		"linebreak-style": [0],
 		"node/no-missing-require": [0],
 		"no-console": [0],
-		"node/no-unsupported-features/es-builtins": [
-			"error",
-			{ "version": ">=18.12.1" }
-		],
-		"node/no-unsupported-features/node-builtins": [
-			"error",
-			{ "version": ">=18.12.1" }
-		],
+		"node/no-unsupported-features/es-builtins": 0,
+		"node/no-unsupported-features/node-builtins": 0,
 		"func-names": [
 			"error",
 			"never",

.gitattributes

@@ -1 +1 @@
-test/binding.gyp linguist-vendored
+test-addon/binding.gyp linguist-vendored

.github/workflows/cpplint.yml

@@ -0,0 +1,47 @@
+name: Cpplint
+defaults:
+  run:
+    shell: bash
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  eslint:
+    name: Cpplint
+    runs-on: ubuntu-20.04
+
+    steps:
+
+      - name: Fetch Repository
+        uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+
+      - name: Install Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.16.0
+          cache: 'npm'
+
+      - name: Install Modules
+        run: npm ci
+
+      - name: Install Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.12'
+
+      - name: Install Cpplint
+        run: pip install cpplint
+
+      - name: Run Cpplint
+        run: |
+          node -e "require('.').cpcpplint()"
+          cpplint --recursive ./test-addon
+          cpplint --recursive ./include

.github/workflows/eslint.yml

@@ -0,0 +1,36 @@
+name: ESLint
+defaults:
+  run:
+    shell: bash
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  eslint:
+    name: ESLint
+    runs-on: ubuntu-20.04
+
+    steps:
+
+      - name: Fetch Repository
+        uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+
+      - name: Install Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.16.0
+          cache: 'npm'
+
+      - name: Install Modules
+        run: npm ci
+
+      - name: Run ESLint
+        run: npm run eslint

.github/workflows/publish.yml

@@ -21,7 +21,7 @@ jobs:
       - name: Install Node.js
         uses: actions/setup-node@v3
         with:
-          node-version: 18.12.1
+          node-version: 18.16.0
           cache: 'npm'
 
       - name: Get Package Version

.github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: Validate
+name: Test
 defaults:
   run:
     shell: bash
@@ -12,29 +12,6 @@ on:
       - master
 
 jobs:
-  eslint:
-    name: ESLint
-    runs-on: ubuntu-20.04
-
-    steps:
-
-      - name: Fetch Repository
-        uses: actions/checkout@v3
-        with:
-          persist-credentials: false
-
-      - name: Install Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18.12.1
-          cache: 'npm'
-
-      - name: Install Modules
-        run: npm ci
-
-      - name: Run ESLint
-        run: npm run eslint
-
   unit-tests:
     name: Unit Tests
     strategy:
@@ -53,7 +30,7 @@ jobs:
       - name: Install Node.js
         uses: actions/setup-node@v3
         with:
-          node-version: 18.12.1
+          node-version: 18.16.0
           cache: 'npm'
 
       - name: Install Modules

.gitignore

@@ -6,5 +6,4 @@
 .DS_Store
 node_modules/
 test-addon/build/
-doc/jest/
 *.log

.vscode/c_cpp_properties.json

@@ -5,7 +5,7 @@
             "includePath": [
                 "${workspaceFolder}/**",
                 "${LocalAppData}/node-gyp/Cache/16.17.0/include/node",
-                "${LocalAppData}/node-gyp/Cache/18.12.1/include/node"
+                "${LocalAppData}/node-gyp/Cache/18.16.0/include/node"
             ],
             "windowsSdkVersion": "10.0.19041.0",
             "cStandard": "c17",

README.md

@@ -3,10 +3,12 @@
 This is a part of [Node3D](https://github.com/node-3d) project.
 
 [![NPM](https://badge.fury.io/js/addon-tools-raub.svg)](https://badge.fury.io/js/addon-tools-raub)
-[![CodeFactor](https://www.codefactor.io/repository/github/node-3d/addon-tools-raub/badge)](https://www.codefactor.io/repository/github/node-3d/addon-tools-raub)
+[![ESLint](https://github.com/node-3d/addon-tools-raub/actions/workflows/eslint.yml/badge.svg)](https://github.com/node-3d/addon-tools-raub/actions/workflows/eslint.yml)
+[![Test](https://github.com/node-3d/addon-tools-raub/actions/workflows/test.yml/badge.svg)](https://github.com/node-3d/addon-tools-raub/actions/workflows/test.yml)
+[![Cpplint](https://github.com/node-3d/addon-tools-raub/actions/workflows/cpplint.yml/badge.svg)](https://github.com/node-3d/addon-tools-raub/actions/workflows/cpplint.yml)
 
 ```
-npm i addon-tools-raub
+npm i -s addon-tools-raub
 ```
 
 
@@ -65,9 +67,9 @@ See the [TypeScript definitions](/index.d.ts) with comments.
 	the **napi.h** include path won't be a part of the returned string.
 
 
-### Example of `cpbin` usage in **package.json :: scripts**:
+### Example of `cpbin` in **package.json :: scripts**:
 
 ```
-	"build-all": "cd src && node-gyp rebuild -j max --silent && node -e \"require('addon-tools-raub').cpbin('segfault')\" && cd ..",
+	"build": "cd src && node-gyp rebuild -j max --silent && node -e \"require('addon-tools-raub').cpbin('segfault')\" && cd ..",
 	"build-only": "cd src && node-gyp build -j max --silent && node -e \"require('addon-tools-raub').cpbin('segfault')\" && cd ..",
 ```

conf/jest.json

@@ -1,20 +0,0 @@
-{
-    "rootDir": "../",
-    "moduleFileExtensions": [
-        "js",
-        "node"
-    ],
-    "testMatch": [
-        "<rootDir>/**/*.test.js"
-    ],
-    "coverageDirectory": "doc/jest",
-    "coverageReporters": [
-        "lcov"
-    ],
-    "collectCoverageFrom": [
-        "**/*.js",
-        "!**/*.test.js",
-        "!index.js",
-        "!utils.js"
-    ]
-}

include/index.test.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const tools = require('.');
 
 
@@ -9,30 +12,30 @@ describe('AT / include', () => {
 	stringMethods.forEach((name) => {
 		describe(`#${name}()`, () => {
 			it('is a function', () => {
-				expect(typeof tools[name]).toBe('function');
+				assert.strictEqual(typeof tools[name], 'function');
 			});
 			
 			it('returns an object', () => {
-				expect(typeof tools[name]()).toBe('string');
+				assert.strictEqual(typeof tools[name](), 'string');
 			});
 		});
 	});
 	
 	describe('#getPaths()', () => {
 		it('is a function', () => {
-			expect(typeof tools.getPaths).toBe('function');
+			assert.strictEqual(typeof tools.getPaths, 'function');
 		});
 		
 		it('returns an object', () => {
-			expect(typeof tools.getPaths(__dirname)).toBe('object');
+			assert.strictEqual(typeof tools.getPaths(__dirname), 'object');
 		});
 		
 		it('has "include" string', () => {
-			expect(typeof tools.getPaths(__dirname).include).toBe('string');
+			assert.strictEqual(typeof tools.getPaths(__dirname).include, 'string');
 		});
 		
 		it('has "bin" string', () => {
-			expect(typeof tools.getPaths(__dirname).include).toBe('string');
+			assert.strictEqual(typeof tools.getPaths(__dirname).include, 'string');
 		});
 	});
 });

index.d.ts

@@ -1,22 +1,26 @@
-import type { Stats } from 'node:fs';
-import type { Writable } from 'node:stream';
-
-
 declare module "addon-tools-raub" {
+	type Stats = import('node:fs').Stats;
+	type Writable = import('node:stream').Writable;
+	type Readable = import('node:stream').Readable;
+	type WritableOptions = import('node:stream').WritableOptions;
+	
 	/**
-	* Get the internal paths for an addon
-	* Returns a set of platform dependent paths depending on the input dir
-	*/
+	 * Get the internal paths for an addon
+	 *
+	 * Returns a set of platform dependent paths depending on the input dir
+	 */
 	export const getPaths: (dir: string) => Readonly<{
 		/**
-		* Path to binaries
-		* Platform binary directory absolute path for this `dir`
-		*/
+		 * Path to binaries
+		 *
+		 * Platform binary directory absolute path for this `dir`
+		 */
 		bin: string;
 		/**
-		* Path to include
-		* Include directory for this `dir`
-		*/
+		 * Path to include
+		 *
+		 * Include directory for this `dir`
+		 */
 		include: string;
 	}>;
 	
@@ -24,214 +28,334 @@ declare module "addon-tools-raub" {
 	type TPlatformDir = `bin-${TPlatformName}`;
 	
 	/**
-	* Get the platform-specific binary directory name
-	*/
+	 * Get the platform-specific binary directory name
+	 */
 	export const getBin: () => TPlatformDir;
 	
 	/**
-	* Get the platform identifier
-	*/
+	 * Get the platform identifier
+	 */
 	export const getPlatform: () => TPlatformName;
 	
 	/**
-	* Get the include directories for **binding.gyp**
-	* Both 'addon-tools-raub' and 'node-addon-api' include paths.
-	* In binding.gyp: `'<!@(node -p "require(\'addon-tools-raub\').getInclude()")'`
-	*/
+	 * Get the include directories for **binding.gyp**
+	 *
+	 * Both 'addon-tools-raub' and 'node-addon-api' include paths.
+	 * In binding.gyp: `'<!@(node -p "require(\'addon-tools-raub\').getInclude()")'`
+	 */
 	export const getInclude: () => string;
 	
 	/**
-	* Install binaries
-	* Downloads and unpacks the platform specific binary for the calling package.
-	* To use it, create a new script for your package, which may as well be named
-	* **install.js**, with the following content:
-	*
-	* ```
-	* 'use strict';
-	* const { install } = require('addon-tools-raub');
-	* const prefix = 'https://github.com/USER/ADDON-NAME/releases/download';
-	* const tag = '1.0.0';
-	* install(`${prefix}/${tag}`);
-	* ```
-	*
-	* * `prefix` - the constant base part of the download url.
-	* * `tag` - the version-dependent part of the url.
-	*
-	* ```
-	* "scripts": {
-	*   "postinstall": "node install"
-	* },
-	* ```
-	*/
+	 * Install binaries
+	 *
+	 * Downloads and unpacks the platform specific binary for the calling package.
+	 * To use it, create a new script for your package, which may as well be named
+	 * **install.js**, with the following content:
+	 *
+	 * ```
+	 * 'use strict';
+	 * const { install } = require('addon-tools-raub');
+	 * const prefix = 'https://github.com/USER/ADDON-NAME/releases/download';
+	 * const tag = '1.0.0';
+	 * install(`${prefix}/${tag}`);
+	 * ```
+	 *
+	 * * `prefix` - the constant base part of the download url.
+	 * * `tag` - the version-dependent part of the url.
+	 *
+	 * ```
+	 * "scripts": {
+	 *   "postinstall": "node install"
+	 * },
+	 * ```
+	 */
 	export const install: (folder: string) => Promise<boolean>;
 	
 	
 	/**
-	* Copy binary
-	* Copies the addon binary from `src/build/Release` to the platform-specific folder.
-	*
-	* ```
-	* "scripts": {
-	*   * "build": "node-gyp rebuild && node -e \"require('addon-tools-raub').cpbin('ADDON')\""
-	* },
-	* ```
-	*
-	* Here ADDON should be replaced with the name of your addon, without `.node` extension.
-	*/
+	 * Copy binary
+	 *
+	 * Copies the addon binary from `src/build/Release` to the platform-specific folder.
+	 *
+	 * ```
+	 * "scripts": {
+	 *   * "build": "node-gyp rebuild && node -e \"require('addon-tools-raub').cpbin('ADDON')\""
+	 * },
+	 * ```
+	 *
+	 * Here ADDON should be replaced with the name of your addon, without `.node` extension.
+	 */
 	export const cpbin: (name: string) => Promise<void>;
 	
 	
 	/**
-	* Packs binaries into GZIP
-	* Example of `actionPack` usage in **Github Actions**:
-	*
-	* ```
-	* - name: Pack Files
-	* id: pack-files
-	* run: node -e "require('addon-tools-raub').actionPack()" >> $GITHUB_OUTPUT
-	* - name: Store Binaries
-	* uses: softprops/action-gh-release@v1
-	* with:
-	* 	files: ${{ steps.pack-files.outputs.pack }}
-	* ```
-	*/
+	 * Packs binaries into GZIP
+	 *
+	 * Example of `actionPack` usage in **Github Actions**:
+	 *
+	 * ```
+	 * - name: Pack Files
+	 * id: pack-files
+	 * run: node -e "require('addon-tools-raub').actionPack()" >> $GITHUB_OUTPUT
+	 * - name: Store Binaries
+	 * uses: softprops/action-gh-release@v1
+	 * with:
+	 * 	files: ${{ steps.pack-files.outputs.pack }}
+	 * ```
+	 */
 	export const actionPack: () => Promise<void>;
 	
 	
 	/**
-	* Download to memory
-	* Accepts an **URL**, and returns an in-memory file Buffer,
-	* when the file is loaded. Use for small files, as the whole
-	* file will be loaded into memory at once.
-	*
-	* ```
-	* download(srcUrl).then(data => useData(data), err => emit('error', err));
-	* ```
-	* or
-	* ```
-	* const data = await download(srcUrl);
-	* useData(data);
-	* ```
-	*/
+	 * Download to memory
+	 *
+	 * Accepts an **URL**, and returns an in-memory file Buffer,
+	 * when the file is loaded. Use for small files, as the whole
+	 * file will be loaded into memory at once.
+	 *
+	 * ```
+	 * download(srcUrl).then(data => useData(data), err => emit('error', err));
+	 * ```
+	 * or
+	 * ```
+	 * const data = await download(srcUrl);
+	 * useData(data);
+	 * ```
+	 */
 	export const download: (url: string) => Promise<Buffer>;
 	
 	/**
-	* (async) Read a file
-	* Reads a whole file to string, NOT A Buffer
-	*/
+	 * (async) Read a file
+	 *
+	 * Reads a whole file to string, NOT A Buffer
+	 */
 	
 	
+    type ComposeFnParam = (source: any) => void;
 	/**
-	* WritableBuffer
-	* A [Writable](https://nodejs.org/api/stream.html#stream_writable_streams)
-	* stream buffer, that is stored in-memory and can be fully
-	* obtained when writing was finished. It is equivalent to stream-writing
-	* a temporary file and then reading it into a `Buffer`.
-	*/
-	export class WritableBuffer extends Writable {
+	 * WritableBuffer
+	 *
+	 * A [Writable](https://nodejs.org/api/stream.html#stream_writable_streams)
+	 * stream buffer, that is stored in-memory and can be fully
+	 * obtained when writing was finished. It is equivalent to stream-writing
+	 * a temporary file and then reading it into a `Buffer`.
+	 */
+	export class WritableBuffer implements Writable {
 		constructor();
 		/**
-		* Get the downloaded data
-		* Use `stream.get()` to obtain the data when writing was finished
-		*/
+		 * Get the downloaded data
+		 * Use `stream.get()` to obtain the data when writing was finished
+		 */
 		get(): Buffer;
+		
+		// ----------- implements Writable
+		
+        readonly writable: boolean;
+        readonly writableEnded: boolean;
+        readonly writableFinished: boolean;
+        readonly writableHighWaterMark: number;
+        readonly writableLength: number;
+        readonly writableObjectMode: boolean;
+        readonly writableCorked: number;
+        destroyed: boolean;
+        readonly closed: boolean;
+        readonly errored: Error | null;
+        readonly writableNeedDrain: boolean;
+        constructor(opts?: WritableOptions);
+        _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+        _writev?(
+            chunks: Array<{
+                chunk: any;
+                encoding: BufferEncoding;
+            }>,
+            callback: (error?: Error | null) => void,
+        ): void;
+        _construct?(callback: (error?: Error | null) => void): void;
+        _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+        _final(callback: (error?: Error | null) => void): void;
+        write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean;
+        write(chunk: any, encoding: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean;
+        setDefaultEncoding(encoding: BufferEncoding): this;
+        end(cb?: () => void): this;
+        end(chunk: any, cb?: () => void): this;
+        end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
+        cork(): void;
+        uncork(): void;
+        destroy(error?: Error): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "drain", listener: () => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "finish", listener: () => void): this;
+        addListener(event: "pipe", listener: (src: Readable) => void): this;
+        addListener(event: "unpipe", listener: (src: Readable) => void): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        emit(event: "close"): boolean;
+        emit(event: "drain"): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "finish"): boolean;
+        emit(event: "pipe", src: Readable): boolean;
+        emit(event: "unpipe", src: Readable): boolean;
+        emit(event: string | symbol, ...args: any[]): boolean;
+        on(event: "close", listener: () => void): this;
+        on(event: "drain", listener: () => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "finish", listener: () => void): this;
+        on(event: "pipe", listener: (src: Readable) => void): this;
+        on(event: "unpipe", listener: (src: Readable) => void): this;
+        on(event: string | symbol, listener: (...args: any[]) => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "drain", listener: () => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "finish", listener: () => void): this;
+        once(event: "pipe", listener: (src: Readable) => void): this;
+        once(event: "unpipe", listener: (src: Readable) => void): this;
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "drain", listener: () => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "finish", listener: () => void): this;
+        prependListener(event: "pipe", listener: (src: Readable) => void): this;
+        prependListener(event: "unpipe", listener: (src: Readable) => void): this;
+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "drain", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "finish", listener: () => void): this;
+        prependOnceListener(event: "pipe", listener: (src: Readable) => void): this;
+        prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this;
+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        removeListener(event: "close", listener: () => void): this;
+        removeListener(event: "drain", listener: () => void): this;
+        removeListener(event: "error", listener: (err: Error) => void): this;
+        removeListener(event: "finish", listener: () => void): this;
+        removeListener(event: "pipe", listener: (src: Readable) => void): this;
+        removeListener(event: "unpipe", listener: (src: Readable) => void): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+        pipe<T extends NodeJS.WritableStream>(
+            destination: T,
+            options?: {
+                end?: boolean | undefined;
+            },
+        ): T;
+        compose<T extends NodeJS.ReadableStream>(
+            stream: T | ComposeFnParam | Iterable<T> | AsyncIterable<T>,
+            options?: { signal: AbortSignal },
+        ): T;
+		off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+		removeAllListeners(event?: string | symbol): this;
+		setMaxListeners(n: number): this;
+		getMaxListeners(): number;
+		listeners(eventName: string | symbol): Function[];
+		rawListeners(eventName: string | symbol): Function[];
+		emit(eventName: string | symbol, ...args: any[]): boolean;
+		listenerCount(eventName: string | symbol, listener?: Function): number;
+		eventNames(): Array<string | symbol>;
 	}
 	
 	
 	export const read: (name: string) => Promise<string>;
 	
 	/**
-	* (async) Write a file
-	*/
+	 * (async) Write a file
+	 */
 	export const write: (name: string, text: string) => Promise<void>;
 	
 	/**
-	* (async) Copy a file
-	*/
+	 * (async) Copy a file
+	 */
 	export const copy: (src: string, dest: string) => Promise<void>;
 	
 	/**
-	* (async) Check if a file/folder exists
-	*/
+	 * (async) Check if a file/folder exists
+	 */
 	export const exists: (name: string) => Promise<boolean>;
 	
 	/**
-	* (async) Create an empty folder
-	*/
+	 * (async) Create an empty folder
+	 */
 	export const mkdir: (name: string) => Promise<void>;
 	
 	/**
-	* (async) Get status on a file
-	*/
+	 * (async) Get status on a file
+	 */
 	export const stat: (name: string) => Promise<Stats>;
 	
 	/**
-	* (async) Check if the path is a folder
-	*/
+	 * (async) Check if the path is a folder
+	 */
 	export const isDir: (name: string) => Promise<boolean>;
 	
 	/**
-	* (async) Check if the path is a file
-	*/
+	 * (async) Check if the path is a file
+	 */
 	export const isFile: (name: string) => Promise<boolean>;
 	
 	/**
-	* Cut the path one folder up
-	*/
+	 * Cut the path one folder up
+	 */
 	export const dirUp: (dir: string) => string;
 	
 	/**
-	* (async) Create a directory
-	* Like `mkdir -p`, makes sure a directory exists
-	*/
+	 * (async) Create a directory
+	 *
+	 * Like `mkdir -p`, makes sure a directory exists
+	 */
 	export const ensuredir: (dir: string) => Promise<void>;
 	
 	/**
-	* (async) Copy a file
-	* Copy a file, `dest` folder is created if needed
-	*/
+	 * (async) Copy a file
+	 *
+	 * Copy a file, `dest` folder is created if needed
+	 */
 	export const copysafe: (src: string, dest: string) => Promise<void>;
 	
 	/**
-	* (async) Read a directory
-	* Get file/folder names of the 1st level
-	*/
+	 * (async) Read a directory
+	 *
+	 * Get file/folder names of the 1st level
+	 */
 	export const readdir: (src: string, dest: string) => Promise<ReadonlyArray<string>>;
 	
 	/**
-	* (async) List subdirectories
-	* Get folder paths (concatenated with input) of the 1st level
-	*/
+	 * (async) List subdirectories
+	 *
+	 * Get folder paths (concatenated with input) of the 1st level
+	 */
 	export const subdirs: (name: string) => Promise<ReadonlyArray<string>>;
 	
 	/**
-	* (async) List nested files
-	* Get file paths (concatenated with input) of the 1st level
-	*/
+	 * (async) List nested files
+	 *
+	 * Get file paths (concatenated with input) of the 1st level
+	 */
 	export const subfiles: (name: string) => Promise<ReadonlyArray<string>>;
 	
 	/**
-	* (async) Get all nested files recursively
-	* Folder paths are omitted by default.
-	* Order is: shallow-to-deep, each subdirectory lists dirs-then-files.
-	*/
+	 * (async) Get all nested files recursively
+	 *
+	 * Folder paths are omitted by default.
+	 * Order is: shallow-to-deep, each subdirectory lists dirs-then-files.
+	 */
 	export const traverse: (name: string, showDirs?: boolean) => Promise<ReadonlyArray<string>>;
 	
 	/**
-	* (async) Copy a directory
-	* Copy a folder with all the contained files
-	*/
+	 * (async) Copy a directory
+	 *
+	 * Copy a folder with all the contained files
+	 */
 	export const copyall: (src: string, dest: string) => Promise<void>;
 	
 	/**
-	* (async) Remove a directory
-	* Like `rm -rf`, removes everything recursively
-	*/
+	 * (async) Remove a directory
+	 *
+	 * Like `rm -rf`, removes everything recursively
+	 */
 	export const rmdir: (name: string) => Promise<void>;
 	
 	/**
-	* (async) Remove a file
-	* Must be a file, not a folder. Just `fs.unlink`.
-	*/
+	 * (async) Remove a file
+	 *
+	 * Must be a file, not a folder. Just `fs.unlink`.
+	 */
 	export const rm: (name: string) => Promise<void>;
 }

package.json

@@ -1,7 +1,7 @@
 {
 	"author": "Luis Blanco <luisblanco1337@gmail.com>",
 	"name": "addon-tools-raub",
-	"version": "7.2.1",
+	"version": "7.4.0",
 	"description": "Helpers for Node.js addons and dependency packages",
 	"license": "MIT",
 	"main": "index.js",
@@ -34,9 +34,8 @@
 	},
 	"scripts": {
 		"eslint": "eslint .",
-		"test": "jest --coverage=false --watch --config=conf/jest.json",
-		"test-ci": "jest --ci --runInBand --coverage=false --forceExit --detectOpenHandles --config=conf/jest.json",
-		"test-coverage": "rm -rf doc/jest && jest --coverage --silent --config=conf/jest.json",
+		"test": "node --test --watch .",
+		"test-ci": "node --test",
 		"build-test": "cd test-addon && node-gyp rebuild -j max --silent && cd .."
 	},
 	"repository": {
@@ -44,17 +43,18 @@
 		"url": "https://github.com/node-3d/addon-tools-raub.git"
 	},
 	"peerDependencies": {
-		"node-addon-api": "^6.1.0"
+		"node-addon-api": "^7.0.0"
 	},
 	"peerDependenciesMeta": {
-		"node-addon-api": { "optional": true }
+		"node-addon-api": {
+			"optional": true
+		}
 	},
 	"devDependencies": {
-		"eslint-plugin-jest": "^27.2.1",
+		"@types/node": "^20.8.3",
+		"eslint": "^8.51.0",
 		"eslint-plugin-node": "^11.1.0",
-		"eslint": "^8.40.0",
-		"jest": "^29.5.0",
-		"node-addon-api": "^6.1.0",
-		"typescript": "^5.0.4"
+		"node-addon-api": "^7.0.0",
+		"typescript": "^5.2.2"
 	}
 }

test-addon/hpp-arg-array-str.test.js

@@ -1,42 +1,45 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const arrayArgMsg = 'Argument 0 must be of type `Array`';
+const arrayArgLetMsg = { message: 'Argument 0 must be of type `Array` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / LET_ARRAY_ARG', () => {
+describe('AT / HPP / LET_ARRAY_ARG', () => {
 	it('exports letArrayStrArg', () => {
-		expect(typeof test.letArrayStrArg).toBe('function');
+		assert.strictEqual(typeof test.letArrayStrArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letArrayStrArg('1')).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayStrArg('1'), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letArrayStrArg(1)).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayStrArg(1), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letArrayStrArg(true)).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayStrArg(true), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.letArrayStrArg(test.retExt())).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayStrArg(test.retExt()), arrayArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letArrayStrArg({})).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayStrArg({}), arrayArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(Array.isArray(test.letArrayStrArg())).toBe(true);
+		assert.ok(Array.isArray(test.letArrayStrArg()));
 	});
 	it('accepts undefined', () => {
-		expect(Array.isArray(test.letArrayStrArg(undefined))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayStrArg(undefined)));
 	});
 	it('accepts null', () => {
-		expect(Array.isArray(test.letArrayStrArg(null))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayStrArg(null)));
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.letArrayStrArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayStrArg([])));
 	});
 	it('returns same array', () => {
-		expect(test.letArrayStrArg(['a', 'b'])).toEqual(['a', 'b']);
+		assert.deepStrictEqual(test.letArrayStrArg(['a', 'b']),['a', 'b']);
 	});
 });

test-addon/hpp-arg-array.test.js

@@ -1,105 +1,109 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const arrayArgMsg = 'Argument 0 must be of type `Array`';
+const arrayArgMsg = { message: 'Argument 0 must be of type `Array`' };
+const arrayArgLetMsg = { message: 'Argument 0 must be of type `Array` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_ARRAY_ARG', () => {
+describe('AT / HPP / REQ_ARRAY_ARG', () => {
 	it('exports reqArrayArg', () => {
-		expect(typeof test.reqArrayArg).toBe('function');
+		assert.strictEqual(typeof test.reqArrayArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqArrayArg()).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(), arrayArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqArrayArg(undefined)).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(undefined), arrayArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqArrayArg(null)).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(null), arrayArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqArrayArg('1')).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg('1'), arrayArgMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.reqArrayArg(1)).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(1), arrayArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqArrayArg(true)).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(true), arrayArgMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.reqArrayArg(test.retExt())).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg(test.retExt()), arrayArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqArrayArg({})).toThrow(arrayArgMsg);
+		assert.throws(() => test.reqArrayArg({}), arrayArgMsg);
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.reqArrayArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.reqArrayArg([])));
 	});
 });
 
 describe('addon-tools.hpp: LET_ARRAY_ARG', () => {
 	it('exports letArrayArg', () => {
-		expect(typeof test.letArrayArg).toBe('function');
+		assert.strictEqual(typeof test.letArrayArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letArrayArg('1')).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayArg('1'), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letArrayArg(1)).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayArg(1), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letArrayArg(true)).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayArg(true), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.letArrayArg(test.retExt())).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayArg(test.retExt()), arrayArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letArrayArg({})).toThrow(arrayArgMsg);
+		assert.throws(() => test.letArrayArg({}), arrayArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(Array.isArray(test.letArrayArg())).toBe(true);
+		assert.ok(Array.isArray(test.letArrayArg()));
 	});
 	it('accepts undefined', () => {
-		expect(Array.isArray(test.letArrayArg(undefined))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayArg(undefined)));
 	});
 	it('accepts null', () => {
-		expect(Array.isArray(test.letArrayArg(null))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayArg(null)));
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.letArrayArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.letArrayArg([])));
 	});
 });
 
 describe('addon-tools.hpp: USE_ARRAY_ARG', () => {
 	it('exports useArrayArg', () => {
-		expect(typeof test.useArrayArg).toBe('function');
+		assert.strictEqual(typeof test.useArrayArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useArrayArg('1')).toThrow(arrayArgMsg);
+		assert.throws(() => test.useArrayArg('1'), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.useArrayArg(1)).toThrow(arrayArgMsg);
+		assert.throws(() => test.useArrayArg(1), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useArrayArg(true)).toThrow(arrayArgMsg);
+		assert.throws(() => test.useArrayArg(true), arrayArgLetMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.useArrayArg(test.retExt())).toThrow(arrayArgMsg);
+		assert.throws(() => test.useArrayArg(test.retExt()), arrayArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useArrayArg({})).toThrow(arrayArgMsg);
+		assert.throws(() => test.useArrayArg({}), arrayArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(Array.isArray(test.useArrayArg())).toBe(true);
+		assert.ok(Array.isArray(test.useArrayArg()));
 	});
 	it('accepts undefined', () => {
-		expect(Array.isArray(test.useArrayArg(undefined))).toBe(true);
+		assert.ok(Array.isArray(test.useArrayArg(undefined)));
 	});
 	it('accepts null', () => {
-		expect(Array.isArray(test.useArrayArg(null))).toBe(true);
+		assert.ok(Array.isArray(test.useArrayArg(null)));
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.useArrayArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.useArrayArg([])));
 	});
 });

test-addon/hpp-arg-bool.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const boolArgMsg = 'Argument 0 must be of type `Bool`';
+const boolArgMsg = { message: 'Argument 0 must be of type `Bool`' };
+const boolArgLetMsg = { message: 'Argument 0 must be of type `Bool` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_BOOL_ARG', () => {
+describe('AT / HPP / REQ_BOOL_ARG', () => {
 	it('exports reqBoolArg', () => {
-		expect(typeof test.reqBoolArg).toBe('function');
+		assert.strictEqual(typeof test.reqBoolArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqBoolArg()).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg(), boolArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqBoolArg(undefined)).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg(undefined), boolArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqBoolArg(null)).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg(null), boolArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqBoolArg('1')).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg('1'), boolArgMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.reqBoolArg(1)).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg(1), boolArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqBoolArg({})).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg({}), boolArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqBoolArg([])).toThrow(boolArgMsg);
+		assert.throws(() => test.reqBoolArg([]), boolArgMsg);
 	});
 	it('accepts a boolean', () => {
-		expect(test.reqBoolArg(true)).toEqual(true);
+		assert.ok(test.reqBoolArg(true));
 	});
 });
 
 describe('addon-tools.hpp: LET_BOOL_ARG', () => {
 	it('exports letBoolArg', () => {
-		expect(typeof test.letBoolArg).toBe('function');
+		assert.strictEqual(typeof test.letBoolArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letBoolArg('1')).toThrow(boolArgMsg);
+		assert.throws(() => test.letBoolArg('1'), boolArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letBoolArg(1)).toThrow(boolArgMsg);
+		assert.throws(() => test.letBoolArg(1), boolArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letBoolArg({})).toThrow(boolArgMsg);
+		assert.throws(() => test.letBoolArg({}), boolArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letBoolArg([])).toThrow(boolArgMsg);
+		assert.throws(() => test.letBoolArg([]), boolArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letBoolArg()).toEqual(false);
+		assert.strictEqual(test.letBoolArg(), false);
 	});
 	it('accepts undefined', () => {
-		expect(test.letBoolArg(undefined)).toEqual(false);
+		assert.strictEqual(test.letBoolArg(undefined), false);
 	});
 	it('accepts null', () => {
-		expect(test.letBoolArg(null)).toEqual(false);
+		assert.strictEqual(test.letBoolArg(null), false);
 	});
 	it('accepts a boolean', () => {
-		expect(test.letBoolArg(true)).toEqual(true);
+		assert.ok(test.letBoolArg(true));
 	});
 });
 
 describe('addon-tools.hpp: USE_BOOL_ARG', () => {
 	it('exports useBoolArg', () => {
-		expect(typeof test.useBoolArg).toBe('function');
+		assert.strictEqual(typeof test.useBoolArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useBoolArg('1')).toThrow(boolArgMsg);
+		assert.throws(() => test.useBoolArg('1'), boolArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.useBoolArg(1)).toThrow(boolArgMsg);
+		assert.throws(() => test.useBoolArg(1), boolArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useBoolArg({})).toThrow(boolArgMsg);
+		assert.throws(() => test.useBoolArg({}), boolArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useBoolArg([])).toThrow(boolArgMsg);
+		assert.throws(() => test.useBoolArg([]), boolArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useBoolArg()).toEqual(true);
+		assert.ok(test.useBoolArg());
 	});
 	it('accepts undefined', () => {
-		expect(test.useBoolArg(undefined)).toEqual(true);
+		assert.ok(test.useBoolArg(undefined));
 	});
 	it('accepts null', () => {
-		expect(test.useBoolArg(null)).toEqual(true);
+		assert.ok(test.useBoolArg(null));
 	});
 	it('accepts a boolean', () => {
-		expect(test.useBoolArg(true)).toEqual(true);
+		assert.ok(test.useBoolArg(true));
 	});
 });

test-addon/hpp-arg-double.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const numArgMsg = 'Argument 0 must be of type `Number`';
+const numArgMsg = { message: 'Argument 0 must be of type `Number`' };
+const numArgLetMsg = { message: 'Argument 0 must be of type `Number` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_DOUBLE_ARG', () => {
+describe('AT / HPP / REQ_DOUBLE_ARG', () => {
 	it('exports reqDoubleArg', () => {
-		expect(typeof test.reqDoubleArg).toBe('function');
+		assert.strictEqual(typeof test.reqDoubleArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqDoubleArg()).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg(), numArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqDoubleArg(undefined)).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg(undefined), numArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqDoubleArg(null)).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg(null), numArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqDoubleArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg('1'), numArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqDoubleArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg(true), numArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqDoubleArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg({}), numArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqDoubleArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.reqDoubleArg([]), numArgMsg);
 	});
 	it('accepts a number', () => {
-		expect(test.reqDoubleArg(55)).toEqual(55);
+		assert.strictEqual(test.reqDoubleArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: LET_DOUBLE_ARG', () => {
 	it('exports letDoubleArg', () => {
-		expect(typeof test.letDoubleArg).toBe('function');
+		assert.strictEqual(typeof test.letDoubleArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letDoubleArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.letDoubleArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letDoubleArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.letDoubleArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letDoubleArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.letDoubleArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letDoubleArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.letDoubleArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letDoubleArg()).toEqual(0);
+		assert.strictEqual(test.letDoubleArg(), 0);
 	});
 	it('accepts undefined', () => {
-		expect(test.letDoubleArg(undefined)).toEqual(0);
+		assert.strictEqual(test.letDoubleArg(undefined), 0);
 	});
 	it('accepts null', () => {
-		expect(test.letDoubleArg(null)).toEqual(0);
+		assert.strictEqual(test.letDoubleArg(null), 0);
 	});
 	it('accepts a number', () => {
-		expect(test.letDoubleArg(55)).toEqual(55);
+		assert.strictEqual(test.letDoubleArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: USE_DOUBLE_ARG', () => {
 	it('exports useDoubleArg', () => {
-		expect(typeof test.useDoubleArg).toBe('function');
+		assert.strictEqual(typeof test.useDoubleArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useDoubleArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.useDoubleArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useDoubleArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.useDoubleArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useDoubleArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.useDoubleArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useDoubleArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.useDoubleArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useDoubleArg()).toEqual(10);
+		assert.strictEqual(test.useDoubleArg(), 10);
 	});
 	it('accepts undefined', () => {
-		expect(test.useDoubleArg(undefined)).toEqual(10);
+		assert.strictEqual(test.useDoubleArg(undefined), 10);
 	});
 	it('accepts null', () => {
-		expect(test.useDoubleArg(null)).toEqual(10);
+		assert.strictEqual(test.useDoubleArg(null), 10);
 	});
 	it('accepts a number', () => {
-		expect(test.useDoubleArg(55)).toEqual(55);
+		assert.strictEqual(test.useDoubleArg(55), 55);
 	});
 });

test-addon/hpp-arg-ext.test.js

@@ -1,105 +1,109 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const extArgMsg = 'Argument 0 must be of type `Pointer`';
+const extArgMsg = { message: 'Argument 0 must be of type `Pointer`' };
+const extArgLetMsg = { message: 'Argument 0 must be of type `Pointer` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_EXT_ARG', () => {
+describe('AT / HPP / REQ_EXT_ARG', () => {
 	it('exports reqExtArg', () => {
-		expect(typeof test.reqExtArg).toBe('function');
+		assert.strictEqual(typeof test.reqExtArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqExtArg()).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg(), extArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqExtArg(undefined)).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg(undefined), extArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqExtArg(null)).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg(null), extArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqExtArg('1')).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg('1'), extArgMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.reqExtArg(1)).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg(1), extArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqExtArg(true)).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg(true), extArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqExtArg({})).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg({}), extArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqExtArg([])).toThrow(extArgMsg);
+		assert.throws(() => test.reqExtArg([]), extArgMsg);
 	});
 	it('accepts a pointer', () => {
-		expect(typeof test.reqExtArg(test.retExt())).toBe('object');
+		assert.strictEqual(typeof test.reqExtArg(test.retExt()), 'object');
 	});
 });
 
 describe('addon-tools.hpp: LET_EXT_ARG', () => {
 	it('exports letExtArg', () => {
-		expect(typeof test.letExtArg).toBe('function');
+		assert.strictEqual(typeof test.letExtArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letExtArg('1')).toThrow(extArgMsg);
+		assert.throws(() => test.letExtArg('1'), extArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letExtArg(1)).toThrow(extArgMsg);
+		assert.throws(() => test.letExtArg(1), extArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letExtArg(true)).toThrow(extArgMsg);
+		assert.throws(() => test.letExtArg(true), extArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letExtArg({})).toThrow(extArgMsg);
+		assert.throws(() => test.letExtArg({}), extArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letExtArg([])).toThrow(extArgMsg);
+		assert.throws(() => test.letExtArg([]), extArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(typeof test.letExtArg()).toBe('object');
+		assert.strictEqual(typeof test.letExtArg(), 'object');
 	});
 	it('accepts undefined', () => {
-		expect(typeof test.letExtArg(undefined)).toBe('object');
+		assert.strictEqual(typeof test.letExtArg(undefined), 'object');
 	});
 	it('accepts null', () => {
-		expect(typeof test.letExtArg(null)).toBe('object');
+		assert.strictEqual(typeof test.letExtArg(null), 'object');
 	});
 	it('accepts a pointer', () => {
-		expect(typeof test.reqExtArg(test.retExt())).toBe('object');
+		assert.strictEqual(typeof test.reqExtArg(test.retExt()), 'object');
 	});
 });
 
 describe('addon-tools.hpp: USE_EXT_ARG', () => {
 	it('exports useExtArg', () => {
-		expect(typeof test.useExtArg).toBe('function');
+		assert.strictEqual(typeof test.useExtArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useExtArg('1')).toThrow(extArgMsg);
+		assert.throws(() => test.useExtArg('1'), extArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.useExtArg(1)).toThrow(extArgMsg);
+		assert.throws(() => test.useExtArg(1), extArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useExtArg(true)).toThrow(extArgMsg);
+		assert.throws(() => test.useExtArg(true), extArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useExtArg({})).toThrow(extArgMsg);
+		assert.throws(() => test.useExtArg({}), extArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useExtArg([])).toThrow(extArgMsg);
+		assert.throws(() => test.useExtArg([]), extArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(typeof test.useExtArg()).toBe('object');
+		assert.strictEqual(typeof test.useExtArg(), 'object');
 	});
 	it('accepts undefined', () => {
-		expect(typeof test.useExtArg(undefined)).toBe('object');
+		assert.strictEqual(typeof test.useExtArg(undefined), 'object');
 	});
 	it('accepts null', () => {
-		expect(typeof test.useExtArg(null)).toBe('object');
+		assert.strictEqual(typeof test.useExtArg(null), 'object');
 	});
 	it('accepts a number', () => {
-		expect(typeof test.useExtArg(test.retExt())).toBe('object');
+		assert.strictEqual(typeof test.useExtArg(test.retExt()), 'object');
 	});
 });

test-addon/hpp-arg-float.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const numArgMsg = 'Argument 0 must be of type `Number`';
+const numArgMsg = { message: 'Argument 0 must be of type `Number`' };
+const numArgLetMsg = { message: 'Argument 0 must be of type `Number` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_FLOAT_ARG', () => {
+describe('AT / HPP / REQ_FLOAT_ARG', () => {
 	it('exports reqFloatArg', () => {
-		expect(typeof test.reqFloatArg).toBe('function');
+		assert.strictEqual(typeof test.reqFloatArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqFloatArg()).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg(), numArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqFloatArg(undefined)).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg(undefined), numArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqFloatArg(null)).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg(null), numArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqFloatArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg('1'), numArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqFloatArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg(true), numArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqFloatArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg({}), numArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqFloatArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.reqFloatArg([]), numArgMsg);
 	});
 	it('accepts a number', () => {
-		expect(test.reqFloatArg(55)).toEqual(55);
+		assert.strictEqual(test.reqFloatArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: LET_FLOAT_ARG', () => {
 	it('exports letFloatArg', () => {
-		expect(typeof test.letFloatArg).toBe('function');
+		assert.strictEqual(typeof test.letFloatArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letFloatArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.letFloatArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letFloatArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.letFloatArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letFloatArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.letFloatArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letFloatArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.letFloatArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letFloatArg()).toEqual(0);
+		assert.strictEqual(test.letFloatArg(), 0);
 	});
 	it('accepts undefined', () => {
-		expect(test.letFloatArg(undefined)).toEqual(0);
+		assert.strictEqual(test.letFloatArg(undefined), 0);
 	});
 	it('accepts null', () => {
-		expect(test.letFloatArg(null)).toEqual(0);
+		assert.strictEqual(test.letFloatArg(null), 0);
 	});
 	it('accepts a number', () => {
-		expect(test.letFloatArg(55)).toEqual(55);
+		assert.strictEqual(test.letFloatArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: USE_FLOAT_ARG', () => {
 	it('exports useFloatArg', () => {
-		expect(typeof test.useFloatArg).toBe('function');
+		assert.strictEqual(typeof test.useFloatArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useFloatArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.useFloatArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useFloatArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.useFloatArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useFloatArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.useFloatArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useFloatArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.useFloatArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useFloatArg()).toEqual(10);
+		assert.strictEqual(test.useFloatArg(), 10);
 	});
 	it('accepts undefined', () => {
-		expect(test.useFloatArg(undefined)).toEqual(10);
+		assert.strictEqual(test.useFloatArg(undefined), 10);
 	});
 	it('accepts null', () => {
-		expect(test.useFloatArg(null)).toEqual(10);
+		assert.strictEqual(test.useFloatArg(null), 10);
 	});
 	it('accepts a number', () => {
-		expect(test.useFloatArg(55)).toEqual(55);
+		assert.strictEqual(test.useFloatArg(55), 55);
 	});
 });

test-addon/hpp-arg-int.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const intArgMsg = 'Argument 0 must be of type `Int32`';
+const intArgMsg = { message: 'Argument 0 must be of type `Int32`' };
+const intArgLetMsg = { message: 'Argument 0 must be of type `Int32` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_INT_ARG, REQ_INT32_ARG', () => {
+describe('AT / HPP / REQ_INT_ARG, REQ_INT32_ARG', () => {
 	it('exports reqIntArg', () => {
-		expect(typeof test.reqIntArg).toBe('function');
+		assert.strictEqual(typeof test.reqIntArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqIntArg()).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg(), intArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqIntArg(undefined)).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg(undefined), intArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqIntArg(null)).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg(null), intArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqIntArg('1')).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg('1'), intArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqIntArg(true)).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg(true), intArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqIntArg({})).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg({}), intArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqIntArg([])).toThrow(intArgMsg);
+		assert.throws(() => test.reqIntArg([]), intArgMsg);
 	});
 	it('accepts a number', () => {
-		expect(test.reqIntArg(55)).toEqual(55);
+		assert.strictEqual(test.reqIntArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: LET_INT_ARG / LET_INT32_ARG', () => {
 	it('exports letIntArg', () => {
-		expect(typeof test.letIntArg).toBe('function');
+		assert.strictEqual(typeof test.letIntArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letIntArg('1')).toThrow(intArgMsg);
+		assert.throws(() => test.letIntArg('1'), intArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letIntArg(true)).toThrow(intArgMsg);
+		assert.throws(() => test.letIntArg(true), intArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letIntArg({})).toThrow(intArgMsg);
+		assert.throws(() => test.letIntArg({}), intArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letIntArg([])).toThrow(intArgMsg);
+		assert.throws(() => test.letIntArg([]), intArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letIntArg()).toEqual(0);
+		assert.strictEqual(test.letIntArg(), 0);
 	});
 	it('accepts undefined', () => {
-		expect(test.letIntArg(undefined)).toEqual(0);
+		assert.strictEqual(test.letIntArg(undefined), 0);
 	});
 	it('accepts null', () => {
-		expect(test.letIntArg(null)).toEqual(0);
+		assert.strictEqual(test.letIntArg(null), 0);
 	});
 	it('accepts a number', () => {
-		expect(test.letIntArg(55)).toEqual(55);
+		assert.strictEqual(test.letIntArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: USE_INT_ARG / USE_INT32_ARG', () => {
 	it('exports useIntArg', () => {
-		expect(typeof test.useIntArg).toBe('function');
+		assert.strictEqual(typeof test.useIntArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useIntArg('1')).toThrow(intArgMsg);
+		assert.throws(() => test.useIntArg('1'), intArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useIntArg(true)).toThrow(intArgMsg);
+		assert.throws(() => test.useIntArg(true), intArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useIntArg({})).toThrow(intArgMsg);
+		assert.throws(() => test.useIntArg({}), intArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useIntArg([])).toThrow(intArgMsg);
+		assert.throws(() => test.useIntArg([]), intArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useIntArg()).toEqual(10);
+		assert.strictEqual(test.useIntArg(), 10);
 	});
 	it('accepts undefined', () => {
-		expect(test.useIntArg(undefined)).toEqual(10);
+		assert.strictEqual(test.useIntArg(undefined), 10);
 	});
 	it('accepts null', () => {
-		expect(test.useIntArg(null)).toEqual(10);
+		assert.strictEqual(test.useIntArg(null), 10);
 	});
 	it('accepts a number', () => {
-		expect(test.useIntArg(55)).toEqual(55);
+		assert.strictEqual(test.useIntArg(55), 55);
 	});
 });

test-addon/hpp-arg-obj.test.js

@@ -1,105 +1,109 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const objArgMsg = 'Argument 0 must be of type `Object`';
+const objArgMsg = { message: 'Argument 0 must be of type `Object`' };
+const objArgLetMsg = { message: 'Argument 0 must be of type `Object` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_OBJ_ARG', () => {
+describe('AT / HPP / REQ_OBJ_ARG', () => {
 	it('exports reqObjArg', () => {
-		expect(typeof test.reqObjArg).toBe('function');
+		assert.strictEqual(typeof test.reqObjArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqObjArg()).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(), objArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqObjArg(undefined)).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(undefined), objArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqObjArg(null)).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(null), objArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqObjArg('1')).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg('1'), objArgMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.reqObjArg(1)).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(1), objArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqObjArg(true)).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(true), objArgMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.reqObjArg(test.retExt())).toThrow(objArgMsg);
+		assert.throws(() => test.reqObjArg(test.retExt()), objArgMsg);
 	});
 	it('accepts an object', () => {
-		expect(typeof test.reqObjArg({})).toBe('object');
+		assert.strictEqual(typeof test.reqObjArg({}), 'object');
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.reqObjArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.reqObjArg([])));
 	});
 });
 
 describe('addon-tools.hpp: LET_OBJ_ARG', () => {
 	it('exports letObjArg', () => {
-		expect(typeof test.letObjArg).toBe('function');
+		assert.strictEqual(typeof test.letObjArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letObjArg('1')).toThrow(objArgMsg);
+		assert.throws(() => test.letObjArg('1'), objArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letObjArg(1)).toThrow(objArgMsg);
+		assert.throws(() => test.letObjArg(1), objArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letObjArg(true)).toThrow(objArgMsg);
+		assert.throws(() => test.letObjArg(true), objArgLetMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.letObjArg(test.retExt())).toThrow(objArgMsg);
+		assert.throws(() => test.letObjArg(test.retExt()), objArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(typeof test.letObjArg()).toBe('object');
+		assert.strictEqual(typeof test.letObjArg(), 'object');
 	});
 	it('accepts undefined', () => {
-		expect(typeof test.letObjArg(undefined)).toBe('object');
+		assert.strictEqual(typeof test.letObjArg(undefined), 'object');
 	});
 	it('accepts null', () => {
-		expect(typeof test.letObjArg(null)).toBe('object');
+		assert.strictEqual(typeof test.letObjArg(null), 'object');
 	});
 	it('accepts an object', () => {
-		expect(typeof test.letObjArg({})).toBe('object');
+		assert.strictEqual(typeof test.letObjArg({}), 'object');
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.letObjArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.letObjArg([])));
 	});
 });
 
 describe('addon-tools.hpp: USE_OBJ_ARG', () => {
 	it('exports useObjArg', () => {
-		expect(typeof test.useObjArg).toBe('function');
+		assert.strictEqual(typeof test.useObjArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useObjArg('1')).toThrow(objArgMsg);
+		assert.throws(() => test.useObjArg('1'), objArgLetMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.useObjArg(1)).toThrow(objArgMsg);
+		assert.throws(() => test.useObjArg(1), objArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useObjArg(true)).toThrow(objArgMsg);
+		assert.throws(() => test.useObjArg(true), objArgLetMsg);
 	});
 	it('throws if arg was passed a pointer', () => {
-		expect(() => test.useObjArg(test.retExt())).toThrow(objArgMsg);
+		assert.throws(() => test.useObjArg(test.retExt()), objArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(typeof test.useObjArg()).toBe('object');
+		assert.strictEqual(typeof test.useObjArg(), 'object');
 	});
 	it('accepts undefined', () => {
-		expect(typeof test.useObjArg(undefined)).toBe('object');
+		assert.strictEqual(typeof test.useObjArg(undefined), 'object');
 	});
 	it('accepts null', () => {
-		expect(typeof test.useObjArg(null)).toBe('object');
+		assert.strictEqual(typeof test.useObjArg(null), 'object');
 	});
 	it('accepts an object', () => {
-		expect(typeof test.useObjArg({})).toBe('object');
+		assert.strictEqual(typeof test.useObjArg({}), 'object');
 	});
 	it('accepts an array', () => {
-		expect(Array.isArray(test.useObjArg([]))).toBe(true);
+		assert.ok(Array.isArray(test.useObjArg([])));
 	});
 });

test-addon/hpp-arg-offs.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const numArgMsg = 'Argument 0 must be of type `Number`';
+const numArgMsg = { message: 'Argument 0 must be of type `Number`' };
+const numArgLetMsg = { message: 'Argument 0 must be of type `Number` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_OFFS_ARG', () => {
+describe('AT / HPP / REQ_OFFS_ARG', () => {
 	it('exports reqOffsArg', () => {
-		expect(typeof test.reqOffsArg).toBe('function');
+		assert.strictEqual(typeof test.reqOffsArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqOffsArg()).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg(), numArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqOffsArg(undefined)).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg(undefined), numArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqOffsArg(null)).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg(null), numArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqOffsArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg('1'), numArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqOffsArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg(true), numArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqOffsArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg({}), numArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqOffsArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.reqOffsArg([]), numArgMsg);
 	});
 	it('accepts a number', () => {
-		expect(test.reqOffsArg(55)).toEqual(55);
+		assert.strictEqual(test.reqOffsArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: LET_OFFS_ARG', () => {
 	it('exports letOffsArg', () => {
-		expect(typeof test.letOffsArg).toBe('function');
+		assert.strictEqual(typeof test.letOffsArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letOffsArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.letOffsArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letOffsArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.letOffsArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letOffsArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.letOffsArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letOffsArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.letOffsArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letOffsArg()).toEqual(0);
+		assert.strictEqual(test.letOffsArg(), 0);
 	});
 	it('accepts undefined', () => {
-		expect(test.letOffsArg(undefined)).toEqual(0);
+		assert.strictEqual(test.letOffsArg(undefined), 0);
 	});
 	it('accepts null', () => {
-		expect(test.letOffsArg(null)).toEqual(0);
+		assert.strictEqual(test.letOffsArg(null), 0);
 	});
 	it('accepts a number', () => {
-		expect(test.letOffsArg(55)).toEqual(55);
+		assert.strictEqual(test.letOffsArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: USE_OFFS_ARG', () => {
 	it('exports useOffsArg', () => {
-		expect(typeof test.useOffsArg).toBe('function');
+		assert.strictEqual(typeof test.useOffsArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useOffsArg('1')).toThrow(numArgMsg);
+		assert.throws(() => test.useOffsArg('1'), numArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useOffsArg(true)).toThrow(numArgMsg);
+		assert.throws(() => test.useOffsArg(true), numArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useOffsArg({})).toThrow(numArgMsg);
+		assert.throws(() => test.useOffsArg({}), numArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useOffsArg([])).toThrow(numArgMsg);
+		assert.throws(() => test.useOffsArg([]), numArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useOffsArg()).toEqual(10);
+		assert.strictEqual(test.useOffsArg(), 10);
 	});
 	it('accepts undefined', () => {
-		expect(test.useOffsArg(undefined)).toEqual(10);
+		assert.strictEqual(test.useOffsArg(undefined), 10);
 	});
 	it('accepts null', () => {
-		expect(test.useOffsArg(null)).toEqual(10);
+		assert.strictEqual(test.useOffsArg(null), 10);
 	});
 	it('accepts a number', () => {
-		expect(test.useOffsArg(55)).toEqual(55);
+		assert.strictEqual(test.useOffsArg(55), 55);
 	});
 });

test-addon/hpp-arg-str.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const strArgMsg = 'Argument 0 must be of type `String`';
+const strArgMsg = { message: 'Argument 0 must be of type `String`' };
+const strArgLetMsg = { message: 'Argument 0 must be of type `String` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_STR_ARG', () => {
+describe('AT / HPP / REQ_STR_ARG', () => {
 	it('exports reqStrArg', () => {
-		expect(typeof test.reqStrArg).toBe('function');
+		assert.strictEqual(typeof test.reqStrArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqStrArg()).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg(), strArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqStrArg(undefined)).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg(undefined), strArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqStrArg(null)).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg(null), strArgMsg);
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.reqStrArg(1)).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg(1), strArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqStrArg(true)).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg(true), strArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqStrArg({})).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg({}), strArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqStrArg([])).toThrow(strArgMsg);
+		assert.throws(() => test.reqStrArg([]), strArgMsg);
 	});
 	it('accepts a string', () => {
-		expect(test.reqStrArg('1abc')).toEqual('1abc');
+		assert.strictEqual(test.reqStrArg('1abc'), '1abc');
 	});
 });
 
 describe('addon-tools.hpp: LET_STR_ARG', () => {
 	it('exports letStrArg', () => {
-		expect(typeof test.letStrArg).toBe('function');
+		assert.strictEqual(typeof test.letStrArg, 'function');
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.letStrArg(1)).toThrow(strArgMsg);
+		assert.throws(() => test.letStrArg(1), strArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letStrArg(true)).toThrow(strArgMsg);
+		assert.throws(() => test.letStrArg(true), strArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letStrArg({})).toThrow(strArgMsg);
+		assert.throws(() => test.letStrArg({}), strArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letStrArg([])).toThrow(strArgMsg);
+		assert.throws(() => test.letStrArg([]), strArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letStrArg()).toEqual('');
+		assert.strictEqual(test.letStrArg(), '');
 	});
 	it('accepts undefined', () => {
-		expect(test.letStrArg(undefined)).toEqual('');
+		assert.strictEqual(test.letStrArg(undefined), '');
 	});
 	it('accepts null', () => {
-		expect(test.letStrArg(null)).toEqual('');
+		assert.strictEqual(test.letStrArg(null), '');
 	});
 	it('accepts a string', () => {
-		expect(test.letStrArg('1abc')).toEqual('1abc');
+		assert.strictEqual(test.letStrArg('1abc'), '1abc');
 	});
 });
 
 describe('addon-tools.hpp: USE_STR_ARG', () => {
 	it('exports useStrArg', () => {
-		expect(typeof test.useStrArg).toBe('function');
+		assert.strictEqual(typeof test.useStrArg, 'function');
 	});
 	it('throws if arg was passed a number', () => {
-		expect(() => test.useStrArg(1)).toThrow(strArgMsg);
+		assert.throws(() => test.useStrArg(1), strArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useStrArg(true)).toThrow(strArgMsg);
+		assert.throws(() => test.useStrArg(true), strArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useStrArg({})).toThrow(strArgMsg);
+		assert.throws(() => test.useStrArg({}), strArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useStrArg([])).toThrow(strArgMsg);
+		assert.throws(() => test.useStrArg([]), strArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useStrArg()).toEqual('default');
+		assert.strictEqual(test.useStrArg(), 'default');
 	});
 	it('accepts undefined', () => {
-		expect(test.useStrArg(undefined)).toEqual('default');
+		assert.strictEqual(test.useStrArg(undefined), 'default');
 	});
 	it('accepts null', () => {
-		expect(test.useStrArg(null)).toEqual('default');
+		assert.strictEqual(test.useStrArg(null), 'default');
 	});
 	it('accepts a string', () => {
-		expect(test.useStrArg('1abc')).toEqual('1abc');
+		assert.strictEqual(test.useStrArg('1abc'), '1abc');
 	});
 });

test-addon/hpp-arg-uint.test.js

@@ -1,96 +1,100 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-const uintArgMsg = 'Argument 0 must be of type `Uint32`';
+const uintArgMsg = { message: 'Argument 0 must be of type `Uint32`' };
+const uintArgLetMsg = { message: 'Argument 0 must be of type `Uint32` or be `null`/`undefined`' };
 
-describe('AT / addon-tools.hpp / REQ_UINT_ARG, REQ_UINT32_ARG', () => {
+describe('AT / HPP / REQ_UINT_ARG, REQ_UINT32_ARG', () => {
 	it('exports reqUintArg', () => {
-		expect(typeof test.reqUintArg).toBe('function');
+		assert.strictEqual(typeof test.reqUintArg, 'function');
 	});
 	it('throws if arg was not passed', () => {
-		expect(() => test.reqUintArg()).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg(), uintArgMsg);
 	});
 	it('throws if arg was passed undefined', () => {
-		expect(() => test.reqUintArg(undefined)).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg(undefined), uintArgMsg);
 	});
 	it('throws if arg was passed null', () => {
-		expect(() => test.reqUintArg(null)).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg(null), uintArgMsg);
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.reqUintArg('1')).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg('1'), uintArgMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.reqUintArg(true)).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg(true), uintArgMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.reqUintArg({})).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg({}), uintArgMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.reqUintArg([])).toThrow(uintArgMsg);
+		assert.throws(() => test.reqUintArg([]), uintArgMsg);
 	});
 	it('accepts a number', () => {
-		expect(test.reqUintArg(55)).toEqual(55);
+		assert.strictEqual(test.reqUintArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: LET_UINT_ARG / LET_UINT32_ARG', () => {
 	it('exports letUintArg', () => {
-		expect(typeof test.letUintArg).toBe('function');
+		assert.strictEqual(typeof test.letUintArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.letUintArg('1')).toThrow(uintArgMsg);
+		assert.throws(() => test.letUintArg('1'), uintArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.letUintArg(true)).toThrow(uintArgMsg);
+		assert.throws(() => test.letUintArg(true), uintArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.letUintArg({})).toThrow(uintArgMsg);
+		assert.throws(() => test.letUintArg({}), uintArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.letUintArg([])).toThrow(uintArgMsg);
+		assert.throws(() => test.letUintArg([]), uintArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.letUintArg()).toEqual(0);
+		assert.strictEqual(test.letUintArg(), 0);
 	});
 	it('accepts undefined', () => {
-		expect(test.letUintArg(undefined)).toEqual(0);
+		assert.strictEqual(test.letUintArg(undefined), 0);
 	});
 	it('accepts null', () => {
-		expect(test.letUintArg(null)).toEqual(0);
+		assert.strictEqual(test.letUintArg(null), 0);
 	});
 	it('accepts a number', () => {
-		expect(test.letUintArg(55)).toEqual(55);
+		assert.strictEqual(test.letUintArg(55), 55);
 	});
 });
 
 describe('addon-tools.hpp: USE_UINT_ARG / USE_UINT32_ARG', () => {
 	it('exports useUintArg', () => {
-		expect(typeof test.useUintArg).toBe('function');
+		assert.strictEqual(typeof test.useUintArg, 'function');
 	});
 	it('throws if arg was passed a string', () => {
-		expect(() => test.useUintArg('1')).toThrow(uintArgMsg);
+		assert.throws(() => test.useUintArg('1'), uintArgLetMsg);
 	});
 	it('throws if arg was passed a boolean', () => {
-		expect(() => test.useUintArg(true)).toThrow(uintArgMsg);
+		assert.throws(() => test.useUintArg(true), uintArgLetMsg);
 	});
 	it('throws if arg was passed an object', () => {
-		expect(() => test.useUintArg({})).toThrow(uintArgMsg);
+		assert.throws(() => test.useUintArg({}), uintArgLetMsg);
 	});
 	it('throws if arg was passed an array', () => {
-		expect(() => test.useUintArg([])).toThrow(uintArgMsg);
+		assert.throws(() => test.useUintArg([]), uintArgLetMsg);
 	});
 	it('accepts an empty arg', () => {
-		expect(test.useUintArg()).toEqual(10);
+		assert.strictEqual(test.useUintArg(), 10);
 	});
 	it('accepts undefined', () => {
-		expect(test.useUintArg(undefined)).toEqual(10);
+		assert.strictEqual(test.useUintArg(undefined), 10);
 	});
 	it('accepts null', () => {
-		expect(test.useUintArg(null)).toEqual(10);
+		assert.strictEqual(test.useUintArg(null), 10);
 	});
 	it('accepts a number', () => {
-		expect(test.useUintArg(55)).toEqual(55);
+		assert.strictEqual(test.useUintArg(55), 55);
 	});
 });

test-addon/hpp-arg.test.js

@@ -1,205 +1,211 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const test = require('./build/Release/test.node');
 
 
-describe('AT / addon-tools.hpp / Function arguments', () => {
+describe('AT / HPP / Function arguments', () => {
+	
+	const arg3Msg = { message: 'Expected at least 3 arguments' };
+	
 	describe('REQ_ARGS', () => {
 		it('exports reqArgs3', () => {
-			expect(typeof test.reqArgs3).toBe('function');
+			assert.strictEqual(typeof test.reqArgs3, 'function');
 		});
 		it('throws if no args passed', () => {
-			expect(() => test.reqArgs3()).toThrow('Expected at least 3 arguments');
+			assert.throws(() => test.reqArgs3(), arg3Msg);
 		});
 		it('throws if 1 arg passed', () => {
-			expect(() => test.reqArgs3(1)).toThrow('Expected at least 3 arguments');
+			assert.throws(() => test.reqArgs3(1), arg3Msg);
 		});
 		it('returns true if 3 args passed', () => {
-			expect(test.reqArgs3(1, 2, 3)).toEqual(true);
+			assert.ok(test.reqArgs3(1, 2, 3));
 		});
 		it('returns true if 5 args passed', () => {
-			expect(test.reqArgs3(1, 2, 3, 4, 5)).toEqual(true);
+			assert.ok(test.reqArgs3(1, 2, 3, 4, 5));
 		});
 	});
 	
 	describe('IS_ARG_EMPTY', () => {
 		it('exports isArg0Empty', () => {
-			expect(typeof test.isArg0Empty).toBe('function');
+			assert.strictEqual(typeof test.isArg0Empty, 'function');
 		});
 		it('returns true for absent arg', () => {
-			expect(test.isArg0Empty()).toEqual(true);
+			assert.ok(test.isArg0Empty());
 		});
 		it('returns true for undefined arg', () => {
-			expect(test.isArg0Empty(undefined)).toEqual(true);
+			assert.ok(test.isArg0Empty(undefined));
 		});
 		it('returns true for null arg', () => {
-			expect(test.isArg0Empty(null)).toEqual(true);
+			assert.ok(test.isArg0Empty(null));
 		});
 		it('returns false for non-empty value', () => {
-			expect(test.isArg0Empty(1)).toEqual(false);
+			assert.strictEqual(test.isArg0Empty(1), false);
 		});
 	});
 	
 	// ------------------------------ FUN_ARG
 	
-	const funArgMsg = 'Argument 0 must be of type `Function`';
+	const funArgMsg = { message: 'Argument 0 must be of type `Function`' };
 	
 	describe('REQ_FUN_ARG', () => {
 		it('exports reqFunArg', () => {
-			expect(typeof test.reqFunArg).toBe('function');
+			assert.strictEqual(typeof test.reqFunArg, 'function');
 		});
 		it('throws if arg was not passed', () => {
-			expect(() => test.reqFunArg()).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(), funArgMsg);
 		});
 		it('throws if arg was passed undefined', () => {
-			expect(() => test.reqFunArg(undefined)).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(undefined), funArgMsg);
 		});
 		it('throws if arg was passed null', () => {
-			expect(() => test.reqFunArg(null)).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(null), funArgMsg);
 		});
 		it('throws if arg was passed a string', () => {
-			expect(() => test.reqFunArg('1')).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg('1'), funArgMsg);
 		});
 		it('throws if arg was passed a number', () => {
-			expect(() => test.reqFunArg(1)).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(1), funArgMsg);
 		});
 		it('throws if arg was passed a boolean', () => {
-			expect(() => test.reqFunArg(true)).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(true), funArgMsg);
 		});
 		it('throws if arg was passed a pointer', () => {
-			expect(() => test.reqFunArg(test.retExt())).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg(test.retExt()), funArgMsg);
 		});
 		it('throws if arg was passed an object', () => {
-			expect(() => test.reqFunArg({})).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg({}), funArgMsg);
 		});
 		it('throws if arg was passed an array', () => {
-			expect(() => test.reqFunArg([])).toThrow(funArgMsg);
+			assert.throws(() => test.reqFunArg([]), funArgMsg);
 		});
 		it('accepts a function', () => {
-			expect(typeof test.reqFunArg(() => {})).toBe('function');
+			assert.strictEqual(typeof test.reqFunArg(() => {}), 'function');
 		});
 	});
 	
 	// ------------------------------ ARRV_ARG
 	
-	const arrvArgMsg = 'Argument 0 must be of type `ArrayBuffer`';
+	const arrvArgMsg = { message: 'Argument 0 must be of type `ArrayBuffer`' };
 	
 	describe('REQ_ARRV_ARG', () => {
 		it('exports reqArrvArg', () => {
-			expect(typeof test.reqArrvArg).toBe('function');
+			assert.strictEqual(typeof test.reqArrvArg, 'function');
 		});
 		it('throws if arg was not passed', () => {
-			expect(() => test.reqArrvArg()).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(), arrvArgMsg);
 		});
 		it('throws if arg was passed undefined', () => {
-			expect(() => test.reqArrvArg(undefined)).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(undefined), arrvArgMsg);
 		});
 		it('throws if arg was passed null', () => {
-			expect(() => test.reqArrvArg(null)).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(null), arrvArgMsg);
 		});
 		it('throws if arg was passed a string', () => {
-			expect(() => test.reqArrvArg('1')).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg('1'), arrvArgMsg);
 		});
 		it('throws if arg was passed a number', () => {
-			expect(() => test.reqArrvArg(1)).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(1), arrvArgMsg);
 		});
 		it('throws if arg was passed a boolean', () => {
-			expect(() => test.reqArrvArg(true)).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(true), arrvArgMsg);
 		});
 		it('throws if arg was passed a pointer', () => {
-			expect(() => test.reqArrvArg(test.retExt())).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg(test.retExt()), arrvArgMsg);
 		});
 		it('throws if arg was passed an object', () => {
-			expect(() => test.reqArrvArg({})).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg({}), arrvArgMsg);
 		});
 		it('throws if arg was passed an array', () => {
-			expect(() => test.reqArrvArg([])).toThrow(arrvArgMsg);
+			assert.throws(() => test.reqArrvArg([]), arrvArgMsg);
 		});
 		it('accepts an array buffer', () => {
 			const { buffer } = new Uint8Array([1, 2, 3]);
-			expect(test.reqArrvArg(buffer)).toEqual(buffer);
+			assert.strictEqual(test.reqArrvArg(buffer), buffer);
 		});
 	});
 	
 	// ------------------------------ BUF_ARG
 	
-	const bufArgMsg = 'Argument 0 must be of type `Buffer`';
+	const bufArgMsg = { message: 'Argument 0 must be of type `Buffer`' };
 	
 	describe('REQ_BUF_ARG', () => {
 		it('exports reqBufArg', () => {
-			expect(typeof test.reqBufArg).toBe('function');
+			assert.strictEqual(typeof test.reqBufArg, 'function');
 		});
 		it('throws if arg was not passed', () => {
-			expect(() => test.reqBufArg()).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(), bufArgMsg);
 		});
 		it('throws if arg was passed undefined', () => {
-			expect(() => test.reqBufArg(undefined)).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(undefined), bufArgMsg);
 		});
 		it('throws if arg was passed null', () => {
-			expect(() => test.reqBufArg(null)).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(null), bufArgMsg);
 		});
 		it('throws if arg was passed a string', () => {
-			expect(() => test.reqBufArg('1')).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg('1'), bufArgMsg);
 		});
 		it('throws if arg was passed a number', () => {
-			expect(() => test.reqBufArg(1)).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(1), bufArgMsg);
 		});
 		it('throws if arg was passed a boolean', () => {
-			expect(() => test.reqBufArg(true)).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(true), bufArgMsg);
 		});
 		it('throws if arg was passed a pointer', () => {
-			expect(() => test.reqBufArg(test.retExt())).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg(test.retExt()), bufArgMsg);
 		});
 		it('throws if arg was passed an object', () => {
-			expect(() => test.reqBufArg({})).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg({}), bufArgMsg);
 		});
 		it('throws if arg was passed an array', () => {
-			expect(() => test.reqBufArg([])).toThrow(bufArgMsg);
+			assert.throws(() => test.reqBufArg([]), bufArgMsg);
 		});
 		it('accepts a buffer', () => {
 			const buffer = Buffer.from([1, 2, 3]);
-			expect(test.reqBufArg(buffer)).toEqual(buffer);
+			assert.strictEqual(test.reqBufArg(buffer), buffer);
 		});
 	});
 	
 	// ------------------------------ TYPED_ARRAY_ARG
 	
-	const typedArgMsg = 'Argument 0 must be of type `TypedArray`';
+	const typedArgMsg = { message: 'Argument 0 must be of type `TypedArray`' };
 	
 	describe('REQ_TYPED_ARRAY_ARG', () => {
 		it('exports reqTypedArg', () => {
-			expect(typeof test.reqTypedArg).toBe('function');
+			assert.strictEqual(typeof test.reqTypedArg, 'function');
 		});
 		it('throws if arg was not passed', () => {
-			expect(() => test.reqTypedArg()).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(), typedArgMsg);
 		});
 		it('throws if arg was passed undefined', () => {
-			expect(() => test.reqTypedArg(undefined)).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(undefined), typedArgMsg);
 		});
 		it('throws if arg was passed null', () => {
-			expect(() => test.reqTypedArg(null)).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(null), typedArgMsg);
 		});
 		it('throws if arg was passed a string', () => {
-			expect(() => test.reqTypedArg('1')).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg('1'), typedArgMsg);
 		});
 		it('throws if arg was passed a number', () => {
-			expect(() => test.reqTypedArg(1)).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(1), typedArgMsg);
 		});
 		it('throws if arg was passed a boolean', () => {
-			expect(() => test.reqTypedArg(true)).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(true), typedArgMsg);
 		});
 		it('throws if arg was passed a pointer', () => {
-			expect(() => test.reqTypedArg(test.retExt())).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg(test.retExt()), typedArgMsg);
 		});
 		it('throws if arg was passed an object', () => {
-			expect(() => test.reqTypedArg({})).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg({}), typedArgMsg);
 		});
 		it('throws if arg was passed an array', () => {
-			expect(() => test.reqTypedArg([])).toThrow(typedArgMsg);
+			assert.throws(() => test.reqTypedArg([]), typedArgMsg);
 		});
 		it('accepts a typed array', () => {
 			const typed = new Uint8Array([1, 2, 3]);
-			expect(test.reqTypedArg(typed)).toEqual(typed);
+			assert.strictEqual(test.reqTypedArg(typed), typed);
 		});
 	});
 });

utils/CPPLINT.cfg

@@ -1,17 +1,18 @@
 set noparent
 linelength=110
-filter=-legal/copyright
-filter=-build/include_order
-filter=-build/include
 filter=-build/header_guard
-filter=-build/namespaces
+filter=-build/include
+filter=-build/include_order
 filter=-build/include_what_you_use
+filter=-build/namespaces
+filter=-legal/copyright
+filter=-readability/todo
+filter=-runtime/indentation_namespace
 filter=-whitespace/blank_line
+filter=-whitespace/braces
 filter=-whitespace/comments
-filter=-whitespace/tab
 filter=-whitespace/end_of_line
 filter=-whitespace/indent
 filter=-whitespace/operators
 filter=-whitespace/parens
-filter=-readability/todo
-filter=-runtime/indentation_namespace
+filter=-whitespace/tab

utils/cpcpplint.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { copy, exists } = require('./files');
+
+
+const cpcpplint = async () => {
+	const cpplintDest = `${process.cwd()}/CPPLINT.cfg`.replace(/\\/g, '/');
+	const cpplintSrc = `${__dirname}/CPPLINT.cfg`.replace(/\\/g, '/');
+	
+	if (!await exists(cpplintSrc) ) {
+		console.error('Error. File "CPPLINT.cfg" not found.');
+		return;
+	}
+	
+	if (await exists(cpplintDest) ) {
+		console.warn('Warning. Dest "CPPLINT.cfg" exists and will be overwritten.');
+	}
+	
+	await copy(cpplintSrc, cpplintDest);
+	
+	console.log(`"CPPLINT.cfg" was copied to "${cpplintDest}".`);
+};
+
+module.exports = { cpcpplint };

utils/index.js

@@ -5,6 +5,7 @@ module.exports = Object.assign(
 	{},
 	require('./action-pack'),
 	require('./cpbin'),
+	require('./cpcpplint'),
 	require('./download'),
 	require('./files'),
 	require('./install'),

utils/utils.test.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const assert = require('node:assert').strict;
+const { describe, it } = require('node:test');
+
 const utils = require('.');
 
 
@@ -13,7 +16,7 @@ describe('AT / utils', () => {
 	
 	methods.forEach((name) => {
 		it(`exports the "${name}" function`, () => {
-			expect(typeof utils[name]).toBe('function');
+			assert.strictEqual(typeof utils[name], 'function');
 		});
 	});
 });