fca-rqzax-remake 0.0.1-security → 8.19.2

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/exit-handler.js

@@ -0,0 +1,229 @@
+const os = require('os')
+const fs = require('fs')
+
+const log = require('./log-shim.js')
+const errorMessage = require('./error-message.js')
+const replaceInfo = require('./replace-info.js')
+
+const indent = (val) => Array.isArray(val) ? val.map(v => indent(v)) : `    ${val}`
+
+let npm = null // set by the cli
+let exitHandlerCalled = false
+let showLogFileError = false
+
+process.on('exit', code => {
+  log.disableProgress()
+
+  // process.emit is synchronous, so the timeEnd handler will run before the
+  // unfinished timer check below
+  process.emit('timeEnd', 'npm')
+
+  const hasLoadedNpm = npm?.config.loaded
+
+  // Unfinished timers can be read before config load
+  if (npm) {
+    for (const [name, timer] of npm.unfinishedTimers) {
+      log.verbose('unfinished npm timer', name, timer)
+    }
+  }
+
+  if (!code) {
+    log.info('ok')
+  } else {
+    log.verbose('code', code)
+  }
+
+  if (!exitHandlerCalled) {
+    process.exitCode = code || 1
+    log.error('', 'Exit handler never called!')
+    // eslint-disable-next-line no-console
+    console.error('')
+    log.error('', 'This is an error with npm itself. Please report this error at:')
+    log.error('', '    <https://github.com/npm/cli/issues>')
+    showLogFileError = true
+  }
+
+  // npm must be loaded to know where the log file was written
+  if (hasLoadedNpm) {
+    // write the timing file now, this might do nothing based on the configs set.
+    // we need to call it here in case it errors so we dont tell the user
+    // about a timing file that doesn't exist
+    npm.writeTimingFile()
+
+    const logsDir = npm.logsDir
+    const logFiles = npm.logFiles
+
+    const timingDir = npm.timingDir
+    const timingFile = npm.timingFile
+
+    const timing = npm.config.get('timing')
+    const logsMax = npm.config.get('logs-max')
+
+    // Determine whether to show log file message and why it is
+    // being shown since in timing mode we always show the log file message
+    const logMethod = showLogFileError ? 'error' : timing ? 'info' : null
+
+    if (logMethod) {
+      if (!npm.silent) {
+        // just a line break if not in silent mode
+        // eslint-disable-next-line no-console
+        console.error('')
+      }
+
+      const message = []
+
+      if (timingFile) {
+        message.push('Timing info written to:', indent(timingFile))
+      } else if (timing) {
+        message.push(
+          `The timing file was not written due to an error writing to the directory: ${timingDir}`
+        )
+      }
+
+      if (logFiles.length) {
+        message.push('A complete log of this run can be found in:', ...indent(logFiles))
+      } else if (logsMax <= 0) {
+        // user specified no log file
+        message.push(`Log files were not written due to the config logs-max=${logsMax}`)
+      } else {
+        // could be an error writing to the directory
+        message.push(
+          `Log files were not written due to an error writing to the directory: ${logsDir}`,
+          'You can rerun the command with `--loglevel=verbose` to see the logs in your terminal'
+        )
+      }
+
+      log[logMethod]('', message.join('\n'))
+    }
+
+    // This removes any listeners npm setup, mostly for tests to avoid max listener warnings
+    npm.unload()
+  }
+
+  // these are needed for the tests to have a clean slate in each test case
+  exitHandlerCalled = false
+  showLogFileError = false
+})
+
+const exitHandler = err => {
+  exitHandlerCalled = true
+
+  log.disableProgress()
+
+  const hasLoadedNpm = npm?.config.loaded
+
+  if (!npm) {
+    err = err || new Error('Exit prior to setting npm in exit handler')
+    // eslint-disable-next-line no-console
+    console.error(err.stack || err.message)
+    return process.exit(1)
+  }
+
+  if (!hasLoadedNpm) {
+    err = err || new Error('Exit prior to config file resolving.')
+    // eslint-disable-next-line no-console
+    console.error(err.stack || err.message)
+  }
+
+  // only show the notification if it finished.
+  if (typeof npm.updateNotification === 'string') {
+    const { level } = log
+    log.level = 'notice'
+    log.notice('', npm.updateNotification)
+    log.level = level
+  }
+
+  let exitCode
+  let noLogMessage
+  let jsonError
+
+  if (err) {
+    exitCode = 1
+    // if we got a command that just shells out to something else, then it
+    // will presumably print its own errors and exit with a proper status
+    // code if there's a problem.  If we got an error with a code=0, then...
+    // something else went wrong along the way, so maybe an npm problem?
+    const isShellout = npm.isShellout
+    const quietShellout = isShellout && typeof err.code === 'number' && err.code
+    if (quietShellout) {
+      exitCode = err.code
+      noLogMessage = true
+    } else if (typeof err === 'string') {
+      // XXX: we should stop throwing strings
+      log.error('', err)
+      noLogMessage = true
+    } else if (!(err instanceof Error)) {
+      log.error('weird error', err)
+      noLogMessage = true
+    } else {
+      if (!err.code) {
+        const matchErrorCode = err.message.match(/^(?:Error: )?(E[A-Z]+)/)
+        err.code = matchErrorCode && matchErrorCode[1]
+      }
+
+      for (const k of ['type', 'stack', 'statusCode', 'pkgid']) {
+        const v = err[k]
+        if (v) {
+          log.verbose(k, replaceInfo(v))
+        }
+      }
+
+      log.verbose('cwd', process.cwd())
+      log.verbose('', os.type() + ' ' + os.release())
+      log.verbose('node', process.version)
+      log.verbose('npm ', 'v' + npm.version)
+
+      for (const k of ['code', 'syscall', 'file', 'path', 'dest', 'errno']) {
+        const v = err[k]
+        if (v) {
+          log.error(k, v)
+        }
+      }
+
+      const { summary, detail, json, files = [] } = errorMessage(err, npm)
+      jsonError = json
+
+      for (let [file, content] of files) {
+        file = `${npm.logPath}${file}`
+        content = `'Log files:\n${npm.logFiles.join('\n')}\n\n${content.trim()}\n`
+        try {
+          fs.writeFileSync(file, content)
+          detail.push(['', `\n\nFor a full report see:\n${file}`])
+        } catch (logFileErr) {
+          log.warn('', `Could not write error message to ${file} due to ${logFileErr}`)
+        }
+      }
+
+      for (const errline of [...summary, ...detail]) {
+        log.error(...errline)
+      }
+
+      if (typeof err.errno === 'number') {
+        exitCode = err.errno
+      } else if (typeof err.code === 'number') {
+        exitCode = err.code
+      }
+    }
+  }
+
+  if (hasLoadedNpm) {
+    npm.flushOutput(jsonError)
+  }
+
+  log.verbose('exit', exitCode || 0)
+
+  showLogFileError = (hasLoadedNpm && npm.silent) || noLogMessage
+    ? false
+    : !!exitCode
+
+  // explicitly call process.exit now so we don't hang on things like the
+  // update notifier, also flush stdout/err beforehand because process.exit doesn't
+  // wait for that to happen.
+  let flushed = 0
+  const flush = [process.stderr, process.stdout]
+  const exit = () => ++flushed === flush.length && process.exit(exitCode)
+  flush.forEach((f) => f.write('', exit))
+}
+
+module.exports = exitHandler
+module.exports.setNpm = n => (npm = n)

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/explain-dep.js

@@ -0,0 +1,148 @@
+const chalk = require('chalk')
+const nocolor = {
+  bold: s => s,
+  dim: s => s,
+  red: s => s,
+  yellow: s => s,
+  cyan: s => s,
+  magenta: s => s,
+  blue: s => s,
+  green: s => s,
+  gray: s => s,
+}
+
+const { relative } = require('path')
+
+const explainNode = (node, depth, color) =>
+  printNode(node, color) +
+  explainDependents(node, depth, color) +
+  explainLinksIn(node, depth, color)
+
+const colorType = (type, color) => {
+  const { red, yellow, cyan, magenta, blue, green, gray } = color ? chalk : nocolor
+  const style = type === 'extraneous' ? red
+    : type === 'dev' ? yellow
+    : type === 'optional' ? cyan
+    : type === 'peer' ? magenta
+    : type === 'bundled' ? blue
+    : type === 'workspace' ? green
+    : type === 'overridden' ? gray
+    : /* istanbul ignore next */ s => s
+  return style(type)
+}
+
+const printNode = (node, color) => {
+  const {
+    name,
+    version,
+    location,
+    extraneous,
+    dev,
+    optional,
+    peer,
+    bundled,
+    isWorkspace,
+    overridden,
+  } = node
+  const { bold, dim, green } = color ? chalk : nocolor
+  const extra = []
+  if (extraneous) {
+    extra.push(' ' + bold(colorType('extraneous', color)))
+  }
+
+  if (dev) {
+    extra.push(' ' + bold(colorType('dev', color)))
+  }
+
+  if (optional) {
+    extra.push(' ' + bold(colorType('optional', color)))
+  }
+
+  if (peer) {
+    extra.push(' ' + bold(colorType('peer', color)))
+  }
+
+  if (bundled) {
+    extra.push(' ' + bold(colorType('bundled', color)))
+  }
+
+  if (overridden) {
+    extra.push(' ' + bold(colorType('overridden', color)))
+  }
+
+  const pkgid = isWorkspace
+    ? green(`${name}@${version}`)
+    : `${bold(name)}@${bold(version)}`
+
+  return `${pkgid}${extra.join('')}` +
+    (location ? dim(`\n${location}`) : '')
+}
+
+const explainLinksIn = ({ linksIn }, depth, color) => {
+  if (!linksIn || !linksIn.length || depth <= 0) {
+    return ''
+  }
+
+  const messages = linksIn.map(link => explainNode(link, depth - 1, color))
+  const str = '\n' + messages.join('\n')
+  return str.split('\n').join('\n  ')
+}
+
+const explainDependents = ({ name, dependents }, depth, color) => {
+  if (!dependents || !dependents.length || depth <= 0) {
+    return ''
+  }
+
+  const max = Math.ceil(depth / 2)
+  const messages = dependents.slice(0, max)
+    .map(edge => explainEdge(edge, depth, color))
+
+  // show just the names of the first 5 deps that overflowed the list
+  if (dependents.length > max) {
+    let len = 0
+    const maxLen = 50
+    const showNames = []
+    for (let i = max; i < dependents.length; i++) {
+      const { from: { name: depName = 'the root project' } } = dependents[i]
+      len += depName.length
+      if (len >= maxLen && i < dependents.length - 1) {
+        showNames.push('...')
+        break
+      }
+      showNames.push(depName)
+    }
+    const show = `(${showNames.join(', ')})`
+    messages.push(`${dependents.length - max} more ${show}`)
+  }
+
+  const str = '\n' + messages.join('\n')
+  return str.split('\n').join('\n  ')
+}
+
+const explainEdge = ({ name, type, bundled, from, spec, rawSpec, overridden }, depth, color) => {
+  const { bold } = color ? chalk : nocolor
+  let dep = type === 'workspace'
+    ? bold(relative(from.location, spec.slice('file:'.length)))
+    : `${bold(name)}@"${bold(spec)}"`
+  if (overridden) {
+    dep = `${colorType('overridden', color)} ${dep} (was "${rawSpec}")`
+  }
+
+  const fromMsg = ` from ${explainFrom(from, depth, color)}`
+
+  return (type === 'prod' ? '' : `${colorType(type, color)} `) +
+    (bundled ? `${colorType('bundled', color)} ` : '') +
+    `${dep}${fromMsg}`
+}
+
+const explainFrom = (from, depth, color) => {
+  if (!from.name && !from.version) {
+    return 'the root project'
+  }
+
+  return printNode(from, color) +
+    explainDependents(from, depth - 1, color) +
+    explainLinksIn(from, depth - 1, color)
+}
+
+module.exports = { explainNode, printNode, explainEdge }

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/explain-eresolve.js

@@ -0,0 +1,71 @@
+// this is called when an ERESOLVE error is caught in the exit-handler,
+// or when there's a log.warn('eresolve', msg, explanation), to turn it
+// into a human-intelligible explanation of what's wrong and how to fix.
+const { explainEdge, explainNode, printNode } = require('./explain-dep.js')
+
+// expl is an explanation object that comes from Arborist.  It looks like:
+// Depth is how far we want to want to descend into the object making a report.
+// The full report (ie, depth=Infinity) is always written to the cache folder
+// at ${cache}/eresolve-report.txt along with full json.
+const explain = (expl, color, depth) => {
+  const { edge, dep, current, peerConflict, currentEdge } = expl
+
+  const out = []
+  const whileInstalling = dep && dep.whileInstalling ||
+    current && current.whileInstalling ||
+    edge && edge.from && edge.from.whileInstalling
+  if (whileInstalling) {
+    out.push('While resolving: ' + printNode(whileInstalling, color))
+  }
+
+  // it "should" be impossible for an ERESOLVE explanation to lack both
+  // current and currentEdge, but better to have a less helpful error
+  // than a crashing failure.
+  if (current) {
+    out.push('Found: ' + explainNode(current, depth, color))
+  } else if (peerConflict && peerConflict.current) {
+    out.push('Found: ' + explainNode(peerConflict.current, depth, color))
+  } else if (currentEdge) {
+    out.push('Found: ' + explainEdge(currentEdge, depth, color))
+  } else /* istanbul ignore else - should always have one */ if (edge) {
+    out.push('Found: ' + explainEdge(edge, depth, color))
+  }
+
+  out.push('\nCould not resolve dependency:\n' +
+    explainEdge(edge, depth, color))
+
+  if (peerConflict) {
+    const heading = '\nConflicting peer dependency:'
+    const pc = explainNode(peerConflict.peer, depth, color)
+    out.push(heading + ' ' + pc)
+  }
+
+  return out.join('\n')
+}
+
+// generate a full verbose report and tell the user how to fix it
+const report = (expl, color) => {
+  const flags = [
+    expl.strictPeerDeps ? '--no-strict-peer-deps' : '',
+    '--force',
+    '--legacy-peer-deps',
+  ].filter(Boolean)
+
+  const or = (arr) => arr.length <= 2
+    ? arr.join(' or ') :
+    arr.map((v, i, l) => i + 1 === l.length ? `or ${v}` : v).join(', ')
+
+  const fix = `Fix the upstream dependency conflict, or retry
+this command with ${or(flags)}
+to accept an incorrect (and potentially broken) dependency resolution.`
+
+  return {
+    explanation: `${explain(expl, color, 4)}\n\n${fix}`,
+    file: `# npm resolution error report\n\n${explain(expl, false, Infinity)}\n\n${fix}`,
+  }
+}
+
+module.exports = {
+  explain,
+  report,
+}

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/format-bytes.js

@@ -0,0 +1,30 @@
+// Convert bytes to printable output, for file reporting in tarballs
+// Only supports up to GB because that's way larger than anything the registry
+// supports anyways.
+
+const formatBytes = (bytes, space = true) => {
+  let spacer = ''
+  if (space) {
+    spacer = ' '
+  }
+
+  if (bytes < 1000) {
+    // B
+    return `${bytes}${spacer}B`
+  }
+
+  if (bytes < 1000000) {
+    // kB
+    return `${(bytes / 1000).toFixed(1)}${spacer}kB`
+  }
+
+  if (bytes < 1000000000) {
+    // MB
+    return `${(bytes / 1000000).toFixed(1)}${spacer}MB`
+  }
+
+  // GB
+  return `${(bytes / 1000000000).toFixed(1)}${spacer}GB`
+}
+
+module.exports = formatBytes

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/format-search-stream.js

@@ -0,0 +1,160 @@
+const Minipass = require('minipass')
+const columnify = require('columnify')
+
+// This module consumes package data in the following format:
+//
+// {
+//   name: String,
+//   description: String,
+//   maintainers: [{ username: String, email: String }],
+//   keywords: String | [String],
+//   version: String,
+//   date: Date // can be null,
+// }
+//
+// The returned stream will format this package data
+// into a byte stream of formatted, displayable output.
+
+module.exports = (opts) => {
+  return opts.json ? new JSONOutputStream() : new TextOutputStream(opts)
+}
+
+class JSONOutputStream extends Minipass {
+  #didFirst = false
+
+  write (obj) {
+    if (!this.#didFirst) {
+      super.write('[\n')
+      this.#didFirst = true
+    } else {
+      super.write('\n,\n')
+    }
+
+    return super.write(JSON.stringify(obj))
+  }
+
+  end () {
+    super.write(this.#didFirst ? ']\n' : '\n[]\n')
+    super.end()
+  }
+}
+
+class TextOutputStream extends Minipass {
+  constructor (opts) {
+    super()
+    this._opts = opts
+    this._line = 0
+  }
+
+  write (pkg) {
+    return super.write(prettify(pkg, ++this._line, this._opts))
+  }
+}
+
+function prettify (data, num, opts) {
+  var truncate = !opts.long
+
+  var pkg = normalizePackage(data, opts)
+
+  var columns = ['name', 'description', 'author', 'date', 'version', 'keywords']
+
+  if (opts.parseable) {
+    return columns.map(function (col) {
+      return pkg[col] && ('' + pkg[col]).replace(/\t/g, ' ')
+    }).join('\t')
+  }
+
+  // stdout in tap is never a tty
+  /* istanbul ignore next */
+  const maxWidth = process.stdout.isTTY ? process.stdout.getWindowSize()[0] : Infinity
+  let output = columnify(
+    [pkg],
+    {
+      include: columns,
+      showHeaders: num <= 1,
+      columnSplitter: ' | ',
+      truncate: truncate,
+      config: {
+        name: { minWidth: 25, maxWidth: 25, truncate: false, truncateMarker: '' },
+        description: { minWidth: 20, maxWidth: 20 },
+        author: { minWidth: 15, maxWidth: 15 },
+        date: { maxWidth: 11 },
+        version: { minWidth: 8, maxWidth: 8 },
+        keywords: { maxWidth: Infinity },
+      },
+    }
+  ).split('\n').map(line => line.slice(0, maxWidth)).join('\n')
+
+  if (opts.color) {
+    output = highlightSearchTerms(output, opts.args)
+  }
+
+  return output
+}
+
+var colors = [31, 33, 32, 36, 34, 35]
+var cl = colors.length
+
+function addColorMarker (str, arg, i) {
+  var m = i % cl + 1
+  var markStart = String.fromCharCode(m)
+  var markEnd = String.fromCharCode(0)
+
+  if (arg.charAt(0) === '/') {
+    return str.replace(
+      new RegExp(arg.slice(1, -1), 'gi'),
+      bit => markStart + bit + markEnd
+    )
+  }
+
+  // just a normal string, do the split/map thing
+  var pieces = str.toLowerCase().split(arg.toLowerCase())
+  var p = 0
+
+  return pieces.map(function (piece) {
+    piece = str.slice(p, p + piece.length)
+    var mark = markStart +
+               str.slice(p + piece.length, p + piece.length + arg.length) +
+               markEnd
+    p += piece.length + arg.length
+    return piece + mark
+  }).join('')
+}
+
+function colorize (line) {
+  for (var i = 0; i < cl; i++) {
+    var m = i + 1
+    var color = '\u001B[' + colors[i] + 'm'
+    line = line.split(String.fromCharCode(m)).join(color)
+  }
+  var uncolor = '\u001B[0m'
+  return line.split('\u0000').join(uncolor)
+}
+
+function highlightSearchTerms (str, terms) {
+  terms.forEach(function (arg, i) {
+    str = addColorMarker(str, arg, i)
+  })
+
+  return colorize(str).trim()
+}
+
+function normalizePackage (data, opts) {
+  return {
+    name: data.name,
+    description: data.description,
+    author: data.maintainers.map((m) => `=${m.username}`).join(' '),
+    keywords: Array.isArray(data.keywords)
+      ? data.keywords.join(' ')
+      : typeof data.keywords === 'string'
+        ? data.keywords.replace(/[,\s]+/, ' ')
+        : '',
+    version: data.version,
+    date: (data.date &&
+          (data.date.toISOString() // remove time
+            .split('T').join(' ')
+            .replace(/:[0-9]{2}\.[0-9]{3}Z$/, ''))
+            .slice(0, -5)) ||
+          'prehistoric',
+  }
+}

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/get-identity.js

@@ -0,0 +1,26 @@
+const npmFetch = require('npm-registry-fetch')
+
+module.exports = async (npm, opts) => {
+  const { registry } = opts
+
+  // First, check if we have a user/pass-based auth
+  const creds = npm.config.getCredentialsByURI(registry)
+  if (creds.username) {
+    return creds.username
+  }
+
+  // No username, but we have other credentials; fetch the username from registry
+  if (creds.token || creds.certfile && creds.keyfile) {
+    const registryData = await npmFetch.json('/-/whoami', { ...opts })
+    if (typeof registryData?.username === 'string') {
+      return registryData.username
+    }
+  }
+
+  // At this point, even if they have a credentials object, it doesn't have a
+  // valid token.
+  throw Object.assign(
+    new Error('This command requires you to be logged in.'),
+    { code: 'ENEEDAUTH' }
+  )
+}

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/is-windows.js

@@ -0,0 +1,6 @@
+const isWindows = process.platform === 'win32'
+const isWindowsShell = isWindows &&
+  !/^MINGW(32|64)$/.test(process.env.MSYSTEM) && process.env.TERM !== 'cygwin'
+
+exports.isWindows = isWindows
+exports.isWindowsShell = isWindowsShell