wice_grid 7.1.0 → 7.1.1

data/node_modules/decaffeinate-coffeescript2/lib/coffeescript/optparse.js

@@ -1,230 +0,0 @@
-// Generated by CoffeeScript 2.2.1
-(function() {
-  var LONG_FLAG, MULTI_FLAG, OPTIONAL, OptionParser, SHORT_FLAG, buildRule, buildRules, normalizeArguments, repeat,
-    splice = [].splice;
-
-  ({repeat} = require('./helpers'));
-
-  // A simple **OptionParser** class to parse option flags from the command-line.
-  // Use it like so:
-
-  //     parser  = new OptionParser switches, helpBanner
-  //     options = parser.parse process.argv
-
-  // The first non-option is considered to be the start of the file (and file
-  // option) list, and all subsequent arguments are left unparsed.
-
-  // The `coffee` command uses an instance of **OptionParser** to parse its
-  // command-line arguments in `src/command.coffee`.
-  exports.OptionParser = OptionParser = class OptionParser {
-    // Initialize with a list of valid options, in the form:
-
-    //     [short-flag, long-flag, description]
-
-    // Along with an optional banner for the usage help.
-    constructor(ruleDeclarations, banner) {
-      this.banner = banner;
-      this.rules = buildRules(ruleDeclarations);
-    }
-
-    // Parse the list of arguments, populating an `options` object with all of the
-    // specified options, and return it. Options after the first non-option
-    // argument are treated as arguments. `options.arguments` will be an array
-    // containing the remaining arguments. This is a simpler API than many option
-    // parsers that allow you to attach callback actions for every flag. Instead,
-    // you're responsible for interpreting the options object.
-    parse(args) {
-      var argument, hasArgument, i, isList, len, name, options, positional, rules;
-      // The CoffeeScript option parser is a little odd; options after the first
-      // non-option argument are treated as non-option arguments themselves.
-      // Optional arguments are normalized by expanding merged flags into multiple
-      // flags. This allows you to have `-wl` be the same as `--watch --lint`.
-      // Note that executable scripts with a shebang (`#!`) line should use the
-      // line `#!/usr/bin/env coffee`, or `#!/absolute/path/to/coffee`, without a
-      // `--` argument after, because that will fail on Linux (see #3946).
-      ({rules, positional} = normalizeArguments(args, this.rules.flagDict));
-      options = {};
-// The `argument` field is added to the rule instance non-destructively by
-// `normalizeArguments`.
-      for (i = 0, len = rules.length; i < len; i++) {
-        ({hasArgument, argument, isList, name} = rules[i]);
-        if (hasArgument) {
-          if (isList) {
-            if (options[name] == null) {
-              options[name] = [];
-            }
-            options[name].push(argument);
-          } else {
-            options[name] = argument;
-          }
-        } else {
-          options[name] = true;
-        }
-      }
-      if (positional[0] === '--') {
-        options.doubleDashed = true;
-        positional = positional.slice(1);
-      }
-      options.arguments = positional;
-      return options;
-    }
-
-    // Return the help text for this **OptionParser**, listing and describing all
-    // of the valid options, for `--help` and such.
-    help() {
-      var i, len, letPart, lines, ref, rule, spaces;
-      lines = [];
-      if (this.banner) {
-        lines.unshift(`${this.banner}\n`);
-      }
-      ref = this.rules.ruleList;
-      for (i = 0, len = ref.length; i < len; i++) {
-        rule = ref[i];
-        spaces = 15 - rule.longFlag.length;
-        spaces = spaces > 0 ? repeat(' ', spaces) : '';
-        letPart = rule.shortFlag ? rule.shortFlag + ', ' : '    ';
-        lines.push('  ' + letPart + rule.longFlag + spaces + rule.description);
-      }
-      return `\n${lines.join('\n')}\n`;
-    }
-
-  };
-
-  // Helpers
-  // -------
-
-  // Regex matchers for option flags on the command line and their rules.
-  LONG_FLAG = /^(--\w[\w\-]*)/;
-
-  SHORT_FLAG = /^(-\w)$/;
-
-  MULTI_FLAG = /^-(\w{2,})/;
-
-  // Matches the long flag part of a rule for an option with an argument. Not
-  // applied to anything in process.argv.
-  OPTIONAL = /\[(\w+(\*?))\]/;
-
-  // Build and return the list of option rules. If the optional *short-flag* is
-  // unspecified, leave it out by padding with `null`.
-  buildRules = function(ruleDeclarations) {
-    var flag, flagDict, i, j, len, len1, ref, rule, ruleList, tuple;
-    ruleList = (function() {
-      var i, len, results;
-      results = [];
-      for (i = 0, len = ruleDeclarations.length; i < len; i++) {
-        tuple = ruleDeclarations[i];
-        if (tuple.length < 3) {
-          tuple.unshift(null);
-        }
-        results.push(buildRule(...tuple));
-      }
-      return results;
-    })();
-    flagDict = {};
-    for (i = 0, len = ruleList.length; i < len; i++) {
-      rule = ruleList[i];
-      ref = [rule.shortFlag, rule.longFlag];
-      // `shortFlag` is null if not provided in the rule.
-      for (j = 0, len1 = ref.length; j < len1; j++) {
-        flag = ref[j];
-        if (!(flag != null)) {
-          continue;
-        }
-        if (flagDict[flag] != null) {
-          throw new Error(`flag ${flag} for switch ${rule.name} was already declared for switch ${flagDict[flag].name}`);
-        }
-        flagDict[flag] = rule;
-      }
-    }
-    return {ruleList, flagDict};
-  };
-
-  // Build a rule from a `-o` short flag, a `--output [DIR]` long flag, and the
-  // description of what the option does.
-  buildRule = function(shortFlag, longFlag, description) {
-    var match;
-    match = longFlag.match(OPTIONAL);
-    shortFlag = shortFlag != null ? shortFlag.match(SHORT_FLAG)[1] : void 0;
-    longFlag = longFlag.match(LONG_FLAG)[1];
-    return {
-      name: longFlag.replace(/^--/, ''),
-      shortFlag: shortFlag,
-      longFlag: longFlag,
-      description: description,
-      hasArgument: !!(match && match[1]),
-      isList: !!(match && match[2])
-    };
-  };
-
-  normalizeArguments = function(args, flagDict) {
-    var arg, argIndex, flag, i, innerOpts, j, lastOpt, len, len1, multiFlags, multiOpts, needsArgOpt, positional, ref, rule, rules, singleRule, withArg;
-    rules = [];
-    positional = [];
-    needsArgOpt = null;
-    for (argIndex = i = 0, len = args.length; i < len; argIndex = ++i) {
-      arg = args[argIndex];
-      // If the previous argument given to the script was an option that uses the
-      // next command-line argument as its argument, create copy of the option’s
-      // rule with an `argument` field.
-      if (needsArgOpt != null) {
-        withArg = Object.assign({}, needsArgOpt.rule, {
-          argument: arg
-        });
-        rules.push(withArg);
-        needsArgOpt = null;
-        continue;
-      }
-      multiFlags = (ref = arg.match(MULTI_FLAG)) != null ? ref[1].split('').map(function(flagName) {
-        return `-${flagName}`;
-      }) : void 0;
-      if (multiFlags != null) {
-        multiOpts = multiFlags.map(function(flag) {
-          var rule;
-          rule = flagDict[flag];
-          if (rule == null) {
-            throw new Error(`unrecognized option ${flag} in multi-flag ${arg}`);
-          }
-          return {rule, flag};
-        });
-        // Only the last flag in a multi-flag may have an argument.
-        [...innerOpts] = multiOpts, [lastOpt] = splice.call(innerOpts, -1);
-        for (j = 0, len1 = innerOpts.length; j < len1; j++) {
-          ({rule, flag} = innerOpts[j]);
-          if (rule.hasArgument) {
-            throw new Error(`cannot use option ${flag} in multi-flag ${arg} except as the last option, because it needs an argument`);
-          }
-          rules.push(rule);
-        }
-        if (lastOpt.rule.hasArgument) {
-          needsArgOpt = lastOpt;
-        } else {
-          rules.push(lastOpt.rule);
-        }
-      } else if ([LONG_FLAG, SHORT_FLAG].some(function(pat) {
-        return arg.match(pat) != null;
-      })) {
-        singleRule = flagDict[arg];
-        if (singleRule == null) {
-          throw new Error(`unrecognized option ${arg}`);
-        }
-        if (singleRule.hasArgument) {
-          needsArgOpt = {
-            rule: singleRule,
-            flag: arg
-          };
-        } else {
-          rules.push(singleRule);
-        }
-      } else {
-        // This is a positional argument.
-        positional = args.slice(argIndex);
-        break;
-      }
-    }
-    if (needsArgOpt != null) {
-      throw new Error(`value required for ${needsArgOpt.flag}, but it was the last argument provided`);
-    }
-    return {rules, positional};
-  };
-
-}).call(this);