rollup 2.0.3 → 2.1.0

package/dist/bin/rollup

@@ -2,8 +2,8 @@
 
 /*
   @license
-	Rollup.js v2.0.3
-	Tue, 10 Mar 2020 07:01:48 GMT - commit 3ef6f073e4b54da2b2e61de5e3fd66f9f7352bca
+	Rollup.js v2.1.0
+	Wed, 18 Mar 2020 05:17:01 GMT - commit f8bc01847155ccf69f9e772ee99fc0905848548f
 
 
 	https://github.com/rollup/rollup
@@ -121,13 +121,13 @@ var tokenizeArgString = function (argString) {
 
   argString = argString.trim();
 
-  var i = 0;
-  var prevC = null;
-  var c = null;
-  var opening = null;
-  var args = [];
+  let i = 0;
+  let prevC = null;
+  let c = null;
+  let opening = null;
+  const args = [];
 
-  for (var ii = 0; ii < argString.length; ii++) {
+  for (let ii = 0; ii < argString.length; ii++) {
     prevC = c;
     c = argString.charAt(ii);
 
@@ -155,58 +155,59 @@ var tokenizeArgString = function (argString) {
 };
 
 function parse (args, opts) {
-  if (!opts) opts = {};
+  opts = Object.assign(Object.create(null), 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 = Object.assign({
-    'short-option-groups': true,
+  const aliases = combineAliases(Object.assign(Object.create(null), opts.alias));
+  const configuration = Object.assign({
+    'boolean-negation': true,
     'camel-case-expansion': true,
+    'combine-arrays': false,
     'dot-notation': true,
-    'parse-numbers': true,
-    'boolean-negation': true,
-    'negation-prefix': 'no-',
     'duplicate-arguments-array': true,
     'flatten-duplicate-arrays': true,
+    'greedy-arrays': true,
+    'halt-at-non-option': false,
+    'nargs-eats-options': false,
+    'negation-prefix': 'no-',
+    'parse-numbers': true,
     'populate--': false,
-    'combine-arrays': false,
     'set-placeholder-key': false,
-    'halt-at-non-option': false,
+    'short-option-groups': true,
     'strip-aliased': false,
     'strip-dashed': false,
     'unknown-options-as-args': false
   }, opts.configuration);
-  var defaults = opts.default || {};
-  var configObjects = opts.configObjects || [];
-  var envPrefix = opts.envPrefix;
-  var notFlagsOption = configuration['populate--'];
-  var notFlagsArgv = notFlagsOption ? '--' : '_';
-  var newAliases = {};
-  var defaulted = {};
+  const defaults = Object.assign(Object.create(null), opts.default);
+  const configObjects = opts.configObjects || [];
+  const envPrefix = opts.envPrefix;
+  const notFlagsOption = configuration['populate--'];
+  const notFlagsArgv = notFlagsOption ? '--' : '_';
+  const newAliases = Object.create(null);
+  const defaulted = Object.create(null);
   // allow a i18n handler to be passed in, default to a fake one (util.format).
-  var __ = opts.__ || _events_commonjsExternal.require$$1.format;
-  var error = null;
-  var flags = {
-    aliases: {},
-    arrays: {},
-    bools: {},
-    strings: {},
-    numbers: {},
-    counts: {},
-    normalize: {},
-    configs: {},
-    nargs: {},
-    coercions: {},
+  const __ = opts.__ || _events_commonjsExternal.require$$1.format;
+  const flags = {
+    aliases: Object.create(null),
+    arrays: Object.create(null),
+    bools: Object.create(null),
+    strings: Object.create(null),
+    numbers: Object.create(null),
+    counts: Object.create(null),
+    normalize: Object.create(null),
+    configs: Object.create(null),
+    nargs: Object.create(null),
+    coercions: Object.create(null),
     keys: []
   };
-  var negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
-  var negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)')
+  const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
+  const negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)')
 
   ;[].concat(opts.array).filter(Boolean).forEach(function (opt) {
-    var key = opt.key || opt;
+    const key = opt.key || opt;
 
     // assign to flags[bools|strings|numbers]
     const assignment = Object.keys(opt).map(function (key) {
@@ -282,19 +283,25 @@ function parse (args, opts) {
     });
   });
 
+  let error = null;
   checkConfiguration();
 
-  var argv = { _: [] };
-  var notFlags = [];
+  let notFlags = [];
 
-  for (var i = 0; i < args.length; i++) {
-    var arg = args[i];
-    var broken;
-    var key;
-    var letters;
-    var m;
-    var next;
-    var value;
+  const argv = Object.assign(Object.create(null), { _: [] });
+  // TODO(bcoe): for the first pass at removing object prototype  we didn't
+  // remove all prototypes from objects returned by this API, we might want
+  // to gradually move towards doing so.
+  const argvReturn = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    let broken;
+    let key;
+    let letters;
+    let m;
+    let next;
+    let value;
 
     // any unknown option (except for end-of-options, "--")
     if (arg !== '--' && isUnknownOptionAsArg(arg)) {
@@ -308,14 +315,14 @@ function parse (args, opts) {
       // http://stackoverflow.com/a/1068308/13216
       m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
 
-      // nargs format = '--f=monkey washing cat'
-      if (checkAllAliases(m[1], flags.nargs)) {
-        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)) {
+      if (checkAllAliases(m[1], flags.arrays)) {
         args.splice(i + 1, 0, m[2]);
         i = eatArray(i, m[1], args);
+      } else if (checkAllAliases(m[1], flags.nargs)) {
+        // nargs format = '--f=monkey washing cat'
+        args.splice(i + 1, 0, m[2]);
+        i = eatNargs(i, m[1], args);
       } else {
         setArg(m[1], m[2]);
       }
@@ -329,13 +336,13 @@ function parse (args, opts) {
     )) {
       key = arg.match(/^--?(.+)/)[1];
 
-      // nargs format = '--foo a b c'
-      // 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)) {
+      if (checkAllAliases(key, flags.arrays)) {
+        // array format = '--foo a b c'
         i = eatArray(i, key, args);
+      } else if (checkAllAliases(key, flags.nargs) !== false) {
+        // nargs format = '--foo a b c'
+        // should be truthy even if: flags.nargs[key] === 0
+        i = eatNargs(i, key, args);
       } else {
         next = args[i + 1];
 
@@ -375,21 +382,21 @@ function parse (args, opts) {
       letters = arg.slice(1, -1).split('');
       broken = false;
 
-      for (var j = 0; j < letters.length; j++) {
+      for (let j = 0; j < letters.length; j++) {
         next = arg.slice(j + 2);
 
         if (letters[j + 1] && letters[j + 1] === '=') {
           value = arg.slice(j + 3);
           key = letters[j];
 
-          // nargs format = '-f=monkey washing cat'
-          if (checkAllAliases(key, flags.nargs)) {
-            args.splice(i + 1, 0, value);
-            i = eatNargs(i, key, args);
-          // array format = '-f=a b c'
-          } else if (checkAllAliases(key, flags.arrays)) {
+          if (checkAllAliases(key, flags.arrays)) {
+            // array format = '-f=a b c'
             args.splice(i + 1, 0, value);
             i = eatArray(i, key, args);
+          } else if (checkAllAliases(key, flags.nargs)) {
+            // nargs format = '-f=monkey washing cat'
+            args.splice(i + 1, 0, value);
+            i = eatNargs(i, key, args);
           } else {
             setArg(key, value);
           }
@@ -423,13 +430,13 @@ function parse (args, opts) {
       key = arg.slice(-1)[0];
 
       if (!broken && key !== '-') {
-        // nargs format = '-f a b c'
-        // 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)) {
+        if (checkAllAliases(key, flags.arrays)) {
+          // array format = '-f a b c'
           i = eatArray(i, key, args);
+        } else if (checkAllAliases(key, flags.nargs) !== false) {
+          // nargs format = '-f a b c'
+          // should be truthy even if: flags.nargs[key] === 0
+          i = eatNargs(i, key, args);
         } else {
           next = args[i + 1];
 
@@ -447,6 +454,12 @@ function parse (args, opts) {
           }
         }
       }
+    } else if (arg.match(/^-[0-9]$/) &&
+      arg.match(negative) &&
+      checkAllAliases(arg.slice(1), flags.bools)) {
+      // single-digit boolean alias, e.g: xargs -0
+      key = arg.slice(1);
+      setArg(key, defaultValue(key));
     } else if (arg === '--') {
       notFlags = args.slice(i + 1);
       break
@@ -502,24 +515,32 @@ function parse (args, opts) {
   // how many arguments should we consume, based
   // on the nargs option?
   function eatNargs (i, key, args) {
-    var ii;
-    const toEat = checkAllAliases(key, flags.nargs);
+    let ii;
+    let toEat = checkAllAliases(key, flags.nargs);
+    // NaN has a special meaning for the array type, indicating that one or
+    // more values are expected.
+    toEat = isNaN(toEat) ? 1 : toEat;
 
     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]/) || args[ii].match(negative) || isUnknownOptionAsArg(args[ii])) available++;
-      else break
+    let available = 0;
+    if (configuration['nargs-eats-options']) {
+      // classic behavior, yargs eats positional and dash arguments.
+      if (args.length - (i + 1) < toEat) error = Error(__('Not enough arguments following: %s', key));
+      available = toEat;
+    } else {
+      // nargs will not consume flag arguments, e.g., -abc, --foo,
+      // and terminates when one is observed.
+      for (ii = i + 1; ii < args.length; ii++) {
+        if (!args[ii].match(/^-[^0-9]/) || args[ii].match(negative) || isUnknownOptionAsArg(args[ii])) available++;
+        else break
+      }
+      if (available < toEat) error = Error(__('Not enough arguments following: %s', key));
     }
 
-    if (available < toEat) error = Error(__('Not enough arguments following: %s', key));
-
     const consumed = Math.min(available, toEat);
     for (ii = i + 1; ii < (consumed + i + 1); ii++) {
       setArg(key, args[ii]);
@@ -534,40 +555,51 @@ function parse (args, opts) {
   function eatArray (i, key, args) {
     let argsToSet = [];
     let next = args[i + 1];
+    // If both array and nargs are configured, enforce the nargs count:
+    const nargsCount = checkAllAliases(key, flags.nargs);
 
     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)) {
+      if (defaults[key] !== undefined) {
         const defVal = defaults[key];
         argsToSet = Array.isArray(defVal) ? defVal : [defVal];
       }
     } else {
-      for (var ii = i + 1; ii < args.length; ii++) {
+      for (let 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));
+        if (!configuration['greedy-arrays'] ||
+            (nargsCount && argsToSet.length >= nargsCount)) break
       }
     }
 
+    // If both array and nargs are configured, create an error if less than
+    // nargs positionals were found. NaN has special meaning, indicating
+    // that at least one value is required (more are okay).
+    if ((nargsCount && argsToSet.length < nargsCount) ||
+        (isNaN(nargsCount) && argsToSet.length === 0)) {
+      error = Error(__('Not enough arguments following: %s', key));
+    }
+
     setArg(key, argsToSet);
     return i
   }
 
   function setArg (key, val) {
     if (/-/.test(key) && configuration['camel-case-expansion']) {
-      var alias = key.split('.').map(function (prop) {
+      const alias = key.split('.').map(function (prop) {
         return camelcase(prop)
       }).join('.');
       addNewAlias(key, alias);
     }
 
-    var value = processValue(key, val);
-
-    var splitKey = key.split('.');
+    const value = processValue(key, val);
+    const splitKey = key.split('.');
     setKey(argv, splitKey, value);
 
     // handle populating aliases of the full key
@@ -584,7 +616,7 @@ function parse (args, opts) {
         x = x.split('.');
 
         // expand alias with nested objects in key
-        var a = [].concat(splitKey);
+        const a = [].concat(splitKey);
         a.shift(); // nuke the old key.
         x = x.concat(a);
 
@@ -594,14 +626,16 @@ function parse (args, opts) {
 
     // Set normalize getter and setter when key is in 'normalize' but isn't an array
     if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
-      var keys = [key].concat(flags.aliases[key] || []);
+      const keys = [key].concat(flags.aliases[key] || []);
       keys.forEach(function (key) {
-        argv.__defineSetter__(key, function (v) {
-          val = _events_commonjsExternal.sysPath.normalize(v);
-        });
-
-        argv.__defineGetter__(key, function () {
-          return typeof val === 'string' ? _events_commonjsExternal.sysPath.normalize(val) : val
+        Object.defineProperty(argvReturn, key, {
+          enumerable: true,
+          get () {
+            return val
+          },
+          set (value) {
+            val = typeof value === 'string' ? _events_commonjsExternal.sysPath.normalize(value) : value;
+          }
         });
       });
     }
@@ -631,7 +665,7 @@ function parse (args, opts) {
       if (typeof val === 'string') val = val === 'true';
     }
 
-    var value = Array.isArray(val)
+    let value = Array.isArray(val)
       ? val.map(function (v) { return maybeCoerceNumber(key, v) })
       : maybeCoerceNumber(key, val);
 
@@ -661,18 +695,18 @@ function parse (args, opts) {
   // set args from config.json file, this should be
   // applied last so that defaults can be applied.
   function setConfig (argv) {
-    var configLookup = {};
+    const configLookup = Object.create(null);
 
     // expand defaults/aliases, in-case any happen to reference
     // the config.json file.
     applyDefaultsAndAliases(configLookup, flags.aliases, defaults);
 
     Object.keys(flags.configs).forEach(function (configKey) {
-      var configPath = argv[configKey] || configLookup[configKey];
+      const configPath = argv[configKey] || configLookup[configKey];
       if (configPath) {
         try {
-          var config = null;
-          var resolvedConfigPath = _events_commonjsExternal.sysPath.resolve(process.cwd(), configPath);
+          let config = null;
+          const resolvedConfigPath = _events_commonjsExternal.sysPath.resolve(process.cwd(), configPath);
 
           if (typeof flags.configs[configKey] === 'function') {
             try {
@@ -700,8 +734,8 @@ function parse (args, opts) {
   // it recursively checks nested objects.
   function setConfigObject (config, prev) {
     Object.keys(config).forEach(function (key) {
-      var value = config[key];
-      var fullKey = prev ? prev + '.' + key : key;
+      const value = config[key];
+      const fullKey = prev ? prev + '.' + key : key;
 
       // if the value is an inner object and we have dot-notation
       // enabled, treat inner objects in config the same as
@@ -730,11 +764,11 @@ function parse (args, opts) {
   function applyEnvVars (argv, configOnly) {
     if (typeof envPrefix === 'undefined') return
 
-    var prefix = typeof envPrefix === 'string' ? envPrefix : '';
+    const prefix = typeof envPrefix === 'string' ? envPrefix : '';
     Object.keys(process.env).forEach(function (envVar) {
       if (prefix === '' || envVar.lastIndexOf(prefix, 0) === 0) {
         // get array of nested keys and convert them to camel case
-        var keys = envVar.split('__').map(function (key, i) {
+        const keys = envVar.split('__').map(function (key, i) {
           if (i === 0) {
             key = key.substring(prefix.length);
           }
@@ -749,16 +783,17 @@ function parse (args, opts) {
   }
 
   function applyCoercions (argv) {
-    var coerce;
-    var applied = {};
+    let coerce;
+    const applied = new Set();
     Object.keys(argv).forEach(function (key) {
-      if (!applied.hasOwnProperty(key)) { // If we haven't already coerced this option via one of its aliases
+      if (!applied.has(key)) { // If we haven't already coerced this option via one of its aliases
         coerce = checkAllAliases(key, flags.coercions);
         if (typeof coerce === 'function') {
           try {
-            var value = maybeCoerceNumber(key, coerce(argv[key]))
+            const value = maybeCoerceNumber(key, coerce(argv[key]))
             ;([].concat(flags.aliases[key] || [], key)).forEach(ali => {
-              applied[ali] = argv[ali] = value;
+              applied.add(ali);
+              argv[ali] = value;
             });
           } catch (err) {
             error = err;
@@ -792,7 +827,7 @@ function parse (args, opts) {
   }
 
   function hasKey (obj, keys) {
-    var o = obj;
+    let o = obj;
 
     if (!configuration['dot-notation']) keys = [keys.join('.')];
 
@@ -800,18 +835,22 @@ function parse (args, opts) {
       o = (o[key] || {});
     });
 
-    var key = keys[keys.length - 1];
+    const key = keys[keys.length - 1];
 
     if (typeof o !== 'object') return false
     else return key in o
   }
 
   function setKey (obj, keys, value) {
-    var o = obj;
+    let o = obj;
 
     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] = {};
       }
@@ -831,11 +870,13 @@ 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]);
 
-    var isTypeArray = checkAllAliases(keys.join('.'), flags.arrays);
-    var isValueArray = Array.isArray(value);
-    var duplicate = configuration['duplicate-arguments-array'];
+    const isTypeArray = checkAllAliases(keys.join('.'), flags.arrays);
+    const isValueArray = Array.isArray(value);
+    let duplicate = configuration['duplicate-arguments-array'];
 
     // nargs has higher priority than duplicate
     if (!duplicate && checkAllAliases(key, flags.nargs)) {
@@ -857,8 +898,12 @@ function parse (args, opts) {
       }
     } else if (o[key] === undefined && isTypeArray) {
       o[key] = isValueArray ? value : [value];
-    } else if (duplicate && !(o[key] === undefined || checkAllAliases(key, flags.counts))) {
-      o[key] = [ o[key], value ];
+    } else if (duplicate && !(
+      o[key] === undefined ||
+        checkAllAliases(key, flags.counts) ||
+        checkAllAliases(key, flags.bools)
+    )) {
+      o[key] = [o[key], value];
     } else {
       o[key] = value;
     }
@@ -877,7 +922,7 @@ function parse (args, opts) {
         // For "--option-name", also set argv.optionName
         flags.aliases[key].concat(key).forEach(function (x) {
           if (/-/.test(x) && configuration['camel-case-expansion']) {
-            var c = camelcase(x);
+            const c = camelcase(x);
             if (c !== key && flags.aliases[key].indexOf(c) === -1) {
               flags.aliases[key].push(c);
               newAliases[c] = true;
@@ -887,7 +932,7 @@ 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, '-');
+            const c = decamelize(x, '-');
             if (c !== key && flags.aliases[key].indexOf(c) === -1) {
               flags.aliases[key].push(c);
               newAliases[c] = true;
@@ -905,24 +950,23 @@ function parse (args, opts) {
 
   // return the 1st set flag for any of a key's aliases (or false if no flag set)
   function checkAllAliases (key, flag) {
-    var toCheck = [].concat(flags.aliases[key] || [], key);
-    let setAlias = toCheck.find(key => flag.hasOwnProperty(key));
+    const toCheck = [].concat(flags.aliases[key] || [], key);
+    const keys = Object.keys(flag);
+    const setAlias = toCheck.find(key => keys.includes(key));
     return setAlias ? flag[setAlias] : false
   }
 
   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]));
-
+    const toCheck = [].concat(Object.keys(flags).map(k => flags[k]));
     return toCheck.some(function (flag) {
-      return flag[key]
+      return Array.isArray(flag) ? flag.includes(key) : flag[key]
     })
   }
 
   function hasFlagsMatching (arg, ...patterns) {
-    var toCheck = [].concat(...patterns);
+    const toCheck = [].concat(...patterns);
     return toCheck.some(function (pattern) {
-      var match = arg.match(pattern);
+      const match = arg.match(pattern);
       return match && hasAnyFlag(match[1])
     })
   }
@@ -931,10 +975,10 @@ function parse (args, opts) {
   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++) {
+    let hasAllFlags = true;
+    let next;
+    const letters = arg.slice(1).split('');
+    for (let j = 0; j < letters.length; j++) {
       next = arg.slice(j + 2);
 
       if (!hasAnyFlag(letters[j])) {
@@ -968,7 +1012,7 @@ function parse (args, opts) {
     // e.g. '-a-'
     const flagEndingInHyphen = /^-+([^=]+?)-$/;
     // e.g. '-abc123'
-    const flagEndingInDigits = /^-+([^=]+?)\d+$/;
+    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
@@ -990,7 +1034,7 @@ function parse (args, opts) {
   // 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) {
-    var def = {
+    const def = {
       boolean: true,
       string: '',
       number: undefined,
@@ -1002,13 +1046,11 @@ function parse (args, opts) {
 
   // given a flag, enforce a default type.
   function guessType (key) {
-    var type = 'boolean';
-
+    let 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
   }
 
@@ -1042,11 +1084,11 @@ function parse (args, opts) {
   }
 
   return {
-    argv: argv,
+    argv: Object.assign(argvReturn, argv),
     error: error,
-    aliases: flags.aliases,
-    newAliases: newAliases,
-    defaulted: defaulted,
+    aliases: Object.assign({}, flags.aliases),
+    newAliases: Object.assign({}, newAliases),
+    defaulted: Object.assign({}, defaulted),
     configuration: configuration
   }
 }
@@ -1054,9 +1096,9 @@ function parse (args, opts) {
 // if any aliases reference each other, we should
 // merge them together.
 function combineAliases (aliases) {
-  var aliasArrays = [];
-  var change = true;
-  var combined = {};
+  const aliasArrays = [];
+  const combined = Object.create(null);
+  let change = true;
 
   // turn alias lookup hash {key: ['alias1', 'alias2']} into
   // a simple array ['key', 'alias1', 'alias2']
@@ -1070,9 +1112,9 @@ function combineAliases (aliases) {
   // made in an iteration.
   while (change) {
     change = false;
-    for (var i = 0; i < aliasArrays.length; i++) {
-      for (var ii = i + 1; ii < aliasArrays.length; ii++) {
-        var intersect = aliasArrays[i].filter(function (v) {
+    for (let i = 0; i < aliasArrays.length; i++) {
+      for (let ii = i + 1; ii < aliasArrays.length; ii++) {
+        const intersect = aliasArrays[i].filter(function (v) {
           return aliasArrays[ii].indexOf(v) !== -1
         });
 
@@ -1106,8 +1148,7 @@ function increment (orig) {
 }
 
 function Parser (args, opts) {
-  var result = parse(args.slice(), opts);
-
+  const result = parse(args.slice(), opts);
   return result.argv
 }
 
@@ -1117,6 +1158,13 @@ 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
+}
+
 var yargsParser = Parser;
 
 var modules = {};