Name: js-handler/node_modules/optimist/node_modules/minimist/index.js 
1:
module.exports = function (args, opts) {
2:
    if (!opts) opts = {};
3:
    
4:
    var flags = { bools : {}, strings : {} };
5:
    
6:
    [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
7:
        flags.bools[key] = true;
8:
    });
9:
    
10:
    [].concat(opts.string).filter(Boolean).forEach(function (key) {
11:
        flags.strings[key] = true;
12:
    });
13:
    
14:
    var aliases = {};
15:
    Object.keys(opts.alias || {}).forEach(function (key) {
16:
        aliases[key] = [].concat(opts.alias[key]);
17:
        aliases[key].forEach(function (x) {
18:
            aliases[x] = [key].concat(aliases[key].filter(function (y) {
19:
                return x !== y;
20:
            }));
21:
        });
22:
    });
23:
    
24:
    var defaults = opts['default'] || {};
25:
    
26:
    var argv = { _ : [] };
27:
    Object.keys(flags.bools).forEach(function (key) {
28:
        setArg(key, defaults[key] === undefined ? false : defaults[key]);
29:
    });
30:
    
31:
    function setArg (key, val) {
32:
        var value = !flags.strings[key] && isNumber(val)
33:
            ? Number(val) : val
34:
        ;
35:
        setKey(argv, key.split('.'), value);
36:
        
37:
        (aliases[key] || []).forEach(function (x) {
38:
            argv[x] = argv[key];
39:
        });
40:
    }
41:
    
42:
    for (var i = 0; i < args.length; i++) {
43:
        var arg = args[i];
44:
        
45:
        if (arg === '--') {
46:
            argv._.push.apply(argv._, args.slice(i + 1));
47:
            break;
48:
        }
49:
        else if (arg.match(/^--.+=/)) {
50:
            // Using [\s\S] instead of . because js doesn't support the
51:
            // 'dotall' regex modifier. See:
52:
            // http://stackoverflow.com/a/1068308/13216
53:
            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
54:
            setArg(m[1], m[2]);
55:
        }
56:
        else if (arg.match(/^--no-.+/)) {
57:
            var key = arg.match(/^--no-(.+)/)[1];
58:
            setArg(key, false);
59:
        }
60:
        else if (arg.match(/^--.+/)) {
61:
            var key = arg.match(/^--(.+)/)[1];
62:
            var next = args[i + 1];
63:
            if (next !== undefined && !next.match(/^-/)
64:
            && !flags.bools[key]
65:
            && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
66:
                setArg(key, next);
67:
                i++;
68:
            }
69:
            else if (/^(true|false)$/.test(next)) {
70:
                setArg(key, next === 'true');
71:
                i++;
72:
            }
73:
            else {
74:
                setArg(key, true);
75:
            }
76:
        }
77:
        else if (arg.match(/^-[^-]+/)) {
78:
            var letters = arg.slice(1,-1).split('');
79:
            
80:
            var broken = false;
81:
            for (var j = 0; j < letters.length; j++) {
82:
                var next = arg.slice(j+2);
83:
                
84:
                if (next === '-') {
85:
                    setArg(letters[j], next)
86:
                    continue;
87:
                }
88:
                
89:
                if (/[A-Za-z]/.test(letters[j])
90:
                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
91:
                    setArg(letters[j], next);
92:
                    broken = true;
93:
                    break;
94:
                }
95:
                
96:
                if (letters[j+1] && letters[j+1].match(/\W/)) {
97:
                    setArg(letters[j], arg.slice(j+2));
98:
                    broken = true;
99:
                    break;
100:
                }
101:
                else {
102:
                    setArg(letters[j], true);
103:
                }
104:
            }
105:
            
106:
            var key = arg.slice(-1)[0];
107:
            if (!broken && key !== '-') {
108:
                
109:
                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
110:
                && !flags.bools[key]
111:
                && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
112:
                    setArg(key, args[i+1]);
113:
                    i++;
114:
                }
115:
                else if (args[i+1] && /true|false/.test(args[i+1])) {
116:
                    setArg(key, args[i+1] === 'true');
117:
                    i++;
118:
                }
119:
                else {
120:
                    setArg(key, true);
121:
                }
122:
            }
123:
        }
124:
        else {
125:
            argv._.push(
126:
                flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
127:
            );
128:
        }
129:
    }
130:
    
131:
    Object.keys(defaults).forEach(function (key) {
132:
        if (!(key in argv)) {
133:
            argv[key] = defaults[key];
134:
            if (key in aliases) {
135:
                argv[aliases[key]] = defaults[key];
136:
            }
137:
        }
138:
    });
139:
    
140:
    return argv;
141:
};
142:
 
143:
function setKey (obj, keys, value) {
144:
    var o = obj;
145:
    keys.slice(0,-1).forEach(function (key) {
146:
        if (o[key] === undefined) o[key] = {};
147:
        o = o[key];
148:
    });
149:
    
150:
    var key = keys[keys.length - 1];
151:
    if (o[key] === undefined || typeof o[key] === 'boolean') {
152:
        o[key] = value;
153:
    }
154:
    else if (Array.isArray(o[key])) {
155:
        o[key].push(value);
156:
    }
157:
    else {
158:
        o[key] = [ o[key], value ];
159:
    }
160:
}
161:
 
162:
function isNumber (x) {
163:
    if (typeof x === 'number') return true;
164:
    if (/^0x[0-9a-f]+$/i.test(x)) return true;
165:
    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
166:
}
167:
 
168:
function longest (xs) {
169:
    return Math.max.apply(null, xs.map(function (x) { return x.length }));
170:
}