git.r.bdr.sh - rbdr/dotfiles/blob - vim/ftplugin/javascript/jslint/jslint-core.js

   1 // jslint.js
   2 // 2012-02-23
   3
   4 // Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)
   5
   6 // Permission is hereby granted, free of charge, to any person obtaining a copy
   7 // of this software and associated documentation files (the "Software"), to deal
   8 // in the Software without restriction, including without limitation the rights
   9 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10 // copies of the Software, and to permit persons to whom the Software is
  11 // furnished to do so, subject to the following conditions:
  12
  13 // The above copyright notice and this permission notice shall be included in
  14 // all copies or substantial portions of the Software.
  15
  16 // The Software shall be used for Good, not Evil.
  17
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24 // SOFTWARE.
  25
  26 // WARNING: JSLint will hurt your feelings.
  27
  28 // JSLINT is a global function. It takes two parameters.
  29
  30 //     var myResult = JSLINT(source, option);
  31
  32 // The first parameter is either a string or an array of strings. If it is a
  33 // string, it will be split on '\n' or '\r'. If it is an array of strings, it
  34 // is assumed that each string represents one line. The source can be a
  35 // JavaScript text, or HTML text, or a JSON text, or a CSS text.
  36
  37 // The second parameter is an optional object of options that control the
  38 // operation of JSLINT. Most of the options are booleans: They are all
  39 // optional and have a default value of false. One of the options, predef,
  40 // can be an array of names, which will be used to declare global variables,
  41 // or an object whose keys are used as global names, with a boolean value
  42 // that determines if they are assignable.
  43
  44 // If it checks out, JSLINT returns true. Otherwise, it returns false.
  45
  46 // If false, you can inspect JSLINT.errors to find out the problems.
  47 // JSLINT.errors is an array of objects containing these properties:
  48
  49 //  {
  50 //      line      : The line (relative to 0) at which the lint was found
  51 //      character : The character (relative to 0) at which the lint was found
  52 //      reason    : The problem
  53 //      evidence  : The text line in which the problem occurred
  54 //      raw       : The raw message before the details were inserted
  55 //      a         : The first detail
  56 //      b         : The second detail
  57 //      c         : The third detail
  58 //      d         : The fourth detail
  59 //  }
  60
  61 // If a stopping error was found, a null will be the last element of the
  62 // JSLINT.errors array. A stopping error means that JSLint was not confident
  63 // enough to continue. It does not necessarily mean that the error was
  64 // especially heinous.
  65
  66 // You can request a Function Report, which shows all of the functions
  67 // and the parameters and vars that they use. This can be used to find
  68 // implied global variables and other problems. The report is in HTML and
  69 // can be inserted in an HTML <body>.
  70
  71 //     var myReport = JSLINT.report(errors_only);
  72
  73 // If errors_only is true, then the report will be limited to only errors.
  74
  75 // You can request a data structure that contains JSLint's results.
  76
  77 //     var myData = JSLINT.data();
  78
  79 // It returns a structure with this form:
  80
  81 //     {
  82 //         errors: [
  83 //             {
  84 //                 line: NUMBER,
  85 //                 character: NUMBER,
  86 //                 reason: STRING,
  87 //                 evidence: STRING
  88 //             }
  89 //         ],
  90 //         functions: [
  91 //             {
  92 //                 name: STRING,
  93 //                 line: NUMBER,
  94 //                 last: NUMBER,
  95 //                 params: [
  96 //                     {
  97 //                         string: STRING
  98 //                     }
  99 //                 ],
 100 //                 closure: [
 101 //                     STRING
 102 //                 ],
 103 //                 var: [
 104 //                     STRING
 105 //                 ],
 106 //                 exception: [
 107 //                     STRING
 108 //                 ],
 109 //                 outer: [
 110 //                     STRING
 111 //                 ],
 112 //                 unused: [
 113 //                     STRING
 114 //                 ],
 115 //                 undef: [
 116 //                     STRING
 117 //                 ],
 118 //                 global: [
 119 //                     STRING
 120 //                 ],
 121 //                 label: [
 122 //                     STRING
 123 //                 ]
 124 //             }
 125 //         ],
 126 //         globals: [
 127 //             STRING
 128 //         ],
 129 //         member: {
 130 //             STRING: NUMBER
 131 //         },
 132 //         urls: [
 133 //             STRING
 134 //         ],
 135 //         json: BOOLEAN
 136 //     }
 137
 138 // Empty arrays will not be included.
 139
 140 // You can obtain the parse tree that JSLint constructed while parsing. The
 141 // latest tree is kept in JSLINT.tree. A nice stringication can be produced
 142 // with
 143
 144 //     JSON.stringify(JSLINT.tree, [
 145 //         'string',  'arity', 'name',  'first',
 146 //         'second', 'third', 'block', 'else'
 147 //     ], 4));
 148
 149 // JSLint provides three directives. They look like slashstar comments, and
 150 // allow for setting options, declaring global variables, and establishing a
 151 // set of allowed property names.
 152
 153 // These directives respect function scope.
 154
 155 // The jslint directive is a special comment that can set one or more options.
 156 // The current option set is
 157
 158 //     anon       true, if the space may be omitted in anonymous function declarations
 159 //     bitwise    true, if bitwise operators should be allowed
 160 //     browser    true, if the standard browser globals should be predefined
 161 //     cap        true, if upper case HTML should be allowed
 162 //     'continue' true, if the continuation statement should be tolerated
 163 //     css        true, if CSS workarounds should be tolerated
 164 //     debug      true, if debugger statements should be allowed
 165 //     devel      true, if logging should be allowed (console, alert, etc.)
 166 //     eqeq       true, if == should be allowed
 167 //     es5        true, if ES5 syntax should be allowed
 168 //     evil       true, if eval should be allowed
 169 //     forin      true, if for in statements need not filter
 170 //     fragment   true, if HTML fragments should be allowed
 171 //     indent     the indentation factor
 172 //     maxerr     the maximum number of errors to allow
 173 //     maxlen     the maximum length of a source line
 174 //     newcap     true, if constructor names capitalization is ignored
 175 //     node       true, if Node.js globals should be predefined
 176 //     nomen      true, if names may have dangling _
 177 //     on         true, if HTML event handlers should be allowed
 178 //     passfail   true, if the scan should stop on first error
 179 //     plusplus   true, if increment/decrement should be allowed
 180 //     properties true, if all property names must be declared with /*properties*/
 181 //     regexp     true, if the . should be allowed in regexp literals
 182 //     rhino      true, if the Rhino environment globals should be predefined
 183 //     undef      true, if variables can be declared out of order
 184 //     unparam    true, if unused parameters should be tolerated
 185 //     sloppy     true, if the 'use strict'; pragma is optional
 186 //     sub        true, if all forms of subscript notation are tolerated
 187 //     vars       true, if multiple var statements per function should be allowed
 188 //     white      true, if sloppy whitespace is tolerated
 189 //     widget     true  if the Yahoo Widgets globals should be predefined
 190 //     windows    true, if MS Windows-specific globals should be predefined
 191
 192 // For example:
 193
 194 /*jslint
 195     evil: true, nomen: true, regexp: true
 196 */
 197
 198 // The properties directive declares an exclusive list of property names.
 199 // Any properties named in the program that are not in the list will
 200 // produce a warning.
 201
 202 // For example:
 203
 204 /*properties
 205     '\b', '\t', '\n', '\f', '\r', '!=', '!==', '"', '%', '\'', '(arguments)',
 206     '(begin)', '(breakage)', '(context)', '(error)', '(identifier)', '(line)',
 207     '(loopage)', '(name)', '(params)', '(scope)', '(token)', '(vars)', '(verb)',
 208     '*', '+', '-', '/', '<', '<=', '==', '===', '>', '>=', ADSAFE,
 209     Array, Date, Function, Object, '\\', a, a_label, a_not_allowed,
 210     a_not_defined, a_scope, abbr, acronym, address, adsafe, adsafe_a,
 211     adsafe_autocomplete, adsafe_bad_id, adsafe_div, adsafe_fragment, adsafe_go,
 212     adsafe_html, adsafe_id, adsafe_id_go, adsafe_lib, adsafe_lib_second,
 213     adsafe_missing_id, adsafe_name_a, adsafe_placement, adsafe_prefix_a,
 214     adsafe_script, adsafe_source, adsafe_subscript_a, adsafe_tag, all,
 215     already_defined, and, anon, applet, apply, approved, area, arity, article,
 216     aside, assign, assign_exception, assignment_function_expression, at,
 217     attribute_case_a, audio, autocomplete, avoid_a, b, background,
 218     'background-attachment', 'background-color', 'background-image',
 219     'background-position', 'background-repeat', bad_assignment, bad_color_a,
 220     bad_constructor, bad_entity, bad_html, bad_id_a, bad_in_a, bad_invocation,
 221     bad_name_a, bad_new, bad_number, bad_operand, bad_style, bad_type, bad_url_a,
 222     bad_wrap, base, bdo, big, bitwise, block, blockquote, body, border,
 223     'border-bottom', 'border-bottom-color', 'border-bottom-left-radius',
 224     'border-bottom-right-radius', 'border-bottom-style', 'border-bottom-width',
 225     'border-collapse', 'border-color', 'border-left', 'border-left-color',
 226     'border-left-style', 'border-left-width', 'border-radius', 'border-right',
 227     'border-right-color', 'border-right-style', 'border-right-width',
 228     'border-spacing', 'border-style', 'border-top', 'border-top-color',
 229     'border-top-left-radius', 'border-top-right-radius', 'border-top-style',
 230     'border-top-width', 'border-width', bottom, br, braille, browser, button, c,
 231     call, canvas, cap, caption, 'caption-side', center, charAt, charCodeAt,
 232     character, cite, clear, clip, closure, cm, code, col, colgroup, color,
 233     combine_var, command, conditional_assignment, confusing_a, confusing_regexp,
 234     constructor_name_a, content, continue, control_a, 'counter-increment',
 235     'counter-reset', create, css, cursor, d, dangerous_comment, dangling_a, data,
 236     datalist, dd, debug, del, deleted, details, devel, dfn, dialog, dir,
 237     direction, display, disrupt, div, dl, dt, duplicate_a, edge, edition, else,
 238     em, embed, embossed, empty, 'empty-cells', empty_block, empty_case,
 239     empty_class, entityify, eqeq, errors, es5, eval, evidence, evil, ex,
 240     exception, exec, expected_a, expected_a_at_b_c, expected_a_b,
 241     expected_a_b_from_c_d, expected_at_a, expected_attribute_a,
 242     expected_attribute_value_a, expected_class_a, expected_fraction_a,
 243     expected_id_a, expected_identifier_a, expected_identifier_a_reserved,
 244     expected_lang_a, expected_linear_a, expected_media_a, expected_name_a,
 245     expected_nonstandard_style_attribute, expected_number_a, expected_operator_a,
 246     expected_percent_a, expected_positive_a, expected_pseudo_a,
 247     expected_selector_a, expected_small_a, expected_space_a_b, expected_string_a,
 248     expected_style_attribute, expected_style_pattern, expected_tagname_a,
 249     expected_type_a, f, fieldset, figure, filter, first, flag, float, floor,
 250     font, 'font-family', 'font-size', 'font-size-adjust', 'font-stretch',
 251     'font-style', 'font-variant', 'font-weight', footer, forEach, for_if, forin,
 252     form, fragment, frame, frameset, from, fromCharCode, fud, funct, function,
 253     function_block, function_eval, function_loop, function_statement,
 254     function_strict, functions, global, globals, h1, h2, h3, h4, h5, h6,
 255     handheld, hasOwnProperty, head, header, height, hgroup, hr,
 256     'hta:application', html, html_confusion_a, html_handlers, i, id, identifier,
 257     identifier_function, iframe, img, immed, implied_evil, in, indent, indexOf,
 258     infix_in, init, input, ins, insecure_a, isAlpha, isArray, isDigit, isNaN,
 259     join, jslint, json, kbd, keygen, keys, label, label_a_b, labeled, lang, lbp,
 260     leading_decimal_a, led, left, legend, length, 'letter-spacing', li, lib,
 261     line, 'line-height', link, 'list-style', 'list-style-image',
 262     'list-style-position', 'list-style-type', map, margin, 'margin-bottom',
 263     'margin-left', 'margin-right', 'margin-top', mark, 'marker-offset', match,
 264     'max-height', 'max-width', maxerr, maxlen, member, menu, message, meta,
 265     meter, 'min-height', 'min-width', missing_a, missing_a_after_b,
 266     missing_option, missing_property, missing_space_a_b, missing_url,
 267     missing_use_strict, mixed, mm, mode, move_invocation, move_var, n, name,
 268     name_function, nav, nested_comment, newcap, node, noframes, nomen, noscript,
 269     not, not_a_constructor, not_a_defined, not_a_function, not_a_label,
 270     not_a_scope, not_greater, nud, number, object, octal_a, ol, on, opacity,
 271     open, optgroup, option, outer, outline, 'outline-color', 'outline-style',
 272     'outline-width', output, overflow, 'overflow-x', 'overflow-y', p, padding,
 273     'padding-bottom', 'padding-left', 'padding-right', 'padding-top',
 274     'page-break-after', 'page-break-before', param, parameter_a_get_b,
 275     parameter_arguments_a, parameter_set_a, params, paren, parent, passfail, pc,
 276     plusplus, pop, position, postscript, pre, predef, print, progress,
 277     projection, properties, prototype, pt, push, px, q, quote, quotes, r, radix,
 278     range, raw, read_only, reason, redefinition_a, regexp, replace, report,
 279     reserved, reserved_a, rhino, right, rp, rt, ruby, safe, samp, scanned_a_b,
 280     screen, script, search, second, section, select, shift, slash_equal, slice,
 281     sloppy, small, sort, source, span, speech, split, src, statement_block,
 282     stopping, strange_loop, strict, string, strong, style, styleproperty, sub,
 283     subscript, substr, sup, supplant, t, table, 'table-layout', tag_a_in_b,
 284     tbody, td, test, 'text-align', 'text-decoration', 'text-indent',
 285     'text-shadow', 'text-transform', textarea, tfoot, th, thead, third, thru,
 286     time, title, toLowerCase, toString, toUpperCase, token, too_long, too_many,
 287     top, tr, trailing_decimal_a, tree, tt, tty, tv, type, u, ul, unclosed,
 288     unclosed_comment, unclosed_regexp, undef, undefined, unescaped_a,
 289     unexpected_a, unexpected_char_a_b, unexpected_comment, unexpected_else,
 290     unexpected_property_a, unexpected_space_a_b, 'unicode-bidi',
 291     unnecessary_initialize, unnecessary_use, unparam, unreachable_a_b,
 292     unrecognized_style_attribute_a, unrecognized_tag_a, unsafe, unused, url,
 293     urls, use_array, use_braces, use_charAt, use_object, use_or, use_param,
 294     used_before_a, var, var_a_not, vars, 'vertical-align', video, visibility,
 295     was, weird_assignment, weird_condition, weird_new, weird_program,
 296     weird_relation, weird_ternary, white, 'white-space', widget, width, windows,
 297     'word-spacing', 'word-wrap', wrap, wrap_immediate, wrap_regexp,
 298     write_is_wrong, writeable, 'z-index'
 299 */
 300
 301 // The global directive is used to declare global variables that can
 302 // be accessed by the program. If a declaration is true, then the variable
 303 // is writeable. Otherwise, it is read-only.
 304
 305 // We build the application inside a function so that we produce only a single
 306 // global variable. That function will be invoked immediately, and its return
 307 // value is the JSLINT function itself. That function is also an object that
 308 // can contain data and other functions.
 309
 310 var JSLINT = (function () {
 311     'use strict';
 312
 313     function array_to_object(array, value) {
 314
 315 // Make an object from an array of keys and a common value.
 316
 317         var i, length = array.length, object = {};
 318         for (i = 0; i < length; i += 1) {
 319             object[array[i]] = value;
 320         }
 321         return object;
 322     }
 323
 324
 325     var adsafe_id,      // The widget's ADsafe id.
 326         adsafe_may,     // The widget may load approved scripts.
 327         adsafe_top,     // At the top of the widget script.
 328         adsafe_went,    // ADSAFE.go has been called.
 329         allowed_option = {
 330             anon      : true,
 331             bitwise   : true,
 332             browser   : true,
 333             cap       : true,
 334             'continue': true,
 335             css       : true,
 336             debug     : true,
 337             devel     : true,
 338             eqeq      : true,
 339             es5       : true,
 340             evil      : true,
 341             forin     : true,
 342             fragment  : true,
 343             indent    :   10,
 344             maxerr    : 1000,
 345             maxlen    :  256,
 346             newcap    : true,
 347             node      : true,
 348             nomen     : true,
 349             on        : true,
 350             passfail  : true,
 351             plusplus  : true,
 352             properties: true,
 353             regexp    : true,
 354             rhino     : true,
 355             undef     : true,
 356             unparam   : true,
 357             sloppy    : true,
 358             sub       : true,
 359             vars      : true,
 360             white     : true,
 361             widget    : true,
 362             windows   : true
 363         },
 364         anonname,       // The guessed name for anonymous functions.
 365         approved,       // ADsafe approved urls.
 366
 367 // These are operators that should not be used with the ! operator.
 368
 369         bang = {
 370             '<'  : true,
 371             '<=' : true,
 372             '==' : true,
 373             '===': true,
 374             '!==': true,
 375             '!=' : true,
 376             '>'  : true,
 377             '>=' : true,
 378             '+'  : true,
 379             '-'  : true,
 380             '*'  : true,
 381             '/'  : true,
 382             '%'  : true
 383         },
 384
 385 // These are property names that should not be permitted in the safe subset.
 386
 387         banned = array_to_object([
 388             'arguments', 'callee', 'caller', 'constructor', 'eval', 'prototype',
 389             'stack', 'unwatch', 'valueOf', 'watch'
 390         ], true),
 391         begin,          // The root token
 392
 393 // browser contains a set of global names that are commonly provided by a
 394 // web browser environment.
 395
 396         browser = array_to_object([
 397             'clearInterval', 'clearTimeout', 'document', 'event', 'frames',
 398             'history', 'Image', 'localStorage', 'location', 'name', 'navigator',
 399             'Option', 'parent', 'screen', 'sessionStorage', 'setInterval',
 400             'setTimeout', 'Storage', 'window', 'XMLHttpRequest'
 401         ], false),
 402
 403 // bundle contains the text messages.
 404
 405         bundle = {
 406             a_label: "'{a}' is a statement label.",
 407             a_not_allowed: "'{a}' is not allowed.",
 408             a_not_defined: "'{a}' is not defined.",
 409             a_scope: "'{a}' used out of scope.",
 410             adsafe_a: "ADsafe violation: '{a}'.",
 411             adsafe_autocomplete: "ADsafe autocomplete violation.",
 412             adsafe_bad_id: "ADSAFE violation: bad id.",
 413             adsafe_div: "ADsafe violation: Wrap the widget in a div.",
 414             adsafe_fragment: "ADSAFE: Use the fragment option.",
 415             adsafe_go: "ADsafe violation: Misformed ADSAFE.go.",
 416             adsafe_html: "Currently, ADsafe does not operate on whole HTML " +
 417                 "documents. It operates on <div> fragments and .js files.",
 418             adsafe_id: "ADsafe violation: id does not match.",
 419             adsafe_id_go: "ADsafe violation: Missing ADSAFE.id or ADSAFE.go.",
 420             adsafe_lib: "ADsafe lib violation.",
 421             adsafe_lib_second: "ADsafe: The second argument to lib must be a function.",
 422             adsafe_missing_id: "ADSAFE violation: missing ID_.",
 423             adsafe_name_a: "ADsafe name violation: '{a}'.",
 424             adsafe_placement: "ADsafe script placement violation.",
 425             adsafe_prefix_a: "ADsafe violation: An id must have a '{a}' prefix",
 426             adsafe_script: "ADsafe script violation.",
 427             adsafe_source: "ADsafe unapproved script source.",
 428             adsafe_subscript_a: "ADsafe subscript '{a}'.",
 429             adsafe_tag: "ADsafe violation: Disallowed tag '{a}'.",
 430             already_defined: "'{a}' is already defined.",
 431             and: "The '&&' subexpression should be wrapped in parens.",
 432             assign_exception: "Do not assign to the exception parameter.",
 433             assignment_function_expression: "Expected an assignment or " +
 434                 "function call and instead saw an expression.",
 435             attribute_case_a: "Attribute '{a}' not all lower case.",
 436             avoid_a: "Avoid '{a}'.",
 437             bad_assignment: "Bad assignment.",
 438             bad_color_a: "Bad hex color '{a}'.",
 439             bad_constructor: "Bad constructor.",
 440             bad_entity: "Bad entity.",
 441             bad_html: "Bad HTML string",
 442             bad_id_a: "Bad id: '{a}'.",
 443             bad_in_a: "Bad for in variable '{a}'.",
 444             bad_invocation: "Bad invocation.",
 445             bad_name_a: "Bad name: '{a}'.",
 446             bad_new: "Do not use 'new' for side effects.",
 447             bad_number: "Bad number '{a}'.",
 448             bad_operand: "Bad operand.",
 449             bad_style: "Bad style.",
 450             bad_type: "Bad type.",
 451             bad_url_a: "Bad url '{a}'.",
 452             bad_wrap: "Do not wrap function literals in parens unless they " +
 453                 "are to be immediately invoked.",
 454             combine_var: "Combine this with the previous 'var' statement.",
 455             conditional_assignment: "Expected a conditional expression and " +
 456                 "instead saw an assignment.",
 457             confusing_a: "Confusing use of '{a}'.",
 458             confusing_regexp: "Confusing regular expression.",
 459             constructor_name_a: "A constructor name '{a}' should start with " +
 460                 "an uppercase letter.",
 461             control_a: "Unexpected control character '{a}'.",
 462             css: "A css file should begin with @charset 'UTF-8';",
 463             dangling_a: "Unexpected dangling '_' in '{a}'.",
 464             dangerous_comment: "Dangerous comment.",
 465             deleted: "Only properties should be deleted.",
 466             duplicate_a: "Duplicate '{a}'.",
 467             empty_block: "Empty block.",
 468             empty_case: "Empty case.",
 469             empty_class: "Empty class.",
 470             es5: "This is an ES5 feature.",
 471             evil: "eval is evil.",
 472             expected_a: "Expected '{a}'.",
 473             expected_a_b: "Expected '{a}' and instead saw '{b}'.",
 474             expected_a_b_from_c_d: "Expected '{a}' to match '{b}' from line " +
 475                 "{c} and instead saw '{d}'.",
 476             expected_at_a: "Expected an at-rule, and instead saw @{a}.",
 477             expected_a_at_b_c: "Expected '{a}' at column {b}, not column {c}.",
 478             expected_attribute_a: "Expected an attribute, and instead saw [{a}].",
 479             expected_attribute_value_a: "Expected an attribute value and " +
 480                 "instead saw '{a}'.",
 481             expected_class_a: "Expected a class, and instead saw .{a}.",
 482             expected_fraction_a: "Expected a number between 0 and 1 and " +
 483                 "instead saw '{a}'",
 484             expected_id_a: "Expected an id, and instead saw #{a}.",
 485             expected_identifier_a: "Expected an identifier and instead saw '{a}'.",
 486             expected_identifier_a_reserved: "Expected an identifier and " +
 487                 "instead saw '{a}' (a reserved word).",
 488             expected_linear_a: "Expected a linear unit and instead saw '{a}'.",
 489             expected_lang_a: "Expected a lang code, and instead saw :{a}.",
 490             expected_media_a: "Expected a CSS media type, and instead saw '{a}'.",
 491             expected_name_a: "Expected a name and instead saw '{a}'.",
 492             expected_nonstandard_style_attribute: "Expected a non-standard " +
 493                 "style attribute and instead saw '{a}'.",
 494             expected_number_a: "Expected a number and instead saw '{a}'.",
 495             expected_operator_a: "Expected an operator and instead saw '{a}'.",
 496             expected_percent_a: "Expected a percentage and instead saw '{a}'",
 497             expected_positive_a: "Expected a positive number and instead saw '{a}'",
 498             expected_pseudo_a: "Expected a pseudo, and instead saw :{a}.",
 499             expected_selector_a: "Expected a CSS selector, and instead saw {a}.",
 500             expected_small_a: "Expected a small positive integer and instead saw '{a}'",
 501             expected_space_a_b: "Expected exactly one space between '{a}' and '{b}'.",
 502             expected_string_a: "Expected a string and instead saw {a}.",
 503             expected_style_attribute: "Excepted a style attribute, and instead saw '{a}'.",
 504             expected_style_pattern: "Expected a style pattern, and instead saw '{a}'.",
 505             expected_tagname_a: "Expected a tagName, and instead saw {a}.",
 506             expected_type_a: "Expected a type, and instead saw {a}.",
 507             for_if: "The body of a for in should be wrapped in an if " +
 508                 "statement to filter unwanted properties from the prototype.",
 509             function_block: "Function statements should not be placed in blocks. " +
 510                 "Use a function expression or move the statement to the top of " +
 511                 "the outer function.",
 512             function_eval: "The Function constructor is eval.",
 513             function_loop: "Don't make functions within a loop.",
 514             function_statement: "Function statements are not invocable. " +
 515                 "Wrap the whole function invocation in parens.",
 516             function_strict: "Use the function form of 'use strict'.",
 517             html_confusion_a: "HTML confusion in regular expression '<{a}'.",
 518             html_handlers: "Avoid HTML event handlers.",
 519             identifier_function: "Expected an identifier in an assignment " +
 520                 "and instead saw a function invocation.",
 521             implied_evil: "Implied eval is evil. Pass a function instead of a string.",
 522             infix_in: "Unexpected 'in'. Compare with undefined, or use the " +
 523                 "hasOwnProperty method instead.",
 524             insecure_a: "Insecure '{a}'.",
 525             isNaN: "Use the isNaN function to compare with NaN.",
 526             label_a_b: "Label '{a}' on '{b}' statement.",
 527             lang: "lang is deprecated.",
 528             leading_decimal_a: "A leading decimal point can be confused with a dot: '.{a}'.",
 529             missing_a: "Missing '{a}'.",
 530             missing_a_after_b: "Missing '{a}' after '{b}'.",
 531             missing_option: "Missing option value.",
 532             missing_property: "Missing property name.",
 533             missing_space_a_b: "Missing space between '{a}' and '{b}'.",
 534             missing_url: "Missing url.",
 535             missing_use_strict: "Missing 'use strict' statement.",
 536             mixed: "Mixed spaces and tabs.",
 537             move_invocation: "Move the invocation into the parens that " +
 538                 "contain the function.",
 539             move_var: "Move 'var' declarations to the top of the function.",
 540             name_function: "Missing name in function statement.",
 541             nested_comment: "Nested comment.",
 542             not: "Nested not.",
 543             not_a_constructor: "Do not use {a} as a constructor.",
 544             not_a_defined: "'{a}' has not been fully defined yet.",
 545             not_a_function: "'{a}' is not a function.",
 546             not_a_label: "'{a}' is not a label.",
 547             not_a_scope: "'{a}' is out of scope.",
 548             not_greater: "'{a}' should not be greater than '{b}'.",
 549             octal_a: "Don't use octal: '{a}'. Use '\\u....' instead.",
 550             parameter_arguments_a: "Do not mutate parameter '{a}' when using 'arguments'.",
 551             parameter_a_get_b: "Unexpected parameter '{a}' in get {b} function.",
 552             parameter_set_a: "Expected parameter (value) in set {a} function.",
 553             radix: "Missing radix parameter.",
 554             read_only: "Read only.",
 555             redefinition_a: "Redefinition of '{a}'.",
 556             reserved_a: "Reserved name '{a}'.",
 557             scanned_a_b: "{a} ({b}% scanned).",
 558             slash_equal: "A regular expression literal can be confused with '/='.",
 559             statement_block: "Expected to see a statement and instead saw a block.",
 560             stopping: "Stopping. ",
 561             strange_loop: "Strange loop.",
 562             strict: "Strict violation.",
 563             subscript: "['{a}'] is better written in dot notation.",
 564             tag_a_in_b: "A '<{a}>' must be within '<{b}>'.",
 565             too_long: "Line too long.",
 566             too_many: "Too many errors.",
 567             trailing_decimal_a: "A trailing decimal point can be confused " +
 568                 "with a dot: '.{a}'.",
 569             type: "type is unnecessary.",
 570             unclosed: "Unclosed string.",
 571             unclosed_comment: "Unclosed comment.",
 572             unclosed_regexp: "Unclosed regular expression.",
 573             unescaped_a: "Unescaped '{a}'.",
 574             unexpected_a: "Unexpected '{a}'.",
 575             unexpected_char_a_b: "Unexpected character '{a}' in {b}.",
 576             unexpected_comment: "Unexpected comment.",
 577             unexpected_else: "Unexpected 'else' after 'return'.",
 578             unexpected_property_a: "Unexpected /*property*/ '{a}'.",
 579             unexpected_space_a_b: "Unexpected space between '{a}' and '{b}'.",
 580             unnecessary_initialize: "It is not necessary to initialize '{a}' " +
 581                 "to 'undefined'.",
 582             unnecessary_use: "Unnecessary 'use strict'.",
 583             unreachable_a_b: "Unreachable '{a}' after '{b}'.",
 584             unrecognized_style_attribute_a: "Unrecognized style attribute '{a}'.",
 585             unrecognized_tag_a: "Unrecognized tag '<{a}>'.",
 586             unsafe: "Unsafe character.",
 587             url: "JavaScript URL.",
 588             use_array: "Use the array literal notation [].",
 589             use_braces: "Spaces are hard to count. Use {{a}}.",
 590             use_charAt: "Use the charAt method.",
 591             use_object: "Use the object literal notation {}.",
 592             use_or: "Use the || operator.",
 593             use_param: "Use a named parameter.",
 594             used_before_a: "'{a}' was used before it was defined.",
 595             var_a_not: "Variable {a} was not declared correctly.",
 596             weird_assignment: "Weird assignment.",
 597             weird_condition: "Weird condition.",
 598             weird_new: "Weird construction. Delete 'new'.",
 599             weird_program: "Weird program.",
 600             weird_relation: "Weird relation.",
 601             weird_ternary: "Weird ternary.",
 602             wrap_immediate: "Wrap an immediate function invocation in parentheses " +
 603                 "to assist the reader in understanding that the expression " +
 604                 "is the result of a function, and not the function itself.",
 605             wrap_regexp: "Wrap the /regexp/ literal in parens to " +
 606                 "disambiguate the slash operator.",
 607             write_is_wrong: "document.write can be a form of eval."
 608         },
 609         comments_off,
 610         css_attribute_data,
 611         css_any,
 612
 613         css_colorData = array_to_object([
 614             "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige",
 615             "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown",
 616             "burlywood", "cadetblue", "chartreuse", "chocolate", "coral",
 617             "cornflowerblue", "cornsilk", "crimson", "cyan", "darkblue",
 618             "darkcyan", "darkgoldenrod", "darkgray", "darkgreen", "darkkhaki",
 619             "darkmagenta", "darkolivegreen", "darkorange", "darkorchid",
 620             "darkred", "darksalmon", "darkseagreen", "darkslateblue",
 621             "darkslategray", "darkturquoise", "darkviolet", "deeppink",
 622             "deepskyblue", "dimgray", "dodgerblue", "firebrick", "floralwhite",
 623             "forestgreen", "fuchsia", "gainsboro", "ghostwhite", "gold",
 624             "goldenrod", "gray", "green", "greenyellow", "honeydew", "hotpink",
 625             "indianred", "indigo", "ivory", "khaki", "lavender",
 626             "lavenderblush", "lawngreen", "lemonchiffon", "lightblue",
 627             "lightcoral", "lightcyan", "lightgoldenrodyellow", "lightgreen",
 628             "lightpink", "lightsalmon", "lightseagreen", "lightskyblue",
 629             "lightslategray", "lightsteelblue", "lightyellow", "lime",
 630             "limegreen", "linen", "magenta", "maroon", "mediumaquamarine",
 631             "mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen",
 632             "mediumslateblue", "mediumspringgreen", "mediumturquoise",
 633             "mediumvioletred", "midnightblue", "mintcream", "mistyrose",
 634             "moccasin", "navajowhite", "navy", "oldlace", "olive", "olivedrab",
 635             "orange", "orangered", "orchid", "palegoldenrod", "palegreen",
 636             "paleturquoise", "palevioletred", "papayawhip", "peachpuff",
 637             "peru", "pink", "plum", "powderblue", "purple", "red", "rosybrown",
 638             "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen",
 639             "seashell", "sienna", "silver", "skyblue", "slateblue", "slategray",
 640             "snow", "springgreen", "steelblue", "tan", "teal", "thistle",
 641             "tomato", "turquoise", "violet", "wheat", "white", "whitesmoke",
 642             "yellow", "yellowgreen",
 643
 644             "activeborder", "activecaption", "appworkspace", "background",
 645             "buttonface", "buttonhighlight", "buttonshadow", "buttontext",
 646             "captiontext", "graytext", "highlight", "highlighttext",
 647             "inactiveborder", "inactivecaption", "inactivecaptiontext",
 648             "infobackground", "infotext", "menu", "menutext", "scrollbar",
 649             "threeddarkshadow", "threedface", "threedhighlight",
 650             "threedlightshadow", "threedshadow", "window", "windowframe",
 651             "windowtext"
 652         ], true),
 653
 654         css_border_style,
 655         css_break,
 656
 657         css_lengthData = {
 658             '%': true,
 659             'cm': true,
 660             'em': true,
 661             'ex': true,
 662             'in': true,
 663             'mm': true,
 664             'pc': true,
 665             'pt': true,
 666             'px': true
 667         },
 668
 669         css_media,
 670         css_overflow,
 671
 672         descapes = {
 673             'b': '\b',
 674             't': '\t',
 675             'n': '\n',
 676             'f': '\f',
 677             'r': '\r',
 678             '"': '"',
 679             '/': '/',
 680             '\\': '\\'
 681         },
 682
 683         devel = array_to_object([
 684             'alert', 'confirm', 'console', 'Debug', 'opera', 'prompt', 'WSH'
 685         ], false),
 686         directive,
 687         escapes = {
 688             '\b': '\\b',
 689             '\t': '\\t',
 690             '\n': '\\n',
 691             '\f': '\\f',
 692             '\r': '\\r',
 693             '\'': '\\\'',
 694             '"' : '\\"',
 695             '/' : '\\/',
 696             '\\': '\\\\'
 697         },
 698
 699         funct,          // The current function, including the labels used in
 700                         // the function, as well as (breakage),
 701                         // (context), (loopage), (name), (params), (token),
 702                         // (vars), (verb)
 703
 704         functionicity = [
 705             'closure', 'exception', 'global', 'label', 'outer', 'undef',
 706             'unused', 'var'
 707         ],
 708
 709         functions,      // All of the functions
 710         global_funct,   // The global body
 711         global_scope,   // The global scope
 712         html_tag = {
 713             a:        {},
 714             abbr:     {},
 715             acronym:  {},
 716             address:  {},
 717             applet:   {},
 718             area:     {empty: true, parent: ' map '},
 719             article:  {},
 720             aside:    {},
 721             audio:    {},
 722             b:        {},
 723             base:     {empty: true, parent: ' head '},
 724             bdo:      {},
 725             big:      {},
 726             blockquote: {},
 727             body:     {parent: ' html noframes '},
 728             br:       {empty: true},
 729             button:   {},
 730             canvas:   {parent: ' body p div th td '},
 731             caption:  {parent: ' table '},
 732             center:   {},
 733             cite:     {},
 734             code:     {},
 735             col:      {empty: true, parent: ' table colgroup '},
 736             colgroup: {parent: ' table '},
 737             command:  {parent: ' menu '},
 738             datalist: {},
 739             dd:       {parent: ' dl '},
 740             del:      {},
 741             details:  {},
 742             dialog:   {},
 743             dfn:      {},
 744             dir:      {},
 745             div:      {},
 746             dl:       {},
 747             dt:       {parent: ' dl '},
 748             em:       {},
 749             embed:    {},
 750             fieldset: {},
 751             figure:   {},
 752             font:     {},
 753             footer:   {},
 754             form:     {},
 755             frame:    {empty: true, parent: ' frameset '},
 756             frameset: {parent: ' html frameset '},
 757             h1:       {},
 758             h2:       {},
 759             h3:       {},
 760             h4:       {},
 761             h5:       {},
 762             h6:       {},
 763             head:     {parent: ' html '},
 764             header:   {},
 765             hgroup:   {},
 766             hr:       {empty: true},
 767             'hta:application':
 768                       {empty: true, parent: ' head '},
 769             html:     {parent: '*'},
 770             i:        {},
 771             iframe:   {},
 772             img:      {empty: true},
 773             input:    {empty: true},
 774             ins:      {},
 775             kbd:      {},
 776             keygen:   {},
 777             label:    {},
 778             legend:   {parent: ' details fieldset figure '},
 779             li:       {parent: ' dir menu ol ul '},
 780             link:     {empty: true, parent: ' head '},
 781             map:      {},
 782             mark:     {},
 783             menu:     {},
 784             meta:     {empty: true, parent: ' head noframes noscript '},
 785             meter:    {},
 786             nav:      {},
 787             noframes: {parent: ' html body '},
 788             noscript: {parent: ' body head noframes '},
 789             object:   {},
 790             ol:       {},
 791             optgroup: {parent: ' select '},
 792             option:   {parent: ' optgroup select '},
 793             output:   {},
 794             p:        {},
 795             param:    {empty: true, parent: ' applet object '},
 796             pre:      {},
 797             progress: {},
 798             q:        {},
 799             rp:       {},
 800             rt:       {},
 801             ruby:     {},
 802             samp:     {},
 803             script:   {empty: true, parent: ' body div frame head iframe p pre span '},
 804             section:  {},
 805             select:   {},
 806             small:    {},
 807             span:     {},
 808             source:   {},
 809             strong:   {},
 810             style:    {parent: ' head ', empty: true},
 811             sub:      {},
 812             sup:      {},
 813             table:    {},
 814             tbody:    {parent: ' table '},
 815             td:       {parent: ' tr '},
 816             textarea: {},
 817             tfoot:    {parent: ' table '},
 818             th:       {parent: ' tr '},
 819             thead:    {parent: ' table '},
 820             time:     {},
 821             title:    {parent: ' head '},
 822             tr:       {parent: ' table tbody thead tfoot '},
 823             tt:       {},
 824             u:        {},
 825             ul:       {},
 826             'var':    {},
 827             video:    {}
 828         },
 829
 830         ids,            // HTML ids
 831         in_block,
 832         indent,
 833         itself,         // JSLint itself
 834         json_mode,
 835         lex,            // the tokenizer
 836         lines,
 837         lookahead,
 838         node = array_to_object([
 839             'Buffer', 'clearInterval', 'clearTimeout', 'console', 'exports',
 840             'global', 'module', 'process', 'querystring', 'require',
 841             'setInterval', 'setTimeout', '__dirname', '__filename'
 842         ], false),
 843         node_js,
 844         numbery = array_to_object(['indexOf', 'lastIndexOf', 'search'], true),
 845         next_token,
 846         option,
 847         predefined,     // Global variables defined by option
 848         prereg,
 849         prev_token,
 850         property,
 851         regexp_flag = array_to_object(['g', 'i', 'm'], true),
 852         return_this = function return_this() {
 853             return this;
 854         },
 855         rhino = array_to_object([
 856             'defineClass', 'deserialize', 'gc', 'help', 'load', 'loadClass',
 857             'print', 'quit', 'readFile', 'readUrl', 'runCommand', 'seal',
 858             'serialize', 'spawn', 'sync', 'toint32', 'version'
 859         ], false),
 860
 861         scope,      // An object containing an object for each variable in scope
 862         semicolon_coda = array_to_object([';', '"', '\'', ')'], true),
 863         src,
 864         stack,
 865
 866 // standard contains the global names that are provided by the
 867 // ECMAScript standard.
 868
 869         standard = array_to_object([
 870             'Array', 'Boolean', 'Date', 'decodeURI', 'decodeURIComponent',
 871             'encodeURI', 'encodeURIComponent', 'Error', 'eval', 'EvalError',
 872             'Function', 'isFinite', 'isNaN', 'JSON', 'Math', 'Number',
 873             'Object', 'parseInt', 'parseFloat', 'RangeError', 'ReferenceError',
 874             'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError'
 875         ], false),
 876
 877         strict_mode,
 878         syntax = {},
 879         tab,
 880         token,
 881         urls,
 882         var_mode,
 883         warnings,
 884
 885 // widget contains the global names which are provided to a Yahoo
 886 // (fna Konfabulator) widget.
 887
 888         widget = array_to_object([
 889             'alert', 'animator', 'appleScript', 'beep', 'bytesToUIString',
 890             'Canvas', 'chooseColor', 'chooseFile', 'chooseFolder',
 891             'closeWidget', 'COM', 'convertPathToHFS', 'convertPathToPlatform',
 892             'CustomAnimation', 'escape', 'FadeAnimation', 'filesystem', 'Flash',
 893             'focusWidget', 'form', 'FormField', 'Frame', 'HotKey', 'Image',
 894             'include', 'isApplicationRunning', 'iTunes', 'konfabulatorVersion',
 895             'log', 'md5', 'MenuItem', 'MoveAnimation', 'openURL', 'play',
 896             'Point', 'popupMenu', 'preferenceGroups', 'preferences', 'print',
 897             'prompt', 'random', 'Rectangle', 'reloadWidget', 'ResizeAnimation',
 898             'resolvePath', 'resumeUpdates', 'RotateAnimation', 'runCommand',
 899             'runCommandInBg', 'saveAs', 'savePreferences', 'screen',
 900             'ScrollBar', 'showWidgetPreferences', 'sleep', 'speak', 'Style',
 901             'suppressUpdates', 'system', 'tellWidget', 'Text', 'TextArea',
 902             'Timer', 'unescape', 'updateNow', 'URL', 'Web', 'widget', 'Window',
 903             'XMLDOM', 'XMLHttpRequest', 'yahooCheckLogin', 'yahooLogin',
 904             'yahooLogout'
 905         ], true),
 906
 907         windows = array_to_object([
 908             'ActiveXObject', 'CScript', 'Debug', 'Enumerator', 'System',
 909             'VBArray', 'WScript', 'WSH'
 910         ], false),
 911
 912 //  xmode is used to adapt to the exceptions in html parsing.
 913 //  It can have these states:
 914 //      ''      .js script file
 915 //      'html'
 916 //      'outer'
 917 //      'script'
 918 //      'style'
 919 //      'scriptstring'
 920 //      'styleproperty'
 921
 922         xmode,
 923         xquote,
 924
 925 // Regular expressions. Some of these are stupidly long.
 926
 927 // unsafe comment or string
 928         ax = /@cc|<\/?|script|\]\s*\]|<\s*!|&lt/i,
 929 // carriage return, carriage return linefeed, or linefeed
 930         crlfx = /\r\n?|\n/,
 931 // unsafe characters that are silently deleted by one or more browsers
 932         cx = /[\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/,
 933 // query characters for ids
 934         dx = /[\[\]\/\\"'*<>.&:(){}+=#]/,
 935 // html token
 936         hx = /^\s*(['"=>\/&#]|<(?:\/|\!(?:--)?)?|[a-zA-Z][a-zA-Z0-9_\-:]*|[0-9]+|--)/,
 937 // identifier
 938         ix = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/,
 939 // javascript url
 940         jx = /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i,
 941 // star slash
 942         lx = /\*\/|\/\*/,
 943 // characters in strings that need escapement
 944         nx = /[\u0000-\u001f'\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
 945 // outer html token
 946         ox = /[>&]|<[\/!]?|--/,
 947 // attributes characters
 948         qx = /[^a-zA-Z0-9+\-_\/ ]/,
 949 // style
 950         sx = /^\s*([{}:#%.=,>+\[\]@()"';]|[*$\^~]=|[a-zA-Z_][a-zA-Z0-9_\-]*|[0-9]+|<\/|\/\*)/,
 951         ssx = /^\s*([@#!"'};:\-%.=,+\[\]()*_]|[a-zA-Z][a-zA-Z0-9._\-]*|\/\*?|\d+(?:\.\d+)?|<\/)/,
 952 // token
 953         tx = /^\s*([(){}\[\]\?.,:;'"~#@`]|={1,3}|\/(\*(jslint|properties|property|members?|globals?)?|=|\/)?|\*[\/=]?|\+(?:=|\++)?|-(?:=|-+)?|[\^%]=?|&[&=]?|\|[|=]?|>{1,3}=?|<(?:[\/=!]|\!(\[|--)?|<=?)?|\!={0,2}|[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+(?:[xX][0-9a-fA-F]+|\.[0-9]*)?(?:[eE][+\-]?[0-9]+)?)/,
 954 // url badness
 955         ux = /&|\+|\u00AD|\.\.|\/\*|%[^;]|base64|url|expression|data|mailto|script/i,
 956
 957         rx = {
 958             outer: hx,
 959             html: hx,
 960             style: sx,
 961             styleproperty: ssx
 962         };
 963
 964
 965     function F() {}     // Used by Object.create
 966
 967 // Provide critical ES5 functions to ES3.
 968
 969     if (typeof Array.prototype.filter !== 'function') {
 970         Array.prototype.filter = function (f) {
 971             var i, length = this.length, result = [], value;
 972             for (i = 0; i < length; i += 1) {
 973                 try {
 974                     value = this[i];
 975                     if (f(value)) {
 976                         result.push(value);
 977                     }
 978                 } catch (ignore) {
 979                 }
 980             }
 981             return result;
 982         };
 983     }
 984
 985     if (typeof Array.prototype.forEach !== 'function') {
 986         Array.prototype.forEach = function (f) {
 987             var i, length = this.length;
 988             for (i = 0; i < length; i += 1) {
 989                 try {
 990                     f(this[i]);
 991                 } catch (ignore) {
 992                 }
 993             }
 994         };
 995     }
 996
 997     if (typeof Array.isArray !== 'function') {
 998         Array.isArray = function (o) {
 999             return Object.prototype.toString.apply(o) === '[object Array]';
1000         };
1001     }
1002
1003     if (!Object.prototype.hasOwnProperty.call(Object, 'create')) {
1004         Object.create = function (o) {
1005             F.prototype = o;
1006             return new F();
1007         };
1008     }
1009
1010     if (typeof Object.keys !== 'function') {
1011         Object.keys = function (o) {
1012             var array = [], key;
1013             for (key in o) {
1014                 if (Object.prototype.hasOwnProperty.call(o, key)) {
1015                     array.push(key);
1016                 }
1017             }
1018             return array;
1019         };
1020     }
1021
1022     if (typeof String.prototype.entityify !== 'function') {
1023         String.prototype.entityify = function () {
1024             return this
1025                 .replace(/&/g, '&amp;')
1026                 .replace(/</g, '&lt;')
1027                 .replace(/>/g, '&gt;');
1028         };
1029     }
1030
1031     if (typeof String.prototype.isAlpha !== 'function') {
1032         String.prototype.isAlpha = function () {
1033             return (this >= 'a' && this <= 'z\uffff') ||
1034                 (this >= 'A' && this <= 'Z\uffff');
1035         };
1036     }
1037
1038     if (typeof String.prototype.isDigit !== 'function') {
1039         String.prototype.isDigit = function () {
1040             return (this >= '0' && this <= '9');
1041         };
1042     }
1043
1044     if (typeof String.prototype.supplant !== 'function') {
1045         String.prototype.supplant = function (o) {
1046             return this.replace(/\{([^{}]*)\}/g, function (a, b) {
1047                 var replacement = o[b];
1048                 return typeof replacement === 'string' ||
1049                     typeof replacement === 'number' ? replacement : a;
1050             });
1051         };
1052     }
1053
1054
1055     function sanitize(a) {
1056
1057 //  Escapify a troublesome character.
1058
1059         return escapes[a] ||
1060             '\\u' + ('0000' + a.charCodeAt().toString(16)).slice(-4);
1061     }
1062
1063
1064     function add_to_predefined(group) {
1065         Object.keys(group).forEach(function (name) {
1066             predefined[name] = group[name];
1067         });
1068     }
1069
1070
1071     function assume() {
1072         if (!option.safe) {
1073             if (option.rhino) {
1074                 add_to_predefined(rhino);
1075                 option.rhino = false;
1076             }
1077             if (option.devel) {
1078                 add_to_predefined(devel);
1079                 option.devel = false;
1080             }
1081             if (option.browser) {
1082                 add_to_predefined(browser);
1083                 option.browser = false;
1084             }
1085             if (option.windows) {
1086                 add_to_predefined(windows);
1087                 option.windows = false;
1088             }
1089             if (option.node) {
1090                 add_to_predefined(node);
1091                 option.node = false;
1092                 node_js = true;
1093             }
1094             if (option.widget) {
1095                 add_to_predefined(widget);
1096                 option.widget = false;
1097             }
1098         }
1099     }
1100
1101
1102 // Produce an error warning.
1103
1104     function artifact(tok) {
1105         if (!tok) {
1106             tok = next_token;
1107         }
1108         return tok.number || tok.string;
1109     }
1110
1111     function quit(message, line, character) {
1112         throw {
1113             name: 'JSLintError',
1114             line: line,
1115             character: character,
1116             message: bundle.scanned_a_b.supplant({
1117                 a: message,
1118                 b: Math.floor((line / lines.length) * 100)
1119             })
1120         };
1121     }
1122
1123     function warn(message, offender, a, b, c, d) {
1124         var character, line, warning;
1125         offender = offender || next_token;  // ~~
1126         line = offender.line || 0;
1127         character = offender.from || 0;
1128         warning = {
1129             id: '(error)',
1130             raw: bundle[message] || message,
1131             evidence: lines[line - 1] || '',
1132             line: line,
1133             character: character,
1134             a: a || (offender.id === '(number)'
1135                 ? String(offender.number)
1136                 : offender.string),
1137             b: b,
1138             c: c,
1139             d: d
1140         };
1141         warning.reason = warning.raw.supplant(warning);
1142         JSLINT.errors.push(warning);
1143         if (option.passfail) {
1144             quit(bundle.stopping, line, character);
1145         }
1146         warnings += 1;
1147         if (warnings >= option.maxerr) {
1148             quit(bundle.too_many, line, character);
1149         }
1150         return warning;
1151     }
1152
1153     function warn_at(message, line, character, a, b, c, d) {
1154         return warn(message, {
1155             line: line,
1156             from: character
1157         }, a, b, c, d);
1158     }
1159
1160     function stop(message, offender, a, b, c, d) {
1161         var warning = warn(message, offender, a, b, c, d);
1162         quit(bundle.stopping, warning.line, warning.character);
1163     }
1164
1165     function stop_at(message, line, character, a, b, c, d) {
1166         return stop(message, {
1167             line: line,
1168             from: character
1169         }, a, b, c, d);
1170     }
1171
1172     function expected_at(at) {
1173         if (!option.white && next_token.from !== at) {
1174             warn('expected_a_at_b_c', next_token, '', at,
1175                 next_token.from);
1176         }
1177     }
1178
1179     function aint(it, name, expected) {
1180         if (it[name] !== expected) {
1181             warn('expected_a_b', it, expected, it[name]);
1182             return true;
1183         }
1184         return false;
1185     }
1186
1187
1188 // lexical analysis and token construction
1189
1190     lex = (function lex() {
1191         var character, c, from, length, line, pos, source_row;
1192
1193 // Private lex methods
1194
1195         function next_line() {
1196             var at;
1197             if (line >= lines.length) {
1198                 return false;
1199             }
1200             character = 1;
1201             source_row = lines[line];
1202             line += 1;
1203             at = source_row.search(/ \t/);
1204             if (at >= 0) {
1205                 warn_at('mixed', line, at + 1);
1206             }
1207             source_row = source_row.replace(/\t/g, tab);
1208             at = source_row.search(cx);
1209             if (at >= 0) {
1210                 warn_at('unsafe', line, at);
1211             }
1212             if (option.maxlen && option.maxlen < source_row.length) {
1213                 warn_at('too_long', line, source_row.length);
1214             }
1215             return true;
1216         }
1217
1218 // Produce a token object.  The token inherits from a syntax symbol.
1219
1220         function it(type, value) {
1221             var id, the_token;
1222             if (type === '(string)' || type === '(range)') {
1223                 if (jx.test(value)) {
1224                     warn_at('url', line, from);
1225                 }
1226             }
1227             the_token = Object.create(syntax[(
1228                 type === '(punctuator)' || (type === '(identifier)' &&
1229                         Object.prototype.hasOwnProperty.call(syntax, value))
1230                     ? value
1231                     : type
1232             )] || syntax['(error)']);
1233             if (type === '(identifier)') {
1234                 the_token.identifier = true;
1235                 if (value === '__iterator__' || value === '__proto__') {
1236                     stop_at('reserved_a', line, from, value);
1237                 } else if (!option.nomen &&
1238                         (value.charAt(0) === '_' ||
1239                         value.charAt(value.length - 1) === '_')) {
1240                     warn_at('dangling_a', line, from, value);
1241                 }
1242             }
1243             if (type === '(number)') {
1244                 the_token.number = +value;
1245             } else if (value !== undefined) {
1246                 the_token.string = String(value);
1247             }
1248             the_token.line = line;
1249             the_token.from = from;
1250             the_token.thru = character;
1251             id = the_token.id;
1252             prereg = id && (
1253                 ('(,=:[!&|?{};'.indexOf(id.charAt(id.length - 1)) >= 0) ||
1254                 id === 'return' || id === 'case'
1255             );
1256             return the_token;
1257         }
1258
1259         function match(x) {
1260             var exec = x.exec(source_row), first;
1261             if (exec) {
1262                 length = exec[0].length;
1263                 first = exec[1];
1264                 c = first.charAt(0);
1265                 source_row = source_row.slice(length);
1266                 from = character + length - first.length;
1267                 character += length;
1268                 return first;
1269             }
1270         }
1271
1272         function string(x) {
1273             var c, pos = 0, r = '', result;
1274
1275             function hex(n) {
1276                 var i = parseInt(source_row.substr(pos + 1, n), 16);
1277                 pos += n;
1278                 if (i >= 32 && i <= 126 &&
1279                         i !== 34 && i !== 92 && i !== 39) {
1280                     warn_at('unexpected_a', line, character, '\\');
1281                 }
1282                 character += n;
1283                 c = String.fromCharCode(i);
1284             }
1285
1286             if (json_mode && x !== '"') {
1287                 warn_at('expected_a', line, character, '"');
1288             }
1289
1290             if (xquote === x || (xmode === 'scriptstring' && !xquote)) {
1291                 return it('(punctuator)', x);
1292             }
1293
1294             for (;;) {
1295                 while (pos >= source_row.length) {
1296                     pos = 0;
1297                     if (xmode !== 'html' || !next_line()) {
1298                         stop_at('unclosed', line, from);
1299                     }
1300                 }
1301                 c = source_row.charAt(pos);
1302                 if (c === x) {
1303                     character += 1;
1304                     source_row = source_row.slice(pos + 1);
1305                     result = it('(string)', r);
1306                     result.quote = x;
1307                     return result;
1308                 }
1309                 if (c < ' ') {
1310                     if (c === '\n' || c === '\r') {
1311                         break;
1312                     }
1313                     warn_at('control_a', line, character + pos,
1314                         source_row.slice(0, pos));
1315                 } else if (c === xquote) {
1316                     warn_at('bad_html', line, character + pos);
1317                 } else if (c === '<') {
1318                     if (option.safe && xmode === 'html') {
1319                         warn_at('adsafe_a', line, character + pos, c);
1320                     } else if (source_row.charAt(pos + 1) === '/' && (xmode || option.safe)) {
1321                         warn_at('expected_a_b', line, character,
1322                             '<\\/', '</');
1323                     } else if (source_row.charAt(pos + 1) === '!' && (xmode || option.safe)) {
1324                         warn_at('unexpected_a', line, character, '<!');
1325                     }
1326                 } else if (c === '\\') {
1327                     if (xmode === 'html') {
1328                         if (option.safe) {
1329                             warn_at('adsafe_a', line, character + pos, c);
1330                         }
1331                     } else if (xmode === 'styleproperty') {
1332                         pos += 1;
1333                         character += 1;
1334                         c = source_row.charAt(pos);
1335                         if (c !== x) {
1336                             warn_at('unexpected_a', line, character, '\\');
1337                         }
1338                     } else {
1339                         pos += 1;
1340                         character += 1;
1341                         c = source_row.charAt(pos);
1342                         switch (c) {
1343                         case '':
1344                             if (!option.es5) {
1345                                 warn_at('es5', line, character);
1346                             }
1347                             next_line();
1348                             pos = -1;
1349                             break;
1350                         case xquote:
1351                             warn_at('bad_html', line, character + pos);
1352                             break;
1353                         case '\'':
1354                             if (json_mode) {
1355                                 warn_at('unexpected_a', line, character, '\\\'');
1356                             }
1357                             break;
1358                         case 'u':
1359                             hex(4);
1360                             break;
1361                         case 'v':
1362                             if (json_mode) {
1363                                 warn_at('unexpected_a', line, character, '\\v');
1364                             }
1365                             c = '\v';
1366                             break;
1367                         case 'x':
1368                             if (json_mode) {
1369                                 warn_at('unexpected_a', line, character, '\\x');
1370                             }
1371                             hex(2);
1372                             break;
1373                         default:
1374                             if (typeof descapes[c] !== 'string') {
1375                                 warn_at(c >= '0' && c <= '7' ? 'octal_a' : 'unexpected_a',
1376                                     line, character, '\\' + c);
1377                             } else {
1378                                 c = descapes[c];
1379                             }
1380                         }
1381                     }
1382                 }
1383                 r += c;
1384                 character += 1;
1385                 pos += 1;
1386             }
1387         }
1388
1389         function number(snippet) {
1390             var digit;
1391             if (xmode !== 'style' && xmode !== 'styleproperty' &&
1392                     source_row.charAt(0).isAlpha()) {
1393                 warn_at('expected_space_a_b',
1394                     line, character, c, source_row.charAt(0));
1395             }
1396             if (c === '0') {
1397                 digit = snippet.charAt(1);
1398                 if (digit.isDigit()) {
1399                     if (token.id !== '.' && xmode !== 'styleproperty') {
1400                         warn_at('unexpected_a', line, character, snippet);
1401                     }
1402                 } else if (json_mode && (digit === 'x' || digit === 'X')) {
1403                     warn_at('unexpected_a', line, character, '0x');
1404                 }
1405             }
1406             if (snippet.slice(snippet.length - 1) === '.') {
1407                 warn_at('trailing_decimal_a', line, character, snippet);
1408             }
1409             if (xmode !== 'style') {
1410                 digit = +snippet;
1411                 if (!isFinite(digit)) {
1412                     warn_at('bad_number', line, character, snippet);
1413                 }
1414                 snippet = digit;
1415             }
1416             return it('(number)', snippet);
1417         }
1418
1419         function comment(snippet) {
1420             if (comments_off || src || (xmode && xmode !== 'script' &&
1421                     xmode !== 'style' && xmode !== 'styleproperty')) {
1422                 warn_at('unexpected_comment', line, character);
1423             } else if (xmode === 'script' && /<\//i.test(source_row)) {
1424                 warn_at('unexpected_a', line, character, '<\/');
1425             } else if (option.safe && ax.test(snippet)) {
1426                 warn_at('dangerous_comment', line, character);
1427             }
1428         }
1429
1430         function regexp() {
1431             var b,
1432                 bit,
1433                 captures = 0,
1434                 depth = 0,
1435                 flag = '',
1436                 high,
1437                 letter,
1438                 length = 0,
1439                 low,
1440                 potential,
1441                 quote,
1442                 result;
1443             for (;;) {
1444                 b = true;
1445                 c = source_row.charAt(length);
1446                 length += 1;
1447                 switch (c) {
1448                 case '':
1449                     stop_at('unclosed_regexp', line, from);
1450                     return;
1451                 case '/':
1452                     if (depth > 0) {
1453                         warn_at('unescaped_a', line, from + length, '/');
1454                     }
1455                     c = source_row.slice(0, length - 1);
1456                     potential = Object.create(regexp_flag);
1457                     for (;;) {
1458                         letter = source_row.charAt(length);
1459                         if (potential[letter] !== true) {
1460                             break;
1461                         }
1462                         potential[letter] = false;
1463                         length += 1;
1464                         flag += letter;
1465                     }
1466                     if (source_row.charAt(length).isAlpha()) {
1467                         stop_at('unexpected_a', line, from, source_row.charAt(length));
1468                     }
1469                     character += length;
1470                     source_row = source_row.slice(length);
1471                     quote = source_row.charAt(0);
1472                     if (quote === '/' || quote === '*') {
1473                         stop_at('confusing_regexp', line, from);
1474                     }
1475                     result = it('(regexp)', c);
1476                     result.flag = flag;
1477                     return result;
1478                 case '\\':
1479                     c = source_row.charAt(length);
1480                     if (c < ' ') {
1481                         warn_at('control_a', line, from + length, String(c));
1482                     } else if (c === '<') {
1483                         warn_at(bundle.unexpected_a, line, from + length, '\\');
1484                     }
1485                     length += 1;
1486                     break;
1487                 case '(':
1488                     depth += 1;
1489                     b = false;
1490                     if (source_row.charAt(length) === '?') {
1491                         length += 1;
1492                         switch (source_row.charAt(length)) {
1493                         case ':':
1494                         case '=':
1495                         case '!':
1496                             length += 1;
1497                             break;
1498                         default:
1499                             warn_at(bundle.expected_a_b, line, from + length,
1500                                 ':', source_row.charAt(length));
1501                         }
1502                     } else {
1503                         captures += 1;
1504                     }
1505                     break;
1506                 case '|':
1507                     b = false;
1508                     break;
1509                 case ')':
1510                     if (depth === 0) {
1511                         warn_at('unescaped_a', line, from + length, ')');
1512                     } else {
1513                         depth -= 1;
1514                     }
1515                     break;
1516                 case ' ':
1517                     pos = 1;
1518                     while (source_row.charAt(length) === ' ') {
1519                         length += 1;
1520                         pos += 1;
1521                     }
1522                     if (pos > 1) {
1523                         warn_at('use_braces', line, from + length, pos);
1524                     }
1525                     break;
1526                 case '[':
1527                     c = source_row.charAt(length);
1528                     if (c === '^') {
1529                         length += 1;
1530                         if (!option.regexp) {
1531                             warn_at('insecure_a', line, from + length, c);
1532                         } else if (source_row.charAt(length) === ']') {
1533                             stop_at('unescaped_a', line, from + length, '^');
1534                         }
1535                     }
1536                     bit = false;
1537                     if (c === ']') {
1538                         warn_at('empty_class', line, from + length - 1);
1539                         bit = true;
1540                     }
1541 klass:              do {
1542                         c = source_row.charAt(length);
1543                         length += 1;
1544                         switch (c) {
1545                         case '[':
1546                         case '^':
1547                             warn_at('unescaped_a', line, from + length, c);
1548                             bit = true;
1549                             break;
1550                         case '-':
1551                             if (bit) {
1552                                 bit = false;
1553                             } else {
1554                                 warn_at('unescaped_a', line, from + length, '-');
1555                                 bit = true;
1556                             }
1557                             break;
1558                         case ']':
1559                             if (!bit) {
1560                                 warn_at('unescaped_a', line, from + length - 1, '-');
1561                             }
1562                             break klass;
1563                         case '\\':
1564                             c = source_row.charAt(length);
1565                             if (c < ' ') {
1566                                 warn_at(bundle.control_a, line, from + length, String(c));
1567                             } else if (c === '<') {
1568                                 warn_at(bundle.unexpected_a, line, from + length, '\\');
1569                             }
1570                             length += 1;
1571                             bit = true;
1572                             break;
1573                         case '/':
1574                             warn_at('unescaped_a', line, from + length - 1, '/');
1575                             bit = true;
1576                             break;
1577                         case '<':
1578                             if (xmode === 'script') {
1579                                 c = source_row.charAt(length);
1580                                 if (c === '!' || c === '/') {
1581                                     warn_at(bundle.html_confusion_a, line,
1582                                         from + length, c);
1583                                 }
1584                             }
1585                             bit = true;
1586                             break;
1587                         default:
1588                             bit = true;
1589                         }
1590                     } while (c);
1591                     break;
1592                 case '.':
1593                     if (!option.regexp) {
1594                         warn_at('insecure_a', line, from + length, c);
1595                     }
1596                     break;
1597                 case ']':
1598                 case '?':
1599                 case '{':
1600                 case '}':
1601                 case '+':
1602                 case '*':
1603                     warn_at('unescaped_a', line, from + length, c);
1604                     break;
1605                 case '<':
1606                     if (xmode === 'script') {
1607                         c = source_row.charAt(length);
1608                         if (c === '!' || c === '/') {
1609                             warn_at(bundle.html_confusion_a, line, from + length, c);
1610                         }
1611                     }
1612                     break;
1613                 }
1614                 if (b) {
1615                     switch (source_row.charAt(length)) {
1616                     case '?':
1617                     case '+':
1618                     case '*':
1619                         length += 1;
1620                         if (source_row.charAt(length) === '?') {
1621                             length += 1;
1622                         }
1623                         break;
1624                     case '{':
1625                         length += 1;
1626                         c = source_row.charAt(length);
1627                         if (c < '0' || c > '9') {
1628                             warn_at(bundle.expected_number_a, line,
1629                                 from + length, c);
1630                         }
1631                         length += 1;
1632                         low = +c;
1633                         for (;;) {
1634                             c = source_row.charAt(length);
1635                             if (c < '0' || c > '9') {
1636                                 break;
1637                             }
1638                             length += 1;
1639                             low = +c + (low * 10);
1640                         }
1641                         high = low;
1642                         if (c === ',') {
1643                             length += 1;
1644                             high = Infinity;
1645                             c = source_row.charAt(length);
1646                             if (c >= '0' && c <= '9') {
1647                                 length += 1;
1648                                 high = +c;
1649                                 for (;;) {
1650                                     c = source_row.charAt(length);
1651                                     if (c < '0' || c > '9') {
1652                                         break;
1653                                     }
1654                                     length += 1;
1655                                     high = +c + (high * 10);
1656                                 }
1657                             }
1658                         }
1659                         if (source_row.charAt(length) !== '}') {
1660                             warn_at(bundle.expected_a_b, line, from + length,
1661                                 '}', c);
1662                         } else {
1663                             length += 1;
1664                         }
1665                         if (source_row.charAt(length) === '?') {
1666                             length += 1;
1667                         }
1668                         if (low > high) {
1669                             warn_at(bundle.not_greater, line, from + length,
1670                                 low, high);
1671                         }
1672                         break;
1673                     }
1674                 }
1675             }
1676             c = source_row.slice(0, length - 1);
1677             character += length;
1678             source_row = source_row.slice(length);
1679             return it('(regexp)', c);
1680         }
1681
1682 // Public lex methods
1683
1684         return {
1685             init: function (source) {
1686                 if (typeof source === 'string') {
1687                     lines = source.split(crlfx);
1688                 } else {
1689                     lines = source;
1690                 }
1691                 line = 0;
1692                 next_line();
1693                 from = 1;
1694             },
1695
1696             range: function (begin, end) {
1697                 var c, value = '';
1698                 from = character;
1699                 if (source_row.charAt(0) !== begin) {
1700                     stop_at('expected_a_b', line, character, begin,
1701                         source_row.charAt(0));
1702                 }
1703                 for (;;) {
1704                     source_row = source_row.slice(1);
1705                     character += 1;
1706                     c = source_row.charAt(0);
1707                     switch (c) {
1708                     case '':
1709                         stop_at('missing_a', line, character, c);
1710                         break;
1711                     case end:
1712                         source_row = source_row.slice(1);
1713                         character += 1;
1714                         return it('(range)', value);
1715                     case xquote:
1716                     case '\\':
1717                         warn_at('unexpected_a', line, character, c);
1718                         break;
1719                     }
1720                     value += c;
1721                 }
1722             },
1723
1724 // token -- this is called by advance to get the next token.
1725
1726             token: function () {
1727                 var c, i, snippet;
1728
1729                 for (;;) {
1730                     while (!source_row) {
1731                         if (!next_line()) {
1732                             return it('(end)');
1733                         }
1734                     }
1735                     while (xmode === 'outer') {
1736                         i = source_row.search(ox);
1737                         if (i === 0) {
1738                             break;
1739                         } else if (i > 0) {
1740                             character += 1;
1741                             source_row = source_row.slice(i);
1742                             break;
1743                         } else {
1744                             if (!next_line()) {
1745                                 return it('(end)', '');
1746                             }
1747                         }
1748                     }
1749                     snippet = match(rx[xmode] || tx);
1750                     if (!snippet) {
1751                         if (source_row) {
1752                             if (source_row.charAt(0) === ' ') {
1753                                 if (!option.white) {
1754                                     warn_at('unexpected_a', line, character,
1755                                         '(space)');
1756                                 }
1757                                 character += 1;
1758                                 source_row = '';
1759                             } else {
1760                                 stop_at('unexpected_a', line, character,
1761                                     source_row.charAt(0));
1762                             }
1763                         }
1764                     } else {
1765
1766 //      identifier
1767
1768                         c = snippet.charAt(0);
1769                         if (c.isAlpha() || c === '_' || c === '$') {
1770                             return it('(identifier)', snippet);
1771                         }
1772
1773 //      number
1774
1775                         if (c.isDigit()) {
1776                             return number(snippet);
1777                         }
1778                         switch (snippet) {
1779
1780 //      string
1781
1782                         case '"':
1783                         case "'":
1784                             return string(snippet);
1785
1786 //      // comment
1787
1788                         case '//':
1789                             comment(source_row);
1790                             source_row = '';
1791                             break;
1792
1793 //      /* comment
1794
1795                         case '/*':
1796                             for (;;) {
1797                                 i = source_row.search(lx);
1798                                 if (i >= 0) {
1799                                     break;
1800                                 }
1801                                 comment(source_row);
1802                                 if (!next_line()) {
1803                                     stop_at('unclosed_comment', line, character);
1804                                 }
1805                             }
1806                             comment(source_row.slice(0, i));
1807                             character += i + 2;
1808                             if (source_row.charAt(i) === '/') {
1809                                 stop_at('nested_comment', line, character);
1810                             }
1811                             source_row = source_row.slice(i + 2);
1812                             break;
1813
1814                         case '':
1815                             break;
1816 //      /
1817                         case '/':
1818                             if (token.id === '/=') {
1819                                 stop_at(
1820                                     bundle.slash_equal,
1821                                     line,
1822                                     from
1823                                 );
1824                             }
1825                             return prereg
1826                                 ? regexp()
1827                                 : it('(punctuator)', snippet);
1828
1829 //      punctuator
1830
1831                         case '<!--':
1832                             length = line;
1833 //                            c = character;
1834                             for (;;) {
1835                                 i = source_row.indexOf('--');
1836                                 if (i >= 0) {
1837                                     break;
1838                                 }
1839                                 i = source_row.indexOf('<!');
1840                                 if (i >= 0) {
1841                                     stop_at('nested_comment',
1842                                         line, character + i);
1843                                 }
1844                                 if (!next_line()) {
1845                                     stop_at('unclosed_comment', length, c);
1846                                 }
1847                             }
1848                             length = source_row.indexOf('<!');
1849                             if (length >= 0 && length < i) {
1850                                 stop_at('nested_comment',
1851                                     line, character + length);
1852                             }
1853                             character += i;
1854                             if (source_row.charAt(i + 2) !== '>') {
1855                                 stop_at('expected_a', line, character, '-->');
1856                             }
1857                             character += 3;
1858                             source_row = source_row.slice(i + 3);
1859                             break;
1860                         case '#':
1861                             if (xmode === 'html' || xmode === 'styleproperty') {
1862                                 for (;;) {
1863                                     c = source_row.charAt(0);
1864                                     if ((c < '0' || c > '9') &&
1865                                             (c < 'a' || c > 'f') &&
1866                                             (c < 'A' || c > 'F')) {
1867                                         break;
1868                                     }
1869                                     character += 1;
1870                                     source_row = source_row.slice(1);
1871                                     snippet += c;
1872                                 }
1873                                 if (snippet.length !== 4 && snippet.length !== 7) {
1874                                     warn_at('bad_color_a', line,
1875                                         from + length, snippet);
1876                                 }
1877                                 return it('(color)', snippet);
1878                             }
1879                             return it('(punctuator)', snippet);
1880
1881                         default:
1882                             if (xmode === 'outer' && c === '&') {
1883                                 character += 1;
1884                                 source_row = source_row.slice(1);
1885                                 for (;;) {
1886                                     c = source_row.charAt(0);
1887                                     character += 1;
1888                                     source_row = source_row.slice(1);
1889                                     if (c === ';') {
1890                                         break;
1891                                     }
1892                                     if (!((c >= '0' && c <= '9') ||
1893                                             (c >= 'a' && c <= 'z') ||
1894                                             c === '#')) {
1895                                         stop_at('bad_entity', line, from + length,
1896                                             character);
1897                                     }
1898                                 }
1899                                 break;
1900                             }
1901                             return it('(punctuator)', snippet);
1902                         }
1903                     }
1904                 }
1905             }
1906         };
1907     }());
1908
1909
1910     function add_label(token, kind, name) {
1911
1912 // Define the symbol in the current function in the current scope.
1913
1914         name = name || token.string;
1915
1916 // Global variables cannot be created in the safe subset. If a global variable
1917 // already exists, do nothing. If it is predefined, define it.
1918
1919         if (funct === global_funct) {
1920             if (option.safe) {
1921                 warn('adsafe_a', token, name);
1922             }
1923             if (typeof global_funct[name] !== 'string') {
1924                 token.writeable = typeof predefined[name] === 'boolean'
1925                     ? predefined[name]
1926                     : true;
1927                 token.funct = funct;
1928                 global_scope[name] = token;
1929             }
1930             if (kind === 'becoming') {
1931                 kind = 'var';
1932             }
1933
1934 // Ordinary variables.
1935
1936         } else {
1937
1938 // Warn if the variable already exists.
1939
1940             if (typeof funct[name] === 'string') {
1941                 if (funct[name] === 'undef') {
1942                     if (!option.undef) {
1943                         warn('used_before_a', token, name);
1944                     }
1945                     kind = 'var';
1946                 } else {
1947                     warn('already_defined', token, name);
1948                 }
1949             } else {
1950
1951 // Add the symbol to the current function.
1952
1953                 token.funct = funct;
1954                 token.writeable = true;
1955                 scope[name] = token;
1956             }
1957         }
1958         funct[name] = kind;
1959     }
1960
1961
1962     function peek(distance) {
1963
1964 // Peek ahead to a future token. The distance is how far ahead to look. The
1965 // default is the next token.
1966
1967         var found, slot = 0;
1968
1969         distance = distance || 0;
1970         while (slot <= distance) {
1971             found = lookahead[slot];
1972             if (!found) {
1973                 found = lookahead[slot] = lex.token();
1974             }
1975             slot += 1;
1976         }
1977         return found;
1978     }
1979
1980
1981     function advance(id, match) {
1982
1983 // Produce the next token, also looking for programming errors.
1984
1985         if (indent) {
1986
1987 // If indentation checking was requested, then inspect all of the line breakings.
1988 // The var statement is tricky because the names might be aligned or not. We
1989 // look at the first line break after the var to determine the programmer's
1990 // intention.
1991
1992             if (var_mode && next_token.line !== token.line) {
1993                 if ((var_mode !== indent || !next_token.edge) &&
1994                         next_token.from === indent.at -
1995                         (next_token.edge ? option.indent : 0)) {
1996                     var dent = indent;
1997                     for (;;) {
1998                         dent.at -= option.indent;
1999                         if (dent === var_mode) {
2000                             break;
2001                         }
2002                         dent = dent.was;
2003                     }
2004                     dent.open = false;
2005                 }
2006                 var_mode = null;
2007             }
2008             if (next_token.id === '?' && indent.mode === ':' &&
2009                     token.line !== next_token.line) {
2010                 indent.at -= option.indent;
2011             }
2012             if (indent.open) {
2013
2014 // If the token is an edge.
2015
2016                 if (next_token.edge) {
2017                     if (next_token.edge === 'label') {
2018                         expected_at(1);
2019                     } else if (next_token.edge === 'case' || indent.mode === 'statement') {
2020                         expected_at(indent.at - option.indent);
2021                     } else if (indent.mode !== 'array' || next_token.line !== token.line) {
2022                         expected_at(indent.at);
2023                     }
2024
2025 // If the token is not an edge, but is the first token on the line.
2026
2027                 } else if (next_token.line !== token.line) {
2028                     if (next_token.from < indent.at + (indent.mode ===
2029                             'expression' ? 0 : option.indent)) {
2030                         expected_at(indent.at + option.indent);
2031                     }
2032                     indent.wrap = true;
2033                 }
2034             } else if (next_token.line !== token.line) {
2035                 if (next_token.edge) {
2036                     expected_at(indent.at);
2037                 } else {
2038                     indent.wrap = true;
2039                     if (indent.mode === 'statement' || indent.mode === 'var') {
2040                         expected_at(indent.at + option.indent);
2041                     } else if (next_token.from < indent.at + (indent.mode ===
2042                             'expression' ? 0 : option.indent)) {
2043                         expected_at(indent.at + option.indent);
2044                     }
2045                 }
2046             }
2047         }
2048
2049         switch (token.id) {
2050         case '(number)':
2051             if (next_token.id === '.') {
2052                 warn('trailing_decimal_a');
2053             }
2054             break;
2055         case '-':
2056             if (next_token.id === '-' || next_token.id === '--') {
2057                 warn('confusing_a');
2058             }
2059             break;
2060         case '+':
2061             if (next_token.id === '+' || next_token.id === '++') {
2062                 warn('confusing_a');
2063             }
2064             break;
2065         }
2066         if (token.id === '(string)' || token.identifier) {
2067             anonname = token.string;
2068         }
2069
2070         if (id && next_token.id !== id) {
2071             if (match) {
2072                 warn('expected_a_b_from_c_d', next_token, id,
2073                     match.id, match.line, artifact());
2074             } else if (!next_token.identifier || next_token.string !== id) {
2075                 warn('expected_a_b', next_token, id, artifact());
2076             }
2077         }
2078         prev_token = token;
2079         token = next_token;
2080         next_token = lookahead.shift() || lex.token();
2081     }
2082
2083
2084     function advance_identifier(string) {
2085         if (next_token.identifier && next_token.string === string) {
2086             advance();
2087         } else {
2088             warn('expected_a_b', next_token, string, artifact());
2089         }
2090     }
2091
2092
2093     function do_safe() {
2094         if (option.adsafe) {
2095             option.safe = true;
2096         }
2097         if (option.safe) {
2098             option.browser     =
2099                 option['continue'] =
2100                 option.css     =
2101                 option.debug   =
2102                 option.devel   =
2103                 option.evil    =
2104                 option.forin   =
2105                 option.newcap  =
2106                 option.nomen   =
2107                 option.on      =
2108                 option.rhino   =
2109                 option.sloppy  =
2110                 option.sub     =
2111                 option.undef   =
2112                 option.widget  =
2113                 option.windows = false;
2114
2115
2116             delete predefined.Array;
2117             delete predefined.Date;
2118             delete predefined.Function;
2119             delete predefined.Object;
2120             delete predefined['eval'];
2121
2122             add_to_predefined({
2123                 ADSAFE: false,
2124                 lib: false
2125             });
2126         }
2127     }
2128
2129
2130     function do_globals() {
2131         var name, writeable;
2132         for (;;) {
2133             if (next_token.id !== '(string)' && !next_token.identifier) {
2134                 return;
2135             }
2136             name = next_token.string;
2137             advance();
2138             writeable = false;
2139             if (next_token.id === ':') {
2140                 advance(':');
2141                 switch (next_token.id) {
2142                 case 'true':
2143                     writeable = predefined[name] !== false;
2144                     advance('true');
2145                     break;
2146                 case 'false':
2147                     advance('false');
2148                     break;
2149                 default:
2150                     stop('unexpected_a');
2151                 }
2152             }
2153             predefined[name] = writeable;
2154             if (next_token.id !== ',') {
2155                 return;
2156             }
2157             advance(',');
2158         }
2159     }
2160
2161
2162     function do_jslint() {
2163         var name, value;
2164         while (next_token.id === '(string)' || next_token.identifier) {
2165             name = next_token.string;
2166             if (!allowed_option[name]) {
2167                 stop('unexpected_a');
2168             }
2169             advance();
2170             if (next_token.id !== ':') {
2171                 stop('expected_a_b', next_token, ':', artifact());
2172             }
2173             advance(':');
2174             if (typeof allowed_option[name] === 'number') {
2175                 value = next_token.number;
2176                 if (value > allowed_option[name] || value <= 0 ||
2177                         Math.floor(value) !== value) {
2178                     stop('expected_small_a');
2179                 }
2180                 option[name] = value;
2181             } else {
2182                 if (next_token.id === 'true') {
2183                     option[name] = true;
2184                 } else if (next_token.id === 'false') {
2185                     option[name] = false;
2186                 } else {
2187                     stop('unexpected_a');
2188                 }
2189             }
2190             advance();
2191             if (next_token.id === ',') {
2192                 advance(',');
2193             }
2194         }
2195         assume();
2196     }
2197
2198
2199     function do_properties() {
2200         var name;
2201         option.properties = true;
2202         for (;;) {
2203             if (next_token.id !== '(string)' && !next_token.identifier) {
2204                 return;
2205             }
2206             name = next_token.string;
2207             advance();
2208             if (next_token.id === ':') {
2209                 for (;;) {
2210                     advance();
2211                     if (next_token.id !== '(string)' && !next_token.identifier) {
2212                         break;
2213                     }
2214                 }
2215             }
2216             property[name] = 0;
2217             if (next_token.id !== ',') {
2218                 return;
2219             }
2220             advance(',');
2221         }
2222     }
2223
2224
2225     directive = function directive() {
2226         var command = this.id,
2227             old_comments_off = comments_off,
2228             old_indent = indent;
2229         comments_off = true;
2230         indent = null;
2231         if (next_token.line === token.line && next_token.from === token.thru) {
2232             warn('missing_space_a_b', next_token, artifact(token), artifact());
2233         }
2234         if (lookahead.length > 0) {
2235             warn('unexpected_a', this);
2236         }
2237         switch (command) {
2238         case '/*properties':
2239         case '/*property':
2240         case '/*members':
2241         case '/*member':
2242             do_properties();
2243             break;
2244         case '/*jslint':
2245             if (option.safe) {
2246                 warn('adsafe_a', this);
2247             }
2248             do_jslint();
2249             break;
2250         case '/*globals':
2251         case '/*global':
2252             if (option.safe) {
2253                 warn('adsafe_a', this);
2254             }
2255             do_globals();
2256             break;
2257         default:
2258             stop('unexpected_a', this);
2259         }
2260         comments_off = old_comments_off;
2261         advance('*/');
2262         indent = old_indent;
2263     };
2264
2265
2266 // Indentation intention
2267
2268     function edge(mode) {
2269         next_token.edge = indent ? indent.open && (mode || 'edge') : '';
2270     }
2271
2272
2273     function step_in(mode) {
2274         var open;
2275         if (typeof mode === 'number') {
2276             indent = {
2277                 at: +mode,
2278                 open: true,
2279                 was: indent
2280             };
2281         } else if (!indent) {
2282             indent = {
2283                 at: 1,
2284                 mode: 'statement',
2285                 open: true
2286             };
2287         } else if (mode === 'statement') {
2288             indent = {
2289                 at: indent.at,
2290                 open: true,
2291                 was: indent
2292             };
2293         } else {
2294             open = mode === 'var' || next_token.line !== token.line;
2295             indent = {
2296                 at: (open || mode === 'control'
2297                     ? indent.at + option.indent
2298                     : indent.at) + (indent.wrap ? option.indent : 0),
2299                 mode: mode,
2300                 open: open,
2301                 was: indent
2302             };
2303             if (mode === 'var' && open) {
2304                 var_mode = indent;
2305             }
2306         }
2307     }
2308
2309     function step_out(id, symbol) {
2310         if (id) {
2311             if (indent && indent.open) {
2312                 indent.at -= option.indent;
2313                 edge();
2314             }
2315             advance(id, symbol);
2316         }
2317         if (indent) {
2318             indent = indent.was;
2319         }
2320     }
2321
2322 // Functions for conformance of whitespace.
2323
2324     function one_space(left, right) {
2325         left = left || token;
2326         right = right || next_token;
2327         if (right.id !== '(end)' && !option.white &&
2328                 (token.line !== right.line ||
2329                 token.thru + 1 !== right.from)) {
2330             warn('expected_space_a_b', right, artifact(token), artifact(right));
2331         }
2332     }
2333
2334     function one_space_only(left, right) {
2335         left = left || token;
2336         right = right || next_token;
2337         if (right.id !== '(end)' && (left.line !== right.line ||
2338                 (!option.white && left.thru + 1 !== right.from))) {
2339             warn('expected_space_a_b', right, artifact(left), artifact(right));
2340         }
2341     }
2342
2343     function no_space(left, right) {
2344         left = left || token;
2345         right = right || next_token;
2346         if ((!option.white || xmode === 'styleproperty' || xmode === 'style') &&
2347                 left.thru !== right.from && left.line === right.line) {
2348             warn('unexpected_space_a_b', right, artifact(left), artifact(right));
2349         }
2350     }
2351
2352     function no_space_only(left, right) {
2353         left = left || token;
2354         right = right || next_token;
2355         if (right.id !== '(end)' && (left.line !== right.line ||
2356                 (!option.white && left.thru !== right.from))) {
2357             warn('unexpected_space_a_b', right, artifact(left), artifact(right));
2358         }
2359     }
2360
2361     function spaces(left, right) {
2362         if (!option.white) {
2363             left = left || token;
2364             right = right || next_token;
2365             if (left.thru === right.from && left.line === right.line) {
2366                 warn('missing_space_a_b', right, artifact(left), artifact(right));
2367             }
2368         }
2369     }
2370
2371     function comma() {
2372         if (next_token.id !== ',') {
2373             warn_at('expected_a_b', token.line, token.thru, ',', artifact());
2374         } else {
2375             if (!option.white) {
2376                 no_space_only();
2377             }
2378             advance(',');
2379             spaces();
2380         }
2381     }
2382
2383
2384     function semicolon() {
2385         if (next_token.id !== ';') {
2386             warn_at('expected_a_b', token.line, token.thru, ';', artifact());
2387         } else {
2388             if (!option.white) {
2389                 no_space_only();
2390             }
2391             advance(';');
2392             if (semicolon_coda[next_token.id] !== true) {
2393                 spaces();
2394             }
2395         }
2396     }
2397
2398     function use_strict() {
2399         if (next_token.string === 'use strict') {
2400             if (strict_mode) {
2401                 warn('unnecessary_use');
2402             }
2403             edge();
2404             advance();
2405             semicolon();
2406             strict_mode = true;
2407             option.newcap = false;
2408             option.undef = false;
2409             return true;
2410         }
2411         return false;
2412     }
2413
2414
2415     function are_similar(a, b) {
2416         if (a === b) {
2417             return true;
2418         }
2419         if (Array.isArray(a)) {
2420             if (Array.isArray(b) && a.length === b.length) {
2421                 var i;
2422                 for (i = 0; i < a.length; i += 1) {
2423                     if (!are_similar(a[i], b[i])) {
2424                         return false;
2425                     }
2426                 }
2427                 return true;
2428             }
2429             return false;
2430         }
2431         if (Array.isArray(b)) {
2432             return false;
2433         }
2434         if (a.id === '(number)' && b.id === '(number)') {
2435             return a.number === b.number;
2436         }
2437         if (a.arity === b.arity && a.string === b.string) {
2438             switch (a.arity) {
2439             case 'prefix':
2440             case 'suffix':
2441             case undefined:
2442                 return a.id === b.id && are_similar(a.first, b.first);
2443             case 'infix':
2444                 return are_similar(a.first, b.first) &&
2445                     are_similar(a.second, b.second);
2446             case 'ternary':
2447                 return are_similar(a.first, b.first) &&
2448                     are_similar(a.second, b.second) &&
2449                     are_similar(a.third, b.third);
2450             case 'function':
2451             case 'regexp':
2452                 return false;
2453             default:
2454                 return true;
2455             }
2456         } else {
2457             if (a.id === '.' && b.id === '[' && b.arity === 'infix') {
2458                 return a.second.string === b.second.string && b.second.id === '(string)';
2459             }
2460             if (a.id === '[' && a.arity === 'infix' && b.id === '.') {
2461                 return a.second.string === b.second.string && a.second.id === '(string)';
2462             }
2463         }
2464         return false;
2465     }
2466
2467
2468 // This is the heart of JSLINT, the Pratt parser. In addition to parsing, it
2469 // is looking for ad hoc lint patterns. We add .fud to Pratt's model, which is
2470 // like .nud except that it is only used on the first token of a statement.
2471 // Having .fud makes it much easier to define statement-oriented languages like
2472 // JavaScript. I retained Pratt's nomenclature.
2473
2474 // .nud     Null denotation
2475 // .fud     First null denotation
2476 // .led     Left denotation
2477 //  lbp     Left binding power
2478 //  rbp     Right binding power
2479
2480 // They are elements of the parsing method called Top Down Operator Precedence.
2481
2482     function expression(rbp, initial) {
2483
2484 // rbp is the right binding power.
2485 // initial indicates that this is the first expression of a statement.
2486
2487         var left;
2488         if (next_token.id === '(end)') {
2489             stop('unexpected_a', token, next_token.id);
2490         }
2491         advance();
2492         if (option.safe && scope[token.string] &&
2493                 scope[token.string] === global_scope[token.string] &&
2494                 (next_token.id !== '(' && next_token.id !== '.')) {
2495             warn('adsafe_a', token);
2496         }
2497         if (initial) {
2498             anonname = 'anonymous';
2499             funct['(verb)'] = token.string;
2500         }
2501         if (initial === true && token.fud) {
2502             left = token.fud();
2503         } else {
2504             if (token.nud) {
2505                 left = token.nud();
2506             } else {
2507                 if (next_token.id === '(number)' && token.id === '.') {
2508                     warn('leading_decimal_a', token, artifact());
2509                     advance();
2510                     return token;
2511                 }
2512                 stop('expected_identifier_a', token, token.id);
2513             }
2514             while (rbp < next_token.lbp) {
2515                 advance();
2516                 if (token.led) {
2517                     left = token.led(left);
2518                 } else {
2519                     stop('expected_operator_a', token, token.id);
2520                 }
2521             }
2522         }
2523         return left;
2524     }
2525
2526
2527 // Functional constructors for making the symbols that will be inherited by
2528 // tokens.
2529
2530     function symbol(s, p) {
2531         var x = syntax[s];
2532         if (!x || typeof x !== 'object') {
2533             syntax[s] = x = {
2534                 id: s,
2535                 lbp: p || 0,
2536                 string: s
2537             };
2538         }
2539         return x;
2540     }
2541
2542     function postscript(x) {
2543         x.postscript = true;
2544         return x;
2545     }
2546
2547     function ultimate(s) {
2548         var x = symbol(s, 0);
2549         x.from = 1;
2550         x.thru = 1;
2551         x.line = 0;
2552         x.edge = 'edge';
2553         s.string = s;
2554         return postscript(x);
2555     }
2556
2557
2558     function stmt(s, f) {
2559         var x = symbol(s);
2560         x.identifier = x.reserved = true;
2561         x.fud = f;
2562         return x;
2563     }
2564
2565     function labeled_stmt(s, f) {
2566         var x = stmt(s, f);
2567         x.labeled = true;
2568     }
2569
2570     function disrupt_stmt(s, f) {
2571         var x = stmt(s, f);
2572         x.disrupt = true;
2573     }
2574
2575
2576     function reserve_name(x) {
2577         var c = x.id.charAt(0);
2578         if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
2579             x.identifier = x.reserved = true;
2580         }
2581         return x;
2582     }
2583
2584
2585     function prefix(s, f) {
2586         var x = symbol(s, 150);
2587         reserve_name(x);
2588         x.nud = typeof f === 'function'
2589             ? f
2590             : function () {
2591                 if (s === 'typeof') {
2592                     one_space();
2593                 } else {
2594                     no_space_only();
2595                 }
2596                 this.first = expression(150);
2597                 this.arity = 'prefix';
2598                 if (this.id === '++' || this.id === '--') {
2599                     if (!option.plusplus) {
2600                         warn('unexpected_a', this);
2601                     } else if ((!this.first.identifier || this.first.reserved) &&
2602                             this.first.id !== '.' && this.first.id !== '[') {
2603                         warn('bad_operand', this);
2604                     }
2605                 }
2606                 return this;
2607             };
2608         return x;
2609     }
2610
2611
2612     function type(s, t, nud) {
2613         var x = symbol(s);
2614         x.arity = t;
2615         if (nud) {
2616             x.nud = nud;
2617         }
2618         return x;
2619     }
2620
2621
2622     function reserve(s, f) {
2623         var x = symbol(s);
2624         x.identifier = x.reserved = true;
2625         if (typeof f === 'function') {
2626             x.nud = f;
2627         }
2628         return x;
2629     }
2630
2631
2632     function constant(name) {
2633         var x = reserve(name);
2634         x.string = name;
2635         x.nud = return_this;
2636         return x;
2637     }
2638
2639
2640     function reservevar(s, v) {
2641         return reserve(s, function () {
2642             if (typeof v === 'function') {
2643                 v(this);
2644             }
2645             return this;
2646         });
2647     }
2648
2649
2650     function infix(s, p, f, w) {
2651         var x = symbol(s, p);
2652         reserve_name(x);
2653         x.led = function (left) {
2654             this.arity = 'infix';
2655             if (!w) {
2656                 spaces(prev_token, token);
2657                 spaces();
2658             }
2659             if (!option.bitwise && this.bitwise) {
2660                 warn('unexpected_a', this);
2661             }
2662             if (typeof f === 'function') {
2663                 return f(left, this);
2664             }
2665             this.first = left;
2666             this.second = expression(p);
2667             return this;
2668         };
2669         return x;
2670     }
2671
2672     function expected_relation(node, message) {
2673         if (node.assign) {
2674             warn(message || bundle.conditional_assignment, node);
2675         }
2676         return node;
2677     }
2678
2679     function expected_condition(node, message) {
2680         switch (node.id) {
2681         case '[':
2682         case '-':
2683             if (node.arity !== 'infix') {
2684                 warn(message || bundle.weird_condition, node);
2685             }
2686             break;
2687         case 'false':
2688         case 'function':
2689         case 'Infinity':
2690         case 'NaN':
2691         case 'null':
2692         case 'true':
2693         case 'undefined':
2694         case 'void':
2695         case '(number)':
2696         case '(regexp)':
2697         case '(string)':
2698         case '{':
2699             warn(message || bundle.weird_condition, node);
2700             break;
2701         case '(':
2702             if (node.first.id === '.' && numbery[node.first.second.string] === true) {
2703                 warn(message || bundle.weird_condition, node);
2704             }
2705             break;
2706         }
2707         return node;
2708     }
2709
2710     function check_relation(node) {
2711         switch (node.arity) {
2712         case 'prefix':
2713             switch (node.id) {
2714             case '{':
2715             case '[':
2716                 warn('unexpected_a', node);
2717                 break;
2718             case '!':
2719                 warn('confusing_a', node);
2720                 break;
2721             }
2722             break;
2723         case 'function':
2724         case 'regexp':
2725             warn('unexpected_a', node);
2726             break;
2727         default:
2728             if (node.id  === 'NaN') {
2729                 warn('isNaN', node);
2730             }
2731         }
2732         return node;
2733     }
2734
2735
2736     function relation(s, eqeq) {
2737         return infix(s, 100, function (left, that) {
2738             check_relation(left);
2739             if (eqeq && !option.eqeq) {
2740                 warn('expected_a_b', that, eqeq, that.id);
2741             }
2742             var right = expression(100);
2743             if (are_similar(left, right) ||
2744                     ((left.id === '(string)' || left.id === '(number)') &&
2745                     (right.id === '(string)' || right.id === '(number)'))) {
2746                 warn('weird_relation', that);
2747             }
2748             that.first = left;
2749             that.second = check_relation(right);
2750             return that;
2751         });
2752     }
2753
2754
2755     function assignop(s, op) {
2756         var x = infix(s, 20, function (left, that) {
2757             var l;
2758             that.first = left;
2759             if (left.identifier) {
2760                 if (scope[left.string]) {
2761                     if (scope[left.string].writeable === false) {
2762                         warn('read_only', left);
2763                     }
2764                 } else {
2765                     stop('read_only');
2766                 }
2767                 if (funct['(params)']) {
2768                     funct['(params)'].forEach(function (value) {
2769                         if (value.string === left.string) {
2770                             value.assign = true;
2771                         }
2772                     });
2773                 }
2774             } else if (option.safe) {
2775                 l = left;
2776                 do {
2777                     if (typeof predefined[l.string] === 'boolean') {
2778                         warn('adsafe_a', l);
2779                     }
2780                     l = l.first;
2781                 } while (l);
2782             }
2783             if (left === syntax['function']) {
2784                 warn('identifier_function', token);
2785             }
2786             if (left.id === '.' || left.id === '[') {
2787                 if (!left.first || left.first.string === 'arguments') {
2788                     warn('bad_assignment', that);
2789                 }
2790             } else if (left.identifier) {
2791                 if (!left.reserved && funct[left.string] === 'exception') {
2792                     warn('assign_exception', left);
2793                 }
2794             } else {
2795                 warn('bad_assignment', that);
2796             }
2797             that.second = expression(19);
2798             if (that.id === '=' && are_similar(that.first, that.second)) {
2799                 warn('weird_assignment', that);
2800             }
2801             return that;
2802         });
2803         x.assign = true;
2804         if (op) {
2805             if (syntax[op].bitwise) {
2806                 x.bitwise = true;
2807             }
2808         }
2809         return x;
2810     }
2811
2812
2813     function bitwise(s, p) {
2814         var x = infix(s, p, 'number');
2815         x.bitwise = true;
2816         return x;
2817     }
2818
2819
2820     function suffix(s) {
2821         var x = symbol(s, 150);
2822         x.led = function (left) {
2823             no_space_only(prev_token, token);
2824             if (!option.plusplus) {
2825                 warn('unexpected_a', this);
2826             } else if ((!left.identifier || left.reserved) &&
2827                     left.id !== '.' && left.id !== '[') {
2828                 warn('bad_operand', this);
2829             }
2830             this.first = left;
2831             this.arity = 'suffix';
2832             return this;
2833         };
2834         return x;
2835     }
2836
2837
2838     function optional_identifier() {
2839         if (next_token.identifier) {
2840             advance();
2841             if (option.safe && banned[token.string]) {
2842                 warn('adsafe_a', token);
2843             } else if (token.reserved && !option.es5) {
2844                 warn('expected_identifier_a_reserved', token);
2845             }
2846             return token.string;
2847         }
2848     }
2849
2850
2851     function identifier() {
2852         var i = optional_identifier();
2853         if (!i) {
2854             stop(token.id === 'function' && next_token.id === '('
2855                 ? 'name_function'
2856                 : 'expected_identifier_a');
2857         }
2858         return i;
2859     }
2860
2861
2862     function statement() {
2863
2864         var label, old_scope = scope, the_statement;
2865
2866 // We don't like the empty statement.
2867
2868         if (next_token.id === ';') {
2869             warn('unexpected_a');
2870             semicolon();
2871             return;
2872         }
2873
2874 // Is this a labeled statement?
2875
2876         if (next_token.identifier && !next_token.reserved && peek().id === ':') {
2877             edge('label');
2878             label = next_token;
2879             advance();
2880             advance(':');
2881             scope = Object.create(old_scope);
2882             add_label(label, 'label');
2883             if (next_token.labeled !== true) {
2884                 warn('label_a_b', next_token, label.string, artifact());
2885             } else if (jx.test(label.string + ':')) {
2886                 warn('url', label);
2887             } else if (funct === global_funct) {
2888                 stop('unexpected_a', token);
2889             }
2890             next_token.label = label;
2891         }
2892
2893 // Parse the statement.
2894
2895         if (token.id !== 'else') {
2896             edge();
2897         }
2898         step_in('statement');
2899         the_statement = expression(0, true);
2900         if (the_statement) {
2901
2902 // Look for the final semicolon.
2903
2904             if (the_statement.arity === 'statement') {
2905                 if (the_statement.id === 'switch' ||
2906                         (the_statement.block && the_statement.id !== 'do')) {
2907                     spaces();
2908                 } else {
2909                     semicolon();
2910                 }
2911             } else {
2912
2913 // If this is an expression statement, determine if it is acceptable.
2914 // We do not like
2915 //      new Blah();
2916 // statments. If it is to be used at all, new should only be used to make
2917 // objects, not side effects. The expression statements we do like do
2918 // assignment or invocation or delete.
2919
2920                 if (the_statement.id === '(') {
2921                     if (the_statement.first.id === 'new') {
2922                         warn('bad_new');
2923                     }
2924                 } else if (!the_statement.assign &&
2925                         the_statement.id !== 'delete' &&
2926                         the_statement.id !== '++' &&
2927                         the_statement.id !== '--') {
2928                     warn('assignment_function_expression', token);
2929                 }
2930                 semicolon();
2931             }
2932         }
2933         step_out();
2934         scope = old_scope;
2935         return the_statement;
2936     }
2937
2938
2939     function statements() {
2940         var array = [], disruptor, the_statement;
2941
2942 // A disrupt statement may not be followed by any other statement.
2943 // If the last statement is disrupt, then the sequence is disrupt.
2944
2945         while (next_token.postscript !== true) {
2946             if (next_token.id === ';') {
2947                 warn('unexpected_a', next_token);
2948                 semicolon();
2949             } else {
2950                 if (next_token.string === 'use strict') {
2951                     if ((!node_js && xmode !== 'script') || funct !== global_funct || array.length > 0) {
2952                         warn('function_strict');
2953                     }
2954                     use_strict();
2955                 }
2956                 if (disruptor) {
2957                     warn('unreachable_a_b', next_token, next_token.string,
2958                         disruptor.string);
2959                     disruptor = null;
2960                 }
2961                 the_statement = statement();
2962                 if (the_statement) {
2963                     array.push(the_statement);
2964                     if (the_statement.disrupt) {
2965                         disruptor = the_statement;
2966                         array.disrupt = true;
2967                     }
2968                 }
2969             }
2970         }
2971         return array;
2972     }
2973
2974
2975     function block(ordinary) {
2976
2977 // array block is array sequence of statements wrapped in braces.
2978 // ordinary is false for function bodies and try blocks.
2979 // ordinary is true for if statements, while, etc.
2980
2981         var array,
2982             curly = next_token,
2983             old_in_block = in_block,
2984             old_scope = scope,
2985             old_strict_mode = strict_mode;
2986
2987         in_block = ordinary;
2988         scope = Object.create(scope);
2989         spaces();
2990         if (next_token.id === '{') {
2991             advance('{');
2992             step_in();
2993             if (!ordinary && !use_strict() && !old_strict_mode &&
2994                     !option.sloppy && funct['(context)'] === global_funct) {
2995                 warn('missing_use_strict');
2996             }
2997             array = statements();
2998             strict_mode = old_strict_mode;
2999             step_out('}', curly);
3000         } else if (!ordinary) {
3001             stop('expected_a_b', next_token, '{', artifact());
3002         } else {
3003             warn('expected_a_b', next_token, '{', artifact());
3004             array = [statement()];
3005             array.disrupt = array[0].disrupt;
3006         }
3007         funct['(verb)'] = null;
3008         scope = old_scope;
3009         in_block = old_in_block;
3010         if (ordinary && array.length === 0) {
3011             warn('empty_block');
3012         }
3013         return array;
3014     }
3015
3016
3017     function tally_property(name) {
3018         if (option.properties && typeof property[name] !== 'number') {
3019             warn('unexpected_property_a', token, name);
3020         }
3021         if (typeof property[name] === 'number') {
3022             property[name] += 1;
3023         } else {
3024             property[name] = 1;
3025         }
3026     }
3027
3028
3029 // ECMAScript parser
3030
3031     syntax['(identifier)'] = {
3032         id: '(identifier)',
3033         lbp: 0,
3034         identifier: true,
3035         nud: function () {
3036             var name = this.string,
3037                 variable = scope[name],
3038                 site,
3039                 writeable;
3040
3041 // If the variable is not in scope, then we may have an undeclared variable.
3042 // Check the predefined list. If it was predefined, create the global
3043 // variable.
3044
3045             if (typeof variable !== 'object') {
3046                 writeable = predefined[name];
3047                 if (typeof writeable === 'boolean') {
3048                     global_scope[name] = variable = {
3049                         string:    name,
3050                         writeable: writeable,
3051                         funct:     global_funct
3052                     };
3053                     global_funct[name] = 'var';
3054
3055 // But if the variable is not in scope, and is not predefined, and if we are not
3056 // in the global scope, then we have an undefined variable error.
3057
3058                 } else {
3059                     if (!option.undef) {
3060                         warn('used_before_a', token);
3061                     }
3062                     scope[name] = variable = {
3063                         string: name,
3064                         writeable: true,
3065                         funct: funct
3066                     };
3067                     funct[name] = 'undef';
3068                 }
3069
3070             }
3071             site = variable.funct;
3072
3073 // The name is in scope and defined in the current function.
3074
3075             if (funct === site) {
3076
3077 //      Change 'unused' to 'var', and reject labels.
3078
3079                 switch (funct[name]) {
3080                 case 'becoming':
3081                     warn('unexpected_a', token);
3082                     funct[name] = 'var';
3083                     break;
3084                 case 'unused':
3085                     funct[name] = 'var';
3086                     break;
3087                 case 'unparam':
3088                     funct[name] = 'parameter';
3089                     break;
3090                 case 'unction':
3091                     funct[name] = 'function';
3092                     break;
3093                 case 'label':
3094                     warn('a_label', token, name);
3095                     break;
3096                 }
3097
3098 // If the name is already defined in the current
3099 // function, but not as outer, then there is a scope error.
3100
3101             } else {
3102                 switch (funct[name]) {
3103                 case 'closure':
3104                 case 'function':
3105                 case 'var':
3106                 case 'unused':
3107                     warn('a_scope', token, name);
3108                     break;
3109                 case 'label':
3110                     warn('a_label', token, name);
3111                     break;
3112                 case 'outer':
3113                 case 'global':
3114                     break;
3115                 default:
3116
3117 // If the name is defined in an outer function, make an outer entry, and if
3118 // it was unused, make it var.
3119
3120                     switch (site[name]) {
3121                     case 'becoming':
3122                     case 'closure':
3123                     case 'function':
3124                     case 'parameter':
3125                     case 'unction':
3126                     case 'unused':
3127                     case 'var':
3128                         site[name] = 'closure';
3129                         funct[name] = site === global_funct
3130                             ? 'global'
3131                             : 'outer';
3132                         break;
3133                     case 'unparam':
3134                         site[name] = 'parameter';
3135                         funct[name] = 'outer';
3136                         break;
3137                     case 'undef':
3138                         funct[name] = 'undef';
3139                         break;
3140                     case 'label':
3141                         warn('a_label', token, name);
3142                         break;
3143                     }
3144                 }
3145             }
3146             return this;
3147         },
3148         led: function () {
3149             stop('expected_operator_a');
3150         }
3151     };
3152
3153 // Build the syntax table by declaring the syntactic elements.
3154
3155     type('(array)', 'array');
3156     type('(color)', 'color');
3157     type('(function)', 'function');
3158     type('(number)', 'number', return_this);
3159     type('(object)', 'object');
3160     type('(string)', 'string', return_this);
3161     type('(boolean)', 'boolean', return_this);
3162     type('(range)', 'range');
3163     type('(regexp)', 'regexp', return_this);
3164
3165     ultimate('(begin)');
3166     ultimate('(end)');
3167     ultimate('(error)');
3168     postscript(symbol('</'));
3169     symbol('<!');
3170     symbol('<!--');
3171     symbol('-->');
3172     postscript(symbol('}'));
3173     symbol(')');
3174     symbol(']');
3175     postscript(symbol('"'));
3176     postscript(symbol('\''));
3177     symbol(';');
3178     symbol(':');
3179     symbol(',');
3180     symbol('#');
3181     symbol('@');
3182     symbol('*/');
3183     postscript(reserve('case'));
3184     reserve('catch');
3185     postscript(reserve('default'));
3186     reserve('else');
3187     reserve('finally');
3188
3189     reservevar('arguments', function (x) {
3190         if (strict_mode && funct === global_funct) {
3191             warn('strict', x);
3192         } else if (option.safe) {
3193             warn('adsafe_a', x);
3194         }
3195         funct['(arguments)'] = true;
3196     });
3197     reservevar('eval', function (x) {
3198         if (option.safe) {
3199             warn('adsafe_a', x);
3200         }
3201     });
3202     constant('false', 'boolean');
3203     constant('Infinity', 'number');
3204     constant('NaN', 'number');
3205     constant('null', '');
3206     reservevar('this', function (x) {
3207         if (option.safe) {
3208             warn('adsafe_a', x);
3209         } else if (strict_mode && funct['(token)'].arity === 'statement' &&
3210                 funct['(name)'].charAt(0) > 'Z') {
3211             warn('strict', x);
3212         }
3213     });
3214     constant('true', 'boolean');
3215     constant('undefined', '');
3216
3217     infix('?', 30, function (left, that) {
3218         step_in('?');
3219         that.first = expected_condition(expected_relation(left));
3220         that.second = expression(0);
3221         spaces();
3222         step_out();
3223         var colon = next_token;
3224         advance(':');
3225         step_in(':');
3226         spaces();
3227         that.third = expression(10);
3228         that.arity = 'ternary';
3229         if (are_similar(that.second, that.third)) {
3230             warn('weird_ternary', colon);
3231         } else if (are_similar(that.first, that.second)) {
3232             warn('use_or', that);
3233         }
3234         step_out();
3235         return that;
3236     });
3237
3238     infix('||', 40, function (left, that) {
3239         function paren_check(that) {
3240             if (that.id === '&&' && !that.paren) {
3241                 warn('and', that);
3242             }
3243             return that;
3244         }
3245
3246         that.first = paren_check(expected_condition(expected_relation(left)));
3247         that.second = paren_check(expected_relation(expression(40)));
3248         if (are_similar(that.first, that.second)) {
3249             warn('weird_condition', that);
3250         }
3251         return that;
3252     });
3253
3254     infix('&&', 50, function (left, that) {
3255         that.first = expected_condition(expected_relation(left));
3256         that.second = expected_relation(expression(50));
3257         if (are_similar(that.first, that.second)) {
3258             warn('weird_condition', that);
3259         }
3260         return that;
3261     });
3262
3263     prefix('void', function () {
3264         this.first = expression(0);
3265         this.arity = 'prefix';
3266         if (option.es5) {
3267             warn('expected_a_b', this, 'undefined', 'void');
3268         } else if (this.first.number !== 0) {
3269             warn('expected_a_b', this.first, '0', artifact(this.first));
3270         }
3271         return this;
3272     });
3273
3274     bitwise('|', 70);
3275     bitwise('^', 80);
3276     bitwise('&', 90);
3277
3278     relation('==', '===');
3279     relation('===');
3280     relation('!=', '!==');
3281     relation('!==');
3282     relation('<');
3283     relation('>');
3284     relation('<=');
3285     relation('>=');
3286
3287     bitwise('<<', 120);
3288     bitwise('>>', 120);
3289     bitwise('>>>', 120);
3290
3291     infix('in', 120, function (left, that) {
3292         warn('infix_in', that);
3293         that.left = left;
3294         that.right = expression(130);
3295         return that;
3296     });
3297     infix('instanceof', 120);
3298     infix('+', 130, function (left, that) {
3299         if (left.id === '(number)') {
3300             if (left.number === 0) {
3301                 warn('unexpected_a', left, '0');
3302             }
3303         } else if (left.id === '(string)') {
3304             if (left.string === '') {
3305                 warn('expected_a_b', left, 'String', '\'\'');
3306             }
3307         }
3308         var right = expression(130);
3309         if (right.id === '(number)') {
3310             if (right.number === 0) {
3311                 warn('unexpected_a', right, '0');
3312             }
3313         } else if (right.id === '(string)') {
3314             if (right.string === '') {
3315                 warn('expected_a_b', right, 'String', '\'\'');
3316             }
3317         }
3318         if (left.id === right.id) {
3319             if (left.id === '(string)' || left.id === '(number)') {
3320                 if (left.id === '(string)') {
3321                     left.string += right.string;
3322                     if (jx.test(left.string)) {
3323                         warn('url', left);
3324                     }
3325                 } else {
3326                     left.number += right.number;
3327                 }
3328                 left.thru = right.thru;
3329                 return left;
3330             }
3331         }
3332         that.first = left;
3333         that.second = right;
3334         return that;
3335     });
3336     prefix('+', 'num');
3337     prefix('+++', function () {
3338         warn('confusing_a', token);
3339         this.first = expression(150);
3340         this.arity = 'prefix';
3341         return this;
3342     });
3343     infix('+++', 130, function (left) {
3344         warn('confusing_a', token);
3345         this.first = left;
3346         this.second = expression(130);
3347         return this;
3348     });
3349     infix('-', 130, function (left, that) {
3350         if ((left.id === '(number)' && left.number === 0) || left.id === '(string)') {
3351             warn('unexpected_a', left);
3352         }
3353         var right = expression(130);
3354         if ((right.id === '(number)' && right.number === 0) || right.id === '(string)') {
3355             warn('unexpected_a', right);
3356         }
3357         if (left.id === right.id && left.id === '(number)') {
3358             left.number -= right.number;
3359             left.thru = right.thru;
3360             return left;
3361         }
3362         that.first = left;
3363         that.second = right;
3364         return that;
3365     });
3366     prefix('-');
3367     prefix('---', function () {
3368         warn('confusing_a', token);
3369         this.first = expression(150);
3370         this.arity = 'prefix';
3371         return this;
3372     });
3373     infix('---', 130, function (left) {
3374         warn('confusing_a', token);
3375         this.first = left;
3376         this.second = expression(130);
3377         return this;
3378     });
3379     infix('*', 140, function (left, that) {
3380         if ((left.id === '(number)' && (left.number === 0 || left.number === 1)) || left.id === '(string)') {
3381             warn('unexpected_a', left);
3382         }
3383         var right = expression(140);
3384         if ((right.id === '(number)' && (right.number === 0 || right.number === 1)) || right.id === '(string)') {
3385             warn('unexpected_a', right);
3386         }
3387         if (left.id === right.id && left.id === '(number)') {
3388             left.number *= right.number;
3389             left.thru = right.thru;
3390             return left;
3391         }
3392         that.first = left;
3393         that.second = right;
3394         return that;
3395     });
3396     infix('/', 140, function (left, that) {
3397         if ((left.id === '(number)' && left.number === 0) || left.id === '(string)') {
3398             warn('unexpected_a', left);
3399         }
3400         var right = expression(140);
3401         if ((right.id === '(number)' && (right.number === 0 || right.number === 1)) || right.id === '(string)') {
3402             warn('unexpected_a', right);
3403         }
3404         if (left.id === right.id && left.id === '(number)') {
3405             left.number /= right.number;
3406             left.thru = right.thru;
3407             return left;
3408         }
3409         that.first = left;
3410         that.second = right;
3411         return that;
3412     });
3413     infix('%', 140, function (left, that) {
3414         if ((left.id === '(number)' && (left.number === 0 || left.number === 1)) || left.id === '(string)') {
3415             warn('unexpected_a', left);
3416         }
3417         var right = expression(140);
3418         if ((right.id === '(number)' && right.number === 0) || right.id === '(string)') {
3419             warn('unexpected_a', right);
3420         }
3421         if (left.id === right.id && left.id === '(number)') {
3422             left.number %= right.number;
3423             left.thru = right.thru;
3424             return left;
3425         }
3426         that.first = left;
3427         that.second = right;
3428         return that;
3429     });
3430
3431     suffix('++');
3432     prefix('++');
3433
3434     suffix('--');
3435     prefix('--');
3436     prefix('delete', function () {
3437         one_space();
3438         var p = expression(0);
3439         if (!p || (p.id !== '.' && p.id !== '[')) {
3440             warn('deleted');
3441         }
3442         this.first = p;
3443         return this;
3444     });
3445
3446
3447     prefix('~', function () {
3448         no_space_only();
3449         if (!option.bitwise) {
3450             warn('unexpected_a', this);
3451         }
3452         expression(150);
3453         return this;
3454     });
3455     prefix('!', function () {
3456         no_space_only();
3457         this.first = expected_condition(expression(150));
3458         this.arity = 'prefix';
3459         if (bang[this.first.id] === true || this.first.assign) {
3460             warn('confusing_a', this);
3461         }
3462         return this;
3463     });
3464     prefix('typeof', null);
3465     prefix('new', function () {
3466         one_space();
3467         var c = expression(160), n, p, v;
3468         this.first = c;
3469         if (c.id !== 'function') {
3470             if (c.identifier) {
3471                 switch (c.string) {
3472                 case 'Object':
3473                     warn('use_object', token);
3474                     break;
3475                 case 'Array':
3476                     if (next_token.id === '(') {
3477                         p = next_token;
3478                         p.first = this;
3479                         advance('(');
3480                         if (next_token.id !== ')') {
3481                             n = expression(0);
3482                             p.second = [n];
3483                             if (n.id !== '(number)' || next_token.id === ',') {
3484                                 warn('use_array', p);
3485                             }
3486                             while (next_token.id === ',') {
3487                                 advance(',');
3488                                 p.second.push(expression(0));
3489                             }
3490                         } else {
3491                             warn('use_array', token);
3492                         }
3493                         advance(')', p);
3494                         return p;
3495                     }
3496                     warn('use_array', token);
3497                     break;
3498                 case 'Number':
3499                 case 'String':
3500                 case 'Boolean':
3501                 case 'Math':
3502                 case 'JSON':
3503                     warn('not_a_constructor', c);
3504                     break;
3505                 case 'Function':
3506                     if (!option.evil) {
3507                         warn('function_eval');
3508                     }
3509                     break;
3510                 case 'Date':
3511                 case 'RegExp':
3512                 case 'this':
3513                     break;
3514                 default:
3515                     if (c.id !== 'function') {
3516                         v = c.string.charAt(0);
3517                         if (!option.newcap && (v < 'A' || v > 'Z')) {
3518                             warn('constructor_name_a', token);
3519                         }
3520                     }
3521                 }
3522             } else {
3523                 if (c.id !== '.' && c.id !== '[' && c.id !== '(') {
3524                     warn('bad_constructor', token);
3525                 }
3526             }
3527         } else {
3528             warn('weird_new', this);
3529         }
3530         if (next_token.id !== '(') {
3531             warn('missing_a', next_token, '()');
3532         }
3533         return this;
3534     });
3535
3536     infix('(', 160, function (left, that) {
3537         var p;
3538         if (indent && indent.mode === 'expression') {
3539             no_space(prev_token, token);
3540         } else {
3541             no_space_only(prev_token, token);
3542         }
3543         if (!left.immed && left.id === 'function') {
3544             warn('wrap_immediate');
3545         }
3546         p = [];
3547         if (left.identifier) {
3548             if (left.string.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) {
3549                 if (left.string !== 'Number' && left.string !== 'String' &&
3550                         left.string !== 'Boolean' && left.string !== 'Date') {
3551                     if (left.string === 'Math' || left.string === 'JSON') {
3552                         warn('not_a_function', left);
3553                     } else if (left.string === 'Object') {
3554                         warn('use_object', token);
3555                     } else if (left.string === 'Array' || !option.newcap) {
3556                         warn('missing_a', left, 'new');
3557                     }
3558                 }
3559             }
3560         } else if (left.id === '.') {
3561             if (option.safe && left.first.string === 'Math' &&
3562                     left.second === 'random') {
3563                 warn('adsafe_a', left);
3564             } else if (left.second.string === 'split' &&
3565                     left.first.id === '(string)') {
3566                 warn('use_array', left.second);
3567             }
3568         }
3569         step_in();
3570         if (next_token.id !== ')') {
3571             no_space();
3572             for (;;) {
3573                 edge();
3574                 p.push(expression(10));
3575                 if (next_token.id !== ',') {
3576                     break;
3577                 }
3578                 comma();
3579             }
3580         }
3581         no_space();
3582         step_out(')', that);
3583         if (typeof left === 'object') {
3584             if (left.string === 'parseInt' && p.length === 1) {
3585                 warn('radix', left);
3586             }
3587             if (!option.evil) {
3588                 if (left.string === 'eval' || left.string === 'Function' ||
3589                         left.string === 'execScript') {
3590                     warn('evil', left);
3591                 } else if (p[0] && p[0].id === '(string)' &&
3592                         (left.string === 'setTimeout' ||
3593                         left.string === 'setInterval')) {
3594                     warn('implied_evil', left);
3595                 }
3596             }
3597             if (!left.identifier && left.id !== '.' && left.id !== '[' &&
3598                     left.id !== '(' && left.id !== '&&' && left.id !== '||' &&
3599                     left.id !== '?') {
3600                 warn('bad_invocation', left);
3601             }
3602         }
3603         that.first = left;
3604         that.second = p;
3605         return that;
3606     }, true);
3607
3608     prefix('(', function () {
3609         step_in('expression');
3610         no_space();
3611         edge();
3612         if (next_token.id === 'function') {
3613             next_token.immed = true;
3614         }
3615         var value = expression(0);
3616         value.paren = true;
3617         no_space();
3618         step_out(')', this);
3619         if (value.id === 'function') {
3620             switch (next_token.id) {
3621             case '(':
3622                 warn('move_invocation');
3623                 break;
3624             case '.':
3625             case '[':
3626                 warn('unexpected_a');
3627                 break;
3628             default:
3629                 warn('bad_wrap', this);
3630             }
3631         }
3632         return value;
3633     });
3634
3635     infix('.', 170, function (left, that) {
3636         no_space(prev_token, token);
3637         no_space();
3638         var name = identifier();
3639         if (typeof name === 'string') {
3640             tally_property(name);
3641         }
3642         that.first = left;
3643         that.second = token;
3644         if (left && left.string === 'arguments' &&
3645                 (name === 'callee' || name === 'caller')) {
3646             warn('avoid_a', left, 'arguments.' + name);
3647         } else if (!option.evil && left && left.string === 'document' &&
3648                 (name === 'write' || name === 'writeln')) {
3649             warn('write_is_wrong', left);
3650         } else if (option.adsafe) {
3651             if (!adsafe_top && left.string === 'ADSAFE') {
3652                 if (name === 'id' || name === 'lib') {
3653                     warn('adsafe_a', that);
3654                 } else if (name === 'go') {
3655                     if (xmode !== 'script') {
3656                         warn('adsafe_a', that);
3657                     } else if (adsafe_went || next_token.id !== '(' ||
3658                             peek(0).id !== '(string)' ||
3659                             peek(0).string !== adsafe_id ||
3660                             peek(1).id !== ',') {
3661                         stop('adsafe_a', that, 'go');
3662                     }
3663                     adsafe_went = true;
3664                     adsafe_may = false;
3665                 }
3666             }
3667             adsafe_top = false;
3668         }
3669         if (!option.evil && (name === 'eval' || name === 'execScript')) {
3670             warn('evil');
3671         } else if (option.safe) {
3672             for (;;) {
3673                 if (banned[name] === true) {
3674                     warn('adsafe_a', token, name);
3675                 }
3676                 if (typeof predefined[left.string] !== 'boolean' ||    //// check for writeable
3677                         next_token.id === '(') {
3678                     break;
3679                 }
3680                 if (next_token.id !== '.') {
3681                     warn('adsafe_a', that);
3682                     break;
3683                 }
3684                 advance('.');
3685                 token.first = that;
3686                 token.second = name;
3687                 that = token;
3688                 name = identifier();
3689                 if (typeof name === 'string') {
3690                     tally_property(name);
3691                 }
3692             }
3693         }
3694         return that;
3695     }, true);
3696
3697     infix('[', 170, function (left, that) {
3698         var e, s;
3699         no_space_only(prev_token, token);
3700         no_space();
3701         step_in();
3702         edge();
3703         e = expression(0);
3704         switch (e.id) {
3705         case '(number)':
3706             if (e.id === '(number)' && left.id === 'arguments') {
3707                 warn('use_param', left);
3708             }
3709             break;
3710         case '(string)':
3711             if (option.safe && (banned[e.string] ||
3712                     e.string.charAt(0) === '_' || e.string.slice(-1) === '_')) {
3713                 warn('adsafe_subscript_a', e);
3714             } else if (!option.evil &&
3715                     (e.string === 'eval' || e.string === 'execScript')) {
3716                 warn('evil', e);
3717             } else if (!option.sub && ix.test(e.string)) {
3718                 s = syntax[e.string];
3719                 if (!s || !s.reserved) {
3720                     warn('subscript', e);
3721                 }
3722             }
3723             tally_property(e.string);
3724             break;
3725         default:
3726             if (option.safe) {
3727                 warn('adsafe_subscript_a', e);
3728             }
3729         }
3730         step_out(']', that);
3731         no_space(prev_token, token);
3732         that.first = left;
3733         that.second = e;
3734         return that;
3735     }, true);
3736
3737     prefix('[', function () {
3738         this.arity = 'prefix';
3739         this.first = [];
3740         step_in('array');
3741         while (next_token.id !== '(end)') {
3742             while (next_token.id === ',') {
3743                 warn('unexpected_a', next_token);
3744                 advance(',');
3745             }
3746             if (next_token.id === ']') {
3747                 break;
3748             }
3749             indent.wrap = false;
3750             edge();
3751             this.first.push(expression(10));
3752             if (next_token.id === ',') {
3753                 comma();
3754                 if (next_token.id === ']' && !option.es5) {
3755                     warn('unexpected_a', token);
3756                     break;
3757                 }
3758             } else {
3759                 break;
3760             }
3761         }
3762         step_out(']', this);
3763         return this;
3764     }, 170);
3765
3766
3767     function property_name() {
3768         var id = optional_identifier(true);
3769         if (!id) {
3770             if (next_token.id === '(string)') {
3771                 id = next_token.string;
3772                 if (option.safe) {
3773                     if (banned[id]) {
3774                         warn('adsafe_a');
3775                     } else if (id.charAt(0) === '_' ||
3776                             id.charAt(id.length - 1) === '_') {
3777                         warn('dangling_a');
3778                     }
3779                 }
3780                 advance();
3781             } else if (next_token.id === '(number)') {
3782                 id = next_token.number.toString();
3783                 advance();
3784             }
3785         }
3786         return id;
3787     }
3788
3789
3790     function function_params() {
3791         var id, paren = next_token, params = [];
3792         advance('(');
3793         step_in();
3794         no_space();
3795         if (next_token.id === ')') {
3796             no_space();
3797             step_out(')', paren);
3798             return params;
3799         }
3800         for (;;) {
3801             edge();
3802             id = identifier();
3803             params.push(token);
3804             add_label(token, option.unparam ? 'parameter' : 'unparam');
3805             if (next_token.id === ',') {
3806                 comma();
3807             } else {
3808                 no_space();
3809                 step_out(')', paren);
3810                 return params;
3811             }
3812         }
3813     }
3814
3815
3816
3817     function do_function(func, name) {
3818         var old_funct      = funct,
3819             old_option     = option,
3820             old_scope      = scope;
3821         funct = {
3822             '(name)'     : name || '\'' + (anonname || '').replace(nx, sanitize) + '\'',
3823             '(line)'     : next_token.line,
3824             '(context)'  : old_funct,
3825             '(breakage)' : 0,
3826             '(loopage)'  : 0,
3827             '(scope)'    : scope,
3828             '(token)'    : func
3829         };
3830         option = Object.create(old_option);
3831         scope = Object.create(old_scope);
3832         functions.push(funct);
3833         func.name = name;
3834         if (name) {
3835             add_label(func, 'function', name);
3836         }
3837         func.writeable = false;
3838         func.first = funct['(params)'] = function_params();
3839         one_space();
3840         func.block = block(false);
3841         if (funct['(arguments)']) {
3842             func.first.forEach(function (value) {
3843                 if (value.assign) {
3844                     warn('parameter_arguments_a', value, value.string);
3845                 }
3846             });
3847         }
3848         funct      = old_funct;
3849         option     = old_option;
3850         scope      = old_scope;
3851     }
3852
3853
3854     assignop('=');
3855     assignop('+=', '+');
3856     assignop('-=', '-');
3857     assignop('*=', '*');
3858     assignop('/=', '/').nud = function () {
3859         stop('slash_equal');
3860     };
3861     assignop('%=', '%');
3862     assignop('&=', '&');
3863     assignop('|=', '|');
3864     assignop('^=', '^');
3865     assignop('<<=', '<<');
3866     assignop('>>=', '>>');
3867     assignop('>>>=', '>>>');
3868
3869
3870     prefix('{', function () {
3871         var get, i, j, name, p, set, seen = {};
3872         this.arity = 'prefix';
3873         this.first = [];
3874         step_in();
3875         while (next_token.id !== '}') {
3876             indent.wrap = false;
3877
3878 // JSLint recognizes the ES5 extension for get/set in object literals,
3879 // but requires that they be used in pairs.
3880
3881             edge();
3882             if (next_token.string === 'get' && peek().id !== ':') {
3883                 if (!option.es5) {
3884                     warn('es5');
3885                 }
3886                 get = next_token;
3887                 advance('get');
3888                 one_space_only();
3889                 name = next_token;
3890                 i = property_name();
3891                 if (!i) {
3892                     stop('missing_property');
3893                 }
3894                 get.string = '';
3895                 do_function(get);
3896                 if (funct['(loopage)']) {
3897                     warn('function_loop', get);
3898                 }
3899                 p = get.first;
3900                 if (p) {
3901                     warn('parameter_a_get_b', p[0], p[0].string, i);
3902                 }
3903                 comma();
3904                 set = next_token;
3905                 spaces();
3906                 edge();
3907                 advance('set');
3908                 set.string = '';
3909                 one_space_only();
3910                 j = property_name();
3911                 if (i !== j) {
3912                     stop('expected_a_b', token, i, j || next_token.string);
3913                 }
3914                 do_function(set);
3915                 if (set.block.length === 0) {
3916                     warn('missing_a', token, 'throw');
3917                 }
3918                 p = set.first;
3919                 if (!p || p.length !== 1) {
3920                     stop('parameter_set_a', set, 'value');
3921                 } else if (p[0].string !== 'value') {
3922                     stop('expected_a_b', p[0], 'value', p[0].string);
3923                 }
3924                 name.first = [get, set];
3925             } else {
3926                 name = next_token;
3927                 i = property_name();
3928                 if (typeof i !== 'string') {
3929                     stop('missing_property');
3930                 }
3931                 advance(':');
3932                 spaces();
3933                 name.first = expression(10);
3934             }
3935             this.first.push(name);
3936             if (seen[i] === true) {
3937                 warn('duplicate_a', next_token, i);
3938             }
3939             seen[i] = true;
3940             tally_property(i);
3941             if (next_token.id !== ',') {
3942                 break;
3943             }
3944             for (;;) {
3945                 comma();
3946                 if (next_token.id !== ',') {
3947                     break;
3948                 }
3949                 warn('unexpected_a', next_token);
3950             }
3951             if (next_token.id === '}' && !option.es5) {
3952                 warn('unexpected_a', token);
3953             }
3954         }
3955         step_out('}', this);
3956         return this;
3957     });
3958
3959     stmt('{', function () {
3960         warn('statement_block');
3961         this.arity = 'statement';
3962         this.block = statements();
3963         this.disrupt = this.block.disrupt;
3964         advance('}', this);
3965         return this;
3966     });
3967
3968     stmt('/*global', directive);
3969     stmt('/*globals', directive);
3970     stmt('/*jslint', directive);
3971     stmt('/*member', directive);
3972     stmt('/*members', directive);
3973     stmt('/*property', directive);
3974     stmt('/*properties', directive);
3975
3976     stmt('var', function () {
3977
3978 // JavaScript does not have block scope. It only has function scope. So,
3979 // declaring a variable in a block can have unexpected consequences.
3980
3981 // var.first will contain an array, the array containing name tokens
3982 // and assignment tokens.
3983
3984         var assign, id, name;
3985
3986         if (funct['(vars)'] && !option.vars) {
3987             warn('combine_var');
3988         } else if (funct !== global_funct) {
3989             funct['(vars)'] = true;
3990         }
3991         this.arity = 'statement';
3992         this.first = [];
3993         step_in('var');
3994         for (;;) {
3995             name = next_token;
3996             id = identifier();
3997             add_label(name, 'becoming');
3998
3999             if (next_token.id === '=') {
4000                 assign = next_token;
4001                 assign.first = name;
4002                 spaces();
4003                 advance('=');
4004                 spaces();
4005                 if (next_token.id === 'undefined') {
4006                     warn('unnecessary_initialize', token, id);
4007                 }
4008                 if (peek(0).id === '=' && next_token.identifier) {
4009                     stop('var_a_not');
4010                 }
4011                 assign.second = expression(0);
4012                 assign.arity = 'infix';
4013                 this.first.push(assign);
4014             } else {
4015                 this.first.push(name);
4016             }
4017             if (funct[id] === 'becoming') {
4018                 funct[id] = 'unused';
4019             }
4020             if (next_token.id !== ',') {
4021                 break;
4022             }
4023             comma();
4024             indent.wrap = false;
4025             if (var_mode && next_token.line === token.line &&
4026                     this.first.length === 1) {
4027                 var_mode = null;
4028                 indent.open = false;
4029                 indent.at -= option.indent;
4030             }
4031             spaces();
4032             edge();
4033         }
4034         var_mode = null;
4035         step_out();
4036         return this;
4037     });
4038
4039     stmt('function', function () {
4040         one_space();
4041         if (in_block) {
4042             warn('function_block', token);
4043         }
4044         var name = next_token, id = identifier();
4045         add_label(name, 'unction');
4046         no_space();
4047         this.arity = 'statement';
4048         do_function(this, id);
4049         if (next_token.id === '(' && next_token.line === token.line) {
4050             stop('function_statement');
4051         }
4052         return this;
4053     });
4054
4055     prefix('function', function () {
4056         if (!option.anon) {
4057             one_space();
4058         }
4059         var id = optional_identifier();
4060         if (id) {
4061             no_space();
4062         } else {
4063             id = '';
4064         }
4065         do_function(this, id);
4066         if (funct['(loopage)']) {
4067             warn('function_loop');
4068         }
4069         switch (next_token.id) {
4070         case ';':
4071         case '(':
4072         case ')':
4073         case ',':
4074         case ']':
4075         case '}':
4076         case ':':
4077             break;
4078         case '.':
4079             if (peek().string !== 'bind' || peek(1).id !== '(') {
4080                 warn('unexpected_a');
4081             }
4082             break;
4083         default:
4084             stop('unexpected_a');
4085         }
4086         this.arity = 'function';
4087         return this;
4088     });
4089
4090     stmt('if', function () {
4091         var paren = next_token;
4092         one_space();
4093         advance('(');
4094         step_in('control');
4095         no_space();
4096         edge();
4097         this.arity = 'statement';
4098         this.first = expected_condition(expected_relation(expression(0)));
4099         no_space();
4100         step_out(')', paren);
4101         one_space();
4102         this.block = block(true);
4103         if (next_token.id === 'else') {
4104             one_space();
4105             advance('else');
4106             one_space();
4107             this['else'] = next_token.id === 'if' || next_token.id === 'switch'
4108                 ? statement(true)
4109                 : block(true);
4110             if (this['else'].disrupt && this.block.disrupt) {
4111                 this.disrupt = true;
4112             }
4113         }
4114         return this;
4115     });
4116
4117     stmt('try', function () {
4118
4119 // try.first    The catch variable
4120 // try.second   The catch clause
4121 // try.third    The finally clause
4122 // try.block    The try block
4123
4124         var exception_variable, old_scope, paren;
4125         if (option.adsafe) {
4126             warn('adsafe_a', this);
4127         }
4128         one_space();
4129         this.arity = 'statement';
4130         this.block = block(false);
4131         if (next_token.id === 'catch') {
4132             one_space();
4133             advance('catch');
4134             one_space();
4135             paren = next_token;
4136             advance('(');
4137             step_in('control');
4138             no_space();
4139             edge();
4140             old_scope = scope;
4141             scope = Object.create(old_scope);
4142             exception_variable = next_token.string;
4143             this.first = exception_variable;
4144             if (!next_token.identifier) {
4145                 warn('expected_identifier_a', next_token);
4146             } else {
4147                 add_label(next_token, 'exception');
4148             }
4149             advance();
4150             no_space();
4151             step_out(')', paren);
4152             one_space();
4153             this.second = block(false);
4154             scope = old_scope;
4155         }
4156         if (next_token.id === 'finally') {
4157             one_space();
4158             advance('finally');
4159             one_space();
4160             this.third = block(false);
4161         } else if (!this.second) {
4162             stop('expected_a_b', next_token, 'catch', artifact());
4163         }
4164         return this;
4165     });
4166
4167     labeled_stmt('while', function () {
4168         one_space();
4169         var paren = next_token;
4170         funct['(breakage)'] += 1;
4171         funct['(loopage)'] += 1;
4172         advance('(');
4173         step_in('control');
4174         no_space();
4175         edge();
4176         this.arity = 'statement';
4177         this.first = expected_relation(expression(0));
4178         if (this.first.id !== 'true') {
4179             expected_condition(this.first, bundle.unexpected_a);
4180         }
4181         no_space();
4182         step_out(')', paren);
4183         one_space();
4184         this.block = block(true);
4185         if (this.block.disrupt) {
4186             warn('strange_loop', prev_token);
4187         }
4188         funct['(breakage)'] -= 1;
4189         funct['(loopage)'] -= 1;
4190         return this;
4191     });
4192
4193     reserve('with');
4194
4195     labeled_stmt('switch', function () {
4196
4197 // switch.first         the switch expression
4198 // switch.second        the array of cases. A case is 'case' or 'default' token:
4199 //    case.first        the array of case expressions
4200 //    case.second       the array of statements
4201 // If all of the arrays of statements are disrupt, then the switch is disrupt.
4202
4203         var cases = [],
4204             old_in_block = in_block,
4205             particular,
4206             the_case = next_token,
4207             unbroken = true;
4208
4209         function find_duplicate_case(value) {
4210             if (are_similar(particular, value)) {
4211                 warn('duplicate_a', value);
4212             }
4213         }
4214
4215         funct['(breakage)'] += 1;
4216         one_space();
4217         advance('(');
4218         no_space();
4219         step_in();
4220         this.arity = 'statement';
4221         this.first = expected_condition(expected_relation(expression(0)));
4222         no_space();
4223         step_out(')', the_case);
4224         one_space();
4225         advance('{');
4226         step_in();
4227         in_block = true;
4228         this.second = [];
4229         while (next_token.id === 'case') {
4230             the_case = next_token;
4231             cases.forEach(find_duplicate_case);
4232             the_case.first = [];
4233             the_case.arity = 'case';
4234             spaces();
4235             edge('case');
4236             advance('case');
4237             for (;;) {
4238                 one_space();
4239                 particular = expression(0);
4240                 cases.forEach(find_duplicate_case);
4241                 cases.push(particular);
4242                 the_case.first.push(particular);
4243                 if (particular.id === 'NaN') {
4244                     warn('unexpected_a', particular);
4245                 }
4246                 no_space_only();
4247                 advance(':');
4248                 if (next_token.id !== 'case') {
4249                     break;
4250                 }
4251                 spaces();
4252                 edge('case');
4253                 advance('case');
4254             }
4255             spaces();
4256             the_case.second = statements();
4257             if (the_case.second && the_case.second.length > 0) {
4258                 particular = the_case.second[the_case.second.length - 1];
4259                 if (particular.disrupt) {
4260                     if (particular.id === 'break') {
4261                         unbroken = false;
4262                     }
4263                 } else {
4264                     warn('missing_a_after_b', next_token, 'break', 'case');
4265                 }
4266             } else {
4267                 warn('empty_case');
4268             }
4269             this.second.push(the_case);
4270         }
4271         if (this.second.length === 0) {
4272             warn('missing_a', next_token, 'case');
4273         }
4274         if (next_token.id === 'default') {
4275             spaces();
4276             the_case = next_token;
4277             the_case.arity = 'case';
4278             edge('case');
4279             advance('default');
4280             no_space_only();
4281             advance(':');
4282             spaces();
4283             the_case.second = statements();
4284             if (the_case.second && the_case.second.length > 0) {
4285                 particular = the_case.second[the_case.second.length - 1];
4286                 if (unbroken && particular.disrupt && particular.id !== 'break') {
4287                     this.disrupt = true;
4288                 }
4289             }
4290             this.second.push(the_case);
4291         }
4292         funct['(breakage)'] -= 1;
4293         spaces();
4294         step_out('}', this);
4295         in_block = old_in_block;
4296         return this;
4297     });
4298
4299     stmt('debugger', function () {
4300         if (!option.debug) {
4301             warn('unexpected_a', this);
4302         }
4303         this.arity = 'statement';
4304         return this;
4305     });
4306
4307     labeled_stmt('do', function () {
4308         funct['(breakage)'] += 1;
4309         funct['(loopage)'] += 1;
4310         one_space();
4311         this.arity = 'statement';
4312         this.block = block(true);
4313         if (this.block.disrupt) {
4314             warn('strange_loop', prev_token);
4315         }
4316         one_space();
4317         advance('while');
4318         var paren = next_token;
4319         one_space();
4320         advance('(');
4321         step_in();
4322         no_space();
4323         edge();
4324         this.first = expected_condition(expected_relation(expression(0)), bundle.unexpected_a);
4325         no_space();
4326         step_out(')', paren);
4327         funct['(breakage)'] -= 1;
4328         funct['(loopage)'] -= 1;
4329         return this;
4330     });
4331
4332     labeled_stmt('for', function () {
4333
4334         var blok, filter, ok = false, paren = next_token, value;
4335         this.arity = 'statement';
4336         funct['(breakage)'] += 1;
4337         funct['(loopage)'] += 1;
4338         advance('(');
4339         if (next_token.id === ';') {
4340             no_space();
4341             advance(';');
4342             no_space();
4343             advance(';');
4344             no_space();
4345             advance(')');
4346             blok = block(true);
4347         } else {
4348             step_in('control');
4349             spaces(this, paren);
4350             no_space();
4351             if (next_token.id === 'var') {
4352                 stop('move_var');
4353             }
4354             edge();
4355             if (peek(0).id === 'in') {
4356                 this.forin = true;
4357                 value = next_token;
4358                 switch (funct[value.string]) {
4359                 case 'unused':
4360                     funct[value.string] = 'var';
4361                     break;
4362                 case 'closure':
4363                 case 'var':
4364                     break;
4365                 default:
4366                     warn('bad_in_a', value);
4367                 }
4368                 advance();
4369                 advance('in');
4370                 this.first = value;
4371                 this.second = expression(20);
4372                 step_out(')', paren);
4373                 blok = block(true);
4374                 if (!option.forin) {
4375                     if (blok.length === 1 && typeof blok[0] === 'object' &&
4376                             blok[0].string === 'if' && !blok[0]['else']) {
4377                         filter = blok[0].first;
4378                         while (filter.id === '&&') {
4379                             filter = filter.first;
4380                         }
4381                         switch (filter.id) {
4382                         case '===':
4383                         case '!==':
4384                             ok = filter.first.id === '['
4385                                 ? filter.first.first.string === this.second.string &&
4386                                     filter.first.second.string === this.first.string
4387                                 : filter.first.id === 'typeof' &&
4388                                     filter.first.first.id === '[' &&
4389                                     filter.first.first.first.string === this.second.string &&
4390                                     filter.first.first.second.string === this.first.string;
4391                             break;
4392                         case '(':
4393                             ok = filter.first.id === '.' && ((
4394                                 filter.first.first.string === this.second.string &&
4395                                 filter.first.second.string === 'hasOwnProperty' &&
4396                                 filter.second[0].string === this.first.string
4397                             ) || (
4398                                 filter.first.first.string === 'ADSAFE' &&
4399                                 filter.first.second.string === 'has' &&
4400                                 filter.second[0].string === this.second.string &&
4401                                 filter.second[1].string === this.first.string
4402                             ) || (
4403                                 filter.first.first.id === '.' &&
4404                                 filter.first.first.first.id === '.' &&
4405                                 filter.first.first.first.first.string === 'Object' &&
4406                                 filter.first.first.first.second.string === 'prototype' &&
4407                                 filter.first.first.second.string === 'hasOwnProperty' &&
4408                                 filter.first.second.string === 'call' &&
4409                                 filter.second[0].string === this.second.string &&
4410                                 filter.second[1].string === this.first.string
4411                             ));
4412                             break;
4413                         }
4414                     }
4415                     if (!ok) {
4416                         warn('for_if', this);
4417                     }
4418                 }
4419             } else {
4420                 edge();
4421                 this.first = [];
4422                 for (;;) {
4423                     this.first.push(expression(0, 'for'));
4424                     if (next_token.id !== ',') {
4425                         break;
4426                     }
4427                     comma();
4428                 }
4429                 semicolon();
4430                 edge();
4431                 this.second = expected_relation(expression(0));
4432                 if (this.second.id !== 'true') {
4433                     expected_condition(this.second, bundle.unexpected_a);
4434                 }
4435                 semicolon(token);
4436                 if (next_token.id === ';') {
4437                     stop('expected_a_b', next_token, ')', ';');
4438                 }
4439                 this.third = [];
4440                 edge();
4441                 for (;;) {
4442                     this.third.push(expression(0, 'for'));
4443                     if (next_token.id !== ',') {
4444                         break;
4445                     }
4446                     comma();
4447                 }
4448                 no_space();
4449                 step_out(')', paren);
4450                 one_space();
4451                 blok = block(true);
4452             }
4453         }
4454         if (blok.disrupt) {
4455             warn('strange_loop', prev_token);
4456         }
4457         this.block = blok;
4458         funct['(breakage)'] -= 1;
4459         funct['(loopage)'] -= 1;
4460         return this;
4461     });
4462
4463     disrupt_stmt('break', function () {
4464         var label = next_token.string;
4465         this.arity = 'statement';
4466         if (funct['(breakage)'] === 0) {
4467             warn('unexpected_a', this);
4468         }
4469         if (next_token.identifier && token.line === next_token.line) {
4470             one_space_only();
4471             if (funct[label] !== 'label') {
4472                 warn('not_a_label', next_token);
4473             } else if (scope[label].funct !== funct) {
4474                 warn('not_a_scope', next_token);
4475             }
4476             this.first = next_token;
4477             advance();
4478         }
4479         return this;
4480     });
4481
4482     disrupt_stmt('continue', function () {
4483         if (!option['continue']) {
4484             warn('unexpected_a', this);
4485         }
4486         var label = next_token.string;
4487         this.arity = 'statement';
4488         if (funct['(breakage)'] === 0) {
4489             warn('unexpected_a', this);
4490         }
4491         if (next_token.identifier && token.line === next_token.line) {
4492             one_space_only();
4493             if (funct[label] !== 'label') {
4494                 warn('not_a_label', next_token);
4495             } else if (scope[label].funct !== funct) {
4496                 warn('not_a_scope', next_token);
4497             }
4498             this.first = next_token;
4499             advance();
4500         }
4501         return this;
4502     });
4503
4504     disrupt_stmt('return', function () {
4505         if (funct === global_funct && xmode !== 'scriptstring') {
4506             warn('unexpected_a', this);
4507         }
4508         this.arity = 'statement';
4509         if (next_token.id !== ';' && next_token.line === token.line) {
4510             one_space_only();
4511             if (next_token.id === '/' || next_token.id === '(regexp)') {
4512                 warn('wrap_regexp');
4513             }
4514             this.first = expression(20);
4515         }
4516         if (peek(0).id === '}' && peek(1).id === 'else') {
4517             warn('unexpected_else', this);
4518         }
4519         return this;
4520     });
4521
4522     disrupt_stmt('throw', function () {
4523         this.arity = 'statement';
4524         one_space_only();
4525         this.first = expression(20);
4526         return this;
4527     });
4528
4529
4530 //  Superfluous reserved words
4531
4532     reserve('class');
4533     reserve('const');
4534     reserve('enum');
4535     reserve('export');
4536     reserve('extends');
4537     reserve('import');
4538     reserve('super');
4539
4540 // Harmony reserved words
4541
4542     reserve('implements');
4543     reserve('interface');
4544     reserve('let');
4545     reserve('package');
4546     reserve('private');
4547     reserve('protected');
4548     reserve('public');
4549     reserve('static');
4550     reserve('yield');
4551
4552
4553 // Parse JSON
4554
4555     function json_value() {
4556
4557         function json_object() {
4558             var brace = next_token, object = {};
4559             advance('{');
4560             if (next_token.id !== '}') {
4561                 while (next_token.id !== '(end)') {
4562                     while (next_token.id === ',') {
4563                         warn('unexpected_a', next_token);
4564                         advance(',');
4565                     }
4566                     if (next_token.id !== '(string)') {
4567                         warn('expected_string_a');
4568                     }
4569                     if (object[next_token.string] === true) {
4570                         warn('duplicate_a');
4571                     } else if (next_token.string === '__proto__') {
4572                         warn('dangling_a');
4573                     } else {
4574                         object[next_token.string] = true;
4575                     }
4576                     advance();
4577                     advance(':');
4578                     json_value();
4579                     if (next_token.id !== ',') {
4580                         break;
4581                     }
4582                     advance(',');
4583                     if (next_token.id === '}') {
4584                         warn('unexpected_a', token);
4585                         break;
4586                     }
4587                 }
4588             }
4589             advance('}', brace);
4590         }
4591
4592         function json_array() {
4593             var bracket = next_token;
4594             advance('[');
4595             if (next_token.id !== ']') {
4596                 while (next_token.id !== '(end)') {
4597                     while (next_token.id === ',') {
4598                         warn('unexpected_a', next_token);
4599                         advance(',');
4600                     }
4601                     json_value();
4602                     if (next_token.id !== ',') {
4603                         break;
4604                     }
4605                     advance(',');
4606                     if (next_token.id === ']') {
4607                         warn('unexpected_a', token);
4608                         break;
4609                     }
4610                 }
4611             }
4612             advance(']', bracket);
4613         }
4614
4615         switch (next_token.id) {
4616         case '{':
4617             json_object();
4618             break;
4619         case '[':
4620             json_array();
4621             break;
4622         case 'true':
4623         case 'false':
4624         case 'null':
4625         case '(number)':
4626         case '(string)':
4627             advance();
4628             break;
4629         case '-':
4630             advance('-');
4631             no_space_only();
4632             advance('(number)');
4633             break;
4634         default:
4635             stop('unexpected_a');
4636         }
4637     }
4638
4639
4640 // CSS parsing.
4641
4642     function css_name() {
4643         if (next_token.identifier) {
4644             advance();
4645             return true;
4646         }
4647     }
4648
4649
4650     function css_number() {
4651         if (next_token.id === '-') {
4652             advance('-');
4653             no_space_only();
4654         }
4655         if (next_token.id === '(number)') {
4656             advance('(number)');
4657             return true;
4658         }
4659     }
4660
4661
4662     function css_string() {
4663         if (next_token.id === '(string)') {
4664             advance();
4665             return true;
4666         }
4667     }
4668
4669     function css_color() {
4670         var i, number, paren, value;
4671         if (next_token.identifier) {
4672             value = next_token.string;
4673             if (value === 'rgb' || value === 'rgba') {
4674                 advance();
4675                 paren = next_token;
4676                 advance('(');
4677                 for (i = 0; i < 3; i += 1) {
4678                     if (i) {
4679                         comma();
4680                     }
4681                     number = next_token.number;
4682                     if (next_token.id !== '(number)' || number < 0) {
4683                         warn('expected_positive_a', next_token);
4684                         advance();
4685                     } else {
4686                         advance();
4687                         if (next_token.id === '%') {
4688                             advance('%');
4689                             if (number > 100) {
4690                                 warn('expected_percent_a', token, number);
4691                             }
4692                         } else {
4693                             if (number > 255) {
4694                                 warn('expected_small_a', token, number);
4695                             }
4696                         }
4697                     }
4698                 }
4699                 if (value === 'rgba') {
4700                     comma();
4701                     number = next_token.number;
4702                     if (next_token.id !== '(number)' || number < 0 || number > 1) {
4703                         warn('expected_fraction_a', next_token);
4704                     }
4705                     advance();
4706                     if (next_token.id === '%') {
4707                         warn('unexpected_a');
4708                         advance('%');
4709                     }
4710                 }
4711                 advance(')', paren);
4712                 return true;
4713             }
4714             if (css_colorData[next_token.string] === true) {
4715                 advance();
4716                 return true;
4717             }
4718         } else if (next_token.id === '(color)') {
4719             advance();
4720             return true;
4721         }
4722         return false;
4723     }
4724
4725
4726     function css_length() {
4727         if (next_token.id === '-') {
4728             advance('-');
4729             no_space_only();
4730         }
4731         if (next_token.id === '(number)') {
4732             advance();
4733             if (next_token.id !== '(string)' &&
4734                     css_lengthData[next_token.string] === true) {
4735                 no_space_only();
4736                 advance();
4737             } else if (+token.number !== 0) {
4738                 warn('expected_linear_a');
4739             }
4740             return true;
4741         }
4742         return false;
4743     }
4744
4745
4746     function css_line_height() {
4747         if (next_token.id === '-') {
4748             advance('-');
4749             no_space_only();
4750         }
4751         if (next_token.id === '(number)') {
4752             advance();
4753             if (next_token.id !== '(string)' &&
4754                     css_lengthData[next_token.string] === true) {
4755                 no_space_only();
4756                 advance();
4757             }
4758             return true;
4759         }
4760         return false;
4761     }
4762
4763
4764     function css_width() {
4765         if (next_token.identifier) {
4766             switch (next_token.string) {
4767             case 'thin':
4768             case 'medium':
4769             case 'thick':
4770                 advance();
4771                 return true;
4772             }
4773         } else {
4774             return css_length();
4775         }
4776     }
4777
4778
4779     function css_margin() {
4780         if (next_token.identifier) {
4781             if (next_token.string === 'auto') {
4782                 advance();
4783                 return true;
4784             }
4785         } else {
4786             return css_length();
4787         }
4788     }
4789
4790     function css_attr() {
4791         if (next_token.identifier && next_token.string === 'attr') {
4792             advance();
4793             advance('(');
4794             if (!next_token.identifier) {
4795                 warn('expected_name_a');
4796             }
4797             advance();
4798             advance(')');
4799             return true;
4800         }
4801         return false;
4802     }
4803
4804
4805     function css_comma_list() {
4806         while (next_token.id !== ';') {
4807             if (!css_name() && !css_string()) {
4808                 warn('expected_name_a');
4809             }
4810             if (next_token.id !== ',') {
4811                 return true;
4812             }
4813             comma();
4814         }
4815     }
4816
4817
4818     function css_counter() {
4819         if (next_token.identifier && next_token.string === 'counter') {
4820             advance();
4821             advance('(');
4822             advance();
4823             if (next_token.id === ',') {
4824                 comma();
4825                 if (next_token.id !== '(string)') {
4826                     warn('expected_string_a');
4827                 }
4828                 advance();
4829             }
4830             advance(')');
4831             return true;
4832         }
4833         if (next_token.identifier && next_token.string === 'counters') {
4834             advance();
4835             advance('(');
4836             if (!next_token.identifier) {
4837                 warn('expected_name_a');
4838             }
4839             advance();
4840             if (next_token.id === ',') {
4841                 comma();
4842                 if (next_token.id !== '(string)') {
4843                     warn('expected_string_a');
4844                 }
4845                 advance();
4846             }
4847             if (next_token.id === ',') {
4848                 comma();
4849                 if (next_token.id !== '(string)') {
4850                     warn('expected_string_a');
4851                 }
4852                 advance();
4853             }
4854             advance(')');
4855             return true;
4856         }
4857         return false;
4858     }
4859
4860
4861     function css_radius() {
4862         return css_length() && (next_token.id !== '(number)' || css_length());
4863     }
4864
4865
4866     function css_shape() {
4867         var i;
4868         if (next_token.identifier && next_token.string === 'rect') {
4869             advance();
4870             advance('(');
4871             for (i = 0; i < 4; i += 1) {
4872                 if (!css_length()) {
4873                     warn('expected_number_a');
4874                     break;
4875                 }
4876             }
4877             advance(')');
4878             return true;
4879         }
4880         return false;
4881     }
4882
4883
4884     function css_url() {
4885         var c, url;
4886         if (next_token.identifier && next_token.string === 'url') {
4887             next_token = lex.range('(', ')');
4888             url = next_token.string;
4889             c = url.charAt(0);
4890             if (c === '"' || c === '\'') {
4891                 if (url.slice(-1) !== c) {
4892                     warn('bad_url_a');
4893                 } else {
4894                     url = url.slice(1, -1);
4895                     if (url.indexOf(c) >= 0) {
4896                         warn('bad_url_a');
4897                     }
4898                 }
4899             }
4900             if (!url) {
4901                 warn('missing_url');
4902             }
4903             if (ux.test(url)) {
4904                 stop('bad_url_a');
4905             }
4906             urls.push(url);
4907             advance();
4908             return true;
4909         }
4910         return false;
4911     }
4912
4913
4914     css_any = [css_url, function () {
4915         for (;;) {
4916             if (next_token.identifier) {
4917                 switch (next_token.string.toLowerCase()) {
4918                 case 'url':
4919                     css_url();
4920                     break;
4921                 case 'expression':
4922                     warn('unexpected_a');
4923                     advance();
4924                     break;
4925                 default:
4926                     advance();
4927                 }
4928             } else {
4929                 if (next_token.id === ';' || next_token.id === '!'  ||
4930                         next_token.id === '(end)' || next_token.id === '}') {
4931                     return true;
4932                 }
4933                 advance();
4934             }
4935         }
4936     }];
4937
4938
4939     function font_face() {
4940         advance_identifier('font-family');
4941         advance(':');
4942         if (!css_name() && !css_string()) {
4943             stop('expected_name_a');
4944         }
4945         semicolon();
4946         advance_identifier('src');
4947         advance(':');
4948         while (true) {
4949             if (next_token.string === 'local') {
4950                 advance_identifier('local');
4951                 advance('(');
4952                 if (ux.test(next_token.string)) {
4953                     stop('bad_url_a');
4954                 }
4955
4956                 if (!css_name() && !css_string()) {
4957                     stop('expected_name_a');
4958                 }
4959                 advance(')');
4960             } else if (!css_url()) {
4961                 stop('expected_a_b', next_token, 'url', artifact());
4962             }
4963             if (next_token.id !== ',') {
4964                 break;
4965             }
4966             comma();
4967         }
4968         semicolon();
4969     }
4970
4971
4972     css_border_style = [
4973         'none', 'dashed', 'dotted', 'double', 'groove',
4974         'hidden', 'inset', 'outset', 'ridge', 'solid'
4975     ];
4976
4977     css_break = [
4978         'auto', 'always', 'avoid', 'left', 'right'
4979     ];
4980
4981     css_media = {
4982         'all': true,
4983         'braille': true,
4984         'embossed': true,
4985         'handheld': true,
4986         'print': true,
4987         'projection': true,
4988         'screen': true,
4989         'speech': true,
4990         'tty': true,
4991         'tv': true
4992     };
4993
4994     css_overflow = [
4995         'auto', 'hidden', 'scroll', 'visible'
4996     ];
4997
4998     css_attribute_data = {
4999         background: [
5000             true, 'background-attachment', 'background-color',
5001             'background-image', 'background-position', 'background-repeat'
5002         ],
5003         'background-attachment': ['scroll', 'fixed'],
5004         'background-color': ['transparent', css_color],
5005         'background-image': ['none', css_url],
5006         'background-position': [
5007             2, [css_length, 'top', 'bottom', 'left', 'right', 'center']
5008         ],
5009         'background-repeat': [
5010             'repeat', 'repeat-x', 'repeat-y', 'no-repeat'
5011         ],
5012         'border': [true, 'border-color', 'border-style', 'border-width'],
5013         'border-bottom': [
5014             true, 'border-bottom-color', 'border-bottom-style',
5015             'border-bottom-width'
5016         ],
5017         'border-bottom-color': css_color,
5018         'border-bottom-left-radius': css_radius,
5019         'border-bottom-right-radius': css_radius,
5020         'border-bottom-style': css_border_style,
5021         'border-bottom-width': css_width,
5022         'border-collapse': ['collapse', 'separate'],
5023         'border-color': ['transparent', 4, css_color],
5024         'border-left': [
5025             true, 'border-left-color', 'border-left-style', 'border-left-width'
5026         ],
5027         'border-left-color': css_color,
5028         'border-left-style': css_border_style,
5029         'border-left-width': css_width,
5030         'border-radius': function () {
5031             function count(separator) {
5032                 var n = 1;
5033                 if (separator) {
5034                     advance(separator);
5035                 }
5036                 if (!css_length()) {
5037                     return false;
5038                 }
5039                 while (next_token.id === '(number)') {
5040                     if (!css_length()) {
5041                         return false;
5042                     }
5043                     n += 1;
5044                 }
5045                 if (n > 4) {
5046                     warn('bad_style');
5047                 }
5048                 return true;
5049             }
5050
5051             return count() && (next_token.id !== '/' || count('/'));
5052         },
5053         'border-right': [
5054             true, 'border-right-color', 'border-right-style',
5055             'border-right-width'
5056         ],
5057         'border-right-color': css_color,
5058         'border-right-style': css_border_style,
5059         'border-right-width': css_width,
5060         'border-spacing': [2, css_length],
5061         'border-style': [4, css_border_style],
5062         'border-top': [
5063             true, 'border-top-color', 'border-top-style', 'border-top-width'
5064         ],
5065         'border-top-color': css_color,
5066         'border-top-left-radius': css_radius,
5067         'border-top-right-radius': css_radius,
5068         'border-top-style': css_border_style,
5069         'border-top-width': css_width,
5070         'border-width': [4, css_width],
5071         bottom: [css_length, 'auto'],
5072         'caption-side' : ['bottom', 'left', 'right', 'top'],
5073         clear: ['both', 'left', 'none', 'right'],
5074         clip: [css_shape, 'auto'],
5075         color: css_color,
5076         content: [
5077             'open-quote', 'close-quote', 'no-open-quote', 'no-close-quote',
5078             css_string, css_url, css_counter, css_attr
5079         ],
5080         'counter-increment': [
5081             css_name, 'none'
5082         ],
5083         'counter-reset': [
5084             css_name, 'none'
5085         ],
5086         cursor: [
5087             css_url, 'auto', 'crosshair', 'default', 'e-resize', 'help', 'move',
5088             'n-resize', 'ne-resize', 'nw-resize', 'pointer', 's-resize',
5089             'se-resize', 'sw-resize', 'w-resize', 'text', 'wait'
5090         ],
5091         direction: ['ltr', 'rtl'],
5092         display: [
5093             'block', 'compact', 'inline', 'inline-block', 'inline-table',
5094             'list-item', 'marker', 'none', 'run-in', 'table', 'table-caption',
5095             'table-cell', 'table-column', 'table-column-group',
5096             'table-footer-group', 'table-header-group', 'table-row',
5097             'table-row-group'
5098         ],
5099         'empty-cells': ['show', 'hide'],
5100         'float': ['left', 'none', 'right'],
5101         font: [
5102             'caption', 'icon', 'menu', 'message-box', 'small-caption',
5103             'status-bar', true, 'font-size', 'font-style', 'font-weight',
5104             'font-family'
5105         ],
5106         'font-family': css_comma_list,
5107         'font-size': [
5108             'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large',
5109             'xx-large', 'larger', 'smaller', css_length
5110         ],
5111         'font-size-adjust': ['none', css_number],
5112         'font-stretch': [
5113             'normal', 'wider', 'narrower', 'ultra-condensed',
5114             'extra-condensed', 'condensed', 'semi-condensed',
5115             'semi-expanded', 'expanded', 'extra-expanded'
5116         ],
5117         'font-style': [
5118             'normal', 'italic', 'oblique'
5119         ],
5120         'font-variant': [
5121             'normal', 'small-caps'
5122         ],
5123         'font-weight': [
5124             'normal', 'bold', 'bolder', 'lighter', css_number
5125         ],
5126         height: [css_length, 'auto'],
5127         left: [css_length, 'auto'],
5128         'letter-spacing': ['normal', css_length],
5129         'line-height': ['normal', css_line_height],
5130         'list-style': [
5131             true, 'list-style-image', 'list-style-position', 'list-style-type'
5132         ],
5133         'list-style-image': ['none', css_url],
5134         'list-style-position': ['inside', 'outside'],
5135         'list-style-type': [
5136             'circle', 'disc', 'square', 'decimal', 'decimal-leading-zero',
5137             'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha',
5138             'lower-latin', 'upper-alpha', 'upper-latin', 'hebrew', 'katakana',
5139             'hiragana-iroha', 'katakana-oroha', 'none'
5140         ],
5141         margin: [4, css_margin],
5142         'margin-bottom': css_margin,
5143         'margin-left': css_margin,
5144         'margin-right': css_margin,
5145         'margin-top': css_margin,
5146         'marker-offset': [css_length, 'auto'],
5147         'max-height': [css_length, 'none'],
5148         'max-width': [css_length, 'none'],
5149         'min-height': css_length,
5150         'min-width': css_length,
5151         opacity: css_number,
5152         outline: [true, 'outline-color', 'outline-style', 'outline-width'],
5153         'outline-color': ['invert', css_color],
5154         'outline-style': [
5155             'dashed', 'dotted', 'double', 'groove', 'inset', 'none',
5156             'outset', 'ridge', 'solid'
5157         ],
5158         'outline-width': css_width,
5159         overflow: css_overflow,
5160         'overflow-x': css_overflow,
5161         'overflow-y': css_overflow,
5162         padding: [4, css_length],
5163         'padding-bottom': css_length,
5164         'padding-left': css_length,
5165         'padding-right': css_length,
5166         'padding-top': css_length,
5167         'page-break-after': css_break,
5168         'page-break-before': css_break,
5169         position: ['absolute', 'fixed', 'relative', 'static'],
5170         quotes: [8, css_string],
5171         right: [css_length, 'auto'],
5172         'table-layout': ['auto', 'fixed'],
5173         'text-align': ['center', 'justify', 'left', 'right'],
5174         'text-decoration': [
5175             'none', 'underline', 'overline', 'line-through', 'blink'
5176         ],
5177         'text-indent': css_length,
5178         'text-shadow': ['none', 4, [css_color, css_length]],
5179         'text-transform': ['capitalize', 'uppercase', 'lowercase', 'none'],
5180         top: [css_length, 'auto'],
5181         'unicode-bidi': ['normal', 'embed', 'bidi-override'],
5182         'vertical-align': [
5183             'baseline', 'bottom', 'sub', 'super', 'top', 'text-top', 'middle',
5184             'text-bottom', css_length
5185         ],
5186         visibility: ['visible', 'hidden', 'collapse'],
5187         'white-space': [
5188             'normal', 'nowrap', 'pre', 'pre-line', 'pre-wrap', 'inherit'
5189         ],
5190         width: [css_length, 'auto'],
5191         'word-spacing': ['normal', css_length],
5192         'word-wrap': ['break-word', 'normal'],
5193         'z-index': ['auto', css_number]
5194     };
5195
5196     function style_attribute() {
5197         var v;
5198         while (next_token.id === '*' || next_token.id === '#' ||
5199                 next_token.string === '_') {
5200             if (!option.css) {
5201                 warn('unexpected_a');
5202             }
5203             advance();
5204         }
5205         if (next_token.id === '-') {
5206             if (!option.css) {
5207                 warn('unexpected_a');
5208             }
5209             advance('-');
5210             if (!next_token.identifier) {
5211                 warn('expected_nonstandard_style_attribute');
5212             }
5213             advance();
5214             return css_any;
5215         }
5216         if (!next_token.identifier) {
5217             warn('expected_style_attribute');
5218         } else {
5219             if (Object.prototype.hasOwnProperty.call(css_attribute_data,
5220                     next_token.string)) {
5221                 v = css_attribute_data[next_token.string];
5222             } else {
5223                 v = css_any;
5224                 if (!option.css) {
5225                     warn('unrecognized_style_attribute_a');
5226                 }
5227             }
5228         }
5229         advance();
5230         return v;
5231     }
5232
5233
5234     function style_value(v) {
5235         var i = 0,
5236             n,
5237             once,
5238             match,
5239             round,
5240             start = 0,
5241             vi;
5242         switch (typeof v) {
5243         case 'function':
5244             return v();
5245         case 'string':
5246             if (next_token.identifier && next_token.string === v) {
5247                 advance();
5248                 return true;
5249             }
5250             return false;
5251         }
5252         for (;;) {
5253             if (i >= v.length) {
5254                 return false;
5255             }
5256             vi = v[i];
5257             i += 1;
5258             if (typeof vi === 'boolean') {
5259                 break;
5260             } else if (typeof vi === 'number') {
5261                 n = vi;
5262                 vi = v[i];
5263                 i += 1;
5264             } else {
5265                 n = 1;
5266             }
5267             match = false;
5268             while (n > 0) {
5269                 if (style_value(vi)) {
5270                     match = true;
5271                     n -= 1;
5272                 } else {
5273                     break;
5274                 }
5275             }
5276             if (match) {
5277                 return true;
5278             }
5279         }
5280         start = i;
5281         once = [];
5282         for (;;) {
5283             round = false;
5284             for (i = start; i < v.length; i += 1) {
5285                 if (!once[i]) {
5286                     if (style_value(css_attribute_data[v[i]])) {
5287                         match = true;
5288                         round = true;
5289                         once[i] = true;
5290                         break;
5291                     }
5292                 }
5293             }
5294             if (!round) {
5295                 return match;
5296             }
5297         }
5298     }
5299
5300     function style_child() {
5301         if (next_token.id === '(number)') {
5302             advance();
5303             if (next_token.string === 'n' && next_token.identifier) {
5304                 no_space_only();
5305                 advance();
5306                 if (next_token.id === '+') {
5307                     no_space_only();
5308                     advance('+');
5309                     no_space_only();
5310                     advance('(number)');
5311                 }
5312             }
5313             return;
5314         }
5315         if (next_token.identifier &&
5316                 (next_token.string === 'odd' || next_token.string === 'even')) {
5317             advance();
5318             return;
5319         }
5320         warn('unexpected_a');
5321     }
5322
5323     function substyle() {
5324         var v;
5325         for (;;) {
5326             if (next_token.id === '}' || next_token.id === '(end)' ||
5327                     (xquote && next_token.id === xquote)) {
5328                 return;
5329             }
5330             v = style_attribute();
5331             advance(':');
5332             if (next_token.identifier && next_token.string === 'inherit') {
5333                 advance();
5334             } else {
5335                 if (!style_value(v)) {
5336                     warn('unexpected_a');
5337                     advance();
5338                 }
5339             }
5340             if (next_token.id === '!') {
5341                 advance('!');
5342                 no_space_only();
5343                 if (next_token.identifier && next_token.string === 'important') {
5344                     advance();
5345                 } else {
5346                     warn('expected_a_b',
5347                         next_token, 'important', artifact());
5348                 }
5349             }
5350             if (next_token.id === '}' || next_token.id === xquote) {
5351                 warn('expected_a_b', next_token, ';', artifact());
5352             } else {
5353                 semicolon();
5354             }
5355         }
5356     }
5357
5358     function style_selector() {
5359         if (next_token.identifier) {
5360             if (!Object.prototype.hasOwnProperty.call(html_tag, option.cap
5361                     ? next_token.string.toLowerCase()
5362                     : next_token.string)) {
5363                 warn('expected_tagname_a');
5364             }
5365             advance();
5366         } else {
5367             switch (next_token.id) {
5368             case '>':
5369             case '+':
5370                 advance();
5371                 style_selector();
5372                 break;
5373             case ':':
5374                 advance(':');
5375                 switch (next_token.string) {
5376                 case 'active':
5377                 case 'after':
5378                 case 'before':
5379                 case 'checked':
5380                 case 'disabled':
5381                 case 'empty':
5382                 case 'enabled':
5383                 case 'first-child':
5384                 case 'first-letter':
5385                 case 'first-line':
5386                 case 'first-of-type':
5387                 case 'focus':
5388                 case 'hover':
5389                 case 'last-child':
5390                 case 'last-of-type':
5391                 case 'link':
5392                 case 'only-of-type':
5393                 case 'root':
5394                 case 'target':
5395                 case 'visited':
5396                     advance_identifier(next_token.string);
5397                     break;
5398                 case 'lang':
5399                     advance_identifier('lang');
5400                     advance('(');
5401                     if (!next_token.identifier) {
5402                         warn('expected_lang_a');
5403                     }
5404                     advance(')');
5405                     break;
5406                 case 'nth-child':
5407                 case 'nth-last-child':
5408                 case 'nth-last-of-type':
5409                 case 'nth-of-type':
5410                     advance_identifier(next_token.string);
5411                     advance('(');
5412                     style_child();
5413                     advance(')');
5414                     break;
5415                 case 'not':
5416                     advance_identifier('not');
5417                     advance('(');
5418                     if (next_token.id === ':' && peek(0).string === 'not') {
5419                         warn('not');
5420                     }
5421                     style_selector();
5422                     advance(')');
5423                     break;
5424                 default:
5425                     warn('expected_pseudo_a');
5426                 }
5427                 break;
5428             case '#':
5429                 advance('#');
5430                 if (!next_token.identifier) {
5431                     warn('expected_id_a');
5432                 }
5433                 advance();
5434                 break;
5435             case '*':
5436                 advance('*');
5437                 break;
5438             case '.':
5439                 advance('.');
5440                 if (!next_token.identifier) {
5441                     warn('expected_class_a');
5442                 }
5443                 advance();
5444                 break;
5445             case '[':
5446                 advance('[');
5447                 if (!next_token.identifier) {
5448                     warn('expected_attribute_a');
5449                 }
5450                 advance();
5451                 if (next_token.id === '=' || next_token.string === '~=' ||
5452                         next_token.string === '$=' ||
5453                         next_token.string === '|=' ||
5454                         next_token.id === '*=' ||
5455                         next_token.id === '^=') {
5456                     advance();
5457                     if (next_token.id !== '(string)') {
5458                         warn('expected_string_a');
5459                     }
5460                     advance();
5461                 }
5462                 advance(']');
5463                 break;
5464             default:
5465                 stop('expected_selector_a');
5466             }
5467         }
5468     }
5469
5470     function style_pattern() {
5471         if (next_token.id === '{') {
5472             warn('expected_style_pattern');
5473         }
5474         for (;;) {
5475             style_selector();
5476             if (next_token.id === '</' || next_token.id === '{' ||
5477                     next_token.id === '}' || next_token.id === '(end)') {
5478                 return '';
5479             }
5480             if (next_token.id === ',') {
5481                 comma();
5482             }
5483         }
5484     }
5485
5486     function style_list() {
5487         while (next_token.id !== '}' && next_token.id !== '</' &&
5488                 next_token.id !== '(end)') {
5489             style_pattern();
5490             xmode = 'styleproperty';
5491             if (next_token.id === ';') {
5492                 semicolon();
5493             } else {
5494                 advance('{');
5495                 substyle();
5496                 xmode = 'style';
5497                 advance('}');
5498             }
5499         }
5500     }
5501
5502     function styles() {
5503         var i;
5504         while (next_token.id === '@') {
5505             i = peek();
5506             advance('@');
5507             switch (next_token.string) {
5508             case 'import':
5509                 advance_identifier('import');
5510                 if (!css_url()) {
5511                     warn('expected_a_b',
5512                         next_token, 'url', artifact());
5513                     advance();
5514                 }
5515                 semicolon();
5516                 break;
5517             case 'media':
5518                 advance_identifier('media');
5519                 for (;;) {
5520                     if (!next_token.identifier || css_media[next_token.string] !== true) {
5521                         stop('expected_media_a');
5522                     }
5523                     advance();
5524                     if (next_token.id !== ',') {
5525                         break;
5526                     }
5527                     comma();
5528                 }
5529                 advance('{');
5530                 style_list();
5531                 advance('}');
5532                 break;
5533             case 'font-face':
5534                 advance_identifier('font-face');
5535                 advance('{');
5536                 font_face();
5537                 advance('}');
5538                 break;
5539             default:
5540                 stop('expected_at_a');
5541             }
5542         }
5543         style_list();
5544     }
5545
5546
5547 // Parse HTML
5548
5549     function do_begin(n) {
5550         if (n !== 'html' && !option.fragment) {
5551             if (n === 'div' && option.adsafe) {
5552                 stop('adsafe_fragment');
5553             } else {
5554                 stop('expected_a_b', token, 'html', n);
5555             }
5556         }
5557         if (option.adsafe) {
5558             if (n === 'html') {
5559                 stop('adsafe_html', token);
5560             }
5561             if (option.fragment) {
5562                 if (n !== 'div') {
5563                     stop('adsafe_div', token);
5564                 }
5565             } else {
5566                 stop('adsafe_fragment', token);
5567             }
5568         }
5569         option.browser = true;
5570     }
5571
5572     function do_attribute(a, v) {
5573         var u, x;
5574         if (a === 'id') {
5575             u = typeof v === 'string' ? v.toUpperCase() : '';
5576             if (ids[u] === true) {
5577                 warn('duplicate_a', next_token, v);
5578             }
5579             if (!/^[A-Za-z][A-Za-z0-9._:\-]*$/.test(v)) {
5580                 warn('bad_id_a', next_token, v);
5581             } else if (option.adsafe) {
5582                 if (adsafe_id) {
5583                     if (v.slice(0, adsafe_id.length) !== adsafe_id) {
5584                         warn('adsafe_prefix_a', next_token, adsafe_id);
5585                     } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) {
5586                         warn('adsafe_bad_id');
5587                     }
5588                 } else {
5589                     adsafe_id = v;
5590                     if (!/^[A-Z]+_$/.test(v)) {
5591                         warn('adsafe_bad_id');
5592                     }
5593                 }
5594             }
5595             x = v.search(dx);
5596             if (x >= 0) {
5597                 warn('unexpected_char_a_b', token, v.charAt(x), a);
5598             }
5599             ids[u] = true;
5600         } else if (a === 'class' || a === 'type' || a === 'name') {
5601             x = v.search(qx);
5602             if (x >= 0) {
5603                 warn('unexpected_char_a_b', token, v.charAt(x), a);
5604             }
5605             ids[u] = true;
5606         } else if (a === 'href' || a === 'background' ||
5607                 a === 'content' || a === 'data' ||
5608                 a.indexOf('src') >= 0 || a.indexOf('url') >= 0) {
5609             if (option.safe && ux.test(v)) {
5610                 stop('bad_url_a', next_token, v);
5611             }
5612             urls.push(v);
5613         } else if (a === 'for') {
5614             if (option.adsafe) {
5615                 if (adsafe_id) {
5616                     if (v.slice(0, adsafe_id.length) !== adsafe_id) {
5617                         warn('adsafe_prefix_a', next_token, adsafe_id);
5618                     } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) {
5619                         warn('adsafe_bad_id');
5620                     }
5621                 } else {
5622                     warn('adsafe_bad_id');
5623                 }
5624             }
5625         } else if (a === 'name') {
5626             if (option.adsafe && v.indexOf('_') >= 0) {
5627                 warn('adsafe_name_a', next_token, v);
5628             }
5629         }
5630     }
5631
5632     function do_tag(name, attribute) {
5633         var i, tag = html_tag[name], script, x;
5634         src = false;
5635         if (!tag) {
5636             stop(
5637                 bundle.unrecognized_tag_a,
5638                 next_token,
5639                 name === name.toLowerCase()
5640                     ? name
5641                     : name + ' (capitalization error)'
5642             );
5643         }
5644         if (stack.length > 0) {
5645             if (name === 'html') {
5646                 stop('unexpected_a', token, name);
5647             }
5648             x = tag.parent;
5649             if (x) {
5650                 if (x.indexOf(' ' + stack[stack.length - 1].name + ' ') < 0) {
5651                     stop('tag_a_in_b', token, name, x);
5652                 }
5653             } else if (!option.adsafe && !option.fragment) {
5654                 i = stack.length;
5655                 do {
5656                     if (i <= 0) {
5657                         stop('tag_a_in_b', token, name, 'body');
5658                     }
5659                     i -= 1;
5660                 } while (stack[i].name !== 'body');
5661             }
5662         }
5663         switch (name) {
5664         case 'div':
5665             if (option.adsafe && stack.length === 1 && !adsafe_id) {
5666                 warn('adsafe_missing_id');
5667             }
5668             break;
5669         case 'script':
5670             xmode = 'script';
5671             advance('>');
5672             if (attribute.lang) {
5673                 warn('lang', token);
5674             }
5675             if (option.adsafe && stack.length !== 1) {
5676                 warn('adsafe_placement', token);
5677             }
5678             if (attribute.src) {
5679                 if (option.adsafe && (!adsafe_may || !approved[attribute.src])) {
5680                     warn('adsafe_source', token);
5681                 }
5682             } else {
5683                 step_in(next_token.from);
5684                 edge();
5685                 use_strict();
5686                 adsafe_top = true;
5687                 script = statements();
5688
5689 // JSLint is also the static analyzer for ADsafe. See www.ADsafe.org.
5690
5691                 if (option.adsafe) {
5692                     if (adsafe_went) {
5693                         stop('adsafe_script', token);
5694                     }
5695                     if (script.length !== 1 ||
5696                             aint(script[0],             'id',     '(') ||
5697                             aint(script[0].first,       'id',     '.') ||
5698                             aint(script[0].first.first, 'string', 'ADSAFE') ||
5699                             aint(script[0].second[0],   'string', adsafe_id)) {
5700                         stop('adsafe_id_go');
5701                     }
5702                     switch (script[0].first.second.string) {
5703                     case 'id':
5704                         if (adsafe_may || adsafe_went ||
5705                                 script[0].second.length !== 1) {
5706                             stop('adsafe_id', next_token);
5707                         }
5708                         adsafe_may = true;
5709                         break;
5710                     case 'go':
5711                         if (adsafe_went) {
5712                             stop('adsafe_go');
5713                         }
5714                         if (script[0].second.length !== 2 ||
5715                                 aint(script[0].second[1], 'id', 'function') ||
5716                                 !script[0].second[1].first ||
5717                                 aint(script[0].second[1].first[0], 'string', 'dom') ||
5718                                 script[0].second[1].first.length > 2 ||
5719                                 (script[0].second[1].first.length === 2 &&
5720                                 aint(script[0].second[1].first[1], 'string', 'lib'))) {
5721                             stop('adsafe_go', next_token);
5722                         }
5723                         adsafe_went = true;
5724                         break;
5725                     default:
5726                         stop('adsafe_id_go');
5727                     }
5728                 }
5729                 indent = null;
5730             }
5731             xmode = 'html';
5732             advance('</');
5733             advance_identifier('script');
5734             xmode = 'outer';
5735             break;
5736         case 'style':
5737             xmode = 'style';
5738             advance('>');
5739             styles();
5740             xmode = 'html';
5741             advance('</');
5742             advance_identifier('style');
5743             break;
5744         case 'input':
5745             switch (attribute.type) {
5746             case 'button':
5747             case 'checkbox':
5748             case 'radio':
5749             case 'reset':
5750             case 'submit':
5751                 break;
5752             case 'file':
5753             case 'hidden':
5754             case 'image':
5755             case 'password':
5756             case 'text':
5757                 if (option.adsafe && attribute.autocomplete !== 'off') {
5758                     warn('adsafe_autocomplete');
5759                 }
5760                 break;
5761             default:
5762                 warn('bad_type');
5763             }
5764             break;
5765         case 'applet':
5766         case 'body':
5767         case 'embed':
5768         case 'frame':
5769         case 'frameset':
5770         case 'head':
5771         case 'iframe':
5772         case 'noembed':
5773         case 'noframes':
5774         case 'object':
5775         case 'param':
5776             if (option.adsafe) {
5777                 warn('adsafe_tag', next_token, name);
5778             }
5779             break;
5780         }
5781     }
5782
5783
5784     function closetag(name) {
5785         return '</' + name + '>';
5786     }
5787
5788     function html() {
5789         var attribute, attributes, is_empty, name, old_white = option.white,
5790             quote, tag_name, tag, wmode;
5791         xmode = 'html';
5792         xquote = '';
5793         stack = null;
5794         for (;;) {
5795             switch (next_token.string) {
5796             case '<':
5797                 xmode = 'html';
5798                 advance('<');
5799                 attributes = {};
5800                 tag_name = next_token;
5801                 name = tag_name.string;
5802                 advance_identifier(name);
5803                 if (option.cap) {
5804                     name = name.toLowerCase();
5805                 }
5806                 tag_name.name = name;
5807                 if (!stack) {
5808                     stack = [];
5809                     do_begin(name);
5810                 }
5811                 tag = html_tag[name];
5812                 if (typeof tag !== 'object') {
5813                     stop('unrecognized_tag_a', tag_name, name);
5814                 }
5815                 is_empty = tag.empty;
5816                 tag_name.type = name;
5817                 for (;;) {
5818                     if (next_token.id === '/') {
5819                         advance('/');
5820                         if (next_token.id !== '>') {
5821                             warn('expected_a_b', next_token, '>', artifact());
5822                         }
5823                         break;
5824                     }
5825                     if (next_token.id && next_token.id.charAt(0) === '>') {
5826                         break;
5827                     }
5828                     if (!next_token.identifier) {
5829                         if (next_token.id === '(end)' || next_token.id === '(error)') {
5830                             warn('expected_a_b', next_token, '>', artifact());
5831                         }
5832                         warn('bad_name_a');
5833                     }
5834                     option.white = false;
5835                     spaces();
5836                     attribute = next_token.string;
5837                     option.white = old_white;
5838                     advance();
5839                     if (!option.cap && attribute !== attribute.toLowerCase()) {
5840                         warn('attribute_case_a', token);
5841                     }
5842                     attribute = attribute.toLowerCase();
5843                     xquote = '';
5844                     if (Object.prototype.hasOwnProperty.call(attributes, attribute)) {
5845                         warn('duplicate_a', token, attribute);
5846                     }
5847                     if (attribute.slice(0, 2) === 'on') {
5848                         if (!option.on) {
5849                             warn('html_handlers');
5850                         }
5851                         xmode = 'scriptstring';
5852                         advance('=');
5853                         quote = next_token.id;
5854                         if (quote !== '"' && quote !== '\'') {
5855                             stop('expected_a_b', next_token, '"', artifact());
5856                         }
5857                         xquote = quote;
5858                         wmode = option.white;
5859                         option.white = true;
5860                         advance(quote);
5861                         use_strict();
5862                         statements();
5863                         option.white = wmode;
5864                         if (next_token.id !== quote) {
5865                             stop('expected_a_b', next_token, quote, artifact());
5866                         }
5867                         xmode = 'html';
5868                         xquote = '';
5869                         advance(quote);
5870                         tag = false;
5871                     } else if (attribute === 'style') {
5872                         xmode = 'scriptstring';
5873                         advance('=');
5874                         quote = next_token.id;
5875                         if (quote !== '"' && quote !== '\'') {
5876                             stop('expected_a_b', next_token, '"', artifact());
5877                         }
5878                         xmode = 'styleproperty';
5879                         xquote = quote;
5880                         advance(quote);
5881                         substyle();
5882                         xmode = 'html';
5883                         xquote = '';
5884                         advance(quote);
5885                         tag = false;
5886                     } else {
5887                         if (next_token.id === '=') {
5888                             advance('=');
5889                             tag = next_token.string;
5890                             if (!next_token.identifier &&
5891                                     next_token.id !== '"' &&
5892                                     next_token.id !== '\'' &&
5893                                     next_token.id !== '(string)' &&
5894                                     next_token.id !== '(string)' &&
5895                                     next_token.id !== '(color)') {
5896                                 warn('expected_attribute_value_a', token, attribute);
5897                             }
5898                             advance();
5899                         } else {
5900                             tag = true;
5901                         }
5902                     }
5903                     attributes[attribute] = tag;
5904                     do_attribute(attribute, tag);
5905                 }
5906                 do_tag(name, attributes);
5907                 if (!is_empty) {
5908                     stack.push(tag_name);
5909                 }
5910                 xmode = 'outer';
5911                 advance('>');
5912                 break;
5913             case '</':
5914                 xmode = 'html';
5915                 advance('</');
5916                 if (!next_token.identifier) {
5917                     warn('bad_name_a');
5918                 }
5919                 name = next_token.string;
5920                 if (option.cap) {
5921                     name = name.toLowerCase();
5922                 }
5923                 advance();
5924                 if (!stack) {
5925                     stop('unexpected_a', next_token, closetag(name));
5926                 }
5927                 tag_name = stack.pop();
5928                 if (!tag_name) {
5929                     stop('unexpected_a', next_token, closetag(name));
5930                 }
5931                 if (tag_name.name !== name) {
5932                     stop('expected_a_b',
5933                         next_token, closetag(tag_name.name), closetag(name));
5934                 }
5935                 if (next_token.id !== '>') {
5936                     stop('expected_a_b', next_token, '>', artifact());
5937                 }
5938                 xmode = 'outer';
5939                 advance('>');
5940                 break;
5941             case '<!':
5942                 if (option.safe) {
5943                     warn('adsafe_a');
5944                 }
5945                 xmode = 'html';
5946                 for (;;) {
5947                     advance();
5948                     if (next_token.id === '>' || next_token.id === '(end)') {
5949                         break;
5950                     }
5951                     if (next_token.string.indexOf('--') >= 0) {
5952                         stop('unexpected_a', next_token, '--');
5953                     }
5954                     if (next_token.string.indexOf('<') >= 0) {
5955                         stop('unexpected_a', next_token, '<');
5956                     }
5957                     if (next_token.string.indexOf('>') >= 0) {
5958                         stop('unexpected_a', next_token, '>');
5959                     }
5960                 }
5961                 xmode = 'outer';
5962                 advance('>');
5963                 break;
5964             case '(end)':
5965                 return;
5966             default:
5967                 if (next_token.id === '(end)') {
5968                     stop('missing_a', next_token,
5969                         '</' + stack[stack.length - 1].string + '>');
5970                 } else {
5971                     advance();
5972                 }
5973             }
5974             if (stack && stack.length === 0 && (option.adsafe ||
5975                     !option.fragment || next_token.id === '(end)')) {
5976                 break;
5977             }
5978         }
5979         if (next_token.id !== '(end)') {
5980             stop('unexpected_a');
5981         }
5982     }
5983
5984
5985 // The actual JSLINT function itself.
5986
5987     itself = function JSLint(the_source, the_option) {
5988
5989         var i, predef, tree;
5990         JSLINT.errors = [];
5991         JSLINT.tree = '';
5992         begin = prev_token = token = next_token =
5993             Object.create(syntax['(begin)']);
5994         predefined = {};
5995         add_to_predefined(standard);
5996         property = {};
5997         if (the_option) {
5998             option = Object.create(the_option);
5999             predef = option.predef;
6000             if (predef) {
6001                 if (Array.isArray(predef)) {
6002                     for (i = 0; i < predef.length; i += 1) {
6003                         predefined[predef[i]] = true;
6004                     }
6005                 } else if (typeof predef === 'object') {
6006                     add_to_predefined(predef);
6007                 }
6008             }
6009             do_safe();
6010         } else {
6011             option = {};
6012         }
6013         option.indent = +option.indent || 4;
6014         option.maxerr = +option.maxerr || 50;
6015         adsafe_id = '';
6016         adsafe_may = adsafe_top = adsafe_went = false;
6017         approved = {};
6018         if (option.approved) {
6019             for (i = 0; i < option.approved.length; i += 1) {
6020                 approved[option.approved[i]] = option.approved[i];
6021             }
6022         } else {
6023             approved.test = 'test';
6024         }
6025         tab = '';
6026         for (i = 0; i < option.indent; i += 1) {
6027             tab += ' ';
6028         }
6029         global_scope = scope = {};
6030         global_funct = funct = {
6031             '(scope)': scope,
6032             '(breakage)': 0,
6033             '(loopage)': 0
6034         };
6035         functions = [funct];
6036
6037         comments_off = false;
6038         ids = {};
6039         in_block = false;
6040         indent = null;
6041         json_mode = false;
6042         lookahead = [];
6043         node_js = false;
6044         prereg = true;
6045         src = false;
6046         stack = null;
6047         strict_mode = false;
6048         urls = [];
6049         var_mode = null;
6050         warnings = 0;
6051         xmode = '';
6052         lex.init(the_source);
6053
6054         assume();
6055
6056         try {
6057             advance();
6058             if (next_token.id === '(number)') {
6059                 stop('unexpected_a');
6060             } else if (next_token.string.charAt(0) === '<') {
6061                 html();
6062                 if (option.adsafe && !adsafe_went) {
6063                     warn('adsafe_go', this);
6064                 }
6065             } else {
6066                 switch (next_token.id) {
6067                 case '{':
6068                 case '[':
6069                     json_mode = true;
6070                     json_value();
6071                     break;
6072                 case '@':
6073                 case '*':
6074                 case '#':
6075                 case '.':
6076                 case ':':
6077                     xmode = 'style';
6078                     advance();
6079                     if (token.id !== '@' || !next_token.identifier ||
6080                             next_token.string !== 'charset' || token.line !== 1 ||
6081                             token.from !== 1) {
6082                         stop('css');
6083                     }
6084                     advance();
6085                     if (next_token.id !== '(string)' &&
6086                             next_token.string !== 'UTF-8') {
6087                         stop('css');
6088                     }
6089                     advance();
6090                     semicolon();
6091                     styles();
6092                     break;
6093
6094                 default:
6095                     if (option.adsafe && option.fragment) {
6096                         stop('expected_a_b',
6097                             next_token, '<div>', artifact());
6098                     }
6099
6100 // If the first token is a semicolon, ignore it. This is sometimes used when
6101 // files are intended to be appended to files that may be sloppy. A sloppy
6102 // file may be depending on semicolon insertion on its last line.
6103
6104                     step_in(1);
6105                     if (next_token.id === ';' && !node_js) {
6106                         semicolon();
6107                     }
6108                     adsafe_top = true;
6109                     tree = statements();
6110                     begin.first = tree;
6111                     JSLINT.tree = begin;
6112                     // infer_types(tree);
6113                     if (option.adsafe && (tree.length !== 1 ||
6114                             aint(tree[0], 'id', '(') ||
6115                             aint(tree[0].first, 'id', '.') ||
6116                             aint(tree[0].first.first, 'string', 'ADSAFE') ||
6117                             aint(tree[0].first.second, 'string', 'lib') ||
6118                             tree[0].second.length !== 2 ||
6119                             tree[0].second[0].id !== '(string)' ||
6120                             aint(tree[0].second[1], 'id', 'function'))) {
6121                         stop('adsafe_lib');
6122                     }
6123                     if (tree.disrupt) {
6124                         warn('weird_program', prev_token);
6125                     }
6126                 }
6127             }
6128             indent = null;
6129             advance('(end)');
6130         } catch (e) {
6131             if (e) {        // ~~
6132                 JSLINT.errors.push({
6133                     reason    : e.message,
6134                     line      : e.line || next_token.line,
6135                     character : e.character || next_token.from
6136                 }, null);
6137             }
6138         }
6139         return JSLINT.errors.length === 0;
6140     };
6141
6142
6143 // Data summary.
6144
6145     itself.data = function () {
6146         var data = {functions: []},
6147             function_data,
6148             globals,
6149             i,
6150             j,
6151             kind,
6152             members = [],
6153             name,
6154             the_function,
6155             undef = [],
6156             unused = [];
6157         if (itself.errors.length) {
6158             data.errors = itself.errors;
6159         }
6160
6161         if (json_mode) {
6162             data.json = true;
6163         }
6164
6165         if (urls.length > 0) {
6166             data.urls = urls;
6167         }
6168
6169         globals = Object.keys(global_scope).filter(function (value) {
6170             return value.charAt(0) !== '(' && typeof standard[value] !== 'boolean';
6171         });
6172         if (globals.length > 0) {
6173             data.globals = globals;
6174         }
6175
6176         for (i = 1; i < functions.length; i += 1) {
6177             the_function = functions[i];
6178             function_data = {};
6179             for (j = 0; j < functionicity.length; j += 1) {
6180                 function_data[functionicity[j]] = [];
6181             }
6182             for (name in the_function) {
6183                 if (Object.prototype.hasOwnProperty.call(the_function, name)) {
6184                     if (name.charAt(0) !== '(') {
6185                         kind = the_function[name];
6186                         if (kind === 'unction' || kind === 'unparam') {
6187                             kind = 'unused';
6188                         }
6189                         if (Array.isArray(function_data[kind])) {
6190                             function_data[kind].push(name);
6191                             if (kind === 'unused') {
6192                                 unused.push({
6193                                     name: name,
6194                                     line: the_function['(line)'],
6195                                     'function': the_function['(name)']
6196                                 });
6197                             } else if (kind === 'undef') {
6198                                 undef.push({
6199                                     name: name,
6200                                     line: the_function['(line)'],
6201                                     'function': the_function['(name)']
6202                                 });
6203                             }
6204                         }
6205                     }
6206                 }
6207             }
6208             for (j = 0; j < functionicity.length; j += 1) {
6209                 if (function_data[functionicity[j]].length === 0) {
6210                     delete function_data[functionicity[j]];
6211                 }
6212             }
6213             function_data.name = the_function['(name)'];
6214             function_data.params = the_function['(params)'];
6215             function_data.line = the_function['(line)'];
6216             data.functions.push(function_data);
6217         }
6218
6219         if (unused.length > 0) {
6220             data.unused = unused;
6221         }
6222         if (undef.length > 0) {
6223             data['undefined'] = undef;
6224         }
6225
6226         members = [];
6227         for (name in property) {
6228             if (typeof property[name] === 'number') {
6229                 data.member = property;
6230                 break;
6231             }
6232         }
6233
6234         return data;
6235     };
6236
6237
6238     itself.report = function (errors_only) {
6239         var data = itself.data(), err, evidence, i, italics, j, key, keys,
6240             length, mem = '', name, names, not_first, output = [], snippets,
6241             the_function, warning;
6242
6243         function detail(h, value) {
6244             var comma_needed, singularity;
6245             if (Array.isArray(value)) {
6246                 output.push('<div><i>' + h + '</i> ');
6247                 value.sort().forEach(function (item) {
6248                     if (item !== singularity) {
6249                         singularity = item;
6250                         output.push((comma_needed ? ', ' : '') + singularity);
6251                         comma_needed = true;
6252                     }
6253                 });
6254                 output.push('</div>');
6255             } else if (value) {
6256                 output.push('<div><i>' + h + '</i> ' + value + '</div>');
6257             }
6258         }
6259
6260         if (data.errors || data.unused || data['undefined']) {
6261             err = true;
6262             output.push('<div id=errors><i>Error:</i>');
6263             if (data.errors) {
6264                 for (i = 0; i < data.errors.length; i += 1) {
6265                     warning = data.errors[i];
6266                     if (warning) {
6267                         evidence = warning.evidence || '';
6268                         output.push('<p>Problem' + (isFinite(warning.line)
6269                             ? ' at line ' + String(warning.line) +
6270                                 ' character ' + String(warning.character)
6271                             : '') +
6272                             ': ' + warning.reason.entityify() +
6273                             '</p><p class=evidence>' +
6274                             (evidence && (evidence.length > 80
6275                                 ? evidence.slice(0, 77) + '...'
6276                                 : evidence).entityify()) + '</p>');
6277                     }
6278                 }
6279             }
6280
6281             if (data['undefined']) {
6282                 snippets = [];
6283                 for (i = 0; i < data['undefined'].length; i += 1) {
6284                     snippets[i] = '<code><u>' + data['undefined'][i].name + '</u></code>&nbsp;<i>' +
6285                         String(data['undefined'][i].line) + ' </i> <small>' +
6286                         data['undefined'][i]['function'] + '</small>';
6287                 }
6288                 output.push('<p><i>Undefined variable:</i> ' + snippets.join(', ') + '</p>');
6289             }
6290             if (data.unused) {
6291                 snippets = [];
6292                 for (i = 0; i < data.unused.length; i += 1) {
6293                     snippets[i] = '<code><u>' + data.unused[i].name + '</u></code>&nbsp;<i>' +
6294                         String(data.unused[i].line) + ' </i> <small>' +
6295                         data.unused[i]['function'] + '</small>';
6296                 }
6297                 output.push('<p><i>Unused variable:</i> ' + snippets.join(', ') + '</p>');
6298             }
6299             if (data.json) {
6300                 output.push('<p>JSON: bad.</p>');
6301             }
6302             output.push('</div>');
6303         }
6304
6305         if (!errors_only) {
6306
6307             output.push('<br><div id=functions>');
6308
6309             if (data.urls) {
6310                 detail("URLs<br>", data.urls, '<br>');
6311             }
6312
6313             if (xmode === 'style') {
6314                 output.push('<p>CSS.</p>');
6315             } else if (data.json && !err) {
6316                 output.push('<p>JSON: good.</p>');
6317             } else if (data.globals) {
6318                 output.push('<div><i>Global</i> ' +
6319                     data.globals.sort().join(', ') + '</div>');
6320             } else {
6321                 output.push('<div><i>No new global variables introduced.</i></div>');
6322             }
6323
6324             for (i = 0; i < data.functions.length; i += 1) {
6325                 the_function = data.functions[i];
6326                 names = [];
6327                 if (the_function.params) {
6328                     for (j = 0; j < the_function.params.length; j += 1) {
6329                         names[j] = the_function.params[j].string;
6330                     }
6331                 }
6332                 output.push('<br><div class=function><i>' +
6333                     String(the_function.line) + '</i> ' +
6334                     the_function.name.entityify() +
6335                     '(' + names.join(', ') + ')</div>');
6336                 detail('<big><b>Undefined</b></big>', the_function['undefined']);
6337                 detail('<big><b>Unused</b></big>', the_function.unused);
6338                 detail('Closure', the_function.closure);
6339                 detail('Variable', the_function['var']);
6340                 detail('Exception', the_function.exception);
6341                 detail('Outer', the_function.outer);
6342                 detail('Global', the_function.global);
6343                 detail('Label', the_function.label);
6344             }
6345
6346             if (data.member) {
6347                 keys = Object.keys(data.member);
6348                 if (keys.length) {
6349                     keys = keys.sort();
6350                     output.push('<br><pre id=properties>/*properties<br>');
6351                     mem = '    ';
6352                     italics = 0;
6353                     j = 0;
6354                     not_first = false;
6355                     for (i = 0; i < keys.length; i += 1) {
6356                         key = keys[i];
6357                         if (data.member[key] > 0) {
6358                             if (not_first) {
6359                                 mem += ', ';
6360                             }
6361                             name = ix.test(key)
6362                                 ? key
6363                                 : '\'' + key.entityify().replace(nx, sanitize) + '\'';
6364                             length += name.length + 2;
6365                             if (data.member[key] === 1) {
6366                                 name = '<i>' + name + '</i>';
6367                                 italics += 1;
6368                                 j = 1;
6369                             }
6370                             if (mem.length + name.length - (italics * 7) > 80) {
6371                                 output.push(mem + '<br>');
6372                                 mem = '    ';
6373                                 italics = j;
6374                             }
6375                             mem += name;
6376                             j = 0;
6377                             not_first = true;
6378                         }
6379                     }
6380                     output.push(mem + '<br>*/</pre>');
6381                 }
6382                 output.push('</div>');
6383             }
6384         }
6385         return output.join('');
6386     };
6387     itself.jslint = itself;
6388
6389     itself.edition = '2012-02-23';
6390
6391     return itself;
6392 }());