Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/npm/cli.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/node_modules/yargs-parser
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/yargs-parser')
-rw-r--r--node_modules/yargs-parser/CHANGELOG.md209
-rw-r--r--node_modules/yargs-parser/README.md128
-rw-r--r--node_modules/yargs-parser/index.js349
-rw-r--r--node_modules/yargs-parser/lib/tokenize-arg-string.js6
-rw-r--r--node_modules/yargs-parser/node_modules/camelcase/index.d.ts63
-rw-r--r--node_modules/yargs-parser/node_modules/camelcase/index.js76
-rw-r--r--node_modules/yargs-parser/node_modules/camelcase/license9
-rw-r--r--node_modules/yargs-parser/node_modules/camelcase/package.json75
-rw-r--r--node_modules/yargs-parser/node_modules/camelcase/readme.md99
-rw-r--r--node_modules/yargs-parser/package.json40
10 files changed, 927 insertions, 127 deletions
diff --git a/node_modules/yargs-parser/CHANGELOG.md b/node_modules/yargs-parser/CHANGELOG.md
index a0186f233..18ed4b34c 100644
--- a/node_modules/yargs-parser/CHANGELOG.md
+++ b/node_modules/yargs-parser/CHANGELOG.md
@@ -1,7 +1,214 @@
-# Change Log
+# Changelog
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+## [15.0.0](https://github.com/yargs/yargs-parser/compare/v14.0.0...v15.0.0) (2019-10-07)
+
+
+### Features
+
+* rework `collect-unknown-options` into `unknown-options-as-args`, providing more comprehensive functionality ([ef771ca](https://github.com/yargs/yargs-parser/commit/ef771ca))
+
+
+### BREAKING CHANGES
+
+* rework `collect-unknown-options` into `unknown-options-as-args`, providing more comprehensive functionality
+
+
+
+## [14.0.0](https://github.com/yargs/yargs-parser/compare/v13.1.1...v14.0.0) (2019-09-06)
+
+
+### Bug Fixes
+
+* boolean arrays with default values ([#185](https://github.com/yargs/yargs-parser/issues/185)) ([7d42572](https://github.com/yargs/yargs-parser/commit/7d42572))
+* boolean now behaves the same as other array types ([#184](https://github.com/yargs/yargs-parser/issues/184)) ([17ca3bd](https://github.com/yargs/yargs-parser/commit/17ca3bd))
+* eatNargs() for 'opt.narg === 0' and boolean typed options ([#188](https://github.com/yargs/yargs-parser/issues/188)) ([c5a1db0](https://github.com/yargs/yargs-parser/commit/c5a1db0))
+* maybeCoerceNumber now takes precedence over coerce return value ([#182](https://github.com/yargs/yargs-parser/issues/182)) ([2f26436](https://github.com/yargs/yargs-parser/commit/2f26436))
+* take into account aliases when appending arrays from config object ([#199](https://github.com/yargs/yargs-parser/issues/199)) ([f8a2d3f](https://github.com/yargs/yargs-parser/commit/f8a2d3f))
+
+
+### Features
+
+* add configuration option to "collect-unknown-options" ([#181](https://github.com/yargs/yargs-parser/issues/181)) ([7909cc4](https://github.com/yargs/yargs-parser/commit/7909cc4))
+* maybeCoerceNumber() now takes into account arrays ([#187](https://github.com/yargs/yargs-parser/issues/187)) ([31c204b](https://github.com/yargs/yargs-parser/commit/31c204b))
+
+
+### BREAKING CHANGES
+
+* unless "parse-numbers" is set to "false", arrays of numeric strings are now parsed as numbers, rather than strings.
+* we have dropped the broken "defaulted" functionality; we would like to revisit adding this in the future.
+* maybeCoerceNumber now takes precedence over coerce return value (#182)
+
+
+
+### [13.1.1](https://www.github.com/yargs/yargs-parser/compare/v13.1.0...v13.1.1) (2019-06-10)
+
+
+### Bug Fixes
+
+* convert values to strings when tokenizing ([#167](https://www.github.com/yargs/yargs-parser/issues/167)) ([57b7883](https://www.github.com/yargs/yargs-parser/commit/57b7883))
+* nargs should allow duplicates when duplicate-arguments-array=false ([#164](https://www.github.com/yargs/yargs-parser/issues/164)) ([47ccb0b](https://www.github.com/yargs/yargs-parser/commit/47ccb0b))
+* should populate "_" when given config with "short-option-groups" false ([#179](https://www.github.com/yargs/yargs-parser/issues/179)) ([6055974](https://www.github.com/yargs/yargs-parser/commit/6055974))
+
+## [13.1.0](https://github.com/yargs/yargs-parser/compare/v13.0.0...v13.1.0) (2019-05-05)
+
+
+### Features
+
+* add `strip-aliased` and `strip-dashed` configuration options. ([#172](https://github.com/yargs/yargs-parser/issues/172)) ([a3936aa](https://github.com/yargs/yargs-parser/commit/a3936aa))
+* support boolean which do not consume next argument. ([#171](https://github.com/yargs/yargs-parser/issues/171)) ([0ae7fcb](https://github.com/yargs/yargs-parser/commit/0ae7fcb))
+
+
+
+<a name="13.0.0"></a>
+# [13.0.0](https://github.com/yargs/yargs-parser/compare/v12.0.0...v13.0.0) (2019-02-02)
+
+
+### Features
+
+* don't coerce number from string with leading '0' or '+' ([#158](https://github.com/yargs/yargs-parser/issues/158)) ([18d0fd5](https://github.com/yargs/yargs-parser/commit/18d0fd5))
+
+
+### BREAKING CHANGES
+
+* options with leading '+' or '0' now parse as strings
+
+
+
+<a name="12.0.0"></a>
+# [12.0.0](https://github.com/yargs/yargs-parser/compare/v11.1.1...v12.0.0) (2019-01-29)
+
+
+### Bug Fixes
+
+* better handling of quoted strings ([#153](https://github.com/yargs/yargs-parser/issues/153)) ([2fb71b2](https://github.com/yargs/yargs-parser/commit/2fb71b2))
+
+
+### Features
+
+* default value is now used if no right-hand value provided for numbers/strings ([#156](https://github.com/yargs/yargs-parser/issues/156)) ([5a7c46a](https://github.com/yargs/yargs-parser/commit/5a7c46a))
+
+
+### BREAKING CHANGES
+
+* a flag with no right-hand value no longer populates defaulted options with `undefined`.
+* quotes at beginning and endings of strings are not removed during parsing.
+
+
+
+<a name="11.1.1"></a>
+## [11.1.1](https://github.com/yargs/yargs-parser/compare/v11.1.0...v11.1.1) (2018-11-19)
+
+
+### Bug Fixes
+
+* ensure empty string is added into argv._ ([#140](https://github.com/yargs/yargs-parser/issues/140)) ([79cda98](https://github.com/yargs/yargs-parser/commit/79cda98))
+
+
+### Reverts
+
+* make requiresArg work in conjunction with arrays ([#136](https://github.com/yargs/yargs-parser/issues/136)) ([f4a3063](https://github.com/yargs/yargs-parser/commit/f4a3063))
+
+
+
+<a name="11.1.0"></a>
+# [11.1.0](https://github.com/yargs/yargs-parser/compare/v11.0.0...v11.1.0) (2018-11-10)
+
+
+### Bug Fixes
+
+* handling of one char alias ([#139](https://github.com/yargs/yargs-parser/issues/139)) ([ee56e31](https://github.com/yargs/yargs-parser/commit/ee56e31))
+
+
+### Features
+
+* add halt-at-non-option configuration option ([#130](https://github.com/yargs/yargs-parser/issues/130)) ([a849fce](https://github.com/yargs/yargs-parser/commit/a849fce))
+
+
+
+<a name="11.0.0"></a>
+# [11.0.0](https://github.com/yargs/yargs-parser/compare/v10.1.0...v11.0.0) (2018-10-06)
+
+
+### Bug Fixes
+
+* flatten-duplicate-arrays:false for more than 2 arrays ([#128](https://github.com/yargs/yargs-parser/issues/128)) ([2bc395f](https://github.com/yargs/yargs-parser/commit/2bc395f))
+* hyphenated flags combined with dot notation broke parsing ([#131](https://github.com/yargs/yargs-parser/issues/131)) ([dc788da](https://github.com/yargs/yargs-parser/commit/dc788da))
+* make requiresArg work in conjunction with arrays ([#136](https://github.com/yargs/yargs-parser/issues/136)) ([77ae1d4](https://github.com/yargs/yargs-parser/commit/77ae1d4))
+
+
+### Chores
+
+* update dependencies ([6dc42a1](https://github.com/yargs/yargs-parser/commit/6dc42a1))
+
+
+### Features
+
+* also add camelCase array options ([#125](https://github.com/yargs/yargs-parser/issues/125)) ([08c0117](https://github.com/yargs/yargs-parser/commit/08c0117))
+* array.type can now be provided, supporting coercion ([#132](https://github.com/yargs/yargs-parser/issues/132)) ([4b8cfce](https://github.com/yargs/yargs-parser/commit/4b8cfce))
+
+
+### BREAKING CHANGES
+
+* drops Node 4 support
+* the argv object is now populated differently (correctly) when hyphens and dot notation are used in conjunction.
+
+
+
+<a name="10.1.0"></a>
+# [10.1.0](https://github.com/yargs/yargs-parser/compare/v10.0.0...v10.1.0) (2018-06-29)
+
+
+### Features
+
+* add `set-placeholder-key` configuration ([#123](https://github.com/yargs/yargs-parser/issues/123)) ([19386ee](https://github.com/yargs/yargs-parser/commit/19386ee))
+
+
+
+<a name="10.0.0"></a>
+# [10.0.0](https://github.com/yargs/yargs-parser/compare/v9.0.2...v10.0.0) (2018-04-04)
+
+
+### Bug Fixes
+
+* do not set boolean flags if not defined in `argv` ([#119](https://github.com/yargs/yargs-parser/issues/119)) ([f6e6599](https://github.com/yargs/yargs-parser/commit/f6e6599))
+
+
+### BREAKING CHANGES
+
+* `boolean` flags defined without a `default` value will now behave like other option type and won't be set in the parsed results when the user doesn't set the corresponding CLI arg.
+
+Previous behavior:
+```js
+var parse = require('yargs-parser');
+
+parse('--flag', {boolean: ['flag']});
+// => { _: [], flag: true }
+
+parse('--no-flag', {boolean: ['flag']});
+// => { _: [], flag: false }
+
+parse('', {boolean: ['flag']});
+// => { _: [], flag: false }
+```
+
+New behavior:
+```js
+var parse = require('yargs-parser');
+
+parse('--flag', {boolean: ['flag']});
+// => { _: [], flag: true }
+
+parse('--no-flag', {boolean: ['flag']});
+// => { _: [], flag: false }
+
+parse('', {boolean: ['flag']});
+// => { _: [] } => flag not set similarly to other option type
+```
+
+
+
<a name="9.0.2"></a>
## [9.0.2](https://github.com/yargs/yargs-parser/compare/v9.0.1...v9.0.2) (2018-01-20)
diff --git a/node_modules/yargs-parser/README.md b/node_modules/yargs-parser/README.md
index 6d6d0d4c9..5f1ccb987 100644
--- a/node_modules/yargs-parser/README.md
+++ b/node_modules/yargs-parser/README.md
@@ -1,9 +1,8 @@
# yargs-parser
-[![Build Status](https://travis-ci.org/yargs/yargs-parser.png)](https://travis-ci.org/yargs/yargs-parser)
+[![Build Status](https://travis-ci.org/yargs/yargs-parser.svg)](https://travis-ci.org/yargs/yargs-parser)
[![Coverage Status](https://coveralls.io/repos/yargs/yargs-parser/badge.svg?branch=)](https://coveralls.io/r/yargs/yargs-parser?branch=master)
[![NPM version](https://img.shields.io/npm/v/yargs-parser.svg)](https://www.npmjs.com/package/yargs-parser)
-[![Windows Tests](https://img.shields.io/appveyor/ci/bcoe/yargs-parser/master.svg?label=Windows%20Tests)](https://ci.appveyor.com/project/bcoe/yargs-parser)
[![Standard Version](https://img.shields.io/badge/release-standard%20version-brightgreen.svg)](https://github.com/conventional-changelog/standard-version)
@@ -32,7 +31,7 @@ node example.js --foo=33 --bar hello
_or parse a string!_
```js
-var argv = require('./')('--foo=99 --bar=33')
+var argv = require('yargs-parser')('--foo=99 --bar=33')
console.log(argv)
```
@@ -59,20 +58,24 @@ Parses command line arguments returning a simple mapping of keys and values.
* `args`: a string or array of strings representing the options to parse.
* `opts`: provide a set of hints indicating how `args` should be parsed:
* `opts.alias`: an object representing the set of aliases for a key: `{alias: {foo: ['f']}}`.
- * `opts.array`: indicate that keys should be parsed as an array: `{array: ['foo', 'bar']}`.
+ * `opts.array`: indicate that keys should be parsed as an array: `{array: ['foo', 'bar']}`.<br>
+ Indicate that keys should be parsed as an array and coerced to booleans / numbers:<br>
+ `{array: [{ key: 'foo', boolean: true }, {key: 'bar', number: true}]}`.
* `opts.boolean`: arguments should be parsed as booleans: `{boolean: ['x', 'y']}`.
- * `opts.config`: indicate a key that represents a path to a configuration file (this file will be loaded and parsed).
* `opts.coerce`: provide a custom synchronous function that returns a coerced value from the argument provided
- (or throws an error), e.g. `{coerce: {foo: function (arg) {return modifiedArg}}}`.
+ (or throws an error). For arrays the function is called only once for the entire array:<br>
+ `{coerce: {foo: function (arg) {return modifiedArg}}}`.
+ * `opts.config`: indicate a key that represents a path to a configuration file (this file will be loaded and parsed).
+ * `opts.configObjects`: configuration objects to parse, their properties will be set as arguments:<br>
+ `{configObjects: [{'x': 5, 'y': 33}, {'z': 44}]}`.
+ * `opts.configuration`: provide configuration options to the yargs-parser (see: [configuration](#configuration)).
* `opts.count`: indicate a key that should be used as a counter, e.g., `-vvv` = `{v: 3}`.
* `opts.default`: provide default values for keys: `{default: {x: 33, y: 'hello world!'}}`.
* `opts.envPrefix`: environment variables (`process.env`) with the prefix provided should be parsed.
* `opts.narg`: specify that a key requires `n` arguments: `{narg: {x: 2}}`.
* `opts.normalize`: `path.normalize()` will be applied to values set to this key.
- * `opts.string`: keys should be treated as strings (even if they resemble a number `-x 33`).
- * `opts.configuration`: provide configuration options to the yargs-parser (see: [configuration](#configuration)).
* `opts.number`: keys should be treated as numbers.
- * `opts['--']`: arguments after the end-of-options flag `--` will be set to the `argv.['--']` array instead of being set to the `argv._` array.
+ * `opts.string`: keys should be treated as strings (even if they resemble a number `-x 33`).
**returns:**
@@ -298,6 +301,113 @@ node example.js a -b -- x y
{ _: [ 'a' ], '--': [ 'x', 'y' ], b: true }
```
+### set placeholder key
+
+* default: `false`.
+* key: `set-placeholder-key`.
+
+Should a placeholder be added for keys not set via the corresponding CLI argument?
+
+_If disabled:_
+
+```sh
+node example.js -a 1 -c 2
+{ _: [], a: 1, c: 2 }
+```
+
+_If enabled:_
+
+```sh
+node example.js -a 1 -c 2
+{ _: [], a: 1, b: undefined, c: 2 }
+```
+
+### halt at non-option
+
+* default: `false`.
+* key: `halt-at-non-option`.
+
+Should parsing stop at the first positional argument? This is similar to how e.g. `ssh` parses its command line.
+
+_If disabled:_
+
+```sh
+node example.js -a run b -x y
+{ _: [ 'b' ], a: 'run', x: 'y' }
+```
+
+_If enabled:_
+
+```sh
+node example.js -a run b -x y
+{ _: [ 'b', '-x', 'y' ], a: 'run' }
+```
+
+### strip aliased
+
+* default: `false`
+* key: `strip-aliased`
+
+Should aliases be removed before returning results?
+
+_If disabled:_
+
+```sh
+node example.js --test-field 1
+{ _: [], 'test-field': 1, testField: 1, 'test-alias': 1, testAlias: 1 }
+```
+
+_If enabled:_
+
+```sh
+node example.js --test-field 1
+{ _: [], 'test-field': 1, testField: 1 }
+```
+
+### strip dashed
+
+* default: `false`
+* key: `strip-dashed`
+
+Should dashed keys be removed before returning results? This option has no effect if
+`camel-case-expansion` is disabled.
+
+_If disabled:_
+
+```sh
+node example.js --test-field 1
+{ _: [], 'test-field': 1, testField: 1 }
+```
+
+_If enabled:_
+
+```sh
+node example.js --test-field 1
+{ _: [], testField: 1 }
+```
+
+### unknown options as args
+
+* default: `false`
+* key: `unknown-options-as-args`
+
+Should unknown options be treated like regular arguments? An unknown option is one that is not
+configured in `opts`.
+
+_If disabled_
+
+```sh
+node example.js --unknown-option --known-option 2 --string-option --unknown-option2
+{ _: [], unknownOption: true, knownOption: 2, stringOption: '', unknownOption2: true }
+```
+
+_If enabled_
+
+```sh
+node example.js --unknown-option --known-option 2 --string-option --unknown-option2
+{ _: ['--unknown-option'], knownOption: 2, stringOption: '--unknown-option2' }
+```
+
## Special Thanks
The yargs project evolves from optimist and minimist. It owes its
diff --git a/node_modules/yargs-parser/index.js b/node_modules/yargs-parser/index.js
index d39414b73..726855321 100644
--- a/node_modules/yargs-parser/index.js
+++ b/node_modules/yargs-parser/index.js
@@ -1,4 +1,5 @@
var camelCase = require('camelcase')
+var decamelize = require('decamelize')
var path = require('path')
var tokenizeArgString = require('./lib/tokenize-arg-string')
var util = require('util')
@@ -8,9 +9,10 @@ function parse (args, opts) {
// allow a string argument to be passed in rather
// than an argv array.
args = tokenizeArgString(args)
+
// aliases might have transitive relationships, normalize this.
var aliases = combineAliases(opts.alias || {})
- var configuration = assign({
+ var configuration = Object.assign({
'short-option-groups': true,
'camel-case-expansion': true,
'dot-notation': true,
@@ -20,7 +22,12 @@ function parse (args, opts) {
'duplicate-arguments-array': true,
'flatten-duplicate-arrays': true,
'populate--': false,
- 'combine-arrays': false
+ 'combine-arrays': false,
+ 'set-placeholder-key': false,
+ 'halt-at-non-option': false,
+ 'strip-aliased': false,
+ 'strip-dashed': false,
+ 'unknown-options-as-args': false
}, opts.configuration)
var defaults = opts.default || {}
var configObjects = opts.configObjects || []
@@ -29,9 +36,7 @@ function parse (args, opts) {
var notFlagsArgv = notFlagsOption ? '--' : '_'
var newAliases = {}
// allow a i18n handler to be passed in, default to a fake one (util.format).
- var __ = opts.__ || function (str) {
- return util.format.apply(util, Array.prototype.slice.call(arguments))
- }
+ var __ = opts.__ || util.format
var error = null
var flags = {
aliases: {},
@@ -42,43 +47,67 @@ function parse (args, opts) {
counts: {},
normalize: {},
configs: {},
- defaulted: {},
nargs: {},
- coercions: {}
+ coercions: {},
+ keys: []
}
var negative = /^-[0-9]+(\.[0-9]+)?/
var negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)')
- ;[].concat(opts.array).filter(Boolean).forEach(function (key) {
+ ;[].concat(opts.array).filter(Boolean).forEach(function (opt) {
+ var key = opt.key || opt
+
+ // assign to flags[bools|strings|numbers]
+ const assignment = Object.keys(opt).map(function (key) {
+ return ({
+ boolean: 'bools',
+ string: 'strings',
+ number: 'numbers'
+ })[key]
+ }).filter(Boolean).pop()
+
+ // assign key to be coerced
+ if (assignment) {
+ flags[assignment][key] = true
+ }
+
flags.arrays[key] = true
+ flags.keys.push(key)
})
;[].concat(opts.boolean).filter(Boolean).forEach(function (key) {
flags.bools[key] = true
+ flags.keys.push(key)
})
;[].concat(opts.string).filter(Boolean).forEach(function (key) {
flags.strings[key] = true
+ flags.keys.push(key)
})
;[].concat(opts.number).filter(Boolean).forEach(function (key) {
flags.numbers[key] = true
+ flags.keys.push(key)
})
;[].concat(opts.count).filter(Boolean).forEach(function (key) {
flags.counts[key] = true
+ flags.keys.push(key)
})
;[].concat(opts.normalize).filter(Boolean).forEach(function (key) {
flags.normalize[key] = true
+ flags.keys.push(key)
})
Object.keys(opts.narg || {}).forEach(function (k) {
flags.nargs[k] = opts.narg[k]
+ flags.keys.push(k)
})
Object.keys(opts.coerce || {}).forEach(function (k) {
flags.coercions[k] = opts.coerce[k]
+ flags.keys.push(k)
})
if (Array.isArray(opts.config) || typeof opts.config === 'string') {
@@ -103,17 +132,7 @@ function parse (args, opts) {
})
var argv = { _: [] }
-
- Object.keys(flags.bools).forEach(function (key) {
- setArg(key, !(key in defaults) ? false : defaults[key])
- setDefaulted(key)
- })
-
var notFlags = []
- if (args.indexOf('--') !== -1) {
- notFlags = args.slice(args.indexOf('--') + 1)
- args = args.slice(0, args.indexOf('--'))
- }
for (var i = 0; i < args.length; i++) {
var arg = args[i]
@@ -124,8 +143,10 @@ function parse (args, opts) {
var next
var value
- // -- seperated by =
- if (arg.match(/^--.+=/) || (
+ if (isUnknownOptionAsArg(arg)) {
+ argv._.push(arg)
+ // -- separated by =
+ } else if (arg.match(/^--.+=/) || (
!configuration['short-option-groups'] && arg.match(/^-.+=/)
)) {
// Using [\s\S] instead of . because js doesn't support the
@@ -138,7 +159,7 @@ function parse (args, opts) {
args.splice(i + 1, 0, m[2])
i = eatNargs(i, m[1], args)
// arrays format = '--f=a b c'
- } else if (checkAllAliases(m[1], flags.arrays) && args.length > i + 1) {
+ } else if (checkAllAliases(m[1], flags.arrays)) {
args.splice(i + 1, 0, m[2])
i = eatArray(i, m[1], args)
} else {
@@ -146,19 +167,20 @@ function parse (args, opts) {
}
} else if (arg.match(negatedBoolean) && configuration['boolean-negation']) {
key = arg.match(negatedBoolean)[1]
- setArg(key, false)
+ setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false)
- // -- seperated by space.
+ // -- separated by space.
} else if (arg.match(/^--.+/) || (
- !configuration['short-option-groups'] && arg.match(/^-.+/)
+ !configuration['short-option-groups'] && arg.match(/^-[^-]+/)
)) {
key = arg.match(/^--?(.+)/)[1]
// nargs format = '--foo a b c'
- if (checkAllAliases(key, flags.nargs)) {
+ // should be truthy even if: flags.nargs[key] === 0
+ if (checkAllAliases(key, flags.nargs) !== false) {
i = eatNargs(i, key, args)
// array format = '--foo a b c'
- } else if (checkAllAliases(key, flags.arrays) && args.length > i + 1) {
+ } else if (checkAllAliases(key, flags.arrays)) {
i = eatArray(i, key, args)
} else {
next = args[i + 1]
@@ -173,16 +195,16 @@ function parse (args, opts) {
setArg(key, next)
i++
} else {
- setArg(key, defaultForType(guessType(key, flags)))
+ setArg(key, defaultValue(key))
}
}
- // dot-notation flag seperated by '='.
+ // dot-notation flag separated by '='.
} else if (arg.match(/^-.\..+=/)) {
m = arg.match(/^-([^=]+)=([\s\S]*)$/)
setArg(m[1], m[2])
- // dot-notation flag seperated by space.
+ // dot-notation flag separated by space.
} else if (arg.match(/^-.\..+/)) {
next = args[i + 1]
key = arg.match(/^-(.\..+)/)[1]
@@ -193,7 +215,7 @@ function parse (args, opts) {
setArg(key, next)
i++
} else {
- setArg(key, defaultForType(guessType(key, flags)))
+ setArg(key, defaultValue(key))
}
} else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
letters = arg.slice(1, -1).split('')
@@ -211,7 +233,7 @@ function parse (args, opts) {
args.splice(i + 1, 0, value)
i = eatNargs(i, key, args)
// array format = '-f=a b c'
- } else if (checkAllAliases(key, flags.arrays) && args.length > i + 1) {
+ } else if (checkAllAliases(key, flags.arrays)) {
args.splice(i + 1, 0, value)
i = eatArray(i, key, args)
} else {
@@ -240,7 +262,7 @@ function parse (args, opts) {
broken = true
break
} else {
- setArg(letters[j], defaultForType(guessType(letters[j], flags)))
+ setArg(letters[j], defaultValue(letters[j]))
}
}
@@ -248,10 +270,11 @@ function parse (args, opts) {
if (!broken && key !== '-') {
// nargs format = '-f a b c'
- if (checkAllAliases(key, flags.nargs)) {
+ // should be truthy even if: flags.nargs[key] === 0
+ if (checkAllAliases(key, flags.nargs) !== false) {
i = eatNargs(i, key, args)
// array format = '-f a b c'
- } else if (checkAllAliases(key, flags.arrays) && args.length > i + 1) {
+ } else if (checkAllAliases(key, flags.arrays)) {
i = eatArray(i, key, args)
} else {
next = args[i + 1]
@@ -266,10 +289,16 @@ function parse (args, opts) {
setArg(key, next)
i++
} else {
- setArg(key, defaultForType(guessType(key, flags)))
+ setArg(key, defaultValue(key))
}
}
}
+ } else if (arg === '--') {
+ notFlags = args.slice(i + 1)
+ break
+ } else if (configuration['halt-at-non-option']) {
+ notFlags = args.slice(i)
+ break
} else {
argv._.push(maybeCoerceNumber('_', arg))
}
@@ -287,6 +316,7 @@ function parse (args, opts) {
setConfigObjects()
applyDefaultsAndAliases(argv, flags.aliases, defaults)
applyCoercions(argv)
+ if (configuration['set-placeholder-key']) setPlaceholderKeys(argv)
// for any counts either not in args or without an explicit default, set to 0
Object.keys(flags.counts).forEach(function (key) {
@@ -299,17 +329,39 @@ function parse (args, opts) {
argv[notFlagsArgv].push(key)
})
+ if (configuration['camel-case-expansion'] && configuration['strip-dashed']) {
+ Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => {
+ delete argv[key]
+ })
+ }
+
+ if (configuration['strip-aliased']) {
+ // XXX Switch to [].concat(...Object.values(aliases)) once node.js 6 is dropped
+ ;[].concat(...Object.keys(aliases).map(k => aliases[k])).forEach(alias => {
+ if (configuration['camel-case-expansion']) {
+ delete argv[alias.split('.').map(prop => camelCase(prop)).join('.')]
+ }
+
+ delete argv[alias]
+ })
+ }
+
// how many arguments should we consume, based
// on the nargs option?
function eatNargs (i, key, args) {
var ii
const toEat = checkAllAliases(key, flags.nargs)
+ if (toEat === 0) {
+ setArg(key, defaultValue(key))
+ return i
+ }
+
// nargs will not consume flag arguments, e.g., -abc, --foo,
// and terminates when one is observed.
var available = 0
for (ii = i + 1; ii < args.length; ii++) {
- if (!args[ii].match(/^-[^0-9]/)) available++
+ if (!args[ii].match(/^-[^0-9]/) || isUnknownOptionAsArg(args[ii])) available++
else break
}
@@ -327,38 +379,36 @@ function parse (args, opts) {
// following it... YUM!
// e.g., --foo apple banana cat becomes ["apple", "banana", "cat"]
function eatArray (i, key, args) {
- var start = i + 1
- var argsToSet = []
- var multipleArrayFlag = i > 0
- for (var ii = i + 1; ii < args.length; ii++) {
- if (/^-/.test(args[ii]) && !negative.test(args[ii])) {
- if (ii === start) {
- setArg(key, defaultForType('array'))
- }
- multipleArrayFlag = true
- break
+ let argsToSet = []
+ let next = args[i + 1]
+
+ if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) {
+ argsToSet.push(true)
+ } else if (isUndefined(next) || (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))) {
+ // for keys without value ==> argsToSet remains an empty []
+ // set user default value, if available
+ if (defaults.hasOwnProperty(key)) {
+ argsToSet.push(defaults[key])
}
- i = ii
- argsToSet.push(args[ii])
- }
- if (multipleArrayFlag) {
- setArg(key, argsToSet.map(function (arg) {
- return processValue(key, arg)
- }))
} else {
- argsToSet.forEach(function (arg) {
- setArg(key, arg)
- })
+ for (var ii = i + 1; ii < args.length; ii++) {
+ next = args[ii]
+ if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) break
+ i = ii
+ argsToSet.push(processValue(key, next))
+ }
}
+ setArg(key, argsToSet)
return i
}
function setArg (key, val) {
- unsetDefaulted(key)
-
if (/-/.test(key) && configuration['camel-case-expansion']) {
- addNewAlias(key, camelCase(key))
+ var alias = key.split('.').map(function (prop) {
+ return camelCase(prop)
+ }).join('.')
+ addNewAlias(key, alias)
}
var value = processValue(key, val)
@@ -367,7 +417,7 @@ function parse (args, opts) {
setKey(argv, splitKey, value)
// handle populating aliases of the full key
- if (flags.aliases[key]) {
+ if (flags.aliases[key] && flags.aliases[key].forEach) {
flags.aliases[key].forEach(function (x) {
x = x.split('.')
setKey(argv, x, value)
@@ -414,12 +464,22 @@ function parse (args, opts) {
}
function processValue (key, val) {
+ // strings may be quoted, clean this up as we assign values.
+ if (typeof val === 'string' &&
+ (val[0] === "'" || val[0] === '"') &&
+ val[val.length - 1] === val[0]
+ ) {
+ val = val.substring(1, val.length - 1)
+ }
+
// handle parsing boolean arguments --foo=true --bar false.
if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
if (typeof val === 'string') val = val === 'true'
}
- var value = maybeCoerceNumber(key, val)
+ var value = Array.isArray(val)
+ ? val.map(function (v) { return maybeCoerceNumber(key, v) })
+ : maybeCoerceNumber(key, val)
// increment a count given as arg (either no value or value parsed as boolean)
if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
@@ -435,7 +495,7 @@ function parse (args, opts) {
}
function maybeCoerceNumber (key, value) {
- if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.coercions)) {
+ if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {
const shouldCoerceNumber = isNumber(value) && configuration['parse-numbers'] && (
Number.isSafeInteger(Math.floor(value))
)
@@ -498,7 +558,7 @@ function parse (args, opts) {
} else {
// setting arguments via CLI takes precedence over
// values within the config file.
- if (!hasKey(argv, fullKey.split('.')) || (flags.defaulted[fullKey]) || (flags.arrays[fullKey] && configuration['combine-arrays'])) {
+ if (!hasKey(argv, fullKey.split('.')) || (checkAllAliases(fullKey, flags.arrays) && configuration['combine-arrays'])) {
setArg(fullKey, value)
}
}
@@ -527,7 +587,7 @@ function parse (args, opts) {
return camelCase(key)
})
- if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && (!hasKey(argv, keys) || flags.defaulted[keys.join('.')])) {
+ if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && !hasKey(argv, keys)) {
setArg(keys.join('.'), process.env[envVar])
}
}
@@ -542,7 +602,7 @@ function parse (args, opts) {
coerce = checkAllAliases(key, flags.coercions)
if (typeof coerce === 'function') {
try {
- var value = coerce(argv[key])
+ var value = maybeCoerceNumber(key, coerce(argv[key]))
;([].concat(flags.aliases[key] || [], key)).forEach(ali => {
applied[ali] = argv[ali] = value
})
@@ -554,6 +614,15 @@ function parse (args, opts) {
})
}
+ function setPlaceholderKeys (argv) {
+ flags.keys.forEach((key) => {
+ // don't set placeholder keys for dot notation options 'foo.bar'.
+ if (~key.indexOf('.')) return
+ if (typeof argv[key] === 'undefined') argv[key] = undefined
+ })
+ return argv
+ }
+
function applyDefaultsAndAliases (obj, aliases, defaults) {
Object.keys(defaults).forEach(function (key) {
if (!hasKey(obj, key.split('.'))) {
@@ -588,6 +657,10 @@ function parse (args, opts) {
if (!configuration['dot-notation']) keys = [keys.join('.')]
keys.slice(0, -1).forEach(function (key, index) {
+ // TODO(bcoe): in the next major version of yargs, switch to
+ // Object.create(null) for dot notation:
+ key = sanitizeKey(key)
+
if (typeof o === 'object' && o[key] === undefined) {
o[key] = {}
}
@@ -607,17 +680,27 @@ function parse (args, opts) {
}
})
- var key = keys[keys.length - 1]
+ // TODO(bcoe): in the next major version of yargs, switch to
+ // Object.create(null) for dot notation:
+ const key = sanitizeKey(keys[keys.length - 1])
+
+ const isTypeArray = checkAllAliases(keys.join('.'), flags.arrays)
+ const isValueArray = Array.isArray(value)
+ let duplicate = configuration['duplicate-arguments-array']
- var isTypeArray = checkAllAliases(keys.join('.'), flags.arrays)
- var isValueArray = Array.isArray(value)
- var duplicate = configuration['duplicate-arguments-array']
+ // nargs has higher priority than duplicate
+ if (!duplicate && checkAllAliases(key, flags.nargs)) {
+ duplicate = true
+ if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length === flags.nargs[key])) {
+ o[key] = undefined
+ }
+ }
if (value === increment) {
o[key] = increment(o[key])
} else if (Array.isArray(o[key])) {
if (duplicate && isTypeArray && isValueArray) {
- o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : [o[key]].concat([value])
+ o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value])
} else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
o[key] = value
} else {
@@ -625,7 +708,7 @@ function parse (args, opts) {
}
} else if (o[key] === undefined && isTypeArray) {
o[key] = isValueArray ? value : [value]
- } else if (duplicate && !(o[key] === undefined || checkAllAliases(key, flags.bools) || checkAllAliases(keys.join('.'), flags.bools) || checkAllAliases(key, flags.counts))) {
+ } else if (duplicate && !(o[key] === undefined || checkAllAliases(key, flags.counts))) {
o[key] = [ o[key], value ]
} else {
o[key] = value
@@ -633,8 +716,8 @@ function parse (args, opts) {
}
// extend the aliases list with inferred aliases.
- function extendAliases () {
- Array.prototype.slice.call(arguments).forEach(function (obj) {
+ function extendAliases (...args) {
+ args.forEach(function (obj) {
Object.keys(obj || {}).forEach(function (key) {
// short-circuit if we've already added a key
// to the aliases array, for example it might
@@ -652,6 +735,16 @@ function parse (args, opts) {
}
}
})
+ // For "--optionName", also set argv['option-name']
+ flags.aliases[key].concat(key).forEach(function (x) {
+ if (x.length > 1 && /[A-Z]/.test(x) && configuration['camel-case-expansion']) {
+ var c = decamelize(x, '-')
+ if (c !== key && flags.aliases[key].indexOf(c) === -1) {
+ flags.aliases[key].push(c)
+ newAliases[c] = true
+ }
+ }
+ })
flags.aliases[key].forEach(function (x) {
flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) {
return x !== y
@@ -667,24 +760,89 @@ function parse (args, opts) {
var toCheck = [].concat(flags.aliases[key] || [], key)
toCheck.forEach(function (key) {
- if (flag[key]) isSet = flag[key]
+ if (flag.hasOwnProperty(key)) isSet = flag[key]
})
return isSet
}
- function setDefaulted (key) {
- [].concat(flags.aliases[key] || [], key).forEach(function (k) {
- flags.defaulted[k] = true
+ function hasAnyFlag (key) {
+ // XXX Switch to [].concat(...Object.values(flags)) once node.js 6 is dropped
+ var toCheck = [].concat(...Object.keys(flags).map(k => flags[k]))
+
+ return toCheck.some(function (flag) {
+ return flag[key]
})
}
- function unsetDefaulted (key) {
- [].concat(flags.aliases[key] || [], key).forEach(function (k) {
- delete flags.defaulted[k]
+ function hasFlagsMatching (arg, ...patterns) {
+ var toCheck = [].concat(...patterns)
+ return toCheck.some(function (pattern) {
+ var match = arg.match(pattern)
+ return match && hasAnyFlag(match[1])
})
}
+ // based on a simplified version of the short flag group parsing logic
+ function hasAllShortFlags (arg) {
+ // if this is a negative number, or doesn't start with a single hyphen, it's not a short flag group
+ if (arg.match(negative) || !arg.match(/^-[^-]+/)) { return false }
+ var hasAllFlags = true
+ var letters = arg.slice(1).split('')
+ var next
+ for (var j = 0; j < letters.length; j++) {
+ next = arg.slice(j + 2)
+
+ if (!hasAnyFlag(letters[j])) {
+ hasAllFlags = false
+ break
+ }
+
+ if ((letters[j + 1] && letters[j + 1] === '=') ||
+ next === '-' ||
+ (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) ||
+ (letters[j + 1] && letters[j + 1].match(/\W/))) {
+ break
+ }
+ }
+ return hasAllFlags
+ }
+
+ function isUnknownOptionAsArg (arg) {
+ return configuration['unknown-options-as-args'] && isUnknownOption(arg)
+ }
+
+ function isUnknownOption (arg) {
+ // ignore negative numbers
+ if (arg.match(negative)) { return false }
+ // if this is a short option group and all of them are configured, it isn't unknown
+ if (hasAllShortFlags(arg)) { return false }
+ // e.g. '--count=2'
+ const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/
+ // e.g. '-a' or '--arg'
+ const normalFlag = /^-+([^=]+?)$/
+ // e.g. '-a-'
+ const flagEndingInHyphen = /^-+([^=]+?)-$/
+ // e.g. '-abc123'
+ const flagEndingInDigits = /^-+([^=]+?)\d+$/
+ // e.g. '-a/usr/local'
+ const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/
+ // check the different types of flag styles, including negatedBoolean, a pattern defined near the start of the parse method
+ return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters)
+ }
+
+ // make a best effor to pick a default value
+ // for an option based on name and type.
+ function defaultValue (key) {
+ if (!checkAllAliases(key, flags.bools) &&
+ !checkAllAliases(key, flags.counts) &&
+ `${key}` in defaults) {
+ return defaults[key]
+ } else {
+ return defaultForType(guessType(key))
+ }
+ }
+
// return a default value, given the type of a flag.,
// e.g., key of type 'string' will default to '', rather than 'true'.
function defaultForType (type) {
@@ -699,20 +857,26 @@ function parse (args, opts) {
}
// given a flag, enforce a default type.
- function guessType (key, flags) {
+ function guessType (key) {
var type = 'boolean'
if (checkAllAliases(key, flags.strings)) type = 'string'
else if (checkAllAliases(key, flags.numbers)) type = 'number'
+ else if (checkAllAliases(key, flags.bools)) type = 'boolean'
else if (checkAllAliases(key, flags.arrays)) type = 'array'
return type
}
function isNumber (x) {
+ if (x === null || x === undefined) return false
+ // if loaded from config, may already be a number.
if (typeof x === 'number') return true
+ // hexadecimal.
if (/^0x[0-9a-f]+$/i.test(x)) return true
- return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x)
+ // don't treat 0123 as a number; as it drops the leading '0'.
+ if (x.length > 1 && x[0] === '0') return false
+ return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x)
}
function isUndefined (num) {
@@ -775,20 +939,6 @@ function combineAliases (aliases) {
return combined
}
-function assign (defaults, configuration) {
- var o = {}
- configuration = configuration || {}
-
- Object.keys(defaults).forEach(function (k) {
- o[k] = defaults[k]
- })
- Object.keys(configuration).forEach(function (k) {
- o[k] = configuration[k]
- })
-
- return o
-}
-
// this function should only be called when a count is given as an arg
// it is NOT called to set a default value
// thus we can start the count at 1 instead of 0
@@ -808,4 +958,11 @@ Parser.detailed = function (args, opts) {
return parse(args.slice(), opts)
}
+// TODO(bcoe): in the next major version of yargs, switch to
+// Object.create(null) for dot notation:
+function sanitizeKey (key) {
+ if (key === '__proto__') return '___proto___'
+ return key
+}
+
module.exports = Parser
diff --git a/node_modules/yargs-parser/lib/tokenize-arg-string.js b/node_modules/yargs-parser/lib/tokenize-arg-string.js
index 6c8d23ef2..fe05e27fd 100644
--- a/node_modules/yargs-parser/lib/tokenize-arg-string.js
+++ b/node_modules/yargs-parser/lib/tokenize-arg-string.js
@@ -1,6 +1,8 @@
// take an un-split argv string and tokenize it.
module.exports = function (argString) {
- if (Array.isArray(argString)) return argString
+ if (Array.isArray(argString)) {
+ return argString.map(e => typeof e !== 'string' ? e + '' : e)
+ }
argString = argString.trim()
@@ -26,10 +28,8 @@ module.exports = function (argString) {
// opening or closing single and double quotes.
if (c === opening) {
opening = null
- continue
} else if ((c === "'" || c === '"') && !opening) {
opening = c
- continue
}
if (!args[i]) args[i] = ''
diff --git a/node_modules/yargs-parser/node_modules/camelcase/index.d.ts b/node_modules/yargs-parser/node_modules/camelcase/index.d.ts
new file mode 100644
index 000000000..58f2069ad
--- /dev/null
+++ b/node_modules/yargs-parser/node_modules/camelcase/index.d.ts
@@ -0,0 +1,63 @@
+declare namespace camelcase {
+ interface Options {
+ /**
+ Uppercase the first character: `foo-bar` → `FooBar`.
+
+ @default false
+ */
+ readonly pascalCase?: boolean;
+ }
+}
+
+declare const camelcase: {
+ /**
+ Convert a dash/dot/underscore/space separated string to camelCase or PascalCase: `foo-bar` → `fooBar`.
+
+ @param input - String to convert to camel case.
+
+ @example
+ ```
+ import camelCase = require('camelcase');
+
+ camelCase('foo-bar');
+ //=> 'fooBar'
+
+ camelCase('foo_bar');
+ //=> 'fooBar'
+
+ camelCase('Foo-Bar');
+ //=> 'fooBar'
+
+ camelCase('Foo-Bar', {pascalCase: true});
+ //=> 'FooBar'
+
+ camelCase('--foo.bar', {pascalCase: false});
+ //=> 'fooBar'
+
+ camelCase('foo bar');
+ //=> 'fooBar'
+
+ console.log(process.argv[3]);
+ //=> '--foo-bar'
+ camelCase(process.argv[3]);
+ //=> 'fooBar'
+
+ camelCase(['foo', 'bar']);
+ //=> 'fooBar'
+
+ camelCase(['__foo__', '--bar'], {pascalCase: true});
+ //=> 'FooBar'
+ ```
+ */
+ (input: string | ReadonlyArray<string>, options?: camelcase.Options): string;
+
+ // TODO: Remove this for the next major release, refactor the whole definition to:
+ // declare function camelcase(
+ // input: string | ReadonlyArray<string>,
+ // options?: camelcase.Options
+ // ): string;
+ // export = camelcase;
+ default: typeof camelcase;
+};
+
+export = camelcase;
diff --git a/node_modules/yargs-parser/node_modules/camelcase/index.js b/node_modules/yargs-parser/node_modules/camelcase/index.js
new file mode 100644
index 000000000..579f99b47
--- /dev/null
+++ b/node_modules/yargs-parser/node_modules/camelcase/index.js
@@ -0,0 +1,76 @@
+'use strict';
+
+const preserveCamelCase = string => {
+ let isLastCharLower = false;
+ let isLastCharUpper = false;
+ let isLastLastCharUpper = false;
+
+ for (let i = 0; i < string.length; i++) {
+ const character = string[i];
+
+ if (isLastCharLower && /[a-zA-Z]/.test(character) && character.toUpperCase() === character) {
+ string = string.slice(0, i) + '-' + string.slice(i);
+ isLastCharLower = false;
+ isLastLastCharUpper = isLastCharUpper;
+ isLastCharUpper = true;
+ i++;
+ } else if (isLastCharUpper && isLastLastCharUpper && /[a-zA-Z]/.test(character) && character.toLowerCase() === character) {
+ string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
+ isLastLastCharUpper = isLastCharUpper;
+ isLastCharUpper = false;
+ isLastCharLower = true;
+ } else {
+ isLastCharLower = character.toLowerCase() === character && character.toUpperCase() !== character;
+ isLastLastCharUpper = isLastCharUpper;
+ isLastCharUpper = character.toUpperCase() === character && character.toLowerCase() !== character;
+ }
+ }
+
+ return string;
+};
+
+const camelCase = (input, options) => {
+ if (!(typeof input === 'string' || Array.isArray(input))) {
+ throw new TypeError('Expected the input to be `string | string[]`');
+ }
+
+ options = Object.assign({
+ pascalCase: false
+ }, options);
+
+ const postProcess = x => options.pascalCase ? x.charAt(0).toUpperCase() + x.slice(1) : x;
+
+ if (Array.isArray(input)) {
+ input = input.map(x => x.trim())
+ .filter(x => x.length)
+ .join('-');
+ } else {
+ input = input.trim();
+ }
+
+ if (input.length === 0) {
+ return '';
+ }
+
+ if (input.length === 1) {
+ return options.pascalCase ? input.toUpperCase() : input.toLowerCase();
+ }
+
+ const hasUpperCase = input !== input.toLowerCase();
+
+ if (hasUpperCase) {
+ input = preserveCamelCase(input);
+ }
+
+ input = input
+ .replace(/^[_.\- ]+/, '')
+ .toLowerCase()
+ .replace(/[_.\- ]+(\w|$)/g, (_, p1) => p1.toUpperCase())
+ .replace(/\d+(\w|$)/g, m => m.toUpperCase());
+
+ return postProcess(input);
+};
+
+module.exports = camelCase;
+// TODO: Remove this for the next major release
+module.exports.default = camelCase;
diff --git a/node_modules/yargs-parser/node_modules/camelcase/license b/node_modules/yargs-parser/node_modules/camelcase/license
new file mode 100644
index 000000000..e7af2f771
--- /dev/null
+++ b/node_modules/yargs-parser/node_modules/camelcase/license
@@ -0,0 +1,9 @@
+MIT License
+
+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.
diff --git a/node_modules/yargs-parser/node_modules/camelcase/package.json b/node_modules/yargs-parser/node_modules/camelcase/package.json
new file mode 100644
index 000000000..86f54e45c
--- /dev/null
+++ b/node_modules/yargs-parser/node_modules/camelcase/package.json
@@ -0,0 +1,75 @@
+{
+ "_from": "camelcase@^5.0.0",
+ "_id": "camelcase@5.3.1",
+ "_inBundle": false,
+ "_integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+ "_location": "/yargs-parser/camelcase",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "camelcase@^5.0.0",
+ "name": "camelcase",
+ "escapedName": "camelcase",
+ "rawSpec": "^5.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^5.0.0"
+ },
+ "_requiredBy": [
+ "/yargs-parser"
+ ],
+ "_resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
+ "_shasum": "e3c9b31569e106811df242f715725a1f4c494320",
+ "_spec": "camelcase@^5.0.0",
+ "_where": "/Users/isaacs/dev/npm/cli/node_modules/yargs-parser",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "bugs": {
+ "url": "https://github.com/sindresorhus/camelcase/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "Convert a dash/dot/underscore/space separated string to camelCase or PascalCase: `foo-bar` → `fooBar`",
+ "devDependencies": {
+ "ava": "^1.4.1",
+ "tsd": "^0.7.1",
+ "xo": "^0.24.0"
+ },
+ "engines": {
+ "node": ">=6"
+ },
+ "files": [
+ "index.js",
+ "index.d.ts"
+ ],
+ "homepage": "https://github.com/sindresorhus/camelcase#readme",
+ "keywords": [
+ "camelcase",
+ "camel-case",
+ "camel",
+ "case",
+ "dash",
+ "hyphen",
+ "dot",
+ "underscore",
+ "separator",
+ "string",
+ "text",
+ "convert",
+ "pascalcase",
+ "pascal-case"
+ ],
+ "license": "MIT",
+ "name": "camelcase",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/sindresorhus/camelcase.git"
+ },
+ "scripts": {
+ "test": "xo && ava && tsd"
+ },
+ "version": "5.3.1"
+}
diff --git a/node_modules/yargs-parser/node_modules/camelcase/readme.md b/node_modules/yargs-parser/node_modules/camelcase/readme.md
new file mode 100644
index 000000000..fde27261b
--- /dev/null
+++ b/node_modules/yargs-parser/node_modules/camelcase/readme.md
@@ -0,0 +1,99 @@
+# camelcase [![Build Status](https://travis-ci.org/sindresorhus/camelcase.svg?branch=master)](https://travis-ci.org/sindresorhus/camelcase)
+
+> Convert a dash/dot/underscore/space separated string to camelCase or PascalCase: `foo-bar` → `fooBar`
+
+---
+
+<div align="center">
+ <b>
+ <a href="https://tidelift.com/subscription/pkg/npm-camelcase?utm_source=npm-camelcase&utm_medium=referral&utm_campaign=readme">Get professional support for 'camelcase' with a Tidelift subscription</a>
+ </b>
+ <br>
+ <sub>
+ Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+ </sub>
+</div>
+
+---
+
+## Install
+
+```
+$ npm install camelcase
+```
+
+
+## Usage
+
+```js
+const camelCase = require('camelcase');
+
+camelCase('foo-bar');
+//=> 'fooBar'
+
+camelCase('foo_bar');
+//=> 'fooBar'
+
+camelCase('Foo-Bar');
+//=> 'fooBar'
+
+camelCase('Foo-Bar', {pascalCase: true});
+//=> 'FooBar'
+
+camelCase('--foo.bar', {pascalCase: false});
+//=> 'fooBar'
+
+camelCase('foo bar');
+//=> 'fooBar'
+
+console.log(process.argv[3]);
+//=> '--foo-bar'
+camelCase(process.argv[3]);
+//=> 'fooBar'
+
+camelCase(['foo', 'bar']);
+//=> 'fooBar'
+
+camelCase(['__foo__', '--bar'], {pascalCase: true});
+//=> 'FooBar'
+```
+
+
+## API
+
+### camelCase(input, [options])
+
+#### input
+
+Type: `string` `string[]`
+
+String to convert to camel case.
+
+#### options
+
+Type: `Object`
+
+##### pascalCase
+
+Type: `boolean`<br>
+Default: `false`
+
+Uppercase the first character: `foo-bar` → `FooBar`
+
+
+## Security
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.
+
+
+## Related
+
+- [decamelize](https://github.com/sindresorhus/decamelize) - The inverse of this module
+- [uppercamelcase](https://github.com/SamVerschueren/uppercamelcase) - Like this module, but to PascalCase instead of camelCase
+- [titleize](https://github.com/sindresorhus/titleize) - Capitalize every word in string
+- [humanize-string](https://github.com/sindresorhus/humanize-string) - Convert a camelized/dasherized/underscored string into a humanized one
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)
diff --git a/node_modules/yargs-parser/package.json b/node_modules/yargs-parser/package.json
index c4d1ca1ce..1cb0feb0b 100644
--- a/node_modules/yargs-parser/package.json
+++ b/node_modules/yargs-parser/package.json
@@ -1,27 +1,27 @@
{
- "_from": "yargs-parser@^9.0.2",
- "_id": "yargs-parser@9.0.2",
+ "_from": "yargs-parser@^15.0.1",
+ "_id": "yargs-parser@15.0.1",
"_inBundle": false,
- "_integrity": "sha1-nM9qQ0YP5O1Aqbto9I1DuKaMwHc=",
+ "_integrity": "sha512-0OAMV2mAZQrs3FkNpDQcBk1x5HXb8X4twADss4S0Iuk+2dGnLOE/fRHrsYm542GduMveyA77OF4wrNJuanRCWw==",
"_location": "/yargs-parser",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
- "raw": "yargs-parser@^9.0.2",
+ "raw": "yargs-parser@^15.0.1",
"name": "yargs-parser",
"escapedName": "yargs-parser",
- "rawSpec": "^9.0.2",
+ "rawSpec": "^15.0.1",
"saveSpec": null,
- "fetchSpec": "^9.0.2"
+ "fetchSpec": "^15.0.1"
},
"_requiredBy": [
"/yargs"
],
- "_resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-9.0.2.tgz",
- "_shasum": "9ccf6a43460fe4ed40a9bb68f48d43b8a68cc077",
- "_spec": "yargs-parser@^9.0.2",
- "_where": "/Users/rebecca/code/npm/node_modules/yargs",
+ "_resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-15.0.1.tgz",
+ "_shasum": "54786af40b820dcb2fb8025b11b4d659d76323b3",
+ "_spec": "yargs-parser@^15.0.1",
+ "_where": "/Users/isaacs/dev/npm/cli/node_modules/yargs",
"author": {
"name": "Ben Coe",
"email": "ben@npmjs.com"
@@ -31,17 +31,21 @@
},
"bundleDependencies": false,
"dependencies": {
- "camelcase": "^4.1.0"
+ "camelcase": "^5.0.0",
+ "decamelize": "^1.2.0"
},
"deprecated": false,
"description": "the mighty option parser used by yargs",
"devDependencies": {
- "chai": "^3.5.0",
- "coveralls": "^2.11.12",
- "mocha": "^3.0.1",
- "nyc": "^11.4.1",
- "standard": "^10.0.2",
- "standard-version": "^4.3.0"
+ "chai": "^4.2.0",
+ "coveralls": "^3.0.2",
+ "mocha": "^5.2.0",
+ "nyc": "^14.1.0",
+ "standard": "^12.0.1",
+ "standard-version": "^6.0.0"
+ },
+ "engine": {
+ "node": ">=6"
},
"files": [
"lib",
@@ -71,5 +75,5 @@
"release": "standard-version",
"test": "nyc mocha test/*.js"
},
- "version": "9.0.2"
+ "version": "15.0.1"
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-23 16:50:21 +0300