jfrog-cli-v2-jf 2.6.0

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/diff-trees.js

@@ -0,0 +1,244 @@
+'use strict'
+var npm = require('../npm.js')
+var validate = require('aproba')
+var npa = require('npm-package-arg')
+var flattenTree = require('./flatten-tree.js')
+var isOnlyDev = require('./is-only-dev.js')
+var log = require('npmlog')
+var path = require('path')
+var ssri = require('ssri')
+var moduleName = require('../utils/module-name.js')
+
+// we don't use get-requested because we're operating on files on disk, and
+// we don't want to extropolate from what _should_ be there.
+function pkgRequested (pkg) {
+  return pkg._requested || (pkg._resolved && npa(pkg._resolved)) || (pkg._from && npa(pkg._from))
+}
+
+function nonRegistrySource (requested) {
+  if (fromGit(requested)) return true
+  if (fromLocal(requested)) return true
+  if (fromRemote(requested)) return true
+  return false
+}
+
+function fromRemote (requested) {
+  if (requested.type === 'remote') return true
+}
+
+function fromLocal (requested) {
+  // local is an npm@3 type that meant "file"
+  if (requested.type === 'file' || requested.type === 'directory' || requested.type === 'local') return true
+  return false
+}
+
+function fromGit (requested) {
+  if (requested.type === 'hosted' || requested.type === 'git') return true
+  return false
+}
+
+function pkgIntegrity (pkg) {
+  try {
+    // dist is provided by the registry
+    var sri = (pkg.dist && pkg.dist.integrity) ||
+              // _integrity is provided by pacote
+              pkg._integrity ||
+              // _shasum is legacy
+              (pkg._shasum && ssri.fromHex(pkg._shasum, 'sha1').toString())
+    if (!sri) return
+    var integrity = ssri.parse(sri)
+    if (Object.keys(integrity).length === 0) return
+    return integrity
+  } catch (ex) {
+    return
+  }
+}
+
+function sriMatch (aa, bb) {
+  if (!aa || !bb) return false
+  for (let algo of Object.keys(aa)) {
+    if (!bb[algo]) continue
+    for (let aaHash of aa[algo]) {
+      for (let bbHash of bb[algo]) {
+        return aaHash.digest === bbHash.digest
+      }
+    }
+  }
+  return false
+}
+
+function pkgAreEquiv (aa, bb) {
+  // coming in we know they share a path…
+
+  // if they share package metadata _identity_, they're the same thing
+  if (aa.package === bb.package) return true
+  // if they share integrity information, they're the same thing
+  var aaIntegrity = pkgIntegrity(aa.package)
+  var bbIntegrity = pkgIntegrity(bb.package)
+  if (aaIntegrity || bbIntegrity) return sriMatch(aaIntegrity, bbIntegrity)
+
+  // if they're links and they share the same target, they're the same thing
+  if (aa.isLink && bb.isLink) return aa.realpath === bb.realpath
+
+  // if we can't determine both their sources then we have no way to know
+  // if they're the same thing, so we have to assume they aren't
+  var aaReq = pkgRequested(aa.package)
+  var bbReq = pkgRequested(bb.package)
+  if (!aaReq || !bbReq) return false
+
+  if (fromGit(aaReq) && fromGit(bbReq)) {
+    // if both are git and share a _resolved specifier (one with the
+    // comittish replaced by a commit hash) then they're the same
+    return aa.package._resolved && bb.package._resolved &&
+           aa.package._resolved === bb.package._resolved
+  }
+
+  // we have to give up trying to find matches for non-registry sources at this point…
+  if (nonRegistrySource(aaReq) || nonRegistrySource(bbReq)) return false
+
+  // finally, if they ARE a registry source then version matching counts
+  return aa.package.version === bb.package.version
+}
+
+function pushAll (aa, bb) {
+  Array.prototype.push.apply(aa, bb)
+}
+
+module.exports = function (oldTree, newTree, differences, log, next) {
+  validate('OOAOF', arguments)
+  pushAll(differences, sortActions(diffTrees(oldTree, newTree)))
+  log.finish()
+  next()
+}
+
+function isNotTopOrExtraneous (node) {
+  return !node.isTop && !node.userRequired && !node.existing
+}
+
+var sortActions = module.exports.sortActions = function (differences) {
+  var actions = {}
+  differences.forEach(function (action) {
+    var child = action[1]
+    actions[child.location] = action
+  })
+
+  var sorted = []
+  var added = {}
+
+  var sortedlocs = Object.keys(actions).sort(sortByLocation)
+
+  // We're going to sort the actions taken on top level dependencies first, before
+  // considering the order of transitive deps. Because we're building our list
+  // from the bottom up, this means we will return a list with top level deps LAST.
+  // This is important in terms of keeping installations as consistent as possible
+  // as folks add new dependencies.
+  var toplocs = sortedlocs.filter(function (location) {
+    var mod = actions[location][1]
+    if (!mod.requiredBy) return true
+    // If this module is required by any non-top level module
+    // or by any extraneous module, eg user requested or existing
+    // then we don't want to give this priority sorting.
+    return !mod.requiredBy.some(isNotTopOrExtraneous)
+  })
+
+  toplocs.concat(sortedlocs).forEach(function (location) {
+    sortByDeps(actions[location])
+  })
+
+  function sortByLocation (aa, bb) {
+    return bb.localeCompare(aa)
+  }
+  function sortModuleByLocation (aa, bb) {
+    return sortByLocation(aa && aa.location, bb && bb.location)
+  }
+  function sortByDeps (action) {
+    var mod = action[1]
+    if (added[mod.location]) return
+    added[mod.location] = action
+    if (!mod.requiredBy) mod.requiredBy = []
+    mod.requiredBy.sort(sortModuleByLocation).forEach(function (mod) {
+      if (actions[mod.location]) sortByDeps(actions[mod.location])
+    })
+    sorted.unshift(action)
+  }
+
+  return sorted
+}
+
+function setAction (differences, action, pkg) {
+  differences.push([action, pkg])
+}
+
+var diffTrees = module.exports._diffTrees = function (oldTree, newTree) {
+  validate('OO', arguments)
+  var differences = []
+  var flatOldTree = flattenTree(oldTree)
+  var flatNewTree = flattenTree(newTree)
+  var toRemove = {}
+  var toRemoveByName = {}
+
+  // Build our tentative remove list.  We don't add remove actions yet
+  // because we might resuse them as part of a move.
+  Object.keys(flatOldTree).forEach(function (flatname) {
+    if (flatname === '/') return
+    if (flatNewTree[flatname]) return
+    var pkg = flatOldTree[flatname]
+    if (pkg.isInLink && /^[.][.][/\\]/.test(path.relative(newTree.realpath, pkg.realpath))) return
+
+    toRemove[flatname] = pkg
+    var name = moduleName(pkg)
+    if (!toRemoveByName[name]) toRemoveByName[name] = []
+    toRemoveByName[name].push({flatname: flatname, pkg: pkg})
+  })
+
+  // generate our add/update/move actions
+  Object.keys(flatNewTree).forEach(function (flatname) {
+    if (flatname === '/') return
+    var pkg = flatNewTree[flatname]
+    var oldPkg = pkg.oldPkg = flatOldTree[flatname]
+    if (oldPkg) {
+      // if the versions are equivalent then we don't need to update… unless
+      // the user explicitly asked us to.
+      if (!pkg.userRequired && pkgAreEquiv(oldPkg, pkg)) return
+      setAction(differences, 'update', pkg)
+    } else {
+      var name = moduleName(pkg)
+      // find any packages we're removing that share the same name and are equivalent
+      var removing = (toRemoveByName[name] || []).filter((rm) => pkgAreEquiv(rm.pkg, pkg))
+      var bundlesOrFromBundle = pkg.fromBundle || pkg.package.bundleDependencies
+      // if we have any removes that match AND we're not working with a bundle then upgrade to a move
+      if (removing.length && !bundlesOrFromBundle) {
+        var toMv = removing.shift()
+        toRemoveByName[name] = toRemoveByName[name].filter((rm) => rm !== toMv)
+        pkg.fromPath = toMv.pkg.path
+        setAction(differences, 'move', pkg)
+        delete toRemove[toMv.flatname]
+      // we don't generate add actions for things found in links (which already exist on disk) or
+      // for bundled modules (which will be installed when we install their parent)
+      } else if (!(pkg.isInLink && pkg.fromBundle)) {
+        setAction(differences, 'add', pkg)
+      }
+    }
+  })
+
+  // finally generate our remove actions from any not consumed by moves
+  Object
+    .keys(toRemove)
+    .map((flatname) => toRemove[flatname])
+    .forEach((pkg) => setAction(differences, 'remove', pkg))
+
+  const includeDev = npm.config.get('dev') ||
+    (!/^prod(uction)?$/.test(npm.config.get('only')) && !npm.config.get('production')) ||
+    /^dev(elopment)?$/.test(npm.config.get('only')) ||
+    /^dev(elopment)?$/.test(npm.config.get('also'))
+  const includeProd = !/^dev(elopment)?$/.test(npm.config.get('only'))
+  if (!includeProd || !includeDev) {
+    log.silly('diff-trees', 'filtering actions:', 'includeDev', includeDev, 'includeProd', includeProd)
+    differences = differences.filter((diff) => {
+      const pkg = diff[1]
+      const pkgIsOnlyDev = isOnlyDev(pkg)
+      return (!includeProd && pkgIsOnlyDev) || (includeDev && pkgIsOnlyDev) || (includeProd && !pkgIsOnlyDev)
+    })
+  }
+  return differences
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/exists.js

@@ -0,0 +1,27 @@
+'use strict'
+var fs = require('fs')
+var inflight = require('inflight')
+var accessError = require('./access-error.js')
+var isFsAccessAvailable = require('./is-fs-access-available.js')
+
+if (isFsAccessAvailable) {
+  module.exports = fsAccessImplementation
+} else {
+  module.exports = fsStatImplementation
+}
+
+// exposed only for testing purposes
+module.exports.fsAccessImplementation = fsAccessImplementation
+module.exports.fsStatImplementation = fsStatImplementation
+
+function fsAccessImplementation (dir, done) {
+  done = inflight('exists:' + dir, done)
+  if (!done) return
+  fs.access(dir, fs.F_OK, done)
+}
+
+function fsStatImplementation (dir, done) {
+  done = inflight('exists:' + dir, done)
+  if (!done) return
+  fs.stat(dir, function (er) { done(accessError(dir, er)) })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/flatten-tree.js

@@ -0,0 +1,42 @@
+'use strict'
+var validate = require('aproba')
+var moduleName = require('../utils/module-name.js')
+
+module.exports = flattenTree
+module.exports.flatName = flatName
+module.exports.flatNameFromTree = flatNameFromTree
+
+function flattenTree (tree) {
+  validate('O', arguments)
+  var seen = new Set()
+  var flat = {}
+  var todo = [[tree, '/']]
+  while (todo.length) {
+    var next = todo.shift()
+    var pkg = next[0]
+    seen.add(pkg)
+    var path = next[1]
+    flat[path] = pkg
+    if (path !== '/') path += '/'
+    for (var ii = 0; ii < pkg.children.length; ++ii) {
+      var child = pkg.children[ii]
+      if (!seen.has(child)) {
+        todo.push([child, flatName(path, child)])
+      }
+    }
+  }
+  return flat
+}
+
+function flatName (path, child) {
+  validate('SO', arguments)
+  return path + (moduleName(child) || 'TOP')
+}
+
+function flatNameFromTree (tree) {
+  validate('O', arguments)
+  if (tree.isTop) return '/'
+  var path = flatNameFromTree(tree.parent)
+  if (path !== '/') path += '/'
+  return flatName(path, tree)
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/get-requested.js

@@ -0,0 +1,12 @@
+'use strict'
+const npa = require('npm-package-arg')
+const moduleName = require('../utils/module-name.js')
+
+module.exports = function (child) {
+  if (!child.requiredBy.length) return
+  const reqBy = child.requiredBy[0]
+  const deps = reqBy.package.dependencies || {}
+  const devDeps = reqBy.package.devDependencies || {}
+  const name = moduleName(child)
+  return npa.resolve(name, deps[name] || devDeps[name], reqBy.realpath)
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/inflate-bundled.js

@@ -0,0 +1,18 @@
+'use strict'
+
+var childPath = require('../utils/child-path.js')
+var reset = require('./node.js').reset
+
+module.exports = function inflateBundled (bundler, parent, children) {
+  children.forEach(function (child) {
+    if (child.fromBundle === bundler) return
+    reset(child)
+    child.fromBundle = bundler
+    child.isInLink = bundler.isLink
+    child.parent = parent
+    child.path = childPath(parent.path, child)
+    child.realpath = bundler.isLink ? child.realpath : childPath(parent.realpath, child)
+    child.isLink = child.isLink || parent.isLink || parent.target
+    inflateBundled(bundler, child, child.children)
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/inflate-shrinkwrap.js

@@ -0,0 +1,206 @@
+'use strict'
+
+const BB = require('bluebird')
+
+let addBundled
+const childPath = require('../utils/child-path.js')
+const createChild = require('./node.js').create
+let fetchPackageMetadata
+const inflateBundled = require('./inflate-bundled.js')
+const moduleName = require('../utils/module-name.js')
+const normalizePackageData = require('normalize-package-data')
+const npm = require('../npm.js')
+const realizeShrinkwrapSpecifier = require('./realize-shrinkwrap-specifier.js')
+const validate = require('aproba')
+const path = require('path')
+const isRegistry = require('../utils/is-registry.js')
+
+module.exports = function (tree, sw, opts, finishInflating) {
+  if (!fetchPackageMetadata) {
+    fetchPackageMetadata = BB.promisify(require('../fetch-package-metadata.js'))
+    addBundled = BB.promisify(fetchPackageMetadata.addBundled)
+  }
+  if (arguments.length === 3) {
+    finishInflating = opts
+    opts = {}
+  }
+  if (!npm.config.get('shrinkwrap') || !npm.config.get('package-lock')) {
+    return finishInflating()
+  }
+  tree.loaded = false
+  tree.hasRequiresFromLock = sw.requires
+  return inflateShrinkwrap(tree.path, tree, sw.dependencies, opts).then(
+    () => finishInflating(),
+    finishInflating
+  )
+}
+
+function inflateShrinkwrap (topPath, tree, swdeps, opts) {
+  if (!swdeps) return Promise.resolve()
+  if (!opts) opts = {}
+  const onDisk = {}
+  tree.children.forEach((child) => {
+    onDisk[moduleName(child)] = child
+  })
+
+  tree.children = []
+
+  return BB.each(Object.keys(swdeps), (name) => {
+    const sw = swdeps[name]
+    const dependencies = sw.dependencies || {}
+    const requested = realizeShrinkwrapSpecifier(name, sw, topPath)
+    return inflatableChild(
+      onDisk[name], name, topPath, tree, sw, requested, opts
+    ).then((child) => {
+      child.hasRequiresFromLock = tree.hasRequiresFromLock
+      return inflateShrinkwrap(topPath, child, dependencies)
+    })
+  })
+}
+
+function normalizePackageDataNoErrors (pkg) {
+  try {
+    normalizePackageData(pkg)
+  } catch (ex) {
+    // don't care
+  }
+}
+
+function inflatableChild (onDiskChild, name, topPath, tree, sw, requested, opts) {
+  validate('OSSOOOO|ZSSOOOO', arguments)
+  if (onDiskChild && childIsEquivalent(sw, requested, onDiskChild)) {
+    // The version on disk matches the shrinkwrap entry.
+    if (!onDiskChild.fromShrinkwrap) onDiskChild.fromShrinkwrap = true
+    onDiskChild.package._requested = requested
+    onDiskChild.package._spec = requested.rawSpec
+    onDiskChild.package._where = topPath
+    onDiskChild.package._optional = sw.optional
+    onDiskChild.package._development = sw.dev
+    onDiskChild.package._inBundle = sw.bundled
+    onDiskChild.fromBundle = (sw.bundled || onDiskChild.package._inBundle) ? tree.fromBundle || tree : null
+    if (!onDiskChild.package._args) onDiskChild.package._args = []
+    onDiskChild.package._args.push([String(requested), topPath])
+    // non-npm registries can and will return unnormalized data, plus
+    // even the npm registry may have package data normalized with older
+    // normalization rules. This ensures we get package data in a consistent,
+    // stable format.
+    normalizePackageDataNoErrors(onDiskChild.package)
+    onDiskChild.swRequires = sw.requires
+    tree.children.push(onDiskChild)
+    return BB.resolve(onDiskChild)
+  } else if ((sw.version && sw.integrity) || sw.bundled) {
+    // The shrinkwrap entry has an integrity field. We can fake a pkg to get
+    // the installer to do a content-address fetch from the cache, if possible.
+    return BB.resolve(makeFakeChild(name, topPath, tree, sw, requested))
+  } else {
+    // It's not on disk, and we can't just look it up by address -- do a full
+    // fpm/inflate bundle pass. For registry deps, this will go straight to the
+    // tarball URL, as if it were a remote tarball dep.
+    return fetchChild(topPath, tree, sw, requested)
+  }
+}
+
+function makeFakeChild (name, topPath, tree, sw, requested) {
+  const from = sw.from || requested.raw
+  const pkg = {
+    name: name,
+    version: sw.version,
+    _id: name + '@' + sw.version,
+    _resolved: adaptResolved(requested, sw.resolved),
+    _requested: requested,
+    _optional: sw.optional,
+    _development: sw.dev,
+    _inBundle: sw.bundled,
+    _integrity: sw.integrity,
+    _from: from,
+    _spec: requested.rawSpec,
+    _where: topPath,
+    _args: [[requested.toString(), topPath]],
+    dependencies: sw.requires
+  }
+
+  if (!sw.bundled) {
+    const bundleDependencies = Object.keys(sw.dependencies || {}).filter((d) => sw.dependencies[d].bundled)
+    if (bundleDependencies.length === 0) {
+      pkg.bundleDependencies = bundleDependencies
+    }
+  }
+  const child = createChild({
+    package: pkg,
+    loaded: true,
+    parent: tree,
+    children: [],
+    fromShrinkwrap: true,
+    fakeChild: sw,
+    fromBundle: sw.bundled ? tree.fromBundle || tree : null,
+    path: childPath(tree.path, pkg),
+    realpath: childPath(tree.realpath, pkg),
+    location: tree.location + '/' + pkg.name,
+    isLink: requested.type === 'directory',
+    isInLink: tree.isLink,
+    swRequires: sw.requires
+  })
+  tree.children.push(child)
+  return child
+}
+
+function adaptResolved (requested, resolved) {
+  const registry = requested.scope
+  ? npm.config.get(`${requested.scope}:registry`) || npm.config.get('registry')
+  : npm.config.get('registry')
+  if (!isRegistry(requested) || (resolved && resolved.indexOf(registry) === 0)) {
+    // Nothing to worry about here. Pass it through.
+    return resolved
+  } else {
+    // We could fast-path for registry.npmjs.org here, but if we do, it
+    // would end up getting written back to the `resolved` field. By always
+    // returning `null` for other registries, `pacote.extract()` will take
+    // care of any required metadata fetches internally, without altering
+    // the tree we're going to write out to shrinkwrap/lockfile.
+    return null
+  }
+}
+
+function fetchChild (topPath, tree, sw, requested) {
+  return fetchPackageMetadata(requested, topPath).then((pkg) => {
+    pkg._from = sw.from || requested.raw
+    pkg._optional = sw.optional
+    pkg._development = sw.dev
+    pkg._inBundle = false
+    return addBundled(pkg).then(() => pkg)
+  }).then((pkg) => {
+    var isLink = pkg._requested.type === 'directory'
+    const child = createChild({
+      package: pkg,
+      loaded: false,
+      parent: tree,
+      fromShrinkwrap: requested,
+      path: childPath(tree.path, pkg),
+      realpath: isLink ? requested.fetchSpec : childPath(tree.realpath, pkg),
+      children: pkg._bundled || [],
+      location: tree.location + '/' + pkg.name,
+      fromBundle: null,
+      isLink: isLink,
+      isInLink: tree.isLink,
+      swRequires: sw.requires
+    })
+    tree.children.push(child)
+    if (pkg._bundled) {
+      delete pkg._bundled
+      inflateBundled(child, child, child.children)
+    }
+    return child
+  })
+}
+
+function childIsEquivalent (sw, requested, child) {
+  if (!child) return false
+  if (child.fromShrinkwrap) return true
+  if (sw.integrity && child.package._integrity === sw.integrity) return true
+  if (child.isLink && requested.type === 'directory') return path.relative(child.realpath, requested.fetchSpec) === ''
+
+  if (sw.resolved) return child.package._resolved === sw.resolved
+  if (!isRegistry(requested) && sw.from) return child.package._from === sw.from
+  if (!isRegistry(requested) && child.package._resolved) return sw.version === child.package._resolved
+  return child.package.version === sw.version
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/is-dev-dep.js

@@ -0,0 +1,8 @@
+'use strict'
+module.exports = isDevDep
+
+function isDevDep (node, name) {
+  return node.package &&
+    node.package.devDependencies &&
+    node.package.devDependencies[name]
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/is-extraneous.js

@@ -0,0 +1,27 @@
+'use strict'
+module.exports = isExtraneous
+
+function isExtraneous (tree) {
+  var result = !isNotExtraneous(tree)
+  return result
+}
+
+function topHasNoPjson (tree) {
+  var top = tree
+  while (!top.isTop) top = top.parent
+  return top.error
+}
+
+function isNotExtraneous (tree, isCycle) {
+  if (!isCycle) isCycle = {}
+  if (tree.isTop || tree.userRequired) {
+    return true
+  } else if (isCycle[tree.path]) {
+    return topHasNoPjson(tree)
+  } else {
+    isCycle[tree.path] = true
+    return tree.requiredBy && tree.requiredBy.some(function (node) {
+      return isNotExtraneous(node, Object.create(isCycle))
+    })
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/is-fs-access-available.js

@@ -0,0 +1,22 @@
+'use strict'
+var fs = require('fs')
+var semver = require('semver')
+var isWindows = process.platform === 'win32'
+
+// fs.access first introduced in node 0.12 / io.js
+if (!fs.access) {
+  module.exports = false
+} else if (!isWindows) {
+  // fs.access always works on non-Windows OSes
+  module.exports = true
+} else {
+  // The Windows implementation of `fs.access` has a bug where it will
+  // sometimes return access errors all the time for directories, even
+  // when access is available. As all we actually test ARE directories, this
+  // is a bit of a problem.
+  // This was fixed in io.js version 1.5.0
+  // As of 2015-07-20, it is still unfixed in node:
+  // https://github.com/joyent/node/issues/25657
+
+  module.exports = semver.gte(process.version, '1.5.0')
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/is-only-dev.js

@@ -0,0 +1,35 @@
+'use strict'
+module.exports = isOnlyDev
+
+const moduleName = require('../utils/module-name.js')
+const isDevDep = require('./is-dev-dep.js')
+const isProdDep = require('./is-prod-dep.js')
+
+// Returns true if the module `node` is only required direcctly as a dev
+// dependency of the top level or transitively _from_ top level dev
+// dependencies.
+// Dual mode modules (that are both dev AND prod) should return false.
+function isOnlyDev (node, seen) {
+  if (!seen) seen = new Set()
+  return node.requiredBy.length && node.requiredBy.every(andIsOnlyDev(moduleName(node), seen))
+}
+
+// There is a known limitation with this implementation: If a dependency is
+// ONLY required by cycles that are detached from the top level then it will
+// ultimately return true.
+//
+// This is ok though: We don't allow shrinkwraps with extraneous deps and
+// these situation is caught by the extraneous checker before we get here.
+function andIsOnlyDev (name, seen) {
+  return function (req) {
+    const isDev = isDevDep(req, name)
+    const isProd = isProdDep(req, name)
+    if (req.isTop) {
+      return isDev && !isProd
+    } else {
+      if (seen.has(req)) return true
+      seen.add(req)
+      return isOnlyDev(req, seen)
+    }
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/is-only-optional.js

@@ -0,0 +1,18 @@
+'use strict'
+module.exports = isOptional
+
+const isOptDep = require('./is-opt-dep.js')
+
+function isOptional (node, seen) {
+  if (!seen) seen = new Set()
+  // If a node is not required by anything, then we've reached
+  // the top level package.
+  if (seen.has(node) || node.requiredBy.length === 0) {
+    return false
+  }
+  seen.add(node)
+
+  return node.requiredBy.every(function (req) {
+    return isOptDep(req, node.package.name) || isOptional(req, seen)
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/is-opt-dep.js

@@ -0,0 +1,8 @@
+'use strict'
+module.exports = isOptDep
+
+function isOptDep (node, name) {
+  return node.package &&
+    node.package.optionalDependencies &&
+    node.package.optionalDependencies[name]
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/install/is-prod-dep.js

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = isProdDep
+
+function isProdDep (node, name) {
+  return node.package &&
+    node.package.dependencies &&
+    node.package.dependencies[name]
+}