fca-rqzax-remake 0.0.1-security → 8.19.2

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/cmd-list.js

@@ -0,0 +1,150 @@
+const abbrev = require('abbrev')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+
+// plumbing should not have any aliases
+const aliases = {
+
+  // aliases
+  author: 'owner',
+  home: 'docs',
+  issues: 'bugs',
+  info: 'view',
+  show: 'view',
+  find: 'search',
+  add: 'install',
+  unlink: 'uninstall',
+  remove: 'uninstall',
+  rm: 'uninstall',
+  r: 'uninstall',
+
+  // short names for common things
+  un: 'uninstall',
+  rb: 'rebuild',
+  list: 'ls',
+  ln: 'link',
+  create: 'init',
+  i: 'install',
+  it: 'install-test',
+  cit: 'install-ci-test',
+  up: 'update',
+  c: 'config',
+  s: 'search',
+  se: 'search',
+  tst: 'test',
+  t: 'test',
+  ddp: 'dedupe',
+  v: 'view',
+  run: 'run-script',
+  'clean-install': 'ci',
+  'clean-install-test': 'install-ci-test',
+  x: 'exec',
+  why: 'explain',
+  la: 'll',
+  verison: 'version',
+  ic: 'ci',
+
+  // typos
+  innit: 'init',
+  // manually abbrev so that install-test doesn't make insta stop working
+  in: 'install',
+  ins: 'install',
+  inst: 'install',
+  insta: 'install',
+  instal: 'install',
+  isnt: 'install',
+  isnta: 'install',
+  isntal: 'install',
+  isntall: 'install',
+  'install-clean': 'ci',
+  'isntall-clean': 'ci',
+  hlep: 'help',
+  'dist-tags': 'dist-tag',
+  upgrade: 'update',
+  udpate: 'update',
+  rum: 'run-script',
+  sit: 'install-ci-test',
+  urn: 'run-script',
+  ogr: 'org',
+  'add-user': 'adduser',
+}
+
+// these are filenames in .
+const commands = [
+  'access',
+  'adduser',
+  'audit',
+  'bugs',
+  'cache',
+  'ci',
+  'completion',
+  'config',
+  'dedupe',
+  'deprecate',
+  'diff',
+  'dist-tag',
+  'docs',
+  'doctor',
+  'edit',
+  'exec',
+  'explain',
+  'explore',
+  'find-dupes',
+  'fund',
+  'get',
+  'help',
+  'hook',
+  'init',
+  'install',
+  'install-ci-test',
+  'install-test',
+  'link',
+  'll',
+  'login', // This is an alias for `adduser` but it can be confusing
+  'logout',
+  'ls',
+  'org',
+  'outdated',
+  'owner',
+  'pack',
+  'ping',
+  'pkg',
+  'prefix',
+  'profile',
+  'prune',
+  'publish',
+  'query',
+  'rebuild',
+  'repo',
+  'restart',
+  'root',
+  'run-script',
+  'search',
+  'set',
+  'shrinkwrap',
+  'star',
+  'stars',
+  'start',
+  'stop',
+  'team',
+  'test',
+  'token',
+  'uninstall',
+  'unpublish',
+  'unstar',
+  'update',
+  'version',
+  'view',
+  'whoami',
+].sort(localeCompare)
+
+const plumbing = ['help-search']
+const allCommands = [...commands, ...plumbing].sort(localeCompare)
+const abbrevs = abbrev(commands.concat(Object.keys(aliases)))
+
+module.exports = {
+  abbrevs,
+  aliases,
+  commands,
+  plumbing,
+  allCommands,
+}

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/completion/installed-deep.js

@@ -0,0 +1,45 @@
+const { resolve } = require('path')
+const Arborist = require('@npmcli/arborist')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+
+const installedDeep = async (npm) => {
+  const {
+    depth,
+    global,
+    prefix,
+    workspacesEnabled,
+  } = npm.flatOptions
+
+  const getValues = (tree) =>
+    [...tree.inventory.values()]
+      .filter(i => i.location !== '' && !i.isRoot)
+      .map(i => {
+        return i
+      })
+      .filter(i => (i.depth - 1) <= depth)
+      .sort((a, b) => (a.depth - b.depth) || localeCompare(a.name, b.name))
+
+  const res = new Set()
+  const gArb = new Arborist({
+    global: true,
+    path: resolve(npm.globalDir, '..'),
+    workspacesEnabled,
+  })
+  const gTree = await gArb.loadActual({ global: true })
+
+  for (const node of getValues(gTree)) {
+    res.add(global ? node.name : [node.name, '-g'])
+  }
+
+  if (!global) {
+    const arb = new Arborist({ global: false, path: prefix, workspacesEnabled })
+    const tree = await arb.loadActual()
+    for (const node of getValues(tree)) {
+      res.add(node.name)
+    }
+  }
+
+  return [...res]
+}
+
+module.exports = installedDeep

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/completion/installed-shallow.js

@@ -0,0 +1,19 @@
+const { readdirScoped } = require('@npmcli/fs')
+
+const installedShallow = async (npm, opts) => {
+  const names = async global => {
+    const paths = await readdirScoped(global ? npm.globalDir : npm.localDir)
+    return paths.map(p => p.replace(/\\/g, '/'))
+  }
+  const { conf: { argv: { remain } } } = opts
+  if (remain.length > 3) {
+    return null
+  }
+
+  const { global } = npm.flatOptions
+  const locals = global ? [] : await names(false)
+  const globals = (await names(true)).map(n => global ? n : `${n} -g`)
+  return [...locals, ...globals]
+}
+
+module.exports = installedShallow

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/completion.fish

@@ -0,0 +1,40 @@
+# npm completions for Fish shell
+# This script is a work in progress and does not fall under the normal semver contract as the rest of npm.
+
+# __fish_npm_needs_command taken from:
+# https://stackoverflow.com/questions/16657803/creating-autocomplete-script-with-sub-commands
+function __fish_npm_needs_command
+    set -l cmd (commandline -opc)
+
+    if test (count $cmd) -eq 1
+        return 0
+    end
+
+    return 1
+end
+
+# Taken from https://github.com/fish-shell/fish-shell/blob/HEAD/share/completions/npm.fish
+function __fish_complete_npm -d "Complete the commandline using npm's 'completion' tool"
+    # tell npm we are fish shell
+    set -lx COMP_FISH true
+    if command -sq npm
+        # npm completion is bash-centric, so we need to translate fish's "commandline" stuff to bash's $COMP_* stuff
+        # COMP_LINE is an array with the words in the commandline
+        set -lx COMP_LINE (commandline -opc)
+        # COMP_CWORD is the index of the current word in COMP_LINE
+        # bash starts arrays with 0, so subtract 1
+        set -lx COMP_CWORD (math (count $COMP_LINE) - 1)
+        # COMP_POINT is the index of point/cursor when the commandline is viewed as a string
+        set -lx COMP_POINT (commandline -C)
+        # If the cursor is after the last word, the empty token will disappear in the expansion
+        # Readd it
+        if test (commandline -ct) = ""
+            set COMP_CWORD (math $COMP_CWORD + 1)
+            set COMP_LINE $COMP_LINE ""
+        end
+        command npm completion -- $COMP_LINE 2>/dev/null
+    end
+end
+
+# flush out what ships with fish
+complete -e npm

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/completion.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+###-begin-npm-completion-###
+#
+# npm command completion script
+#
+# Installation: npm completion >> ~/.bashrc  (or ~/.zshrc)
+# Or, maybe: npm completion > /usr/local/etc/bash_completion.d/npm
+#
+
+if type complete &>/dev/null; then
+  _npm_completion () {
+    local words cword
+    if type _get_comp_words_by_ref &>/dev/null; then
+      _get_comp_words_by_ref -n = -n @ -n : -w words -i cword
+    else
+      cword="$COMP_CWORD"
+      words=("${COMP_WORDS[@]}")
+    fi
+
+    local si="$IFS"
+    if ! IFS=$'\n' COMPREPLY=($(COMP_CWORD="$cword" \
+                           COMP_LINE="$COMP_LINE" \
+                           COMP_POINT="$COMP_POINT" \
+                           npm completion -- "${words[@]}" \
+                           2>/dev/null)); then
+      local ret=$?
+      IFS="$si"
+      return $ret
+    fi
+    IFS="$si"
+    if type __ltrim_colon_completions &>/dev/null; then
+      __ltrim_colon_completions "${words[cword]}"
+    fi
+  }
+  complete -o default -F _npm_completion npm
+elif type compdef &>/dev/null; then
+  _npm_completion() {
+    local si=$IFS
+    compadd -- $(COMP_CWORD=$((CURRENT-1)) \
+                 COMP_LINE=$BUFFER \
+                 COMP_POINT=0 \
+                 npm completion -- "${words[@]}" \
+                 2>/dev/null)
+    IFS=$si
+  }
+  compdef _npm_completion npm
+elif type compctl &>/dev/null; then
+  _npm_completion () {
+    local cword line point words si
+    read -Ac words
+    read -cn cword
+    let cword-=1
+    read -l line
+    read -ln point
+    si="$IFS"
+    if ! IFS=$'\n' reply=($(COMP_CWORD="$cword" \
+                       COMP_LINE="$line" \
+                       COMP_POINT="$point" \
+                       npm completion -- "${words[@]}" \
+                       2>/dev/null)); then
+
+      local ret=$?
+      IFS="$si"
+      return $ret
+    fi
+    IFS="$si"
+  }
+  compctl -K _npm_completion npm
+fi
+###-end-npm-completion-###

package/.config/npm/node_global/lib/node_modules/npm/lib/utils/config/definition.js

@@ -0,0 +1,251 @@
+// class that describes a config key we know about
+// this keeps us from defining a config key and not
+// providing a default, description, etc.
+//
+// TODO: some kind of categorization system, so we can
+// say "these are for registry access", "these are for
+// version resolution" etc.
+
+const required = ['type', 'description', 'default', 'key']
+
+const allowed = [
+  'default',
+  'defaultDescription',
+  'deprecated',
+  'description',
+  'flatten',
+  'hint',
+  'key',
+  'short',
+  'type',
+  'typeDescription',
+  'usage',
+  'envExport',
+]
+
+const {
+  typeDefs: {
+    semver: { type: semver },
+    Umask: { type: Umask },
+    url: { type: url },
+    path: { type: path },
+  },
+} = require('@npmcli/config')
+
+class Definition {
+  constructor (key, def) {
+    this.key = key
+    // if it's set falsey, don't export it, otherwise we do by default
+    this.envExport = true
+    Object.assign(this, def)
+    this.validate()
+    if (!this.defaultDescription) {
+      this.defaultDescription = describeValue(this.default)
+    }
+    if (!this.typeDescription) {
+      this.typeDescription = describeType(this.type)
+    }
+    // hint is only used for non-boolean values
+    if (!this.hint) {
+      if (this.type === Number) {
+        this.hint = '<number>'
+      } else {
+        this.hint = `<${this.key}>`
+      }
+    }
+    if (!this.usage) {
+      this.usage = describeUsage(this)
+    }
+  }
+
+  validate () {
+    for (const req of required) {
+      if (!Object.prototype.hasOwnProperty.call(this, req)) {
+        throw new Error(`config lacks ${req}: ${this.key}`)
+      }
+    }
+    if (!this.key) {
+      throw new Error(`config lacks key: ${this.key}`)
+    }
+    for (const field of Object.keys(this)) {
+      if (!allowed.includes(field)) {
+        throw new Error(`config defines unknown field ${field}: ${this.key}`)
+      }
+    }
+  }
+
+  // a textual description of this config, suitable for help output
+  describe () {
+    const description = unindent(this.description)
+    const noEnvExport = this.envExport
+      ? ''
+      : `
+This value is not exported to the environment for child processes.
+`
+    const deprecated = !this.deprecated ? '' : `* DEPRECATED: ${unindent(this.deprecated)}\n`
+    return wrapAll(`#### \`${this.key}\`
+
+* Default: ${unindent(this.defaultDescription)}
+* Type: ${unindent(this.typeDescription)}
+${deprecated}
+${description}
+${noEnvExport}`)
+  }
+}
+
+const describeUsage = def => {
+  let key = ''
+
+  // Single type
+  if (!Array.isArray(def.type)) {
+    if (def.short) {
+      key = `-${def.short}|`
+    }
+
+    if (def.type === Boolean && def.default !== false) {
+      key = `${key}--no-${def.key}`
+    } else {
+      key = `${key}--${def.key}`
+    }
+
+    if (def.type !== Boolean) {
+      key = `${key} ${def.hint}`
+    }
+
+    return key
+  }
+
+  key = `--${def.key}`
+  if (def.short) {
+    key = `-${def.short}|--${def.key}`
+  }
+
+  // Multiple types
+  let types = def.type
+  const multiple = types.includes(Array)
+  const bool = types.includes(Boolean)
+
+  // null type means optional and doesn't currently affect usage output since
+  // all non-optional params have defaults so we render everything as optional
+  types = types.filter(t => t !== null && t !== Array && t !== Boolean)
+
+  if (!types.length) {
+    return key
+  }
+
+  let description
+  if (!types.some(t => typeof t !== 'string')) {
+    // Specific values, use specifics given
+    description = `<${types.filter(d => d).join('|')}>`
+  } else {
+    // Generic values, use hint
+    description = def.hint
+  }
+
+  if (bool) {
+    // Currently none of our multi-type configs with boolean values default to
+    // false so all their hints should show `--no-`, if we ever add ones that
+    // default to false we can branch the logic here
+    key = `--no-${def.key}|${key}`
+  }
+
+  const usage = `${key} ${description}`
+  if (multiple) {
+    return `${usage} [${usage} ...]`
+  } else {
+    return usage
+  }
+}
+
+const describeType = type => {
+  if (Array.isArray(type)) {
+    const descriptions = type.filter(t => t !== Array).map(t => describeType(t))
+
+    // [a] => "a"
+    // [a, b] => "a or b"
+    // [a, b, c] => "a, b, or c"
+    // [a, Array] => "a (can be set multiple times)"
+    // [a, Array, b] => "a or b (can be set multiple times)"
+    const last = descriptions.length > 1 ? [descriptions.pop()] : []
+    const oxford = descriptions.length > 1 ? ', or ' : ' or '
+    const words = [descriptions.join(', ')].concat(last).join(oxford)
+    const multiple = type.includes(Array) ? ' (can be set multiple times)' : ''
+    return `${words}${multiple}`
+  }
+
+  // Note: these are not quite the same as the description printed
+  // when validation fails.  In that case, we want to give the user
+  // a bit more information to help them figure out what's wrong.
+  switch (type) {
+    case String:
+      return 'String'
+    case Number:
+      return 'Number'
+    case Umask:
+      return 'Octal numeric string in range 0000..0777 (0..511)'
+    case Boolean:
+      return 'Boolean'
+    case Date:
+      return 'Date'
+    case path:
+      return 'Path'
+    case semver:
+      return 'SemVer string'
+    case url:
+      return 'URL'
+    default:
+      return describeValue(type)
+  }
+}
+
+// if it's a string, quote it.  otherwise, just cast to string.
+const describeValue = val => (typeof val === 'string' ? JSON.stringify(val) : String(val))
+
+const unindent = s => {
+  // get the first \n followed by a bunch of spaces, and pluck off
+  // that many spaces from the start of every line.
+  const match = s.match(/\n +/)
+  return !match ? s.trim() : s.split(match[0]).join('\n').trim()
+}
+
+const wrap = s => {
+  const cols = Math.min(Math.max(20, process.stdout.columns) || 80, 80) - 5
+  return unindent(s)
+    .split(/[ \n]+/)
+    .reduce((left, right) => {
+      const last = left.split('\n').pop()
+      const join = last.length && last.length + right.length > cols ? '\n' : ' '
+      return left + join + right
+    })
+}
+
+const wrapAll = s => {
+  let inCodeBlock = false
+  return s
+    .split('\n\n')
+    .map(block => {
+      if (inCodeBlock || block.startsWith('```')) {
+        inCodeBlock = !block.endsWith('```')
+        return block
+      }
+
+      if (block.charAt(0) === '*') {
+        return (
+          '* ' +
+          block
+            .slice(1)
+            .trim()
+            .split('\n* ')
+            .map(li => {
+              return wrap(li).replace(/\n/g, '\n  ')
+            })
+            .join('\n* ')
+        )
+      } else {
+        return wrap(block)
+      }
+    })
+    .join('\n\n')
+}
+
+module.exports = Definition