anchor.diff:   *           'arm': 'ARM Holding 32-bit chip'
    *         });
    *
  - * If you define a set of options like the above, then calling this:
  + * To display the help, use the ArgParser getUsage() method:
    *
    *     print(parser.getUsage());
  - *
  - * Will display something like:
  + * 
  + * The resulting string looks something like this:
    *
    *     --mode            The compiler configuration
    *                       [debug, release]
  
positive.code:  *
   * ## Defining commands ##
   *
   * In addition to *options*, you can also define *commands*. A command is a
   * named argument that has its own set of options. For example, when you run:
   *
   *     $ git commit -a
   *
   * The executable is `git`, the command is `commit`, and the `-a` option is an
   * option passed to the command. You can add a command like so:
   *
   *     var parser = new ArgParser();
   *     var command = parser.addCommand('commit');
   *
   * It returns another [ArgParser] which you can then use to define options
   * specific to that command. If you already have an [ArgParser] for the
   * command's options, you can pass it to [addCommand]:
   *
   *     var parser = new ArgParser();
   *     var command = new ArgParser();
   *     parser.addCommand('commit', command);
   *
   * The [ArgParser] for a command can then define whatever options or flags:
   *
   *     command.addFlag('all', abbr: 'a');
   *
   * You can add multiple commands to the same parser so that a user can select
   * one from a range of possible commands. When an argument list is parsed,
   * you can then determine which command was entered and what options were
   * provided for it.
   *
   *     var results = parser.parse(['commit', '-a']);
   *     print(results.command.name); // "commit"
   *     print(results.command['a']); // true
   *
   * Options for a command must appear after the command in the argument list.
   * For example, given the above parser, "git -a commit" is *not* valid. The
   * parser will try to find the right-most command that accepts an option. For
   * example:
   *
   *     var parser = new ArgParser();
   *     parser.addFlag('all', abbr: 'a');
   *     var command = new ArgParser().addCommand('commit');
   *     parser.addFlag('all', abbr: 'a');
   *     var results = parser.parse(['commit', '-a']);
   *     print(results.command['a']); // true
   *
   * Here, both the top-level parser and the "commit" command can accept a "-a"
   * (which is probably a bad command line interface, admittedly). In that case,
   * when "-a" appears after "commit", it will be applied to that command. If it
   * appears to the left of "commit", it will be given to the top-level parser.
   *
   * ## Displaying usage ##
   *
   * This library can also be used to automatically generate nice usage help
   * text like you get when you run a program with `--help`. To use this, you
   * will also want to provide some help text when you create your options. To
   * define help text for the entire option, do:
   *
   *     parser.addOption('mode', help: 'The compiler configuration',
   *         allowed: ['debug', 'release']);
   *     parser.addFlag('verbose', help: 'Show additional diagnostic info');
   *
   * For non-flag options, you can also provide detailed help for each expected
   * value using a map:
   *
   *     parser.addOption('arch', help: 'The architecture to compile for',
   *         allowedHelp: {
  
negative.code:  *     var results = parser.parse(['--mode', 'on', '--mode', 'off']);
   *     print(results['mode']); // prints 'off'
   *
   * If you need multiple values, set the `allowMultiple` parameter. In that
   * case the option can occur multiple times, and the parse() method returns
   * a list of values:
   *
   *     var parser = new ArgParser();
   *     parser.addOption('mode', allowMultiple: true);
  