49         for (const key of Object.keys(demandedOptions)) {
50             if (!Object.prototype.hasOwnProperty.call(argv, key) ||
51                 typeof argv[key] === 'undefined') {
53                 missing[key] = demandedOptions[key];
58             for (const key of Object.keys(missing)) {
59                 const msg = missing[key];
76         Object.keys(argv).forEach(key => {
77             if (!specialKeys.includes(key) &&
78                 !Object.prototype.hasOwnProperty.call(positionalMap, key) &&
79 …        !Object.prototype.hasOwnProperty.call(yargs.getInternalMethods().getParseContext(), key) &&
80                 !self.isValidAndSomeAliasIsNotNew(key, aliases)) {
81                 unknown.push(key);
88             argv._.slice(currentContext.commands.length).forEach(key => {
89                 if (!commandKeys.includes('' + key)) {
90                     unknown.push('' + key);
99                 argv._.slice(expected).forEach(key => {
100                     key = String(key);
101                     if (!currentContext.commands.includes(key) &&
102                         !unknown.includes(key)) {
103                         unknown.push(key);
120             argv._.slice(currentContext.commands.length).forEach(key => {
121                 if (!commandKeys.includes('' + key)) {
122                     unknown.push('' + key);
134     self.isValidAndSomeAliasIsNotNew = function isValidAndSomeAliasIsNotNew(key, aliases) {  argument
135         if (!Object.prototype.hasOwnProperty.call(aliases, key)) {
139 …return [key, ...aliases[key]].some(a => !Object.prototype.hasOwnProperty.call(newAliases, a) || !n…
146         Object.keys(argv).forEach(key => {
147             if (specialKeys.indexOf(key) === -1 &&
148                 Object.prototype.hasOwnProperty.call(options.choices, key)) {
149                 [].concat(argv[key]).forEach(value => {
150                     if (options.choices[key].indexOf(value) === -1 &&
152                         invalid[key] = (invalid[key] || []).concat(value);
161         invalidKeys.forEach(key => {
162 …nt: %s, Given: %s, Choices: %s', key, usage.stringifiedValues(invalid[key]), usage.stringifiedValu…
167     self.implies = function implies(key, value) {  argument
168         argsert('<string|object> [array|number|string]', [key, value], arguments.length);
169         if (typeof key === 'object') {
170             Object.keys(key).forEach(k => {
171                 self.implies(k, key[k]);
175             yargs.global(key);
176             if (!implied[key]) {
177                 implied[key] = [];
180                 value.forEach(i => self.implies(key, i));
184                 implied[key].push(value);
208         Object.keys(implied).forEach(key => {
209             const origKey = key;
210             (implied[key] || []).forEach(value => {
211                 let key = origKey;
213                 key = keyExists(argv, key);
215                 if (key && !value) {
229     self.conflicts = function conflicts(key, value) {  argument
230         argsert('<string|object> [array|string]', [key, value], arguments.length);
231         if (typeof key === 'object') {
232             Object.keys(key).forEach(k => {
233                 self.conflicts(k, key[k]);
237             yargs.global(key);
238             if (!conflicting[key]) {
239                 conflicting[key] = [];
242                 value.forEach(i => self.conflicts(key, i));
245                 conflicting[key].push(value);
251         Object.keys(argv).forEach(key => {
252             if (conflicting[key]) {
253                 conflicting[key].forEach(value => {
254                     if (value && argv[key] !== undefined && argv[value] !== undefined) {
255                         usage.fail(__('Arguments %s and %s are mutually exclusive', key, value));
261             Object.keys(conflicting).forEach(key => {
262                 conflicting[key].forEach(value => {
264                         argv[shim.Parser.camelCase(key)] !== undefined &&
266                         usage.fail(__('Arguments %s and %s are mutually exclusive', key, value));