3 if (typeof window
=== 'undefined') window
= {};
6 require
=(function e(t
,n
,r
){function s(o
,u
){if(!n
[o
]){if(!t
[o
]){var a
=typeof require
=="function"&&require
;if(!u
&&a
)return a(o
,!0);if(i
)return i(o
,!0);throw new Error("Cannot find module '"+o
+"'")}var f
=n
[o
]={exports
:{}};t
[o
][0].call(f
.exports
,function(e
){var n
=t
[o
][1][e
];return s(n
?n
:e
)},f
,f
.exports
,e
,t
,n
,r
)}return n
[o
].exports
}var i
=typeof require
=="function"&&require
;for(var o
=0;o
<r
.length
;o
++)s(r
[o
]);return s
})({1:[function(require
,module
,exports
){
7 var identifierStartTable
= [];
9 for (var i
= 0; i
< 128; i
++) {
10 identifierStartTable
[i
] =
12 i
>= 65 && i
<= 90 || // A-Z
14 i
>= 97 && i
<= 122; // a-z
17 var identifierPartTable
= [];
19 for (var i
= 0; i
< 128; i
++) {
20 identifierPartTable
[i
] =
21 identifierStartTable
[i
] || // $, _, A-Z, a-z
22 i
>= 48 && i
<= 57; // 0-9
26 asciiIdentifierStartTable
: identifierStartTable
,
27 asciiIdentifierPartTable
: identifierPartTable
30 },{}],2:[function(require
,module
,exports
){
1602 },{}],3:[function(require
,module
,exports
){
50081 },{}],4:[function(require
,module
,exports
){
50082 // http://wiki.commonjs.org/wiki/Unit_Testing/1.0
50084 // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
50086 // Originally from narwhal.js (http://narwhaljs.org)
50087 // Copyright (c) 2009 Thomas Robinson <280north.com>
50089 // Permission is hereby granted, free of charge, to any person obtaining a copy
50090 // of this software and associated documentation files (the 'Software'), to
50091 // deal in the Software without restriction, including without limitation the
50092 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
50093 // sell copies of the Software, and to permit persons to whom the Software is
50094 // furnished to do so, subject to the following conditions:
50096 // The above copyright notice and this permission notice shall be included in
50097 // all copies or substantial portions of the Software.
50099 // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
50100 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
50101 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
50102 // AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
50103 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
50104 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
50106 // when used in node, this will actually load the util module we depend on
50107 // versus loading the builtin util module as happens otherwise
50108 // this is a bug in node module loading as far as I am concerned
50109 var util
= require('util/');
50111 var pSlice
= Array
.prototype.slice
;
50112 var hasOwn
= Object
.prototype.hasOwnProperty
;
50114 // 1. The assert module provides functions that throw
50115 // AssertionError's when particular conditions are not met. The
50116 // assert module must conform to the following interface.
50118 var assert
= module
.exports
= ok
;
50120 // 2. The AssertionError is defined in assert.
50121 // new assert.AssertionError({ message: message,
50123 // expected: expected })
50125 assert
.AssertionError
= function AssertionError(options
) {
50126 this.name
= 'AssertionError';
50127 this.actual
= options
.actual
;
50128 this.expected
= options
.expected
;
50129 this.operator
= options
.operator
;
50130 if (options
.message
) {
50131 this.message
= options
.message
;
50132 this.generatedMessage
= false;
50134 this.message
= getMessage(this);
50135 this.generatedMessage
= true;
50137 var stackStartFunction
= options
.stackStartFunction
|| fail
;
50139 if (Error
.captureStackTrace
) {
50140 Error
.captureStackTrace(this, stackStartFunction
);
50143 // non v8 browsers so we can have a stacktrace
50144 var err
= new Error();
50146 var out
= err
.stack
;
50148 // try to strip useless frames
50149 var fn_name
= stackStartFunction
.name
;
50150 var idx
= out
.indexOf('\n' + fn_name
);
50152 // once we have located the function frame
50153 // we need to strip out everything before it (and its line)
50154 var next_line
= out
.indexOf('\n', idx
+ 1);
50155 out
= out
.substring(next_line
+ 1);
50163 // assert.AssertionError instanceof Error
50164 util
.inherits(assert
.AssertionError
, Error
);
50166 function replacer(key
, value
) {
50167 if (util
.isUndefined(value
)) {
50170 if (util
.isNumber(value
) && (isNaN(value
) || !isFinite(value
))) {
50171 return value
.toString();
50173 if (util
.isFunction(value
) || util
.isRegExp(value
)) {
50174 return value
.toString();
50179 function truncate(s
, n
) {
50180 if (util
.isString(s
)) {
50181 return s
.length
< n
? s
: s
.slice(0, n
);
50187 function getMessage(self
) {
50188 return truncate(JSON
.stringify(self
.actual
, replacer
), 128) + ' ' +
50189 self
.operator
+ ' ' +
50190 truncate(JSON
.stringify(self
.expected
, replacer
), 128);
50193 // At present only the three keys mentioned above are used and
50194 // understood by the spec. Implementations or sub modules can pass
50195 // other keys to the AssertionError's constructor - they will be
50198 // 3. All of the following functions must throw an AssertionError
50199 // when a corresponding condition is not met, with a message that
50200 // may be undefined if not provided. All assertion methods provide
50201 // both the actual and expected values to the assertion error for
50202 // display purposes.
50204 function fail(actual
, expected
, message
, operator
, stackStartFunction
) {
50205 throw new assert
.AssertionError({
50208 expected
: expected
,
50209 operator
: operator
,
50210 stackStartFunction
: stackStartFunction
50214 // EXTENSION! allows for well behaved errors defined elsewhere.
50215 assert
.fail
= fail
;
50217 // 4. Pure assertion tests whether a value is truthy, as determined
50219 // assert.ok(guard, message_opt);
50220 // This statement is equivalent to assert.equal(true, !!guard,
50221 // message_opt);. To test strictly for the value true, use
50222 // assert.strictEqual(true, guard, message_opt);.
50224 function ok(value
, message
) {
50225 if (!value
) fail(value
, true, message
, '==', assert
.ok
);
50229 // 5. The equality assertion tests shallow, coercive equality with
50231 // assert.equal(actual, expected, message_opt);
50233 assert
.equal
= function equal(actual
, expected
, message
) {
50234 if (actual
!= expected
) fail(actual
, expected
, message
, '==', assert
.equal
);
50237 // 6. The non-equality assertion tests for whether two objects are not equal
50238 // with != assert.notEqual(actual, expected, message_opt);
50240 assert
.notEqual
= function notEqual(actual
, expected
, message
) {
50241 if (actual
== expected
) {
50242 fail(actual
, expected
, message
, '!=', assert
.notEqual
);
50246 // 7. The equivalence assertion tests a deep equality relation.
50247 // assert.deepEqual(actual, expected, message_opt);
50249 assert
.deepEqual
= function deepEqual(actual
, expected
, message
) {
50250 if (!_deepEqual(actual
, expected
)) {
50251 fail(actual
, expected
, message
, 'deepEqual', assert
.deepEqual
);
50255 function _deepEqual(actual
, expected
) {
50256 // 7.1. All identical values are equivalent, as determined by ===.
50257 if (actual
=== expected
) {
50260 } else if (util
.isBuffer(actual
) && util
.isBuffer(expected
)) {
50261 if (actual
.length
!= expected
.length
) return false;
50263 for (var i
= 0; i
< actual
.length
; i
++) {
50264 if (actual
[i
] !== expected
[i
]) return false;
50269 // 7.2. If the expected value is a Date object, the actual value is
50270 // equivalent if it is also a Date object that refers to the same time.
50271 } else if (util
.isDate(actual
) && util
.isDate(expected
)) {
50272 return actual
.getTime() === expected
.getTime();
50274 // 7.3 If the expected value is a RegExp object, the actual value is
50275 // equivalent if it is also a RegExp object with the same source and
50276 // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
50277 } else if (util
.isRegExp(actual
) && util
.isRegExp(expected
)) {
50278 return actual
.source
=== expected
.source
&&
50279 actual
.global
=== expected
.global
&&
50280 actual
.multiline
=== expected
.multiline
&&
50281 actual
.lastIndex
=== expected
.lastIndex
&&
50282 actual
.ignoreCase
=== expected
.ignoreCase
;
50284 // 7.4. Other pairs that do not both pass typeof value == 'object',
50285 // equivalence is determined by ==.
50286 } else if (!util
.isObject(actual
) && !util
.isObject(expected
)) {
50287 return actual
== expected
;
50289 // 7.5 For all other Object pairs, including Array objects, equivalence is
50290 // determined by having the same number of owned properties (as verified
50291 // with Object.prototype.hasOwnProperty.call), the same set of keys
50292 // (although not necessarily the same order), equivalent values for every
50293 // corresponding key, and an identical 'prototype' property. Note: this
50294 // accounts for both named and indexed properties on Arrays.
50296 return objEquiv(actual
, expected
);
50300 function isArguments(object
) {
50301 return Object
.prototype.toString
.call(object
) == '[object Arguments]';
50304 function objEquiv(a
, b
) {
50305 if (util
.isNullOrUndefined(a
) || util
.isNullOrUndefined(b
))
50307 // an identical 'prototype' property.
50308 if (a
.prototype !== b
.prototype) return false;
50309 //~~~I've managed to break Object.keys through screwy arguments passing.
50310 // Converting to array solves the problem.
50311 if (isArguments(a
)) {
50312 if (!isArguments(b
)) {
50315 a
= pSlice
.call(a
);
50316 b
= pSlice
.call(b
);
50317 return _deepEqual(a
, b
);
50320 var ka
= objectKeys(a
),
50321 kb
= objectKeys(b
),
50323 } catch (e
) {//happens when one is a string literal and the other isn't
50326 // having the same number of owned properties (keys incorporates
50328 if (ka
.length
!= kb
.length
)
50330 //the same set of keys (although not necessarily the same order),
50333 //~~~cheap key test
50334 for (i
= ka
.length
- 1; i
>= 0; i
--) {
50335 if (ka
[i
] != kb
[i
])
50338 //equivalent values for every corresponding key, and
50339 //~~~possibly expensive deep test
50340 for (i
= ka
.length
- 1; i
>= 0; i
--) {
50342 if (!_deepEqual(a
[key
], b
[key
])) return false;
50347 // 8. The non-equivalence assertion tests for any deep inequality.
50348 // assert.notDeepEqual(actual, expected, message_opt);
50350 assert
.notDeepEqual
= function notDeepEqual(actual
, expected
, message
) {
50351 if (_deepEqual(actual
, expected
)) {
50352 fail(actual
, expected
, message
, 'notDeepEqual', assert
.notDeepEqual
);
50356 // 9. The strict equality assertion tests strict equality, as determined by ===.
50357 // assert.strictEqual(actual, expected, message_opt);
50359 assert
.strictEqual
= function strictEqual(actual
, expected
, message
) {
50360 if (actual
!== expected
) {
50361 fail(actual
, expected
, message
, '===', assert
.strictEqual
);
50365 // 10. The strict non-equality assertion tests for strict inequality, as
50366 // determined by !==. assert.notStrictEqual(actual, expected, message_opt);
50368 assert
.notStrictEqual
= function notStrictEqual(actual
, expected
, message
) {
50369 if (actual
=== expected
) {
50370 fail(actual
, expected
, message
, '!==', assert
.notStrictEqual
);
50374 function expectedException(actual
, expected
) {
50375 if (!actual
|| !expected
) {
50379 if (Object
.prototype.toString
.call(expected
) == '[object RegExp]') {
50380 return expected
.test(actual
);
50381 } else if (actual
instanceof expected
) {
50383 } else if (expected
.call({}, actual
) === true) {
50390 function _throws(shouldThrow
, block
, expected
, message
) {
50393 if (util
.isString(expected
)) {
50394 message
= expected
;
50404 message
= (expected
&& expected
.name
? ' (' + expected
.name
+ ').' : '.') +
50405 (message
? ' ' + message
: '.');
50407 if (shouldThrow
&& !actual
) {
50408 fail(actual
, expected
, 'Missing expected exception' + message
);
50411 if (!shouldThrow
&& expectedException(actual
, expected
)) {
50412 fail(actual
, expected
, 'Got unwanted exception' + message
);
50415 if ((shouldThrow
&& actual
&& expected
&&
50416 !expectedException(actual
, expected
)) || (!shouldThrow
&& actual
)) {
50421 // 11. Expected to throw an error:
50422 // assert.throws(block, Error_opt, message_opt);
50424 assert
.throws = function(block
, /*optional*/error
, /*optional*/message
) {
50425 _throws
.apply(this, [true].concat(pSlice
.call(arguments
)));
50428 // EXTENSION! This is annoying to write outside this module.
50429 assert
.doesNotThrow = function(block
, /*optional*/message
) {
50430 _throws
.apply(this, [false].concat(pSlice
.call(arguments
)));
50433 assert
.ifError = function(err
) { if (err
) {throw err
;}};
50435 var objectKeys
= Object
.keys
|| function (obj
) {
50437 for (var key
in obj
) {
50438 if (Object
.prototype.hasOwnProperty
.call(obj
, key
)) keys
.push(key
);
50443 },{"util/":9}],5:[function(require
,module
,exports
){
50444 // Copyright Joyent, Inc. and other Node contributors.
50446 // Permission is hereby granted, free of charge, to any person obtaining a
50447 // copy of this software and associated documentation files (the
50448 // "Software"), to deal in the Software without restriction, including
50449 // without limitation the rights to use, copy, modify, merge, publish,
50450 // distribute, sublicense, and/or sell copies of the Software, and to permit
50451 // persons to whom the Software is furnished to do so, subject to the
50452 // following conditions:
50454 // The above copyright notice and this permission notice shall be included
50455 // in all copies or substantial portions of the Software.
50457 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
50458 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
50459 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
50460 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
50461 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
50462 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
50463 // USE OR OTHER DEALINGS IN THE SOFTWARE.
50465 function EventEmitter() {
50466 this._events
= this._events
|| {};
50467 this._maxListeners
= this._maxListeners
|| undefined;
50469 module
.exports
= EventEmitter
;
50471 // Backwards-compat with node 0.10.x
50472 EventEmitter
.EventEmitter
= EventEmitter
;
50474 EventEmitter
.prototype._events
= undefined;
50475 EventEmitter
.prototype._maxListeners
= undefined;
50477 // By default EventEmitters will print a warning if more than 10 listeners are
50478 // added to it. This is a useful default which helps finding memory leaks.
50479 EventEmitter
.defaultMaxListeners
= 10;
50481 // Obviously not all Emitters should be limited to 10. This function allows
50482 // that to be increased. Set to zero for unlimited.
50483 EventEmitter
.prototype.setMaxListeners = function(n
) {
50484 if (!isNumber(n
) || n
< 0 || isNaN(n
))
50485 throw TypeError('n must be a positive number');
50486 this._maxListeners
= n
;
50490 EventEmitter
.prototype.emit = function(type
) {
50491 var er
, handler
, len
, args
, i
, listeners
;
50496 // If there is no 'error' event listener then throw.
50497 if (type
=== 'error') {
50498 if (!this._events
.error
||
50499 (isObject(this._events
.error
) && !this._events
.error
.length
)) {
50501 if (er
instanceof Error
) {
50502 throw er
; // Unhandled 'error' event
50504 throw TypeError('Uncaught, unspecified "error" event.');
50510 handler
= this._events
[type
];
50512 if (isUndefined(handler
))
50515 if (isFunction(handler
)) {
50516 switch (arguments
.length
) {
50519 handler
.call(this);
50522 handler
.call(this, arguments
[1]);
50525 handler
.call(this, arguments
[1], arguments
[2]);
50529 len
= arguments
.length
;
50530 args
= new Array(len
- 1);
50531 for (i
= 1; i
< len
; i
++)
50532 args
[i
- 1] = arguments
[i
];
50533 handler
.apply(this, args
);
50535 } else if (isObject(handler
)) {
50536 len
= arguments
.length
;
50537 args
= new Array(len
- 1);
50538 for (i
= 1; i
< len
; i
++)
50539 args
[i
- 1] = arguments
[i
];
50541 listeners
= handler
.slice();
50542 len
= listeners
.length
;
50543 for (i
= 0; i
< len
; i
++)
50544 listeners
[i
].apply(this, args
);
50550 EventEmitter
.prototype.addListener = function(type
, listener
) {
50553 if (!isFunction(listener
))
50554 throw TypeError('listener must be a function');
50559 // To avoid recursion in the case that type === "newListener"! Before
50560 // adding it to the listeners, first emit "newListener".
50561 if (this._events
.newListener
)
50562 this.emit('newListener', type
,
50563 isFunction(listener
.listener
) ?
50564 listener
.listener
: listener
);
50566 if (!this._events
[type
])
50567 // Optimize the case of one listener. Don't need the extra array object.
50568 this._events
[type
] = listener
;
50569 else if (isObject(this._events
[type
]))
50570 // If we've already got an array, just append.
50571 this._events
[type
].push(listener
);
50573 // Adding the second element, need to change to array.
50574 this._events
[type
] = [this._events
[type
], listener
];
50576 // Check for listener leak
50577 if (isObject(this._events
[type
]) && !this._events
[type
].warned
) {
50579 if (!isUndefined(this._maxListeners
)) {
50580 m
= this._maxListeners
;
50582 m
= EventEmitter
.defaultMaxListeners
;
50585 if (m
&& m
> 0 && this._events
[type
].length
> m
) {
50586 this._events
[type
].warned
= true;
50587 console
.error('(node) warning: possible EventEmitter memory ' +
50588 'leak detected. %d listeners added. ' +
50589 'Use emitter.setMaxListeners() to increase limit.',
50590 this._events
[type
].length
);
50598 EventEmitter
.prototype.on
= EventEmitter
.prototype.addListener
;
50600 EventEmitter
.prototype.once = function(type
, listener
) {
50601 if (!isFunction(listener
))
50602 throw TypeError('listener must be a function');
50607 this.removeListener(type
, g
);
50611 listener
.apply(this, arguments
);
50615 g
.listener
= listener
;
50621 // emits a 'removeListener' event iff the listener was removed
50622 EventEmitter
.prototype.removeListener = function(type
, listener
) {
50623 var list
, position
, length
, i
;
50625 if (!isFunction(listener
))
50626 throw TypeError('listener must be a function');
50628 if (!this._events
|| !this._events
[type
])
50631 list
= this._events
[type
];
50632 length
= list
.length
;
50635 if (list
=== listener
||
50636 (isFunction(list
.listener
) && list
.listener
=== listener
)) {
50637 delete this._events
[type
];
50638 if (this._events
.removeListener
)
50639 this.emit('removeListener', type
, listener
);
50641 } else if (isObject(list
)) {
50642 for (i
= length
; i
-- > 0;) {
50643 if (list
[i
] === listener
||
50644 (list
[i
].listener
&& list
[i
].listener
=== listener
)) {
50653 if (list
.length
=== 1) {
50655 delete this._events
[type
];
50657 list
.splice(position
, 1);
50660 if (this._events
.removeListener
)
50661 this.emit('removeListener', type
, listener
);
50667 EventEmitter
.prototype.removeAllListeners = function(type
) {
50668 var key
, listeners
;
50673 // not listening for removeListener, no need to emit
50674 if (!this._events
.removeListener
) {
50675 if (arguments
.length
=== 0)
50677 else if (this._events
[type
])
50678 delete this._events
[type
];
50682 // emit removeListener for all listeners on all events
50683 if (arguments
.length
=== 0) {
50684 for (key
in this._events
) {
50685 if (key
=== 'removeListener') continue;
50686 this.removeAllListeners(key
);
50688 this.removeAllListeners('removeListener');
50693 listeners
= this._events
[type
];
50695 if (isFunction(listeners
)) {
50696 this.removeListener(type
, listeners
);
50699 while (listeners
.length
)
50700 this.removeListener(type
, listeners
[listeners
.length
- 1]);
50702 delete this._events
[type
];
50707 EventEmitter
.prototype.listeners = function(type
) {
50709 if (!this._events
|| !this._events
[type
])
50711 else if (isFunction(this._events
[type
]))
50712 ret
= [this._events
[type
]];
50714 ret
= this._events
[type
].slice();
50718 EventEmitter
.listenerCount = function(emitter
, type
) {
50720 if (!emitter
._events
|| !emitter
._events
[type
])
50722 else if (isFunction(emitter
._events
[type
]))
50725 ret
= emitter
._events
[type
].length
;
50729 function isFunction(arg
) {
50730 return typeof arg
=== 'function';
50733 function isNumber(arg
) {
50734 return typeof arg
=== 'number';
50737 function isObject(arg
) {
50738 return typeof arg
=== 'object' && arg
!== null;
50741 function isUndefined(arg
) {
50742 return arg
=== void 0;
50745 },{}],6:[function(require
,module
,exports
){
50746 if (typeof Object
.create
=== 'function') {
50747 // implementation from standard node.js 'util' module
50748 module
.exports
= function inherits(ctor
, superCtor
) {
50749 ctor
.super_
= superCtor
50750 ctor
.prototype = Object
.create(superCtor
.prototype, {
50760 // old school shim for old browsers
50761 module
.exports
= function inherits(ctor
, superCtor
) {
50762 ctor
.super_
= superCtor
50763 var TempCtor = function () {}
50764 TempCtor
.prototype = superCtor
.prototype
50765 ctor
.prototype = new TempCtor()
50766 ctor
.prototype.constructor = ctor
50770 },{}],7:[function(require
,module
,exports
){
50771 // shim for using process in browser
50773 var process
= module
.exports
= {};
50775 process
.nextTick
= (function () {
50776 var canSetImmediate
= typeof window
!== 'undefined'
50777 && window
.setImmediate
;
50778 var canPost
= typeof window
!== 'undefined'
50779 && window
.postMessage
&& window
.addEventListener
50782 if (canSetImmediate
) {
50783 return function (f
) { return window
.setImmediate(f
) };
50788 window
.addEventListener('message', function (ev
) {
50789 var source
= ev
.source
;
50790 if ((source
=== window
|| source
=== null) && ev
.data
=== 'process-tick') {
50791 ev
.stopPropagation();
50792 if (queue
.length
> 0) {
50793 var fn
= queue
.shift();
50799 return function nextTick(fn
) {
50801 window
.postMessage('process-tick', '*');
50805 return function nextTick(fn
) {
50810 process
.title
= 'browser';
50811 process
.browser
= true;
50815 process
.binding = function (name
) {
50816 throw new Error('process.binding is not supported');
50820 process
.cwd = function () { return '/' };
50821 process
.chdir = function (dir
) {
50822 throw new Error('process.chdir is not supported');
50825 },{}],8:[function(require
,module
,exports
){
50826 module
.exports
= function isBuffer(arg
) {
50827 return arg
&& typeof arg
=== 'object'
50828 && typeof arg
.copy
=== 'function'
50829 && typeof arg
.fill
=== 'function'
50830 && typeof arg
.readUInt8
=== 'function';
50832 },{}],9:[function(require
,module
,exports
){
50833 var process
=require("__browserify_process"),global
=typeof self
!== "undefined" ? self
: typeof window
!== "undefined" ? window
: {};// Copyright Joyent, Inc. and other Node contributors.
50835 // Permission is hereby granted, free of charge, to any person obtaining a
50836 // copy of this software and associated documentation files (the
50837 // "Software"), to deal in the Software without restriction, including
50838 // without limitation the rights to use, copy, modify, merge, publish,
50839 // distribute, sublicense, and/or sell copies of the Software, and to permit
50840 // persons to whom the Software is furnished to do so, subject to the
50841 // following conditions:
50843 // The above copyright notice and this permission notice shall be included
50844 // in all copies or substantial portions of the Software.
50846 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
50847 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
50848 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
50849 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
50850 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
50851 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
50852 // USE OR OTHER DEALINGS IN THE SOFTWARE.
50854 var formatRegExp
= /%[sdj%]/g;
50855 exports
.format = function(f
) {
50856 if (!isString(f
)) {
50858 for (var i
= 0; i
< arguments
.length
; i
++) {
50859 objects
.push(inspect(arguments
[i
]));
50861 return objects
.join(' ');
50865 var args
= arguments
;
50866 var len
= args
.length
;
50867 var str
= String(f
).replace(formatRegExp
, function(x
) {
50868 if (x
=== '%%') return '%';
50869 if (i
>= len
) return x
;
50871 case '%s': return String(args
[i
++]);
50872 case '%d': return Number(args
[i
++]);
50875 return JSON
.stringify(args
[i
++]);
50877 return '[Circular]';
50883 for (var x
= args
[i
]; i
< len
; x
= args
[++i
]) {
50884 if (isNull(x
) || !isObject(x
)) {
50887 str
+= ' ' + inspect(x
);
50894 // Mark that a method should not be used.
50895 // Returns a modified function which warns once by default.
50896 // If --no-deprecation is set, then it is a no-op.
50897 exports
.deprecate = function(fn
, msg
) {
50898 // Allow for deprecating things in the process of starting up.
50899 if (isUndefined(global
.process
)) {
50900 return function() {
50901 return exports
.deprecate(fn
, msg
).apply(this, arguments
);
50905 if (process
.noDeprecation
=== true) {
50909 var warned
= false;
50910 function deprecated() {
50912 if (process
.throwDeprecation
) {
50913 throw new Error(msg
);
50914 } else if (process
.traceDeprecation
) {
50915 console
.trace(msg
);
50917 console
.error(msg
);
50921 return fn
.apply(this, arguments
);
50930 exports
.debuglog = function(set) {
50931 if (isUndefined(debugEnviron
))
50932 debugEnviron
= process
.env
.NODE_DEBUG
|| '';
50933 set = set.toUpperCase();
50934 if (!debugs
[set]) {
50935 if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron
)) {
50936 var pid
= process
.pid
;
50937 debugs
[set] = function() {
50938 var msg
= exports
.format
.apply(exports
, arguments
);
50939 console
.error('%s %d: %s', set, pid
, msg
);
50942 debugs
[set] = function() {};
50945 return debugs
[set];
50950 * Echos the value of a value. Trys to print the value out
50951 * in the best way possible given the different types.
50953 * @param {Object} obj The object to print out.
50954 * @param {Object} opts Optional options object that alters the output.
50956 /* legacy: obj, showHidden, depth, colors*/
50957 function inspect(obj
, opts
) {
50961 stylize
: stylizeNoColor
50964 if (arguments
.length
>= 3) ctx
.depth
= arguments
[2];
50965 if (arguments
.length
>= 4) ctx
.colors
= arguments
[3];
50966 if (isBoolean(opts
)) {
50968 ctx
.showHidden
= opts
;
50970 // got an "options" object
50971 exports
._extend(ctx
, opts
);
50973 // set default options
50974 if (isUndefined(ctx
.showHidden
)) ctx
.showHidden
= false;
50975 if (isUndefined(ctx
.depth
)) ctx
.depth
= 2;
50976 if (isUndefined(ctx
.colors
)) ctx
.colors
= false;
50977 if (isUndefined(ctx
.customInspect
)) ctx
.customInspect
= true;
50978 if (ctx
.colors
) ctx
.stylize
= stylizeWithColor
;
50979 return formatValue(ctx
, obj
, ctx
.depth
);
50981 exports
.inspect
= inspect
;
50984 // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
50987 'italic' : [3, 23],
50988 'underline' : [4, 24],
50989 'inverse' : [7, 27],
50990 'white' : [37, 39],
50992 'black' : [30, 39],
50995 'green' : [32, 39],
50996 'magenta' : [35, 39],
50998 'yellow' : [33, 39]
51001 // Don't use 'blue' not visible on cmd.exe
51004 'number': 'yellow',
51005 'boolean': 'yellow',
51006 'undefined': 'grey',
51010 // "name": intentionally not styling
51015 function stylizeWithColor(str
, styleType
) {
51016 var style
= inspect
.styles
[styleType
];
51019 return '\u001b[' + inspect
.colors
[style
][0] + 'm' + str
+
51020 '\u001b[' + inspect
.colors
[style
][1] + 'm';
51027 function stylizeNoColor(str
, styleType
) {
51032 function arrayToHash(array
) {
51035 array
.forEach(function(val
, idx
) {
51043 function formatValue(ctx
, value
, recurseTimes
) {
51044 // Provide a hook for user-specified inspect functions.
51045 // Check that value is an object with an inspect function on it
51046 if (ctx
.customInspect
&&
51048 isFunction(value
.inspect
) &&
51049 // Filter out the util module, it's inspect function is special
51050 value
.inspect
!== exports
.inspect
&&
51051 // Also filter out any prototype objects using the circular check.
51052 !(value
.constructor && value
.constructor.prototype === value
)) {
51053 var ret
= value
.inspect(recurseTimes
, ctx
);
51054 if (!isString(ret
)) {
51055 ret
= formatValue(ctx
, ret
, recurseTimes
);
51060 // Primitive types cannot have properties
51061 var primitive
= formatPrimitive(ctx
, value
);
51066 // Look up the keys of the object.
51067 var keys
= Object
.keys(value
);
51068 var visibleKeys
= arrayToHash(keys
);
51070 if (ctx
.showHidden
) {
51071 keys
= Object
.getOwnPropertyNames(value
);
51074 // IE doesn't make error fields non-enumerable
51075 // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
51077 && (keys
.indexOf('message') >= 0 || keys
.indexOf('description') >= 0)) {
51078 return formatError(value
);
51081 // Some type of object without properties can be shortcutted.
51082 if (keys
.length
=== 0) {
51083 if (isFunction(value
)) {
51084 var name
= value
.name
? ': ' + value
.name
: '';
51085 return ctx
.stylize('[Function' + name
+ ']', 'special');
51087 if (isRegExp(value
)) {
51088 return ctx
.stylize(RegExp
.prototype.toString
.call(value
), 'regexp');
51090 if (isDate(value
)) {
51091 return ctx
.stylize(Date
.prototype.toString
.call(value
), 'date');
51093 if (isError(value
)) {
51094 return formatError(value
);
51098 var base
= '', array
= false, braces
= ['{', '}'];
51100 // Make Array say that they are Array
51101 if (isArray(value
)) {
51103 braces
= ['[', ']'];
51106 // Make functions say that they are functions
51107 if (isFunction(value
)) {
51108 var n
= value
.name
? ': ' + value
.name
: '';
51109 base
= ' [Function' + n
+ ']';
51112 // Make RegExps say that they are RegExps
51113 if (isRegExp(value
)) {
51114 base
= ' ' + RegExp
.prototype.toString
.call(value
);
51117 // Make dates with properties first say the date
51118 if (isDate(value
)) {
51119 base
= ' ' + Date
.prototype.toUTCString
.call(value
);
51122 // Make error with message first say the error
51123 if (isError(value
)) {
51124 base
= ' ' + formatError(value
);
51127 if (keys
.length
=== 0 && (!array
|| value
.length
== 0)) {
51128 return braces
[0] + base
+ braces
[1];
51131 if (recurseTimes
< 0) {
51132 if (isRegExp(value
)) {
51133 return ctx
.stylize(RegExp
.prototype.toString
.call(value
), 'regexp');
51135 return ctx
.stylize('[Object]', 'special');
51139 ctx
.seen
.push(value
);
51143 output
= formatArray(ctx
, value
, recurseTimes
, visibleKeys
, keys
);
51145 output
= keys
.map(function(key
) {
51146 return formatProperty(ctx
, value
, recurseTimes
, visibleKeys
, key
, array
);
51152 return reduceToSingleString(output
, base
, braces
);
51156 function formatPrimitive(ctx
, value
) {
51157 if (isUndefined(value
))
51158 return ctx
.stylize('undefined', 'undefined');
51159 if (isString(value
)) {
51160 var simple
= '\'' + JSON
.stringify(value
).replace(/^"|"$/g, '')
51161 .replace(/'/g, "\\'")
51162 .replace(/\\"/g
, '"') + '\'';
51163 return ctx
.stylize(simple
, 'string');
51165 if (isNumber(value
))
51166 return ctx
.stylize('' + value
, 'number');
51167 if (isBoolean(value
))
51168 return ctx
.stylize('' + value
, 'boolean');
51169 // For some reason typeof null is "object", so special case here.
51171 return ctx
.stylize('null', 'null');
51175 function formatError(value
) {
51176 return '[' + Error
.prototype.toString
.call(value
) + ']';
51180 function formatArray(ctx
, value
, recurseTimes
, visibleKeys
, keys
) {
51182 for (var i
= 0, l
= value
.length
; i
< l
; ++i
) {
51183 if (hasOwnProperty(value
, String(i
))) {
51184 output
.push(formatProperty(ctx
, value
, recurseTimes
, visibleKeys
,
51190 keys
.forEach(function(key
) {
51191 if (!key
.match(/^\d+$/)) {
51192 output
.push(formatProperty(ctx
, value
, recurseTimes
, visibleKeys
,
51200 function formatProperty(ctx
, value
, recurseTimes
, visibleKeys
, key
, array
) {
51201 var name
, str
, desc
;
51202 desc
= Object
.getOwnPropertyDescriptor(value
, key
) || { value
: value
[key
] };
51205 str
= ctx
.stylize('[Getter/Setter]', 'special');
51207 str
= ctx
.stylize('[Getter]', 'special');
51211 str
= ctx
.stylize('[Setter]', 'special');
51214 if (!hasOwnProperty(visibleKeys
, key
)) {
51215 name
= '[' + key
+ ']';
51218 if (ctx
.seen
.indexOf(desc
.value
) < 0) {
51219 if (isNull(recurseTimes
)) {
51220 str
= formatValue(ctx
, desc
.value
, null);
51222 str
= formatValue(ctx
, desc
.value
, recurseTimes
- 1);
51224 if (str
.indexOf('\n') > -1) {
51226 str
= str
.split('\n').map(function(line
) {
51228 }).join('\n').substr(2);
51230 str
= '\n' + str
.split('\n').map(function(line
) {
51236 str
= ctx
.stylize('[Circular]', 'special');
51239 if (isUndefined(name
)) {
51240 if (array
&& key
.match(/^\d+$/)) {
51243 name
= JSON
.stringify('' + key
);
51244 if (name
.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
51245 name
= name
.substr(1, name
.length
- 2);
51246 name
= ctx
.stylize(name
, 'name');
51248 name
= name
.replace(/'/g, "\\'")
51249 .replace(/\\"/g
, '"')
51250 .replace(/(^"|"$)/g, "'");
51251 name
= ctx
.stylize(name
, 'string');
51255 return name
+ ': ' + str
;
51259 function reduceToSingleString(output
, base
, braces
) {
51260 var numLinesEst
= 0;
51261 var length
= output
.reduce(function(prev
, cur
) {
51263 if (cur
.indexOf('\n') >= 0) numLinesEst
++;
51264 return prev
+ cur
.replace(/\u001b\[\d\d?m/g, '').length
+ 1;
51269 (base
=== '' ? '' : base
+ '\n ') +
51271 output
.join(',\n ') +
51276 return braces
[0] + base
+ ' ' + output
.join(', ') + ' ' + braces
[1];
51280 // NOTE: These type checking functions intentionally don't use `instanceof`
51281 // because it is fragile and can be easily faked with `Object.create()`.
51282 function isArray(ar
) {
51283 return Array
.isArray(ar
);
51285 exports
.isArray
= isArray
;
51287 function isBoolean(arg
) {
51288 return typeof arg
=== 'boolean';
51290 exports
.isBoolean
= isBoolean
;
51292 function isNull(arg
) {
51293 return arg
=== null;
51295 exports
.isNull
= isNull
;
51297 function isNullOrUndefined(arg
) {
51298 return arg
== null;
51300 exports
.isNullOrUndefined
= isNullOrUndefined
;
51302 function isNumber(arg
) {
51303 return typeof arg
=== 'number';
51305 exports
.isNumber
= isNumber
;
51307 function isString(arg
) {
51308 return typeof arg
=== 'string';
51310 exports
.isString
= isString
;
51312 function isSymbol(arg
) {
51313 return typeof arg
=== 'symbol';
51315 exports
.isSymbol
= isSymbol
;
51317 function isUndefined(arg
) {
51318 return arg
=== void 0;
51320 exports
.isUndefined
= isUndefined
;
51322 function isRegExp(re
) {
51323 return isObject(re
) && objectToString(re
) === '[object RegExp]';
51325 exports
.isRegExp
= isRegExp
;
51327 function isObject(arg
) {
51328 return typeof arg
=== 'object' && arg
!== null;
51330 exports
.isObject
= isObject
;
51332 function isDate(d
) {
51333 return isObject(d
) && objectToString(d
) === '[object Date]';
51335 exports
.isDate
= isDate
;
51337 function isError(e
) {
51338 return isObject(e
) &&
51339 (objectToString(e
) === '[object Error]' || e
instanceof Error
);
51341 exports
.isError
= isError
;
51343 function isFunction(arg
) {
51344 return typeof arg
=== 'function';
51346 exports
.isFunction
= isFunction
;
51348 function isPrimitive(arg
) {
51349 return arg
=== null ||
51350 typeof arg
=== 'boolean' ||
51351 typeof arg
=== 'number' ||
51352 typeof arg
=== 'string' ||
51353 typeof arg
=== 'symbol' || // ES6 symbol
51354 typeof arg
=== 'undefined';
51356 exports
.isPrimitive
= isPrimitive
;
51358 exports
.isBuffer
= require('./support/isBuffer');
51360 function objectToString(o
) {
51361 return Object
.prototype.toString
.call(o
);
51366 return n
< 10 ? '0' + n
.toString(10) : n
.toString(10);
51370 var months
= ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
51371 'Oct', 'Nov', 'Dec'];
51374 function timestamp() {
51375 var d
= new Date();
51376 var time
= [pad(d
.getHours()),
51377 pad(d
.getMinutes()),
51378 pad(d
.getSeconds())].join(':');
51379 return [d
.getDate(), months
[d
.getMonth()], time
].join(' ');
51383 // log is just a thin wrapper to console.log that prepends a timestamp
51384 exports
.log = function() {
51385 console
.log('%s - %s', timestamp(), exports
.format
.apply(exports
, arguments
));
51390 * Inherit the prototype methods from one constructor into another.
51392 * The Function.prototype.inherits from lang.js rewritten as a standalone
51393 * function (not on Function.prototype). NOTE: If this file is to be loaded
51394 * during bootstrapping this function needs to be rewritten using some native
51395 * functions as prototype setup using normal JavaScript does not work as
51396 * expected during bootstrapping (see mirror.js in r114903).
51398 * @param {function} ctor Constructor function which needs to inherit the
51400 * @param {function} superCtor Constructor function to inherit prototype from.
51402 exports
.inherits
= require('inherits');
51404 exports
._extend = function(origin
, add
) {
51405 // Don't do anything if add isn't an object
51406 if (!add
|| !isObject(add
)) return origin
;
51408 var keys
= Object
.keys(add
);
51409 var i
= keys
.length
;
51411 origin
[keys
[i
]] = add
[keys
[i
]];
51416 function hasOwnProperty(obj
, prop
) {
51417 return Object
.prototype.hasOwnProperty
.call(obj
, prop
);
51420 },{"./support/isBuffer":8,"__browserify_process":7,"inherits":6}],10:[function(require
,module
,exports
){
51421 var global
=typeof self
!== "undefined" ? self
: typeof window
!== "undefined" ? window
: {};/*global window, global*/
51422 var util
= require("util")
51423 var assert
= require("assert")
51425 var slice
= Array
.prototype.slice
51429 if (typeof global
!== "undefined" && global
.console
) {
51430 console
= global
.console
51431 } else if (typeof window
!== "undefined" && window
.console
) {
51432 console
= window
.console
51434 console
= window
.console
= {}
51443 , [timeEnd
, "timeEnd"]
51446 , [assert
, "assert"]
51449 for (var i
= 0; i
< functions
.length
; i
++) {
51450 var tuple
= functions
[i
]
51452 var name
= tuple
[1]
51454 if (!console
[name
]) {
51459 module
.exports
= console
51464 console
.log
.apply(console
, arguments
)
51468 console
.log
.apply(console
, arguments
)
51472 console
.warn
.apply(console
, arguments
)
51475 function time(label
) {
51476 times
[label
] = Date
.now()
51479 function timeEnd(label
) {
51480 var time
= times
[label
]
51482 throw new Error("No such label: " + label
)
51485 var duration
= Date
.now() - time
51486 console
.log(label
+ ": " + duration
+ "ms")
51490 var err
= new Error()
51492 err
.message
= util
.format
.apply(null, arguments
)
51493 console
.error(err
.stack
)
51496 function dir(object
) {
51497 console
.log(util
.inspect(object
) + "\n")
51500 function assert(expression
) {
51502 var arr
= slice
.call(arguments
, 1)
51503 assert
.ok(false, util
.format
.apply(null, arr
))
51507 },{"assert":4,"util":9}],11:[function(require
,module
,exports
){
51508 // Underscore.js 1.4.4
51509 // http://underscorejs.org
51510 // (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
51511 // Underscore may be freely distributed under the MIT license.
51518 // Establish the root object, `window` in the browser, or `global` on the server.
51521 // Save the previous value of the `_` variable.
51522 var previousUnderscore
= root
._
;
51524 // Establish the object that gets returned to break out of a loop iteration.
51527 // Save bytes in the minified (but not gzipped) version:
51528 var ArrayProto
= Array
.prototype, ObjProto
= Object
.prototype, FuncProto
= Function
.prototype;
51530 // Create quick reference variables for speed access to core prototypes.
51531 var push
= ArrayProto
.push
,
51532 slice
= ArrayProto
.slice
,
51533 concat
= ArrayProto
.concat
,
51534 toString
= ObjProto
.toString
,
51535 hasOwnProperty
= ObjProto
.hasOwnProperty
;
51537 // All **ECMAScript 5** native function implementations that we hope to use
51538 // are declared here.
51540 nativeForEach
= ArrayProto
.forEach
,
51541 nativeMap
= ArrayProto
.map
,
51542 nativeReduce
= ArrayProto
.reduce
,
51543 nativeReduceRight
= ArrayProto
.reduceRight
,
51544 nativeFilter
= ArrayProto
.filter
,
51545 nativeEvery
= ArrayProto
.every
,
51546 nativeSome
= ArrayProto
.some
,
51547 nativeIndexOf
= ArrayProto
.indexOf
,
51548 nativeLastIndexOf
= ArrayProto
.lastIndexOf
,
51549 nativeIsArray
= Array
.isArray
,
51550 nativeKeys
= Object
.keys
,
51551 nativeBind
= FuncProto
.bind
;
51553 // Create a safe reference to the Underscore object for use below.
51554 var _ = function(obj
) {
51555 if (obj
instanceof _
) return obj
;
51556 if (!(this instanceof _
)) return new _(obj
);
51557 this._wrapped
= obj
;
51560 // Export the Underscore object for **Node.js**, with
51561 // backwards-compatibility for the old `require()` API. If we're in
51562 // the browser, add `_` as a global object via a string identifier,
51563 // for Closure Compiler "advanced" mode.
51564 if (typeof exports
!== 'undefined') {
51565 if (typeof module
!== 'undefined' && module
.exports
) {
51566 exports
= module
.exports
= _
;
51573 // Current version.
51574 _
.VERSION
= '1.4.4';
51576 // Collection Functions
51577 // --------------------
51579 // The cornerstone, an `each` implementation, aka `forEach`.
51580 // Handles objects with the built-in `forEach`, arrays, and raw objects.
51581 // Delegates to **ECMAScript 5**'s native `forEach` if available.
51582 var each
= _
.each
= _
.forEach = function(obj
, iterator
, context
) {
51583 if (obj
== null) return;
51584 if (nativeForEach
&& obj
.forEach
=== nativeForEach
) {
51585 obj
.forEach(iterator
, context
);
51586 } else if (obj
.length
=== +obj
.length
) {
51587 for (var i
= 0, l
= obj
.length
; i
< l
; i
++) {
51588 if (iterator
.call(context
, obj
[i
], i
, obj
) === breaker
) return;
51591 for (var key
in obj
) {
51592 if (_
.has(obj
, key
)) {
51593 if (iterator
.call(context
, obj
[key
], key
, obj
) === breaker
) return;
51599 // Return the results of applying the iterator to each element.
51600 // Delegates to **ECMAScript 5**'s native `map` if available.
51601 _
.map
= _
.collect = function(obj
, iterator
, context
) {
51603 if (obj
== null) return results
;
51604 if (nativeMap
&& obj
.map
=== nativeMap
) return obj
.map(iterator
, context
);
51605 each(obj
, function(value
, index
, list
) {
51606 results
[results
.length
] = iterator
.call(context
, value
, index
, list
);
51611 var reduceError
= 'Reduce of empty array with no initial value';
51613 // **Reduce** builds up a single result from a list of values, aka `inject`,
51614 // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
51615 _
.reduce
= _
.foldl
= _
.inject = function(obj
, iterator
, memo
, context
) {
51616 var initial
= arguments
.length
> 2;
51617 if (obj
== null) obj
= [];
51618 if (nativeReduce
&& obj
.reduce
=== nativeReduce
) {
51619 if (context
) iterator
= _
.bind(iterator
, context
);
51620 return initial
? obj
.reduce(iterator
, memo
) : obj
.reduce(iterator
);
51622 each(obj
, function(value
, index
, list
) {
51627 memo
= iterator
.call(context
, memo
, value
, index
, list
);
51630 if (!initial
) throw new TypeError(reduceError
);
51634 // The right-associative version of reduce, also known as `foldr`.
51635 // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
51636 _
.reduceRight
= _
.foldr = function(obj
, iterator
, memo
, context
) {
51637 var initial
= arguments
.length
> 2;
51638 if (obj
== null) obj
= [];
51639 if (nativeReduceRight
&& obj
.reduceRight
=== nativeReduceRight
) {
51640 if (context
) iterator
= _
.bind(iterator
, context
);
51641 return initial
? obj
.reduceRight(iterator
, memo
) : obj
.reduceRight(iterator
);
51643 var length
= obj
.length
;
51644 if (length
!== +length
) {
51645 var keys
= _
.keys(obj
);
51646 length
= keys
.length
;
51648 each(obj
, function(value
, index
, list
) {
51649 index
= keys
? keys
[--length
] : --length
;
51654 memo
= iterator
.call(context
, memo
, obj
[index
], index
, list
);
51657 if (!initial
) throw new TypeError(reduceError
);
51661 // Return the first value which passes a truth test. Aliased as `detect`.
51662 _
.find
= _
.detect = function(obj
, iterator
, context
) {
51664 any(obj
, function(value
, index
, list
) {
51665 if (iterator
.call(context
, value
, index
, list
)) {
51673 // Return all the elements that pass a truth test.
51674 // Delegates to **ECMAScript 5**'s native `filter` if available.
51675 // Aliased as `select`.
51676 _
.filter
= _
.select = function(obj
, iterator
, context
) {
51678 if (obj
== null) return results
;
51679 if (nativeFilter
&& obj
.filter
=== nativeFilter
) return obj
.filter(iterator
, context
);
51680 each(obj
, function(value
, index
, list
) {
51681 if (iterator
.call(context
, value
, index
, list
)) results
[results
.length
] = value
;
51686 // Return all the elements for which a truth test fails.
51687 _
.reject = function(obj
, iterator
, context
) {
51688 return _
.filter(obj
, function(value
, index
, list
) {
51689 return !iterator
.call(context
, value
, index
, list
);
51693 // Determine whether all of the elements match a truth test.
51694 // Delegates to **ECMAScript 5**'s native `every` if available.
51695 // Aliased as `all`.
51696 _
.every
= _
.all = function(obj
, iterator
, context
) {
51697 iterator
|| (iterator
= _
.identity
);
51699 if (obj
== null) return result
;
51700 if (nativeEvery
&& obj
.every
=== nativeEvery
) return obj
.every(iterator
, context
);
51701 each(obj
, function(value
, index
, list
) {
51702 if (!(result
= result
&& iterator
.call(context
, value
, index
, list
))) return breaker
;
51707 // Determine if at least one element in the object matches a truth test.
51708 // Delegates to **ECMAScript 5**'s native `some` if available.
51709 // Aliased as `any`.
51710 var any
= _
.some
= _
.any = function(obj
, iterator
, context
) {
51711 iterator
|| (iterator
= _
.identity
);
51712 var result
= false;
51713 if (obj
== null) return result
;
51714 if (nativeSome
&& obj
.some
=== nativeSome
) return obj
.some(iterator
, context
);
51715 each(obj
, function(value
, index
, list
) {
51716 if (result
|| (result
= iterator
.call(context
, value
, index
, list
))) return breaker
;
51721 // Determine if the array or object contains a given value (using `===`).
51722 // Aliased as `include`.
51723 _
.contains
= _
.include = function(obj
, target
) {
51724 if (obj
== null) return false;
51725 if (nativeIndexOf
&& obj
.indexOf
=== nativeIndexOf
) return obj
.indexOf(target
) != -1;
51726 return any(obj
, function(value
) {
51727 return value
=== target
;
51731 // Invoke a method (with arguments) on every item in a collection.
51732 _
.invoke = function(obj
, method
) {
51733 var args
= slice
.call(arguments
, 2);
51734 var isFunc
= _
.isFunction(method
);
51735 return _
.map(obj
, function(value
) {
51736 return (isFunc
? method
: value
[method
]).apply(value
, args
);
51740 // Convenience version of a common use case of `map`: fetching a property.
51741 _
.pluck = function(obj
, key
) {
51742 return _
.map(obj
, function(value
){ return value
[key
]; });
51745 // Convenience version of a common use case of `filter`: selecting only objects
51746 // containing specific `key:value` pairs.
51747 _
.where = function(obj
, attrs
, first
) {
51748 if (_
.isEmpty(attrs
)) return first
? null : [];
51749 return _
[first
? 'find' : 'filter'](obj
, function(value
) {
51750 for (var key
in attrs
) {
51751 if (attrs
[key
] !== value
[key
]) return false;
51757 // Convenience version of a common use case of `find`: getting the first object
51758 // containing specific `key:value` pairs.
51759 _
.findWhere = function(obj
, attrs
) {
51760 return _
.where(obj
, attrs
, true);
51763 // Return the maximum element or (element-based computation).
51764 // Can't optimize arrays of integers longer than 65,535 elements.
51765 // See: https://bugs.webkit.org/show_bug.cgi?id=80797
51766 _
.max = function(obj
, iterator
, context
) {
51767 if (!iterator
&& _
.isArray(obj
) && obj
[0] === +obj
[0] && obj
.length
< 65535) {
51768 return Math
.max
.apply(Math
, obj
);
51770 if (!iterator
&& _
.isEmpty(obj
)) return -Infinity
;
51771 var result
= {computed
: -Infinity
, value
: -Infinity
};
51772 each(obj
, function(value
, index
, list
) {
51773 var computed
= iterator
? iterator
.call(context
, value
, index
, list
) : value
;
51774 computed
>= result
.computed
&& (result
= {value
: value
, computed
: computed
});
51776 return result
.value
;
51779 // Return the minimum element (or element-based computation).
51780 _
.min = function(obj
, iterator
, context
) {
51781 if (!iterator
&& _
.isArray(obj
) && obj
[0] === +obj
[0] && obj
.length
< 65535) {
51782 return Math
.min
.apply(Math
, obj
);
51784 if (!iterator
&& _
.isEmpty(obj
)) return Infinity
;
51785 var result
= {computed
: Infinity
, value
: Infinity
};
51786 each(obj
, function(value
, index
, list
) {
51787 var computed
= iterator
? iterator
.call(context
, value
, index
, list
) : value
;
51788 computed
< result
.computed
&& (result
= {value
: value
, computed
: computed
});
51790 return result
.value
;
51793 // Shuffle an array.
51794 _
.shuffle = function(obj
) {
51798 each(obj
, function(value
) {
51799 rand
= _
.random(index
++);
51800 shuffled
[index
- 1] = shuffled
[rand
];
51801 shuffled
[rand
] = value
;
51806 // An internal function to generate lookup iterators.
51807 var lookupIterator = function(value
) {
51808 return _
.isFunction(value
) ? value : function(obj
){ return obj
[value
]; };
51811 // Sort the object's values by a criterion produced by an iterator.
51812 _
.sortBy = function(obj
, value
, context
) {
51813 var iterator
= lookupIterator(value
);
51814 return _
.pluck(_
.map(obj
, function(value
, index
, list
) {
51818 criteria
: iterator
.call(context
, value
, index
, list
)
51820 }).sort(function(left
, right
) {
51821 var a
= left
.criteria
;
51822 var b
= right
.criteria
;
51824 if (a
> b
|| a
=== void 0) return 1;
51825 if (a
< b
|| b
=== void 0) return -1;
51827 return left
.index
< right
.index
? -1 : 1;
51831 // An internal function used for aggregate "group by" operations.
51832 var group = function(obj
, value
, context
, behavior
) {
51834 var iterator
= lookupIterator(value
|| _
.identity
);
51835 each(obj
, function(value
, index
) {
51836 var key
= iterator
.call(context
, value
, index
, obj
);
51837 behavior(result
, key
, value
);
51842 // Groups the object's values by a criterion. Pass either a string attribute
51843 // to group by, or a function that returns the criterion.
51844 _
.groupBy = function(obj
, value
, context
) {
51845 return group(obj
, value
, context
, function(result
, key
, value
) {
51846 (_
.has(result
, key
) ? result
[key
] : (result
[key
] = [])).push(value
);
51850 // Counts instances of an object that group by a certain criterion. Pass
51851 // either a string attribute to count by, or a function that returns the
51853 _
.countBy = function(obj
, value
, context
) {
51854 return group(obj
, value
, context
, function(result
, key
) {
51855 if (!_
.has(result
, key
)) result
[key
] = 0;
51860 // Use a comparator function to figure out the smallest index at which
51861 // an object should be inserted so as to maintain order. Uses binary search.
51862 _
.sortedIndex = function(array
, obj
, iterator
, context
) {
51863 iterator
= iterator
== null ? _
.identity
: lookupIterator(iterator
);
51864 var value
= iterator
.call(context
, obj
);
51865 var low
= 0, high
= array
.length
;
51866 while (low
< high
) {
51867 var mid
= (low
+ high
) >>> 1;
51868 iterator
.call(context
, array
[mid
]) < value
? low
= mid
+ 1 : high
= mid
;
51873 // Safely convert anything iterable into a real, live array.
51874 _
.toArray = function(obj
) {
51875 if (!obj
) return [];
51876 if (_
.isArray(obj
)) return slice
.call(obj
);
51877 if (obj
.length
=== +obj
.length
) return _
.map(obj
, _
.identity
);
51878 return _
.values(obj
);
51881 // Return the number of elements in an object.
51882 _
.size = function(obj
) {
51883 if (obj
== null) return 0;
51884 return (obj
.length
=== +obj
.length
) ? obj
.length
: _
.keys(obj
).length
;
51890 // Get the first element of an array. Passing **n** will return the first N
51891 // values in the array. Aliased as `head` and `take`. The **guard** check
51892 // allows it to work with `_.map`.
51893 _
.first
= _
.head
= _
.take = function(array
, n
, guard
) {
51894 if (array
== null) return void 0;
51895 return (n
!= null) && !guard
? slice
.call(array
, 0, n
) : array
[0];
51898 // Returns everything but the last entry of the array. Especially useful on
51899 // the arguments object. Passing **n** will return all the values in
51900 // the array, excluding the last N. The **guard** check allows it to work with
51902 _
.initial = function(array
, n
, guard
) {
51903 return slice
.call(array
, 0, array
.length
- ((n
== null) || guard
? 1 : n
));
51906 // Get the last element of an array. Passing **n** will return the last N
51907 // values in the array. The **guard** check allows it to work with `_.map`.
51908 _
.last = function(array
, n
, guard
) {
51909 if (array
== null) return void 0;
51910 if ((n
!= null) && !guard
) {
51911 return slice
.call(array
, Math
.max(array
.length
- n
, 0));
51913 return array
[array
.length
- 1];
51917 // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
51918 // Especially useful on the arguments object. Passing an **n** will return
51919 // the rest N values in the array. The **guard**
51920 // check allows it to work with `_.map`.
51921 _
.rest
= _
.tail
= _
.drop = function(array
, n
, guard
) {
51922 return slice
.call(array
, (n
== null) || guard
? 1 : n
);
51925 // Trim out all falsy values from an array.
51926 _
.compact = function(array
) {
51927 return _
.filter(array
, _
.identity
);
51930 // Internal implementation of a recursive `flatten` function.
51931 var flatten = function(input
, shallow
, output
) {
51932 each(input
, function(value
) {
51933 if (_
.isArray(value
)) {
51934 shallow
? push
.apply(output
, value
) : flatten(value
, shallow
, output
);
51936 output
.push(value
);
51942 // Return a completely flattened version of an array.
51943 _
.flatten = function(array
, shallow
) {
51944 return flatten(array
, shallow
, []);
51947 // Return a version of the array that does not contain the specified value(s).
51948 _
.without = function(array
) {
51949 return _
.difference(array
, slice
.call(arguments
, 1));
51952 // Produce a duplicate-free version of the array. If the array has already
51953 // been sorted, you have the option of using a faster algorithm.
51954 // Aliased as `unique`.
51955 _
.uniq
= _
.unique = function(array
, isSorted
, iterator
, context
) {
51956 if (_
.isFunction(isSorted
)) {
51957 context
= iterator
;
51958 iterator
= isSorted
;
51961 var initial
= iterator
? _
.map(array
, iterator
, context
) : array
;
51964 each(initial
, function(value
, index
) {
51965 if (isSorted
? (!index
|| seen
[seen
.length
- 1] !== value
) : !_
.contains(seen
, value
)) {
51967 results
.push(array
[index
]);
51973 // Produce an array that contains the union: each distinct element from all of
51974 // the passed-in arrays.
51975 _
.union = function() {
51976 return _
.uniq(concat
.apply(ArrayProto
, arguments
));
51979 // Produce an array that contains every item shared between all the
51980 // passed-in arrays.
51981 _
.intersection = function(array
) {
51982 var rest
= slice
.call(arguments
, 1);
51983 return _
.filter(_
.uniq(array
), function(item
) {
51984 return _
.every(rest
, function(other
) {
51985 return _
.indexOf(other
, item
) >= 0;
51990 // Take the difference between one array and a number of other arrays.
51991 // Only the elements present in just the first array will remain.
51992 _
.difference = function(array
) {
51993 var rest
= concat
.apply(ArrayProto
, slice
.call(arguments
, 1));
51994 return _
.filter(array
, function(value
){ return !_
.contains(rest
, value
); });
51997 // Zip together multiple lists into a single array -- elements that share
51998 // an index go together.
51999 _
.zip = function() {
52000 var args
= slice
.call(arguments
);
52001 var length
= _
.max(_
.pluck(args
, 'length'));
52002 var results
= new Array(length
);
52003 for (var i
= 0; i
< length
; i
++) {
52004 results
[i
] = _
.pluck(args
, "" + i
);
52009 // Converts lists into objects. Pass either a single array of `[key, value]`
52010 // pairs, or two parallel arrays of the same length -- one of keys, and one of
52011 // the corresponding values.
52012 _
.object = function(list
, values
) {
52013 if (list
== null) return {};
52015 for (var i
= 0, l
= list
.length
; i
< l
; i
++) {
52017 result
[list
[i
]] = values
[i
];
52019 result
[list
[i
][0]] = list
[i
][1];
52025 // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
52026 // we need this function. Return the position of the first occurrence of an
52027 // item in an array, or -1 if the item is not included in the array.
52028 // Delegates to **ECMAScript 5**'s native `indexOf` if available.
52029 // If the array is large and already in sort order, pass `true`
52030 // for **isSorted** to use binary search.
52031 _
.indexOf = function(array
, item
, isSorted
) {
52032 if (array
== null) return -1;
52033 var i
= 0, l
= array
.length
;
52035 if (typeof isSorted
== 'number') {
52036 i
= (isSorted
< 0 ? Math
.max(0, l
+ isSorted
) : isSorted
);
52038 i
= _
.sortedIndex(array
, item
);
52039 return array
[i
] === item
? i
: -1;
52042 if (nativeIndexOf
&& array
.indexOf
=== nativeIndexOf
) return array
.indexOf(item
, isSorted
);
52043 for (; i
< l
; i
++) if (array
[i
] === item
) return i
;
52047 // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
52048 _
.lastIndexOf = function(array
, item
, from) {
52049 if (array
== null) return -1;
52050 var hasIndex
= from != null;
52051 if (nativeLastIndexOf
&& array
.lastIndexOf
=== nativeLastIndexOf
) {
52052 return hasIndex
? array
.lastIndexOf(item
, from) : array
.lastIndexOf(item
);
52054 var i
= (hasIndex
? from : array
.length
);
52055 while (i
--) if (array
[i
] === item
) return i
;
52059 // Generate an integer Array containing an arithmetic progression. A port of
52060 // the native Python `range()` function. See
52061 // [the Python documentation](http://docs.python.org/library/functions.html#range).
52062 _
.range = function(start
, stop
, step
) {
52063 if (arguments
.length
<= 1) {
52067 step
= arguments
[2] || 1;
52069 var len
= Math
.max(Math
.ceil((stop
- start
) / step
), 0);
52071 var range
= new Array(len
);
52074 range
[idx
++] = start
;
52081 // Function (ahem) Functions
52082 // ------------------
52084 // Create a function bound to a given object (assigning `this`, and arguments,
52085 // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
52087 _
.bind = function(func
, context
) {
52088 if (func
.bind
=== nativeBind
&& nativeBind
) return nativeBind
.apply(func
, slice
.call(arguments
, 1));
52089 var args
= slice
.call(arguments
, 2);
52090 return function() {
52091 return func
.apply(context
, args
.concat(slice
.call(arguments
)));
52095 // Partially apply a function by creating a version that has had some of its
52096 // arguments pre-filled, without changing its dynamic `this` context.
52097 _
.partial = function(func
) {
52098 var args
= slice
.call(arguments
, 1);
52099 return function() {
52100 return func
.apply(this, args
.concat(slice
.call(arguments
)));
52104 // Bind all of an object's methods to that object. Useful for ensuring that
52105 // all callbacks defined on an object belong to it.
52106 _
.bindAll = function(obj
) {
52107 var funcs
= slice
.call(arguments
, 1);
52108 if (funcs
.length
=== 0) funcs
= _
.functions(obj
);
52109 each(funcs
, function(f
) { obj
[f
] = _
.bind(obj
[f
], obj
); });
52113 // Memoize an expensive function by storing its results.
52114 _
.memoize = function(func
, hasher
) {
52116 hasher
|| (hasher
= _
.identity
);
52117 return function() {
52118 var key
= hasher
.apply(this, arguments
);
52119 return _
.has(memo
, key
) ? memo
[key
] : (memo
[key
] = func
.apply(this, arguments
));
52123 // Delays a function for the given number of milliseconds, and then calls
52124 // it with the arguments supplied.
52125 _
.delay = function(func
, wait
) {
52126 var args
= slice
.call(arguments
, 2);
52127 return setTimeout(function(){ return func
.apply(null, args
); }, wait
);
52130 // Defers a function, scheduling it to run after the current call stack has
52132 _
.defer = function(func
) {
52133 return _
.delay
.apply(_
, [func
, 1].concat(slice
.call(arguments
, 1)));
52136 // Returns a function, that, when invoked, will only be triggered at most once
52137 // during a given window of time.
52138 _
.throttle = function(func
, wait
) {
52139 var context
, args
, timeout
, result
;
52141 var later = function() {
52142 previous
= new Date
;
52144 result
= func
.apply(context
, args
);
52146 return function() {
52147 var now
= new Date
;
52148 var remaining
= wait
- (now
- previous
);
52151 if (remaining
<= 0) {
52152 clearTimeout(timeout
);
52155 result
= func
.apply(context
, args
);
52156 } else if (!timeout
) {
52157 timeout
= setTimeout(later
, remaining
);
52163 // Returns a function, that, as long as it continues to be invoked, will not
52164 // be triggered. The function will be called after it stops being called for
52165 // N milliseconds. If `immediate` is passed, trigger the function on the
52166 // leading edge, instead of the trailing.
52167 _
.debounce = function(func
, wait
, immediate
) {
52168 var timeout
, result
;
52169 return function() {
52170 var context
= this, args
= arguments
;
52171 var later = function() {
52173 if (!immediate
) result
= func
.apply(context
, args
);
52175 var callNow
= immediate
&& !timeout
;
52176 clearTimeout(timeout
);
52177 timeout
= setTimeout(later
, wait
);
52178 if (callNow
) result
= func
.apply(context
, args
);
52183 // Returns a function that will be executed at most one time, no matter how
52184 // often you call it. Useful for lazy initialization.
52185 _
.once = function(func
) {
52186 var ran
= false, memo
;
52187 return function() {
52188 if (ran
) return memo
;
52190 memo
= func
.apply(this, arguments
);
52196 // Returns the first function passed as an argument to the second,
52197 // allowing you to adjust arguments, run code before and after, and
52198 // conditionally execute the original function.
52199 _
.wrap = function(func
, wrapper
) {
52200 return function() {
52202 push
.apply(args
, arguments
);
52203 return wrapper
.apply(this, args
);
52207 // Returns a function that is the composition of a list of functions, each
52208 // consuming the return value of the function that follows.
52209 _
.compose = function() {
52210 var funcs
= arguments
;
52211 return function() {
52212 var args
= arguments
;
52213 for (var i
= funcs
.length
- 1; i
>= 0; i
--) {
52214 args
= [funcs
[i
].apply(this, args
)];
52220 // Returns a function that will only be executed after being called N times.
52221 _
.after = function(times
, func
) {
52222 if (times
<= 0) return func();
52223 return function() {
52225 return func
.apply(this, arguments
);
52230 // Object Functions
52231 // ----------------
52233 // Retrieve the names of an object's properties.
52234 // Delegates to **ECMAScript 5**'s native `Object.keys`
52235 _
.keys
= nativeKeys
|| function(obj
) {
52236 if (obj
!== Object(obj
)) throw new TypeError('Invalid object');
52238 for (var key
in obj
) if (_
.has(obj
, key
)) keys
[keys
.length
] = key
;
52242 // Retrieve the values of an object's properties.
52243 _
.values = function(obj
) {
52245 for (var key
in obj
) if (_
.has(obj
, key
)) values
.push(obj
[key
]);
52249 // Convert an object into a list of `[key, value]` pairs.
52250 _
.pairs = function(obj
) {
52252 for (var key
in obj
) if (_
.has(obj
, key
)) pairs
.push([key
, obj
[key
]]);
52256 // Invert the keys and values of an object. The values must be serializable.
52257 _
.invert = function(obj
) {
52259 for (var key
in obj
) if (_
.has(obj
, key
)) result
[obj
[key
]] = key
;
52263 // Return a sorted list of the function names available on the object.
52264 // Aliased as `methods`
52265 _
.functions
= _
.methods = function(obj
) {
52267 for (var key
in obj
) {
52268 if (_
.isFunction(obj
[key
])) names
.push(key
);
52270 return names
.sort();
52273 // Extend a given object with all the properties in passed-in object(s).
52274 _
.extend = function(obj
) {
52275 each(slice
.call(arguments
, 1), function(source
) {
52277 for (var prop
in source
) {
52278 obj
[prop
] = source
[prop
];
52285 // Return a copy of the object only containing the whitelisted properties.
52286 _
.pick = function(obj
) {
52288 var keys
= concat
.apply(ArrayProto
, slice
.call(arguments
, 1));
52289 each(keys
, function(key
) {
52290 if (key
in obj
) copy
[key
] = obj
[key
];
52295 // Return a copy of the object without the blacklisted properties.
52296 _
.omit = function(obj
) {
52298 var keys
= concat
.apply(ArrayProto
, slice
.call(arguments
, 1));
52299 for (var key
in obj
) {
52300 if (!_
.contains(keys
, key
)) copy
[key
] = obj
[key
];
52305 // Fill in a given object with default properties.
52306 _
.defaults = function(obj
) {
52307 each(slice
.call(arguments
, 1), function(source
) {
52309 for (var prop
in source
) {
52310 if (obj
[prop
] == null) obj
[prop
] = source
[prop
];
52317 // Create a (shallow-cloned) duplicate of an object.
52318 _
.clone = function(obj
) {
52319 if (!_
.isObject(obj
)) return obj
;
52320 return _
.isArray(obj
) ? obj
.slice() : _
.extend({}, obj
);
52323 // Invokes interceptor with the obj, and then returns obj.
52324 // The primary purpose of this method is to "tap into" a method chain, in
52325 // order to perform operations on intermediate results within the chain.
52326 _
.tap = function(obj
, interceptor
) {
52331 // Internal recursive comparison function for `isEqual`.
52332 var eq = function(a
, b
, aStack
, bStack
) {
52333 // Identical objects are equal. `0 === -0`, but they aren't identical.
52334 // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
52335 if (a
=== b
) return a
!== 0 || 1 / a
== 1 / b
;
52336 // A strict comparison is necessary because `null == undefined`.
52337 if (a
== null || b
== null) return a
=== b
;
52338 // Unwrap any wrapped objects.
52339 if (a
instanceof _
) a
= a
._wrapped
;
52340 if (b
instanceof _
) b
= b
._wrapped
;
52341 // Compare `[[Class]]` names.
52342 var className
= toString
.call(a
);
52343 if (className
!= toString
.call(b
)) return false;
52344 switch (className
) {
52345 // Strings, numbers, dates, and booleans are compared by value.
52346 case '[object String]':
52347 // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
52348 // equivalent to `new String("5")`.
52349 return a
== String(b
);
52350 case '[object Number]':
52351 // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
52352 // other numeric values.
52353 return a
!= +a
? b
!= +b
: (a
== 0 ? 1 / a
== 1 / b
: a
== +b
);
52354 case '[object Date]':
52355 case '[object Boolean]':
52356 // Coerce dates and booleans to numeric primitive values. Dates are compared by their
52357 // millisecond representations. Note that invalid dates with millisecond representations
52358 // of `NaN` are not equivalent.
52360 // RegExps are compared by their source patterns and flags.
52361 case '[object RegExp]':
52362 return a
.source
== b
.source
&&
52363 a
.global
== b
.global
&&
52364 a
.multiline
== b
.multiline
&&
52365 a
.ignoreCase
== b
.ignoreCase
;
52367 if (typeof a
!= 'object' || typeof b
!= 'object') return false;
52368 // Assume equality for cyclic structures. The algorithm for detecting cyclic
52369 // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
52370 var length
= aStack
.length
;
52372 // Linear search. Performance is inversely proportional to the number of
52373 // unique nested structures.
52374 if (aStack
[length
] == a
) return bStack
[length
] == b
;
52376 // Add the first object to the stack of traversed objects.
52379 var size
= 0, result
= true;
52380 // Recursively compare objects and arrays.
52381 if (className
== '[object Array]') {
52382 // Compare array lengths to determine if a deep comparison is necessary.
52384 result
= size
== b
.length
;
52386 // Deep compare the contents, ignoring non-numeric properties.
52388 if (!(result
= eq(a
[size
], b
[size
], aStack
, bStack
))) break;
52392 // Objects with different constructors are not equivalent, but `Object`s
52393 // from different frames are.
52394 var aCtor
= a
.constructor, bCtor
= b
.constructor;
52395 if (aCtor
!== bCtor
&& !(_
.isFunction(aCtor
) && (aCtor
instanceof aCtor
) &&
52396 _
.isFunction(bCtor
) && (bCtor
instanceof bCtor
))) {
52399 // Deep compare objects.
52400 for (var key
in a
) {
52401 if (_
.has(a
, key
)) {
52402 // Count the expected number of properties.
52404 // Deep compare each member.
52405 if (!(result
= _
.has(b
, key
) && eq(a
[key
], b
[key
], aStack
, bStack
))) break;
52408 // Ensure that both objects contain the same number of properties.
52411 if (_
.has(b
, key
) && !(size
--)) break;
52416 // Remove the first object from the stack of traversed objects.
52422 // Perform a deep comparison to check if two objects are equal.
52423 _
.isEqual = function(a
, b
) {
52424 return eq(a
, b
, [], []);
52427 // Is a given array, string, or object empty?
52428 // An "empty" object has no enumerable own-properties.
52429 _
.isEmpty = function(obj
) {
52430 if (obj
== null) return true;
52431 if (_
.isArray(obj
) || _
.isString(obj
)) return obj
.length
=== 0;
52432 for (var key
in obj
) if (_
.has(obj
, key
)) return false;
52436 // Is a given value a DOM element?
52437 _
.isElement = function(obj
) {
52438 return !!(obj
&& obj
.nodeType
=== 1);
52441 // Is a given value an array?
52442 // Delegates to ECMA5's native Array.isArray
52443 _
.isArray
= nativeIsArray
|| function(obj
) {
52444 return toString
.call(obj
) == '[object Array]';
52447 // Is a given variable an object?
52448 _
.isObject = function(obj
) {
52449 return obj
=== Object(obj
);
52452 // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
52453 each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name
) {
52454 _
['is' + name
] = function(obj
) {
52455 return toString
.call(obj
) == '[object ' + name
+ ']';
52459 // Define a fallback version of the method in browsers (ahem, IE), where
52460 // there isn't any inspectable "Arguments" type.
52461 if (!_
.isArguments(arguments
)) {
52462 _
.isArguments = function(obj
) {
52463 return !!(obj
&& _
.has(obj
, 'callee'));
52467 // Optimize `isFunction` if appropriate.
52468 if (typeof (/./) !== 'function') {
52469 _
.isFunction = function(obj
) {
52470 return typeof obj
=== 'function';
52474 // Is a given object a finite number?
52475 _
.isFinite = function(obj
) {
52476 return isFinite(obj
) && !isNaN(parseFloat(obj
));
52479 // Is the given value `NaN`? (NaN is the only number which does not equal itself).
52480 _
.isNaN = function(obj
) {
52481 return _
.isNumber(obj
) && obj
!= +obj
;
52484 // Is a given value a boolean?
52485 _
.isBoolean = function(obj
) {
52486 return obj
=== true || obj
=== false || toString
.call(obj
) == '[object Boolean]';
52489 // Is a given value equal to null?
52490 _
.isNull = function(obj
) {
52491 return obj
=== null;
52494 // Is a given variable undefined?
52495 _
.isUndefined = function(obj
) {
52496 return obj
=== void 0;
52499 // Shortcut function for checking if an object has a given property directly
52500 // on itself (in other words, not on a prototype).
52501 _
.has = function(obj
, key
) {
52502 return hasOwnProperty
.call(obj
, key
);
52505 // Utility Functions
52506 // -----------------
52508 // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
52509 // previous owner. Returns a reference to the Underscore object.
52510 _
.noConflict = function() {
52511 root
._
= previousUnderscore
;
52515 // Keep the identity function around for default iterators.
52516 _
.identity = function(value
) {
52520 // Run a function **n** times.
52521 _
.times = function(n
, iterator
, context
) {
52522 var accum
= Array(n
);
52523 for (var i
= 0; i
< n
; i
++) accum
[i
] = iterator
.call(context
, i
);
52527 // Return a random integer between min and max (inclusive).
52528 _
.random = function(min
, max
) {
52533 return min
+ Math
.floor(Math
.random() * (max
- min
+ 1));
52536 // List of HTML entities for escaping.
52547 entityMap
.unescape
= _
.invert(entityMap
.escape
);
52549 // Regexes containing the keys and values listed immediately above.
52550 var entityRegexes
= {
52551 escape
: new RegExp('[' + _
.keys(entityMap
.escape
).join('') + ']', 'g'),
52552 unescape
: new RegExp('(' + _
.keys(entityMap
.unescape
).join('|') + ')', 'g')
52555 // Functions for escaping and unescaping strings to/from HTML interpolation.
52556 _
.each(['escape', 'unescape'], function(method
) {
52557 _
[method
] = function(string
) {
52558 if (string
== null) return '';
52559 return ('' + string
).replace(entityRegexes
[method
], function(match
) {
52560 return entityMap
[method
][match
];
52565 // If the value of the named property is a function then invoke it;
52566 // otherwise, return it.
52567 _
.result = function(object
, property
) {
52568 if (object
== null) return null;
52569 var value
= object
[property
];
52570 return _
.isFunction(value
) ? value
.call(object
) : value
;
52573 // Add your own custom functions to the Underscore object.
52574 _
.mixin = function(obj
) {
52575 each(_
.functions(obj
), function(name
){
52576 var func
= _
[name
] = obj
[name
];
52577 _
.prototype[name
] = function() {
52578 var args
= [this._wrapped
];
52579 push
.apply(args
, arguments
);
52580 return result
.call(this, func
.apply(_
, args
));
52585 // Generate a unique integer id (unique within the entire client session).
52586 // Useful for temporary DOM ids.
52588 _
.uniqueId = function(prefix
) {
52589 var id
= ++idCounter
+ '';
52590 return prefix
? prefix
+ id
: id
;
52593 // By default, Underscore uses ERB-style template delimiters, change the
52594 // following template settings to use alternative delimiters.
52595 _
.templateSettings
= {
52596 evaluate
: /<%([\s\S]+?)%>/g,
52597 interpolate
: /<%=([\s\S]+?)%>/g,
52598 escape
: /<%-([\s\S]+?)%>/g
52601 // When customizing `templateSettings`, if you don't want to define an
52602 // interpolation, evaluation or escaping regex, we need one that is
52603 // guaranteed not to match.
52604 var noMatch
= /(.)^/;
52606 // Certain characters need to be escaped so that they can be put into a
52618 var escaper
= /\\|'|\r|\n|\t|\u2028|\u2029/g;
52620 // JavaScript micro-templating, similar to John Resig's implementation.
52621 // Underscore templating handles arbitrary delimiters, preserves whitespace,
52622 // and correctly escapes quotes within interpolated code.
52623 _
.template = function(text
, data
, settings
) {
52625 settings
= _
.defaults({}, settings
, _
.templateSettings
);
52627 // Combine delimiters into one regular expression via alternation.
52628 var matcher
= new RegExp([
52629 (settings
.escape
|| noMatch
).source
,
52630 (settings
.interpolate
|| noMatch
).source
,
52631 (settings
.evaluate
|| noMatch
).source
52632 ].join('|') + '|$', 'g');
52634 // Compile the template source, escaping string literals appropriately.
52636 var source
= "__p+='";
52637 text
.replace(matcher
, function(match
, escape
, interpolate
, evaluate
, offset
) {
52638 source
+= text
.slice(index
, offset
)
52639 .replace(escaper
, function(match
) { return '\\' + escapes
[match
]; });
52642 source
+= "'+\n((__t=(" + escape
+ "))==null?'':_.escape(__t))+\n'";
52645 source
+= "'+\n((__t=(" + interpolate
+ "))==null?'':__t)+\n'";
52648 source
+= "';\n" + evaluate
+ "\n__p+='";
52650 index
= offset
+ match
.length
;
52655 // If a variable is not specified, place data values in local scope.
52656 if (!settings
.variable
) source
= 'with(obj||{}){\n' + source
+ '}\n';
52658 source
= "var __t,__p='',__j=Array.prototype.join," +
52659 "print=function(){__p+=__j.call(arguments,'');};\n" +
52660 source
+ "return __p;\n";
52663 render
= new Function(settings
.variable
|| 'obj', '_', source
);
52669 if (data
) return render(data
, _
);
52670 var template = function(data
) {
52671 return render
.call(this, data
, _
);
52674 // Provide the compiled function source as a convenience for precompilation.
52675 template
.source
= 'function(' + (settings
.variable
|| 'obj') + '){\n' + source
+ '}';
52680 // Add a "chain" function, which will delegate to the wrapper.
52681 _
.chain = function(obj
) {
52682 return _(obj
).chain();
52687 // If Underscore is called as a function, it returns a wrapped object that
52688 // can be used OO-style. This wrapper holds altered versions of all the
52689 // underscore functions. Wrapped objects may be chained.
52691 // Helper function to continue chaining intermediate results.
52692 var result = function(obj
) {
52693 return this._chain
? _(obj
).chain() : obj
;
52696 // Add all of the Underscore functions to the wrapper object.
52699 // Add all mutator Array functions to the wrapper.
52700 each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name
) {
52701 var method
= ArrayProto
[name
];
52702 _
.prototype[name
] = function() {
52703 var obj
= this._wrapped
;
52704 method
.apply(obj
, arguments
);
52705 if ((name
== 'shift' || name
== 'splice') && obj
.length
=== 0) delete obj
[0];
52706 return result
.call(this, obj
);
52710 // Add all accessor Array functions to the wrapper.
52711 each(['concat', 'join', 'slice'], function(name
) {
52712 var method
= ArrayProto
[name
];
52713 _
.prototype[name
] = function() {
52714 return result
.call(this, method
.apply(this._wrapped
, arguments
));
52718 _
.extend(_
.prototype, {
52720 // Start chaining a wrapped Underscore object.
52721 chain: function() {
52722 this._chain
= true;
52726 // Extracts the result from a wrapped and chained object.
52727 value: function() {
52728 return this._wrapped
;
52735 },{}],"jshint":[function(require
,module
,exports
){
52736 module
.exports
=require('nr+AlQ');
52737 },{}],"nr+AlQ":[function(require
,module
,exports
){
52739 * JSHint, by JSHint Community.
52741 * This file (and this file only) is licensed under the same slightly modified
52742 * MIT license that JSLint is. It stops evil-doers everywhere:
52744 * Copyright (c) 2002 Douglas Crockford (www.JSLint.com)
52746 * Permission is hereby granted, free of charge, to any person obtaining
52747 * a copy of this software and associated documentation files (the "Software"),
52748 * to deal in the Software without restriction, including without limitation
52749 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
52750 * and/or sell copies of the Software, and to permit persons to whom
52751 * the Software is furnished to do so, subject to the following conditions:
52753 * The above copyright notice and this permission notice shall be included
52754 * in all copies or substantial portions of the Software.
52756 * The Software shall be used for Good, not Evil.
52758 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
52759 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
52760 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
52761 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
52762 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
52763 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
52764 * DEALINGS IN THE SOFTWARE.
52768 /*jshint quotmark:double */
52769 /*global console:true */
52770 /*exported console */
52772 var _
= require("underscore");
52773 var events
= require("events");
52774 var vars
= require("./vars.js");
52775 var messages
= require("./messages.js");
52776 var Lexer
= require("./lex.js").Lexer
;
52777 var reg
= require("./reg.js");
52778 var state
= require("./state.js").state
;
52779 var style
= require("./style.js");
52781 // We need this module here because environments such as IE and Rhino
52782 // don't necessarily expose the 'console' API and browserify uses
52783 // it to log things. It's a sad state of affair, really.
52784 var console
= require("console-browserify");
52786 // We build the application inside a function so that we produce only a singleton
52787 // variable. That function will be invoked immediately, and its return value is
52788 // the JSHINT function itself.
52790 var JSHINT
= (function () {
52793 var anonname
, // The guessed name for anonymous functions.
52794 api
, // Extension API
52796 // These are operators that should not be used with the ! operator.
52813 // These are the JSHint boolean options.
52815 asi
: true, // if automatic semicolon insertion should be tolerated
52816 bitwise
: true, // if bitwise operators should not be allowed
52817 boss
: true, // if advanced usage of assignments should be allowed
52818 browser
: true, // if the standard browser globals should be predefined
52819 camelcase
: true, // if identifiers should be required in camel case
52820 couch
: true, // if CouchDB globals should be predefined
52821 curly
: true, // if curly braces around all blocks should be required
52822 debug
: true, // if debugger statements should be allowed
52823 devel
: true, // if logging globals should be predefined (console, alert, etc.)
52824 dojo
: true, // if Dojo Toolkit globals should be predefined
52825 eqeqeq
: true, // if === should be required
52826 eqnull
: true, // if == null comparisons should be tolerated
52827 notypeof
: true, // if should report typos in typeof comparisons
52828 es3
: true, // if ES3 syntax should be allowed
52829 es5
: true, // if ES5 syntax should be allowed (is now set per default)
52830 esnext
: true, // if es.next specific syntax should be allowed
52831 moz
: true, // if mozilla specific syntax should be allowed
52832 evil
: true, // if eval should be allowed
52833 expr
: true, // if ExpressionStatement should be allowed as Programs
52834 forin
: true, // if for in statements must filter
52835 funcscope
: true, // if only function scope should be used for scope tests
52836 gcl
: true, // if JSHint should be compatible with Google Closure Linter
52837 globalstrict
: true, // if global "use strict"; should be allowed (also enables 'strict')
52838 immed
: true, // if immediate invocations must be wrapped in parens
52839 iterator
: true, // if the `__iterator__` property should be allowed
52840 jquery
: true, // if jQuery globals should be predefined
52841 lastsemic
: true, // if semicolons may be omitted for the trailing
52842 // statements inside of a one-line blocks.
52843 laxbreak
: true, // if line breaks should not be checked
52844 laxcomma
: true, // if line breaks should not be checked around commas
52845 loopfunc
: true, // if functions should be allowed to be defined within
52847 mootools
: true, // if MooTools globals should be predefined
52848 multistr
: true, // allow multiline strings
52849 freeze
: true, // if modifying native object prototypes should be disallowed
52850 newcap
: true, // if constructor names must be capitalized
52851 noarg
: true, // if arguments.caller and arguments.callee should be
52853 node
: true, // if the Node.js environment globals should be
52855 noempty
: true, // if empty blocks should be disallowed
52856 nonbsp
: true, // if non-breaking spaces should be disallowed
52857 nonew
: true, // if using `new` for side-effects should be disallowed
52858 nonstandard
: true, // if non-standard (but widely adopted) globals should
52860 nomen
: true, // if names should be checked
52861 onevar
: true, // if only one var statement per function should be
52863 passfail
: true, // if the scan should stop on first error
52864 phantom
: true, // if PhantomJS symbols should be allowed
52865 plusplus
: true, // if increment/decrement should not be allowed
52866 proto
: true, // if the `__proto__` property should be allowed
52867 prototypejs
: true, // if Prototype and Scriptaculous globals should be
52869 rhino
: true, // if the Rhino environment globals should be predefined
52870 shelljs
: true, // if ShellJS globals should be predefined
52871 typed
: true, // if typed array globals should be predefined
52872 undef
: true, // if variables should be declared before used
52873 scripturl
: true, // if script-targeted URLs should be tolerated
52874 smarttabs
: true, // if smarttabs should be tolerated
52875 // (http://www.emacswiki.org/emacs/SmartTabs)
52876 strict
: true, // require the "use strict"; pragma
52877 sub
: true, // if all forms of subscript notation are tolerated
52878 supernew
: true, // if `new function () { ... };` and `new Object;`
52879 // should be tolerated
52880 trailing
: true, // if trailing whitespace rules apply
52881 validthis
: true, // if 'this' inside a non-constructor function is valid.
52882 // This is a function scoped option only.
52883 withstmt
: true, // if with statements should be allowed
52884 white
: true, // if strict whitespace rules apply
52885 worker
: true, // if Web Worker script symbols should be allowed
52886 wsh
: true, // if the Windows Scripting Host environment globals
52887 // should be predefined
52888 yui
: true, // YUI variables should be predefined
52889 noyield
: true, // allow generators without a yield
52891 // Obsolete options
52892 onecase
: true, // if one case switch statements should be allowed
52893 regexp
: true, // if the . should not be allowed in regexp literals
52894 regexdash
: true // if unescaped first/last dash (-) inside brackets
52895 // should be tolerated
52898 // These are the JSHint options that can take any value
52899 // (we use this object to detect invalid options)
52904 predef
: false, //predef is deprecated and being replaced by globals
52906 quotmark
: false, //'single'|'double'|true
52908 maxstatements
: false, // {int} max statements per function
52909 maxdepth
: false, // {int} max nested block depth per function
52910 maxparams
: false, // {int} max params per function
52911 maxcomplexity
: false, // {int} max cyclomatic complexity per function
52912 shadow
: false, // if variable shadowing should be tolerated
52913 // "inner" - check for variables defined in the same scope only
52914 // "outer" - check for variables defined in outer scopes as well
52915 // false - same as inner
52916 // true - allow variable shadowing
52917 unused
: true, // warn if variables are unused. Available options:
52918 // false - don't check for unused variables
52919 // true - "vars" + check last function param
52920 // "vars" - skip checking unused function params
52921 // "strict" - "vars" + check all function params
52922 latedef
: false, // warn if the variable is used before its definition
52923 // false - don't emit any warnings
52924 // true - warn if any variable is used before its definition
52925 // "nofunc" - warn for any variable but function declarations
52926 ignore
: false // start/end ignoring lines of code, bypassing the lexer
52927 // start - start ignoring lines, including the current line
52928 // end - stop ignoring lines, starting on the next line
52929 // line - ignore warnings / errors for just a single line
52930 // (this option does not bypass the lexer)
52933 // These are JSHint boolean options which are shared with JSLint
52934 // where the definition in JSHint is opposite JSLint
52935 invertedOptions
= {
52945 // Inverted and renamed, use JSHint name here
52951 // These are JSHint boolean options which are shared with JSLint
52952 // where the name has been changed but the effect is unchanged
52960 declared
, // Globals that were declared using /*global ... */ syntax.
52961 exported
, // Variables that are used outside of the current file.
52964 "closure", "exception", "global", "label",
52965 "outer", "unused", "var"
52968 funct
, // The current function
52969 functions
, // All of the functions
52971 global
, // The global scope
52972 implied
, // Implied globals
52980 predefined
, // Global variables defined by option
52982 scope
, // The current scope
52989 emitter
= new events
.EventEmitter();
52991 function checkOption(name
, t
) {
52992 name
= name
.trim();
52994 if (/^[+-]W\d{3}$/g.test(name
)) {
52998 if (valOptions
[name
] === undefined && boolOptions
[name
] === undefined) {
52999 if (t
.type
!== "jslint") {
53000 error("E001", t
, name
);
53008 function isString(obj
) {
53009 return Object
.prototype.toString
.call(obj
) === "[object String]";
53012 function isIdentifier(tkn
, value
) {
53016 if (!tkn
.identifier
|| tkn
.value
!== value
)
53022 function isReserved(token
) {
53023 if (!token
.reserved
) {
53026 var meta
= token
.meta
;
53028 if (meta
&& meta
.isFutureReservedWord
&& state
.option
.inES5()) {
53029 // ES3 FutureReservedWord in an ES5 environment.
53034 // Some ES5 FutureReservedWord identifiers are active only
53035 // within a strict mode environment.
53036 if (meta
.strictOnly
) {
53037 if (!state
.option
.strict
&& !state
.directive
["use strict"]) {
53042 if (token
.isProperty
) {
53050 function supplant(str
, data
) {
53051 return str
.replace(/\{([^{}]*)\}/g, function (a
, b
) {
53053 return typeof r
=== "string" || typeof r
=== "number" ? r
: a
;
53057 function combine(dest
, src
) {
53058 Object
.keys(src
).forEach(function (name
) {
53059 if (JSHINT
.blacklist
.hasOwnProperty(name
)) return;
53060 dest
[name
] = src
[name
];
53064 function assume() {
53065 if (state
.option
.es5
) {
53068 if (state
.option
.couch
) {
53069 combine(predefined
, vars
.couch
);
53072 if (state
.option
.rhino
) {
53073 combine(predefined
, vars
.rhino
);
53076 if (state
.option
.shelljs
) {
53077 combine(predefined
, vars
.shelljs
);
53078 combine(predefined
, vars
.node
);
53080 if (state
.option
.typed
) {
53081 combine(predefined
, vars
.typed
);
53084 if (state
.option
.phantom
) {
53085 combine(predefined
, vars
.phantom
);
53088 if (state
.option
.prototypejs
) {
53089 combine(predefined
, vars
.prototypejs
);
53092 if (state
.option
.node
) {
53093 combine(predefined
, vars
.node
);
53094 combine(predefined
, vars
.typed
);
53097 if (state
.option
.devel
) {
53098 combine(predefined
, vars
.devel
);
53101 if (state
.option
.dojo
) {
53102 combine(predefined
, vars
.dojo
);
53105 if (state
.option
.browser
) {
53106 combine(predefined
, vars
.browser
);
53107 combine(predefined
, vars
.typed
);
53110 if (state
.option
.nonstandard
) {
53111 combine(predefined
, vars
.nonstandard
);
53114 if (state
.option
.jquery
) {
53115 combine(predefined
, vars
.jquery
);
53118 if (state
.option
.mootools
) {
53119 combine(predefined
, vars
.mootools
);
53122 if (state
.option
.worker
) {
53123 combine(predefined
, vars
.worker
);
53126 if (state
.option
.wsh
) {
53127 combine(predefined
, vars
.wsh
);
53130 if (state
.option
.globalstrict
&& state
.option
.strict
!== false) {
53131 state
.option
.strict
= true;
53134 if (state
.option
.yui
) {
53135 combine(predefined
, vars
.yui
);
53138 // Let's assume that chronologically ES3 < ES5 < ES6/ESNext < Moz
53140 state
.option
.inMoz = function (strict
) {
53142 return state
.option
.moz
&& !state
.option
.esnext
;
53144 return state
.option
.moz
;
53147 state
.option
.inESNext = function (strict
) {
53149 return !state
.option
.moz
&& state
.option
.esnext
;
53151 return state
.option
.moz
|| state
.option
.esnext
;
53154 state
.option
.inES5 = function (/* strict */) {
53155 return !state
.option
.es3
;
53158 state
.option
.inES3 = function (strict
) {
53160 return !state
.option
.moz
&& !state
.option
.esnext
&& state
.option
.es3
;
53162 return state
.option
.es3
;
53166 // Produce an error warning.
53167 function quit(code
, line
, chr
) {
53168 var percentage
= Math
.floor((line
/ state
.lines
.length
) * 100);
53169 var message
= messages
.errors
[code
].desc
;
53172 name
: "JSHintError",
53175 message
: message
+ " (" + percentage
+ "% scanned).",
53181 function isundef(scope
, code
, token
, a
) {
53182 return JSHINT
.undefs
.push([scope
, code
, token
, a
]);
53185 function warning(code
, t
, a
, b
, c
, d
) {
53188 if (/^W\d{3}$/.test(code
)) {
53189 if (state
.ignored
[code
])
53192 msg
= messages
.warnings
[code
];
53193 } else if (/E\d{3}/.test(code
)) {
53194 msg
= messages
.errors
[code
];
53195 } else if (/I\d{3}/.test(code
)) {
53196 msg
= messages
.info
[code
];
53199 t
= t
|| state
.tokens
.next
;
53200 if (t
.id
=== "(end)") { // `~
53201 t
= state
.tokens
.curr
;
53211 evidence
: state
.lines
[l
- 1] || "",
53214 scope
: JSHINT
.scope
,
53221 w
.reason
= supplant(msg
.desc
, w
);
53222 JSHINT
.errors
.push(w
);
53224 if (state
.option
.passfail
) {
53225 quit("E042", l
, ch
);
53229 if (warnings
>= state
.option
.maxerr
) {
53230 quit("E043", l
, ch
);
53236 function warningAt(m
, l
, ch
, a
, b
, c
, d
) {
53237 return warning(m
, {
53243 function error(m
, t
, a
, b
, c
, d
) {
53244 warning(m
, t
, a
, b
, c
, d
);
53247 function errorAt(m
, l
, ch
, a
, b
, c
, d
) {
53254 // Tracking of "internal" scripts, like eval containing a static string
53255 function addInternalSrc(elem
, src
) {
53262 JSHINT
.internals
.push(i
);
53267 // opts: { type: string, token: token, islet: bool }
53268 function addlabel(name
, opts
) {
53271 var type
= opts
.type
;
53272 var token
= opts
.token
;
53273 var islet
= opts
.islet
;
53275 // Define label in the current function in the current scope.
53276 if (type
=== "exception") {
53277 if (_
.has(funct
["(context)"], name
)) {
53278 if (funct
[name
] !== true && !state
.option
.node
) {
53279 warning("W002", state
.tokens
.next
, name
);
53284 if (_
.has(funct
, name
) && !funct
["(global)"]) {
53285 if (funct
[name
] === true) {
53286 if (state
.option
.latedef
) {
53287 if ((state
.option
.latedef
=== true && _
.contains([funct
[name
], type
], "unction")) ||
53288 !_
.contains([funct
[name
], type
], "unction")) {
53289 warning("W003", state
.tokens
.next
, name
);
53293 if ((!state
.option
.shadow
|| _
.contains([ "inner", "outer" ], state
.option
.shadow
)) &&
53294 type
!== "exception" || funct
["(blockscope)"].getlabel(name
)) {
53295 warning("W004", state
.tokens
.next
, name
);
53300 if (funct
["(context)"] && _
.has(funct
["(context)"], name
) && type
!== "function") {
53301 if (state
.option
.shadow
=== "outer") {
53302 warning("W123", state
.tokens
.next
, name
);
53306 // if the identifier is from a let, adds it only to the current blockscope
53308 funct
["(blockscope)"].current
.add(name
, type
, state
.tokens
.curr
);
53310 funct
["(blockscope)"].shadow(name
);
53311 funct
[name
] = type
;
53314 funct
["(tokens)"][name
] = token
;
53317 setprop(funct
, name
, { unused
: opts
.unused
|| false });
53319 if (funct
["(global)"]) {
53320 global
[name
] = funct
;
53321 if (_
.has(implied
, name
)) {
53322 if (state
.option
.latedef
) {
53323 if ((state
.option
.latedef
=== true && _
.contains([funct
[name
], type
], "unction")) ||
53324 !_
.contains([funct
[name
], type
], "unction")) {
53325 warning("W003", state
.tokens
.next
, name
);
53329 delete implied
[name
];
53332 scope
[name
] = funct
;
53337 function doOption() {
53338 var nt
= state
.tokens
.next
;
53339 var body
= nt
.body
.split(",").map(function (s
) { return s
.trim(); });
53342 if (nt
.type
=== "globals") {
53343 body
.forEach(function (g
) {
53345 var key
= (g
[0] || "").trim();
53346 var val
= (g
[1] || "").trim();
53348 if (key
.charAt(0) === "-") {
53349 key
= key
.slice(1);
53352 JSHINT
.blacklist
[key
] = key
;
53353 delete predefined
[key
];
53355 predef
[key
] = (val
=== "true");
53359 combine(predefined
, predef
);
53361 for (var key
in predef
) {
53362 if (_
.has(predef
, key
)) {
53363 declared
[key
] = nt
;
53368 if (nt
.type
=== "exported") {
53369 body
.forEach(function (e
) {
53370 exported
[e
] = true;
53374 if (nt
.type
=== "members") {
53375 membersOnly
= membersOnly
|| {};
53377 body
.forEach(function (m
) {
53378 var ch1
= m
.charAt(0);
53379 var ch2
= m
.charAt(m
.length
- 1);
53381 if (ch1
=== ch2
&& (ch1
=== "\"" || ch1
=== "'")) {
53383 .substr(1, m
.length
- 2)
53384 .replace("\\\"", "\"");
53387 membersOnly
[m
] = false;
53401 if (nt
.type
=== "jshint" || nt
.type
=== "jslint") {
53402 body
.forEach(function (g
) {
53404 var key
= (g
[0] || "").trim();
53405 var val
= (g
[1] || "").trim();
53407 if (!checkOption(key
, nt
)) {
53411 if (numvals
.indexOf(key
) >= 0) {
53413 // GH988 - numeric options can be disabled by setting them to `false`
53414 if (val
!== "false") {
53417 if (typeof val
!== "number" || !isFinite(val
) || val
<= 0 || Math
.floor(val
) !== val
) {
53418 error("E032", nt
, g
[1].trim());
53422 if (key
=== "indent") {
53423 state
.option
["(explicitIndent)"] = true;
53425 state
.option
[key
] = val
;
53427 if (key
=== "indent") {
53428 state
.option
["(explicitIndent)"] = false;
53430 state
.option
[key
] = false;
53437 if (key
=== "validthis") {
53438 // `validthis` is valid only within a function scope.
53440 if (funct
["(global)"])
53441 return void error("E009");
53443 if (val
!== "true" && val
!== "false")
53444 return void error("E002", nt
);
53446 state
.option
.validthis
= (val
=== "true");
53450 if (key
=== "quotmark") {
53454 state
.option
.quotmark
= (val
=== "true");
53458 state
.option
.quotmark
= val
;
53466 if (key
=== "shadow") {
53469 state
.option
.shadow
= true;
53472 state
.option
.shadow
= "outer";
53476 state
.option
.shadow
= "inner";
53484 if (key
=== "unused") {
53487 state
.option
.unused
= true;
53490 state
.option
.unused
= false;
53494 state
.option
.unused
= val
;
53502 if (key
=== "latedef") {
53505 state
.option
.latedef
= true;
53508 state
.option
.latedef
= false;
53511 state
.option
.latedef
= "nofunc";
53519 if (key
=== "ignore") {
53522 state
.ignoreLinterErrors
= true;
53525 state
.ignoreLinterErrors
= false;
53528 // Any errors or warnings that happened on the current line, make them go away.
53529 JSHINT
.errors
= _
.reject(JSHINT
.errors
, function (error
) {
53530 // nt.line returns to the current line
53531 return error
.line
=== nt
.line
;
53540 var match
= /^([+-])(W\d{3})$/g.exec(key
);
53542 // ignore for -W..., unignore for +W...
53543 state
.ignored
[match
[2]] = (match
[1] === "-");
53548 if (val
=== "true" || val
=== "false") {
53549 if (nt
.type
=== "jslint") {
53550 tn
= renamedOptions
[key
] || key
;
53551 state
.option
[tn
] = (val
=== "true");
53553 if (invertedOptions
[tn
] !== undefined) {
53554 state
.option
[tn
] = !state
.option
[tn
];
53557 state
.option
[key
] = (val
=== "true");
53560 if (key
=== "newcap") {
53561 state
.option
["(explicitNewcap)"] = true;
53573 // We need a peek function. If it has an argument, it peeks that much farther
53574 // ahead. It is used to distinguish
53575 // for ( var i in ...
53577 // for ( var i = ...
53580 var i
= p
|| 0, j
= 0, t
;
53585 t
= lookahead
[j
] = lex
.token();
53592 // Produce the next token. It looks for programming errors.
53594 function advance(id
, t
) {
53595 switch (state
.tokens
.curr
.id
) {
53597 if (state
.tokens
.next
.id
=== ".") {
53598 warning("W005", state
.tokens
.curr
);
53602 if (state
.tokens
.next
.id
=== "-" || state
.tokens
.next
.id
=== "--") {
53607 if (state
.tokens
.next
.id
=== "+" || state
.tokens
.next
.id
=== "++") {
53613 if (state
.tokens
.curr
.type
=== "(string)" || state
.tokens
.curr
.identifier
) {
53614 anonname
= state
.tokens
.curr
.value
;
53617 if (id
&& state
.tokens
.next
.id
!== id
) {
53619 if (state
.tokens
.next
.id
=== "(end)") {
53620 error("E019", t
, t
.id
);
53622 error("E020", state
.tokens
.next
, id
, t
.id
, t
.line
, state
.tokens
.next
.value
);
53624 } else if (state
.tokens
.next
.type
!== "(identifier)" || state
.tokens
.next
.value
!== id
) {
53625 warning("W116", state
.tokens
.next
, id
, state
.tokens
.next
.value
);
53629 state
.tokens
.prev
= state
.tokens
.curr
;
53630 state
.tokens
.curr
= state
.tokens
.next
;
53632 state
.tokens
.next
= lookahead
.shift() || lex
.token();
53634 if (!state
.tokens
.next
) { // No more tokens left, give up
53635 quit("E041", state
.tokens
.curr
.line
);
53638 if (state
.tokens
.next
.id
=== "(end)" || state
.tokens
.next
.id
=== "(error)") {
53642 if (state
.tokens
.next
.check
) {
53643 state
.tokens
.next
.check();
53646 if (state
.tokens
.next
.isSpecial
) {
53649 if (state
.tokens
.next
.id
!== "(endline)") {
53656 function isInfix(token
) {
53657 return token
.infix
|| (!token
.identifier
&& !!token
.led
);
53660 function isEndOfExpr() {
53661 var curr
= state
.tokens
.curr
;
53662 var next
= state
.tokens
.next
;
53663 if (next
.id
=== ";" || next
.id
=== "}" || next
.id
=== ":") {
53666 if (isInfix(next
) === isInfix(curr
) || (curr
.id
=== "yield" && state
.option
.inMoz(true))) {
53667 return curr
.line
!== next
.line
;
53672 // This is the heart of JSHINT, the Pratt parser. In addition to parsing, it
53673 // is looking for ad hoc lint patterns. We add .fud to Pratt's model, which is
53674 // like .nud except that it is only used on the first token of a statement.
53675 // Having .fud makes it much easier to define statement-oriented languages like
53676 // JavaScript. I retained Pratt's nomenclature.
53678 // .nud Null denotation
53679 // .fud First null denotation
53680 // .led Left denotation
53681 // lbp Left binding power
53682 // rbp Right binding power
53684 // They are elements of the parsing method called Top Down Operator Precedence.
53686 function expression(rbp
, initial
) {
53687 var left
, isArray
= false, isObject
= false, isLetExpr
= false;
53689 // if current expression is a let expression
53690 if (!initial
&& state
.tokens
.next
.value
=== "let" && peek(0).value
=== "(") {
53691 if (!state
.option
.inMoz(true)) {
53692 warning("W118", state
.tokens
.next
, "let expressions");
53695 // create a new block scope we use only for the current expression
53696 funct
["(blockscope)"].stack();
53699 state
.syntax
["let"].fud
.call(state
.syntax
["let"].fud
, false);
53703 if (state
.tokens
.next
.id
=== "(end)")
53704 error("E006", state
.tokens
.curr
);
53709 anonname
= "anonymous";
53710 funct
["(verb)"] = state
.tokens
.curr
.value
;
53713 if (initial
=== true && state
.tokens
.curr
.fud
) {
53714 left
= state
.tokens
.curr
.fud();
53716 if (state
.tokens
.curr
.nud
) {
53717 left
= state
.tokens
.curr
.nud();
53719 error("E030", state
.tokens
.curr
, state
.tokens
.curr
.id
);
53722 while (rbp
< state
.tokens
.next
.lbp
&& !isEndOfExpr()) {
53723 isArray
= state
.tokens
.curr
.value
=== "Array";
53724 isObject
= state
.tokens
.curr
.value
=== "Object";
53726 // #527, new Foo.Array(), Foo.Array(), new Foo.Object(), Foo.Object()
53727 // Line breaks in IfStatement heads exist to satisfy the checkJSHint
53728 // "Line too long." error.
53729 if (left
&& (left
.value
|| (left
.first
&& left
.first
.value
))) {
53730 // If the left.value is not "new", or the left.first.value is a "."
53731 // then safely assume that this is not "new Array()" and possibly
53732 // not "new Object()"...
53733 if (left
.value
!== "new" ||
53734 (left
.first
&& left
.first
.value
&& left
.first
.value
=== ".")) {
53736 // ...In the case of Object, if the left.value and state.tokens.curr.value
53737 // are not equal, then safely assume that this not "new Object()"
53738 if (left
.value
!== state
.tokens
.curr
.value
) {
53746 if (isArray
&& state
.tokens
.curr
.id
=== "(" && state
.tokens
.next
.id
=== ")") {
53747 warning("W009", state
.tokens
.curr
);
53750 if (isObject
&& state
.tokens
.curr
.id
=== "(" && state
.tokens
.next
.id
=== ")") {
53751 warning("W010", state
.tokens
.curr
);
53754 if (left
&& state
.tokens
.curr
.led
) {
53755 left
= state
.tokens
.curr
.led(left
);
53757 error("E033", state
.tokens
.curr
, state
.tokens
.curr
.id
);
53762 funct
["(blockscope)"].unstack();
53768 // Functions for conformance of style.
53770 function adjacent(left
, right
) {
53771 left
= left
|| state
.tokens
.curr
;
53772 right
= right
|| state
.tokens
.next
;
53773 if (state
.option
.white
) {
53774 if (left
.character
!== right
.from && left
.line
=== right
.line
) {
53775 left
.from += (left
.character
- left
.from);
53776 warning("W011", left
, left
.value
);
53781 function nobreak(left
, right
) {
53782 left
= left
|| state
.tokens
.curr
;
53783 right
= right
|| state
.tokens
.next
;
53784 if (state
.option
.white
&& (left
.character
!== right
.from || left
.line
!== right
.line
)) {
53785 warning("W012", right
, right
.value
);
53789 function nospace(left
, right
) {
53790 left
= left
|| state
.tokens
.curr
;
53791 right
= right
|| state
.tokens
.next
;
53792 if (state
.option
.white
&& !left
.comment
) {
53793 if (left
.line
=== right
.line
) {
53794 adjacent(left
, right
);
53799 function nonadjacent(left
, right
) {
53800 if (state
.option
.white
) {
53801 left
= left
|| state
.tokens
.curr
;
53802 right
= right
|| state
.tokens
.next
;
53804 if (left
.value
=== ";" && right
.value
=== ";") {
53808 if (left
.line
=== right
.line
&& left
.character
=== right
.from) {
53809 left
.from += (left
.character
- left
.from);
53810 warning("W013", left
, left
.value
);
53815 function nobreaknonadjacent(left
, right
) {
53816 left
= left
|| state
.tokens
.curr
;
53817 right
= right
|| state
.tokens
.next
;
53818 if (!state
.option
.laxbreak
&& left
.line
!== right
.line
) {
53819 warning("W014", right
, right
.value
);
53820 } else if (state
.option
.white
) {
53821 left
= left
|| state
.tokens
.curr
;
53822 right
= right
|| state
.tokens
.next
;
53823 if (left
.character
=== right
.from) {
53824 left
.from += (left
.character
- left
.from);
53825 warning("W013", left
, left
.value
);
53830 function indentation(bias
) {
53831 if (!state
.option
.white
&& !state
.option
["(explicitIndent)"]) {
53835 if (state
.tokens
.next
.id
=== "(end)") {
53839 var i
= indent
+ (bias
|| 0);
53840 if (state
.tokens
.next
.from !== i
) {
53841 warning("W015", state
.tokens
.next
, state
.tokens
.next
.value
, i
, state
.tokens
.next
.from);
53845 function nolinebreak(t
) {
53846 t
= t
|| state
.tokens
.curr
;
53847 if (t
.line
!== state
.tokens
.next
.line
) {
53848 warning("E022", t
, t
.value
);
53852 function nobreakcomma(left
, right
) {
53853 if (left
.line
!== right
.line
) {
53854 if (!state
.option
.laxcomma
) {
53857 comma
.first
= false;
53859 warning("W014", left
, right
.value
);
53861 } else if (!left
.comment
&& left
.character
!== right
.from && state
.option
.white
) {
53862 left
.from += (left
.character
- left
.from);
53863 warning("W011", left
, left
.value
);
53867 function comma(opts
) {
53871 nobreakcomma(state
.tokens
.curr
, state
.tokens
.next
);
53874 nobreakcomma(state
.tokens
.prev
, state
.tokens
.curr
);
53877 // TODO: This is a temporary solution to fight against false-positives in
53878 // arrays and objects with trailing commas (see GH-363). The best solution
53879 // would be to extract all whitespace rules out of parser.
53881 if (state
.tokens
.next
.value
!== "]" && state
.tokens
.next
.value
!== "}") {
53882 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
53885 if (state
.tokens
.next
.identifier
&& !(opts
.property
&& state
.option
.inES5())) {
53886 // Keywords that cannot follow a comma operator.
53887 switch (state
.tokens
.next
.value
) {
53908 error("E024", state
.tokens
.next
, state
.tokens
.next
.value
);
53913 if (state
.tokens
.next
.type
=== "(punctuator)") {
53914 switch (state
.tokens
.next
.value
) {
53918 if (opts
.allowTrailing
) {
53922 /* falls through */
53924 error("E024", state
.tokens
.next
, state
.tokens
.next
.value
);
53931 // Functional constructors for making the symbols that will be inherited by
53934 function symbol(s
, p
) {
53935 var x
= state
.syntax
[s
];
53936 if (!x
|| typeof x
!== "object") {
53937 state
.syntax
[s
] = x
= {
53946 function delim(s
) {
53947 return symbol(s
, 0);
53950 function stmt(s
, f
) {
53952 x
.identifier
= x
.reserved
= true;
53957 function blockstmt(s
, f
) {
53958 var x
= stmt(s
, f
);
53963 function reserveName(x
) {
53964 var c
= x
.id
.charAt(0);
53965 if ((c
>= "a" && c
<= "z") || (c
>= "A" && c
<= "Z")) {
53966 x
.identifier
= x
.reserved
= true;
53971 function prefix(s
, f
) {
53972 var x
= symbol(s
, 150);
53975 x
.nud
= (typeof f
=== "function") ? f : function () {
53976 this.right
= expression(150);
53977 this.arity
= "unary";
53979 if (this.id
=== "++" || this.id
=== "--") {
53980 if (state
.option
.plusplus
) {
53981 warning("W016", this, this.id
);
53982 } else if (this.right
&& (!this.right
.identifier
|| isReserved(this.right
)) &&
53983 this.right
.id
!== "." && this.right
.id
!== "[") {
53984 warning("W017", this);
53994 function type(s
, f
) {
54001 function reserve(name
, func
) {
54002 var x
= type(name
, func
);
54003 x
.identifier
= true;
54008 function FutureReservedWord(name
, meta
) {
54009 var x
= type(name
, (meta
&& meta
.nud
) || function () {
54014 meta
.isFutureReservedWord
= true;
54017 x
.identifier
= true;
54024 function reservevar(s
, v
) {
54025 return reserve(s
, function () {
54026 if (typeof v
=== "function") {
54033 function infix(s
, f
, p
, w
) {
54034 var x
= symbol(s
, p
);
54037 x
.led = function (left
) {
54039 nobreaknonadjacent(state
.tokens
.prev
, state
.tokens
.curr
);
54040 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
54042 if (s
=== "in" && left
.id
=== "!") {
54043 warning("W018", left
, "!");
54045 if (typeof f
=== "function") {
54046 return f(left
, this);
54049 this.right
= expression(p
);
54057 function application(s
) {
54058 var x
= symbol(s
, 42);
54060 x
.led = function (left
) {
54061 if (!state
.option
.inESNext()) {
54062 warning("W104", state
.tokens
.curr
, "arrow function syntax (=>)");
54065 nobreaknonadjacent(state
.tokens
.prev
, state
.tokens
.curr
);
54066 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
54069 this.right
= doFunction(undefined, undefined, false, left
);
54075 function relation(s
, f
) {
54076 var x
= symbol(s
, 100);
54078 x
.led = function (left
) {
54079 nobreaknonadjacent(state
.tokens
.prev
, state
.tokens
.curr
);
54080 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
54081 var right
= expression(100);
54083 if (isIdentifier(left
, "NaN") || isIdentifier(right
, "NaN")) {
54084 warning("W019", this);
54086 f
.apply(this, [left
, right
]);
54089 if (!left
|| !right
) {
54090 quit("E041", state
.tokens
.curr
.line
);
54093 if (left
.id
=== "!") {
54094 warning("W018", left
, "!");
54097 if (right
.id
=== "!") {
54098 warning("W018", right
, "!");
54102 this.right
= right
;
54108 function isPoorRelation(node
) {
54110 ((node
.type
=== "(number)" && +node
.value
=== 0) ||
54111 (node
.type
=== "(string)" && node
.value
=== "") ||
54112 (node
.type
=== "null" && !state
.option
.eqnull
) ||
54113 node
.type
=== "true" ||
54114 node
.type
=== "false" ||
54115 node
.type
=== "undefined");
54118 // Checks whether the 'typeof' operator is used with the correct
54119 // value. For docs on 'typeof' see:
54120 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof
54122 function isTypoTypeof(left
, right
) {
54123 if (state
.option
.notypeof
)
54126 if (!left
|| !right
)
54130 "undefined", "object", "boolean", "number",
54131 "string", "function", "xml", "object", "unknown"
54134 if (right
.type
=== "(identifier)" && right
.value
=== "typeof" && left
.type
=== "(string)")
54135 return !_
.contains(values
, left
.value
);
54140 function findNativePrototype(left
) {
54142 "Array", "ArrayBuffer", "Boolean", "Collator", "DataView", "Date",
54143 "DateTimeFormat", "Error", "EvalError", "Float32Array", "Float64Array",
54144 "Function", "Infinity", "Intl", "Int16Array", "Int32Array", "Int8Array",
54145 "Iterator", "Number", "NumberFormat", "Object", "RangeError",
54146 "ReferenceError", "RegExp", "StopIteration", "String", "SyntaxError",
54147 "TypeError", "Uint16Array", "Uint32Array", "Uint8Array", "Uint8ClampedArray",
54151 function walkPrototype(obj
) {
54152 if (typeof obj
!== "object") return;
54153 return obj
.right
=== "prototype" ? obj
: walkPrototype(obj
.left
);
54156 function walkNative(obj
) {
54157 while (!obj
.identifier
&& typeof obj
.left
=== "object")
54160 if (obj
.identifier
&& natives
.indexOf(obj
.value
) >= 0)
54164 var prototype = walkPrototype(left
);
54165 if (prototype) return walkNative(prototype);
54168 function assignop(s
, f
, p
) {
54169 var x
= infix(s
, typeof f
=== "function" ? f : function (left
, that
) {
54173 if (state
.option
.freeze
) {
54174 var nativeObject
= findNativePrototype(left
);
54176 warning("W121", left
, nativeObject
);
54179 if (predefined
[left
.value
] === false &&
54180 scope
[left
.value
]["(global)"] === true) {
54181 warning("W020", left
);
54182 } else if (left
["function"]) {
54183 warning("W021", left
, left
.value
);
54186 if (funct
[left
.value
] === "const") {
54187 error("E013", left
, left
.value
);
54190 if (left
.id
=== ".") {
54192 warning("E031", that
);
54193 } else if (left
.left
.value
=== "arguments" && !state
.directive
["use strict"]) {
54194 warning("E031", that
);
54197 that
.right
= expression(10);
54199 } else if (left
.id
=== "[") {
54200 if (state
.tokens
.curr
.left
.first
) {
54201 state
.tokens
.curr
.left
.first
.forEach(function (t
) {
54202 if (funct
[t
.value
] === "const") {
54203 error("E013", t
, t
.value
);
54206 } else if (!left
.left
) {
54207 warning("E031", that
);
54208 } else if (left
.left
.value
=== "arguments" && !state
.directive
["use strict"]) {
54209 warning("E031", that
);
54211 that
.right
= expression(10);
54213 } else if (left
.identifier
&& !isReserved(left
)) {
54214 if (funct
[left
.value
] === "exception") {
54215 warning("W022", left
);
54217 that
.right
= expression(10);
54221 if (left
=== state
.syntax
["function"]) {
54222 warning("W023", state
.tokens
.curr
);
54226 error("E031", that
);
54235 function bitwise(s
, f
, p
) {
54236 var x
= symbol(s
, p
);
54238 x
.led
= (typeof f
=== "function") ? f : function (left
) {
54239 if (state
.option
.bitwise
) {
54240 warning("W016", this, this.id
);
54243 this.right
= expression(p
);
54250 function bitwiseassignop(s
) {
54251 return assignop(s
, function (left
, that
) {
54252 if (state
.option
.bitwise
) {
54253 warning("W016", that
, that
.id
);
54255 nonadjacent(state
.tokens
.prev
, state
.tokens
.curr
);
54256 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
54258 if (left
.id
=== "." || left
.id
=== "[" ||
54259 (left
.identifier
&& !isReserved(left
))) {
54263 if (left
=== state
.syntax
["function"]) {
54264 warning("W023", state
.tokens
.curr
);
54268 error("E031", that
);
54273 function suffix(s
) {
54274 var x
= symbol(s
, 150);
54276 x
.led = function (left
) {
54277 if (state
.option
.plusplus
) {
54278 warning("W016", this, this.id
);
54279 } else if ((!left
.identifier
|| isReserved(left
)) && left
.id
!== "." && left
.id
!== "[") {
54280 warning("W017", this);
54289 // fnparam means that this identifier is being defined as a function
54290 // argument (see identifier())
54291 // prop means that this identifier is that of an object property
54293 function optionalidentifier(fnparam
, prop
) {
54294 if (!state
.tokens
.next
.identifier
) {
54300 var curr
= state
.tokens
.curr
;
54301 var val
= state
.tokens
.curr
.value
;
54303 if (!isReserved(curr
)) {
54308 if (state
.option
.inES5()) {
54313 if (fnparam
&& val
=== "undefined") {
54317 // Display an info message about reserved words as properties
54318 // and ES5 but do it only once.
54319 if (prop
&& !api
.getCache("displayed:I002")) {
54320 api
.setCache("displayed:I002", true);
54324 warning("W024", state
.tokens
.curr
, state
.tokens
.curr
.id
);
54328 // fnparam means that this identifier is being defined as a function
54330 // prop means that this identifier is that of an object property
54331 function identifier(fnparam
, prop
) {
54332 var i
= optionalidentifier(fnparam
, prop
);
54336 if (state
.tokens
.curr
.id
=== "function" && state
.tokens
.next
.id
=== "(") {
54339 error("E030", state
.tokens
.next
, state
.tokens
.next
.value
);
54344 function reachable(s
) {
54346 if (state
.tokens
.next
.id
!== ";" || noreach
) {
54353 } while (t
.id
!= "(end)" && t
.id
=== "(comment)");
54358 if (t
.id
!== "(endline)") {
54359 if (t
.id
=== "function") {
54360 if (state
.option
.latedef
=== true) {
54361 warning("W026", t
);
54366 warning("W027", t
, t
.value
, s
);
54373 function statement(noindent
) {
54375 var i
= indent
, r
, s
= scope
, t
= state
.tokens
.next
;
54377 if (t
.id
=== ";") {
54382 // Is this a labelled statement?
54383 var res
= isReserved(t
);
54385 // We're being more tolerant here: if someone uses
54386 // a FutureReservedWord as a label, we warn but proceed
54389 if (res
&& t
.meta
&& t
.meta
.isFutureReservedWord
&& peek().id
=== ":") {
54390 warning("W024", t
, t
.id
);
54394 // detect a destructuring assignment
54395 if (_
.has(["[", "{"], t
.value
)) {
54396 if (lookupBlockType().isDestAssign
) {
54397 if (!state
.option
.inESNext()) {
54398 warning("W104", state
.tokens
.curr
, "destructuring expression");
54400 values
= destructuringExpression();
54401 values
.forEach(function (tok
) {
54402 isundef(funct
, "W117", tok
.token
, tok
.id
);
54405 destructuringExpressionMatch(values
, expression(10, true));
54410 if (t
.identifier
&& !res
&& peek().id
=== ":") {
54413 scope
= Object
.create(s
);
54414 addlabel(t
.value
, { type
: "label" });
54416 if (!state
.tokens
.next
.labelled
&& state
.tokens
.next
.value
!== "{") {
54417 warning("W028", state
.tokens
.next
, t
.value
, state
.tokens
.next
.value
);
54420 state
.tokens
.next
.label
= t
.value
;
54421 t
= state
.tokens
.next
;
54424 // Is it a lonely block?
54426 if (t
.id
=== "{") {
54427 // Is it a switch case block?
54430 // case bar: { <= here.
54434 var iscase
= (funct
["(verb)"] === "case" && state
.tokens
.curr
.value
=== ":");
54435 block(true, true, false, false, iscase
);
54439 // Parse the statement.
54444 r
= expression(0, true);
54446 if (r
&& (!r
.identifier
|| r
.value
!== "function") && (r
.type
!== "(punctuator)")) {
54447 if (!state
.directive
["use strict"] &&
54448 state
.option
.globalstrict
&&
54449 state
.option
.strict
) {
54454 // Look for the final semicolon.
54457 if (!state
.option
.expr
&& (!r
|| !r
.exps
)) {
54458 warning("W030", state
.tokens
.curr
);
54459 } else if (state
.option
.nonew
&& r
&& r
.left
&& r
.id
=== "(" && r
.left
.id
=== "new") {
54460 warning("W031", t
);
54463 if (state
.tokens
.next
.id
!== ";") {
54464 if (!state
.option
.asi
) {
54465 // If this is the last statement in a block that ends on
54466 // the same line *and* option lastsemic is on, ignore the warning.
54467 // Otherwise, complain about missing semicolon.
54468 if (!state
.option
.lastsemic
|| state
.tokens
.next
.id
!== "}" ||
54469 state
.tokens
.next
.line
!== state
.tokens
.curr
.line
) {
54470 warningAt("W033", state
.tokens
.curr
.line
, state
.tokens
.curr
.character
);
54474 adjacent(state
.tokens
.curr
, state
.tokens
.next
);
54476 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
54480 // Restore the indentation.
54488 function statements(startLine
) {
54491 while (!state
.tokens
.next
.reach
&& state
.tokens
.next
.id
!== "(end)") {
54492 if (state
.tokens
.next
.id
=== ";") {
54495 if (!p
|| (p
.id
!== "(" && p
.id
!== "[")) {
54501 a
.push(statement(startLine
=== state
.tokens
.next
.line
));
54509 * read all directives
54510 * recognizes a simple form of asi, but always
54511 * warns, if it is used
54513 function directives() {
54517 if (state
.tokens
.next
.id
=== "(string)") {
54519 if (p
.id
=== "(endline)") {
54524 } while (pn
.id
=== "(endline)");
54526 if (pn
.id
!== ";") {
54527 if (pn
.id
!== "(string)" && pn
.id
!== "(number)" &&
54528 pn
.id
!== "(regexp)" && pn
.identifier
!== true &&
54532 warning("W033", state
.tokens
.next
);
54536 } else if (p
.id
=== "}") {
54537 // Directive with no other statements, warn about missing semicolon
54538 warning("W033", p
);
54539 } else if (p
.id
!== ";") {
54545 if (state
.directive
[state
.tokens
.curr
.value
]) {
54546 warning("W034", state
.tokens
.curr
, state
.tokens
.curr
.value
);
54549 if (state
.tokens
.curr
.value
=== "use strict") {
54550 if (!state
.option
["(explicitNewcap)"])
54551 state
.option
.newcap
= true;
54552 state
.option
.undef
= true;
54555 // there's no directive negation, so always set to true
54556 state
.directive
[state
.tokens
.curr
.value
] = true;
54558 if (p
.id
=== ";") {
54569 * Parses a single block. A block is a sequence of statements wrapped in
54572 * ordinary - true for everything but function bodies and try blocks.
54573 * stmt - true if block can be a single statement (e.g. in if/for/while).
54574 * isfunc - true if block is a function body
54575 * isfatarrow - true if its a body of a fat arrow function
54576 * iscase - true if block is a switch case block
54578 function block(ordinary
, stmt
, isfunc
, isfatarrow
, iscase
) {
54581 old_indent
= indent
,
54588 inblock
= ordinary
;
54590 if (!ordinary
|| !state
.option
.funcscope
)
54591 scope
= Object
.create(scope
);
54593 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
54594 t
= state
.tokens
.next
;
54596 var metrics
= funct
["(metrics)"];
54597 metrics
.nestedBlockDepth
+= 1;
54598 metrics
.verifyMaxNestedBlockDepthPerFunction();
54600 if (state
.tokens
.next
.id
=== "{") {
54603 // create a new block scope
54604 funct
["(blockscope)"].stack();
54606 line
= state
.tokens
.curr
.line
;
54607 if (state
.tokens
.next
.id
!== "}") {
54608 indent
+= state
.option
.indent
;
54609 while (!ordinary
&& state
.tokens
.next
.from > indent
) {
54610 indent
+= state
.option
.indent
;
54615 for (d
in state
.directive
) {
54616 if (_
.has(state
.directive
, d
)) {
54617 m
[d
] = state
.directive
[d
];
54622 if (state
.option
.strict
&& funct
["(context)"]["(global)"]) {
54623 if (!m
["use strict"] && !state
.directive
["use strict"]) {
54629 a
= statements(line
);
54631 metrics
.statementCount
+= a
.length
;
54634 state
.directive
= m
;
54637 indent
-= state
.option
.indent
;
54638 if (line
!== state
.tokens
.next
.line
) {
54641 } else if (line
!== state
.tokens
.next
.line
) {
54646 funct
["(blockscope)"].unstack();
54648 indent
= old_indent
;
54649 } else if (!ordinary
) {
54652 if (stmt
&& !isfatarrow
&& !state
.option
.inMoz(true)) {
54653 error("W118", state
.tokens
.curr
, "function closure expressions");
54657 for (d
in state
.directive
) {
54658 if (_
.has(state
.directive
, d
)) {
54659 m
[d
] = state
.directive
[d
];
54665 if (state
.option
.strict
&& funct
["(context)"]["(global)"]) {
54666 if (!m
["use strict"] && !state
.directive
["use strict"]) {
54671 error("E021", state
.tokens
.next
, "{", state
.tokens
.next
.value
);
54675 // check to avoid let declaration not within a block
54676 funct
["(nolet)"] = true;
54678 if (!stmt
|| state
.option
.curly
) {
54679 warning("W116", state
.tokens
.next
, "{", state
.tokens
.next
.value
);
54683 indent
+= state
.option
.indent
;
54684 // test indentation only if statement is in new line
54685 a
= [statement(state
.tokens
.next
.line
=== state
.tokens
.curr
.line
)];
54686 indent
-= state
.option
.indent
;
54689 delete funct
["(nolet)"];
54691 // Don't clear and let it propagate out if it is "break", "return", or "throw" in switch case
54692 if (!(iscase
&& ["break", "return", "throw"].indexOf(funct
["(verb)"]) != -1)) {
54693 funct
["(verb)"] = null;
54696 if (!ordinary
|| !state
.option
.funcscope
) scope
= s
;
54698 if (ordinary
&& state
.option
.noempty
&& (!a
|| a
.length
=== 0)) {
54701 metrics
.nestedBlockDepth
-= 1;
54706 function countMember(m
) {
54707 if (membersOnly
&& typeof membersOnly
[m
] !== "boolean") {
54708 warning("W036", state
.tokens
.curr
, m
);
54710 if (typeof member
[m
] === "number") {
54718 function note_implied(tkn
) {
54719 var name
= tkn
.value
;
54720 var desc
= Object
.getOwnPropertyDescriptor(implied
, name
);
54723 implied
[name
] = [tkn
.line
];
54725 desc
.value
.push(tkn
.line
);
54729 // Build the syntax table by declaring the syntactic elements of the language.
54731 type("(number)", function () {
54735 type("(string)", function () {
54739 state
.syntax
["(identifier)"] = {
54740 type
: "(identifier)",
54745 var v
= this.value
;
54750 if (typeof s
=== "function") {
54751 // Protection against accidental inheritance.
54753 } else if (!funct
["(blockscope)"].current
.has(v
) && typeof s
=== "boolean") {
54755 funct
= functions
[0];
54756 addlabel(v
, { type
: "var" });
54761 block
= funct
["(blockscope)"].getlabel(v
);
54763 // The name is in scope and defined in the current function.
54764 if (funct
=== s
|| block
) {
54765 // Change 'unused' to 'var', and reject labels.
54766 // the name is in a block scope.
54767 switch (block
? block
[v
]["(type)"] : funct
[v
]) {
54769 if (block
) block
[v
]["(type)"] = "var";
54770 else funct
[v
] = "var";
54773 if (block
) block
[v
]["(type)"] = "function";
54774 else funct
[v
] = "function";
54775 this["function"] = true;
54778 setprop(funct
, v
, { unused
: false });
54781 this["function"] = true;
54784 warning("W037", state
.tokens
.curr
, v
);
54787 } else if (funct
["(global)"]) {
54788 // The name is not defined in the function. If we are in the global
54789 // scope, then we have an undefined variable.
54791 // Operators typeof and delete do not raise runtime errors even if
54792 // the base object of a reference is null so no need to display warning
54793 // if we're inside of typeof or delete.
54795 if (typeof predefined
[v
] !== "boolean") {
54796 // Attempting to subscript a null reference will throw an
54797 // error, even within the typeof and delete operators
54798 if (!(anonname
=== "typeof" || anonname
=== "delete") ||
54799 (state
.tokens
.next
&& (state
.tokens
.next
.value
=== "." ||
54800 state
.tokens
.next
.value
=== "["))) {
54802 // if we're in a list comprehension, variables are declared
54803 // locally and used before being defined. So we check
54804 // the presence of the given variable in the comp array
54805 // before declaring it undefined.
54807 if (!funct
["(comparray)"].check(v
)) {
54808 isundef(funct
, "W117", state
.tokens
.curr
, v
);
54813 note_implied(state
.tokens
.curr
);
54815 // If the name is already defined in the current
54816 // function, but not as outer, then there is a scope error.
54818 switch (funct
[v
]) {
54823 warning("W038", state
.tokens
.curr
, v
);
54826 warning("W037", state
.tokens
.curr
, v
);
54832 // If the name is defined in an outer function, make an outer entry,
54833 // and if it was unused, make it var.
54836 } else if (s
=== null) {
54837 warning("W039", state
.tokens
.curr
, v
);
54838 note_implied(state
.tokens
.curr
);
54839 } else if (typeof s
!== "object") {
54840 // Operators typeof and delete do not raise runtime errors even
54841 // if the base object of a reference is null so no need to
54843 // display warning if we're inside of typeof or delete.
54844 // Attempting to subscript a null reference will throw an
54845 // error, even within the typeof and delete operators
54846 if (!(anonname
=== "typeof" || anonname
=== "delete") ||
54847 (state
.tokens
.next
&&
54848 (state
.tokens
.next
.value
=== "." || state
.tokens
.next
.value
=== "["))) {
54850 isundef(funct
, "W117", state
.tokens
.curr
, v
);
54853 note_implied(state
.tokens
.curr
);
54858 this["function"] = true;
54860 funct
[v
] = s
["(global)"] ? "global" : "outer";
54865 funct
[v
] = s
["(global)"] ? "global" : "outer";
54868 setprop(s
, v
, { unused
: false });
54871 funct
[v
] = s
["(global)"] ? "global" : "outer";
54874 warning("W037", state
.tokens
.curr
, v
);
54883 error("E033", state
.tokens
.next
, state
.tokens
.next
.value
);
54887 type("(regexp)", function () {
54891 // ECMAScript parser
54893 delim("(endline)");
54895 delim("(end)").reach
= true;
54896 delim("(error)").reach
= true;
54897 delim("}").reach
= true;
54900 delim("\"").reach
= true;
54901 delim("'").reach
= true;
54903 delim(":").reach
= true;
54907 reserve("case").reach
= true;
54909 reserve("default").reach
= true;
54910 reserve("finally");
54911 reservevar("arguments", function (x
) {
54912 if (state
.directive
["use strict"] && funct
["(global)"]) {
54913 warning("E008", x
);
54916 reservevar("eval");
54917 reservevar("false");
54918 reservevar("Infinity");
54919 reservevar("null");
54920 reservevar("this", function (x
) {
54921 if (state
.directive
["use strict"] && !state
.option
.validthis
&& ((funct
["(statement)"] &&
54922 funct
["(name)"].charAt(0) > "Z") || funct
["(global)"])) {
54923 warning("W040", x
);
54926 reservevar("true");
54927 reservevar("undefined");
54929 assignop("=", "assign", 20);
54930 assignop("+=", "assignadd", 20);
54931 assignop("-=", "assignsub", 20);
54932 assignop("*=", "assignmult", 20);
54933 assignop("/=", "assigndiv", 20).nud = function () {
54936 assignop("%=", "assignmod", 20);
54938 bitwiseassignop("&=", "assignbitand", 20);
54939 bitwiseassignop("|=", "assignbitor", 20);
54940 bitwiseassignop("^=", "assignbitxor", 20);
54941 bitwiseassignop("<<=", "assignshiftleft", 20);
54942 bitwiseassignop(">>=", "assignshiftright", 20);
54943 bitwiseassignop(">>>=", "assignshiftrightunsigned", 20);
54944 infix(",", function (left
, that
) {
54946 that
.exprs
= [left
];
54947 if (!comma({peek
: true})) {
54951 if (!(expr
= expression(10))) {
54954 that
.exprs
.push(expr
);
54955 if (state
.tokens
.next
.value
!== "," || !comma()) {
54962 infix("?", function (left
, that
) {
54963 increaseComplexityCount();
54965 that
.right
= expression(10);
54967 that
["else"] = expression(10);
54971 var orPrecendence
= 40;
54972 infix("||", function (left
, that
) {
54973 increaseComplexityCount();
54975 that
.right
= expression(orPrecendence
);
54978 infix("&&", "and", 50);
54979 bitwise("|", "bitor", 70);
54980 bitwise("^", "bitxor", 80);
54981 bitwise("&", "bitand", 90);
54982 relation("==", function (left
, right
) {
54983 var eqnull
= state
.option
.eqnull
&& (left
.value
=== "null" || right
.value
=== "null");
54986 case !eqnull
&& state
.option
.eqeqeq
:
54987 this.from = this.character
;
54988 warning("W116", this, "===", "==");
54990 case isPoorRelation(left
):
54991 warning("W041", this, "===", left
.value
);
54993 case isPoorRelation(right
):
54994 warning("W041", this, "===", right
.value
);
54996 case isTypoTypeof(right
, left
):
54997 warning("W122", this, right
.value
);
54999 case isTypoTypeof(left
, right
):
55000 warning("W122", this, left
.value
);
55006 relation("===", function (left
, right
) {
55007 if (isTypoTypeof(right
, left
)) {
55008 warning("W122", this, right
.value
);
55009 } else if (isTypoTypeof(left
, right
)) {
55010 warning("W122", this, left
.value
);
55014 relation("!=", function (left
, right
) {
55015 var eqnull
= state
.option
.eqnull
&&
55016 (left
.value
=== "null" || right
.value
=== "null");
55018 if (!eqnull
&& state
.option
.eqeqeq
) {
55019 this.from = this.character
;
55020 warning("W116", this, "!==", "!=");
55021 } else if (isPoorRelation(left
)) {
55022 warning("W041", this, "!==", left
.value
);
55023 } else if (isPoorRelation(right
)) {
55024 warning("W041", this, "!==", right
.value
);
55025 } else if (isTypoTypeof(right
, left
)) {
55026 warning("W122", this, right
.value
);
55027 } else if (isTypoTypeof(left
, right
)) {
55028 warning("W122", this, left
.value
);
55032 relation("!==", function (left
, right
) {
55033 if (isTypoTypeof(right
, left
)) {
55034 warning("W122", this, right
.value
);
55035 } else if (isTypoTypeof(left
, right
)) {
55036 warning("W122", this, left
.value
);
55044 bitwise("<<", "shiftleft", 120);
55045 bitwise(">>", "shiftright", 120);
55046 bitwise(">>>", "shiftrightunsigned", 120);
55047 infix("in", "in", 120);
55048 infix("instanceof", "instanceof", 120);
55049 infix("+", function (left
, that
) {
55050 var right
= expression(130);
55051 if (left
&& right
&& left
.id
=== "(string)" && right
.id
=== "(string)") {
55052 left
.value
+= right
.value
;
55053 left
.character
= right
.character
;
55054 if (!state
.option
.scripturl
&& reg
.javascriptURL
.test(left
.value
)) {
55055 warning("W050", left
);
55060 that
.right
= right
;
55063 prefix("+", "num");
55064 prefix("+++", function () {
55066 this.right
= expression(150);
55067 this.arity
= "unary";
55070 infix("+++", function (left
) {
55073 this.right
= expression(130);
55076 infix("-", "sub", 130);
55077 prefix("-", "neg");
55078 prefix("---", function () {
55080 this.right
= expression(150);
55081 this.arity
= "unary";
55084 infix("---", function (left
) {
55087 this.right
= expression(130);
55090 infix("*", "mult", 140);
55091 infix("/", "div", 140);
55092 infix("%", "mod", 140);
55094 suffix("++", "postinc");
55095 prefix("++", "preinc");
55096 state
.syntax
["++"].exps
= true;
55098 suffix("--", "postdec");
55099 prefix("--", "predec");
55100 state
.syntax
["--"].exps
= true;
55101 prefix("delete", function () {
55102 var p
= expression(10);
55103 if (!p
|| (p
.id
!== "." && p
.id
!== "[")) {
55110 prefix("~", function () {
55111 if (state
.option
.bitwise
) {
55112 warning("W052", this, "~");
55118 prefix("...", function () {
55119 if (!state
.option
.inESNext()) {
55120 warning("W104", this, "spread/rest operator");
55122 if (!state
.tokens
.next
.identifier
) {
55123 error("E030", state
.tokens
.next
, state
.tokens
.next
.value
);
55129 prefix("!", function () {
55130 this.right
= expression(150);
55131 this.arity
= "unary";
55133 if (!this.right
) { // '!' followed by nothing? Give up.
55134 quit("E041", this.line
|| 0);
55137 if (bang
[this.right
.id
] === true) {
55138 warning("W018", this, "!");
55143 prefix("typeof", "typeof");
55144 prefix("new", function () {
55145 var c
= expression(155), i
;
55146 if (c
&& c
.id
!== "function") {
55147 if (c
.identifier
) {
55155 warning("W053", state
.tokens
.prev
, c
.value
);
55158 if (!state
.option
.evil
) {
55167 if (c
.id
!== "function") {
55168 i
= c
.value
.substr(0, 1);
55169 if (state
.option
.newcap
&& (i
< "A" || i
> "Z") && !_
.has(global
, c
.value
)) {
55170 warning("W055", state
.tokens
.curr
);
55175 if (c
.id
!== "." && c
.id
!== "[" && c
.id
!== "(") {
55176 warning("W056", state
.tokens
.curr
);
55180 if (!state
.option
.supernew
)
55181 warning("W057", this);
55183 adjacent(state
.tokens
.curr
, state
.tokens
.next
);
55184 if (state
.tokens
.next
.id
!== "(" && !state
.option
.supernew
) {
55185 warning("W058", state
.tokens
.curr
, state
.tokens
.curr
.value
);
55190 state
.syntax
["new"].exps
= true;
55192 prefix("void").exps
= true;
55194 infix(".", function (left
, that
) {
55195 adjacent(state
.tokens
.prev
, state
.tokens
.curr
);
55197 var m
= identifier(false, true);
55199 if (typeof m
=== "string") {
55206 if (m
&& m
=== "hasOwnProperty" && state
.tokens
.next
.value
=== "=") {
55210 if (left
&& left
.value
=== "arguments" && (m
=== "callee" || m
=== "caller")) {
55211 if (state
.option
.noarg
)
55212 warning("W059", left
, m
);
55213 else if (state
.directive
["use strict"])
55215 } else if (!state
.option
.evil
&& left
&& left
.value
=== "document" &&
55216 (m
=== "write" || m
=== "writeln")) {
55217 warning("W060", left
);
55220 if (!state
.option
.evil
&& (m
=== "eval" || m
=== "execScript")) {
55227 infix("(", function (left
, that
) {
55228 if (state
.tokens
.prev
.id
!== "}" && state
.tokens
.prev
.id
!== ")") {
55229 nobreak(state
.tokens
.prev
, state
.tokens
.curr
);
55233 if (state
.option
.immed
&& left
&& !left
.immed
&& left
.id
=== "function") {
55241 if (left
.type
=== "(identifier)") {
55242 if (left
.value
.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) {
55243 if ("Number String Boolean Date Object".indexOf(left
.value
) === -1) {
55244 if (left
.value
=== "Math") {
55245 warning("W063", left
);
55246 } else if (state
.option
.newcap
) {
55247 warning("W064", left
);
55254 if (state
.tokens
.next
.id
!== ")") {
55256 p
[p
.length
] = expression(10);
55258 if (state
.tokens
.next
.id
!== ",") {
55266 nospace(state
.tokens
.prev
, state
.tokens
.curr
);
55268 if (typeof left
=== "object") {
55269 if (state
.option
.inES3() && left
.value
=== "parseInt" && n
=== 1) {
55270 warning("W065", state
.tokens
.curr
);
55272 if (!state
.option
.evil
) {
55273 if (left
.value
=== "eval" || left
.value
=== "Function" ||
55274 left
.value
=== "execScript") {
55275 warning("W061", left
);
55277 if (p
[0] && [0].id
=== "(string)") {
55278 addInternalSrc(left
, p
[0].value
);
55280 } else if (p
[0] && p
[0].id
=== "(string)" &&
55281 (left
.value
=== "setTimeout" ||
55282 left
.value
=== "setInterval")) {
55283 warning("W066", left
);
55284 addInternalSrc(left
, p
[0].value
);
55286 // window.setTimeout/setInterval
55287 } else if (p
[0] && p
[0].id
=== "(string)" &&
55288 left
.value
=== "." &&
55289 left
.left
.value
=== "window" &&
55290 (left
.right
=== "setTimeout" ||
55291 left
.right
=== "setInterval")) {
55292 warning("W066", left
);
55293 addInternalSrc(left
, p
[0].value
);
55296 if (!left
.identifier
&& left
.id
!== "." && left
.id
!== "[" &&
55297 left
.id
!== "(" && left
.id
!== "&&" && left
.id
!== "||" &&
55299 warning("W067", left
);
55305 }, 155, true).exps
= true;
55307 prefix("(", function () {
55309 var bracket
, brackets
= [];
55310 var pn
, pn1
, i
= 0;
55317 if (pn
.value
=== "(") {
55319 } else if (pn
.value
=== ")") {
55326 } while (!(parens
=== 0 && pn
.value
=== ")") &&
55327 pn1
.value
!== "=>" && pn1
.value
!== ";" && pn1
.type
!== "(end)");
55329 if (state
.tokens
.next
.id
=== "function") {
55330 state
.tokens
.next
.immed
= true;
55335 if (state
.tokens
.next
.id
!== ")") {
55337 if (pn1
.value
=== "=>" && _
.contains(["{", "["], state
.tokens
.next
.value
)) {
55338 bracket
= state
.tokens
.next
;
55339 bracket
.left
= destructuringExpression();
55340 brackets
.push(bracket
);
55341 for (var t
in bracket
.left
) {
55342 exprs
.push(bracket
.left
[t
].token
);
55345 exprs
.push(expression(10));
55347 if (state
.tokens
.next
.id
!== ",") {
55354 advance(")", this);
55355 nospace(state
.tokens
.prev
, state
.tokens
.curr
);
55356 if (state
.option
.immed
&& exprs
[0] && exprs
[0].id
=== "function") {
55357 if (state
.tokens
.next
.id
!== "(" &&
55358 (state
.tokens
.next
.id
!== "." || (peek().value
!== "call" && peek().value
!== "apply"))) {
55359 warning("W068", this);
55363 if (state
.tokens
.next
.value
=== "=>") {
55366 if (!exprs
.length
) {
55369 if (exprs
.length
> 1) {
55370 ret
= Object
.create(state
.syntax
[","]);
55383 infix("[", function (left
, that
) {
55384 nobreak(state
.tokens
.prev
, state
.tokens
.curr
);
55386 var e
= expression(10), s
;
55387 if (e
&& e
.type
=== "(string)") {
55388 if (!state
.option
.evil
&& (e
.value
=== "eval" || e
.value
=== "execScript")) {
55389 warning("W061", that
);
55392 countMember(e
.value
);
55393 if (!state
.option
.sub
&& reg
.identifier
.test(e
.value
)) {
55394 s
= state
.syntax
[e
.value
];
55395 if (!s
|| !isReserved(s
)) {
55396 warning("W069", state
.tokens
.prev
, e
.value
);
55400 advance("]", that
);
55402 if (e
&& e
.value
=== "hasOwnProperty" && state
.tokens
.next
.value
=== "=") {
55406 nospace(state
.tokens
.prev
, state
.tokens
.curr
);
55412 function comprehensiveArrayExpression() {
55415 funct
["(comparray)"].stack();
55417 // Handle reversed for expressions, used in spidermonkey
55418 var reversed
= false;
55419 if (state
.tokens
.next
.value
!== "for") {
55421 if (!state
.option
.inMoz(true)) {
55422 warning("W116", state
.tokens
.next
, "for", state
.tokens
.next
.value
);
55424 funct
["(comparray)"].setState("use");
55425 res
.right
= expression(10);
55429 if (state
.tokens
.next
.value
=== "each") {
55431 if (!state
.option
.inMoz(true)) {
55432 warning("W118", state
.tokens
.curr
, "for each");
55436 funct
["(comparray)"].setState("define");
55437 res
.left
= expression(130);
55438 if (_
.contains(["in", "of"], state
.tokens
.next
.value
)) {
55441 error("E045", state
.tokens
.curr
);
55443 funct
["(comparray)"].setState("generate");
55447 if (state
.tokens
.next
.value
=== "if") {
55450 funct
["(comparray)"].setState("filter");
55451 res
.filter
= expression(10);
55456 funct
["(comparray)"].setState("use");
55457 res
.right
= expression(10);
55461 funct
["(comparray)"].unstack();
55465 prefix("[", function () {
55466 var blocktype
= lookupBlockType(true);
55467 if (blocktype
.isCompArray
) {
55468 if (!state
.option
.inESNext()) {
55469 warning("W119", state
.tokens
.curr
, "array comprehension");
55471 return comprehensiveArrayExpression();
55472 } else if (blocktype
.isDestAssign
&& !state
.option
.inESNext()) {
55473 warning("W104", state
.tokens
.curr
, "destructuring assignment");
55475 var b
= state
.tokens
.curr
.line
!== state
.tokens
.next
.line
;
55478 indent
+= state
.option
.indent
;
55479 if (state
.tokens
.next
.from === indent
+ state
.option
.indent
) {
55480 indent
+= state
.option
.indent
;
55483 while (state
.tokens
.next
.id
!== "(end)") {
55484 while (state
.tokens
.next
.id
=== ",") {
55485 if (!state
.option
.inES5())
55489 if (state
.tokens
.next
.id
=== "]") {
55492 if (b
&& state
.tokens
.curr
.line
!== state
.tokens
.next
.line
) {
55495 this.first
.push(expression(10));
55496 if (state
.tokens
.next
.id
=== ",") {
55497 comma({ allowTrailing
: true });
55498 if (state
.tokens
.next
.id
=== "]" && !state
.option
.inES5(true)) {
55499 warning("W070", state
.tokens
.curr
);
55507 indent
-= state
.option
.indent
;
55510 advance("]", this);
55515 function property_name() {
55516 var id
= optionalidentifier(false, true);
55519 if (state
.tokens
.next
.id
=== "(string)") {
55520 id
= state
.tokens
.next
.value
;
55522 } else if (state
.tokens
.next
.id
=== "(number)") {
55523 id
= state
.tokens
.next
.value
.toString();
55528 if (id
=== "hasOwnProperty") {
55535 function functionparams(parsed
) {
55541 var pastDefault
= false;
55544 if (Array
.isArray(parsed
)) {
55545 for (var i
in parsed
) {
55547 if (_
.contains(["{", "["], curr
.id
)) {
55548 for (t
in curr
.left
) {
55552 addlabel(t
.id
, { type
: "unused", token
: t
.token
});
55555 } else if (curr
.value
=== "...") {
55556 if (!state
.option
.inESNext()) {
55557 warning("W104", curr
, "spread/rest operator");
55560 } else if (curr
.value
!== ",") {
55561 params
.push(curr
.value
);
55562 addlabel(curr
.value
, { type
: "unused", token
: curr
});
55567 if (parsed
.identifier
=== true) {
55568 addlabel(parsed
.value
, { type
: "unused", token
: parsed
});
55574 next
= state
.tokens
.next
;
55579 if (state
.tokens
.next
.id
=== ")") {
55585 if (_
.contains(["{", "["], state
.tokens
.next
.id
)) {
55586 tokens
= destructuringExpression();
55587 for (t
in tokens
) {
55591 addlabel(t
.id
, { type
: "unused", token
: t
.token
});
55594 } else if (state
.tokens
.next
.value
=== "...") {
55595 if (!state
.option
.inESNext()) {
55596 warning("W104", state
.tokens
.next
, "spread/rest operator");
55600 ident
= identifier(true);
55601 params
.push(ident
);
55602 addlabel(ident
, { type
: "unused", token
: state
.tokens
.curr
});
55604 ident
= identifier(true);
55605 params
.push(ident
);
55606 addlabel(ident
, { type
: "unused", token
: state
.tokens
.curr
});
55609 // it is a syntax error to have a regular argument after a default argument
55611 if (state
.tokens
.next
.id
!== "=") {
55612 error("E051", state
.tokens
.current
);
55615 if (state
.tokens
.next
.id
=== "=") {
55616 if (!state
.option
.inESNext()) {
55617 warning("W119", state
.tokens
.next
, "default parameters");
55620 pastDefault
= true;
55623 if (state
.tokens
.next
.id
=== ",") {
55626 advance(")", next
);
55627 nospace(state
.tokens
.prev
, state
.tokens
.curr
);
55633 function setprop(funct
, name
, values
) {
55634 if (!funct
["(properties)"][name
]) {
55635 funct
["(properties)"][name
] = { unused
: false };
55638 _
.extend(funct
["(properties)"][name
], values
);
55641 function getprop(funct
, name
, prop
) {
55642 if (!funct
["(properties)"][name
])
55645 return funct
["(properties)"][name
][prop
] || null;
55648 function functor(name
, token
, scope
, overwrites
) {
55655 "(properties)": {},
55658 "(global)" : false,
55661 "(character)" : null,
55662 "(metrics)" : null,
55663 "(statement)" : null,
55664 "(context)" : null,
55665 "(blockscope)": null,
55666 "(comparray)" : null,
55667 "(generator)" : null,
55673 "(line)" : token
.line
,
55674 "(character)": token
.character
,
55675 "(metrics)" : createMetrics(token
)
55679 _
.extend(funct
, overwrites
);
55681 if (funct
["(context)"]) {
55682 funct
["(blockscope)"] = funct
["(context)"]["(blockscope)"];
55683 funct
["(comparray)"] = funct
["(context)"]["(comparray)"];
55689 function doFunction(name
, statement
, generator
, fatarrowparams
) {
55691 var oldOption
= state
.option
;
55692 var oldIgnored
= state
.ignored
;
55693 var oldScope
= scope
;
55695 state
.option
= Object
.create(state
.option
);
55696 state
.ignored
= Object
.create(state
.ignored
);
55697 scope
= Object
.create(scope
);
55699 funct
= functor(name
|| "\"" + anonname
+ "\"", state
.tokens
.next
, scope
, {
55700 "(statement)": statement
,
55701 "(context)": funct
,
55702 "(generator)": generator
? true : null
55706 state
.tokens
.curr
.funct
= funct
;
55708 functions
.push(funct
);
55711 addlabel(name
, { type
: "function" });
55714 funct
["(params)"] = functionparams(fatarrowparams
);
55715 funct
["(metrics)"].verifyMaxParametersPerFunction(funct
["(params)"]);
55717 // So we parse fat-arrow functions after we encounter =>. So basically
55718 // doFunction is called with the left side of => as its last argument.
55719 // This means that the parser, at that point, had already added its
55720 // arguments to the undefs array and here we undo that.
55722 JSHINT
.undefs
= _
.filter(JSHINT
.undefs
, function (item
) {
55723 return !_
.contains(_
.union(fatarrowparams
), item
[2]);
55726 block(false, true, true, fatarrowparams
? true : false);
55728 if (!state
.option
.noyield
&& generator
&& funct
["(generator)"] !== "yielded") {
55729 warning("W124", state
.tokens
.curr
);
55732 funct
["(metrics)"].verifyMaxStatementsPerFunction();
55733 funct
["(metrics)"].verifyMaxComplexityPerFunction();
55734 funct
["(unusedOption)"] = state
.option
.unused
;
55737 state
.option
= oldOption
;
55738 state
.ignored
= oldIgnored
;
55739 funct
["(last)"] = state
.tokens
.curr
.line
;
55740 funct
["(lastcharacter)"] = state
.tokens
.curr
.character
;
55742 _
.map(Object
.keys(funct
), function (key
) {
55743 if (key
[0] === "(") return;
55744 funct
["(blockscope)"].unshadow(key
);
55747 funct
= funct
["(context)"];
55752 function createMetrics(functionStartToken
) {
55755 nestedBlockDepth
: -1,
55756 ComplexityCount
: 1,
55758 verifyMaxStatementsPerFunction: function () {
55759 if (state
.option
.maxstatements
&&
55760 this.statementCount
> state
.option
.maxstatements
) {
55761 warning("W071", functionStartToken
, this.statementCount
);
55765 verifyMaxParametersPerFunction: function (params
) {
55766 params
= params
|| [];
55768 if (state
.option
.maxparams
&& params
.length
> state
.option
.maxparams
) {
55769 warning("W072", functionStartToken
, params
.length
);
55773 verifyMaxNestedBlockDepthPerFunction: function () {
55774 if (state
.option
.maxdepth
&&
55775 this.nestedBlockDepth
> 0 &&
55776 this.nestedBlockDepth
=== state
.option
.maxdepth
+ 1) {
55777 warning("W073", null, this.nestedBlockDepth
);
55781 verifyMaxComplexityPerFunction: function () {
55782 var max
= state
.option
.maxcomplexity
;
55783 var cc
= this.ComplexityCount
;
55784 if (max
&& cc
> max
) {
55785 warning("W074", functionStartToken
, cc
);
55791 function increaseComplexityCount() {
55792 funct
["(metrics)"].ComplexityCount
+= 1;
55795 // Parse assignments that were found instead of conditionals.
55796 // For example: if (a = 1) { ... }
55798 function checkCondAssignment(expr
) {
55802 paren
= expr
.paren
;
55803 if (id
=== "," && (expr
= expr
.exprs
[expr
.exprs
.length
- 1])) {
55805 paren
= paren
|| expr
.paren
;
55818 if (!paren
&& !state
.option
.boss
) {
55826 x
.nud = function (isclassdef
) {
55827 var b
, f
, i
, p
, t
, g
;
55828 var props
= {}; // All properties, including accessors
55831 function saveProperty(name
, tkn
) {
55832 if (props
[name
] && _
.has(props
, name
))
55833 warning("W075", state
.tokens
.next
, i
);
55837 props
[name
].basic
= true;
55838 props
[name
].basictkn
= tkn
;
55841 function saveSetter(name
, tkn
) {
55842 if (props
[name
] && _
.has(props
, name
)) {
55843 if (props
[name
].basic
|| props
[name
].setter
)
55844 warning("W075", state
.tokens
.next
, i
);
55849 props
[name
].setter
= true;
55850 props
[name
].setterToken
= tkn
;
55853 function saveGetter(name
) {
55854 if (props
[name
] && _
.has(props
, name
)) {
55855 if (props
[name
].basic
|| props
[name
].getter
)
55856 warning("W075", state
.tokens
.next
, i
);
55861 props
[name
].getter
= true;
55862 props
[name
].getterToken
= state
.tokens
.curr
;
55865 b
= state
.tokens
.curr
.line
!== state
.tokens
.next
.line
;
55867 indent
+= state
.option
.indent
;
55868 if (state
.tokens
.next
.from === indent
+ state
.option
.indent
) {
55869 indent
+= state
.option
.indent
;
55874 if (state
.tokens
.next
.id
=== "}") {
55882 if (isclassdef
&& state
.tokens
.next
.value
=== "static") {
55887 if (state
.tokens
.next
.value
=== "get" && peek().id
!== ":") {
55890 if (!state
.option
.inES5(!isclassdef
)) {
55894 i
= property_name();
55896 // ES6 allows for get() {...} and set() {...} method
55897 // definition shorthand syntax, so we don't produce an error
55898 // if the esnext option is enabled.
55899 if (!i
&& !state
.option
.inESNext()) {
55903 // It is a Syntax Error if PropName of MethodDefinition is
55904 // "constructor" and SpecialMethod of MethodDefinition is true.
55905 if (isclassdef
&& i
=== "constructor") {
55906 error("E049", state
.tokens
.next
, "class getter method", i
);
55909 // We don't want to save this getter unless it's an actual getter
55910 // and not an ES6 concise method
55912 saveGetter(tag
+ i
);
55915 t
= state
.tokens
.next
;
55916 adjacent(state
.tokens
.curr
, state
.tokens
.next
);
55920 // Don't warn about getter/setter pairs if this is an ES6 concise method
55922 warning("W076", t
, p
[0], i
);
55925 adjacent(state
.tokens
.curr
, state
.tokens
.next
);
55926 } else if (state
.tokens
.next
.value
=== "set" && peek().id
!== ":") {
55929 if (!state
.option
.inES5(!isclassdef
)) {
55933 i
= property_name();
55935 // ES6 allows for get() {...} and set() {...} method
55936 // definition shorthand syntax, so we don't produce an error
55937 // if the esnext option is enabled.
55938 if (!i
&& !state
.option
.inESNext()) {
55942 // It is a Syntax Error if PropName of MethodDefinition is
55943 // "constructor" and SpecialMethod of MethodDefinition is true.
55944 if (isclassdef
&& i
=== "constructor") {
55945 error("E049", state
.tokens
.next
, "class setter method", i
);
55948 // We don't want to save this getter unless it's an actual getter
55949 // and not an ES6 concise method
55951 saveSetter(tag
+ i
, state
.tokens
.next
);
55954 t
= state
.tokens
.next
;
55955 adjacent(state
.tokens
.curr
, state
.tokens
.next
);
55959 // Don't warn about getter/setter pairs if this is an ES6 concise method
55960 if (i
&& (!p
|| p
.length
!== 1)) {
55961 warning("W077", t
, i
);
55965 if (state
.tokens
.next
.value
=== "*" && state
.tokens
.next
.type
=== "(punctuator)") {
55966 if (!state
.option
.inESNext()) {
55967 warning("W104", state
.tokens
.next
, "generator functions");
55972 i
= property_name();
55973 saveProperty(tag
+ i
, state
.tokens
.next
);
55975 if (typeof i
!== "string") {
55979 if (state
.tokens
.next
.value
=== "(") {
55980 if (!state
.option
.inESNext()) {
55981 warning("W104", state
.tokens
.curr
, "concise methods");
55983 doFunction(i
, undefined, g
);
55984 } else if (!isclassdef
) {
55986 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
55990 // It is a Syntax Error if PropName of MethodDefinition is "prototype".
55991 if (isclassdef
&& i
=== "prototype") {
55992 error("E049", state
.tokens
.next
, "class method", i
);
56000 if (state
.tokens
.next
.id
=== ",") {
56001 comma({ allowTrailing
: true, property
: true });
56002 if (state
.tokens
.next
.id
=== ",") {
56003 warning("W070", state
.tokens
.curr
);
56004 } else if (state
.tokens
.next
.id
=== "}" && !state
.option
.inES5(true)) {
56005 warning("W070", state
.tokens
.curr
);
56012 indent
-= state
.option
.indent
;
56015 advance("}", this);
56017 // Check for lonely setters if in the ES5 mode.
56018 if (state
.option
.inES5()) {
56019 for (var name
in props
) {
56020 if (_
.has(props
, name
) && props
[name
].setter
&& !props
[name
].getter
) {
56021 warning("W078", props
[name
].setterToken
);
56027 x
.fud = function () {
56028 error("E036", state
.tokens
.curr
);
56032 function destructuringExpression() {
56034 var identifiers
= [];
56035 if (!state
.option
.inESNext()) {
56036 warning("W104", state
.tokens
.curr
, "destructuring expression");
56038 var nextInnerDE = function () {
56040 if (_
.contains(["[", "{"], state
.tokens
.next
.value
)) {
56041 ids
= destructuringExpression();
56042 for (var id
in ids
) {
56044 identifiers
.push({ id
: id
.id
, token
: id
.token
});
56046 } else if (state
.tokens
.next
.value
=== ",") {
56047 identifiers
.push({ id
: null, token
: state
.tokens
.curr
});
56048 } else if (state
.tokens
.next
.value
=== "(") {
56053 ident
= identifier();
56055 identifiers
.push({ id
: ident
, token
: state
.tokens
.curr
});
56058 if (state
.tokens
.next
.value
=== "[") {
56061 while (state
.tokens
.next
.value
!== "]") {
56066 } else if (state
.tokens
.next
.value
=== "{") {
56069 if (state
.tokens
.next
.value
=== ":") {
56073 identifiers
.push({ id
: id
, token
: state
.tokens
.curr
});
56075 while (state
.tokens
.next
.value
!== "}") {
56078 if (state
.tokens
.next
.value
=== ":") {
56082 identifiers
.push({ id
: id
, token
: state
.tokens
.curr
});
56087 return identifiers
;
56090 function destructuringExpressionMatch(tokens
, value
) {
56091 var first
= value
.first
;
56096 _
.zip(tokens
, Array
.isArray(first
) ? first
: [ first
]).forEach(function (val
) {
56097 var token
= val
[0];
56098 var value
= val
[1];
56100 if (token
&& value
)
56101 token
.first
= value
;
56102 else if (token
&& token
.first
&& !value
)
56103 warning("W080", token
.first
, token
.first
.value
);
56107 var conststatement
= stmt("const", function (prefix
) {
56110 var lone
; // State variable to know if it is a lone identifier, or a destructuring statement.
56112 if (!state
.option
.inESNext())
56113 warning("W104", state
.tokens
.curr
, "const");
56118 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56119 if (_
.contains(["{", "["], state
.tokens
.next
.value
)) {
56120 tokens
= destructuringExpression();
56123 tokens
= [ { id
: identifier(), token
: state
.tokens
.curr
} ];
56126 for (var t
in tokens
) {
56127 if (tokens
.hasOwnProperty(t
)) {
56129 if (funct
[t
.id
] === "const") {
56130 warning("E011", null, t
.id
);
56132 if (funct
["(global)"] && predefined
[t
.id
] === false) {
56133 warning("W079", t
.token
, t
.id
);
56136 addlabel(t
.id
, { token
: t
.token
, type
: "const", unused
: true });
56137 names
.push(t
.token
);
56145 this.first
= this.first
.concat(names
);
56147 if (state
.tokens
.next
.id
!== "=") {
56148 warning("E012", state
.tokens
.curr
, state
.tokens
.curr
.value
);
56151 if (state
.tokens
.next
.id
=== "=") {
56152 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56154 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56155 if (state
.tokens
.next
.id
=== "undefined") {
56156 warning("W080", state
.tokens
.prev
, state
.tokens
.prev
.value
);
56158 if (peek(0).id
=== "=" && state
.tokens
.next
.identifier
) {
56159 warning("W120", state
.tokens
.next
, state
.tokens
.next
.value
);
56161 value
= expression(10);
56163 tokens
[0].first
= value
;
56165 destructuringExpressionMatch(names
, value
);
56169 if (state
.tokens
.next
.id
!== ",") {
56177 conststatement
.exps
= true;
56178 var varstatement
= stmt("var", function (prefix
) {
56179 // JavaScript does not have block scope. It only has function scope. So,
56180 // declaring a variable in a block can have unexpected consequences.
56181 var tokens
, lone
, value
;
56183 if (funct
["(onevar)"] && state
.option
.onevar
) {
56185 } else if (!funct
["(global)"]) {
56186 funct
["(onevar)"] = true;
56192 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56193 if (_
.contains(["{", "["], state
.tokens
.next
.value
)) {
56194 tokens
= destructuringExpression();
56197 tokens
= [ { id
: identifier(), token
: state
.tokens
.curr
} ];
56200 for (var t
in tokens
) {
56201 if (tokens
.hasOwnProperty(t
)) {
56203 if (state
.option
.inESNext() && funct
[t
.id
] === "const") {
56204 warning("E011", null, t
.id
);
56206 if (funct
["(global)"] && predefined
[t
.id
] === false) {
56207 warning("W079", t
.token
, t
.id
);
56210 addlabel(t
.id
, { type
: "unused", token
: t
.token
});
56211 names
.push(t
.token
);
56219 this.first
= this.first
.concat(names
);
56221 if (state
.tokens
.next
.id
=== "=") {
56222 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56224 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56225 if (state
.tokens
.next
.id
=== "undefined") {
56226 warning("W080", state
.tokens
.prev
, state
.tokens
.prev
.value
);
56228 if (peek(0).id
=== "=" && state
.tokens
.next
.identifier
) {
56229 warning("W120", state
.tokens
.next
, state
.tokens
.next
.value
);
56231 value
= expression(10);
56233 tokens
[0].first
= value
;
56235 destructuringExpressionMatch(names
, value
);
56239 if (state
.tokens
.next
.id
!== ",") {
56246 varstatement
.exps
= true;
56248 var letstatement
= stmt("let", function (prefix
) {
56249 var tokens
, lone
, value
, letblock
;
56251 if (!state
.option
.inESNext()) {
56252 warning("W104", state
.tokens
.curr
, "let");
56255 if (state
.tokens
.next
.value
=== "(") {
56256 if (!state
.option
.inMoz(true)) {
56257 warning("W118", state
.tokens
.next
, "let block");
56260 funct
["(blockscope)"].stack();
56262 } else if (funct
["(nolet)"]) {
56263 error("E048", state
.tokens
.curr
);
56266 if (funct
["(onevar)"] && state
.option
.onevar
) {
56268 } else if (!funct
["(global)"]) {
56269 funct
["(onevar)"] = true;
56275 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56276 if (_
.contains(["{", "["], state
.tokens
.next
.value
)) {
56277 tokens
= destructuringExpression();
56280 tokens
= [ { id
: identifier(), token
: state
.tokens
.curr
.value
} ];
56283 for (var t
in tokens
) {
56284 if (tokens
.hasOwnProperty(t
)) {
56286 if (state
.option
.inESNext() && funct
[t
.id
] === "const") {
56287 warning("E011", null, t
.id
);
56289 if (funct
["(global)"] && predefined
[t
.id
] === false) {
56290 warning("W079", t
.token
, t
.id
);
56292 if (t
.id
&& !funct
["(nolet)"]) {
56293 addlabel(t
.id
, { type
: "unused", token
: t
.token
, islet
: true });
56294 names
.push(t
.token
);
56302 this.first
= this.first
.concat(names
);
56304 if (state
.tokens
.next
.id
=== "=") {
56305 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56307 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56308 if (state
.tokens
.next
.id
=== "undefined") {
56309 warning("W080", state
.tokens
.prev
, state
.tokens
.prev
.value
);
56311 if (peek(0).id
=== "=" && state
.tokens
.next
.identifier
) {
56312 warning("W120", state
.tokens
.next
, state
.tokens
.next
.value
);
56314 value
= expression(10);
56316 tokens
[0].first
= value
;
56318 destructuringExpressionMatch(names
, value
);
56322 if (state
.tokens
.next
.id
!== ",") {
56331 funct
["(blockscope)"].unstack();
56336 letstatement
.exps
= true;
56338 blockstmt("class", function () {
56339 return classdef
.call(this, true);
56342 function classdef(stmt
) {
56343 /*jshint validthis:true */
56344 if (!state
.option
.inESNext()) {
56345 warning("W104", state
.tokens
.curr
, "class");
56348 // BindingIdentifier
56349 this.name
= identifier();
56350 addlabel(this.name
, { type
: "unused", token
: state
.tokens
.curr
});
56351 } else if (state
.tokens
.next
.identifier
&& state
.tokens
.next
.value
!== "extends") {
56352 // BindingIdentifier(opt)
56353 this.name
= identifier();
56359 function classtail(c
) {
56360 var strictness
= state
.directive
["use strict"];
56362 // ClassHeritage(opt)
56363 if (state
.tokens
.next
.value
=== "extends") {
56364 advance("extends");
56365 c
.heritage
= expression(10);
56368 // A ClassBody is always strict code.
56369 state
.directive
["use strict"] = true;
56372 c
.body
= state
.syntax
["{"].nud(true);
56373 state
.directive
["use strict"] = strictness
;
56376 blockstmt("function", function () {
56377 var generator
= false;
56378 if (state
.tokens
.next
.value
=== "*") {
56380 if (state
.option
.inESNext(true)) {
56383 warning("W119", state
.tokens
.curr
, "function*");
56387 warning("W082", state
.tokens
.curr
);
56390 var i
= identifier();
56391 if (funct
[i
] === "const") {
56392 warning("E011", null, i
);
56394 adjacent(state
.tokens
.curr
, state
.tokens
.next
);
56395 addlabel(i
, { type
: "unction", token
: state
.tokens
.curr
});
56397 doFunction(i
, { statement
: true }, generator
);
56398 if (state
.tokens
.next
.id
=== "(" && state
.tokens
.next
.line
=== state
.tokens
.curr
.line
) {
56404 prefix("function", function () {
56405 var generator
= false;
56406 if (state
.tokens
.next
.value
=== "*") {
56407 if (!state
.option
.inESNext()) {
56408 warning("W119", state
.tokens
.curr
, "function*");
56413 var i
= optionalidentifier();
56414 if (i
|| state
.option
.gcl
) {
56415 adjacent(state
.tokens
.curr
, state
.tokens
.next
);
56417 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56419 doFunction(i
, undefined, generator
);
56420 if (!state
.option
.loopfunc
&& funct
["(loopage)"]) {
56426 blockstmt("if", function () {
56427 var t
= state
.tokens
.next
;
56428 increaseComplexityCount();
56429 state
.condition
= true;
56431 nonadjacent(this, t
);
56433 checkCondAssignment(expression(0));
56435 state
.condition
= false;
56436 nospace(state
.tokens
.prev
, state
.tokens
.curr
);
56438 if (state
.tokens
.next
.id
=== "else") {
56439 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56441 if (state
.tokens
.next
.id
=== "if" || state
.tokens
.next
.id
=== "switch") {
56450 blockstmt("try", function () {
56453 function doCatch() {
56454 var oldScope
= scope
;
56458 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56461 scope
= Object
.create(oldScope
);
56463 e
= state
.tokens
.next
.value
;
56464 if (state
.tokens
.next
.type
!== "(identifier)") {
56466 warning("E030", state
.tokens
.next
, e
);
56471 funct
= functor("(catch)", state
.tokens
.next
, scope
, {
56472 "(context)" : funct
,
56473 "(breakage)" : funct
["(breakage)"],
56474 "(loopage)" : funct
["(loopage)"],
56475 "(statement)": false,
56480 addlabel(e
, { type
: "exception" });
56483 if (state
.tokens
.next
.value
=== "if") {
56484 if (!state
.option
.inMoz(true)) {
56485 warning("W118", state
.tokens
.curr
, "catch filter");
56493 state
.tokens
.curr
.funct
= funct
;
56494 functions
.push(funct
);
56500 funct
["(last)"] = state
.tokens
.curr
.line
;
56501 funct
["(lastcharacter)"] = state
.tokens
.curr
.character
;
56502 funct
= funct
["(context)"];
56507 while (state
.tokens
.next
.id
=== "catch") {
56508 increaseComplexityCount();
56509 if (b
&& (!state
.option
.inMoz(true))) {
56510 warning("W118", state
.tokens
.next
, "multiple catch blocks");
56516 if (state
.tokens
.next
.id
=== "finally") {
56517 advance("finally");
56523 error("E021", state
.tokens
.next
, "catch", state
.tokens
.next
.value
);
56529 blockstmt("while", function () {
56530 var t
= state
.tokens
.next
;
56531 funct
["(breakage)"] += 1;
56532 funct
["(loopage)"] += 1;
56533 increaseComplexityCount();
56535 nonadjacent(this, t
);
56537 checkCondAssignment(expression(0));
56539 nospace(state
.tokens
.prev
, state
.tokens
.curr
);
56541 funct
["(breakage)"] -= 1;
56542 funct
["(loopage)"] -= 1;
56544 }).labelled
= true;
56546 blockstmt("with", function () {
56547 var t
= state
.tokens
.next
;
56548 if (state
.directive
["use strict"]) {
56549 error("E010", state
.tokens
.curr
);
56550 } else if (!state
.option
.withstmt
) {
56551 warning("W085", state
.tokens
.curr
);
56555 nonadjacent(this, t
);
56559 nospace(state
.tokens
.prev
, state
.tokens
.curr
);
56565 blockstmt("switch", function () {
56566 var t
= state
.tokens
.next
;
56568 var noindent
= false;
56570 funct
["(breakage)"] += 1;
56572 nonadjacent(this, t
);
56574 checkCondAssignment(expression(0));
56576 nospace(state
.tokens
.prev
, state
.tokens
.curr
);
56577 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56578 t
= state
.tokens
.next
;
56580 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56582 if (state
.tokens
.next
.from === indent
)
56586 indent
+= state
.option
.indent
;
56591 switch (state
.tokens
.next
.id
) {
56593 switch (funct
["(verb)"]) {
56603 // You can tell JSHint that you don't use break intentionally by
56604 // adding a comment /* falls through */ on a line just before
56605 // the next `case`.
56606 if (!reg
.fallsThrough
.test(state
.lines
[state
.tokens
.next
.line
- 2])) {
56607 warning("W086", state
.tokens
.curr
, "case");
56612 this.cases
.push(expression(20));
56613 increaseComplexityCount();
56616 funct
["(verb)"] = "case";
56619 switch (funct
["(verb)"]) {
56627 // Do not display a warning if 'default' is the first statement or if
56628 // there is a special /* falls through */ comment.
56629 if (this.cases
.length
) {
56630 if (!reg
.fallsThrough
.test(state
.lines
[state
.tokens
.next
.line
- 2])) {
56631 warning("W086", state
.tokens
.curr
, "default");
56636 advance("default");
56642 indent
-= state
.option
.indent
;
56645 funct
["(breakage)"] -= 1;
56646 funct
["(verb)"] = undefined;
56649 error("E023", state
.tokens
.next
, "}");
56652 indent
+= state
.option
.indent
;
56654 switch (state
.tokens
.curr
.id
) {
56663 error("E025", state
.tokens
.curr
);
56667 if (state
.tokens
.curr
.id
=== ":") {
56669 error("E024", state
.tokens
.curr
, ":");
56672 error("E021", state
.tokens
.next
, "case", state
.tokens
.next
.value
);
56676 indent
-= state
.option
.indent
;
56679 }).labelled
= true;
56681 stmt("debugger", function () {
56682 if (!state
.option
.debug
) {
56683 warning("W087", this);
56689 var x
= stmt("do", function () {
56690 funct
["(breakage)"] += 1;
56691 funct
["(loopage)"] += 1;
56692 increaseComplexityCount();
56694 this.first
= block(true, true);
56696 var t
= state
.tokens
.next
;
56697 nonadjacent(state
.tokens
.curr
, t
);
56700 checkCondAssignment(expression(0));
56702 nospace(state
.tokens
.prev
, state
.tokens
.curr
);
56703 funct
["(breakage)"] -= 1;
56704 funct
["(loopage)"] -= 1;
56711 blockstmt("for", function () {
56712 var s
, t
= state
.tokens
.next
;
56713 var letscope
= false;
56714 var foreachtok
= null;
56716 if (t
.value
=== "each") {
56719 if (!state
.option
.inMoz(true)) {
56720 warning("W118", state
.tokens
.curr
, "for each");
56724 funct
["(breakage)"] += 1;
56725 funct
["(loopage)"] += 1;
56726 increaseComplexityCount();
56728 nonadjacent(this, t
);
56731 // what kind of for(…) statement it is? for(…of…)? for(…in…)? for(…;…;…)?
56732 var nextop
; // contains the token of the "in" or "of" operator
56734 var inof
= ["in", "of"];
56738 } while (!_
.contains(inof
, nextop
.value
) && nextop
.value
!== ";" &&
56739 nextop
.type
!== "(end)");
56741 // if we're in a for (… in|of …) statement
56742 if (_
.contains(inof
, nextop
.value
)) {
56743 if (!state
.option
.inESNext() && nextop
.value
=== "of") {
56744 error("W104", nextop
, "for of");
56746 if (state
.tokens
.next
.id
=== "var") {
56748 state
.syntax
["var"].fud
.call(state
.syntax
["var"].fud
, true);
56749 } else if (state
.tokens
.next
.id
=== "let") {
56751 // create a new block scope
56753 funct
["(blockscope)"].stack();
56754 state
.syntax
["let"].fud
.call(state
.syntax
["let"].fud
, true);
56756 switch (funct
[state
.tokens
.next
.value
]) {
56758 funct
[state
.tokens
.next
.value
] = "var";
56763 if (!funct
["(blockscope)"].getlabel(state
.tokens
.next
.value
))
56764 warning("W088", state
.tokens
.next
, state
.tokens
.next
.value
);
56768 advance(nextop
.value
);
56771 s
= block(true, true);
56772 if (state
.option
.forin
&& s
&& (s
.length
> 1 || typeof s
[0] !== "object" ||
56773 s
[0].value
!== "if")) {
56774 warning("W089", this);
56776 funct
["(breakage)"] -= 1;
56777 funct
["(loopage)"] -= 1;
56780 error("E045", foreachtok
);
56782 if (state
.tokens
.next
.id
!== ";") {
56783 if (state
.tokens
.next
.id
=== "var") {
56785 state
.syntax
["var"].fud
.call(state
.syntax
["var"].fud
);
56786 } else if (state
.tokens
.next
.id
=== "let") {
56788 // create a new block scope
56790 funct
["(blockscope)"].stack();
56791 state
.syntax
["let"].fud
.call(state
.syntax
["let"].fud
);
56794 expression(0, "for");
56795 if (state
.tokens
.next
.id
!== ",") {
56802 nolinebreak(state
.tokens
.curr
);
56804 if (state
.tokens
.next
.id
!== ";") {
56805 checkCondAssignment(expression(0));
56807 nolinebreak(state
.tokens
.curr
);
56809 if (state
.tokens
.next
.id
=== ";") {
56810 error("E021", state
.tokens
.next
, ")", ";");
56812 if (state
.tokens
.next
.id
!== ")") {
56814 expression(0, "for");
56815 if (state
.tokens
.next
.id
!== ",") {
56822 nospace(state
.tokens
.prev
, state
.tokens
.curr
);
56824 funct
["(breakage)"] -= 1;
56825 funct
["(loopage)"] -= 1;
56828 // unstack loop blockscope
56830 funct
["(blockscope)"].unstack();
56833 }).labelled
= true;
56836 stmt("break", function () {
56837 var v
= state
.tokens
.next
.value
;
56839 if (funct
["(breakage)"] === 0)
56840 warning("W052", state
.tokens
.next
, this.value
);
56842 if (!state
.option
.asi
)
56845 if (state
.tokens
.next
.id
!== ";" && !state
.tokens
.next
.reach
) {
56846 if (state
.tokens
.curr
.line
=== state
.tokens
.next
.line
) {
56847 if (funct
[v
] !== "label") {
56848 warning("W090", state
.tokens
.next
, v
);
56849 } else if (scope
[v
] !== funct
) {
56850 warning("W091", state
.tokens
.next
, v
);
56852 this.first
= state
.tokens
.next
;
56856 reachable("break");
56861 stmt("continue", function () {
56862 var v
= state
.tokens
.next
.value
;
56864 if (funct
["(breakage)"] === 0)
56865 warning("W052", state
.tokens
.next
, this.value
);
56867 if (!state
.option
.asi
)
56870 if (state
.tokens
.next
.id
!== ";" && !state
.tokens
.next
.reach
) {
56871 if (state
.tokens
.curr
.line
=== state
.tokens
.next
.line
) {
56872 if (funct
[v
] !== "label") {
56873 warning("W090", state
.tokens
.next
, v
);
56874 } else if (scope
[v
] !== funct
) {
56875 warning("W091", state
.tokens
.next
, v
);
56877 this.first
= state
.tokens
.next
;
56880 } else if (!funct
["(loopage)"]) {
56881 warning("W052", state
.tokens
.next
, this.value
);
56883 reachable("continue");
56888 stmt("return", function () {
56889 if (this.line
=== state
.tokens
.next
.line
) {
56890 if (state
.tokens
.next
.id
!== ";" && !state
.tokens
.next
.reach
) {
56891 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56892 this.first
= expression(0);
56895 this.first
.type
=== "(punctuator)" && this.first
.value
=== "=" &&
56896 !this.first
.paren
&& !state
.option
.boss
) {
56897 warningAt("W093", this.first
.line
, this.first
.character
);
56901 if (state
.tokens
.next
.type
=== "(punctuator)" &&
56902 ["[", "{", "+", "-"].indexOf(state
.tokens
.next
.value
) > -1) {
56903 nolinebreak(this); // always warn (Line breaking error)
56906 reachable("return");
56913 }(prefix("yield", function () {
56914 var prev
= state
.tokens
.prev
;
56915 if (state
.option
.inESNext(true) && !funct
["(generator)"]) {
56916 error("E046", state
.tokens
.curr
, "yield");
56917 } else if (!state
.option
.inESNext()) {
56918 warning("W104", state
.tokens
.curr
, "yield");
56920 funct
["(generator)"] = "yielded";
56921 if (this.line
=== state
.tokens
.next
.line
|| !state
.option
.inMoz(true)) {
56922 if (state
.tokens
.next
.id
!== ";" && !state
.tokens
.next
.reach
&& state
.tokens
.next
.nud
) {
56923 nobreaknonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56924 this.first
= expression(10);
56926 if (this.first
.type
=== "(punctuator)" && this.first
.value
=== "=" &&
56927 !this.first
.paren
&& !state
.option
.boss
) {
56928 warningAt("W093", this.first
.line
, this.first
.character
);
56932 if (state
.option
.inMoz(true) && state
.tokens
.next
.id
!== ")" &&
56933 (prev
.lbp
> 30 || (!prev
.assign
&& !isEndOfExpr()) || prev
.id
=== "yield")) {
56934 error("E050", this);
56936 } else if (!state
.option
.asi
) {
56937 nolinebreak(this); // always warn (Line breaking error)
56943 stmt("throw", function () {
56945 nonadjacent(state
.tokens
.curr
, state
.tokens
.next
);
56946 this.first
= expression(20);
56947 reachable("throw");
56951 stmt("import", function () {
56952 if (!state
.option
.inESNext()) {
56953 warning("W119", state
.tokens
.curr
, "import");
56956 if (state
.tokens
.next
.identifier
) {
56957 this.name
= identifier();
56958 addlabel(this.name
, { type
: "unused", token
: state
.tokens
.curr
});
56963 if (state
.tokens
.next
.type
=== "default") {
56964 importName
= "default";
56965 advance("default");
56967 importName
= identifier();
56969 if (state
.tokens
.next
.value
=== "as") {
56971 importName
= identifier();
56973 addlabel(importName
, { type
: "unused", token
: state
.tokens
.curr
});
56975 if (state
.tokens
.next
.value
=== ",") {
56977 } else if (state
.tokens
.next
.value
=== "}") {
56981 error("E024", state
.tokens
.next
, state
.tokens
.next
.value
);
56988 advance("(string)");
56992 stmt("export", function () {
56993 if (!state
.option
.inESNext()) {
56994 warning("W119", state
.tokens
.curr
, "export");
56997 if (state
.tokens
.next
.type
=== "default") {
56998 advance("default");
56999 if (state
.tokens
.next
.id
=== "function" || state
.tokens
.next
.id
=== "class") {
57002 this.exportee
= expression(10);
57007 if (state
.tokens
.next
.value
=== "{") {
57012 if (state
.tokens
.next
.value
=== ",") {
57014 } else if (state
.tokens
.next
.value
=== "}") {
57018 error("E024", state
.tokens
.next
, state
.tokens
.next
.value
);
57025 if (state
.tokens
.next
.id
=== "var") {
57027 state
.syntax
["var"].fud
.call(state
.syntax
["var"].fud
);
57028 } else if (state
.tokens
.next
.id
=== "let") {
57030 state
.syntax
["let"].fud
.call(state
.syntax
["let"].fud
);
57031 } else if (state
.tokens
.next
.id
=== "const") {
57033 state
.syntax
["const"].fud
.call(state
.syntax
["const"].fud
);
57034 } else if (state
.tokens
.next
.id
=== "function") {
57036 advance("function");
57037 state
.syntax
["function"].fud();
57038 } else if (state
.tokens
.next
.id
=== "class") {
57041 state
.syntax
["class"].fud();
57043 error("E024", state
.tokens
.next
, state
.tokens
.next
.value
);
57049 // Future Reserved Words
57051 FutureReservedWord("abstract");
57052 FutureReservedWord("boolean");
57053 FutureReservedWord("byte");
57054 FutureReservedWord("char");
57055 FutureReservedWord("class", { es5
: true, nud
: classdef
});
57056 FutureReservedWord("double");
57057 FutureReservedWord("enum", { es5
: true });
57058 FutureReservedWord("export", { es5
: true });
57059 FutureReservedWord("extends", { es5
: true });
57060 FutureReservedWord("final");
57061 FutureReservedWord("float");
57062 FutureReservedWord("goto");
57063 FutureReservedWord("implements", { es5
: true, strictOnly
: true });
57064 FutureReservedWord("import", { es5
: true });
57065 FutureReservedWord("int");
57066 FutureReservedWord("interface", { es5
: true, strictOnly
: true });
57067 FutureReservedWord("long");
57068 FutureReservedWord("native");
57069 FutureReservedWord("package", { es5
: true, strictOnly
: true });
57070 FutureReservedWord("private", { es5
: true, strictOnly
: true });
57071 FutureReservedWord("protected", { es5
: true, strictOnly
: true });
57072 FutureReservedWord("public", { es5
: true, strictOnly
: true });
57073 FutureReservedWord("short");
57074 FutureReservedWord("static", { es5
: true, strictOnly
: true });
57075 FutureReservedWord("super", { es5
: true });
57076 FutureReservedWord("synchronized");
57077 FutureReservedWord("throws");
57078 FutureReservedWord("transient");
57079 FutureReservedWord("volatile");
57081 // this function is used to determine wether a squarebracket or a curlybracket
57082 // expression is a comprehension array, destructuring assignment or a json value.
57084 var lookupBlockType = function () {
57087 var bracketStack
= 0;
57089 if (_
.contains(["[", "{"], state
.tokens
.curr
.value
))
57092 pn
= (i
=== -1) ? state
.tokens
.next
: peek(i
);
57095 if (_
.contains(["[", "{"], pn
.value
)) {
57097 } else if (_
.contains(["]", "}"], pn
.value
)) {
57100 if (pn
.identifier
&& pn
.value
=== "for" && bracketStack
=== 1) {
57101 ret
.isCompArray
= true;
57102 ret
.notJson
= true;
57105 if (_
.contains(["}", "]"], pn
.value
) && pn1
.value
=== "=" && bracketStack
=== 0) {
57106 ret
.isDestAssign
= true;
57107 ret
.notJson
= true;
57110 if (pn
.value
=== ";") {
57111 ret
.isBlock
= true;
57112 ret
.notJson
= true;
57114 } while (bracketStack
> 0 && pn
.id
!== "(end)" && i
< 15);
57118 // Check whether this function has been reached for a destructuring assign with undeclared values
57119 function destructuringAssignOrJsonValue() {
57120 // lookup for the assignment (esnext only)
57121 // if it has semicolons, it is a block, so go parse it as a block
57122 // or it's not a block, but there are assignments, check for undeclared variables
57124 var block
= lookupBlockType();
57125 if (block
.notJson
) {
57126 if (!state
.option
.inESNext() && block
.isDestAssign
) {
57127 warning("W104", state
.tokens
.curr
, "destructuring assignment");
57130 // otherwise parse json value
57132 state
.option
.laxbreak
= true;
57133 state
.jsonMode
= true;
57138 // array comprehension parsing function
57139 // parses and defines the three states of the list comprehension in order
57140 // to avoid defining global variables, but keeping them to the list comprehension scope
57141 // only. The order of the states are as follows:
57142 // * "use" which will be the returned iterative part of the list comprehension
57143 // * "define" which will define the variables local to the list comprehension
57144 // * "filter" which will help filter out values
57146 var arrayComprehension = function () {
57147 var CompArray = function () {
57149 this.variables
= [];
57153 function declare(v
) {
57154 var l
= _current
.variables
.filter(function (elt
) {
57155 // if it has, change its undef state
57156 if (elt
.value
=== v
) {
57164 var l
= _current
.variables
.filter(function (elt
) {
57165 // and if it has been defined
57166 if (elt
.value
=== v
&& !elt
.undef
) {
57167 if (elt
.unused
=== true) {
57168 elt
.unused
= false;
57173 // otherwise we warn about it
57176 return {stack: function () {
57177 _current
= new CompArray();
57178 _carrays
.push(_current
);
57180 unstack: function () {
57181 _current
.variables
.filter(function (v
) {
57183 warning("W098", v
.token
, v
.value
);
57185 isundef(v
.funct
, "W117", v
.token
, v
.value
);
57187 _carrays
.splice(-1, 1);
57188 _current
= _carrays
[_carrays
.length
- 1];
57190 setState: function (s
) {
57191 if (_
.contains(["use", "define", "generate", "filter"], s
))
57194 check: function (v
) {
57198 // When we are in "use" state of the list comp, we enqueue that var
57199 if (_current
&& _current
.mode
=== "use") {
57201 _current
.variables
.push({
57203 token
: state
.tokens
.curr
,
57210 // When we are in "define" state of the list comp,
57211 } else if (_current
&& _current
.mode
=== "define") {
57212 // check if the variable has been used previously
57214 _current
.variables
.push({
57216 token
: state
.tokens
.curr
,
57223 // When we are in the "generate" state of the list comp,
57224 } else if (_current
&& _current
.mode
=== "generate") {
57225 isundef(funct
, "W117", state
.tokens
.curr
, v
);
57227 // When we are in "filter" state,
57228 } else if (_current
&& _current
.mode
=== "filter") {
57229 // we check whether current variable has been declared
57231 // if not we warn about it
57232 isundef(funct
, "W117", state
.tokens
.curr
, v
);
57244 function jsonValue() {
57246 function jsonObject() {
57247 var o
= {}, t
= state
.tokens
.next
;
57249 if (state
.tokens
.next
.id
!== "}") {
57251 if (state
.tokens
.next
.id
=== "(end)") {
57252 error("E026", state
.tokens
.next
, t
.line
);
57253 } else if (state
.tokens
.next
.id
=== "}") {
57254 warning("W094", state
.tokens
.curr
);
57256 } else if (state
.tokens
.next
.id
=== ",") {
57257 error("E028", state
.tokens
.next
);
57258 } else if (state
.tokens
.next
.id
!== "(string)") {
57259 warning("W095", state
.tokens
.next
, state
.tokens
.next
.value
);
57261 if (o
[state
.tokens
.next
.value
] === true) {
57262 warning("W075", state
.tokens
.next
, state
.tokens
.next
.value
);
57263 } else if ((state
.tokens
.next
.value
=== "__proto__" &&
57264 !state
.option
.proto
) || (state
.tokens
.next
.value
=== "__iterator__" &&
57265 !state
.option
.iterator
)) {
57266 warning("W096", state
.tokens
.next
, state
.tokens
.next
.value
);
57268 o
[state
.tokens
.next
.value
] = true;
57273 if (state
.tokens
.next
.id
!== ",") {
57282 function jsonArray() {
57283 var t
= state
.tokens
.next
;
57285 if (state
.tokens
.next
.id
!== "]") {
57287 if (state
.tokens
.next
.id
=== "(end)") {
57288 error("E027", state
.tokens
.next
, t
.line
);
57289 } else if (state
.tokens
.next
.id
=== "]") {
57290 warning("W094", state
.tokens
.curr
);
57292 } else if (state
.tokens
.next
.id
=== ",") {
57293 error("E028", state
.tokens
.next
);
57296 if (state
.tokens
.next
.id
!== ",") {
57305 switch (state
.tokens
.next
.id
) {
57321 if (state
.tokens
.curr
.character
!== state
.tokens
.next
.from) {
57322 warning("W011", state
.tokens
.curr
);
57324 adjacent(state
.tokens
.curr
, state
.tokens
.next
);
57325 advance("(number)");
57328 error("E003", state
.tokens
.next
);
57332 var blockScope = function () {
57334 var _variables
= [_current
];
57336 function _checkBlockLabels() {
57337 for (var t
in _current
) {
57338 if (_current
[t
]["(type)"] === "unused") {
57339 if (state
.option
.unused
) {
57340 var tkn
= _current
[t
]["(token)"];
57341 var line
= tkn
.line
;
57342 var chr
= tkn
.character
;
57343 warningAt("W098", line
, chr
, t
);
57350 stack: function () {
57352 _variables
.push(_current
);
57355 unstack: function () {
57356 _checkBlockLabels();
57357 _variables
.splice(_variables
.length
- 1, 1);
57358 _current
= _
.last(_variables
);
57361 getlabel: function (l
) {
57362 for (var i
= _variables
.length
- 1 ; i
>= 0; --i
) {
57363 if (_
.has(_variables
[i
], l
) && !_variables
[i
][l
]["(shadowed)"]) {
57364 return _variables
[i
];
57369 shadow: function (name
) {
57370 for (var i
= _variables
.length
- 1; i
>= 0; i
--) {
57371 if (_
.has(_variables
[i
], name
)) {
57372 _variables
[i
][name
]["(shadowed)"] = true;
57377 unshadow: function (name
) {
57378 for (var i
= _variables
.length
- 1; i
>= 0; i
--) {
57379 if (_
.has(_variables
[i
], name
)) {
57380 _variables
[i
][name
]["(shadowed)"] = false;
57386 has: function (t
) {
57387 return _
.has(_current
, t
);
57390 add: function (t
, type
, tok
) {
57391 _current
[t
] = { "(type)" : type
, "(token)": tok
, "(shadowed)": false };
57397 // The actual JSHINT function itself.
57398 var itself = function (s
, o
, g
) {
57401 var newOptionObj
= {};
57402 var newIgnoredObj
= {};
57407 if (o
&& o
.scope
) {
57408 JSHINT
.scope
= o
.scope
;
57410 JSHINT
.errors
= [];
57411 JSHINT
.undefs
= [];
57412 JSHINT
.internals
= [];
57413 JSHINT
.blacklist
= {};
57414 JSHINT
.scope
= "(main)";
57417 predefined
= Object
.create(null);
57418 combine(predefined
, vars
.ecmaIdentifiers
);
57419 combine(predefined
, vars
.reservedVars
);
57421 combine(predefined
, g
|| {});
57423 declared
= Object
.create(null);
57424 exported
= Object
.create(null);
57426 function each(obj
, cb
) {
57430 if (!Array
.isArray(obj
) && typeof obj
=== "object")
57431 obj
= Object
.keys(obj
);
57437 each(o
.predef
|| null, function (item
) {
57440 if (item
[0] === "-") {
57441 slice
= item
.slice(1);
57442 JSHINT
.blacklist
[slice
] = slice
;
57444 prop
= Object
.getOwnPropertyDescriptor(o
.predef
, item
);
57445 predefined
[item
] = prop
? prop
.value
: false;
57449 each(o
.exported
|| null, function (item
) {
57450 exported
[item
] = true;
57456 optionKeys
= Object
.keys(o
);
57457 for (x
= 0; x
< optionKeys
.length
; x
++) {
57458 if (/^-W\d{3}$/g.test(optionKeys
[x
])) {
57459 newIgnoredObj
[optionKeys
[x
].slice(1)] = true;
57461 newOptionObj
[optionKeys
[x
]] = o
[optionKeys
[x
]];
57463 if (optionKeys
[x
] === "newcap" && o
[optionKeys
[x
]] === false)
57464 newOptionObj
["(explicitNewcap)"] = true;
57466 if (optionKeys
[x
] === "indent")
57467 newOptionObj
["(explicitIndent)"] = o
[optionKeys
[x
]] === false ? false : true;
57472 state
.option
= newOptionObj
;
57473 state
.ignored
= newIgnoredObj
;
57475 state
.option
.indent
= state
.option
.indent
|| 4;
57476 state
.option
.maxerr
= state
.option
.maxerr
|| 50;
57479 global
= Object
.create(predefined
);
57482 funct
= functor("(global)", null, scope
, {
57484 "(blockscope)": blockScope(),
57485 "(comparray)" : arrayComprehension(),
57486 "(metrics)" : createMetrics(state
.tokens
.next
)
57489 functions
= [funct
];
57493 membersOnly
= null;
57500 if (!isString(s
) && !Array
.isArray(s
)) {
57501 errorAt("E004", 0);
57507 return state
.jsonMode
;
57510 getOption: function (name
) {
57511 return state
.option
[name
] || null;
57514 getCache: function (name
) {
57515 return state
.cache
[name
];
57518 setCache: function (name
, value
) {
57519 state
.cache
[name
] = value
;
57522 warn: function (code
, data
) {
57523 warningAt
.apply(null, [ code
, data
.line
, data
.char ].concat(data
.data
));
57526 on: function (names
, listener
) {
57527 names
.split(" ").forEach(function (name
) {
57528 emitter
.on(name
, listener
);
57533 emitter
.removeAllListeners();
57534 (extraModules
|| []).forEach(function (func
) {
57538 state
.tokens
.prev
= state
.tokens
.curr
= state
.tokens
.next
= state
.syntax
["(begin)"];
57540 lex
= new Lexer(s
);
57542 lex
.on("warning", function (ev
) {
57543 warningAt
.apply(null, [ ev
.code
, ev
.line
, ev
.character
].concat(ev
.data
));
57546 lex
.on("error", function (ev
) {
57547 errorAt
.apply(null, [ ev
.code
, ev
.line
, ev
.character
].concat(ev
.data
));
57550 lex
.on("fatal", function (ev
) {
57551 quit("E041", ev
.line
, ev
.from);
57554 lex
.on("Identifier", function (ev
) {
57555 emitter
.emit("Identifier", ev
);
57558 lex
.on("String", function (ev
) {
57559 emitter
.emit("String", ev
);
57562 lex
.on("Number", function (ev
) {
57563 emitter
.emit("Number", ev
);
57569 for (var name
in o
) {
57570 if (_
.has(o
, name
)) {
57571 checkOption(name
, state
.tokens
.curr
);
57577 // combine the passed globals after we've assumed all our options
57578 combine(predefined
, g
|| {});
57581 comma
.first
= true;
57585 switch (state
.tokens
.next
.id
) {
57588 destructuringAssignOrJsonValue();
57593 if (state
.directive
["use strict"]) {
57594 if (!state
.option
.globalstrict
&& !(state
.option
.node
|| state
.option
.phantom
)) {
57595 warning("W097", state
.tokens
.prev
);
57601 advance((state
.tokens
.next
&& state
.tokens
.next
.value
!== ".") ? "(end)" : undefined);
57602 funct
["(blockscope)"].unstack();
57604 var markDefined = function (name
, context
) {
57606 if (typeof context
[name
] === "string") {
57607 // JSHINT marks unused variables as 'unused' and
57608 // unused function declaration as 'unction'. This
57609 // code changes such instances back 'var' and
57610 // 'closure' so that the code in JSHINT.data()
57611 // doesn't think they're unused.
57613 if (context
[name
] === "unused")
57614 context
[name
] = "var";
57615 else if (context
[name
] === "unction")
57616 context
[name
] = "closure";
57621 context
= context
["(context)"];
57627 var clearImplied = function (name
, line
) {
57628 if (!implied
[name
])
57631 var newImplied
= [];
57632 for (var i
= 0; i
< implied
[name
].length
; i
+= 1) {
57633 if (implied
[name
][i
] !== line
)
57634 newImplied
.push(implied
[name
][i
]);
57637 if (newImplied
.length
=== 0)
57638 delete implied
[name
];
57640 implied
[name
] = newImplied
;
57643 var warnUnused = function (name
, tkn
, type
, unused_opt
) {
57644 var line
= tkn
.line
;
57645 var chr
= tkn
.character
;
57647 if (unused_opt
=== undefined) {
57648 unused_opt
= state
.option
.unused
;
57651 if (unused_opt
=== true) {
57652 unused_opt
= "last-param";
57655 var warnable_types
= {
57657 "last-param": ["var", "param"],
57658 "strict": ["var", "param", "last-param"]
57662 if (warnable_types
[unused_opt
] && warnable_types
[unused_opt
].indexOf(type
) !== -1) {
57663 warningAt("W098", line
, chr
, name
);
57674 var checkUnused = function (func
, key
) {
57675 var type
= func
[key
];
57676 var tkn
= func
["(tokens)"][key
];
57678 if (key
.charAt(0) === "(")
57681 if (type
!== "unused" && type
!== "unction" && type
!== "const")
57684 // Params are checked separately from other variables.
57685 if (func
["(params)"] && func
["(params)"].indexOf(key
) !== -1)
57688 // Variable is in global scope and defined as exported.
57689 if (func
["(global)"] && _
.has(exported
, key
))
57692 // Is this constant unused?
57693 if (type
=== "const" && !getprop(func
, key
, "unused"))
57696 warnUnused(key
, tkn
, "var");
57699 // Check queued 'x is not defined' instances to see if they're still undefined.
57700 for (i
= 0; i
< JSHINT
.undefs
.length
; i
+= 1) {
57701 k
= JSHINT
.undefs
[i
].slice(0);
57703 if (markDefined(k
[2].value
, k
[0])) {
57704 clearImplied(k
[2].value
, k
[2].line
);
57705 } else if (state
.option
.undef
) {
57706 warning
.apply(warning
, k
.slice(1));
57710 functions
.forEach(function (func
) {
57711 if (func
["(unusedOption)"] === false) {
57715 for (var key
in func
) {
57716 if (_
.has(func
, key
)) {
57717 checkUnused(func
, key
);
57721 if (!func
["(params)"])
57724 var params
= func
["(params)"].slice();
57725 var param
= params
.pop();
57726 var type
, unused_opt
;
57729 type
= func
[param
];
57730 unused_opt
= func
["(unusedOption)"] || state
.option
.unused
;
57731 unused_opt
= unused_opt
=== true ? "last-param" : unused_opt
;
57733 // 'undefined' is a special case for (function (window, undefined) { ... })();
57736 if (param
=== "undefined")
57739 if (type
=== "unused" || type
=== "unction") {
57740 warnUnused(param
, func
["(tokens)"][param
], "param", func
["(unusedOption)"]);
57741 } else if (unused_opt
=== "last-param") {
57745 param
= params
.pop();
57749 for (var key
in declared
) {
57750 if (_
.has(declared
, key
) && !_
.has(global
, key
) && !_
.has(exported
, key
)) {
57751 warnUnused(key
, declared
[key
], "var");
57756 if (err
&& err
.name
=== "JSHintError") {
57757 var nt
= state
.tokens
.next
|| {};
57758 JSHINT
.errors
.push({
57762 reason
: err
.message
,
57763 line
: err
.line
|| nt
.line
,
57764 character
: err
.character
|| nt
.from
57771 // Loop over the listed "internals", and check them as well.
57773 if (JSHINT
.scope
=== "(main)") {
57776 for (i
= 0; i
< JSHINT
.internals
.length
; i
+= 1) {
57777 k
= JSHINT
.internals
[i
];
57779 itself(k
.value
, o
, g
);
57783 return JSHINT
.errors
.length
=== 0;
57787 itself
.addModule = function (func
) {
57788 extraModules
.push(func
);
57791 itself
.addModule(style
.register
);
57794 itself
.data = function () {
57797 options
: state
.option
57802 var fu
, f
, i
, j
, n
, globals
;
57804 if (itself
.errors
.length
) {
57805 data
.errors
= itself
.errors
;
57808 if (state
.jsonMode
) {
57812 for (n
in implied
) {
57813 if (_
.has(implied
, n
)) {
57821 if (implieds
.length
> 0) {
57822 data
.implieds
= implieds
;
57825 if (urls
.length
> 0) {
57829 globals
= Object
.keys(scope
);
57830 if (globals
.length
> 0) {
57831 data
.globals
= globals
;
57834 for (i
= 1; i
< functions
.length
; i
+= 1) {
57838 for (j
= 0; j
< functionicity
.length
; j
+= 1) {
57839 fu
[functionicity
[j
]] = [];
57842 for (j
= 0; j
< functionicity
.length
; j
+= 1) {
57843 if (fu
[functionicity
[j
]].length
=== 0) {
57844 delete fu
[functionicity
[j
]];
57848 fu
.name
= f
["(name)"];
57849 fu
.param
= f
["(params)"];
57850 fu
.line
= f
["(line)"];
57851 fu
.character
= f
["(character)"];
57852 fu
.last
= f
["(last)"];
57853 fu
.lastcharacter
= f
["(lastcharacter)"];
57856 complexity
: f
["(metrics)"].ComplexityCount
,
57857 parameters
: (f
["(params)"] || []).length
,
57858 statements
: f
["(metrics)"].statementCount
57861 data
.functions
.push(fu
);
57864 if (unuseds
.length
> 0) {
57865 data
.unused
= unuseds
;
57869 for (n
in member
) {
57870 if (typeof member
[n
] === "number") {
57871 data
.member
= member
;
57879 itself
.jshint
= itself
;
57884 // Make JSHINT a Node module, if possible.
57885 if (typeof exports
=== "object" && exports
) {
57886 exports
.JSHINT
= JSHINT
;
57889 },{"./lex.js":14,"./messages.js":15,"./reg.js":16,"./state.js":17,"./style.js":18,"./vars.js":19,"console-browserify":10,"events":5,"underscore":11}],14:[function(require
,module
,exports
){
57891 * Lexical analysis and token construction.
57896 var _
= require("underscore");
57897 var events
= require("events");
57898 var reg
= require("./reg.js");
57899 var state
= require("./state.js").state
;
57901 var unicodeData
= require("../data/ascii-identifier-data.js");
57902 var asciiIdentifierStartTable
= unicodeData
.asciiIdentifierStartTable
;
57903 var asciiIdentifierPartTable
= unicodeData
.asciiIdentifierPartTable
;
57904 var nonAsciiIdentifierStartTable
= require("../data/non-ascii-identifier-start.js");
57905 var nonAsciiIdentifierPartTable
= require("../data/non-ascii-identifier-part-only.js");
57907 // Some of these token types are from JavaScript Parser API
57908 // while others are specific to JSHint parser.
57909 // JS Parser API: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
57923 // Object that handles postponed lexing verifications that checks the parsed
57924 // environment state.
57926 function asyncTrigger() {
57930 push: function (fn
) {
57934 check: function () {
57935 for (var check
= 0; check
< _checks
.length
; ++check
) {
57939 _checks
.splice(0, _checks
.length
);
57945 * Lexer for JSHint.
57947 * This object does a char-by-char scan of the provided source code
57948 * and produces a sequence of tokens.
57950 * var lex = new Lexer("var i = 0;");
57952 * lex.token(); // returns the next token
57954 * You have to use the token() method to move the lexer forward
57955 * but you don't have to use its return value to get tokens. In addition
57956 * to token() method returning the next token, the Lexer object also
57959 * lex.on("Identifier", function (data) {
57960 * if (data.name.indexOf("_") >= 0) {
57961 * // Produce a warning.
57965 * Note that the token() method returns tokens in a JSLint-compatible
57966 * format while the event emitter uses a slightly modified version of
57967 * Mozilla's JavaScript Parser API. Eventually, we will move away from
57970 function Lexer(source
) {
57971 var lines
= source
;
57973 if (typeof lines
=== "string") {
57975 .replace(/\r\n/g, "\n")
57976 .replace(/\r/g, "\n")
57980 // If the first line is a shebang (#!), make it a blank and move on.
57981 // Shebangs are used by Node scripts.
57983 if (lines
[0] && lines
[0].substr(0, 2) === "#!") {
57984 if (lines
[0].indexOf("node") !== -1) {
57985 state
.option
.node
= true;
57990 this.emitter
= new events
.EventEmitter();
57991 this.source
= source
;
57992 this.setLines(lines
);
57993 this.prereg
= true;
57999 this.inComment
= false;
58001 for (var i
= 0; i
< state
.option
.indent
; i
+= 1) {
58006 Lexer
.prototype = {
58009 getLines: function () {
58010 this._lines
= state
.lines
;
58011 return this._lines
;
58014 setLines: function (val
) {
58016 state
.lines
= this._lines
;
58020 * Return the next i character without actually moving the
58023 peek: function (i
) {
58024 return this.input
.charAt(i
|| 0);
58028 * Move the char pointer forward i times.
58030 skip: function (i
) {
58033 this.input
= this.input
.slice(i
);
58037 * Subscribe to a token event. The API for this method is similar
58038 * Underscore.js i.e. you can subscribe to multiple events with
58041 * lex.on("Identifier Number", function (data) {
58045 on: function (names
, listener
) {
58046 names
.split(" ").forEach(function (name
) {
58047 this.emitter
.on(name
, listener
);
58052 * Trigger a token event. All arguments will be passed to each
58055 trigger: function () {
58056 this.emitter
.emit
.apply(this.emitter
, Array
.prototype.slice
.call(arguments
));
58060 * Postpone a token event. the checking condition is set as
58061 * last parameter, and the trigger function is called in a
58062 * stored callback. To be later called using the check() function
58063 * by the parser. This avoids parser's peek() to give the lexer
58066 triggerAsync: function (type
, args
, checks
, fn
) {
58067 checks
.push(function () {
58069 this.trigger(type
, args
);
58075 * Extract a punctuator out of the next sequence of characters
58076 * or return 'null' if its not possible.
58078 * This method's implementation was heavily influenced by the
58079 * scanPunctuator function in the Esprima parser's source code.
58081 scanPunctuator: function () {
58082 var ch1
= this.peek();
58086 // Most common single-character punctuators
58088 if ((/^[0-9]$/).test(this.peek(1))) {
58091 if (this.peek(1) === "." && this.peek(2) === ".") {
58093 type
: Token
.Punctuator
,
58097 /* falls through */
58110 type
: Token
.Punctuator
,
58114 // A pound sign (for Node shebangs)
58117 type
: Token
.Punctuator
,
58121 // We're at the end of input
58126 // Peek more characters
58128 ch2
= this.peek(1);
58129 ch3
= this.peek(2);
58130 ch4
= this.peek(3);
58132 // 4-character punctuator: >>>=
58134 if (ch1
=== ">" && ch2
=== ">" && ch3
=== ">" && ch4
=== "=") {
58136 type
: Token
.Punctuator
,
58141 // 3-character punctuators: === !== >>> <<= >>=
58143 if (ch1
=== "=" && ch2
=== "=" && ch3
=== "=") {
58145 type
: Token
.Punctuator
,
58150 if (ch1
=== "!" && ch2
=== "=" && ch3
=== "=") {
58152 type
: Token
.Punctuator
,
58157 if (ch1
=== ">" && ch2
=== ">" && ch3
=== ">") {
58159 type
: Token
.Punctuator
,
58164 if (ch1
=== "<" && ch2
=== "<" && ch3
=== "=") {
58166 type
: Token
.Punctuator
,
58171 if (ch1
=== ">" && ch2
=== ">" && ch3
=== "=") {
58173 type
: Token
.Punctuator
,
58178 // Fat arrow punctuator
58179 if (ch1
=== "=" && ch2
=== ">") {
58181 type
: Token
.Punctuator
,
58186 // 2-character punctuators: <= >= == != ++ -- << >> && ||
58187 // += -= *= %= &= |= ^= (but not /=, see below)
58188 if (ch1
=== ch2
&& ("+-<>&|".indexOf(ch1
) >= 0)) {
58190 type
: Token
.Punctuator
,
58195 if ("<>=!+-*%&|^".indexOf(ch1
) >= 0) {
58198 type
: Token
.Punctuator
,
58204 type
: Token
.Punctuator
,
58209 // Special case: /=. We need to make sure that this is an
58210 // operator and not a regular expression.
58213 if (ch2
=== "=" && /\/=(?!(\S*\/[gim]?))/.test(this.input
)) {
58214 // /= is not a part of a regular expression, return it as a
58217 type
: Token
.Punctuator
,
58223 type
: Token
.Punctuator
,
58232 * Extract a comment out of the next sequence of characters and/or
58233 * lines or return 'null' if its not possible. Since comments can
58234 * span across multiple lines this method has to move the char
58237 * In addition to normal JavaScript comments (// and /*) this method
58238 * also recognizes JSHint- and JSLint-specific comments such as
58239 * /*jshint, /*jslint, /*globals and so on.
58241 scanComments: function () {
58242 var ch1
= this.peek();
58243 var ch2
= this.peek(1);
58244 var rest
= this.input
.substr(2);
58245 var startLine
= this.line
;
58246 var startChar
= this.char;
58248 // Create a comment token object and make sure it
58249 // has all the data JSHint needs to work with special
58252 function commentToken(label
, body
, opt
) {
58253 var special
= ["jshint", "jslint", "members", "member", "globals", "global", "exported"];
58254 var isSpecial
= false;
58255 var value
= label
+ body
;
58256 var commentType
= "plain";
58259 if (opt
.isMultiline
) {
58263 special
.forEach(function (str
) {
58268 // Don't recognize any special comments other than jshint for single-line
58269 // comments. This introduced many problems with legit comments.
58270 if (label
=== "//" && str
!== "jshint") {
58274 if (body
.substr(0, str
.length
) === str
) {
58276 label
= label
+ str
;
58277 body
= body
.substr(str
.length
);
58280 if (!isSpecial
&& body
.charAt(0) === " " && body
.substr(1, str
.length
) === str
) {
58282 label
= label
+ " " + str
;
58283 body
= body
.substr(str
.length
+ 1);
58292 commentType
= "members";
58295 commentType
= "globals";
58303 type
: Token
.Comment
,
58304 commentType
: commentType
,
58307 isSpecial
: isSpecial
,
58308 isMultiline
: opt
.isMultiline
|| false,
58309 isMalformed
: opt
.isMalformed
|| false
58313 // End of unbegun comment. Raise an error and skip that input.
58314 if (ch1
=== "*" && ch2
=== "/") {
58315 this.trigger("error", {
58318 character
: startChar
58325 // Comments must start either with // or /*
58326 if (ch1
!== "/" || (ch2
!== "*" && ch2
!== "/")) {
58330 // One-line comment
58332 this.skip(this.input
.length
); // Skip to the EOL.
58333 return commentToken("//", rest
);
58338 /* Multi-line comment */
58340 this.inComment
= true;
58343 while (this.peek() !== "*" || this.peek(1) !== "/") {
58344 if (this.peek() === "") { // End of Line
58347 // If we hit EOF and our comment is still unclosed,
58348 // trigger an error and end the comment implicitly.
58349 if (!this.nextLine()) {
58350 this.trigger("error", {
58353 character
: startChar
58356 this.inComment
= false;
58357 return commentToken("/*", body
, {
58363 body
+= this.peek();
58369 this.inComment
= false;
58370 return commentToken("/*", body
, { isMultiline
: true });
58375 * Extract a keyword out of the next sequence of characters or
58376 * return 'null' if its not possible.
58378 scanKeyword: function () {
58379 var result
= /^[a-zA-Z_$][a-zA-Z0-9_$]*/.exec(this.input
);
58381 "if", "in", "do", "var", "for", "new",
58382 "try", "let", "this", "else", "case",
58383 "void", "with", "enum", "while", "break",
58384 "catch", "throw", "const", "yield", "class",
58385 "super", "return", "typeof", "delete",
58386 "switch", "export", "import", "default",
58387 "finally", "extends", "function", "continue",
58388 "debugger", "instanceof"
58391 if (result
&& keywords
.indexOf(result
[0]) >= 0) {
58393 type
: Token
.Keyword
,
58402 * Extract a JavaScript identifier out of the next sequence of
58403 * characters or return 'null' if its not possible. In addition,
58404 * to Identifier this method can also produce BooleanLiteral
58405 * (true/false) and NullLiteral (null).
58407 scanIdentifier: function () {
58412 function isNonAsciiIdentifierStart(code
) {
58413 return nonAsciiIdentifierStartTable
.indexOf(code
) > -1;
58416 function isNonAsciiIdentifierPart(code
) {
58417 return isNonAsciiIdentifierStart(code
) || nonAsciiIdentifierPartTable
.indexOf(code
) > -1;
58420 function isHexDigit(str
) {
58421 return (/^[0-9a-fA-F]$/).test(str
);
58424 var readUnicodeEscapeSequence = function () {
58425 /*jshint validthis:true */
58428 if (this.peek(index
) !== "u") {
58432 var ch1
= this.peek(index
+ 1);
58433 var ch2
= this.peek(index
+ 2);
58434 var ch3
= this.peek(index
+ 3);
58435 var ch4
= this.peek(index
+ 4);
58438 if (isHexDigit(ch1
) && isHexDigit(ch2
) && isHexDigit(ch3
) && isHexDigit(ch4
)) {
58439 code
= parseInt(ch1
+ ch2
+ ch3
+ ch4
, 16);
58441 if (asciiIdentifierPartTable
[code
] || isNonAsciiIdentifierPart(code
)) {
58443 return "\\u" + ch1
+ ch2
+ ch3
+ ch4
;
58452 var getIdentifierStart = function () {
58453 /*jshint validthis:true */
58454 var chr
= this.peek(index
);
58455 var code
= chr
.charCodeAt(0);
58458 return readUnicodeEscapeSequence();
58462 if (asciiIdentifierStartTable
[code
]) {
58470 if (isNonAsciiIdentifierStart(code
)) {
58478 var getIdentifierPart = function () {
58479 /*jshint validthis:true */
58480 var chr
= this.peek(index
);
58481 var code
= chr
.charCodeAt(0);
58484 return readUnicodeEscapeSequence();
58488 if (asciiIdentifierPartTable
[code
]) {
58496 if (isNonAsciiIdentifierPart(code
)) {
58504 char = getIdentifierStart();
58505 if (char === null) {
58511 char = getIdentifierPart();
58513 if (char === null) {
58523 type
= Token
.BooleanLiteral
;
58526 type
= Token
.NullLiteral
;
58529 type
= Token
.Identifier
;
58539 * Extract a numeric literal out of the next sequence of
58540 * characters or return 'null' if its not possible. This method
58541 * supports all numeric literals described in section 7.8.3
58542 * of the EcmaScript 5 specification.
58544 * This method's implementation was heavily influenced by the
58545 * scanNumericLiteral function in the Esprima parser's source code.
58547 scanNumericLiteral: function () {
58550 var length
= this.input
.length
;
58551 var char = this.peek(index
);
58554 function isDecimalDigit(str
) {
58555 return (/^[0-9]$/).test(str
);
58558 function isOctalDigit(str
) {
58559 return (/^[0-7]$/).test(str
);
58562 function isHexDigit(str
) {
58563 return (/^[0-9a-fA-F]$/).test(str
);
58566 function isIdentifierStart(ch
) {
58567 return (ch
=== "$") || (ch
=== "_") || (ch
=== "\\") ||
58568 (ch
>= "a" && ch
<= "z") || (ch
>= "A" && ch
<= "Z");
58571 // Numbers must start either with a decimal digit or a point.
58573 if (char !== "." && !isDecimalDigit(char)) {
58577 if (char !== ".") {
58578 value
= this.peek(index
);
58580 char = this.peek(index
);
58582 if (value
=== "0") {
58583 // Base-16 numbers.
58584 if (char === "x" || char === "X") {
58588 while (index
< length
) {
58589 char = this.peek(index
);
58590 if (!isHexDigit(char)) {
58597 if (value
.length
<= 2) { // 0x
58599 type
: Token
.NumericLiteral
,
58605 if (index
< length
) {
58606 char = this.peek(index
);
58607 if (isIdentifierStart(char)) {
58613 type
: Token
.NumericLiteral
,
58621 if (isOctalDigit(char)) {
58626 while (index
< length
) {
58627 char = this.peek(index
);
58629 // Numbers like '019' (note the 9) are not valid octals
58630 // but we still parse them and mark as malformed.
58632 if (isDecimalDigit(char)) {
58634 } else if (!isOctalDigit(char)) {
58641 if (index
< length
) {
58642 char = this.peek(index
);
58643 if (isIdentifierStart(char)) {
58649 type
: Token
.NumericLiteral
,
58656 // Decimal numbers that start with '0' such as '09' are illegal
58657 // but we still parse them and return as malformed.
58659 if (isDecimalDigit(char)) {
58665 while (index
< length
) {
58666 char = this.peek(index
);
58667 if (!isDecimalDigit(char)) {
58677 if (char === ".") {
58681 while (index
< length
) {
58682 char = this.peek(index
);
58683 if (!isDecimalDigit(char)) {
58693 if (char === "e" || char === "E") {
58696 char = this.peek(index
);
58698 if (char === "+" || char === "-") {
58699 value
+= this.peek(index
);
58703 char = this.peek(index
);
58704 if (isDecimalDigit(char)) {
58708 while (index
< length
) {
58709 char = this.peek(index
);
58710 if (!isDecimalDigit(char)) {
58721 if (index
< length
) {
58722 char = this.peek(index
);
58723 if (isIdentifierStart(char)) {
58729 type
: Token
.NumericLiteral
,
58732 isMalformed
: !isFinite(value
)
58737 * Extract a string out of the next sequence of characters and/or
58738 * lines or return 'null' if its not possible. Since strings can
58739 * span across multiple lines this method has to move the char
58742 * This method recognizes pseudo-multiline JavaScript strings:
58744 * var str = "hello\
58747 scanStringLiteral: function (checks
) {
58748 /*jshint loopfunc:true */
58749 var quote
= this.peek();
58751 // String must start with a quote.
58752 if (quote
!== "\"" && quote
!== "'") {
58756 // In JSON strings must always use double quotes.
58757 this.triggerAsync("warning", {
58760 character
: this.char // +1?
58761 }, checks
, function () { return state
.jsonMode
&& quote
!== "\""; });
58764 var startLine
= this.line
;
58765 var startChar
= this.char;
58766 var allowNewLine
= false;
58770 while (this.peek() !== quote
) {
58771 while (this.peek() === "") { // End Of Line
58773 // If an EOL is not preceded by a backslash, show a warning
58774 // and proceed like it was a legit multi-line string where
58775 // author simply forgot to escape the newline symbol.
58777 // Another approach is to implicitly close a string on EOL
58778 // but it generates too many false positives.
58780 if (!allowNewLine
) {
58781 this.trigger("warning", {
58784 character
: this.char
58787 allowNewLine
= false;
58789 // Otherwise show a warning if multistr option was not set.
58790 // For JSON, show warning no matter what.
58792 this.triggerAsync("warning", {
58795 character
: this.char
58796 }, checks
, function () { return !state
.option
.multistr
; });
58798 this.triggerAsync("warning", {
58801 character
: this.char
58802 }, checks
, function () { return state
.jsonMode
&& state
.option
.multistr
; });
58805 // If we get an EOF inside of an unclosed string, show an
58806 // error and implicitly close it at the EOF point.
58808 if (!this.nextLine()) {
58809 this.trigger("error", {
58812 character
: startChar
58816 type
: Token
.StringLiteral
,
58824 allowNewLine
= false;
58825 var char = this.peek();
58826 var jump
= 1; // A length of a jump, after we're done
58827 // parsing this character.
58830 // Warn about a control character in a string.
58831 this.trigger("warning", {
58834 character
: this.char,
58835 data
: [ "<non-printable>" ]
58839 // Special treatment for some escaped characters.
58841 if (char === "\\") {
58843 char = this.peek();
58847 this.triggerAsync("warning", {
58850 character
: this.char,
58852 }, checks
, function () {return state
.jsonMode
; });
58872 // Octal literals fail in strict mode.
58873 // Check if the number is between 00 and 07.
58874 var n
= parseInt(this.peek(1), 10);
58875 this.triggerAsync("warning", {
58878 character
: this.char
58880 function () { return n
>= 0 && n
<= 7 && state
.directive
["use strict"]; });
58883 char = String
.fromCharCode(parseInt(this.input
.substr(1, 4), 16));
58887 this.triggerAsync("warning", {
58890 character
: this.char,
58892 }, checks
, function () { return state
.jsonMode
; });
58897 var x
= parseInt(this.input
.substr(1, 2), 16);
58899 this.triggerAsync("warning", {
58902 character
: this.char,
58904 }, checks
, function () { return state
.jsonMode
; });
58906 char = String
.fromCharCode(x
);
58918 allowNewLine
= true;
58922 if (value
.slice(value
.length
- 2) === "<") {
58929 this.trigger("warning", {
58932 character
: this.char
58943 type
: Token
.StringLiteral
,
58951 * Extract a regular expression out of the next sequence of
58952 * characters and/or lines or return 'null' if its not possible.
58954 * This method is platform dependent: it accepts almost any
58955 * regular expression values but then tries to compile and run
58956 * them using system's RegExp object. This means that there are
58957 * rare edge cases where one JavaScript engine complains about
58958 * your regular expression while others don't.
58960 scanRegExp: function () {
58962 var length
= this.input
.length
;
58963 var char = this.peek();
58967 var malformed
= false;
58968 var isCharSet
= false;
58971 var scanUnexpectedChars = function () {
58972 // Unexpected control character
58975 this.trigger("warning", {
58978 character
: this.char
58982 // Unexpected escaped character
58983 if (char === "<") {
58985 this.trigger("warning", {
58988 character
: this.char,
58994 // Regular expressions must start with '/'
58995 if (!this.prereg
|| char !== "/") {
59000 terminated
= false;
59002 // Try to get everything in between slashes. A couple of
59003 // cases aside (see scanUnexpectedChars) we don't really
59004 // care whether the resulting expression is valid or not.
59005 // We will check that later using the RegExp object.
59007 while (index
< length
) {
59008 char = this.peek(index
);
59013 if (char === "]") {
59014 if (this.peek(index
- 1) !== "\\" || this.peek(index
- 2) === "\\") {
59019 if (char === "\\") {
59021 char = this.peek(index
);
59025 scanUnexpectedChars();
59032 if (char === "\\") {
59034 char = this.peek(index
);
59038 scanUnexpectedChars();
59040 if (char === "/") {
59045 if (char === "[") {
59051 if (char === "[") {
59057 if (char === "/") {
59058 body
= body
.substr(0, body
.length
- 1);
59067 // A regular expression that was never closed is an
59068 // error from which we cannot recover.
59071 this.trigger("error", {
59074 character
: this.from
59077 return void this.trigger("fatal", {
59083 // Parse flags (if any).
59085 while (index
< length
) {
59086 char = this.peek(index
);
59087 if (!/[gim]/.test(char)) {
59095 // Check regular expression for correctness.
59098 new RegExp(body
, flags
.join(""));
59101 this.trigger("error", {
59104 character
: this.char,
59105 data
: [ err
.message
] // Platform dependent!
59110 type
: Token
.RegExp
,
59113 isMalformed
: malformed
59118 * Scan for any occurrence of mixed tabs and spaces. If smarttabs option
59119 * is on, ignore tabs followed by spaces.
59121 * Tabs followed by one space followed by a block comment are allowed.
59123 scanMixedSpacesAndTabs: function () {
59126 if (state
.option
.smarttabs
) {
59127 // Negative look-behind for "//"
59128 match
= this.input
.match(/(\/\/|^\s?\*)? \t/);
59129 at
= match
&& !match
[1] ? 0 : -1;
59131 at
= this.input
.search(/ \t|\t [^\*]/);
59138 * Scan for any occurrence of non-breaking spaces. Non-breaking spaces
59139 * can be mistakenly typed on OS X with option-space. Non UTF-8 web
59140 * pages with non-breaking pages produce syntax errors.
59142 scanNonBreakingSpaces: function () {
59143 return state
.option
.nonbsp
?
59144 this.input
.search(/(\u00A0)/) : -1;
59148 * Scan for characters that get silently deleted by one or more browsers.
59150 scanUnsafeChars: function () {
59151 return this.input
.search(reg
.unsafeChars
);
59155 * Produce the next raw token or return 'null' if no tokens can be matched.
59156 * This method skips over all space characters.
59158 next: function (checks
) {
59159 this.from = this.char;
59161 // Move to the next non-space character.
59163 if (/\s/.test(this.peek())) {
59166 while (/\s/.test(this.peek())) {
59171 if (this.peek() === "") { // EOL
59172 if (!/^\s*$/.test(this.getLines()[this.line
- 1]) && state
.option
.trailing
) {
59173 this.trigger("warning", { code
: "W102", line
: this.line
, character
: start
});
59178 // Methods that work with multi-line structures and move the
59179 // character pointer.
59181 var match
= this.scanComments() ||
59182 this.scanStringLiteral(checks
);
59188 // Methods that don't move the character pointer.
59191 this.scanRegExp() ||
59192 this.scanPunctuator() ||
59193 this.scanKeyword() ||
59194 this.scanIdentifier() ||
59195 this.scanNumericLiteral();
59198 this.skip(match
.value
.length
);
59202 // No token could be matched, give up.
59208 * Switch to the next line and reset all char pointers. Once
59209 * switched, this method also checks for mixed spaces and tabs
59210 * and other minor warnings.
59212 nextLine: function () {
59215 if (this.line
>= this.getLines().length
) {
59219 this.input
= this.getLines()[this.line
];
59224 var inputTrimmed
= this.input
.trim();
59226 var startsWith = function () {
59227 return _
.some(arguments
, function (prefix
) {
59228 return inputTrimmed
.indexOf(prefix
) === 0;
59232 var endsWith = function () {
59233 return _
.some(arguments
, function (suffix
) {
59234 return inputTrimmed
.indexOf(suffix
, inputTrimmed
.length
- suffix
.length
) !== -1;
59238 // If we are ignoring linter errors, replace the input with empty string
59239 // if it doesn't already at least start or end a multi-line comment
59240 if (state
.ignoreLinterErrors
=== true) {
59241 if (!startsWith("/*", "//") && !endsWith("*/")) {
59246 char = this.scanNonBreakingSpaces();
59248 this.trigger("warning", { code
: "W125", line
: this.line
, character
: char + 1 });
59251 char = this.scanMixedSpacesAndTabs();
59253 this.trigger("warning", { code
: "W099", line
: this.line
, character
: char + 1 });
59256 this.input
= this.input
.replace(/\t/g, state
.tab
);
59257 char = this.scanUnsafeChars();
59260 this.trigger("warning", { code
: "W100", line
: this.line
, character
: char });
59263 // If there is a limit on line length, warn when lines get too
59266 if (state
.option
.maxlen
&& state
.option
.maxlen
< this.input
.length
) {
59267 var inComment
= this.inComment
||
59268 startsWith
.call(inputTrimmed
, "//") ||
59269 startsWith
.call(inputTrimmed
, "/*");
59271 var shouldTriggerError
= !inComment
|| !reg
.maxlenException
.test(inputTrimmed
);
59273 if (shouldTriggerError
) {
59274 this.trigger("warning", { code
: "W101", line
: this.line
, character
: this.input
.length
});
59282 * This is simply a synonym for nextLine() method with a friendlier
59285 start: function () {
59290 * Produce the next token. This function is called by advance() to get
59291 * the next token. It returns a token in a JSLint-compatible format.
59293 token: function () {
59294 /*jshint loopfunc:true */
59295 var checks
= asyncTrigger();
59299 function isReserved(token
, isProperty
) {
59300 if (!token
.reserved
) {
59303 var meta
= token
.meta
;
59305 if (meta
&& meta
.isFutureReservedWord
&& state
.option
.inES5()) {
59306 // ES3 FutureReservedWord in an ES5 environment.
59311 // Some ES5 FutureReservedWord identifiers are active only
59312 // within a strict mode environment.
59313 if (meta
.strictOnly
) {
59314 if (!state
.option
.strict
&& !state
.directive
["use strict"]) {
59327 // Produce a token object.
59328 var create = function (type
, value
, isProperty
) {
59329 /*jshint validthis:true */
59332 if (type
!== "(endline)" && type
!== "(end)") {
59333 this.prereg
= false;
59336 if (type
=== "(punctuator)") {
59343 this.prereg
= false;
59346 this.prereg
= true;
59349 obj
= Object
.create(state
.syntax
[value
] || state
.syntax
["(error)"]);
59352 if (type
=== "(identifier)") {
59353 if (value
=== "return" || value
=== "case" || value
=== "typeof") {
59354 this.prereg
= true;
59357 if (_
.has(state
.syntax
, value
)) {
59358 obj
= Object
.create(state
.syntax
[value
] || state
.syntax
["(error)"]);
59360 // If this can't be a reserved keyword, reset the object.
59361 if (!isReserved(obj
, isProperty
&& type
=== "(identifier)")) {
59368 obj
= Object
.create(state
.syntax
[type
]);
59371 obj
.identifier
= (type
=== "(identifier)");
59372 obj
.type
= obj
.type
|| type
;
59374 obj
.line
= this.line
;
59375 obj
.character
= this.char;
59376 obj
.from = this.from;
59378 if (isProperty
&& obj
.identifier
) {
59379 obj
.isProperty
= isProperty
;
59382 obj
.check
= checks
.check
;
59388 if (!this.input
.length
) {
59389 return create(this.nextLine() ? "(endline)" : "(end)", "");
59392 token
= this.next(checks
);
59395 if (this.input
.length
) {
59396 // Unexpected character.
59397 this.trigger("error", {
59400 character
: this.char,
59401 data
: [ this.peek() ]
59410 switch (token
.type
) {
59411 case Token
.StringLiteral
:
59412 this.triggerAsync("String", {
59416 value
: token
.value
,
59418 }, checks
, function () { return true; });
59420 return create("(string)", token
.value
);
59421 case Token
.Identifier
:
59422 this.trigger("Identifier", {
59427 isProperty
: state
.tokens
.curr
.id
=== "."
59430 /* falls through */
59431 case Token
.Keyword
:
59432 case Token
.NullLiteral
:
59433 case Token
.BooleanLiteral
:
59434 return create("(identifier)", token
.value
, state
.tokens
.curr
.id
=== ".");
59436 case Token
.NumericLiteral
:
59437 if (token
.isMalformed
) {
59438 this.trigger("warning", {
59441 character
: this.char,
59442 data
: [ token
.value
]
59446 this.triggerAsync("warning", {
59449 character
: this.char,
59451 }, checks
, function () { return token
.base
=== 16 && state
.jsonMode
; });
59453 this.triggerAsync("warning", {
59456 character
: this.char
59457 }, checks
, function () {
59458 return state
.directive
["use strict"] && token
.base
=== 8;
59461 this.trigger("Number", {
59465 value
: token
.value
,
59467 isMalformed
: token
.malformed
59470 return create("(number)", token
.value
);
59473 return create("(regexp)", token
.value
);
59475 case Token
.Comment
:
59476 state
.tokens
.curr
.comment
= true;
59478 if (token
.isSpecial
) {
59481 value
: token
.value
,
59483 type
: token
.commentType
,
59484 isSpecial
: token
.isSpecial
,
59486 character
: this.char,
59497 return create("(punctuator)", token
.value
);
59503 exports
.Lexer
= Lexer
;
59505 },{"../data/ascii-identifier-data.js":1,"../data/non-ascii-identifier-part-only.js":2,"../data/non-ascii-identifier-start.js":3,"./reg.js":16,"./state.js":17,"events":5,"underscore":11}],15:[function(require
,module
,exports
){
59508 var _
= require("underscore");
59512 E001
: "Bad option: '{a}'.",
59513 E002
: "Bad option value.",
59516 E003
: "Expected a JSON value.",
59517 E004
: "Input is neither a string nor an array of strings.",
59518 E005
: "Input is empty.",
59519 E006
: "Unexpected early end of program.",
59522 E007
: "Missing \"use strict\" statement.",
59523 E008
: "Strict violation.",
59524 E009
: "Option 'validthis' can't be used in a global scope.",
59525 E010
: "'with' is not allowed in strict mode.",
59528 E011
: "const '{a}' has already been declared.",
59529 E012
: "const '{a}' is initialized to 'undefined'.",
59530 E013
: "Attempting to override '{a}' which is a constant.",
59532 // Regular expressions
59533 E014
: "A regular expression literal can be confused with '/='.",
59534 E015
: "Unclosed regular expression.",
59535 E016
: "Invalid regular expression.",
59538 E017
: "Unclosed comment.",
59539 E018
: "Unbegun comment.",
59540 E019
: "Unmatched '{a}'.",
59541 E020
: "Expected '{a}' to match '{b}' from line {c} and instead saw '{d}'.",
59542 E021
: "Expected '{a}' and instead saw '{b}'.",
59543 E022
: "Line breaking error '{a}'.",
59544 E023
: "Missing '{a}'.",
59545 E024
: "Unexpected '{a}'.",
59546 E025
: "Missing ':' on a case clause.",
59547 E026
: "Missing '}' to match '{' from line {a}.",
59548 E027
: "Missing ']' to match '[' from line {a}.",
59549 E028
: "Illegal comma.",
59550 E029
: "Unclosed string.",
59553 E030
: "Expected an identifier and instead saw '{a}'.",
59554 E031
: "Bad assignment.", // FIXME: Rephrase
59555 E032
: "Expected a small integer or 'false' and instead saw '{a}'.",
59556 E033
: "Expected an operator and instead saw '{a}'.",
59557 E034
: "get/set are ES5 features.",
59558 E035
: "Missing property name.",
59559 E036
: "Expected to see a statement and instead saw a block.",
59562 E039
: "Function declarations are not invocable. Wrap the whole function invocation in parens.",
59563 E040
: "Each value should have its own case label.",
59564 E041
: "Unrecoverable syntax error.",
59566 E043
: "Too many errors.",
59568 E045
: "Invalid for each loop.",
59569 E046
: "A yield statement shall be within a generator function (with syntax: `function*`)",
59570 E047
: null, // Vacant
59571 E048
: "Let declaration not directly within block.",
59572 E049
: "A {a} cannot be named '{b}'.",
59573 E050
: "Mozilla requires the yield expression to be parenthesized here.",
59574 E051
: "Regular parameters cannot come after default parameters."
59578 W001
: "'hasOwnProperty' is a really bad name.",
59579 W002
: "Value of '{a}' may be overwritten in IE 8 and earlier.",
59580 W003
: "'{a}' was used before it was defined.",
59581 W004
: "'{a}' is already defined.",
59582 W005
: "A dot following a number can be confused with a decimal point.",
59583 W006
: "Confusing minuses.",
59584 W007
: "Confusing pluses.",
59585 W008
: "A leading decimal point can be confused with a dot: '{a}'.",
59586 W009
: "The array literal notation [] is preferable.",
59587 W010
: "The object literal notation {} is preferable.",
59588 W011
: "Unexpected space after '{a}'.",
59589 W012
: "Unexpected space before '{a}'.",
59590 W013
: "Missing space after '{a}'.",
59591 W014
: "Bad line breaking before '{a}'.",
59592 W015
: "Expected '{a}' to have an indentation at {b} instead at {c}.",
59593 W016
: "Unexpected use of '{a}'.",
59594 W017
: "Bad operand.",
59595 W018
: "Confusing use of '{a}'.",
59596 W019
: "Use the isNaN function to compare with NaN.",
59597 W020
: "Read only.",
59598 W021
: "'{a}' is a function.",
59599 W022
: "Do not assign to the exception parameter.",
59600 W023
: "Expected an identifier in an assignment and instead saw a function invocation.",
59601 W024
: "Expected an identifier and instead saw '{a}' (a reserved word).",
59602 W025
: "Missing name in function declaration.",
59603 W026
: "Inner functions should be listed at the top of the outer function.",
59604 W027
: "Unreachable '{a}' after '{b}'.",
59605 W028
: "Label '{a}' on {b} statement.",
59606 W030
: "Expected an assignment or function call and instead saw an expression.",
59607 W031
: "Do not use 'new' for side effects.",
59608 W032
: "Unnecessary semicolon.",
59609 W033
: "Missing semicolon.",
59610 W034
: "Unnecessary directive \"{a}\".",
59611 W035
: "Empty block.",
59612 W036
: "Unexpected /*member '{a}'.",
59613 W037
: "'{a}' is a statement label.",
59614 W038
: "'{a}' used out of scope.",
59615 W039
: "'{a}' is not allowed.",
59616 W040
: "Possible strict violation.",
59617 W041
: "Use '{a}' to compare with '{b}'.",
59618 W042
: "Avoid EOL escaping.",
59619 W043
: "Bad escaping of EOL. Use option multistr if needed.",
59620 W044
: "Bad or unnecessary escaping.",
59621 W045
: "Bad number '{a}'.",
59622 W046
: "Don't use extra leading zeros '{a}'.",
59623 W047
: "A trailing decimal point can be confused with a dot: '{a}'.",
59624 W048
: "Unexpected control character in regular expression.",
59625 W049
: "Unexpected escaped character '{a}' in regular expression.",
59626 W050
: "JavaScript URL.",
59627 W051
: "Variables should not be deleted.",
59628 W052
: "Unexpected '{a}'.",
59629 W053
: "Do not use {a} as a constructor.",
59630 W054
: "The Function constructor is a form of eval.",
59631 W055
: "A constructor name should start with an uppercase letter.",
59632 W056
: "Bad constructor.",
59633 W057
: "Weird construction. Is 'new' necessary?",
59634 W058
: "Missing '()' invoking a constructor.",
59635 W059
: "Avoid arguments.{a}.",
59636 W060
: "document.write can be a form of eval.",
59637 W061
: "eval can be harmful.",
59638 W062
: "Wrap an immediate function invocation in parens " +
59639 "to assist the reader in understanding that the expression " +
59640 "is the result of a function, and not the function itself.",
59641 W063
: "Math is not a function.",
59642 W064
: "Missing 'new' prefix when invoking a constructor.",
59643 W065
: "Missing radix parameter.",
59644 W066
: "Implied eval. Consider passing a function instead of a string.",
59645 W067
: "Bad invocation.",
59646 W068
: "Wrapping non-IIFE function literals in parens is unnecessary.",
59647 W069
: "['{a}'] is better written in dot notation.",
59648 W070
: "Extra comma. (it breaks older versions of IE)",
59649 W071
: "This function has too many statements. ({a})",
59650 W072
: "This function has too many parameters. ({a})",
59651 W073
: "Blocks are nested too deeply. ({a})",
59652 W074
: "This function's cyclomatic complexity is too high. ({a})",
59653 W075
: "Duplicate key '{a}'.",
59654 W076
: "Unexpected parameter '{a}' in get {b} function.",
59655 W077
: "Expected a single parameter in set {a} function.",
59656 W078
: "Setter is defined without getter.",
59657 W079
: "Redefinition of '{a}'.",
59658 W080
: "It's not necessary to initialize '{a}' to 'undefined'.",
59659 W081
: "Too many var statements.",
59660 W082
: "Function declarations should not be placed in blocks. " +
59661 "Use a function expression or move the statement to the top of " +
59662 "the outer function.",
59663 W083
: "Don't make functions within a loop.",
59664 W084
: "Expected a conditional expression and instead saw an assignment.",
59665 W085
: "Don't use 'with'.",
59666 W086
: "Expected a 'break' statement before '{a}'.",
59667 W087
: "Forgotten 'debugger' statement?",
59668 W088
: "Creating global 'for' variable. Should be 'for (var {a} ...'.",
59669 W089
: "The body of a for in should be wrapped in an if statement to filter " +
59670 "unwanted properties from the prototype.",
59671 W090
: "'{a}' is not a statement label.",
59672 W091
: "'{a}' is out of scope.",
59673 W093
: "Did you mean to return a conditional instead of an assignment?",
59674 W094
: "Unexpected comma.",
59675 W095
: "Expected a string and instead saw {a}.",
59676 W096
: "The '{a}' key may produce unexpected results.",
59677 W097
: "Use the function form of \"use strict\".",
59678 W098
: "'{a}' is defined but never used.",
59679 W099
: "Mixed spaces and tabs.",
59680 W100
: "This character may get silently deleted by one or more browsers.",
59681 W101
: "Line is too long.",
59682 W102
: "Trailing whitespace.",
59683 W103
: "The '{a}' property is deprecated.",
59684 W104
: "'{a}' is available in ES6 (use esnext option) or Mozilla JS extensions (use moz).",
59685 W105
: "Unexpected {a} in '{b}'.",
59686 W106
: "Identifier '{a}' is not in camel case.",
59687 W107
: "Script URL.",
59688 W108
: "Strings must use doublequote.",
59689 W109
: "Strings must use singlequote.",
59690 W110
: "Mixed double and single quotes.",
59691 W112
: "Unclosed string.",
59692 W113
: "Control character in string: {a}.",
59693 W114
: "Avoid {a}.",
59694 W115
: "Octal literals are not allowed in strict mode.",
59695 W116
: "Expected '{a}' and instead saw '{b}'.",
59696 W117
: "'{a}' is not defined.",
59697 W118
: "'{a}' is only available in Mozilla JavaScript extensions (use moz option).",
59698 W119
: "'{a}' is only available in ES6 (use esnext option).",
59699 W120
: "You might be leaking a variable ({a}) here.",
59700 W121
: "Extending prototype of native object: '{a}'.",
59701 W122
: "Invalid typeof value '{a}'",
59702 W123
: "'{a}' is already defined in outer scope.",
59703 W124
: "A generator function shall contain a yield statement.",
59704 W125
: "This line contains non-breaking spaces: http://jshint.com/doc/options/#nonbsp"
59708 I001
: "Comma warnings can be turned off with 'laxcomma'.",
59709 I002
: "Reserved words as properties can be used under the 'es5' option.",
59710 I003
: "ES5 option is now set per default"
59713 exports
.errors
= {};
59714 exports
.warnings
= {};
59717 _
.each(errors
, function (desc
, code
) {
59718 exports
.errors
[code
] = { code
: code
, desc
: desc
};
59721 _
.each(warnings
, function (desc
, code
) {
59722 exports
.warnings
[code
] = { code
: code
, desc
: desc
};
59725 _
.each(info
, function (desc
, code
) {
59726 exports
.info
[code
] = { code
: code
, desc
: desc
};
59729 },{"underscore":11}],16:[function(require
,module
,exports
){
59731 * Regular expressions. Some of these are stupidly long.
59734 /*jshint maxlen:1000 */
59738 // Unsafe comment or string (ax)
59739 exports
.unsafeString
=
59740 /@cc|<\/?|script|\]\s*\]|<\s*!|</i;
59742 // Unsafe characters that are silently deleted by one or more browsers (cx)
59743 exports
.unsafeChars
=
59744 /[\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/;
59746 // Characters in strings that need escaping (nx and nxg)
59748 /[\u0000-\u001f&<"\/\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/;
59750 exports
.needEscGlobal
=
59751 /[\u0000-\u001f&<"\/\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
59754 exports
.starSlash
= /\*\//;
59757 exports
.identifier
= /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/;
59759 // JavaScript URL (jx)
59760 exports
.javascriptURL
= /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i;
59762 // Catches /* falls through */ comments (ft)
59763 exports
.fallsThrough
= /^\s*\/\*\s*falls?\sthrough\s*\*\/\s*$/;
59765 // very conservative rule (eg: only one space between the start of the comment and the first character)
59766 // to relax the maxlen option
59767 exports
.maxlenException
= /^(?:(?:\/\/|\/\*|\*) ?)?[^ ]+$/;
59769 },{}],17:[function(require
,module
,exports
){
59775 reset: function () {
59784 this.directive
= {};
59785 this.jsonMode
= false;
59786 this.jsonWarnings
= [];
59789 this.cache
= {}; // Node.JS doesn't have Map. Sniff.
59790 this.ignoreLinterErrors
= false; // Blank out non-multi-line-commented
59791 // lines when ignoring linter errors
59795 exports
.state
= state
;
59797 },{}],18:[function(require
,module
,exports
){
59800 exports
.register = function (linter
) {
59801 // Check for properties named __proto__. This special property was
59802 // deprecated and then re-introduced for ES6.
59804 linter
.on("Identifier", function style_scanProto(data
) {
59805 if (linter
.getOption("proto")) {
59809 if (data
.name
=== "__proto__") {
59810 linter
.warn("W103", {
59813 data
: [ data
.name
]
59818 // Check for properties named __iterator__. This is a special property
59819 // available only in browsers with JavaScript 1.7 implementation.
59821 linter
.on("Identifier", function style_scanIterator(data
) {
59822 if (linter
.getOption("iterator")) {
59826 if (data
.name
=== "__iterator__") {
59827 linter
.warn("W104", {
59830 data
: [ data
.name
]
59835 // Check for dangling underscores.
59837 linter
.on("Identifier", function style_scanDangling(data
) {
59838 if (!linter
.getOption("nomen")) {
59843 if (data
.name
=== "_") {
59847 // In Node, __dirname and __filename should be ignored.
59848 if (linter
.getOption("node")) {
59849 if (/^(__dirname|__filename)$/.test(data
.name
) && !data
.isProperty
) {
59854 if (/^(_+.*|.*_+)$/.test(data
.name
)) {
59855 linter
.warn("W105", {
59858 data
: [ "dangling '_'", data
.name
]
59863 // Check that all identifiers are using camelCase notation.
59864 // Exceptions: names like MY_VAR and _myVar.
59866 linter
.on("Identifier", function style_scanCamelCase(data
) {
59867 if (!linter
.getOption("camelcase")) {
59871 if (data
.name
.replace(/^_+|_+$/g, "").indexOf("_") > -1 && !data
.name
.match(/^[A-Z0-9_]*$/)) {
59872 linter
.warn("W106", {
59875 data
: [ data
.name
]
59880 // Enforce consistency in style of quoting.
59882 linter
.on("String", function style_scanQuotes(data
) {
59883 var quotmark
= linter
.getOption("quotmark");
59890 // If quotmark is set to 'single' warn about all double-quotes.
59892 if (quotmark
=== "single" && data
.quote
!== "'") {
59896 // If quotmark is set to 'double' warn about all single-quotes.
59898 if (quotmark
=== "double" && data
.quote
!== "\"") {
59902 // If quotmark is set to true, remember the first quotation style
59903 // and then warn about all others.
59905 if (quotmark
=== true) {
59906 if (!linter
.getCache("quotmark")) {
59907 linter
.setCache("quotmark", data
.quote
);
59910 if (linter
.getCache("quotmark") !== data
.quote
) {
59916 linter
.warn(code
, {
59923 linter
.on("Number", function style_scanNumbers(data
) {
59924 if (data
.value
.charAt(0) === ".") {
59925 // Warn about a leading decimal point.
59926 linter
.warn("W008", {
59929 data
: [ data
.value
]
59933 if (data
.value
.substr(data
.value
.length
- 1) === ".") {
59934 // Warn about a trailing decimal point.
59935 linter
.warn("W047", {
59938 data
: [ data
.value
]
59942 if (/^00+/.test(data
.value
)) {
59943 // Multiple leading zeroes.
59944 linter
.warn("W046", {
59947 data
: [ data
.value
]
59952 // Warn about script URLs.
59954 linter
.on("String", function style_scanJavaScriptURLs(data
) {
59955 var re
= /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i;
59957 if (linter
.getOption("scripturl")) {
59961 if (re
.test(data
.value
)) {
59962 linter
.warn("W107", {
59969 },{}],19:[function(require
,module
,exports
){
59974 // Identifiers provided by the ECMAScript standard.
59976 exports
.reservedVars
= {
59981 exports
.ecmaIdentifiers
= {
59986 decodeURIComponent
: false,
59988 encodeURIComponent
: false,
59993 hasOwnProperty
: false,
60002 parseFloat
: false,
60003 RangeError
: false,
60004 ReferenceError
: false,
60008 SyntaxError
: false,
60014 // Global variables commonly provided by a web browser environment.
60016 exports
.browser
= {
60019 addEventListener
: false,
60020 applicationCache
: false,
60024 CanvasGradient
: false,
60025 CanvasPattern
: false,
60026 CanvasRenderingContext2D
: false,
60027 clearInterval
: false,
60028 clearTimeout
: false,
60031 CustomEvent
: false,
60033 defaultStatus
: false,
60036 ElementTimeControl
: false,
60038 FileReader
: false,
60042 getComputedStyle
: false,
60043 HTMLElement
: false,
60044 HTMLAnchorElement
: false,
60045 HTMLBaseElement
: false,
60046 HTMLBlockquoteElement
: false,
60047 HTMLBodyElement
: false,
60048 HTMLBRElement
: false,
60049 HTMLButtonElement
: false,
60050 HTMLCanvasElement
: false,
60051 HTMLDirectoryElement
: false,
60052 HTMLDivElement
: false,
60053 HTMLDListElement
: false,
60054 HTMLFieldSetElement
: false,
60055 HTMLFontElement
: false,
60056 HTMLFormElement
: false,
60057 HTMLFrameElement
: false,
60058 HTMLFrameSetElement
: false,
60059 HTMLHeadElement
: false,
60060 HTMLHeadingElement
: false,
60061 HTMLHRElement
: false,
60062 HTMLHtmlElement
: false,
60063 HTMLIFrameElement
: false,
60064 HTMLImageElement
: false,
60065 HTMLInputElement
: false,
60066 HTMLIsIndexElement
: false,
60067 HTMLLabelElement
: false,
60068 HTMLLayerElement
: false,
60069 HTMLLegendElement
: false,
60070 HTMLLIElement
: false,
60071 HTMLLinkElement
: false,
60072 HTMLMapElement
: false,
60073 HTMLMenuElement
: false,
60074 HTMLMetaElement
: false,
60075 HTMLModElement
: false,
60076 HTMLObjectElement
: false,
60077 HTMLOListElement
: false,
60078 HTMLOptGroupElement
: false,
60079 HTMLOptionElement
: false,
60080 HTMLParagraphElement
: false,
60081 HTMLParamElement
: false,
60082 HTMLPreElement
: false,
60083 HTMLQuoteElement
: false,
60084 HTMLScriptElement
: false,
60085 HTMLSelectElement
: false,
60086 HTMLStyleElement
: false,
60087 HTMLTableCaptionElement
: false,
60088 HTMLTableCellElement
: false,
60089 HTMLTableColElement
: false,
60090 HTMLTableElement
: false,
60091 HTMLTableRowElement
: false,
60092 HTMLTableSectionElement
: false,
60093 HTMLTextAreaElement
: false,
60094 HTMLTitleElement
: false,
60095 HTMLUListElement
: false,
60096 HTMLVideoElement
: false,
60100 localStorage
: false,
60102 matchMedia
: false,
60103 MessageChannel
: false,
60104 MessageEvent
: false,
60105 MessagePort
: false,
60106 MouseEvent
: false,
60109 MutationObserver
: false,
60112 NodeFilter
: false,
60114 onbeforeunload
: true,
60122 openDatabase
: false,
60127 removeEventListener
: false,
60134 sessionStorage
: false,
60135 setInterval
: false,
60136 setTimeout
: false,
60137 SharedWorker
: false,
60139 SVGAElement
: false,
60140 SVGAltGlyphDefElement
: false,
60141 SVGAltGlyphElement
: false,
60142 SVGAltGlyphItemElement
: false,
60144 SVGAnimateColorElement
: false,
60145 SVGAnimateElement
: false,
60146 SVGAnimateMotionElement
: false,
60147 SVGAnimateTransformElement
: false,
60148 SVGAnimatedAngle
: false,
60149 SVGAnimatedBoolean
: false,
60150 SVGAnimatedEnumeration
: false,
60151 SVGAnimatedInteger
: false,
60152 SVGAnimatedLength
: false,
60153 SVGAnimatedLengthList
: false,
60154 SVGAnimatedNumber
: false,
60155 SVGAnimatedNumberList
: false,
60156 SVGAnimatedPathData
: false,
60157 SVGAnimatedPoints
: false,
60158 SVGAnimatedPreserveAspectRatio
: false,
60159 SVGAnimatedRect
: false,
60160 SVGAnimatedString
: false,
60161 SVGAnimatedTransformList
: false,
60162 SVGAnimationElement
: false,
60163 SVGCSSRule
: false,
60164 SVGCircleElement
: false,
60165 SVGClipPathElement
: false,
60167 SVGColorProfileElement
: false,
60168 SVGColorProfileRule
: false,
60169 SVGComponentTransferFunctionElement
: false,
60170 SVGCursorElement
: false,
60171 SVGDefsElement
: false,
60172 SVGDescElement
: false,
60173 SVGDocument
: false,
60174 SVGElement
: false,
60175 SVGElementInstance
: false,
60176 SVGElementInstanceList
: false,
60177 SVGEllipseElement
: false,
60178 SVGExternalResourcesRequired
: false,
60179 SVGFEBlendElement
: false,
60180 SVGFEColorMatrixElement
: false,
60181 SVGFEComponentTransferElement
: false,
60182 SVGFECompositeElement
: false,
60183 SVGFEConvolveMatrixElement
: false,
60184 SVGFEDiffuseLightingElement
: false,
60185 SVGFEDisplacementMapElement
: false,
60186 SVGFEDistantLightElement
: false,
60187 SVGFEFloodElement
: false,
60188 SVGFEFuncAElement
: false,
60189 SVGFEFuncBElement
: false,
60190 SVGFEFuncGElement
: false,
60191 SVGFEFuncRElement
: false,
60192 SVGFEGaussianBlurElement
: false,
60193 SVGFEImageElement
: false,
60194 SVGFEMergeElement
: false,
60195 SVGFEMergeNodeElement
: false,
60196 SVGFEMorphologyElement
: false,
60197 SVGFEOffsetElement
: false,
60198 SVGFEPointLightElement
: false,
60199 SVGFESpecularLightingElement
: false,
60200 SVGFESpotLightElement
: false,
60201 SVGFETileElement
: false,
60202 SVGFETurbulenceElement
: false,
60203 SVGFilterElement
: false,
60204 SVGFilterPrimitiveStandardAttributes
: false,
60205 SVGFitToViewBox
: false,
60206 SVGFontElement
: false,
60207 SVGFontFaceElement
: false,
60208 SVGFontFaceFormatElement
: false,
60209 SVGFontFaceNameElement
: false,
60210 SVGFontFaceSrcElement
: false,
60211 SVGFontFaceUriElement
: false,
60212 SVGForeignObjectElement
: false,
60213 SVGGElement
: false,
60214 SVGGlyphElement
: false,
60215 SVGGlyphRefElement
: false,
60216 SVGGradientElement
: false,
60217 SVGHKernElement
: false,
60218 SVGICCColor
: false,
60219 SVGImageElement
: false,
60220 SVGLangSpace
: false,
60222 SVGLengthList
: false,
60223 SVGLineElement
: false,
60224 SVGLinearGradientElement
: false,
60225 SVGLocatable
: false,
60226 SVGMPathElement
: false,
60227 SVGMarkerElement
: false,
60228 SVGMaskElement
: false,
60230 SVGMetadataElement
: false,
60231 SVGMissingGlyphElement
: false,
60233 SVGNumberList
: false,
60235 SVGPathElement
: false,
60236 SVGPathSeg
: false,
60237 SVGPathSegArcAbs
: false,
60238 SVGPathSegArcRel
: false,
60239 SVGPathSegClosePath
: false,
60240 SVGPathSegCurvetoCubicAbs
: false,
60241 SVGPathSegCurvetoCubicRel
: false,
60242 SVGPathSegCurvetoCubicSmoothAbs
: false,
60243 SVGPathSegCurvetoCubicSmoothRel
: false,
60244 SVGPathSegCurvetoQuadraticAbs
: false,
60245 SVGPathSegCurvetoQuadraticRel
: false,
60246 SVGPathSegCurvetoQuadraticSmoothAbs
: false,
60247 SVGPathSegCurvetoQuadraticSmoothRel
: false,
60248 SVGPathSegLinetoAbs
: false,
60249 SVGPathSegLinetoHorizontalAbs
: false,
60250 SVGPathSegLinetoHorizontalRel
: false,
60251 SVGPathSegLinetoRel
: false,
60252 SVGPathSegLinetoVerticalAbs
: false,
60253 SVGPathSegLinetoVerticalRel
: false,
60254 SVGPathSegList
: false,
60255 SVGPathSegMovetoAbs
: false,
60256 SVGPathSegMovetoRel
: false,
60257 SVGPatternElement
: false,
60259 SVGPointList
: false,
60260 SVGPolygonElement
: false,
60261 SVGPolylineElement
: false,
60262 SVGPreserveAspectRatio
: false,
60263 SVGRadialGradientElement
: false,
60265 SVGRectElement
: false,
60266 SVGRenderingIntent
: false,
60267 SVGSVGElement
: false,
60268 SVGScriptElement
: false,
60269 SVGSetElement
: false,
60270 SVGStopElement
: false,
60271 SVGStringList
: false,
60272 SVGStylable
: false,
60273 SVGStyleElement
: false,
60274 SVGSwitchElement
: false,
60275 SVGSymbolElement
: false,
60276 SVGTRefElement
: false,
60277 SVGTSpanElement
: false,
60279 SVGTextContentElement
: false,
60280 SVGTextElement
: false,
60281 SVGTextPathElement
: false,
60282 SVGTextPositioningElement
: false,
60283 SVGTitleElement
: false,
60284 SVGTransform
: false,
60285 SVGTransformList
: false,
60286 SVGTransformable
: false,
60287 SVGURIReference
: false,
60288 SVGUnitTypes
: false,
60289 SVGUseElement
: false,
60290 SVGVKernElement
: false,
60291 SVGViewElement
: false,
60292 SVGViewSpec
: false,
60293 SVGZoomAndPan
: false,
60300 XMLHttpRequest
: false,
60301 XMLSerializer
: false,
60302 XPathEvaluator
: false,
60303 XPathException
: false,
60304 XPathExpression
: false,
60305 XPathNamespace
: false,
60306 XPathNSResolver
: false,
60307 XPathResult
: false
60320 importScripts
: true,
60321 postMessage
: true,
60325 // Widely adopted global names that are not part of ECMAScript standard
60326 exports
.nonstandard
= {
60331 // Globals provided by popular JavaScript environments.
60348 __filename
: false,
60355 // These globals are writeable because Node allows the following
60356 // usage pattern: var Buffer = require("buffer").Buffer;
60363 clearTimeout
: true,
60364 setInterval
: true,
60365 clearInterval
: true,
60366 setImmediate
: true, // v0.9.1+
60367 clearImmediate
: true // v0.9.1+
60370 exports
.phantom
= {
60374 console
: true, // in examples, but undocumented
60375 exports
: true // v1.7+
60379 defineClass
: false,
60380 deserialize
: false,
60383 importPackage
: false,
60391 runCommand
: false,
60400 exports
.shelljs
= {
60429 ArrayBuffer
: false,
60430 ArrayBufferView
: false,
60432 Float32Array
: false,
60433 Float64Array
: false,
60434 Int16Array
: false,
60435 Int32Array
: false,
60437 Uint16Array
: false,
60438 Uint32Array
: false,
60439 Uint8Array
: false,
60440 Uint8ClampedArray
: false
60444 ActiveXObject
: true,
60447 ScriptEngine
: true,
60448 ScriptEngineBuildVersion
: true,
60449 ScriptEngineMajorVersion
: true,
60450 ScriptEngineMinorVersion
: true,
60454 XDomainRequest
: true
60457 // Globals provided by popular JavaScript libraries.
60472 exports
.mootools
= {
60496 IframeShim
: false,
60497 InputValidator
: false,
60498 instanceOf
: false,
60520 exports
.prototypejs
= {
60528 "$continue" : false,
60533 Enumerable
: false,
60540 ObjectRange
: false,
60541 PeriodicalExecuter
: false,
60548 Autocompleter
: false,
60552 Draggables
: false,
60553 Droppables
: false,
60556 SortableObserver
: false,
60558 Scriptaculous
: false
60568 },{}]},{},["nr+AlQ"])
60569 JSHINT
= require('jshint').JSHINT
;
60570 if (typeof exports
=== 'object' && exports
) exports
.JSHINT
= JSHINT
;
projects / pve-eslint.git / blob