.gitattributes

@@ -1,2 +1 @@
-* text=auto
-*.js text eol=lf
+* text=auto eol=lf

.github/funding.yml

@@ -0,0 +1,4 @@
+github: sindresorhus
+open_collective: sindresorhus
+tidelift: npm/meow
+custom: https://sindresorhus.com/donate

.github/security.md

@@ -0,0 +1,3 @@
+# Security Policy
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.

.travis.yml

@@ -1,5 +1,5 @@
 language: node_js
 node_js:
+  - '14'
+  - '12'
   - '10'
-  - '8'
-  - '6'

estest/index.js

@@ -0,0 +1,24 @@
+import {createRequire} from 'module';
+
+const meow = createRequire(import.meta.url)('../index.js');
+
+meow(`
+	Usage
+	  $ estest <input>
+
+	Options
+	  --rainbow, -r  Include a rainbow
+
+	Examples
+	  $ estest unicorns --rainbow
+	  🌈 unicorns 🌈
+`,
+	{
+		flags: {
+			rainbow: {
+				type: 'boolean',
+				alias: 'r'
+			}
+		}
+	}
+);

estest/package.json

@@ -0,0 +1,5 @@
+{
+	"name": "estest",
+	"type": "module",
+	"version": "1.2.3"
+}

index.d.ts

@@ -0,0 +1,306 @@
+import {PackageJson} from 'type-fest';
+
+declare namespace meow {
+	type FlagType = 'string' | 'boolean' | 'number';
+
+	/**
+	Callback function to determine if a flag is required during runtime.
+
+	@param flags - Contains the flags converted to camel-case excluding aliases.
+	@param input - Contains the non-flag arguments.
+
+	@returns True if the flag is required, otherwise false.
+	*/
+	type IsRequiredPredicate = (flags: Readonly<AnyFlags>, input: readonly string[]) => boolean;
+
+	interface Flag<Type extends FlagType, Default> {
+		readonly type?: Type;
+		readonly alias?: string;
+		readonly default?: Default;
+		readonly isRequired?: boolean | IsRequiredPredicate;
+		readonly isMultiple?: boolean;
+	}
+
+	type StringFlag = Flag<'string', string>;
+	type BooleanFlag = Flag<'boolean', boolean>;
+	type NumberFlag = Flag<'number', number>;
+
+	type AnyFlag = StringFlag | BooleanFlag | NumberFlag;
+	type AnyFlags = Record<string, AnyFlag>;
+
+	interface Options<Flags extends AnyFlags> {
+		/**
+		Define argument flags.
+
+		The key is the flag name and the value is an object with any of:
+
+		- `type`: Type of value. (Possible values: `string` `boolean` `number`)
+		- `alias`: Usually used to define a short flag alias.
+		- `default`: Default value when the flag is not specified.
+		- `isRequired`: Determine if the flag is required.
+			If it's only known at runtime whether the flag is required or not you can pass a Function instead of a boolean, which based on the given flags and other non-flag arguments should decide if the flag is required.
+		- `isMultiple`: Indicates a flag can be set multiple times. Values are turned into an array. (Default: false)
+			Multiple values are provided by specifying the flag multiple times, for example, `$ foo -u rainbow -u cat`. Space- or comma-separated values are *not* supported.
+
+		@example
+		```
+		flags: {
+			unicorn: {
+				type: 'string',
+				alias: 'u',
+				default: ['rainbow', 'cat'],
+				isMultiple: true,
+				isRequired: (flags, input) => {
+					if (flags.otherFlag) {
+						return true;
+					}
+
+					return false;
+				}
+			}
+		}
+		```
+		*/
+		readonly flags?: Flags;
+
+		/**
+		Description to show above the help text. Default: The package.json `"description"` property.
+
+		Set it to `false` to disable it altogether.
+		*/
+		readonly description?: string | false;
+
+		/**
+		The help text you want shown.
+
+		The input is reindented and starting/ending newlines are trimmed which means you can use a [template literal](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/template_strings) without having to care about using the correct amount of indent.
+
+		The description will be shown above your help text automatically.
+
+		Set it to `false` to disable it altogether.
+		*/
+		readonly help?: string | false;
+
+		/**
+		Set a custom version output. Default: The package.json `"version"` property.
+
+		Set it to `false` to disable it altogether.
+		*/
+		readonly version?: string | false;
+
+		/**
+		Automatically show the help text when the `--help` flag is present. Useful to set this value to `false` when a CLI manages child CLIs with their own help text.
+
+		This option is only considered when there is only one argument in `process.argv`.
+		*/
+		readonly autoHelp?: boolean;
+
+		/**
+		Automatically show the version text when the `--version` flag is present. Useful to set this value to `false` when a CLI manages child CLIs with their own version text.
+
+		This option is only considered when there is only one argument in `process.argv`.
+		*/
+		readonly autoVersion?: boolean;
+
+		/**
+		`package.json` as an `Object`. Default: Closest `package.json` upwards.
+
+		_You most likely don't need this option._
+		*/
+		readonly pkg?: Record<string, unknown>;
+
+		/**
+		Custom arguments object.
+
+		@default process.argv.slice(2)
+		*/
+		readonly argv?: readonly string[];
+
+		/**
+		Infer the argument type.
+
+		By default, the argument `5` in `$ foo 5` becomes a string. Enabling this would infer it as a number.
+
+		@default false
+		*/
+		readonly inferType?: boolean;
+
+		/**
+		Value of `boolean` flags not defined in `argv`.
+
+		If set to `undefined`, the flags not defined in `argv` will be excluded from the result. The `default` value set in `boolean` flags take precedence over `booleanDefault`.
+
+		_Note: If used in conjunction with `isMultiple`, the default flag value is set to `[]`._
+
+		__Caution: Explicitly specifying `undefined` for `booleanDefault` has different meaning from omitting key itself.__
+
+		@example
+		```
+		import meow = require('meow');
+
+		const cli = meow(`
+			Usage
+				$ foo
+
+			Options
+				--rainbow, -r  Include a rainbow
+				--unicorn, -u  Include a unicorn
+				--no-sparkles  Exclude sparkles
+
+			Examples
+				$ foo
+				🌈 unicorns✨🌈
+		`, {
+			booleanDefault: undefined,
+			flags: {
+				rainbow: {
+					type: 'boolean',
+					default: true,
+					alias: 'r'
+				},
+					unicorn: {
+					type: 'boolean',
+					default: false,
+					alias: 'u'
+				},
+				cake: {
+					type: 'boolean',
+					alias: 'c'
+				},
+				sparkles: {
+					type: 'boolean',
+					default: true
+				}
+			}
+		});
+
+		//{
+		//	flags: {
+		//		rainbow: true,
+		//		unicorn: false,
+		//		sparkles: true
+		//	},
+		//	unnormalizedFlags: {
+		//		rainbow: true,
+		//		r: true,
+		//		unicorn: false,
+		//		u: false,
+		//		sparkles: true
+		//	},
+		//	…
+		//}
+		```
+		*/
+		readonly booleanDefault?: boolean | null | undefined;
+
+		/**
+		Whether to use [hard-rejection](https://github.com/sindresorhus/hard-rejection) or not. Disabling this can be useful if you need to handle `process.on('unhandledRejection')` yourself.
+
+		@default true
+		*/
+		readonly hardRejection?: boolean;
+	}
+
+	type TypedFlag<Flag extends AnyFlag> =
+		Flag extends {type: 'number'}
+			? number
+			: Flag extends {type: 'string'}
+				? string
+				: Flag extends {type: 'boolean'}
+					? boolean
+					: unknown;
+
+	type PossiblyOptionalFlag<Flag extends AnyFlag, FlagType> =
+		Flag extends {isRequired: true}
+			? FlagType
+			: Flag extends {default: any}
+				? FlagType
+				: FlagType | undefined;
+
+	type TypedFlags<Flags extends AnyFlags> = {
+		[F in keyof Flags]: Flags[F] extends {isMultiple: true}
+			? PossiblyOptionalFlag<Flags[F], Array<TypedFlag<Flags[F]>>>
+			: PossiblyOptionalFlag<Flags[F], TypedFlag<Flags[F]>>
+	};
+
+	interface Result<Flags extends AnyFlags> {
+		/**
+		Non-flag arguments.
+		*/
+		input: string[];
+
+		/**
+		Flags converted to camelCase excluding aliases.
+		*/
+		flags: TypedFlags<Flags> & Record<string, unknown>;
+
+		/**
+		Flags converted camelCase including aliases.
+		*/
+		unnormalizedFlags: TypedFlags<Flags> & Record<string, unknown>;
+
+		/**
+		The `package.json` object.
+		*/
+		pkg: PackageJson;
+
+		/**
+		The help text used with `--help`.
+		*/
+		help: string;
+
+		/**
+		Show the help text and exit with code.
+
+		@param exitCode - The exit code to use. Default: `2`.
+		*/
+		showHelp: (exitCode?: number) => void;
+
+		/**
+		Show the version text and exit.
+		*/
+		showVersion: () => void;
+	}
+}
+/**
+@param helpMessage - Shortcut for the `help` option.
+
+@example
+```
+#!/usr/bin/env node
+'use strict';
+import meow = require('meow');
+import foo = require('.');
+
+const cli = meow(`
+	Usage
+	  $ foo <input>
+
+	Options
+	  --rainbow, -r  Include a rainbow
+
+	Examples
+	  $ foo unicorns --rainbow
+	  🌈 unicorns 🌈
+`, {
+	flags: {
+		rainbow: {
+			type: 'boolean',
+			alias: 'r'
+		}
+	}
+});
+
+//{
+//	input: ['unicorns'],
+//	flags: {rainbow: true},
+//	...
+//}
+
+foo(cli.input[0], cli.flags);
+```
+*/
+declare function meow<Flags extends meow.AnyFlags>(helpMessage: string, options?: meow.Options<Flags>): meow.Result<Flags>;
+declare function meow<Flags extends meow.AnyFlags>(options?: meow.Options<Flags>): meow.Result<Flags>;
+
+export = meow;

index.js

@@ -1,70 +1,146 @@
 'use strict';
 const path = require('path');
-const buildMinimistOptions = require('minimist-options');
-const yargs = require('yargs-parser');
-const camelcaseKeys = require('camelcase-keys');
+const buildParserOptions = require('minimist-options');
+const parseArguments = require('yargs-parser');
+const camelCaseKeys = require('camelcase-keys');
 const decamelizeKeys = require('decamelize-keys');
 const trimNewlines = require('trim-newlines');
 const redent = require('redent');
 const readPkgUp = require('read-pkg-up');
-const loudRejection = require('loud-rejection');
+const hardRejection = require('hard-rejection');
 const normalizePackageData = require('normalize-package-data');
 
 // Prevent caching of this module so module.parent is always accurate
 delete require.cache[__filename];
-const parentDir = path.dirname(module.parent.filename);
+const parentDir = path.dirname(module.parent && module.parent.filename ? module.parent.filename : '.');
 
-module.exports = (helpMessage, options) => {
-	loudRejection();
+const isFlagMissing = (flagName, definedFlags, receivedFlags, input) => {
+	const flag = definedFlags[flagName];
+	let isFlagRequired = true;
 
-	if (typeof helpMessage === 'object' && !Array.isArray(helpMessage)) {
-		options = helpMessage;
-		helpMessage = '';
+	if (typeof flag.isRequired === 'function') {
+		isFlagRequired = flag.isRequired(receivedFlags, input);
+		if (typeof isFlagRequired !== 'boolean') {
+			throw new TypeError(`Return value for isRequired callback should be of type boolean, but ${typeof isFlagRequired} was returned.`);
+		}
 	}
 
-	options = Object.assign({
-		pkg: readPkgUp.sync({
-			cwd: parentDir,
-			normalize: false
-		}).pkg || {},
+	if (typeof receivedFlags[flagName] === 'undefined') {
+		return isFlagRequired;
+	}
+
+	return flag.isMultiple && receivedFlags[flagName].length === 0;
+};
+
+const getMissingRequiredFlags = (flags, receivedFlags, input) => {
+	const missingRequiredFlags = [];
+	if (typeof flags === 'undefined') {
+		return [];
+	}
+
+	for (const flagName of Object.keys(flags)) {
+		if (flags[flagName].isRequired && isFlagMissing(flagName, flags, receivedFlags, input)) {
+			missingRequiredFlags.push({key: flagName, ...flags[flagName]});
+		}
+	}
+
+	return missingRequiredFlags;
+};
+
+const reportMissingRequiredFlags = missingRequiredFlags => {
+	console.error(`Missing required flag${missingRequiredFlags.length > 1 ? 's' : ''}`);
+	for (const flag of missingRequiredFlags) {
+		console.error(`\t--${flag.key}${flag.alias ? `, -${flag.alias}` : ''}`);
+	}
+};
+
+const buildParserFlags = ({flags, booleanDefault}) => {
+	const parserFlags = {};
+
+	for (const [flagKey, flagValue] of Object.entries(flags)) {
+		const flag = {...flagValue};
+
+		if (
+			typeof booleanDefault !== 'undefined' &&
+			flag.type === 'boolean' &&
+			!Object.prototype.hasOwnProperty.call(flag, 'default')
+		) {
+			flag.default = flag.isMultiple ? [booleanDefault] : booleanDefault;
+		}
+
+		if (flag.isMultiple) {
+			flag.type = flag.type ? `${flag.type}-array` : 'array';
+			flag.default = flag.default || [];
+			delete flag.isMultiple;
+		}
+
+		parserFlags[flagKey] = flag;
+	}
+
+	return parserFlags;
+};
+
+const validateFlags = (flags, options) => {
+	for (const [flagKey, flagValue] of Object.entries(options.flags)) {
+		if (flagKey !== '--' && !flagValue.isMultiple && Array.isArray(flags[flagKey])) {
+			throw new Error(`The flag --${flagKey} can only be set once.`);
+		}
+	}
+};
+
+const meow = (helpText, options) => {
+	if (typeof helpText !== 'string') {
+		options = helpText;
+		helpText = '';
+	}
+
+	const foundPkg = readPkgUp.sync({
+		cwd: parentDir,
+		normalize: false
+	});
+
+	options = {
+		pkg: foundPkg ? foundPkg.packageJson : {},
 		argv: process.argv.slice(2),
+		flags: {},
 		inferType: false,
 		input: 'string',
-		help: helpMessage,
+		help: helpText,
 		autoHelp: true,
 		autoVersion: true,
-		booleanDefault: false
-	}, options);
-
-	const minimistFlags = options.flags && typeof options.booleanDefault !== 'undefined' ? Object.keys(options.flags).reduce(
-		(flags, flag) => {
-			if (flags[flag].type === 'boolean' && !Object.prototype.hasOwnProperty.call(flags[flag], 'default')) {
-				flags[flag].default = options.booleanDefault;
-			}
+		booleanDefault: false,
+		hardRejection: true,
+		...options
+	};
 
-			return flags;
-		},
-		options.flags
-	) : options.flags;
+	if (options.hardRejection) {
+		hardRejection();
+	}
 
-	let minimistoptions = Object.assign({
-		arguments: options.input
-	}, minimistFlags);
+	let parserOptions = {
+		arguments: options.input,
+		...buildParserFlags(options)
+	};
 
-	minimistoptions = decamelizeKeys(minimistoptions, '-', {exclude: ['stopEarly', '--']});
+	parserOptions = decamelizeKeys(parserOptions, '-', {exclude: ['stopEarly', '--']});
 
 	if (options.inferType) {
-		delete minimistoptions.arguments;
+		delete parserOptions.arguments;
 	}
 
-	minimistoptions = buildMinimistOptions(minimistoptions);
+	parserOptions = buildParserOptions(parserOptions);
+
+	parserOptions.configuration = {
+		...parserOptions.configuration,
+		'greedy-arrays': false
+	};
 
-	if (minimistoptions['--']) {
-		minimistoptions.configuration = Object.assign({}, minimistoptions.configuration, {'populate--': true});
+	if (parserOptions['--']) {
+		parserOptions.configuration['populate--'] = true;
 	}
 
 	const {pkg} = options;
-	const argv = yargs(options.argv, minimistoptions);
+	const argv = parseArguments(options.argv, parserOptions);
 	let help = redent(trimNewlines((options.help || '').replace(/\t+\n*$/, '')), 2);
 
 	normalizePackageData(pkg);
@@ -85,28 +161,46 @@ module.exports = (helpMessage, options) => {
 
 	const showVersion = () => {
 		console.log(typeof options.version === 'string' ? options.version : pkg.version);
-		process.exit();
+		process.exit(0);
 	};
 
-	if (argv.version && options.autoVersion) {
-		showVersion();
-	}
+	if (argv._.length === 0 && options.argv.length === 1) {
+		if (argv.version === true && options.autoVersion) {
+			showVersion();
+		}
 
-	if (argv.help && options.autoHelp) {
-		showHelp(0);
+		if (argv.help === true && options.autoHelp) {
+			showHelp(0);
+		}
 	}
 
 	const input = argv._;
 	delete argv._;
 
-	const flags = camelcaseKeys(argv, {exclude: ['--', /^\w$/]});
+	const flags = camelCaseKeys(argv, {exclude: ['--', /^\w$/]});
+	const unnormalizedFlags = {...flags};
+
+	validateFlags(flags, options);
+
+	for (const flagValue of Object.values(options.flags)) {
+		delete flags[flagValue.alias];
+	}
+
+	const missingRequiredFlags = getMissingRequiredFlags(options.flags, flags, input);
+	if (missingRequiredFlags.length > 0) {
+		reportMissingRequiredFlags(missingRequiredFlags);
+		process.exit(2);
+	}
 
 	return {
 		input,
 		flags,
+		unnormalizedFlags,
 		pkg,
 		help,
 		showHelp,
 		showVersion
 	};
 };
+
+module.exports = meow;

index.test-d.ts

@@ -0,0 +1,67 @@
+import {expectAssignable, expectType} from 'tsd';
+import {PackageJson} from 'type-fest';
+import meow = require('.');
+import {Result} from '.';
+
+expectType<Result<never>>(meow('Help text'));
+expectType<Result<never>>(meow('Help text', {hardRejection: false}));
+expectAssignable<{flags: {foo: number}}>(
+	meow({flags: {foo: {type: 'number', isRequired: true}}})
+);
+expectAssignable<{flags: {foo: string}}>(
+	meow({flags: {foo: {type: 'string', isRequired: true}}})
+);
+expectAssignable<{flags: {foo: boolean}}>(
+	meow({flags: {foo: {type: 'boolean', isRequired: true}}})
+);
+expectAssignable<{flags: {foo: number | undefined}}>(
+	meow({flags: {foo: {type: 'number'}}})
+);
+expectAssignable<{flags: {foo: string | undefined}}>(
+	meow({flags: {foo: {type: 'string'}}})
+);
+expectAssignable<{flags: {foo: boolean | undefined}}>(
+	meow({flags: {foo: {type: 'boolean'}}})
+);
+expectType<Result<never>>(meow({description: 'foo'}));
+expectType<Result<never>>(meow({description: false}));
+expectType<Result<never>>(meow({help: 'foo'}));
+expectType<Result<never>>(meow({help: false}));
+expectType<Result<never>>(meow({version: 'foo'}));
+expectType<Result<never>>(meow({version: false}));
+expectType<Result<never>>(meow({autoHelp: false}));
+expectType<Result<never>>(meow({autoVersion: false}));
+expectType<Result<never>>(meow({pkg: {foo: 'bar'}}));
+expectType<Result<never>>(meow({argv: ['foo', 'bar']}));
+expectType<Result<never>>(meow({inferType: true}));
+expectType<Result<never>>(meow({booleanDefault: true}));
+expectType<Result<never>>(meow({booleanDefault: null}));
+expectType<Result<never>>(meow({booleanDefault: undefined}));
+expectType<Result<never>>(meow({hardRejection: false}));
+
+const result = meow('Help text', {
+	flags: {
+		foo: {type: 'boolean', alias: 'f'},
+		'foo-bar': {type: 'number'},
+		bar: {type: 'string', default: ''},
+		abc: {type: 'string', isMultiple: true}
+	}
+});
+
+expectType<string[]>(result.input);
+expectType<PackageJson>(result.pkg);
+expectType<string>(result.help);
+
+expectType<boolean | undefined>(result.flags.foo);
+expectType<unknown>(result.flags.fooBar);
+expectType<string>(result.flags.bar);
+expectType<string[] | undefined>(result.flags.abc);
+expectType<boolean | undefined>(result.unnormalizedFlags.foo);
+expectType<unknown>(result.unnormalizedFlags.f);
+expectType<number | undefined>(result.unnormalizedFlags['foo-bar']);
+expectType<string>(result.unnormalizedFlags.bar);
+expectType<string[] | undefined>(result.unnormalizedFlags.abc);
+
+result.showHelp();
+result.showHelp(1);
+result.showVersion();

license

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://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:
 

package.json

@@ -1,22 +1,24 @@
 {
 	"name": "meow",
-	"version": "5.0.0",
+	"version": "8.0.0",
 	"description": "CLI app helper",
 	"license": "MIT",
 	"repository": "sindresorhus/meow",
+	"funding": "https://github.com/sponsors/sindresorhus",
 	"author": {
 		"name": "Sindre Sorhus",
 		"email": "sindresorhus@gmail.com",
-		"url": "sindresorhus.com"
+		"url": "https://sindresorhus.com"
 	},
 	"engines": {
-		"node": ">=6"
+		"node": ">=10"
 	},
 	"scripts": {
-		"test": "xo && ava"
+		"test": "xo && ava && tsd"
 	},
 	"files": [
-		"index.js"
+		"index.js",
+		"index.d.ts"
 	],
 	"keywords": [
 		"cli",
@@ -38,25 +40,37 @@
 		"console"
 	],
 	"dependencies": {
-		"camelcase-keys": "^4.0.0",
-		"decamelize-keys": "^1.0.0",
-		"loud-rejection": "^1.0.0",
-		"minimist-options": "^3.0.1",
-		"normalize-package-data": "^2.3.4",
-		"read-pkg-up": "^3.0.0",
-		"redent": "^2.0.0",
-		"trim-newlines": "^2.0.0",
-		"yargs-parser": "^10.0.0"
+		"@types/minimist": "^1.2.0",
+		"camelcase-keys": "^6.2.2",
+		"decamelize-keys": "^1.1.0",
+		"hard-rejection": "^2.1.0",
+		"minimist-options": "4.1.0",
+		"normalize-package-data": "^3.0.0",
+		"read-pkg-up": "^7.0.1",
+		"redent": "^3.0.0",
+		"trim-newlines": "^3.0.0",
+		"type-fest": "^0.18.0",
+		"yargs-parser": "^20.2.3"
 	},
 	"devDependencies": {
-		"ava": "*",
-		"execa": "^0.10.0",
-		"indent-string": "^3.0.0",
-		"xo": "*"
+		"ava": "^2.4.0",
+		"execa": "^4.1.0",
+		"indent-string": "^4.0.0",
+		"tsd": "^0.13.1",
+		"xo": "^0.34.1"
 	},
 	"xo": {
 		"rules": {
-			"unicorn/no-process-exit": "off"
-		}
+			"unicorn/no-process-exit": "off",
+			"node/no-unsupported-features/es-syntax": "off"
+		},
+		"ignores": [
+			"estest/index.js"
+		]
+	},
+	"ava": {
+		"files": [
+			"test/*"
+		]
 	}
 }

readme.md

@@ -4,30 +4,30 @@
 
 ![](meow.gif)
 
-
 ## Features
 
 - Parses arguments
 - Converts flags to [camelCase](https://github.com/sindresorhus/camelcase)
+- Negates flags when using the `--no-` prefix
 - Outputs version when `--version`
 - Outputs description and supplied help text when `--help`
-- Makes unhandled rejected promises [fail loudly](https://github.com/sindresorhus/loud-rejection) instead of the default silent fail
+- Makes unhandled rejected promises [fail hard](https://github.com/sindresorhus/hard-rejection) instead of the default silent fail
 - Sets the process title to the binary name defined in package.json
 
-
 ## Install
 
 ```
 $ npm install meow
 ```
 
-
 ## Usage
 
 ```
 $ ./foo-app.js unicorns --rainbow
 ```
 
+**CommonJS**
+
 ```js
 #!/usr/bin/env node
 'use strict';
@@ -63,37 +63,87 @@ const cli = meow(`
 foo(cli.input[0], cli.flags);
 ```
 
+**ES Modules**
+
+```js
+#!/usr/bin/env node
+import {createRequire} from 'module';
+import foo from './lib/index.js';
+
+const meow = createRequire(import.meta.url)('meow');
+
+const cli = meow(`
+	Usage
+	  $ foo <input>
+
+	Options
+	  --rainbow, -r  Include a rainbow
+
+	Examples
+	  $ foo unicorns --rainbow
+	  🌈 unicorns 🌈
+`, {
+	flags: {
+		rainbow: {
+			type: 'boolean',
+			alias: 'r'
+		}
+	}
+});
+/*
+{
+	input: ['unicorns'],
+	flags: {rainbow: true},
+	...
+}
+*/
+
+foo(cli.input[0], cli.flags);
+```
 
 ## API
 
-### meow(options, [minimistOptions])
+### meow(helpText, options?)
+### meow(options)
 
-Returns an `Object` with:
+Returns an `object` with:
 
 - `input` *(Array)* - Non-flag arguments
-- `flags` *(Object)* - Flags converted to camelCase
+- `flags` *(Object)* - Flags converted to camelCase excluding aliases
+- `unnormalizedFlags` *(Object)* - Flags converted to camelCase including aliases
 - `pkg` *(Object)* - The `package.json` object
 - `help` *(string)* - The help text used with `--help`
-- `showHelp([code=2])` *(Function)* - Show the help text and exit with `code`
+- `showHelp([exitCode=2])` *(Function)* - Show the help text and exit with `exitCode`
 - `showVersion()` *(Function)* - Show the version text and exit
 
-#### options
+#### helpText
+
+Type: `string`
+
+Shortcut for the `help` option.
 
-Type: `Object` `Array` `string`
+#### options
 
-Can either be a string/array that is the `help` or an options object.
+Type: `object`
 
 ##### flags
 
-Type: `Object`
+Type: `object`
 
 Define argument flags.
 
 The key is the flag name and the value is an object with any of:
 
-- `type`: Type of value. (Possible values: `string` `boolean`)
+- `type`: Type of value. (Possible values: `string` `boolean` `number`)
 - `alias`: Usually used to define a short flag alias.
 - `default`: Default value when the flag is not specified.
+- `isRequired`: Determine if the flag is required. (Default: false)
+	- If it's only known at runtime whether the flag is required or not, you can pass a `Function` instead of a `boolean`, which based on the given flags and other non-flag arguments, should decide if the flag is required. Two arguments are passed to the function:
+	- The first argument is the **flags** object, which contains the flags converted to camel-case excluding aliases.
+	- The second argument is the **input** string array, which contains the non-flag arguments.
+	- The function should return a `boolean`, true if the flag is required, otherwise false.
+- `isMultiple`: Indicates a flag can be set multiple times. Values are turned into an array. (Default: false)
+	- Multiple values are provided by specifying the flag multiple times, for example, `$ foo -u rainbow -u cat`. Space- or comma-separated values are [currently *not* supported](https://github.com/sindresorhus/meow/issues/164).
 
 Example:
 
@@ -102,15 +152,22 @@ flags: {
 	unicorn: {
 		type: 'string',
 		alias: 'u',
-		default: 'rainbow'
+		default: ['rainbow', 'cat'],
+		isMultiple: true,
+		isRequired: (flags, input) => {
+			if (flags.otherFlag) {
+				return true;
+			}
+
+			return false;
+		}
 	}
 }
 ```
 
-
 ##### description
 
-Type: `string` `boolean`<br>
+Type: `string | boolean`\
 Default: The package.json `"description"` property
 
 Description to show above the help text.
@@ -119,7 +176,7 @@ Set it to `false` to disable it altogether.
 
 ##### help
 
-Type: `string` `boolean`
+Type: `string | boolean`
 
 The help text you want shown.
 
@@ -129,44 +186,48 @@ The description will be shown above your help text automatically.
 
 ##### version
 
-Type: `string` `boolean`<br>
+Type: `string | boolean`\
 Default: The package.json `"version"` property
 
 Set a custom version output.
 
 ##### autoHelp
 
-Type: `boolean`<br>
+Type: `boolean`\
 Default: `true`
 
 Automatically show the help text when the `--help` flag is present. Useful to set this value to `false` when a CLI manages child CLIs with their own help text.
 
+This option is only considered when there is only one argument in `process.argv`.
+
 ##### autoVersion
 
-Type: `boolean`<br>
+Type: `boolean`\
 Default: `true`
 
 Automatically show the version text when the `--version` flag is present. Useful to set this value to `false` when a CLI manages child CLIs with their own version text.
 
+ This option is only considered when there is only one argument in `process.argv`.
+
 ##### pkg
 
-Type: `Object`<br>
+Type: `object`\
 Default: Closest package.json upwards
 
-package.json as an `Object`.
+package.json as an `object`.
 
 *You most likely don't need this option.*
 
 ##### argv
 
-Type: `Array`<br>
+Type: `string[]`\
 Default: `process.argv.slice(2)`
 
 Custom arguments object.
 
 ##### inferType
 
-Type: `boolean`<br>
+Type: `boolean`\
 Default: `false`
 
 Infer the argument type.
@@ -175,58 +236,87 @@ By default, the argument `5` in `$ foo 5` becomes a string. Enabling this would
 
 ##### booleanDefault
 
-Type: `boolean` `null` `undefined`<br>
+Type: `boolean | null | undefined`\
 Default: `false`
 
 Value of `boolean` flags not defined in `argv`.
-If set to `undefined` the flags not defined in `argv` will be excluded from the result.
+
+If set to `undefined`, the flags not defined in `argv` will be excluded from the result.
 The `default` value set in `boolean` flags take precedence over `booleanDefault`.
 
+_Note: If used in conjunction with `isMultiple`, the default flag value is set to `[]`._
+
+__Caution: Explicitly specifying `undefined` for `booleanDefault` has different meaning from omitting key itself.__
+
 Example:
 
 ```js
+const meow = require('meow');
+
 const cli = meow(`
 	Usage
 	  $ foo
 
 	Options
 	  --rainbow, -r  Include a rainbow
-	  --unicorn, -r  Include a unicorn
+	  --unicorn, -u  Include a unicorn
+	  --no-sparkles  Exclude sparkles
 
 	Examples
 	  $ foo
-	  🌈 unicorns 🌈
+	  🌈 unicorns✨🌈
 `, {
 	booleanDefault: undefined,
 	flags: {
 		rainbow: {
 			type: 'boolean',
-			default: true
+			default: true,
 			alias: 'r'
 		},
 		unicorn: {
 			type: 'boolean',
-			default: false
+			default: false,
 			alias: 'u'
 		},
 		cake: {
 			type: 'boolean',
 			alias: 'c'
+		},
+		sparkles: {
+			type: 'boolean',
+			default: true
 		}
 	}
 });
 /*
 {
-	flags: {rainbow: true, unicorn: false},
+	flags: {
+		rainbow: true,
+		unicorn: false,
+		sparkles: true
+	},
+	unnormalizedFlags: {
+		rainbow: true,
+		r: true,
+		unicorn: false,
+		u: false,
+		sparkles: true
+	},
 	…
 }
 */
 ```
 
-## Promises
+##### hardRejection
+
+Type: `boolean`\
+Default: `true`
 
-Meow will make unhandled rejected promises [fail loudly](https://github.com/sindresorhus/loud-rejection) instead of the default silent fail. Meaning you don't have to manually `.catch()` promises used in your CLI.
+Whether to use [`hard-rejection`](https://github.com/sindresorhus/hard-rejection) or not. Disabling this can be useful if you need to handle `process.on('unhandledRejection')` yourself.
 
+## Promises
+
+Meow will make unhandled rejected promises [fail hard](https://github.com/sindresorhus/hard-rejection) instead of the default silent fail. Meaning you don't have to manually `.catch()` promises used in your CLI.
 
 ## Tips
 
@@ -240,7 +330,14 @@ See [`update-notifier`](https://github.com/yeoman/update-notifier) if you want u
 
 [More useful CLI utilities…](https://github.com/sindresorhus/awesome-nodejs#command-line-utilities)
 
-
-## License
-
-MIT © [Sindre Sorhus](https://sindresorhus.com)
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-meow?utm_source=npm-meow&utm_medium=referral&utm_campaign=readme">Get professional support for this package 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>

test/fixtures/fixture-required-function.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+'use strict';
+const meow = require('../..');
+
+const cli = meow({
+	description: 'Custom description',
+	help: `
+		Usage
+		  foo <input>
+  `,
+	flags: {
+		trigger: {
+			type: 'boolean',
+			alias: 't'
+		},
+		withTrigger: {
+			type: 'string',
+			isRequired: (flags, _) => {
+				return flags.trigger;
+			}
+		},
+		allowError: {
+			type: 'boolean',
+			alias: 'a'
+		},
+		shouldError: {
+			type: 'boolean',
+			isRequired: (flags, _) => {
+				if (flags.allowError) {
+					return 'should error';
+				}
+
+				return false;
+			}
+		}
+	}
+});
+
+console.log(`${cli.flags.trigger},${cli.flags.withTrigger}`);

test/fixtures/fixture-required-multiple.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+'use strict';
+const meow = require('../..');
+
+const cli = meow({
+	description: 'Custom description',
+	help: `
+		Usage
+		  foo <input>
+  `,
+	flags: {
+		test: {
+			type: 'number',
+			alias: 't',
+			isRequired: true,
+			isMultiple: true
+		}
+	}
+});
+
+console.log(cli.flags.test);

test/fixtures/fixture-required.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+'use strict';
+const meow = require('../..');
+
+const cli = meow({
+	description: 'Custom description',
+	help: `
+		Usage
+		  foo <input>
+  `,
+	flags: {
+		test: {
+			type: 'string',
+			alias: 't',
+			isRequired: true
+		},
+		number: {
+			type: 'number',
+			isRequired: true
+		},
+		notRequired: {
+			type: 'string'
+		}
+	}
+});
+
+console.log(`${cli.flags.test},${cli.flags.number}`);

fixture.js → test/fixtures/fixture.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 'use strict';
-const meow = require('.');
+const meow = require('../..');
 
 const cli = meow({
 	description: 'Custom description',
 	help: `
 		Usage
 		  foo <input>
   `,
-	autoVersion: process.argv.indexOf('--no-auto-version') === -1,
-	autoHelp: process.argv.indexOf('--no-auto-help') === -1,
+	autoVersion: !process.argv.includes('--no-auto-version'),
+	autoHelp: !process.argv.includes('--no-auto-help'),
 	flags: {
 		unicorn: {alias: 'u'},
 		meow: {default: 'dog'},

test/is-required-flag.js

@@ -0,0 +1,115 @@
+import test from 'ava';
+import execa from 'execa';
+const path = require('path');
+
+const fixtureRequiredPath = path.join(__dirname, 'fixtures', 'fixture-required.js');
+const fixtureRequiredFunctionPath = path.join(__dirname, 'fixtures', 'fixture-required-function.js');
+const fixtureRequiredMultiplePath = path.join(__dirname, 'fixtures', 'fixture-required-multiple.js');
+
+test('spawn cli and test not specifying required flags', async t => {
+	try {
+		await execa(fixtureRequiredPath, []);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 2/);
+		t.regex(stderr, /Missing required flag/);
+		t.regex(stderr, /--test, -t/);
+		t.regex(stderr, /--number/);
+		t.notRegex(stderr, /--notRequired/);
+	}
+});
+
+test('spawn cli and test specifying all required flags', async t => {
+	const {stdout} = await execa(fixtureRequiredPath, [
+		'-t',
+		'test',
+		'--number',
+		'6'
+	]);
+	t.is(stdout, 'test,6');
+});
+
+test('spawn cli and test specifying required string flag with an empty string as value', async t => {
+	try {
+		await execa(fixtureRequiredPath, ['--test', '']);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 2/);
+		t.regex(stderr, /Missing required flag/);
+		t.notRegex(stderr, /--test, -t/);
+	}
+});
+
+test('spawn cli and test specifying required number flag without a number', async t => {
+	try {
+		await execa(fixtureRequiredPath, ['--number']);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 2/);
+		t.regex(stderr, /Missing required flag/);
+		t.regex(stderr, /--number/);
+	}
+});
+
+test('spawn cli and test setting isRequired as a function and not specifying any flags', async t => {
+	const {stdout} = await execa(fixtureRequiredFunctionPath, []);
+	t.is(stdout, 'false,undefined');
+});
+
+test('spawn cli and test setting isRequired as a function and specifying only the flag that activates the isRequired condition for the other flag', async t => {
+	try {
+		await execa(fixtureRequiredFunctionPath, ['--trigger']);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 2/);
+		t.regex(stderr, /Missing required flag/);
+		t.regex(stderr, /--withTrigger/);
+	}
+});
+
+test('spawn cli and test setting isRequired as a function and specifying both the flags', async t => {
+	const {stdout} = await execa(fixtureRequiredFunctionPath, ['--trigger', '--withTrigger', 'specified']);
+	t.is(stdout, 'true,specified');
+});
+
+test('spawn cli and test setting isRequired as a function and check if returning a non-boolean value throws an error', async t => {
+	try {
+		await execa(fixtureRequiredFunctionPath, ['--allowError', '--shouldError', 'specified']);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 1/);
+		t.regex(stderr, /Return value for isRequired callback should be of type boolean, but string was returned./);
+	}
+});
+
+test('spawn cli and test isRequired with isMultiple giving a single value', async t => {
+	const {stdout} = await execa(fixtureRequiredMultiplePath, ['--test', '1']);
+	t.is(stdout, '[ 1 ]');
+});
+
+test('spawn cli and test isRequired with isMultiple giving multiple values', async t => {
+	const {stdout} = await execa(fixtureRequiredMultiplePath, ['--test', '1', '--test', '2']);
+	t.is(stdout, '[ 1, 2 ]');
+});
+
+test('spawn cli and test isRequired with isMultiple giving no values, but flag is given', async t => {
+	try {
+		await execa(fixtureRequiredMultiplePath, ['--test']);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 2/);
+		t.regex(stderr, /Missing required flag/);
+		t.regex(stderr, /--test/);
+	}
+});
+
+test('spawn cli and test isRequired with isMultiple giving no values, but flag is not given', async t => {
+	try {
+		await execa(fixtureRequiredMultiplePath, []);
+	} catch (error) {
+		const {stderr, message} = error;
+		t.regex(message, /Command failed with exit code 2/);
+		t.regex(stderr, /Missing required flag/);
+		t.regex(stderr, /--test/);
+	}
+});

tsconfig.json

@@ -0,0 +1,19 @@
+{
+	"files": [
+		"index.d.ts",
+		"index.test-d.ts",
+	],
+	"compilerOptions": {
+		"strict": true,
+		"jsx": "react",
+		"target": "es2018",
+		"lib": [
+			"es2018"
+		],
+		"module": "commonjs",
+		"moduleResolution": "node",
+		"noImplicitAny": true,
+		"strictNullChecks": true,
+		"noUnusedLocals": true
+	}
+}