nyc 13.2.0 → 14.0.0

package/node_modules/signal-exit/package.json

@@ -1,77 +0,0 @@
-{
-  "_args": [
-    [
-      "signal-exit@3.0.2",
-      "/usr/src/npm/nyc"
-    ]
-  ],
-  "_from": "signal-exit@3.0.2",
-  "_id": "signal-exit@3.0.2",
-  "_inBundle": false,
-  "_integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=",
-  "_location": "/signal-exit",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "signal-exit@3.0.2",
-    "name": "signal-exit",
-    "escapedName": "signal-exit",
-    "rawSpec": "3.0.2",
-    "saveSpec": null,
-    "fetchSpec": "3.0.2"
-  },
-  "_requiredBy": [
-    "/",
-    "/execa",
-    "/foreground-child",
-    "/loud-rejection",
-    "/restore-cursor",
-    "/spawn-wrap",
-    "/standard-version/execa",
-    "/tap",
-    "/write-file-atomic"
-  ],
-  "_resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz",
-  "_spec": "3.0.2",
-  "_where": "/usr/src/npm/nyc",
-  "author": {
-    "name": "Ben Coe",
-    "email": "ben@npmjs.com"
-  },
-  "bugs": {
-    "url": "https://github.com/tapjs/signal-exit/issues"
-  },
-  "description": "when you want to fire an event no matter how a process exits.",
-  "devDependencies": {
-    "chai": "^3.5.0",
-    "coveralls": "^2.11.10",
-    "nyc": "^8.1.0",
-    "standard": "^7.1.2",
-    "standard-version": "^2.3.0",
-    "tap": "^8.0.1"
-  },
-  "files": [
-    "index.js",
-    "signals.js"
-  ],
-  "homepage": "https://github.com/tapjs/signal-exit",
-  "keywords": [
-    "signal",
-    "exit"
-  ],
-  "license": "ISC",
-  "main": "index.js",
-  "name": "signal-exit",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tapjs/signal-exit.git"
-  },
-  "scripts": {
-    "coverage": "nyc report --reporter=text-lcov | coveralls",
-    "pretest": "standard",
-    "release": "standard-version",
-    "test": "tap --timeout=240 ./test/*.js --cov"
-  },
-  "version": "3.0.2"
-}

package/node_modules/signal-exit/signals.js

@@ -1,53 +0,0 @@
-// This is not the set of all possible signals.
-//
-// It IS, however, the set of all signals that trigger
-// an exit on either Linux or BSD systems.  Linux is a
-// superset of the signal names supported on BSD, and
-// the unknown signals just fail to register, so we can
-// catch that easily enough.
-//
-// Don't bother with SIGKILL.  It's uncatchable, which
-// means that we can't fire any callbacks anyway.
-//
-// If a user does happen to register a handler on a non-
-// fatal signal like SIGWINCH or something, and then
-// exit, it'll end up firing `process.emit('exit')`, so
-// the handler will be fired anyway.
-//
-// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
-// artificially, inherently leave the process in a
-// state from which it is not safe to try and enter JS
-// listeners.
-module.exports = [
-  'SIGABRT',
-  'SIGALRM',
-  'SIGHUP',
-  'SIGINT',
-  'SIGTERM'
-]
-
-if (process.platform !== 'win32') {
-  module.exports.push(
-    'SIGVTALRM',
-    'SIGXCPU',
-    'SIGXFSZ',
-    'SIGUSR2',
-    'SIGTRAP',
-    'SIGSYS',
-    'SIGQUIT',
-    'SIGIOT'
-    // should detect profiler and enable/disable accordingly.
-    // see #21
-    // 'SIGPROF'
-  )
-}
-
-if (process.platform === 'linux') {
-  module.exports.push(
-    'SIGIO',
-    'SIGPOLL',
-    'SIGPWR',
-    'SIGSTKFLT',
-    'SIGUNUSED'
-  )
-}

package/node_modules/spawn-wrap/LICENSE

@@ -1,15 +0,0 @@
-The ISC License
-
-Copyright (c) Isaac Z. Schlueter and Contributors
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/node_modules/spawn-wrap/README.md

@@ -1,111 +0,0 @@
-# spawn-wrap
-
-Wrap all spawned Node.js child processes by adding environs and
-arguments ahead of the main JavaScript file argument.
-
-Any child processes launched by that child process will also be
-wrapped in a similar fashion.
-
-This is a bit of a brutal hack, designed primarily to support code
-coverage reporting in cases where tests or the system under test are
-loaded via child processes rather than via `require()`.
-
-It can also be handy if you want to run your own mock executable
-instead of some other thing when child procs call into it.
-
-[![Build Status](https://travis-ci.org/tapjs/spawn-wrap.svg)](https://travis-ci.org/tapjs/spawn-wrap) [![Build status](https://ci.appveyor.com/api/projects/status/oea7gdvqa0qeijrm?svg=true)](https://ci.appveyor.com/project/isaacs/spawn-wrap)
-
-## USAGE
-
-```javascript
-var wrap = require('spawn-wrap')
-
-// wrap(wrapperArgs, environs)
-var unwrap = wrap(['/path/to/my/main.js', 'foo=bar'], { FOO: 1 })
-
-// later to undo the wrapping, you can call the returned function
-unwrap()
-```
-
-In this example, the `/path/to/my/main.js` file will be used as the
-"main" module, whenever any Node or io.js child process is started,
-whether via a call to `spawn` or `exec`, whether node is invoked
-directly as the command or as the result of a shebang `#!` lookup.
-
-In `/path/to/my/main.js`, you can do whatever instrumentation or
-environment manipulation you like.  When you're done, and ready to run
-the "real" main.js file (ie, the one that was spawned in the first
-place), you can do this:
-
-```javascript
-// /path/to/my/main.js
-// process.argv[1] === 'foo=bar'
-// and process.env.FOO === '1'
-
-// my wrapping manipulations
-setupInstrumentationOrCoverageOrWhatever()
-process.on('exit', function (code) {
-  storeCoverageInfoSynchronously()
-})
-
-// now run the instrumented and covered or whatever codes
-require('spawn-wrap').runMain()
-```
-
-## ENVIRONMENT VARIABLES
-
-Spawn-wrap responds to two environment variables, both of which are
-preserved through child processes.
-
-`SPAWN_WRAP_DEBUG=1` in the environment will make this module dump a
-lot of information to stderr.
-
-`SPAWN_WRAP_SHIM_ROOT` can be set to a path on the filesystem where
-the shim files are written in a `.node-spawn-wrap-<id>` folder.  By
-default this is done in `$HOME`, but in some environments you may wish
-to point it at some other root.  (For example, if `$HOME` is mounted
-as read-only in a virtual machine or container.)
-
-## CONTRACTS and CAVEATS
-
-The initial wrap call uses synchronous I/O.  Probably you should not
-be using this script in any production environments anyway.
-
-Also, this will slow down child process execution by a lot, since
-we're adding a few layers of indirection.
-
-The contract which this library aims to uphold is:
-
-* Wrapped processes behave identical to their unwrapped counterparts
-  for all intents and purposes.  That means that the wrapper script
-  propagates all signals and exit codes.
-* If you send a signal to the wrapper, the child gets the signal.
-* If the child exits with a numeric status code, then the wrapper
-  exits with that code.
-* If the child dies with a signal, then the wrapper dies with the
-  same signal.
-* If you execute any Node child process, in any of the various ways
-  that such a thing can be done, it will be wrapped.
-* Children of wrapped processes are also wrapped.
-
-(Much of this made possible by
-[foreground-child](http://npm.im/foreground-child).)
-
-There are a few ways situations in which this contract cannot be
-adhered to, despite best efforts:
-
-1. In order to handle cases where `node` is invoked in a shell script,
-   the `PATH` environment variable is modified such that the the shim
-   will be run before the "real" node.  However, since Windows does
-   not allow executing shebang scripts like regular programs, a
-   `node.cmd` file is required.
-2. Signal propagation through `dash` doesn't always work.  So, if you
-   use `child_process.exec()` on systems where `/bin/sh` is actually
-   `dash`, then the process may exit with a status code > 128 rather
-   than indicating that it received a signal.
-3. `cmd.exe` is even stranger with how it propagates and interprets
-   unix signals.  If you want your programs to be portable, then
-   probably you wanna not rely on signals too much.
-4. It *is* possible to escape the wrapping, if you spawn a bash
-   script, and that script modifies the `PATH`, and then calls a
-   specific `node` binary explicitly.

package/node_modules/spawn-wrap/index.js

@@ -1,447 +0,0 @@
-module.exports = wrap
-wrap.runMain = runMain
-
-var Module = require('module')
-var fs = require('fs')
-var cp = require('child_process')
-var ChildProcess = cp.ChildProcess
-var assert = require('assert')
-var crypto = require('crypto')
-var mkdirp = require('mkdirp')
-var rimraf = require('rimraf')
-var path = require('path')
-var signalExit = require('signal-exit')
-var home = process.env.SPAWN_WRAP_SHIM_ROOT || require('os-homedir')()
-var homedir = home + '/.node-spawn-wrap-'
-var which = require('which')
-var util = require('util')
-
-var doDebug = process.env.SPAWN_WRAP_DEBUG === '1'
-var debug = doDebug ? function () {
-  var message = util.format.apply(util, arguments).trim()
-  var pref = 'SW ' + process.pid + ': '
-  message = pref + message.split('\n').join('\n' + pref)
-  process.stderr.write(message + '\n')
-} : function () {}
-
-var shebang = process.platform === 'os390' ?
-  '#!/bin/env ' : '#!'
-
-var shim = shebang + process.execPath + '\n' +
-  fs.readFileSync(__dirname + '/shim.js')
-
-var isWindows = require('./lib/is-windows')()
-
-var pathRe = /^PATH=/
-if (isWindows) pathRe = /^PATH=/i
-
-var colon = isWindows ? ';' : ':'
-
-function wrap (argv, env, workingDir) {
-  if (!ChildProcess) {
-    var child = cp.spawn(process.execPath, [])
-    ChildProcess = child.constructor
-    if (process.platform === 'os390')
-      child.kill('SIGABRT')
-    else
-      child.kill('SIGKILL')
-  }
-
-  // spawn_sync available since Node v0.11
-  var spawnSyncBinding, spawnSync
-  try {
-    spawnSyncBinding = process.binding('spawn_sync')
-  } catch (e) {}
-
-  // if we're passed in the working dir, then it means that setup
-  // was already done, so no need.
-  var doSetup = !workingDir
-  if (doSetup) {
-    workingDir = setup(argv, env)
-  }
-  var spawn = ChildProcess.prototype.spawn
-  if (spawnSyncBinding) {
-    spawnSync = spawnSyncBinding.spawn
-  }
-
-  function unwrap () {
-    if (doSetup && !doDebug) {
-      rimraf.sync(workingDir)
-    }
-    ChildProcess.prototype.spawn = spawn
-    if (spawnSyncBinding) {
-      spawnSyncBinding.spawn = spawnSync
-    }
-  }
-
-  if (spawnSyncBinding) {
-    spawnSyncBinding.spawn = wrappedSpawnFunction(spawnSync, workingDir)
-  }
-  ChildProcess.prototype.spawn = wrappedSpawnFunction(spawn, workingDir)
-
-  return unwrap
-}
-
-function wrappedSpawnFunction (fn, workingDir) {
-  return wrappedSpawn
-
-  function wrappedSpawn (options) {
-    munge(workingDir, options)
-    debug('WRAPPED', options)
-    return fn.call(this, options)
-  }
-}
-
-function isSh (file) {
-  return file === 'dash' ||
-         file === 'sh' ||
-         file === 'bash' ||
-         file === 'zsh'
-}
-
-function mungeSh (workingDir, options) {
-  var cmdi = options.args.indexOf('-c')
-  if (cmdi === -1)
-    return // no -c argument
-
-  var c = options.args[cmdi + 1]
-  var re = /^\s*((?:[^\= ]*\=[^\=\s]*)*[\s]*)([^\s]+|"[^"]+"|'[^']+')( .*)?$/
-  var match = c.match(re)
-  if (!match)
-    return // not a command invocation.  weird but possible
-
-  var command = match[2]
-  // strip quotes off the command
-  var quote = command.charAt(0)
-  if ((quote === '"' || quote === '\'') && quote === command.slice(-1)) {
-    command = command.slice(1, -1)
-  }
-  var exe = path.basename(command)
-
-  if (isNode(exe)) {
-    options.originalNode = command
-    c = match[1] + match[2] + ' "' + workingDir + '/node" ' + match[3]
-    options.args[cmdi + 1] = c
-  } else if (exe === 'npm' && !isWindows) {
-    // XXX this will exhibit weird behavior when using /path/to/npm,
-    // if some other npm is first in the path.
-    var npmPath = whichOrUndefined('npm')
-
-    if (npmPath) {
-      c = c.replace(re, '$1 "' + workingDir + '/node" "' + npmPath + '" $3')
-      options.args[cmdi + 1] = c
-      debug('npm munge!', c)
-    }
-  }
-}
-
-function isCmd (file) {
-  var comspec = path.basename(process.env.comspec || '').replace(/\.exe$/i, '')
-  return isWindows && (file === comspec || /^cmd(\.exe|\.EXE)?$/.test(file))
-}
-
-function mungeCmd (workingDir, options) {
-  var cmdi = options.args.indexOf('/c')
-  if (cmdi === -1)
-    return
-
-  var re = /^\s*("*)([^"]*?\b(?:node|iojs)(?:\.exe|\.EXE)?)("*)( .*)?$/
-  var npmre = /^\s*("*)([^"]*?\b(?:npm))("*)( |$)/
-  var path_ = require('path')
-  if (path_.win32)
-    path_ = path_.win32
-
-  var command = options.args[cmdi + 1]
-  if (!command)
-    return
-
-  var m = command.match(re)
-  var replace
-  if (m) {
-    options.originalNode = m[2]
-    replace = m[1] + workingDir + '/node.cmd' + m[3] + m[4]
-    options.args[cmdi + 1] = m[1] + m[2] + m[3] +
-      ' "' + workingDir + '\\node"' + m[4]
-  } else {
-    // XXX probably not a good idea to rewrite to the first npm in the
-    // path if it's a full path to npm.  And if it's not a full path to
-    // npm, then the dirname will not work properly!
-    m = command.match(npmre)
-    if (!m)
-      return
-
-    var npmPath = whichOrUndefined('npm') || 'npm'
-    npmPath = path_.dirname(npmPath) + '\\node_modules\\npm\\bin\\npm-cli.js'
-    replace = m[1] + workingDir + '/node.cmd' +
-              ' "' + npmPath + '"' +
-              m[3] + m[4]
-    options.args[cmdi + 1] = command.replace(npmre, replace)
-  }
-}
-
-function isNode (file) {
-  var cmdname = path.basename(process.execPath).replace(/\.exe$/i, '')
-  return file === 'node' || file === 'iojs' || cmdname === file
-}
-
-function mungeNode (workingDir, options) {
-  options.originalNode = options.file
-  var command = path.basename(options.file).replace(/\.exe$/i, '')
-  // make sure it has a main script.
-  // otherwise, just let it through.
-  var a = 0
-  var hasMain = false
-  var mainIndex = 1
-  for (var a = 1; !hasMain && a < options.args.length; a++) {
-    switch (options.args[a]) {
-      case '-p':
-      case '-i':
-      case '--interactive':
-      case '--eval':
-      case '-e':
-      case '-pe':
-        hasMain = false
-        a = options.args.length
-        continue
-
-      case '-r':
-      case '--require':
-        a += 1
-        continue
-
-      default:
-        if (options.args[a].match(/^-/)) {
-          continue
-        } else {
-          hasMain = true
-          mainIndex = a
-          a = options.args.length
-          break
-        }
-    }
-  }
-
-  if (hasMain) {
-    var replace = workingDir + '/' + command
-    options.args.splice(mainIndex, 0, replace)
-  }
-
-  // If the file is just something like 'node' then that'll
-  // resolve to our shim, and so to prevent double-shimming, we need
-  // to resolve that here first.
-  // This also handles the case where there's not a main file, like
-  // `node -e 'program'`, where we want to avoid the shim entirely.
-  if (options.file === options.basename) {
-    var realNode = whichOrUndefined(options.file) || process.execPath
-    options.file = options.args[0] = realNode
-  }
-
-  debug('mungeNode after', options.file, options.args)
-}
-
-function mungeShebang (workingDir, options) {
-  try {
-    var resolved = which.sync(options.file)
-  } catch (er) {
-    // nothing to do if we can't resolve
-    // Most likely: file doesn't exist or is not executable.
-    // Let exec pass through, probably will fail, oh well.
-    return
-  }
-
-  var shebang = fs.readFileSync(resolved, 'utf8')
-  var match = shebang.match(/^#!([^\r\n]+)/)
-  if (!match)
-    return // not a shebang script, probably a binary
-
-  var shebangbin = match[1].split(' ')[0]
-  var maybeNode = path.basename(shebangbin)
-  if (!isNode(maybeNode))
-    return // not a node shebang, leave untouched
-
-  options.originalNode = shebangbin
-  options.basename = maybeNode
-  options.file = shebangbin
-  options.args = [shebangbin, workingDir + '/' + maybeNode]
-    .concat(resolved)
-    .concat(match[1].split(' ').slice(1))
-    .concat(options.args.slice(1))
-}
-
-function mungeEnv (workingDir, options) {
-  var pathEnv
-  for (var i = 0; i < options.envPairs.length; i++) {
-    var ep = options.envPairs[i]
-    if (ep.match(pathRe)) {
-      pathEnv = ep.substr(5)
-      var k = ep.substr(0, 5)
-      options.envPairs[i] = k + workingDir + colon + pathEnv
-    }
-  }
-  if (!pathEnv) {
-    options.envPairs.push((isWindows ? 'Path=' : 'PATH=') + workingDir)
-  }
-  if (options.originalNode) {
-    var key = path.basename(workingDir).substr('.node-spawn-wrap-'.length)
-    options.envPairs.push('SW_ORIG_' + key + '=' + options.originalNode)
-  }
-
-  options.envPairs.push('SPAWN_WRAP_SHIM_ROOT=' + homedir)
-
-  if (process.env.SPAWN_WRAP_DEBUG === '1')
-    options.envPairs.push('SPAWN_WRAP_DEBUG=1')
-}
-
-function isnpm (file) {
-  // XXX is this even possible/necessary?
-  // wouldn't npm just be detected as a node shebang?
-  return file === 'npm' && !isWindows
-}
-
-function mungenpm (workingDir, options) {
-  debug('munge npm')
-  // XXX weird effects of replacing a specific npm with a global one
-  var npmPath = whichOrUndefined('npm')
-
-  if (npmPath) {
-    options.args[0] = npmPath
-
-    options.file = workingDir + '/node'
-    options.args.unshift(workingDir + '/node')
-  }
-}
-
-function munge (workingDir, options) {
-  options.basename = path.basename(options.file).replace(/\.exe$/i, '')
-
-  // XXX: dry this
-  if (isSh(options.basename)) {
-    mungeSh(workingDir, options)
-  } else if (isCmd(options.basename)) {
-    mungeCmd(workingDir, options)
-  } else if (isNode(options.basename)) {
-    mungeNode(workingDir, options)
-  } else if (isnpm(options.basename)) {
-    // XXX unnecessary?  on non-windows, npm is just another shebang
-    mungenpm(workingDir, options)
-  } else {
-    mungeShebang(workingDir, options)
-  }
-
-  // now the options are munged into shape.
-  // whether we changed something or not, we still update the PATH
-  // so that if a script somewhere calls `node foo`, it gets our
-  // wrapper instead.
-
-  mungeEnv(workingDir, options)
-}
-
-function whichOrUndefined (executable) {
-  var path
-  try {
-    path = which.sync(executable)
-  } catch (er) {}
-  return path
-}
-
-function setup (argv, env) {
-  if (argv && typeof argv === 'object' && !env && !Array.isArray(argv)) {
-    env = argv
-    argv = []
-  }
-
-  if (!argv && !env) {
-    throw new Error('at least one of "argv" and "env" required')
-  }
-
-  if (argv) {
-    assert(Array.isArray(argv), 'argv must be array')
-  } else {
-    argv = []
-  }
-
-  if (env) {
-    assert(typeof env === 'object', 'env must be an object')
-  } else {
-    env = {}
-  }
-
-  debug('setup argv=%j env=%j', argv, env)
-
-  // For stuff like --use_strict or --harmony, we need to inject
-  // the argument *before* the wrap-main.
-  var execArgv = []
-  for (var i = 0; i < argv.length; i++) {
-    if (argv[i].match(/^-/)) {
-      execArgv.push(argv[i])
-      if (argv[i] === '-r' || argv[i] === '--require') {
-        execArgv.push(argv[++i])
-      }
-    } else {
-      break
-    }
-  }
-  if (execArgv.length) {
-    if (execArgv.length === argv.length) {
-      argv.length = 0
-    } else {
-      argv = argv.slice(execArgv.length)
-    }
-  }
-
-  var key = process.pid + '-' + crypto.randomBytes(6).toString('hex')
-  var workingDir = homedir + key
-
-  var settings = JSON.stringify({
-    module: __filename,
-    deps: {
-      foregroundChild: require.resolve('foreground-child'),
-      signalExit: require.resolve('signal-exit'),
-    },
-    key: key,
-    workingDir: workingDir,
-    argv: argv,
-    execArgv: execArgv,
-    env: env,
-    root: process.pid
-  }, null, 2) + '\n'
-
-  signalExit(function () {
-    if (!doDebug)
-      rimraf.sync(workingDir)
-  })
-
-  mkdirp.sync(workingDir)
-  workingDir = fs.realpathSync(workingDir)
-  if (isWindows) {
-    var cmdShim =
-      '@echo off\r\n' +
-      'SETLOCAL\r\n' +
-      'SET PATHEXT=%PATHEXT:;.JS;=;%\r\n' +
-      '"' + process.execPath + '"' + ' "%~dp0\\.\\node" %*\r\n'
-
-    fs.writeFileSync(workingDir + '/node.cmd', cmdShim)
-    fs.chmodSync(workingDir + '/node.cmd', '0755')
-    fs.writeFileSync(workingDir + '/iojs.cmd', cmdShim)
-    fs.chmodSync(workingDir + '/iojs.cmd', '0755')
-  }
-  fs.writeFileSync(workingDir + '/node', shim)
-  fs.chmodSync(workingDir + '/node', '0755')
-  fs.writeFileSync(workingDir + '/iojs', shim)
-  fs.chmodSync(workingDir + '/iojs', '0755')
-  var cmdname = path.basename(process.execPath).replace(/\.exe$/i, '')
-  if (cmdname !== 'iojs' && cmdname !== 'node') {
-    fs.writeFileSync(workingDir + '/' + cmdname, shim)
-    fs.chmodSync(workingDir + '/' + cmdname, '0755')
-  }
-  fs.writeFileSync(workingDir + '/settings.json', settings)
-
-  return workingDir
-}
-
-function runMain () {
-  process.argv.splice(1, 1)
-  process.argv[1] = path.resolve(process.argv[1])
-  delete require.cache[process.argv[1]]
-  Module.runMain()
-}