optionator

  var ref$, id, find, sort, min, max, map, unlines, nameToRaw, dasherize, naturalJoin, wordWrap, wordwrap, getPreText, setHelpStyleDefaults, generateHelpForOption, generateHelp;

  ref$ = require('prelude-ls'), id = ref$.id, find = ref$.find, sort = ref$.sort, min = ref$.min, max = ref$.max, map = ref$.map, unlines = ref$.unlines;

  ref$ = require('./util'), nameToRaw = ref$.nameToRaw, dasherize = ref$.dasherize, naturalJoin = ref$.naturalJoin;

  wordWrap = require('@aashutoshrathi/word-wrap');

      : [repeatString$(' ', a), b - a - 1], indent = ref$[0], width = ref$[1];

  getPreText = function(option, arg$, maxWidth){

    var mainName, shortNames, ref$, longNames, type, description, aliasSeparator, typeSeparator, initialIndent, names, namesString, namesStringLen, typeSeparatorString, typeSeparatorStringLen, wrap;

    mainName = option.option, shortNames = (ref$ = option.shortNames) != null

      : [], longNames = (ref$ = option.longNames) != null

      : [], type = option.type, description = option.description;

    aliasSeparator = arg$.aliasSeparator, typeSeparator = arg$.typeSeparator, initialIndent = arg$.initialIndent;

      ? [mainName].concat(shortNames, longNames)

      : shortNames.concat([mainName], longNames);

    namesString = map(nameToRaw, names).join(aliasSeparator);

    typeSeparatorString = mainName === 'NUM' ? '::' : typeSeparator;

    typeSeparatorStringLen = typeSeparatorString.length;

    if (maxWidth != null && !option.boolean && initialIndent + namesStringLen + typeSeparatorStringLen + type.length > maxWidth) {

      wrap = wordwrap(initialIndent + namesStringLen + typeSeparatorStringLen, maxWidth);

      return namesString + "" + typeSeparatorString + wrap(type).replace(/^\s+/, '');

      return namesString + "" + (option.boolean

        : typeSeparatorString + "" + type);

  setHelpStyleDefaults = function(helpStyle){

    helpStyle.aliasSeparator == null && (helpStyle.aliasSeparator = ', ');

    helpStyle.typeSeparator == null && (helpStyle.typeSeparator = ' ');

    helpStyle.descriptionSeparator == null && (helpStyle.descriptionSeparator = '  ');

    helpStyle.initialIndent == null && (helpStyle.initialIndent = 2);

    helpStyle.secondaryIndent == null && (helpStyle.secondaryIndent = 4);

    helpStyle.maxPadFactor == null && (helpStyle.maxPadFactor = 1.5);

  generateHelpForOption = function(getOption, arg$){

    stdout = arg$.stdout, helpStyle = (ref$ = arg$.helpStyle) != null

      var maxWidth, wrap, option, e, pre, defaultString, restPositionalString, description, fullDescription, that, preDescription, descriptionString, exampleString, examples, seperator;

      maxWidth = stdout != null && stdout.isTTY ? stdout.columns - 1 : null;

      wrap = maxWidth ? wordwrap(maxWidth) : id;

        option = getOption(dasherize(optionName));

      pre = getPreText(option, helpStyle);

      defaultString = option['default'] && !option.negateName ? "\ndefault: " + option['default'] : '';

      restPositionalString = option.restPositional ? 'Everything after this option is considered a positional argument, even if it looks like an option.' : '';

      description = option.longDescription || option.description && sentencize(option.description);

      fullDescription = description && restPositionalString

        ? description + " " + restPositionalString

        : (that = description || restPositionalString) ? that : '';

      descriptionString = !fullDescription

        : maxWidth && fullDescription.length - 1 - preDescription.length > maxWidth

          ? "\n" + preDescription + "\n" + wrap(fullDescription)

          : "\n" + preDescription + " " + fullDescription;

      exampleString = (that = option.example) ? (examples = [].concat(that), examples.length > 1

        ? "\nexamples:\n" + unlines(examples)

        : "\nexample: " + examples[0]) : '';

      seperator = defaultString || descriptionString || exampleString ? "\n" + repeatString$('=', pre.length) : '';

      return pre + "" + seperator + defaultString + descriptionString + exampleString;

    var options, prepend, append, helpStyle, ref$, stdout, aliasSeparator, typeSeparator, descriptionSeparator, maxPadFactor, initialIndent, secondaryIndent;

    options = arg$.options, prepend = arg$.prepend, append = arg$.append, helpStyle = (ref$ = arg$.helpStyle) != null

    aliasSeparator = helpStyle.aliasSeparator, typeSeparator = helpStyle.typeSeparator, descriptionSeparator = helpStyle.descriptionSeparator, maxPadFactor = helpStyle.maxPadFactor, initialIndent = helpStyle.initialIndent, secondaryIndent = helpStyle.secondaryIndent;

      var ref$, showHidden, interpolate, maxWidth, output, out, data, optionCount, totalPreLen, preLens, i$, len$, item, that, pre, descParts, desc, preLen, sortedPreLens, maxPreLen, preLenMean, x, padAmount, descSepLen, fullWrapCount, partialWrapCount, descLen, totalLen, initialSpace, wrapAllFull, i, wrap;

        : {}, showHidden = ref$.showHidden, interpolate = ref$.interpolate;

  var VERSION, ref$, id, map, compact, any, groupBy, partition, chars, isItNaN, keys, Obj, camelize, deepIs, closestString, nameToRaw, dasherize, naturalJoin, generateHelp, generateHelpForOption, parsedTypeCheck, parseType, parseLevn, camelizeKeys, parseString, main, toString$ = {}.toString, slice$ = [].slice, arrayFrom$ = Array.from || function(x){return slice$.call(x);};

  ref$ = require('prelude-ls'), id = ref$.id, map = ref$.map, compact = ref$.compact, any = ref$.any, groupBy = ref$.groupBy, partition = ref$.partition, chars = ref$.chars, isItNaN = ref$.isItNaN, keys = ref$.keys, Obj = ref$.Obj, camelize = ref$.camelize;

  ref$ = require('./util'), closestString = ref$.closestString, nameToRaw = ref$.nameToRaw, dasherize = ref$.dasherize, naturalJoin = ref$.naturalJoin;

  ref$ = require('./help'), generateHelp = ref$.generateHelp, generateHelpForOption = ref$.generateHelpForOption;

  ref$ = require('type-check'), parsedTypeCheck = ref$.parsedTypeCheck, parseType = ref$.parseType;

  parseLevn = require('levn').parsedTypeParse;

    var assignOpt, regex, replaceRegex, result;

    assignOpt = '--?[a-zA-Z][-a-z-A-Z0-9]*=';

    regex = RegExp('(?:' + assignOpt + ')?(?:\'(?:\\\\\'|[^\'])+\'|"(?:\\\\"|[^"])+")|[^\'"\\s]+', 'g');

    replaceRegex = RegExp('^(' + assignOpt + ')?[\'"]([\\s\\S]*)[\'"]$');

      return it.replace(replaceRegex, '$1$2');

    var opts, defaults, required, traverse, getOption, parse;

    if (toString$.call(libOptions.stdout).slice(8, -1) === 'Undefined') {

      libOptions.stdout = process.stdout;

    libOptions.positionalAnywhere == null && (libOptions.positionalAnywhere = true);

    libOptions.typeAliases == null && (libOptions.typeAliases = {});

    libOptions.defaults == null && (libOptions.defaults = {});

    if (libOptions.concatRepeatedArrays != null) {

      libOptions.defaults.concatRepeatedArrays = libOptions.concatRepeatedArrays;

    if (libOptions.mergeRepeatedObjects != null) {

      libOptions.defaults.mergeRepeatedObjects = libOptions.mergeRepeatedObjects;

      var i$, len$, option, name, k, ref$, v, type, that, e, parsedPossibilities, parsedType, j$, len1$, possibility, rawDependsType, dependsOpts, dependsType, cra, alias, shortNames, longNames;

      if (toString$.call(options).slice(8, -1) !== 'Array') {

        throw new Error('No options defined.');

      for (i$ = 0, len$ = options.length; i$ < len$; ++i$) {

            throw new Error("Option '" + name + "' already defined.");

          for (k in ref$ = libOptions.defaults) {

            option[k] == null && (option[k] = v);

          if (option.type === 'Boolean') {

            option.boolean == null && (option.boolean = true);

          if (option.parsedType == null) {

              throw new Error("No type defined for option '" + name + "'.");

              type = (that = libOptions.typeAliases[option.type]) != null

              option.parsedType = parseType(type);

              throw new Error("Option '" + name + "': Error parsing type '" + option.type + "': " + e.message);

              defaults[name] = parseLevn(option.parsedType, option['default']);

              throw new Error("Option '" + name + "': Error parsing default value '" + option['default'] + "' for type '" + option.type + "': " + e.message);

          if (option['enum'] && !option.parsedPossiblities) {

            parsedType = option.parsedType;

            for (j$ = 0, len1$ = (ref$ = option['enum']).length; j$ < len1$; ++j$) {

                parsedPossibilities.push(parseLevn(parsedType, possibility));

                throw new Error("Option '" + name + "': Error parsing enum value '" + possibility + "' for type '" + option.type + "': " + e.message);

            option.parsedPossibilities = parsedPossibilities;

              ref$ = [].concat(option.dependsOn), rawDependsType = ref$[0], dependsOpts = slice$.call(ref$, 1);

              dependsType = rawDependsType.toLowerCase();

  "author": "George Zahariev <z@georgezahariev.com>",

  "description": "option parsing and help generation",

  "homepage": "https://github.com/gkz/optionator",

  "bugs": "https://github.com/gkz/optionator/issues",

    "url": "git://github.com/gkz/optionator.git"

    "@aashutoshrathi/word-wrap": "^1.2.3",

Optionator is a JavaScript/Node.js option parsing and help generation library used by [eslint](http://eslint.org), [Grasp](http://graspjs.com), [LiveScript](http://livescript.net), [esmangle](https://github.com/estools/esmangle), [escodegen](https://github.com/estools/escodegen), and [many more](https://www.npmjs.com/browse/depended/optionator).

For an online demo, check out the [Grasp online demo](http://www.graspjs.com/#demo).

[About](#about) &middot; [Usage](#usage) &middot; [Settings Format](#settings-format) &middot; [Argument Format](#argument-format)

The  problem with other option parsers, such as `yargs` or `minimist`, is they just accept all input, valid or not.

With Optionator, if you mistype an option, it will give you an error (with a suggestion for what you meant).

If you give the wrong type of argument for an option, it will give you an error rather than supplying the wrong input to your application.

    Invalid option '--halp' - perhaps you meant '--help'?

    Invalid value for option 'count' - expected type Int, received value: str.

Other helpful features include reformatting the help text based on the size of the console, so that it fits even if the console is narrow, and accepting not just an array (eg. process.argv), but a string or object as well, making things like testing much easier.

Optionator uses [type-check](https://github.com/gkz/type-check) and [levn](https://github.com/gkz/levn) behind the scenes to cast and verify input according the specified types.

For updates on Optionator, [follow me on twitter](https://twitter.com/gkzahariev).

Optionator is a Node.js module, but can be used in the browser as well if packed with webpack/browserify.

`require('optionator');` returns a function. It has one property, `VERSION`, the current version of the library as a string. This function is called with an object specifying your options and other information, see the [settings format section](#settings-format). This in turn returns an object with three properties, `parse`, `parseArgv`, `generateHelp`, and `generateHelpForOption`, which are all functions.

var options = optionator.parseArgv(process.argv);

    console.log(optionator.generateHelp());

`parse` processes the `input` according to your settings, and returns an object with the results.

* input - `[String] | Object | String` - the input you wish to parse

* parseOptions - `{slice: Int}` - all options optional

    - `slice` specifies how much to slice away from the beginning if the input is an array or string - by default `0` for string, `2` for array (works with `process.argv`)

`Object` - the parsed options, each key is a camelCase version of the option name (specified in dash-case), and each value is the processed value for that option. Positional values are in an array under the `_` key.

parse(['node', 't.js', '--count', '2', 'positional']); // {count: 2, _: ['positional']}

parse('--count 2 positional');                         // {count: 2, _: ['positional']}

parse({count: 2, _:['positional']});                   // {count: 2, _: ['positional']}

`parseArgv` works exactly like `parse`, but only for array input and it slices off the first two elements.

* input - `[String]` - the input you wish to parse

`generateHelp` produces help text based on your settings.

* helpOptions - `{showHidden: Boolean, interpolate: Object}` - all options optional

    - `showHidden` specifies whether to show options with `hidden: true` specified, by default it is `false`

    - `interpolate` specify data to be interpolated in `prepend` and `append` text, `{{key}}` is the format - eg. `generateHelp({interpolate:{version: '0.4.2'}})`, will change this `append` text: `Version {{version}}` to `Version 0.4.2`

`generateHelpForOption` produces expanded help text for the specified with `optionName` option. If an `example` was specified for the option, it will be displayed,  and if a `longDescription` was specified, it will display that instead of the `description`.

* optionName - `String` - the name of the option to display

`String` - the generated help text for the option

		@@ -6,3 +6,3 @@ // Generated by LiveScript 1.6.0
		ref$ = require('./util'), nameToRaw = ref$.nameToRaw, dasherize = ref$.dasherize, naturalJoin = ref$.naturalJoin;
		wordWrap = require('word-wrap');
		wordWrap = require('@aashutoshrathi/word-wrap');
		wordwrap = function(a, b){
		@@ -9,0 +9,0 @@ var ref$, indent, width;

		// Generated by LiveScript 1.6.0
		(function(){
		var VERSION, ref$, id, map, compact, any, groupBy, partition, chars, isItNaN, keys, Obj, camelize, deepIs, closestString, nameToRaw, dasherize, naturalJoin, generateHelp, generateHelpForOption, parsedTypeCheck, parseType, parseLevn, camelizeKeys, parseString, main, toString$ = {}.toString, slice$ = [].slice, arrayFrom$ = Array.from \|\| function(x){return slice$.call(x);};
		VERSION = '0.9.2';
		VERSION = '0.9.3';
		ref$ = require('prelude-ls'), id = ref$.id, map = ref$.map, compact = ref$.compact, any = ref$.any, groupBy = ref$.groupBy, partition = ref$.partition, chars = ref$.chars, isItNaN = ref$.isItNaN, keys = ref$.keys, Obj = ref$.Obj, camelize = ref$.camelize;
		@@ -6,0 +6,0 @@ deepIs = require('deep-is');

		{
		"name": "optionator",
		"version": "0.9.2",
		"version": "0.9.3",
		"author": "George Zahariev <z@georgezahariev.com>",
		@@ -5,0 +5,0 @@ "description": "option parsing and help generation",

		@@ -26,3 +26,3 @@ # Optionator

		MIT license. Version 0.9.2
		MIT license. Version 0.9.3

		@@ -29,0 +29,0 @@ npm install optionator

Improved metrics