diff -Nru node-yargs-parser-4.1.0/appveyor.yml node-yargs-parser-8.0.0/appveyor.yml
--- node-yargs-parser-4.1.0/appveyor.yml	2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/appveyor.yml	2017-10-05 06:20:38.000000000 +0000
@@ -2,7 +2,7 @@
   matrix:
     - nodejs_version: '5'
     - nodejs_version: '4'
-    - nodejs_version: '0.12'
+    - nodejs_version: '7'
 install:
   - ps: Install-Product node $env:nodejs_version
   - set CI=true
diff -Nru node-yargs-parser-4.1.0/CHANGELOG.md node-yargs-parser-8.0.0/CHANGELOG.md
--- node-yargs-parser-4.1.0/CHANGELOG.md	2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/CHANGELOG.md	2017-10-05 06:20:38.000000000 +0000
@@ -2,6 +2,121 @@
 
 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.
 
+<a name="8.0.0"></a>
+# [8.0.0](https://github.com/yargs/yargs-parser/compare/v7.0.0...v8.0.0) (2017-10-05)
+
+
+### Bug Fixes
+
+* Ignore multiple spaces between arguments. ([#100](https://github.com/yargs/yargs-parser/issues/100)) ([d137227](https://github.com/yargs/yargs-parser/commit/d137227))
+
+
+### Features
+
+* allow configuration of prefix for boolean negation ([#94](https://github.com/yargs/yargs-parser/issues/94)) ([00bde7d](https://github.com/yargs/yargs-parser/commit/00bde7d))
+* reworking how numbers are parsed ([#104](https://github.com/yargs/yargs-parser/issues/104)) ([fba00eb](https://github.com/yargs/yargs-parser/commit/fba00eb))
+
+
+### BREAKING CHANGES
+
+* strings that fail `Number.isSafeInteger()` are no longer coerced into numbers. 
+
+
+
+<a name="7.0.0"></a>
+# [7.0.0](https://github.com/yargs/yargs-parser/compare/v6.0.1...v7.0.0) (2017-05-02)
+
+
+### Chores
+
+* revert populate-- logic ([#91](https://github.com/yargs/yargs-parser/issues/91)) ([6003e6d](https://github.com/yargs/yargs-parser/commit/6003e6d))
+
+
+### BREAKING CHANGES
+
+* populate-- now defaults to false.
+
+
+
+<a name="6.0.1"></a>
+## [6.0.1](https://github.com/yargs/yargs-parser/compare/v6.0.0...v6.0.1) (2017-05-01)
+
+
+### Bug Fixes
+
+* default '--' to undefined when not provided; this is closer to the array API ([#90](https://github.com/yargs/yargs-parser/issues/90)) ([4e739cc](https://github.com/yargs/yargs-parser/commit/4e739cc))
+
+
+
+<a name="6.0.0"></a>
+# [6.0.0](https://github.com/yargs/yargs-parser/compare/v4.2.1...v6.0.0) (2017-05-01)
+
+
+### Bug Fixes
+
+* environment variables should take precedence over config file ([#81](https://github.com/yargs/yargs-parser/issues/81)) ([76cee1f](https://github.com/yargs/yargs-parser/commit/76cee1f))
+* parsing hints should apply for dot notation keys ([#86](https://github.com/yargs/yargs-parser/issues/86)) ([3e47d62](https://github.com/yargs/yargs-parser/commit/3e47d62))
+
+
+### Chores
+
+* upgrade to newest version of camelcase ([#87](https://github.com/yargs/yargs-parser/issues/87)) ([f1903aa](https://github.com/yargs/yargs-parser/commit/f1903aa))
+
+
+### Features
+
+* add -- option which allows arguments after the -- flag to be returned separated from positional arguments ([#84](https://github.com/yargs/yargs-parser/issues/84)) ([2572ca8](https://github.com/yargs/yargs-parser/commit/2572ca8))
+* when parsing stops, we now populate "--" by default ([#88](https://github.com/yargs/yargs-parser/issues/88)) ([cd666db](https://github.com/yargs/yargs-parser/commit/cd666db))
+
+
+### BREAKING CHANGES
+
+* rather than placing arguments in "_", when parsing is stopped via "--"; we now populate an array called "--" by default.
+* camelcase now requires Node 4+.
+* environment variables will now override config files (args, env, config-file, config-object)
+
+
+
+<a name="5.0.0"></a>
+# [5.0.0](https://github.com/yargs/yargs-parser/compare/v4.2.1...v5.0.0) (2017-02-18)
+
+
+### Bug Fixes
+
+* environment variables should take precedence over config file ([#81](https://github.com/yargs/yargs-parser/issues/81)) ([76cee1f](https://github.com/yargs/yargs-parser/commit/76cee1f))
+
+
+### BREAKING CHANGES
+
+* environment variables will now override config files (args, env, config-file, config-object)
+
+
+
+<a name="4.2.1"></a>
+## [4.2.1](https://github.com/yargs/yargs-parser/compare/v4.2.0...v4.2.1) (2017-01-02)
+
+
+### Bug Fixes
+
+* flatten/duplicate regression ([#75](https://github.com/yargs/yargs-parser/issues/75)) ([68d68a0](https://github.com/yargs/yargs-parser/commit/68d68a0))
+
+
+
+<a name="4.2.0"></a>
+# [4.2.0](https://github.com/yargs/yargs-parser/compare/v4.1.0...v4.2.0) (2016-12-01)
+
+
+### Bug Fixes
+
+* inner objects in configs had their keys appended to top-level key when dot-notation was disabled ([#72](https://github.com/yargs/yargs-parser/issues/72)) ([0b1b5f9](https://github.com/yargs/yargs-parser/commit/0b1b5f9))
+
+
+### Features
+
+* allow multiple arrays to be provided, rather than always combining ([#71](https://github.com/yargs/yargs-parser/issues/71)) ([0f0fb2d](https://github.com/yargs/yargs-parser/commit/0f0fb2d))
+
+
+
 <a name="4.1.0"></a>
 # [4.1.0](https://github.com/yargs/yargs-parser/compare/v4.0.2...v4.1.0) (2016-11-07)
 
diff -Nru node-yargs-parser-4.1.0/debian/changelog node-yargs-parser-8.0.0/debian/changelog
--- node-yargs-parser-4.1.0/debian/changelog	2016-11-26 11:06:29.000000000 +0000
+++ node-yargs-parser-8.0.0/debian/changelog	2017-12-04 15:56:02.000000000 +0000
@@ -1,3 +1,10 @@
+node-yargs-parser (8.0.0-1) unstable; urgency=medium
+
+  * Team upload
+  * New upstream release 
+
+ -- Pirate Praveen <praveen@debian.org>  Mon, 04 Dec 2017 21:26:02 +0530
+
 node-yargs-parser (4.1.0-1) unstable; urgency=medium
 
   * Team upload
diff -Nru node-yargs-parser-4.1.0/debian/control node-yargs-parser-8.0.0/debian/control
--- node-yargs-parser-4.1.0/debian/control	2016-11-26 11:06:29.000000000 +0000
+++ node-yargs-parser-8.0.0/debian/control	2017-12-04 15:56:02.000000000 +0000
@@ -1,5 +1,5 @@
 Source: node-yargs-parser
-Section: web
+Section: javascript
 Priority: optional
 Maintainer: Debian Javascript Maintainers <pkg-javascript-devel@lists.alioth.debian.org>
 Uploaders: Sruthi Chandran <srud@disroot.org>
@@ -7,7 +7,7 @@
  debhelper (>= 9)
  , dh-buildinfo
  , nodejs
-Standards-Version: 3.9.8
+Standards-Version: 4.1.1
 Homepage: https://github.com/yargs/yargs-parser#readme
 Vcs-Git: https://anonscm.debian.org/git/pkg-javascript/node-yargs-parser.git
 Vcs-Browser: https://anonscm.debian.org/cgit/pkg-javascript/node-yargs-parser.git
diff -Nru node-yargs-parser-4.1.0/index.js node-yargs-parser-8.0.0/index.js
--- node-yargs-parser-4.1.0/index.js	2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/index.js	2017-10-05 06:20:38.000000000 +0000
@@ -15,11 +15,17 @@
     'camel-case-expansion': true,
     'dot-notation': true,
     'parse-numbers': true,
-    'boolean-negation': true
+    'boolean-negation': true,
+    'negation-prefix': 'no-',
+    'duplicate-arguments-array': true,
+    'flatten-duplicate-arrays': true,
+    'populate--': false
   }, opts.configuration)
   var defaults = opts.default || {}
   var configObjects = opts.configObjects || []
   var envPrefix = opts.envPrefix
+  var notFlagsOption = configuration['populate--']
+  var notFlagsArgv = notFlagsOption ? '--' : '_'
   var newAliases = {}
   // allow a i18n handler to be passed in, default to a fake one (util.format).
   var __ = opts.__ || function (str) {
@@ -40,6 +46,7 @@
     coercions: {}
   }
   var negative = /^-[0-9]+(\.[0-9]+)?/
+  var negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)')
 
   ;[].concat(opts.array).filter(Boolean).forEach(function (key) {
     flags.arrays[key] = true
@@ -136,8 +143,8 @@
       } else {
         setArg(m[1], m[2])
       }
-    } else if (arg.match(/^--no-.+/) && configuration['boolean-negation']) {
-      key = arg.match(/^--no-(.+)/)[1]
+    } else if (arg.match(negatedBoolean) && configuration['boolean-negation']) {
+      key = arg.match(negatedBoolean)[1]
       setArg(key, false)
 
     // -- seperated by space.
@@ -263,22 +270,20 @@
         }
       }
     } else {
-      argv._.push(
-        flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
-      )
+      argv._.push(maybeCoerceNumber('_', arg))
     }
   }
 
   // order of precedence:
   // 1. command line arg
-  // 2. value from config file
-  // 3. value from config objects
-  // 4. value from env var
+  // 2. value from env var
+  // 3. value from config file
+  // 4. value from config objects
   // 5. configured default value
   applyEnvVars(argv, true) // special case: check env vars that point to config file
+  applyEnvVars(argv, false)
   setConfig(argv)
   setConfigObjects()
-  applyEnvVars(argv, false)
   applyDefaultsAndAliases(argv, flags.aliases, defaults)
   applyCoercions(argv)
 
@@ -287,8 +292,10 @@
     if (!hasKey(argv, key.split('.'))) setArg(key, 0)
   })
 
+  // '--' defaults to undefined.
+  if (notFlagsOption && notFlags.length) argv[notFlagsArgv] = []
   notFlags.forEach(function (key) {
-    argv._.push(key)
+    argv[notFlagsArgv].push(key)
   })
 
   // how many arguments should we consume, based
@@ -310,15 +317,27 @@
   // 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
       }
       i = ii
-      setArg(key, args[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)
+      })
     }
 
     return i
@@ -327,33 +346,11 @@
   function setArg (key, val) {
     unsetDefaulted(key)
 
-    // handle parsing boolean arguments --foo=true --bar false.
-    if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
-      if (typeof val === 'string') val = val === 'true'
+    if (/-/.test(key) && configuration['camel-case-expansion']) {
+      addNewAlias(key, camelCase(key))
     }
 
-    if (/-/.test(key) && !(flags.aliases[key] && flags.aliases[key].length) && configuration['camel-case-expansion']) {
-      var c = camelCase(key)
-      flags.aliases[key] = [c]
-      newAliases[c] = true
-    }
-
-    var value = val
-    if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.coercions)) {
-      if (isNumber(val)) value = Number(val)
-      if (!isUndefined(val) && !isNumber(val) && checkAllAliases(key, flags.numbers)) value = NaN
-    }
-
-    // increment a count given as arg (either no value or value parsed as boolean)
-    if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
-      value = increment
-    }
-
-    // Set normalized value when key is in 'normalize' and in 'arrays'
-    if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
-      if (Array.isArray(val)) value = val.map(path.normalize)
-      else value = path.normalize(val)
-    }
+    var value = processValue(key, val)
 
     var splitKey = key.split('.')
     setKey(argv, splitKey, value)
@@ -395,6 +392,45 @@
     }
   }
 
+  function addNewAlias (key, alias) {
+    if (!(flags.aliases[key] && flags.aliases[key].length)) {
+      flags.aliases[key] = [alias]
+      newAliases[alias] = true
+    }
+    if (!(flags.aliases[alias] && flags.aliases[alias].length)) {
+      addNewAlias(alias, key)
+    }
+  }
+
+  function processValue (key, val) {
+    // 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)
+
+    // increment a count given as arg (either no value or value parsed as boolean)
+    if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
+      value = increment
+    }
+
+    // Set normalized value when key is in 'normalize' and in 'arrays'
+    if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
+      if (Array.isArray(val)) value = val.map(path.normalize)
+      else value = path.normalize(val)
+    }
+    return value
+  }
+
+  function maybeCoerceNumber (key, value) {
+    if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.coercions)) {
+      const shouldCoerceNumber = isNumber(value) && configuration['parse-numbers'] && (Number.isSafeInteger(parseInt(value)))
+      if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) value = Number(value)
+    }
+    return value
+  }
+
   // set args from config.json file, this should be
   // applied last so that defaults can be applied.
   function setConfig (argv) {
@@ -440,7 +476,10 @@
       var value = config[key]
       var fullKey = prev ? prev + '.' + key : key
 
-      if (Object.prototype.toString.call(value) === '[object Object]') {
+      // if the value is an inner object and we have dot-notation
+      // enabled, treat inner objects in config the same as
+      // heavily nested dot notations (foo.bar.apple).
+      if (typeof value === 'object' && !Array.isArray(value) && configuration['dot-notation']) {
         // if the value is an object but not an array, check nested object
         setConfigObject(value, fullKey)
       } else {
@@ -536,16 +575,26 @@
 
     var key = keys[keys.length - 1]
 
+    var isTypeArray = checkAllAliases(keys.join('.'), flags.arrays)
+    var isValueArray = Array.isArray(value)
+    var duplicate = configuration['duplicate-arguments-array']
+
     if (value === increment) {
       o[key] = increment(o[key])
-    } else if (o[key] === undefined && checkAllAliases(key, flags.arrays)) {
-      o[key] = Array.isArray(value) ? value : [value]
-    } else if (o[key] === undefined || checkAllAliases(key, flags.bools) || checkAllAliases(keys.join('.'), flags.bools) || checkAllAliases(key, flags.counts)) {
-      o[key] = value
     } else if (Array.isArray(o[key])) {
-      o[key].push(value)
-    } else {
+      if (duplicate && isTypeArray && isValueArray) {
+        o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : [o[key]].concat([value])
+      } else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
+        o[key] = value
+      } else {
+        o[key] = o[key].concat([value])
+      }
+    } 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))) {
       o[key] = [ o[key], value ]
+    } else {
+      o[key] = value
     }
   }
 
@@ -563,7 +612,9 @@
         flags.aliases[key].concat(key).forEach(function (x) {
           if (/-/.test(x) && configuration['camel-case-expansion']) {
             var c = camelCase(x)
-            flags.aliases[key].push(c)
+            if (flags.aliases[key].indexOf(c) === -1) {
+              flags.aliases[key].push(c)
+            }
             newAliases[c] = true
           }
         })
@@ -625,7 +676,6 @@
   }
 
   function isNumber (x) {
-    if (!configuration['parse-numbers']) return false
     if (typeof x === 'number') return true
     if (/^0x[0-9a-f]+$/i.test(x)) return true
     return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x)
diff -Nru node-yargs-parser-4.1.0/lib/tokenize-arg-string.js node-yargs-parser-8.0.0/lib/tokenize-arg-string.js
--- node-yargs-parser-4.1.0/lib/tokenize-arg-string.js	2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/lib/tokenize-arg-string.js	2017-10-05 06:20:38.000000000 +0000
@@ -3,16 +3,20 @@
   if (Array.isArray(argString)) return argString
 
   var i = 0
+  var prevC = null
   var c = null
   var opening = null
   var args = []
 
   for (var ii = 0; ii < argString.length; ii++) {
+    prevC = c
     c = argString.charAt(ii)
 
     // split on spaces unless we're in quotes.
     if (c === ' ' && !opening) {
-      i++
+      if (!(prevC === ' ')) {
+        i++
+      }
       continue
     }
 
diff -Nru node-yargs-parser-4.1.0/package.json node-yargs-parser-8.0.0/package.json
--- node-yargs-parser-4.1.0/package.json	2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/package.json	2017-10-05 06:20:38.000000000 +0000
@@ -1,6 +1,6 @@
 {
   "name": "yargs-parser",
-  "version": "4.1.0",
+  "version": "8.0.0",
   "description": "the mighty option parser used by yargs",
   "main": "index.js",
   "scripts": {
@@ -29,12 +29,12 @@
     "chai": "^3.5.0",
     "coveralls": "^2.11.12",
     "mocha": "^3.0.1",
-    "nyc": "^8.1.0",
-    "standard": "^8.0.0",
-    "standard-version": "^3.0.0"
+    "nyc": "^11.2.1",
+    "standard": "^10.0.2",
+    "standard-version": "^4.0.0"
   },
   "dependencies": {
-    "camelcase": "^3.0.0"
+    "camelcase": "^4.1.0"
   },
   "files": [
     "lib",
diff -Nru node-yargs-parser-4.1.0/README.md node-yargs-parser-8.0.0/README.md
--- node-yargs-parser-4.1.0/README.md	2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/README.md	2017-10-05 06:20:38.000000000 +0000
@@ -11,7 +11,7 @@
 
 visit the [yargs website](http://yargs.js.org/) for more examples, and thorough usage instructions.
 
-<img width="250" src="yargs-logo.png">
+<img width="250" src="https://raw.githubusercontent.com/yargs/yargs-parser/master/yargs-logo.png">
 
 ## Example
 
@@ -72,12 +72,14 @@
   * `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.
 
 **returns:**
 
 * `obj`: an object representing the parsed value of `args`
   * `key/value`: key value pairs for each argument and their aliases.
   * `_`: an array representing the positional arguments.
+  * [optional] `--`:  an array with arguments after the end-of-options flag `--`.
 
 ### require('yargs-parser').detailed(args, opts={})
 
@@ -100,6 +102,7 @@
 * `configuration`: the configuration loaded from the `yargs` stanza in package.json.
 
 <a name="configuration"></a>
+
 ### Configuration
 
 The yargs-parser applies several automated transformations on the keys provided
@@ -174,7 +177,7 @@
 ### parse numbers
 
 * default: `true`
-* key: 'parse-numbers'
+* key: `parse-numbers`
 
 Should keys that look like numbers be treated as such?
 
@@ -193,7 +196,7 @@
 ### boolean negation
 
 * default: `true`
-* key: 'boolean-negation'
+* key: `boolean-negation`
 
 Should variables prefixed with `--no` be treated as negations?
 
@@ -209,6 +212,84 @@
 { _: [], "no-foo": true }
 ```
 
+### duplicate arguments array
+
+* default: `true`
+* key: `duplicate-arguments-array`
+
+Should arguments be coerced into an array when duplicated:
+
+```sh
+node example.js -x 1 -x 2
+{ _: [], x: [1, 2] }
+```
+
+_if disabled:_
+
+```sh
+node example.js -x 1 -x 2
+{ _: [], x: 2 }
+```
+
+### flatten duplicate arrays
+
+* default: `true`
+* key: `flatten-duplicate-arrays`
+
+Should array arguments be coerced into a single array when duplicated:
+
+```sh
+node example.js -x 1 2 -x 3 4
+{ _: [], x: [1, 2, 3, 4] }
+```
+
+_if disabled:_
+
+```sh
+node example.js -x 1 2 -x 3 4
+{ _: [], x: [[1, 2], [3, 4]] }
+```
+
+### negation prefix
+
+* default: `no-`
+* key: `negation-prefix`
+
+The prefix to use for negated boolean variables.
+
+```sh
+node example.js --no-foo
+{ _: [], foo: false }
+```
+
+_if set to `quux`:_
+
+```sh
+node example.js --quuxfoo
+{ _: [], foo: false }
+```
+
+### populate --
+
+* default: `false`.
+* key: `populate--`
+
+Should unparsed flags be stored in `--` or `_`.
+
+_If disabled:_
+
+```sh
+node example.js a -b -- x y
+{ _: [ 'a', 'x', 'y' ], b: true }
+```
+
+_If enabled:_
+
+```sh
+node example.js a -b -- x y
+{ _: [ 'a' ], '--': [ 'x', 'y' ], b: true }
+```
+
 ## Special Thanks
 
 The yargs project evolves from optimist and minimist. It owes its
diff -Nru node-yargs-parser-4.1.0/test/tokenize-arg-string.js node-yargs-parser-8.0.0/test/tokenize-arg-string.js
--- node-yargs-parser-4.1.0/test/tokenize-arg-string.js	2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/test/tokenize-arg-string.js	2017-10-05 06:20:38.000000000 +0000
@@ -3,6 +3,7 @@
 var tokenizeArgString = require('../lib/tokenize-arg-string')
 
 require('chai').should()
+var expect = require('chai').expect
 
 describe('TokenizeArgString', function () {
   it('handles unquoted string', function () {
@@ -37,4 +38,11 @@
     args[1].should.equal('hello \'world\'')
     args[2].should.equal('--bar=foo "bar"')
   })
+
+  it('multiple spaces only counted in quotes', function () {
+    var args = tokenizeArgString('foo  bar  "foo  bar"')
+    args[0].should.equal('foo')
+    expect(args[1]).equal('bar')
+    expect(args[2]).equal('foo  bar')
+  })
 })
diff -Nru node-yargs-parser-4.1.0/test/yargs-parser.js node-yargs-parser-8.0.0/test/yargs-parser.js
--- node-yargs-parser-4.1.0/test/yargs-parser.js	2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/test/yargs-parser.js	2017-10-05 06:20:38.000000000 +0000
@@ -10,12 +10,14 @@
 describe('yargs-parser', function () {
   it('should parse a "short boolean"', function () {
     var parse = parser([ '-b' ])
+    parse.should.not.have.property('--')
     parse.should.have.property('b').to.be.ok.and.be.a('boolean')
     parse.should.have.property('_').with.length(0)
   })
 
   it('should parse a "long boolean"', function () {
     var parse = parser('--bool')
+    parse.should.not.have.property('--')
     parse.should.have.property('bool', true)
     parse.should.have.property('_').with.length(0)
   })
@@ -94,7 +96,11 @@
       '--key', 'value',
       '-b', '--bool', '--no-meep', '--multi=baz',
       '--', '--not-a-flag', '-', '-h', '-multi', '--', 'eek'
-    ])
+    ], {
+      configuration: {
+        'populate--': false
+      }
+    })
     parse.should.have.property('c', true)
     parse.should.have.property('a', true)
     parse.should.have.property('t', true)
@@ -955,7 +961,7 @@
         boolean: ['b']
       })
       // Assert
-      result.should.have.property('b').that.is.a('boolean').and.is.true
+      result.should.have.property('b').that.is.a('boolean').and.is.true // eslint-disable-line
       result.should.have.property('_').and.deep.equal([123])
     })
   })
@@ -1047,11 +1053,11 @@
           }
 
           it('should set true if --flag in arg', function () {
-            parser(['--flag'], opts).flag.should.be.true
+            parser(['--flag'], opts).flag.should.be.true // eslint-disable-line
           })
 
           it('should set false if --no-flag in arg', function () {
-            parser(['--no-flag'], opts).flag.should.be.false
+            parser(['--no-flag'], opts).flag.should.be.false // eslint-disable-line
           })
 
           it('should set ' + def + ' if no flag in arg', function () {
@@ -1070,15 +1076,15 @@
         })
 
         it('should set true if --flag in arg', function () {
-          parser(['--flag'], opts).flag.should.be.true
+          parser(['--flag'], opts).flag.should.be.true // eslint-disable-line
         })
 
         it('should set false if --no-flag in arg', function () {
-          parser(['--no-flag'], opts).flag.should.be.false
+          parser(['--no-flag'], opts).flag.should.be.false // eslint-disable-line
         })
 
         it('should set false if no flag in arg', function () {
-          parser([], opts).flag.should.be.false
+          parser([], opts).flag.should.be.false // eslint-disable-line
         })
       })
 
@@ -1135,8 +1141,8 @@
         it('should provide options with dashes as camelCase properties', function () {
           var result = parser(['--some-option'])
 
-          result.should.have.property('some-option').that.is.a('boolean').and.is.true
-          result.should.have.property('someOption').that.is.a('boolean').and.is.true
+          result.should.have.property('some-option').that.is.a('boolean').and.is.true // eslint-disable-line
+          result.should.have.property('someOption').that.is.a('boolean').and.is.true // eslint-disable-line
         })
       }
 
@@ -1156,8 +1162,8 @@
           }
         })
 
-        result.should.have.property('some-option').that.is.a('boolean').and.is.true
-        result.should.have.property('someOption').that.is.a('boolean').and.is.true
+        result.should.have.property('some-option').that.is.a('boolean').and.is.true // eslint-disable-line
+        result.should.have.property('someOption').that.is.a('boolean').and.is.true // eslint-disable-line
       })
 
       it('should provide defaults of options with dashes as camelCase properties', function () {
@@ -1329,13 +1335,13 @@
         count: 'v',
         default: { v: undefined }
       })
-      expect(parsed.v).to.be.undefined
+      expect(parsed.v).to.be.undefined // eslint-disable-line
 
       parsed = parser([], {
         count: 'v',
         default: { v: null }
       })
-      expect(parsed.v).to.be.null
+      expect(parsed.v).to.be.null // eslint-disable-line
 
       parsed = parser([], {
         count: 'v',
@@ -1374,11 +1380,16 @@
   })
 
   describe('array', function () {
-    it('should group values into an array if the same option is specified multiple times', function () {
-      var parse = parser(['-v', 'a', '-v', 'b', '-v', 'c'])
+    it('should group values into an array if the same option is specified multiple times (duplicate-arguments-array=true)', function () {
+      var parse = parser(['-v', 'a', '-v', 'b', '-v', 'c'], {configuration: {'duplicate-arguments-array': true}})
       parse.should.have.property('v').and.deep.equal(['a', 'b', 'c'])
       parse.should.have.property('_').with.length(0)
     })
+    it('should keep only the last value if the same option is specified multiple times (duplicate-arguments-false)', function () {
+      var parse = parser(['-v', 'a', '-v', 'b', '-v', 'c'], {configuration: {'duplicate-arguments-array': false}})
+      parse.should.have.property('v').and.equal('c')
+      parse.should.have.property('_').with.length(0)
+    })
 
     it('should default an array to an empty array if passed as first option followed by another', function () {
       var result = parser(['-a', '-b'], {
@@ -1623,8 +1634,8 @@
 
       result.eggs.should.equal('sam')
       result.ham.should.equal('iam')
-      expect(result.oneFish).to.be.undefined
-      expect(result.redFish).to.be.undefined
+      expect(result.oneFish).to.be.undefined // eslint-disable-line
+      expect(result.redFish).to.be.undefined // eslint-disable-line
     })
 
     it('should set aliases for options defined by env var', function () {
@@ -1692,7 +1703,7 @@
     })
 
     var jsonPath = path.resolve(__dirname, './fixtures/config.json')
-    it('should prefer config file value over env var', function () {
+    it('should prefer environment variables over config file', function () {
       process.env.CFG_HERP = 'zerp'
       var result = parser(['--cfg', jsonPath], {
         envPrefix: 'CFG',
@@ -1703,7 +1714,7 @@
         }
       })
 
-      result.herp.should.equal('derp')
+      result.herp.should.equal('zerp')
     })
 
     it('should support an env var value as config file option', function () {
@@ -1886,6 +1897,31 @@
         expect(parsed['foo.bar']).to.equal('banana')
         expect(parsed).not.to.include.keys('f.bar')
       })
+
+      // addresses https://github.com/yargs/yargs/issues/716
+      it('does not append nested-object keys from config to top-level key', function () {
+        var parsed = parser([], {
+          alias: {
+            'foo': ['f']
+          },
+          configuration: {
+            'dot-notation': false
+          },
+          configObjects: [
+            {
+              'website.com': {
+                a: 'b',
+                b: 'c'
+              }
+            }
+          ]
+        })
+
+        parsed['website.com'].should.deep.equal({
+          a: 'b',
+          b: 'c'
+        })
+      })
     })
 
     describe('parse numbers', function () {
@@ -1919,6 +1955,17 @@
         })
         expect(parsed._[0]).to.equal('5')
       })
+
+      it('parses number if option explicitly set to number type', function () {
+        var parsed = parser(['--foo', '5', '--bar', '6'], {
+          number: 'bar',
+          configuration: {
+            'parse-numbers': false
+          }
+        })
+        expect(parsed['foo']).to.equal('5')
+        expect(parsed['bar']).to.equal(6)
+      })
     })
 
     describe('boolean negation', function () {
@@ -1932,6 +1979,295 @@
         parsed['no-dice'].should.equal(true)
         expect(parsed.dice).to.equal(undefined)
       })
+
+      it('negates boolean arguments with correct prefix', function () {
+        var parsed = parser(['--foodice'], {
+          configuration: {
+            'negation-prefix': 'foo'
+          }
+        })
+
+        expect(parsed['dice']).to.equal(false)
+      })
+    })
+
+    describe('duplicate arguments array', function () {
+      it('adds duplicate argument to array', function () {
+        var parsed = parser('-x a -x b', {
+          configuration: {
+            'duplicate-arguments-array': true
+          }
+        })
+
+        parsed['x'].should.deep.equal(['a', 'b'])
+      })
+      it('keeps only last argument', function () {
+        var parsed = parser('-x a -x b', {
+          configuration: {
+            'duplicate-arguments-array': false
+          }
+        })
+
+        parsed['x'].should.equal('b')
+      })
+    })
+
+    describe('flatten duplicate arrays', function () {
+      it('flattens duplicate array type', function () {
+        var parsed = parser('-x a b -x c d', {
+          array: ['x'],
+          configuration: {
+            'flatten-duplicate-arrays': true
+          }
+        })
+
+        parsed['x'].should.deep.equal(['a', 'b', 'c', 'd'])
+      })
+      it('nests duplicate array types', function () {
+        var parsed = parser('-x a b -x c d', {
+          array: ['x'],
+          configuration: {
+            'flatten-duplicate-arrays': false
+          }
+        })
+
+        parsed['x'].should.deep.equal([['a', 'b'], ['c', 'd']])
+      })
+      it('doesn\'t nests single arrays', function () {
+        var parsed = parser('-x a b', {
+          array: ['x'],
+          configuration: {
+            'flatten-duplicate-arrays': false
+          }
+        })
+
+        parsed['x'].should.deep.equal(['a', 'b'])
+      })
+
+      it('flattens duplicate array type, when argument uses dot notation', function () {
+        var parsed = parser('-x.foo a -x.foo b', {
+          array: ['x.foo'],
+          configuration: {
+            'flatten-duplicate-arrays': true
+          }
+        })
+
+        parsed['x'].should.deep.equal({foo: ['a', 'b']})
+      })
+    })
+
+    describe('duplicate-arguments-array VS flatten-duplicate-arrays', function () {
+      /*
+        duplicate=false, flatten=false
+          type=array
+            [-x 1 2 3]          => [1, 2, 3]
+            [-x 1 2 3 -x 2 3 4] => [2, 3, 4]
+          type=string/number/etc
+            [-x 1 -x 2 -x 3]    => 3
+
+        duplicate=false, flatten=true
+          type=array
+            [-x 1 2 3]          => [1, 2, 3]
+            [-x 1 2 3 -x 2 3 4] => [2, 3, 4]
+          type=string/number/etc
+            [-x 1 -x 2 -x 3]    => 3
+
+        duplicate=true, flatten=true
+          type=array
+            [-x 1 2 3]          => [1, 2, 3]
+            [-x 1 2 3 -x 2 3 4] => [1, 2, 3, 2, 3, 4]
+          type=string/number/etc
+            [-x 1 -x 2 -x 3]    => [1, 2, 3]
+
+        duplicate=true, flatten=false
+          type=array
+            [-x 1 2 3]          => [1, 2, 3]
+            [-x 1 2 3 -x 2 3 4] => [[1, 2, 3], [2, 3, 4]]
+          type=string/number/etc
+            [-x 1 -x 2 -x 3]    => [1, 2, 3]
+      */
+      describe('duplicate=false, flatten=false,', function () {
+        describe('type=array', function () {
+          it('[-x 1 2 3] => [1, 2, 3]', function () {
+            var parsed = parser('-x 1 2 3', {
+              array: ['x'],
+              configuration: {
+                'duplicate-arguments-array': false,
+                'flatten-duplicate-arrays': false
+              }
+            })
+            parsed['x'].should.deep.equal([1, 2, 3])
+          })
+          it('[-x 1 2 3 -x 2 3 4] => [2, 3, 4]', function () {
+            var parsed = parser('-x 1 2 3 -x 2 3 4', {
+              array: ['x'],
+              configuration: {
+                'duplicate-arguments-array': false,
+                'flatten-duplicate-arrays': false
+              }
+            })
+            parsed['x'].should.deep.equal([2, 3, 4])
+          })
+        })
+        describe('type=number', function () {
+          it('[-x 1 -x 2 -x 3] => 3', function () {
+            var parsed = parser('-x 1 -x 2 -x 3', {
+              number: 'x',
+              configuration: {
+                'duplicate-arguments-array': false,
+                'flatten-duplicate-arrays': false
+              }
+            })
+            parsed['x'].should.deep.equal(3)
+          })
+        })
+      })
+      describe('duplicate=false, flatten=true,', function () {
+        describe('type=array', function () {
+          it('[-x 1 2 3] => [1, 2, 3]', function () {
+            var parsed = parser('-x 1 2 3', {
+              array: ['x'],
+              configuration: {
+                'duplicate-arguments-array': false,
+                'flatten-duplicate-arrays': true
+              }
+            })
+            parsed['x'].should.deep.equal([1, 2, 3])
+          })
+          it('[-x 1 2 3 -x 2 3 4] => [2, 3, 4]', function () {
+            var parsed = parser('-x 1 2 3 -x 2 3 4', {
+              array: ['x'],
+              configuration: {
+                'duplicate-arguments-array': false,
+                'flatten-duplicate-arrays': true
+              }
+            })
+            parsed['x'].should.deep.equal([2, 3, 4])
+          })
+        })
+        describe('type=number', function () {
+          it('[-x 1 -x 2 -x 3] => 3', function () {
+            var parsed = parser('-x 1 -x 2 -x 3', {
+              number: 'x',
+              configuration: {
+                'duplicate-arguments-array': false,
+                'flatten-duplicate-arrays': true
+              }
+            })
+            parsed['x'].should.deep.equal(3)
+          })
+        })
+      })
+      describe('duplicate=true, flatten=true,', function () {
+        describe('type=array', function () {
+          it('[-x 1 2 3] => [1, 2, 3]', function () {
+            var parsed = parser('-x 1 2 3', {
+              array: ['x'],
+              configuration: {
+                'duplicate-arguments-array': true,
+                'flatten-duplicate-arrays': true
+              }
+            })
+            parsed['x'].should.deep.equal([1, 2, 3])
+          })
+          it('[-x 1 2 3 -x 2 3 4] => [1, 2, 3, 2, 3, 4]', function () {
+            var parsed = parser('-x 1 2 3 -x 2 3 4', {
+              array: ['x'],
+              configuration: {
+                'duplicate-arguments-array': true,
+                'flatten-duplicate-arrays': true
+              }
+            })
+            parsed['x'].should.deep.equal([1, 2, 3, 2, 3, 4])
+          })
+        })
+        describe('type=number', function () {
+          it('[-x 1 -x 2 -x 3] => [1, 2, 3]', function () {
+            var parsed = parser('-x 1 -x 2 -x 3', {
+              number: 'x',
+              configuration: {
+                'duplicate-arguments-array': true,
+                'flatten-duplicate-arrays': true
+              }
+            })
+            parsed['x'].should.deep.equal([1, 2, 3])
+          })
+        })
+      })
+      describe('duplicate=true, flatten=false,', function () {
+        describe('type=array', function () {
+          it('[-x 1 -x 2 -x 3] => [1, 2, 3]', function () {
+            var parsed = parser('-x 1 -x 2 -x 3', {
+              array: ['x'],
+              configuration: {
+                'duplicate-arguments-array': true,
+                'flatten-duplicate-arrays': false
+              }
+            })
+            parsed['x'].should.deep.equal([1, 2, 3])
+          })
+          it('[-x 1 2 3 -x 2 3 4] => [[1, 2, 3], [ 2, 3, 4]]', function () {
+            var parsed = parser('-x 1 2 3 -x 2 3 4', {
+              array: ['x'],
+              configuration: {
+                'duplicate-arguments-array': true,
+                'flatten-duplicate-arrays': false
+              }
+            })
+            parsed['x'].should.deep.equal([[1, 2, 3], [2, 3, 4]])
+          })
+        })
+        describe('type=number', function () {
+          it('[-x 1 -x 2 -x 3] => [1, 2, 3]', function () {
+            var parsed = parser('-x 1 -x 2 -x 3', {
+              number: 'x',
+              configuration: {
+                'duplicate-arguments-array': true,
+                'flatten-duplicate-arrays': false
+              }
+            })
+            parsed['x'].should.deep.equal([1, 2, 3])
+          })
+        })
+      })
+    })
+
+    describe('populate--', function () {
+      it('should populate "_" by default', function () {
+        var result = parser([
+          'bare',
+          '--', '-h', 'eek', '--'
+        ])
+        result.should.have.property('_').and.deep.equal(['bare', '-h', 'eek', '--'])
+        result.should.not.have.property('--')
+      })
+
+      it('should populate the "--" if populate-- is "true"', function () {
+        var result = parser([
+          '--name=meowmers', 'bare', '-cats', 'woo', 'moxy',
+          '-h', 'awesome', '--multi=quux',
+          '--key', 'value',
+          '-b', '--bool', '--no-meep', '--multi=baz',
+          '--', '--not-a-flag', '-', '-h', '-multi', '--', 'eek'
+        ], {
+          configuration: {
+            'populate--': true
+          }
+        })
+        result.should.have.property('c', true)
+        result.should.have.property('a', true)
+        result.should.have.property('t', true)
+        result.should.have.property('s', 'woo')
+        result.should.have.property('h', 'awesome')
+        result.should.have.property('b', true)
+        result.should.have.property('bool', true)
+        result.should.have.property('key', 'value')
+        result.should.have.property('multi').and.deep.equal(['quux', 'baz'])
+        result.should.have.property('meep', false)
+        result.should.have.property('name', 'meowmers')
+        result.should.have.property('_').and.deep.equal(['bare', 'moxy'])
+        result.should.have.property('--').and.deep.equal(['--not-a-flag', '-', '-h', '-multi', '--', 'eek'])
+      })
     })
   })
 
@@ -2115,4 +2451,17 @@
     })
     argv.a.should.deep.equal(['a.txt', 'b.txt'])
   })
+
+  // see: https://github.com/yargs/yargs/issues/963
+  it('does not magically convert numeric strings larger than Number.MAX_SAFE_INTEGER', () => {
+    const argv = parser([ '--foo', '93940495950949399948393' ])
+    argv.foo.should.equal('93940495950949399948393')
+  })
+
+  it('converts numeric options larger than Number.MAX_SAFE_INTEGER to number', () => {
+    const argv = parser([ '--foo', '93940495950949399948393' ], {
+      number: ['foo']
+    })
+    argv.foo.should.equal(9.39404959509494e+22)
+  })
 })
diff -Nru node-yargs-parser-4.1.0/.travis.yml node-yargs-parser-8.0.0/.travis.yml
--- node-yargs-parser-4.1.0/.travis.yml	2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/.travis.yml	2017-10-05 06:20:38.000000000 +0000
@@ -2,9 +2,8 @@
 os:
   - linux
 node_js:
-  - "0.10"
-  - "0.12"
-  - "4.1"
+  - "4"
+  - "6"
   - "node"
 after_script: npm run coverage
 deploy: