.-.-.-.-.-

PKi^�\�*��package.jsonnu�[���{
  "_id": "cross-spawn@7.0.3",
  "_inBundle": true,
  "_location": "/npm/cross-spawn",
  "_phantomChildren": {
    "isexe": "2.0.0"
  },
  "_requiredBy": [
    "/npm/foreground-child"
  ],
  "author": {
    "name": "André Cruz",
    "email": "andre@moxy.studio"
  },
  "bugs": {
    "url": "https://github.com/moxystudio/node-cross-spawn/issues"
  },
  "commitlint": {
    "extends": [
      "@commitlint/config-conventional"
    ]
  },
  "dependencies": {
    "path-key": "^3.1.0",
    "shebang-command": "^2.0.0",
    "which": "^2.0.1"
  },
  "description": "Cross platform child_process#spawn and child_process#spawnSync",
  "devDependencies": {
    "@commitlint/cli": "^8.1.0",
    "@commitlint/config-conventional": "^8.1.0",
    "babel-core": "^6.26.3",
    "babel-jest": "^24.9.0",
    "babel-preset-moxy": "^3.1.0",
    "eslint": "^5.16.0",
    "eslint-config-moxy": "^7.1.0",
    "husky": "^3.0.5",
    "jest": "^24.9.0",
    "lint-staged": "^9.2.5",
    "mkdirp": "^0.5.1",
    "rimraf": "^3.0.0",
    "standard-version": "^7.0.0"
  },
  "engines": {
    "node": ">= 8"
  },
  "files": [
    "lib"
  ],
  "homepage": "https://github.com/moxystudio/node-cross-spawn",
  "husky": {
    "hooks": {
      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
      "pre-commit": "lint-staged"
    }
  },
  "keywords": [
    "spawn",
    "spawnSync",
    "windows",
    "cross-platform",
    "path-ext",
    "shebang",
    "cmd",
    "execute"
  ],
  "license": "MIT",
  "lint-staged": {
    "*.js": [
      "eslint --fix",
      "git add"
    ]
  },
  "main": "index.js",
  "name": "cross-spawn",
  "repository": {
    "type": "git",
    "url": "git+ssh://git@github.com/moxystudio/node-cross-spawn.git"
  },
  "scripts": {
    "lint": "eslint .",
    "postrelease": "git push --follow-tags origin HEAD && npm publish",
    "prerelease": "npm t && npm run lint",
    "release": "standard-version",
    "test": "jest --env node --coverage"
  },
  "version": "7.0.3"
}
PKi^�\������ node_modules/.bin/node-which.ps1nu�[���#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
  & "$basedir/node$exe"  "$basedir/../which/bin/node-which" $args
  $ret=$LASTEXITCODE
} else {
  & "node$exe"  "$basedir/../which/bin/node-which" $args
  $ret=$LASTEXITCODE
}
exit $ret
PKi^�\�h� node_modules/.bin/node-which.cmdnu�[���@ECHO off
SETLOCAL
CALL :find_dp0

IF EXIST "%dp0%\node.exe" (
  SET "_prog=%dp0%\node.exe"
) ELSE (
  SET "_prog=node"
  SET PATHEXT=%PATHEXT:;.JS;=;%
)

"%_prog%"  "%dp0%\..\which\bin\node-which" %*
ENDLOCAL
EXIT /b %errorlevel%
:find_dp0
SET dp0=%~dp0
EXIT /b
PKi^�\���FFnode_modules/.bin/node-whichnu�[���#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")

case `uname` in
    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
esac

if [ -x "$basedir/node" ]; then
  "$basedir/node"  "$basedir/../which/bin/node-which" "$@"
  ret=$?
else 
  node  "$basedir/../which/bin/node-which" "$@"
  ret=$?
fi
exit $ret
PKi^�\��[ccnode_modules/which/package.jsonnu�[���{
  "_id": "which@2.0.2",
  "_inBundle": true,
  "_location": "/npm/cross-spawn/which",
  "_phantomChildren": {},
  "_requiredBy": [
    "/npm/cross-spawn"
  ],
  "author": {
    "name": "Isaac Z. Schlueter",
    "email": "i@izs.me",
    "url": "http://blog.izs.me"
  },
  "bin": {
    "node-which": "bin/node-which"
  },
  "bugs": {
    "url": "https://github.com/isaacs/node-which/issues"
  },
  "dependencies": {
    "isexe": "^2.0.0"
  },
  "description": "Like which(1) unix command. Find the first instance of an executable in the PATH.",
  "devDependencies": {
    "mkdirp": "^0.5.0",
    "rimraf": "^2.6.2",
    "tap": "^14.6.9"
  },
  "engines": {
    "node": ">= 8"
  },
  "files": [
    "which.js",
    "bin/node-which"
  ],
  "homepage": "https://github.com/isaacs/node-which#readme",
  "license": "ISC",
  "main": "which.js",
  "name": "which",
  "repository": {
    "type": "git",
    "url": "git://github.com/isaacs/node-which.git"
  },
  "scripts": {
    "changelog": "git add CHANGELOG.md",
    "postchangelog": "git commit -m 'update changelog - '${npm_package_version}",
    "postpublish": "git push origin --follow-tags",
    "postversion": "npm publish",
    "prechangelog": "bash gen-changelog.sh",
    "prepublish": "npm run changelog",
    "preversion": "npm test",
    "test": "tap"
  },
  "tap": {
    "check-coverage": true
  },
  "version": "2.0.2"
}
PKi^�\�aGW��node_modules/which/LICENSEnu�[���The ISC License

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.
PKi^�\Fڧ��!node_modules/which/bin/node-whichnu�[���#!/usr/bin/env node
var which = require("../")
if (process.argv.length < 3)
  usage()

function usage () {
  console.error('usage: which [-as] program ...')
  process.exit(1)
}

var all = false
var silent = false
var dashdash = false
var args = process.argv.slice(2).filter(function (arg) {
  if (dashdash || !/^-/.test(arg))
    return true

if (arg === '--') {
    dashdash = true
    return false
  }

var flags = arg.substr(1).split('')
  for (var f = 0; f < flags.length; f++) {
    var flag = flags[f]
    switch (flag) {
      case 's':
        silent = true
        break
      case 'a':
        all = true
        break
      default:
        console.error('which: illegal option -- ' + flag)
        usage()
    }
  }
  return false
})

process.exit(args.reduce(function (pv, current) {
  try {
    var f = which.sync(current, { all: all })
    if (all)
      f = f.join('\n')
    if (!silent)
      console.log(f)
    return pv;
  } catch (e) {
    return 1;
  }
}, 0))
PKi^�\��r-[[node_modules/which/which.jsnu�[���const isWindows = process.platform === 'win32' ||
    process.env.OSTYPE === 'cygwin' ||
    process.env.OSTYPE === 'msys'

const path = require('path')
const COLON = isWindows ? ';' : ':'
const isexe = require('isexe')

const getNotFoundError = (cmd) =>
  Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' })

const getPathInfo = (cmd, opt) => {
  const colon = opt.colon || COLON

// If it has a slash, then we don't bother searching the pathenv.
  // just check the file itself, and that's it.
  const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
    : (
      [
        // windows always checks the cwd first
        ...(isWindows ? [process.cwd()] : []),
        ...(opt.path || process.env.PATH ||
          /* istanbul ignore next: very unusual */ '').split(colon),
      ]
    )
  const pathExtExe = isWindows
    ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
    : ''
  const pathExt = isWindows ? pathExtExe.split(colon) : ['']

if (isWindows) {
    if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
      pathExt.unshift('')
  }

return {
    pathEnv,
    pathExt,
    pathExtExe,
  }
}

const which = (cmd, opt, cb) => {
  if (typeof opt === 'function') {
    cb = opt
    opt = {}
  }
  if (!opt)
    opt = {}

const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt)
  const found = []

const step = i => new Promise((resolve, reject) => {
    if (i === pathEnv.length)
      return opt.all && found.length ? resolve(found)
        : reject(getNotFoundError(cmd))

const ppRaw = pathEnv[i]
    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw

const pCmd = path.join(pathPart, cmd)
    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
      : pCmd

resolve(subStep(p, i, 0))
  })

const subStep = (p, i, ii) => new Promise((resolve, reject) => {
    if (ii === pathExt.length)
      return resolve(step(i + 1))
    const ext = pathExt[ii]
    isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
      if (!er && is) {
        if (opt.all)
          found.push(p + ext)
        else
          return resolve(p + ext)
      }
      return resolve(subStep(p, i, ii + 1))
    })
  })

return cb ? step(0).then(res => cb(null, res), cb) : step(0)
}

const whichSync = (cmd, opt) => {
  opt = opt || {}

const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt)
  const found = []

for (let i = 0; i < pathEnv.length; i ++) {
    const ppRaw = pathEnv[i]
    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw

const pCmd = path.join(pathPart, cmd)
    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
      : pCmd

for (let j = 0; j < pathExt.length; j ++) {
      const cur = p + pathExt[j]
      try {
        const is = isexe.sync(cur, { pathExt: pathExtExe })
        if (is) {
          if (opt.all)
            found.push(cur)
          else
            return cur
        }
      } catch (ex) {}
    }
  }

if (opt.all && found.length)
    return found

if (opt.nothrow)
    return null

throw getNotFoundError(cmd)
}

module.exports = which
which.sync = whichSync
PKi^�\撱UHHnode_modules/which/README.mdnu�[���# which

Like the unix `which` utility.

Finds the first instance of a specified executable in the PATH
environment variable.  Does not cache the results, so `hash -r` is not
needed when the PATH changes.

## USAGE

```javascript
var which = require('which')

// async usage
which('node', function (er, resolvedPath) {
  // er is returned if no "node" is found on the PATH
  // if it is found, then the absolute path to the exec is returned
})

// or promise
which('node').then(resolvedPath => { ... }).catch(er => { ... not found ... })

// sync usage
// throws if not found
var resolved = which.sync('node')

// if nothrow option is used, returns null if not found
resolved = which.sync('node', {nothrow: true})

// Pass options to override the PATH and PATHEXT environment vars.
which('node', { path: someOtherPath }, function (er, resolved) {
  if (er)
    throw er
  console.log('found at %j', resolved)
})
```

## CLI USAGE

Same as the BSD `which(1)` binary.

```
usage: which [-as] program ...
```

## OPTIONS

You may pass an options object as the second argument.

- `path`: Use instead of the `PATH` environment variable.
- `pathExt`: Use instead of the `PATHEXT` environment variable.
- `all`: Return all matches, instead of just the first one.  Note that
  this means the function returns an array of strings instead of a
  single string.
PKi^�\�;��lib/parse.jsnu�[���'use strict';

const path = require('path');
const resolveCommand = require('./util/resolveCommand');
const escape = require('./util/escape');
const readShebang = require('./util/readShebang');

const isWin = process.platform === 'win32';
const isExecutableRegExp = /\.(?:com|exe)$/i;
const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;

function detectShebang(parsed) {
    parsed.file = resolveCommand(parsed);

const shebang = parsed.file && readShebang(parsed.file);

if (shebang) {
        parsed.args.unshift(parsed.file);
        parsed.command = shebang;

return resolveCommand(parsed);
    }

return parsed.file;
}

function parseNonShell(parsed) {
    if (!isWin) {
        return parsed;
    }

// Detect & add support for shebangs
    const commandFile = detectShebang(parsed);

// We don't need a shell if the command filename is an executable
    const needsShell = !isExecutableRegExp.test(commandFile);

// If a shell is required, use cmd.exe and take care of escaping everything correctly
    // Note that `forceShell` is an hidden option used only in tests
    if (parsed.options.forceShell || needsShell) {
        // Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`
        // The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument
        // Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,
        // we need to double escape them
        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);

// Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
        // This is necessary otherwise it will always fail with ENOENT in those cases
        parsed.command = path.normalize(parsed.command);

// Escape command & arguments
        parsed.command = escape.command(parsed.command);
        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));

const shellCommand = [parsed.command].concat(parsed.args).join(' ');

parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
        parsed.command = process.env.comspec || 'cmd.exe';
        parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
    }

return parsed;
}

function parse(command, args, options) {
    // Normalize arguments, similar to nodejs
    if (args && !Array.isArray(args)) {
        options = args;
        args = null;
    }

args = args ? args.slice(0) : []; // Clone array to avoid changing the original
    options = Object.assign({}, options); // Clone object to avoid changing the original

// Build our parsed object
    const parsed = {
        command,
        args,
        options,
        file: undefined,
        original: {
            command,
            args,
        },
    };

// Delegate further parsing to shell or non-shell
    return options.shell ? parsed : parseNonShell(parsed);
}

module.exports = parse;
PKi^�\ͨ����
lib/enoent.jsnu�[���'use strict';

const isWin = process.platform === 'win32';

function notFoundError(original, syscall) {
    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
        code: 'ENOENT',
        errno: 'ENOENT',
        syscall: `${syscall} ${original.command}`,
        path: original.command,
        spawnargs: original.args,
    });
}

function hookChildProcess(cp, parsed) {
    if (!isWin) {
        return;
    }

const originalEmit = cp.emit;

cp.emit = function (name, arg1) {
        // If emitting "exit" event and exit code is 1, we need to check if
        // the command exists and emit an "error" instead
        // See https://github.com/IndigoUnited/node-cross-spawn/issues/16
        if (name === 'exit') {
            const err = verifyENOENT(arg1, parsed, 'spawn');

if (err) {
                return originalEmit.call(cp, 'error', err);
            }
        }

return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params
    };
}

function verifyENOENT(status, parsed) {
    if (isWin && status === 1 && !parsed.file) {
        return notFoundError(parsed.original, 'spawn');
    }

return null;
}

function verifyENOENTSync(status, parsed) {
    if (isWin && status === 1 && !parsed.file) {
        return notFoundError(parsed.original, 'spawnSync');
    }

return null;
}

module.exports = {
    hookChildProcess,
    verifyENOENT,
    verifyENOENTSync,
    notFoundError,
};
PKi^�\��+��lib/util/escape.jsnu�[���'use strict';

// See http://www.robvanderwoude.com/escapechars.php
const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;

function escapeCommand(arg) {
    // Escape meta chars
    arg = arg.replace(metaCharsRegExp, '^$1');

return arg;
}

function escapeArgument(arg, doubleEscapeMetaChars) {
    // Convert to string
    arg = `${arg}`;

// Algorithm below is based on https://qntm.org/cmd

// Sequence of backslashes followed by a double quote:
    // double up all the backslashes and escape the double quote
    arg = arg.replace(/(\\*)"/g, '$1$1\\"');

// Sequence of backslashes followed by the end of the string
    // (which will become a double quote later):
    // double up all the backslashes
    arg = arg.replace(/(\\*)$/, '$1$1');

// All other backslashes occur literally

// Quote the whole thing:
    arg = `"${arg}"`;

// Escape meta chars
    arg = arg.replace(metaCharsRegExp, '^$1');

// Double escape meta chars if necessary
    if (doubleEscapeMetaChars) {
        arg = arg.replace(metaCharsRegExp, '^$1');
    }

return arg;
}

module.exports.command = escapeCommand;
module.exports.argument = escapeArgument;
PKi^�\�(9�lib/util/resolveCommand.jsnu�[���'use strict';

const path = require('path');
const which = require('which');
const getPathKey = require('path-key');

function resolveCommandAttempt(parsed, withoutPathExt) {
    const env = parsed.options.env || process.env;
    const cwd = process.cwd();
    const hasCustomCwd = parsed.options.cwd != null;
    // Worker threads do not have process.chdir()
    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;

// If a custom `cwd` was specified, we need to change the process cwd
    // because `which` will do stat calls but does not support a custom cwd
    if (shouldSwitchCwd) {
        try {
            process.chdir(parsed.options.cwd);
        } catch (err) {
            /* Empty */
        }
    }

let resolved;

try {
        resolved = which.sync(parsed.command, {
            path: env[getPathKey({ env })],
            pathExt: withoutPathExt ? path.delimiter : undefined,
        });
    } catch (e) {
        /* Empty */
    } finally {
        if (shouldSwitchCwd) {
            process.chdir(cwd);
        }
    }

// If we successfully resolved, ensure that an absolute path is returned
    // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
    if (resolved) {
        resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
    }

return resolved;
}

function resolveCommand(parsed) {
    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
}

module.exports = resolveCommand;
PKi^�\�>��%%lib/util/readShebang.jsnu�[���'use strict';

const fs = require('fs');
const shebangCommand = require('shebang-command');

function readShebang(command) {
    // Read the first 150 bytes from the file
    const size = 150;
    const buffer = Buffer.alloc(size);

let fd;

try {
        fd = fs.openSync(command, 'r');
        fs.readSync(fd, buffer, 0, size, 0);
        fs.closeSync(fd);
    } catch (e) { /* Empty */ }

// Attempt to extract shebang (null is returned if not a shebang)
    return shebangCommand(buffer.toString());
}

module.exports = readShebang;
PKi^�\��}QQLICENSEnu�[���The MIT License (MIT)

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.
PKi^�\&�<��index.jsnu�[���'use strict';

const cp = require('child_process');
const parse = require('./lib/parse');
const enoent = require('./lib/enoent');

function spawn(command, args, options) {
    // Parse the arguments
    const parsed = parse(command, args, options);

// Spawn the child process
    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);

// Hook into child process "exit" event to emit an error if the command
    // does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
    enoent.hookChildProcess(spawned, parsed);

return spawned;
}

function spawnSync(command, args, options) {
    // Parse the arguments
    const parsed = parse(command, args, options);

// Spawn the child process
    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);

// Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);

return result;
}

module.exports = spawn;
module.exports.spawn = spawn;
module.exports.sync = spawnSync;

module.exports._parse = parse;
module.exports._enoent = enoent;
PKi^�\�*��package.jsonnu�[���PKi^�\������ �node_modules/.bin/node-which.ps1nu�[���PKi^�\�h� -
node_modules/.bin/node-which.cmdnu�[���PKi^�\���FF�node_modules/.bin/node-whichnu�[���PKi^�\��[cc'
node_modules/which/package.jsonnu�[���PKi^�\�aGW���node_modules/which/LICENSEnu�[���PKi^�\Fڧ��! node_modules/which/bin/node-whichnu�[���PKi^�\��r-[[Jnode_modules/which/which.jsnu�[���PKi^�\撱UHH�&node_modules/which/README.mdnu�[���PKi^�\�;���,lib/parse.jsnu�[���PKi^�\ͨ����
�8lib/enoent.jsnu�[���PKi^�\��+���>lib/util/escape.jsnu�[���PKi^�\�(9��Clib/util/resolveCommand.jsnu�[���PKi^�\�>��%%�Ilib/util/readShebang.jsnu�[���PKi^�\��}QQ_LLICENSEnu�[���PKi^�\&�<���Pindex.jsnu�[���PKd�U

/home/emeraadmin/www/CBNA/../node_modules/array-slice/../d3-timer/../../4d695/cross-spawn.zip