node-red-contrib-tak-registration 0.7.1 → 0.7.2

package/node_modules/spawn-wrap/CHANGELOG.md

@@ -1,43 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
-
-## [2.0.0](https://github.com/istanbuljs/spawn-wrap/compare/v1.4.3...v2.0.0) (2019-12-20)
-
-
-### ⚠ BREAKING CHANGES
-
-* no longer feature detect spawnSync, present since Node 0.11.
-* Drop support for iojs (#84)
-* explicitly drops support for Node 6
-
-### Bug Fixes
-
-* Avoid path concatenation ([5626f2a](https://github.com/istanbuljs/spawn-wrap/commit/5626f2a))
-* Handle whitespace in homedir paths ([#98](https://github.com/istanbuljs/spawn-wrap/issues/98)) ([f002ecc](https://github.com/istanbuljs/spawn-wrap/commit/f002ecc)), closes [istanbuljs/nyc#784](https://github.com/istanbuljs/nyc/issues/784)
-* Make munge functions pure ([#99](https://github.com/istanbuljs/spawn-wrap/issues/99)) ([5c1293e](https://github.com/istanbuljs/spawn-wrap/commit/5c1293e))
-* Remove '/.node-spawn-wrap-' from lib/homedir.js export ([5bcb288](https://github.com/istanbuljs/spawn-wrap/commit/5bcb288))
-* Remove legacy `ChildProcess` resolution ([#85](https://github.com/istanbuljs/spawn-wrap/issues/85)) ([da05012](https://github.com/istanbuljs/spawn-wrap/commit/da05012))
-* Remove legacy `spawnSync` feature detection ([#87](https://github.com/istanbuljs/spawn-wrap/issues/87)) ([78777aa](https://github.com/istanbuljs/spawn-wrap/commit/78777aa))
-* Switch from mkdirp to make-dir ([#94](https://github.com/istanbuljs/spawn-wrap/issues/94)) ([b8dace1](https://github.com/istanbuljs/spawn-wrap/commit/b8dace1))
-* Use `is-windows` package for detection ([#88](https://github.com/istanbuljs/spawn-wrap/issues/88)) ([c3e6239](https://github.com/istanbuljs/spawn-wrap/commit/c3e6239)), closes [istanbuljs/spawn-wrap#61](https://github.com/istanbuljs/spawn-wrap/issues/61)
-* Use safe path functions in `setup` ([#86](https://github.com/istanbuljs/spawn-wrap/issues/86)) ([4103f72](https://github.com/istanbuljs/spawn-wrap/commit/4103f72))
-
-### Features
-
-* Drop support for iojs ([#84](https://github.com/istanbuljs/spawn-wrap/issues/84)) ([6e86337](https://github.com/istanbuljs/spawn-wrap/commit/6e86337))
-* require Node 8 ([#80](https://github.com/istanbuljs/spawn-wrap/issues/80)) ([19543e7](https://github.com/istanbuljs/spawn-wrap/commit/19543e7))
-
-
-## [2.0.0-beta.0](https://github.com/istanbuljs/spawn-wrap/compare/v1.4.3...v2.0.0-beta.0) (2019-10-07)
-
-
-See 2.0.0 for notes.
-
-
-### [1.4.3](https://github.com/isaacs/spawn-wrap/compare/v1.4.2...v1.4.3) (2019-08-23)
-
-
-### Bug Fixes
-
-* **win32:** handle cases where "node" is quoted ([#102](https://github.com/isaacs/spawn-wrap/issues/102)) ([aac8730](https://github.com/isaacs/spawn-wrap/commit/aac8730))

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/istanbuljs/spawn-wrap.svg)](https://travis-ci.org/istanbuljs/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,165 +0,0 @@
-'use strict';
-
-module.exports = wrap
-wrap.runMain = runMain
-
-const Module = require('module')
-const fs = require('fs')
-const cp = require('child_process')
-const ChildProcess = cp.ChildProcess
-const assert = require('assert')
-const crypto = require('crypto')
-const IS_WINDOWS = require('is-windows')()
-const makeDir = require('make-dir')
-const rimraf = require('rimraf')
-const path = require('path')
-const signalExit = require('signal-exit')
-const {IS_DEBUG, debug} = require("./lib/debug")
-const munge = require("./lib/munge")
-const homedir = require("./lib/homedir")
-
-const shebang = process.platform === 'os390' ?
-  '#!/bin/env ' : '#!'
-
-const shim = shebang + process.execPath + '\n' +
-  fs.readFileSync(path.join(__dirname, 'shim.js'))
-
-function wrap(argv, env, workingDir) {
-  const spawnSyncBinding = process.binding('spawn_sync')
-
-  // if we're passed in the working dir, then it means that setup
-  // was already done, so no need.
-  const doSetup = !workingDir
-  if (doSetup) {
-    workingDir = setup(argv, env)
-  }
-  const spawn = ChildProcess.prototype.spawn
-  const spawnSync = spawnSyncBinding.spawn
-
-  function unwrap() {
-    if (doSetup && !IS_DEBUG) {
-      rimraf.sync(workingDir)
-    }
-    ChildProcess.prototype.spawn = spawn
-    spawnSyncBinding.spawn = spawnSync
-  }
-
-  spawnSyncBinding.spawn = wrappedSpawnFunction(spawnSync, workingDir)
-  ChildProcess.prototype.spawn = wrappedSpawnFunction(spawn, workingDir)
-
-  return unwrap
-}
-
-function wrappedSpawnFunction (fn, workingDir) {
-  return wrappedSpawn
-
-  function wrappedSpawn (options) {
-    const mungedOptions = munge(workingDir, options)
-    debug('WRAPPED', mungedOptions)
-    return fn.call(this, mungedOptions)
-  }
-}
-
-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 an 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.
-  const execArgv = []
-  for (let i = 0; i < argv.length; i++) {
-    if (argv[i].startsWith('-')) {
-      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)
-    }
-  }
-
-  const key = process.pid + '-' + crypto.randomBytes(6).toString('hex')
-  let workingDir = path.resolve(homedir, `.node-spawn-wrap-${key}`)
-
-  const settings = JSON.stringify({
-    module: __filename,
-    deps: {
-      foregroundChild: require.resolve('foreground-child'),
-      signalExit: require.resolve('signal-exit'),
-      debug: require.resolve('./lib/debug')
-    },
-    isWindows: IS_WINDOWS,
-    key,
-    workingDir,
-    argv,
-    execArgv,
-    env,
-    root: process.pid
-  }, null, 2) + '\n'
-
-  if (!IS_DEBUG) {
-    signalExit(() => rimraf.sync(workingDir))
-  }
-
-  makeDir.sync(workingDir)
-  workingDir = fs.realpathSync(workingDir)
-  if (IS_WINDOWS) {
-    const cmdShim =
-      '@echo off\r\n' +
-      'SETLOCAL\r\n' +
-      'CALL :find_dp0\r\n' +
-      'SET PATHEXT=%PATHEXT:;.JS;=;%\r\n' +
-      '"' + process.execPath + '" "%dp0%node" %*\r\n' +
-      'EXIT /b %errorlevel%\r\n'+
-      ':find_dp0\r\n' +
-      'SET dp0=%~dp0\r\n' +
-      'EXIT /b\r\n'
-
-    fs.writeFileSync(path.join(workingDir, 'node.cmd'), cmdShim)
-    fs.chmodSync(path.join(workingDir, 'node.cmd'), '0755')
-  }
-  fs.writeFileSync(path.join(workingDir, 'node'), shim)
-  fs.chmodSync(path.join(workingDir, 'node'), '0755')
-  const cmdname = path.basename(process.execPath).replace(/\.exe$/i, '')
-  if (cmdname !== 'node') {
-    fs.writeFileSync(path.join(workingDir, cmdname), shim)
-    fs.chmodSync(path.join(workingDir, cmdname), '0755')
-  }
-  fs.writeFileSync(path.join(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()
-}

package/node_modules/spawn-wrap/lib/debug.js

@@ -1,32 +0,0 @@
-'use strict';
-
-const util = require('util');
-const fs = require('fs')
-
-/**
- * Boolean indicating if debug mode is enabled.
- *
- * @type {boolean}
- */
-const IS_DEBUG = process.env.SPAWN_WRAP_DEBUG === '1'
-
-/**
- * If debug is enabled, write message to stderr.
- *
- * If debug is disabled, no message is written.
- */
-function debug(...args) {
-  if (!IS_DEBUG) {
-    return;
-  }
-
-  const prefix = `SW ${process.pid}: `
-  const data = util.format(...args).trim()
-  const message = data.split('\n').map(line => `${prefix}${line}\n`).join('')
-  fs.writeSync(2, message)
-}
-
-module.exports = {
-  IS_DEBUG,
-  debug,
-}

package/node_modules/spawn-wrap/lib/exe-type.js

@@ -1,53 +0,0 @@
-'use strict';
-
-const isWindows = require("is-windows")
-const path = require("path")
-
-function isCmd(file) {
-  const comspec = path.basename(process.env.comspec || '').replace(/\.exe$/i, '')
-  return isWindows() && (file === comspec || /^cmd(?:\.exe)?$/i.test(file))
-}
-
-function isNode(file) {
-  const cmdname = path.basename(process.execPath).replace(/\.exe$/i, '')
-  return file === 'node' || cmdname === file
-}
-
-function isNpm(file) {
-  // XXX is this even possible/necessary?
-  // wouldn't npm just be detected as a node shebang?
-  return file === 'npm' && !isWindows()
-}
-
-function isSh(file) {
-  return ['dash', 'sh', 'bash', 'zsh'].includes(file)
-}
-
-/**
- * Returns the basename of the executable.
- *
- * On Windows, strips the `.exe` extension (if any) and normalizes the name to
- * lowercase.
- *
- * @param exePath {string} Path of the executable as passed to spawned processes:
- *   either command or a path to a file.
- * @return {string} Basename of the executable.
- */
-function getExeBasename(exePath) {
-  const baseName = path.basename(exePath);
-  if (isWindows()) {
-    // Stripping `.exe` seems to be enough for our usage. We may eventually
-    // want to handle all executable extensions (such as `.bat` or `.cmd`).
-    return baseName.replace(/\.exe$/i, "").toLowerCase();
-  } else {
-    return baseName;
-  }
-}
-
-module.exports = {
-  isCmd,
-  isNode,
-  isNpm,
-  isSh,
-  getExeBasename,
-}

package/node_modules/spawn-wrap/lib/homedir.js

@@ -1,5 +0,0 @@
-'use strict'
-
-const os = require('os')
-
-module.exports = process.env.SPAWN_WRAP_SHIM_ROOT || os.homedir()

package/node_modules/spawn-wrap/lib/munge.js

@@ -1,84 +0,0 @@
-'use strict';
-
-const {isCmd, isNode, isNpm, isSh, getExeBasename} = require("./exe-type")
-const mungeCmd = require("./mungers/cmd")
-const mungeEnv = require("./mungers/env")
-const mungeNode = require("./mungers/node")
-const mungeNpm = require("./mungers/npm")
-const mungeSh = require("./mungers/sh")
-const mungeShebang = require("./mungers/shebang")
-
-/**
- * @typedef {object} InternalSpawnOptions Options for the internal spawn functions
- *   `childProcess.ChildProcess.prototype.spawn` and `process.binding('spawn_sync').spawn`.
- *   These are the options mapped by the `munge` function to intercept spawned processes and
- *   handle the wrapping logic.
- *
- * @property {string} file File to execute: either an absolute system-dependent path or a
- *   command name.
- * @property {string[]} args Command line arguments passed to the spawn process, including argv0.
- * @property {string | undefined} cwd Optional path to the current working directory passed to the
- *   spawned process. Default: `process.cwd()`
- * @property {boolean} windowsHide Boolean controlling if the process should be spawned as
- *   hidden (no GUI) on Windows.
- * @property {boolean} windowsVerbatimArguments Boolean controlling if Node should preprocess
- *   the CLI arguments on Windows.
- * @property {boolean} detached Boolean controlling if the child process should keep its parent
- *   alive or not.
- * @property {string[]} envPairs Array of serialized environment variable key/value pairs. The
- *   variables serialized as `key + "=" + value`.
- * @property {import("child_process").StdioOptions} stdio Stdio options, with the same semantics
- *   as the `stdio` parameter from the public API.
- * @property {number | undefined} uid User id for the spawn process, same as the `uid` parameter
- *   from the public API.
- * @property {number | undefined} gid Group id for the spawn process, same as the `gid` parameter
- *   from the public API.
- *
- * @property {string | undefined} originalNode Custom property only used by `spawn-wrap`. It is
- *   used to remember the original Node executable that was intended to be spawned by the user.
- */
-
-/**
- * Returns updated internal spawn options to redirect the process through the shim and wrapper.
- *
- * This works on the options passed to `childProcess.ChildProcess.prototype.spawn` and
- * `process.binding('spawn_sync').spawn`.
- *
- * This function works by trying to identify the spawn process and map the options accordingly.
- * `spawn-wrap` recognizes most shells, Windows `cmd.exe`, Node and npm invocations; when spawn
- * either directly or through a script with a shebang line.
- * It also unconditionally updates the environment variables so bare `node` commands execute
- * the shim script instead of Node's binary.
- *
- * @param workingDir {string} Absolute system-dependent path to the directory containing the shim files.
- * @param options {InternalSpawnOptions} Original internal spawn options.
- * @return {InternalSpawnOptions} Updated internal spawn options.
- */
-function munge(workingDir, options) {
-  const basename = getExeBasename(options.file);
-
-  // XXX: dry this
-  if (isSh(basename)) {
-    options = mungeSh(workingDir, options)
-  } else if (isCmd(basename)) {
-    options = mungeCmd(workingDir, options)
-  } else if (isNode(basename)) {
-    options = mungeNode(workingDir, options)
-  } else if (isNpm(basename)) {
-    // XXX unnecessary?  on non-windows, npm is just another shebang
-    options = mungeNpm(workingDir, options)
-  } else {
-    options = 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.
-
-  options = mungeEnv(workingDir, options)
-
-  return options
-}
-
-module.exports = munge

package/node_modules/spawn-wrap/lib/mungers/cmd.js

@@ -1,59 +0,0 @@
-'use strict';
-
-const path = require("path")
-const whichOrUndefined = require("../which-or-undefined")
-
-/**
- * Intercepts Node and npm processes spawned through Windows' `cmd.exe`.
- *
- * @param workingDir {string} Absolute system-dependent path to the directory containing the shim files.
- * @param options {import("../munge").InternalSpawnOptions} Original internal spawn options.
- * @return {import("../munge").InternalSpawnOptions} Updated internal spawn options.
- */
-function mungeCmd(workingDir, options) {
-  const cmdi = options.args.indexOf('/c')
-  if (cmdi === -1) {
-    return {...options}
-  }
-
-  const re = /^\s*("*)([^"]*?\bnode(?:\.exe|\.EXE)?)("*)( .*)?$/
-  const npmre = /^\s*("*)([^"]*?\b(?:npm))("*)( |$)/
-
-  const command = options.args[cmdi + 1]
-  if (command === undefined) {
-    return {...options}
-  }
-
-  let newArgs = [...options.args];
-  // Remember the original Node command to use it in the shim
-  let originalNode;
-
-  let m = command.match(re)
-  let replace
-  if (m) {
-    originalNode = m[2]
-    // TODO: Remove `replace`: seems unused
-    replace = m[1] + path.join(workingDir, 'node.cmd') + m[3] + m[4]
-    newArgs[cmdi + 1] = m[1] + m[2] + m[3] +
-      ' "' + path.join(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 === null) {
-      return {...options}
-    }
-
-    let npmPath = whichOrUndefined('npm') || 'npm'
-    npmPath = path.join(path.dirname(npmPath), 'node_modules', 'npm', 'bin', 'npm-cli.js')
-    replace = m[1] + '"' + path.join(workingDir, 'node.cmd') + '"' +
-      ' "' + npmPath + '"' +
-      m[3] + m[4]
-    newArgs[cmdi + 1] = command.replace(npmre, replace)
-  }
-
-  return {...options, args: newArgs, originalNode};
-}
-
-module.exports = mungeCmd

package/node_modules/spawn-wrap/lib/mungers/env.js

@@ -1,49 +0,0 @@
-'use strict';
-
-const isWindows = require("is-windows")
-const path = require("path")
-const homedir = require("../homedir")
-
-const pathRe = isWindows() ? /^PATH=/i : /^PATH=/;
-
-/**
- * Updates the environment variables to intercept `node` commands and pass down options.
- *
- * @param workingDir {string} Absolute system-dependent path to the directory containing the shim files.
- * @param options {import("../munge").InternalSpawnOptions} Original internal spawn options.
- * @return {import("../munge").InternalSpawnOptions} Updated internal spawn options.
- */
-function mungeEnv(workingDir, options) {
-  let pathEnv
-
-  const envPairs = options.envPairs.map((ep) => {
-    if (pathRe.test(ep)) {
-      // `PATH` env var: prefix its value with `workingDir`
-      // `5` corresponds to the length of `PATH=`
-      pathEnv = ep.substr(5)
-      const k = ep.substr(0, 5)
-      return k + workingDir + path.delimiter + pathEnv
-    } else {
-      // Return as-is
-      return ep;
-    }
-  });
-
-  if (pathEnv === undefined) {
-    envPairs.push((isWindows() ? 'Path=' : 'PATH=') + workingDir)
-  }
-  if (options.originalNode) {
-    const key = path.basename(workingDir).substr('.node-spawn-wrap-'.length)
-    envPairs.push('SW_ORIG_' + key + '=' + options.originalNode)
-  }
-
-  envPairs.push('SPAWN_WRAP_SHIM_ROOT=' + homedir)
-
-  if (process.env.SPAWN_WRAP_DEBUG === '1') {
-    envPairs.push('SPAWN_WRAP_DEBUG=1')
-  }
-
-  return {...options, envPairs};
-}
-
-module.exports = mungeEnv