From 43b922ef90752df805f848a6d5996d1d6f1293bc Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Fri, 4 Jan 2013 16:42:49 -0600
Subject: [PATCH 01/25] added turd file

---
 node_modules/.turd | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 node_modules/.turd

diff --git a/node_modules/.turd b/node_modules/.turd
new file mode 100644
index 0000000..e69de29

From fd20859ae76ca9c3ea5158d5d7d443425b67bc34 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Tue, 8 Jan 2013 08:28:31 -0600
Subject: [PATCH 02/25] big moderization, now works with the latest express

---
 .gitignore   |   1 +
 app.js       | 100 +++++++++++++++++++++++----------------------------
 package.json |  15 ++++++--
 3 files changed, 57 insertions(+), 59 deletions(-)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..07e6e47
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/node_modules
diff --git a/app.js b/app.js
index 793236a..7d9f55d 100644
--- a/app.js
+++ b/app.js
@@ -1,3 +1,6 @@
+#!node
+;
+'use strict';
 /* HTTP interface to JSLint.
 
    Takes roughly half the time to jslint something with this than to
@@ -6,98 +9,81 @@
    Invoke from bash script like:
 
      curl --form source="<${1}" --form filename="${1}" ${JSLINT_URL}
-     
+
    or use the provided jslint.curl
-   
+
      jslint.curl <file>
 
 */
 
-/*global process, require */
 var express = require("express");
-var JSLINT = require('./fulljslint');
-var fs = require('fs');
-var _ = require('underscore');
+var http = require('http');
+var JSLINT = require('./fulljslint').JSLINT;
+var package_info = require('./package');
 
-var app = express.createServer();
+var app = express();
 
-app.configure(function () {
-    app.use(express.errorHandler(
-        { dumpExceptions: true, showStack: true }));
-    app.use(express.bodyParser());
-});
+app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
+app.use(express.bodyParser());
 
 var jslint_port = 3003;
 
-/* copied from jslint's rhino.js */
+// use jslint's default options, by default
 var jslint_options = {
-    bitwise: true,
-    eqeqeq: true,
-    immed: true,
-    newcap: true,
-    nomen: true,
-    onevar: true,
-    plusplus: true,
-    regexp: true,
-    rhino: true,
-    undef: true,
-    white: true
 };
 
 var outputErrors = function (errors) {
     var e, i, output = [];
     // debug("Handling " + errors.length + "errors" + '\n');
-    function write(s) {
-        output.push(s + '\n');
-    }
+
     /* This formatting is copied from JSLint's rhino.js, to be compatible with
        the command-line invocation. */
     for (i = 0; i < errors.length; i += 1) {
         e = errors[i];
         if (e) {
-            write('Lint at line ' + e.line + ' character ' +
-                        e.character + ': ' + e.reason);
-            write((e.evidence || '').replace(/^\s*(\S*(\s+\S+)*)\s*$/, "$1"));
-            write('');
+            output.push('Lint at line ', e.line,  ' character ', e.character, ': ', e.reason, '\n');
+            output.push((e.evidence || '').replace(/^\s*(\S*(\s+\S+)*)\s*$/, "$1"), '\n');
+            output.push('\n');
         }
     }
     return output.join('');
 };
 
 app.get('/', function (req, res) {
-    res.send('lintnode');
+    res.type('text/plain').end('lintnode version: ' + package_info.version + '\n' + 'jslint edition: ' + JSLINT.edition + '\n');
 });
 
 app.post('/jslint', function (req, res) {
     function doLint(sourcedata) {
         var passed, results;
-        passed = JSLINT.JSLINT(sourcedata, jslint_options);
+        passed = JSLINT(sourcedata, jslint_options);
         if (passed) {
             results = "jslint: No problems found in " + req.body.filename + "\n";
         } else {
-            results = outputErrors(JSLINT.JSLINT.errors);
+            results = outputErrors(JSLINT.errors);
         }
         return results;
     }
-    res.send(doLint(req.body.source), {'Content-Type': 'text/plain'});
+    res.type('text/plain').end(doLint(req.body.source));
 });
 
 /* This action always return some JSLint problems. */
-var exampleFunc = function (req, res) {
-    JSLINT.JSLINT("a = function(){ return 7 + x }()",
+var exampleErrors = function (req, res) {
+    JSLINT("a = function(){ return 7 + x }()",
         jslint_options);
-    res.send(outputErrors(JSLINT.JSLINT.errors),
-        {'Content-Type': 'text/plain'});
+    res.type('text/plain').end(outputErrors(JSLINT.errors));
 };
 
-app.get('/example/errors', exampleFunc);
-app.post('/example/errors', exampleFunc);
-
 /* This action always returns JSLint's a-okay message. */
-app.post('/example/ok', function (req, res) {
-    res.send("jslint: No problems found in example.js\n",
-        {'Content-Type': 'text/plain'});
-});
+var exampleOk = function (req, res) {
+    res.type('text/plain').end("jslint: No problems found in example.js\n");
+};
+
+app.get('/example/errors', exampleErrors);
+app.post('/example/errors', exampleErrors);
+
+app.get('/example/ok', exampleOk);
+app.post('/example/ok', exampleOk);
 
 function parseCommandLine() {
     var port_index, exclude_index, exclude_opts, include_index, include_opts, set_index, set_opts, set_pair, properties;
@@ -111,7 +97,7 @@ function parseCommandLine() {
     if (exclude_index > -1) {
         exclude_opts = process.argv[exclude_index + 1].split(",");
         if (exclude_opts.length > 0 && exclude_opts[0] !== '') {
-            _.each(exclude_opts, function (opt) {
+            exclude_opts.forEach(function (opt) {
                 jslint_options[opt] = false;
             });
         }
@@ -119,7 +105,7 @@ function parseCommandLine() {
     if (include_index > -1) {
         include_opts = process.argv[include_index + 1].split(",");
         if (include_opts.length > 0 && include_opts[0] !== '') {
-            _.each(include_opts, function (opt) {
+            include_opts.forEach(function (opt) {
                 jslint_options[opt] = true;
             });
         }
@@ -127,7 +113,7 @@ function parseCommandLine() {
     if (set_index > -1) {
         set_opts = process.argv[set_index + 1].split(",");
         if (set_opts.length > 0 && set_opts[0] !== '') {
-            _.each(set_opts, function (opt) {
+            set_opts.forEach(function (opt) {
                 if (opt.indexOf(":") > -1) {
                     set_pair = opt.split(":");
                     if (set_pair[1] === "true") {
@@ -142,11 +128,10 @@ function parseCommandLine() {
             });
         }
     }
-    properties = "";
-    _.each(jslint_options, function (value, opt) {
-        properties = properties + opt + ": " + value + ", ";
-    });
-    return properties.substring(0, properties.length-2);
+    properties = Object.keys(jslint_options).map(function (opt) {
+        return opt + ": " + jslint_options[opt];
+    }).join('; ');
+    return properties;
 }
 
 process.on('SIGINT', function () {
@@ -154,7 +139,10 @@ process.on('SIGINT', function () {
     process.exit(0);
 });
 
+console.log('[lintnode] version:', package_info.version);
+console.log('[lintnode] jslint edition:', JSLINT.edition);
 console.log("[lintnode]", parseCommandLine());
-app.listen(jslint_port, function () {
+var http_server = http.createServer(app);
+http_server.listen(jslint_port, function () {
     console.log("[lintnode] server running on port", jslint_port);
-});
\ No newline at end of file
+});
diff --git a/package.json b/package.json
index db16950..04d13c9 100644
--- a/package.json
+++ b/package.json
@@ -7,10 +7,19 @@
         "name": "Kevin Turner",
         "url": "http://keturn.net/"
     },
+    "contributors": [
+        {
+            "name": "David Miller",
+            "url": "http://github.com/davidmiller/lintnode"
+        },
+        {
+            "name": "Chad Walker",
+            "email": "chad@chad-cat-lore-eddie.com"
+        }
+    ],
+    "bin": "./app.js",
     "dependencies": {
-        "express": "<=2.5.9",
-        "haml": ">=0.2.0",
-        "underscore": ""
+        "express": "latest"
     },
     "engines": ["node >= 0.6.0"]
 }

From 292a6a3ef7574181f0be2e00331eea44c72b35e3 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Tue, 8 Jan 2013 08:37:04 -0600
Subject: [PATCH 03/25] fixed executing lintnode

---
 app.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)
 mode change 100644 => 100755 app.js

diff --git a/app.js b/app.js
old mode 100644
new mode 100755
index 7d9f55d..7bc0608
--- a/app.js
+++ b/app.js
@@ -1,6 +1,8 @@
-#!node
-;
+#!/usr/bin/env node
+
+/*global */
 'use strict';
+
 /* HTTP interface to JSLint.
 
    Takes roughly half the time to jslint something with this than to

From 1b52a0142b22312a976fd477b36923a297e33919 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Tue, 8 Jan 2013 09:14:08 -0600
Subject: [PATCH 04/25] updated to newest jslint (2012-12-31) and lowercased
 the jslint identifier

---
 app.js        | 14 +++++++-------
 fulljslint.js | 30 +++++++++++++++++-------------
 2 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/app.js b/app.js
index 7bc0608..c2e96bd 100755
--- a/app.js
+++ b/app.js
@@ -20,7 +20,7 @@
 
 var express = require("express");
 var http = require('http');
-var JSLINT = require('./fulljslint').JSLINT;
+var jslint = require('./fulljslint').jslint;
 var package_info = require('./package');
 
 var app = express();
@@ -52,17 +52,17 @@ var outputErrors = function (errors) {
 };
 
 app.get('/', function (req, res) {
-    res.type('text/plain').end('lintnode version: ' + package_info.version + '\n' + 'jslint edition: ' + JSLINT.edition + '\n');
+    res.type('text/plain').end('lintnode version: ' + package_info.version + '\n' + 'jslint edition: ' + jslint.edition + '\n');
 });
 
 app.post('/jslint', function (req, res) {
     function doLint(sourcedata) {
         var passed, results;
-        passed = JSLINT(sourcedata, jslint_options);
+        passed = jslint(sourcedata, jslint_options);
         if (passed) {
             results = "jslint: No problems found in " + req.body.filename + "\n";
         } else {
-            results = outputErrors(JSLINT.errors);
+            results = outputErrors(jslint.errors);
         }
         return results;
     }
@@ -71,9 +71,9 @@ app.post('/jslint', function (req, res) {
 
 /* This action always return some JSLint problems. */
 var exampleErrors = function (req, res) {
-    JSLINT("a = function(){ return 7 + x }()",
+    jslint("a = function(){ return 7 + x }()",
         jslint_options);
-    res.type('text/plain').end(outputErrors(JSLINT.errors));
+    res.type('text/plain').end(outputErrors(jslint.errors));
 };
 
 /* This action always returns JSLint's a-okay message. */
@@ -142,7 +142,7 @@ process.on('SIGINT', function () {
 });
 
 console.log('[lintnode] version:', package_info.version);
-console.log('[lintnode] jslint edition:', JSLINT.edition);
+console.log('[lintnode] jslint edition:', jslint.edition);
 console.log("[lintnode]", parseCommandLine());
 var http_server = http.createServer(app);
 http_server.listen(jslint_port, function () {
diff --git a/fulljslint.js b/fulljslint.js
index e8e89a6..07394e9 100644
--- a/fulljslint.js
+++ b/fulljslint.js
@@ -1,5 +1,5 @@
 // jslint.js
-// 2012-12-04
+// 2012-12-31
 
 // Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)
 
@@ -272,7 +272,7 @@
     'margin-left', 'margin-right', 'margin-top', mark, 'marker-offset', match,
     'max-height', 'max-width', maxerr, maxlen, menu, message, meta, meter,
     'min-height', 'min-width', missing_a, missing_a_after_b, missing_option,
-    missing_property, missing_space_a_b, missing_url, missing_use_strict, mixed,
+    missing_property, missing_space_a_b, missing_url, missing_use_strict,
     mm, mode, move_invocation, move_var, n, name, name_function, nav,
     nested_comment, newcap, node, noframes, nomen, noscript, not,
     not_a_constructor, not_a_defined, not_a_function, not_a_label, not_a_scope,
@@ -289,8 +289,8 @@
     scanned_a_b, screen, script, search, second, section, select, shift,
     slash_equal, slice, sloppy, small, sort, source, span, speech, split, src,
     statement_block, stopping, strange_loop, strict, string, strong, stupid,
-    style, styleproperty, sub, subscript, substr, sup, supplant, sync_a, t,
-    table, 'table-layout', tag_a_in_b, tbody, td, test, 'text-align',
+    style, styleproperty, sub, subscript, substr, summary, sup, supplant,
+    sync_a, t,table, 'table-layout', tag_a_in_b, tbody, td, test, 'text-align',
     'text-decoration', 'text-indent', 'text-shadow', 'text-transform', textarea,
     tfoot, th, thead, third, thru, time, title, todo, todo_comment, toLowerCase,
     toString, toUpperCase, token, too_long, too_many, top, tr,
@@ -301,8 +301,8 @@
     unexpected_typeof_a, 'unicode-bidi', unnecessary_initialize,
     unnecessary_use, unparam, unreachable_a_b, unrecognized_style_attribute_a,
     unrecognized_tag_a, unsafe, unused, url, urls, use_array, use_braces,
-    use_charAt, use_object, use_or, use_param, used_before_a, var, var_a_not,
-    vars, 'vertical-align', video, visibility, was, weird_assignment,
+    use_charAt, use_object, use_or, use_param, use_spaces, used_before_a, var,
+    var_a_not, vars, 'vertical-align', video, visibility, was, weird_assignment,
     weird_condition, weird_new, weird_program, weird_relation, weird_ternary,
     white, 'white-space', width, windows, 'word-spacing', 'word-wrap', wrap,
     wrap_immediate, wrap_regexp, write_is_wrong, writeable, 'z-index'
@@ -542,7 +542,6 @@ var JSLINT = (function () {
             missing_space_a_b: "Missing space between '{a}' and '{b}'.",
             missing_url: "Missing url.",
             missing_use_strict: "Missing 'use strict' statement.",
-            mixed: "Mixed spaces and tabs.",
             move_invocation: "Move the invocation into the parens that " +
                 "contain the function.",
             move_var: "Move 'var' declarations to the top of the function.",
@@ -605,6 +604,7 @@ var JSLINT = (function () {
             use_object: "Use the object literal notation {}.",
             use_or: "Use the || operator.",
             use_param: "Use a named parameter.",
+            use_spaces: "Use spaces, not tabs.",
             used_before_a: "'{a}' was used before it was defined.",
             var_a_not: "Variable {a} was not declared correctly.",
             weird_assignment: "Weird assignment.",
@@ -825,6 +825,7 @@ var JSLINT = (function () {
             strong:   {},
             style:    {parent: ' head ', empty: true},
             sub:      {},
+            summary:  {parent: ' details '},
             sup:      {},
             table:    {},
             tbody:    {parent: ' table '},
@@ -923,7 +924,7 @@ var JSLINT = (function () {
 // carriage return, carriage return linefeed, or linefeed
         crlfx = /\r\n?|\n/,
 // unsafe characters that are silently deleted by one or more browsers
-        cx = /[\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/,
+        cx = /[\u0000-\u0008\u000a-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/,
 // query characters for ids
         dx = /[\[\]\/\\"'*<>.&:(){}+=#]/,
 // html token
@@ -1195,11 +1196,14 @@ var JSLINT = (function () {
             character = 1;
             source_row = lines[line];
             line += 1;
-            at = source_row.search(/ \t/);
+            at = source_row.search(/\t/);
             if (at >= 0) {
-                warn_at('mixed', line, at + 1);
+                if (option.white) {
+                    source_row = source_row.replace(/\t/g, ' ');
+                } else {
+                    warn_at('use_spaces', line, at + 1);
+                }
             }
-            source_row = source_row.replace(/\t/g, tab);
             at = source_row.search(cx);
             if (at >= 0) {
                 warn_at('unsafe', line, at);
@@ -6449,9 +6453,9 @@ klass:              do {
 
     itself.jslint = itself;
 
-    itself.edition = '2012-12-04';
+    itself.edition = '2012-12-31';
 
     return itself;
 }());
 
-exports.JSLINT = JSLINT;
\ No newline at end of file
+exports.jslint = JSLINT;

From 7b0d654d008750842e425328f88a21a71855e87e Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Thu, 24 Jan 2013 10:48:19 -0600
Subject: [PATCH 05/25] updated package

---
 package.json | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index 04d13c9..45911a3 100644
--- a/package.json
+++ b/package.json
@@ -1,8 +1,9 @@
 {
     "name": "lintnode",
-    "version": "0.1.1",
+    "version": "0.2.0",
     "description": "A JSLint server for more expedient linting.",
-    "homepage": "http://github.com/keturn/lintnode",
+    "keywords": "emacs flymake js-mode jslint",
+    "homepage": "http://github.com/chad3814/lintnode",
     "author": {
         "name": "Kevin Turner",
         "url": "http://keturn.net/"
@@ -17,9 +18,14 @@
             "email": "chad@chad-cat-lore-eddie.com"
         }
     ],
+    "repository": {
+        "type" : "git",
+        "url" : "http://github.com/chad3814/lintnode.git"
+    }
+    "preferGlobal": true,
     "bin": "./app.js",
     "dependencies": {
-        "express": "latest"
+        "express": "3.x"
     },
     "engines": ["node >= 0.6.0"]
 }

From 00031a945eb775bf2a21a47846c2745d8266fe6c Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Thu, 24 Jan 2013 10:52:39 -0600
Subject: [PATCH 06/25] fixed the package

---
 package.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index 45911a3..f64580d 100644
--- a/package.json
+++ b/package.json
@@ -19,9 +19,9 @@
         }
     ],
     "repository": {
-        "type" : "git",
-        "url" : "http://github.com/chad3814/lintnode.git"
-    }
+        "type": "git",
+        "url": "http://github.com/chad3814/lintnode.git"
+    },
     "preferGlobal": true,
     "bin": "./app.js",
     "dependencies": {

From 524aa9cbc948239cad519ac35f539d3eb6d6139b Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Thu, 24 Jan 2013 11:03:36 -0600
Subject: [PATCH 07/25] more package tweaks

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index f64580d..ca37b02 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
     "name": "lintnode",
     "version": "0.2.0",
     "description": "A JSLint server for more expedient linting.",
-    "keywords": "emacs flymake js-mode jslint",
+    "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",
     "author": {
         "name": "Kevin Turner",

From 6a523d01e23585fa4d0ce103a7318fc1d2f6ab79 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Thu, 24 Jan 2013 11:30:46 -0600
Subject: [PATCH 08/25] bumped version to fix keyword snafu

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index ca37b02..7432636 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",

From 32a48d9bafd2ed7feae55a204e76084b9ea42989 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Fri, 3 May 2013 22:51:22 -0500
Subject: [PATCH 09/25] updated to jslint.js from 2013-05-01, added
 setImmediate and clearImmediate to list of globals for node

---
 fulljslint.js | 4145 ++++++++++++-------------------------------------
 1 file changed, 967 insertions(+), 3178 deletions(-)

diff --git a/fulljslint.js b/fulljslint.js
index 07394e9..b9ef681 100644
--- a/fulljslint.js
+++ b/fulljslint.js
@@ -1,5 +1,5 @@
 // jslint.js
-// 2012-12-31
+// 2013-05-01
 
 // Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)
 
@@ -32,7 +32,7 @@
 // The first parameter is either a string or an array of strings. If it is a
 // string, it will be split on '\n' or '\r'. If it is an array of strings, it
 // is assumed that each string represents one line. The source can be a
-// JavaScript text, or HTML text, or a JSON text, or a CSS text.
+// JavaScript text or a JSON text.
 
 // The second parameter is an optional object of options that control the
 // operation of JSLINT. Most of the options are booleans: They are all
@@ -83,12 +83,7 @@
 //                 name: STRING,
 //                 line: NUMBER,
 //                 last: NUMBER,
-//                 params: [
-//                     {
-//                         string: STRING
-//                     }
-//                 ],
-//                 closure: [
+//                 parameter: [
 //                     STRING
 //                 ],
 //                 var: [
@@ -97,13 +92,10 @@
 //                 exception: [
 //                     STRING
 //                 ],
-//                 outer: [
-//                     STRING
-//                 ],
-//                 unused: [
+//                 closure: [
 //                     STRING
 //                 ],
-//                 undef: [
+//                 outer: [
 //                     STRING
 //                 ],
 //                 global: [
@@ -114,24 +106,19 @@
 //                 ]
 //             }
 //         ],
-//         globals: [
+//         global: [
 //             STRING
 //         ],
 //         member: {
 //             STRING: NUMBER
 //         },
-//         urls: [
-//             STRING
-//         ],
 //         json: BOOLEAN
 //     }
 
-// Empty arrays will not be included.
-
 // You can request a Function Report, which shows all of the functions
 // and the parameters and vars that they use. This can be used to find
 // implied global variables and other problems. The report is in HTML and
-// can be inserted in an HTML <body>. It should be given the result of the
+// can be inserted into an HTML <body>. It should be given the result of the
 // JSLINT.data function.
 
 //     var myReport = JSLINT.report(data);
@@ -140,6 +127,11 @@
 
 //     var myErrorReport = JSLINT.error_report(data);
 
+// You can obtain an object containing all of the properties found in the
+// file. JSLINT.property contains an object containing a key for each
+// property used in the program, the value being the number of times that
+// property name was used in the file.
+
 // You can request a properties report, which produces a list of the program's
 // properties in the form of a /*properties*/ declaration.
 
@@ -154,8 +146,24 @@
 //         'second', 'third', 'block', 'else'
 //     ], 4));
 
-// JSLint provides three directives. They look like slashstar comments, and
-// allow for setting options, declaring global variables, and establishing a
+// You can request a context coloring table. It contains information that can be
+// applied to the file that was analyzed. Context coloring colors functions
+// based on their nesting level, and variables on the color of the functions
+// in which they are defined.
+
+//      var myColorization = JSLINT.color(data);
+
+// It returns an array containing objects of this form:
+
+//      {
+//          from: COLUMN,
+//          thru: COLUMN,
+//          line: ROW,
+//          level: 0 or higher
+//      }
+
+// JSLint provides three inline directives. They look like slashstar comments,
+// and allow for setting options, declaring global variables, and establishing a
 // set of allowed property names.
 
 // These directives respect function scope.
@@ -164,36 +172,33 @@
 // For example:
 
 /*jslint
-    evil: true, nomen: true, regexp: true, todo: true
+    es5: true, evil: true, nomen: true, regexp: true, todo: true
 */
 
 // The current option set is
 
-//     anon       true, if the space may be omitted in anonymous function declarations
+//     ass        true, if assignment expressions should be allowed
 //     bitwise    true, if bitwise operators should be allowed
 //     browser    true, if the standard browser globals should be predefined
-//     'continue' true, if the continuation statement should be tolerated
-//     css        true, if CSS workarounds should be tolerated
+//     closure    true, if Google Closure idioms should be tolerated
+//     continue   true, if the continuation statement should be tolerated
 //     debug      true, if debugger statements should be allowed
 //     devel      true, if logging should be allowed (console, alert, etc.)
 //     eqeq       true, if == should be allowed
 //     es5        true, if ES5 syntax should be allowed
 //     evil       true, if eval should be allowed
 //     forin      true, if for in statements need not filter
-//     fragment   true, if HTML fragments should be allowed
 //     indent     the indentation factor
 //     maxerr     the maximum number of errors to allow
 //     maxlen     the maximum length of a source line
 //     newcap     true, if constructor names capitalization is ignored
 //     node       true, if Node.js globals should be predefined
 //     nomen      true, if names may have dangling _
-//     on         true, if HTML event handlers should be allowed
 //     passfail   true, if the scan should stop on first error
 //     plusplus   true, if increment/decrement should be allowed
 //     properties true, if all property names must be declared with /*properties*/
 //     regexp     true, if the . should be allowed in regexp literals
 //     rhino      true, if the Rhino environment globals should be predefined
-//     undef      true, if variables can be declared out of order
 //     unparam    true, if unused parameters should be tolerated
 //     sloppy     true, if the 'use strict'; pragma is optional
 //     stupid     true, if really stupid practices are tolerated
@@ -210,102 +215,51 @@
 // For example:
 
 /*properties
-    '\b', '\t', '\n', '\f', '\r', '!', '!=', '!==', '"', '%', '\'',
-    '(arguments)', '(begin)', '(breakage)', '(context)', '(error)',
-    '(identifier)', '(line)', '(loopage)', '(name)', '(params)', '(scope)',
-    '(token)', '(vars)', '(verb)', '*', '+', '-', '/', '<', '<=', '==', '===',
-    '>', '>=', ADSAFE, Array, Date, Function, Object, '\\', a, a_label,
-    a_not_allowed, a_not_defined, a_scope, abbr, acronym, address, adsafe,
-    adsafe_a, adsafe_autocomplete, adsafe_bad_id, adsafe_div, adsafe_fragment,
-    adsafe_go, adsafe_html, adsafe_id, adsafe_id_go, adsafe_lib,
-    adsafe_lib_second, adsafe_missing_id, adsafe_name_a, adsafe_placement,
-    adsafe_prefix_a, adsafe_script, adsafe_source, adsafe_subscript_a,
-    adsafe_tag, all, already_defined, and, anon, applet, apply, approved, area,
-    arity, article, aside, assign, assign_exception,
-    assignment_function_expression, at, attribute_case_a, audio, autocomplete,
-    avoid_a, b, background, 'background-attachment', 'background-color',
-    'background-image', 'background-position', 'background-repeat',
-    bad_assignment, bad_color_a, bad_constructor, bad_entity, bad_html, bad_id_a,
-    bad_in_a, bad_invocation, bad_name_a, bad_new, bad_number, bad_operand,
-    bad_style, bad_type, bad_url_a, bad_wrap, base, bdo, big, bitwise, block,
-    blockquote, body, border, 'border-bottom', 'border-bottom-color',
-    'border-bottom-left-radius', 'border-bottom-right-radius',
-    'border-bottom-style', 'border-bottom-width', 'border-collapse',
-    'border-color', 'border-left', 'border-left-color', 'border-left-style',
-    'border-left-width', 'border-radius', 'border-right', 'border-right-color',
-    'border-right-style', 'border-right-width', 'border-spacing', 'border-style',
-    'border-top', 'border-top-color', 'border-top-left-radius',
-    'border-top-right-radius', 'border-top-style', 'border-top-width',
-    'border-width', bottom, 'box-shadow', br, braille, browser, button, c, call,
-    canvas, caption, 'caption-side', center, charAt, charCodeAt, character,
-    cite, clear, clip, closure, cm, code, col, colgroup, color, combine_var,
-    command, conditional_assignment, confusing_a, confusing_regexp,
-    constructor_name_a, content, continue, control_a, 'counter-increment',
-    'counter-reset', create, css, cursor, d, dangerous_comment, dangling_a, data,
-    datalist, dd, debug, del, deleted, details, devel, dfn, dialog, dir,
-    direction, display, disrupt, div, dl, dt, duplicate_a, edge, edition, else,
-    em, embed, embossed, empty, 'empty-cells', empty_block, empty_case,
-    empty_class, entityify, eqeq, error_report, errors, es5, eval, evidence,
-    evil, ex, exception, exec, expected_a, expected_a_at_b_c, expected_a_b,
-    expected_a_b_from_c_d, expected_at_a, expected_attribute_a,
-    expected_attribute_value_a, expected_class_a, expected_fraction_a,
-    expected_id_a, expected_identifier_a, expected_identifier_a_reserved,
-    expected_lang_a, expected_linear_a, expected_media_a, expected_name_a,
-    expected_nonstandard_style_attribute, expected_number_a, expected_operator_a,
-    expected_percent_a, expected_positive_a, expected_pseudo_a,
-    expected_selector_a, expected_small_a, expected_space_a_b, expected_string_a,
-    expected_style_attribute, expected_style_pattern, expected_tagname_a,
-    expected_type_a, f, fieldset, figcaption, figure, filter, first, flag, float,
-    floor, font, 'font-family', 'font-size', 'font-size-adjust', 'font-stretch',
-    'font-style', 'font-variant', 'font-weight', footer, forEach, for_if, forin,
-    form, fragment, frame, frameset, from, fromCharCode, fud, funct, function,
-    function_block, function_eval, function_loop, function_statement,
-    function_strict, functions, global, globals, h1, h2, h3, h4, h5, h6,
-    handheld, hasOwnProperty, head, header, height, hgroup, hr,
-    'hta:application', html, html_confusion_a, html_handlers, i, id, identifier,
-    identifier_function, iframe, img, immed, implied_evil, in, indent, indexOf,
-    infix_in, init, input, ins, insecure_a, isAlpha, isArray, isDigit, isNaN,
-    join, jslint, json, kbd, keygen, keys, label, labeled, lang, lbp,
-    leading_decimal_a, led, left, legend, length, 'letter-spacing', li, lib,
-    line, 'line-height', link, 'list-style', 'list-style-image',
-    'list-style-position', 'list-style-type', map, margin, 'margin-bottom',
-    'margin-left', 'margin-right', 'margin-top', mark, 'marker-offset', match,
-    'max-height', 'max-width', maxerr, maxlen, menu, message, meta, meter,
-    'min-height', 'min-width', missing_a, missing_a_after_b, missing_option,
-    missing_property, missing_space_a_b, missing_url, missing_use_strict,
-    mm, mode, move_invocation, move_var, n, name, name_function, nav,
-    nested_comment, newcap, node, noframes, nomen, noscript, not,
-    not_a_constructor, not_a_defined, not_a_function, not_a_label, not_a_scope,
-    not_greater, nud, number, object, octal_a, ol, on, opacity, open, optgroup,
-    option, outer, outline, 'outline-color', 'outline-style', 'outline-width',
-    output, overflow, 'overflow-x', 'overflow-y', p, padding, 'padding-bottom',
-    'padding-left', 'padding-right', 'padding-top', 'page-break-after',
-    'page-break-before', param, parameter_a_get_b, parameter_arguments_a,
-    parameter_set_a, params, paren, parent, passfail, pc, plusplus, pop,
-    position, postscript, pre, predef, print, progress, projection, properties,
-    properties_report, property, prototype, pt, push, px, q, quote, quotes, r,
-    radix, range, raw, read_only, reason, redefinition_a, regexp, replace,
-    report, reserved, reserved_a, rhino, right, rp, rt, ruby, safe, samp,
-    scanned_a_b, screen, script, search, second, section, select, shift,
-    slash_equal, slice, sloppy, small, sort, source, span, speech, split, src,
-    statement_block, stopping, strange_loop, strict, string, strong, stupid,
-    style, styleproperty, sub, subscript, substr, summary, sup, supplant,
-    sync_a, t,table, 'table-layout', tag_a_in_b, tbody, td, test, 'text-align',
-    'text-decoration', 'text-indent', 'text-shadow', 'text-transform', textarea,
-    tfoot, th, thead, third, thru, time, title, todo, todo_comment, toLowerCase,
-    toString, toUpperCase, token, too_long, too_many, top, tr,
-    trailing_decimal_a, tree, tt, tty, tv, type, u, ul, unclosed,
-    unclosed_comment, unclosed_regexp, undef, undefined, unescaped_a,
-    unexpected_a, unexpected_char_a_b, unexpected_comment, unexpected_else,
-    unexpected_label_a, unexpected_property_a, unexpected_space_a_b,
-    unexpected_typeof_a, 'unicode-bidi', unnecessary_initialize,
-    unnecessary_use, unparam, unreachable_a_b, unrecognized_style_attribute_a,
-    unrecognized_tag_a, unsafe, unused, url, urls, use_array, use_braces,
-    use_charAt, use_object, use_or, use_param, use_spaces, used_before_a, var,
-    var_a_not, vars, 'vertical-align', video, visibility, was, weird_assignment,
+    '\b', '\t', '\n', '\f', '\r', '!', '!=', '!==', '"', '%', '\'', '(begin)',
+    '(error)', '*', '+', '-', '/', '<', '<=', '==', '===', '>', '>=', '\\', a,
+    a_label, a_scope, already_defined, and, arguments, arity, ass, assign,
+    assignment_expression, assignment_function_expression, at, avoid_a, b,
+    bad_assignment, bad_constructor, bad_in_a, bad_invocation, bad_new,
+    bad_number, bad_operand, bad_wrap, bitwise, block, browser, c, call, charAt,
+    charCodeAt, character, closure, color, combine_var, comments,
+    conditional_assignment, confusing_a, confusing_regexp, constructor_name_a,
+    continue, control_a, couch, create, d, dangling_a, data, dead, debug,
+    deleted, devel, disrupt, duplicate_a, edge, edition, else, empty_block,
+    empty_case, empty_class, entityify, eqeq, error_report, errors, es5,
+    evidence, evil, exception, exec, expected_a_at_b_c, expected_a_b,
+    expected_a_b_from_c_d, expected_id_a, expected_identifier_a,
+    expected_identifier_a_reserved, expected_number_a, expected_operator_a,
+    expected_positive_a, expected_small_a, expected_space_a_b,
+    expected_string_a, f, first, flag, floor, forEach, for_if, forin, from,
+    fromCharCode, fud, function, function_block, function_eval, function_loop,
+    function_statement, function_strict, functions, global, hasOwnProperty, id,
+    identifier, identifier_function, immed, implied_evil, indent, indexOf,
+    infix_in, init, insecure_a, isAlpha, isArray, isDigit, isNaN, join, jslint,
+    json, keys, kind, label, labeled, lbp, leading_decimal_a, led, left, length,
+    level, line, loopage, master, match, maxerr, maxlen, message, missing_a,
+    missing_a_after_b, missing_property, missing_space_a_b, missing_use_strict,
+    mode, move_invocation, move_var, n, name, name_function, nested_comment,
+    newcap, node, nomen, not, not_a_constructor, not_a_defined, not_a_function,
+    not_a_label, not_a_scope, not_greater, nud, number, octal_a, open, outer,
+    parameter, parameter_a_get_b, parameter_arguments_a, parameter_set_a,
+    params, paren, passfail, plusplus, postscript, predef, properties,
+    properties_report, property, prototype, push, quote, r, radix, raw,
+    read_only, reason, regexp, relation, replace, report, reserved, reserved_a,
+    rhino, right, scanned_a_b, scope, search, second, shift, slash_equal, slice,
+    sloppy, sort, split, statement, statement_block, stop, stopping,
+    strange_loop, strict, string, stupid, sub, subscript, substr, supplant,
+    sync_a, t, tag_a_in_b, test, third, thru, toString, todo, todo_comment,
+    token, tokens, too_long, too_many, trailing_decimal_a, tree, unclosed,
+    unclosed_comment, unclosed_regexp, unescaped_a, unexpected_a,
+    unexpected_char_a, unexpected_comment, unexpected_else, unexpected_label_a,
+    unexpected_property_a, unexpected_space_a_b, unexpected_typeof_a,
+    uninitialized_a, unnecessary_initialize, unnecessary_use, unparam,
+    unreachable_a_b, unsafe, unused_a, url, use_array, use_braces, use_object,
+    use_or, use_param, use_spaces, used, used_before_a, var, var_a_not,
+    var_loop, vars, varstatement, warn, warning, was, weird_assignment,
     weird_condition, weird_new, weird_program, weird_relation, weird_ternary,
-    white, 'white-space', width, windows, 'word-spacing', 'word-wrap', wrap,
-    wrap_immediate, wrap_regexp, write_is_wrong, writeable, 'z-index'
+    white, windows, wrap, wrap_immediate, wrap_regexp, write_is_wrong,
+    writeable
 */
 
 // The global directive is used to declare global variables that can
@@ -324,7 +278,7 @@ var JSLINT = (function () {
 
 // Make an object from an array of keys and a common value.
 
-        var i, length = array.length, object = {};
+        var i, length = array.length, object = Object.create(null);
         for (i = 0; i < length; i += 1) {
             object[array[i]] = value;
         }
@@ -332,36 +286,30 @@ var JSLINT = (function () {
     }
 
 
-    var adsafe_id,      // The widget's ADsafe id.
-        adsafe_may,     // The widget may load approved scripts.
-        adsafe_top,     // At the top of the widget script.
-        adsafe_went,    // ADSAFE.go has been called.
-        allowed_option = {
-            anon      : true,
+    var allowed_option = {
+            ass       : true,
             bitwise   : true,
             browser   : true,
-            'continue': true,
-            css       : true,
+            closure   : true,
+            continue  : true,
+            couch     : true,
             debug     : true,
             devel     : true,
             eqeq      : true,
             es5       : true,
             evil      : true,
             forin     : true,
-            fragment  : true,
             indent    :   10,
             maxerr    : 1000,
             maxlen    :  256,
             newcap    : true,
             node      : true,
             nomen     : true,
-            on        : true,
             passfail  : true,
             plusplus  : true,
             properties: true,
             regexp    : true,
             rhino     : true,
-            undef     : true,
             unparam   : true,
             sloppy    : true,
             stupid    : true,
@@ -372,7 +320,6 @@ var JSLINT = (function () {
             windows   : true
         },
         anonname,       // The guessed name for anonymous functions.
-        approved,       // ADsafe approved urls.
 
 // These are operators that should not be used with the ! operator.
 
@@ -391,14 +338,8 @@ var JSLINT = (function () {
             '/'  : true,
             '%'  : true
         },
-
-// These are property names that should not be permitted in the safe subset.
-
-        banned = array_to_object([
-            'arguments', 'callee', 'caller', 'constructor', 'eval', 'prototype',
-            'stack', 'unwatch', 'valueOf', 'watch'
-        ], true),
         begin,          // The root token
+        block_var,     // vars defined in the current block
 
 // browser contains a set of global names that are commonly provided by a
 // web browser environment.
@@ -414,51 +355,20 @@ var JSLINT = (function () {
 
         bundle = {
             a_label: "'{a}' is a statement label.",
-            a_not_allowed: "'{a}' is not allowed.",
-            a_not_defined: "'{a}' is not defined.",
             a_scope: "'{a}' used out of scope.",
-            adsafe_a: "ADsafe violation: '{a}'.",
-            adsafe_autocomplete: "ADsafe autocomplete violation.",
-            adsafe_bad_id: "ADSAFE violation: bad id.",
-            adsafe_div: "ADsafe violation: Wrap the widget in a div.",
-            adsafe_fragment: "ADSAFE: Use the fragment option.",
-            adsafe_go: "ADsafe violation: Misformed ADSAFE.go.",
-            adsafe_html: "Currently, ADsafe does not operate on whole HTML " +
-                "documents. It operates on <div> fragments and .js files.",
-            adsafe_id: "ADsafe violation: id does not match.",
-            adsafe_id_go: "ADsafe violation: Missing ADSAFE.id or ADSAFE.go.",
-            adsafe_lib: "ADsafe lib violation.",
-            adsafe_lib_second: "ADsafe: The second argument to lib must be a function.",
-            adsafe_missing_id: "ADSAFE violation: missing ID_.",
-            adsafe_name_a: "ADsafe name violation: '{a}'.",
-            adsafe_placement: "ADsafe script placement violation.",
-            adsafe_prefix_a: "ADsafe violation: An id must have a '{a}' prefix",
-            adsafe_script: "ADsafe script violation.",
-            adsafe_source: "ADsafe unapproved script source.",
-            adsafe_subscript_a: "ADsafe subscript '{a}'.",
-            adsafe_tag: "ADsafe violation: Disallowed tag '{a}'.",
             already_defined: "'{a}' is already defined.",
             and: "The '&&' subexpression should be wrapped in parens.",
-            assign_exception: "Do not assign to the exception parameter.",
+            assignment_expression: "Unexpected assignment expression.",
             assignment_function_expression: "Expected an assignment or " +
                 "function call and instead saw an expression.",
-            attribute_case_a: "Attribute '{a}' not all lower case.",
             avoid_a: "Avoid '{a}'.",
             bad_assignment: "Bad assignment.",
-            bad_color_a: "Bad hex color '{a}'.",
             bad_constructor: "Bad constructor.",
-            bad_entity: "Bad entity.",
-            bad_html: "Bad HTML string",
-            bad_id_a: "Bad id: '{a}'.",
             bad_in_a: "Bad for in variable '{a}'.",
             bad_invocation: "Bad invocation.",
-            bad_name_a: "Bad name: '{a}'.",
             bad_new: "Do not use 'new' for side effects.",
             bad_number: "Bad number '{a}'.",
             bad_operand: "Bad operand.",
-            bad_style: "Bad style.",
-            bad_type: "Bad type.",
-            bad_url_a: "Bad url '{a}'.",
             bad_wrap: "Do not wrap function literals in parens unless they " +
                 "are to be immediately invoked.",
             combine_var: "Combine this with the previous 'var' statement.",
@@ -469,9 +379,7 @@ var JSLINT = (function () {
             constructor_name_a: "A constructor name '{a}' should start with " +
                 "an uppercase letter.",
             control_a: "Unexpected control character '{a}'.",
-            css: "A css file should begin with @charset 'UTF-8';",
             dangling_a: "Unexpected dangling '_' in '{a}'.",
-            dangerous_comment: "Dangerous comment.",
             deleted: "Only properties should be deleted.",
             duplicate_a: "Duplicate '{a}'.",
             empty_block: "Empty block.",
@@ -479,41 +387,20 @@ var JSLINT = (function () {
             empty_class: "Empty class.",
             es5: "This is an ES5 feature.",
             evil: "eval is evil.",
-            expected_a: "Expected '{a}'.",
             expected_a_b: "Expected '{a}' and instead saw '{b}'.",
             expected_a_b_from_c_d: "Expected '{a}' to match '{b}' from line " +
                 "{c} and instead saw '{d}'.",
-            expected_at_a: "Expected an at-rule, and instead saw @{a}.",
             expected_a_at_b_c: "Expected '{a}' at column {b}, not column {c}.",
-            expected_attribute_a: "Expected an attribute, and instead saw [{a}].",
-            expected_attribute_value_a: "Expected an attribute value and " +
-                "instead saw '{a}'.",
-            expected_class_a: "Expected a class, and instead saw .{a}.",
-            expected_fraction_a: "Expected a number between 0 and 1 and " +
-                "instead saw '{a}'",
             expected_id_a: "Expected an id, and instead saw #{a}.",
             expected_identifier_a: "Expected an identifier and instead saw '{a}'.",
             expected_identifier_a_reserved: "Expected an identifier and " +
                 "instead saw '{a}' (a reserved word).",
-            expected_linear_a: "Expected a linear unit and instead saw '{a}'.",
-            expected_lang_a: "Expected a lang code, and instead saw :{a}.",
-            expected_media_a: "Expected a CSS media type, and instead saw '{a}'.",
-            expected_name_a: "Expected a name and instead saw '{a}'.",
-            expected_nonstandard_style_attribute: "Expected a non-standard " +
-                "style attribute and instead saw '{a}'.",
             expected_number_a: "Expected a number and instead saw '{a}'.",
             expected_operator_a: "Expected an operator and instead saw '{a}'.",
-            expected_percent_a: "Expected a percentage and instead saw '{a}'",
             expected_positive_a: "Expected a positive number and instead saw '{a}'",
-            expected_pseudo_a: "Expected a pseudo, and instead saw :{a}.",
-            expected_selector_a: "Expected a CSS selector, and instead saw {a}.",
             expected_small_a: "Expected a small positive integer and instead saw '{a}'",
             expected_space_a_b: "Expected exactly one space between '{a}' and '{b}'.",
             expected_string_a: "Expected a string and instead saw '{a}'.",
-            expected_style_attribute: "Excepted a style attribute, and instead saw '{a}'.",
-            expected_style_pattern: "Expected a style pattern, and instead saw '{a}'.",
-            expected_tagname_a: "Expected a tagName, and instead saw {a}.",
-            expected_type_a: "Expected a type, and instead saw {a}.",
             for_if: "The body of a for in should be wrapped in an if " +
                 "statement to filter unwanted properties from the prototype.",
             function_block: "Function statements should not be placed in blocks." +
@@ -521,11 +408,9 @@ var JSLINT = (function () {
                 "the outer function.",
             function_eval: "The Function constructor is eval.",
             function_loop: "Don't make functions within a loop.",
-            function_statement: "Function statements are not invocable." +
+            function_statement: "Function statements are not invocable. " +
                 "Wrap the whole function invocation in parens.",
             function_strict: "Use the function form of 'use strict'.",
-            html_confusion_a: "HTML confusion in regular expression '<{a}'.",
-            html_handlers: "Avoid HTML event handlers.",
             identifier_function: "Expected an identifier in an assignment " +
                 "and instead saw a function invocation.",
             implied_evil: "Implied eval is evil. Pass a function instead of a string.",
@@ -533,14 +418,11 @@ var JSLINT = (function () {
                 "hasOwnProperty method instead.",
             insecure_a: "Insecure '{a}'.",
             isNaN: "Use the isNaN function to compare with NaN.",
-            lang: "lang is deprecated.",
             leading_decimal_a: "A leading decimal point can be confused with a dot: '.{a}'.",
             missing_a: "Missing '{a}'.",
             missing_a_after_b: "Missing '{a}' after '{b}'.",
-            missing_option: "Missing option value.",
             missing_property: "Missing property name.",
             missing_space_a_b: "Missing space between '{a}' and '{b}'.",
-            missing_url: "Missing url.",
             missing_use_strict: "Missing 'use strict' statement.",
             move_invocation: "Move the invocation into the parens that " +
                 "contain the function.",
@@ -560,7 +442,6 @@ var JSLINT = (function () {
             parameter_set_a: "Expected parameter (value) in set {a} function.",
             radix: "Missing radix parameter.",
             read_only: "Read only.",
-            redefinition_a: "Redefinition of '{a}'.",
             reserved_a: "Reserved name '{a}'.",
             scanned_a_b: "{a} ({b}% scanned).",
             slash_equal: "A regular expression literal can be confused with '/='.",
@@ -576,13 +457,12 @@ var JSLINT = (function () {
             too_many: "Too many errors.",
             trailing_decimal_a: "A trailing decimal point can be confused " +
                 "with a dot: '.{a}'.",
-            type: "type is unnecessary.",
             unclosed: "Unclosed string.",
             unclosed_comment: "Unclosed comment.",
             unclosed_regexp: "Unclosed regular expression.",
             unescaped_a: "Unescaped '{a}'.",
             unexpected_a: "Unexpected '{a}'.",
-            unexpected_char_a_b: "Unexpected character '{a}' in {b}.",
+            unexpected_char_a: "Unexpected character '{a}'.",
             unexpected_comment: "Unexpected comment.",
             unexpected_else: "Unexpected 'else' after 'return'.",
             unexpected_label_a: "Unexpected label '{a}'.",
@@ -590,98 +470,45 @@ var JSLINT = (function () {
             unexpected_space_a_b: "Unexpected space between '{a}' and '{b}'.",
             unexpected_typeof_a: "Unexpected 'typeof'. " +
                 "Use '===' to compare directly with {a}.",
+            uninitialized_a: "Uninitialized '{a}'.",
             unnecessary_initialize: "It is not necessary to initialize '{a}' " +
                 "to 'undefined'.",
             unnecessary_use: "Unnecessary 'use strict'.",
             unreachable_a_b: "Unreachable '{a}' after '{b}'.",
-            unrecognized_style_attribute_a: "Unrecognized style attribute '{a}'.",
-            unrecognized_tag_a: "Unrecognized tag '<{a}>'.",
             unsafe: "Unsafe character.",
+            unused_a: "Unused '{a}'.",
             url: "JavaScript URL.",
             use_array: "Use the array literal notation [].",
             use_braces: "Spaces are hard to count. Use {{a}}.",
-            use_charAt: "Use the charAt method.",
-            use_object: "Use the object literal notation {}.",
+            use_object: "Use the object literal notation {} or Object.create(null).",
             use_or: "Use the || operator.",
             use_param: "Use a named parameter.",
             use_spaces: "Use spaces, not tabs.",
             used_before_a: "'{a}' was used before it was defined.",
             var_a_not: "Variable {a} was not declared correctly.",
+            var_loop: "Don't declare variables in a loop.",
             weird_assignment: "Weird assignment.",
             weird_condition: "Weird condition.",
             weird_new: "Weird construction. Delete 'new'.",
             weird_program: "Weird program.",
             weird_relation: "Weird relation.",
             weird_ternary: "Weird ternary.",
-            wrap_immediate: "Wrap an immediate function invocation in parentheses " +
-                "to assist the reader in understanding that the expression " +
-                "is the result of a function, and not the function itself.",
+            wrap_immediate: "Wrap an immediate function invocation in " +
+                "parentheses to assist the reader in understanding that the " +
+                "expression is the result of a function, and not the " +
+                "function itself.",
             wrap_regexp: "Wrap the /regexp/ literal in parens to " +
                 "disambiguate the slash operator.",
             write_is_wrong: "document.write can be a form of eval."
         },
+        closure = array_to_object([
+            'goog'
+        ], false),
+        comments,
         comments_off,
-        css_attribute_data,
-        css_any,
-
-        css_colorData = array_to_object([
-            "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige",
-            "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown",
-            "burlywood", "cadetblue", "chartreuse", "chocolate", "coral",
-            "cornflowerblue", "cornsilk", "crimson", "cyan", "darkblue",
-            "darkcyan", "darkgoldenrod", "darkgray", "darkgreen", "darkkhaki",
-            "darkmagenta", "darkolivegreen", "darkorange", "darkorchid",
-            "darkred", "darksalmon", "darkseagreen", "darkslateblue",
-            "darkslategray", "darkturquoise", "darkviolet", "deeppink",
-            "deepskyblue", "dimgray", "dodgerblue", "firebrick", "floralwhite",
-            "forestgreen", "fuchsia", "gainsboro", "ghostwhite", "gold",
-            "goldenrod", "gray", "green", "greenyellow", "honeydew", "hotpink",
-            "indianred", "indigo", "ivory", "khaki", "lavender",
-            "lavenderblush", "lawngreen", "lemonchiffon", "lightblue",
-            "lightcoral", "lightcyan", "lightgoldenrodyellow", "lightgreen",
-            "lightpink", "lightsalmon", "lightseagreen", "lightskyblue",
-            "lightslategray", "lightsteelblue", "lightyellow", "lime",
-            "limegreen", "linen", "magenta", "maroon", "mediumaquamarine",
-            "mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen",
-            "mediumslateblue", "mediumspringgreen", "mediumturquoise",
-            "mediumvioletred", "midnightblue", "mintcream", "mistyrose",
-            "moccasin", "navajowhite", "navy", "oldlace", "olive", "olivedrab",
-            "orange", "orangered", "orchid", "palegoldenrod", "palegreen",
-            "paleturquoise", "palevioletred", "papayawhip", "peachpuff",
-            "peru", "pink", "plum", "powderblue", "purple", "red", "rosybrown",
-            "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen",
-            "seashell", "sienna", "silver", "skyblue", "slateblue", "slategray",
-            "snow", "springgreen", "steelblue", "tan", "teal", "thistle",
-            "tomato", "turquoise", "violet", "wheat", "white", "whitesmoke",
-            "yellow", "yellowgreen",
-
-            "activeborder", "activecaption", "appworkspace", "background",
-            "buttonface", "buttonhighlight", "buttonshadow", "buttontext",
-            "captiontext", "graytext", "highlight", "highlighttext",
-            "inactiveborder", "inactivecaption", "inactivecaptiontext",
-            "infobackground", "infotext", "menu", "menutext", "scrollbar",
-            "threeddarkshadow", "threedface", "threedhighlight",
-            "threedlightshadow", "threedshadow", "window", "windowframe",
-            "windowtext"
-        ], true),
-
-        css_border_style,
-        css_break,
-
-        css_lengthData = {
-            '%': true,
-            'cm': true,
-            'em': true,
-            'ex': true,
-            'in': true,
-            'mm': true,
-            'pc': true,
-            'pt': true,
-            'px': true
-        },
-
-        css_media,
-        css_overflow,
+        couch = array_to_object([
+            'emit'
+        ], false),
 
         descapes = {
             'b': '\b',
@@ -711,151 +538,22 @@ var JSLINT = (function () {
             '\\': '\\\\'
         },
 
-        funct,          // The current function, including the labels used in
-                        // the function, as well as (breakage),
-                        // (context), (loopage), (name), (params), (token),
-                        // (vars), (verb)
-
-        functionicity = [
-            'closure', 'exception', 'global', 'label', 'outer', 'undef',
-            'unused', 'var'
-        ],
+        funct,          // The current function
 
         functions,      // All of the functions
         global_funct,   // The global body
         global_scope,   // The global scope
-        html_tag = {
-            a:        {},
-            abbr:     {},
-            acronym:  {},
-            address:  {},
-            applet:   {},
-            area:     {empty: true, parent: ' map '},
-            article:  {},
-            aside:    {},
-            audio:    {},
-            b:        {},
-            base:     {empty: true, parent: ' head '},
-            bdo:      {},
-            big:      {},
-            blockquote: {},
-            body:     {parent: ' html noframes '},
-            br:       {empty: true},
-            button:   {},
-            canvas:   {parent: ' body p div th td '},
-            caption:  {parent: ' table '},
-            center:   {},
-            cite:     {},
-            code:     {},
-            col:      {empty: true, parent: ' table colgroup '},
-            colgroup: {parent: ' table '},
-            command:  {parent: ' menu '},
-            datalist: {},
-            dd:       {parent: ' dl '},
-            del:      {},
-            details:  {},
-            dialog:   {},
-            dfn:      {},
-            dir:      {},
-            div:      {},
-            dl:       {},
-            dt:       {parent: ' dl '},
-            em:       {},
-            embed:    {},
-            fieldset: {},
-            figcaption: {parent: ' figure '},
-            figure:   {},
-            font:     {},
-            footer:   {},
-            form:     {},
-            frame:    {empty: true, parent: ' frameset '},
-            frameset: {parent: ' html frameset '},
-            h1:       {},
-            h2:       {},
-            h3:       {},
-            h4:       {},
-            h5:       {},
-            h6:       {},
-            head:     {parent: ' html '},
-            header:   {},
-            hgroup:   {},
-            hr:       {empty: true},
-            'hta:application':
-                      {empty: true, parent: ' head '},
-            html:     {parent: '*'},
-            i:        {},
-            iframe:   {},
-            img:      {empty: true},
-            input:    {empty: true},
-            ins:      {},
-            kbd:      {},
-            keygen:   {},
-            label:    {},
-            legend:   {parent: ' details fieldset figure '},
-            li:       {parent: ' dir menu ol ul '},
-            link:     {empty: true, parent: ' head '},
-            map:      {},
-            mark:     {},
-            menu:     {},
-            meta:     {empty: true, parent: ' head noframes noscript '},
-            meter:    {},
-            nav:      {},
-            noframes: {parent: ' html body '},
-            noscript: {parent: ' body head noframes '},
-            object:   {},
-            ol:       {},
-            optgroup: {parent: ' select '},
-            option:   {parent: ' optgroup select '},
-            output:   {},
-            p:        {},
-            param:    {empty: true, parent: ' applet object '},
-            pre:      {},
-            progress: {},
-            q:        {},
-            rp:       {},
-            rt:       {},
-            ruby:     {},
-            samp:     {},
-            script:   {empty: true, parent: ' body div frame head iframe p pre span '},
-            section:  {},
-            select:   {},
-            small:    {},
-            span:     {},
-            source:   {},
-            strong:   {},
-            style:    {parent: ' head ', empty: true},
-            sub:      {},
-            summary:  {parent: ' details '},
-            sup:      {},
-            table:    {},
-            tbody:    {parent: ' table '},
-            td:       {parent: ' tr '},
-            textarea: {},
-            tfoot:    {parent: ' table '},
-            th:       {parent: ' tr '},
-            thead:    {parent: ' table '},
-            time:     {},
-            title:    {parent: ' head '},
-            tr:       {parent: ' table tbody thead tfoot '},
-            tt:       {},
-            u:        {},
-            ul:       {},
-            'var':    {},
-            video:    {}
-        },
-
-        ids,            // HTML ids
-        in_block,
+        in_block,       // Where function statements are not allowed
         indent,
-        itself,         // JSLint itself
+        itself,         // JSLINT itself
         json_mode,
         lex,            // the tokenizer
         lines,
         lookahead,
         node = array_to_object([
-            'Buffer', 'clearInterval', 'clearTimeout', 'console', 'exports',
+            'Buffer', 'clearImmediate', 'clearInterval', 'clearTimeout', 'console', 'exports',
             'global', 'module', 'process', 'querystring', 'require',
-            'setInterval', 'setTimeout', '__dirname', '__filename'
+            'setImmediate', 'setInterval', 'setTimeout', '__dirname', '__filename'
         ], false),
         node_js,
         numbery = array_to_object(['indexOf', 'lastIndexOf', 'search'], true),
@@ -865,6 +563,7 @@ var JSLINT = (function () {
         prereg,
         prev_token,
         property,
+        protosymbol,
         regexp_flag = array_to_object(['g', 'i', 'm'], true),
         return_this = function return_this() {
             return this;
@@ -877,8 +576,6 @@ var JSLINT = (function () {
 
         scope,      // An object containing an object for each variable in scope
         semicolon_coda = array_to_object([';', '"', '\'', ')'], true),
-        src,
-        stack,
 
 // standard contains the global names that are provided by the
 // ECMAScript standard.
@@ -892,10 +589,9 @@ var JSLINT = (function () {
         ], false),
 
         strict_mode,
-        syntax = {},
-        tab,
+        syntax = Object.create(null),
         token,
-        urls,
+        tokens,
         var_mode,
         warnings,
 
@@ -904,31 +600,12 @@ var JSLINT = (function () {
             'VBArray', 'WScript', 'WSH'
         ], false),
 
-//  xmode is used to adapt to the exceptions in html parsing.
-//  It can have these states:
-//      ''      .js script file
-//      'html'
-//      'outer'
-//      'script'
-//      'style'
-//      'scriptstring'
-//      'styleproperty'
-
-        xmode,
-        xquote,
-
 // Regular expressions. Some of these are stupidly long.
 
-// unsafe comment or string
-        ax = /@cc|<\/?|script|\]\s*\]|<\s*!|&lt/i,
 // carriage return, carriage return linefeed, or linefeed
         crlfx = /\r\n?|\n/,
 // unsafe characters that are silently deleted by one or more browsers
         cx = /[\u0000-\u0008\u000a-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/,
-// query characters for ids
-        dx = /[\[\]\/\\"'*<>.&:(){}+=#]/,
-// html token
-        hx = /^\s*(['"=>\/&#]|<(?:\/|\!(?:--)?)?|[a-zA-Z][a-zA-Z0-9_\-:]*|[0-9]+|--)/,
 // identifier
         ix = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/,
 // javascript url
@@ -937,87 +614,13 @@ var JSLINT = (function () {
         lx = /\*\/|\/\*/,
 // characters in strings that need escapement
         nx = /[\u0000-\u001f'\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
-// outer html token
-        ox = /[>&]|<[\/!]?|--/,
-// attributes characters
-        qx = /[^a-zA-Z0-9+\-_\/. ]/,
-// style
-        ssx = /^\s*([@#!"'};:\-%.=,+\[\]()*_]|[a-zA-Z][a-zA-Z0-9._\-]*|\/\*?|\d+(?:\.\d+)?|<\/)/,
-        sx = /^\s*([{}:#%.=,>+\[\]@()"';]|[*$\^~]=|[a-zA-Z_][a-zA-Z0-9_\-]*|[0-9]+|<\/|\/\*)/,
-
 // sync
         syx = /Sync$/,
 // comment todo
         tox = /^\W*to\s*do(?:\W|$)/i,
 // token
-        tx = /^\s*([(){}\[\]\?.,:;'"~#@`]|={1,3}|\/(\*(jslint|properties|property|members?|globals?)?|=|\/)?|\*[\/=]?|\+(?:=|\++)?|-(?:=|-+)?|[\^%]=?|&[&=]?|\|[|=]?|>{1,3}=?|<(?:[\/=!]|\!(\[|--)?|<=?)?|\!(\!|==?)?|[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+(?:[xX][0-9a-fA-F]+|\.[0-9]*)?(?:[eE][+\-]?[0-9]+)?)/,
-// url badness
-        ux = /&|\+|\u00AD|\.\.|\/\*|%[^;]|base64|url|expression|data|mailto|script/i,
-
-        rx = {
-            outer: hx,
-            html: hx,
-            style: sx,
-            styleproperty: ssx
-        };
-
-
-    function F() {}     // Used by Object.create
-
-// Provide critical ES5 functions to ES3.
-
-    if (typeof Array.prototype.filter !== 'function') {
-        Array.prototype.filter = function (f) {
-            var i, length = this.length, result = [], value;
-            for (i = 0; i < length; i += 1) {
-                try {
-                    value = this[i];
-                    if (f(value)) {
-                        result.push(value);
-                    }
-                } catch (ignore) {
-                }
-            }
-            return result;
-        };
-    }
-
-    if (typeof Array.prototype.forEach !== 'function') {
-        Array.prototype.forEach = function (f) {
-            var i, length = this.length;
-            for (i = 0; i < length; i += 1) {
-                try {
-                    f(this[i]);
-                } catch (ignore) {
-                }
-            }
-        };
-    }
-
-    if (typeof Array.isArray !== 'function') {
-        Array.isArray = function (o) {
-            return Object.prototype.toString.apply(o) === '[object Array]';
-        };
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(Object, 'create')) {
-        Object.create = function (o) {
-            F.prototype = o;
-            return new F();
-        };
-    }
+        tx = /^\s*([(){}\[\]\?.,:;'"~#@`]|={1,3}|\/(\*(jslint|properties|property|members?|globals?)?|=|\/)?|\*[\/=]?|\+(?:=|\++)?|-(?:=|-+)?|[\^%]=?|&[&=]?|\|[|=]?|>{1,3}=?|<(?:[\/=!]|\!(\[|--)?|<=?)?|\!(\!|==?)?|[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+(?:[xX][0-9a-fA-F]+|\.[0-9]*)?(?:[eE][+\-]?[0-9]+)?)/;
 
-    if (typeof Object.keys !== 'function') {
-        Object.keys = function (o) {
-            var array = [], key;
-            for (key in o) {
-                if (Object.prototype.hasOwnProperty.call(o, key)) {
-                    array.push(key);
-                }
-            }
-            return array;
-        };
-    }
 
     if (typeof String.prototype.entityify !== 'function') {
         String.prototype.entityify = function () {
@@ -1069,28 +672,33 @@ var JSLINT = (function () {
 
 
     function assume() {
-        if (!option.safe) {
-            if (option.rhino) {
-                add_to_predefined(rhino);
-                option.rhino = false;
-            }
-            if (option.devel) {
-                add_to_predefined(devel);
-                option.devel = false;
-            }
-            if (option.browser) {
-                add_to_predefined(browser);
-                option.browser = false;
-            }
-            if (option.windows) {
-                add_to_predefined(windows);
-                option.windows = false;
-            }
-            if (option.node) {
-                add_to_predefined(node);
-                option.node = false;
-                node_js = true;
-            }
+        if (option.browser) {
+            add_to_predefined(browser);
+            option.browser = false;
+        }
+        if (option.closure) {
+            add_to_predefined(closure);
+        }
+        if (option.couch) {
+            add_to_predefined(couch);
+            option.couch = false;
+        }
+        if (option.devel) {
+            add_to_predefined(devel);
+            option.devel = false;
+        }
+        if (option.node) {
+            add_to_predefined(node);
+            option.node = false;
+            node_js = true;
+        }
+        if (option.rhino) {
+            add_to_predefined(rhino);
+            option.rhino = false;
+        }
+        if (option.windows) {
+            add_to_predefined(windows);
+            option.windows = false;
         }
     }
 
@@ -1101,7 +709,7 @@ var JSLINT = (function () {
         if (!tok) {
             tok = next_token;
         }
-        return tok.number || tok.string;
+        return tok.id === '(number)' ? tok.number : tok.string;
     }
 
     function quit(message, line, character) {
@@ -1116,26 +724,20 @@ var JSLINT = (function () {
         };
     }
 
-    function warn(message, offender, a, b, c, d) {
-        var character, line, warning;
-        offender = offender || next_token;  // ~~
-        line = offender.line || 0;
-        character = offender.from || 0;
-        warning = {
+    function warn(message, line, character, a, b, c, d) {
+        var warning = {         // ~~
             id: '(error)',
             raw: bundle[message] || message,
             evidence: lines[line - 1] || '',
             line: line,
             character: character,
-            a: a || (offender.id === '(number)'
-                ? String(offender.number)
-                : offender.string),
+            a: a || artifact(this),
             b: b,
             c: c,
             d: d
         };
         warning.reason = warning.raw.supplant(warning);
-        JSLINT.errors.push(warning);
+        itself.errors.push(warning);
         if (option.passfail) {
             quit(bundle.stopping, line, character);
         }
@@ -1146,41 +748,17 @@ var JSLINT = (function () {
         return warning;
     }
 
-    function warn_at(message, line, character, a, b, c, d) {
-        return warn(message, {
-            line: line,
-            from: character
-        }, a, b, c, d);
-    }
-
-    function stop(message, offender, a, b, c, d) {
-        var warning = warn(message, offender, a, b, c, d);
+    function stop(message, line, character, a, b, c, d) {
+        var warning = warn(message, line, character, a, b, c, d);
         quit(bundle.stopping, warning.line, warning.character);
     }
 
-    function stop_at(message, line, character, a, b, c, d) {
-        return stop(message, {
-            line: line,
-            from: character
-        }, a, b, c, d);
-    }
-
     function expected_at(at) {
         if (!option.white && next_token.from !== at) {
-            warn('expected_a_at_b_c', next_token, '', at,
-                next_token.from);
-        }
-    }
-
-    function aint(it, name, expected) {
-        if (it[name] !== expected) {
-            warn('expected_a_b', it, expected, it[name]);
-            return true;
+            next_token.warn('expected_a_at_b_c', '', at, next_token.from);
         }
-        return false;
     }
 
-
 // lexical analysis and token construction
 
     lex = (function lex() {
@@ -1190,26 +768,26 @@ var JSLINT = (function () {
 
         function next_line() {
             var at;
-            if (line >= lines.length) {
-                return false;
-            }
             character = 1;
             source_row = lines[line];
             line += 1;
+            if (source_row === undefined) {
+                return false;
+            }
             at = source_row.search(/\t/);
             if (at >= 0) {
                 if (option.white) {
                     source_row = source_row.replace(/\t/g, ' ');
                 } else {
-                    warn_at('use_spaces', line, at + 1);
+                    warn('use_spaces', line, at + 1);
                 }
             }
             at = source_row.search(cx);
             if (at >= 0) {
-                warn_at('unsafe', line, at);
+                warn('unsafe', line, at);
             }
             if (option.maxlen && option.maxlen < source_row.length) {
-                warn_at('too_long', line, source_row.length);
+                warn('too_long', line, source_row.length);
             }
             return true;
         }
@@ -1218,9 +796,9 @@ var JSLINT = (function () {
 
         function it(type, value) {
             var id, the_token;
-            if (type === '(string)' || type === '(range)') {
+            if (type === '(string)') {
                 if (jx.test(value)) {
-                    warn_at('url', line, from);
+                    warn('url', line, from);
                 }
             }
             the_token = Object.create(syntax[(
@@ -1232,11 +810,11 @@ var JSLINT = (function () {
             if (type === '(identifier)') {
                 the_token.identifier = true;
                 if (value === '__iterator__' || value === '__proto__') {
-                    stop_at('reserved_a', line, from, value);
+                    stop('reserved_a', line, from, value);
                 } else if (!option.nomen &&
                         (value.charAt(0) === '_' ||
                         value.charAt(value.length - 1) === '_')) {
-                    warn_at('dangling_a', line, from, value);
+                    warn('dangling_a', line, from, value);
                 }
             }
             if (type === '(number)') {
@@ -1247,6 +825,10 @@ var JSLINT = (function () {
             the_token.line = line;
             the_token.from = from;
             the_token.thru = character;
+            if (comments.length) {
+                the_token.comments = comments;
+                comments = [];
+            }
             id = the_token.id;
             prereg = id && (
                 ('(,=:[!&|?{};~+-*%^<>'.indexOf(id.charAt(id.length - 1)) >= 0) ||
@@ -1266,6 +848,22 @@ var JSLINT = (function () {
                 character += length;
                 return first;
             }
+            for (;;) {
+                if (!source_row) {
+                    if (!option.white) {
+                        warn('unexpected_char_a', line, character - 1, '(space)');
+                    }
+                    return;
+                }
+                c = source_row.charAt(0);
+                if (c !== ' ') {
+                    break;
+                }
+                source_row = source_row.slice(1);
+                character += 1;
+            }
+            stop('unexpected_char_a', line, character, c);
+
         }
 
         function string(x) {
@@ -1276,25 +874,21 @@ var JSLINT = (function () {
                 pos += n;
                 if (i >= 32 && i <= 126 &&
                         i !== 34 && i !== 92 && i !== 39) {
-                    warn_at('unexpected_a', line, character, '\\');
+                    warn('unexpected_a', line, character, '\\');
                 }
                 character += n;
                 c = String.fromCharCode(i);
             }
 
             if (json_mode && x !== '"') {
-                warn_at('expected_a', line, character, '"');
-            }
-
-            if (xquote === x || (xmode === 'scriptstring' && !xquote)) {
-                return it('(punctuator)', x);
+                warn('expected_a_b', line, character, '"', x);
             }
 
             for (;;) {
                 while (pos >= source_row.length) {
                     pos = 0;
-                    if (xmode !== 'html' || !next_line()) {
-                        stop_at('unclosed', line, from);
+                    if (!next_line()) {
+                        stop('unclosed', line - 1, from);
                     }
                 }
                 c = source_row.charAt(pos);
@@ -1309,73 +903,46 @@ var JSLINT = (function () {
                     if (c === '\n' || c === '\r') {
                         break;
                     }
-                    warn_at('control_a', line, character + pos,
+                    warn('control_a', line, character + pos,
                         source_row.slice(0, pos));
-                } else if (c === xquote) {
-                    warn_at('bad_html', line, character + pos);
-                } else if (c === '<') {
-                    if (option.safe && xmode === 'html') {
-                        warn_at('adsafe_a', line, character + pos, c);
-                    } else if (source_row.charAt(pos + 1) === '/' && (xmode || option.safe)) {
-                        warn_at('expected_a_b', line, character,
-                            '<\\/', '</');
-                    } else if (source_row.charAt(pos + 1) === '!' && (xmode || option.safe)) {
-                        warn_at('unexpected_a', line, character, '<!');
-                    }
                 } else if (c === '\\') {
-                    if (xmode === 'html') {
-                        if (option.safe) {
-                            warn_at('adsafe_a', line, character + pos, c);
+                    pos += 1;
+                    character += 1;
+                    c = source_row.charAt(pos);
+                    switch (c) {
+                    case '':
+                        if (!option.es5) {
+                            warn('es5', line, character);
                         }
-                    } else if (xmode === 'styleproperty') {
-                        pos += 1;
-                        character += 1;
-                        c = source_row.charAt(pos);
-                        if (c !== x) {
-                            warn_at('unexpected_a', line, character, '\\');
+                        next_line();
+                        pos = -1;
+                        break;
+                    case '\'':
+                        if (json_mode) {
+                            warn('unexpected_a', line, character, '\\\'');
                         }
-                    } else {
-                        pos += 1;
-                        character += 1;
-                        c = source_row.charAt(pos);
-                        switch (c) {
-                        case '':
-                            if (!option.es5) {
-                                warn_at('es5', line, character);
-                            }
-                            next_line();
-                            pos = -1;
-                            break;
-                        case xquote:
-                            warn_at('bad_html', line, character + pos);
-                            break;
-                        case '\'':
-                            if (json_mode) {
-                                warn_at('unexpected_a', line, character, '\\\'');
-                            }
-                            break;
-                        case 'u':
-                            hex(4);
-                            break;
-                        case 'v':
-                            if (json_mode) {
-                                warn_at('unexpected_a', line, character, '\\v');
-                            }
-                            c = '\v';
-                            break;
-                        case 'x':
-                            if (json_mode) {
-                                warn_at('unexpected_a', line, character, '\\x');
-                            }
-                            hex(2);
-                            break;
-                        default:
-                            if (typeof descapes[c] !== 'string') {
-                                warn_at(c >= '0' && c <= '7' ? 'octal_a' : 'unexpected_a',
-                                    line, character, '\\' + c);
-                            } else {
-                                c = descapes[c];
-                            }
+                        break;
+                    case 'u':
+                        hex(4);
+                        break;
+                    case 'v':
+                        if (json_mode) {
+                            warn('unexpected_a', line, character, '\\v');
+                        }
+                        c = '\v';
+                        break;
+                    case 'x':
+                        if (json_mode) {
+                            warn('unexpected_a', line, character, '\\x');
+                        }
+                        hex(2);
+                        break;
+                    default:
+                        if (typeof descapes[c] !== 'string') {
+                            warn(c >= '0' && c <= '7' ? 'octal_a' : 'unexpected_a',
+                                line, character, '\\' + c);
+                        } else {
+                            c = descapes[c];
                         }
                     }
                 }
@@ -1387,51 +954,49 @@ var JSLINT = (function () {
 
         function number(snippet) {
             var digit;
-            if (xmode !== 'style' && xmode !== 'styleproperty' &&
-                    source_row.charAt(0).isAlpha()) {
-                warn_at('expected_space_a_b',
+            if (source_row.charAt(0).isAlpha()) {
+                warn('expected_space_a_b',
                     line, character, c, source_row.charAt(0));
             }
             if (c === '0') {
                 digit = snippet.charAt(1);
                 if (digit.isDigit()) {
-                    if (token.id !== '.' && xmode !== 'styleproperty') {
-                        warn_at('unexpected_a', line, character, snippet);
+                    if (token.id !== '.') {
+                        warn('unexpected_a', line, character, snippet);
                     }
                 } else if (json_mode && (digit === 'x' || digit === 'X')) {
-                    warn_at('unexpected_a', line, character, '0x');
+                    warn('unexpected_a', line, character, '0x');
                 }
             }
             if (snippet.slice(snippet.length - 1) === '.') {
-                warn_at('trailing_decimal_a', line, character, snippet);
+                warn('trailing_decimal_a', line, character, snippet);
             }
-            if (xmode !== 'style') {
-                digit = +snippet;
-                if (!isFinite(digit)) {
-                    warn_at('bad_number', line, character, snippet);
-                }
-                snippet = digit;
+            digit = +snippet;
+            if (!isFinite(digit)) {
+                warn('bad_number', line, character, snippet);
             }
+            snippet = digit;
             return it('(number)', snippet);
         }
 
-        function comment(snippet) {
-            if (comments_off || src || (xmode && xmode !== 'script' &&
-                    xmode !== 'style' && xmode !== 'styleproperty')) {
-                warn_at('unexpected_comment', line, character);
-            } else if (xmode === 'script' && /<\//i.test(source_row)) {
-                warn_at('unexpected_a', line, character, '<\/');
-            } else if (option.safe && ax.test(snippet)) {
-                warn_at('dangerous_comment', line, character);
+        function comment(snippet, type) {
+            if (comments_off) {
+                warn('unexpected_comment', line, character);
             } else if (!option.todo && tox.test(snippet)) {
-                warn_at('todo_comment', line, character);
-            }
+                warn('todo_comment', line, character);
+            }
+            comments.push({
+                id: type,
+                from: from,
+                thru: character,
+                line: line,
+                string: snippet
+            });
         }
 
         function regexp() {
             var b,
                 bit,
-                captures = 0,
                 depth = 0,
                 flag = '',
                 high,
@@ -1447,11 +1012,11 @@ var JSLINT = (function () {
                 length += 1;
                 switch (c) {
                 case '':
-                    stop_at('unclosed_regexp', line, from);
+                    stop('unclosed_regexp', line, from);
                     return;
                 case '/':
                     if (depth > 0) {
-                        warn_at('unescaped_a', line, from + length, '/');
+                        warn('unescaped_a', line, from + length, '/');
                     }
                     c = source_row.slice(0, length - 1);
                     potential = Object.create(regexp_flag);
@@ -1465,13 +1030,13 @@ var JSLINT = (function () {
                         flag += letter;
                     }
                     if (source_row.charAt(length).isAlpha()) {
-                        stop_at('unexpected_a', line, from, source_row.charAt(length));
+                        stop('unexpected_a', line, from, source_row.charAt(length));
                     }
                     character += length;
                     source_row = source_row.slice(length);
                     quote = source_row.charAt(0);
                     if (quote === '/' || quote === '*') {
-                        stop_at('confusing_regexp', line, from);
+                        stop('confusing_regexp', line, from);
                     }
                     result = it('(regexp)', c);
                     result.flag = flag;
@@ -1479,9 +1044,9 @@ var JSLINT = (function () {
                 case '\\':
                     c = source_row.charAt(length);
                     if (c < ' ') {
-                        warn_at('control_a', line, from + length, String(c));
+                        warn('control_a', line, from + length, String(c));
                     } else if (c === '<') {
-                        warn_at(bundle.unexpected_a, line, from + length, '\\');
+                        warn(bundle.unexpected_a, line, from + length, '\\');
                     }
                     length += 1;
                     break;
@@ -1497,11 +1062,9 @@ var JSLINT = (function () {
                             length += 1;
                             break;
                         default:
-                            warn_at(bundle.expected_a_b, line, from + length,
+                            warn(bundle.expected_a_b, line, from + length,
                                 ':', source_row.charAt(length));
                         }
-                    } else {
-                        captures += 1;
                     }
                     break;
                 case '|':
@@ -1509,7 +1072,7 @@ var JSLINT = (function () {
                     break;
                 case ')':
                     if (depth === 0) {
-                        warn_at('unescaped_a', line, from + length, ')');
+                        warn('unescaped_a', line, from + length, ')');
                     } else {
                         depth -= 1;
                     }
@@ -1521,7 +1084,7 @@ var JSLINT = (function () {
                         pos += 1;
                     }
                     if (pos > 1) {
-                        warn_at('use_braces', line, from + length, pos);
+                        warn('use_braces', line, from + length, pos);
                     }
                     break;
                 case '[':
@@ -1529,14 +1092,14 @@ var JSLINT = (function () {
                     if (c === '^') {
                         length += 1;
                         if (!option.regexp) {
-                            warn_at('insecure_a', line, from + length, c);
+                            warn('insecure_a', line, from + length, c);
                         } else if (source_row.charAt(length) === ']') {
-                            stop_at('unescaped_a', line, from + length, '^');
+                            stop('unescaped_a', line, from + length, '^');
                         }
                     }
                     bit = false;
                     if (c === ']') {
-                        warn_at('empty_class', line, from + length - 1);
+                        warn('empty_class', line, from + length - 1);
                         bit = true;
                     }
 klass:              do {
@@ -1545,44 +1108,34 @@ klass:              do {
                         switch (c) {
                         case '[':
                         case '^':
-                            warn_at('unescaped_a', line, from + length, c);
+                            warn('unescaped_a', line, from + length, c);
                             bit = true;
                             break;
                         case '-':
                             if (bit) {
                                 bit = false;
                             } else {
-                                warn_at('unescaped_a', line, from + length, '-');
+                                warn('unescaped_a', line, from + length, '-');
                                 bit = true;
                             }
                             break;
                         case ']':
                             if (!bit) {
-                                warn_at('unescaped_a', line, from + length - 1, '-');
+                                warn('unescaped_a', line, from + length - 1, '-');
                             }
                             break klass;
                         case '\\':
                             c = source_row.charAt(length);
                             if (c < ' ') {
-                                warn_at(bundle.control_a, line, from + length, String(c));
+                                warn(bundle.control_a, line, from + length, String(c));
                             } else if (c === '<') {
-                                warn_at(bundle.unexpected_a, line, from + length, '\\');
+                                warn(bundle.unexpected_a, line, from + length, '\\');
                             }
                             length += 1;
                             bit = true;
                             break;
                         case '/':
-                            warn_at('unescaped_a', line, from + length - 1, '/');
-                            bit = true;
-                            break;
-                        case '<':
-                            if (xmode === 'script') {
-                                c = source_row.charAt(length);
-                                if (c === '!' || c === '/') {
-                                    warn_at(bundle.html_confusion_a, line,
-                                        from + length, c);
-                                }
-                            }
+                            warn('unescaped_a', line, from + length - 1, '/');
                             bit = true;
                             break;
                         default:
@@ -1592,7 +1145,7 @@ klass:              do {
                     break;
                 case '.':
                     if (!option.regexp) {
-                        warn_at('insecure_a', line, from + length, c);
+                        warn('insecure_a', line, from + length, c);
                     }
                     break;
                 case ']':
@@ -1601,15 +1154,7 @@ klass:              do {
                 case '}':
                 case '+':
                 case '*':
-                    warn_at('unescaped_a', line, from + length, c);
-                    break;
-                case '<':
-                    if (xmode === 'script') {
-                        c = source_row.charAt(length);
-                        if (c === '!' || c === '/') {
-                            warn_at(bundle.html_confusion_a, line, from + length, c);
-                        }
-                    }
+                    warn('unescaped_a', line, from + length, c);
                     break;
                 }
                 if (b) {
@@ -1626,7 +1171,7 @@ klass:              do {
                         length += 1;
                         c = source_row.charAt(length);
                         if (c < '0' || c > '9') {
-                            warn_at(bundle.expected_number_a, line,
+                            warn(bundle.expected_number_a, line,
                                 from + length, c);
                         }
                         length += 1;
@@ -1658,7 +1203,7 @@ klass:              do {
                             }
                         }
                         if (source_row.charAt(length) !== '}') {
-                            warn_at(bundle.expected_a_b, line, from + length,
+                            warn(bundle.expected_a_b, line, from + length,
                                 '}', c);
                         } else {
                             length += 1;
@@ -1667,7 +1212,7 @@ klass:              do {
                             length += 1;
                         }
                         if (low > high) {
-                            warn_at(bundle.not_greater, line, from + length,
+                            warn(bundle.not_greater, line, from + length,
                                 low, high);
                         }
                         break;
@@ -1694,34 +1239,6 @@ klass:              do {
                 from = 1;
             },
 
-            range: function (begin, end) {
-                var c, value = '';
-                from = character;
-                if (source_row.charAt(0) !== begin) {
-                    stop_at('expected_a_b', line, character, begin,
-                        source_row.charAt(0));
-                }
-                for (;;) {
-                    source_row = source_row.slice(1);
-                    character += 1;
-                    c = source_row.charAt(0);
-                    switch (c) {
-                    case '':
-                        stop_at('missing_a', line, character, c);
-                        break;
-                    case end:
-                        source_row = source_row.slice(1);
-                        character += 1;
-                        return it('(range)', value);
-                    case xquote:
-                    case '\\':
-                        warn_at('unexpected_a', line, character, c);
-                        break;
-                    }
-                    value += c;
-                }
-            },
-
 // token -- this is called by advance to get the next token.
 
             token: function () {
@@ -1733,36 +1250,8 @@ klass:              do {
                             return it('(end)');
                         }
                     }
-                    while (xmode === 'outer') {
-                        i = source_row.search(ox);
-                        if (i === 0) {
-                            break;
-                        } else if (i > 0) {
-                            character += i;
-                            source_row = source_row.slice(i);
-                            break;
-                        } else {
-                            if (!next_line()) {
-                                return it('(end)', '');
-                            }
-                        }
-                    }
-                    snippet = match(rx[xmode] || tx);
-                    if (!snippet) {
-                        if (source_row) {
-                            if (source_row.charAt(0) === ' ') {
-                                if (!option.white) {
-                                    warn_at('unexpected_a', line, character,
-                                        '(space)');
-                                }
-                                character += 1;
-                                source_row = '';
-                            } else {
-                                stop_at('unexpected_a', line, character,
-                                    source_row.charAt(0));
-                            }
-                        }
-                    } else {
+                    snippet = match(tx);
+                    if (snippet) {
 
 //      identifier
 
@@ -1787,7 +1276,7 @@ klass:              do {
 //      // comment
 
                         case '//':
-                            comment(source_row);
+                            comment(source_row, '//');
                             source_row = '';
                             break;
 
@@ -1799,15 +1288,17 @@ klass:              do {
                                 if (i >= 0) {
                                     break;
                                 }
+                                character = source_row.length;
                                 comment(source_row);
+                                from = 0;
                                 if (!next_line()) {
-                                    stop_at('unclosed_comment', line, character);
+                                    stop('unclosed_comment', line, character);
                                 }
                             }
-                            comment(source_row.slice(0, i));
+                            comment(source_row.slice(0, i), '/*');
                             character += i + 2;
                             if (source_row.charAt(i) === '/') {
-                                stop_at('nested_comment', line, character);
+                                stop('nested_comment', line, character);
                             }
                             source_row = source_row.slice(i + 2);
                             break;
@@ -1817,88 +1308,14 @@ klass:              do {
 //      /
                         case '/':
                             if (token.id === '/=') {
-                                stop_at(
-                                    bundle.slash_equal,
-                                    line,
-                                    from
-                                );
+                                stop(bundle.slash_equal, line, from);
                             }
                             return prereg
                                 ? regexp()
                                 : it('(punctuator)', snippet);
 
 //      punctuator
-
-                        case '<!--':
-                            length = line;
-//                            c = character;
-                            for (;;) {
-                                i = source_row.indexOf('--');
-                                if (i >= 0) {
-                                    break;
-                                }
-                                i = source_row.indexOf('<!');
-                                if (i >= 0) {
-                                    stop_at('nested_comment',
-                                        line, character + i);
-                                }
-                                if (!next_line()) {
-                                    stop_at('unclosed_comment', length, c);
-                                }
-                            }
-                            length = source_row.indexOf('<!');
-                            if (length >= 0 && length < i) {
-                                stop_at('nested_comment',
-                                    line, character + length);
-                            }
-                            character += i;
-                            if (source_row.charAt(i + 2) !== '>') {
-                                stop_at('expected_a', line, character, '-->');
-                            }
-                            character += 3;
-                            source_row = source_row.slice(i + 3);
-                            break;
-                        case '#':
-                            if (xmode === 'html' || xmode === 'styleproperty') {
-                                for (;;) {
-                                    c = source_row.charAt(0);
-                                    if ((c < '0' || c > '9') &&
-                                            (c < 'a' || c > 'f') &&
-                                            (c < 'A' || c > 'F')) {
-                                        break;
-                                    }
-                                    character += 1;
-                                    source_row = source_row.slice(1);
-                                    snippet += c;
-                                }
-                                if (snippet.length !== 4 && snippet.length !== 7) {
-                                    warn_at('bad_color_a', line,
-                                        from + length, snippet);
-                                }
-                                return it('(color)', snippet);
-                            }
-                            return it('(punctuator)', snippet);
-
                         default:
-                            if (xmode === 'outer' && c === '&') {
-                                character += 1;
-                                source_row = source_row.slice(1);
-                                for (;;) {
-                                    c = source_row.charAt(0);
-                                    character += 1;
-                                    source_row = source_row.slice(1);
-                                    if (c === ';') {
-                                        break;
-                                    }
-                                    if (!((c >= '0' && c <= '9') ||
-                                            (c >= 'a' && c <= 'z') ||
-                                            c === '#')) {
-                                        stop_at('bad_entity', line, from + length,
-                                            character);
-                                    }
-                                }
-                                break;
-                            }
                             return it('(punctuator)', snippet);
                         }
                     }
@@ -1907,59 +1324,50 @@ klass:              do {
         };
     }());
 
+    function define(kind, token) {
 
-    function add_label(token, kind, name) {
+// Define a name.
 
-// Define the symbol in the current function in the current scope.
+        var name = token.string,
+            master = scope[name];       // The current definition of the name
 
-        name = name || token.string;
+// vars are created with a deadzone, so that the expression that initializes
+// the var cannot access the var. Functions are not writeable.
 
-// Global variables cannot be created in the safe subset. If a global variable
-// already exists, do nothing. If it is predefined, define it.
+        token.dead = false;
+        token.init = false;
+        token.kind = kind;
+        token.master = master;
+        token.used = 0;
+        token.writeable = false;
 
-        if (funct === global_funct) {
-            if (option.safe) {
-                warn('adsafe_a', token, name);
-            }
-            if (typeof global_funct[name] !== 'string') {
-                token.writeable = typeof predefined[name] === 'boolean'
-                    ? predefined[name]
-                    : true;
-                token.funct = funct;
+// Global variables are a little weird. They can be defined multiple times.
+// Some predefined global vars are (or should) not be writeable.
+
+        if (kind === 'var' && funct === global_funct) {
+            if (!master) {
+                if (predefined[name] === false) {
+                    token.writeable = false;
+                }
                 global_scope[name] = token;
             }
-            if (kind === 'becoming') {
-                kind = 'var';
-            }
-
-// Ordinary variables.
-
         } else {
 
-// Warn if the variable already exists.
+// It is an error if the name has already been defined in this scope, except
+// when reusing an exception variable name.
 
-            if (typeof funct[name] === 'string') {
-                if (funct[name] === 'undef') {
-                    if (!option.undef) {
-                        warn('used_before_a', token, name);
-                    }
-                    kind = 'var';
-                } else {
-                    warn('already_defined', token, name);
+            if (master && master.function === funct) {
+                if (master.kind !== 'exception' || kind !== 'exception' || !master.dead) {
+                    token.warn('already_defined', name);
                 }
-            } else {
-
-// Add the symbol to the current function.
-
-                token.funct = funct;
-                token.writeable = true;
-                scope[name] = token;
+            }
+            scope[name] = token;
+            if (kind === 'var') {
+                block_var.push(name);
             }
         }
-        funct[name] = kind;
     }
 
-
     function peek(distance) {
 
 // Peek ahead to a future token. The distance is how far ahead to look. The
@@ -2050,17 +1458,17 @@ klass:              do {
         switch (token.id) {
         case '(number)':
             if (next_token.id === '.') {
-                warn('trailing_decimal_a');
+                next_token.warn('trailing_decimal_a');
             }
             break;
         case '-':
             if (next_token.id === '-' || next_token.id === '--') {
-                warn('confusing_a');
+                next_token.warn('confusing_a');
             }
             break;
         case '+':
             if (next_token.id === '+' || next_token.id === '++') {
-                warn('confusing_a');
+                next_token.warn('confusing_a');
             }
             break;
         }
@@ -2070,60 +1478,17 @@ klass:              do {
 
         if (id && next_token.id !== id) {
             if (match) {
-                warn('expected_a_b_from_c_d', next_token, id,
+                next_token.warn('expected_a_b_from_c_d', id,
                     match.id, match.line, artifact());
             } else if (!next_token.identifier || next_token.string !== id) {
-                warn('expected_a_b', next_token, id, artifact());
+                next_token.warn('expected_a_b', id, artifact());
             }
         }
         prev_token = token;
         token = next_token;
         next_token = lookahead.shift() || lex.token();
-    }
-
-
-    function advance_identifier(string) {
-        if (next_token.identifier && next_token.string === string) {
-            advance();
-        } else {
-            warn('expected_a_b', next_token, string, artifact());
-        }
-    }
-
-
-    function do_safe() {
-        if (option.adsafe) {
-            option.safe = true;
-        }
-        if (option.safe) {
-            option.browser     =
-                option['continue'] =
-                option.css     =
-                option.debug   =
-                option.devel   =
-                option.evil    =
-                option.forin   =
-                option.newcap  =
-                option.nomen   =
-                option.on      =
-                option.rhino   =
-                option.sloppy  =
-                option.sub     =
-                option.undef   =
-                option.windows = false;
-
-
-            delete predefined.Array;
-            delete predefined.Date;
-            delete predefined.Function;
-            delete predefined.Object;
-            delete predefined['eval'];
-
-            add_to_predefined({
-                ADSAFE: false,
-                lib: false
-            });
-        }
+        next_token.function = funct;
+        tokens.push(next_token);
     }
 
 
@@ -2147,7 +1512,7 @@ klass:              do {
                     advance('false');
                     break;
                 default:
-                    stop('unexpected_a');
+                    next_token.stop('unexpected_a');
                 }
             }
             predefined[name] = writeable;
@@ -2164,18 +1529,18 @@ klass:              do {
         while (next_token.id === '(string)' || next_token.identifier) {
             name = next_token.string;
             if (!allowed_option[name]) {
-                stop('unexpected_a');
+                next_token.stop('unexpected_a');
             }
             advance();
             if (next_token.id !== ':') {
-                stop('expected_a_b', next_token, ':', artifact());
+                next_token.stop('expected_a_b', ':', artifact());
             }
             advance(':');
             if (typeof allowed_option[name] === 'number') {
                 value = next_token.number;
                 if (value > allowed_option[name] || value <= 0 ||
                         Math.floor(value) !== value) {
-                    stop('expected_small_a');
+                    next_token.stop('expected_small_a');
                 }
                 option[name] = value;
             } else {
@@ -2184,7 +1549,7 @@ klass:              do {
                 } else if (next_token.id === 'false') {
                     option[name] = false;
                 } else {
-                    stop('unexpected_a');
+                    next_token.stop('unexpected_a');
                 }
             }
             advance();
@@ -2229,10 +1594,10 @@ klass:              do {
         comments_off = true;
         indent = null;
         if (next_token.line === token.line && next_token.from === token.thru) {
-            warn('missing_space_a_b', next_token, artifact(token), artifact());
+            next_token.warn('missing_space_a_b', artifact(token), artifact());
         }
         if (lookahead.length > 0) {
-            warn('unexpected_a', this);
+            this.warn('unexpected_a');
         }
         switch (command) {
         case '/*properties':
@@ -2242,20 +1607,14 @@ klass:              do {
             do_properties();
             break;
         case '/*jslint':
-            if (option.safe) {
-                warn('adsafe_a', this);
-            }
             do_jslint();
             break;
         case '/*globals':
         case '/*global':
-            if (option.safe) {
-                warn('adsafe_a', this);
-            }
             do_globals();
             break;
         default:
-            stop('unexpected_a', this);
+            this.stop('unexpected_a');
         }
         comments_off = old_comments_off;
         advance('*/');
@@ -2327,7 +1686,7 @@ klass:              do {
         if (right.id !== '(end)' && !option.white &&
                 (token.line !== right.line ||
                 token.thru + 1 !== right.from)) {
-            warn('expected_space_a_b', right, artifact(token), artifact(right));
+            right.warn('expected_space_a_b', artifact(token), artifact(right));
         }
     }
 
@@ -2336,16 +1695,16 @@ klass:              do {
         right = right || next_token;
         if (right.id !== '(end)' && (left.line !== right.line ||
                 (!option.white && left.thru + 1 !== right.from))) {
-            warn('expected_space_a_b', right, artifact(left), artifact(right));
+            right.warn('expected_space_a_b', artifact(left), artifact(right));
         }
     }
 
     function no_space(left, right) {
         left = left || token;
         right = right || next_token;
-        if ((!option.white || xmode === 'styleproperty' || xmode === 'style') &&
+        if ((!option.white) &&
                 left.thru !== right.from && left.line === right.line) {
-            warn('unexpected_space_a_b', right, artifact(left), artifact(right));
+            right.warn('unexpected_space_a_b', artifact(left), artifact(right));
         }
     }
 
@@ -2354,7 +1713,7 @@ klass:              do {
         right = right || next_token;
         if (right.id !== '(end)' && (left.line !== right.line ||
                 (!option.white && left.thru !== right.from))) {
-            warn('unexpected_space_a_b', right, artifact(left), artifact(right));
+            right.warn('unexpected_space_a_b', artifact(left), artifact(right));
         }
     }
 
@@ -2363,14 +1722,14 @@ klass:              do {
             left = left || token;
             right = right || next_token;
             if (left.thru === right.from && left.line === right.line) {
-                warn('missing_space_a_b', right, artifact(left), artifact(right));
+                right.warn('missing_space_a_b', artifact(left), artifact(right));
             }
         }
     }
 
     function comma() {
         if (next_token.id !== ',') {
-            warn_at('expected_a_b', token.line, token.thru, ',', artifact());
+            warn('expected_a_b', token.line, token.thru, ',', artifact());
         } else {
             if (!option.white) {
                 no_space_only();
@@ -2383,7 +1742,7 @@ klass:              do {
 
     function semicolon() {
         if (next_token.id !== ';') {
-            warn_at('expected_a_b', token.line, token.thru, ';', artifact());
+            warn('expected_a_b', token.line, token.thru, ';', artifact());
         } else {
             if (!option.white) {
                 no_space_only();
@@ -2398,13 +1757,12 @@ klass:              do {
     function use_strict() {
         if (next_token.string === 'use strict') {
             if (strict_mode) {
-                warn('unnecessary_use');
+                next_token.warn('unnecessary_use');
             }
             edge();
             advance();
             semicolon();
             strict_mode = true;
-            option.undef = false;
             return true;
         }
         return false;
@@ -2486,17 +1844,11 @@ klass:              do {
 
         var left;
         if (next_token.id === '(end)') {
-            stop('unexpected_a', token, next_token.id);
+            token.stop('unexpected_a', next_token.id);
         }
         advance();
-        if (option.safe && scope[token.string] &&
-                scope[token.string] === global_scope[token.string] &&
-                (next_token.id !== '(' && next_token.id !== '.')) {
-            warn('adsafe_a', token);
-        }
         if (initial) {
             anonname = 'anonymous';
-            funct['(verb)'] = token.string;
         }
         if (initial === true && token.fud) {
             left = token.fud();
@@ -2505,36 +1857,58 @@ klass:              do {
                 left = token.nud();
             } else {
                 if (next_token.id === '(number)' && token.id === '.') {
-                    warn('leading_decimal_a', token, artifact());
+                    token.warn('leading_decimal_a', artifact());
                     advance();
                     return token;
                 }
-                stop('expected_identifier_a', token, token.id);
+                token.stop('expected_identifier_a', artifact(token));
             }
             while (rbp < next_token.lbp) {
                 advance();
-                if (token.led) {
-                    left = token.led(left);
-                } else {
-                    stop('expected_operator_a', token, token.id);
-                }
+                left = token.led(left);
+            }
+        }
+        if (left && left.assign && !initial) {
+            if (!option.ass) {
+                left.warn('assignment_expression');
+            }
+            if (left.id !== '=' && left.first.master) {
+                left.first.master.used = true;
             }
         }
         return left;
     }
 
+    protosymbol = {
+        nud: function () {
+            this.stop('unexpected_a');
+        },
+        led: function () {
+            this.stop('expected_operator_a');
+        },
+        warn: function (message, a, b, c, d) {
+            if (!this.warning) {
+                this.warning = warn(message, this.line || 0, this.from || 0,
+                    a || artifact(this), b, c, d);
+            }
+        },
+        stop: function (message, a, b, c, d) {
+            var warning = this.warn(message, a, b, c, d);
+            return quit(bundle.stopping, warning.line, warning.character);
+        },
+        lbp: 0
+    };
 
 // Functional constructors for making the symbols that will be inherited by
 // tokens.
 
-    function symbol(s, p) {
+    function symbol(s, bp) {
         var x = syntax[s];
-        if (!x || typeof x !== 'object') {
-            syntax[s] = x = {
-                id: s,
-                lbp: p || 0,
-                string: s
-            };
+        if (!x) {
+            x = Object.create(protosymbol);
+            x.id = x.string = s;
+            x.lbp = bp || 0;
+            syntax[s] = x;
         }
         return x;
     }
@@ -2605,16 +1979,16 @@ klass:              do {
             case '++':
             case '--':
                 if (!option.plusplus) {
-                    warn('unexpected_a', that);
+                    that.warn('unexpected_a');
                 } else if ((!that.first.identifier || that.first.reserved) &&
                         that.first.id !== '.' && that.first.id !== '[') {
-                    warn('bad_operand', that);
+                    that.warn('bad_operand');
                 }
                 break;
             default:
                 if (that.first.arity === 'prefix' ||
                         that.first.arity === 'function') {
-                    warn('unexpected_a', that);
+                    that.warn('unexpected_a');
                 }
             }
             return that;
@@ -2671,7 +2045,7 @@ klass:              do {
                 spaces();
             }
             if (!option.bitwise && this.bitwise) {
-                warn('unexpected_a', this);
+                this.warn('unexpected_a');
             }
             if (typeof f === 'function') {
                 return f(left, this);
@@ -2685,7 +2059,7 @@ klass:              do {
 
     function expected_relation(node, message) {
         if (node.assign) {
-            warn(message || bundle.conditional_assignment, node);
+            node.warn(message || bundle.conditional_assignment);
         }
         return node;
     }
@@ -2695,7 +2069,7 @@ klass:              do {
         case '[':
         case '-':
             if (node.arity !== 'infix') {
-                warn(message || bundle.weird_condition, node);
+                node.warn(message || bundle.weird_condition);
             }
             break;
         case 'false':
@@ -2710,14 +2084,16 @@ klass:              do {
         case '(regexp)':
         case '(string)':
         case '{':
-            warn(message || bundle.weird_condition, node);
+        case '?':
+        case '~':
+            node.warn(message || bundle.weird_condition);
             break;
         case '(':
             if (node.first.id === 'new' ||
                     (node.first.string === 'Boolean') ||
                     (node.first.id === '.' &&
                         numbery[node.first.second.string] === true)) {
-                warn(message || bundle.weird_condition, node);
+                node.warn(message || bundle.weird_condition);
             }
             break;
         }
@@ -2730,20 +2106,22 @@ klass:              do {
             switch (node.id) {
             case '{':
             case '[':
-                warn('unexpected_a', node);
+                node.warn('unexpected_a');
                 break;
             case '!':
-                warn('confusing_a', node);
+                node.warn('confusing_a');
                 break;
             }
             break;
         case 'function':
         case 'regexp':
-            warn('unexpected_a', node);
+            node.warn('unexpected_a');
             break;
         default:
             if (node.id  === 'NaN') {
-                warn('isNaN', node);
+                node.warn('isNaN');
+            } else if (node.relation) {
+                node.warn('weird_relation');
             }
         }
         return node;
@@ -2751,78 +2129,79 @@ klass:              do {
 
 
     function relation(s, eqeq) {
-        return infix(s, 100, function (left, that) {
+        var x = infix(s, 100, function (left, that) {
             check_relation(left);
             if (eqeq && !option.eqeq) {
-                warn('expected_a_b', that, eqeq, that.id);
+                that.warn('expected_a_b', eqeq, that.id);
             }
             var right = expression(100);
             if (are_similar(left, right) ||
                     ((left.id === '(string)' || left.id === '(number)') &&
                     (right.id === '(string)' || right.id === '(number)'))) {
-                warn('weird_relation', that);
+                that.warn('weird_relation');
             } else if (left.id === 'typeof') {
                 if (right.id !== '(string)') {
-                    warn("expected_string_a", right, right.id === '(number)'
-                        ? right.number
-                        : right.string);
+                    right.warn("expected_string_a", artifact(right));
                 } else if (right.string === 'undefined' ||
                         right.string === 'null') {
-                    warn("unexpected_typeof_a", left, right.string);
+                    left.warn("unexpected_typeof_a", right.string);
+                }
+            } else if (right.id === 'typeof') {
+                if (left.id !== '(string)') {
+                    left.warn("expected_string_a", artifact(left));
+                } else if (left.string === 'undefined' ||
+                        left.string === 'null') {
+                    right.warn("unexpected_typeof_a", left.string);
                 }
             }
             that.first = left;
             that.second = check_relation(right);
             return that;
         });
+        x.relation = true;
+        return x;
     }
 
-
-    function assignop(s, op) {
-        var x = infix(s, 20, function (left, that) {
-            var l;
-            that.first = left;
-            if (left.identifier) {
-                if (scope[left.string]) {
-                    if (scope[left.string].writeable === false) {
-                        warn('read_only', left);
-                    }
-                } else {
-                    stop('read_only');
+    function lvalue(that, s) {
+        var master;
+        if (that.identifier) {
+            master = scope[that.string];
+            if (master) {
+                if (scope[that.string].writeable !== true) {
+                    that.warn('read_only');
                 }
-                if (funct['(params)']) {
-                    funct['(params)'].forEach(function (value) {
-                        if (value.string === left.string) {
-                            value.assign = true;
-                        }
-                    });
+                master.used -= 1;
+                if (s === '=') {
+                    master.init = true;
                 }
-            } else if (option.safe) {
-                l = left;
-                do {
-                    if (typeof predefined[l.string] === 'boolean') {
-                        warn('adsafe_a', l);
-                    }
-                    l = l.first;
-                } while (l);
             }
-            if (left === syntax['function']) {
-                warn('identifier_function', token);
-            }
-            if (left.id === '.' || left.id === '[') {
-                if (!left.first || left.first.string === 'arguments') {
-                    warn('bad_assignment', that);
-                }
-            } else if (left.identifier) {
-                if (!left.reserved && funct[left.string] === 'exception') {
-                    warn('assign_exception', left);
-                }
-            } else {
-                warn('bad_assignment', that);
+        } else if (that.id === '.' || that.id === '[') {
+            if (!that.first || that.first.string === 'arguments') {
+                that.warn('bad_assignment');
             }
-            that.second = expression(19);
+        } else {
+            that.warn('bad_assignment');
+        }
+    }
+
+
+    function assignop(s, op) {
+        var x = infix(s, 20, function (left, that) {
+            var next;
+            that.first = left;
+            lvalue(left, s);
+            that.second = expression(20);
             if (that.id === '=' && are_similar(that.first, that.second)) {
-                warn('weird_assignment', that);
+                that.warn('weird_assignment');
+            }
+            next = that;
+            while (next_token.id === '=') {
+                lvalue(next.second, '=');
+                next_token.first = next.second;
+                next.second = next_token;
+                next = next_token;
+                advance('=');
+                next.second = expression(20);
             }
             return that;
         });
@@ -2848,10 +2227,10 @@ klass:              do {
         x.led = function (left) {
             no_space_only(prev_token, token);
             if (!option.plusplus) {
-                warn('unexpected_a', this);
+                this.warn('unexpected_a');
             } else if ((!left.identifier || left.reserved) &&
                     left.id !== '.' && left.id !== '[') {
-                warn('bad_operand', this);
+                this.warn('bad_operand');
             }
             this.first = left;
             this.arity = 'suffix';
@@ -2864,10 +2243,8 @@ klass:              do {
     function optional_identifier(variable) {
         if (next_token.identifier) {
             advance();
-            if (option.safe && banned[token.string]) {
-                warn('adsafe_a', token);
-            } else if (token.reserved && (!option.es5 || variable)) {
-                warn('expected_identifier_a_reserved', token);
+            if (token.reserved && (!option.es5 || variable)) {
+                token.warn('expected_identifier_a_reserved');
             }
             return token.string;
         }
@@ -2877,7 +2254,7 @@ klass:              do {
     function identifier(variable) {
         var i = optional_identifier(variable);
         if (!i) {
-            stop(token.id === 'function' && next_token.id === '('
+            next_token.stop(token.id === 'function' && next_token.id === '('
                 ? 'name_function'
                 : 'expected_identifier_a');
         }
@@ -2887,12 +2264,12 @@ klass:              do {
 
     function statement() {
 
-        var label, old_scope = scope, the_statement;
+        var label, preamble, the_statement;
 
 // We don't like the empty statement.
 
         if (next_token.id === ';') {
-            warn('unexpected_a');
+            next_token.warn('unexpected_a');
             semicolon();
             return;
         }
@@ -2904,18 +2281,19 @@ klass:              do {
             label = next_token;
             advance();
             advance(':');
-            scope = Object.create(old_scope);
-            add_label(label, 'label');
+            define('label', label);
             if (next_token.labeled !== true || funct === global_funct) {
-                stop('unexpected_label_a', label);
+                label.stop('unexpected_label_a');
             } else if (jx.test(label.string + ':')) {
-                warn('url', label);
+                label.warn('url');
             }
             next_token.label = label;
+            label.init = true;
         }
 
 // Parse the statement.
 
+        preamble = next_token;
         if (token.id !== 'else') {
             edge();
         }
@@ -2937,25 +2315,30 @@ klass:              do {
 // If this is an expression statement, determine if it is acceptable.
 // We do not like
 //      new Blah;
-// statments. If it is to be used at all, new should only be used to make
+// statements. If it is to be used at all, new should only be used to make
 // objects, not side effects. The expression statements we do like do
 // assignment or invocation or delete.
 
                 if (the_statement.id === '(') {
                     if (the_statement.first.id === 'new') {
-                        warn('bad_new');
+                        next_token.warn('bad_new');
                     }
+                } else if (the_statement.id === '++' ||
+                        the_statement.id === '--') {
+                    lvalue(the_statement.first);
                 } else if (!the_statement.assign &&
-                        the_statement.id !== 'delete' &&
-                        the_statement.id !== '++' &&
-                        the_statement.id !== '--') {
-                    warn('assignment_function_expression', the_statement);
+                        the_statement.id !== 'delete') {
+                    if (!option.closure || !preamble.comments) {
+                        preamble.warn('assignment_function_expression');
+                    }
                 }
                 semicolon();
             }
         }
         step_out();
-        scope = old_scope;
+        if (label) {
+            label.dead = true;
+        }
         return the_statement;
     }
 
@@ -2968,17 +2351,17 @@ klass:              do {
 
         while (next_token.postscript !== true) {
             if (next_token.id === ';') {
-                warn('unexpected_a', next_token);
+                next_token.warn('unexpected_a');
                 semicolon();
             } else {
                 if (next_token.string === 'use strict') {
-                    if ((!node_js && xmode !== 'script') || funct !== global_funct || array.length > 0) {
-                        warn('function_strict');
+                    if ((!node_js) || funct !== global_funct || array.length > 0) {
+                        next_token.warn('function_strict');
                     }
                     use_strict();
                 }
                 if (disruptor) {
-                    warn('unreachable_a_b', next_token, next_token.string,
+                    next_token.warn('unreachable_a_b', next_token.string,
                         disruptor.string);
                     disruptor = null;
                 }
@@ -2996,53 +2379,53 @@ klass:              do {
     }
 
 
-    function block(ordinary) {
+    function block(kind) {
 
-// array block is array sequence of statements wrapped in braces.
-// ordinary is false for function bodies and try blocks.
-// ordinary is true for if statements, while, etc.
+// A block is a sequence of statements wrapped in braces.
 
         var array,
             curly = next_token,
+            old_block_var = block_var,
             old_in_block = in_block,
-            old_scope = scope,
             old_strict_mode = strict_mode;
 
-        in_block = ordinary;
-        scope = Object.create(scope);
-        spaces();
-        if (next_token.id === '{') {
+        in_block = kind !== 'function' && kind !== 'try' && kind !== 'catch';
+        block_var = [];
+        if (curly.id === '{') {
+            spaces();
             advance('{');
             step_in();
-            if (!ordinary && !use_strict() && !old_strict_mode &&
-                    !option.sloppy && funct['(context)'] === global_funct) {
-                warn('missing_use_strict');
+            if (kind === 'function' && !use_strict() && !old_strict_mode &&
+                    !option.sloppy && funct.level === 1) {
+                next_token.warn('missing_use_strict');
             }
             array = statements();
             strict_mode = old_strict_mode;
             step_out('}', curly);
-        } else if (!ordinary) {
-            stop('expected_a_b', next_token, '{', artifact());
+        } else if (in_block) {
+            curly.stop('expected_a_b', '{', artifact());
         } else {
-            warn('expected_a_b', next_token, '{', artifact());
+            curly.warn('expected_a_b', '{', artifact());
             array = [statement()];
             array.disrupt = array[0].disrupt;
         }
-        funct['(verb)'] = null;
-        scope = old_scope;
-        in_block = old_in_block;
-        if (ordinary && array.length === 0) {
-            warn('empty_block');
+        if (kind !== 'catch' && array.length === 0) {
+            curly.warn('empty_block');
         }
+        block_var.forEach(function (name) {
+            scope[name].dead = true;
+        });
+        block_var = old_block_var;
+        in_block = old_in_block;
         return array;
     }
 
 
     function tally_property(name) {
         if (option.properties && typeof property[name] !== 'number') {
-            warn('unexpected_property_a', token, name);
+            token.warn('unexpected_property_a', name);
         }
-        if (typeof property[name] === 'number') {
+        if (property[name]) {
             property[name] += 1;
         } else {
             property[name] = 1;
@@ -3052,147 +2435,77 @@ klass:              do {
 
 // ECMAScript parser
 
-    syntax['(identifier)'] = {
-        id: '(identifier)',
-        lbp: 0,
-        identifier: true,
-        nud: function () {
+    (function () {
+        var x = symbol('(identifier)');
+        x.nud = function () {
             var name = this.string,
-                variable = scope[name],
-                site,
+                master = scope[name],
                 writeable;
 
-// If the variable is not in scope, then we may have an undeclared variable.
+// If the master is not in scope, then we may have an undeclared variable.
 // Check the predefined list. If it was predefined, create the global
 // variable.
 
-            if (typeof variable !== 'object') {
+            if (!master) {
                 writeable = predefined[name];
                 if (typeof writeable === 'boolean') {
-                    global_scope[name] = variable = {
-                        string:    name,
-                        writeable: writeable,
-                        funct:     global_funct
+                    global_scope[name] = master = {
+                        dead: false,
+                        function: global_funct,
+                        kind: 'var',
+                        string: name,
+                        writeable: writeable
                     };
-                    global_funct[name] = 'var';
 
 // But if the variable is not in scope, and is not predefined, and if we are not
 // in the global scope, then we have an undefined variable error.
 
                 } else {
-                    if (!option.undef) {
-                        warn('used_before_a', token);
-                    }
-                    scope[name] = variable = {
-                        string: name,
-                        writeable: true,
-                        funct: funct
-                    };
-                    funct[name] = 'undef';
+                    token.warn('used_before_a');
                 }
-
+            } else {
+                this.master = master;
             }
-            site = variable.funct;
-
-// The name is in scope and defined in the current function.
-
-            if (funct === site) {
-
-//      Change 'unused' to 'var', and reject labels.
-
-                switch (funct[name]) {
-                case 'becoming':
-                    warn('unexpected_a', token);
-                    funct[name] = 'var';
-                    break;
-                case 'unused':
-                    funct[name] = 'var';
-                    break;
-                case 'unparam':
-                    funct[name] = 'parameter';
-                    break;
-                case 'unction':
-                    funct[name] = 'function';
-                    break;
-                case 'label':
-                    warn('a_label', token, name);
-                    break;
-                }
 
-// If the name is already defined in the current
-// function, but not as outer, then there is a scope error.
-
-            } else {
-                switch (funct[name]) {
-                case 'closure':
-                case 'function':
-                case 'var':
-                case 'unused':
-                    warn('a_scope', token, name);
-                    break;
-                case 'label':
-                    warn('a_label', token, name);
-                    break;
-                case 'outer':
-                case 'global':
-                    break;
-                default:
+// Annotate uses that cross scope boundaries.
 
-// If the name is defined in an outer function, make an outer entry, and if
-// it was unused, make it var.
-
-                    switch (site[name]) {
-                    case 'becoming':
-                    case 'closure':
-                    case 'function':
-                    case 'parameter':
-                    case 'unction':
-                    case 'unused':
-                    case 'var':
-                        site[name] = 'closure';
-                        funct[name] = site === global_funct
-                            ? 'global'
-                            : 'outer';
-                        break;
-                    case 'unparam':
-                        site[name] = 'parameter';
-                        funct[name] = 'outer';
-                        break;
-                    case 'undef':
-                        funct[name] = 'undef';
-                        break;
-                    case 'label':
-                        warn('a_label', token, name);
-                        break;
+            if (master) {
+                if (master.kind === 'label') {
+                    this.warn('a_label');
+                } else {
+                    if (master.dead === true || master.dead === funct) {
+                        this.warn('a_scope');
+                    }
+                    master.used += 1;
+                    if (master.function !== funct) {
+                        if (master.function === global_funct) {
+                            funct.global.push(name);
+                        } else {
+                            master.function.closure.push(name);
+                            funct.outer.push(name);
+                        }
                     }
                 }
             }
             return this;
-        },
-        led: function () {
-            stop('expected_operator_a');
-        }
-    };
+        };
+        x.identifier = true;
+    }());
+
 
 // Build the syntax table by declaring the syntactic elements.
 
     type('(array)', 'array');
-    type('(color)', 'color');
     type('(function)', 'function');
     type('(number)', 'number', return_this);
     type('(object)', 'object');
     type('(string)', 'string', return_this);
     type('(boolean)', 'boolean', return_this);
-    type('(range)', 'range');
     type('(regexp)', 'regexp', return_this);
 
     ultimate('(begin)');
     ultimate('(end)');
     ultimate('(error)');
-    postscript(symbol('</'));
-    symbol('<!');
-    symbol('<!--');
-    symbol('-->');
     postscript(symbol('}'));
     symbol(')');
     symbol(']');
@@ -3212,28 +2525,18 @@ klass:              do {
 
     reservevar('arguments', function (x) {
         if (strict_mode && funct === global_funct) {
-            warn('strict', x);
-        } else if (option.safe) {
-            warn('adsafe_a', x);
-        }
-        funct['(arguments)'] = true;
-    });
-    reservevar('eval', function (x) {
-        if (option.safe) {
-            warn('adsafe_a', x);
+            x.warn('strict');
         }
+        funct.arguments = true;
     });
+    reservevar('eval');
     constant('false', 'boolean');
     constant('Infinity', 'number');
     constant('NaN', 'number');
     constant('null', '');
     reservevar('this', function (x) {
-        if (option.safe) {
-            warn('adsafe_a', x);
-        } else if (strict_mode && funct['(token)'] &&
-                (funct['(token)'].arity === 'statement' &&
-                funct['(name)'].charAt(0) > 'Z')) {
-            warn('strict', x);
+        if (strict_mode && funct.statement && funct.name.charAt(0) > 'Z') {
+            x.warn('strict');
         }
     });
     constant('true', 'boolean');
@@ -3252,9 +2555,9 @@ klass:              do {
         that.third = expression(10);
         that.arity = 'ternary';
         if (are_similar(that.second, that.third)) {
-            warn('weird_ternary', colon);
+            colon.warn('weird_ternary');
         } else if (are_similar(that.first, that.second)) {
-            warn('use_or', that);
+            that.warn('use_or');
         }
         step_out();
         return that;
@@ -3263,7 +2566,7 @@ klass:              do {
     infix('||', 40, function (left, that) {
         function paren_check(that) {
             if (that.id === '&&' && !that.paren) {
-                warn('and', that);
+                that.warn('and');
             }
             return that;
         }
@@ -3271,7 +2574,7 @@ klass:              do {
         that.first = paren_check(expected_condition(expected_relation(left)));
         that.second = paren_check(expected_relation(expression(40)));
         if (are_similar(that.first, that.second)) {
-            warn('weird_condition', that);
+            that.warn('weird_condition');
         }
         return that;
     });
@@ -3280,7 +2583,7 @@ klass:              do {
         that.first = expected_condition(expected_relation(left));
         that.second = expected_relation(expression(50));
         if (are_similar(that.first, that.second)) {
-            warn('weird_condition', that);
+            that.warn('weird_condition');
         }
         return that;
     });
@@ -3288,9 +2591,9 @@ klass:              do {
     prefix('void', function (that) {
         that.first = expression(0);
         if (option.es5 || strict_mode) {
-            warn('expected_a_b', that, 'undefined', 'void');
+            that.warn('expected_a_b', 'undefined', 'void');
         } else if (that.first.number !== 0) {
-            warn('expected_a_b', that.first, '0', artifact(that.first));
+            that.first.warn('expected_a_b', '0', artifact(that.first));
         }
         return that;
     });
@@ -3313,7 +2616,7 @@ klass:              do {
     bitwise('>>>', 120);
 
     infix('in', 120, function (left, that) {
-        warn('infix_in', that);
+        that.warn('infix_in');
         that.left = left;
         that.right = expression(130);
         return that;
@@ -3322,21 +2625,21 @@ klass:              do {
     infix('+', 130, function (left, that) {
         if (left.id === '(number)') {
             if (left.number === 0) {
-                warn('unexpected_a', left, '0');
+                left.warn('unexpected_a', '0');
             }
         } else if (left.id === '(string)') {
             if (left.string === '') {
-                warn('expected_a_b', left, 'String', '\'\'');
+                left.warn('expected_a_b', 'String', '\'\'');
             }
         }
         var right = expression(130);
         if (right.id === '(number)') {
             if (right.number === 0) {
-                warn('unexpected_a', right, '0');
+                right.warn('unexpected_a', '0');
             }
         } else if (right.id === '(string)') {
             if (right.string === '') {
-                warn('expected_a_b', right, 'String', '\'\'');
+                right.warn('expected_a_b', 'String', '\'\'');
             }
         }
         if (left.id === right.id) {
@@ -3344,7 +2647,7 @@ klass:              do {
                 if (left.id === '(string)') {
                     left.string += right.string;
                     if (jx.test(left.string)) {
-                        warn('url', left);
+                        left.warn('url');
                     }
                 } else {
                     left.number += right.number;
@@ -3359,24 +2662,24 @@ klass:              do {
     });
     prefix('+');
     prefix('+++', function () {
-        warn('confusing_a', token);
+        token.warn('confusing_a');
         this.first = expression(150);
         this.arity = 'prefix';
         return this;
     });
     infix('+++', 130, function (left) {
-        warn('confusing_a', token);
+        token.warn('confusing_a');
         this.first = left;
         this.second = expression(130);
         return this;
     });
     infix('-', 130, function (left, that) {
         if ((left.id === '(number)' && left.number === 0) || left.id === '(string)') {
-            warn('unexpected_a', left);
+            left.warn('unexpected_a');
         }
         var right = expression(130);
         if ((right.id === '(number)' && right.number === 0) || right.id === '(string)') {
-            warn('unexpected_a', right);
+            right.warn('unexpected_a');
         }
         if (left.id === right.id && left.id === '(number)') {
             left.number -= right.number;
@@ -3389,24 +2692,24 @@ klass:              do {
     });
     prefix('-');
     prefix('---', function () {
-        warn('confusing_a', token);
+        token.warn('confusing_a');
         this.first = expression(150);
         this.arity = 'prefix';
         return this;
     });
     infix('---', 130, function (left) {
-        warn('confusing_a', token);
+        token.warn('confusing_a');
         this.first = left;
         this.second = expression(130);
         return this;
     });
     infix('*', 140, function (left, that) {
         if ((left.id === '(number)' && (left.number === 0 || left.number === 1)) || left.id === '(string)') {
-            warn('unexpected_a', left);
+            left.warn('unexpected_a');
         }
         var right = expression(140);
         if ((right.id === '(number)' && (right.number === 0 || right.number === 1)) || right.id === '(string)') {
-            warn('unexpected_a', right);
+            right.warn('unexpected_a');
         }
         if (left.id === right.id && left.id === '(number)') {
             left.number *= right.number;
@@ -3419,11 +2722,11 @@ klass:              do {
     });
     infix('/', 140, function (left, that) {
         if ((left.id === '(number)' && left.number === 0) || left.id === '(string)') {
-            warn('unexpected_a', left);
+            left.warn('unexpected_a');
         }
         var right = expression(140);
         if ((right.id === '(number)' && (right.number === 0 || right.number === 1)) || right.id === '(string)') {
-            warn('unexpected_a', right);
+            right.warn('unexpected_a');
         }
         if (left.id === right.id && left.id === '(number)') {
             left.number /= right.number;
@@ -3436,11 +2739,11 @@ klass:              do {
     });
     infix('%', 140, function (left, that) {
         if ((left.id === '(number)' && (left.number === 0 || left.number === 1)) || left.id === '(string)') {
-            warn('unexpected_a', left);
+            left.warn('unexpected_a');
         }
         var right = expression(140);
         if ((right.id === '(number)' && right.number === 0) || right.id === '(string)') {
-            warn('unexpected_a', right);
+            right.warn('unexpected_a');
         }
         if (left.id === right.id && left.id === '(number)') {
             left.number %= right.number;
@@ -3461,7 +2764,7 @@ klass:              do {
         one_space();
         var p = expression(0);
         if (!p || (p.id !== '.' && p.id !== '[')) {
-            warn('deleted');
+            next_token.warn('deleted');
         }
         that.first = p;
         return that;
@@ -3471,7 +2774,7 @@ klass:              do {
     prefix('~', function (that) {
         no_space_only();
         if (!option.bitwise) {
-            warn('unexpected_a', that);
+            that.warn('unexpected_a');
         }
         that.first = expression(150);
         return that;
@@ -3480,7 +2783,7 @@ klass:              do {
         no_space_only();
         that.first = expected_condition(expression(150));
         if (bang[that.first.id] === that || that.first.assign) {
-            warn('confusing_a', that);
+            that.warn('confusing_a');
         }
         return that;
     }
@@ -3495,7 +2798,7 @@ klass:              do {
             if (c.identifier) {
                 switch (c.string) {
                 case 'Object':
-                    warn('use_object', token);
+                    token.warn('use_object');
                     break;
                 case 'Array':
                     if (next_token.id === '(') {
@@ -3506,30 +2809,30 @@ klass:              do {
                             n = expression(0);
                             p.second = [n];
                             if (n.id !== '(number)' || next_token.id === ',') {
-                                warn('use_array', p);
+                                p.warn('use_array');
                             }
                             while (next_token.id === ',') {
                                 advance(',');
                                 p.second.push(expression(0));
                             }
                         } else {
-                            warn('use_array', token);
+                            token.warn('use_array');
                         }
                         advance(')', p);
                         return p;
                     }
-                    warn('use_array', token);
+                    token.warn('use_array');
                     break;
                 case 'Number':
                 case 'String':
                 case 'Boolean':
                 case 'Math':
                 case 'JSON':
-                    warn('not_a_constructor', c);
+                    c.warn('not_a_constructor');
                     break;
                 case 'Function':
                     if (!option.evil) {
-                        warn('function_eval');
+                        next_token.warn('function_eval');
                     }
                     break;
                 case 'Date':
@@ -3540,20 +2843,20 @@ klass:              do {
                     if (c.id !== 'function') {
                         v = c.string.charAt(0);
                         if (!option.newcap && (v < 'A' || v > 'Z')) {
-                            warn('constructor_name_a', token);
+                            token.warn('constructor_name_a');
                         }
                     }
                 }
             } else {
                 if (c.id !== '.' && c.id !== '[' && c.id !== '(') {
-                    warn('bad_constructor', token);
+                    token.warn('bad_constructor');
                 }
             }
         } else {
-            warn('weird_new', that);
+            that.warn('weird_new');
         }
         if (next_token.id !== '(') {
-            warn('missing_a', next_token, '()');
+            next_token.warn('missing_a', '()');
         }
         return that;
     });
@@ -3566,7 +2869,7 @@ klass:              do {
             no_space_only(prev_token, token);
         }
         if (!left.immed && left.id === 'function') {
-            warn('wrap_immediate');
+            next_token.warn('wrap_immediate');
         }
         p = [];
         if (left.identifier) {
@@ -3574,21 +2877,18 @@ klass:              do {
                 if (left.string !== 'Number' && left.string !== 'String' &&
                         left.string !== 'Boolean' && left.string !== 'Date') {
                     if (left.string === 'Math' || left.string === 'JSON') {
-                        warn('not_a_function', left);
+                        left.warn('not_a_function');
                     } else if (left.string === 'Object') {
-                        warn('use_object', token);
+                        token.warn('use_object');
                     } else if (left.string === 'Array' || !option.newcap) {
-                        warn('missing_a', left, 'new');
+                        left.warn('missing_a', 'new');
                     }
                 }
             }
         } else if (left.id === '.') {
-            if (option.safe && left.first.string === 'Math' &&
-                    left.second === 'random') {
-                warn('adsafe_a', left);
-            } else if (left.second.string === 'split' &&
+            if (left.second.string === 'split' &&
                     left.first.id === '(string)') {
-                warn('use_array', left.second);
+                left.second.warn('use_array');
             }
         }
         step_in();
@@ -3598,7 +2898,7 @@ klass:              do {
                 edge();
                 e = expression(10);
                 if (left.string === 'Boolean' && (e.id === '!' || e.id === '~')) {
-                    warn('weird_condition', e);
+                    e.warn('weird_condition');
                 }
                 p.push(e);
                 if (next_token.id !== ',') {
@@ -3611,24 +2911,24 @@ klass:              do {
         step_out(')', that);
         if (typeof left === 'object') {
             if (left.string === 'parseInt' && p.length === 1) {
-                warn('radix', left);
+                left.warn('radix');
             } else if (left.string === 'String' && p.length >= 1 && p[0].id === '(string)') {
-                warn('unexpected_a', left);
+                left.warn('unexpected_a');
             }
             if (!option.evil) {
                 if (left.string === 'eval' || left.string === 'Function' ||
                         left.string === 'execScript') {
-                    warn('evil', left);
+                    left.warn('evil');
                 } else if (p[0] && p[0].id === '(string)' &&
                         (left.string === 'setTimeout' ||
                         left.string === 'setInterval')) {
-                    warn('implied_evil', left);
+                    left.warn('implied_evil');
                 }
             }
             if (!left.identifier && left.id !== '.' && left.id !== '[' &&
                     left.id !== '(' && left.id !== '&&' && left.id !== '||' &&
                     left.id !== '?') {
-                warn('bad_invocation', left);
+                left.warn('bad_invocation');
             }
             if (left.id === '.') {
                 if (p.length > 0 &&
@@ -3637,12 +2937,12 @@ klass:              do {
                     if (left.second.string === 'call' ||
                             (left.second.string === 'apply' && (p.length === 1 ||
                             (p[1].arity === 'prefix' && p[1].id === '[')))) {
-                        warn('unexpected_a', left.second);
+                        left.second.warn('unexpected_a');
                     }
                 }
                 if (left.second.string === 'toString') {
                     if (left.first.id === '(string)' || left.first.id === '(number)') {
-                        warn('unexpected_a', left.second);
+                        left.second.warn('unexpected_a');
                     }
                 }
             }
@@ -3666,17 +2966,19 @@ klass:              do {
         if (value.id === 'function') {
             switch (next_token.id) {
             case '(':
-                warn('move_invocation');
+                next_token.warn('move_invocation');
                 break;
             case '.':
             case '[':
-                warn('unexpected_a');
+                next_token.warn('unexpected_a');
                 break;
             default:
-                warn('bad_wrap', that);
+                that.warn('bad_wrap');
             }
         } else if (!value.arity) {
-            warn('unexpected_a', that);
+            if (!option.closure || !that.comments) {
+                that.warn('unexpected_a');
+            }
         }
         return value;
     });
@@ -3692,55 +2994,15 @@ klass:              do {
         that.second = token;
         if (left && left.string === 'arguments' &&
                 (name === 'callee' || name === 'caller')) {
-            warn('avoid_a', left, 'arguments.' + name);
+            left.warn('avoid_a', 'arguments.' + name);
         } else if (!option.evil && left && left.string === 'document' &&
                 (name === 'write' || name === 'writeln')) {
-            warn('write_is_wrong', left);
+            left.warn('write_is_wrong');
         } else if (!option.stupid && syx.test(name)) {
-            warn('sync_a', token);
-        } else if (option.adsafe) {
-            if (!adsafe_top && left.string === 'ADSAFE') {
-                if (name === 'id' || name === 'lib') {
-                    warn('adsafe_a', that);
-                } else if (name === 'go') {
-                    if (xmode !== 'script') {
-                        warn('adsafe_a', that);
-                    } else if (adsafe_went || next_token.id !== '(' ||
-                            peek(0).id !== '(string)' ||
-                            peek(0).string !== adsafe_id ||
-                            peek(1).id !== ',') {
-                        stop('adsafe_a', that, 'go');
-                    }
-                    adsafe_went = true;
-                    adsafe_may = false;
-                }
-            }
-            adsafe_top = false;
+            token.warn('sync_a');
         }
         if (!option.evil && (name === 'eval' || name === 'execScript')) {
-            warn('evil');
-        } else if (option.safe) {
-            for (;;) {
-                if (banned[name] === true) {
-                    warn('adsafe_a', token, name);
-                }
-                if (typeof predefined[left.string] !== 'boolean' ||    //// check for writeable
-                        next_token.id === '(') {
-                    break;
-                }
-                if (next_token.id !== '.') {
-                    warn('adsafe_a', that);
-                    break;
-                }
-                advance('.');
-                token.first = that;
-                token.second = name;
-                that = token;
-                name = identifier();
-                if (typeof name === 'string') {
-                    tally_property(name);
-                }
-            }
+            next_token.warn('evil');
         }
         return that;
     }, true);
@@ -3755,31 +3017,21 @@ klass:              do {
         switch (e.id) {
         case '(number)':
             if (e.id === '(number)' && left.id === 'arguments') {
-                warn('use_param', left);
+                left.warn('use_param', left);
             }
             break;
         case '(string)':
-            if (option.safe && (banned[e.string] ||
-                    e.string.charAt(0) === '_' || e.string.slice(-1) === '_')) {
-                warn('adsafe_subscript_a', e);
-            } else if (!option.evil &&
+            if (!option.evil &&
                     (e.string === 'eval' || e.string === 'execScript')) {
-                warn('evil', e);
+                e.warn('evil');
             } else if (!option.sub && ix.test(e.string)) {
                 s = syntax[e.string];
                 if (!s || !s.reserved) {
-                    warn('subscript', e);
+                    e.warn('subscript');
                 }
             }
             tally_property(e.string);
             break;
-        default:
-            if (option.safe) {
-                if ((e.id !== '+' || e.arity !== 'prefix') &&
-                        e.id !== '-' && e.id !== '*') {
-                    warn('adsafe_subscript_a', e);
-                }
-            }
         }
         step_out(']', that);
         no_space(prev_token, token);
@@ -3793,7 +3045,7 @@ klass:              do {
         step_in('array');
         while (next_token.id !== '(end)') {
             while (next_token.id === ',') {
-                warn('unexpected_a', next_token);
+                next_token.warn('unexpected_a');
                 advance(',');
             }
             if (next_token.id === ']') {
@@ -3805,7 +3057,7 @@ klass:              do {
             if (next_token.id === ',') {
                 comma();
                 if (next_token.id === ']' && !option.es5) {
-                    warn('unexpected_a', token);
+                    token.warn('unexpected_a');
                     break;
                 }
             } else {
@@ -3822,14 +3074,6 @@ klass:              do {
         if (!id) {
             if (next_token.id === '(string)') {
                 id = next_token.string;
-                if (option.safe) {
-                    if (banned[id]) {
-                        warn('adsafe_a');
-                    } else if (id.charAt(0) === '_' ||
-                            id.charAt(id.length - 1) === '_') {
-                        warn('dangling_a');
-                    }
-                }
                 advance();
             } else if (next_token.id === '(number)') {
                 id = next_token.number.toString();
@@ -3840,88 +3084,92 @@ klass:              do {
     }
 
 
-    function function_params() {
-        var id, paren = next_token, params = [];
+
+    assignop('=');
+    assignop('+=', '+');
+    assignop('-=', '-');
+    assignop('*=', '*');
+    assignop('/=', '/').nud = function () {
+        next_token.stop('slash_equal');
+    };
+    assignop('%=', '%');
+    assignop('&=', '&');
+    assignop('|=', '|');
+    assignop('^=', '^');
+    assignop('<<=', '<<');
+    assignop('>>=', '>>');
+    assignop('>>>=', '>>>');
+
+    function function_parameters() {
+        var id, parameters = [], paren = next_token;
         advance('(');
+        token.function = funct;
         step_in();
         no_space();
-        if (next_token.id === ')') {
-            no_space();
-            step_out(')', paren);
-            return params;
-        }
-        for (;;) {
-            edge();
-            id = identifier();
-            params.push(token);
-            add_label(token, option.unparam ? 'parameter' : 'unparam');
-            if (next_token.id === ',') {
+        if (next_token.id !== ')') {
+            for (;;) {
+                edge();
+                id = identifier();
+                define('parameter', token);
+                parameters.push(id);
+                token.init = true;
+                token.writeable = true;
+                if (next_token.id !== ',') {
+                    break;
+                }
                 comma();
-            } else {
-                no_space();
-                step_out(')', paren);
-                return params;
             }
         }
+        no_space();
+        step_out(')', paren);
+        return parameters;
     }
 
-
-
     function do_function(func, name) {
-        var old_funct      = funct,
-            old_option     = option,
-            old_scope      = scope;
+        var old_funct = funct,
+            old_option = option,
+            old_scope = scope;
+        scope = Object.create(old_scope);
         funct = {
-            '(name)'     : name || '\'' + (anonname || '').replace(nx, sanitize) + '\'',
-            '(line)'     : next_token.line,
-            '(context)'  : old_funct,
-            '(breakage)' : 0,
-            '(loopage)'  : 0,
-            '(scope)'    : scope,
-            '(token)'    : func
+            closure: [],
+            global: [],
+            level: old_funct.level + 1,
+            line: next_token.line,
+            loopage: 0,
+            name: name || '\'' + (anonname || '').replace(nx, sanitize) + '\'',
+            outer: [],
+            scope: scope
         };
+        funct.parameter = function_parameters();
+        func.function = funct;
         option = Object.create(old_option);
-        scope = Object.create(old_scope);
         functions.push(funct);
-        func.name = name;
         if (name) {
-            add_label(func, 'function', name);
+            func.name = name;
+            func.string = name;
+            define('function', func);
+            func.init = true;
+            func.used += 1;
         }
         func.writeable = false;
-        func.first = funct['(params)'] = function_params();
         one_space();
-        func.block = block(false);
-        if (funct['(arguments)']) {
-            func.first.forEach(function (value) {
-                if (value.assign) {
-                    warn('parameter_arguments_a', value, value.string);
-                }
-            });
-        }
-        funct      = old_funct;
-        option     = old_option;
-        scope      = old_scope;
+        func.block = block('function');
+        Object.keys(scope).forEach(function (name) {
+            var master = scope[name];
+            if (!master.used && master.kind !== 'exception' &&
+                    (master.kind !== 'parameter' || !option.unparam)) {
+                master.warn('unused_a');
+            } else if (!master.init) {
+                master.warn('uninitialized_a');
+            }
+        });
+        funct = old_funct;
+        option = old_option;
+        scope = old_scope;
     }
 
-
-    assignop('=');
-    assignop('+=', '+');
-    assignop('-=', '-');
-    assignop('*=', '*');
-    assignop('/=', '/').nud = function () {
-        stop('slash_equal');
-    };
-    assignop('%=', '%');
-    assignop('&=', '&');
-    assignop('|=', '|');
-    assignop('^=', '^');
-    assignop('<<=', '<<');
-    assignop('>>=', '>>');
-    assignop('>>>=', '>>>');
-
-
     prefix('{', function (that) {
-        var get, i, j, name, p, set, seen = {};
+        var get, i, j, name, p, set, seen = Object.create(null);
         that.first = [];
         step_in();
         while (next_token.id !== '}') {
@@ -3933,7 +3181,7 @@ klass:              do {
             edge();
             if (next_token.string === 'get' && peek().id !== ':') {
                 if (!option.es5) {
-                    warn('es5');
+                    next_token.warn('es5');
                 }
                 get = next_token;
                 advance('get');
@@ -3941,16 +3189,16 @@ klass:              do {
                 name = next_token;
                 i = property_name();
                 if (!i) {
-                    stop('missing_property');
+                    next_token.stop('missing_property');
                 }
                 get.string = '';
                 do_function(get);
-                if (funct['(loopage)']) {
-                    warn('function_loop', get);
+                if (funct.loopage) {
+                    get.warn('function_loop');
                 }
                 p = get.first;
                 if (p && p.length) {
-                    warn('parameter_a_get_b', p[0], p[0].string, i);
+                    p[0].warn('parameter_a_get_b', p[0].string, i);
                 }
                 comma();
                 set = next_token;
@@ -3961,24 +3209,24 @@ klass:              do {
                 one_space_only();
                 j = property_name();
                 if (i !== j) {
-                    stop('expected_a_b', token, i, j || next_token.string);
+                    token.stop('expected_a_b', i, j || next_token.string);
                 }
                 do_function(set);
                 if (set.block.length === 0) {
-                    warn('missing_a', token, 'throw');
+                    token.warn('missing_a', 'throw');
                 }
                 p = set.first;
                 if (!p || p.length !== 1) {
-                    stop('parameter_set_a', set, 'value');
+                    set.stop('parameter_set_a', 'value');
                 } else if (p[0].string !== 'value') {
-                    stop('expected_a_b', p[0], 'value', p[0].string);
+                    p[0].stop('expected_a_b', 'value', p[0].string);
                 }
                 name.first = [get, set];
             } else {
                 name = next_token;
                 i = property_name();
                 if (typeof i !== 'string') {
-                    stop('missing_property');
+                    next_token.stop('missing_property');
                 }
                 advance(':');
                 spaces();
@@ -3986,7 +3234,7 @@ klass:              do {
             }
             that.first.push(name);
             if (seen[i] === true) {
-                warn('duplicate_a', next_token, i);
+                next_token.warn('duplicate_a', i);
             }
             seen[i] = true;
             tally_property(i);
@@ -3998,10 +3246,10 @@ klass:              do {
                 if (next_token.id !== ',') {
                     break;
                 }
-                warn('unexpected_a', next_token);
+                next_token.warn('unexpected_a');
             }
             if (next_token.id === '}' && !option.es5) {
-                warn('unexpected_a', token);
+                token.warn('unexpected_a');
             }
         }
         step_out('}', that);
@@ -4009,7 +3257,7 @@ klass:              do {
     });
 
     stmt('{', function () {
-        warn('statement_block');
+        next_token.warn('statement_block');
         this.arity = 'statement';
         this.block = statements();
         this.disrupt = this.block.disrupt;
@@ -4035,10 +3283,13 @@ klass:              do {
 
         var assign, id, name;
 
-        if (funct['(vars)'] && !option.vars) {
-            warn('combine_var');
-        } else if (funct !== global_funct) {
-            funct['(vars)'] = true;
+        if (funct.loopage) {
+            next_token.warn('var_loop');
+        } else if (funct.varstatement && !option.vars) {
+            next_token.warn('combine_var');
+        }
+        if (funct !== global_funct) {
+            funct.varstatement = true;
         }
         this.arity = 'statement';
         this.first = [];
@@ -4046,8 +3297,8 @@ klass:              do {
         for (;;) {
             name = next_token;
             id = identifier(true);
-            add_label(name, 'becoming');
-
+            define('var', name);
+            name.dead = funct;
             if (next_token.id === '=') {
                 assign = next_token;
                 assign.first = name;
@@ -4055,20 +3306,20 @@ klass:              do {
                 advance('=');
                 spaces();
                 if (next_token.id === 'undefined') {
-                    warn('unnecessary_initialize', token, id);
+                    token.warn('unnecessary_initialize', id);
                 }
                 if (peek(0).id === '=' && next_token.identifier) {
-                    stop('var_a_not');
+                    next_token.stop('var_a_not');
                 }
                 assign.second = expression(0);
                 assign.arity = 'infix';
+                name.init = true;
                 this.first.push(assign);
             } else {
                 this.first.push(name);
             }
-            if (funct[id] === 'becoming') {
-                funct[id] = 'unused';
-            }
+            name.dead = false;
+            name.writeable = true;
             if (next_token.id !== ',') {
                 break;
             }
@@ -4091,32 +3342,36 @@ klass:              do {
     stmt('function', function () {
         one_space();
         if (in_block) {
-            warn('function_block', token);
+            token.warn('function_block');
         }
-        var name = next_token, id = identifier(true);
-        add_label(name, 'unction');
+        var name = next_token,
+            id = identifier(true);
+        define('var', name);
+        name.init = true;
+        name.statement = true;
         no_space();
         this.arity = 'statement';
         do_function(this, id);
         if (next_token.id === '(' && next_token.line === token.line) {
-            stop('function_statement');
+            next_token.stop('function_statement');
         }
         return this;
     });
 
     prefix('function', function (that) {
-        if (!option.anon) {
-            one_space();
-        }
-        var id = optional_identifier(true);
+        var id = optional_identifier(true), name;
         if (id) {
+            name = token;
             no_space();
         } else {
             id = '';
         }
         do_function(that, id);
-        if (funct['(loopage)']) {
-            warn('function_loop');
+        if (name) {
+            name.function = that.function;
+        }
+        if (funct.loopage) {
+            that.warn('function_loop');
         }
         switch (next_token.id) {
         case ';':
@@ -4129,11 +3384,11 @@ klass:              do {
             break;
         case '.':
             if (peek().string !== 'bind' || peek(1).id !== '(') {
-                warn('unexpected_a');
+                next_token.warn('unexpected_a');
             }
             break;
         default:
-            stop('unexpected_a');
+            next_token.stop('unexpected_a');
         }
         that.arity = 'function';
         return that;
@@ -4151,15 +3406,15 @@ klass:              do {
         no_space();
         step_out(')', paren);
         one_space();
-        this.block = block(true);
+        this.block = block('if');
         if (next_token.id === 'else') {
             one_space();
             advance('else');
             one_space();
-            this['else'] = next_token.id === 'if' || next_token.id === 'switch'
+            this.else = next_token.id === 'if' || next_token.id === 'switch'
                 ? statement(true)
-                : block(true);
-            if (this['else'].disrupt && this.block.disrupt) {
+                : block('else');
+            if (this.else.disrupt && this.block.disrupt) {
                 this.disrupt = true;
             }
         }
@@ -4173,13 +3428,10 @@ klass:              do {
 // try.third    The finally clause
 // try.block    The try block
 
-        var exception_variable, old_scope, paren;
-        if (option.adsafe) {
-            warn('adsafe_a', this);
-        }
+        var exception_variable, paren;
         one_space();
         this.arity = 'statement';
-        this.block = block(false);
+        this.block = block('try');
         if (next_token.id === 'catch') {
             one_space();
             advance('catch');
@@ -4189,29 +3441,33 @@ klass:              do {
             step_in('control');
             no_space();
             edge();
-            old_scope = scope;
-            scope = Object.create(old_scope);
-            exception_variable = next_token.string;
-            this.first = exception_variable;
-            if (!next_token.identifier) {
-                warn('expected_identifier_a', next_token);
-            } else {
-                add_label(next_token, 'exception');
-            }
-            advance();
+            exception_variable = next_token;
+            this.first = identifier();
+            define('exception', exception_variable);
+            exception_variable.init = true;
             no_space();
             step_out(')', paren);
             one_space();
-            this.second = block(false);
-            scope = old_scope;
+            this.second = block('catch');
+            if (this.second.length) {
+                if (this.first === 'ignore') {
+                    exception_variable.warn('unexpected_a');
+                }
+            } else {
+                if (this.first !== 'ignore') {
+                    exception_variable.warn('expected_a_b', 'ignore',
+                        exception_variable.string);
+                }
+            }
+            exception_variable.dead = true;
         }
         if (next_token.id === 'finally') {
             one_space();
             advance('finally');
             one_space();
-            this.third = block(false);
+            this.third = block('finally');
         } else if (!this.second) {
-            stop('expected_a_b', next_token, 'catch', artifact());
+            next_token.stop('expected_a_b', 'catch', artifact());
         }
         return this;
     });
@@ -4219,8 +3475,7 @@ klass:              do {
     labeled_stmt('while', function () {
         one_space();
         var paren = next_token;
-        funct['(breakage)'] += 1;
-        funct['(loopage)'] += 1;
+        funct.loopage += 1;
         advance('(');
         step_in('control');
         no_space();
@@ -4233,12 +3488,11 @@ klass:              do {
         no_space();
         step_out(')', paren);
         one_space();
-        this.block = block(true);
+        this.block = block('while');
         if (this.block.disrupt) {
-            warn('strange_loop', prev_token);
+            prev_token.warn('strange_loop');
         }
-        funct['(breakage)'] -= 1;
-        funct['(loopage)'] -= 1;
+        funct.loopage -= 1;
         return this;
     });
 
@@ -4255,16 +3509,16 @@ klass:              do {
         var cases = [],
             old_in_block = in_block,
             particular,
+            that = token,
             the_case = next_token,
             unbroken = true;
 
         function find_duplicate_case(value) {
             if (are_similar(particular, value)) {
-                warn('duplicate_a', value);
+                value.warn('duplicate_a');
             }
         }
 
-        funct['(breakage)'] += 1;
         one_space();
         advance('(');
         no_space();
@@ -4278,6 +3532,9 @@ klass:              do {
         step_in();
         in_block = true;
         this.second = [];
+        if (that.from !== next_token.from && !option.white) {
+            next_token.warn('expected_a_at_b_c', next_token.string, that.from, next_token.from);
+        }
         while (next_token.id === 'case') {
             the_case = next_token;
             cases.forEach(find_duplicate_case);
@@ -4293,7 +3550,7 @@ klass:              do {
                 cases.push(particular);
                 the_case.first.push(particular);
                 if (particular.id === 'NaN') {
-                    warn('unexpected_a', particular);
+                    particular.warn('unexpected_a');
                 }
                 no_space_only();
                 advance(':');
@@ -4313,15 +3570,15 @@ klass:              do {
                         unbroken = false;
                     }
                 } else {
-                    warn('missing_a_after_b', next_token, 'break', 'case');
+                    next_token.warn('missing_a_after_b', 'break', 'case');
                 }
             } else {
-                warn('empty_case');
+                next_token.warn('empty_case');
             }
             this.second.push(the_case);
         }
         if (this.second.length === 0) {
-            warn('missing_a', next_token, 'case');
+            next_token.warn('missing_a', 'case');
         }
         if (next_token.id === 'default') {
             spaces();
@@ -4341,7 +3598,6 @@ klass:              do {
             }
             this.second.push(the_case);
         }
-        funct['(breakage)'] -= 1;
         spaces();
         step_out('}', this);
         in_block = old_in_block;
@@ -4350,20 +3606,19 @@ klass:              do {
 
     stmt('debugger', function () {
         if (!option.debug) {
-            warn('unexpected_a', this);
+            this.warn('unexpected_a');
         }
         this.arity = 'statement';
         return this;
     });
 
     labeled_stmt('do', function () {
-        funct['(breakage)'] += 1;
-        funct['(loopage)'] += 1;
+        funct.loopage += 1;
         one_space();
         this.arity = 'statement';
-        this.block = block(true);
+        this.block = block('do');
         if (this.block.disrupt) {
-            warn('strange_loop', prev_token);
+            prev_token.warn('strange_loop');
         }
         one_space();
         advance('while');
@@ -4376,17 +3631,15 @@ klass:              do {
         this.first = expected_condition(expected_relation(expression(0)), bundle.unexpected_a);
         no_space();
         step_out(')', paren);
-        funct['(breakage)'] -= 1;
-        funct['(loopage)'] -= 1;
+        funct.loopage -= 1;
         return this;
     });
 
     labeled_stmt('for', function () {
 
-        var blok, filter, ok = false, paren = next_token, value;
+        var blok, filter, master, ok = false, paren = next_token, value;
         this.arity = 'statement';
-        funct['(breakage)'] += 1;
-        funct['(loopage)'] += 1;
+        funct.loopage += 1;
         advance('(');
         if (next_token.id === ';') {
             no_space();
@@ -4395,37 +3648,33 @@ klass:              do {
             advance(';');
             no_space();
             advance(')');
-            blok = block(true);
+            blok = block('for');
         } else {
             step_in('control');
             spaces(this, paren);
             no_space();
             if (next_token.id === 'var') {
-                stop('move_var');
+                next_token.stop('move_var');
             }
             edge();
             if (peek(0).id === 'in') {
                 this.forin = true;
-                value = next_token;
-                switch (funct[value.string]) {
-                case 'unused':
-                    funct[value.string] = 'var';
-                    break;
-                case 'closure':
-                case 'var':
-                    break;
-                default:
-                    warn('bad_in_a', value);
-                }
-                advance();
-                advance('in');
+                value = expression(1000);
+                master = value.master;
+                if (master.kind !== 'var' || master.function !== funct ||
+                        !master.writeable || master.dead) {
+                    value.warn('bad_in_a');
+                }
+                master.init = true;
+                master.used -= 1;
                 this.first = value;
+                advance('in');
                 this.second = expression(20);
                 step_out(')', paren);
-                blok = block(true);
+                blok = block('for');
                 if (!option.forin) {
                     if (blok.length === 1 && typeof blok[0] === 'object' &&
-                            blok[0].string === 'if' && !blok[0]['else']) {
+                            blok[0].string === 'if' && !blok[0].else) {
                         filter = blok[0].first;
                         while (filter.id === '&&') {
                             filter = filter.first;
@@ -4446,11 +3695,6 @@ klass:              do {
                                 filter.first.first.string === this.second.string &&
                                 filter.first.second.string === 'hasOwnProperty' &&
                                 filter.second[0].string === this.first.string
-                            ) || (
-                                filter.first.first.string === 'ADSAFE' &&
-                                filter.first.second.string === 'has' &&
-                                filter.second[0].string === this.second.string &&
-                                filter.second[1].string === this.first.string
                             ) || (
                                 filter.first.first.id === '.' &&
                                 filter.first.first.first.id === '.' &&
@@ -4465,7 +3709,7 @@ klass:              do {
                         }
                     }
                     if (!ok) {
-                        warn('for_if', this);
+                        this.warn('for_if');
                     }
                 }
             } else {
@@ -4486,7 +3730,7 @@ klass:              do {
                 }
                 semicolon(token);
                 if (next_token.id === ';') {
-                    stop('expected_a_b', next_token, ')', ';');
+                    next_token.stop('expected_a_b', ')', ';');
                 }
                 this.third = [];
                 edge();
@@ -4500,76 +3744,70 @@ klass:              do {
                 no_space();
                 step_out(')', paren);
                 one_space();
-                blok = block(true);
+                blok = block('for');
             }
         }
         if (blok.disrupt) {
-            warn('strange_loop', prev_token);
+            prev_token.warn('strange_loop');
         }
         this.block = blok;
-        funct['(breakage)'] -= 1;
-        funct['(loopage)'] -= 1;
+        funct.loopage -= 1;
         return this;
     });
 
-    disrupt_stmt('break', function () {
-        var label = next_token.string;
-        this.arity = 'statement';
-        if (funct['(breakage)'] === 0) {
-            warn('unexpected_a', this);
-        }
+    function optional_label(that) {
+        var label = next_token.string,
+            master;
+        that.arity = 'statement';
         if (next_token.identifier && token.line === next_token.line) {
             one_space_only();
-            if (funct[label] !== 'label') {
-                warn('not_a_label', next_token);
-            } else if (scope[label].funct !== funct) {
-                warn('not_a_scope', next_token);
+            master = scope[label];
+            if (!master || master.kind !== 'label') {
+                next_token.warn('not_a_label');
+            } else if (master.dead || master.function !== funct) {
+                next_token.warn('not_a_scope');
+            } else {
+                master.used += 1;
             }
-            this.first = next_token;
+            that.first = next_token;
             advance();
         }
-        return this;
+        return that;
+
+    }
+
+    disrupt_stmt('break', function () {
+        return optional_label(this);
     });
 
     disrupt_stmt('continue', function () {
-        if (!option['continue']) {
-            warn('unexpected_a', this);
-        }
-        var label = next_token.string;
-        this.arity = 'statement';
-        if (funct['(breakage)'] === 0) {
-            warn('unexpected_a', this);
+        if (!option.continue) {
+            this.warn('unexpected_a');
         }
-        if (next_token.identifier && token.line === next_token.line) {
-            one_space_only();
-            if (funct[label] !== 'label') {
-                warn('not_a_label', next_token);
-            } else if (scope[label].funct !== funct) {
-                warn('not_a_scope', next_token);
-            }
-            this.first = next_token;
-            advance();
-        }
-        return this;
+        return optional_label(this);
     });
 
     disrupt_stmt('return', function () {
-        if (funct === global_funct && xmode !== 'scriptstring') {
-            warn('unexpected_a', this);
+        if (funct === global_funct) {
+            this.warn('unexpected_a');
         }
         this.arity = 'statement';
         if (next_token.id !== ';' && next_token.line === token.line) {
-            one_space_only();
+            if (option.closure) {
+                spaces();
+            } else {
+                one_space_only();
+            }
             if (next_token.id === '/' || next_token.id === '(regexp)') {
-                warn('wrap_regexp');
+                next_token.warn('wrap_regexp');
             }
             this.first = expression(0);
             if (this.first.assign) {
-                warn('unexpected_a', this.first);
+                this.first.warn('unexpected_a');
             }
         }
         if (peek(0).id === '}' && peek(1).id === 'else') {
-            warn('unexpected_else', this);
+            this.warn('unexpected_else');
         }
         return this;
     });
@@ -4610,21 +3848,21 @@ klass:              do {
     function json_value() {
 
         function json_object() {
-            var brace = next_token, object = {};
+            var brace = next_token, object = Object.create(null);
             advance('{');
             if (next_token.id !== '}') {
                 while (next_token.id !== '(end)') {
                     while (next_token.id === ',') {
-                        warn('unexpected_a', next_token);
+                        next_token.warn('unexpected_a');
                         advance(',');
                     }
                     if (next_token.id !== '(string)') {
-                        warn('expected_string_a');
+                        next_token.warn('expected_string_a');
                     }
                     if (object[next_token.string] === true) {
-                        warn('duplicate_a');
+                        next_token.warn('duplicate_a');
                     } else if (next_token.string === '__proto__') {
-                        warn('dangling_a');
+                        next_token.warn('dangling_a');
                     } else {
                         object[next_token.string] = true;
                     }
@@ -4636,7 +3874,7 @@ klass:              do {
                     }
                     advance(',');
                     if (next_token.id === '}') {
-                        warn('unexpected_a', token);
+                        token.warn('unexpected_a');
                         break;
                     }
                 }
@@ -4650,7 +3888,7 @@ klass:              do {
             if (next_token.id !== ']') {
                 while (next_token.id !== '(end)') {
                     while (next_token.id === ',') {
-                        warn('unexpected_a', next_token);
+                        next_token.warn('unexpected_a');
                         advance(',');
                     }
                     json_value();
@@ -4659,7 +3897,7 @@ klass:              do {
                     }
                     advance(',');
                     if (next_token.id === ']') {
-                        warn('unexpected_a', token);
+                        token.warn('unexpected_a');
                         break;
                     }
                 }
@@ -4687,1508 +3925,93 @@ klass:              do {
             advance('(number)');
             break;
         default:
-            stop('unexpected_a');
+            next_token.stop('unexpected_a');
         }
     }
 
 
-// CSS parsing.
-
-    function css_name() {
-        if (next_token.identifier) {
-            advance();
-            return true;
-        }
-    }
+// The actual JSLINT function itself.
 
+    itself = function JSLint(the_source, the_option) {
 
-    function css_number() {
-        if (next_token.id === '-') {
-            advance('-');
-            no_space_only();
-        }
-        if (next_token.id === '(number)') {
-            advance('(number)');
-            return true;
+        var i, predef, tree;
+        itself.errors = [];
+        itself.tree = '';
+        itself.properties = '';
+        begin = prev_token = token = next_token =
+            Object.create(syntax['(begin)']);
+        tokens = [];
+        predefined = Object.create(null);
+        add_to_predefined(standard);
+        property = Object.create(null);
+        if (the_option) {
+            option = Object.create(the_option);
+            predef = option.predef;
+            if (predef) {
+                if (Array.isArray(predef)) {
+                    for (i = 0; i < predef.length; i += 1) {
+                        predefined[predef[i]] = true;
+                    }
+                } else if (typeof predef === 'object') {
+                    add_to_predefined(predef);
+                }
+            }
+        } else {
+            option = Object.create(null);
         }
-    }
+        option.indent = +option.indent || 4;
+        option.maxerr = +option.maxerr || 50;
+        global_scope = scope = Object.create(null);
+        global_funct = funct = {
+            scope: scope,
+            loopage: 0,
+            level: 0
+        };
+        functions = [funct];
+        block_var = [];
 
+        comments = [];
+        comments_off = false;
+        in_block = false;
+        indent = null;
+        json_mode = false;
+        lookahead = [];
+        node_js = false;
+        prereg = true;
+        strict_mode = false;
+        var_mode = null;
+        warnings = 0;
+        lex.init(the_source);
+
+        assume();
 
-    function css_string() {
-        if (next_token.id === '(string)') {
+        try {
             advance();
-            return true;
-        }
-    }
+            if (next_token.id === '(number)') {
+                next_token.stop('unexpected_a');
+            } else {
+                switch (next_token.id) {
+                case '{':
+                case '[':
+                    comments_off = true;
+                    json_mode = true;
+                    json_value();
+                    break;
+                default:
 
-    function css_color() {
-        var i, number, paren, value;
-        if (next_token.identifier) {
-            value = next_token.string;
-            if (value === 'rgb' || value === 'rgba') {
-                advance();
-                paren = next_token;
-                advance('(');
-                for (i = 0; i < 3; i += 1) {
-                    if (i) {
-                        comma();
+// If the first token is a semicolon, ignore it. This is sometimes used when
+// files are intended to be appended to files that may be sloppy. A sloppy
+// file may be depending on semicolon insertion on its last line.
+
+                    step_in(1);
+                    if (next_token.id === ';' && !node_js) {
+                        semicolon();
                     }
-                    number = next_token.number;
-                    if (next_token.id !== '(number)' || number < 0) {
-                        warn('expected_positive_a', next_token);
-                        advance();
-                    } else {
-                        advance();
-                        if (next_token.id === '%') {
-                            advance('%');
-                            if (number > 100) {
-                                warn('expected_percent_a', token, number);
-                            }
-                        } else {
-                            if (number > 255) {
-                                warn('expected_small_a', token, number);
-                            }
-                        }
-                    }
-                }
-                if (value === 'rgba') {
-                    comma();
-                    number = next_token.number;
-                    if (next_token.id !== '(number)' || number < 0 || number > 1) {
-                        warn('expected_fraction_a', next_token);
-                    }
-                    advance();
-                    if (next_token.id === '%') {
-                        warn('unexpected_a');
-                        advance('%');
-                    }
-                }
-                advance(')', paren);
-                return true;
-            }
-            if (css_colorData[next_token.string] === true) {
-                advance();
-                return true;
-            }
-        } else if (next_token.id === '(color)') {
-            advance();
-            return true;
-        }
-        return false;
-    }
-
-
-    function css_length() {
-        if (next_token.id === '-') {
-            advance('-');
-            no_space_only();
-        }
-        if (next_token.id === '(number)') {
-            advance();
-            if (next_token.id !== '(string)' &&
-                    css_lengthData[next_token.string] === true) {
-                no_space_only();
-                advance();
-            } else if (+token.number !== 0) {
-                warn('expected_linear_a');
-            }
-            return true;
-        }
-        return false;
-    }
-
-
-    function css_line_height() {
-        if (next_token.id === '-') {
-            advance('-');
-            no_space_only();
-        }
-        if (next_token.id === '(number)') {
-            advance();
-            if (next_token.id !== '(string)' &&
-                    css_lengthData[next_token.string] === true) {
-                no_space_only();
-                advance();
-            }
-            return true;
-        }
-        return false;
-    }
-
-
-    function css_width() {
-        if (next_token.identifier) {
-            switch (next_token.string) {
-            case 'thin':
-            case 'medium':
-            case 'thick':
-                advance();
-                return true;
-            }
-        } else {
-            return css_length();
-        }
-    }
-
-
-    function css_margin() {
-        if (next_token.identifier) {
-            if (next_token.string === 'auto') {
-                advance();
-                return true;
-            }
-        } else {
-            return css_length();
-        }
-    }
-
-    function css_attr() {
-        if (next_token.identifier && next_token.string === 'attr') {
-            advance();
-            advance('(');
-            if (!next_token.identifier) {
-                warn('expected_name_a');
-            }
-            advance();
-            advance(')');
-            return true;
-        }
-        return false;
-    }
-
-
-    function css_comma_list() {
-        while (next_token.id !== ';') {
-            if (!css_name() && !css_string()) {
-                warn('expected_name_a');
-            }
-            if (next_token.id !== ',') {
-                return true;
-            }
-            comma();
-        }
-    }
-
-
-    function css_counter() {
-        if (next_token.identifier && next_token.string === 'counter') {
-            advance();
-            advance('(');
-            advance();
-            if (next_token.id === ',') {
-                comma();
-                if (next_token.id !== '(string)') {
-                    warn('expected_string_a');
-                }
-                advance();
-            }
-            advance(')');
-            return true;
-        }
-        if (next_token.identifier && next_token.string === 'counters') {
-            advance();
-            advance('(');
-            if (!next_token.identifier) {
-                warn('expected_name_a');
-            }
-            advance();
-            if (next_token.id === ',') {
-                comma();
-                if (next_token.id !== '(string)') {
-                    warn('expected_string_a');
-                }
-                advance();
-            }
-            if (next_token.id === ',') {
-                comma();
-                if (next_token.id !== '(string)') {
-                    warn('expected_string_a');
-                }
-                advance();
-            }
-            advance(')');
-            return true;
-        }
-        return false;
-    }
-
-
-    function css_radius() {
-        return css_length() && (next_token.id !== '(number)' || css_length());
-    }
-
-
-    function css_shadow() {
-        for (;;) {
-            if (next_token.string === 'inset') {
-                advance();
-            }
-            for (;;) {
-                if (!css_length()) {
-                    break;
-                }
-            }
-            css_color();
-            if (next_token.id !== ',') {
-                break;
-            }
-            advance(',');
-        }
-        return true;
-    }
-
-
-    function css_shape() {
-        var i;
-        if (next_token.identifier && next_token.string === 'rect') {
-            advance();
-            advance('(');
-            for (i = 0; i < 4; i += 1) {
-                if (!css_length()) {
-                    warn('expected_number_a');
-                    break;
-                }
-            }
-            advance(')');
-            return true;
-        }
-        return false;
-    }
-
-
-    function css_url() {
-        var c, url;
-        if (next_token.identifier && next_token.string === 'url') {
-            next_token = lex.range('(', ')');
-            url = next_token.string;
-            c = url.charAt(0);
-            if (c === '"' || c === '\'') {
-                if (url.slice(-1) !== c) {
-                    warn('bad_url_a');
-                } else {
-                    url = url.slice(1, -1);
-                    if (url.indexOf(c) >= 0) {
-                        warn('bad_url_a');
-                    }
-                }
-            }
-            if (!url) {
-                warn('missing_url');
-            }
-            if (ux.test(url)) {
-                stop('bad_url_a');
-            }
-            urls.push(url);
-            advance();
-            return true;
-        }
-        return false;
-    }
-
-
-    css_any = [css_url, function () {
-        for (;;) {
-            if (next_token.identifier) {
-                switch (next_token.string.toLowerCase()) {
-                case 'url':
-                    css_url();
-                    break;
-                case 'expression':
-                    warn('unexpected_a');
-                    advance();
-                    break;
-                default:
-                    advance();
-                }
-            } else {
-                if (next_token.id === ';' || next_token.id === '!'  ||
-                        next_token.id === '(end)' || next_token.id === '}') {
-                    return true;
-                }
-                advance();
-            }
-        }
-    }];
-
-
-    function font_face() {
-        advance_identifier('font-family');
-        advance(':');
-        if (!css_name() && !css_string()) {
-            stop('expected_name_a');
-        }
-        semicolon();
-        advance_identifier('src');
-        advance(':');
-        while (true) {
-            if (next_token.string === 'local') {
-                advance_identifier('local');
-                advance('(');
-                if (ux.test(next_token.string)) {
-                    stop('bad_url_a');
-                }
-
-                if (!css_name() && !css_string()) {
-                    stop('expected_name_a');
-                }
-                advance(')');
-            } else if (!css_url()) {
-                stop('expected_a_b', next_token, 'url', artifact());
-            }
-            if (next_token.id !== ',') {
-                break;
-            }
-            comma();
-        }
-        semicolon();
-    }
-
-
-    css_border_style = [
-        'none', 'dashed', 'dotted', 'double', 'groove',
-        'hidden', 'inset', 'outset', 'ridge', 'solid'
-    ];
-
-    css_break = [
-        'auto', 'always', 'avoid', 'left', 'right'
-    ];
-
-    css_media = {
-        'all': true,
-        'braille': true,
-        'embossed': true,
-        'handheld': true,
-        'print': true,
-        'projection': true,
-        'screen': true,
-        'speech': true,
-        'tty': true,
-        'tv': true
-    };
-
-    css_overflow = [
-        'auto', 'hidden', 'scroll', 'visible'
-    ];
-
-    css_attribute_data = {
-        background: [
-            true, 'background-attachment', 'background-color',
-            'background-image', 'background-position', 'background-repeat'
-        ],
-        'background-attachment': ['scroll', 'fixed'],
-        'background-color': ['transparent', css_color],
-        'background-image': ['none', css_url],
-        'background-position': [
-            2, [css_length, 'top', 'bottom', 'left', 'right', 'center']
-        ],
-        'background-repeat': [
-            'repeat', 'repeat-x', 'repeat-y', 'no-repeat'
-        ],
-        'border': [true, 'border-color', 'border-style', 'border-width'],
-        'border-bottom': [
-            true, 'border-bottom-color', 'border-bottom-style',
-            'border-bottom-width'
-        ],
-        'border-bottom-color': css_color,
-        'border-bottom-left-radius': css_radius,
-        'border-bottom-right-radius': css_radius,
-        'border-bottom-style': css_border_style,
-        'border-bottom-width': css_width,
-        'border-collapse': ['collapse', 'separate'],
-        'border-color': ['transparent', 4, css_color],
-        'border-left': [
-            true, 'border-left-color', 'border-left-style', 'border-left-width'
-        ],
-        'border-left-color': css_color,
-        'border-left-style': css_border_style,
-        'border-left-width': css_width,
-        'border-radius': function () {
-            function count(separator) {
-                var n = 1;
-                if (separator) {
-                    advance(separator);
-                }
-                if (!css_length()) {
-                    return false;
-                }
-                while (next_token.id === '(number)') {
-                    if (!css_length()) {
-                        return false;
-                    }
-                    n += 1;
-                }
-                if (n > 4) {
-                    warn('bad_style');
-                }
-                return true;
-            }
-
-            return count() && (next_token.id !== '/' || count('/'));
-        },
-        'border-right': [
-            true, 'border-right-color', 'border-right-style',
-            'border-right-width'
-        ],
-        'border-right-color': css_color,
-        'border-right-style': css_border_style,
-        'border-right-width': css_width,
-        'border-spacing': [2, css_length],
-        'border-style': [4, css_border_style],
-        'border-top': [
-            true, 'border-top-color', 'border-top-style', 'border-top-width'
-        ],
-        'border-top-color': css_color,
-        'border-top-left-radius': css_radius,
-        'border-top-right-radius': css_radius,
-        'border-top-style': css_border_style,
-        'border-top-width': css_width,
-        'border-width': [4, css_width],
-        bottom: [css_length, 'auto'],
-        'box-shadow': ['none', css_shadow],
-        'caption-side' : ['bottom', 'left', 'right', 'top'],
-        clear: ['both', 'left', 'none', 'right'],
-        clip: [css_shape, 'auto'],
-        color: css_color,
-        content: [
-            'open-quote', 'close-quote', 'no-open-quote', 'no-close-quote',
-            css_string, css_url, css_counter, css_attr
-        ],
-        'counter-increment': [
-            css_name, 'none'
-        ],
-        'counter-reset': [
-            css_name, 'none'
-        ],
-        cursor: [
-            css_url, 'auto', 'crosshair', 'default', 'e-resize', 'help', 'move',
-            'n-resize', 'ne-resize', 'nw-resize', 'pointer', 's-resize',
-            'se-resize', 'sw-resize', 'w-resize', 'text', 'wait'
-        ],
-        direction: ['ltr', 'rtl'],
-        display: [
-            'block', 'compact', 'inline', 'inline-block', 'inline-table',
-            'list-item', 'marker', 'none', 'run-in', 'table', 'table-caption',
-            'table-cell', 'table-column', 'table-column-group',
-            'table-footer-group', 'table-header-group', 'table-row',
-            'table-row-group'
-        ],
-        'empty-cells': ['show', 'hide'],
-        'float': ['left', 'none', 'right'],
-        font: [
-            'caption', 'icon', 'menu', 'message-box', 'small-caption',
-            'status-bar', true, 'font-size', 'font-style', 'font-weight',
-            'font-family'
-        ],
-        'font-family': css_comma_list,
-        'font-size': [
-            'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large',
-            'xx-large', 'larger', 'smaller', css_length
-        ],
-        'font-size-adjust': ['none', css_number],
-        'font-stretch': [
-            'normal', 'wider', 'narrower', 'ultra-condensed',
-            'extra-condensed', 'condensed', 'semi-condensed',
-            'semi-expanded', 'expanded', 'extra-expanded'
-        ],
-        'font-style': [
-            'normal', 'italic', 'oblique'
-        ],
-        'font-variant': [
-            'normal', 'small-caps'
-        ],
-        'font-weight': [
-            'normal', 'bold', 'bolder', 'lighter', css_number
-        ],
-        height: [css_length, 'auto'],
-        left: [css_length, 'auto'],
-        'letter-spacing': ['normal', css_length],
-        'line-height': ['normal', css_line_height],
-        'list-style': [
-            true, 'list-style-image', 'list-style-position', 'list-style-type'
-        ],
-        'list-style-image': ['none', css_url],
-        'list-style-position': ['inside', 'outside'],
-        'list-style-type': [
-            'circle', 'disc', 'square', 'decimal', 'decimal-leading-zero',
-            'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha',
-            'lower-latin', 'upper-alpha', 'upper-latin', 'hebrew', 'katakana',
-            'hiragana-iroha', 'katakana-oroha', 'none'
-        ],
-        margin: [4, css_margin],
-        'margin-bottom': css_margin,
-        'margin-left': css_margin,
-        'margin-right': css_margin,
-        'margin-top': css_margin,
-        'marker-offset': [css_length, 'auto'],
-        'max-height': [css_length, 'none'],
-        'max-width': [css_length, 'none'],
-        'min-height': css_length,
-        'min-width': css_length,
-        opacity: css_number,
-        outline: [true, 'outline-color', 'outline-style', 'outline-width'],
-        'outline-color': ['invert', css_color],
-        'outline-style': [
-            'dashed', 'dotted', 'double', 'groove', 'inset', 'none',
-            'outset', 'ridge', 'solid'
-        ],
-        'outline-width': css_width,
-        overflow: css_overflow,
-        'overflow-x': css_overflow,
-        'overflow-y': css_overflow,
-        padding: [4, css_length],
-        'padding-bottom': css_length,
-        'padding-left': css_length,
-        'padding-right': css_length,
-        'padding-top': css_length,
-        'page-break-after': css_break,
-        'page-break-before': css_break,
-        position: ['absolute', 'fixed', 'relative', 'static'],
-        quotes: [8, css_string],
-        right: [css_length, 'auto'],
-        'table-layout': ['auto', 'fixed'],
-        'text-align': ['center', 'justify', 'left', 'right'],
-        'text-decoration': [
-            'none', 'underline', 'overline', 'line-through', 'blink'
-        ],
-        'text-indent': css_length,
-        'text-shadow': ['none', 4, [css_color, css_length]],
-        'text-transform': ['capitalize', 'uppercase', 'lowercase', 'none'],
-        top: [css_length, 'auto'],
-        'unicode-bidi': ['normal', 'embed', 'bidi-override'],
-        'vertical-align': [
-            'baseline', 'bottom', 'sub', 'super', 'top', 'text-top', 'middle',
-            'text-bottom', css_length
-        ],
-        visibility: ['visible', 'hidden', 'collapse'],
-        'white-space': [
-            'normal', 'nowrap', 'pre', 'pre-line', 'pre-wrap', 'inherit'
-        ],
-        width: [css_length, 'auto'],
-        'word-spacing': ['normal', css_length],
-        'word-wrap': ['break-word', 'normal'],
-        'z-index': ['auto', css_number]
-    };
-
-    function style_attribute() {
-        var v;
-        while (next_token.id === '*' || next_token.id === '#' ||
-                next_token.string === '_') {
-            if (!option.css) {
-                warn('unexpected_a');
-            }
-            advance();
-        }
-        if (next_token.id === '-') {
-            if (!option.css) {
-                warn('unexpected_a');
-            }
-            advance('-');
-            if (!next_token.identifier) {
-                warn('expected_nonstandard_style_attribute');
-            }
-            advance();
-            return css_any;
-        }
-        if (!next_token.identifier) {
-            warn('expected_style_attribute');
-        } else {
-            if (Object.prototype.hasOwnProperty.call(css_attribute_data,
-                    next_token.string)) {
-                v = css_attribute_data[next_token.string];
-            } else {
-                v = css_any;
-                if (!option.css) {
-                    warn('unrecognized_style_attribute_a');
-                }
-            }
-        }
-        advance();
-        return v;
-    }
-
-
-    function style_value(v) {
-        var i = 0,
-            n,
-            once,
-            match,
-            round,
-            start = 0,
-            vi;
-        switch (typeof v) {
-        case 'function':
-            return v();
-        case 'string':
-            if (next_token.identifier && next_token.string === v) {
-                advance();
-                return true;
-            }
-            return false;
-        }
-        for (;;) {
-            if (i >= v.length) {
-                return false;
-            }
-            vi = v[i];
-            i += 1;
-            if (typeof vi === 'boolean') {
-                break;
-            } else if (typeof vi === 'number') {
-                n = vi;
-                vi = v[i];
-                i += 1;
-            } else {
-                n = 1;
-            }
-            match = false;
-            while (n > 0) {
-                if (style_value(vi)) {
-                    match = true;
-                    n -= 1;
-                } else {
-                    break;
-                }
-            }
-            if (match) {
-                return true;
-            }
-        }
-        start = i;
-        once = [];
-        for (;;) {
-            round = false;
-            for (i = start; i < v.length; i += 1) {
-                if (!once[i]) {
-                    if (style_value(css_attribute_data[v[i]])) {
-                        match = true;
-                        round = true;
-                        once[i] = true;
-                        break;
-                    }
-                }
-            }
-            if (!round) {
-                return match;
-            }
-        }
-    }
-
-    function style_child() {
-        if (next_token.id === '(number)') {
-            advance();
-            if (next_token.string === 'n' && next_token.identifier) {
-                no_space_only();
-                advance();
-                if (next_token.id === '+') {
-                    no_space_only();
-                    advance('+');
-                    no_space_only();
-                    advance('(number)');
-                }
-            }
-            return;
-        }
-        if (next_token.identifier &&
-                (next_token.string === 'odd' || next_token.string === 'even')) {
-            advance();
-            return;
-        }
-        warn('unexpected_a');
-    }
-
-    function substyle() {
-        var v;
-        for (;;) {
-            if (next_token.id === '}' || next_token.id === '(end)' ||
-                    (xquote && next_token.id === xquote)) {
-                return;
-            }
-            v = style_attribute();
-            advance(':');
-            if (next_token.identifier && next_token.string === 'inherit') {
-                advance();
-            } else {
-                if (!style_value(v)) {
-                    warn('unexpected_a');
-                    advance();
-                }
-            }
-            if (next_token.id === '!') {
-                advance('!');
-                no_space_only();
-                if (next_token.identifier && next_token.string === 'important') {
-                    advance();
-                } else {
-                    warn('expected_a_b',
-                        next_token, 'important', artifact());
-                }
-            }
-            if (next_token.id === '}' || next_token.id === xquote) {
-                warn('expected_a_b', next_token, ';', artifact());
-            } else {
-                semicolon();
-            }
-        }
-    }
-
-    function style_selector() {
-        if (next_token.identifier) {
-            if (!Object.prototype.hasOwnProperty.call(html_tag,
-                    next_token.string)) {
-                warn('expected_tagname_a');
-            }
-            advance();
-        } else {
-            switch (next_token.id) {
-            case '>':
-            case '+':
-                advance();
-                style_selector();
-                break;
-            case ':':
-                advance(':');
-                switch (next_token.string) {
-                case 'active':
-                case 'after':
-                case 'before':
-                case 'checked':
-                case 'disabled':
-                case 'empty':
-                case 'enabled':
-                case 'first-child':
-                case 'first-letter':
-                case 'first-line':
-                case 'first-of-type':
-                case 'focus':
-                case 'hover':
-                case 'last-child':
-                case 'last-of-type':
-                case 'link':
-                case 'only-of-type':
-                case 'root':
-                case 'target':
-                case 'visited':
-                    advance_identifier(next_token.string);
-                    break;
-                case 'lang':
-                    advance_identifier('lang');
-                    advance('(');
-                    if (!next_token.identifier) {
-                        warn('expected_lang_a');
-                    }
-                    advance(')');
-                    break;
-                case 'nth-child':
-                case 'nth-last-child':
-                case 'nth-last-of-type':
-                case 'nth-of-type':
-                    advance_identifier(next_token.string);
-                    advance('(');
-                    style_child();
-                    advance(')');
-                    break;
-                case 'not':
-                    advance_identifier('not');
-                    advance('(');
-                    if (next_token.id === ':' && peek(0).string === 'not') {
-                        warn('not');
-                    }
-                    style_selector();
-                    advance(')');
-                    break;
-                default:
-                    warn('expected_pseudo_a');
-                }
-                break;
-            case '#':
-                advance('#');
-                if (!next_token.identifier) {
-                    warn('expected_id_a');
-                }
-                advance();
-                break;
-            case '*':
-                advance('*');
-                break;
-            case '.':
-                advance('.');
-                if (!next_token.identifier) {
-                    warn('expected_class_a');
-                }
-                advance();
-                break;
-            case '[':
-                advance('[');
-                if (!next_token.identifier) {
-                    warn('expected_attribute_a');
-                }
-                advance();
-                if (next_token.id === '=' || next_token.string === '~=' ||
-                        next_token.string === '$=' ||
-                        next_token.string === '|=' ||
-                        next_token.id === '*=' ||
-                        next_token.id === '^=') {
-                    advance();
-                    if (next_token.id !== '(string)') {
-                        warn('expected_string_a');
-                    }
-                    advance();
-                }
-                advance(']');
-                break;
-            default:
-                stop('expected_selector_a');
-            }
-        }
-    }
-
-    function style_pattern() {
-        if (next_token.id === '{') {
-            warn('expected_style_pattern');
-        }
-        for (;;) {
-            style_selector();
-            if (next_token.id === '</' || next_token.id === '{' ||
-                    next_token.id === '}' || next_token.id === '(end)') {
-                return '';
-            }
-            if (next_token.id === ',') {
-                comma();
-            }
-        }
-    }
-
-    function style_list() {
-        while (next_token.id !== '}' && next_token.id !== '</' &&
-                next_token.id !== '(end)') {
-            style_pattern();
-            xmode = 'styleproperty';
-            if (next_token.id === ';') {
-                semicolon();
-            } else {
-                advance('{');
-                substyle();
-                xmode = 'style';
-                advance('}');
-            }
-        }
-    }
-
-    function styles() {
-        var i;
-        while (next_token.id === '@') {
-            i = peek();
-            advance('@');
-            switch (next_token.string) {
-            case 'import':
-                advance_identifier('import');
-                if (!css_url()) {
-                    warn('expected_a_b',
-                        next_token, 'url', artifact());
-                    advance();
-                }
-                semicolon();
-                break;
-            case 'media':
-                advance_identifier('media');
-                for (;;) {
-                    if (!next_token.identifier || css_media[next_token.string] !== true) {
-                        stop('expected_media_a');
-                    }
-                    advance();
-                    if (next_token.id !== ',') {
-                        break;
-                    }
-                    comma();
-                }
-                advance('{');
-                style_list();
-                advance('}');
-                break;
-            case 'font-face':
-                advance_identifier('font-face');
-                advance('{');
-                font_face();
-                advance('}');
-                break;
-            default:
-                stop('expected_at_a');
-            }
-        }
-        style_list();
-    }
-
-
-// Parse HTML
-
-    function do_begin(n) {
-        if (n !== 'html' && !option.fragment) {
-            if (n === 'div' && option.adsafe) {
-                stop('adsafe_fragment');
-            } else {
-                stop('expected_a_b', token, 'html', n);
-            }
-        }
-        if (option.adsafe) {
-            if (n === 'html') {
-                stop('adsafe_html', token);
-            }
-            if (option.fragment) {
-                if (n !== 'div') {
-                    stop('adsafe_div', token);
-                }
-            } else {
-                stop('adsafe_fragment', token);
-            }
-        }
-        option.browser = true;
-    }
-
-    function do_attribute(a, v) {
-        var u, x;
-        if (a === 'id') {
-            u = typeof v === 'string' ? v.toUpperCase() : '';
-            if (ids[u] === true) {
-                warn('duplicate_a', next_token, v);
-            }
-            if (!/^[A-Za-z][A-Za-z0-9._:\-]*$/.test(v)) {
-                warn('bad_id_a', next_token, v);
-            } else if (option.adsafe) {
-                if (adsafe_id) {
-                    if (v.slice(0, adsafe_id.length) !== adsafe_id) {
-                        warn('adsafe_prefix_a', next_token, adsafe_id);
-                    } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) {
-                        warn('adsafe_bad_id');
-                    }
-                } else {
-                    adsafe_id = v;
-                    if (!/^[A-Z]+_$/.test(v)) {
-                        warn('adsafe_bad_id');
-                    }
-                }
-            }
-            x = v.search(dx);
-            if (x >= 0) {
-                warn('unexpected_char_a_b', token, v.charAt(x), a);
-            }
-            ids[u] = true;
-        } else if (a === 'class' || a === 'type' || a === 'name') {
-            x = v.search(qx);
-            if (x >= 0) {
-                warn('unexpected_char_a_b', token, v.charAt(x), a);
-            }
-            ids[u] = true;
-        } else if (a === 'href' || a === 'background' ||
-                a === 'content' || a === 'data' ||
-                a.indexOf('src') >= 0 || a.indexOf('url') >= 0) {
-            if (option.safe && ux.test(v)) {
-                stop('bad_url_a', next_token, v);
-            }
-            urls.push(v);
-        } else if (a === 'for') {
-            if (option.adsafe) {
-                if (adsafe_id) {
-                    if (v.slice(0, adsafe_id.length) !== adsafe_id) {
-                        warn('adsafe_prefix_a', next_token, adsafe_id);
-                    } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) {
-                        warn('adsafe_bad_id');
-                    }
-                } else {
-                    warn('adsafe_bad_id');
-                }
-            }
-        } else if (a === 'name') {
-            if (option.adsafe && v.indexOf('_') >= 0) {
-                warn('adsafe_name_a', next_token, v);
-            }
-        }
-    }
-
-    function do_tag(tag, name, attribute) {
-        var i, script, x;
-        src = false;
-        if (stack.length > 0) {
-            if (name === 'html') {
-                stop('unexpected_a', token, name);
-            }
-            x = tag.parent;
-            if (x) {
-                if (x.indexOf(' ' + stack[stack.length - 1].name + ' ') < 0) {
-                    stop('tag_a_in_b', token, name, x);
-                }
-            } else if (x !== false && !option.adsafe && !option.fragment) {
-                i = stack.length;
-                do {
-                    if (i <= 0) {
-                        stop('tag_a_in_b', token, name, 'body');
-                    }
-                    i -= 1;
-                } while (stack[i].name !== 'body');
-            }
-        }
-        switch (name) {
-        case 'div':
-            if (option.adsafe && stack.length === 1 && !adsafe_id) {
-                warn('adsafe_missing_id');
-            }
-            break;
-        case 'script':
-            xmode = 'script';
-            advance('>');
-            if (attribute.lang) {
-                warn('lang', token);
-            }
-            if (option.adsafe && stack.length !== 1) {
-                warn('adsafe_placement', token);
-            }
-            if (attribute.src) {
-                if (option.adsafe && (!adsafe_may || !approved[attribute.src])) {
-                    warn('adsafe_source', token);
-                }
-            } else {
-                step_in(next_token.from);
-                edge();
-                use_strict();
-                adsafe_top = true;
-                script = statements();
-
-// JSLint is also the static analyzer for ADsafe. See www.ADsafe.org.
-
-                if (option.adsafe) {
-                    if (adsafe_went) {
-                        stop('adsafe_script', token);
-                    }
-                    if (script.length !== 1 ||
-                            aint(script[0],             'id',     '(') ||
-                            aint(script[0].first,       'id',     '.') ||
-                            aint(script[0].first.first, 'string', 'ADSAFE') ||
-                            aint(script[0].second[0],   'string', adsafe_id)) {
-                        stop('adsafe_id_go');
-                    }
-                    switch (script[0].first.second.string) {
-                    case 'id':
-                        if (adsafe_may || adsafe_went ||
-                                script[0].second.length !== 1) {
-                            stop('adsafe_id', next_token);
-                        }
-                        adsafe_may = true;
-                        break;
-                    case 'go':
-                        if (adsafe_went) {
-                            stop('adsafe_go');
-                        }
-                        if (script[0].second.length !== 2 ||
-                                aint(script[0].second[1], 'id', 'function') ||
-                                !script[0].second[1].first ||
-                                aint(script[0].second[1].first[0], 'string', 'dom') ||
-                                script[0].second[1].first.length > 2 ||
-                                (script[0].second[1].first.length === 2 &&
-                                aint(script[0].second[1].first[1], 'string', 'lib'))) {
-                            stop('adsafe_go', next_token);
-                        }
-                        adsafe_went = true;
-                        break;
-                    default:
-                        stop('adsafe_id_go');
-                    }
-                }
-                indent = null;
-            }
-            xmode = 'html';
-            advance('</');
-            advance_identifier('script');
-            xmode = 'outer';
-            break;
-        case 'style':
-            xmode = 'style';
-            advance('>');
-            styles();
-            xmode = 'html';
-            advance('</');
-            advance_identifier('style');
-            break;
-        case 'input':
-            switch (attribute.type) {
-            case 'button':
-            case 'checkbox':
-            case 'radio':
-            case 'reset':
-            case 'submit':
-                break;
-            case 'file':
-            case 'hidden':
-            case 'image':
-            case 'password':
-            case 'text':
-                if (option.adsafe && attribute.autocomplete !== 'off') {
-                    warn('adsafe_autocomplete');
-                }
-                break;
-            default:
-                warn('bad_type');
-            }
-            break;
-        case 'applet':
-        case 'body':
-        case 'embed':
-        case 'frame':
-        case 'frameset':
-        case 'head':
-        case 'iframe':
-        case 'noembed':
-        case 'noframes':
-        case 'object':
-        case 'param':
-            if (option.adsafe) {
-                warn('adsafe_tag', next_token, name);
-            }
-            break;
-        }
-    }
-
-
-    function closetag(name) {
-        return '</' + name + '>';
-    }
-
-    function html() {
-        var attribute, attributes, is_empty, name, old_white = option.white,
-            quote, tag_name, tag, value, wmode;
-        xmode = 'html';
-        xquote = '';
-        stack = null;
-        for (;;) {
-            switch (next_token.string) {
-            case '<':
-                xmode = 'html';
-                advance('<');
-                attributes = {};
-                tag_name = next_token;
-                name = tag_name.string;
-                advance_identifier(name);
-                tag_name.name = name;
-                if (!stack) {
-                    stack = [];
-                    do_begin(name);
-                }
-                tag = html_tag[name];
-                if (typeof tag !== 'object') {
-                    tag = {parent: false};
-                    warn('unrecognized_tag_a', tag_name, name === name.toLowerCase()
-                        ? name
-                        : name + ' (capitalization error)');
-                } else {
-                    is_empty = tag.empty;
-                }
-                tag_name.type = name;
-                for (;;) {
-                    if (next_token.id === '/') {
-                        advance('/');
-                        if (next_token.id !== '>') {
-                            warn('expected_a_b', next_token, '>', artifact());
-                        }
-                        break;
-                    }
-                    if (next_token.id && next_token.id.charAt(0) === '>') {
-                        break;
-                    }
-                    if (!next_token.identifier) {
-                        if (next_token.id === '(end)' || next_token.id === '(error)') {
-                            warn('expected_a_b', next_token, '>', artifact());
-                        }
-                        warn('bad_name_a');
-                    }
-                    option.white = false;
-                    spaces();
-                    attribute = next_token.string;
-                    option.white = old_white;
-                    advance();
-                    if (attribute !== attribute.toLowerCase()) {
-                        warn('attribute_case_a', token);
-                    }
-                    attribute = attribute.toLowerCase();
-                    xquote = '';
-                    if (Object.prototype.hasOwnProperty.call(attributes, attribute)) {
-                        warn('duplicate_a', token, attribute);
-                    }
-                    if (attribute.slice(0, 2) === 'on') {
-                        if (!option.on) {
-                            warn('html_handlers');
-                        }
-                        xmode = 'scriptstring';
-                        advance('=');
-                        quote = next_token.id;
-                        if (quote !== '"' && quote !== '\'') {
-                            stop('expected_a_b', next_token, '"', artifact());
-                        }
-                        xquote = quote;
-                        wmode = option.white;
-                        option.white = true;
-                        advance(quote);
-                        use_strict();
-                        statements();
-                        option.white = wmode;
-                        if (next_token.id !== quote) {
-                            stop('expected_a_b', next_token, quote, artifact());
-                        }
-                        xmode = 'html';
-                        xquote = '';
-                        advance(quote);
-                        value = false;
-                    } else if (attribute === 'style') {
-                        xmode = 'scriptstring';
-                        advance('=');
-                        quote = next_token.id;
-                        if (quote !== '"' && quote !== '\'') {
-                            stop('expected_a_b', next_token, '"', artifact());
-                        }
-                        xmode = 'styleproperty';
-                        xquote = quote;
-                        advance(quote);
-                        substyle();
-                        xmode = 'html';
-                        xquote = '';
-                        advance(quote);
-                        value = false;
-                    } else {
-                        if (next_token.id === '=') {
-                            advance('=');
-                            value = next_token.string;
-                            if (!next_token.identifier &&
-                                    next_token.id !== '"' &&
-                                    next_token.id !== '\'' &&
-                                    next_token.id !== '(string)' &&
-                                    next_token.id !== '(number)' &&
-                                    next_token.id !== '(color)') {
-                                warn('expected_attribute_value_a', token, attribute);
-                            }
-                            advance();
-                        } else {
-                            value = true;
-                        }
-                    }
-                    attributes[attribute] = value;
-                    do_attribute(attribute, value);
-                }
-                do_tag(tag, name, attributes);
-                if (!is_empty) {
-                    stack.push(tag_name);
-                }
-                xmode = 'outer';
-                advance('>');
-                break;
-            case '</':
-                xmode = 'html';
-                advance('</');
-                if (!next_token.identifier) {
-                    warn('bad_name_a');
-                }
-                name = next_token.string;
-                advance();
-                if (!stack) {
-                    stop('unexpected_a', next_token, closetag(name));
-                }
-                tag_name = stack.pop();
-                if (!tag_name) {
-                    stop('unexpected_a', next_token, closetag(name));
-                }
-                if (tag_name.name !== name) {
-                    stop('expected_a_b',
-                        next_token, closetag(tag_name.name), closetag(name));
-                }
-                if (next_token.id !== '>') {
-                    stop('expected_a_b', next_token, '>', artifact());
-                }
-                xmode = 'outer';
-                advance('>');
-                break;
-            case '<!':
-                if (option.safe) {
-                    warn('adsafe_a');
-                }
-                xmode = 'html';
-                for (;;) {
-                    advance();
-                    if (next_token.id === '>' || next_token.id === '(end)') {
-                        break;
-                    }
-                    if (next_token.string.indexOf('--') >= 0) {
-                        stop('unexpected_a', next_token, '--');
-                    }
-                    if (next_token.string.indexOf('<') >= 0) {
-                        stop('unexpected_a', next_token, '<');
-                    }
-                    if (next_token.string.indexOf('>') >= 0) {
-                        stop('unexpected_a', next_token, '>');
-                    }
-                }
-                xmode = 'outer';
-                advance('>');
-                break;
-            case '(end)':
-                if (stack.length !== 0) {
-                    warn('missing_a', next_token, '</' + stack.pop().string + '>');
-                }
-                return;
-            default:
-                if (next_token.id === '(end)') {
-                    stop('missing_a', next_token,
-                        '</' + stack[stack.length - 1].string + '>');
-                } else {
-                    advance();
-                }
-            }
-            if (stack && stack.length === 0 && (option.adsafe ||
-                    !option.fragment || next_token.id === '(end)')) {
-                break;
-            }
-        }
-        if (next_token.id !== '(end)') {
-            stop('unexpected_a');
-        }
-    }
-
-
-// The actual JSLINT function itself.
-
-    itself = function JSLint(the_source, the_option) {
-
-        var i, predef, tree;
-        JSLINT.errors = [];
-        JSLINT.tree = '';
-        JSLINT.properties = '';
-        begin = prev_token = token = next_token =
-            Object.create(syntax['(begin)']);
-        predefined = {};
-        add_to_predefined(standard);
-        property = {};
-        if (the_option) {
-            option = Object.create(the_option);
-            predef = option.predef;
-            if (predef) {
-                if (Array.isArray(predef)) {
-                    for (i = 0; i < predef.length; i += 1) {
-                        predefined[predef[i]] = true;
-                    }
-                } else if (typeof predef === 'object') {
-                    add_to_predefined(predef);
-                }
-            }
-            do_safe();
-        } else {
-            option = {};
-        }
-        option.indent = +option.indent || 4;
-        option.maxerr = +option.maxerr || 50;
-        adsafe_id = '';
-        adsafe_may = adsafe_top = adsafe_went = false;
-        approved = {};
-        if (option.approved) {
-            for (i = 0; i < option.approved.length; i += 1) {
-                approved[option.approved[i]] = option.approved[i];
-            }
-        } else {
-            approved.test = 'test';
-        }
-        tab = '';
-        for (i = 0; i < option.indent; i += 1) {
-            tab += ' ';
-        }
-        global_scope = scope = {};
-        global_funct = funct = {
-            '(scope)': scope,
-            '(breakage)': 0,
-            '(loopage)': 0
-        };
-        functions = [funct];
-
-        comments_off = false;
-        ids = {};
-        in_block = false;
-        indent = null;
-        json_mode = false;
-        lookahead = [];
-        node_js = false;
-        prereg = true;
-        src = false;
-        stack = null;
-        strict_mode = false;
-        urls = [];
-        var_mode = null;
-        warnings = 0;
-        xmode = '';
-        lex.init(the_source);
-
-        assume();
-
-        try {
-            advance();
-            if (next_token.id === '(number)') {
-                stop('unexpected_a');
-            } else if (next_token.string.charAt(0) === '<') {
-                html();
-                if (option.adsafe && !adsafe_went) {
-                    warn('adsafe_go', this);
-                }
-            } else {
-                switch (next_token.id) {
-                case '{':
-                case '[':
-                    json_mode = true;
-                    json_value();
-                    break;
-                case '@':
-                case '*':
-                case '#':
-                case '.':
-                case ':':
-                    xmode = 'style';
-                    advance();
-                    if (token.id !== '@' || !next_token.identifier ||
-                            next_token.string !== 'charset' || token.line !== 1 ||
-                            token.from !== 1) {
-                        stop('css');
-                    }
-                    advance();
-                    if (next_token.id !== '(string)' &&
-                            next_token.string !== 'UTF-8') {
-                        stop('css');
-                    }
-                    advance();
-                    semicolon();
-                    styles();
-                    break;
-
-                default:
-                    if (option.adsafe && option.fragment) {
-                        stop('expected_a_b',
-                            next_token, '<div>', artifact());
-                    }
-
-// If the first token is a semicolon, ignore it. This is sometimes used when
-// files are intended to be appended to files that may be sloppy. A sloppy
-// file may be depending on semicolon insertion on its last line.
-
-                    step_in(1);
-                    if (next_token.id === ';' && !node_js) {
-                        semicolon();
-                    }
-                    adsafe_top = true;
-                    tree = statements();
-                    begin.first = tree;
-                    itself.tree = begin;
-                    if (option.adsafe && (tree.length !== 1 ||
-                            aint(tree[0], 'id', '(') ||
-                            aint(tree[0].first, 'id', '.') ||
-                            aint(tree[0].first.first, 'string', 'ADSAFE') ||
-                            aint(tree[0].first.second, 'string', 'lib') ||
-                            tree[0].second.length !== 2 ||
-                            tree[0].second[0].id !== '(string)' ||
-                            aint(tree[0].second[1], 'id', 'function'))) {
-                        stop('adsafe_lib');
-                    }
-                    if (tree.disrupt) {
-                        warn('weird_program', prev_token);
+                    tree = statements();
+                    begin.first = tree;
+                    itself.tree = begin;
+                    if (tree.disrupt) {
+                        prev_token.warn('weird_program');
                     }
                 }
             }
@@ -6197,103 +4020,81 @@ klass:              do {
             itself.property = property;
         } catch (e) {
             if (e) {        // ~~
-                JSLINT.errors.push({
+                itself.errors.push({
                     reason    : e.message,
                     line      : e.line || next_token.line,
                     character : e.character || next_token.from
                 }, null);
             }
         }
-        return JSLINT.errors.length === 0;
+        return itself.errors.length === 0;
     };
 
+    function unique(array) {
+        array = array.sort();
+        var i, length = 0, previous, value;
+        for (i = 0; i < array.length; i += 1) {
+            value = array[i];
+            if (value !== previous) {
+                array[length] = value;
+                previous = value;
+                length += 1;
+            }
+        }
+        array.length = length;
+        return array;
+    }
 
 // Data summary.
 
     itself.data = function () {
         var data = {functions: []},
             function_data,
-            globals,
             i,
-            j,
-            kind,
-            name,
-            the_function,
-            undef = [],
-            unused = [];
-        if (itself.errors.length) {
-            data.errors = itself.errors;
-        }
-
-        if (json_mode) {
-            data.json = true;
-        }
-
-        if (urls.length > 0) {
-            data.urls = urls;
-        }
-
-        globals = Object.keys(global_scope).filter(function (value) {
-            return value.charAt(0) !== '(' && typeof standard[value] !== 'boolean';
-        });
-        if (globals.length > 0) {
-            data.globals = globals;
+            scope,
+            the_function;
+        data.errors = itself.errors;
+        data.json = json_mode;
+        data.global = unique(Object.keys(global_scope));
+
+        function selects(name) {
+            var kind = scope[name].kind;
+            switch (kind) {
+            case 'var':
+            case 'exception':
+            case 'label':
+                function_data[kind].push(name);
+                break;
+            }
         }
 
         for (i = 1; i < functions.length; i += 1) {
             the_function = functions[i];
-            function_data = {};
-            for (j = 0; j < functionicity.length; j += 1) {
-                function_data[functionicity[j]] = [];
-            }
-            for (name in the_function) {
-                if (Object.prototype.hasOwnProperty.call(the_function, name)) {
-                    if (name.charAt(0) !== '(') {
-                        kind = the_function[name];
-                        if (kind === 'unction' || kind === 'unparam') {
-                            kind = 'unused';
-                        }
-                        if (Array.isArray(function_data[kind])) {
-                            function_data[kind].push(name);
-                            if (kind === 'unused') {
-                                unused.push({
-                                    name: name,
-                                    line: the_function['(line)'],
-                                    'function': the_function['(name)']
-                                });
-                            } else if (kind === 'undef') {
-                                undef.push({
-                                    name: name,
-                                    line: the_function['(line)'],
-                                    'function': the_function['(name)']
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-            for (j = 0; j < functionicity.length; j += 1) {
-                if (function_data[functionicity[j]].length === 0) {
-                    delete function_data[functionicity[j]];
-                }
-            }
-            function_data.name = the_function['(name)'];
-            function_data.params = the_function['(params)'];
-            function_data.line = the_function['(line)'];
+            function_data = {
+                name: the_function.name,
+                line: the_function.line,
+                level: the_function.level,
+                parameter: the_function.parameter,
+                var: [],
+                exception: [],
+                closure: unique(the_function.closure),
+                outer: unique(the_function.outer),
+                global: unique(the_function.global),
+                label: []
+            };
+            scope = the_function.scope;
+            Object.keys(scope).forEach(selects);
+            function_data.var.sort();
+            function_data.exception.sort();
+            function_data.label.sort();
             data.functions.push(function_data);
         }
-
-        if (unused.length > 0) {
-            data.unused = unused;
-        }
-        if (undef.length > 0) {
-            data['undefined'] = undef;
-        }
+        data.tokens = tokens;
         return data;
     };
 
     itself.error_report = function (data) {
-        var evidence, i, output = [], snippets, warning;
+        var evidence, i, output = [], warning;
         if (data.errors) {
             if (data.json) {
                 output.push('<cite>JSON: bad.</cite><br>');
@@ -6316,33 +4117,6 @@ klass:              do {
                 }
             }
         }
-        if (data.unused || data['undefined']) {
-            output.push('<dl>');
-            if (data['undefined']) {
-                output.push('<dt>undefined</dt><dd>');
-                snippets = [];
-                for (i = 0; i < data['undefined'].length; i += 1) {
-                    snippets[i] = '<code>' + data['undefined'][i].name +
-                        '</code>&nbsp;<address>' +
-                        data['undefined'][i]['function']  + ' ' +
-                        String(data['undefined'][i].line) + '</address>';
-                }
-                output.push(snippets.join(', '));
-                output.push('</dd>');
-            }
-            if (data.unused) {
-                output.push('<dt>unused</dt><dd>');
-                snippets = [];
-                for (i = 0; i < data.unused.length; i += 1) {
-                    snippets[i] = '<code>' + data.unused[i].name + '</code>&nbsp;<address>' +
-                        data.unused[i]['function']  + ' ' +
-                        String(data.unused[i].line) + '</address>';
-                }
-                output.push(snippets.join(', '));
-                output.push('</dd>');
-            }
-            output.push('</dl>');
-        }
         return output.join('');
     };
 
@@ -6350,33 +4124,22 @@ klass:              do {
     itself.report = function (data) {
         var dl, i, j, names, output = [], the_function;
 
-        function detail(h, value) {
-            var comma_needed, singularity;
-            if (Array.isArray(value)) {
+        function detail(h, array) {
+            var comma_needed = false;
+            if (array.length) {
                 output.push("<dt>" + h + "</dt><dd>");
-                value.sort().forEach(function (item) {
-                    if (item !== singularity) {
-                        singularity = item;
-                        output.push((comma_needed ? ', ' : '') + singularity);
-                        comma_needed = true;
-                    }
+                array.forEach(function (item) {
+                    output.push((comma_needed ? ', ' : '') + item);
+                    comma_needed = true;
                 });
                 output.push("</dd>");
-            } else if (value) {
-                output.push("<dt>" + h + "</dt><dd>", value, "</dd>");
             }
         }
 
-        output.push('<dl>');
-        if (data.urls) {
-            detail('url', data.urls);
-            dl = true;
-        }
-        if (data.globals) {
-            detail('global', data.globals);
+        output.push('<dl class=level0>');
+        if (data.global.length) {
+            detail('global', data.global);
             dl = true;
-        } else if (xmode === 'style') {
-            output.push("<dt>CSS.</dt>");
         } else if (data.json) {
             if (!data.errors) {
                 output.push("<dt>JSON: good.</dt>");
@@ -6399,15 +4162,14 @@ klass:              do {
                         names[j] = the_function.params[j].string;
                     }
                 }
-                output.push('<dl><address>line ' +
-                    String(the_function.line) + '</address>' +
-                    the_function.name.entityify() +
-                    '(' + names.join(', ') + ')');
-                detail('undefined', the_function['undefined']);
-                detail('unused', the_function.unused);
-                detail('closure', the_function.closure);
-                detail('variable', the_function['var']);
+                output.push('<dl class=level' + the_function.level +
+                    '><address>line ' + String(the_function.line) +
+                    '</address>' + the_function.name.entityify() + '(' +
+                    names.join(', ') + ')');
+                detail('parameter', the_function.parameter);
+                detail('variable', the_function.var);
                 detail('exception', the_function.exception);
+                detail('closure', the_function.closure);
                 detail('outer', the_function.outer);
                 detail('global', the_function.global);
                 detail('label', the_function.label);
@@ -6424,7 +4186,6 @@ klass:              do {
         var i,
             key,
             keys = Object.keys(property).sort(),
-            length,
             mem = '    ',
             name,
             not_first = false,
@@ -6438,8 +4199,7 @@ klass:              do {
                 name = ix.test(key)
                     ? key
                     : '\'' + key.replace(nx, sanitize) + '\'';
-                length += name.length + 2;
-                if (mem.length + name.length > 80) {
+                if (mem.length + name.length >= 80) {
                     output.push(mem);
                     mem = '    ';
                 }
@@ -6451,9 +4211,38 @@ klass:              do {
         return output.join('\n');
     };
 
+    itself.color = function (data) {
+        var from,
+            i = 1,
+            level,
+            line,
+            result = [],
+            thru,
+            token = data.tokens[0];
+        while (token && token.id !== '(end)') {
+            from = token.from;
+            line = token.line;
+            thru = token.thru;
+            level = token.function.level;
+            do {
+                thru = token.thru;
+                token = data.tokens[i];
+                i += 1;
+            } while (token && token.line === line && token.from - thru < 5 &&
+                    level === token.function.level);
+            result.push({
+                line: line,
+                level: level,
+                from: from,
+                thru: thru
+            });
+        }
+        return result;
+    };
+
     itself.jslint = itself;
 
-    itself.edition = '2012-12-31';
+    itself.edition = '2013-05-01';
 
     return itself;
 }());

From 4dd18e4728dbee633d43bbb8eace3c0c4ba1b70c Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Fri, 3 May 2013 22:57:22 -0500
Subject: [PATCH 10/25] bumped the version for the update of jslint

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 7432636..c81583b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.1",
+    "version": "0.2.2",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",

From ada6d71f93b4cb25c5d6e5ae2b8f4a4574058715 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Mon, 6 May 2013 10:00:06 -0500
Subject: [PATCH 11/25] changed to how node-jslint loads the jslint.js

node-jslint (https://github.com/reid/node-jslint), loads the jslint.js file in an execution context.
This way, to update to the latest jslint.js, one just needs to download the new file.

Also bumped the version
---
 app.js                     |  2 +-
 fulljslint.js => jslint.js |  6 ++----
 nodelint.js                | 11 +++++++++++
 package.json               | 10 +++++-----
 4 files changed, 19 insertions(+), 10 deletions(-)
 rename fulljslint.js => jslint.js (99%)
 create mode 100644 nodelint.js

diff --git a/app.js b/app.js
index c2e96bd..fce12e5 100755
--- a/app.js
+++ b/app.js
@@ -20,7 +20,7 @@
 
 var express = require("express");
 var http = require('http');
-var jslint = require('./fulljslint').jslint;
+var jslint = require('./nodelint');
 var package_info = require('./package');
 
 var app = express();
diff --git a/fulljslint.js b/jslint.js
similarity index 99%
rename from fulljslint.js
rename to jslint.js
index b9ef681..b8787e8 100644
--- a/fulljslint.js
+++ b/jslint.js
@@ -551,8 +551,8 @@ var JSLINT = (function () {
         lines,
         lookahead,
         node = array_to_object([
-            'Buffer', 'clearImmediate', 'clearInterval', 'clearTimeout', 'console', 'exports',
-            'global', 'module', 'process', 'querystring', 'require',
+            'Buffer', 'clearImmediate', 'clearInterval', 'clearTimeout', 'console',
+            'exports', 'global', 'module', 'process', 'querystring', 'require',
             'setImmediate', 'setInterval', 'setTimeout', '__dirname', '__filename'
         ], false),
         node_js,
@@ -4246,5 +4246,3 @@ klass:              do {
 
     return itself;
 }());
-
-exports.jslint = JSLINT;
diff --git a/nodelint.js b/nodelint.js
new file mode 100644
index 0000000..c4e29f6
--- /dev/null
+++ b/nodelint.js
@@ -0,0 +1,11 @@
+/*jslint nomen: true*/
+'use strict';
+
+var vm = require("vm");
+var fs = require("fs");
+
+var ctx = vm.createContext();
+
+vm.runInContext(fs.readFileSync(__dirname + "/jslint.js"), ctx);
+
+module.exports = ctx.JSLINT;
diff --git a/package.json b/package.json
index c81583b..f312e01 100644
--- a/package.json
+++ b/package.json
@@ -1,12 +1,12 @@
 {
     "name": "lintnode",
-    "version": "0.2.2",
+    "version": "0.2.3",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",
     "author": {
-        "name": "Kevin Turner",
-        "url": "http://keturn.net/"
+        "name": "Chad Walker",
+        "email": "chad@chad-cat-lore-eddie.com"
     },
     "contributors": [
         {
@@ -14,8 +14,8 @@
             "url": "http://github.com/davidmiller/lintnode"
         },
         {
-            "name": "Chad Walker",
-            "email": "chad@chad-cat-lore-eddie.com"
+            "name": "Kevin Turner",
+            "url": "http://keturn.net/"
         }
     ],
     "repository": {

From c93163126ad9b1a0b7b5facaf3dcb54c5c0753c5 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Mon, 6 May 2013 10:46:55 -0500
Subject: [PATCH 12/25] updated to actual jslint.js

---
 jslint.js    | 11 ++++++-----
 package.json |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/jslint.js b/jslint.js
index b8787e8..66ece9a 100644
--- a/jslint.js
+++ b/jslint.js
@@ -1,5 +1,5 @@
 // jslint.js
-// 2013-05-01
+// 2013-05-05
 
 // Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)
 
@@ -551,9 +551,10 @@ var JSLINT = (function () {
         lines,
         lookahead,
         node = array_to_object([
-            'Buffer', 'clearImmediate', 'clearInterval', 'clearTimeout', 'console',
-            'exports', 'global', 'module', 'process', 'querystring', 'require',
-            'setImmediate', 'setInterval', 'setTimeout', '__dirname', '__filename'
+            'Buffer', 'clearImmediate', 'clearInterval', 'clearTimeout',
+            'console', 'exports', 'global', 'module', 'process', 'querystring',
+            'require', 'setImmediate', 'setInterval', 'setTimeout',
+            '__dirname', '__filename'
         ], false),
         node_js,
         numbery = array_to_object(['indexOf', 'lastIndexOf', 'search'], true),
@@ -4242,7 +4243,7 @@ klass:              do {
 
     itself.jslint = itself;
 
-    itself.edition = '2013-05-01';
+    itself.edition = '2013-05-05';
 
     return itself;
 }());
diff --git a/package.json b/package.json
index f312e01..4c6ba57 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.3",
+    "version": "0.2.4",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",

From 7dcd94593a26d2e0cd4db5e9d55c8a7e12277931 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Mon, 6 May 2013 11:33:55 -0500
Subject: [PATCH 13/25] added a commandline help

---
 app.js | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/app.js b/app.js
index fce12e5..b3646bf 100755
--- a/app.js
+++ b/app.js
@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 
-/*global */
 'use strict';
 
 /* HTTP interface to JSLint.
@@ -88,11 +87,12 @@ app.get('/example/ok', exampleOk);
 app.post('/example/ok', exampleOk);
 
 function parseCommandLine() {
-    var port_index, exclude_index, exclude_opts, include_index, include_opts, set_index, set_opts, set_pair, properties;
+    var port_index, exclude_index, exclude_opts, include_index, include_opts, set_index, set_opts, set_pair, properties, help_index;
     port_index = process.argv.indexOf('--port');
     exclude_index = process.argv.indexOf('--exclude');
     include_index = process.argv.indexOf('--include');
     set_index = process.argv.indexOf('--set');
+    help_index = process.argv.indexOf('--help');
     if (port_index > -1) {
         jslint_port = process.argv[port_index + 1];
     }
@@ -130,6 +130,20 @@ function parseCommandLine() {
             });
         }
     }
+    if (help_index > -1) {
+        console.error('Usuage:', process.argv[1], '[--port <port>] [--exclude <option,option,...>] [--include <option,option,...>] [--set <option:value,option:value,...>] [--help]');
+        console.error('\t--port <port>');
+        console.error('\t\tSet the port the server will listen on');
+        console.error('\t--exclude <option,option,...>');
+        console.error('\t\tShorthand for option:false,option:false,...');
+        console.error('\t--include <option,option,...>');
+        console.error('\t\tShorthand for option:true,option:true,...');
+        console.error('\t--set <option:value,option:value,...>');
+        console.error('\t\tSet the options like /*jslint option:value*/');
+        console.error('\t--help');
+        console.error('\t\tThis help');
+        process.exit(0);
+    }
     properties = Object.keys(jslint_options).map(function (opt) {
         return opt + ": " + jslint_options[opt];
     }).join('; ');

From ab2071d0758a0fa1e3a9b8defd830b593f9a8e31 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Mon, 6 May 2013 11:45:52 -0500
Subject: [PATCH 14/25] added --quiet option

---
 app.js | 30 +++++++++++++++++++++++-------
 1 file changed, 23 insertions(+), 7 deletions(-)

diff --git a/app.js b/app.js
index b3646bf..79fc57d 100755
--- a/app.js
+++ b/app.js
@@ -28,6 +28,7 @@ app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
 app.use(express.bodyParser());
 
 var jslint_port = 3003;
+var quiet = false;
 
 // use jslint's default options, by default
 var jslint_options = {
@@ -87,11 +88,12 @@ app.get('/example/ok', exampleOk);
 app.post('/example/ok', exampleOk);
 
 function parseCommandLine() {
-    var port_index, exclude_index, exclude_opts, include_index, include_opts, set_index, set_opts, set_pair, properties, help_index;
+    var port_index, exclude_index, exclude_opts, include_index, include_opts, set_index, set_opts, set_pair, properties, help_index, quiet_index;
     port_index = process.argv.indexOf('--port');
     exclude_index = process.argv.indexOf('--exclude');
     include_index = process.argv.indexOf('--include');
     set_index = process.argv.indexOf('--set');
+    quiet_index = process.argv.indexOf('--quiet');
     help_index = process.argv.indexOf('--help');
     if (port_index > -1) {
         jslint_port = process.argv[port_index + 1];
@@ -130,8 +132,11 @@ function parseCommandLine() {
             });
         }
     }
+    if (quiet_index > -1) {
+        quiet = true;
+    }
     if (help_index > -1) {
-        console.error('Usuage:', process.argv[1], '[--port <port>] [--exclude <option,option,...>] [--include <option,option,...>] [--set <option:value,option:value,...>] [--help]');
+        console.error('Usuage:', process.argv[1], '[--port <port>] [--exclude <option,option,...>] [--include <option,option,...>] [--set <option:value,option:value,...>] [--quiet] [--help]');
         console.error('\t--port <port>');
         console.error('\t\tSet the port the server will listen on');
         console.error('\t--exclude <option,option,...>');
@@ -140,6 +145,8 @@ function parseCommandLine() {
         console.error('\t\tShorthand for option:true,option:true,...');
         console.error('\t--set <option:value,option:value,...>');
         console.error('\t\tSet the options like /*jslint option:value*/');
+        console.error('\t--quiet');
+        console.error('\t\tDon\'t output diagnostics');
         console.error('\t--help');
         console.error('\t\tThis help');
         process.exit(0);
@@ -151,14 +158,23 @@ function parseCommandLine() {
 }
 
 process.on('SIGINT', function () {
-    console.log("\n[lintnode] received SIGINT, shutting down");
+    if (!quiet) {
+        console.log("\n[lintnode] received SIGINT, shutting down");
+    }
     process.exit(0);
 });
 
-console.log('[lintnode] version:', package_info.version);
-console.log('[lintnode] jslint edition:', jslint.edition);
-console.log("[lintnode]", parseCommandLine());
+var properties = parseCommandLine();
+
+if (!quiet) {
+    console.log('[lintnode] version:', package_info.version);
+    console.log('[lintnode] jslint edition:', jslint.edition);
+    console.log("[lintnode]", properties);
+}
+
 var http_server = http.createServer(app);
 http_server.listen(jslint_port, function () {
-    console.log("[lintnode] server running on port", jslint_port);
+    if (!quiet) {
+        console.log("[lintnode] server running on port", jslint_port);
+    }
 });

From 0d3adeed923b204b0c52cc4fa9f5f08cff1f4b8a Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Mon, 6 May 2013 12:14:22 -0500
Subject: [PATCH 15/25] install a commandline tool to use the server, called
 jslinter

---
 package.json | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index 4c6ba57..990a59f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.4",
+    "version": "0.2.5",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",
@@ -23,7 +23,10 @@
         "url": "http://github.com/chad3814/lintnode.git"
     },
     "preferGlobal": true,
-    "bin": "./app.js",
+    "bin": {
+        "lintnode": "./app.js",
+        "jslinter": "./jslint.curl"
+    },
     "dependencies": {
         "express": "3.x"
     },

From e0401dba218e856d3efa17f75641e34a02dd5e4f Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Mon, 6 May 2013 14:25:18 -0500
Subject: [PATCH 16/25] fix empty lintnode-jslint-set

---
 flymake-jslint.el | 9 ++++++---
 package.json      | 2 +-
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/flymake-jslint.el b/flymake-jslint.el
index 8fbe356..3866aab 100644
--- a/flymake-jslint.el
+++ b/flymake-jslint.el
@@ -72,15 +72,18 @@ Uses `lintnode-node-program' and `lintnode-location'."
                              (mapconcat 'identity (mapcar 'symbol-name lintnode-jslint-excludes) ",")))
 		(lintnode-includes (if (not lintnode-jslint-includes)
                                ""
-                             (mapconcat 'identity (mapcar 'symbol-name lintnode-jslint-includes) ","))))
-					   
+                             (mapconcat 'identity (mapcar 'symbol-name lintnode-jslint-includes) ",")))
+		(lintnode-set (if (not lintnode-jslint-set)
+                               ""
+			     lintnode-jslint-set)))
+
     (start-process "lintnode-server" "*lintnode*"
                    lintnode-node-program
                    lintnode-location
                    "--port" (number-to-string lintnode-port)
                    "--exclude" lintnode-excludes
 				   "--include" lintnode-includes
-				   "--set" lintnode-jslint-set)))
+				   "--set" lintnode-set)))
 
 (defun lintnode-stop ()
   "stop the lintnode server process"
diff --git a/package.json b/package.json
index 990a59f..c4a6eb6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.5",
+    "version": "0.2.6",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",

From 6a7136351c7c804130278d5be5e9e45d321ea1fc Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Mon, 6 May 2013 20:25:06 -0500
Subject: [PATCH 17/25] added optional pretty printing of errors

---
 app.js | 50 ++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 38 insertions(+), 12 deletions(-)

diff --git a/app.js b/app.js
index 79fc57d..ef2ea7d 100755
--- a/app.js
+++ b/app.js
@@ -34,7 +34,22 @@ var quiet = false;
 var jslint_options = {
 };
 
-var outputErrors = function (errors) {
+var outputPrettyErrors = function (filename, errors) {
+    var results = ['', filename, '\n'];
+    errors.forEach(function (e, i) {
+        if (e) {
+            var pad = '#' + i + ' ';
+            while (pad.length < 4) {
+                pad = ' ' + pad;
+            }
+            e.evidence = e.evidence || '';
+            results.push(pad, e.reason || '', '\n    ', e.evidence.replace(/^\s*/, ''), ' // Line ', e.line + 1, ', Pos ', e.character + 1, '\n');
+        }
+    });
+    return results.join('');
+};
+
+var outputTerseErrors = function (filename, errors) {
     var e, i, output = [];
     // debug("Handling " + errors.length + "errors" + '\n');
 
@@ -48,21 +63,36 @@ var outputErrors = function (errors) {
             output.push('\n');
         }
     }
-    return output.join('');
+    return filename + '\n' + output.join('');
+};
+
+var getOptionString = function () {
+    return Object.keys(jslint_options).map(function (opt) {
+        return opt + ": " + jslint_options[opt];
+    }).join('; ');
 };
 
 app.get('/', function (req, res) {
-    res.type('text/plain').end('lintnode version: ' + package_info.version + '\n' + 'jslint edition: ' + jslint.edition + '\n');
+    res.type('text/plain').end('lintnode version: ' + package_info.version + '\n' + 'jslint edition: ' + jslint.edition + '\n' + 'options: ' + getOptionString());
 });
 
 app.post('/jslint', function (req, res) {
+    if (req.body.source.substr(0, 2) === '#!') {
+        /*jslint regexp: true*/
+        req.body.source = req.body.source.replace(/^#!.*/, '');
+        /*jslint regexp: false*/
+    }
     function doLint(sourcedata) {
         var passed, results;
         passed = jslint(sourcedata, jslint_options);
         if (passed) {
             results = "jslint: No problems found in " + req.body.filename + "\n";
         } else {
-            results = outputErrors(jslint.errors);
+            if (req.body.pretty) {
+                results = outputPrettyErrors(req.body.filename, jslint.errors);
+            } else {
+                results = outputTerseErrors(req.body.filename, jslint.errors);
+            }
         }
         return results;
     }
@@ -73,7 +103,7 @@ app.post('/jslint', function (req, res) {
 var exampleErrors = function (req, res) {
     jslint("a = function(){ return 7 + x }()",
         jslint_options);
-    res.type('text/plain').end(outputErrors(jslint.errors));
+    res.type('text/plain').end(outputTerseErrors('example', jslint.errors));
 };
 
 /* This action always returns JSLint's a-okay message. */
@@ -88,7 +118,7 @@ app.get('/example/ok', exampleOk);
 app.post('/example/ok', exampleOk);
 
 function parseCommandLine() {
-    var port_index, exclude_index, exclude_opts, include_index, include_opts, set_index, set_opts, set_pair, properties, help_index, quiet_index;
+    var port_index, exclude_index, exclude_opts, include_index, include_opts, set_index, set_opts, set_pair, help_index, quiet_index;
     port_index = process.argv.indexOf('--port');
     exclude_index = process.argv.indexOf('--exclude');
     include_index = process.argv.indexOf('--include');
@@ -151,10 +181,6 @@ function parseCommandLine() {
         console.error('\t\tThis help');
         process.exit(0);
     }
-    properties = Object.keys(jslint_options).map(function (opt) {
-        return opt + ": " + jslint_options[opt];
-    }).join('; ');
-    return properties;
 }
 
 process.on('SIGINT', function () {
@@ -164,12 +190,12 @@ process.on('SIGINT', function () {
     process.exit(0);
 });
 
-var properties = parseCommandLine();
+parseCommandLine();
 
 if (!quiet) {
     console.log('[lintnode] version:', package_info.version);
     console.log('[lintnode] jslint edition:', jslint.edition);
-    console.log("[lintnode]", properties);
+    console.log("[lintnode]", getOptionString());
 }
 
 var http_server = http.createServer(app);

From d9c489752749818f8c806d8cb2edce175be65ade Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Mon, 6 May 2013 20:33:52 -0500
Subject: [PATCH 18/25] new client prints errors prettier and exits with
 non-zero when there are errors

---
 jslint.curl  | 6 +++++-
 package.json | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/jslint.curl b/jslint.curl
index 1bcd85c..f807d25 100755
--- a/jslint.curl
+++ b/jslint.curl
@@ -1,5 +1,9 @@
 #!/bin/bash
 # A faster way to jslint; curl's start-up cost is much lower than rhino's.
 JSLINT_URL="http://localhost:3003/jslint"
-exec curl --form source="<${1}" --form filename="${1}" ${JSLINT_URL}
+RESULTS=`curl -s --form pretty="1" --form source="<${1}" --form filename="${1}" ${JSLINT_URL}`
+echo "$RESULTS"
+if [[ `echo "$RESULTS" | wc -l` -gt 1 ]] ; then
+    exit 1
+fi
 #exec curl --form source="@${1}" ${JSLINT_URL}
diff --git a/package.json b/package.json
index c4a6eb6..d850f62 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.6",
+    "version": "0.2.7",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",

From 205dc4b823d16aa720e863923d3c6303406c91b3 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Mon, 6 May 2013 20:41:56 -0500
Subject: [PATCH 19/25] oops had pretty printed errors off by a line and a
 character

---
 app.js       | 2 +-
 package.json | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/app.js b/app.js
index ef2ea7d..6aaece7 100755
--- a/app.js
+++ b/app.js
@@ -43,7 +43,7 @@ var outputPrettyErrors = function (filename, errors) {
                 pad = ' ' + pad;
             }
             e.evidence = e.evidence || '';
-            results.push(pad, e.reason || '', '\n    ', e.evidence.replace(/^\s*/, ''), ' // Line ', e.line + 1, ', Pos ', e.character + 1, '\n');
+            results.push(pad, e.reason || '', '\n    ', e.evidence.replace(/^\s*/, ''), ' // Line ', e.line, ', Pos ', e.character, '\n');
         }
     });
     return results.join('');
diff --git a/package.json b/package.json
index d850f62..e4e64b8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.7",
+    "version": "0.2.8",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",

From dfb145738c5e97dfb37902196b6686f4404d6e47 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Tue, 7 May 2013 19:56:49 -0500
Subject: [PATCH 20/25] added a newline prefix to the pretty printed error

---
 app.js       | 2 +-
 package.json | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/app.js b/app.js
index 6aaece7..b12094a 100755
--- a/app.js
+++ b/app.js
@@ -35,7 +35,7 @@ var jslint_options = {
 };
 
 var outputPrettyErrors = function (filename, errors) {
-    var results = ['', filename, '\n'];
+    var results = ['\n', filename, '\n'];
     errors.forEach(function (e, i) {
         if (e) {
             var pad = '#' + i + ' ';
diff --git a/package.json b/package.json
index e4e64b8..bbed950 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.8",
+    "version": "0.2.9",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",

From 37ae5cb56828b0908564c0c930adcdee6fc99e6f Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Mon, 15 Jul 2013 13:16:25 -0500
Subject: [PATCH 21/25] updated to newest jslint.js

---
 jslint.js | 230 +++++++++++++++++++++++++++---------------------------
 1 file changed, 114 insertions(+), 116 deletions(-)

diff --git a/jslint.js b/jslint.js
index 66ece9a..b0bbb66 100644
--- a/jslint.js
+++ b/jslint.js
@@ -1,5 +1,5 @@
 // jslint.js
-// 2013-05-05
+// 2013-07-02
 
 // Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)
 
@@ -82,7 +82,7 @@
 //             {
 //                 name: STRING,
 //                 line: NUMBER,
-//                 last: NUMBER,
+//                 level: NUMBER,
 //                 parameter: [
 //                     STRING
 //                 ],
@@ -206,7 +206,6 @@
 //     todo       true, if TODO comments are tolerated
 //     vars       true, if multiple var statements per function should be allowed
 //     white      true, if sloppy whitespace is tolerated
-//     windows    true, if MS Windows-specific globals should be predefined
 
 // The properties directive declares an exclusive list of property names.
 // Any properties named in the program that are not in the list will
@@ -221,7 +220,7 @@
     assignment_expression, assignment_function_expression, at, avoid_a, b,
     bad_assignment, bad_constructor, bad_in_a, bad_invocation, bad_new,
     bad_number, bad_operand, bad_wrap, bitwise, block, browser, c, call, charAt,
-    charCodeAt, character, closure, color, combine_var, comments,
+    charCodeAt, character, closure, code, color, combine_var, comments,
     conditional_assignment, confusing_a, confusing_regexp, constructor_name_a,
     continue, control_a, couch, create, d, dangling_a, data, dead, debug,
     deleted, devel, disrupt, duplicate_a, edge, edition, else, empty_block,
@@ -251,14 +250,14 @@
     sync_a, t, tag_a_in_b, test, third, thru, toString, todo, todo_comment,
     token, tokens, too_long, too_many, trailing_decimal_a, tree, unclosed,
     unclosed_comment, unclosed_regexp, unescaped_a, unexpected_a,
-    unexpected_char_a, unexpected_comment, unexpected_else, unexpected_label_a,
+    unexpected_char_a, unexpected_comment, unexpected_label_a,
     unexpected_property_a, unexpected_space_a_b, unexpected_typeof_a,
-    uninitialized_a, unnecessary_initialize, unnecessary_use, unparam,
-    unreachable_a_b, unsafe, unused_a, url, use_array, use_braces, use_object,
-    use_or, use_param, use_spaces, used, used_before_a, var, var_a_not,
-    var_loop, vars, varstatement, warn, warning, was, weird_assignment,
-    weird_condition, weird_new, weird_program, weird_relation, weird_ternary,
-    white, windows, wrap, wrap_immediate, wrap_regexp, write_is_wrong,
+    uninitialized_a, unnecessary_else, unnecessary_initialize, unnecessary_use,
+    unparam, unreachable_a_b, unsafe, unused_a, url, use_array, use_braces,
+    use_object, use_or, use_param, use_spaces, used, used_before_a, var,
+    var_a_not, var_loop, vars, varstatement, warn, warning, was,
+    weird_assignment, weird_condition, weird_new, weird_program, weird_relation,
+    weird_ternary, white, wrap, wrap_immediate, wrap_regexp, write_is_wrong,
     writeable
 */
 
@@ -316,8 +315,7 @@ var JSLINT = (function () {
             sub       : true,
             todo      : true,
             vars      : true,
-            white     : true,
-            windows   : true
+            white     : true
         },
         anonname,       // The guessed name for anonymous functions.
 
@@ -464,13 +462,13 @@ var JSLINT = (function () {
             unexpected_a: "Unexpected '{a}'.",
             unexpected_char_a: "Unexpected character '{a}'.",
             unexpected_comment: "Unexpected comment.",
-            unexpected_else: "Unexpected 'else' after 'return'.",
             unexpected_label_a: "Unexpected label '{a}'.",
             unexpected_property_a: "Unexpected /*property*/ '{a}'.",
             unexpected_space_a_b: "Unexpected space between '{a}' and '{b}'.",
             unexpected_typeof_a: "Unexpected 'typeof'. " +
                 "Use '===' to compare directly with {a}.",
             uninitialized_a: "Uninitialized '{a}'.",
+            unnecessary_else: "Unnecessary 'else' after disruption.",
             unnecessary_initialize: "It is not necessary to initialize '{a}' " +
                 "to 'undefined'.",
             unnecessary_use: "Unnecessary 'use strict'.",
@@ -507,7 +505,8 @@ var JSLINT = (function () {
         comments,
         comments_off,
         couch = array_to_object([
-            'emit'
+            'emit', 'getRow', 'isArray', 'log', 'provides', 'registerType',
+            'require', 'send', 'start', 'sum', 'toJSON'
         ], false),
 
         descapes = {
@@ -596,11 +595,6 @@ var JSLINT = (function () {
         var_mode,
         warnings,
 
-        windows = array_to_object([
-            'ActiveXObject', 'CScript', 'Debug', 'Enumerator', 'System',
-            'VBArray', 'WScript', 'WSH'
-        ], false),
-
 // Regular expressions. Some of these are stupidly long.
 
 // carriage return, carriage return linefeed, or linefeed
@@ -610,7 +604,7 @@ var JSLINT = (function () {
 // identifier
         ix = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/,
 // javascript url
-        jx = /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i,
+        jx = /^(?:javascript|jscript|ecmascript|vbscript)\s*:/i,
 // star slash
         lx = /\*\/|\/\*/,
 // characters in strings that need escapement
@@ -683,6 +677,7 @@ var JSLINT = (function () {
         if (option.couch) {
             add_to_predefined(couch);
             option.couch = false;
+            option.es5 = true;
         }
         if (option.devel) {
             add_to_predefined(devel);
@@ -691,16 +686,13 @@ var JSLINT = (function () {
         if (option.node) {
             add_to_predefined(node);
             option.node = false;
+            option.es5 = true;
             node_js = true;
         }
         if (option.rhino) {
             add_to_predefined(rhino);
             option.rhino = false;
         }
-        if (option.windows) {
-            add_to_predefined(windows);
-            option.windows = false;
-        }
     }
 
 
@@ -719,16 +711,17 @@ var JSLINT = (function () {
             line: line,
             character: character,
             message: bundle.scanned_a_b.supplant({
-                a: message,
+                a: bundle[message] || message,
                 b: Math.floor((line / lines.length) * 100)
             })
         };
     }
 
-    function warn(message, line, character, a, b, c, d) {
+    function warn(code, line, character, a, b, c, d) {
         var warning = {         // ~~
             id: '(error)',
-            raw: bundle[message] || message,
+            raw: bundle[code] || code,
+            code: code,
             evidence: lines[line - 1] || '',
             line: line,
             character: character,
@@ -740,18 +733,18 @@ var JSLINT = (function () {
         warning.reason = warning.raw.supplant(warning);
         itself.errors.push(warning);
         if (option.passfail) {
-            quit(bundle.stopping, line, character);
+            quit('stopping', line, character);
         }
         warnings += 1;
         if (warnings >= option.maxerr) {
-            quit(bundle.too_many, line, character);
+            quit('too_many', line, character);
         }
         return warning;
     }
 
-    function stop(message, line, character, a, b, c, d) {
-        var warning = warn(message, line, character, a, b, c, d);
-        quit(bundle.stopping, warning.line, warning.character);
+    function stop(code, line, character, a, b, c, d) {
+        var warning = warn(code, line, character, a, b, c, d);
+        quit('stopping', warning.line, warning.character);
     }
 
     function expected_at(at) {
@@ -1047,7 +1040,7 @@ var JSLINT = (function () {
                     if (c < ' ') {
                         warn('control_a', line, from + length, String(c));
                     } else if (c === '<') {
-                        warn(bundle.unexpected_a, line, from + length, '\\');
+                        warn('unexpected_a', line, from + length, '\\');
                     }
                     length += 1;
                     break;
@@ -1063,7 +1056,7 @@ var JSLINT = (function () {
                             length += 1;
                             break;
                         default:
-                            warn(bundle.expected_a_b, line, from + length,
+                            warn('expected_a_b', line, from + length,
                                 ':', source_row.charAt(length));
                         }
                     }
@@ -1128,9 +1121,9 @@ klass:              do {
                         case '\\':
                             c = source_row.charAt(length);
                             if (c < ' ') {
-                                warn(bundle.control_a, line, from + length, String(c));
+                                warn('control_a', line, from + length, String(c));
                             } else if (c === '<') {
-                                warn(bundle.unexpected_a, line, from + length, '\\');
+                                warn('unexpected_a', line, from + length, '\\');
                             }
                             length += 1;
                             bit = true;
@@ -1172,7 +1165,7 @@ klass:              do {
                         length += 1;
                         c = source_row.charAt(length);
                         if (c < '0' || c > '9') {
-                            warn(bundle.expected_number_a, line,
+                            warn('expected_number_a', line,
                                 from + length, c);
                         }
                         length += 1;
@@ -1204,7 +1197,7 @@ klass:              do {
                             }
                         }
                         if (source_row.charAt(length) !== '}') {
-                            warn(bundle.expected_a_b, line, from + length,
+                            warn('expected_a_b', line, from + length,
                                 '}', c);
                         } else {
                             length += 1;
@@ -1213,7 +1206,7 @@ klass:              do {
                             length += 1;
                         }
                         if (low > high) {
-                            warn(bundle.not_greater, line, from + length,
+                            warn('not_greater', line, from + length,
                                 low, high);
                         }
                         break;
@@ -1309,7 +1302,7 @@ klass:              do {
 //      /
                         case '/':
                             if (token.id === '/=') {
-                                stop(bundle.slash_equal, line, from);
+                                stop('slash_equal', line, from);
                             }
                             return prereg
                                 ? regexp()
@@ -1794,9 +1787,10 @@ klass:              do {
         }
         if (a.arity === b.arity && a.string === b.string) {
             switch (a.arity) {
+            case undefined:
+                return a.string === b.string;
             case 'prefix':
             case 'suffix':
-            case undefined:
                 return a.id === b.id && are_similar(a.first, b.first) &&
                     a.id !== '{' && a.id !== '[';
             case 'infix':
@@ -1812,13 +1806,12 @@ klass:              do {
             default:
                 return true;
             }
-        } else {
-            if (a.id === '.' && b.id === '[' && b.arity === 'infix') {
-                return a.second.string === b.second.string && b.second.id === '(string)';
-            }
-            if (a.id === '[' && a.arity === 'infix' && b.id === '.') {
-                return a.second.string === b.second.string && a.second.id === '(string)';
-            }
+        }
+        if (a.id === '.' && b.id === '[' && b.arity === 'infix') {
+            return a.second.string === b.second.string && b.second.id === '(string)';
+        }
+        if (a.id === '[' && a.arity === 'infix' && b.id === '.') {
+            return a.second.string === b.second.string && a.second.id === '(string)';
         }
         return false;
     }
@@ -1887,15 +1880,16 @@ klass:              do {
         led: function () {
             this.stop('expected_operator_a');
         },
-        warn: function (message, a, b, c, d) {
+        warn: function (code, a, b, c, d) {
             if (!this.warning) {
-                this.warning = warn(message, this.line || 0, this.from || 0,
+                this.warning = warn(code, this.line || 0, this.from || 0,
                     a || artifact(this), b, c, d);
             }
         },
-        stop: function (message, a, b, c, d) {
-            var warning = this.warn(message, a, b, c, d);
-            return quit(bundle.stopping, warning.line, warning.character);
+        stop: function (code, a, b, c, d) {
+            this.warning = undefined;
+            this.warn(code, a, b, c, d);
+            return quit('stopping', this.line, this.character);
         },
         lbp: 0
     };
@@ -1929,17 +1923,18 @@ klass:              do {
         return postscript(x);
     }
 
+    function reserve_name(x) {
+        var c = x.id.charAt(0);
+        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
+            x.identifier = x.reserved = true;
+        }
+        return x;
+    }
 
     function stmt(s, f) {
         var x = symbol(s);
-        x.identifier = x.reserved = true;
         x.fud = f;
-        return x;
-    }
-
-    function labeled_stmt(s, f) {
-        var x = stmt(s, f);
-        x.labeled = true;
+        return reserve_name(x);
     }
 
     function disrupt_stmt(s, f) {
@@ -1947,16 +1942,11 @@ klass:              do {
         x.disrupt = true;
     }
 
-
-    function reserve_name(x) {
-        var c = x.id.charAt(0);
-        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
-            x.identifier = x.reserved = true;
-        }
-        return x;
+    function labeled_stmt(s, f) {
+        var x = stmt(s, f);
+        x.labeled = true;
     }
 
-
     function prefix(s, f) {
         var x = symbol(s, 150);
         reserve_name(x);
@@ -2060,7 +2050,7 @@ klass:              do {
 
     function expected_relation(node, message) {
         if (node.assign) {
-            node.warn(message || bundle.conditional_assignment);
+            node.warn(message || 'conditional_assignment');
         }
         return node;
     }
@@ -2070,7 +2060,7 @@ klass:              do {
         case '[':
         case '-':
             if (node.arity !== 'infix') {
-                node.warn(message || bundle.weird_condition);
+                node.warn(message || 'weird_condition');
             }
             break;
         case 'false':
@@ -2087,14 +2077,14 @@ klass:              do {
         case '{':
         case '?':
         case '~':
-            node.warn(message || bundle.weird_condition);
+            node.warn(message || 'weird_condition');
             break;
         case '(':
             if (node.first.id === 'new' ||
                     (node.first.string === 'Boolean') ||
                     (node.first.id === '.' &&
                         numbery[node.first.second.string] === true)) {
-                node.warn(message || bundle.weird_condition);
+                node.warn(message || 'weird_condition');
             }
             break;
         }
@@ -3018,7 +3008,7 @@ klass:              do {
         switch (e.id) {
         case '(number)':
             if (e.id === '(number)' && left.id === 'arguments') {
-                left.warn('use_param', left);
+                left.warn('use_param');
             }
             break;
         case '(string)':
@@ -3366,6 +3356,7 @@ klass:              do {
             no_space();
         } else {
             id = '';
+            one_space();
         }
         do_function(that, id);
         if (name) {
@@ -3409,6 +3400,9 @@ klass:              do {
         one_space();
         this.block = block('if');
         if (next_token.id === 'else') {
+            if (this.block.disrupt) {
+                next_token.warn('unnecessary_else');
+            }
             one_space();
             advance('else');
             one_space();
@@ -3484,7 +3478,7 @@ klass:              do {
         this.arity = 'statement';
         this.first = expected_relation(expression(0));
         if (this.first.id !== 'true') {
-            expected_condition(this.first, bundle.unexpected_a);
+            expected_condition(this.first, 'unexpected_a');
         }
         no_space();
         step_out(')', paren);
@@ -3629,7 +3623,7 @@ klass:              do {
         step_in();
         no_space();
         edge();
-        this.first = expected_condition(expected_relation(expression(0)), bundle.unexpected_a);
+        this.first = expected_condition(expected_relation(expression(0)), 'unexpected_a');
         no_space();
         step_out(')', paren);
         funct.loopage -= 1;
@@ -3674,39 +3668,46 @@ klass:              do {
                 step_out(')', paren);
                 blok = block('for');
                 if (!option.forin) {
-                    if (blok.length === 1 && typeof blok[0] === 'object' &&
-                            blok[0].string === 'if' && !blok[0].else) {
-                        filter = blok[0].first;
-                        while (filter.id === '&&') {
-                            filter = filter.first;
-                        }
-                        switch (filter.id) {
-                        case '===':
-                        case '!==':
-                            ok = filter.first.id === '['
-                                ? filter.first.first.string === this.second.string &&
-                                    filter.first.second.string === this.first.string
-                                : filter.first.id === 'typeof' &&
-                                    filter.first.first.id === '[' &&
-                                    filter.first.first.first.string === this.second.string &&
-                                    filter.first.first.second.string === this.first.string;
-                            break;
-                        case '(':
-                            ok = filter.first.id === '.' && ((
-                                filter.first.first.string === this.second.string &&
-                                filter.first.second.string === 'hasOwnProperty' &&
-                                filter.second[0].string === this.first.string
-                            ) || (
-                                filter.first.first.id === '.' &&
-                                filter.first.first.first.id === '.' &&
-                                filter.first.first.first.first.string === 'Object' &&
-                                filter.first.first.first.second.string === 'prototype' &&
-                                filter.first.first.second.string === 'hasOwnProperty' &&
-                                filter.first.second.string === 'call' &&
-                                filter.second[0].string === this.second.string &&
-                                filter.second[1].string === this.first.string
-                            ));
-                            break;
+                    if (blok.length === 1 && typeof blok[0] === 'object') {
+                        if (blok[0].id === 'if' && !blok[0].else) {
+                            filter = blok[0].first;
+                            while (filter.id === '&&') {
+                                filter = filter.first;
+                            }
+                            switch (filter.id) {
+                            case '===':
+                            case '!==':
+                                ok = filter.first.id === '['
+                                    ? are_similar(filter.first.first, this.second) &&
+                                        are_similar(filter.first.second, this.first)
+                                    : filter.first.id === 'typeof' &&
+                                        filter.first.first.id === '[' &&
+                                        are_similar(filter.first.first.first, this.second) &&
+                                        are_similar(filter.first.first.second, this.first);
+                                break;
+                            case '(':
+                                ok = filter.first.id === '.' && ((
+                                    are_similar(filter.first.first, this.second) &&
+                                    filter.first.second.string === 'hasOwnProperty' &&
+                                    are_similar(filter.second[0], this.first)
+                                ) || (
+                                    filter.first.first.id === '.' &&
+                                    filter.first.first.first.first.string === 'Object' &&
+                                    filter.first.first.first.id === '.' &&
+                                    filter.first.first.first.second.string === 'prototype' &&
+                                    filter.first.first.second.string === 'hasOwnProperty' &&
+                                    filter.first.second.string === 'call' &&
+                                    are_similar(filter.second[0], this.second) &&
+                                    are_similar(filter.second[1], this.first)
+                                ));
+                                break;
+                            }
+                        } else if (blok[0].id === 'switch') {
+                            ok = blok[0].id === 'switch' &&
+                                blok[0].first.id === 'typeof' &&
+                                blok[0].first.first.id === '[' &&
+                                are_similar(blok[0].first.first.first, this.second) &&
+                                are_similar(blok[0].first.first.second, this.first);
                         }
                     }
                     if (!ok) {
@@ -3727,7 +3728,7 @@ klass:              do {
                 edge();
                 this.second = expected_relation(expression(0));
                 if (this.second.id !== 'true') {
-                    expected_condition(this.second, bundle.unexpected_a);
+                    expected_condition(this.second, 'unexpected_a');
                 }
                 semicolon(token);
                 if (next_token.id === ';') {
@@ -3807,9 +3808,6 @@ klass:              do {
                 this.first.warn('unexpected_a');
             }
         }
-        if (peek(0).id === '}' && peek(1).id === 'else') {
-            this.warn('unexpected_else');
-        }
         return this;
     });
 
@@ -4096,7 +4094,7 @@ klass:              do {
 
     itself.error_report = function (data) {
         var evidence, i, output = [], warning;
-        if (data.errors) {
+        if (data.errors.length) {
             if (data.json) {
                 output.push('<cite>JSON: bad.</cite><br>');
             }
@@ -4142,7 +4140,7 @@ klass:              do {
             detail('global', data.global);
             dl = true;
         } else if (data.json) {
-            if (!data.errors) {
+            if (!data.errors.length) {
                 output.push("<dt>JSON: good.</dt>");
             }
         } else {
@@ -4243,7 +4241,7 @@ klass:              do {
 
     itself.jslint = itself;
 
-    itself.edition = '2013-05-05';
+    itself.edition = '2013-07-02';
 
     return itself;
 }());

From 297c19f2f64fbf33099ac7b15ee65c2c236e2811 Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Tue, 23 Jul 2013 13:34:55 -0500
Subject: [PATCH 22/25] updated jslint.js to 2013-07-17, bumped package version

---
 jslint.js    | 5 +++--
 package.json | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/jslint.js b/jslint.js
index b0bbb66..07fd992 100644
--- a/jslint.js
+++ b/jslint.js
@@ -1,5 +1,5 @@
 // jslint.js
-// 2013-07-02
+// 2013-07-17
 
 // Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)
 
@@ -3692,6 +3692,7 @@ klass:              do {
                                     are_similar(filter.second[0], this.first)
                                 ) || (
                                     filter.first.first.id === '.' &&
+                                    filter.first.first.first.first &&
                                     filter.first.first.first.first.string === 'Object' &&
                                     filter.first.first.first.id === '.' &&
                                     filter.first.first.first.second.string === 'prototype' &&
@@ -4241,7 +4242,7 @@ klass:              do {
 
     itself.jslint = itself;
 
-    itself.edition = '2013-07-02';
+    itself.edition = '2013-07-17';
 
     return itself;
 }());
diff --git a/package.json b/package.json
index bbed950..3f75f42 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.9",
+    "version": "0.2.10",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",

From c6b4540309d4005a3416a615335eb4fa1a16518b Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Sun, 27 Oct 2013 08:33:53 -0500
Subject: [PATCH 23/25] updated to jslint 2013-09-22

---
 jslint.js | 324 +++++++++++++++++++++++++++---------------------------
 1 file changed, 164 insertions(+), 160 deletions(-)

diff --git a/jslint.js b/jslint.js
index 07fd992..57ccd2d 100644
--- a/jslint.js
+++ b/jslint.js
@@ -1,5 +1,5 @@
 // jslint.js
-// 2013-07-17
+// 2013-09-22
 
 // Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)
 
@@ -172,7 +172,7 @@
 // For example:
 
 /*jslint
-    es5: true, evil: true, nomen: true, regexp: true, todo: true
+    evil: true, nomen: true, regexp: true, todo: true
 */
 
 // The current option set is
@@ -185,7 +185,6 @@
 //     debug      true, if debugger statements should be allowed
 //     devel      true, if logging should be allowed (console, alert, etc.)
 //     eqeq       true, if == should be allowed
-//     es5        true, if ES5 syntax should be allowed
 //     evil       true, if eval should be allowed
 //     forin      true, if for in statements need not filter
 //     indent     the indentation factor
@@ -224,7 +223,7 @@
     conditional_assignment, confusing_a, confusing_regexp, constructor_name_a,
     continue, control_a, couch, create, d, dangling_a, data, dead, debug,
     deleted, devel, disrupt, duplicate_a, edge, edition, else, empty_block,
-    empty_case, empty_class, entityify, eqeq, error_report, errors, es5,
+    empty_case, empty_class, entityify, eqeq, error_report, errors,
     evidence, evil, exception, exec, expected_a_at_b_c, expected_a_b,
     expected_a_b_from_c_d, expected_id_a, expected_identifier_a,
     expected_identifier_a_reserved, expected_number_a, expected_operator_a,
@@ -243,13 +242,13 @@
     parameter, parameter_a_get_b, parameter_arguments_a, parameter_set_a,
     params, paren, passfail, plusplus, postscript, predef, properties,
     properties_report, property, prototype, push, quote, r, radix, raw,
-    read_only, reason, regexp, relation, replace, report, reserved, reserved_a,
-    rhino, right, scanned_a_b, scope, search, second, shift, slash_equal, slice,
-    sloppy, sort, split, statement, statement_block, stop, stopping,
-    strange_loop, strict, string, stupid, sub, subscript, substr, supplant,
-    sync_a, t, tag_a_in_b, test, third, thru, toString, todo, todo_comment,
-    token, tokens, too_long, too_many, trailing_decimal_a, tree, unclosed,
-    unclosed_comment, unclosed_regexp, unescaped_a, unexpected_a,
+    read_only, reason, redefinition_a_b, regexp, relation, replace, report,
+    reserved, reserved_a, rhino, right, scanned_a_b, scope, search, second,
+    shift, slash_equal, slice, sloppy, sort, split, statement, statement_block,
+    stop, stopping, strange_loop, strict, string, stupid, sub, subscript,
+    substr, supplant, sync_a, t, tag_a_in_b, test, third, thru, toString, todo,
+    todo_comment, token, tokens, too_long, too_many, trailing_decimal_a, tree,
+    unclosed, unclosed_comment, unclosed_regexp, unescaped_a, unexpected_a,
     unexpected_char_a, unexpected_comment, unexpected_label_a,
     unexpected_property_a, unexpected_space_a_b, unexpected_typeof_a,
     uninitialized_a, unnecessary_else, unnecessary_initialize, unnecessary_use,
@@ -295,7 +294,6 @@ var JSLINT = (function () {
             debug     : true,
             devel     : true,
             eqeq      : true,
-            es5       : true,
             evil      : true,
             forin     : true,
             indent    :   10,
@@ -383,7 +381,6 @@ var JSLINT = (function () {
             empty_block: "Empty block.",
             empty_case: "Empty case.",
             empty_class: "Empty class.",
-            es5: "This is an ES5 feature.",
             evil: "eval is evil.",
             expected_a_b: "Expected '{a}' and instead saw '{b}'.",
             expected_a_b_from_c_d: "Expected '{a}' to match '{b}' from line " +
@@ -440,6 +437,7 @@ var JSLINT = (function () {
             parameter_set_a: "Expected parameter (value) in set {a} function.",
             radix: "Missing radix parameter.",
             read_only: "Read only.",
+            redefinition_a_b: "Redefinition of '{a}' from line {b}.",
             reserved_a: "Reserved name '{a}'.",
             scanned_a_b: "{a} ({b}% scanned).",
             slash_equal: "A regular expression literal can be confused with '/='.",
@@ -583,9 +581,11 @@ var JSLINT = (function () {
         standard = array_to_object([
             'Array', 'Boolean', 'Date', 'decodeURI', 'decodeURIComponent',
             'encodeURI', 'encodeURIComponent', 'Error', 'eval', 'EvalError',
-            'Function', 'isFinite', 'isNaN', 'JSON', 'Math', 'Number',
-            'Object', 'parseInt', 'parseFloat', 'RangeError', 'ReferenceError',
-            'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError'
+            'Function', 'isFinite', 'isNaN', 'JSON', 'Map', 'Math', 'Number',
+            'Object', 'parseInt', 'parseFloat', 'Promise', 'Proxy',
+            'RangeError', 'ReferenceError', 'Reflect', 'RegExp', 'Set',
+            'String', 'Symbol', 'SyntaxError', 'System', 'TypeError',
+            'URIError', 'WeakMap', 'WeakSet'
         ], false),
 
         strict_mode,
@@ -677,7 +677,6 @@ var JSLINT = (function () {
         if (option.couch) {
             add_to_predefined(couch);
             option.couch = false;
-            option.es5 = true;
         }
         if (option.devel) {
             add_to_predefined(devel);
@@ -686,7 +685,6 @@ var JSLINT = (function () {
         if (option.node) {
             add_to_predefined(node);
             option.node = false;
-            option.es5 = true;
             node_js = true;
         }
         if (option.rhino) {
@@ -861,17 +859,17 @@ var JSLINT = (function () {
         }
 
         function string(x) {
-            var c, pos = 0, r = '', result;
+            var ch, at = 0, r = '', result;
 
             function hex(n) {
-                var i = parseInt(source_row.substr(pos + 1, n), 16);
-                pos += n;
+                var i = parseInt(source_row.substr(at + 1, n), 16);
+                at += n;
                 if (i >= 32 && i <= 126 &&
                         i !== 34 && i !== 92 && i !== 39) {
                     warn('unexpected_a', line, character, '\\');
                 }
                 character += n;
-                c = String.fromCharCode(i);
+                ch = String.fromCharCode(i);
             }
 
             if (json_mode && x !== '"') {
@@ -879,37 +877,35 @@ var JSLINT = (function () {
             }
 
             for (;;) {
-                while (pos >= source_row.length) {
-                    pos = 0;
+                while (at >= source_row.length) {
+                    at = 0;
                     if (!next_line()) {
                         stop('unclosed', line - 1, from);
                     }
                 }
-                c = source_row.charAt(pos);
-                if (c === x) {
+                ch = source_row.charAt(at);
+                if (ch === x) {
                     character += 1;
-                    source_row = source_row.slice(pos + 1);
+                    source_row = source_row.slice(at + 1);
                     result = it('(string)', r);
                     result.quote = x;
                     return result;
                 }
-                if (c < ' ') {
-                    if (c === '\n' || c === '\r') {
+                if (ch < ' ') {
+                    if (ch === '\n' || ch === '\r') {
                         break;
                     }
-                    warn('control_a', line, character + pos,
-                        source_row.slice(0, pos));
-                } else if (c === '\\') {
-                    pos += 1;
+                    warn('control_a', line, character + at,
+                        source_row.slice(0, at));
+                } else if (ch === '\\') {
+                    at += 1;
                     character += 1;
-                    c = source_row.charAt(pos);
-                    switch (c) {
+                    ch = source_row.charAt(at);
+                    switch (ch) {
                     case '':
-                        if (!option.es5) {
-                            warn('es5', line, character);
-                        }
+                        warn('unexpected_a', line, character, '\\');
                         next_line();
-                        pos = -1;
+                        at = -1;
                         break;
                     case '\'':
                         if (json_mode) {
@@ -923,7 +919,7 @@ var JSLINT = (function () {
                         if (json_mode) {
                             warn('unexpected_a', line, character, '\\v');
                         }
-                        c = '\v';
+                        ch = '\v';
                         break;
                     case 'x':
                         if (json_mode) {
@@ -932,17 +928,17 @@ var JSLINT = (function () {
                         hex(2);
                         break;
                     default:
-                        if (typeof descapes[c] !== 'string') {
-                            warn(c >= '0' && c <= '7' ? 'octal_a' : 'unexpected_a',
-                                line, character, '\\' + c);
+                        if (typeof descapes[ch] !== 'string') {
+                            warn(ch >= '0' && ch <= '7' ? 'octal_a' : 'unexpected_a',
+                                line, character, '\\' + ch);
                         } else {
-                            c = descapes[c];
+                            ch = descapes[ch];
                         }
                     }
                 }
-                r += c;
+                r += ch;
                 character += 1;
-                pos += 1;
+                at += 1;
             }
         }
 
@@ -989,45 +985,45 @@ var JSLINT = (function () {
         }
 
         function regexp() {
-            var b,
+            var at = 0,
+                b,
                 bit,
                 depth = 0,
                 flag = '',
                 high,
                 letter,
-                length = 0,
                 low,
                 potential,
                 quote,
                 result;
             for (;;) {
                 b = true;
-                c = source_row.charAt(length);
-                length += 1;
+                c = source_row.charAt(at);
+                at += 1;
                 switch (c) {
                 case '':
                     stop('unclosed_regexp', line, from);
                     return;
                 case '/':
                     if (depth > 0) {
-                        warn('unescaped_a', line, from + length, '/');
+                        warn('unescaped_a', line, from + at, '/');
                     }
-                    c = source_row.slice(0, length - 1);
+                    c = source_row.slice(0, at - 1);
                     potential = Object.create(regexp_flag);
                     for (;;) {
-                        letter = source_row.charAt(length);
+                        letter = source_row.charAt(at);
                         if (potential[letter] !== true) {
                             break;
                         }
                         potential[letter] = false;
-                        length += 1;
+                        at += 1;
                         flag += letter;
                     }
-                    if (source_row.charAt(length).isAlpha()) {
-                        stop('unexpected_a', line, from, source_row.charAt(length));
+                    if (source_row.charAt(at).isAlpha()) {
+                        stop('unexpected_a', line, from, source_row.charAt(at));
                     }
-                    character += length;
-                    source_row = source_row.slice(length);
+                    character += at;
+                    source_row = source_row.slice(at);
                     quote = source_row.charAt(0);
                     if (quote === '/' || quote === '*') {
                         stop('confusing_regexp', line, from);
@@ -1036,28 +1032,28 @@ var JSLINT = (function () {
                     result.flag = flag;
                     return result;
                 case '\\':
-                    c = source_row.charAt(length);
+                    c = source_row.charAt(at);
                     if (c < ' ') {
-                        warn('control_a', line, from + length, String(c));
+                        warn('control_a', line, from + at, String(c));
                     } else if (c === '<') {
-                        warn('unexpected_a', line, from + length, '\\');
+                        warn('unexpected_a', line, from + at, '\\');
                     }
-                    length += 1;
+                    at += 1;
                     break;
                 case '(':
                     depth += 1;
                     b = false;
-                    if (source_row.charAt(length) === '?') {
-                        length += 1;
-                        switch (source_row.charAt(length)) {
+                    if (source_row.charAt(at) === '?') {
+                        at += 1;
+                        switch (source_row.charAt(at)) {
                         case ':':
                         case '=':
                         case '!':
-                            length += 1;
+                            at += 1;
                             break;
                         default:
-                            warn('expected_a_b', line, from + length,
-                                ':', source_row.charAt(length));
+                            warn('expected_a_b', line, from + at,
+                                ':', source_row.charAt(at));
                         }
                     }
                     break;
@@ -1066,70 +1062,70 @@ var JSLINT = (function () {
                     break;
                 case ')':
                     if (depth === 0) {
-                        warn('unescaped_a', line, from + length, ')');
+                        warn('unescaped_a', line, from + at, ')');
                     } else {
                         depth -= 1;
                     }
                     break;
                 case ' ':
                     pos = 1;
-                    while (source_row.charAt(length) === ' ') {
-                        length += 1;
+                    while (source_row.charAt(at) === ' ') {
+                        at += 1;
                         pos += 1;
                     }
                     if (pos > 1) {
-                        warn('use_braces', line, from + length, pos);
+                        warn('use_braces', line, from + at, pos);
                     }
                     break;
                 case '[':
-                    c = source_row.charAt(length);
+                    c = source_row.charAt(at);
                     if (c === '^') {
-                        length += 1;
+                        at += 1;
                         if (!option.regexp) {
-                            warn('insecure_a', line, from + length, c);
-                        } else if (source_row.charAt(length) === ']') {
-                            stop('unescaped_a', line, from + length, '^');
+                            warn('insecure_a', line, from + at, c);
+                        } else if (source_row.charAt(at) === ']') {
+                            stop('unescaped_a', line, from + at, '^');
                         }
                     }
                     bit = false;
                     if (c === ']') {
-                        warn('empty_class', line, from + length - 1);
+                        warn('empty_class', line, from + at - 1);
                         bit = true;
                     }
 klass:              do {
-                        c = source_row.charAt(length);
-                        length += 1;
+                        c = source_row.charAt(at);
+                        at += 1;
                         switch (c) {
                         case '[':
                         case '^':
-                            warn('unescaped_a', line, from + length, c);
+                            warn('unescaped_a', line, from + at, c);
                             bit = true;
                             break;
                         case '-':
                             if (bit) {
                                 bit = false;
                             } else {
-                                warn('unescaped_a', line, from + length, '-');
+                                warn('unescaped_a', line, from + at, '-');
                                 bit = true;
                             }
                             break;
                         case ']':
                             if (!bit) {
-                                warn('unescaped_a', line, from + length - 1, '-');
+                                warn('unescaped_a', line, from + at - 1, '-');
                             }
                             break klass;
                         case '\\':
-                            c = source_row.charAt(length);
+                            c = source_row.charAt(at);
                             if (c < ' ') {
-                                warn('control_a', line, from + length, String(c));
+                                warn('control_a', line, from + at, String(c));
                             } else if (c === '<') {
-                                warn('unexpected_a', line, from + length, '\\');
+                                warn('unexpected_a', line, from + at, '\\');
                             }
-                            length += 1;
+                            at += 1;
                             bit = true;
                             break;
                         case '/':
-                            warn('unescaped_a', line, from + length - 1, '/');
+                            warn('unescaped_a', line, from + at - 1, '/');
                             bit = true;
                             break;
                         default:
@@ -1139,7 +1135,7 @@ klass:              do {
                     break;
                 case '.':
                     if (!option.regexp) {
-                        warn('insecure_a', line, from + length, c);
+                        warn('insecure_a', line, from + at, c);
                     }
                     break;
                 case ']':
@@ -1148,74 +1144,74 @@ klass:              do {
                 case '}':
                 case '+':
                 case '*':
-                    warn('unescaped_a', line, from + length, c);
+                    warn('unescaped_a', line, from + at, c);
                     break;
                 }
                 if (b) {
-                    switch (source_row.charAt(length)) {
+                    switch (source_row.charAt(at)) {
                     case '?':
                     case '+':
                     case '*':
-                        length += 1;
-                        if (source_row.charAt(length) === '?') {
-                            length += 1;
+                        at += 1;
+                        if (source_row.charAt(at) === '?') {
+                            at += 1;
                         }
                         break;
                     case '{':
-                        length += 1;
-                        c = source_row.charAt(length);
+                        at += 1;
+                        c = source_row.charAt(at);
                         if (c < '0' || c > '9') {
                             warn('expected_number_a', line,
-                                from + length, c);
+                                from + at, c);
                         }
-                        length += 1;
+                        at += 1;
                         low = +c;
                         for (;;) {
-                            c = source_row.charAt(length);
+                            c = source_row.charAt(at);
                             if (c < '0' || c > '9') {
                                 break;
                             }
-                            length += 1;
+                            at += 1;
                             low = +c + (low * 10);
                         }
                         high = low;
                         if (c === ',') {
-                            length += 1;
+                            at += 1;
                             high = Infinity;
-                            c = source_row.charAt(length);
+                            c = source_row.charAt(at);
                             if (c >= '0' && c <= '9') {
-                                length += 1;
+                                at += 1;
                                 high = +c;
                                 for (;;) {
-                                    c = source_row.charAt(length);
+                                    c = source_row.charAt(at);
                                     if (c < '0' || c > '9') {
                                         break;
                                     }
-                                    length += 1;
+                                    at += 1;
                                     high = +c + (high * 10);
                                 }
                             }
                         }
-                        if (source_row.charAt(length) !== '}') {
-                            warn('expected_a_b', line, from + length,
+                        if (source_row.charAt(at) !== '}') {
+                            warn('expected_a_b', line, from + at,
                                 '}', c);
                         } else {
-                            length += 1;
+                            at += 1;
                         }
-                        if (source_row.charAt(length) === '?') {
-                            length += 1;
+                        if (source_row.charAt(at) === '?') {
+                            at += 1;
                         }
                         if (low > high) {
-                            warn('not_greater', line, from + length,
+                            warn('not_greater', line, from + at,
                                 low, high);
                         }
                         break;
                     }
                 }
             }
-            c = source_row.slice(0, length - 1);
-            character += length;
-            source_row = source_row.slice(length);
+            c = source_row.slice(0, at - 1);
+            character += at;
+            source_row = source_row.slice(at);
             return it('(regexp)', c);
         }
 
@@ -1236,7 +1232,7 @@ klass:              do {
 // token -- this is called by advance to get the next token.
 
             token: function () {
-                var c, i, snippet;
+                var first, i, snippet;
 
                 for (;;) {
                     while (!source_row) {
@@ -1249,14 +1245,14 @@ klass:              do {
 
 //      identifier
 
-                        c = snippet.charAt(0);
-                        if (c.isAlpha() || c === '_' || c === '$') {
+                        first = snippet.charAt(0);
+                        if (first.isAlpha() || first === '_' || first === '$') {
                             return it('(identifier)', snippet);
                         }
 
 //      number
 
-                        if (c.isDigit()) {
+                        if (first.isDigit()) {
                             return number(snippet);
                         }
                         switch (snippet) {
@@ -1333,7 +1329,7 @@ klass:              do {
         token.kind = kind;
         token.master = master;
         token.used = 0;
-        token.writeable = false;
+        token.writeable = true;
 
 // Global variables are a little weird. They can be defined multiple times.
 // Some predefined global vars are (or should) not be writeable.
@@ -1350,9 +1346,16 @@ klass:              do {
 // It is an error if the name has already been defined in this scope, except
 // when reusing an exception variable name.
 
-            if (master && master.function === funct) {
-                if (master.kind !== 'exception' || kind !== 'exception' || !master.dead) {
-                    token.warn('already_defined', name);
+            if (master) {
+                if (master.function === funct) {
+                    if (master.kind !== 'exception' || kind !== 'exception' ||
+                            !master.dead) {
+                        token.warn('already_defined', name);
+                    }
+                } else if (master.function !== global_funct) {
+                    if (kind === 'var') {
+                        token.warn('redefinition_a_b', name, master.line);
+                    }
                 }
             }
             scope[name] = token;
@@ -2234,7 +2237,7 @@ klass:              do {
     function optional_identifier(variable) {
         if (next_token.identifier) {
             advance();
-            if (token.reserved && (!option.es5 || variable)) {
+            if (token.reserved && variable) {
                 token.warn('expected_identifier_a_reserved');
             }
             return token.string;
@@ -2581,11 +2584,7 @@ klass:              do {
 
     prefix('void', function (that) {
         that.first = expression(0);
-        if (option.es5 || strict_mode) {
-            that.warn('expected_a_b', 'undefined', 'void');
-        } else if (that.first.number !== 0) {
-            that.first.warn('expected_a_b', '0', artifact(that.first));
-        }
+        that.warn('expected_a_b', 'undefined', 'void');
         return that;
     });
 
@@ -2867,7 +2866,7 @@ klass:              do {
             if (left.string.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) {
                 if (left.string !== 'Number' && left.string !== 'String' &&
                         left.string !== 'Boolean' && left.string !== 'Date') {
-                    if (left.string === 'Math' || left.string === 'JSON') {
+                    if (left.string === 'Math') {
                         left.warn('not_a_function');
                     } else if (left.string === 'Object') {
                         token.warn('use_object');
@@ -2875,6 +2874,8 @@ klass:              do {
                         left.warn('missing_a', 'new');
                     }
                 }
+            } else if (left.string === 'JSON') {
+                left.warn('not_a_function');
             }
         } else if (left.id === '.') {
             if (left.second.string === 'split' &&
@@ -3047,7 +3048,7 @@ klass:              do {
             that.first.push(expression(10));
             if (next_token.id === ',') {
                 comma();
-                if (next_token.id === ']' && !option.es5) {
+                if (next_token.id === ']') {
                     token.warn('unexpected_a');
                     break;
                 }
@@ -3160,7 +3161,7 @@ klass:              do {
     }
 
     prefix('{', function (that) {
-        var get, i, j, name, p, set, seen = Object.create(null);
+        var get, i, j, name, set, seen = Object.create(null);
         that.first = [];
         step_in();
         while (next_token.id !== '}') {
@@ -3171,9 +3172,6 @@ klass:              do {
 
             edge();
             if (next_token.string === 'get' && peek().id !== ':') {
-                if (!option.es5) {
-                    next_token.warn('es5');
-                }
                 get = next_token;
                 advance('get');
                 one_space_only();
@@ -3187,9 +3185,8 @@ klass:              do {
                 if (funct.loopage) {
                     get.warn('function_loop');
                 }
-                p = get.first;
-                if (p && p.length) {
-                    p[0].warn('parameter_a_get_b', p[0].string, i);
+                if (get.function.parameter.length) {
+                    get.warn('parameter_a_get_b', get.function.parameter[0], i);
                 }
                 comma();
                 set = next_token;
@@ -3206,11 +3203,11 @@ klass:              do {
                 if (set.block.length === 0) {
                     token.warn('missing_a', 'throw');
                 }
-                p = set.first;
-                if (!p || p.length !== 1) {
+                if (set.function.parameter.length === 0) {
                     set.stop('parameter_set_a', 'value');
-                } else if (p[0].string !== 'value') {
-                    p[0].stop('expected_a_b', 'value', p[0].string);
+                } else if (set.function.parameter[0] !== 'value') {
+                    set.stop('expected_a_b', 'value',
+                        set.function.parameter[0]);
                 }
                 name.first = [get, set];
             } else {
@@ -3239,7 +3236,7 @@ klass:              do {
                 }
                 next_token.warn('unexpected_a');
             }
-            if (next_token.id === '}' && !option.es5) {
+            if (next_token.id === '}') {
                 token.warn('unexpected_a');
             }
         }
@@ -3291,6 +3288,9 @@ klass:              do {
             define('var', name);
             name.dead = funct;
             if (next_token.id === '=') {
+                if (funct === global_funct && !name.writeable) {
+                    name.warn('read_only');
+                }
                 assign = next_token;
                 assign.first = name;
                 spaces();
@@ -3338,6 +3338,9 @@ klass:              do {
         var name = next_token,
             id = identifier(true);
         define('var', name);
+        if (!name.writeable) {
+            name.warn('read_only');
+        }
         name.init = true;
         name.statement = true;
         no_space();
@@ -3373,6 +3376,7 @@ klass:              do {
         case ']':
         case '}':
         case ':':
+        case '(end)':
             break;
         case '.':
             if (peek().string !== 'bind' || peek(1).id !== '(') {
@@ -4051,14 +4055,14 @@ klass:              do {
         var data = {functions: []},
             function_data,
             i,
-            scope,
-            the_function;
+            the_function,
+            the_scope;
         data.errors = itself.errors;
         data.json = json_mode;
         data.global = unique(Object.keys(global_scope));
 
         function selects(name) {
-            var kind = scope[name].kind;
+            var kind = the_scope[name].kind;
             switch (kind) {
             case 'var':
             case 'exception':
@@ -4082,8 +4086,8 @@ klass:              do {
                 global: unique(the_function.global),
                 label: []
             };
-            scope = the_function.scope;
-            Object.keys(scope).forEach(selects);
+            the_scope = the_function.scope;
+            Object.keys(the_scope).forEach(selects);
             function_data.var.sort();
             function_data.exception.sort();
             function_data.label.sort();
@@ -4164,8 +4168,7 @@ klass:              do {
                 }
                 output.push('<dl class=level' + the_function.level +
                     '><address>line ' + String(the_function.line) +
-                    '</address>' + the_function.name.entityify() + '(' +
-                    names.join(', ') + ')');
+                    '</address>' + the_function.name.entityify());
                 detail('parameter', the_function.parameter);
                 detail('variable', the_function.var);
                 detail('exception', the_function.exception);
@@ -4218,18 +4221,19 @@ klass:              do {
             line,
             result = [],
             thru,
-            token = data.tokens[0];
-        while (token && token.id !== '(end)') {
-            from = token.from;
-            line = token.line;
-            thru = token.thru;
-            level = token.function.level;
+            data_token = data.tokens[0];
+        while (data_token && data_token.id !== '(end)') {
+            from = data_token.from;
+            line = data_token.line;
+            thru = data_token.thru;
+            level = data_token.function.level;
             do {
-                thru = token.thru;
-                token = data.tokens[i];
+                thru = data_token.thru;
+                data_token = data.tokens[i];
                 i += 1;
-            } while (token && token.line === line && token.from - thru < 5 &&
-                    level === token.function.level);
+            } while (data_token && data_token.line === line &&
+                    data_token.from - thru < 5 &&
+                    level === data_token.function.level);
             result.push({
                 line: line,
                 level: level,
@@ -4242,7 +4246,7 @@ klass:              do {
 
     itself.jslint = itself;
 
-    itself.edition = '2013-07-17';
+    itself.edition = '2013-09-22';
 
     return itself;
 }());

From 6945601f83c56056e435dbce6b3319e7eba8656e Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Sun, 27 Oct 2013 08:34:41 -0500
Subject: [PATCH 24/25] bumped npm version

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 3f75f42..666d004 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.10",
+    "version": "0.2.11",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",

From b0cb6e6f668bb1a19649776b9a3f1b6a29fd810b Mon Sep 17 00:00:00 2001
From: Chad Walker <chad@chad-cat-lore-eddie.com>
Date: Tue, 19 Nov 2013 11:54:12 -0600
Subject: [PATCH 25/25] Updated to newest jslint.js (2013-11-13)

- made a tweak so that jslinter without any options dumps your current
- bump npm version
---
 jslint.curl  | 8 ++++++--
 jslint.js    | 6 +++---
 package.json | 2 +-
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/jslint.curl b/jslint.curl
index f807d25..30d41b6 100755
--- a/jslint.curl
+++ b/jslint.curl
@@ -1,7 +1,11 @@
 #!/bin/bash
 # A faster way to jslint; curl's start-up cost is much lower than rhino's.
-JSLINT_URL="http://localhost:3003/jslint"
-RESULTS=`curl -s --form pretty="1" --form source="<${1}" --form filename="${1}" ${JSLINT_URL}`
+JSLINT_URL="http://localhost:3003/"
+if [[ -z $1 ]] ; then
+    RESULTS=`curl -s ${JSLINT_URL}`
+else
+    RESULTS=`curl -s --form pretty="1" --form source="<${1}" --form filename="${1}" ${JSLINT_URL}jslint`
+fi
 echo "$RESULTS"
 if [[ `echo "$RESULTS" | wc -l` -gt 1 ]] ; then
     exit 1
diff --git a/jslint.js b/jslint.js
index 57ccd2d..d9f92da 100644
--- a/jslint.js
+++ b/jslint.js
@@ -1,5 +1,5 @@
 // jslint.js
-// 2013-09-22
+// 2013-11-13
 
 // Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)
 
@@ -2798,7 +2798,7 @@ klass:              do {
                         if (next_token.id !== ')') {
                             n = expression(0);
                             p.second = [n];
-                            if (n.id !== '(number)' || next_token.id === ',') {
+                            if (n.id === '(string)' || next_token.id === ',') {
                                 p.warn('use_array');
                             }
                             while (next_token.id === ',') {
@@ -4246,7 +4246,7 @@ klass:              do {
 
     itself.jslint = itself;
 
-    itself.edition = '2013-09-22';
+    itself.edition = '2013-11-13';
 
     return itself;
 }());
diff --git a/package.json b/package.json
index 666d004..2bc21a9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "lintnode",
-    "version": "0.2.11",
+    "version": "0.2.12",
     "description": "A JSLint server for more expedient linting.",
     "keywords": ["emacs", "flymake", "js-mode", "jslint"],
     "homepage": "http://github.com/chad3814/lintnode",