jfrog-cli-v2-jf 2.6.0

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+Copyright (c) 2017 Kat Marchán
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.
+

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/README.md

@@ -0,0 +1,201 @@
+# pacote [![npm version](https://img.shields.io/npm/v/pacote.svg)](https://npm.im/pacote) [![license](https://img.shields.io/npm/l/pacote.svg)](https://npm.im/pacote) [![Travis](https://img.shields.io/travis/zkat/pacote.svg)](https://travis-ci.org/zkat/pacote) [![AppVeyor](https://ci.appveyor.com/api/projects/status/github/zkat/pacote?svg=true)](https://ci.appveyor.com/project/zkat/pacote) [![Coverage Status](https://coveralls.io/repos/github/zkat/pacote/badge.svg?branch=latest)](https://coveralls.io/github/zkat/pacote?branch=latest)
+
+[`pacote`](https://github.com/zkat/pacote) is a Node.js library for downloading
+[npm](https://npmjs.org)-compatible packages. It supports all package specifier
+syntax that `npm install` and its ilk support. It transparently caches anything
+needed to reduce excess operations, using [`cacache`](https://npm.im/cacache).
+
+## Install
+
+`$ npm install --save pacote`
+
+## Table of Contents
+
+* [Example](#example)
+* [Features](#features)
+* [Contributing](#contributing)
+* [API](#api)
+  * [`manifest`](#manifest)
+  * [`extract`](#extract)
+  * [`tarball`](#tarball)
+  * [`tarball.stream`](#tarball-stream)
+  * [`tarball.toFile`](#tarball-to-file)
+  * [`prefetch`](#prefetch)
+  * [`options`](#options)
+  * [`clearMemoized`](#clearMemoized)
+
+### Example
+
+```javascript
+const pacote = require('pacote')
+
+pacote.manifest('pacote@^1').then(pkg => {
+  console.log('package manifest for registry pkg:', pkg)
+  // { "name": "pacote", "version": "1.0.0", ... }
+})
+
+pacote.extract('http://hi.com/pkg.tgz', './here').then(() => {
+  console.log('remote tarball contents extracted to ./here')
+})
+```
+
+### Features
+
+* Handles all package types [npm](https://npm.im/npm) does
+* [high-performance, reliable, verified local cache](https://npm.im/cacache)
+* offline mode
+* authentication support (private git, private npm registries, etc)
+* github, gitlab, and bitbucket-aware
+* semver range support for git dependencies
+
+### Contributing
+
+The pacote team enthusiastically welcomes contributions and project participation! There's a bunch of things you can do if you want to contribute! The [Contributor Guide](CONTRIBUTING.md) has all the information you need for everything from reporting bugs to contributing entire new features. Please don't hesitate to jump in if you'd like to, or even ask us questions if something isn't clear.
+
+### API
+
+#### <a name="manifest"></a> `> pacote.manifest(spec, [opts])`
+
+Fetches the *manifest* for a package. Manifest objects are similar and based
+on the `package.json` for that package, but with pre-processed and limited
+fields. The object has the following shape:
+
+```javascript
+{
+  "name": PkgName,
+  "version": SemverString,
+  "dependencies": { PkgName: SemverString },
+  "optionalDependencies": { PkgName: SemverString },
+  "devDependencies": { PkgName: SemverString },
+  "peerDependencies": { PkgName: SemverString },
+  "bundleDependencies": false || [PkgName],
+  "bin": { BinName: Path },
+  "_resolved": TarballSource, // different for each package type
+  "_integrity": SubresourceIntegrityHash,
+  "_shrinkwrap": null || ShrinkwrapJsonObj
+}
+```
+
+Note that depending on the spec type, some additional fields might be present.
+For example, packages from `registry.npmjs.org` have additional metadata
+appended by the registry.
+
+##### Example
+
+```javascript
+pacote.manifest('pacote@1.0.0').then(pkgJson => {
+  // fetched `package.json` data from the registry
+})
+```
+
+#### <a name="extract"></a> `> pacote.extract(spec, destination, [opts])`
+
+Extracts package data identified by `<spec>` into a directory named
+`<destination>`, which will be created if it does not already exist.
+
+If `opts.digest` is provided and the data it identifies is present in the cache,
+`extract` will bypass most of its operations and go straight to extracting the
+tarball.
+
+##### Example
+
+```javascript
+pacote.extract('pacote@1.0.0', './woot', {
+  digest: 'deadbeef'
+}).then(() => {
+  // Succeeds as long as `pacote@1.0.0` still exists somewhere. Network and
+  // other operations are bypassed entirely if `digest` is present in the cache.
+})
+```
+
+#### <a name="tarball"></a> `> pacote.tarball(spec, [opts])`
+
+Fetches package data identified by `<spec>` and returns the data as a buffer.
+
+This API has two variants:
+
+* `pacote.tarball.stream(spec, [opts])` - Same as `pacote.tarball`, except it returns a stream instead of a Promise.
+* `pacote.tarball.toFile(spec, dest, [opts])` - Instead of returning data directly, data will be written directly to `dest`, and create any required directories along the way.
+
+##### Example
+
+```javascript
+pacote.tarball('pacote@1.0.0', { cache: './my-cache' }).then(data => {
+  // data is the tarball data for pacote@1.0.0
+})
+```
+
+#### <a name="tarball-stream"></a> `> pacote.tarball.stream(spec, [opts])`
+
+Same as `pacote.tarball`, except it returns a stream instead of a Promise.
+
+##### Example
+
+```javascript
+pacote.tarball.stream('pacote@1.0.0')
+.pipe(fs.createWriteStream('./pacote-1.0.0.tgz'))
+```
+
+#### <a name="tarball-to-file"></a> `> pacote.tarball.toFile(spec, dest, [opts])`
+
+Like `pacote.tarball`, but instead of returning data directly, data will be
+written directly to `dest`, and create any required directories along the way.
+
+##### Example
+
+```javascript
+pacote.tarball.toFile('pacote@1.0.0', './pacote-1.0.0.tgz')
+.then(() => /* pacote tarball written directly to ./pacote-1.0.0.tgz */)
+```
+
+#### <a name="prefetch"></a> `> pacote.prefetch(spec, [opts])`
+
+##### THIS API IS DEPRECATED. USE `pacote.tarball()` INSTEAD
+
+Fetches package data identified by `<spec>`, usually for the purpose of warming
+up the local package cache (with `opts.cache`). It does not return anything.
+
+##### Example
+
+```javascript
+pacote.prefetch('pacote@1.0.0', { cache: './my-cache' }).then(() => {
+  // ./my-cache now has both the manifest and tarball for `pacote@1.0.0`.
+})
+```
+
+#### <a name="clearMemoized"></a> `> pacote.clearMemoized()`
+
+This utility function can be used to force pacote to release its references
+to any memoized data in its various internal caches. It might help free
+some memory.
+
+```javascript
+pacote.manifest(...).then(() => pacote.clearMemoized)
+
+```
+
+#### <a name="options"></a> `> options`
+
+##### `opts.integrity`
+
+If provided, pacote will confirm that the relevant integrity hash for each
+operation's results matches the given digest. The call will return `EINTEGRITY`
+if the check fails.
+
+Additionally, `pacote.extract` will use this integrity string check the cache
+directly for matching contents before performing any other operations.
+
+##### `opts.cache`
+##### `opts.cacheUid`/`opts.cacheGid`
+##### `opts.uid`/`opts.gid`
+##### `opts.scope`
+##### `opts.registry`
+##### `opts.@somescope:registry`
+##### `opts.auth`
+##### `opts.log`
+##### `opts.maxSockets`
+
+Default: `silentNpmLog`
+
+An [`npmlog`](https://npm.im/npmlog)-compatible logger. Will be used to log
+various events at the levels specified by `npmlog`.

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/extract.js

@@ -0,0 +1,100 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const cacache = require('cacache')
+const extractStream = require('./lib/extract-stream')
+const mkdirp = BB.promisify(require('mkdirp'))
+const npa = require('npm-package-arg')
+const optCheck = require('./lib/util/opt-check')
+const retry = require('promise-retry')
+const rimraf = BB.promisify(require('rimraf'))
+
+module.exports = extract
+function extract (spec, dest, opts) {
+  opts = optCheck(opts)
+  spec = npa(spec, opts.where)
+  const startTime = Date.now()
+  if (opts.integrity && opts.cache && !opts.preferOnline) {
+    opts.log.silly('pacote', `trying ${spec} by hash: ${opts.integrity}`)
+    return extractByDigest(
+      startTime, spec, dest, opts
+    ).catch(err => {
+      if (err.code === 'ENOENT') {
+        opts.log.silly('pacote', `data for ${opts.integrity} not present. Using manifest.`)
+        return extractByManifest(startTime, spec, dest, opts)
+      }
+
+      if (err.code === 'EINTEGRITY' || err.code === 'Z_DATA_ERROR') {
+        opts.log.warn('pacote', `cached data for ${spec} (${opts.integrity}) seems to be corrupted. Refreshing cache.`)
+      }
+      return cleanUpCached(
+        dest, opts.cache, opts.integrity, opts
+      ).then(() => {
+        return extractByManifest(startTime, spec, dest, opts)
+      })
+    })
+  } else {
+    opts.log.silly('pacote', 'no tarball hash provided for', spec.name, '- extracting by manifest')
+    return BB.resolve(retry((tryAgain, attemptNum) => {
+      return extractByManifest(
+        startTime, spec, dest, opts
+      ).catch(err => {
+        // Retry once if we have a cache, to clear up any weird conditions.
+        // Don't retry network errors, though -- make-fetch-happen has already
+        // taken care of making sure we're all set on that front.
+        if (opts.cache && !err.code.match(/^E\d{3}$/)) {
+          if (err.code === 'EINTEGRITY' || err.code === 'Z_DATA_ERROR') {
+            opts.log.warn('pacote', `tarball data for ${spec} (${opts.integrity}) seems to be corrupted. Trying one more time.`)
+          }
+          return cleanUpCached(
+            dest, opts.cache, err.sri, opts
+          ).then(() => tryAgain(err))
+        } else {
+          throw err
+        }
+      })
+    }, {retries: 1}))
+  }
+}
+
+function extractByDigest (start, spec, dest, opts) {
+  return mkdirp(dest).then(() => {
+    const xtractor = extractStream(dest, opts)
+    const cached = cacache.get.stream.byDigest(opts.cache, opts.integrity, opts)
+    cached.pipe(xtractor)
+    return new BB((resolve, reject) => {
+      cached.on('error', reject)
+      xtractor.on('error', reject)
+      xtractor.on('close', resolve)
+    })
+  }).then(() => {
+    opts.log.silly('pacote', `${spec} extracted to ${dest} by content address ${Date.now() - start}ms`)
+  })
+}
+
+let fetch
+function extractByManifest (start, spec, dest, opts) {
+  return mkdirp(dest).then(() => {
+    const xtractor = extractStream(dest, opts)
+    if (!fetch) {
+      fetch = require('./lib/fetch')
+    }
+    const tardata = fetch.tarball(spec, opts)
+    tardata.pipe(xtractor)
+    return new BB((resolve, reject) => {
+      tardata.on('error', reject)
+      xtractor.on('error', reject)
+      xtractor.on('close', resolve)
+    })
+  }).then(() => {
+    opts.log.silly('pacote', `${spec} extracted in ${Date.now() - start}ms`)
+  })
+}
+
+function cleanUpCached (dest, cachePath, integrity, opts) {
+  return BB.join(
+    rimraf(dest),
+    cacache.rm.content(cachePath, integrity, opts)
+  )
+}

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

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = {
+  extract: require('./extract'),
+  manifest: require('./manifest'),
+  prefetch: require('./prefetch'),
+  tarball: require('./tarball'),
+  clearMemoized: require('./lib/fetch').clearMemoized
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/lib/extract-stream.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const path = require('path')
+const tar = require('tar')
+
+module.exports = extractStream
+module.exports._computeMode = computeMode
+
+function computeMode (fileMode, optMode, umask) {
+  return (fileMode | optMode) & ~(umask || 0)
+}
+
+function extractStream (dest, opts) {
+  opts = opts || {}
+  const sawIgnores = new Set()
+  return tar.x({
+    cwd: dest,
+    filter: (name, entry) => !entry.header.type.match(/^.*link$/i),
+    strip: 1,
+    onwarn: msg => opts.log && opts.log.warn('tar', msg),
+    uid: opts.uid,
+    gid: opts.gid,
+    onentry (entry) {
+      if (entry.type.toLowerCase() === 'file') {
+        entry.mode = computeMode(entry.mode, opts.fmode, opts.umask)
+      } else if (entry.type.toLowerCase() === 'directory') {
+        entry.mode = computeMode(entry.mode, opts.dmode, opts.umask)
+      } else {
+        entry.mode = computeMode(entry.mode, 0, opts.umask)
+      }
+
+      // Note: This mirrors logic in the fs read operations that are
+      // employed during tarball creation, in the fstream-npm module.
+      // It is duplicated here to handle tarballs that are created
+      // using other means, such as system tar or git archive.
+      if (entry.type.toLowerCase() === 'file') {
+        const base = path.basename(entry.path)
+        if (base === '.npmignore') {
+          sawIgnores.add(entry.path)
+        } else if (base === '.gitignore') {
+          const npmignore = entry.path.replace(/\.gitignore$/, '.npmignore')
+          if (!sawIgnores.has(npmignore)) {
+            // Rename, may be clobbered later.
+            entry.path = npmignore
+          }
+        }
+      }
+    }
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/lib/fetch.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const duck = require('protoduck')
+
+const Fetcher = duck.define(['spec', 'opts', 'manifest'], {
+  manifest: ['spec', 'opts'],
+  tarball: ['spec', 'opts'],
+  fromManifest: ['manifest', 'spec', 'opts'],
+  clearMemoized () {}
+}, {name: 'Fetcher'})
+module.exports = Fetcher
+
+module.exports.manifest = manifest
+function manifest (spec, opts) {
+  const fetcher = getFetcher(spec.type)
+  return fetcher.manifest(spec, opts)
+}
+
+module.exports.tarball = tarball
+function tarball (spec, opts) {
+  return getFetcher(spec.type).tarball(spec, opts)
+}
+
+module.exports.fromManifest = fromManifest
+function fromManifest (manifest, spec, opts) {
+  return getFetcher(spec.type).fromManifest(manifest, spec, opts)
+}
+
+const fetchers = {}
+
+module.exports.clearMemoized = clearMemoized
+function clearMemoized () {
+  Object.keys(fetchers).forEach(k => {
+    fetchers[k].clearMemoized()
+  })
+}
+
+function getFetcher (type) {
+  if (!fetchers[type]) {
+    // This is spelled out both to prevent sketchy stuff and to make life
+    // easier for bundlers/preprocessors.
+    switch (type) {
+      case 'directory':
+        fetchers[type] = require('./fetchers/directory')
+        break
+      case 'file':
+        fetchers[type] = require('./fetchers/file')
+        break
+      case 'git':
+        fetchers[type] = require('./fetchers/git')
+        break
+      case 'hosted':
+        fetchers[type] = require('./fetchers/hosted')
+        break
+      case 'range':
+        fetchers[type] = require('./fetchers/range')
+        break
+      case 'remote':
+        fetchers[type] = require('./fetchers/remote')
+        break
+      case 'tag':
+        fetchers[type] = require('./fetchers/tag')
+        break
+      case 'version':
+        fetchers[type] = require('./fetchers/version')
+        break
+      default:
+        throw new Error(`Invalid dependency type requested: ${type}`)
+    }
+  }
+  return fetchers[type]
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/lib/fetchers/directory.js

@@ -0,0 +1,71 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const Fetcher = require('../fetch')
+const glob = BB.promisify(require('glob'))
+const packDir = require('../util/pack-dir')
+const path = require('path')
+const pipe = BB.promisify(require('mississippi').pipe)
+const through = require('mississippi').through
+
+const readFileAsync = BB.promisify(require('fs').readFile)
+
+const fetchDirectory = module.exports = Object.create(null)
+
+Fetcher.impl(fetchDirectory, {
+  // `directory` manifests come from the actual manifest/lockfile data.
+  manifest (spec, opts) {
+    const pkgPath = path.join(spec.fetchSpec, 'package.json')
+    const srPath = path.join(spec.fetchSpec, 'npm-shrinkwrap.json')
+    return BB.join(
+      readFileAsync(pkgPath).then(JSON.parse).catch({code: 'ENOENT'}, err => {
+        err.code = 'ENOPACKAGEJSON'
+        throw err
+      }),
+      readFileAsync(srPath).then(JSON.parse).catch({code: 'ENOENT'}, () => null),
+      (pkg, sr) => {
+        pkg._shrinkwrap = sr
+        pkg._hasShrinkwrap = !!sr
+        pkg._resolved = spec.fetchSpec
+        pkg._integrity = false // Don't auto-calculate integrity
+        return pkg
+      }
+    ).then(pkg => {
+      if (!pkg.bin && pkg.directories && pkg.directories.bin) {
+        const dirBin = pkg.directories.bin
+        return glob(path.join(spec.fetchSpec, dirBin, '/**'), {nodir: true}).then(matches => {
+          matches.forEach(filePath => {
+            const relative = path.relative(spec.fetchSpec, filePath)
+            if (relative && relative[0] !== '.') {
+              if (!pkg.bin) { pkg.bin = {} }
+              pkg.bin[path.basename(relative)] = relative
+            }
+          })
+        }).then(() => pkg)
+      } else {
+        return pkg
+      }
+    })
+  },
+
+  // As of npm@5, the npm installer doesn't pack + install directories: it just
+  // creates symlinks. This code is here because `npm pack` still needs the
+  // ability to create a tarball from a local directory.
+  tarball (spec, opts) {
+    const stream = through()
+    this.manifest(spec, opts).then(mani => {
+      return pipe(this.fromManifest(mani, spec, opts), stream)
+    }).catch(err => stream.emit('error', err))
+    return stream
+  },
+
+  // `directory` tarballs are generated in a very similar way to git tarballs.
+  fromManifest (manifest, spec, opts) {
+    const stream = through()
+    packDir(manifest, manifest._resolved, manifest._resolved, stream, opts).catch(err => {
+      stream.emit('error', err)
+    })
+    return stream
+  }
+})

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/lib/fetchers/file.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const cacache = require('cacache')
+const Fetcher = require('../fetch')
+const fs = require('fs')
+const pipe = BB.promisify(require('mississippi').pipe)
+const through = require('mississippi').through
+
+const readFileAsync = BB.promisify(fs.readFile)
+const statAsync = BB.promisify(fs.stat)
+
+const MAX_BULK_SIZE = 2 * 1024 * 1024 // 2MB
+
+// `file` packages refer to local tarball files.
+const fetchFile = module.exports = Object.create(null)
+
+Fetcher.impl(fetchFile, {
+  manifest (spec, opts) {
+    // We can't do much here. `finalizeManifest` will take care of
+    // calling `tarball` to fill out all the necessary details.
+    return BB.resolve(null)
+  },
+
+  // All the heavy lifting for `file` packages is done here.
+  // They're never cached. We just read straight out of the file.
+  // TODO - maybe they *should* be cached?
+  tarball (spec, opts) {
+    const src = spec._resolved || spec.fetchSpec
+    const stream = through()
+    statAsync(src).then(stat => {
+      if (spec._resolved) { stream.emit('manifest', spec) }
+      if (stat.size <= MAX_BULK_SIZE) {
+        // YAY LET'S DO THING IN BULK
+        return readFileAsync(src).then(data => {
+          if (opts.cache) {
+            return cacache.put(
+              opts.cache, `pacote:tarball:file:${src}`, data, {
+                integrity: opts.integrity
+              }
+            ).then(integrity => ({data, integrity}))
+          } else {
+            return {data}
+          }
+        }).then(info => {
+          if (info.integrity) { stream.emit('integrity', info.integrity) }
+          stream.write(info.data, () => {
+            stream.end()
+          })
+        })
+      } else {
+        let integrity
+        const cacheWriter = !opts.cache
+        ? BB.resolve(null)
+        : (pipe(
+          fs.createReadStream(src),
+          cacache.put.stream(opts.cache, `pacote:tarball:${src}`, {
+            integrity: opts.integrity
+          }).on('integrity', d => { integrity = d })
+        ))
+        return cacheWriter.then(() => {
+          if (integrity) { stream.emit('integrity', integrity) }
+          return pipe(fs.createReadStream(src), stream)
+        })
+      }
+    }, err => stream.emit('error', err))
+    return stream
+  },
+
+  fromManifest (manifest, spec, opts) {
+    return this.tarball(manifest || spec, opts)
+  }
+})