| Server IP : 170.10.162.208 / Your IP : 216.73.216.181 Web Server : LiteSpeed System : Linux altar19.supremepanel19.com 4.18.0-553.69.1.lve.el8.x86_64 #1 SMP Wed Aug 13 19:53:59 UTC 2025 x86_64 User : deltahospital ( 1806) PHP Version : 7.4.33 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : OFF | Pkexec : OFF Directory : /home/deltahospital/.cagefs/tmp/ |
Upload File : |
/* IMPORTANT
* This snapshot file is auto-generated, but designed for humans.
* It should be checked into source control and tracked carefully.
* Re-generate by setting TAP_SNAPSHOT=1 and running tests.
* Make sure to inspect the output below. Do not ignore changes!
*/
'use strict'
exports[`test/tap/fund.js TAP fund containing multi-level nested deps with no funding > should omit dependencies with no funding declared 1`] = `
nested-no-funding-packages@1.0.0
+-- https://example.com/lorem
| \`-- lorem@1.0.0
+-- http://example.com/donate
| \`-- bar@1.0.0
\`-- https://example.com/sponsor
\`-- sub-bar@1.0.0
`
exports[`test/tap/fund.js TAP fund does not support global > should throw EFUNDGLOBAL error 1`] = `
`
exports[`test/tap/fund.js TAP fund does not support global > should write error msgs to stderr 1`] = `
npm ERR! code EFUNDGLOBAL
npm ERR! \`npm fund\` does not support global packages
`
exports[`test/tap/fund.js TAP fund does not support global, using --json option > should write error msgs to stderr 1`] = `
npm ERR! code EFUNDGLOBAL
npm ERR! \`npm fund\` does not support global packages
`
exports[`test/tap/fund.js TAP fund in which same maintainer owns all its deps > should print stack packages together 1`] = `
maintainer-owns-all-deps@1.0.0
\`-- http://example.com/donate
\`-- dep-bar@1.0.0, dep-foo@1.0.0, dep-sub-foo@1.0.0
`
exports[`test/tap/fund.js TAP fund using nested packages with multiple sources > should prompt with all available URLs 1`] = `
1: Funding available at the following URL: https://one.example.com
2: Funding available at the following URL: https://two.example.com
Run \`npm fund [<@scope>/]<pkg> --which=1\`, for example, to open the first funding URL listed in that package
`
exports[`test/tap/fund.js TAP fund using nested packages with multiple sources, with a source number > should open the numbered URL 1`] = `
Funding available at the following URL:
https://one.example.com
`
exports[`test/tap/fund.js TAP fund using package argument with no browser > should open funding url 1`] = `
individual funding available at the following URL:
http://example.com/donate
`
exports[`test/tap/fund.js TAP fund using string shorthand > should open string-only url 1`] = `
Funding available at the following URL:
https://example.com/sponsor
`
exports[`test/tap/fund.js TAP fund with no package containing funding > should print empty funding info 1`] = `
no-funding-package@0.0.0
`
/* IMPORTANT
* This snapshot file is auto-generated, but designed for humans.
* It should be checked into source control and tracked carefully.
* Re-generate by setting TAP_SNAPSHOT=1 and running tests.
* Make sure to inspect the output below. Do not ignore changes!
*/
'use strict'
exports[`test/tap/repo.js TAP npm repo underscore --json > should print json result 1`] = `
{
"title": "repository available at the following URL",
"url": "https://github.com/jashkenas/underscore"
}
`
exports[`test/tap/repo.js TAP npm repo underscore --no-browser > should print alternative msg 1`] = `
repository available at the following URL:
https://github.com/jashkenas/underscore
`
:: Created by npm, please don't edit manually.
@ECHO OFF
SETLOCAL
SET "NODE_EXE=%~dp0\node.exe"
IF NOT EXIST "%NODE_EXE%" (
SET "NODE_EXE=node"
)
SET "NPM_CLI_JS=%~dp0\node_modules\npm\bin\npm-cli.js"
FOR /F "delims=" %%F IN ('CALL "%NODE_EXE%" "%NPM_CLI_JS%" prefix -g') DO (
SET "NPM_PREFIX_NPM_CLI_JS=%%F\node_modules\npm\bin\npm-cli.js"
)
IF EXIST "%NPM_PREFIX_NPM_CLI_JS%" (
SET "NPM_CLI_JS=%NPM_PREFIX_NPM_CLI_JS%"
)
"%NODE_EXE%" "%NPM_CLI_JS%" %*
:: Created by npm, please don't edit manually.
@ECHO OFF
SETLOCAL
SET "NODE_EXE=%~dp0\node.exe"
IF NOT EXIST "%NODE_EXE%" (
SET "NODE_EXE=node"
)
SET "NPM_CLI_JS=%~dp0\node_modules\npm\bin\npm-cli.js"
SET "NPX_CLI_JS=%~dp0\node_modules\npm\bin\npx-cli.js"
FOR /F "delims=" %%F IN ('CALL "%NODE_EXE%" "%NPM_CLI_JS%" prefix -g') DO (
SET "NPM_PREFIX_NPX_CLI_JS=%%F\node_modules\npm\bin\npx-cli.js"
)
IF EXIST "%NPM_PREFIX_NPX_CLI_JS%" (
SET "NPX_CLI_JS=%NPM_PREFIX_NPX_CLI_JS%"
)
"%NODE_EXE%" "%NPX_CLI_JS%" %*
#!/usr/bin/node
const npx = require('libnpx')
const path = require('path')
const NPM_PATH = path.join(__dirname, 'npm-cli.js')
npx(npx.parseArgs(process.argv, NPM_PATH))
#!/bin/sh
(set -o igncr) 2>/dev/null && set -o igncr; # cygwin encoding fix
basedir=`dirname "$0"`
case `uname` in
*CYGWIN*) basedir=`cygpath -w "$basedir"`;;
esac
NODE_EXE="$basedir/node.exe"
if ! [ -x "$NODE_EXE" ]; then
NODE_EXE=node
fi
NPM_CLI_JS="$basedir/node_modules/npm/bin/npm-cli.js"
NPX_CLI_JS="$basedir/node_modules/npm/bin/npx-cli.js"
case `uname` in
*MINGW*)
NPM_PREFIX=`"$NODE_EXE" "$NPM_CLI_JS" prefix -g`
NPM_PREFIX_NPX_CLI_JS="$NPM_PREFIX/node_modules/npm/bin/npx-cli.js"
if [ -f "$NPM_PREFIX_NPX_CLI_JS" ]; then
NPX_CLI_JS="$NPM_PREFIX_NPX_CLI_JS"
fi
;;
*CYGWIN*)
NPM_PREFIX=`"$NODE_EXE" "$NPM_CLI_JS" prefix -g`
NPM_PREFIX_NPX_CLI_JS="$NPM_PREFIX/node_modules/npm/bin/npx-cli.js"
if [ -f "$NPM_PREFIX_NPX_CLI_JS" ]; then
NPX_CLI_JS="$NPM_PREFIX_NPX_CLI_JS"
fi
;;
esac
"$NODE_EXE" "$NPX_CLI_JS" "$@"
#!/bin/sh
(set -o igncr) 2>/dev/null && set -o igncr; # cygwin encoding fix
basedir=`dirname "$0"`
case `uname` in
*CYGWIN*) basedir=`cygpath -w "$basedir"`;;
esac
NODE_EXE="$basedir/node.exe"
if ! [ -x "$NODE_EXE" ]; then
NODE_EXE="$basedir/node"
fi
if ! [ -x "$NODE_EXE" ]; then
NODE_EXE=node
fi
NPM_CLI_JS="$basedir/node_modules/npm/bin/npm-cli.js"
case `uname` in
*MINGW*)
NPM_PREFIX=`"$NODE_EXE" "$NPM_CLI_JS" prefix -g`
NPM_PREFIX_NPM_CLI_JS="$NPM_PREFIX/node_modules/npm/bin/npm-cli.js"
if [ -f "$NPM_PREFIX_NPM_CLI_JS" ]; then
NPM_CLI_JS="$NPM_PREFIX_NPM_CLI_JS"
fi
;;
*CYGWIN*)
NPM_PREFIX=`"$NODE_EXE" "$NPM_CLI_JS" prefix -g`
NPM_PREFIX_NPM_CLI_JS="$NPM_PREFIX/node_modules/npm/bin/npm-cli.js"
if [ -f "$NPM_PREFIX_NPM_CLI_JS" ]; then
NPM_CLI_JS="$NPM_PREFIX_NPM_CLI_JS"
fi
;;
esac
"$NODE_EXE" "$NPM_CLI_JS" "$@"
#!/usr/bin/node
;(function () { // wrapper in case we're in module_context mode
// windows: running "npm blah" in this folder will invoke WSH, not node.
/* global WScript */
if (typeof WScript !== 'undefined') {
WScript.echo(
'npm does not work when run\n' +
'with the Windows Scripting Host\n\n' +
"'cd' to a different directory,\n" +
"or type 'npm.cmd <args>',\n" +
"or type 'node npm <args>'."
)
WScript.quit(1)
return
}
process.title = 'npm'
var unsupported = require('../lib/utils/unsupported.js')
unsupported.checkForBrokenNode()
var log = require('npmlog')
log.pause() // will be unpaused when config is loaded.
log.info('it worked if it ends with', 'ok')
unsupported.checkForUnsupportedNode()
var npm = require('../lib/npm.js')
var npmconf = require('../lib/config/core.js')
var errorHandler = require('../lib/utils/error-handler.js')
var replaceInfo = require('../lib/utils/replace-info.js')
var configDefs = npmconf.defs
var shorthands = configDefs.shorthands
var types = configDefs.types
var nopt = require('nopt')
// if npm is called as "npmg" or "npm_g", then
// run in global mode.
if (process.argv[1][process.argv[1].length - 1] === 'g') {
process.argv.splice(1, 1, 'npm', '-g')
}
var args = replaceInfo(process.argv)
log.verbose('cli', args)
var conf = nopt(types, shorthands)
npm.argv = conf.argv.remain
if (npm.deref(npm.argv[0])) npm.command = npm.argv.shift()
else conf.usage = true
if (conf.version) {
console.log(npm.version)
return errorHandler.exit(0)
}
if (conf.versions) {
npm.command = 'version'
conf.usage = false
npm.argv = []
}
log.info('using', 'npm@%s', npm.version)
log.info('using', 'node@%s', process.version)
process.on('uncaughtException', errorHandler)
process.on('unhandledRejection', errorHandler)
if (conf.usage && npm.command !== 'help') {
npm.argv.unshift(npm.command)
npm.command = 'help'
}
// now actually fire up npm and run the command.
// this is how to use npm programmatically:
conf._exit = true
npm.load(conf, function (er) {
if (er) return errorHandler(er)
npm.commands[npm.command](npm.argv, function (err) {
// https://genius.com/Lin-manuel-miranda-your-obedient-servant-lyrics
if (
!err &&
npm.config.get('ham-it-up') &&
!npm.config.get('json') &&
!npm.config.get('parseable') &&
npm.command !== 'completion'
) {
console.error(
`\n ${
npm.config.get('unicode') ? '🎵 ' : ''
} I Have the Honour to Be Your Obedient Servant,${
npm.config.get('unicode') ? '🎵 ' : ''
} ~ npm ${
npm.config.get('unicode') ? '📜🖋 ' : ''
}\n`
)
}
errorHandler.apply(this, arguments)
})
})
})()
if not defined npm_config_node_gyp (
node "%~dp0\..\..\node_modules\node-gyp\bin\node-gyp.js" %*
) else (
node "%npm_config_node_gyp%" %*
)
#!/usr/bin/sh
if [ "x$npm_config_node_gyp" = "x" ]; then
node "`dirname "$0"`/../../node_modules/node-gyp/bin/node-gyp.js" "$@"
else
"$npm_config_node_gyp" "$@"
fi
npm(1) -- a JavaScript package manager
==============================
[](https://travis-ci.org/npm/cli)
## SYNOPSIS
This is just enough info to get you up and running.
Much more info will be available via `npm help` once it's installed.
## IMPORTANT
**You need node v6 or higher to run this program.**
To install an old **and unsupported** version of npm that works on node v5
and prior, clone the git repo and dig through the old tags and branches.
**npm is configured to use npm, Inc.'s public registry at
<https://registry.npmjs.org> by default.** Use of the npm public registry
is subject to terms of use available at <https://www.npmjs.com/policies/terms>.
You can configure npm to use any compatible registry you
like, and even run your own registry. Check out the [doc on
registries](https://docs.npmjs.com/misc/registry).
## Super Easy Install
npm is bundled with [node](https://nodejs.org/en/download/).
### Windows Computers
[Get the MSI](https://nodejs.org/en/download/). npm is in it.
### Apple Macintosh Computers
[Get the pkg](https://nodejs.org/en/download/). npm is in it.
### Other Sorts of Unices
Run `make install`. npm will be installed with node.
If you want a more fancy pants install (a different version, customized
paths, etc.) then read on.
## Fancy Install (Unix)
There's a pretty robust install script at
<https://www.npmjs.com/install.sh>. You can download that and run it.
Here's an example using curl:
```sh
curl -L https://www.npmjs.com/install.sh | sh
```
### Slightly Fancier
You can set any npm configuration params with that script:
```sh
npm_config_prefix=/some/path sh install.sh
```
Or, you can run it in uber-debuggery mode:
```sh
npm_debug=1 sh install.sh
```
### Even Fancier
Get the code with git. Use `make` to build the docs and do other stuff.
If you plan on hacking on npm, `make link` is your friend.
If you've got the npm source code, you can also semi-permanently set
arbitrary config keys using the `./configure --key=val ...`, and then
run npm commands by doing `node bin/npm-cli.js <command> <args>`. (This is helpful
for testing, or running stuff without actually installing npm itself.)
## Windows Install or Upgrade
Many improvements for Windows users have been made in npm 3 - you will have a better
experience if you run a recent version of npm. To upgrade, either use [Microsoft's
upgrade tool](https://github.com/felixrieseberg/npm-windows-upgrade),
[download a new version of Node](https://nodejs.org/en/download/),
or follow the Windows upgrade instructions in the
[Installing/upgrading npm](https://npm.community/t/installing-upgrading-npm/251/2) post.
If that's not fancy enough for you, then you can fetch the code with
git, and mess with it directly.
## Installing on Cygwin
No.
## Uninstalling
So sad to see you go.
```sh
sudo npm uninstall npm -g
```
Or, if that fails,
```sh
sudo make uninstall
```
## More Severe Uninstalling
Usually, the above instructions are sufficient. That will remove
npm, but leave behind anything you've installed.
If you would like to remove all the packages that you have installed,
then you can use the `npm ls` command to find them, and then `npm rm` to
remove them.
To remove cruft left behind by npm 0.x, you can use the included
`clean-old.sh` script file. You can run it conveniently like this:
```sh
npm explore npm -g -- sh scripts/clean-old.sh
```
npm uses two configuration files, one for per-user configs, and another
for global (every-user) configs. You can view them by doing:
```sh
npm config get userconfig # defaults to ~/.npmrc
npm config get globalconfig # defaults to /usr/local/etc/npmrc
```
Uninstalling npm does not remove configuration files by default. You
must remove them yourself manually if you want them gone. Note that
this means that future npm installs will not remember the settings that
you have chosen.
## More Docs
Check out the [docs](https://docs.npmjs.com/).
You can use the `npm help` command to read any of them.
If you're a developer, and you want to use npm to publish your program,
you should [read this](https://docs.npmjs.com/misc/developers).
## BUGS
When you find issues, please report them:
* web:
<https://npm.community/c/bugs>
Be sure to include *all* of the output from the npm command that didn't work
as expected. The `npm-debug.log` file is also helpful to provide.
## SEE ALSO
* npm(1)
* npm-help(1)
'use strict'
var util = require('util')
var User = exports.User = function User (msg) {
var err = new Error(msg)
Error.captureStackTrace(err, User)
err.code = 'EGAUGE'
return err
}
exports.MissingTemplateValue = function MissingTemplateValue (item, values) {
var err = new User(util.format('Missing template value "%s"', item.type))
Error.captureStackTrace(err, MissingTemplateValue)
err.template = item
err.values = values
return err
}
exports.Internal = function Internal (msg) {
var err = new Error(msg)
Error.captureStackTrace(err, Internal)
err.code = 'EGAUGEINTERNAL'
return err
}
'use strict'
var process = require('./process')
try {
module.exports = setImmediate
} catch (ex) {
module.exports = process.nextTick
}
'use strict'
var objectAssign = require('object-assign')
module.exports = function () {
return ThemeSetProto.newThemeSet()
}
var ThemeSetProto = {}
ThemeSetProto.baseTheme = require('./base-theme.js')
ThemeSetProto.newTheme = function (parent, theme) {
if (!theme) {
theme = parent
parent = this.baseTheme
}
return objectAssign({}, parent, theme)
}
ThemeSetProto.getThemeNames = function () {
return Object.keys(this.themes)
}
ThemeSetProto.addTheme = function (name, parent, theme) {
this.themes[name] = this.newTheme(parent, theme)
}
ThemeSetProto.addToAllThemes = function (theme) {
var themes = this.themes
Object.keys(themes).forEach(function (name) {
objectAssign(themes[name], theme)
})
objectAssign(this.baseTheme, theme)
}
ThemeSetProto.getTheme = function (name) {
if (!this.themes[name]) throw this.newMissingThemeError(name)
return this.themes[name]
}
ThemeSetProto.setDefault = function (opts, name) {
if (name == null) {
name = opts
opts = {}
}
var platform = opts.platform == null ? 'fallback' : opts.platform
var hasUnicode = !!opts.hasUnicode
var hasColor = !!opts.hasColor
if (!this.defaults[platform]) this.defaults[platform] = {true: {}, false: {}}
this.defaults[platform][hasUnicode][hasColor] = name
}
ThemeSetProto.getDefault = function (opts) {
if (!opts) opts = {}
var platformName = opts.platform || process.platform
var platform = this.defaults[platformName] || this.defaults.fallback
var hasUnicode = !!opts.hasUnicode
var hasColor = !!opts.hasColor
if (!platform) throw this.newMissingDefaultThemeError(platformName, hasUnicode, hasColor)
if (!platform[hasUnicode][hasColor]) {
if (hasUnicode && hasColor && platform[!hasUnicode][hasColor]) {
hasUnicode = false
} else if (hasUnicode && hasColor && platform[hasUnicode][!hasColor]) {
hasColor = false
} else if (hasUnicode && hasColor && platform[!hasUnicode][!hasColor]) {
hasUnicode = false
hasColor = false
} else if (hasUnicode && !hasColor && platform[!hasUnicode][hasColor]) {
hasUnicode = false
} else if (!hasUnicode && hasColor && platform[hasUnicode][!hasColor]) {
hasColor = false
} else if (platform === this.defaults.fallback) {
throw this.newMissingDefaultThemeError(platformName, hasUnicode, hasColor)
}
}
if (platform[hasUnicode][hasColor]) {
return this.getTheme(platform[hasUnicode][hasColor])
} else {
return this.getDefault(objectAssign({}, opts, {platform: 'fallback'}))
}
}
ThemeSetProto.newMissingThemeError = function newMissingThemeError (name) {
var err = new Error('Could not find a gauge theme named "' + name + '"')
Error.captureStackTrace.call(err, newMissingThemeError)
err.theme = name
err.code = 'EMISSINGTHEME'
return err
}
ThemeSetProto.newMissingDefaultThemeError = function newMissingDefaultThemeError (platformName, hasUnicode, hasColor) {
var err = new Error(
'Could not find a gauge theme for your platform/unicode/color use combo:\n' +
' platform = ' + platformName + '\n' +
' hasUnicode = ' + hasUnicode + '\n' +
' hasColor = ' + hasColor)
Error.captureStackTrace.call(err, newMissingDefaultThemeError)
err.platform = platformName
err.hasUnicode = hasUnicode
err.hasColor = hasColor
err.code = 'EMISSINGTHEME'
return err
}
ThemeSetProto.newThemeSet = function () {
var themeset = function (opts) {
return themeset.getDefault(opts)
}
return objectAssign(themeset, ThemeSetProto, {
themes: objectAssign({}, this.themes),
baseTheme: objectAssign({}, this.baseTheme),
defaults: JSON.parse(JSON.stringify(this.defaults || {}))
})
}
'use strict'
module.exports = isWin32() || isColorTerm()
function isWin32 () {
return process.platform === 'win32'
}
function isColorTerm () {
var termHasColor = /^screen|^xterm|^vt100|color|ansi|cygwin|linux/i
return !!process.env.COLORTERM || termHasColor.test(process.env.TERM)
}
'use strict'
var consoleControl = require('console-control-strings')
var renderTemplate = require('./render-template.js')
var validate = require('aproba')
var Plumbing = module.exports = function (theme, template, width) {
if (!width) width = 80
validate('OAN', [theme, template, width])
this.showing = false
this.theme = theme
this.width = width
this.template = template
}
Plumbing.prototype = {}
Plumbing.prototype.setTheme = function (theme) {
validate('O', [theme])
this.theme = theme
}
Plumbing.prototype.setTemplate = function (template) {
validate('A', [template])
this.template = template
}
Plumbing.prototype.setWidth = function (width) {
validate('N', [width])
this.width = width
}
Plumbing.prototype.hide = function () {
return consoleControl.gotoSOL() + consoleControl.eraseLine()
}
Plumbing.prototype.hideCursor = consoleControl.hideCursor
Plumbing.prototype.showCursor = consoleControl.showCursor
Plumbing.prototype.show = function (status) {
var values = Object.create(this.theme)
for (var key in status) {
values[key] = status[key]
}
return renderTemplate(this.width, this.template, values).trim() +
consoleControl.color('reset') +
consoleControl.eraseLine() + consoleControl.gotoSOL()
}
gauge
=====
A nearly stateless terminal based horizontal gauge / progress bar.
```javascript
var Gauge = require("gauge")
var gauge = new Gauge()
gauge.show("test", 0.20)
gauge.pulse("this")
gauge.hide()
```
### CHANGES FROM 1.x
Gauge 2.x is breaking release, please see the [changelog] for details on
what's changed if you were previously a user of this module.
[changelog]: CHANGELOG.md
### THE GAUGE CLASS
This is the typical interface to the module– it provides a pretty
fire-and-forget interface to displaying your status information.
```
var Gauge = require("gauge")
var gauge = new Gauge([stream], [options])
```
* **stream** – *(optional, default STDERR)* A stream that progress bar
updates are to be written to. Gauge honors backpressure and will pause
most writing if it is indicated.
* **options** – *(optional)* An option object.
Constructs a new gauge. Gauges are drawn on a single line, and are not drawn
if **stream** isn't a tty and a tty isn't explicitly provided.
If **stream** is a terminal or if you pass in **tty** to **options** then we
will detect terminal resizes and redraw to fit. We do this by watching for
`resize` events on the tty. (To work around a bug in verisons of Node prior
to 2.5.0, we watch for them on stdout if the tty is stderr.) Resizes to
larger window sizes will be clean, but shrinking the window will always
result in some cruft.
**IMPORTANT:** If you prevously were passing in a non-tty stream but you still
want output (for example, a stream wrapped by the `ansi` module) then you
need to pass in the **tty** option below, as `gauge` needs access to
the underlying tty in order to do things like terminal resizes and terminal
width detection.
The **options** object can have the following properties, all of which are
optional:
* **updateInterval**: How often gauge updates should be drawn, in miliseconds.
* **fixedFramerate**: Defaults to false on node 0.8, true on everything
else. When this is true a timer is created to trigger once every
`updateInterval` ms, when false, updates are printed as soon as they come
in but updates more often than `updateInterval` are ignored. The reason
0.8 doesn't have this set to true is that it can't `unref` its timer and
so it would stop your program from exiting– if you want to use this
feature with 0.8 just make sure you call `gauge.disable()` before you
expect your program to exit.
* **themes**: A themeset to use when selecting the theme to use. Defaults
to `gauge/themes`, see the [themes] documentation for details.
* **theme**: Select a theme for use, it can be a:
* Theme object, in which case the **themes** is not used.
* The name of a theme, which will be looked up in the current *themes*
object.
* A configuration object with any of `hasUnicode`, `hasColor` or
`platform` keys, which if wlll be used to override our guesses when making
a default theme selection.
If no theme is selected then a default is picked using a combination of our
best guesses at your OS, color support and unicode support.
* **template**: Describes what you want your gauge to look like. The
default is what npm uses. Detailed [documentation] is later in this
document.
* **hideCursor**: Defaults to true. If true, then the cursor will be hidden
while the gauge is displayed.
* **tty**: The tty that you're ultimately writing to. Defaults to the same
as **stream**. This is used for detecting the width of the terminal and
resizes. The width used is `tty.columns - 1`. If no tty is available then
a width of `79` is assumed.
* **enabled**: Defaults to true if `tty` is a TTY, false otherwise. If true
the gauge starts enabled. If disabled then all update commands are
ignored and no gauge will be printed until you call `.enable()`.
* **Plumbing**: The class to use to actually generate the gauge for
printing. This defaults to `require('gauge/plumbing')` and ordinarly you
shouldn't need to override this.
* **cleanupOnExit**: Defaults to true. Ordinarily we register an exit
handler to make sure your cursor is turned back on and the progress bar
erased when your process exits, even if you Ctrl-C out or otherwise exit
unexpectedly. You can disable this and it won't register the exit handler.
[has-unicode]: https://www.npmjs.com/package/has-unicode
[themes]: #themes
[documentation]: #templates
#### `gauge.show(section | status, [completed])`
The first argument is either the section, the name of the current thing
contributing to progress, or an object with keys like **section**,
**subsection** & **completed** (or any others you have types for in a custom
template). If you don't want to update or set any of these you can pass
`null` and it will be ignored.
The second argument is the percent completed as a value between 0 and 1.
Without it, completion is just not updated. You'll also note that completion
can be passed in as part of a status object as the first argument. If both
it and the completed argument are passed in, the completed argument wins.
#### `gauge.hide([cb])`
Removes the gauge from the terminal. Optionally, callback `cb` after IO has
had an opportunity to happen (currently this just means after `setImmediate`
has called back.)
It turns out this is important when you're pausing the progress bar on one
filehandle and printing to another– otherwise (with a big enough print) node
can end up printing the "end progress bar" bits to the progress bar filehandle
while other stuff is printing to another filehandle. These getting interleaved
can cause corruption in some terminals.
#### `gauge.pulse([subsection])`
* **subsection** – *(optional)* The specific thing that triggered this pulse
Spins the spinner in the gauge to show output. If **subsection** is
included then it will be combined with the last name passed to `gauge.show`.
#### `gauge.disable()`
Hides the gauge and ignores further calls to `show` or `pulse`.
#### `gauge.enable()`
Shows the gauge and resumes updating when `show` or `pulse` is called.
#### `gauge.isEnabled()`
Returns true if the gauge is enabled.
#### `gauge.setThemeset(themes)`
Change the themeset to select a theme from. The same as the `themes` option
used in the constructor. The theme will be reselected from this themeset.
#### `gauge.setTheme(theme)`
Change the active theme, will be displayed with the next show or pulse. This can be:
* Theme object, in which case the **themes** is not used.
* The name of a theme, which will be looked up in the current *themes*
object.
* A configuration object with any of `hasUnicode`, `hasColor` or
`platform` keys, which if wlll be used to override our guesses when making
a default theme selection.
If no theme is selected then a default is picked using a combination of our
best guesses at your OS, color support and unicode support.
#### `gauge.setTemplate(template)`
Change the active template, will be displayed with the next show or pulse
### Tracking Completion
If you have more than one thing going on that you want to track completion
of, you may find the related [are-we-there-yet] helpful. It's `change`
event can be wired up to the `show` method to get a more traditional
progress bar interface.
[are-we-there-yet]: https://www.npmjs.com/package/are-we-there-yet
### THEMES
```
var themes = require('gauge/themes')
// fetch the default color unicode theme for this platform
var ourTheme = themes({hasUnicode: true, hasColor: true})
// fetch the default non-color unicode theme for osx
var ourTheme = themes({hasUnicode: true, hasColor: false, platform: 'darwin'})
// create a new theme based on the color ascii theme for this platform
// that brackets the progress bar with arrows
var ourTheme = themes.newTheme(theme(hasUnicode: false, hasColor: true}), {
preProgressbar: '→',
postProgressbar: '←'
})
```
The object returned by `gauge/themes` is an instance of the `ThemeSet` class.
```
var ThemeSet = require('gauge/theme-set')
var themes = new ThemeSet()
// or
var themes = require('gauge/themes')
var mythemes = themes.newThemeset() // creates a new themeset based on the default themes
```
#### themes(opts)
#### themes.getDefault(opts)
Theme objects are a function that fetches the default theme based on
platform, unicode and color support.
Options is an object with the following properties:
* **hasUnicode** - If true, fetch a unicode theme, if no unicode theme is
available then a non-unicode theme will be used.
* **hasColor** - If true, fetch a color theme, if no color theme is
available a non-color theme will be used.
* **platform** (optional) - Defaults to `process.platform`. If no
platform match is available then `fallback` is used instead.
If no compatible theme can be found then an error will be thrown with a
`code` of `EMISSINGTHEME`.
#### themes.addTheme(themeName, themeObj)
#### themes.addTheme(themeName, [parentTheme], newTheme)
Adds a named theme to the themeset. You can pass in either a theme object,
as returned by `themes.newTheme` or the arguments you'd pass to
`themes.newTheme`.
#### themes.getThemeNames()
Return a list of all of the names of the themes in this themeset. Suitable
for use in `themes.getTheme(…)`.
#### themes.getTheme(name)
Returns the theme object from this theme set named `name`.
If `name` does not exist in this themeset an error will be thrown with
a `code` of `EMISSINGTHEME`.
#### themes.setDefault([opts], themeName)
`opts` is an object with the following properties.
* **platform** - Defaults to `'fallback'`. If your theme is platform
specific, specify that here with the platform from `process.platform`, eg,
`win32`, `darwin`, etc.
* **hasUnicode** - Defaults to `false`. If your theme uses unicode you
should set this to true.
* **hasColor** - Defaults to `false`. If your theme uses color you should
set this to true.
`themeName` is the name of the theme (as given to `addTheme`) to use for
this set of `opts`.
#### themes.newTheme([parentTheme,] newTheme)
Create a new theme object based on `parentTheme`. If no `parentTheme` is
provided then a minimal parentTheme that defines functions for rendering the
activity indicator (spinner) and progress bar will be defined. (This
fallback parent is defined in `gauge/base-theme`.)
newTheme should be a bare object– we'll start by discussing the properties
defined by the default themes:
* **preProgressbar** - displayed prior to the progress bar, if the progress
bar is displayed.
* **postProgressbar** - displayed after the progress bar, if the progress bar
is displayed.
* **progressBarTheme** - The subtheme passed through to the progress bar
renderer, it's an object with `complete` and `remaining` properties
that are the strings you want repeated for those sections of the progress
bar.
* **activityIndicatorTheme** - The theme for the activity indicator (spinner),
this can either be a string, in which each character is a different step, or
an array of strings.
* **preSubsection** - Displayed as a separator between the `section` and
`subsection` when the latter is printed.
More generally, themes can have any value that would be a valid value when rendering
templates. The properties in the theme are used when their name matches a type in
the template. Their values can be:
* **strings & numbers** - They'll be included as is
* **function (values, theme, width)** - Should return what you want in your output.
*values* is an object with values provided via `gauge.show`,
*theme* is the theme specific to this item (see below) or this theme object,
and *width* is the number of characters wide your result should be.
There are a couple of special prefixes:
* **pre** - Is shown prior to the property, if its displayed.
* **post** - Is shown after the property, if its displayed.
And one special suffix:
* **Theme** - Its value is passed to a function-type item as the theme.
#### themes.addToAllThemes(theme)
This *mixes-in* `theme` into all themes currently defined. It also adds it
to the default parent theme for this themeset, so future themes added to
this themeset will get the values from `theme` by default.
#### themes.newThemeset()
Copy the current themeset into a new one. This allows you to easily inherit
one themeset from another.
### TEMPLATES
A template is an array of objects and strings that, after being evaluated,
will be turned into the gauge line. The default template is:
```javascript
[
{type: 'progressbar', length: 20},
{type: 'activityIndicator', kerning: 1, length: 1},
{type: 'section', kerning: 1, default: ''},
{type: 'subsection', kerning: 1, default: ''}
]
```
The various template elements can either be **plain strings**, in which case they will
be be included verbatum in the output, or objects with the following properties:
* *type* can be any of the following plus any keys you pass into `gauge.show` plus
any keys you have on a custom theme.
* `section` – What big thing you're working on now.
* `subsection` – What component of that thing is currently working.
* `activityIndicator` – Shows a spinner using the `activityIndicatorTheme`
from your active theme.
* `progressbar` – A progress bar representing your current `completed`
using the `progressbarTheme` from your active theme.
* *kerning* – Number of spaces that must be between this item and other
items, if this item is displayed at all.
* *maxLength* – The maximum length for this element. If its value is longer it
will be truncated.
* *minLength* – The minimum length for this element. If its value is shorter it
will be padded according to the *align* value.
* *align* – (Default: left) Possible values "left", "right" and "center". Works
as you'd expect from word processors.
* *length* – Provides a single value for both *minLength* and *maxLength*. If both
*length* and *minLength or *maxLength* are specifed then the latter take precedence.
* *value* – A literal value to use for this template item.
* *default* – A default value to use for this template item if a value
wasn't otherwise passed in.
### PLUMBING
This is the super simple, assume nothing, do no magic internals used by gauge to
implement its ordinary interface.
```
var Plumbing = require('gauge/plumbing')
var gauge = new Plumbing(theme, template, width)
```
* **theme**: The theme to use.
* **template**: The template to use.
* **width**: How wide your gauge should be
#### `gauge.setTheme(theme)`
Change the active theme.
#### `gauge.setTemplate(template)`
Change the active template.
#### `gauge.setWidth(width)`
Change the width to render at.
#### `gauge.hide()`
Return the string necessary to hide the progress bar
#### `gauge.hideCursor()`
Return a string to hide the cursor.
#### `gauge.showCursor()`
Return a string to show the cursor.
#### `gauge.show(status)`
Using `status` for values, render the provided template with the theme and return
a string that is suitable for printing to update the gauge.
'use strict'
var stringWidth = require('string-width')
module.exports = TemplateItem
function isPercent (num) {
if (typeof num !== 'string') return false
return num.slice(-1) === '%'
}
function percent (num) {
return Number(num.slice(0, -1)) / 100
}
function TemplateItem (values, outputLength) {
this.overallOutputLength = outputLength
this.finished = false
this.type = null
this.value = null
this.length = null
this.maxLength = null
this.minLength = null
this.kerning = null
this.align = 'left'
this.padLeft = 0
this.padRight = 0
this.index = null
this.first = null
this.last = null
if (typeof values === 'string') {
this.value = values
} else {
for (var prop in values) this[prop] = values[prop]
}
// Realize percents
if (isPercent(this.length)) {
this.length = Math.round(this.overallOutputLength * percent(this.length))
}
if (isPercent(this.minLength)) {
this.minLength = Math.round(this.overallOutputLength * percent(this.minLength))
}
if (isPercent(this.maxLength)) {
this.maxLength = Math.round(this.overallOutputLength * percent(this.maxLength))
}
return this
}
TemplateItem.prototype = {}
TemplateItem.prototype.getBaseLength = function () {
var length = this.length
if (length == null && typeof this.value === 'string' && this.maxLength == null && this.minLength == null) {
length = stringWidth(this.value)
}
return length
}
TemplateItem.prototype.getLength = function () {
var length = this.getBaseLength()
if (length == null) return null
return length + this.padLeft + this.padRight
}
TemplateItem.prototype.getMaxLength = function () {
if (this.maxLength == null) return null
return this.maxLength + this.padLeft + this.padRight
}
TemplateItem.prototype.getMinLength = function () {
if (this.minLength == null) return null
return this.minLength + this.padLeft + this.padRight
}
aproba
======
A ridiculously light-weight function argument validator
```
var validate = require("aproba")
function myfunc(a, b, c) {
// `a` must be a string, `b` a number, `c` a function
validate('SNF', arguments) // [a,b,c] is also valid
}
myfunc('test', 23, function () {}) // ok
myfunc(123, 23, function () {}) // type error
myfunc('test', 23) // missing arg error
myfunc('test', 23, function () {}, true) // too many args error
```
Valid types are:
| type | description
| :--: | :----------
| * | matches any type
| A | `Array.isArray` OR an `arguments` object
| S | typeof == string
| N | typeof == number
| F | typeof == function
| O | typeof == object and not type A and not type E
| B | typeof == boolean
| E | `instanceof Error` OR `null` **(special: see below)**
| Z | == `null`
Validation failures throw one of three exception types, distinguished by a
`code` property of `EMISSINGARG`, `EINVALIDTYPE` or `ETOOMANYARGS`.
If you pass in an invalid type then it will throw with a code of
`EUNKNOWNTYPE`.
If an **error** argument is found and is not null then the remaining
arguments are optional. That is, if you say `ESO` then that's like using a
non-magical `E` in: `E|ESO|ZSO`.
### But I have optional arguments?!
You can provide more than one signature by separating them with pipes `|`.
If any signature matches the arguments then they'll be considered valid.
So for example, say you wanted to write a signature for
`fs.createWriteStream`. The docs for it describe it thusly:
```
fs.createWriteStream(path[, options])
```
This would be a signature of `SO|S`. That is, a string and and object, or
just a string.
Now, if you read the full `fs` docs, you'll see that actually path can ALSO
be a buffer. And options can be a string, that is:
```
path <String> | <Buffer>
options <String> | <Object>
```
To reproduce this you have to fully enumerate all of the possible
combinations and that implies a signature of `SO|SS|OO|OS|S|O`. The
awkwardness is a feature: It reminds you of the complexity you're adding to
your API when you do this sort of thing.
### Browser support
This has no dependencies and should work in browsers, though you'll have
noisier stack traces.
### Why this exists
I wanted a very simple argument validator. It needed to do two things:
1. Be more concise and easier to use than assertions
2. Not encourage an infinite bikeshed of DSLs
This is why types are specified by a single character and there's no such
thing as an optional argument.
This is not intended to validate user data. This is specifically about
asserting the interface of your functions.
If you need greater validation, I encourage you to write them by hand or
look elsewhere.
{
"_from": "aproba@^1.0.3",
"_id": "aproba@1.2.0",
"_inBundle": false,
"_integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==",
"_location": "/gauge/aproba",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "aproba@^1.0.3",
"name": "aproba",
"escapedName": "aproba",
"rawSpec": "^1.0.3",
"saveSpec": null,
"fetchSpec": "^1.0.3"
},
"_requiredBy": [
"/gauge"
],
"_resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz",
"_shasum": "6802e6264efd18c790a1b0d517f0f2627bf2c94a",
"_spec": "aproba@^1.0.3",
"_where": "/Users/aeschright/code/cli/node_modules/gauge",
"author": {
"name": "Rebecca Turner",
"email": "me@re-becca.org"
},
"bugs": {
"url": "https://github.com/iarna/aproba/issues"
},
"bundleDependencies": false,
"dependencies": {},
"deprecated": false,
"description": "A ridiculously light-weight argument validator (now browser friendly)",
"devDependencies": {
"standard": "^10.0.3",
"tap": "^10.0.2"
},
"directories": {
"test": "test"
},
"files": [
"index.js"
],
"homepage": "https://github.com/iarna/aproba",
"keywords": [
"argument",
"validate"
],
"license": "ISC",
"main": "index.js",
"name": "aproba",
"repository": {
"type": "git",
"url": "git+https://github.com/iarna/aproba.git"
},
"scripts": {
"test": "standard && tap -j3 test/*.js"
},
"version": "1.2.0"
}
Copyright (c) 2015, Rebecca Turner <me@re-becca.org>
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.
'use strict'
function isArguments (thingy) {
return thingy != null && typeof thingy === 'object' && thingy.hasOwnProperty('callee')
}
var types = {
'*': {label: 'any', check: function () { return true }},
A: {label: 'array', check: function (thingy) { return Array.isArray(thingy) || isArguments(thingy) }},
S: {label: 'string', check: function (thingy) { return typeof thingy === 'string' }},
N: {label: 'number', check: function (thingy) { return typeof thingy === 'number' }},
F: {label: 'function', check: function (thingy) { return typeof thingy === 'function' }},
O: {label: 'object', check: function (thingy) { return typeof thingy === 'object' && thingy != null && !types.A.check(thingy) && !types.E.check(thingy) }},
B: {label: 'boolean', check: function (thingy) { return typeof thingy === 'boolean' }},
E: {label: 'error', check: function (thingy) { return thingy instanceof Error }},
Z: {label: 'null', check: function (thingy) { return thingy == null }}
}
function addSchema (schema, arity) {
var group = arity[schema.length] = arity[schema.length] || []
if (group.indexOf(schema) === -1) group.push(schema)
}
var validate = module.exports = function (rawSchemas, args) {
if (arguments.length !== 2) throw wrongNumberOfArgs(['SA'], arguments.length)
if (!rawSchemas) throw missingRequiredArg(0, 'rawSchemas')
if (!args) throw missingRequiredArg(1, 'args')
if (!types.S.check(rawSchemas)) throw invalidType(0, ['string'], rawSchemas)
if (!types.A.check(args)) throw invalidType(1, ['array'], args)
var schemas = rawSchemas.split('|')
var arity = {}
schemas.forEach(function (schema) {
for (var ii = 0; ii < schema.length; ++ii) {
var type = schema[ii]
if (!types[type]) throw unknownType(ii, type)
}
if (/E.*E/.test(schema)) throw moreThanOneError(schema)
addSchema(schema, arity)
if (/E/.test(schema)) {
addSchema(schema.replace(/E.*$/, 'E'), arity)
addSchema(schema.replace(/E/, 'Z'), arity)
if (schema.length === 1) addSchema('', arity)
}
})
var matching = arity[args.length]
if (!matching) {
throw wrongNumberOfArgs(Object.keys(arity), args.length)
}
for (var ii = 0; ii < args.length; ++ii) {
var newMatching = matching.filter(function (schema) {
var type = schema[ii]
var typeCheck = types[type].check
return typeCheck(args[ii])
})
if (!newMatching.length) {
var labels = matching.map(function (schema) {
return types[schema[ii]].label
}).filter(function (schema) { return schema != null })
throw invalidType(ii, labels, args[ii])
}
matching = newMatching
}
}
function missingRequiredArg (num) {
return newException('EMISSINGARG', 'Missing required argument #' + (num + 1))
}
function unknownType (num, type) {
return newException('EUNKNOWNTYPE', 'Unknown type ' + type + ' in argument #' + (num + 1))
}
function invalidType (num, expectedTypes, value) {
var valueType
Object.keys(types).forEach(function (typeCode) {
if (types[typeCode].check(value)) valueType = types[typeCode].label
})
return newException('EINVALIDTYPE', 'Argument #' + (num + 1) + ': Expected ' +
englishList(expectedTypes) + ' but got ' + valueType)
}
function englishList (list) {
return list.join(', ').replace(/, ([^,]+)$/, ' or $1')
}
function wrongNumberOfArgs (expected, got) {
var english = englishList(expected)
var args = expected.every(function (ex) { return ex.length === 1 })
? 'argument'
: 'arguments'
return newException('EWRONGARGCOUNT', 'Expected ' + english + ' ' + args + ' but got ' + got)
}
function moreThanOneError (schema) {
return newException('ETOOMANYERRORTYPES',
'Only one error type per argument signature is allowed, more than one found in "' + schema + '"')
}
function newException (code, msg) {
var e = new Error(msg)
e.code = code
if (Error.captureStackTrace) Error.captureStackTrace(e, validate)
return e
}
# string-width [](https://travis-ci.org/sindresorhus/string-width)
> Get the visual width of a string - the number of columns required to display it
Some Unicode characters are [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) and use double the normal width. [ANSI escape codes](http://en.wikipedia.org/wiki/ANSI_escape_code) are stripped and doesn't affect the width.
Useful to be able to measure the actual width of command-line output.
## Install
```
$ npm install --save string-width
```
## Usage
```js
const stringWidth = require('string-width');
stringWidth('古');
//=> 2
stringWidth('\u001b[1m古\u001b[22m');
//=> 2
stringWidth('a');
//=> 1
```
## Related
- [string-width-cli](https://github.com/sindresorhus/string-width-cli) - CLI for this module
- [string-length](https://github.com/sindresorhus/string-length) - Get the real length of a string
- [widest-line](https://github.com/sindresorhus/widest-line) - Get the visual width of the widest line in a string
## License
MIT © [Sindre Sorhus](https://sindresorhus.com)
The MIT License (MIT)
Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
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.
{
"_from": "string-width@^1.0.1",
"_id": "string-width@1.0.2",
"_inBundle": false,
"_integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=",
"_location": "/gauge/string-width",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "string-width@^1.0.1",
"name": "string-width",
"escapedName": "string-width",
"rawSpec": "^1.0.1",
"saveSpec": null,
"fetchSpec": "^1.0.1"
},
"_requiredBy": [
"/gauge"
],
"_resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz",
"_shasum": "118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3",
"_spec": "string-width@^1.0.1",
"_where": "/Users/rebecca/code/npm/node_modules/gauge",
"author": {
"name": "Sindre Sorhus",
"email": "sindresorhus@gmail.com",
"url": "sindresorhus.com"
},
"bugs": {
"url": "https://github.com/sindresorhus/string-width/issues"
},
"bundleDependencies": false,
"dependencies": {
"code-point-at": "^1.0.0",
"is-fullwidth-code-point": "^1.0.0",
"strip-ansi": "^3.0.0"
},
"deprecated": false,
"description": "Get the visual width of a string - the number of columns required to display it",
"devDependencies": {
"ava": "*",
"xo": "*"
},
"engines": {
"node": ">=0.10.0"
},
"files": [
"index.js"
],
"homepage": "https://github.com/sindresorhus/string-width#readme",
"keywords": [
"string",
"str",
"character",
"char",
"unicode",
"width",
"visual",
"column",
"columns",
"fullwidth",
"full-width",
"full",
"ansi",
"escape",
"codes",
"cli",
"command-line",
"terminal",
"console",
"cjk",
"chinese",
"japanese",
"korean",
"fixed-width"
],
"license": "MIT",
"name": "string-width",
"repository": {
"type": "git",
"url": "git+https://github.com/sindresorhus/string-width.git"
},
"scripts": {
"test": "xo && ava"
},
"version": "1.0.2"
}
'use strict';
var stripAnsi = require('strip-ansi');
var codePointAt = require('code-point-at');
var isFullwidthCodePoint = require('is-fullwidth-code-point');
// https://github.com/nodejs/io.js/blob/cff7300a578be1b10001f2d967aaedc88aee6402/lib/readline.js#L1345
module.exports = function (str) {
if (typeof str !== 'string' || str.length === 0) {
return 0;
}
var width = 0;
str = stripAnsi(str);
for (var i = 0; i < str.length; i++) {
var code = codePointAt(str, i);
// ignore control characters
if (code <= 0x1f || (code >= 0x7f && code <= 0x9f)) {
continue;
}
// surrogates
if (code >= 0x10000) {
i++;
}
if (isFullwidthCodePoint(code)) {
width += 2;
} else {
width++;
}
}
return width;
};
'use strict'
var consoleControl = require('console-control-strings')
var ThemeSet = require('./theme-set.js')
var themes = module.exports = new ThemeSet()
themes.addTheme('ASCII', {
preProgressbar: '[',
postProgressbar: ']',
progressbarTheme: {
complete: '#',
remaining: '.'
},
activityIndicatorTheme: '-\\|/',
preSubsection: '>'
})
themes.addTheme('colorASCII', themes.getTheme('ASCII'), {
progressbarTheme: {
preComplete: consoleControl.color('inverse'),
complete: ' ',
postComplete: consoleControl.color('stopInverse'),
preRemaining: consoleControl.color('brightBlack'),
remaining: '.',
postRemaining: consoleControl.color('reset')
}
})
themes.addTheme('brailleSpinner', {
preProgressbar: '⸨',
postProgressbar: '⸩',
progressbarTheme: {
complete: '░',
remaining: '⠂'
},
activityIndicatorTheme: '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏',
preSubsection: '>'
})
themes.addTheme('colorBrailleSpinner', themes.getTheme('brailleSpinner'), {
progressbarTheme: {
preComplete: consoleControl.color('inverse'),
complete: ' ',
postComplete: consoleControl.color('stopInverse'),
preRemaining: consoleControl.color('brightBlack'),
remaining: '░',
postRemaining: consoleControl.color('reset')
}
})
themes.setDefault({}, 'ASCII')
themes.setDefault({hasColor: true}, 'colorASCII')
themes.setDefault({platform: 'darwin', hasUnicode: true}, 'brailleSpinner')
themes.setDefault({platform: 'darwin', hasUnicode: true, hasColor: true}, 'colorBrailleSpinner')
'use strict'
var align = require('wide-align')
var validate = require('aproba')
var objectAssign = require('object-assign')
var wideTruncate = require('./wide-truncate')
var error = require('./error')
var TemplateItem = require('./template-item')
function renderValueWithValues (values) {
return function (item) {
return renderValue(item, values)
}
}
var renderTemplate = module.exports = function (width, template, values) {
var items = prepareItems(width, template, values)
var rendered = items.map(renderValueWithValues(values)).join('')
return align.left(wideTruncate(rendered, width), width)
}
function preType (item) {
var cappedTypeName = item.type[0].toUpperCase() + item.type.slice(1)
return 'pre' + cappedTypeName
}
function postType (item) {
var cappedTypeName = item.type[0].toUpperCase() + item.type.slice(1)
return 'post' + cappedTypeName
}
function hasPreOrPost (item, values) {
if (!item.type) return
return values[preType(item)] || values[postType(item)]
}
function generatePreAndPost (baseItem, parentValues) {
var item = objectAssign({}, baseItem)
var values = Object.create(parentValues)
var template = []
var pre = preType(item)
var post = postType(item)
if (values[pre]) {
template.push({value: values[pre]})
values[pre] = null
}
item.minLength = null
item.length = null
item.maxLength = null
template.push(item)
values[item.type] = values[item.type]
if (values[post]) {
template.push({value: values[post]})
values[post] = null
}
return function ($1, $2, length) {
return renderTemplate(length, template, values)
}
}
function prepareItems (width, template, values) {
function cloneAndObjectify (item, index, arr) {
var cloned = new TemplateItem(item, width)
var type = cloned.type
if (cloned.value == null) {
if (!(type in values)) {
if (cloned.default == null) {
throw new error.MissingTemplateValue(cloned, values)
} else {
cloned.value = cloned.default
}
} else {
cloned.value = values[type]
}
}
if (cloned.value == null || cloned.value === '') return null
cloned.index = index
cloned.first = index === 0
cloned.last = index === arr.length - 1
if (hasPreOrPost(cloned, values)) cloned.value = generatePreAndPost(cloned, values)
return cloned
}
var output = template.map(cloneAndObjectify).filter(function (item) { return item != null })
var outputLength = 0
var remainingSpace = width
var variableCount = output.length
function consumeSpace (length) {
if (length > remainingSpace) length = remainingSpace
outputLength += length
remainingSpace -= length
}
function finishSizing (item, length) {
if (item.finished) throw new error.Internal('Tried to finish template item that was already finished')
if (length === Infinity) throw new error.Internal('Length of template item cannot be infinity')
if (length != null) item.length = length
item.minLength = null
item.maxLength = null
--variableCount
item.finished = true
if (item.length == null) item.length = item.getBaseLength()
if (item.length == null) throw new error.Internal('Finished template items must have a length')
consumeSpace(item.getLength())
}
output.forEach(function (item) {
if (!item.kerning) return
var prevPadRight = item.first ? 0 : output[item.index - 1].padRight
if (!item.first && prevPadRight < item.kerning) item.padLeft = item.kerning - prevPadRight
if (!item.last) item.padRight = item.kerning
})
// Finish any that have a fixed (literal or intuited) length
output.forEach(function (item) {
if (item.getBaseLength() == null) return
finishSizing(item)
})
var resized = 0
var resizing
var hunkSize
do {
resizing = false
hunkSize = Math.round(remainingSpace / variableCount)
output.forEach(function (item) {
if (item.finished) return
if (!item.maxLength) return
if (item.getMaxLength() < hunkSize) {
finishSizing(item, item.maxLength)
resizing = true
}
})
} while (resizing && resized++ < output.length)
if (resizing) throw new error.Internal('Resize loop iterated too many times while determining maxLength')
resized = 0
do {
resizing = false
hunkSize = Math.round(remainingSpace / variableCount)
output.forEach(function (item) {
if (item.finished) return
if (!item.minLength) return
if (item.getMinLength() >= hunkSize) {
finishSizing(item, item.minLength)
resizing = true
}
})
} while (resizing && resized++ < output.length)
if (resizing) throw new error.Internal('Resize loop iterated too many times while determining minLength')
hunkSize = Math.round(remainingSpace / variableCount)
output.forEach(function (item) {
if (item.finished) return
finishSizing(item, hunkSize)
})
return output
}
function renderFunction (item, values, length) {
validate('OON', arguments)
if (item.type) {
return item.value(values, values[item.type + 'Theme'] || {}, length)
} else {
return item.value(values, {}, length)
}
}
function renderValue (item, values) {
var length = item.getBaseLength()
var value = typeof item.value === 'function' ? renderFunction(item, values, length) : item.value
if (value == null || value === '') return ''
var alignWith = align[item.align] || align.left
var leftPadding = item.padLeft ? align.left('', item.padLeft) : ''
var rightPadding = item.padRight ? align.right('', item.padRight) : ''
var truncated = wideTruncate(String(value), length)
var aligned = alignWith(truncated, length)
return leftPadding + aligned + rightPadding
}
{
"_from": "gauge@~2.7.3",
"_id": "gauge@2.7.4",
"_inBundle": false,
"_integrity": "sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=",
"_location": "/gauge",
"_phantomChildren": {
"code-point-at": "1.1.0",
"number-is-nan": "1.0.1"
},
"_requested": {
"type": "range",
"registry": true,
"raw": "gauge@~2.7.3",
"name": "gauge",
"escapedName": "gauge",
"rawSpec": "~2.7.3",
"saveSpec": null,
"fetchSpec": "~2.7.3"
},
"_requiredBy": [
"/npmlog"
],
"_resolved": "https://registry.npmjs.org/gauge/-/gauge-2.7.4.tgz",
"_shasum": "2c03405c7538c39d7eb37b317022e325fb018bf7",
"_spec": "gauge@~2.7.3",
"_where": "/Users/rebecca/code/npm/node_modules/npmlog",
"author": {
"name": "Rebecca Turner",
"email": "me@re-becca.org"
},
"bugs": {
"url": "https://github.com/iarna/gauge/issues"
},
"bundleDependencies": false,
"dependencies": {
"aproba": "^1.0.3",
"console-control-strings": "^1.0.0",
"has-unicode": "^2.0.0",
"object-assign": "^4.1.0",
"signal-exit": "^3.0.0",
"string-width": "^1.0.1",
"strip-ansi": "^3.0.1",
"wide-align": "^1.1.0"
},
"deprecated": false,
"description": "A terminal based horizontal guage",
"devDependencies": {
"readable-stream": "^2.0.6",
"require-inject": "^1.4.0",
"standard": "^7.1.2",
"tap": "^5.7.2",
"through2": "^2.0.0"
},
"files": [
"base-theme.js",
"CHANGELOG.md",
"error.js",
"has-color.js",
"index.js",
"LICENSE",
"package.json",
"plumbing.js",
"process.js",
"progress-bar.js",
"README.md",
"render-template.js",
"set-immediate.js",
"set-interval.js",
"spin.js",
"template-item.js",
"theme-set.js",
"themes.js",
"wide-truncate.js"
],
"homepage": "https://github.com/iarna/gauge",
"keywords": [
"progressbar",
"progress",
"gauge"
],
"license": "ISC",
"main": "index.js",
"name": "gauge",
"repository": {
"type": "git",
"url": "git+https://github.com/iarna/gauge.git"
},
"scripts": {
"prepublish": "rm -f *~",
"test": "standard && tap test/*.js --coverage"
},
"version": "2.7.4"
}
'use strict'
var spin = require('./spin.js')
var progressBar = require('./progress-bar.js')
module.exports = {
activityIndicator: function (values, theme, width) {
if (values.spun == null) return
return spin(theme, values.spun)
},
progressbar: function (values, theme, width) {
if (values.completed == null) return
return progressBar(theme, width, values.completed)
}
}
### v2.7.4
* Reset colors prior to ending a line, to eliminate flicker when a line
is trucated between start and end color sequences.
### v2.7.3
* Only create our onExit handler when we're enabled and remove it when we're
disabled. This stops us from creating multiple onExit handlers when
multiple gauge objects are being used.
* Fix bug where if a theme name were given instead of a theme object, it
would crash.
* Remove supports-color because it's not actually used. Uhm. Yes, I just
updated it. >.>
### v2.7.2
* Use supports-color instead of has-color (as the module has been renamed)
### v2.7.1
* Bug fix: Calls to show/pulse while the progress bar is disabled should still
update our internal representation of what would be shown should it be enabled.
### v2.7.0
* New feature: Add new `isEnabled` method to allow introspection of the gauge's
"enabledness" as controlled by `.enable()` and `.disable()`.
### v2.6.0
* Bug fix: Don't run the code associated with `enable`/`disable` if the gauge
is already enabled or disabled respectively. This prevents leaking event
listeners, amongst other weirdness.
* New feature: Template items can have default values that will be used if no
value was otherwise passed in.
### v2.5.3
* Default to `enabled` only if we have a tty. Users can always override
this by passing in the `enabled` option explicitly or by calling calling
`gauge.enable()`.
### v2.5.2
* Externalized `./console-strings.js` into `console-control-strings`.
### v2.5.1
* Update to `signal-exit@3.0.0`, which fixes a compatibility bug with the
node profiler.
* [#39](https://github.com/iarna/gauge/pull/39) Fix tests on 0.10 and add
a missing devDependency. ([@helloyou2012](https://github.com/helloyou2012))
### v2.5.0
* Add way to programmatically fetch a list of theme names in a themeset
(`Themeset.getThemeNames`).
### v2.4.0
* Add support for setting themesets on existing gauge objects.
* Add post-IO callback to `gauge.hide()` as it is somtetimes necessary when
your terminal is interleaving output from multiple filehandles (ie, stdout
& stderr).
### v2.3.1
* Fix a refactor bug in setTheme where it wasn't accepting the various types
of args it should.
### v2.3.0
#### FEATURES
* Add setTemplate & setTheme back in.
* Add support for named themes, you can now ask for things like 'colorASCII'
and 'brailleSpinner'. Of course, you can still pass in theme objects.
Additionally you can now pass in an object with `hasUnicode`, `hasColor` and
`platform` keys in order to override our guesses as to those values when
selecting a default theme from the themeset.
* Make the output stream optional (it defaults to `process.stderr` now).
* Add `setWriteTo(stream[, tty])` to change the output stream and,
optionally, tty.
#### BUG FIXES & REFACTORING
* Abort the display phase early if we're supposed to be hidden and we are.
* Stop printing a bunch of spaces at the end of lines, since we're already
using an erase-to-end-of-line code anyway.
* The unicode themes were missing the subsection separator.
### v2.2.1
* Fix image in readme
### v2.2.0
* All new themes API– reference themes by name and pass in custom themes and
themesets (themesets get platform support autodetection done on them to
select the best theme). Theme mixins let you add features to all existing
themes.
* Much, much improved test coverage.
### v2.1.0
* Got rid of ░ in the default platform, noUnicode, hasColor theme. Thanks
to @yongtw123 for pointing out this had snuck in.
* Fiddled with the demo output to make it easier to see the spinner spin. Also
added prints before each platforms test output.
* I forgot to include `signal-exit` in our deps. <.< Thank you @KenanY for
finding this. Then I was lazy and made a new commit instead of using his
PR. Again, thank you for your patience @KenenY.
* Drastically speed up travis testing.
* Add a small javascript demo (demo.js) for showing off the various themes
(and testing them on diff platforms).
* Change: The subsection separator from ⁄ and / (different chars) to >.
* Fix crasher: A show or pulse without a label would cause the template renderer
to complain about a missing value.
* New feature: Add the ability to disable the clean-up-on-exit behavior.
Not something I expect to be widely desirable, but important if you have
multiple distinct gauge instances in your app.
* Use our own color support detection.
The `has-color` module proved too magic for my needs, making assumptions
as to which stream we write to and reading command line arguments.
### v2.0.0
This is a major rewrite of the internals. Externally there are fewer
changes:
* On node>0.8 gauge object now prints updates at a fixed rate. This means
that when you call `show` it may wate up to `updateInterval` ms before it
actually prints an update. You override this behavior with the
`fixedFramerate` option.
* The gauge object now keeps the cursor hidden as long as it's enabled and
shown.
* The constructor's arguments have changed, now it takes a mandatory output
stream and an optional options object. The stream no longer needs to be
an `ansi`ified stream, although it can be if you want (but we won't make
use of its special features).
* Previously the gauge was disabled by default if `process.stdout` wasn't a
tty. Now it always defaults to enabled. If you want the previous
behavior set the `enabled` option to `process.stdout.isTTY`.
* The constructor's options have changed– see the docs for details.
* Themes are entirely different. If you were using a custom theme, or
referring to one directly (eg via `Gauge.unicode` or `Gauge.ascii`) then
you'll need to change your code. You can get the equivalent of the latter
with:
```
var themes = require('gauge/themes')
var unicodeTheme = themes(true, true) // returns the color unicode theme for your platform
```
The default themes no longer use any ambiguous width characters, so even
if you choose to display those as wide your progress bar should still
display correctly.
* Templates are entirely different and if you were using a custom one, you
should consult the documentation to learn how to recreate it. If you were
using the default, be aware that it has changed and the result looks quite
a bit different.
'use strict'
// this exists so we can replace it during testing
module.exports = process
'use strict'
module.exports = function spin (spinstr, spun) {
return spinstr[spun % spinstr.length]
}
'use strict'
var validate = require('aproba')
var renderTemplate = require('./render-template.js')
var wideTruncate = require('./wide-truncate')
var stringWidth = require('string-width')
module.exports = function (theme, width, completed) {
validate('ONN', [theme, width, completed])
if (completed < 0) completed = 0
if (completed > 1) completed = 1
if (width <= 0) return ''
var sofar = Math.round(width * completed)
var rest = width - sofar
var template = [
{type: 'complete', value: repeat(theme.complete, sofar), length: sofar},
{type: 'remaining', value: repeat(theme.remaining, rest), length: rest}
]
return renderTemplate(width, template, theme)
}
// lodash's way of repeating
function repeat (string, width) {
var result = ''
var n = width
do {
if (n % 2) {
result += string
}
n = Math.floor(n / 2)
/*eslint no-self-assign: 0*/
string += string
} while (n && stringWidth(result) < width)
return wideTruncate(result, width)
}
Copyright (c) 2014, Rebecca Turner <me@re-becca.org>
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.
'use strict'
var stringWidth = require('string-width')
var stripAnsi = require('strip-ansi')
module.exports = wideTruncate
function wideTruncate (str, target) {
if (stringWidth(str) === 0) return str
if (target <= 0) return ''
if (stringWidth(str) <= target) return str
// We compute the number of bytes of ansi sequences here and add
// that to our initial truncation to ensure that we don't slice one
// that we want to keep in half.
var noAnsi = stripAnsi(str)
var ansiSize = str.length + noAnsi.length
var truncated = str.slice(0, target + ansiSize)
// we have to shrink the result to account for our ansi sequence buffer
// (if an ansi sequence was truncated) and double width characters.
while (stringWidth(truncated) > target) {
truncated = truncated.slice(0, -1)
}
return truncated
}
'use strict'
var Plumbing = require('./plumbing.js')
var hasUnicode = require('has-unicode')
var hasColor = require('./has-color.js')
var onExit = require('signal-exit')
var defaultThemes = require('./themes')
var setInterval = require('./set-interval.js')
var process = require('./process.js')
var setImmediate = require('./set-immediate')
module.exports = Gauge
function callWith (obj, method) {
return function () {
return method.call(obj)
}
}
function Gauge (arg1, arg2) {
var options, writeTo
if (arg1 && arg1.write) {
writeTo = arg1
options = arg2 || {}
} else if (arg2 && arg2.write) {
writeTo = arg2
options = arg1 || {}
} else {
writeTo = process.stderr
options = arg1 || arg2 || {}
}
this._status = {
spun: 0,
section: '',
subsection: ''
}
this._paused = false // are we paused for back pressure?
this._disabled = true // are all progress bar updates disabled?
this._showing = false // do we WANT the progress bar on screen
this._onScreen = false // IS the progress bar on screen
this._needsRedraw = false // should we print something at next tick?
this._hideCursor = options.hideCursor == null ? true : options.hideCursor
this._fixedFramerate = options.fixedFramerate == null
? !(/^v0\.8\./.test(process.version))
: options.fixedFramerate
this._lastUpdateAt = null
this._updateInterval = options.updateInterval == null ? 50 : options.updateInterval
this._themes = options.themes || defaultThemes
this._theme = options.theme
var theme = this._computeTheme(options.theme)
var template = options.template || [
{type: 'progressbar', length: 20},
{type: 'activityIndicator', kerning: 1, length: 1},
{type: 'section', kerning: 1, default: ''},
{type: 'subsection', kerning: 1, default: ''}
]
this.setWriteTo(writeTo, options.tty)
var PlumbingClass = options.Plumbing || Plumbing
this._gauge = new PlumbingClass(theme, template, this.getWidth())
this._$$doRedraw = callWith(this, this._doRedraw)
this._$$handleSizeChange = callWith(this, this._handleSizeChange)
this._cleanupOnExit = options.cleanupOnExit == null || options.cleanupOnExit
this._removeOnExit = null
if (options.enabled || (options.enabled == null && this._tty && this._tty.isTTY)) {
this.enable()
} else {
this.disable()
}
}
Gauge.prototype = {}
Gauge.prototype.isEnabled = function () {
return !this._disabled
}
Gauge.prototype.setTemplate = function (template) {
this._gauge.setTemplate(template)
if (this._showing) this._requestRedraw()
}
Gauge.prototype._computeTheme = function (theme) {
if (!theme) theme = {}
if (typeof theme === 'string') {
theme = this._themes.getTheme(theme)
} else if (theme && (Object.keys(theme).length === 0 || theme.hasUnicode != null || theme.hasColor != null)) {
var useUnicode = theme.hasUnicode == null ? hasUnicode() : theme.hasUnicode
var useColor = theme.hasColor == null ? hasColor : theme.hasColor
theme = this._themes.getDefault({hasUnicode: useUnicode, hasColor: useColor, platform: theme.platform})
}
return theme
}
Gauge.prototype.setThemeset = function (themes) {
this._themes = themes
this.setTheme(this._theme)
}
Gauge.prototype.setTheme = function (theme) {
this._gauge.setTheme(this._computeTheme(theme))
if (this._showing) this._requestRedraw()
this._theme = theme
}
Gauge.prototype._requestRedraw = function () {
this._needsRedraw = true
if (!this._fixedFramerate) this._doRedraw()
}
Gauge.prototype.getWidth = function () {
return ((this._tty && this._tty.columns) || 80) - 1
}
Gauge.prototype.setWriteTo = function (writeTo, tty) {
var enabled = !this._disabled
if (enabled) this.disable()
this._writeTo = writeTo
this._tty = tty ||
(writeTo === process.stderr && process.stdout.isTTY && process.stdout) ||
(writeTo.isTTY && writeTo) ||
this._tty
if (this._gauge) this._gauge.setWidth(this.getWidth())
if (enabled) this.enable()
}
Gauge.prototype.enable = function () {
if (!this._disabled) return
this._disabled = false
if (this._tty) this._enableEvents()
if (this._showing) this.show()
}
Gauge.prototype.disable = function () {
if (this._disabled) return
if (this._showing) {
this._lastUpdateAt = null
this._showing = false
this._doRedraw()
this._showing = true
}
this._disabled = true
if (this._tty) this._disableEvents()
}
Gauge.prototype._enableEvents = function () {
if (this._cleanupOnExit) {
this._removeOnExit = onExit(callWith(this, this.disable))
}
this._tty.on('resize', this._$$handleSizeChange)
if (this._fixedFramerate) {
this.redrawTracker = setInterval(this._$$doRedraw, this._updateInterval)
if (this.redrawTracker.unref) this.redrawTracker.unref()
}
}
Gauge.prototype._disableEvents = function () {
this._tty.removeListener('resize', this._$$handleSizeChange)
if (this._fixedFramerate) clearInterval(this.redrawTracker)
if (this._removeOnExit) this._removeOnExit()
}
Gauge.prototype.hide = function (cb) {
if (this._disabled) return cb && process.nextTick(cb)
if (!this._showing) return cb && process.nextTick(cb)
this._showing = false
this._doRedraw()
cb && setImmediate(cb)
}
Gauge.prototype.show = function (section, completed) {
this._showing = true
if (typeof section === 'string') {
this._status.section = section
} else if (typeof section === 'object') {
var sectionKeys = Object.keys(section)
for (var ii = 0; ii < sectionKeys.length; ++ii) {
var key = sectionKeys[ii]
this._status[key] = section[key]
}
}
if (completed != null) this._status.completed = completed
if (this._disabled) return
this._requestRedraw()
}
Gauge.prototype.pulse = function (subsection) {
this._status.subsection = subsection || ''
this._status.spun ++
if (this._disabled) return
if (!this._showing) return
this._requestRedraw()
}
Gauge.prototype._handleSizeChange = function () {
this._gauge.setWidth(this._tty.columns - 1)
this._requestRedraw()
}
Gauge.prototype._doRedraw = function () {
if (this._disabled || this._paused) return
if (!this._fixedFramerate) {
var now = Date.now()
if (this._lastUpdateAt && now - this._lastUpdateAt < this._updateInterval) return
this._lastUpdateAt = now
}
if (!this._showing && this._onScreen) {
this._onScreen = false
var result = this._gauge.hide()
if (this._hideCursor) {
result += this._gauge.showCursor()
}
return this._writeTo.write(result)
}
if (!this._showing && !this._onScreen) return
if (this._showing && !this._onScreen) {
this._onScreen = true
this._needsRedraw = true
if (this._hideCursor) {
this._writeTo.write(this._gauge.hideCursor())
}
}
if (!this._needsRedraw) return
if (!this._writeTo.write(this._gauge.show(this._status))) {
this._paused = true
this._writeTo.on('drain', callWith(this, function () {
this._paused = false
this._doRedraw()
}))
}
}
'use strict'
// this exists so we can replace it during testing
module.exports = setInterval
# duplexer3 [](https://travis-ci.org/floatdrop/duplexer3) [](https://coveralls.io/github/floatdrop/duplexer3?branch=master)
Like [duplexer2](https://github.com/deoxxa/duplexer2) but using Streams3 without readable-stream dependency
```javascript
var stream = require("stream");
var duplexer3 = require("duplexer3");
var writable = new stream.Writable({objectMode: true}),
readable = new stream.Readable({objectMode: true});
writable._write = function _write(input, encoding, done) {
if (readable.push(input)) {
return done();
} else {
readable.once("drain", done);
}
};
readable._read = function _read(n) {
// no-op
};
// simulate the readable thing closing after a bit
writable.once("finish", function() {
setTimeout(function() {
readable.push(null);
}, 500);
});
var duplex = duplexer3(writable, readable);
duplex.on("data", function(e) {
console.log("got data", JSON.stringify(e));
});
duplex.on("finish", function() {
console.log("got finish event");
});
duplex.on("end", function() {
console.log("got end event");
});
duplex.write("oh, hi there", function() {
console.log("finished writing");
});
duplex.end(function() {
console.log("finished ending");
});
```
```
got data "oh, hi there"
finished writing
got finish event
finished ending
got end event
```
## Overview
This is a reimplementation of [duplexer](https://www.npmjs.com/package/duplexer) using the
Streams3 API which is standard in Node as of v4. Everything largely
works the same.
## Installation
[Available via `npm`](https://docs.npmjs.com/cli/install):
```
$ npm i duplexer3
```
## API
### duplexer3
Creates a new `DuplexWrapper` object, which is the actual class that implements
most of the fun stuff. All that fun stuff is hidden. DON'T LOOK.
```javascript
duplexer3([options], writable, readable)
```
```javascript
const duplex = duplexer3(new stream.Writable(), new stream.Readable());
```
Arguments
* __options__ - an object specifying the regular `stream.Duplex` options, as
well as the properties described below.
* __writable__ - a writable stream
* __readable__ - a readable stream
Options
* __bubbleErrors__ - a boolean value that specifies whether to bubble errors
from the underlying readable/writable streams. Default is `true`.
## License
3-clause BSD. [A copy](./LICENSE) is included with the source.
## Contact
* GitHub ([deoxxa](http://github.com/deoxxa))
* Twitter ([@deoxxa](http://twitter.com/deoxxa))
* Email ([deoxxa@fknsrs.biz](mailto:deoxxa@fknsrs.biz))
{
"_from": "duplexer3@^0.1.4",
"_id": "duplexer3@0.1.4",
"_inBundle": false,
"_integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=",
"_location": "/duplexer3",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "duplexer3@^0.1.4",
"name": "duplexer3",
"escapedName": "duplexer3",
"rawSpec": "^0.1.4",
"saveSpec": null,
"fetchSpec": "^0.1.4"
},
"_requiredBy": [
"/got"
],
"_resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz",
"_shasum": "ee01dd1cac0ed3cbc7fdbea37dc0a8f1ce002ce2",
"_spec": "duplexer3@^0.1.4",
"_where": "/Users/rebecca/code/npm/node_modules/got",
"author": {
"name": "Conrad Pankoff",
"email": "deoxxa@fknsrs.biz",
"url": "http://www.fknsrs.biz/"
},
"bugs": {
"url": "https://github.com/floatdrop/duplexer3/issues"
},
"bundleDependencies": false,
"deprecated": false,
"description": "Like duplexer but using streams3",
"devDependencies": {
"mocha": "^2.2.5"
},
"engine": {
"node": ">=4"
},
"files": [
"index.js"
],
"homepage": "https://github.com/floatdrop/duplexer3#readme",
"keywords": [
"duplex",
"duplexer",
"stream",
"stream3",
"join",
"combine"
],
"license": "BSD-3-Clause",
"name": "duplexer3",
"repository": {
"type": "git",
"url": "git+https://github.com/floatdrop/duplexer3.git"
},
"scripts": {
"test": "mocha -R tap"
},
"version": "0.1.4"
}
Copyright (c) 2013, Deoxxa Development
======================================
All rights reserved.
--------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of Deoxxa Development nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY DEOXXA DEVELOPMENT ''AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL DEOXXA DEVELOPMENT BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"use strict";
var stream = require("stream");
function DuplexWrapper(options, writable, readable) {
if (typeof readable === "undefined") {
readable = writable;
writable = options;
options = null;
}
stream.Duplex.call(this, options);
if (typeof readable.read !== "function") {
readable = (new stream.Readable(options)).wrap(readable);
}
this._writable = writable;
this._readable = readable;
this._waiting = false;
var self = this;
writable.once("finish", function() {
self.end();
});
this.once("finish", function() {
writable.end();
});
readable.on("readable", function() {
if (self._waiting) {
self._waiting = false;
self._read();
}
});
readable.once("end", function() {
self.push(null);
});
if (!options || typeof options.bubbleErrors === "undefined" || options.bubbleErrors) {
writable.on("error", function(err) {
self.emit("error", err);
});
readable.on("error", function(err) {
self.emit("error", err);
});
}
}
DuplexWrapper.prototype = Object.create(stream.Duplex.prototype, {constructor: {value: DuplexWrapper}});
DuplexWrapper.prototype._write = function _write(input, encoding, done) {
this._writable.write(input, encoding, done);
};
DuplexWrapper.prototype._read = function _read() {
var buf;
var reads = 0;
while ((buf = this._readable.read()) !== null) {
this.push(buf);
reads++;
}
if (reads === 0) {
this._waiting = true;
}
};
module.exports = function duplex2(options, writable, readable) {
return new DuplexWrapper(options, writable, readable);
};
module.exports.DuplexWrapper = DuplexWrapper;
# lodash.clonedeep v4.5.0
The [lodash](https://lodash.com/) method `_.cloneDeep` exported as a [Node.js](https://nodejs.org/) module.
## Installation
Using npm:
```bash
$ {sudo -H} npm i -g npm
$ npm i --save lodash.clonedeep
```
In Node.js:
```js
var cloneDeep = require('lodash.clonedeep');
```
See the [documentation](https://lodash.com/docs#cloneDeep) or [package source](https://github.com/lodash/lodash/blob/4.5.0-npm-packages/lodash.clonedeep) for more details.
{
"_args": [
[
"lodash.clonedeep@4.5.0",
"/Users/rebecca/code/npm"
]
],
"_from": "lodash.clonedeep@4.5.0",
"_id": "lodash.clonedeep@4.5.0",
"_inBundle": false,
"_integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=",
"_location": "/lodash.clonedeep",
"_phantomChildren": {},
"_requested": {
"type": "version",
"registry": true,
"raw": "lodash.clonedeep@4.5.0",
"name": "lodash.clonedeep",
"escapedName": "lodash.clonedeep",
"rawSpec": "4.5.0",
"saveSpec": null,
"fetchSpec": "4.5.0"
},
"_requiredBy": [
"/"
],
"_resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz",
"_spec": "4.5.0",
"_where": "/Users/rebecca/code/npm",
"author": {
"name": "John-David Dalton",
"email": "john.david.dalton@gmail.com",
"url": "http://allyoucanleet.com/"
},
"bugs": {
"url": "https://github.com/lodash/lodash/issues"
},
"contributors": [
{
"name": "John-David Dalton",
"email": "john.david.dalton@gmail.com",
"url": "http://allyoucanleet.com/"
},
{
"name": "Blaine Bublitz",
"email": "blaine.bublitz@gmail.com",
"url": "https://github.com/phated"
},
{
"name": "Mathias Bynens",
"email": "mathias@qiwi.be",
"url": "https://mathiasbynens.be/"
}
],
"description": "The lodash method `_.cloneDeep` exported as a module.",
"homepage": "https://lodash.com/",
"icon": "https://lodash.com/icon.svg",
"keywords": [
"lodash-modularized",
"clonedeep"
],
"license": "MIT",
"name": "lodash.clonedeep",
"repository": {
"type": "git",
"url": "git+https://github.com/lodash/lodash.git"
},
"scripts": {
"test": "echo \"See https://travis-ci.org/lodash/lodash-cli for testing details.\""
},
"version": "4.5.0"
}
Copyright jQuery Foundation and other contributors <https://jquery.org/>
Based on Underscore.js, copyright Jeremy Ashkenas,
DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
This software consists of voluntary contributions made by many
individuals. For exact contribution history, see the revision history
available at https://github.com/lodash/lodash
The following license applies to all parts of this software except as
documented below:
====
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.
====
Copyright and related rights for sample code are waived via CC0. Sample
code is defined as all source code displayed within the prose of the
documentation.
CC0: http://creativecommons.org/publicdomain/zero/1.0/
====
Files located in the node_modules and vendor directories are externally
maintained libraries used by this software which have their own
licenses; we recommend you read them, as their terms may differ from the
terms above.
/**
* lodash (Custom Build) <https://lodash.com/>
* Build: `lodash modularize exports="npm" -o ./`
* Copyright jQuery Foundation and other contributors <https://jquery.org/>
* Released under MIT license <https://lodash.com/license>
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
*/
/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;
/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';
/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991;
/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
arrayTag = '[object Array]',
boolTag = '[object Boolean]',
dateTag = '[object Date]',
errorTag = '[object Error]',
funcTag = '[object Function]',
genTag = '[object GeneratorFunction]',
mapTag = '[object Map]',
numberTag = '[object Number]',
objectTag = '[object Object]',
promiseTag = '[object Promise]',
regexpTag = '[object RegExp]',
setTag = '[object Set]',
stringTag = '[object String]',
symbolTag = '[object Symbol]',
weakMapTag = '[object WeakMap]';
var arrayBufferTag = '[object ArrayBuffer]',
dataViewTag = '[object DataView]',
float32Tag = '[object Float32Array]',
float64Tag = '[object Float64Array]',
int8Tag = '[object Int8Array]',
int16Tag = '[object Int16Array]',
int32Tag = '[object Int32Array]',
uint8Tag = '[object Uint8Array]',
uint8ClampedTag = '[object Uint8ClampedArray]',
uint16Tag = '[object Uint16Array]',
uint32Tag = '[object Uint32Array]';
/**
* Used to match `RegExp`
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
*/
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
/** Used to match `RegExp` flags from their coerced string values. */
var reFlags = /\w*$/;
/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;
/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]\d*)$/;
/** Used to identify `toStringTag` values supported by `_.clone`. */
var cloneableTags = {};
cloneableTags[argsTag] = cloneableTags[arrayTag] =
cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
cloneableTags[boolTag] = cloneableTags[dateTag] =
cloneableTags[float32Tag] = cloneableTags[float64Tag] =
cloneableTags[int8Tag] = cloneableTags[int16Tag] =
cloneableTags[int32Tag] = cloneableTags[mapTag] =
cloneableTags[numberTag] = cloneableTags[objectTag] =
cloneableTags[regexpTag] = cloneableTags[setTag] =
cloneableTags[stringTag] = cloneableTags[symbolTag] =
cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
cloneableTags[errorTag] = cloneableTags[funcTag] =
cloneableTags[weakMapTag] = false;
/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();
/** Detect free variable `exports`. */
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
/** Detect free variable `module`. */
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
/** Detect the popular CommonJS extension `module.exports`. */
var moduleExports = freeModule && freeModule.exports === freeExports;
/**
* Adds the key-value `pair` to `map`.
*
* @private
* @param {Object} map The map to modify.
* @param {Array} pair The key-value pair to add.
* @returns {Object} Returns `map`.
*/
function addMapEntry(map, pair) {
// Don't return `map.set` because it's not chainable in IE 11.
map.set(pair[0], pair[1]);
return map;
}
/**
* Adds `value` to `set`.
*
* @private
* @param {Object} set The set to modify.
* @param {*} value The value to add.
* @returns {Object} Returns `set`.
*/
function addSetEntry(set, value) {
// Don't return `set.add` because it's not chainable in IE 11.
set.add(value);
return set;
}
/**
* A specialized version of `_.forEach` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns `array`.
*/
function arrayEach(array, iteratee) {
var index = -1,
length = array ? array.length : 0;
while (++index < length) {
if (iteratee(array[index], index, array) === false) {
break;
}
}
return array;
}
/**
* Appends the elements of `values` to `array`.
*
* @private
* @param {Array} array The array to modify.
* @param {Array} values The values to append.
* @returns {Array} Returns `array`.
*/
function arrayPush(array, values) {
var index = -1,
length = values.length,
offset = array.length;
while (++index < length) {
array[offset + index] = values[index];
}
return array;
}
/**
* A specialized version of `_.reduce` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @param {*} [accumulator] The initial value.
* @param {boolean} [initAccum] Specify using the first element of `array` as
* the initial value.
* @returns {*} Returns the accumulated value.
*/
function arrayReduce(array, iteratee, accumulator, initAccum) {
var index = -1,
length = array ? array.length : 0;
if (initAccum && length) {
accumulator = array[++index];
}
while (++index < length) {
accumulator = iteratee(accumulator, array[index], index, array);
}
return accumulator;
}
/**
* The base implementation of `_.times` without support for iteratee shorthands
* or max array length checks.
*
* @private
* @param {number} n The number of times to invoke `iteratee`.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns the array of results.
*/
function baseTimes(n, iteratee) {
var index = -1,
result = Array(n);
while (++index < n) {
result[index] = iteratee(index);
}
return result;
}
/**
* Gets the value at `key` of `object`.
*
* @private
* @param {Object} [object] The object to query.
* @param {string} key The key of the property to get.
* @returns {*} Returns the property value.
*/
function getValue(object, key) {
return object == null ? undefined : object[key];
}
/**
* Checks if `value` is a host object in IE < 9.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a host object, else `false`.
*/
function isHostObject(value) {
// Many host objects are `Object` objects that can coerce to strings
// despite having improperly defined `toString` methods.
var result = false;
if (value != null && typeof value.toString != 'function') {
try {
result = !!(value + '');
} catch (e) {}
}
return result;
}
/**
* Converts `map` to its key-value pairs.
*
* @private
* @param {Object} map The map to convert.
* @returns {Array} Returns the key-value pairs.
*/
function mapToArray(map) {
var index = -1,
result = Array(map.size);
map.forEach(function(value, key) {
result[++index] = [key, value];
});
return result;
}
/**
* Creates a unary function that invokes `func` with its argument transformed.
*
* @private
* @param {Function} func The function to wrap.
* @param {Function} transform The argument transform.
* @returns {Function} Returns the new function.
*/
function overArg(func, transform) {
return function(arg) {
return func(transform(arg));
};
}
/**
* Converts `set` to an array of its values.
*
* @private
* @param {Object} set The set to convert.
* @returns {Array} Returns the values.
*/
function setToArray(set) {
var index = -1,
result = Array(set.size);
set.forEach(function(value) {
result[++index] = value;
});
return result;
}
/** Used for built-in method references. */
var arrayProto = Array.prototype,
funcProto = Function.prototype,
objectProto = Object.prototype;
/** Used to detect overreaching core-js shims. */
var coreJsData = root['__core-js_shared__'];
/** Used to detect methods masquerading as native. */
var maskSrcKey = (function() {
var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
return uid ? ('Symbol(src)_1.' + uid) : '';
}());
/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;
/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;
/**
* Used to resolve the
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
* of values.
*/
var objectToString = objectProto.toString;
/** Used to detect if a method is native. */
var reIsNative = RegExp('^' +
funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
);
/** Built-in value references. */
var Buffer = moduleExports ? root.Buffer : undefined,
Symbol = root.Symbol,
Uint8Array = root.Uint8Array,
getPrototype = overArg(Object.getPrototypeOf, Object),
objectCreate = Object.create,
propertyIsEnumerable = objectProto.propertyIsEnumerable,
splice = arrayProto.splice;
/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeGetSymbols = Object.getOwnPropertySymbols,
nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
nativeKeys = overArg(Object.keys, Object);
/* Built-in method references that are verified to be native. */
var DataView = getNative(root, 'DataView'),
Map = getNative(root, 'Map'),
Promise = getNative(root, 'Promise'),
Set = getNative(root, 'Set'),
WeakMap = getNative(root, 'WeakMap'),
nativeCreate = getNative(Object, 'create');
/** Used to detect maps, sets, and weakmaps. */
var dataViewCtorString = toSource(DataView),
mapCtorString = toSource(Map),
promiseCtorString = toSource(Promise),
setCtorString = toSource(Set),
weakMapCtorString = toSource(WeakMap);
/** Used to convert symbols to primitives and strings. */
var symbolProto = Symbol ? Symbol.prototype : undefined,
symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
/**
* Creates a hash object.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function Hash(entries) {
var index = -1,
length = entries ? entries.length : 0;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
/**
* Removes all key-value entries from the hash.
*
* @private
* @name clear
* @memberOf Hash
*/
function hashClear() {
this.__data__ = nativeCreate ? nativeCreate(null) : {};
}
/**
* Removes `key` and its value from the hash.
*
* @private
* @name delete
* @memberOf Hash
* @param {Object} hash The hash to modify.
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function hashDelete(key) {
return this.has(key) && delete this.__data__[key];
}
/**
* Gets the hash value for `key`.
*
* @private
* @name get
* @memberOf Hash
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function hashGet(key) {
var data = this.__data__;
if (nativeCreate) {
var result = data[key];
return result === HASH_UNDEFINED ? undefined : result;
}
return hasOwnProperty.call(data, key) ? data[key] : undefined;
}
/**
* Checks if a hash value for `key` exists.
*
* @private
* @name has
* @memberOf Hash
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function hashHas(key) {
var data = this.__data__;
return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
}
/**
* Sets the hash `key` to `value`.
*
* @private
* @name set
* @memberOf Hash
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the hash instance.
*/
function hashSet(key, value) {
var data = this.__data__;
data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
return this;
}
// Add methods to `Hash`.
Hash.prototype.clear = hashClear;
Hash.prototype['delete'] = hashDelete;
Hash.prototype.get = hashGet;
Hash.prototype.has = hashHas;
Hash.prototype.set = hashSet;
/**
* Creates an list cache object.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function ListCache(entries) {
var index = -1,
length = entries ? entries.length : 0;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
/**
* Removes all key-value entries from the list cache.
*
* @private
* @name clear
* @memberOf ListCache
*/
function listCacheClear() {
this.__data__ = [];
}
/**
* Removes `key` and its value from the list cache.
*
* @private
* @name delete
* @memberOf ListCache
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function listCacheDelete(key) {
var data = this.__data__,
index = assocIndexOf(data, key);
if (index < 0) {
return false;
}
var lastIndex = data.length - 1;
if (index == lastIndex) {
data.pop();
} else {
splice.call(data, index, 1);
}
return true;
}
/**
* Gets the list cache value for `key`.
*
* @private
* @name get
* @memberOf ListCache
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function listCacheGet(key) {
var data = this.__data__,
index = assocIndexOf(data, key);
return index < 0 ? undefined : data[index][1];
}
/**
* Checks if a list cache value for `key` exists.
*
* @private
* @name has
* @memberOf ListCache
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function listCacheHas(key) {
return assocIndexOf(this.__data__, key) > -1;
}
/**
* Sets the list cache `key` to `value`.
*
* @private
* @name set
* @memberOf ListCache
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the list cache instance.
*/
function listCacheSet(key, value) {
var data = this.__data__,
index = assocIndexOf(data, key);
if (index < 0) {
data.push([key, value]);
} else {
data[index][1] = value;
}
return this;
}
// Add methods to `ListCache`.
ListCache.prototype.clear = listCacheClear;
ListCache.prototype['delete'] = listCacheDelete;
ListCache.prototype.get = listCacheGet;
ListCache.prototype.has = listCacheHas;
ListCache.prototype.set = listCacheSet;
/**
* Creates a map cache object to store key-value pairs.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function MapCache(entries) {
var index = -1,
length = entries ? entries.length : 0;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
/**
* Removes all key-value entries from the map.
*
* @private
* @name clear
* @memberOf MapCache
*/
function mapCacheClear() {
this.__data__ = {
'hash': new Hash,
'map': new (Map || ListCache),
'string': new Hash
};
}
/**
* Removes `key` and its value from the map.
*
* @private
* @name delete
* @memberOf MapCache
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function mapCacheDelete(key) {
return getMapData(this, key)['delete'](key);
}
/**
* Gets the map value for `key`.
*
* @private
* @name get
* @memberOf MapCache
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function mapCacheGet(key) {
return getMapData(this, key).get(key);
}
/**
* Checks if a map value for `key` exists.
*
* @private
* @name has
* @memberOf MapCache
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function mapCacheHas(key) {
return getMapData(this, key).has(key);
}
/**
* Sets the map `key` to `value`.
*
* @private
* @name set
* @memberOf MapCache
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the map cache instance.
*/
function mapCacheSet(key, value) {
getMapData(this, key).set(key, value);
return this;
}
// Add methods to `MapCache`.
MapCache.prototype.clear = mapCacheClear;
MapCache.prototype['delete'] = mapCacheDelete;
MapCache.prototype.get = mapCacheGet;
MapCache.prototype.has = mapCacheHas;
MapCache.prototype.set = mapCacheSet;
/**
* Creates a stack cache object to store key-value pairs.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function Stack(entries) {
this.__data__ = new ListCache(entries);
}
/**
* Removes all key-value entries from the stack.
*
* @private
* @name clear
* @memberOf Stack
*/
function stackClear() {
this.__data__ = new ListCache;
}
/**
* Removes `key` and its value from the stack.
*
* @private
* @name delete
* @memberOf Stack
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function stackDelete(key) {
return this.__data__['delete'](key);
}
/**
* Gets the stack value for `key`.
*
* @private
* @name get
* @memberOf Stack
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function stackGet(key) {
return this.__data__.get(key);
}
/**
* Checks if a stack value for `key` exists.
*
* @private
* @name has
* @memberOf Stack
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function stackHas(key) {
return this.__data__.has(key);
}
/**
* Sets the stack `key` to `value`.
*
* @private
* @name set
* @memberOf Stack
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the stack cache instance.
*/
function stackSet(key, value) {
var cache = this.__data__;
if (cache instanceof ListCache) {
var pairs = cache.__data__;
if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
pairs.push([key, value]);
return this;
}
cache = this.__data__ = new MapCache(pairs);
}
cache.set(key, value);
return this;
}
// Add methods to `Stack`.
Stack.prototype.clear = stackClear;
Stack.prototype['delete'] = stackDelete;
Stack.prototype.get = stackGet;
Stack.prototype.has = stackHas;
Stack.prototype.set = stackSet;
/**
* Creates an array of the enumerable property names of the array-like `value`.
*
* @private
* @param {*} value The value to query.
* @param {boolean} inherited Specify returning inherited property names.
* @returns {Array} Returns the array of property names.
*/
function arrayLikeKeys(value, inherited) {
// Safari 8.1 makes `arguments.callee` enumerable in strict mode.
// Safari 9 makes `arguments.length` enumerable in strict mode.
var result = (isArray(value) || isArguments(value))
? baseTimes(value.length, String)
: [];
var length = result.length,
skipIndexes = !!length;
for (var key in value) {
if ((inherited || hasOwnProperty.call(value, key)) &&
!(skipIndexes && (key == 'length' || isIndex(key, length)))) {
result.push(key);
}
}
return result;
}
/**
* Assigns `value` to `key` of `object` if the existing value is not equivalent
* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/
function assignValue(object, key, value) {
var objValue = object[key];
if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
(value === undefined && !(key in object))) {
object[key] = value;
}
}
/**
* Gets the index at which the `key` is found in `array` of key-value pairs.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} key The key to search for.
* @returns {number} Returns the index of the matched value, else `-1`.
*/
function assocIndexOf(array, key) {
var length = array.length;
while (length--) {
if (eq(array[length][0], key)) {
return length;
}
}
return -1;
}
/**
* The base implementation of `_.assign` without support for multiple sources
* or `customizer` functions.
*
* @private
* @param {Object} object The destination object.
* @param {Object} source The source object.
* @returns {Object} Returns `object`.
*/
function baseAssign(object, source) {
return object && copyObject(source, keys(source), object);
}
/**
* The base implementation of `_.clone` and `_.cloneDeep` which tracks
* traversed objects.
*
* @private
* @param {*} value The value to clone.
* @param {boolean} [isDeep] Specify a deep clone.
* @param {boolean} [isFull] Specify a clone including symbols.
* @param {Function} [customizer] The function to customize cloning.
* @param {string} [key] The key of `value`.
* @param {Object} [object] The parent object of `value`.
* @param {Object} [stack] Tracks traversed objects and their clone counterparts.
* @returns {*} Returns the cloned value.
*/
function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
var result;
if (customizer) {
result = object ? customizer(value, key, object, stack) : customizer(value);
}
if (result !== undefined) {
return result;
}
if (!isObject(value)) {
return value;
}
var isArr = isArray(value);
if (isArr) {
result = initCloneArray(value);
if (!isDeep) {
return copyArray(value, result);
}
} else {
var tag = getTag(value),
isFunc = tag == funcTag || tag == genTag;
if (isBuffer(value)) {
return cloneBuffer(value, isDeep);
}
if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
if (isHostObject(value)) {
return object ? value : {};
}
result = initCloneObject(isFunc ? {} : value);
if (!isDeep) {
return copySymbols(value, baseAssign(result, value));
}
} else {
if (!cloneableTags[tag]) {
return object ? value : {};
}
result = initCloneByTag(value, tag, baseClone, isDeep);
}
}
// Check for circular references and return its corresponding clone.
stack || (stack = new Stack);
var stacked = stack.get(value);
if (stacked) {
return stacked;
}
stack.set(value, result);
if (!isArr) {
var props = isFull ? getAllKeys(value) : keys(value);
}
arrayEach(props || value, function(subValue, key) {
if (props) {
key = subValue;
subValue = value[key];
}
// Recursively populate clone (susceptible to call stack limits).
assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
});
return result;
}
/**
* The base implementation of `_.create` without support for assigning
* properties to the created object.
*
* @private
* @param {Object} prototype The object to inherit from.
* @returns {Object} Returns the new object.
*/
function baseCreate(proto) {
return isObject(proto) ? objectCreate(proto) : {};
}
/**
* The base implementation of `getAllKeys` and `getAllKeysIn` which uses
* `keysFunc` and `symbolsFunc` to get the enumerable property names and
* symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {Function} keysFunc The function to get the keys of `object`.
* @param {Function} symbolsFunc The function to get the symbols of `object`.
* @returns {Array} Returns the array of property names and symbols.
*/
function baseGetAllKeys(object, keysFunc, symbolsFunc) {
var result = keysFunc(object);
return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
}
/**
* The base implementation of `getTag`.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the `toStringTag`.
*/
function baseGetTag(value) {
return objectToString.call(value);
}
/**
* The base implementation of `_.isNative` without bad shim checks.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a native function,
* else `false`.
*/
function baseIsNative(value) {
if (!isObject(value) || isMasked(value)) {
return false;
}
var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
return pattern.test(toSource(value));
}
/**
* The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
*/
function baseKeys(object) {
if (!isPrototype(object)) {
return nativeKeys(object);
}
var result = [];
for (var key in Object(object)) {
if (hasOwnProperty.call(object, key) && key != 'constructor') {
result.push(key);
}
}
return result;
}
/**
* Creates a clone of `buffer`.
*
* @private
* @param {Buffer} buffer The buffer to clone.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Buffer} Returns the cloned buffer.
*/
function cloneBuffer(buffer, isDeep) {
if (isDeep) {
return buffer.slice();
}
var result = new buffer.constructor(buffer.length);
buffer.copy(result);
return result;
}
/**
* Creates a clone of `arrayBuffer`.
*
* @private
* @param {ArrayBuffer} arrayBuffer The array buffer to clone.
* @returns {ArrayBuffer} Returns the cloned array buffer.
*/
function cloneArrayBuffer(arrayBuffer) {
var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
new Uint8Array(result).set(new Uint8Array(arrayBuffer));
return result;
}
/**
* Creates a clone of `dataView`.
*
* @private
* @param {Object} dataView The data view to clone.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Object} Returns the cloned data view.
*/
function cloneDataView(dataView, isDeep) {
var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
}
/**
* Creates a clone of `map`.
*
* @private
* @param {Object} map The map to clone.
* @param {Function} cloneFunc The function to clone values.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Object} Returns the cloned map.
*/
function cloneMap(map, isDeep, cloneFunc) {
var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);
return arrayReduce(array, addMapEntry, new map.constructor);
}
/**
* Creates a clone of `regexp`.
*
* @private
* @param {Object} regexp The regexp to clone.
* @returns {Object} Returns the cloned regexp.
*/
function cloneRegExp(regexp) {
var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
result.lastIndex = regexp.lastIndex;
return result;
}
/**
* Creates a clone of `set`.
*
* @private
* @param {Object} set The set to clone.
* @param {Function} cloneFunc The function to clone values.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Object} Returns the cloned set.
*/
function cloneSet(set, isDeep, cloneFunc) {
var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);
return arrayReduce(array, addSetEntry, new set.constructor);
}
/**
* Creates a clone of the `symbol` object.
*
* @private
* @param {Object} symbol The symbol object to clone.
* @returns {Object} Returns the cloned symbol object.
*/
function cloneSymbol(symbol) {
return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
}
/**
* Creates a clone of `typedArray`.
*
* @private
* @param {Object} typedArray The typed array to clone.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Object} Returns the cloned typed array.
*/
function cloneTypedArray(typedArray, isDeep) {
var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
}
/**
* Copies the values of `source` to `array`.
*
* @private
* @param {Array} source The array to copy values from.
* @param {Array} [array=[]] The array to copy values to.
* @returns {Array} Returns `array`.
*/
function copyArray(source, array) {
var index = -1,
length = source.length;
array || (array = Array(length));
while (++index < length) {
array[index] = source[index];
}
return array;
}
/**
* Copies properties of `source` to `object`.
*
* @private
* @param {Object} source The object to copy properties from.
* @param {Array} props The property identifiers to copy.
* @param {Object} [object={}] The object to copy properties to.
* @param {Function} [customizer] The function to customize copied values.
* @returns {Object} Returns `object`.
*/
function copyObject(source, props, object, customizer) {
object || (object = {});
var index = -1,
length = props.length;
while (++index < length) {
var key = props[index];
var newValue = customizer
? customizer(object[key], source[key], key, object, source)
: undefined;
assignValue(object, key, newValue === undefined ? source[key] : newValue);
}
return object;
}
/**
* Copies own symbol properties of `source` to `object`.
*
* @private
* @param {Object} source The object to copy symbols from.
* @param {Object} [object={}] The object to copy symbols to.
* @returns {Object} Returns `object`.
*/
function copySymbols(source, object) {
return copyObject(source, getSymbols(source), object);
}
/**
* Creates an array of own enumerable property names and symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names and symbols.
*/
function getAllKeys(object) {
return baseGetAllKeys(object, keys, getSymbols);
}
/**
* Gets the data for `map`.
*
* @private
* @param {Object} map The map to query.
* @param {string} key The reference key.
* @returns {*} Returns the map data.
*/
function getMapData(map, key) {
var data = map.__data__;
return isKeyable(key)
? data[typeof key == 'string' ? 'string' : 'hash']
: data.map;
}
/**
* Gets the native function at `key` of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {string} key The key of the method to get.
* @returns {*} Returns the function if it's native, else `undefined`.
*/
function getNative(object, key) {
var value = getValue(object, key);
return baseIsNative(value) ? value : undefined;
}
/**
* Creates an array of the own enumerable symbol properties of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of symbols.
*/
var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
/**
* Gets the `toStringTag` of `value`.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the `toStringTag`.
*/
var getTag = baseGetTag;
// Fallback for data views, maps, sets, and weak maps in IE 11,
// for data views in Edge < 14, and promises in Node.js.
if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
(Map && getTag(new Map) != mapTag) ||
(Promise && getTag(Promise.resolve()) != promiseTag) ||
(Set && getTag(new Set) != setTag) ||
(WeakMap && getTag(new WeakMap) != weakMapTag)) {
getTag = function(value) {
var result = objectToString.call(value),
Ctor = result == objectTag ? value.constructor : undefined,
ctorString = Ctor ? toSource(Ctor) : undefined;
if (ctorString) {
switch (ctorString) {
case dataViewCtorString: return dataViewTag;
case mapCtorSt