jfrog-cli-v2-jf 2.6.0

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/libnpx/index.js

@@ -0,0 +1,366 @@
+'use strict'
+
+const Buffer = require('safe-buffer').Buffer
+const promisify = require('./util.js').promisify
+
+const child = require('./child')
+const fs = require('fs')
+const parseArgs = require('./parse-args.js')
+const path = require('path')
+const which = promisify(require('which'))
+
+module.exports = npx
+module.exports.parseArgs = parseArgs
+function npx (argv) {
+  const shell = argv['shell-auto-fallback']
+  if (shell || shell === '') {
+    const fallback = require('./auto-fallback.js')(
+      shell, process.env.SHELL, argv
+    )
+    if (fallback) {
+      return console.log(fallback)
+    } else {
+      process.exitCode = 1
+      return
+    }
+  }
+
+  if (!argv.call && (!argv.command || !argv.package)) {
+    !argv.q && console.error(Y()`\nERROR: You must supply a command.\n`)
+    !argv.q && parseArgs.showHelp()
+    process.exitCode = 1
+    return
+  }
+
+  const startTime = Date.now()
+
+  // First, we look to see if we're inside an npm project, and grab its
+  // bin path. This is exactly the same as running `$ npm bin`.
+  return localBinPath(process.cwd()).then(local => {
+    if (local) {
+      // Local project paths take priority. Go ahead and prepend it.
+      process.env.PATH = `${local}${path.delimiter}${process.env.PATH}`
+    }
+    return Promise.all([
+      // Figuring out if a command exists, early on, lets us maybe
+      // short-circuit a few things later. This bit here primarily benefits
+      // calls like `$ npx foo`, where we might just be trying to invoke
+      // a single command and use whatever is already in the path.
+      argv.command && getExistingPath(argv.command, argv),
+      // The `-c` flag involves special behavior when used: in this case,
+      // we take a bit of extra time to pick up npm's full lifecycle script
+      // environment (so you can use `$npm_package_xxxxx` and company).
+      // Without that flag, we just use the current env.
+      argv.call && local && getEnv(argv)
+    ]).then(args => {
+      const existing = args[0]
+      const newEnv = args[1]
+      if (newEnv) {
+        // NOTE - we don't need to manipulate PATH further here, because
+        //        npm has already done so. And even added the node-gyp path!
+        Object.assign(process.env, newEnv)
+      }
+      if ((!existing && !argv.call) || argv.packageRequested) {
+        // We only fire off the updateNotifier if we're installing things
+        if (argv.npxPkg) {
+          try {
+            require('update-notifier')({
+              pkg: require(argv.npxPkg)
+            }).notify()
+          } catch (e) {}
+        }
+        // Some npm packages need to be installed. Let's install them!
+        return ensurePackages(argv.package, argv).then(results => {
+          if (results && results.added && results.updated && !argv.q) {
+            console.error(Y()`npx: installed ${
+              results.added.length + results.updated.length
+            } in ${(Date.now() - startTime) / 1000}s`)
+          }
+          if (
+            argv.command &&
+            !existing &&
+            !argv.packageRequested &&
+            argv.package.length === 1
+          ) {
+            return promisify(fs.readdir)(results.bin).then(bins => {
+              if (process.platform === 'win32') {
+                bins = bins.filter(b => b !== 'etc' && b !== 'node_modules')
+              }
+              const cmd = new RegExp(`^${argv.command}(?:\\.cmd)?$`, 'i')
+              const matching = bins.find(b => b.match(cmd))
+              return path.resolve(results.bin, bins[matching] || bins[0])
+            }, err => {
+              if (err.code === 'ENOENT') {
+                throw new Error(Y()`command not found: ${argv.command}`)
+              } else {
+                throw err
+              }
+            })
+          } else {
+            return existing
+          }
+        })
+      } else {
+        // We can skip any extra installation, 'cause everything exists.
+        return existing
+      }
+    }).then(existing => {
+      return execCommand(existing, argv)
+    }).catch(err => {
+      !argv.q && console.error(err.message)
+      process.exitCode = err.exitCode || 1
+    })
+  })
+}
+
+module.exports._localBinPath = localBinPath
+function localBinPath (cwd) {
+  return require('./get-prefix.js')(cwd).then(prefix => {
+    const pkgjson = path.join(prefix, 'package.json')
+    return promisify(fs.stat)(pkgjson).then(
+      () => path.join(prefix, 'node_modules', '.bin'),
+      err => { if (err.code !== 'ENOENT') throw err }
+    )
+  })
+}
+
+module.exports._getEnv = getEnv
+function getEnv (opts) {
+  const args = ['run', 'env', '--parseable']
+  return findNodeScript(opts.npm, {isLocal: true}).then(npmPath => {
+    if (npmPath) {
+      args.unshift(child.escapeArg(opts.npm))
+      return process.argv[0]
+    } else {
+      return opts.npm
+    }
+  }).then(npmPath => {
+    return child.exec(npmPath, args)
+  }).then(require('dotenv').parse)
+}
+
+module.exports._ensurePackages = ensurePackages
+function ensurePackages (specs, opts) {
+  return (
+    opts.cache ? Promise.resolve(opts.cache) : getNpmCache(opts)
+  ).then(cache => {
+    const prefix = path.join(cache, '_npx', process.pid.toString())
+    const bins = process.platform === 'win32'
+    ? prefix
+    : path.join(prefix, 'bin')
+    const rimraf = require('rimraf')
+    process.on('exit', () => rimraf.sync(prefix))
+    return promisify(rimraf)(bins).then(() => {
+      return installPackages(specs, prefix, opts)
+    }).then(info => {
+      // This will make temp bins _higher priority_ than even local bins.
+      // This is intentional, since npx assumes that if you went through
+      // the trouble of doing `-p`, you're rather have that one. Right? ;)
+      process.env.PATH = `${bins}${path.delimiter}${process.env.PATH}`
+      if (!info) { info = {} }
+      info.prefix = prefix
+      info.bin = bins
+      return info
+    })
+  })
+}
+
+module.exports._getExistingPath = getExistingPath
+function getExistingPath (command, opts) {
+  if (opts.isLocal) {
+    return Promise.resolve(command)
+  } else if (
+    opts.cmdHadVersion || opts.packageRequested || opts.ignoreExisting
+  ) {
+    return Promise.resolve(false)
+  } else {
+    return which(command).catch(err => {
+      if (err.code === 'ENOENT') {
+        if (opts.install === false) {
+          err.exitCode = 127
+          throw err
+        }
+      } else {
+        throw err
+      }
+    })
+  }
+}
+
+module.exports._getNpmCache = getNpmCache
+function getNpmCache (opts) {
+  const args = ['config', 'get', 'cache', '--parseable']
+  if (opts.userconfig) {
+    args.push('--userconfig', child.escapeArg(opts.userconfig, true))
+  }
+  return findNodeScript(opts.npm, {isLocal: true}).then(npmPath => {
+    if (npmPath) {
+      // This one is NOT escaped as a path because it's handed to Node.
+      args.unshift(child.escapeArg(opts.npm))
+      return process.argv[0]
+    } else {
+      return opts.npm
+    }
+  }).then(npmPath => {
+    return child.exec(npmPath, args)
+  }).then(cache => cache.trim())
+}
+
+module.exports._buildArgs = buildArgs
+function buildArgs (specs, prefix, opts) {
+  const args = ['install'].concat(specs)
+  args.push('--global', '--prefix', prefix)
+  if (opts.cache) args.push('--cache', opts.cache)
+  if (opts.userconfig) args.push('--userconfig', opts.userconfig)
+  args.push('--loglevel', 'error', '--json')
+
+  return args
+}
+
+module.exports._installPackages = installPackages
+function installPackages (specs, prefix, opts) {
+  const args = buildArgs(specs, prefix, opts)
+  return findNodeScript(opts.npm, {isLocal: true}).then(npmPath => {
+    if (npmPath) {
+      args.unshift(
+        process.platform === 'win32'
+        ? child.escapeArg(opts.npm)
+        : opts.npm
+      )
+      return process.argv[0]
+    } else {
+      return opts.npm
+    }
+  }).then(npmPath => {
+    return process.platform === 'win32' ? child.escapeArg(npmPath, true) : npmPath
+  }).then(npmPath => {
+    return child.spawn(npmPath, args, {
+      stdio: opts.installerStdio
+        ? opts.installerStdio
+        : [0, 'pipe', opts.q ? 'ignore' : 2]
+    }).then(deets => {
+      try {
+        return deets.stdout ? JSON.parse(deets.stdout) : null
+      } catch (e) { }
+    }, err => {
+      if (err.exitCode) {
+        err.message = Y()`Install for ${specs} failed with code ${err.exitCode}`
+      }
+      throw err
+    })
+  })
+}
+
+module.exports._execCommand = execCommand
+function execCommand (_existing, argv) {
+  return findNodeScript(_existing, argv).then(existing => {
+    if (existing && !argv.nodeArg && !argv.shell && existing !== process.argv[1]) {
+      const Module = require('module')
+      // let it take over the process. This means we can skip node startup!
+      if (!argv.noYargs) {
+        // blow away built-up yargs crud
+        require('yargs').reset()
+      }
+      process.argv = [
+        process.argv[0], // Current node binary
+        existing // node script path. `runMain()` will set this as the new main
+      ].concat(argv.cmdOpts) // options for the cmd itself
+      Module.runMain() // ✨MAGIC✨. Sorry-not-sorry
+    } else if (!existing && argv.nodeArg && argv.nodeArg.length) {
+      throw new Error(Y()`ERROR: --node-arg/-n can only be used on packages with node scripts.`)
+    } else {
+      let cmd = existing
+      let opts = argv
+      if (existing && argv.nodeArg && argv.nodeArg.length) {
+        // If we know we're running a run script and we got a --node-arg,
+        // we need to fudge things a bit to get them working right.
+        let nargs = argv.nodeArg
+        if (typeof nargs === 'string') {
+          nargs = [nargs]
+        }
+        // It's valid for a single arg to be a string of multiple
+        // space-separated node args.
+        // Example: `$ npx -n '--inspect --harmony --debug' ...`
+        nargs = nargs.reduce((acc, arg) => {
+          return acc.concat(arg.split(/\s+/))
+        }, [])
+        cmd = process.argv[0]
+        opts = Object.assign({}, argv, {
+          cmdOpts: nargs.concat([existing], argv.cmdOpts || [])
+        })
+      }
+      return child.runCommand(cmd, opts).catch(err => {
+        if (err.isOperational && err.exitCode) {
+          // At this point, we want to treat errors from the child as if
+          // we were just running the command. That means no extra msg logging
+          process.exitCode = err.exitCode
+        } else {
+          // But if it's not just a regular child-level error, blow up normally
+          throw err
+        }
+      })
+    }
+  })
+}
+
+module.exports._findNodeScript = findNodeScript
+function findNodeScript (existing, opts) {
+  if (!existing) {
+    return Promise.resolve(false)
+  } else {
+    return promisify(fs.stat)(existing).then(stat => {
+      if (opts && opts.isLocal && path.extname(existing) === '.js') {
+        return existing
+      } else if (opts && opts.isLocal && stat.isDirectory()) {
+        // npx will execute the directory itself
+        try {
+          const pkg = require(path.resolve(existing, 'package.json'))
+          const target = path.resolve(existing, pkg.bin || pkg.main || 'index.js')
+          return findNodeScript(target, opts).then(script => {
+            if (script) {
+              return script
+            } else {
+              throw new Error(Y()`command not found: ${target}`)
+            }
+          })
+        } catch (e) {
+          throw new Error(Y()`command not found: ${existing}`)
+        }
+      } else if (process.platform !== 'win32') {
+        const bytecount = 400
+        const buf = Buffer.alloc(bytecount)
+        return promisify(fs.open)(existing, 'r').then(fd => {
+          return promisify(fs.read)(fd, buf, 0, bytecount, 0).then(() => {
+            return promisify(fs.close)(fd)
+          }, err => {
+            return promisify(fs.close)(fd).then(() => { throw err })
+          })
+        }).then(() => {
+          const re = /#!\s*(?:\/usr\/bin\/env\s*node|\/usr\/local\/bin\/node|\/usr\/bin\/node)\s*\r?\n/i
+          return buf.toString('utf8').match(re) && existing
+        })
+      } else if (process.platform === 'win32') {
+        const buf = Buffer.alloc(1000)
+        return promisify(fs.open)(existing, 'r').then(fd => {
+          return promisify(fs.read)(fd, buf, 0, 1000, 0).then(() => {
+            return promisify(fs.close)(fd)
+          }, err => {
+            return promisify(fs.close)(fd).then(() => { throw err })
+          })
+        }).then(() => {
+          return buf.toString('utf8').trim()
+        }).then(str => {
+          const cmd = /"%~dp0\\node\.exe"\s+"%~dp0\\(.*)"\s+%\*/
+          const mingw = /"\$basedir\/node"\s+"\$basedir\/(.*)"\s+"\$@"/i
+          return str.match(cmd) || str.match(mingw)
+        }).then(match => {
+          return match && path.join(path.dirname(existing), match[1])
+        }).then(x => console.log(x) || x)
+      }
+    })
+  }
+}
+
+function Y () {
+  return require('./y.js')
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/libnpx/libnpx.1

@@ -0,0 +1,168 @@
+.TH "NPX" "1" "October 2017" "libnpx@9.7.0" "User Commands"
+.SH "NAME"
+\fBnpx\fR \- execute npm package binaries
+.SH SYNOPSIS
+.P
+\fBnpx [options] <command>[@version] [command\-arg]\.\.\.\fP
+.P
+\fBnpx [options] [\-p|\-\-package <pkg>]\.\.\. <command> [command\-arg]\.\.\.\fP
+.P
+\fBnpx [options] \-c '<command\-string>'\fP
+.P
+\fBnpx \-\-shell\-auto\-fallback [shell]\fP
+.SH INSTALL
+.P
+\fBnpm install \-g npx\fP
+.SH DESCRIPTION
+.P
+Executes \fB<command>\fP either from a local \fBnode_modules/\.bin\fP, or from a central cache, installing any packages needed in order for \fB<command>\fP to run\.
+.P
+By default, \fBnpx\fP will check whether \fB<command>\fP exists in \fB$PATH\fP, or in the local project binaries, and execute that\. If \fB<command>\fP is not found, it will be installed prior to execution\.
+.P
+Unless a \fB\-\-package\fP option is specified, \fBnpx\fP will try to guess the name of the binary to invoke depending on the specifier provided\. All package specifiers understood by \fBnpm\fP may be used with \fBnpx\fP, including git specifiers, remote tarballs, local directories, or scoped packages\.
+.P
+If a full specifier is included, or if \fB\-\-package\fP is used, npx will always use a freshly\-installed, temporary version of the package\. This can also be forced with the \fB\-\-ignore\-existing\fP flag\.
+.RS 0
+.IP \(bu 2
+\fB\-p, \-\-package <package>\fP \- define the package to be installed\. This defaults to the value of \fB<command>\fP\|\. This is only needed for packages with multiple binaries if you want to call one of the other executables, or where the binary name does not match the package name\. If this option is provided \fB<command>\fP will be executed as\-is, without interpreting \fB@version\fP if it's there\. Multiple \fB\-\-package\fP options may be provided, and all the packages specified will be installed\.
+.IP \(bu 2
+\fB\-\-no\-install\fP \- If passed to \fBnpx\fP, it will only try to run \fB<command>\fP if it already exists in the current path or in \fB$prefix/node_modules/\.bin\fP\|\. It won't try to install missing commands\.
+.IP \(bu 2
+\fB\-\-cache <path>\fP \- set the location of the npm cache\. Defaults to npm's own cache settings\.
+.IP \(bu 2
+\fB\-\-userconfig <path>\fP \- path to the user configuration file to pass to npm\. Defaults to whatever npm's current default is\.
+.IP \(bu 2
+\fB\-c <string>\fP \- Execute \fB<string>\fP inside an \fBnpm run\-script\fP\-like shell environment, with all the usual environment variables available\. Only the first item in \fB<string>\fP will be automatically used as \fB<command>\fP\|\. Any others \fImust\fR use \fB\-p\fP\|\.
+.IP \(bu 2
+\fB\-\-shell <string>\fP \- The shell to invoke the command with, if any\.
+.IP \(bu 2
+\fB\-\-shell\-auto\-fallback [<shell>]\fP \- Generates shell code to override your shell's "command not found" handler with one that calls \fBnpx\fP\|\. Tries to figure out your shell, or you can pass its name (either \fBbash\fP, \fBfish\fP, or \fBzsh\fP) as an option\. See below for how to install\.
+.IP \(bu 2
+\fB\-\-ignore\-existing\fP \- If this flag is set, npx will not look in \fB$PATH\fP, or in the current package's \fBnode_modules/\.bin\fP for an existing version before deciding whether to install\. Binaries in those paths will still be available for execution, but will be shadowed by any packages requested by this install\.
+.IP \(bu 2
+\fB\-q, \-\-quiet\fP \- Suppressed any output from npx itself (progress bars, error messages, install reports)\. Subcommand output itself will not be silenced\.
+.IP \(bu 2
+\fB\-n, \-\-node\-arg\fP \- Extra node argument to supply to node when binary is a node script\. You can supply this option multiple times to add more arguments\.
+.IP \(bu 2
+\fB\-v, \-\-version\fP \- Show the current npx version\.
+
+.RE
+.SH EXAMPLES
+.SS Running a project\-local bin
+.P
+.RS 2
+.nf
+$ npm i \-D webpack
+$ npx webpack \.\.\.
+.fi
+.RE
+.SS One\-off invocation without local installation
+.P
+.RS 2
+.nf
+$ npm rm webpack
+$ npx webpack \-\- \.\.\.
+$ cat package\.json
+\|\.\.\.webpack not in "devDependencies"\.\.\.
+.fi
+.RE
+.SS Invoking a command from a github repository
+.P
+.RS 2
+.nf
+$ npx github:piuccio/cowsay
+\|\.\.\.or\.\.\.
+$ npx git+ssh://my\.hosted\.git:cowsay\.git#semver:^1
+\|\.\.\.etc\.\.\.
+.fi
+.RE
+.SS Execute a full shell command using one npx call w/ multiple packages
+.P
+.RS 2
+.nf
+$ npx \-p lolcatjs \-p cowsay \-c \\
+  'echo "$npm_package_name@$npm_package_version" | cowsay | lolcatjs'
+\|\.\.\.
+ _____
+< your\-cool\-package@1\.2\.3 >
+ \-\-\-\-\-
+        \\   ^__^
+         \\  (oo)\\_______
+            (__)\\       )\\/\\
+                ||\-\-\-\-w |
+                ||     ||
+.fi
+.RE
+.SS Run node binary with \-\-inspect
+.P
+.RS 2
+.nf
+$ npx \-\-node\-arg=\-\-inspect cowsay
+Debugger listening on ws://127\.0\.0\.1:9229/\.\.\.\.
+.fi
+.RE
+.SH SHELL AUTO FALLBACK
+.P
+You can configure \fBnpx\fP to run as your default fallback command when you type something in the command line with an \fB@\fP but the command is not found\. This includes installing packages that were not found in the local prefix either\.
+.P
+For example:
+.P
+.RS 2
+.nf
+$ npm@4 \-\-version
+(stderr) npm@4 not found\. Trying with npx\.\.\.
+4\.6\.1
+$ asdfasdfasf
+zsh: command not found: asfdasdfasdf
+.fi
+.RE
+.P
+Currently, \fBzsh\fP, \fBbash\fP (>= 4), and \fBfish\fP are supported\. You can access these completion scripts using \fBnpx \-\-shell\-auto\-fallback <shell>\fP\|\.
+.P
+To install permanently, add the relevant line below to your \fB~/\.bashrc\fP, \fB~/\.zshrc\fP, \fB~/\.config/fish/config\.fish\fP, or as needed\. To install just for the shell session, simply run the line\.
+.P
+You can optionally pass through \fB\-\-no\-install\fP when generating the fallback to prevent it from installing packages if the command is missing\.
+.SS For bash@>=4:
+.P
+.RS 2
+.nf
+$ source <(npx \-\-shell\-auto\-fallback bash)
+.fi
+.RE
+.SS For zsh:
+.P
+.RS 2
+.nf
+$ source <(npx \-\-shell\-auto\-fallback zsh)
+.fi
+.RE
+.SS For fish:
+.P
+.RS 2
+.nf
+$ source (npx \-\-shell\-auto\-fallback fish | psub)
+.fi
+.RE
+.SH ACKNOWLEDGEMENTS
+.P
+Huge thanks to Kwyn Meagher \fIhttps://blog\.kwyn\.io\fR for generously donating the package name in the main npm registry\. Previously \fBnpx\fP was used for a Tessel board Neopixels library, which can now be found under \fBnpx\-tessel\fP \fIhttps://npm\.im/npx\-tessel\fR\|\.
+.SH AUTHOR
+.P
+Written by Kat Marchan \fIhttps://github\.com/zkat\fR\|\.
+.SH REPORTING BUGS
+.P
+Please file any relevant issues on Github\. \fIhttps://github\.com/zkat/npx\fR
+.SH LICENSE
+.P
+This work is released by its authors into the public domain under CC0\-1\.0\. See \fBLICENSE\.md\fP for details\.
+.SH SEE ALSO
+.RS 0
+.IP \(bu 2
+\fBnpm(1)\fP
+.IP \(bu 2
+\fBnpm\-run\-script(1)\fP
+.IP \(bu 2
+\fBnpm\-config(7)\fP
+
+.RE
+

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/libnpx/locales/ar.json

@@ -0,0 +1,29 @@
+{
+  "Execute binaries from npm packages.\n%s": ".npm الثنائية من حزم node تنفيذ ملفات \n %s ",
+  "Package to be installed.": ".الحزمة التي سيتم تثبيتها",
+  "Location of the npm cache.": ".npm موقع الذاكرة المخبأة ل",
+  "Skip installation if a package is missing.": "تخطي التثبيت في حال وجود حزمة مفقودة.",
+  "Path to user npmrc.": "مسار المستخدم إلى npmrc.",
+  "Execute string as if inside `npm run-script`.": ".`npm run-script` نص الامر التنفيذي كما في",
+  "Shell to execute the command with, if any.": "واجهة تنفيذ الأوامر المرغوب استخدامها في حال وجودها.",
+  "Generate shell code to use npx as the \"command not found\" fallback.": ".npx الامرالمتولد لاستدعاء كحل بديل في حالة \"لم يتم العثور على الامر\" من قبل ",
+  "Ignores existing binaries in $PATH, or in the local project. This forces npx to do a temporary install and use the latest version.": " .npx سيتم قسرياً التثبيت بشكل مؤقت  للاصدار الاحدث من قبل .$PATH تجاهل الملفات التنفيذية الثنائية الحالية في المسار  ",
+  "npm binary to use for internal operations.": ".التنفيذي الثنائي الذي سيتم استعماله للعمليات الداخلية npm ملف",
+  "For the full documentation, see the manual page for npx(1).": ".npx(1) للوصول للمستندات المساعدة الكاملة, ابحث في صفحة الدليل عن",
+  "Unable to guess a binary name from %s. Please use --package.": ". --package الرجاء استعمال .%s لم يتمكن تخمين اسم التطبيق الثنائي من  ",
+  "\nERROR: You must supply a command.\n": "\n.خطأ : يتوجب على المستخدم ادخال امر\n",
+  "Command failed: %s %s": "%s %s :فشل الامر ",
+  "Install for %s failed with code %s": "%s بالكود %s تم فشل تثبيت",
+  "%s not found. Trying with npx...": "...npx سيتم اعادة المحاولة باستعمال  .%s  لم يتم العثور على",
+  "command not found: %s": "%s :لم يتم العثور على الأمر",
+  "options": "خيارات",
+  "command": "أمر",
+  "version": "الإصدار",
+  "command-arg": "بارامتر الأمر",
+  "command-string": "نص الأمر",
+  "shell": "واجهة تنفيذ الأوامر",
+  "package": "الحزمة",
+  "npx: installed %s in %ss": "%ss في %s تم تثبيت ",
+  "Suppress output from npx itself. Subcommands will not be affected.": "الاوامر الفرعية لن تتاثر بالتعديل.npx إخفاءالخرج من",
+  "Extra node argument when calling a node binary.": ".node البارامتر الاضافي عند استدعاء"
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/libnpx/locales/ca.json

@@ -0,0 +1,28 @@
+{
+  "Execute binaries from npm packages.\n%s": "Executa comandes de paquets de npm.\n%s",
+  "Package to be installed.": "Paquet per a instal·lar.",
+  "Location of the npm cache.": "Ruta de la memòria cau de npm.",
+  "Skip installation if a package is missing.": "Salta el pas d'instal·lació si el paquet no està present.",
+  "Path to user npmrc.": "Ruta al npmrc de l'usuari.",
+  "Execute string as if inside `npm run-script`.": "Executa l'argument com si estigués dins de `npm run-script`.",
+  "Shell to execute the command with, if any.": "Shell amb el qual s'executarà la comanda, si hi ha algun.",
+  "Generate shell code to use npx as the \"command not found\" fallback.": "Genera codi de shell per utilizar npx com el replegament quan la comanda no existeix.",
+  "Ignores existing binaries in $PATH, or in the local project. This forces npx to do a temporary install and use the latest version.": "Ignora comandaments en $PATH, o en el projecte local. Això obliga a npx a fer una instal·lació temporal i usar la versió més recent de la comanda.",
+  "npm binary to use for internal operations.": "Comando d'npm que es farà servir per a operacions internes de npx.",
+  "For the full documentation, see the manual page for npx(1).": "Per documentació completa, vegeu la pàgina del manual npx(1).",
+  "Unable to guess a binary name from %s. Please use --package.": "No s'ha pogut endevinar el nom de la comanda usant %s. Si us plau utilitza --package.",
+  "\nERROR: You must supply a command.\n": "\nERROR: Has proveir una comanda.\n",
+  "Command failed: %s %s": "La comanda va fracasar: %s %s",
+  "Install for %s failed with code %s": "instal·lació de %s fracassar amb codi %s",
+  "%s not found. Trying with npx...": "%s no existeix. Provant-ho amb npx...",
+  "command not found: %s": "comanda no existeix: %s",
+  "options": "opcions",
+  "command": "comanda",
+  "version": "versió",
+  "command-arg": "argument-de-comanda",
+  "command-string": "text-de-comanda",
+  "shell": "shell",
+  "package": "paquet",
+  "npx: installed %s in %ss": "npx: instal·lat %s en %ss",
+  "Suppress output from npx itself. Subcommands will not be affected.": "Suprimir la sortida d' npx. Les sub-comandes no es veuran afectades."
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/libnpx/locales/cs.json

@@ -0,0 +1,28 @@
+{
+  "Execute binaries from npm packages.\n%s": "Spouštění skriptů z npm balíčků.\n%s",
+  "Package to be installed.": "Balíček k instalaci.",
+  "Location of the npm cache.": "Umístění npm keše.",
+  "Skip installation if a package is missing.": "Neinstalovat chybějící balíčky.",
+  "Path to user npmrc.": "Cesta k uživatelskému npmrc souboru.",
+  "Execute string as if inside `npm run-script`.": "Příkaz, který se spustí jakoby uvnitř `npm run-script`.",
+  "Shell to execute the command with, if any.": "Shell ke spuštění příkazu, pokud je třeba.",
+  "Generate shell code to use npx as the \"command not found\" fallback.": "Vygenerovat shell kód použitelný jako \"command not found\" fallback.",
+  "Ignores existing binaries in $PATH, or in the local project. This forces npx to do a temporary install and use the latest version.": "Ignorovat existující skripty v $PATH i v lokálním projektu, npx tak udělá dočasnou instalaci a použije poslední verzi balíčku.",
+  "npm binary to use for internal operations.": "npm použité pro interní operace.",
+  "For the full documentation, see the manual page for npx(1).": "Úplná dokumentace je dostupná v manuálu pro npx(1).",
+  "Unable to guess a binary name from %s. Please use --package.": "Nelze uhodnout jméno skriptu z %s, použijte prosím --package.",
+  "\nERROR: You must supply a command.\n": "\nCHYBA: Musíte zadat nějaký příkaz.\n",
+  "Command failed: %s %s": "Příkaz selhal: %s %s",
+  "Install for %s failed with code %s": "Instalace %s selhala s kódem %s",
+  "%s not found. Trying with npx...": "%s nenalezen. Zkouším npx...",
+  "command not found: %s": "příkaz nenalezen: %s",
+  "options": "parametry",
+  "command": "příkaz",
+  "version": "verze",
+  "command-arg": "argument",
+  "command-string": "příkaz v řetězci",
+  "shell": "shell",
+  "package": "balíček",
+  "npx: installed %s in %ss": "npx: nainstalováno %s za %ss",
+  "Suppress output from npx itself. Subcommands will not be affected.": "Potlačit výstup z npx. Spuštěné příkazy nebudou ovlivněné."
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/libnpx/locales/de.json

@@ -0,0 +1,29 @@
+{
+  "Execute binaries from npm packages.\n%s": "Führt Programme aus, die von npm Paketen bereitgestellt werden.\n%s",
+  "Package to be installed.": "Das zu installierende Paket.",
+  "Location of the npm cache.": "Ort des npm Zwischenspeichers.",
+  "Skip installation if a package is missing.": "Überspringe die Installation, falls ein Paket fehlt.",
+  "Path to user npmrc.": "Pfad zu npmrc im Benutzerverzeichnis.",
+  "Execute string as if inside `npm run-script`.": "Führe Zeichenkette aus, als wäre sie innerhalb von `npm run-script`.",
+  "Shell to execute the command with, if any.": "Shell, mit der Programme ausgeführt werden soll, wenn überhaupt.",
+  "Generate shell code to use npx as the \"command not found\" fallback.": "Erzeuge Shellcode, um npx als Alternative zu \"Programm konnte nicht gefunden werden\" zu benutzen.",
+  "Ignores existing binaries in $PATH, or in the local project. This forces npx to do a temporary install and use the latest version.": "Ignoriere bestehende Programme innerhalb von $PATH oder im lokalen Projekt. Dies zwingt npx dazu, die neuste Version herunterzuladen und zu benutzen.",
+  "npm binary to use for internal operations.": "npm-Programm für die interne Benutzung.",
+  "For the full documentation, see the manual page for npx(1).": "In der Manpage npx(1) ist die gesamte Dokumentation einzusehen.",
+  "Unable to guess a binary name from %s. Please use --package.": "Der Programmname von %s kann nicht automatisch ermittelt werden. Bitte benutze --package.",
+  "\nERROR: You must supply a command.\n": "\nFEHLER: Du musst einen Befehl angeben.\n",
+  "Command failed: %s %s": "Befehl fehlgeschlagen: %s %s",
+  "Install for %s failed with code %s": "Die Installation von %s ist mit dem Code %s fehlgeschlagen",
+  "%s not found. Trying with npx...": "%s konnte nicht gefunden werden. Versuche mit npx...",
+  "command not found: %s": "Programm konnte nicht gefunden werden: %s",
+  "options": "Optionen",
+  "command": "Befehl",
+  "version": "Version",
+  "command-arg": "Befehlsargument",
+  "command-string": "Befehlszeichenkette",
+  "shell": "Shell",
+  "package": "Paket",
+  "npx: installed %s in %ss": "npx: Installierte %s in %ss",
+  "Suppress output from npx itself. Subcommands will not be affected.": "Unterdrücke Output von npx. Unterbefehle sind nicht davon betroffen.",
+  "Extra node argument when calling a node binary.": "Extra node Argument, wenn eine node ausführbare Binärdatei gerufen ist."
+}