pnpm 11.23.0 → 11.25.0

package/artifacts/exe/dist/node_modules/node-gyp/lib/create-config-gypi.js

@@ -1,153 +0,0 @@
-'use strict'
-
-const fs = require('graceful-fs').promises
-const log = require('./log')
-const path = require('path')
-
-function parseConfigGypi (config) {
-  // translated from tools/js2c.py of Node.js
-  // 1. string comments
-  config = config.replace(/#.*/g, '')
-  // 2. join multiline strings
-  config = config.replace(/'$\s+'/mg, '')
-  // 3. normalize string literals from ' into "
-  config = config.replace(/'/g, '"')
-  return JSON.parse(config)
-}
-
-async function getBaseConfigGypi ({ gyp, nodeDir }) {
-  // try reading $nodeDir/include/node/config.gypi first when:
-  // 1. --dist-url or --nodedir is specified
-  // 2. and --force-process-config is not specified
-  const useCustomHeaders = gyp.opts.nodedir || gyp.opts.disturl || gyp.opts['dist-url']
-  const shouldReadConfigGypi = useCustomHeaders && !gyp.opts['force-process-config']
-  if (shouldReadConfigGypi && nodeDir) {
-    try {
-      const baseConfigGypiPath = path.resolve(nodeDir, 'include/node/config.gypi')
-      const baseConfigGypi = await fs.readFile(baseConfigGypiPath)
-      return parseConfigGypi(baseConfigGypi.toString())
-    } catch (err) {
-      log.warn('read config.gypi', err.message)
-    }
-  }
-
-  // fallback to process.config if it is invalid
-  return JSON.parse(JSON.stringify(process.config))
-}
-
-async function getCurrentConfigGypi ({ gyp, nodeDir, vsInfo, python }) {
-  const config = await getBaseConfigGypi({ gyp, nodeDir })
-  if (!config.target_defaults) {
-    config.target_defaults = {}
-  }
-  if (!config.variables) {
-    config.variables = {}
-  }
-
-  const defaults = config.target_defaults
-  const variables = config.variables
-
-  // don't inherit the "defaults" from the base config.gypi.
-  // doing so could cause problems in cases where the `node` executable was
-  // compiled on a different machine (with different lib/include paths) than
-  // the machine where the addon is being built to
-  defaults.cflags = []
-  defaults.defines = []
-  defaults.include_dirs = []
-  defaults.libraries = []
-
-  // set the default_configuration prop
-  if ('debug' in gyp.opts) {
-    defaults.default_configuration = gyp.opts.debug ? 'Debug' : 'Release'
-  }
-
-  if (!defaults.default_configuration) {
-    defaults.default_configuration = 'Release'
-  }
-
-  // set the target_arch variable
-  variables.target_arch = gyp.opts.arch || process.arch || 'ia32'
-  if (variables.target_arch === 'arm64') {
-    defaults.msvs_configuration_platform = 'ARM64'
-    defaults.xcode_configuration_platform = 'arm64'
-  }
-
-  // set the node development directory
-  variables.nodedir = nodeDir
-
-  // set the configured Python path
-  variables.python = python
-
-  // disable -T "thin" static archives by default
-  variables.standalone_static_library = gyp.opts.thin ? 0 : 1
-
-  if (process.platform === 'win32') {
-    defaults.msbuild_toolset = vsInfo.toolset
-    if (vsInfo.sdk) {
-      defaults.msvs_windows_target_platform_version = vsInfo.sdk
-    }
-    if (variables.target_arch === 'arm64') {
-      if (vsInfo.versionMajor > 15 ||
-          (vsInfo.versionMajor === 15 && vsInfo.versionMajor >= 9)) {
-        defaults.msvs_enable_marmasm = 1
-      } else {
-        log.warn('Compiling ARM64 assembly is only available in\n' +
-          'Visual Studio 2017 version 15.9 and above')
-      }
-    }
-    variables.msbuild_path = vsInfo.msBuild
-    if (config.variables.clang === 1) {
-      config.variables.clang = 0
-    }
-  }
-
-  // loop through the rest of the opts and add the unknown ones as variables.
-  // this allows for module-specific configure flags like:
-  //
-  //   $ node-gyp configure --shared-libxml2
-  Object.keys(gyp.opts).forEach(function (opt) {
-    if (opt === 'argv') {
-      return
-    }
-    if (opt in gyp.configDefs) {
-      return
-    }
-    variables[opt.replace(/-/g, '_')] = gyp.opts[opt]
-  })
-
-  return config
-}
-
-async function createConfigGypi ({ gyp, buildDir, nodeDir, vsInfo, python }) {
-  const configFilename = 'config.gypi'
-  const configPath = path.resolve(buildDir, configFilename)
-
-  log.verbose('build/' + configFilename, 'creating config file')
-
-  const config = await getCurrentConfigGypi({ gyp, nodeDir, vsInfo, python })
-
-  // ensures that any boolean values in config.gypi get stringified
-  function boolsToString (k, v) {
-    if (typeof v === 'boolean') {
-      return String(v)
-    }
-    return v
-  }
-
-  log.silly('build/' + configFilename, config)
-
-  // now write out the config.gypi file to the build/ dir
-  const prefix = '# Do not edit. File was generated by node-gyp\'s "configure" step'
-
-  const json = JSON.stringify(config, boolsToString, 2)
-  log.verbose('build/' + configFilename, 'writing out config file: %s', configPath)
-  await fs.writeFile(configPath, [prefix, json, ''].join('\n'))
-
-  return configPath
-}
-
-module.exports = {
-  createConfigGypi,
-  parseConfigGypi,
-  getCurrentConfigGypi
-}

package/artifacts/exe/dist/node_modules/node-gyp/lib/download.js

@@ -1,86 +0,0 @@
-const { Readable } = require('stream')
-const { EnvHttpProxyAgent } = require('undici')
-const { promises: fs } = require('graceful-fs')
-const log = require('./log')
-
-async function download (gyp, url) {
-  log.http('GET', url)
-
-  const requestOpts = {
-    headers: {
-      'User-Agent': `node-gyp v${gyp.version} (node ${process.version})`,
-      Connection: 'keep-alive'
-    },
-    dispatcher: await createDispatcher(gyp)
-  }
-
-  let res
-  try {
-    res = await fetch(url, requestOpts)
-  } catch (err) {
-    // Built-in fetch wraps low-level errors in "TypeError: fetch failed" with
-    // the underlying error on .cause. Callers inspect .code (e.g. ENOTFOUND).
-    if (err.cause) {
-      throw err.cause
-    }
-    throw err
-  }
-
-  log.http(res.status, res.url)
-
-  const body = res.body ? Readable.fromWeb(res.body) : Readable.from([])
-  return {
-    status: res.status,
-    url: res.url,
-    body,
-    text: async () => {
-      let data = ''
-      body.setEncoding('utf8')
-      for await (const chunk of body) {
-        data += chunk
-      }
-      return data
-    }
-  }
-}
-
-async function createDispatcher (gyp) {
-  const env = process.env
-  const hasProxyEnv = env.http_proxy || env.HTTP_PROXY || env.https_proxy || env.HTTPS_PROXY
-  if (!gyp.opts.proxy && !gyp.opts.cafile && !hasProxyEnv) {
-    return undefined
-  }
-
-  const opts = {}
-  if (gyp.opts.cafile) {
-    const ca = await readCAFile(gyp.opts.cafile)
-    // EnvHttpProxyAgent forwards opts to both its internal Agent (direct) and
-    // ProxyAgent (proxied). Agent reads TLS config from `connect`; ProxyAgent
-    // reads it from `requestTls` (origin) / `proxyTls` (proxy). Set all three
-    // so the custom CA is applied regardless of which path a request takes.
-    opts.connect = { ca }
-    opts.requestTls = { ca }
-    opts.proxyTls = { ca }
-  }
-  if (gyp.opts.proxy) {
-    opts.httpProxy = gyp.opts.proxy
-    opts.httpsProxy = gyp.opts.proxy
-  }
-  if (gyp.opts.noproxy) {
-    opts.noProxy = gyp.opts.noproxy
-  }
-  return new EnvHttpProxyAgent(opts)
-}
-
-async function readCAFile (filename) {
-  // The CA file can contain multiple certificates so split on certificate
-  // boundaries.  [\S\s]*? is used to match everything including newlines.
-  const ca = await fs.readFile(filename, 'utf8')
-  const re = /(-----BEGIN CERTIFICATE-----[\S\s]*?-----END CERTIFICATE-----)/g
-  return ca.match(re)
-}
-
-module.exports = {
-  download,
-  readCAFile
-}

package/artifacts/exe/dist/node_modules/node-gyp/lib/find-node-directory.js

@@ -1,63 +0,0 @@
-'use strict'
-
-const path = require('path')
-const log = require('./log')
-
-function findNodeDirectory (scriptLocation, processObj) {
-  // set dirname and process if not passed in
-  // this facilitates regression tests
-  if (scriptLocation === undefined) {
-    scriptLocation = __dirname
-  }
-  if (processObj === undefined) {
-    processObj = process
-  }
-
-  // Have a look to see what is above us, to try and work out where we are
-  const npmParentDirectory = path.join(scriptLocation, '../../../..')
-  log.verbose('node-gyp root', 'npm_parent_directory is ' +
-              path.basename(npmParentDirectory))
-  let nodeRootDir = ''
-
-  log.verbose('node-gyp root', 'Finding node root directory')
-  if (path.basename(npmParentDirectory) === 'deps') {
-    // We are in a build directory where this script lives in
-    // deps/npm/node_modules/node-gyp/lib
-    nodeRootDir = path.join(npmParentDirectory, '..')
-    log.verbose('node-gyp root', 'in build directory, root = ' +
-                nodeRootDir)
-  } else if (path.basename(npmParentDirectory) === 'node_modules') {
-    // We are in a node install directory where this script lives in
-    // lib/node_modules/npm/node_modules/node-gyp/lib or
-    // node_modules/npm/node_modules/node-gyp/lib depending on the
-    // platform
-    if (processObj.platform === 'win32') {
-      nodeRootDir = path.join(npmParentDirectory, '..')
-    } else {
-      nodeRootDir = path.join(npmParentDirectory, '../..')
-    }
-    log.verbose('node-gyp root', 'in install directory, root = ' +
-                nodeRootDir)
-  } else {
-    // We don't know where we are, try working it out from the location
-    // of the node binary
-    const nodeDir = path.dirname(processObj.execPath)
-    const directoryUp = path.basename(nodeDir)
-    if (directoryUp === 'bin') {
-      nodeRootDir = path.join(nodeDir, '..')
-    } else if (directoryUp === 'Release' || directoryUp === 'Debug') {
-      // If we are a recently built node, and the directory structure
-      // is that of a repository. If we are on Windows then we only need
-      // to go one level up, everything else, two
-      if (processObj.platform === 'win32') {
-        nodeRootDir = path.join(nodeDir, '..')
-      } else {
-        nodeRootDir = path.join(nodeDir, '../..')
-      }
-    }
-    // Else return the default blank, "".
-  }
-  return nodeRootDir
-}
-
-module.exports = findNodeDirectory

package/artifacts/exe/dist/node_modules/node-gyp/lib/find-python.js

@@ -1,304 +0,0 @@
-'use strict'
-
-const log = require('./log')
-const semver = require('semver')
-const { execFile } = require('./util')
-const win = process.platform === 'win32'
-
-function getOsUserInfo () {
-  try {
-    return require('os').userInfo().username
-  } catch {}
-}
-
-const systemDrive = process.env.SystemDrive || 'C:'
-const username = process.env.USERNAME || process.env.USER || getOsUserInfo()
-const localAppData = process.env.LOCALAPPDATA || `${systemDrive}\\${username}\\AppData\\Local`
-const foundLocalAppData = process.env.LOCALAPPDATA || username
-const programFiles = process.env.ProgramW6432 || process.env.ProgramFiles || `${systemDrive}\\Program Files`
-const programFilesX86 = process.env['ProgramFiles(x86)'] || `${programFiles} (x86)`
-
-const winDefaultLocationsArray = []
-for (const majorMinor of ['311', '310', '39', '38']) {
-  if (foundLocalAppData) {
-    winDefaultLocationsArray.push(
-      `${localAppData}\\Programs\\Python\\Python${majorMinor}\\python.exe`,
-      `${programFiles}\\Python${majorMinor}\\python.exe`,
-      `${localAppData}\\Programs\\Python\\Python${majorMinor}-32\\python.exe`,
-      `${programFiles}\\Python${majorMinor}-32\\python.exe`,
-      `${programFilesX86}\\Python${majorMinor}-32\\python.exe`
-    )
-  } else {
-    winDefaultLocationsArray.push(
-      `${programFiles}\\Python${majorMinor}\\python.exe`,
-      `${programFiles}\\Python${majorMinor}-32\\python.exe`,
-      `${programFilesX86}\\Python${majorMinor}-32\\python.exe`
-    )
-  }
-}
-
-class PythonFinder {
-  static findPython = (...args) => new PythonFinder(...args).findPython()
-
-  log = log.withPrefix('find Python')
-  argsExecutable = ['-c', 'import sys; sys.stdout.buffer.write(sys.executable.encode(\'utf-8\'));']
-  argsVersion = ['-c', 'import sys; print("%s.%s.%s" % sys.version_info[:3]);']
-  semverRange = '>=3.6.0'
-
-  // These can be overridden for testing:
-  execFile = execFile
-  env = process.env
-  win = win
-  pyLauncher = 'py.exe'
-  winDefaultLocations = winDefaultLocationsArray
-
-  constructor (configPython) {
-    this.configPython = configPython
-    this.errorLog = []
-  }
-
-  // Logs a message at verbose level, but also saves it to be displayed later
-  // at error level if an error occurs. This should help diagnose the problem.
-  addLog (message) {
-    this.log.verbose(message)
-    this.errorLog.push(message)
-  }
-
-  // Find Python by trying a sequence of possibilities.
-  // Ignore errors, keep trying until Python is found.
-  async findPython () {
-    const SKIP = 0
-    const FAIL = 1
-    const toCheck = (() => {
-      if (this.env.NODE_GYP_FORCE_PYTHON) {
-        return [{
-          before: () => {
-            this.addLog(
-              'checking Python explicitly set from NODE_GYP_FORCE_PYTHON')
-            this.addLog('- process.env.NODE_GYP_FORCE_PYTHON is ' +
-              `"${this.env.NODE_GYP_FORCE_PYTHON}"`)
-          },
-          check: () => this.checkCommand(this.env.NODE_GYP_FORCE_PYTHON)
-        }]
-      }
-
-      const checks = [
-        {
-          before: () => {
-            if (!this.configPython) {
-              this.addLog('--python was not set on the command line')
-              return SKIP
-            }
-            this.addLog(`--python=${this.configPython} was set on the command line`)
-          },
-          check: () => this.checkCommand(this.configPython)
-        },
-        {
-          before: () => {
-            if (!this.env.PYTHON) {
-              this.addLog('Python is not set from environment variable ' +
-                'PYTHON')
-              return SKIP
-            }
-            this.addLog('checking Python explicitly set from environment ' +
-              'variable PYTHON')
-            this.addLog(`- process.env.PYTHON is "${this.env.PYTHON}"`)
-          },
-          check: () => this.checkCommand(this.env.PYTHON)
-        }
-      ]
-
-      if (this.win) {
-        checks.push({
-          before: () => {
-            this.addLog(
-              'checking if the py launcher can be used to find Python 3')
-          },
-          check: () => this.checkPyLauncher()
-        })
-      }
-
-      checks.push(...[
-        {
-          before: () => { this.addLog('checking if "python3" can be used') },
-          check: () => this.checkCommand('python3')
-        },
-        {
-          before: () => { this.addLog('checking if "python" can be used') },
-          check: () => this.checkCommand('python')
-        }
-      ])
-
-      if (this.win) {
-        for (let i = 0; i < this.winDefaultLocations.length; ++i) {
-          const location = this.winDefaultLocations[i]
-          checks.push({
-            before: () => this.addLog(`checking if Python is ${location}`),
-            check: () => this.checkExecPath(location)
-          })
-        }
-      }
-
-      return checks
-    })()
-
-    for (const check of toCheck) {
-      const before = check.before()
-      if (before === SKIP) {
-        continue
-      }
-      if (before === FAIL) {
-        return this.fail()
-      }
-      try {
-        return await check.check()
-      } catch (err) {
-        this.log.silly('runChecks: err = %j', (err && err.stack) || err)
-      }
-    }
-
-    return this.fail()
-  }
-
-  // Check if command is a valid Python to use.
-  // Will exit the Python finder on success.
-  // If on Windows, run in a CMD shell to support BAT/CMD launchers.
-  async checkCommand (command) {
-    let exec = command
-    let args = this.argsExecutable
-    let shell = false
-    if (this.win) {
-      // Arguments have to be manually quoted
-      exec = `"${exec}"`
-      args = args.map(a => `"${a}"`)
-      shell = true
-    }
-
-    this.log.verbose(`- executing "${command}" to get executable path`)
-    // Possible outcomes:
-    // - Error: not in PATH, not executable or execution fails
-    // - Gibberish: the next command to check version will fail
-    // - Absolute path to executable
-    try {
-      const execPath = await this.run(exec, args, shell)
-      this.addLog(`- executable path is "${execPath}"`)
-      return this.checkExecPath(execPath)
-    } catch (err) {
-      this.addLog(`- "${command}" is not in PATH or produced an error`)
-      throw err
-    }
-  }
-
-  // Check if the py launcher can find a valid Python to use.
-  // Will exit the Python finder on success.
-  // Distributions of Python on Windows by default install with the "py.exe"
-  // Python launcher which is more likely to exist than the Python executable
-  // being in the $PATH.
-  // Because the Python launcher supports Python 2 and Python 3, we should
-  // explicitly request a Python 3 version. This is done by supplying "-3" as
-  // the first command line argument. Since "py.exe -3" would be an invalid
-  // executable for "execFile", we have to use the launcher to figure out
-  // where the actual "python.exe" executable is located.
-  async checkPyLauncher () {
-    this.log.verbose(`- executing "${this.pyLauncher}" to get Python 3 executable path`)
-    // Possible outcomes: same as checkCommand
-    try {
-      const execPath = await this.run(this.pyLauncher, ['-3', ...this.argsExecutable], false)
-      this.addLog(`- executable path is "${execPath}"`)
-      return this.checkExecPath(execPath)
-    } catch (err) {
-      this.addLog(`- "${this.pyLauncher}" is not in PATH or produced an error`)
-      throw err
-    }
-  }
-
-  // Check if a Python executable is the correct version to use.
-  // Will exit the Python finder on success.
-  async checkExecPath (execPath) {
-    this.log.verbose(`- executing "${execPath}" to get version`)
-    // Possible outcomes:
-    // - Error: executable can not be run (likely meaning the command wasn't
-    //   a Python executable and the previous command produced gibberish)
-    // - Gibberish: somehow the last command produced an executable path,
-    //   this will fail when verifying the version
-    // - Version of the Python executable
-    try {
-      const version = await this.run(execPath, this.argsVersion, false)
-      this.addLog(`- version is "${version}"`)
-
-      const range = new semver.Range(this.semverRange)
-      let valid = false
-      try {
-        valid = range.test(version)
-      } catch (err) {
-        this.log.silly('range.test() threw:\n%s', err.stack)
-        this.addLog(`- "${execPath}" does not have a valid version`)
-        this.addLog('- is it a Python executable?')
-        throw err
-      }
-      if (!valid) {
-        this.addLog(`- version is ${version} - should be ${this.semverRange}`)
-        this.addLog('- THIS VERSION OF PYTHON IS NOT SUPPORTED')
-        throw new Error(`Found unsupported Python version ${version}`)
-      }
-      return this.succeed(execPath, version)
-    } catch (err) {
-      this.addLog(`- "${execPath}" could not be run`)
-      throw err
-    }
-  }
-
-  // Run an executable or shell command, trimming the output.
-  async run (exec, args, shell) {
-    const env = Object.assign({}, this.env)
-    env.TERM = 'dumb'
-    const opts = { env, shell }
-
-    this.log.silly('execFile: exec = %j', exec)
-    this.log.silly('execFile: args = %j', args)
-    this.log.silly('execFile: opts = %j', opts)
-    try {
-      const [err, stdout, stderr] = await this.execFile(exec, args, opts)
-      this.log.silly('execFile result: err = %j', (err && err.stack) || err)
-      this.log.silly('execFile result: stdout = %j', stdout)
-      this.log.silly('execFile result: stderr = %j', stderr)
-      return stdout.trim()
-    } catch (err) {
-      this.log.silly('execFile: threw:\n%s', err.stack)
-      throw err
-    }
-  }
-
-  succeed (execPath, version) {
-    this.log.info(`using Python version ${version} found at "${execPath}"`)
-    return execPath
-  }
-
-  fail () {
-    const errorLog = this.errorLog.join('\n')
-
-    const pathExample = this.win
-      ? 'C:\\Path\\To\\python.exe'
-      : '/path/to/pythonexecutable'
-    // For Windows 80 col console, use up to the column before the one marked
-    // with X (total 79 chars including logger prefix, 58 chars usable here):
-    //                                                           X
-    const info = [
-      '**********************************************************',
-      'You need to install the latest version of Python.',
-      'Node-gyp should be able to find and use Python. If not,',
-      'you can try one of the following options:',
-      `- Use the switch --python="${pathExample}"`,
-      '  (accepted by both node-gyp and npm)',
-      '- Set the environment variable PYTHON',
-      'For more information consult the documentation at:',
-      'https://github.com/nodejs/node-gyp#installation',
-      '**********************************************************'
-    ].join('\n')
-
-    this.log.error(`\n${errorLog}\n\n${info}\n`)
-    throw new Error('Could not find any Python installation to use')
-  }
-}
-
-module.exports = PythonFinder