@yalehwang/archguard 0.1.31 → 0.1.32

package/node_modules/node-addon-api/tools/check-napi.js

@@ -1,99 +0,0 @@
-'use strict';
-// Descend into a directory structure and, for each file matching *.node, output
-// based on the imports found in the file whether it's an N-API module or not.
-
-const fs = require('fs');
-const path = require('path');
-
-// Read the output of the command, break it into lines, and use the reducer to
-// decide whether the file is an N-API module or not.
-function checkFile (file, command, argv, reducer) {
-  const child = require('child_process').spawn(command, argv, {
-    stdio: ['inherit', 'pipe', 'inherit']
-  });
-  let leftover = '';
-  let isNapi;
-  child.stdout.on('data', (chunk) => {
-    if (isNapi === undefined) {
-      chunk = (leftover + chunk.toString()).split(/[\r\n]+/);
-      leftover = chunk.pop();
-      isNapi = chunk.reduce(reducer, isNapi);
-      if (isNapi !== undefined) {
-        child.kill();
-      }
-    }
-  });
-  child.on('close', (code, signal) => {
-    if ((code === null && signal !== null) || (code !== 0)) {
-      console.log(
-        command + ' exited with code: ' + code + ' and signal: ' + signal);
-    } else {
-      // Green if it's a N-API module, red otherwise.
-      console.log(
-        '\x1b[' + (isNapi ? '42' : '41') + 'm' +
-          (isNapi ? '    N-API' : 'Not N-API') +
-          '\x1b[0m: ' + file);
-    }
-  });
-}
-
-// Use nm -a to list symbols.
-function checkFileUNIX (file) {
-  checkFile(file, 'nm', ['-a', file], (soFar, line) => {
-    if (soFar === undefined) {
-      line = line.match(/([0-9a-f]*)? ([a-zA-Z]) (.*$)/);
-      if (line[2] === 'U') {
-        if (/^napi/.test(line[3])) {
-          soFar = true;
-        }
-      }
-    }
-    return soFar;
-  });
-}
-
-// Use dumpbin /imports to list symbols.
-function checkFileWin32 (file) {
-  checkFile(file, 'dumpbin', ['/imports', file], (soFar, line) => {
-    if (soFar === undefined) {
-      line = line.match(/([0-9a-f]*)? +([a-zA-Z0-9]) (.*$)/);
-      if (line && /^napi/.test(line[line.length - 1])) {
-        soFar = true;
-      }
-    }
-    return soFar;
-  });
-}
-
-// Descend into a directory structure and pass each file ending in '.node' to
-// one of the above checks, depending on the OS.
-function recurse (top) {
-  fs.readdir(top, (error, items) => {
-    if (error) {
-      throw new Error('error reading directory ' + top + ': ' + error);
-    }
-    items.forEach((item) => {
-      item = path.join(top, item);
-      fs.stat(item, ((item) => (error, stats) => {
-        if (error) {
-          throw new Error('error about ' + item + ': ' + error);
-        }
-        if (stats.isDirectory()) {
-          recurse(item);
-        } else if (/[.]node$/.test(item) &&
-            // Explicitly ignore files called 'nothing.node' because they are
-            // artefacts of node-addon-api having identified a version of
-            // Node.js that ships with a correct implementation of N-API.
-            path.basename(item) !== 'nothing.node') {
-          process.platform === 'win32'
-            ? checkFileWin32(item)
-            : checkFileUNIX(item);
-        }
-      })(item));
-    });
-  });
-}
-
-// Start with the directory given on the command line or the current directory
-// if nothing was given.
-recurse(process.argv.length > 3 ? process.argv[2] : '.');

package/node_modules/node-addon-api/tools/clang-format.js

@@ -1,71 +0,0 @@
-#!/usr/bin/env node
-
-const spawn = require('child_process').spawnSync;
-const path = require('path');
-
-const filesToCheck = ['*.h', '*.cc'];
-const FORMAT_START = process.env.FORMAT_START || 'main';
-
-function main (args) {
-  let fix = false;
-  while (args.length > 0) {
-    switch (args[0]) {
-      case '-f':
-      case '--fix':
-        fix = true;
-        break;
-      default:
-    }
-    args.shift();
-  }
-
-  const clangFormatPath = path.dirname(require.resolve('clang-format'));
-  const binary = process.platform === 'win32'
-    ? 'node_modules\\.bin\\clang-format.cmd'
-    : 'node_modules/.bin/clang-format';
-  const options = ['--binary=' + binary, '--style=file'];
-  if (fix) {
-    options.push(FORMAT_START);
-  } else {
-    options.push('--diff', FORMAT_START);
-  }
-
-  const gitClangFormatPath = path.join(clangFormatPath, 'bin/git-clang-format');
-  const result = spawn(
-    'python',
-    [gitClangFormatPath, ...options, '--', ...filesToCheck],
-    { encoding: 'utf-8' }
-  );
-
-  if (result.stderr) {
-    console.error('Error running git-clang-format:', result.stderr);
-    return 2;
-  }
-
-  const clangFormatOutput = result.stdout.trim();
-  // Bail fast if in fix mode.
-  if (fix) {
-    console.log(clangFormatOutput);
-    return 0;
-  }
-  // Detect if there is any complains from clang-format
-  if (
-    clangFormatOutput !== '' &&
-    clangFormatOutput !== 'no modified files to format' &&
-    clangFormatOutput !== 'clang-format did not modify any files'
-  ) {
-    console.error(clangFormatOutput);
-    const fixCmd = 'npm run lint:fix';
-    console.error(`
-      ERROR: please run "${fixCmd}" to format changes in your commit
-        Note that when running the command locally, please keep your local
-        main branch and working branch up to date with nodejs/node-addon-api
-        to exclude un-related complains.
-        Or you can run "env FORMAT_START=upstream/main ${fixCmd}".`);
-    return 1;
-  }
-}
-
-if (require.main === module) {
-  process.exitCode = main(process.argv.slice(2));
-}

package/node_modules/node-addon-api/tools/conversion.js

@@ -1,301 +0,0 @@
-#! /usr/bin/env node
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const args = process.argv.slice(2);
-const dir = args[0];
-if (!dir) {
-  console.log('Usage: node ' + path.basename(__filename) + ' <target-dir>');
-  process.exit(1);
-}
-
-const NodeApiVersion = require('../').version;
-
-const disable = args[1];
-let ConfigFileOperations;
-if (disable !== '--disable' && dir !== '--disable') {
-  ConfigFileOperations = {
-    'package.json': [
-      [/([ ]*)"dependencies": {/g, '$1"dependencies": {\n$1  "node-addon-api": "' + NodeApiVersion + '",'],
-      [/[ ]*"nan": *"[^"]+"(,|)[\n\r]/g, '']
-    ],
-    'binding.gyp': [
-      [/([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1  \'<!(node -p "require(\\\'node-addon-api\\\').include_dir")\','],
-      [/([ ]*)"include_dirs": \[/g, '$1"include_dirs": [\n$1  "<!(node -p \\"require(\'node-addon-api\').include_dir\\")",'],
-      [/[ ]*("|')<!\(node -e ("|'|\\"|\\')require\(("|'|\\"|\\')nan("|'|\\"|\\')\)("|'|\\"|\\')\)("|')(,|)[\r\n]/g, ''],
-      [/([ ]*)("|')target_name("|'): ("|')(.+?)("|'),/g, '$1$2target_name$2: $4$5$6,\n      $2cflags!$2: [ $2-fno-exceptions$2 ],\n      $2cflags_cc!$2: [ $2-fno-exceptions$2 ],\n      $2xcode_settings$2: { $2GCC_ENABLE_CPP_EXCEPTIONS$2: $2YES$2,\n        $2CLANG_CXX_LIBRARY$2: $2libc++$2,\n        $2MACOSX_DEPLOYMENT_TARGET$2: $210.7$2,\n      },\n      $2msvs_settings$2: {\n        $2VCCLCompilerTool$2: { $2ExceptionHandling$2: 1 },\n      },']
-    ]
-  };
-} else {
-  ConfigFileOperations = {
-    'package.json': [
-      [/([ ]*)"dependencies": {/g, '$1"dependencies": {\n$1  "node-addon-api": "' + NodeApiVersion + '",'],
-      [/[ ]*"nan": *"[^"]+"(,|)[\n\r]/g, '']
-    ],
-    'binding.gyp': [
-      [/([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1  \'<!(node -p "require(\\\'node-addon-api\\\').include_dir")\','],
-      [/([ ]*)"include_dirs": \[/g, '$1"include_dirs": [\n$1  "<!(node -p \'require(\\"node-addon-api\\").include_dir\')",'],
-      [/[ ]*("|')<!\(node -e ("|'|\\"|\\')require\(("|'|\\"|\\')nan("|'|\\"|\\')\)("|'|\\"|\\')\)("|')(,|)[\r\n]/g, ''],
-      [/([ ]*)("|')target_name("|'): ("|')(.+?)("|'),/g, '$1$2target_name$2: $4$5$6,\n      $2cflags!$2: [ $2-fno-exceptions$2 ],\n      $2cflags_cc!$2: [ $2-fno-exceptions$2 ],\n      $2defines$2: [ $2NAPI_DISABLE_CPP_EXCEPTIONS$2 ],\n      $2conditions$2: [\n        [\'OS=="win"\', { $2defines$2: [ $2_HAS_EXCEPTIONS=1$2 ] }]\n      ]']
-    ]
-  };
-}
-
-const SourceFileOperations = [
-  [/Nan::SetMethod\(target,[\s]*"(.*)"[\s]*,[\s]*([^)]+)\)/g, 'exports.Set(Napi::String::New(env, "$1"), Napi::Function::New(env, $2))'],
-
-  [/v8::Local<v8::FunctionTemplate>\s+(\w+)\s*=\s*Nan::New<FunctionTemplate>\([\w\d:]+\);(?:\w+->Reset\(\1\))?\s+\1->SetClassName\(Nan::String::New\("(\w+)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$2", {'],
-  [/Local<FunctionTemplate>\s+(\w+)\s*=\s*Nan::New<FunctionTemplate>\([\w\d:]+\);\s+(\w+)\.Reset\((\1)\);\s+\1->SetClassName\((Nan::String::New|Nan::New<(v8::)*String>)\("(.+?)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$6", {'],
-  [/Local<FunctionTemplate>\s+(\w+)\s*=\s*Nan::New<FunctionTemplate>\([\w\d:]+\);(?:\w+->Reset\(\1\))?\s+\1->SetClassName\(Nan::String::New\("(\w+)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$2", {'],
-  [/Nan::New<v8::FunctionTemplate>\(([\w\d:]+)\)->GetFunction\(\)/g, 'Napi::Function::New(env, $1)'],
-  [/Nan::New<FunctionTemplate>\(([\w\d:]+)\)->GetFunction()/g, 'Napi::Function::New(env, $1);'],
-  [/Nan::New<v8::FunctionTemplate>\(([\w\d:]+)\)/g, 'Napi::Function::New(env, $1)'],
-  [/Nan::New<FunctionTemplate>\(([\w\d:]+)\)/g, 'Napi::Function::New(env, $1)'],
-
-  // FunctionTemplate to FunctionReference
-  [/Nan::Persistent<(v8::)*FunctionTemplate>/g, 'Napi::FunctionReference'],
-  [/Nan::Persistent<(v8::)*Function>/g, 'Napi::FunctionReference'],
-  [/v8::Local<v8::FunctionTemplate>/g, 'Napi::FunctionReference'],
-  [/Local<FunctionTemplate>/g, 'Napi::FunctionReference'],
-  [/v8::FunctionTemplate/g, 'Napi::FunctionReference'],
-  [/FunctionTemplate/g, 'Napi::FunctionReference'],
-
-  [/([ ]*)Nan::SetPrototypeMethod\(\w+, "(\w+)", (\w+)\);/g, '$1InstanceMethod("$2", &$3),'],
-  [/([ ]*)(?:\w+\.Reset\(\w+\);\s+)?\(target\)\.Set\("(\w+)",\s*Nan::GetFunction\((\w+)\)\);/gm,
-    '});\n\n' +
-    '$1constructor = Napi::Persistent($3);\n' +
-    '$1constructor.SuppressDestruct();\n' +
-    '$1target.Set("$2", $3);'],
-
-  // TODO: Other attribute combinations
-  [/static_cast<PropertyAttribute>\(ReadOnly\s*\|\s*DontDelete\)/gm,
-    'static_cast<napi_property_attributes>(napi_enumerable | napi_configurable)'],
-
-  [/([\w\d:<>]+?)::Cast\((.+?)\)/g, '$2.As<$1>()'],
-
-  [/\*Nan::Utf8String\(([^)]+)\)/g, '$1->As<Napi::String>().Utf8Value().c_str()'],
-  [/Nan::Utf8String +(\w+)\(([^)]+)\)/g, 'std::string $1 = $2.As<Napi::String>()'],
-  [/Nan::Utf8String/g, 'std::string'],
-
-  [/v8::String::Utf8Value (.+?)\((.+?)\)/g, 'Napi::String $1(env, $2)'],
-  [/String::Utf8Value (.+?)\((.+?)\)/g, 'Napi::String $1(env, $2)'],
-  [/\.length\(\)/g, '.Length()'],
-
-  [/Nan::MakeCallback\(([^,]+),[\s\\]+([^,]+),/gm, '$2.MakeCallback($1,'],
-
-  [/class\s+(\w+)\s*:\s*public\s+Nan::ObjectWrap/g, 'class $1 : public Napi::ObjectWrap<$1>'],
-  [/(\w+)\(([^)]*)\)\s*:\s*Nan::ObjectWrap\(\)\s*(,)?/gm, '$1($2) : Napi::ObjectWrap<$1>()$3'],
-
-  // HandleOKCallback to OnOK
-  [/HandleOKCallback/g, 'OnOK'],
-  // HandleErrorCallback to OnError
-  [/HandleErrorCallback/g, 'OnError'],
-
-  // ex. .As<Function>() to .As<Napi::Object>()
-  [/\.As<v8::(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>\(\)/g, '.As<Napi::$1>()'],
-  [/\.As<(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>\(\)/g, '.As<Napi::$1>()'],
-
-  // ex. Nan::New<Number>(info[0]) to Napi::Number::New(info[0])
-  [/Nan::New<(v8::)*Integer>\((.+?)\)/g, 'Napi::Number::New(env, $2)'],
-  [/Nan::New\(([0-9.]+)\)/g, 'Napi::Number::New(env, $1)'],
-  [/Nan::New<(v8::)*String>\("(.+?)"\)/g, 'Napi::String::New(env, "$2")'],
-  [/Nan::New\("(.+?)"\)/g, 'Napi::String::New(env, "$1")'],
-  [/Nan::New<(v8::)*(.+?)>\(\)/g, 'Napi::$2::New(env)'],
-  [/Nan::New<(.+?)>\(\)/g, 'Napi::$1::New(env)'],
-  [/Nan::New<(v8::)*(.+?)>\(/g, 'Napi::$2::New(env, '],
-  [/Nan::New<(.+?)>\(/g, 'Napi::$1::New(env, '],
-  [/Nan::NewBuffer\(/g, 'Napi::Buffer<char>::New(env, '],
-  // TODO: Properly handle this
-  [/Nan::New\(/g, 'Napi::New(env, '],
-
-  [/\.IsInt32\(\)/g, '.IsNumber()'],
-  [/->IsInt32\(\)/g, '.IsNumber()'],
-
-  [/(.+?)->BooleanValue\(\)/g, '$1.As<Napi::Boolean>().Value()'],
-  [/(.+?)->Int32Value\(\)/g, '$1.As<Napi::Number>().Int32Value()'],
-  [/(.+?)->Uint32Value\(\)/g, '$1.As<Napi::Number>().Uint32Value()'],
-  [/(.+?)->IntegerValue\(\)/g, '$1.As<Napi::Number>().Int64Value()'],
-  [/(.+?)->NumberValue\(\)/g, '$1.As<Napi::Number>().DoubleValue()'],
-
-  // ex. Nan::To<bool>(info[0]) to info[0].Value()
-  [/Nan::To<v8::(Boolean|String|Number|Object|Array|Symbol|Function)>\((.+?)\)/g, '$2.To<Napi::$1>()'],
-  [/Nan::To<(Boolean|String|Number|Object|Array|Symbol|Function)>\((.+?)\)/g, '$2.To<Napi::$1>()'],
-  // ex. Nan::To<bool>(info[0]) to info[0].As<Napi::Boolean>().Value()
-  [/Nan::To<bool>\((.+?)\)/g, '$1.As<Napi::Boolean>().Value()'],
-  // ex. Nan::To<int>(info[0]) to info[0].As<Napi::Number>().Int32Value()
-  [/Nan::To<int>\((.+?)\)/g, '$1.As<Napi::Number>().Int32Value()'],
-  // ex. Nan::To<int32_t>(info[0]) to info[0].As<Napi::Number>().Int32Value()
-  [/Nan::To<int32_t>\((.+?)\)/g, '$1.As<Napi::Number>().Int32Value()'],
-  // ex. Nan::To<uint32_t>(info[0]) to info[0].As<Napi::Number>().Uint32Value()
-  [/Nan::To<uint32_t>\((.+?)\)/g, '$1.As<Napi::Number>().Uint32Value()'],
-  // ex. Nan::To<int64_t>(info[0]) to info[0].As<Napi::Number>().Int64Value()
-  [/Nan::To<int64_t>\((.+?)\)/g, '$1.As<Napi::Number>().Int64Value()'],
-  // ex. Nan::To<float>(info[0]) to info[0].As<Napi::Number>().FloatValue()
-  [/Nan::To<float>\((.+?)\)/g, '$1.As<Napi::Number>().FloatValue()'],
-  // ex. Nan::To<double>(info[0]) to info[0].As<Napi::Number>().DoubleValue()
-  [/Nan::To<double>\((.+?)\)/g, '$1.As<Napi::Number>().DoubleValue()'],
-
-  [/Nan::New\((\w+)\)->HasInstance\((\w+)\)/g, '$2.InstanceOf($1.Value())'],
-
-  [/Nan::Has\(([^,]+),\s*/gm, '($1).Has('],
-  [/\.Has\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\)/gm, '.Has($1)'],
-  [/\.Has\([\s|\\]*Nan::New\(([^)]+)\)\)/gm, '.Has($1)'],
-
-  [/Nan::Get\(([^,]+),\s*/gm, '($1).Get('],
-  [/\.Get\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\)/gm, '.Get($1)'],
-  [/\.Get\([\s|\\]*Nan::New\(([^)]+)\)\)/gm, '.Get($1)'],
-
-  [/Nan::Set\(([^,]+),\s*/gm, '($1).Set('],
-  [/\.Set\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\s*,/gm, '.Set($1,'],
-  [/\.Set\([\s|\\]*Nan::New\(([^)]+)\)\s*,/gm, '.Set($1,'],
-
-  // ex. node::Buffer::HasInstance(info[0]) to info[0].IsBuffer()
-  [/node::Buffer::HasInstance\((.+?)\)/g, '$1.IsBuffer()'],
-  // ex. node::Buffer::Length(info[0]) to info[0].Length()
-  [/node::Buffer::Length\((.+?)\)/g, '$1.As<Napi::Buffer<char>>().Length()'],
-  // ex. node::Buffer::Data(info[0]) to info[0].Data()
-  [/node::Buffer::Data\((.+?)\)/g, '$1.As<Napi::Buffer<char>>().Data()'],
-  [/Nan::CopyBuffer\(/g, 'Napi::Buffer::Copy(env, '],
-
-  // Nan::AsyncQueueWorker(worker)
-  [/Nan::AsyncQueueWorker\((.+)\);/g, '$1.Queue();'],
-  [/Nan::(Undefined|Null|True|False)\(\)/g, 'env.$1()'],
-
-  // Nan::ThrowError(error) to Napi::Error::New(env, error).ThrowAsJavaScriptException()
-  [/([ ]*)return Nan::Throw(\w*?)Error\((.+?)\);/g, '$1Napi::$2Error::New(env, $3).ThrowAsJavaScriptException();\n$1return env.Null();'],
-  [/Nan::Throw(\w*?)Error\((.+?)\);\n(\s*)return;/g, 'Napi::$1Error::New(env, $2).ThrowAsJavaScriptException();\n$3return env.Null();'],
-  [/Nan::Throw(\w*?)Error\((.+?)\);/g, 'Napi::$1Error::New(env, $2).ThrowAsJavaScriptException();\n'],
-  // Nan::RangeError(error) to Napi::RangeError::New(env, error)
-  [/Nan::(\w*?)Error\((.+)\)/g, 'Napi::$1Error::New(env, $2)'],
-
-  [/Nan::Set\((.+?),\n* *(.+?),\n* *(.+?),\n* *(.+?)\)/g, '$1.Set($2, $3, $4)'],
-
-  [/Nan::(Escapable)?HandleScope\s+(\w+)\s*;/g, 'Napi::$1HandleScope $2(env);'],
-  [/Nan::(Escapable)?HandleScope/g, 'Napi::$1HandleScope'],
-  [/Nan::ForceSet\(([^,]+), ?/g, '$1->DefineProperty('],
-  [/\.ForceSet\(Napi::String::New\(env, "(\w+)"\),\s*?/g, '.DefineProperty("$1", '],
-  // [ /Nan::GetPropertyNames\(([^,]+)\)/, '$1->GetPropertyNames()' ],
-  [/Nan::Equals\(([^,]+),/g, '$1.StrictEquals('],
-
-  [/(.+)->Set\(/g, '$1.Set('],
-
-  [/Nan::Callback/g, 'Napi::FunctionReference'],
-
-  [/Nan::Persistent<Object>/g, 'Napi::ObjectReference'],
-  [/Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target/g, 'Napi::Env& env, Napi::Object& target'],
-
-  [/(\w+)\*\s+(\w+)\s*=\s*Nan::ObjectWrap::Unwrap<\w+>\(info\.This\(\)\);/g, '$1* $2 = this;'],
-  [/Nan::ObjectWrap::Unwrap<(\w+)>\((.*)\);/g, '$2.Unwrap<$1>();'],
-
-  [/Nan::NAN_METHOD_RETURN_TYPE/g, 'void'],
-  [/NAN_INLINE/g, 'inline'],
-
-  [/Nan::NAN_METHOD_ARGS_TYPE/g, 'const Napi::CallbackInfo&'],
-  [/NAN_METHOD\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'],
-  [/static\s*NAN_GETTER\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'],
-  [/NAN_GETTER\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'],
-  [/static\s*NAN_SETTER\(([\w\d:]+?)\)/g, 'void $1(const Napi::CallbackInfo& info, const Napi::Value& value)'],
-  [/NAN_SETTER\(([\w\d:]+?)\)/g, 'void $1(const Napi::CallbackInfo& info, const Napi::Value& value)'],
-  [/void Init\((v8::)*Local<(v8::)*Object> exports\)/g, 'Napi::Object Init(Napi::Env env, Napi::Object exports)'],
-  [/NAN_MODULE_INIT\(([\w\d:]+?)\);/g, 'Napi::Object $1(Napi::Env env, Napi::Object exports);'],
-  [/NAN_MODULE_INIT\(([\w\d:]+?)\)/g, 'Napi::Object $1(Napi::Env env, Napi::Object exports)'],
-
-  [/::(Init(?:ialize)?)\(target\)/g, '::$1(env, target, module)'],
-  [/constructor_template/g, 'constructor'],
-
-  [/Nan::FunctionCallbackInfo<(v8::)?Value>[ ]*& [ ]*info\)[ ]*{\n*([ ]*)/gm, 'Napi::CallbackInfo& info) {\n$2Napi::Env env = info.Env();\n$2'],
-  [/Nan::FunctionCallbackInfo<(v8::)*Value>\s*&\s*info\);/g, 'Napi::CallbackInfo& info);'],
-  [/Nan::FunctionCallbackInfo<(v8::)*Value>\s*&/g, 'Napi::CallbackInfo&'],
-
-  [/Buffer::HasInstance\(([^)]+)\)/g, '$1.IsBuffer()'],
-
-  [/info\[(\d+)\]->/g, 'info[$1].'],
-  [/info\[([\w\d]+)\]->/g, 'info[$1].'],
-  [/info\.This\(\)->/g, 'info.This().'],
-  [/->Is(Object|String|Int32|Number)\(\)/g, '.Is$1()'],
-  [/info.GetReturnValue\(\).SetUndefined\(\)/g, 'return env.Undefined()'],
-  [/info\.GetReturnValue\(\)\.Set\(((\n|.)+?)\);/g, 'return $1;'],
-
-  // ex. Local<Value> to Napi::Value
-  [/v8::Local<v8::(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>/g, 'Napi::$1'],
-  [/Local<(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>/g, 'Napi::$1'],
-
-  // Declare an env in helper functions that take a Napi::Value
-  [/(\w+)\(Napi::Value (\w+)(,\s*[^()]+)?\)\s*{\n*([ ]*)/gm, '$1(Napi::Value $2$3) {\n$4Napi::Env env = $2.Env();\n$4'],
-
-  // delete #include <node.h> and/or <v8.h>
-  [/#include +(<|")(?:node|nan).h("|>)/g, '#include $1napi.h$2\n#include $1uv.h$2'],
-  // NODE_MODULE to NODE_API_MODULE
-  [/NODE_MODULE/g, 'NODE_API_MODULE'],
-  [/Nan::/g, 'Napi::'],
-  [/nan.h/g, 'napi.h'],
-
-  // delete .FromJust()
-  [/\.FromJust\(\)/g, ''],
-  // delete .ToLocalCheck()
-  [/\.ToLocalChecked\(\)/g, ''],
-  [/^.*->SetInternalFieldCount\(.*$/gm, ''],
-
-  // replace using node; and/or using v8; to using Napi;
-  [/using (node|v8);/g, 'using Napi;'],
-  [/using namespace (node|Nan|v8);/g, 'using namespace Napi;'],
-  // delete using v8::Local;
-  [/using v8::Local;\n/g, ''],
-  // replace using v8::XXX; with using Napi::XXX
-  [/using v8::([A-Za-z]+);/g, 'using Napi::$1;']
-
-];
-
-const paths = listFiles(dir);
-paths.forEach(function (dirEntry) {
-  const filename = dirEntry.split('\\').pop().split('/').pop();
-
-  // Check whether the file is a source file or a config file
-  // then execute function accordingly
-  const sourcePattern = /.+\.h|.+\.cc|.+\.cpp/;
-  if (sourcePattern.test(filename)) {
-    convertFile(dirEntry, SourceFileOperations);
-  } else if (ConfigFileOperations[filename] != null) {
-    convertFile(dirEntry, ConfigFileOperations[filename]);
-  }
-});
-
-function listFiles (dir, filelist) {
-  const files = fs.readdirSync(dir);
-  filelist = filelist || [];
-  files.forEach(function (file) {
-    if (file === 'node_modules') {
-      return;
-    }
-
-    if (fs.statSync(path.join(dir, file)).isDirectory()) {
-      filelist = listFiles(path.join(dir, file), filelist);
-    } else {
-      filelist.push(path.join(dir, file));
-    }
-  });
-  return filelist;
-}
-
-function convert (content, operations) {
-  for (let i = 0; i < operations.length; i++) {
-    const operation = operations[i];
-    content = content.replace(operation[0], operation[1]);
-  }
-  return content;
-}
-
-function convertFile (fileName, operations) {
-  fs.readFile(fileName, 'utf-8', function (err, file) {
-    if (err) throw err;
-
-    file = convert(file, operations);
-
-    fs.writeFile(fileName, file, function (err) {
-      if (err) throw err;
-    });
-  });
-}

package/node_modules/node-gyp-build/README.md

@@ -1,58 +0,0 @@
-# node-gyp-build
-
-> Build tool and bindings loader for [`node-gyp`][node-gyp] that supports prebuilds.
-
-```
-npm install node-gyp-build
-```
-
-[![Test](https://github.com/prebuild/node-gyp-build/actions/workflows/test.yml/badge.svg)](https://github.com/prebuild/node-gyp-build/actions/workflows/test.yml)
-
-Use together with [`prebuildify`][prebuildify] to easily support prebuilds for your native modules.
-
-## Usage
-
-> **Note.** Prebuild names have changed in [`prebuildify@3`][prebuildify] and `node-gyp-build@4`. Please see the documentation below.
-
-`node-gyp-build` works similar to [`node-gyp build`][node-gyp] except that it will check if a build or prebuild is present before rebuilding your project.
-
-It's main intended use is as an npm install script and bindings loader for native modules that bundle prebuilds using [`prebuildify`][prebuildify].
-
-First add `node-gyp-build` as an install script to your native project
-
-``` js
-{
-  ...
-  "scripts": {
-    "install": "node-gyp-build"
-  }
-}
-```
-
-Then in your `index.js`, instead of using the [`bindings`](https://www.npmjs.com/package/bindings) module use `node-gyp-build` to load your binding.
-
-``` js
-var binding = require('node-gyp-build')(__dirname)
-```
-
-If you do these two things and bundle prebuilds with [`prebuildify`][prebuildify] your native module will work for most platforms
-without having to compile on install time AND will work in both node and electron without the need to recompile between usage.
-
-Users can override `node-gyp-build` and force compiling by doing `npm install --build-from-source`.
-
-Prebuilds will be attempted loaded from `MODULE_PATH/prebuilds/...` and then next `EXEC_PATH/prebuilds/...` (the latter allowing use with `zeit/pkg`)
-
-## Supported prebuild names
-
-If so desired you can bundle more specific flavors, for example `musl` builds to support Alpine, or targeting a numbered ARM architecture version.
-
-These prebuilds can be bundled in addition to generic prebuilds; `node-gyp-build` will try to find the most specific flavor first. Prebuild filenames are composed of _tags_. The runtime tag takes precedence, as does an `abi` tag over `napi`. For more details on tags, please see [`prebuildify`][prebuildify].
-
-Values for the `libc` and `armv` tags are auto-detected but can be overridden through the `LIBC` and `ARM_VERSION` environment variables, respectively.
-
-## License
-
-MIT
-
-[prebuildify]: https://github.com/prebuild/prebuildify
-[node-gyp]: https://www.npmjs.com/package/node-gyp

package/node_modules/node-gyp-build/SECURITY.md

@@ -1,5 +0,0 @@
-## Security contact information
-
-To report a security vulnerability, please use the
-[Tidelift security contact](https://tidelift.com/security).
-Tidelift will coordinate the fix and disclosure.

package/node_modules/node-gyp-build/bin.js

@@ -1,84 +0,0 @@
-#!/usr/bin/env node
-
-var proc = require('child_process')
-var os = require('os')
-var path = require('path')
-
-if (!buildFromSource()) {
-  proc.exec('node-gyp-build-test', function (err, stdout, stderr) {
-    if (err) {
-      if (verbose()) console.error(stderr)
-      preinstall()
-    }
-  })
-} else {
-  preinstall()
-}
-
-function build () {
-  var win32 = os.platform() === 'win32'
-  var shell = win32
-  var args = [win32 ? 'node-gyp.cmd' : 'node-gyp', 'rebuild']
-
-  try {
-    var pkg = require('node-gyp/package.json')
-    args = [
-      process.execPath,
-      path.join(require.resolve('node-gyp/package.json'), '..', typeof pkg.bin === 'string' ? pkg.bin : pkg.bin['node-gyp']),
-      'rebuild'
-    ]
-    shell = false
-  } catch (_) {}
-
-  proc.spawn(args[0], args.slice(1), { stdio: 'inherit', shell, windowsHide: true }).on('exit', function (code) {
-    if (code || !process.argv[3]) process.exit(code)
-    exec(process.argv[3]).on('exit', function (code) {
-      process.exit(code)
-    })
-  })
-}
-
-function preinstall () {
-  if (!process.argv[2]) return build()
-  exec(process.argv[2]).on('exit', function (code) {
-    if (code) process.exit(code)
-    build()
-  })
-}
-
-function exec (cmd) {
-  if (process.platform !== 'win32') {
-    var shell = os.platform() === 'android' ? 'sh' : true
-    return proc.spawn(cmd, [], {
-      shell,
-      stdio: 'inherit'
-    })
-  }
-
-  return proc.spawn(cmd, [], {
-    windowsVerbatimArguments: true,
-    stdio: 'inherit',
-    shell: true,
-    windowsHide: true
-  })
-}
-
-function buildFromSource () {
-  return hasFlag('--build-from-source') || process.env.npm_config_build_from_source === 'true'
-}
-
-function verbose () {
-  return hasFlag('--verbose') || process.env.npm_config_loglevel === 'verbose'
-}
-
-// TODO (next major): remove in favor of env.npm_config_* which works since npm
-// 0.1.8 while npm_config_argv will stop working in npm 7. See npm/rfcs#90
-function hasFlag (flag) {
-  if (!process.env.npm_config_argv) return false
-
-  try {
-    return JSON.parse(process.env.npm_config_argv).original.indexOf(flag) !== -1
-  } catch (_) {
-    return false
-  }
-}

package/node_modules/node-gyp-build/build-test.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-
-process.env.NODE_ENV = 'test'
-
-var path = require('path')
-var test = null
-
-try {
-  var pkg = require(path.join(process.cwd(), 'package.json'))
-  if (pkg.name && process.env[pkg.name.toUpperCase().replace(/-/g, '_')]) {
-    process.exit(0)
-  }
-  test = pkg.prebuild.test
-} catch (err) {
-  //  do nothing
-}
-
-if (test) require(path.join(process.cwd(), test))
-else require('./')()

package/node_modules/node-gyp-build/index.js

@@ -1,6 +0,0 @@
-const runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require // eslint-disable-line
-if (typeof runtimeRequire.addon === 'function') { // if the platform supports native resolving prefer that
-  module.exports = runtimeRequire.addon.bind(runtimeRequire)
-} else { // else use the runtime version here
-  module.exports = require('./node-gyp-build.js')
-}