# Source: https://jshint.com/docs/options/

JSHint Options Reference

JSHint

About

Docs

Install

Contribute

Blog

Jump to docs

JSHint Options

This page's content is sourced from 
the JSHint
project repository
. If you spot an error, please 
open an issue
 or (better yet) 
make
a pull request
!

Enforcing options

When set to true, these options will make JSHint produce more warnings about your code.

bitwise

This option prohibits the use of bitwise operators such as 
^
 (XOR),

|
 (OR) and others. Bitwise operators are very rare in JavaScript
programs and quite often 
&amp;
 is simply a mistyped 
&amp;&amp;
.

camelcase

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style,
 check out 
the JSCS
 project
.

This option allows you to force all variable names to use either
camelCase style or UPPER_CASE with underscores.

curly

This option requires you to always put curly braces around blocks in
loops and conditionals. JavaScript allows you to omit curly braces when
the block consists of only one statement, for example:

while (day)
 shuffle();

However, in some circumstances, it can lead to bugs (you&#39;d think that

sleep()
 is a part of the loop while in reality it is not):

while (day)
 shuffle();
 sleep();

enforceall

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

The option cannot be maintained without automatically opting users in to new features. This can lead to unexpected
 warnings/errors in when upgrading between minor versions of
 JSHint.

This option is a short hand for the most strict JSHint configuration as
available in JSHint version 2.6.3. It enables all enforcing options and
disables all relaxing options that were defined in that release.

eqeqeq

This options prohibits the use of 
==
 and 
!=
 in favor of 
===
 and

!==
. The former try to coerce values before comparing them which can
lead to some unexpected results. The latter don&#39;t do any coercion so
they are generally safer. If you would like to learn more about type
coercion in JavaScript, we recommend 
Truth, Equality and
JavaScript

by Angus Croll.

es3

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

Use 
esversion: 3
 instead.

This option tells JSHint that your code needs to adhere to ECMAScript 3
specification. Use this option if you need your program to be executable
in older browsers—such as Internet Explorer 6/7/8/9—and other legacy
JavaScript environments.

es5

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

Use 
esversion: 5
 instead.

This option enables syntax first defined in 
the ECMAScript 5.1
specification
. This includes allowing reserved
keywords as object properties.

esversion

This option is used to specify the ECMAScript version to which the code
must adhere. It can assume one of the following values:

3
 - If you need your program to be executable
in older browsers—such as Internet Explorer 6/7/8/9—and other legacy
JavaScript environments

5
 - To enable syntax first defined in 
the ECMAScript 5.1
specification
.
This includes allowing reserved keywords as object properties.

6
 - To tell JSHint that your code uses 
ECMAScript
6
 specific
syntax. Note that not all browsers implement them.

7
 - To enable language features introduced by 
ECMAScript
7
. Notable
additions: the exponentiation operator.

8
 - To enable language features introduced by 
ECMAScript
8
. Notable
additions: async functions, shared memory, and atomics

9
 - To enable language features introduced by 
ECMAScript
9
. Notable
additions: asynchronous iteration, rest/spread properties, and various
RegExp extensions

10
 - To enable language features introduced by 
ECMAScript
10
.
Notable additions: optional catch bindings.

11
 - To enable language features introduced by ECMAScript 11. Notable
additions: &quot;export * as ns from &#39;module&#39;&quot;, 
import.meta
, the nullish
coalescing operator, the BigInt type, the 
globalThis
 binding,
optional chaining, and dynamic import.

forin

This option requires all 
for in
 loops to filter object&#39;s items. The
for in statement allows for looping through the names of all of the
properties of an object including those inherited through the prototype
chain. This behavior can lead to unexpected items in your object so it
is generally safer to always filter inherited properties out as shown in
the example:

for (key in obj) {
 if (obj.hasOwnProperty(key)) {
 // We are sure that obj[key] belongs to the object and was not inherited.
 }
}

For more in-depth understanding of 
for in
 loops in JavaScript, read

Exploring JavaScript for-in
loops

by Angus Croll.

freeze

This options prohibits overwriting prototypes of native objects such as

Array
, 
Date
 and so on.

// jshint freeze:true
Array.prototype.count = function (value) { return 4; };
// -&gt; Warning: Extending prototype of native object: &#39;Array&#39;.

futurehostile

This option enables warnings about the use of identifiers which are
defined in future versions of JavaScript. Although overwriting them has
no effect in contexts where they are not implemented, this practice can
cause issues when migrating codebases to newer versions of the language.

globals

This option can be used to specify a white list of global variables that
are not formally defined in the source code. This is most useful when
combined with the 
undef
 option in order to suppress warnings for
project-specific global variables.

Setting an entry to 
true
 enables reading and writing to that variable.
Setting it to 
false
 will trigger JSHint to consider that variable
read-only.

See also the &quot;environment&quot; options: a set of options to be used as short
hand for enabling global variables defined in common JavaScript
environments.

To configure 
globals
 within an individual file, see 
Inline
Configuration
.

immed

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style,
 check out 
the JSCS
 project
.

This option prohibits the use of immediate function invocations without
wrapping them in parentheses. Wrapping parentheses assists readers of
your code in understanding that the expression is the result of a
function, and not the function itself.

indent

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style, check
 out 
the JSCS project
.

This option sets a specific tab width for your code.

latedef

This option prohibits the use of a variable before it was defined.
JavaScript has function scope only and, in addition to that, all variables
are always moved—or hoisted— to the top of the function. This behavior can
lead to some very nasty bugs and that&#39;s why it is safer to always use
variable only after they have been explicitly defined.

Setting this option to &quot;nofunc&quot; will allow function declarations to be
ignored.

For more in-depth understanding of scoping and hoisting in JavaScript,
read 
JavaScript Scoping and
Hoisting

by Ben Cherry.

leanswitch

This option prohibits unnecessary clauses within 
switch
 statements,
e.g.

switch (x) {
 case 1:
 default:
 z();
}

While clauses like these are techincally valid, they do not effect
program behavior and may indicate an erroneous refactoring.

maxcomplexity

This option lets you control cyclomatic complexity throughout your code.
Cyclomatic complexity measures the number of linearly independent paths
through a program&#39;s source code. Read more about 
cyclomatic complexity on
Wikipedia
.

maxdepth

This option lets you control how nested do you want your blocks to be:

// jshint maxdepth:2

function main(meaning) {
 var day = true;

 if (meaning === 42) {
 while (day) {
 shuffle();

 if (tired) { // JSHint: Blocks are nested too deeply (3).
 sleep();
 }
 }
 }
}

maxerr

This options allows you to set the maximum amount of errors JSHint will
produce before giving up. Default is 50.

maxlen

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style, check
 out 
the JSCS project
.

This option lets you set the maximum length of a line.

maxparams

This option lets you set the max number of formal parameters allowed per
function:

// jshint maxparams:3

function login(request, onSuccess) {
 // ...
}

// JSHint: Too many parameters per function (4).
function logout(request, isManual, whereAmI, onSuccess) {
 // ...
}

maxstatements

This option lets you set the max number of statements allowed per function:

// jshint maxstatements:4

function main() {
 var i = 0;
 var j = 0;

 // Function declarations count as one statement. Their bodies
 // don&#39;t get taken into account for the outer function.
 function inner() {
 var i2 = 1;
 var j2 = 1;

 return i2 + j2;
 }

 j = i + j;
 return j; // JSHint: Too many statements per function. (5)
}

newcap

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style,
 check out 
the JSCS
 project
.

This option requires you to capitalize names of constructor functions.
Capitalizing functions that are intended to be used with 
new
 operator
is just a convention that helps programmers to visually distinguish
constructor functions from other types of functions to help spot
mistakes when using 
this
.

Not doing so won&#39;t break your code in any browsers or environments but
it will be a bit harder to figure out—by reading the code—if the
function was supposed to be used with or without new. And this is
important because when the function that was intended to be used with

new
 is used without it, 
this
 will point to the global object instead
of a new object.

noarg

This option prohibits the use of 
arguments.caller
 and

arguments.callee
. Both 
.caller
 and 
.callee
 make quite a few
optimizations impossible so they were deprecated in future versions of
JavaScript. In fact, ECMAScript 5 forbids the use of 
arguments.callee

in strict mode.

nocomma

This option prohibits the use of the comma operator. When misused, the
comma operator can obscure the value of a statement and promote
incorrect code.

noempty

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style,
 check out 
the JSCS
 project
.

This option warns when you have an empty block in your code. JSLint was
originally warning for all empty blocks and we simply made it optional.
There were no studies reporting that empty blocks in JavaScript break
your code in any way.

nonbsp

This option warns about &quot;non-breaking whitespace&quot; characters. These
characters can be entered with option-space on Mac computers and have a
potential of breaking non-UTF8 web pages.

nonew

This option prohibits the use of constructor functions for side-effects.
Some people like to call constructor functions without assigning its
result to any variable:

new MyConstructor();

There is no advantage in this approach over simply calling

MyConstructor
 since the object that the operator 
new
 creates isn&#39;t
used anywhere so you should generally avoid constructors like this one.

noreturnawait

Async functions resolve on their return value. In most cases, this makes
returning the result of an AwaitExpression (which is itself a Promise
instance) unnecessary. For clarity, it&#39;s often preferable to return the
result of the asynchronous operation directly. The notable exception is
within the 
try
 clause of a TryStatement--for more, see &quot;await vs
return vs return await&quot;:

https://jakearchibald.com/2017/await-vs-return-vs-return-await/

predef

This option allows you to control which variables JSHint considers to be
implicitly defined in the environment. Configure it with an array of
string values. Prefixing a variable name with a hyphen (-) character will
remove that name from the collection of predefined variables.

JSHint will consider variables declared in this way to be read-only.

This option cannot be specified in-line; it may only be used via the
JavaScript API or from an external configuration file.

quotmark

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style, check
 out 
the JSCS project
.

This option enforces the consistency of quotation marks used throughout
your code. It accepts three values: 
true
 if you don&#39;t want to enforce
one particular style but want some consistency, 
&quot;single&quot;
 if you want to
allow only single quotes and 
&quot;double&quot;
 if you want to allow only double
quotes.

regexpu

This option enables warnings for regular expressions which do not
include the &quot;u&quot; flag. The &quot;u&quot; flag extends support for Unicode and also
enables more strict parsing rules. JSHint will enforce these rules even
if it is executed in a JavaScript engine which does not support the &quot;u&quot;
flag.

shadow

This option suppresses warnings about variable shadowing i.e. declaring a
variable that had been already declared somewhere in the outer scope.

&quot;inner&quot; - check for variables defined in the same scope only

&quot;outer&quot; - check for variables defined in outer scopes as well

false - same as inner

true - allow variable shadowing

singleGroups

This option prohibits the use of the grouping operator when it is not
strictly required. Such usage commonly reflects a misunderstanding of
unary operators, for example:

// jshint singleGroups: true

delete(obj.attr); // Warning: Unnecessary grouping operator.

strict

This option requires the code to run in ECMAScript 5&#39;s strict mode.

Strict mode

is a way to opt in to a restricted variant of JavaScript. Strict mode
eliminates some JavaScript pitfalls that didn&#39;t cause errors by changing
them to produce errors. It also fixes mistakes that made it difficult
for the JavaScript engines to perform certain optimizations.

&quot;global&quot; - there must be a 
&quot;use strict&quot;;
 directive at global level

&quot;implied&quot; - lint the code as if there is the 
&quot;use strict&quot;;
 directive

false - disable warnings about strict mode

true - there must be a 
&quot;use strict&quot;;
 directive at function level;

 this is preferable for scripts intended to be loaded in web
 browsers directly because enabling strict mode globally
 could adversely effect other scripts running on the same
 page

trailingcomma

This option warns when a comma is not placed after the last element in an
array or object literal. Due to bugs in old versions of IE, trailing
commas used to be discouraged, but since ES5 their semantics were
standardized. (See

#11.1.4
 and

#11.1.5
.)
Now, they help to prevent the same 
visual
ambiguities

that the strict usage of semicolons helps prevent.

For example, this code might have worked last Tuesday:

[
 b + c
].forEach(print);

But if one adds an element to the array and forgets to compensate for the
missing comma, no syntax error is thrown, and a linter cannot determine
if this was a mistake or an intentional function invocation.

[
 b + c
 (d + e)
].forEach(print);

If one always appends a list item with a comma, this ambiguity cannot
occur:

[
 b + c,
].forEach(print);

[
 b + c,
 (d + e),
].forEach(print);

undef

This option prohibits the use of explicitly undeclared variables. This
option is very useful for spotting leaking and mistyped variables.

// jshint undef:true

function test() {
 var myVar = &#39;Hello, World&#39;;
 console.log(myvar); // Oops, typoed here. JSHint with undef will complain
}

If your variable is defined in another file, you can use the 
global

directive to tell JSHint about it.

unused

This option warns when you define and never use your variables. It is very
useful for general code cleanup, especially when used in addition to

undef
.

// jshint unused:true

function test(a, b) {
 var c, d = 2;

 return a + d;
}

test(1, 2);

// Line 3: &#39;b&#39; was defined but never used.
// Line 4: &#39;c&#39; was defined but never used.

In addition to that, this option will warn you about unused global
variables declared via the 
global
 directive.

When set to 
true
, unused parameters that are followed by a used
parameter will not produce warnings. This option can be set to 
vars
 to
only check for variables, not function parameters, or 
strict
 to check
all variables and parameters.

varstmt

When set to true, the use of VariableStatements are forbidden.
For example:

// jshint varstmt: true

var a; // Warning: `var` declarations are forbidden. Use `let` or `const` instead.

Relaxing options

When set to true, these options will make JSHint produce fewer warnings about your code.

asi

This option suppresses warnings about missing semicolons. There is a lot
of FUD about semicolon spread by quite a few people in the community.
The common myths are that semicolons are required all the time (they are
not) and that they are unreliable. JavaScript has rules about semicolons
which are followed by 
all
 browsers so it is up to you to decide
whether you should or should not use semicolons in your code.

For more information about semicolons in JavaScript read 
An Open Letter
to JavaScript Leaders Regarding
Semicolons

by Isaac Schlueter and 
JavaScript Semicolon
Insertion
.

boss

This option suppresses warnings about the use of assignments in cases
where comparisons are expected. More often than not, code like 
if (a =
10) {}
 is a typo. However, it can be useful in cases like this one:

for (var i = 0, person; person = people[i]; i++) {}

You can silence this error on a per-use basis by surrounding the assignment
with parenthesis, such as:

for (var i = 0, person; (person = people[i]); i++) {}

debug

This option suppresses warnings about the 
debugger
 statements in your
code.

elision

This option tells JSHint that your code uses ES3 array elision elements,
or empty elements (for example, 
[1, , , 4, , , 7]
).

eqnull

This option suppresses warnings about 
== null
 comparisons. Such
comparisons are often useful when you want to check if a variable is

null
 or 
undefined
.

esnext

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

Use 
esversion: 6
 instead.

This option tells JSHint that your code uses ECMAScript 6 specific
syntax. Note that not all browsers implement these features.

More info:

Specification for ECMAScript
6

evil

This option suppresses warnings about the use of 
eval
. The use of

eval
 is discouraged because it can make your code vulnerable to
various injection attacks and it makes it hard for JavaScript
interpreter to do certain optimizations.

expr

This option suppresses warnings about the use of expressions where
normally you would expect to see assignments or function calls. Most of
the time, such code is a typo. However, it is not forbidden by the spec
and that&#39;s why this warning is optional.

funcscope

This option suppresses warnings about declaring variables inside
of control structures while accessing them later from the outside.
Even though identifiers declared with 
var
 have two real scopes—global
and function—such practice leads to confusion among people new to
the language and hard-to-debug bugs. This is why, by default, JSHint
warns about variables that are used outside of their intended scope.

function test() {
 if (true) {
 var x = 0;
 }

 x += 1; // Default: &#39;x&#39; used out of scope.
 // No warning when funcscope:true
}

globalstrict

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

Use 
strict: &quot;global&quot;
.

This option suppresses warnings about the use of global strict mode.
Global strict mode can break third-party widgets so it is not
recommended.

For more info about strict mode see the 
strict
 option.

iterator

This option suppresses warnings about the 
__iterator__
 property. This
property is not supported by all browsers so use it carefully.

lastsemic

This option suppresses warnings about missing semicolons, but only when
the semicolon is omitted for the last statement in a one-line block:

var name = (function() { return &#39;Anton&#39; }());

This is a very niche use case that is useful only when you use automatic
JavaScript code generators.

laxbreak

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style,
 check out 
the JSCS
 project
.

This option suppresses most of the warnings about possibly unsafe line
breakings in your code. It doesn&#39;t suppress warnings about comma-first
coding style. To suppress those you have to use 
laxcomma
 (see below).

laxcomma

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style,
 check out 
the JSCS
 project
.

This option suppresses warnings about comma-first coding style:

var obj = {
 name: &#39;Anton&#39;
 , handle: &#39;valueof&#39;
 , role: &#39;SW Engineer&#39;
};

loopfunc

This option suppresses warnings about functions inside of loops.
Defining functions inside of loops can lead to bugs such as this one:

var nums = [];

for (var i = 0; i &lt; 10; i++) {
 nums[i] = function (j) {
 return i + j;
 };
}

nums[0](2); // Prints 12 instead of 2

To fix the code above you need to copy the value of 
i
:

var nums = [];

for (var i = 0; i &lt; 10; i++) {
 (function (i) {
 nums[i] = function (j) {
 return i + j;
 };
 }(i));
}

moz

This options tells JSHint that your code uses Mozilla JavaScript
extensions. Unless you develop specifically for the Firefox web browser
you don&#39;t need this option.

More info:

New in JavaScript
1.7

multistr

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style,
 check out 
the JSCS
 project
.

This option suppresses warnings about multi-line strings. Multi-line
strings can be dangerous in JavaScript because all hell breaks loose if
you accidentally put a whitespace in between the escape character (
\
)
and a new line.

Note that even though this option allows correct multi-line strings, it
still warns about multi-line strings without escape characters or with
anything in between the escape character and a whitespace.

// jshint multistr:true

var text = &quot;Hello\
World&quot;; // All good.

text = &quot;Hello
World&quot;; // Warning, no escape character.

text = &quot;Hello\
World&quot;; // Warning, there is a space after \

notypeof

This option suppresses warnings about invalid 
typeof
 operator values.
This operator has only 
a limited set of possible return
values
.
By default, JSHint warns when you compare its result with an invalid
value which often can be a typo.

// &#39;fuction&#39; instead of &#39;function&#39;
if (typeof a == &quot;fuction&quot;) { // Invalid typeof value &#39;fuction&#39;
 // ...
}

Do not use this option unless you&#39;re absolutely sure you don&#39;t want
these checks.

noyield

This option suppresses warnings about generator functions with no

yield
 statement in them.

plusplus

This option prohibits the use of unary increment and decrement
operators. Some people think that 
++
 and 
--
 reduces the quality of
their coding styles and there are programming languages—such as
Python—that go completely without these operators.

proto

This option suppresses warnings about the 
__proto__
 property.

scripturl

This option suppresses warnings about the use of script-targeted
URLs—such as 
javascript:...
.

sub

Warning
 This option has been deprecated and will be
 removed in the next major release of JSHint.

JSHint is limiting its scope to issues of code correctness. If you would like to enforce rules relating to code style,
 check out 
the JSCS
 project
.

This option suppresses warnings about using 
[]
 notation when it can be
expressed in dot notation: 
person[&#39;name&#39;]
 vs. 
person.name
.

supernew

This option suppresses warnings about &quot;weird&quot; constructions like

new function () { ... }
 and 
new Object;
. Such constructions are
sometimes used to produce singletons in JavaScript:

var singleton = new function() {
 var privateVar;

 this.publicMethod = function () {}
 this.publicMethod2 = function () {}
};

validthis

This option suppresses warnings about possible strict violations when
the code is running in strict mode and you use 
this
 in a
non-constructor function. You should use this option—in a function scope
only—when you are positive that your use of 
this
 is valid in the
strict mode (for example, if you call your function using

Function.call
).

Note:
 This option can be used only inside of a function scope.
JSHint will fail with an error if you will try to set this option
globally.

withstmt

This option suppresses warnings about the use of the 
with
 statement.
The semantics of the 
with
 statement can cause confusion among
developers and accidental definition of global variables.

More info:

with Statement Considered
Harmful

Environments

These options let JSHint know about some pre-defined global variables.

browser

This option defines globals exposed by modern browsers: all the way from
good old 
document
 and 
navigator
 to the HTML5 
FileReader
 and other
new developments in the browser world.

Note:
 This option doesn&#39;t expose variables like 
alert
 or

console
. See option 
devel
 for more information.

browserify

This option defines globals available when using 
the Browserify
tool
 to build a project.

couch

This option defines globals exposed by

CouchDB
. CouchDB is a document-oriented
database that can be queried and indexed in a MapReduce fashion using
JavaScript.

devel

This option defines globals that are usually used for logging poor-man&#39;s
debugging: 
console
, 
alert
, etc. It is usually a good idea to not
ship them in production because, for example, 
console.log
 breaks in
legacy versions of Internet Explorer.

dojo

This option defines globals exposed by the 
Dojo
Toolkit
.

jasmine

This option defines globals exposed by 
the Jasmine unit testing
framework
.

jquery

This option defines globals exposed by the 
jQuery

JavaScript library.

mocha

This option defines globals exposed by the &quot;BDD&quot; and &quot;TDD&quot; UIs of the

Mocha unit testing framework
.

module

This option informs JSHint that the input code describes an ECMAScript 6
module. All module code is interpreted as strict mode code.

mootools

This option defines globals exposed by the

MooTools
 JavaScript framework.

node

This option defines globals available when your code is running inside
of the Node runtime environment. 
Node.js
 is a
server-side JavaScript environment that uses an asynchronous
event-driven model. This option also skips some warnings that make sense
in the browser environments but don&#39;t make sense in Node such as
file-level 
use strict
 pragmas and 
console.log
 statements.

nonstandard

This option defines non-standard but widely adopted globals such as

escape
 and 
unescape
.

phantom

This option defines globals available when your core is running inside
of the PhantomJS runtime environment. 
PhantomJS

is a headless WebKit scriptable with a JavaScript API. It has fast and
native support for various web standards: DOM handling, CSS selector,
JSON, Canvas, and SVG.

prototypejs

This option defines globals exposed by the

Prototype
 JavaScript framework.

qunit

This option defines globals exposed by 
the QUnit unit testing
framework
.

rhino

This option defines globals available when your code is running inside
of the Rhino runtime environment. 
Rhino

is an open-source implementation of JavaScript written entirely in Java.

shelljs

This option defines globals exposed by 
the ShellJS
library
.

typed

This option defines globals for typed array constructors.

More info:

JavaScript typed
arrays

worker

This option defines globals available when your code is running inside
of a Web Worker. 
Web
Workers
 provide a
simple means for web content to run scripts in background threads.

wsh

This option defines globals available when your code is running as a
script for the 
Windows Script
Host
.

yui

This option defines globals exposed by the 
YUI

JavaScript framework.

Unstable

These options enable behavior which is subject to change between major releases of JSHint. Exercise caution when enabling them in automated environments (e.g. continuous integration).

exports.unstable = {
};

// These are JSHint boolean options which are shared with JSLint
// where the definition in JSHint is opposite JSLint
exports.inverted = {
 bitwise

Unstable options allow control for parsing and linting of proposed additions
to the JavaScript language. Just like the language features they describe,
the presence and behavior of these options is volatile; JSHint reserves the
right to remove or modify them between major version releases.