]> source.dussan.org Git - jquery.git/commitdiff
Take out the papers and the trash (from build/)
authorRick Waldron <waldron.rick@gmail.com>
Mon, 4 Jun 2012 16:53:53 +0000 (12:53 -0400)
committerRick Waldron <waldron.rick@gmail.com>
Mon, 4 Jun 2012 16:53:53 +0000 (12:53 -0400)
build/freq.js [deleted file]
build/jshint-check.js [deleted file]
build/lib/jshint.js [deleted file]
build/lib/parse-js.js [deleted file]
build/lib/process.js [deleted file]
build/lib/squeeze-more.js [deleted file]
build/post-compile.js [deleted file]
build/sizer.js [deleted file]
build/uglify.js [deleted file]

diff --git a/build/freq.js b/build/freq.js
deleted file mode 100644 (file)
index 0549f6a..0000000
+++ /dev/null
@@ -1,79 +0,0 @@
-#! /usr/bin/env node
-
-var fs = require( "fs" );
-
-function isEmptyObject( obj ) {
-       for ( var name in obj ) {
-               return false;
-       }
-       return true;
-}
-function extend( obj ) {
-       var dest = obj,
-       src = [].slice.call( arguments, 1 );
-
-       Object.keys( src ).forEach(function( key ) {
-               var copy = src[ key ];
-
-               for ( var prop in copy ) {
-                       dest[ prop ] = copy[ prop ];
-               }
-       });
-
-       return dest;
-};
-
-function charSort( obj, callback ) {
-
-       var ordered = [],
-               table = {},
-               copied;
-
-       copied = extend({}, obj );
-
-       (function order() {
-
-               var largest = 0,
-                               c;
-
-               for ( var i in obj ) {
-                       if ( obj[ i ] >= largest ) {
-                               largest = obj[ i ];
-                               c = i;
-                       }
-               }
-
-               ordered.push( c );
-               delete obj[ c ];
-
-               if ( !isEmptyObject( obj ) ) {
-                       order();
-               } else {
-                       ordered.forEach(function( val ) {
-                               table[ val ] = copied[ val ];
-                       });
-
-                       callback( table );
-               }
-
-       })();
-}
-function charFrequency( src, callback ) {
-       var obj = {};
-
-       src.replace(/[^\w]|\d/gi, "").split("").forEach(function( c ) {
-               obj[ c ] ? ++obj[ c ] : ( obj[ c ] = 1 );
-       });
-
-       return charSort( obj, callback );
-}
-
-
-charFrequency( fs.readFileSync( "dist/jquery.min.js", "utf8" ), function( obj ) {
-       var chr;
-
-       for ( chr in obj ) {
-               console.log( "  " + chr + "   " + obj[ chr ] );
-       }
-});
-
diff --git a/build/jshint-check.js b/build/jshint-check.js
deleted file mode 100644 (file)
index 2594539..0000000
+++ /dev/null
@@ -1,37 +0,0 @@
-var jshint = require("./lib/jshint").JSHINT,
-               src = require("fs").readFileSync("dist/jquery.js", "utf8"),
-               config = {
-                       evil: true,
-                       browser: true,
-                       wsh: true,
-                       eqnull: true,
-                       expr: true,
-                       curly: true,
-                       trailing: true,
-                       undef: true,
-                       smarttabs: true,
-                       predef: [
-                               "define",
-                               "DOMParser"
-                       ],
-                       maxerr: 100
-               };
-
-if ( jshint( src, config ) ) {
-       console.log("JSHint check passed.");
-} else {
-
-       console.log( "JSHint found errors." );
-
-       jshint.errors.forEach(function( e ) {
-               if ( !e ) { return; }
-
-               var str = e.evidence ? e.evidence : "",
-               character = e.character === true ? "EOL" : "C" + e.character;
-
-               if ( str ) {
-                       str = str.replace( /\t/g, " " ).trim();
-                       console.log( " [L" + e.line + ":" + character + "] " + e.reason + "\n  " + str + "\n");
-               }
-       });
-}
\ No newline at end of file
diff --git a/build/lib/jshint.js b/build/lib/jshint.js
deleted file mode 100644 (file)
index a1ec53a..0000000
+++ /dev/null
@@ -1,4359 +0,0 @@
-/*!
- * JSHint, by JSHint Community.
- *
- * Licensed under the same slightly modified MIT license that JSLint is.
- * It stops evil-doers everywhere.
- *
- * JSHint is a derivative work of JSLint:
- *
- *   Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)
- *
- *   Permission is hereby granted, free of charge, to any person obtaining
- *   a copy of this software and associated documentation files (the "Software"),
- *   to deal in the Software without restriction, including without limitation
- *   the rights to use, copy, modify, merge, publish, distribute, sublicense,
- *   and/or sell copies of the Software, and to permit persons to whom
- *   the Software is furnished to do so, subject to the following conditions:
- *
- *   The above copyright notice and this permission notice shall be included
- *   in all copies or substantial portions of the Software.
- *
- *   The Software shall be used for Good, not Evil.
- *
- *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- *   DEALINGS IN THE SOFTWARE.
- *
- * JSHint was forked from 2010-12-16 edition of JSLint.
- *
- */
-
-/*
- JSHINT is a global function. It takes two parameters.
-
-     var myResult = JSHINT(source, option);
-
- 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 a JSON text.
-
- The second parameter is an optional object of options which control the
- operation of JSHINT. Most of the options are booleans: They are all
- optional and have a default value of false. One of the options, predef,
- can be an array of names, which will be used to declare global variables,
- or an object whose keys are used as global names, with a boolean value
- that determines if they are assignable.
-
- If it checks out, JSHINT returns true. Otherwise, it returns false.
-
- If false, you can inspect JSHINT.errors to find out the problems.
- JSHINT.errors is an array of objects containing these members:
-
- {
-     line      : The line (relative to 0) at which the lint was found
-     character : The character (relative to 0) at which the lint was found
-     reason    : The problem
-     evidence  : The text line in which the problem occurred
-     raw       : The raw message before the details were inserted
-     a         : The first detail
-     b         : The second detail
-     c         : The third detail
-     d         : The fourth detail
- }
-
- If a fatal error was found, a null will be the last element of the
- JSHINT.errors array.
-
- 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>.
-
-     var myReport = JSHINT.report(limited);
-
- If limited is true, then the report will be limited to only errors.
-
- You can request a data structure which contains JSHint's results.
-
-     var myData = JSHINT.data();
-
- It returns a structure with this form:
-
- {
-     errors: [
-         {
-             line: NUMBER,
-             character: NUMBER,
-             reason: STRING,
-             evidence: STRING
-         }
-     ],
-     functions: [
-         name: STRING,
-         line: NUMBER,
-         last: NUMBER,
-         param: [
-             STRING
-         ],
-         closure: [
-             STRING
-         ],
-         var: [
-             STRING
-         ],
-         exception: [
-             STRING
-         ],
-         outer: [
-             STRING
-         ],
-         unused: [
-             STRING
-         ],
-         global: [
-             STRING
-         ],
-         label: [
-             STRING
-         ]
-     ],
-     globals: [
-         STRING
-     ],
-     member: {
-         STRING: NUMBER
-     },
-     unused: [
-         {
-             name: STRING,
-             line: NUMBER
-         }
-     ],
-     implieds: [
-         {
-             name: STRING,
-             line: NUMBER
-         }
-     ],
-     urls: [
-         STRING
-     ],
-     json: BOOLEAN
- }
-
- Empty arrays will not be included.
-
-*/
-
-/*jshint
- evil: true, nomen: false, onevar: false, regexp: false, strict: true, boss: true,
- undef: true, maxlen: 100, indent:4
-*/
-
-/*members "\b", "\t", "\n", "\f", "\r", "!=", "!==", "\"", "%", "(begin)",
- "(breakage)", "(context)", "(error)", "(global)", "(identifier)", "(last)",
- "(line)", "(loopage)", "(name)", "(onevar)", "(params)", "(scope)",
- "(statement)", "(verb)", "*", "+", "++", "-", "--", "\/", "<", "<=", "==",
- "===", ">", ">=", $, $$, $A, $F, $H, $R, $break, $continue, $w, Abstract, Ajax,
- __filename, __dirname, ActiveXObject, Array, ArrayBuffer, ArrayBufferView, Audio,
- Autocompleter, Assets, Boolean, Builder, Buffer, Browser, COM, CScript, Canvas,
- CustomAnimation, Class, Control, Chain, Color, Cookie, Core, DataView, Date,
- Debug, Draggable, Draggables, Droppables, Document, DomReady, DOMReady, Drag,
- E, Enumerator, Enumerable, Element, Elements, Error, Effect, EvalError, Event,
- Events, FadeAnimation, Field, Flash, Float32Array, Float64Array, Form,
- FormField, Frame, FormData, Function, Fx, GetObject, Group, Hash, HotKey,
- HTMLElement, HTMLAnchorElement, HTMLBaseElement, HTMLBlockquoteElement,
- HTMLBodyElement, HTMLBRElement, HTMLButtonElement, HTMLCanvasElement, HTMLDirectoryElement,
- HTMLDivElement, HTMLDListElement, HTMLFieldSetElement,
- HTMLFontElement, HTMLFormElement, HTMLFrameElement, HTMLFrameSetElement,
- HTMLHeadElement, HTMLHeadingElement, HTMLHRElement, HTMLHtmlElement,
- HTMLIFrameElement, HTMLImageElement, HTMLInputElement, HTMLIsIndexElement,
- HTMLLabelElement, HTMLLayerElement, HTMLLegendElement, HTMLLIElement,
- HTMLLinkElement, HTMLMapElement, HTMLMenuElement, HTMLMetaElement,
- HTMLModElement, HTMLObjectElement, HTMLOListElement, HTMLOptGroupElement,
- HTMLOptionElement, HTMLParagraphElement, HTMLParamElement, HTMLPreElement,
- HTMLQuoteElement, HTMLScriptElement, HTMLSelectElement, HTMLStyleElement,
- HtmlTable, HTMLTableCaptionElement, HTMLTableCellElement, HTMLTableColElement,
- HTMLTableElement, HTMLTableRowElement, HTMLTableSectionElement,
- HTMLTextAreaElement, HTMLTitleElement, HTMLUListElement, HTMLVideoElement,
- Iframe, IframeShim, Image, Int16Array, Int32Array, Int8Array,
- Insertion, InputValidator, JSON, Keyboard, Locale, LN10, LN2, LOG10E, LOG2E,
- MAX_VALUE, MIN_VALUE, Mask, Math, MenuItem, MoveAnimation, MooTools, Native,
- NEGATIVE_INFINITY, Number, Object, ObjectRange, Option, Options, OverText, PI,
- POSITIVE_INFINITY, PeriodicalExecuter, Point, Position, Prototype, RangeError,
- Rectangle, ReferenceError, RegExp, ResizeAnimation, Request, RotateAnimation,
- SQRT1_2, SQRT2, ScrollBar, ScriptEngine, ScriptEngineBuildVersion,
- ScriptEngineMajorVersion, ScriptEngineMinorVersion, Scriptaculous, Scroller,
- Slick, Slider, Selector, SharedWorker, String, Style, SyntaxError, Sortable, Sortables,
- SortableObserver, Sound, Spinner, System, Swiff, Text, TextArea, Template,
- Timer, Tips, Type, TypeError, Toggle, Try, "use strict", unescape, URI, URIError, URL,
- VBArray, WSH, WScript, XDomainRequest, Web, Window, XMLDOM, XMLHttpRequest, XPathEvaluator,
- XPathException, XPathExpression, XPathNamespace, XPathNSResolver, XPathResult, "\\", a,
- addEventListener, address, alert, apply, applicationCache, arguments, arity,
- asi, b, basic, basicToken, bitwise, block, blur, boolOptions, boss, browser, c, call, callee,
- caller, cases, charAt, charCodeAt, character, clearInterval, clearTimeout,
- close, closed, closure, comment, condition, confirm, console, constructor,
- content, couch, create, css, curly, d, data, datalist, dd, debug, decodeURI,
- decodeURIComponent, defaultStatus, defineClass, deserialize, devel, document,
- dojo, dijit, dojox, define, else, emit, encodeURI, encodeURIComponent,
- entityify, eqeqeq, eqnull, errors, es5, escape, esnext, eval, event, evidence, evil,
- ex, exception, exec, exps, expr, exports, FileReader, first, floor, focus,
- forin, fragment, frames, from, fromCharCode, fud, funcscope, funct, function, functions,
- g, gc, getComputedStyle, getRow, getter, getterToken, GLOBAL, global, globals, globalstrict,
- hasOwnProperty, help, history, i, id, identifier, immed, implieds, importPackage, include,
- indent, indexOf, init, ins, instanceOf, isAlpha, isApplicationRunning, isArray,
- isDigit, isFinite, isNaN, iterator, java, join, jshint,
- JSHINT, json, jquery, jQuery, keys, label, labelled, last, lastsemic, laxbreak, laxcomma,
- latedef, lbp, led, left, length, line, load, loadClass, localStorage, location,
- log, loopfunc, m, match, maxerr, maxlen, member,message, meta, module, moveBy,
- moveTo, mootools, multistr, name, navigator, new, newcap, noarg, node, noempty, nomen,
- nonew, nonstandard, nud, onbeforeunload, onblur, onerror, onevar, onecase, onfocus,
- onload, onresize, onunload, open, openDatabase, openURL, opener, opera, options, outer, param,
- parent, parseFloat, parseInt, passfail, plusplus, predef, print, process, prompt,
- proto, prototype, prototypejs, provides, push, quit, range, raw, reach, reason, regexp,
- readFile, readUrl, regexdash, removeEventListener, replace, report, require,
- reserved, resizeBy, resizeTo, resolvePath, resumeUpdates, respond, rhino, right,
- runCommand, scroll, screen, scripturl, scrollBy, scrollTo, scrollbar, search, seal,
- send, serialize, sessionStorage, setInterval, setTimeout, setter, setterToken, shift, slice,
- smarttabs, sort, spawn, split, stack, status, start, strict, sub, substr, supernew, shadow,
- supplant, sum, sync, test, toLowerCase, toString, toUpperCase, toint32, token, top, trailing,
- type, typeOf, Uint16Array, Uint32Array, Uint8Array, undef, undefs, unused, urls, validthis,
- value, valueOf, var, version, WebSocket, white, window, Worker, wsh*/
-
-/*global exports: false */
-
-// We build the application inside a function so that we produce only a single
-// global variable. That function will be invoked immediately, and its return
-// value is the JSHINT function itself.
-
-var JSHINT = (function () {
-    "use strict";
-
-    var anonname,       // The guessed name for anonymous functions.
-
-// These are operators that should not be used with the ! operator.
-
-        bang = {
-            '<'  : true,
-            '<=' : true,
-            '==' : true,
-            '===': true,
-            '!==': true,
-            '!=' : true,
-            '>'  : true,
-            '>=' : true,
-            '+'  : true,
-            '-'  : true,
-            '*'  : true,
-            '/'  : true,
-            '%'  : true
-        },
-
-        // These are the JSHint boolean options.
-        boolOptions = {
-            asi         : true, // if automatic semicolon insertion should be tolerated
-            bitwise     : true, // if bitwise operators should not be allowed
-            boss        : true, // if advanced usage of assignments should be allowed
-            browser     : true, // if the standard browser globals should be predefined
-            couch       : true, // if CouchDB globals should be predefined
-            curly       : true, // if curly braces around all blocks should be required
-            debug       : true, // if debugger statements should be allowed
-            devel       : true, // if logging globals should be predefined (console,
-                                // alert, etc.)
-            dojo        : true, // if Dojo Toolkit globals should be predefined
-            eqeqeq      : true, // if === should be required
-            eqnull      : true, // if == null comparisons should be tolerated
-            es5         : true, // if ES5 syntax should be allowed
-            esnext      : true, // if es.next specific syntax should be allowed
-            evil        : true, // if eval should be allowed
-            expr        : true, // if ExpressionStatement should be allowed as Programs
-            forin       : true, // if for in statements must filter
-            funcscope   : true, // if only function scope should be used for scope tests
-            globalstrict: true, // if global "use strict"; should be allowed (also
-                                // enables 'strict')
-            immed       : true, // if immediate invocations must be wrapped in parens
-            iterator    : true, // if the `__iterator__` property should be allowed
-            jquery      : true, // if jQuery globals should be predefined
-            lastsemic   : true, // if semicolons may be ommitted for the trailing
-                                // statements inside of a one-line blocks.
-            latedef     : true, // if the use before definition should not be tolerated
-            laxbreak    : true, // if line breaks should not be checked
-            laxcomma    : true, // if line breaks should not be checked around commas
-            loopfunc    : true, // if functions should be allowed to be defined within
-                                // loops
-            mootools    : true, // if MooTools globals should be predefined
-            multistr    : true, // allow multiline strings
-            newcap      : true, // if constructor names must be capitalized
-            noarg       : true, // if arguments.caller and arguments.callee should be
-                                // disallowed
-            node        : true, // if the Node.js environment globals should be
-                                // predefined
-            noempty     : true, // if empty blocks should be disallowed
-            nonew       : true, // if using `new` for side-effects should be disallowed
-            nonstandard : true, // if non-standard (but widely adopted) globals should
-                                // be predefined
-            nomen       : true, // if names should be checked
-            onevar      : true, // if only one var statement per function should be
-                                // allowed
-            onecase     : true, // if one case switch statements should be allowed
-            passfail    : true, // if the scan should stop on first error
-            plusplus    : true, // if increment/decrement should not be allowed
-            proto       : true, // if the `__proto__` property should be allowed
-            prototypejs : true, // if Prototype and Scriptaculous globals should be
-                                // predefined
-            regexdash   : true, // if unescaped first/last dash (-) inside brackets
-                                // should be tolerated
-            regexp      : true, // if the . should not be allowed in regexp literals
-            rhino       : true, // if the Rhino environment globals should be predefined
-            undef       : true, // if variables should be declared before used
-            scripturl   : true, // if script-targeted URLs should be tolerated
-            shadow      : true, // if variable shadowing should be tolerated
-            smarttabs   : true, // if smarttabs should be tolerated
-                                // (http://www.emacswiki.org/emacs/SmartTabs)
-            strict      : true, // require the "use strict"; pragma
-            sub         : true, // if all forms of subscript notation are tolerated
-            supernew    : true, // if `new function () { ... };` and `new Object;`
-                                // should be tolerated
-            trailing    : true, // if trailing whitespace rules apply
-            validthis   : true, // if 'this' inside a non-constructor function is valid.
-                                // This is a function scoped option only.
-            white       : true, // if strict whitespace rules apply
-            wsh         : true  // if the Windows Scripting Host environment globals
-                                // should be predefined
-        },
-
-        // browser contains a set of global names which are commonly provided by a
-        // web browser environment.
-        browser = {
-            ArrayBuffer              :  false,
-            ArrayBufferView          :  false,
-            Audio                    :  false,
-            addEventListener         :  false,
-            applicationCache         :  false,
-            blur                     :  false,
-            clearInterval            :  false,
-            clearTimeout             :  false,
-            close                    :  false,
-            closed                   :  false,
-            DataView                 :  false,
-            defaultStatus            :  false,
-            document                 :  false,
-            event                    :  false,
-            FileReader               :  false,
-            Float32Array             :  false,
-            Float64Array             :  false,
-            FormData                 :  false,
-            focus                    :  false,
-            frames                   :  false,
-            getComputedStyle         :  false,
-            HTMLElement              :  false,
-            HTMLAnchorElement        :  false,
-            HTMLBaseElement          :  false,
-            HTMLBlockquoteElement    :  false,
-            HTMLBodyElement          :  false,
-            HTMLBRElement            :  false,
-            HTMLButtonElement        :  false,
-            HTMLCanvasElement        :  false,
-            HTMLDirectoryElement     :  false,
-            HTMLDivElement           :  false,
-            HTMLDListElement         :  false,
-            HTMLFieldSetElement      :  false,
-            HTMLFontElement          :  false,
-            HTMLFormElement          :  false,
-            HTMLFrameElement         :  false,
-            HTMLFrameSetElement      :  false,
-            HTMLHeadElement          :  false,
-            HTMLHeadingElement       :  false,
-            HTMLHRElement            :  false,
-            HTMLHtmlElement          :  false,
-            HTMLIFrameElement        :  false,
-            HTMLImageElement         :  false,
-            HTMLInputElement         :  false,
-            HTMLIsIndexElement       :  false,
-            HTMLLabelElement         :  false,
-            HTMLLayerElement         :  false,
-            HTMLLegendElement        :  false,
-            HTMLLIElement            :  false,
-            HTMLLinkElement          :  false,
-            HTMLMapElement           :  false,
-            HTMLMenuElement          :  false,
-            HTMLMetaElement          :  false,
-            HTMLModElement           :  false,
-            HTMLObjectElement        :  false,
-            HTMLOListElement         :  false,
-            HTMLOptGroupElement      :  false,
-            HTMLOptionElement        :  false,
-            HTMLParagraphElement     :  false,
-            HTMLParamElement         :  false,
-            HTMLPreElement           :  false,
-            HTMLQuoteElement         :  false,
-            HTMLScriptElement        :  false,
-            HTMLSelectElement        :  false,
-            HTMLStyleElement         :  false,
-            HTMLTableCaptionElement  :  false,
-            HTMLTableCellElement     :  false,
-            HTMLTableColElement      :  false,
-            HTMLTableElement         :  false,
-            HTMLTableRowElement      :  false,
-            HTMLTableSectionElement  :  false,
-            HTMLTextAreaElement      :  false,
-            HTMLTitleElement         :  false,
-            HTMLUListElement         :  false,
-            HTMLVideoElement         :  false,
-            history                  :  false,
-            Int16Array               :  false,
-            Int32Array               :  false,
-            Int8Array                :  false,
-            Image                    :  false,
-            length                   :  false,
-            localStorage             :  false,
-            location                 :  false,
-            moveBy                   :  false,
-            moveTo                   :  false,
-            name                     :  false,
-            navigator                :  false,
-            onbeforeunload           :  true,
-            onblur                   :  true,
-            onerror                  :  true,
-            onfocus                  :  true,
-            onload                   :  true,
-            onresize                 :  true,
-            onunload                 :  true,
-            open                     :  false,
-            openDatabase             :  false,
-            opener                   :  false,
-            Option                   :  false,
-            parent                   :  false,
-            print                    :  false,
-            removeEventListener      :  false,
-            resizeBy                 :  false,
-            resizeTo                 :  false,
-            screen                   :  false,
-            scroll                   :  false,
-            scrollBy                 :  false,
-            scrollTo                 :  false,
-            sessionStorage           :  false,
-            setInterval              :  false,
-            setTimeout               :  false,
-            SharedWorker             :  false,
-            status                   :  false,
-            top                      :  false,
-            Uint16Array              :  false,
-            Uint32Array              :  false,
-            Uint8Array               :  false,
-            WebSocket                :  false,
-            window                   :  false,
-            Worker                   :  false,
-            XMLHttpRequest           :  false,
-            XPathEvaluator           :  false,
-            XPathException           :  false,
-            XPathExpression          :  false,
-            XPathNamespace           :  false,
-            XPathNSResolver          :  false,
-            XPathResult              :  false
-        },
-
-        couch = {
-            "require" : false,
-            respond   : false,
-            getRow    : false,
-            emit      : false,
-            send      : false,
-            start     : false,
-            sum       : false,
-            log       : false,
-            exports   : false,
-            module    : false,
-            provides  : false
-        },
-
-        devel = {
-            alert   : false,
-            confirm : false,
-            console : false,
-            Debug   : false,
-            opera   : false,
-            prompt  : false
-        },
-
-        dojo = {
-            dojo      : false,
-            dijit     : false,
-            dojox     : false,
-            define    : false,
-            "require" : false
-        },
-
-        escapes = {
-            '\b': '\\b',
-            '\t': '\\t',
-            '\n': '\\n',
-            '\f': '\\f',
-            '\r': '\\r',
-            '"' : '\\"',
-            '/' : '\\/',
-            '\\': '\\\\'
-        },
-
-        funct,          // The current function
-
-        functionicity = [
-            'closure', 'exception', 'global', 'label',
-            'outer', 'unused', 'var'
-        ],
-
-        functions,      // All of the functions
-
-        global,         // The global scope
-        implied,        // Implied globals
-        inblock,
-        indent,
-        jsonmode,
-
-        jquery = {
-            '$'    : false,
-            jQuery : false
-        },
-
-        lines,
-        lookahead,
-        member,
-        membersOnly,
-
-        mootools = {
-            '$'             : false,
-            '$$'            : false,
-            Assets          : false,
-            Browser         : false,
-            Chain           : false,
-            Class           : false,
-            Color           : false,
-            Cookie          : false,
-            Core            : false,
-            Document        : false,
-            DomReady        : false,
-            DOMReady        : false,
-            Drag            : false,
-            Element         : false,
-            Elements        : false,
-            Event           : false,
-            Events          : false,
-            Fx              : false,
-            Group           : false,
-            Hash            : false,
-            HtmlTable       : false,
-            Iframe          : false,
-            IframeShim      : false,
-            InputValidator  : false,
-            instanceOf      : false,
-            Keyboard        : false,
-            Locale          : false,
-            Mask            : false,
-            MooTools        : false,
-            Native          : false,
-            Options         : false,
-            OverText        : false,
-            Request         : false,
-            Scroller        : false,
-            Slick           : false,
-            Slider          : false,
-            Sortables       : false,
-            Spinner         : false,
-            Swiff           : false,
-            Tips            : false,
-            Type            : false,
-            typeOf          : false,
-            URI             : false,
-            Window          : false
-        },
-
-        nexttoken,
-
-        node = {
-            __filename    : false,
-            __dirname     : false,
-            Buffer        : false,
-            console       : false,
-            exports       : false,
-            GLOBAL        : false,
-            global        : false,
-            module        : false,
-            process       : false,
-            require       : false,
-            setTimeout    : false,
-            clearTimeout  : false,
-            setInterval   : false,
-            clearInterval : false
-        },
-
-        noreach,
-        option,
-        predefined,     // Global variables defined by option
-        prereg,
-        prevtoken,
-
-        prototypejs = {
-            '$'               : false,
-            '$$'              : false,
-            '$A'              : false,
-            '$F'              : false,
-            '$H'              : false,
-            '$R'              : false,
-            '$break'          : false,
-            '$continue'       : false,
-            '$w'              : false,
-            Abstract          : false,
-            Ajax              : false,
-            Class             : false,
-            Enumerable        : false,
-            Element           : false,
-            Event             : false,
-            Field             : false,
-            Form              : false,
-            Hash              : false,
-            Insertion         : false,
-            ObjectRange       : false,
-            PeriodicalExecuter: false,
-            Position          : false,
-            Prototype         : false,
-            Selector          : false,
-            Template          : false,
-            Toggle            : false,
-            Try               : false,
-            Autocompleter     : false,
-            Builder           : false,
-            Control           : false,
-            Draggable         : false,
-            Draggables        : false,
-            Droppables        : false,
-            Effect            : false,
-            Sortable          : false,
-            SortableObserver  : false,
-            Sound             : false,
-            Scriptaculous     : false
-        },
-
-        rhino = {
-            defineClass  : false,
-            deserialize  : false,
-            gc           : false,
-            help         : false,
-            importPackage: false,
-            "java"       : false,
-            load         : false,
-            loadClass    : false,
-            print        : false,
-            quit         : false,
-            readFile     : false,
-            readUrl      : false,
-            runCommand   : false,
-            seal         : false,
-            serialize    : false,
-            spawn        : false,
-            sync         : false,
-            toint32      : false,
-            version      : false
-        },
-
-        scope,      // The current scope
-        stack,
-
-        // standard contains the global names that are provided by the
-        // ECMAScript standard.
-        standard = {
-            Array               : false,
-            Boolean             : false,
-            Date                : false,
-            decodeURI           : false,
-            decodeURIComponent  : false,
-            encodeURI           : false,
-            encodeURIComponent  : false,
-            Error               : false,
-            'eval'              : false,
-            EvalError           : false,
-            Function            : false,
-            hasOwnProperty      : false,
-            isFinite            : false,
-            isNaN               : false,
-            JSON                : false,
-            Math                : false,
-            Number              : false,
-            Object              : false,
-            parseInt            : false,
-            parseFloat          : false,
-            RangeError          : false,
-            ReferenceError      : false,
-            RegExp              : false,
-            String              : false,
-            SyntaxError         : false,
-            TypeError           : false,
-            URIError            : false
-        },
-
-        // widely adopted global names that are not part of ECMAScript standard
-        nonstandard = {
-            escape              : false,
-            unescape            : false
-        },
-
-        standard_member = {
-            E                   : true,
-            LN2                 : true,
-            LN10                : true,
-            LOG2E               : true,
-            LOG10E              : true,
-            MAX_VALUE           : true,
-            MIN_VALUE           : true,
-            NEGATIVE_INFINITY   : true,
-            PI                  : true,
-            POSITIVE_INFINITY   : true,
-            SQRT1_2             : true,
-            SQRT2               : true
-        },
-
-        directive,
-        syntax = {},
-        tab,
-        token,
-        urls,
-        useESNextSyntax,
-        warnings,
-
-        wsh = {
-            ActiveXObject             : true,
-            Enumerator                : true,
-            GetObject                 : true,
-            ScriptEngine              : true,
-            ScriptEngineBuildVersion  : true,
-            ScriptEngineMajorVersion  : true,
-            ScriptEngineMinorVersion  : true,
-            VBArray                   : true,
-            WSH                       : true,
-            WScript                   : true,
-            XDomainRequest            : true
-        };
-
-    // Regular expressions. Some of these are stupidly long.
-    var ax, cx, tx, nx, nxg, lx, ix, jx, ft;
-    (function () {
-        /*jshint maxlen:300 */
-
-        // unsafe comment or string
-        ax = /@cc|<\/?|script|\]\s*\]|<\s*!|&lt/i;
-
-        // 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]/;
-
-        // token
-        tx = /^\s*([(){}\[.,:;'"~\?\]#@]|==?=?|\/(\*(jshint|jslint|members?|global)?|=|\/)?|\*[\/=]?|\+(?:=|\++)?|-(?:=|-+)?|%=?|&[&=]?|\|[|=]?|>>?>?=?|<([\/=!]|\!(\[|--)?|<=?)?|\^=?|\!=?=?|[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+([xX][0-9a-fA-F]+|\.[0-9]*)?([eE][+\-]?[0-9]+)?)/;
-
-        // 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]/;
-        nxg = /[\u0000-\u001f&<"\/\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
-
-        // star slash
-        lx = /\*\/|\/\*/;
-
-        // identifier
-        ix = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/;
-
-        // javascript url
-        jx = /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i;
-
-        // catches /* falls through */ comments
-        ft = /^\s*\/\*\s*falls\sthrough\s*\*\/\s*$/;
-    }());
-
-    function F() {}     // Used by Object.create
-
-    function is_own(object, name) {
-
-// The object.hasOwnProperty method fails when the property under consideration
-// is named 'hasOwnProperty'. So we have to use this more convoluted form.
-
-        return Object.prototype.hasOwnProperty.call(object, name);
-    }
-
-// Provide critical ES5 functions to ES3.
-
-    if (typeof Array.isArray !== 'function') {
-        Array.isArray = function (o) {
-            return Object.prototype.toString.apply(o) === '[object Array]';
-        };
-    }
-
-    if (typeof Object.create !== 'function') {
-        Object.create = function (o) {
-            F.prototype = o;
-            return new F();
-        };
-    }
-
-    if (typeof Object.keys !== 'function') {
-        Object.keys = function (o) {
-            var a = [], k;
-            for (k in o) {
-                if (is_own(o, k)) {
-                    a.push(k);
-                }
-            }
-            return a;
-        };
-    }
-
-// Non standard methods
-
-    if (typeof String.prototype.entityify !== 'function') {
-        String.prototype.entityify = function () {
-            return this
-                .replace(/&/g, '&amp;')
-                .replace(/</g, '&lt;')
-                .replace(/>/g, '&gt;');
-        };
-    }
-
-    if (typeof String.prototype.isAlpha !== 'function') {
-        String.prototype.isAlpha = function () {
-            return (this >= 'a' && this <= 'z\uffff') ||
-                (this >= 'A' && this <= 'Z\uffff');
-        };
-    }
-
-    if (typeof String.prototype.isDigit !== 'function') {
-        String.prototype.isDigit = function () {
-            return (this >= '0' && this <= '9');
-        };
-    }
-
-    if (typeof String.prototype.supplant !== 'function') {
-        String.prototype.supplant = function (o) {
-            return this.replace(/\{([^{}]*)\}/g, function (a, b) {
-                var r = o[b];
-                return typeof r === 'string' || typeof r === 'number' ? r : a;
-            });
-        };
-    }
-
-    if (typeof String.prototype.name !== 'function') {
-        String.prototype.name = function () {
-
-// If the string looks like an identifier, then we can return it as is.
-// If the string contains no control characters, no quote characters, and no
-// backslash characters, then we can simply slap some quotes around it.
-// Otherwise we must also replace the offending characters with safe
-// sequences.
-
-            if (ix.test(this)) {
-                return this;
-            }
-            if (nx.test(this)) {
-                return '"' + this.replace(nxg, function (a) {
-                    var c = escapes[a];
-                    if (c) {
-                        return c;
-                    }
-                    return '\\u' + ('0000' + a.charCodeAt().toString(16)).slice(-4);
-                }) + '"';
-            }
-            return '"' + this + '"';
-        };
-    }
-
-
-    function combine(t, o) {
-        var n;
-        for (n in o) {
-            if (is_own(o, n)) {
-                t[n] = o[n];
-            }
-        }
-    }
-
-    function assume() {
-        if (option.couch) {
-            combine(predefined, couch);
-        }
-
-        if (option.rhino) {
-            combine(predefined, rhino);
-        }
-
-        if (option.prototypejs) {
-            combine(predefined, prototypejs);
-        }
-
-        if (option.node) {
-            combine(predefined, node);
-        }
-
-        if (option.devel) {
-            combine(predefined, devel);
-        }
-
-        if (option.dojo) {
-            combine(predefined, dojo);
-        }
-
-        if (option.browser) {
-            combine(predefined, browser);
-        }
-
-        if (option.nonstandard) {
-            combine(predefined, nonstandard);
-        }
-
-        if (option.jquery) {
-            combine(predefined, jquery);
-        }
-
-        if (option.mootools) {
-            combine(predefined, mootools);
-        }
-
-        if (option.wsh) {
-            combine(predefined, wsh);
-        }
-
-        if (option.esnext) {
-            useESNextSyntax();
-        }
-
-        if (option.globalstrict && option.strict !== false) {
-            option.strict = true;
-        }
-    }
-
-
-    // Produce an error warning.
-    function quit(message, line, chr) {
-        var percentage = Math.floor((line / lines.length) * 100);
-
-        throw {
-            name: 'JSHintError',
-            line: line,
-            character: chr,
-            message: message + " (" + percentage + "% scanned).",
-            raw: message
-        };
-    }
-
-    function isundef(scope, m, t, a) {
-        return JSHINT.undefs.push([scope, m, t, a]);
-    }
-
-    function warning(m, t, a, b, c, d) {
-        var ch, l, w;
-        t = t || nexttoken;
-        if (t.id === '(end)') {  // `~
-            t = token;
-        }
-        l = t.line || 0;
-        ch = t.from || 0;
-        w = {
-            id: '(error)',
-            raw: m,
-            evidence: lines[l - 1] || '',
-            line: l,
-            character: ch,
-            a: a,
-            b: b,
-            c: c,
-            d: d
-        };
-        w.reason = m.supplant(w);
-        JSHINT.errors.push(w);
-        if (option.passfail) {
-            quit('Stopping. ', l, ch);
-        }
-        warnings += 1;
-        if (warnings >= option.maxerr) {
-            quit("Too many errors.", l, ch);
-        }
-        return w;
-    }
-
-    function warningAt(m, l, ch, a, b, c, d) {
-        return warning(m, {
-            line: l,
-            from: ch
-        }, a, b, c, d);
-    }
-
-    function error(m, t, a, b, c, d) {
-        var w = warning(m, t, a, b, c, d);
-    }
-
-    function errorAt(m, l, ch, a, b, c, d) {
-        return error(m, {
-            line: l,
-            from: ch
-        }, a, b, c, d);
-    }
-
-
-
-// lexical analysis and token construction
-
-    var lex = (function lex() {
-        var character, from, line, s;
-
-// Private lex methods
-
-        function nextLine() {
-            var at,
-                tw; // trailing whitespace check
-
-            if (line >= lines.length)
-                return false;
-
-            character = 1;
-            s = lines[line];
-            line += 1;
-
-            // If smarttabs option is used check for spaces followed by tabs only.
-            // Otherwise check for any occurence of mixed tabs and spaces.
-            if (option.smarttabs)
-                at = s.search(/ \t/);
-            else
-                at = s.search(/ \t|\t /);
-
-            if (at >= 0)
-                warningAt("Mixed spaces and tabs.", line, at + 1);
-
-            s = s.replace(/\t/g, tab);
-            at = s.search(cx);
-
-            if (at >= 0)
-                warningAt("Unsafe character.", line, at);
-
-            if (option.maxlen && option.maxlen < s.length)
-                warningAt("Line too long.", line, s.length);
-
-            // Check for trailing whitespaces
-            tw = /\s+$/.test(s);
-            if (option.trailing && tw && !/^\s+$/.test(s)) {
-                warningAt("Trailing whitespace.", line, tw);
-            }
-            return true;
-        }
-
-// Produce a token object.  The token inherits from a syntax symbol.
-
-        function it(type, value) {
-            var i, t;
-            if (type === '(color)' || type === '(range)') {
-                t = {type: type};
-            } else if (type === '(punctuator)' ||
-                    (type === '(identifier)' && is_own(syntax, value))) {
-                t = syntax[value] || syntax['(error)'];
-            } else {
-                t = syntax[type];
-            }
-            t = Object.create(t);
-            if (type === '(string)' || type === '(range)') {
-                if (!option.scripturl && jx.test(value)) {
-                    warningAt("Script URL.", line, from);
-                }
-            }
-            if (type === '(identifier)') {
-                t.identifier = true;
-                if (value === '__proto__' && !option.proto) {
-                    warningAt("The '{a}' property is deprecated.",
-                        line, from, value);
-                } else if (value === '__iterator__' && !option.iterator) {
-                    warningAt("'{a}' is only available in JavaScript 1.7.",
-                        line, from, value);
-                } else if (option.nomen && (value.charAt(0) === '_' ||
-                         value.charAt(value.length - 1) === '_')) {
-                    if (!option.node || token.id === '.' ||
-                            (value !== '__dirname' && value !== '__filename')) {
-                        warningAt("Unexpected {a} in '{b}'.", line, from, "dangling '_'", value);
-                    }
-                }
-            }
-            t.value = value;
-            t.line = line;
-            t.character = character;
-            t.from = from;
-            i = t.id;
-            if (i !== '(endline)') {
-                prereg = i &&
-                    (('(,=:[!&|?{};'.indexOf(i.charAt(i.length - 1)) >= 0) ||
-                    i === 'return' ||
-                    i === 'case');
-            }
-            return t;
-        }
-
-        // Public lex methods
-        return {
-            init: function (source) {
-                if (typeof source === 'string') {
-                    lines = source
-                        .replace(/\r\n/g, '\n')
-                        .replace(/\r/g, '\n')
-                        .split('\n');
-                } else {
-                    lines = source;
-                }
-
-                // If the first line is a shebang (#!), make it a blank and move on.
-                // Shebangs are used by Node scripts.
-                if (lines[0] && lines[0].substr(0, 2) === '#!')
-                    lines[0] = '';
-
-                line = 0;
-                nextLine();
-                from = 1;
-            },
-
-            range: function (begin, end) {
-                var c, value = '';
-                from = character;
-                if (s.charAt(0) !== begin) {
-                    errorAt("Expected '{a}' and instead saw '{b}'.",
-                            line, character, begin, s.charAt(0));
-                }
-                for (;;) {
-                    s = s.slice(1);
-                    character += 1;
-                    c = s.charAt(0);
-                    switch (c) {
-                    case '':
-                        errorAt("Missing '{a}'.", line, character, c);
-                        break;
-                    case end:
-                        s = s.slice(1);
-                        character += 1;
-                        return it('(range)', value);
-                    case '\\':
-                        warningAt("Unexpected '{a}'.", line, character, c);
-                    }
-                    value += c;
-                }
-
-            },
-
-
-            // token -- this is called by advance to get the next token
-            token: function () {
-                var b, c, captures, d, depth, high, i, l, low, q, t, isLiteral, isInRange;
-
-                function match(x) {
-                    var r = x.exec(s), r1;
-                    if (r) {
-                        l = r[0].length;
-                        r1 = r[1];
-                        c = r1.charAt(0);
-                        s = s.substr(l);
-                        from = character + l - r1.length;
-                        character += l;
-                        return r1;
-                    }
-                }
-
-                function string(x) {
-                    var c, j, r = '', allowNewLine = false;
-
-                    if (jsonmode && x !== '"') {
-                        warningAt("Strings must use doublequote.",
-                                line, character);
-                    }
-
-                    function esc(n) {
-                        var i = parseInt(s.substr(j + 1, n), 16);
-                        j += n;
-                        if (i >= 32 && i <= 126 &&
-                                i !== 34 && i !== 92 && i !== 39) {
-                            warningAt("Unnecessary escapement.", line, character);
-                        }
-                        character += n;
-                        c = String.fromCharCode(i);
-                    }
-                    j = 0;
-unclosedString:     for (;;) {
-                        while (j >= s.length) {
-                            j = 0;
-
-                            var cl = line, cf = from;
-                            if (!nextLine()) {
-                                errorAt("Unclosed string.", cl, cf);
-                                break unclosedString;
-                            }
-
-                            if (allowNewLine) {
-                                allowNewLine = false;
-                            } else {
-                                warningAt("Unclosed string.", cl, cf);
-                            }
-                        }
-                        c = s.charAt(j);
-                        if (c === x) {
-                            character += 1;
-                            s = s.substr(j + 1);
-                            return it('(string)', r, x);
-                        }
-                        if (c < ' ') {
-                            if (c === '\n' || c === '\r') {
-                                break;
-                            }
-                            warningAt("Control character in string: {a}.",
-                                    line, character + j, s.slice(0, j));
-                        } else if (c === '\\') {
-                            j += 1;
-                            character += 1;
-                            c = s.charAt(j);
-                            switch (c) {
-                            case '\\':
-                            case '"':
-                            case '/':
-                                break;
-                            case '\'':
-                                if (jsonmode) {
-                                    warningAt("Avoid \\'.", line, character);
-                                }
-                                break;
-                            case 'b':
-                                c = '\b';
-                                break;
-                            case 'f':
-                                c = '\f';
-                                break;
-                            case 'n':
-                                c = '\n';
-                                break;
-                            case 'r':
-                                c = '\r';
-                                break;
-                            case 't':
-                                c = '\t';
-                                break;
-                            case 'u':
-                                esc(4);
-                                break;
-                            case 'v':
-                                if (jsonmode) {
-                                    warningAt("Avoid \\v.", line, character);
-                                }
-                                c = '\v';
-                                break;
-                            case 'x':
-                                if (jsonmode) {
-                                    warningAt("Avoid \\x-.", line, character);
-                                }
-                                esc(2);
-                                break;
-                            case '':
-                                // last character is escape character
-                                // always allow new line if escaped, but show
-                                // warning if option is not set
-                                allowNewLine = true;
-                                if (option.multistr) {
-                                    if (jsonmode) {
-                                        warningAt("Avoid EOL escapement.", line, character);
-                                    }
-                                    c = '';
-                                    character -= 1;
-                                    break;
-                                }
-                                warningAt("Bad escapement of EOL. Use option multistr if needed.",
-                                    line, character);
-                                break;
-                            default:
-                                warningAt("Bad escapement.", line, character);
-                            }
-                        }
-                        r += c;
-                        character += 1;
-                        j += 1;
-                    }
-                }
-
-                for (;;) {
-                    if (!s) {
-                        return it(nextLine() ? '(endline)' : '(end)', '');
-                    }
-                    t = match(tx);
-                    if (!t) {
-                        t = '';
-                        c = '';
-                        while (s && s < '!') {
-                            s = s.substr(1);
-                        }
-                        if (s) {
-                            errorAt("Unexpected '{a}'.", line, character, s.substr(0, 1));
-                            s = '';
-                        }
-                    } else {
-
-    //      identifier
-
-                        if (c.isAlpha() || c === '_' || c === '$') {
-                            return it('(identifier)', t);
-                        }
-
-    //      number
-
-                        if (c.isDigit()) {
-                            if (!isFinite(Number(t))) {
-                                warningAt("Bad number '{a}'.",
-                                    line, character, t);
-                            }
-                            if (s.substr(0, 1).isAlpha()) {
-                                warningAt("Missing space after '{a}'.",
-                                        line, character, t);
-                            }
-                            if (c === '0') {
-                                d = t.substr(1, 1);
-                                if (d.isDigit()) {
-                                    if (token.id !== '.') {
-                                        warningAt("Don't use extra leading zeros '{a}'.",
-                                            line, character, t);
-                                    }
-                                } else if (jsonmode && (d === 'x' || d === 'X')) {
-                                    warningAt("Avoid 0x-. '{a}'.",
-                                            line, character, t);
-                                }
-                            }
-                            if (t.substr(t.length - 1) === '.') {
-                                warningAt(
-"A trailing decimal point can be confused with a dot '{a}'.", line, character, t);
-                            }
-                            return it('(number)', t);
-                        }
-                        switch (t) {
-
-    //      string
-
-                        case '"':
-                        case "'":
-                            return string(t);
-
-    //      // comment
-
-                        case '//':
-                            s = '';
-                            token.comment = true;
-                            break;
-
-    //      /* comment
-
-                        case '/*':
-                            for (;;) {
-                                i = s.search(lx);
-                                if (i >= 0) {
-                                    break;
-                                }
-                                if (!nextLine()) {
-                                    errorAt("Unclosed comment.", line, character);
-                                }
-                            }
-                            character += i + 2;
-                            if (s.substr(i, 1) === '/') {
-                                errorAt("Nested comment.", line, character);
-                            }
-                            s = s.substr(i + 2);
-                            token.comment = true;
-                            break;
-
-    //      /*members /*jshint /*global
-
-                        case '/*members':
-                        case '/*member':
-                        case '/*jshint':
-                        case '/*jslint':
-                        case '/*global':
-                        case '*/':
-                            return {
-                                value: t,
-                                type: 'special',
-                                line: line,
-                                character: character,
-                                from: from
-                            };
-
-                        case '':
-                            break;
-    //      /
-                        case '/':
-                            if (token.id === '/=') {
-                                errorAt("A regular expression literal can be confused with '/='.",
-                                    line, from);
-                            }
-                            if (prereg) {
-                                depth = 0;
-                                captures = 0;
-                                l = 0;
-                                for (;;) {
-                                    b = true;
-                                    c = s.charAt(l);
-                                    l += 1;
-                                    switch (c) {
-                                    case '':
-                                        errorAt("Unclosed regular expression.", line, from);
-                                        return quit('Stopping.', line, from);
-                                    case '/':
-                                        if (depth > 0) {
-                                            warningAt("{a} unterminated regular expression " +
-                                                "group(s).", line, from + l, depth);
-                                        }
-                                        c = s.substr(0, l - 1);
-                                        q = {
-                                            g: true,
-                                            i: true,
-                                            m: true
-                                        };
-                                        while (q[s.charAt(l)] === true) {
-                                            q[s.charAt(l)] = false;
-                                            l += 1;
-                                        }
-                                        character += l;
-                                        s = s.substr(l);
-                                        q = s.charAt(0);
-                                        if (q === '/' || q === '*') {
-                                            errorAt("Confusing regular expression.",
-                                                    line, from);
-                                        }
-                                        return it('(regexp)', c);
-                                    case '\\':
-                                        c = s.charAt(l);
-                                        if (c < ' ') {
-                                            warningAt(
-"Unexpected control character in regular expression.", line, from + l);
-                                        } else if (c === '<') {
-                                            warningAt(
-"Unexpected escaped character '{a}' in regular expression.", line, from + l, c);
-                                        }
-                                        l += 1;
-                                        break;
-                                    case '(':
-                                        depth += 1;
-                                        b = false;
-                                        if (s.charAt(l) === '?') {
-                                            l += 1;
-                                            switch (s.charAt(l)) {
-                                            case ':':
-                                            case '=':
-                                            case '!':
-                                                l += 1;
-                                                break;
-                                            default:
-                                                warningAt(
-"Expected '{a}' and instead saw '{b}'.", line, from + l, ':', s.charAt(l));
-                                            }
-                                        } else {
-                                            captures += 1;
-                                        }
-                                        break;
-                                    case '|':
-                                        b = false;
-                                        break;
-                                    case ')':
-                                        if (depth === 0) {
-                                            warningAt("Unescaped '{a}'.",
-                                                    line, from + l, ')');
-                                        } else {
-                                            depth -= 1;
-                                        }
-                                        break;
-                                    case ' ':
-                                        q = 1;
-                                        while (s.charAt(l) === ' ') {
-                                            l += 1;
-                                            q += 1;
-                                        }
-                                        if (q > 1) {
-                                            warningAt(
-"Spaces are hard to count. Use {{a}}.", line, from + l, q);
-                                        }
-                                        break;
-                                    case '[':
-                                        c = s.charAt(l);
-                                        if (c === '^') {
-                                            l += 1;
-                                            if (option.regexp) {
-                                                warningAt("Insecure '{a}'.",
-                                                        line, from + l, c);
-                                            } else if (s.charAt(l) === ']') {
-                                                errorAt("Unescaped '{a}'.",
-                                                    line, from + l, '^');
-                                            }
-                                        }
-                                        if (c === ']') {
-                                            warningAt("Empty class.", line,
-                                                    from + l - 1);
-                                        }
-                                        isLiteral = false;
-                                        isInRange = false;
-klass:                                  do {
-                                            c = s.charAt(l);
-                                            l += 1;
-                                            switch (c) {
-                                            case '[':
-                                            case '^':
-                                                warningAt("Unescaped '{a}'.",
-                                                        line, from + l, c);
-                                                if (isInRange) {
-                                                    isInRange = false;
-                                                } else {
-                                                    isLiteral = true;
-                                                }
-                                                break;
-                                            case '-':
-                                                if (isLiteral && !isInRange) {
-                                                    isLiteral = false;
-                                                    isInRange = true;
-                                                } else if (isInRange) {
-                                                    isInRange = false;
-                                                } else if (s.charAt(l) === ']') {
-                                                    isInRange = true;
-                                                } else {
-                                                    if (option.regexdash !== (l === 2 || (l === 3 &&
-                                                        s.charAt(1) === '^'))) {
-                                                        warningAt("Unescaped '{a}'.",
-                                                            line, from + l - 1, '-');
-                                                    }
-                                                    isLiteral = true;
-                                                }
-                                                break;
-                                            case ']':
-                                                if (isInRange && !option.regexdash) {
-                                                    warningAt("Unescaped '{a}'.",
-                                                            line, from + l - 1, '-');
-                                                }
-                                                break klass;
-                                            case '\\':
-                                                c = s.charAt(l);
-                                                if (c < ' ') {
-                                                    warningAt(
-"Unexpected control character in regular expression.", line, from + l);
-                                                } else if (c === '<') {
-                                                    warningAt(
-"Unexpected escaped character '{a}' in regular expression.", line, from + l, c);
-                                                }
-                                                l += 1;
-
-                                                // \w, \s and \d are never part of a character range
-                                                if (/[wsd]/i.test(c)) {
-                                                    if (isInRange) {
-                                                        warningAt("Unescaped '{a}'.",
-                                                            line, from + l, '-');
-                                                        isInRange = false;
-                                                    }
-                                                    isLiteral = false;
-                                                } else if (isInRange) {
-                                                    isInRange = false;
-                                                } else {
-                                                    isLiteral = true;
-                                                }
-                                                break;
-                                            case '/':
-                                                warningAt("Unescaped '{a}'.",
-                                                        line, from + l - 1, '/');
-
-                                                if (isInRange) {
-                                                    isInRange = false;
-                                                } else {
-                                                    isLiteral = true;
-                                                }
-                                                break;
-                                            case '<':
-                                                if (isInRange) {
-                                                    isInRange = false;
-                                                } else {
-                                                    isLiteral = true;
-                                                }
-                                                break;
-                                            default:
-                                                if (isInRange) {
-                                                    isInRange = false;
-                                                } else {
-                                                    isLiteral = true;
-                                                }
-                                            }
-                                        } while (c);
-                                        break;
-                                    case '.':
-                                        if (option.regexp) {
-                                            warningAt("Insecure '{a}'.", line,
-                                                    from + l, c);
-                                        }
-                                        break;
-                                    case ']':
-                                    case '?':
-                                    case '{':
-                                    case '}':
-                                    case '+':
-                                    case '*':
-                                        warningAt("Unescaped '{a}'.", line,
-                                                from + l, c);
-                                    }
-                                    if (b) {
-                                        switch (s.charAt(l)) {
-                                        case '?':
-                                        case '+':
-                                        case '*':
-                                            l += 1;
-                                            if (s.charAt(l) === '?') {
-                                                l += 1;
-                                            }
-                                            break;
-                                        case '{':
-                                            l += 1;
-                                            c = s.charAt(l);
-                                            if (c < '0' || c > '9') {
-                                                warningAt(
-"Expected a number and instead saw '{a}'.", line, from + l, c);
-                                            }
-                                            l += 1;
-                                            low = +c;
-                                            for (;;) {
-                                                c = s.charAt(l);
-                                                if (c < '0' || c > '9') {
-                                                    break;
-                                                }
-                                                l += 1;
-                                                low = +c + (low * 10);
-                                            }
-                                            high = low;
-                                            if (c === ',') {
-                                                l += 1;
-                                                high = Infinity;
-                                                c = s.charAt(l);
-                                                if (c >= '0' && c <= '9') {
-                                                    l += 1;
-                                                    high = +c;
-                                                    for (;;) {
-                                                        c = s.charAt(l);
-                                                        if (c < '0' || c > '9') {
-                                                            break;
-                                                        }
-                                                        l += 1;
-                                                        high = +c + (high * 10);
-                                                    }
-                                                }
-                                            }
-                                            if (s.charAt(l) !== '}') {
-                                                warningAt(
-"Expected '{a}' and instead saw '{b}'.", line, from + l, '}', c);
-                                            } else {
-                                                l += 1;
-                                            }
-                                            if (s.charAt(l) === '?') {
-                                                l += 1;
-                                            }
-                                            if (low > high) {
-                                                warningAt(
-"'{a}' should not be greater than '{b}'.", line, from + l, low, high);
-                                            }
-                                        }
-                                    }
-                                }
-                                c = s.substr(0, l - 1);
-                                character += l;
-                                s = s.substr(l);
-                                return it('(regexp)', c);
-                            }
-                            return it('(punctuator)', t);
-
-    //      punctuator
-
-                        case '#':
-                            return it('(punctuator)', t);
-                        default:
-                            return it('(punctuator)', t);
-                        }
-                    }
-                }
-            }
-        };
-    }());
-
-
-    function addlabel(t, type) {
-
-        if (t === 'hasOwnProperty') {
-            warning("'hasOwnProperty' is a really bad name.");
-        }
-
-// Define t in the current function in the current scope.
-        if (is_own(funct, t) && !funct['(global)']) {
-            if (funct[t] === true) {
-                if (option.latedef)
-                    warning("'{a}' was used before it was defined.", nexttoken, t);
-            } else {
-                if (!option.shadow && type !== "exception")
-                    warning("'{a}' is already defined.", nexttoken, t);
-            }
-        }
-
-        funct[t] = type;
-        if (funct['(global)']) {
-            global[t] = funct;
-            if (is_own(implied, t)) {
-                if (option.latedef)
-                    warning("'{a}' was used before it was defined.", nexttoken, t);
-                delete implied[t];
-            }
-        } else {
-            scope[t] = funct;
-        }
-    }
-
-
-    function doOption() {
-        var b, obj, filter, o = nexttoken.value, t, v;
-        switch (o) {
-        case '*/':
-            error("Unbegun comment.");
-            break;
-        case '/*members':
-        case '/*member':
-            o = '/*members';
-            if (!membersOnly) {
-                membersOnly = {};
-            }
-            obj = membersOnly;
-            break;
-        case '/*jshint':
-        case '/*jslint':
-            obj = option;
-            filter = boolOptions;
-            break;
-        case '/*global':
-            obj = predefined;
-            break;
-        default:
-            error("What?");
-        }
-        t = lex.token();
-loop:   for (;;) {
-            for (;;) {
-                if (t.type === 'special' && t.value === '*/') {
-                    break loop;
-                }
-                if (t.id !== '(endline)' && t.id !== ',') {
-                    break;
-                }
-                t = lex.token();
-            }
-            if (t.type !== '(string)' && t.type !== '(identifier)' &&
-                    o !== '/*members') {
-                error("Bad option.", t);
-            }
-            v = lex.token();
-            if (v.id === ':') {
-                v = lex.token();
-                if (obj === membersOnly) {
-                    error("Expected '{a}' and instead saw '{b}'.",
-                            t, '*/', ':');
-                }
-                if (t.value === 'indent' && (o === '/*jshint' || o === '/*jslint')) {
-                    b = +v.value;
-                    if (typeof b !== 'number' || !isFinite(b) || b <= 0 ||
-                            Math.floor(b) !== b) {
-                        error("Expected a small integer and instead saw '{a}'.",
-                                v, v.value);
-                    }
-                    obj.white = true;
-                    obj.indent = b;
-                } else if (t.value === 'maxerr' && (o === '/*jshint' || o === '/*jslint')) {
-                    b = +v.value;
-                    if (typeof b !== 'number' || !isFinite(b) || b <= 0 ||
-                            Math.floor(b) !== b) {
-                        error("Expected a small integer and instead saw '{a}'.",
-                                v, v.value);
-                    }
-                    obj.maxerr = b;
-                } else if (t.value === 'maxlen' && (o === '/*jshint' || o === '/*jslint')) {
-                    b = +v.value;
-                    if (typeof b !== 'number' || !isFinite(b) || b <= 0 ||
-                            Math.floor(b) !== b) {
-                        error("Expected a small integer and instead saw '{a}'.",
-                                v, v.value);
-                    }
-                    obj.maxlen = b;
-                } else if (t.value === 'validthis') {
-                    if (funct['(global)']) {
-                        error("Option 'validthis' can't be used in a global scope.");
-                    } else {
-                        if (v.value === 'true' || v.value === 'false')
-                            obj[t.value] = v.value === 'true';
-                        else
-                            error("Bad option value.", v);
-                    }
-                } else if (v.value === 'true') {
-                    obj[t.value] = true;
-                } else if (v.value === 'false') {
-                    obj[t.value] = false;
-                } else {
-                    error("Bad option value.", v);
-                }
-                t = lex.token();
-            } else {
-                if (o === '/*jshint' || o === '/*jslint') {
-                    error("Missing option value.", t);
-                }
-                obj[t.value] = false;
-                t = v;
-            }
-        }
-        if (filter) {
-            assume();
-        }
-    }
-
-
-// We need a peek function. If it has an argument, it peeks that much farther
-// ahead. It is used to distinguish
-//     for ( var i in ...
-// from
-//     for ( var i = ...
-
-    function peek(p) {
-        var i = p || 0, j = 0, t;
-
-        while (j <= i) {
-            t = lookahead[j];
-            if (!t) {
-                t = lookahead[j] = lex.token();
-            }
-            j += 1;
-        }
-        return t;
-    }
-
-
-
-// Produce the next token. It looks for programming errors.
-
-    function advance(id, t) {
-        switch (token.id) {
-        case '(number)':
-            if (nexttoken.id === '.') {
-                warning("A dot following a number can be confused with a decimal point.", token);
-            }
-            break;
-        case '-':
-            if (nexttoken.id === '-' || nexttoken.id === '--') {
-                warning("Confusing minusses.");
-            }
-            break;
-        case '+':
-            if (nexttoken.id === '+' || nexttoken.id === '++') {
-                warning("Confusing plusses.");
-            }
-            break;
-        }
-
-        if (token.type === '(string)' || token.identifier) {
-            anonname = token.value;
-        }
-
-        if (id && nexttoken.id !== id) {
-            if (t) {
-                if (nexttoken.id === '(end)') {
-                    warning("Unmatched '{a}'.", t, t.id);
-                } else {
-                    warning("Expected '{a}' to match '{b}' from line {c} and instead saw '{d}'.",
-                            nexttoken, id, t.id, t.line, nexttoken.value);
-                }
-            } else if (nexttoken.type !== '(identifier)' ||
-                            nexttoken.value !== id) {
-                warning("Expected '{a}' and instead saw '{b}'.",
-                        nexttoken, id, nexttoken.value);
-            }
-        }
-
-        prevtoken = token;
-        token = nexttoken;
-        for (;;) {
-            nexttoken = lookahead.shift() || lex.token();
-            if (nexttoken.id === '(end)' || nexttoken.id === '(error)') {
-                return;
-            }
-            if (nexttoken.type === 'special') {
-                doOption();
-            } else {
-                if (nexttoken.id !== '(endline)') {
-                    break;
-                }
-            }
-        }
-    }
-
-
-// This is the heart of JSHINT, the Pratt parser. In addition to parsing, it
-// is looking for ad hoc lint patterns. We add .fud to Pratt's model, which is
-// like .nud except that it is only used on the first token of a statement.
-// Having .fud makes it much easier to define statement-oriented languages like
-// JavaScript. I retained Pratt's nomenclature.
-
-// .nud     Null denotation
-// .fud     First null denotation
-// .led     Left denotation
-//  lbp     Left binding power
-//  rbp     Right binding power
-
-// They are elements of the parsing method called Top Down Operator Precedence.
-
-    function expression(rbp, initial) {
-        var left, isArray = false;
-
-        if (nexttoken.id === '(end)')
-            error("Unexpected early end of program.", token);
-
-        advance();
-        if (initial) {
-            anonname = 'anonymous';
-            funct['(verb)'] = token.value;
-        }
-        if (initial === true && token.fud) {
-            left = token.fud();
-        } else {
-            if (token.nud) {
-                left = token.nud();
-            } else {
-                if (nexttoken.type === '(number)' && token.id === '.') {
-                    warning("A leading decimal point can be confused with a dot: '.{a}'.",
-                            token, nexttoken.value);
-                    advance();
-                    return token;
-                } else {
-                    error("Expected an identifier and instead saw '{a}'.",
-                            token, token.id);
-                }
-            }
-            while (rbp < nexttoken.lbp) {
-                isArray = token.value === 'Array';
-                advance();
-                if (isArray && token.id === '(' && nexttoken.id === ')')
-                    warning("Use the array literal notation [].", token);
-                if (token.led) {
-                    left = token.led(left);
-                } else {
-                    error("Expected an operator and instead saw '{a}'.",
-                        token, token.id);
-                }
-            }
-        }
-        return left;
-    }
-
-
-// Functions for conformance of style.
-
-    function adjacent(left, right) {
-        left = left || token;
-        right = right || nexttoken;
-        if (option.white) {
-            if (left.character !== right.from && left.line === right.line) {
-                left.from += (left.character - left.from);
-                warning("Unexpected space after '{a}'.", left, left.value);
-            }
-        }
-    }
-
-    function nobreak(left, right) {
-        left = left || token;
-        right = right || nexttoken;
-        if (option.white && (left.character !== right.from || left.line !== right.line)) {
-            warning("Unexpected space before '{a}'.", right, right.value);
-        }
-    }
-
-    function nospace(left, right) {
-        left = left || token;
-        right = right || nexttoken;
-        if (option.white && !left.comment) {
-            if (left.line === right.line) {
-                adjacent(left, right);
-            }
-        }
-    }
-
-    function nonadjacent(left, right) {
-        if (option.white) {
-            left = left || token;
-            right = right || nexttoken;
-            if (left.line === right.line && left.character === right.from) {
-                left.from += (left.character - left.from);
-                warning("Missing space after '{a}'.",
-                        left, left.value);
-            }
-        }
-    }
-
-    function nobreaknonadjacent(left, right) {
-        left = left || token;
-        right = right || nexttoken;
-        if (!option.laxbreak && left.line !== right.line) {
-            warning("Bad line breaking before '{a}'.", right, right.id);
-        } else if (option.white) {
-            left = left || token;
-            right = right || nexttoken;
-            if (left.character === right.from) {
-                left.from += (left.character - left.from);
-                warning("Missing space after '{a}'.",
-                        left, left.value);
-            }
-        }
-    }
-
-    function indentation(bias) {
-        var i;
-        if (option.white && nexttoken.id !== '(end)') {
-            i = indent + (bias || 0);
-            if (nexttoken.from !== i) {
-                warning(
-"Expected '{a}' to have an indentation at {b} instead at {c}.",
-                        nexttoken, nexttoken.value, i, nexttoken.from);
-            }
-        }
-    }
-
-    function nolinebreak(t) {
-        t = t || token;
-        if (t.line !== nexttoken.line) {
-            warning("Line breaking error '{a}'.", t, t.value);
-        }
-    }
-
-
-    function comma() {
-        if (token.line !== nexttoken.line) {
-            if (!option.laxcomma) {
-                if (comma.first) {
-                    warning("Comma warnings can be turned off with 'laxcomma'");
-                    comma.first = false;
-                }
-                warning("Bad line breaking before '{a}'.", token, nexttoken.id);
-            }
-        } else if (!token.comment && token.character !== nexttoken.from && option.white) {
-            token.from += (token.character - token.from);
-            warning("Unexpected space after '{a}'.", token, token.value);
-        }
-        advance(',');
-        nonadjacent(token, nexttoken);
-    }
-
-    comma.first = true;
-
-
-// Functional constructors for making the symbols that will be inherited by
-// tokens.
-
-    function symbol(s, p) {
-        var x = syntax[s];
-        if (!x || typeof x !== 'object') {
-            syntax[s] = x = {
-                id: s,
-                lbp: p,
-                value: s
-            };
-        }
-        return x;
-    }
-
-
-    function delim(s) {
-        return symbol(s, 0);
-    }
-
-
-    function stmt(s, f) {
-        var x = delim(s);
-        x.identifier = x.reserved = true;
-        x.fud = f;
-        return x;
-    }
-
-
-    function blockstmt(s, f) {
-        var x = stmt(s, f);
-        x.block = true;
-        return x;
-    }
-
-
-    function reserveName(x) {
-        var c = x.id.charAt(0);
-        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
-            x.identifier = x.reserved = true;
-        }
-        return x;
-    }
-
-
-    function prefix(s, f) {
-        var x = symbol(s, 150);
-        reserveName(x);
-        x.nud = (typeof f === 'function') ? f : function () {
-            this.right = expression(150);
-            this.arity = 'unary';
-            if (this.id === '++' || this.id === '--') {
-                if (option.plusplus) {
-                    warning("Unexpected use of '{a}'.", this, this.id);
-                } else if ((!this.right.identifier || this.right.reserved) &&
-                        this.right.id !== '.' && this.right.id !== '[') {
-                    warning("Bad operand.", this);
-                }
-            }
-            return this;
-        };
-        return x;
-    }
-
-
-    function type(s, f) {
-        var x = delim(s);
-        x.type = s;
-        x.nud = f;
-        return x;
-    }
-
-
-    function reserve(s, f) {
-        var x = type(s, f);
-        x.identifier = x.reserved = true;
-        return x;
-    }
-
-
-    function reservevar(s, v) {
-        return reserve(s, function () {
-            if (typeof v === 'function') {
-                v(this);
-            }
-            return this;
-        });
-    }
-
-
-    function infix(s, f, p, w) {
-        var x = symbol(s, p);
-        reserveName(x);
-        x.led = function (left) {
-            if (!w) {
-                nobreaknonadjacent(prevtoken, token);
-                nonadjacent(token, nexttoken);
-            }
-            if (s === "in" && left.id === "!") {
-                warning("Confusing use of '{a}'.", left, '!');
-            }
-            if (typeof f === 'function') {
-                return f(left, this);
-            } else {
-                this.left = left;
-                this.right = expression(p);
-                return this;
-            }
-        };
-        return x;
-    }
-
-
-    function relation(s, f) {
-        var x = symbol(s, 100);
-        x.led = function (left) {
-            nobreaknonadjacent(prevtoken, token);
-            nonadjacent(token, nexttoken);
-            var right = expression(100);
-            if ((left && left.id === 'NaN') || (right && right.id === 'NaN')) {
-                warning("Use the isNaN function to compare with NaN.", this);
-            } else if (f) {
-                f.apply(this, [left, right]);
-            }
-            if (left.id === '!') {
-                warning("Confusing use of '{a}'.", left, '!');
-            }
-            if (right.id === '!') {
-                warning("Confusing use of '{a}'.", right, '!');
-            }
-            this.left = left;
-            this.right = right;
-            return this;
-        };
-        return x;
-    }
-
-
-    function isPoorRelation(node) {
-        return node &&
-              ((node.type === '(number)' && +node.value === 0) ||
-               (node.type === '(string)' && node.value === '') ||
-               (node.type === 'null' && !option.eqnull) ||
-                node.type === 'true' ||
-                node.type === 'false' ||
-                node.type === 'undefined');
-    }
-
-
-    function assignop(s, f) {
-        symbol(s, 20).exps = true;
-        return infix(s, function (left, that) {
-            var l;
-            that.left = left;
-            if (predefined[left.value] === false &&
-                    scope[left.value]['(global)'] === true) {
-                warning("Read only.", left);
-            } else if (left['function']) {
-                warning("'{a}' is a function.", left, left.value);
-            }
-            if (left) {
-                if (option.esnext && funct[left.value] === 'const') {
-                    warning("Attempting to override '{a}' which is a constant", left, left.value);
-                }
-                if (left.id === '.' || left.id === '[') {
-                    if (!left.left || left.left.value === 'arguments') {
-                        warning('Bad assignment.', that);
-                    }
-                    that.right = expression(19);
-                    return that;
-                } else if (left.identifier && !left.reserved) {
-                    if (funct[left.value] === 'exception') {
-                        warning("Do not assign to the exception parameter.", left);
-                    }
-                    that.right = expression(19);
-                    return that;
-                }
-                if (left === syntax['function']) {
-                    warning(
-"Expected an identifier in an assignment and instead saw a function invocation.",
-                                token);
-                }
-            }
-            error("Bad assignment.", that);
-        }, 20);
-    }
-
-
-    function bitwise(s, f, p) {
-        var x = symbol(s, p);
-        reserveName(x);
-        x.led = (typeof f === 'function') ? f : function (left) {
-            if (option.bitwise) {
-                warning("Unexpected use of '{a}'.", this, this.id);
-            }
-            this.left = left;
-            this.right = expression(p);
-            return this;
-        };
-        return x;
-    }
-
-
-    function bitwiseassignop(s) {
-        symbol(s, 20).exps = true;
-        return infix(s, function (left, that) {
-            if (option.bitwise) {
-                warning("Unexpected use of '{a}'.", that, that.id);
-            }
-            nonadjacent(prevtoken, token);
-            nonadjacent(token, nexttoken);
-            if (left) {
-                if (left.id === '.' || left.id === '[' ||
-                        (left.identifier && !left.reserved)) {
-                    expression(19);
-                    return that;
-                }
-                if (left === syntax['function']) {
-                    warning(
-"Expected an identifier in an assignment, and instead saw a function invocation.",
-                                token);
-                }
-                return that;
-            }
-            error("Bad assignment.", that);
-        }, 20);
-    }
-
-
-    function suffix(s, f) {
-        var x = symbol(s, 150);
-        x.led = function (left) {
-            if (option.plusplus) {
-                warning("Unexpected use of '{a}'.", this, this.id);
-            } else if ((!left.identifier || left.reserved) &&
-                    left.id !== '.' && left.id !== '[') {
-                warning("Bad operand.", this);
-            }
-            this.left = left;
-            return this;
-        };
-        return x;
-    }
-
-
-    // fnparam means that this identifier is being defined as a function
-    // argument (see identifier())
-    function optionalidentifier(fnparam) {
-        if (nexttoken.identifier) {
-            advance();
-            if (token.reserved && !option.es5) {
-                // `undefined` as a function param is a common pattern to protect
-                // against the case when somebody does `undefined = true` and
-                // help with minification. More info: https://gist.github.com/315916
-                if (!fnparam || token.value !== 'undefined') {
-                    warning("Expected an identifier and instead saw '{a}' (a reserved word).",
-                            token, token.id);
-                }
-            }
-            return token.value;
-        }
-    }
-
-    // fnparam means that this identifier is being defined as a function
-    // argument
-    function identifier(fnparam) {
-        var i = optionalidentifier(fnparam);
-        if (i) {
-            return i;
-        }
-        if (token.id === 'function' && nexttoken.id === '(') {
-            warning("Missing name in function declaration.");
-        } else {
-            error("Expected an identifier and instead saw '{a}'.",
-                    nexttoken, nexttoken.value);
-        }
-    }
-
-
-    function reachable(s) {
-        var i = 0, t;
-        if (nexttoken.id !== ';' || noreach) {
-            return;
-        }
-        for (;;) {
-            t = peek(i);
-            if (t.reach) {
-                return;
-            }
-            if (t.id !== '(endline)') {
-                if (t.id === 'function') {
-                    if (!option.latedef) {
-                        break;
-                    }
-                    warning(
-"Inner functions should be listed at the top of the outer function.", t);
-                    break;
-                }
-                warning("Unreachable '{a}' after '{b}'.", t, t.value, s);
-                break;
-            }
-            i += 1;
-        }
-    }
-
-
-    function statement(noindent) {
-        var i = indent, r, s = scope, t = nexttoken;
-
-        if (t.id === ";") {
-            advance(";");
-            return;
-        }
-
-// Is this a labelled statement?
-
-        if (t.identifier && !t.reserved && peek().id === ':') {
-            advance();
-            advance(':');
-            scope = Object.create(s);
-            addlabel(t.value, 'label');
-            if (!nexttoken.labelled) {
-                warning("Label '{a}' on {b} statement.",
-                        nexttoken, t.value, nexttoken.value);
-            }
-            if (jx.test(t.value + ':')) {
-                warning("Label '{a}' looks like a javascript url.",
-                        t, t.value);
-            }
-            nexttoken.label = t.value;
-            t = nexttoken;
-        }
-
-// Parse the statement.
-
-        if (!noindent) {
-            indentation();
-        }
-        r = expression(0, true);
-
-        // Look for the final semicolon.
-        if (!t.block) {
-            if (!option.expr && (!r || !r.exps)) {
-                warning("Expected an assignment or function call and instead saw an expression.",
-                    token);
-            } else if (option.nonew && r.id === '(' && r.left.id === 'new') {
-                warning("Do not use 'new' for side effects.");
-            }
-
-            if (nexttoken.id !== ';') {
-                if (!option.asi) {
-                    // If this is the last statement in a block that ends on
-                    // the same line *and* option lastsemic is on, ignore the warning.
-                    // Otherwise, complain about missing semicolon.
-                    if (!option.lastsemic || nexttoken.id !== '}' ||
-                            nexttoken.line !== token.line) {
-                        warningAt("Missing semicolon.", token.line, token.character);
-                    }
-                }
-            } else {
-                adjacent(token, nexttoken);
-                advance(';');
-                nonadjacent(token, nexttoken);
-            }
-        }
-
-// Restore the indentation.
-
-        indent = i;
-        scope = s;
-        return r;
-    }
-
-
-    function statements(startLine) {
-        var a = [], f, p;
-
-        while (!nexttoken.reach && nexttoken.id !== '(end)') {
-            if (nexttoken.id === ';') {
-                p = peek();
-                if (!p || p.id !== "(") {
-                    warning("Unnecessary semicolon.");
-                }
-                advance(';');
-            } else {
-                a.push(statement(startLine === nexttoken.line));
-            }
-        }
-        return a;
-    }
-
-
-    /*
-     * read all directives
-     * recognizes a simple form of asi, but always
-     * warns, if it is used
-     */
-    function directives() {
-        var i, p, pn;
-
-        for (;;) {
-            if (nexttoken.id === "(string)") {
-                p = peek(0);
-                if (p.id === "(endline)") {
-                    i = 1;
-                    do {
-                        pn = peek(i);
-                        i = i + 1;
-                    } while (pn.id === "(endline)");
-
-                    if (pn.id !== ";") {
-                        if (pn.id !== "(string)" && pn.id !== "(number)" &&
-                            pn.id !== "(regexp)" && pn.identifier !== true &&
-                            pn.id !== "}") {
-                            break;
-                        }
-                        warning("Missing semicolon.", nexttoken);
-                    } else {
-                        p = pn;
-                    }
-                } else if (p.id === "}") {
-                    // directive with no other statements, warn about missing semicolon
-                    warning("Missing semicolon.", p);
-                } else if (p.id !== ";") {
-                    break;
-                }
-
-                indentation();
-                advance();
-                if (directive[token.value]) {
-                    warning("Unnecessary directive \"{a}\".", token, token.value);
-                }
-
-                if (token.value === "use strict") {
-                    option.newcap = true;
-                    option.undef = true;
-                }
-
-                // there's no directive negation, so always set to true
-                directive[token.value] = true;
-
-                if (p.id === ";") {
-                    advance(";");
-                }
-                continue;
-            }
-            break;
-        }
-    }
-
-
-    /*
-     * Parses a single block. A block is a sequence of statements wrapped in
-     * braces.
-     *
-     * ordinary - true for everything but function bodies and try blocks.
-     * stmt     - true if block can be a single statement (e.g. in if/for/while).
-     * isfunc   - true if block is a function body
-     */
-    function block(ordinary, stmt, isfunc) {
-        var a,
-            b = inblock,
-            old_indent = indent,
-            m,
-            s = scope,
-            t,
-            line,
-            d;
-
-        inblock = ordinary;
-        if (!ordinary || !option.funcscope) scope = Object.create(scope);
-        nonadjacent(token, nexttoken);
-        t = nexttoken;
-
-        if (nexttoken.id === '{') {
-            advance('{');
-            line = token.line;
-            if (nexttoken.id !== '}') {
-                indent += option.indent;
-                while (!ordinary && nexttoken.from > indent) {
-                    indent += option.indent;
-                }
-
-                if (isfunc) {
-                    m = {};
-                    for (d in directive) {
-                        if (is_own(directive, d)) {
-                            m[d] = directive[d];
-                        }
-                    }
-                    directives();
-
-                    if (option.strict && funct['(context)']['(global)']) {
-                        if (!m["use strict"] && !directive["use strict"]) {
-                            warning("Missing \"use strict\" statement.");
-                        }
-                    }
-                }
-
-                a = statements(line);
-
-                if (isfunc) {
-                    directive = m;
-                }
-
-                indent -= option.indent;
-                if (line !== nexttoken.line) {
-                    indentation();
-                }
-            } else if (line !== nexttoken.line) {
-                indentation();
-            }
-            advance('}', t);
-            indent = old_indent;
-        } else if (!ordinary) {
-            error("Expected '{a}' and instead saw '{b}'.",
-                  nexttoken, '{', nexttoken.value);
-        } else {
-            if (!stmt || option.curly)
-                warning("Expected '{a}' and instead saw '{b}'.",
-                        nexttoken, '{', nexttoken.value);
-
-            noreach = true;
-            indent += option.indent;
-            // test indentation only if statement is in new line
-            a = [statement(nexttoken.line === token.line)];
-            indent -= option.indent;
-            noreach = false;
-        }
-        funct['(verb)'] = null;
-        if (!ordinary || !option.funcscope) scope = s;
-        inblock = b;
-        if (ordinary && option.noempty && (!a || a.length === 0)) {
-            warning("Empty block.");
-        }
-        return a;
-    }
-
-
-    function countMember(m) {
-        if (membersOnly && typeof membersOnly[m] !== 'boolean') {
-            warning("Unexpected /*member '{a}'.", token, m);
-        }
-        if (typeof member[m] === 'number') {
-            member[m] += 1;
-        } else {
-            member[m] = 1;
-        }
-    }
-
-
-    function note_implied(token) {
-        var name = token.value, line = token.line, a = implied[name];
-        if (typeof a === 'function') {
-            a = false;
-        }
-        if (!a) {
-            a = [line];
-            implied[name] = a;
-        } else if (a[a.length - 1] !== line) {
-            a.push(line);
-        }
-    }
-
-
-    // Build the syntax table by declaring the syntactic elements of the language.
-
-    type('(number)', function () {
-        return this;
-    });
-
-    type('(string)', function () {
-        return this;
-    });
-
-    syntax['(identifier)'] = {
-        type: '(identifier)',
-        lbp: 0,
-        identifier: true,
-        nud: function () {
-            var v = this.value,
-                s = scope[v],
-                f;
-
-            if (typeof s === 'function') {
-                // Protection against accidental inheritance.
-                s = undefined;
-            } else if (typeof s === 'boolean') {
-                f = funct;
-                funct = functions[0];
-                addlabel(v, 'var');
-                s = funct;
-                funct = f;
-            }
-
-            // The name is in scope and defined in the current function.
-            if (funct === s) {
-                // Change 'unused' to 'var', and reject labels.
-                switch (funct[v]) {
-                case 'unused':
-                    funct[v] = 'var';
-                    break;
-                case 'unction':
-                    funct[v] = 'function';
-                    this['function'] = true;
-                    break;
-                case 'function':
-                    this['function'] = true;
-                    break;
-                case 'label':
-                    warning("'{a}' is a statement label.", token, v);
-                    break;
-                }
-            } else if (funct['(global)']) {
-                // The name is not defined in the function.  If we are in the global
-                // scope, then we have an undefined variable.
-                //
-                // Operators typeof and delete do not raise runtime errors even if
-                // the base object of a reference is null so no need to display warning
-                // if we're inside of typeof or delete.
-
-                if (option.undef && typeof predefined[v] !== 'boolean') {
-                    // Attempting to subscript a null reference will throw an
-                    // error, even within the typeof and delete operators
-                    if (!(anonname === 'typeof' || anonname === 'delete') ||
-                        (nexttoken && (nexttoken.value === '.' || nexttoken.value === '['))) {
-
-                        isundef(funct, "'{a}' is not defined.", token, v);
-                    }
-                }
-                note_implied(token);
-            } else {
-                // If the name is already defined in the current
-                // function, but not as outer, then there is a scope error.
-
-                switch (funct[v]) {
-                case 'closure':
-                case 'function':
-                case 'var':
-                case 'unused':
-                    warning("'{a}' used out of scope.", token, v);
-                    break;
-                case 'label':
-                    warning("'{a}' is a statement label.", token, v);
-                    break;
-                case 'outer':
-                case 'global':
-                    break;
-                default:
-                    // If the name is defined in an outer function, make an outer entry,
-                    // and if it was unused, make it var.
-                    if (s === true) {
-                        funct[v] = true;
-                    } else if (s === null) {
-                        warning("'{a}' is not allowed.", token, v);
-                        note_implied(token);
-                    } else if (typeof s !== 'object') {
-                        // Operators typeof and delete do not raise runtime errors even
-                        // if the base object of a reference is null so no need to
-                        // display warning if we're inside of typeof or delete.
-                        if (option.undef) {
-                            // Attempting to subscript a null reference will throw an
-                            // error, even within the typeof and delete operators
-                            if (!(anonname === 'typeof' || anonname === 'delete') ||
-                                (nexttoken &&
-                                    (nexttoken.value === '.' || nexttoken.value === '['))) {
-
-                                isundef(funct, "'{a}' is not defined.", token, v);
-                            }
-                        }
-                        funct[v] = true;
-                        note_implied(token);
-                    } else {
-                        switch (s[v]) {
-                        case 'function':
-                        case 'unction':
-                            this['function'] = true;
-                            s[v] = 'closure';
-                            funct[v] = s['(global)'] ? 'global' : 'outer';
-                            break;
-                        case 'var':
-                        case 'unused':
-                            s[v] = 'closure';
-                            funct[v] = s['(global)'] ? 'global' : 'outer';
-                            break;
-                        case 'closure':
-                        case 'parameter':
-                            funct[v] = s['(global)'] ? 'global' : 'outer';
-                            break;
-                        case 'label':
-                            warning("'{a}' is a statement label.", token, v);
-                        }
-                    }
-                }
-            }
-            return this;
-        },
-        led: function () {
-            error("Expected an operator and instead saw '{a}'.",
-                nexttoken, nexttoken.value);
-        }
-    };
-
-    type('(regexp)', function () {
-        return this;
-    });
-
-
-// ECMAScript parser
-
-    delim('(endline)');
-    delim('(begin)');
-    delim('(end)').reach = true;
-    delim('</').reach = true;
-    delim('<!');
-    delim('<!--');
-    delim('-->');
-    delim('(error)').reach = true;
-    delim('}').reach = true;
-    delim(')');
-    delim(']');
-    delim('"').reach = true;
-    delim("'").reach = true;
-    delim(';');
-    delim(':').reach = true;
-    delim(',');
-    delim('#');
-    delim('@');
-    reserve('else');
-    reserve('case').reach = true;
-    reserve('catch');
-    reserve('default').reach = true;
-    reserve('finally');
-    reservevar('arguments', function (x) {
-        if (directive['use strict'] && funct['(global)']) {
-            warning("Strict violation.", x);
-        }
-    });
-    reservevar('eval');
-    reservevar('false');
-    reservevar('Infinity');
-    reservevar('NaN');
-    reservevar('null');
-    reservevar('this', function (x) {
-        if (directive['use strict'] && !option.validthis && ((funct['(statement)'] &&
-                funct['(name)'].charAt(0) > 'Z') || funct['(global)'])) {
-            warning("Possible strict violation.", x);
-        }
-    });
-    reservevar('true');
-    reservevar('undefined');
-    assignop('=', 'assign', 20);
-    assignop('+=', 'assignadd', 20);
-    assignop('-=', 'assignsub', 20);
-    assignop('*=', 'assignmult', 20);
-    assignop('/=', 'assigndiv', 20).nud = function () {
-        error("A regular expression literal can be confused with '/='.");
-    };
-    assignop('%=', 'assignmod', 20);
-    bitwiseassignop('&=', 'assignbitand', 20);
-    bitwiseassignop('|=', 'assignbitor', 20);
-    bitwiseassignop('^=', 'assignbitxor', 20);
-    bitwiseassignop('<<=', 'assignshiftleft', 20);
-    bitwiseassignop('>>=', 'assignshiftright', 20);
-    bitwiseassignop('>>>=', 'assignshiftrightunsigned', 20);
-    infix('?', function (left, that) {
-        that.left = left;
-        that.right = expression(10);
-        advance(':');
-        that['else'] = expression(10);
-        return that;
-    }, 30);
-
-    infix('||', 'or', 40);
-    infix('&&', 'and', 50);
-    bitwise('|', 'bitor', 70);
-    bitwise('^', 'bitxor', 80);
-    bitwise('&', 'bitand', 90);
-    relation('==', function (left, right) {
-        var eqnull = option.eqnull && (left.value === 'null' || right.value === 'null');
-
-        if (!eqnull && option.eqeqeq)
-            warning("Expected '{a}' and instead saw '{b}'.", this, '===', '==');
-        else if (isPoorRelation(left))
-            warning("Use '{a}' to compare with '{b}'.", this, '===', left.value);
-        else if (isPoorRelation(right))
-            warning("Use '{a}' to compare with '{b}'.", this, '===', right.value);
-
-        return this;
-    });
-    relation('===');
-    relation('!=', function (left, right) {
-        var eqnull = option.eqnull &&
-                (left.value === 'null' || right.value === 'null');
-
-        if (!eqnull && option.eqeqeq) {
-            warning("Expected '{a}' and instead saw '{b}'.",
-                    this, '!==', '!=');
-        } else if (isPoorRelation(left)) {
-            warning("Use '{a}' to compare with '{b}'.",
-                    this, '!==', left.value);
-        } else if (isPoorRelation(right)) {
-            warning("Use '{a}' to compare with '{b}'.",
-                    this, '!==', right.value);
-        }
-        return this;
-    });
-    relation('!==');
-    relation('<');
-    relation('>');
-    relation('<=');
-    relation('>=');
-    bitwise('<<', 'shiftleft', 120);
-    bitwise('>>', 'shiftright', 120);
-    bitwise('>>>', 'shiftrightunsigned', 120);
-    infix('in', 'in', 120);
-    infix('instanceof', 'instanceof', 120);
-    infix('+', function (left, that) {
-        var right = expression(130);
-        if (left && right && left.id === '(string)' && right.id === '(string)') {
-            left.value += right.value;
-            left.character = right.character;
-            if (!option.scripturl && jx.test(left.value)) {
-                warning("JavaScript URL.", left);
-            }
-            return left;
-        }
-        that.left = left;
-        that.right = right;
-        return that;
-    }, 130);
-    prefix('+', 'num');
-    prefix('+++', function () {
-        warning("Confusing pluses.");
-        this.right = expression(150);
-        this.arity = 'unary';
-        return this;
-    });
-    infix('+++', function (left) {
-        warning("Confusing pluses.");
-        this.left = left;
-        this.right = expression(130);
-        return this;
-    }, 130);
-    infix('-', 'sub', 130);
-    prefix('-', 'neg');
-    prefix('---', function () {
-        warning("Confusing minuses.");
-        this.right = expression(150);
-        this.arity = 'unary';
-        return this;
-    });
-    infix('---', function (left) {
-        warning("Confusing minuses.");
-        this.left = left;
-        this.right = expression(130);
-        return this;
-    }, 130);
-    infix('*', 'mult', 140);
-    infix('/', 'div', 140);
-    infix('%', 'mod', 140);
-
-    suffix('++', 'postinc');
-    prefix('++', 'preinc');
-    syntax['++'].exps = true;
-
-    suffix('--', 'postdec');
-    prefix('--', 'predec');
-    syntax['--'].exps = true;
-    prefix('delete', function () {
-        var p = expression(0);
-        if (!p || (p.id !== '.' && p.id !== '[')) {
-            warning("Variables should not be deleted.");
-        }
-        this.first = p;
-        return this;
-    }).exps = true;
-
-    prefix('~', function () {
-        if (option.bitwise) {
-            warning("Unexpected '{a}'.", this, '~');
-        }
-        expression(150);
-        return this;
-    });
-
-    prefix('!', function () {
-        this.right = expression(150);
-        this.arity = 'unary';
-        if (bang[this.right.id] === true) {
-            warning("Confusing use of '{a}'.", this, '!');
-        }
-        return this;
-    });
-    prefix('typeof', 'typeof');
-    prefix('new', function () {
-        var c = expression(155), i;
-        if (c && c.id !== 'function') {
-            if (c.identifier) {
-                c['new'] = true;
-                switch (c.value) {
-                case 'Object':
-                    warning("Use the object literal notation {}.", token);
-                    break;
-                case 'Number':
-                case 'String':
-                case 'Boolean':
-                case 'Math':
-                case 'JSON':
-                    warning("Do not use {a} as a constructor.", token, c.value);
-                    break;
-                case 'Function':
-                    if (!option.evil) {
-                        warning("The Function constructor is eval.");
-                    }
-                    break;
-                case 'Date':
-                case 'RegExp':
-                    break;
-                default:
-                    if (c.id !== 'function') {
-                        i = c.value.substr(0, 1);
-                        if (option.newcap && (i < 'A' || i > 'Z')) {
-                            warning("A constructor name should start with an uppercase letter.",
-                                token);
-                        }
-                    }
-                }
-            } else {
-                if (c.id !== '.' && c.id !== '[' && c.id !== '(') {
-                    warning("Bad constructor.", token);
-                }
-            }
-        } else {
-            if (!option.supernew)
-                warning("Weird construction. Delete 'new'.", this);
-        }
-        adjacent(token, nexttoken);
-        if (nexttoken.id !== '(' && !option.supernew) {
-            warning("Missing '()' invoking a constructor.");
-        }
-        this.first = c;
-        return this;
-    });
-    syntax['new'].exps = true;
-
-    prefix('void').exps = true;
-
-    infix('.', function (left, that) {
-        adjacent(prevtoken, token);
-        nobreak();
-        var m = identifier();
-        if (typeof m === 'string') {
-            countMember(m);
-        }
-        that.left = left;
-        that.right = m;
-        if (left && left.value === 'arguments' && (m === 'callee' || m === 'caller')) {
-            if (option.noarg)
-                warning("Avoid arguments.{a}.", left, m);
-            else if (directive['use strict'])
-                error('Strict violation.');
-        } else if (!option.evil && left && left.value === 'document' &&
-                (m === 'write' || m === 'writeln')) {
-            warning("document.write can be a form of eval.", left);
-        }
-        if (!option.evil && (m === 'eval' || m === 'execScript')) {
-            warning('eval is evil.');
-        }
-        return that;
-    }, 160, true);
-
-    infix('(', function (left, that) {
-        if (prevtoken.id !== '}' && prevtoken.id !== ')') {
-            nobreak(prevtoken, token);
-        }
-        nospace();
-        if (option.immed && !left.immed && left.id === 'function') {
-            warning("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.");
-        }
-        var n = 0,
-            p = [];
-        if (left) {
-            if (left.type === '(identifier)') {
-                if (left.value.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) {
-                    if (left.value !== 'Number' && left.value !== 'String' &&
-                            left.value !== 'Boolean' &&
-                            left.value !== 'Date') {
-                        if (left.value === 'Math') {
-                            warning("Math is not a function.", left);
-                        } else if (option.newcap) {
-                            warning(
-"Missing 'new' prefix when invoking a constructor.", left);
-                        }
-                    }
-                }
-            }
-        }
-        if (nexttoken.id !== ')') {
-            for (;;) {
-                p[p.length] = expression(10);
-                n += 1;
-                if (nexttoken.id !== ',') {
-                    break;
-                }
-                comma();
-            }
-        }
-        advance(')');
-        nospace(prevtoken, token);
-        if (typeof left === 'object') {
-            if (left.value === 'parseInt' && n === 1) {
-                warning("Missing radix parameter.", left);
-            }
-            if (!option.evil) {
-                if (left.value === 'eval' || left.value === 'Function' ||
-                        left.value === 'execScript') {
-                    warning("eval is evil.", left);
-                } else if (p[0] && p[0].id === '(string)' &&
-                       (left.value === 'setTimeout' ||
-                        left.value === 'setInterval')) {
-                    warning(
-    "Implied eval is evil. Pass a function instead of a string.", left);
-                }
-            }
-            if (!left.identifier && left.id !== '.' && left.id !== '[' &&
-                    left.id !== '(' && left.id !== '&&' && left.id !== '||' &&
-                    left.id !== '?') {
-                warning("Bad invocation.", left);
-            }
-        }
-        that.left = left;
-        return that;
-    }, 155, true).exps = true;
-
-    prefix('(', function () {
-        nospace();
-        if (nexttoken.id === 'function') {
-            nexttoken.immed = true;
-        }
-        var v = expression(0);
-        advance(')', this);
-        nospace(prevtoken, token);
-        if (option.immed && v.id === 'function') {
-            if (nexttoken.id === '(') {
-                warning(
-"Move the invocation into the parens that contain the function.", nexttoken);
-            } else {
-                warning(
-"Do not wrap function literals in parens unless they are to be immediately invoked.",
-                        this);
-            }
-        }
-        return v;
-    });
-
-    infix('[', function (left, that) {
-        nobreak(prevtoken, token);
-        nospace();
-        var e = expression(0), s;
-        if (e && e.type === '(string)') {
-            if (!option.evil && (e.value === 'eval' || e.value === 'execScript')) {
-                warning("eval is evil.", that);
-            }
-            countMember(e.value);
-            if (!option.sub && ix.test(e.value)) {
-                s = syntax[e.value];
-                if (!s || !s.reserved) {
-                    warning("['{a}'] is better written in dot notation.",
-                            e, e.value);
-                }
-            }
-        }
-        advance(']', that);
-        nospace(prevtoken, token);
-        that.left = left;
-        that.right = e;
-        return that;
-    }, 160, true);
-
-    prefix('[', function () {
-        var b = token.line !== nexttoken.line;
-        this.first = [];
-        if (b) {
-            indent += option.indent;
-            if (nexttoken.from === indent + option.indent) {
-                indent += option.indent;
-            }
-        }
-        while (nexttoken.id !== '(end)') {
-            while (nexttoken.id === ',') {
-                warning("Extra comma.");
-                advance(',');
-            }
-            if (nexttoken.id === ']') {
-                break;
-            }
-            if (b && token.line !== nexttoken.line) {
-                indentation();
-            }
-            this.first.push(expression(10));
-            if (nexttoken.id === ',') {
-                comma();
-                if (nexttoken.id === ']' && !option.es5) {
-                    warning("Extra comma.", token);
-                    break;
-                }
-            } else {
-                break;
-            }
-        }
-        if (b) {
-            indent -= option.indent;
-            indentation();
-        }
-        advance(']', this);
-        return this;
-    }, 160);
-
-
-    function property_name() {
-        var id = optionalidentifier(true);
-        if (!id) {
-            if (nexttoken.id === '(string)') {
-                id = nexttoken.value;
-                advance();
-            } else if (nexttoken.id === '(number)') {
-                id = nexttoken.value.toString();
-                advance();
-            }
-        }
-        return id;
-    }
-
-
-    function functionparams() {
-        var i, t = nexttoken, p = [];
-        advance('(');
-        nospace();
-        if (nexttoken.id === ')') {
-            advance(')');
-            return;
-        }
-        for (;;) {
-            i = identifier(true);
-            p.push(i);
-            addlabel(i, 'parameter');
-            if (nexttoken.id === ',') {
-                comma();
-            } else {
-                advance(')', t);
-                nospace(prevtoken, token);
-                return p;
-            }
-        }
-    }
-
-
-    function doFunction(i, statement) {
-        var f,
-            oldOption = option,
-            oldScope  = scope;
-
-        option = Object.create(option);
-        scope = Object.create(scope);
-
-        funct = {
-            '(name)'     : i || '"' + anonname + '"',
-            '(line)'     : nexttoken.line,
-            '(context)'  : funct,
-            '(breakage)' : 0,
-            '(loopage)'  : 0,
-            '(scope)'    : scope,
-            '(statement)': statement
-        };
-        f = funct;
-        token.funct = funct;
-        functions.push(funct);
-        if (i) {
-            addlabel(i, 'function');
-        }
-        funct['(params)'] = functionparams();
-
-        block(false, false, true);
-        scope = oldScope;
-        option = oldOption;
-        funct['(last)'] = token.line;
-        funct = funct['(context)'];
-        return f;
-    }
-
-
-    (function (x) {
-        x.nud = function () {
-            var b, f, i, j, p, t;
-            var props = {}; // All properties, including accessors
-
-            function saveProperty(name, token) {
-                if (props[name] && is_own(props, name))
-                    warning("Duplicate member '{a}'.", nexttoken, i);
-                else
-                    props[name] = {};
-
-                props[name].basic = true;
-                props[name].basicToken = token;
-            }
-
-            function saveSetter(name, token) {
-                if (props[name] && is_own(props, name)) {
-                    if (props[name].basic || props[name].setter)
-                        warning("Duplicate member '{a}'.", nexttoken, i);
-                } else {
-                    props[name] = {};
-                }
-
-                props[name].setter = true;
-                props[name].setterToken = token;
-            }
-
-            function saveGetter(name) {
-                if (props[name] && is_own(props, name)) {
-                    if (props[name].basic || props[name].getter)
-                        warning("Duplicate member '{a}'.", nexttoken, i);
-                } else {
-                    props[name] = {};
-                }
-
-                props[name].getter = true;
-                props[name].getterToken = token;
-            }
-
-            b = token.line !== nexttoken.line;
-            if (b) {
-                indent += option.indent;
-                if (nexttoken.from === indent + option.indent) {
-                    indent += option.indent;
-                }
-            }
-            for (;;) {
-                if (nexttoken.id === '}') {
-                    break;
-                }
-                if (b) {
-                    indentation();
-                }
-                if (nexttoken.value === 'get' && peek().id !== ':') {
-                    advance('get');
-                    if (!option.es5) {
-                        error("get/set are ES5 features.");
-                    }
-                    i = property_name();
-                    if (!i) {
-                        error("Missing property name.");
-                    }
-                    saveGetter(i);
-                    t = nexttoken;
-                    adjacent(token, nexttoken);
-                    f = doFunction();
-                    p = f['(params)'];
-                    if (p) {
-                        warning("Unexpected parameter '{a}' in get {b} function.", t, p[0], i);
-                    }
-                    adjacent(token, nexttoken);
-                } else if (nexttoken.value === 'set' && peek().id !== ':') {
-                    advance('set');
-                    if (!option.es5) {
-                        error("get/set are ES5 features.");
-                    }
-                    i = property_name();
-                    if (!i) {
-                        error("Missing property name.");
-                    }
-                    saveSetter(i, nexttoken);
-                    t = nexttoken;
-                    adjacent(token, nexttoken);
-                    f = doFunction();
-                    p = f['(params)'];
-                    if (!p || p.length !== 1) {
-                        warning("Expected a single parameter in set {a} function.", t, i);
-                    }
-                } else {
-                    i = property_name();
-                    saveProperty(i, nexttoken);
-                    if (typeof i !== 'string') {
-                        break;
-                    }
-                    advance(':');
-                    nonadjacent(token, nexttoken);
-                    expression(10);
-                }
-
-                countMember(i);
-                if (nexttoken.id === ',') {
-                    comma();
-                    if (nexttoken.id === ',') {
-                        warning("Extra comma.", token);
-                    } else if (nexttoken.id === '}' && !option.es5) {
-                        warning("Extra comma.", token);
-                    }
-                } else {
-                    break;
-                }
-            }
-            if (b) {
-                indent -= option.indent;
-                indentation();
-            }
-            advance('}', this);
-
-            // Check for lonely setters if in the ES5 mode.
-            if (option.es5) {
-                for (var name in props) {
-                    if (is_own(props, name) && props[name].setter && !props[name].getter) {
-                        warning("Setter is defined without getter.", props[name].setterToken);
-                    }
-                }
-            }
-            return this;
-        };
-        x.fud = function () {
-            error("Expected to see a statement and instead saw a block.", token);
-        };
-    }(delim('{')));
-
-// This Function is called when esnext option is set to true
-// it adds the `const` statement to JSHINT
-
-    useESNextSyntax = function () {
-        var conststatement = stmt('const', function (prefix) {
-            var id, name, value;
-
-            this.first = [];
-            for (;;) {
-                nonadjacent(token, nexttoken);
-                id = identifier();
-                if (funct[id] === "const") {
-                    warning("const '" + id + "' has already been declared");
-                }
-                if (funct['(global)'] && predefined[id] === false) {
-                    warning("Redefinition of '{a}'.", token, id);
-                }
-                addlabel(id, 'const');
-                if (prefix) {
-                    break;
-                }
-                name = token;
-                this.first.push(token);
-
-                if (nexttoken.id !== "=") {
-                    warning("const " +
-                      "'{a}' is initialized to 'undefined'.", token, id);
-                }
-
-                if (nexttoken.id === '=') {
-                    nonadjacent(token, nexttoken);
-                    advance('=');
-                    nonadjacent(token, nexttoken);
-                    if (nexttoken.id === 'undefined') {
-                        warning("It is not necessary to initialize " +
-                          "'{a}' to 'undefined'.", token, id);
-                    }
-                    if (peek(0).id === '=' && nexttoken.identifier) {
-                        error("Constant {a} was not declared correctly.",
-                                nexttoken, nexttoken.value);
-                    }
-                    value = expression(0);
-                    name.first = value;
-                }
-
-                if (nexttoken.id !== ',') {
-                    break;
-                }
-                comma();
-            }
-            return this;
-        });
-        conststatement.exps = true;
-    };
-
-    var varstatement = stmt('var', function (prefix) {
-        // JavaScript does not have block scope. It only has function scope. So,
-        // declaring a variable in a block can have unexpected consequences.
-        var id, name, value;
-
-        if (funct['(onevar)'] && option.onevar) {
-            warning("Too many var statements.");
-        } else if (!funct['(global)']) {
-            funct['(onevar)'] = true;
-        }
-        this.first = [];
-        for (;;) {
-            nonadjacent(token, nexttoken);
-            id = identifier();
-            if (option.esnext && funct[id] === "const") {
-                warning("const '" + id + "' has already been declared");
-            }
-            if (funct['(global)'] && predefined[id] === false) {
-                warning("Redefinition of '{a}'.", token, id);
-            }
-            addlabel(id, 'unused');
-            if (prefix) {
-                break;
-            }
-            name = token;
-            this.first.push(token);
-            if (nexttoken.id === '=') {
-                nonadjacent(token, nexttoken);
-                advance('=');
-                nonadjacent(token, nexttoken);
-                if (nexttoken.id === 'undefined') {
-                    warning("It is not necessary to initialize '{a}' to 'undefined'.", token, id);
-                }
-                if (peek(0).id === '=' && nexttoken.identifier) {
-                    error("Variable {a} was not declared correctly.",
-                            nexttoken, nexttoken.value);
-                }
-                value = expression(0);
-                name.first = value;
-            }
-            if (nexttoken.id !== ',') {
-                break;
-            }
-            comma();
-        }
-        return this;
-    });
-    varstatement.exps = true;
-
-    blockstmt('function', function () {
-        if (inblock) {
-            warning("Function declarations should not be placed in blocks. " +
-                "Use a function expression or move the statement to the top of " +
-                "the outer function.", token);
-
-        }
-        var i = identifier();
-        if (option.esnext && funct[i] === "const") {
-            warning("const '" + i + "' has already been declared");
-        }
-        adjacent(token, nexttoken);
-        addlabel(i, 'unction');
-        doFunction(i, true);
-        if (nexttoken.id === '(' && nexttoken.line === token.line) {
-            error(
-"Function declarations are not invocable. Wrap the whole function invocation in parens.");
-        }
-        return this;
-    });
-
-    prefix('function', function () {
-        var i = optionalidentifier();
-        if (i) {
-            adjacent(token, nexttoken);
-        } else {
-            nonadjacent(token, nexttoken);
-        }
-        doFunction(i);
-        if (!option.loopfunc && funct['(loopage)']) {
-            warning("Don't make functions within a loop.");
-        }
-        return this;
-    });
-
-    blockstmt('if', function () {
-        var t = nexttoken;
-        advance('(');
-        nonadjacent(this, t);
-        nospace();
-        expression(20);
-        if (nexttoken.id === '=') {
-            if (!option.boss)
-                warning("Expected a conditional expression and instead saw an assignment.");
-            advance('=');
-            expression(20);
-        }
-        advance(')', t);
-        nospace(prevtoken, token);
-        block(true, true);
-        if (nexttoken.id === 'else') {
-            nonadjacent(token, nexttoken);
-            advance('else');
-            if (nexttoken.id === 'if' || nexttoken.id === 'switch') {
-                statement(true);
-            } else {
-                block(true, true);
-            }
-        }
-        return this;
-    });
-
-    blockstmt('try', function () {
-        var b, e, s;
-
-        block(false);
-        if (nexttoken.id === 'catch') {
-            advance('catch');
-            nonadjacent(token, nexttoken);
-            advance('(');
-            s = scope;
-            scope = Object.create(s);
-            e = nexttoken.value;
-            if (nexttoken.type !== '(identifier)') {
-                warning("Expected an identifier and instead saw '{a}'.",
-                    nexttoken, e);
-            } else {
-                addlabel(e, 'exception');
-            }
-            advance();
-            advance(')');
-            block(false);
-            b = true;
-            scope = s;
-        }
-        if (nexttoken.id === 'finally') {
-            advance('finally');
-            block(false);
-            return;
-        } else if (!b) {
-            error("Expected '{a}' and instead saw '{b}'.",
-                    nexttoken, 'catch', nexttoken.value);
-        }
-        return this;
-    });
-
-    blockstmt('while', function () {
-        var t = nexttoken;
-        funct['(breakage)'] += 1;
-        funct['(loopage)'] += 1;
-        advance('(');
-        nonadjacent(this, t);
-        nospace();
-        expression(20);
-        if (nexttoken.id === '=') {
-            if (!option.boss)
-                warning("Expected a conditional expression and instead saw an assignment.");
-            advance('=');
-            expression(20);
-        }
-        advance(')', t);
-        nospace(prevtoken, token);
-        block(true, true);
-        funct['(breakage)'] -= 1;
-        funct['(loopage)'] -= 1;
-        return this;
-    }).labelled = true;
-
-    reserve('with');
-
-    blockstmt('switch', function () {
-        var t = nexttoken,
-            g = false;
-        funct['(breakage)'] += 1;
-        advance('(');
-        nonadjacent(this, t);
-        nospace();
-        this.condition = expression(20);
-        advance(')', t);
-        nospace(prevtoken, token);
-        nonadjacent(token, nexttoken);
-        t = nexttoken;
-        advance('{');
-        nonadjacent(token, nexttoken);
-        indent += option.indent;
-        this.cases = [];
-        for (;;) {
-            switch (nexttoken.id) {
-            case 'case':
-                switch (funct['(verb)']) {
-                case 'break':
-                case 'case':
-                case 'continue':
-                case 'return':
-                case 'switch':
-                case 'throw':
-                    break;
-                default:
-                    // You can tell JSHint that you don't use break intentionally by
-                    // adding a comment /* falls through */ on a line just before
-                    // the next `case`.
-                    if (!ft.test(lines[nexttoken.line - 2])) {
-                        warning(
-                            "Expected a 'break' statement before 'case'.",
-                            token);
-                    }
-                }
-                indentation(-option.indent);
-                advance('case');
-                this.cases.push(expression(20));
-                g = true;
-                advance(':');
-                funct['(verb)'] = 'case';
-                break;
-            case 'default':
-                switch (funct['(verb)']) {
-                case 'break':
-                case 'continue':
-                case 'return':
-                case 'throw':
-                    break;
-                default:
-                    if (!ft.test(lines[nexttoken.line - 2])) {
-                        warning(
-                            "Expected a 'break' statement before 'default'.",
-                            token);
-                    }
-                }
-                indentation(-option.indent);
-                advance('default');
-                g = true;
-                advance(':');
-                break;
-            case '}':
-                indent -= option.indent;
-                indentation();
-                advance('}', t);
-                if (this.cases.length === 1 || this.condition.id === 'true' ||
-                        this.condition.id === 'false') {
-                    if (!option.onecase)
-                        warning("This 'switch' should be an 'if'.", this);
-                }
-                funct['(breakage)'] -= 1;
-                funct['(verb)'] = undefined;
-                return;
-            case '(end)':
-                error("Missing '{a}'.", nexttoken, '}');
-                return;
-            default:
-                if (g) {
-                    switch (token.id) {
-                    case ',':
-                        error("Each value should have its own case label.");
-                        return;
-                    case ':':
-                        g = false;
-                        statements();
-                        break;
-                    default:
-                        error("Missing ':' on a case clause.", token);
-                        return;
-                    }
-                } else {
-                    if (token.id === ':') {
-                        advance(':');
-                        error("Unexpected '{a}'.", token, ':');
-                        statements();
-                    } else {
-                        error("Expected '{a}' and instead saw '{b}'.",
-                            nexttoken, 'case', nexttoken.value);
-                        return;
-                    }
-                }
-            }
-        }
-    }).labelled = true;
-
-    stmt('debugger', function () {
-        if (!option.debug) {
-            warning("All 'debugger' statements should be removed.");
-        }
-        return this;
-    }).exps = true;
-
-    (function () {
-        var x = stmt('do', function () {
-            funct['(breakage)'] += 1;
-            funct['(loopage)'] += 1;
-            this.first = block(true);
-            advance('while');
-            var t = nexttoken;
-            nonadjacent(token, t);
-            advance('(');
-            nospace();
-            expression(20);
-            if (nexttoken.id === '=') {
-                if (!option.boss)
-                    warning("Expected a conditional expression and instead saw an assignment.");
-                advance('=');
-                expression(20);
-            }
-            advance(')', t);
-            nospace(prevtoken, token);
-            funct['(breakage)'] -= 1;
-            funct['(loopage)'] -= 1;
-            return this;
-        });
-        x.labelled = true;
-        x.exps = true;
-    }());
-
-    blockstmt('for', function () {
-        var s, t = nexttoken;
-        funct['(breakage)'] += 1;
-        funct['(loopage)'] += 1;
-        advance('(');
-        nonadjacent(this, t);
-        nospace();
-        if (peek(nexttoken.id === 'var' ? 1 : 0).id === 'in') {
-            if (nexttoken.id === 'var') {
-                advance('var');
-                varstatement.fud.call(varstatement, true);
-            } else {
-                switch (funct[nexttoken.value]) {
-                case 'unused':
-                    funct[nexttoken.value] = 'var';
-                    break;
-                case 'var':
-                    break;
-                default:
-                    warning("Bad for in variable '{a}'.",
-                            nexttoken, nexttoken.value);
-                }
-                advance();
-            }
-            advance('in');
-            expression(20);
-            advance(')', t);
-            s = block(true, true);
-            if (option.forin && s && (s.length > 1 || typeof s[0] !== 'object' ||
-                    s[0].value !== 'if')) {
-                warning("The body of a for in should be wrapped in an if statement to filter " +
-                        "unwanted properties from the prototype.", this);
-            }
-            funct['(breakage)'] -= 1;
-            funct['(loopage)'] -= 1;
-            return this;
-        } else {
-            if (nexttoken.id !== ';') {
-                if (nexttoken.id === 'var') {
-                    advance('var');
-                    varstatement.fud.call(varstatement);
-                } else {
-                    for (;;) {
-                        expression(0, 'for');
-                        if (nexttoken.id !== ',') {
-                            break;
-                        }
-                        comma();
-                    }
-                }
-            }
-            nolinebreak(token);
-            advance(';');
-            if (nexttoken.id !== ';') {
-                expression(20);
-                if (nexttoken.id === '=') {
-                    if (!option.boss)
-                        warning("Expected a conditional expression and instead saw an assignment.");
-                    advance('=');
-                    expression(20);
-                }
-            }
-            nolinebreak(token);
-            advance(';');
-            if (nexttoken.id === ';') {
-                error("Expected '{a}' and instead saw '{b}'.",
-                        nexttoken, ')', ';');
-            }
-            if (nexttoken.id !== ')') {
-                for (;;) {
-                    expression(0, 'for');
-                    if (nexttoken.id !== ',') {
-                        break;
-                    }
-                    comma();
-                }
-            }
-            advance(')', t);
-            nospace(prevtoken, token);
-            block(true, true);
-            funct['(breakage)'] -= 1;
-            funct['(loopage)'] -= 1;
-            return this;
-        }
-    }).labelled = true;
-
-
-    stmt('break', function () {
-        var v = nexttoken.value;
-
-        if (funct['(breakage)'] === 0)
-            warning("Unexpected '{a}'.", nexttoken, this.value);
-
-        if (!option.asi)
-            nolinebreak(this);
-
-        if (nexttoken.id !== ';') {
-            if (token.line === nexttoken.line) {
-                if (funct[v] !== 'label') {
-                    warning("'{a}' is not a statement label.", nexttoken, v);
-                } else if (scope[v] !== funct) {
-                    warning("'{a}' is out of scope.", nexttoken, v);
-                }
-                this.first = nexttoken;
-                advance();
-            }
-        }
-        reachable('break');
-        return this;
-    }).exps = true;
-
-
-    stmt('continue', function () {
-        var v = nexttoken.value;
-
-        if (funct['(breakage)'] === 0)
-            warning("Unexpected '{a}'.", nexttoken, this.value);
-
-        if (!option.asi)
-            nolinebreak(this);
-
-        if (nexttoken.id !== ';') {
-            if (token.line === nexttoken.line) {
-                if (funct[v] !== 'label') {
-                    warning("'{a}' is not a statement label.", nexttoken, v);
-                } else if (scope[v] !== funct) {
-                    warning("'{a}' is out of scope.", nexttoken, v);
-                }
-                this.first = nexttoken;
-                advance();
-            }
-        } else if (!funct['(loopage)']) {
-            warning("Unexpected '{a}'.", nexttoken, this.value);
-        }
-        reachable('continue');
-        return this;
-    }).exps = true;
-
-
-    stmt('return', function () {
-        if (this.line === nexttoken.line) {
-            if (nexttoken.id === '(regexp)')
-                warning("Wrap the /regexp/ literal in parens to disambiguate the slash operator.");
-
-            if (nexttoken.id !== ';' && !nexttoken.reach) {
-                nonadjacent(token, nexttoken);
-                if (peek().value === "=" && !option.boss) {
-                    warningAt("Did you mean to return a conditional instead of an assignment?",
-                              token.line, token.character + 1);
-                }
-                this.first = expression(0);
-            }
-        } else if (!option.asi) {
-            nolinebreak(this); // always warn (Line breaking error)
-        }
-        reachable('return');
-        return this;
-    }).exps = true;
-
-
-    stmt('throw', function () {
-        nolinebreak(this);
-        nonadjacent(token, nexttoken);
-        this.first = expression(20);
-        reachable('throw');
-        return this;
-    }).exps = true;
-
-//  Superfluous reserved words
-
-    reserve('class');
-    reserve('const');
-    reserve('enum');
-    reserve('export');
-    reserve('extends');
-    reserve('import');
-    reserve('super');
-
-    reserve('let');
-    reserve('yield');
-    reserve('implements');
-    reserve('interface');
-    reserve('package');
-    reserve('private');
-    reserve('protected');
-    reserve('public');
-    reserve('static');
-
-
-// Parse JSON
-
-    function jsonValue() {
-
-        function jsonObject() {
-            var o = {}, t = nexttoken;
-            advance('{');
-            if (nexttoken.id !== '}') {
-                for (;;) {
-                    if (nexttoken.id === '(end)') {
-                        error("Missing '}' to match '{' from line {a}.",
-                                nexttoken, t.line);
-                    } else if (nexttoken.id === '}') {
-                        warning("Unexpected comma.", token);
-                        break;
-                    } else if (nexttoken.id === ',') {
-                        error("Unexpected comma.", nexttoken);
-                    } else if (nexttoken.id !== '(string)') {
-                        warning("Expected a string and instead saw {a}.",
-                                nexttoken, nexttoken.value);
-                    }
-                    if (o[nexttoken.value] === true) {
-                        warning("Duplicate key '{a}'.",
-                                nexttoken, nexttoken.value);
-                    } else if ((nexttoken.value === '__proto__' &&
-                        !option.proto) || (nexttoken.value === '__iterator__' &&
-                        !option.iterator)) {
-                        warning("The '{a}' key may produce unexpected results.",
-                            nexttoken, nexttoken.value);
-                    } else {
-                        o[nexttoken.value] = true;
-                    }
-                    advance();
-                    advance(':');
-                    jsonValue();
-                    if (nexttoken.id !== ',') {
-                        break;
-                    }
-                    advance(',');
-                }
-            }
-            advance('}');
-        }
-
-        function jsonArray() {
-            var t = nexttoken;
-            advance('[');
-            if (nexttoken.id !== ']') {
-                for (;;) {
-                    if (nexttoken.id === '(end)') {
-                        error("Missing ']' to match '[' from line {a}.",
-                                nexttoken, t.line);
-                    } else if (nexttoken.id === ']') {
-                        warning("Unexpected comma.", token);
-                        break;
-                    } else if (nexttoken.id === ',') {
-                        error("Unexpected comma.", nexttoken);
-                    }
-                    jsonValue();
-                    if (nexttoken.id !== ',') {
-                        break;
-                    }
-                    advance(',');
-                }
-            }
-            advance(']');
-        }
-
-        switch (nexttoken.id) {
-        case '{':
-            jsonObject();
-            break;
-        case '[':
-            jsonArray();
-            break;
-        case 'true':
-        case 'false':
-        case 'null':
-        case '(number)':
-        case '(string)':
-            advance();
-            break;
-        case '-':
-            advance('-');
-            if (token.character !== nexttoken.from) {
-                warning("Unexpected space after '-'.", token);
-            }
-            adjacent(token, nexttoken);
-            advance('(number)');
-            break;
-        default:
-            error("Expected a JSON value.", nexttoken);
-        }
-    }
-
-
-// The actual JSHINT function itself.
-
-    var itself = function (s, o, g) {
-        var a, i, k;
-        JSHINT.errors = [];
-        JSHINT.undefs = [];
-        predefined = Object.create(standard);
-        combine(predefined, g || {});
-        if (o) {
-            a = o.predef;
-            if (a) {
-                if (Array.isArray(a)) {
-                    for (i = 0; i < a.length; i += 1) {
-                        predefined[a[i]] = true;
-                    }
-                } else if (typeof a === 'object') {
-                    k = Object.keys(a);
-                    for (i = 0; i < k.length; i += 1) {
-                        predefined[k[i]] = !!a[k[i]];
-                    }
-                }
-            }
-            option = o;
-        } else {
-            option = {};
-        }
-        option.indent = option.indent || 4;
-        option.maxerr = option.maxerr || 50;
-
-        tab = '';
-        for (i = 0; i < option.indent; i += 1) {
-            tab += ' ';
-        }
-        indent = 1;
-        global = Object.create(predefined);
-        scope = global;
-        funct = {
-            '(global)': true,
-            '(name)': '(global)',
-            '(scope)': scope,
-            '(breakage)': 0,
-            '(loopage)': 0
-        };
-        functions = [funct];
-        urls = [];
-        stack = null;
-        member = {};
-        membersOnly = null;
-        implied = {};
-        inblock = false;
-        lookahead = [];
-        jsonmode = false;
-        warnings = 0;
-        lex.init(s);
-        prereg = true;
-        directive = {};
-
-        prevtoken = token = nexttoken = syntax['(begin)'];
-        assume();
-
-        // combine the passed globals after we've assumed all our options
-        combine(predefined, g || {});
-
-        try {
-            advance();
-            switch (nexttoken.id) {
-            case '{':
-            case '[':
-                option.laxbreak = true;
-                jsonmode = true;
-                jsonValue();
-                break;
-            default:
-                directives();
-                if (directive["use strict"] && !option.globalstrict) {
-                    warning("Use the function form of \"use strict\".", prevtoken);
-                }
-
-                statements();
-            }
-            advance('(end)');
-
-            var isDefined = function (name, context) {
-                do {
-                    if (typeof context[name] === 'string')
-                        return true;
-
-                    context = context['(context)'];
-                } while (context);
-
-                return false;
-            };
-
-            // Check queued 'x is not defined' instances to see if they're still undefined.
-            for (i = 0; i < JSHINT.undefs.length; i += 1) {
-                k = JSHINT.undefs[i].slice(0);
-
-                if (!isDefined(k[2].value, k[0])) {
-                    warning.apply(warning, k.slice(1));
-                }
-            }
-        } catch (e) {
-            if (e) {
-                var nt = nexttoken || {};
-                JSHINT.errors.push({
-                    raw       : e.raw,
-                    reason    : e.message,
-                    line      : e.line || nt.line,
-                    character : e.character || nt.from
-                }, null);
-            }
-        }
-
-        return JSHINT.errors.length === 0;
-    };
-
-    // Data summary.
-    itself.data = function () {
-
-        var data = { functions: [], options: option }, fu, globals, implieds = [], f, i, j,
-            members = [], n, unused = [], v;
-        if (itself.errors.length) {
-            data.errors = itself.errors;
-        }
-
-        if (jsonmode) {
-            data.json = true;
-        }
-
-        for (n in implied) {
-            if (is_own(implied, n)) {
-                implieds.push({
-                    name: n,
-                    line: implied[n]
-                });
-            }
-        }
-        if (implieds.length > 0) {
-            data.implieds = implieds;
-        }
-
-        if (urls.length > 0) {
-            data.urls = urls;
-        }
-
-        globals = Object.keys(scope);
-        if (globals.length > 0) {
-            data.globals = globals;
-        }
-
-        for (i = 1; i < functions.length; i += 1) {
-            f = functions[i];
-            fu = {};
-            for (j = 0; j < functionicity.length; j += 1) {
-                fu[functionicity[j]] = [];
-            }
-            for (n in f) {
-                if (is_own(f, n) && n.charAt(0) !== '(') {
-                    v = f[n];
-                    if (v === 'unction') {
-                        v = 'unused';
-                    }
-                    if (Array.isArray(fu[v])) {
-                        fu[v].push(n);
-                        if (v === 'unused') {
-                            unused.push({
-                                name: n,
-                                line: f['(line)'],
-                                'function': f['(name)']
-                            });
-                        }
-                    }
-                }
-            }
-            for (j = 0; j < functionicity.length; j += 1) {
-                if (fu[functionicity[j]].length === 0) {
-                    delete fu[functionicity[j]];
-                }
-            }
-            fu.name = f['(name)'];
-            fu.param = f['(params)'];
-            fu.line = f['(line)'];
-            fu.last = f['(last)'];
-            data.functions.push(fu);
-        }
-
-        if (unused.length > 0) {
-            data.unused = unused;
-        }
-
-        members = [];
-        for (n in member) {
-            if (typeof member[n] === 'number') {
-                data.member = member;
-                break;
-            }
-        }
-
-        return data;
-    };
-
-    itself.report = function (option) {
-        var data = itself.data();
-
-        var a = [], c, e, err, f, i, k, l, m = '', n, o = [], s;
-
-        function detail(h, array) {
-            var b, i, singularity;
-            if (array) {
-                o.push('<div><i>' + h + '</i> ');
-                array = array.sort();
-                for (i = 0; i < array.length; i += 1) {
-                    if (array[i] !== singularity) {
-                        singularity = array[i];
-                        o.push((b ? ', ' : '') + singularity);
-                        b = true;
-                    }
-                }
-                o.push('</div>');
-            }
-        }
-
-
-        if (data.errors || data.implieds || data.unused) {
-            err = true;
-            o.push('<div id=errors><i>Error:</i>');
-            if (data.errors) {
-                for (i = 0; i < data.errors.length; i += 1) {
-                    c = data.errors[i];
-                    if (c) {
-                        e = c.evidence || '';
-                        o.push('<p>Problem' + (isFinite(c.line) ? ' at line ' +
-                                c.line + ' character ' + c.character : '') +
-                                ': ' + c.reason.entityify() +
-                                '</p><p class=evidence>' +
-                                (e && (e.length > 80 ? e.slice(0, 77) + '...' :
-                                e).entityify()) + '</p>');
-                    }
-                }
-            }
-
-            if (data.implieds) {
-                s = [];
-                for (i = 0; i < data.implieds.length; i += 1) {
-                    s[i] = '<code>' + data.implieds[i].name + '</code>&nbsp;<i>' +
-                        data.implieds[i].line + '</i>';
-                }
-                o.push('<p><i>Implied global:</i> ' + s.join(', ') + '</p>');
-            }
-
-            if (data.unused) {
-                s = [];
-                for (i = 0; i < data.unused.length; i += 1) {
-                    s[i] = '<code><u>' + data.unused[i].name + '</u></code>&nbsp;<i>' +
-                        data.unused[i].line + '</i> <code>' +
-                        data.unused[i]['function'] + '</code>';
-                }
-                o.push('<p><i>Unused variable:</i> ' + s.join(', ') + '</p>');
-            }
-            if (data.json) {
-                o.push('<p>JSON: bad.</p>');
-            }
-            o.push('</div>');
-        }
-
-        if (!option) {
-
-            o.push('<br><div id=functions>');
-
-            if (data.urls) {
-                detail("URLs<br>", data.urls, '<br>');
-            }
-
-            if (data.json && !err) {
-                o.push('<p>JSON: good.</p>');
-            } else if (data.globals) {
-                o.push('<div><i>Global</i> ' +
-                        data.globals.sort().join(', ') + '</div>');
-            } else {
-                o.push('<div><i>No new global variables introduced.</i></div>');
-            }
-
-            for (i = 0; i < data.functions.length; i += 1) {
-                f = data.functions[i];
-
-                o.push('<br><div class=function><i>' + f.line + '-' +
-                        f.last + '</i> ' + (f.name || '') + '(' +
-                        (f.param ? f.param.join(', ') : '') + ')</div>');
-                detail('<big><b>Unused</b></big>', f.unused);
-                detail('Closure', f.closure);
-                detail('Variable', f['var']);
-                detail('Exception', f.exception);
-                detail('Outer', f.outer);
-                detail('Global', f.global);
-                detail('Label', f.label);
-            }
-
-            if (data.member) {
-                a = Object.keys(data.member);
-                if (a.length) {
-                    a = a.sort();
-                    m = '<br><pre id=members>/*members ';
-                    l = 10;
-                    for (i = 0; i < a.length; i += 1) {
-                        k = a[i];
-                        n = k.name();
-                        if (l + n.length > 72) {
-                            o.push(m + '<br>');
-                            m = '    ';
-                            l = 1;
-                        }
-                        l += n.length + 2;
-                        if (data.member[k] === 1) {
-                            n = '<i>' + n + '</i>';
-                        }
-                        if (i < a.length - 1) {
-                            n += ', ';
-                        }
-                        m += n;
-                    }
-                    o.push(m + '<br>*/</pre>');
-                }
-                o.push('</div>');
-            }
-        }
-        return o.join('');
-    };
-
-    itself.jshint = itself;
-
-    return itself;
-}());
-
-// Make JSHINT a Node module, if possible.
-if (typeof exports === 'object' && exports)
-    exports.JSHINT = JSHINT;
\ No newline at end of file
diff --git a/build/lib/parse-js.js b/build/lib/parse-js.js
deleted file mode 100644 (file)
index 8edecb7..0000000
+++ /dev/null
@@ -1,1315 +0,0 @@
-/***********************************************************************
-
-  A JavaScript tokenizer / parser / beautifier / compressor.
-
-  This version is suitable for Node.js.  With minimal changes (the
-  exports stuff) it should work on any JS platform.
-
-  This file contains the tokenizer/parser.  It is a port to JavaScript
-  of parse-js [1], a JavaScript parser library written in Common Lisp
-  by Marijn Haverbeke.  Thank you Marijn!
-
-  [1] http://marijn.haverbeke.nl/parse-js/
-
-  Exported functions:
-
-    - tokenizer(code) -- returns a function.  Call the returned
-      function to fetch the next token.
-
-    - parse(code) -- returns an AST of the given JavaScript code.
-
-  -------------------------------- (C) ---------------------------------
-
-                           Author: Mihai Bazon
-                         <mihai.bazon@gmail.com>
-                       http://mihai.bazon.net/blog
-
-  Distributed under the BSD license:
-
-    Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
-    Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions
-    are met:
-
-        * Redistributions of source code must retain the above
-          copyright notice, this list of conditions and the following
-          disclaimer.
-
-        * Redistributions in binary form must reproduce the above
-          copyright notice, this list of conditions and the following
-          disclaimer in the documentation and/or other materials
-          provided with the distribution.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
-    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
-    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
-    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
-    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-    SUCH DAMAGE.
-
- ***********************************************************************/
-
-/* -----[ Tokenizer (constants) ]----- */
-
-var KEYWORDS = array_to_hash([
-        "break",
-        "case",
-        "catch",
-        "const",
-        "continue",
-        "default",
-        "delete",
-        "do",
-        "else",
-        "finally",
-        "for",
-        "function",
-        "if",
-        "in",
-        "instanceof",
-        "new",
-        "return",
-        "switch",
-        "throw",
-        "try",
-        "typeof",
-        "var",
-        "void",
-        "while",
-        "with"
-]);
-
-var RESERVED_WORDS = array_to_hash([
-        "abstract",
-        "boolean",
-        "byte",
-        "char",
-        "class",
-        "debugger",
-        "double",
-        "enum",
-        "export",
-        "extends",
-        "final",
-        "float",
-        "goto",
-        "implements",
-        "import",
-        "int",
-        "interface",
-        "long",
-        "native",
-        "package",
-        "private",
-        "protected",
-        "public",
-        "short",
-        "static",
-        "super",
-        "synchronized",
-        "throws",
-        "transient",
-        "volatile"
-]);
-
-var KEYWORDS_BEFORE_EXPRESSION = array_to_hash([
-        "return",
-        "new",
-        "delete",
-        "throw",
-        "else",
-        "case"
-]);
-
-var KEYWORDS_ATOM = array_to_hash([
-        "false",
-        "null",
-        "true",
-        "undefined"
-]);
-
-var OPERATOR_CHARS = array_to_hash(characters("+-*&%=<>!?|~^"));
-
-var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
-var RE_OCT_NUMBER = /^0[0-7]+$/;
-var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;
-
-var OPERATORS = array_to_hash([
-        "in",
-        "instanceof",
-        "typeof",
-        "new",
-        "void",
-        "delete",
-        "++",
-        "--",
-        "+",
-        "-",
-        "!",
-        "~",
-        "&",
-        "|",
-        "^",
-        "*",
-        "/",
-        "%",
-        ">>",
-        "<<",
-        ">>>",
-        "<",
-        ">",
-        "<=",
-        ">=",
-        "==",
-        "===",
-        "!=",
-        "!==",
-        "?",
-        "=",
-        "+=",
-        "-=",
-        "/=",
-        "*=",
-        "%=",
-        ">>=",
-        "<<=",
-        ">>>=",
-        "|=",
-        "^=",
-        "&=",
-        "&&",
-        "||"
-]);
-
-var WHITESPACE_CHARS = array_to_hash(characters(" \n\r\t\u200b"));
-
-var PUNC_BEFORE_EXPRESSION = array_to_hash(characters("[{}(,.;:"));
-
-var PUNC_CHARS = array_to_hash(characters("[]{}(),;:"));
-
-var REGEXP_MODIFIERS = array_to_hash(characters("gmsiy"));
-
-/* -----[ Tokenizer ]----- */
-
-// regexps adapted from http://xregexp.com/plugins/#unicode
-var UNICODE = {
-        letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971\\u0972\\u097B-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D3D\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC\\u0EDD\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8B\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10D0-\\u10FA\\u10FC\\u1100-\\u1159\\u115F-\\u11A2\\u11A8-\\u11F9\\u1200-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u1676\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19A9\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u2094\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C6F\\u2C71-\\u2C7D\\u2C80-\\u2CE4\\u2D00-\\u2D25\\u2D30-\\u2D65\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31B7\\u31F0-\\u31FF\\u3400\\u4DB5\\u4E00\\u9FC3\\uA000-\\uA48C\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA65F\\uA662-\\uA66E\\uA67F-\\uA697\\uA717-\\uA71F\\uA722-\\uA788\\uA78B\\uA78C\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA90A-\\uA925\\uA930-\\uA946\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAC00\\uD7A3\\uF900-\\uFA2D\\uFA30-\\uFA6A\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),
-        non_spacing_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),
-        space_combining_mark: new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"),
-        connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]")
-};
-
-function is_letter(ch) {
-        return UNICODE.letter.test(ch);
-};
-
-function is_digit(ch) {
-        ch = ch.charCodeAt(0);
-        return ch >= 48 && ch <= 57; //XXX: find out if "UnicodeDigit" means something else than 0..9
-};
-
-function is_alphanumeric_char(ch) {
-        return is_digit(ch) || is_letter(ch);
-};
-
-function is_unicode_combining_mark(ch) {
-        return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch);
-};
-
-function is_unicode_connector_punctuation(ch) {
-        return UNICODE.connector_punctuation.test(ch);
-};
-
-function is_identifier_start(ch) {
-        return ch == "$" || ch == "_" || is_letter(ch);
-};
-
-function is_identifier_char(ch) {
-        return is_identifier_start(ch)
-                || is_unicode_combining_mark(ch)
-                || is_digit(ch)
-                || is_unicode_connector_punctuation(ch)
-                || ch == "\u200c" // zero-width non-joiner <ZWNJ>
-                || ch == "\u200d" // zero-width joiner <ZWJ> (in my ECMA-262 PDF, this is also 200c)
-        ;
-};
-
-function parse_js_number(num) {
-        if (RE_HEX_NUMBER.test(num)) {
-                return parseInt(num.substr(2), 16);
-        } else if (RE_OCT_NUMBER.test(num)) {
-                return parseInt(num.substr(1), 8);
-        } else if (RE_DEC_NUMBER.test(num)) {
-                return parseFloat(num);
-        }
-};
-
-function JS_Parse_Error(message, line, col, pos) {
-        this.message = message;
-        this.line = line;
-        this.col = col;
-        this.pos = pos;
-        try {
-                ({})();
-        } catch(ex) {
-                this.stack = ex.stack;
-        };
-};
-
-JS_Parse_Error.prototype.toString = function() {
-        return this.message + " (line: " + this.line + ", col: " + this.col + ", pos: " + this.pos + ")" + "\n\n" + this.stack;
-};
-
-function js_error(message, line, col, pos) {
-        throw new JS_Parse_Error(message, line, col, pos);
-};
-
-function is_token(token, type, val) {
-        return token.type == type && (val == null || token.value == val);
-};
-
-var EX_EOF = {};
-
-function tokenizer($TEXT) {
-
-        var S = {
-                text            : $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/^\uFEFF/, ''),
-                pos             : 0,
-                tokpos          : 0,
-                line            : 0,
-                tokline         : 0,
-                col             : 0,
-                tokcol          : 0,
-                newline_before  : false,
-                regex_allowed   : false,
-                comments_before : []
-        };
-
-        function peek() { return S.text.charAt(S.pos); };
-
-        function next(signal_eof) {
-                var ch = S.text.charAt(S.pos++);
-                if (signal_eof && !ch)
-                        throw EX_EOF;
-                if (ch == "\n") {
-                        S.newline_before = true;
-                        ++S.line;
-                        S.col = 0;
-                } else {
-                        ++S.col;
-                }
-                return ch;
-        };
-
-        function eof() {
-                return !S.peek();
-        };
-
-        function find(what, signal_eof) {
-                var pos = S.text.indexOf(what, S.pos);
-                if (signal_eof && pos == -1) throw EX_EOF;
-                return pos;
-        };
-
-        function start_token() {
-                S.tokline = S.line;
-                S.tokcol = S.col;
-                S.tokpos = S.pos;
-        };
-
-        function token(type, value, is_comment) {
-                S.regex_allowed = ((type == "operator" && !HOP(UNARY_POSTFIX, value)) ||
-                                   (type == "keyword" && HOP(KEYWORDS_BEFORE_EXPRESSION, value)) ||
-                                   (type == "punc" && HOP(PUNC_BEFORE_EXPRESSION, value)));
-                var ret = {
-                        type  : type,
-                        value : value,
-                        line  : S.tokline,
-                        col   : S.tokcol,
-                        pos   : S.tokpos,
-                        nlb   : S.newline_before
-                };
-                if (!is_comment) {
-                        ret.comments_before = S.comments_before;
-                        S.comments_before = [];
-                }
-                S.newline_before = false;
-                return ret;
-        };
-
-        function skip_whitespace() {
-                while (HOP(WHITESPACE_CHARS, peek()))
-                        next();
-        };
-
-        function read_while(pred) {
-                var ret = "", ch = peek(), i = 0;
-                while (ch && pred(ch, i++)) {
-                        ret += next();
-                        ch = peek();
-                }
-                return ret;
-        };
-
-        function parse_error(err) {
-                js_error(err, S.tokline, S.tokcol, S.tokpos);
-        };
-
-        function read_num(prefix) {
-                var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".";
-                var num = read_while(function(ch, i){
-                        if (ch == "x" || ch == "X") {
-                                if (has_x) return false;
-                                return has_x = true;
-                        }
-                        if (!has_x && (ch == "E" || ch == "e")) {
-                                if (has_e) return false;
-                                return has_e = after_e = true;
-                        }
-                        if (ch == "-") {
-                                if (after_e || (i == 0 && !prefix)) return true;
-                                return false;
-                        }
-                        if (ch == "+") return after_e;
-                        after_e = false;
-                        if (ch == ".") {
-                                if (!has_dot && !has_x)
-                                        return has_dot = true;
-                                return false;
-                        }
-                        return is_alphanumeric_char(ch);
-                });
-                if (prefix)
-                        num = prefix + num;
-                var valid = parse_js_number(num);
-                if (!isNaN(valid)) {
-                        return token("num", valid);
-                } else {
-                        parse_error("Invalid syntax: " + num);
-                }
-        };
-
-        function read_escaped_char() {
-                var ch = next(true);
-                switch (ch) {
-                    case "n" : return "\n";
-                    case "r" : return "\r";
-                    case "t" : return "\t";
-                    case "b" : return "\b";
-                    case "v" : return "\v";
-                    case "f" : return "\f";
-                    case "0" : return "\0";
-                    case "x" : return String.fromCharCode(hex_bytes(2));
-                    case "u" : return String.fromCharCode(hex_bytes(4));
-                    default  : return ch;
-                }
-        };
-
-        function hex_bytes(n) {
-                var num = 0;
-                for (; n > 0; --n) {
-                        var digit = parseInt(next(true), 16);
-                        if (isNaN(digit))
-                                parse_error("Invalid hex-character pattern in string");
-                        num = (num << 4) | digit;
-                }
-                return num;
-        };
-
-        function read_string() {
-                return with_eof_error("Unterminated string constant", function(){
-                        var quote = next(), ret = "";
-                        for (;;) {
-                                var ch = next(true);
-                                if (ch == "\\") ch = read_escaped_char();
-                                else if (ch == quote) break;
-                                ret += ch;
-                        }
-                        return token("string", ret);
-                });
-        };
-
-        function read_line_comment() {
-                next();
-                var i = find("\n"), ret;
-                if (i == -1) {
-                        ret = S.text.substr(S.pos);
-                        S.pos = S.text.length;
-                } else {
-                        ret = S.text.substring(S.pos, i);
-                        S.pos = i;
-                }
-                return token("comment1", ret, true);
-        };
-
-        function read_multiline_comment() {
-                next();
-                return with_eof_error("Unterminated multiline comment", function(){
-                        var i = find("*/", true),
-                            text = S.text.substring(S.pos, i),
-                            tok = token("comment2", text, true);
-                        S.pos = i + 2;
-                        S.line += text.split("\n").length - 1;
-                        S.newline_before = text.indexOf("\n") >= 0;
-
-                        // https://github.com/mishoo/UglifyJS/issues/#issue/100
-                        if (/^@cc_on/i.test(text)) {
-                                warn("WARNING: at line " + S.line);
-                                warn("*** Found \"conditional comment\": " + text);
-                                warn("*** UglifyJS DISCARDS ALL COMMENTS.  This means your code might no longer work properly in Internet Explorer.");
-                        }
-
-                        return tok;
-                });
-        };
-
-        function read_name() {
-                var backslash = false, name = "", ch;
-                while ((ch = peek()) != null) {
-                        if (!backslash) {
-                                if (ch == "\\") backslash = true, next();
-                                else if (is_identifier_char(ch)) name += next();
-                                else break;
-                        }
-                        else {
-                                if (ch != "u") parse_error("Expecting UnicodeEscapeSequence -- uXXXX");
-                                ch = read_escaped_char();
-                                if (!is_identifier_char(ch)) parse_error("Unicode char: " + ch.charCodeAt(0) + " is not valid in identifier");
-                                name += ch;
-                                backslash = false;
-                        }
-                }
-                return name;
-        };
-
-        function read_regexp() {
-                return with_eof_error("Unterminated regular expression", function(){
-                        var prev_backslash = false, regexp = "", ch, in_class = false;
-                        while ((ch = next(true))) if (prev_backslash) {
-                                regexp += "\\" + ch;
-                                prev_backslash = false;
-                        } else if (ch == "[") {
-                                in_class = true;
-                                regexp += ch;
-                        } else if (ch == "]" && in_class) {
-                                in_class = false;
-                                regexp += ch;
-                        } else if (ch == "/" && !in_class) {
-                                break;
-                        } else if (ch == "\\") {
-                                prev_backslash = true;
-                        } else {
-                                regexp += ch;
-                        }
-                        var mods = read_name();
-                        return token("regexp", [ regexp, mods ]);
-                });
-        };
-
-        function read_operator(prefix) {
-                function grow(op) {
-                        if (!peek()) return op;
-                        var bigger = op + peek();
-                        if (HOP(OPERATORS, bigger)) {
-                                next();
-                                return grow(bigger);
-                        } else {
-                                return op;
-                        }
-                };
-                return token("operator", grow(prefix || next()));
-        };
-
-        function handle_slash() {
-                next();
-                var regex_allowed = S.regex_allowed;
-                switch (peek()) {
-                    case "/":
-                        S.comments_before.push(read_line_comment());
-                        S.regex_allowed = regex_allowed;
-                        return next_token();
-                    case "*":
-                        S.comments_before.push(read_multiline_comment());
-                        S.regex_allowed = regex_allowed;
-                        return next_token();
-                }
-                return S.regex_allowed ? read_regexp() : read_operator("/");
-        };
-
-        function handle_dot() {
-                next();
-                return is_digit(peek())
-                        ? read_num(".")
-                        : token("punc", ".");
-        };
-
-        function read_word() {
-                var word = read_name();
-                return !HOP(KEYWORDS, word)
-                        ? token("name", word)
-                        : HOP(OPERATORS, word)
-                        ? token("operator", word)
-                        : HOP(KEYWORDS_ATOM, word)
-                        ? token("atom", word)
-                        : token("keyword", word);
-        };
-
-        function with_eof_error(eof_error, cont) {
-                try {
-                        return cont();
-                } catch(ex) {
-                        if (ex === EX_EOF) parse_error(eof_error);
-                        else throw ex;
-                }
-        };
-
-        function next_token(force_regexp) {
-                if (force_regexp)
-                        return read_regexp();
-                skip_whitespace();
-                start_token();
-                var ch = peek();
-                if (!ch) return token("eof");
-                if (is_digit(ch)) return read_num();
-                if (ch == '"' || ch == "'") return read_string();
-                if (HOP(PUNC_CHARS, ch)) return token("punc", next());
-                if (ch == ".") return handle_dot();
-                if (ch == "/") return handle_slash();
-                if (HOP(OPERATOR_CHARS, ch)) return read_operator();
-                if (ch == "\\" || is_identifier_start(ch)) return read_word();
-                parse_error("Unexpected character '" + ch + "'");
-        };
-
-        next_token.context = function(nc) {
-                if (nc) S = nc;
-                return S;
-        };
-
-        return next_token;
-
-};
-
-/* -----[ Parser (constants) ]----- */
-
-var UNARY_PREFIX = array_to_hash([
-        "typeof",
-        "void",
-        "delete",
-        "--",
-        "++",
-        "!",
-        "~",
-        "-",
-        "+"
-]);
-
-var UNARY_POSTFIX = array_to_hash([ "--", "++" ]);
-
-var ASSIGNMENT = (function(a, ret, i){
-        while (i < a.length) {
-                ret[a[i]] = a[i].substr(0, a[i].length - 1);
-                i++;
-        }
-        return ret;
-})(
-        ["+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&="],
-        { "=": true },
-        0
-);
-
-var PRECEDENCE = (function(a, ret){
-        for (var i = 0, n = 1; i < a.length; ++i, ++n) {
-                var b = a[i];
-                for (var j = 0; j < b.length; ++j) {
-                        ret[b[j]] = n;
-                }
-        }
-        return ret;
-})(
-        [
-                ["||"],
-                ["&&"],
-                ["|"],
-                ["^"],
-                ["&"],
-                ["==", "===", "!=", "!=="],
-                ["<", ">", "<=", ">=", "in", "instanceof"],
-                [">>", "<<", ">>>"],
-                ["+", "-"],
-                ["*", "/", "%"]
-        ],
-        {}
-);
-
-var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
-
-var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
-
-/* -----[ Parser ]----- */
-
-function NodeWithToken(str, start, end) {
-        this.name = str;
-        this.start = start;
-        this.end = end;
-};
-
-NodeWithToken.prototype.toString = function() { return this.name; };
-
-function parse($TEXT, exigent_mode, embed_tokens) {
-
-        var S = {
-                input       : typeof $TEXT == "string" ? tokenizer($TEXT, true) : $TEXT,
-                token       : null,
-                prev        : null,
-                peeked      : null,
-                in_function : 0,
-                in_loop     : 0,
-                labels      : []
-        };
-
-        S.token = next();
-
-        function is(type, value) {
-                return is_token(S.token, type, value);
-        };
-
-        function peek() { return S.peeked || (S.peeked = S.input()); };
-
-        function next() {
-                S.prev = S.token;
-                if (S.peeked) {
-                        S.token = S.peeked;
-                        S.peeked = null;
-                } else {
-                        S.token = S.input();
-                }
-                return S.token;
-        };
-
-        function prev() {
-                return S.prev;
-        };
-
-        function croak(msg, line, col, pos) {
-                var ctx = S.input.context();
-                js_error(msg,
-                         line != null ? line : ctx.tokline,
-                         col != null ? col : ctx.tokcol,
-                         pos != null ? pos : ctx.tokpos);
-        };
-
-        function token_error(token, msg) {
-                croak(msg, token.line, token.col);
-        };
-
-        function unexpected(token) {
-                if (token == null)
-                        token = S.token;
-                token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")");
-        };
-
-        function expect_token(type, val) {
-                if (is(type, val)) {
-                        return next();
-                }
-                token_error(S.token, "Unexpected token " + S.token.type + ", expected " + type);
-        };
-
-        function expect(punc) { return expect_token("punc", punc); };
-
-        function can_insert_semicolon() {
-                return !exigent_mode && (
-                        S.token.nlb || is("eof") || is("punc", "}")
-                );
-        };
-
-        function semicolon() {
-                if (is("punc", ";")) next();
-                else if (!can_insert_semicolon()) unexpected();
-        };
-
-        function as() {
-                return slice(arguments);
-        };
-
-        function parenthesised() {
-                expect("(");
-                var ex = expression();
-                expect(")");
-                return ex;
-        };
-
-        function add_tokens(str, start, end) {
-                return str instanceof NodeWithToken ? str : new NodeWithToken(str, start, end);
-        };
-
-        function maybe_embed_tokens(parser) {
-                if (embed_tokens) return function() {
-                        var start = S.token;
-                        var ast = parser.apply(this, arguments);
-                        ast[0] = add_tokens(ast[0], start, prev());
-                        return ast;
-                };
-                else return parser;
-        };
-
-        var statement = maybe_embed_tokens(function() {
-                if (is("operator", "/")) {
-                        S.peeked = null;
-                        S.token = S.input(true); // force regexp
-                }
-                switch (S.token.type) {
-                    case "num":
-                    case "string":
-                    case "regexp":
-                    case "operator":
-                    case "atom":
-                        return simple_statement();
-
-                    case "name":
-                        return is_token(peek(), "punc", ":")
-                                ? labeled_statement(prog1(S.token.value, next, next))
-                                : simple_statement();
-
-                    case "punc":
-                        switch (S.token.value) {
-                            case "{":
-                                return as("block", block_());
-                            case "[":
-                            case "(":
-                                return simple_statement();
-                            case ";":
-                                next();
-                                return as("block");
-                            default:
-                                unexpected();
-                        }
-
-                    case "keyword":
-                        switch (prog1(S.token.value, next)) {
-                            case "break":
-                                return break_cont("break");
-
-                            case "continue":
-                                return break_cont("continue");
-
-                            case "debugger":
-                                semicolon();
-                                return as("debugger");
-
-                            case "do":
-                                return (function(body){
-                                        expect_token("keyword", "while");
-                                        return as("do", prog1(parenthesised, semicolon), body);
-                                })(in_loop(statement));
-
-                            case "for":
-                                return for_();
-
-                            case "function":
-                                return function_(true);
-
-                            case "if":
-                                return if_();
-
-                            case "return":
-                                if (S.in_function == 0)
-                                        croak("'return' outside of function");
-                                return as("return",
-                                          is("punc", ";")
-                                          ? (next(), null)
-                                          : can_insert_semicolon()
-                                          ? null
-                                          : prog1(expression, semicolon));
-
-                            case "switch":
-                                return as("switch", parenthesised(), switch_block_());
-
-                            case "throw":
-                                return as("throw", prog1(expression, semicolon));
-
-                            case "try":
-                                return try_();
-
-                            case "var":
-                                return prog1(var_, semicolon);
-
-                            case "const":
-                                return prog1(const_, semicolon);
-
-                            case "while":
-                                return as("while", parenthesised(), in_loop(statement));
-
-                            case "with":
-                                return as("with", parenthesised(), statement());
-
-                            default:
-                                unexpected();
-                        }
-                }
-        });
-
-        function labeled_statement(label) {
-                S.labels.push(label);
-                var start = S.token, stat = statement();
-                if (exigent_mode && !HOP(STATEMENTS_WITH_LABELS, stat[0]))
-                        unexpected(start);
-                S.labels.pop();
-                return as("label", label, stat);
-        };
-
-        function simple_statement() {
-                return as("stat", prog1(expression, semicolon));
-        };
-
-        function break_cont(type) {
-                var name = is("name") ? S.token.value : null;
-                if (name != null) {
-                        next();
-                        if (!member(name, S.labels))
-                                croak("Label " + name + " without matching loop or statement");
-                }
-                else if (S.in_loop == 0)
-                        croak(type + " not inside a loop or switch");
-                semicolon();
-                return as(type, name);
-        };
-
-        function for_() {
-                expect("(");
-                var init = null;
-                if (!is("punc", ";")) {
-                        init = is("keyword", "var")
-                                ? (next(), var_(true))
-                                : expression(true, true);
-                        if (is("operator", "in"))
-                                return for_in(init);
-                }
-                return regular_for(init);
-        };
-
-        function regular_for(init) {
-                expect(";");
-                var test = is("punc", ";") ? null : expression();
-                expect(";");
-                var step = is("punc", ")") ? null : expression();
-                expect(")");
-                return as("for", init, test, step, in_loop(statement));
-        };
-
-        function for_in(init) {
-                var lhs = init[0] == "var" ? as("name", init[1][0]) : init;
-                next();
-                var obj = expression();
-                expect(")");
-                return as("for-in", init, lhs, obj, in_loop(statement));
-        };
-
-        var function_ = maybe_embed_tokens(function(in_statement) {
-                var name = is("name") ? prog1(S.token.value, next) : null;
-                if (in_statement && !name)
-                        unexpected();
-                expect("(");
-                return as(in_statement ? "defun" : "function",
-                          name,
-                          // arguments
-                          (function(first, a){
-                                  while (!is("punc", ")")) {
-                                          if (first) first = false; else expect(",");
-                                          if (!is("name")) unexpected();
-                                          a.push(S.token.value);
-                                          next();
-                                  }
-                                  next();
-                                  return a;
-                          })(true, []),
-                          // body
-                          (function(){
-                                  ++S.in_function;
-                                  var loop = S.in_loop;
-                                  S.in_loop = 0;
-                                  var a = block_();
-                                  --S.in_function;
-                                  S.in_loop = loop;
-                                  return a;
-                          })());
-        });
-
-        function if_() {
-                var cond = parenthesised(), body = statement(), belse;
-                if (is("keyword", "else")) {
-                        next();
-                        belse = statement();
-                }
-                return as("if", cond, body, belse);
-        };
-
-        function block_() {
-                expect("{");
-                var a = [];
-                while (!is("punc", "}")) {
-                        if (is("eof")) unexpected();
-                        a.push(statement());
-                }
-                next();
-                return a;
-        };
-
-        var switch_block_ = curry(in_loop, function(){
-                expect("{");
-                var a = [], cur = null;
-                while (!is("punc", "}")) {
-                        if (is("eof")) unexpected();
-                        if (is("keyword", "case")) {
-                                next();
-                                cur = [];
-                                a.push([ expression(), cur ]);
-                                expect(":");
-                        }
-                        else if (is("keyword", "default")) {
-                                next();
-                                expect(":");
-                                cur = [];
-                                a.push([ null, cur ]);
-                        }
-                        else {
-                                if (!cur) unexpected();
-                                cur.push(statement());
-                        }
-                }
-                next();
-                return a;
-        });
-
-        function try_() {
-                var body = block_(), bcatch, bfinally;
-                if (is("keyword", "catch")) {
-                        next();
-                        expect("(");
-                        if (!is("name"))
-                                croak("Name expected");
-                        var name = S.token.value;
-                        next();
-                        expect(")");
-                        bcatch = [ name, block_() ];
-                }
-                if (is("keyword", "finally")) {
-                        next();
-                        bfinally = block_();
-                }
-                if (!bcatch && !bfinally)
-                        croak("Missing catch/finally blocks");
-                return as("try", body, bcatch, bfinally);
-        };
-
-        function vardefs(no_in) {
-                var a = [];
-                for (;;) {
-                        if (!is("name"))
-                                unexpected();
-                        var name = S.token.value;
-                        next();
-                        if (is("operator", "=")) {
-                                next();
-                                a.push([ name, expression(false, no_in) ]);
-                        } else {
-                                a.push([ name ]);
-                        }
-                        if (!is("punc", ","))
-                                break;
-                        next();
-                }
-                return a;
-        };
-
-        function var_(no_in) {
-                return as("var", vardefs(no_in));
-        };
-
-        function const_() {
-                return as("const", vardefs());
-        };
-
-        function new_() {
-                var newexp = expr_atom(false), args;
-                if (is("punc", "(")) {
-                        next();
-                        args = expr_list(")");
-                } else {
-                        args = [];
-                }
-                return subscripts(as("new", newexp, args), true);
-        };
-
-        var expr_atom = maybe_embed_tokens(function(allow_calls) {
-                if (is("operator", "new")) {
-                        next();
-                        return new_();
-                }
-                if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) {
-                        return make_unary("unary-prefix",
-                                          prog1(S.token.value, next),
-                                          expr_atom(allow_calls));
-                }
-                if (is("punc")) {
-                        switch (S.token.value) {
-                            case "(":
-                                next();
-                                return subscripts(prog1(expression, curry(expect, ")")), allow_calls);
-                            case "[":
-                                next();
-                                return subscripts(array_(), allow_calls);
-                            case "{":
-                                next();
-                                return subscripts(object_(), allow_calls);
-                        }
-                        unexpected();
-                }
-                if (is("keyword", "function")) {
-                        next();
-                        return subscripts(function_(false), allow_calls);
-                }
-                if (HOP(ATOMIC_START_TOKEN, S.token.type)) {
-                        var atom = S.token.type == "regexp"
-                                ? as("regexp", S.token.value[0], S.token.value[1])
-                                : as(S.token.type, S.token.value);
-                        return subscripts(prog1(atom, next), allow_calls);
-                }
-                unexpected();
-        });
-
-        function expr_list(closing, allow_trailing_comma, allow_empty) {
-                var first = true, a = [];
-                while (!is("punc", closing)) {
-                        if (first) first = false; else expect(",");
-                        if (allow_trailing_comma && is("punc", closing)) break;
-                        if (is("punc", ",") && allow_empty) {
-                                a.push([ "atom", "undefined" ]);
-                        } else {
-                                a.push(expression(false));
-                        }
-                }
-                next();
-                return a;
-        };
-
-        function array_() {
-                return as("array", expr_list("]", !exigent_mode, true));
-        };
-
-        function object_() {
-                var first = true, a = [];
-                while (!is("punc", "}")) {
-                        if (first) first = false; else expect(",");
-                        if (!exigent_mode && is("punc", "}"))
-                                // allow trailing comma
-                                break;
-                        var type = S.token.type;
-                        var name = as_property_name();
-                        if (type == "name" && (name == "get" || name == "set") && !is("punc", ":")) {
-                                a.push([ as_name(), function_(false), name ]);
-                        } else {
-                                expect(":");
-                                a.push([ name, expression(false) ]);
-                        }
-                }
-                next();
-                return as("object", a);
-        };
-
-        function as_property_name() {
-                switch (S.token.type) {
-                    case "num":
-                    case "string":
-                        return prog1(S.token.value, next);
-                }
-                return as_name();
-        };
-
-        function as_name() {
-                switch (S.token.type) {
-                    case "name":
-                    case "operator":
-                    case "keyword":
-                    case "atom":
-                        return prog1(S.token.value, next);
-                    default:
-                        unexpected();
-                }
-        };
-
-        function subscripts(expr, allow_calls) {
-                if (is("punc", ".")) {
-                        next();
-                        return subscripts(as("dot", expr, as_name()), allow_calls);
-                }
-                if (is("punc", "[")) {
-                        next();
-                        return subscripts(as("sub", expr, prog1(expression, curry(expect, "]"))), allow_calls);
-                }
-                if (allow_calls && is("punc", "(")) {
-                        next();
-                        return subscripts(as("call", expr, expr_list(")")), true);
-                }
-                if (allow_calls && is("operator") && HOP(UNARY_POSTFIX, S.token.value)) {
-                        return prog1(curry(make_unary, "unary-postfix", S.token.value, expr),
-                                     next);
-                }
-                return expr;
-        };
-
-        function make_unary(tag, op, expr) {
-                if ((op == "++" || op == "--") && !is_assignable(expr))
-                        croak("Invalid use of " + op + " operator");
-                return as(tag, op, expr);
-        };
-
-        function expr_op(left, min_prec, no_in) {
-                var op = is("operator") ? S.token.value : null;
-                if (op && op == "in" && no_in) op = null;
-                var prec = op != null ? PRECEDENCE[op] : null;
-                if (prec != null && prec > min_prec) {
-                        next();
-                        var right = expr_op(expr_atom(true), prec, no_in);
-                        return expr_op(as("binary", op, left, right), min_prec, no_in);
-                }
-                return left;
-        };
-
-        function expr_ops(no_in) {
-                return expr_op(expr_atom(true), 0, no_in);
-        };
-
-        function maybe_conditional(no_in) {
-                var expr = expr_ops(no_in);
-                if (is("operator", "?")) {
-                        next();
-                        var yes = expression(false);
-                        expect(":");
-                        return as("conditional", expr, yes, expression(false, no_in));
-                }
-                return expr;
-        };
-
-        function is_assignable(expr) {
-                if (!exigent_mode) return true;
-                switch (expr[0]) {
-                    case "dot":
-                    case "sub":
-                    case "new":
-                    case "call":
-                        return true;
-                    case "name":
-                        return expr[1] != "this";
-                }
-        };
-
-        function maybe_assign(no_in) {
-                var left = maybe_conditional(no_in), val = S.token.value;
-                if (is("operator") && HOP(ASSIGNMENT, val)) {
-                        if (is_assignable(left)) {
-                                next();
-                                return as("assign", ASSIGNMENT[val], left, maybe_assign(no_in));
-                        }
-                        croak("Invalid assignment");
-                }
-                return left;
-        };
-
-        var expression = maybe_embed_tokens(function(commas, no_in) {
-                if (arguments.length == 0)
-                        commas = true;
-                var expr = maybe_assign(no_in);
-                if (commas && is("punc", ",")) {
-                        next();
-                        return as("seq", expr, expression(true, no_in));
-                }
-                return expr;
-        });
-
-        function in_loop(cont) {
-                try {
-                        ++S.in_loop;
-                        return cont();
-                } finally {
-                        --S.in_loop;
-                }
-        };
-
-        return as("toplevel", (function(a){
-                while (!is("eof"))
-                        a.push(statement());
-                return a;
-        })([]));
-
-};
-
-/* -----[ Utilities ]----- */
-
-function curry(f) {
-        var args = slice(arguments, 1);
-        return function() { return f.apply(this, args.concat(slice(arguments))); };
-};
-
-function prog1(ret) {
-        if (ret instanceof Function)
-                ret = ret();
-        for (var i = 1, n = arguments.length; --n > 0; ++i)
-                arguments[i]();
-        return ret;
-};
-
-function array_to_hash(a) {
-        var ret = {};
-        for (var i = 0; i < a.length; ++i)
-                ret[a[i]] = true;
-        return ret;
-};
-
-function slice(a, start) {
-        return Array.prototype.slice.call(a, start == null ? 0 : start);
-};
-
-function characters(str) {
-        return str.split("");
-};
-
-function member(name, array) {
-        for (var i = array.length; --i >= 0;)
-                if (array[i] === name)
-                        return true;
-        return false;
-};
-
-function HOP(obj, prop) {
-        return Object.prototype.hasOwnProperty.call(obj, prop);
-};
-
-var warn = function() {};
-
-/* -----[ Exports ]----- */
-
-exports.tokenizer = tokenizer;
-exports.parse = parse;
-exports.slice = slice;
-exports.curry = curry;
-exports.member = member;
-exports.array_to_hash = array_to_hash;
-exports.PRECEDENCE = PRECEDENCE;
-exports.KEYWORDS_ATOM = KEYWORDS_ATOM;
-exports.RESERVED_WORDS = RESERVED_WORDS;
-exports.KEYWORDS = KEYWORDS;
-exports.ATOMIC_START_TOKEN = ATOMIC_START_TOKEN;
-exports.OPERATORS = OPERATORS;
-exports.is_alphanumeric_char = is_alphanumeric_char;
-exports.set_logger = function(logger) {
-        warn = logger;
-};
diff --git a/build/lib/process.js b/build/lib/process.js
deleted file mode 100644 (file)
index 3878c8d..0000000
+++ /dev/null
@@ -1,1666 +0,0 @@
-/***********************************************************************
-
-  A JavaScript tokenizer / parser / beautifier / compressor.
-
-  This version is suitable for Node.js.  With minimal changes (the
-  exports stuff) it should work on any JS platform.
-
-  This file implements some AST processors.  They work on data built
-  by parse-js.
-
-  Exported functions:
-
-    - ast_mangle(ast, options) -- mangles the variable/function names
-      in the AST.  Returns an AST.
-
-    - ast_squeeze(ast) -- employs various optimizations to make the
-      final generated code even smaller.  Returns an AST.
-
-    - gen_code(ast, options) -- generates JS code from the AST.  Pass
-      true (or an object, see the code for some options) as second
-      argument to get "pretty" (indented) code.
-
-  -------------------------------- (C) ---------------------------------
-
-                           Author: Mihai Bazon
-                         <mihai.bazon@gmail.com>
-                       http://mihai.bazon.net/blog
-
-  Distributed under the BSD license:
-
-    Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions
-    are met:
-
-        * Redistributions of source code must retain the above
-          copyright notice, this list of conditions and the following
-          disclaimer.
-
-        * Redistributions in binary form must reproduce the above
-          copyright notice, this list of conditions and the following
-          disclaimer in the documentation and/or other materials
-          provided with the distribution.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
-    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
-    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
-    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
-    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-    SUCH DAMAGE.
-
- ***********************************************************************/
-
-var jsp = require("./parse-js"),
-    slice = jsp.slice,
-    member = jsp.member,
-    PRECEDENCE = jsp.PRECEDENCE,
-    OPERATORS = jsp.OPERATORS;
-
-/* -----[ helper for AST traversal ]----- */
-
-function ast_walker(ast) {
-        function _vardefs(defs) {
-                return [ this[0], MAP(defs, function(def){
-                        var a = [ def[0] ];
-                        if (def.length > 1)
-                                a[1] = walk(def[1]);
-                        return a;
-                }) ];
-        };
-        function _block(statements) {
-                var out = [ this[0] ];
-                if (statements != null)
-                        out.push(MAP(statements, walk));
-                return out;
-        };
-        var walkers = {
-                "string": function(str) {
-                        return [ this[0], str ];
-                },
-                "num": function(num) {
-                        return [ this[0], num ];
-                },
-                "name": function(name) {
-                        return [ this[0], name ];
-                },
-                "toplevel": function(statements) {
-                        return [ this[0], MAP(statements, walk) ];
-                },
-                "block": _block,
-                "splice": _block,
-                "var": _vardefs,
-                "const": _vardefs,
-                "try": function(t, c, f) {
-                        return [
-                                this[0],
-                                MAP(t, walk),
-                                c != null ? [ c[0], MAP(c[1], walk) ] : null,
-                                f != null ? MAP(f, walk) : null
-                        ];
-                },
-                "throw": function(expr) {
-                        return [ this[0], walk(expr) ];
-                },
-                "new": function(ctor, args) {
-                        return [ this[0], walk(ctor), MAP(args, walk) ];
-                },
-                "switch": function(expr, body) {
-                        return [ this[0], walk(expr), MAP(body, function(branch){
-                                return [ branch[0] ? walk(branch[0]) : null,
-                                         MAP(branch[1], walk) ];
-                        }) ];
-                },
-                "break": function(label) {
-                        return [ this[0], label ];
-                },
-                "continue": function(label) {
-                        return [ this[0], label ];
-                },
-                "conditional": function(cond, t, e) {
-                        return [ this[0], walk(cond), walk(t), walk(e) ];
-                },
-                "assign": function(op, lvalue, rvalue) {
-                        return [ this[0], op, walk(lvalue), walk(rvalue) ];
-                },
-                "dot": function(expr) {
-                        return [ this[0], walk(expr) ].concat(slice(arguments, 1));
-                },
-                "call": function(expr, args) {
-                        return [ this[0], walk(expr), MAP(args, walk) ];
-                },
-                "function": function(name, args, body) {
-                        return [ this[0], name, args.slice(), MAP(body, walk) ];
-                },
-                "defun": function(name, args, body) {
-                        return [ this[0], name, args.slice(), MAP(body, walk) ];
-                },
-                "if": function(conditional, t, e) {
-                        return [ this[0], walk(conditional), walk(t), walk(e) ];
-                },
-                "for": function(init, cond, step, block) {
-                        return [ this[0], walk(init), walk(cond), walk(step), walk(block) ];
-                },
-                "for-in": function(vvar, key, hash, block) {
-                        return [ this[0], walk(vvar), walk(key), walk(hash), walk(block) ];
-                },
-                "while": function(cond, block) {
-                        return [ this[0], walk(cond), walk(block) ];
-                },
-                "do": function(cond, block) {
-                        return [ this[0], walk(cond), walk(block) ];
-                },
-                "return": function(expr) {
-                        return [ this[0], walk(expr) ];
-                },
-                "binary": function(op, left, right) {
-                        return [ this[0], op, walk(left), walk(right) ];
-                },
-                "unary-prefix": function(op, expr) {
-                        return [ this[0], op, walk(expr) ];
-                },
-                "unary-postfix": function(op, expr) {
-                        return [ this[0], op, walk(expr) ];
-                },
-                "sub": function(expr, subscript) {
-                        return [ this[0], walk(expr), walk(subscript) ];
-                },
-                "object": function(props) {
-                        return [ this[0], MAP(props, function(p){
-                                return p.length == 2
-                                        ? [ p[0], walk(p[1]) ]
-                                        : [ p[0], walk(p[1]), p[2] ]; // get/set-ter
-                        }) ];
-                },
-                "regexp": function(rx, mods) {
-                        return [ this[0], rx, mods ];
-                },
-                "array": function(elements) {
-                        return [ this[0], MAP(elements, walk) ];
-                },
-                "stat": function(stat) {
-                        return [ this[0], walk(stat) ];
-                },
-                "seq": function() {
-                        return [ this[0] ].concat(MAP(slice(arguments), walk));
-                },
-                "label": function(name, block) {
-                        return [ this[0], name, walk(block) ];
-                },
-                "with": function(expr, block) {
-                        return [ this[0], walk(expr), walk(block) ];
-                },
-                "atom": function(name) {
-                        return [ this[0], name ];
-                }
-        };
-
-        var user = {};
-        var stack = [];
-        function walk(ast) {
-                if (ast == null)
-                        return null;
-                try {
-                        stack.push(ast);
-                        var type = ast[0];
-                        var gen = user[type];
-                        if (gen) {
-                                var ret = gen.apply(ast, ast.slice(1));
-                                if (ret != null)
-                                        return ret;
-                        }
-                        gen = walkers[type];
-                        return gen.apply(ast, ast.slice(1));
-                } finally {
-                        stack.pop();
-                }
-        };
-
-        function with_walkers(walkers, cont){
-                var save = {}, i;
-                for (i in walkers) if (HOP(walkers, i)) {
-                        save[i] = user[i];
-                        user[i] = walkers[i];
-                }
-                var ret = cont();
-                for (i in save) if (HOP(save, i)) {
-                        if (!save[i]) delete user[i];
-                        else user[i] = save[i];
-                }
-                return ret;
-        };
-
-        return {
-                walk: walk,
-                with_walkers: with_walkers,
-                parent: function() {
-                        return stack[stack.length - 2]; // last one is current node
-                },
-                stack: function() {
-                        return stack;
-                }
-        };
-};
-
-/* -----[ Scope and mangling ]----- */
-
-function Scope(parent) {
-        this.names = {};        // names defined in this scope
-        this.mangled = {};      // mangled names (orig.name => mangled)
-        this.rev_mangled = {};  // reverse lookup (mangled => orig.name)
-        this.cname = -1;        // current mangled name
-        this.refs = {};         // names referenced from this scope
-        this.uses_with = false; // will become TRUE if with() is detected in this or any subscopes
-        this.uses_eval = false; // will become TRUE if eval() is detected in this or any subscopes
-        this.parent = parent;   // parent scope
-        this.children = [];     // sub-scopes
-        if (parent) {
-                this.level = parent.level + 1;
-                parent.children.push(this);
-        } else {
-                this.level = 0;
-        }
-};
-
-var base54 = (function(){
-        var DIGITS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_";
-        return function(num) {
-                var ret = "";
-                do {
-                        ret = DIGITS.charAt(num % 54) + ret;
-                        num = Math.floor(num / 54);
-                } while (num > 0);
-                return ret;
-        };
-})();
-
-Scope.prototype = {
-        has: function(name) {
-                for (var s = this; s; s = s.parent)
-                        if (HOP(s.names, name))
-                                return s;
-        },
-        has_mangled: function(mname) {
-                for (var s = this; s; s = s.parent)
-                        if (HOP(s.rev_mangled, mname))
-                                return s;
-        },
-        toJSON: function() {
-                return {
-                        names: this.names,
-                        uses_eval: this.uses_eval,
-                        uses_with: this.uses_with
-                };
-        },
-
-        next_mangled: function() {
-                // we must be careful that the new mangled name:
-                //
-                // 1. doesn't shadow a mangled name from a parent
-                //    scope, unless we don't reference the original
-                //    name from this scope OR from any sub-scopes!
-                //    This will get slow.
-                //
-                // 2. doesn't shadow an original name from a parent
-                //    scope, in the event that the name is not mangled
-                //    in the parent scope and we reference that name
-                //    here OR IN ANY SUBSCOPES!
-                //
-                // 3. doesn't shadow a name that is referenced but not
-                //    defined (possibly global defined elsewhere).
-                for (;;) {
-                        var m = base54(++this.cname), prior;
-
-                        // case 1.
-                        prior = this.has_mangled(m);
-                        if (prior && this.refs[prior.rev_mangled[m]] === prior)
-                                continue;
-
-                        // case 2.
-                        prior = this.has(m);
-                        if (prior && prior !== this && this.refs[m] === prior && !prior.has_mangled(m))
-                                continue;
-
-                        // case 3.
-                        if (HOP(this.refs, m) && this.refs[m] == null)
-                                continue;
-
-                        // I got "do" once. :-/
-                        if (!is_identifier(m))
-                                continue;
-
-                        return m;
-                }
-        },
-        get_mangled: function(name, newMangle) {
-                if (this.uses_eval || this.uses_with) return name; // no mangle if eval or with is in use
-                var s = this.has(name);
-                if (!s) return name; // not in visible scope, no mangle
-                if (HOP(s.mangled, name)) return s.mangled[name]; // already mangled in this scope
-                if (!newMangle) return name;                      // not found and no mangling requested
-
-                var m = s.next_mangled();
-                s.rev_mangled[m] = name;
-                return s.mangled[name] = m;
-        },
-        define: function(name) {
-                if (name != null)
-                        return this.names[name] = name;
-        }
-};
-
-function ast_add_scope(ast) {
-
-        var current_scope = null;
-        var w = ast_walker(), walk = w.walk;
-        var having_eval = [];
-
-        function with_new_scope(cont) {
-                current_scope = new Scope(current_scope);
-                var ret = current_scope.body = cont();
-                ret.scope = current_scope;
-                current_scope = current_scope.parent;
-                return ret;
-        };
-
-        function define(name) {
-                return current_scope.define(name);
-        };
-
-        function reference(name) {
-                current_scope.refs[name] = true;
-        };
-
-        function _lambda(name, args, body) {
-                var is_defun = this[0] == "defun";
-                return [ this[0], is_defun ? define(name) : name, args, with_new_scope(function(){
-                        if (!is_defun) define(name);
-                        MAP(args, define);
-                        return MAP(body, walk);
-                })];
-        };
-
-        return with_new_scope(function(){
-                // process AST
-                var ret = w.with_walkers({
-                        "function": _lambda,
-                        "defun": _lambda,
-                        "with": function(expr, block) {
-                                for (var s = current_scope; s; s = s.parent)
-                                        s.uses_with = true;
-                        },
-                        "var": function(defs) {
-                                MAP(defs, function(d){ define(d[0]) });
-                        },
-                        "const": function(defs) {
-                                MAP(defs, function(d){ define(d[0]) });
-                        },
-                        "try": function(t, c, f) {
-                                if (c != null) return [
-                                        this[0],
-                                        MAP(t, walk),
-                                        [ define(c[0]), MAP(c[1], walk) ],
-                                        f != null ? MAP(f, walk) : null
-                                ];
-                        },
-                        "name": function(name) {
-                                if (name == "eval")
-                                        having_eval.push(current_scope);
-                                reference(name);
-                        }
-                }, function(){
-                        return walk(ast);
-                });
-
-                // the reason why we need an additional pass here is
-                // that names can be used prior to their definition.
-
-                // scopes where eval was detected and their parents
-                // are marked with uses_eval, unless they define the
-                // "eval" name.
-                MAP(having_eval, function(scope){
-                        if (!scope.has("eval")) while (scope) {
-                                scope.uses_eval = true;
-                                scope = scope.parent;
-                        }
-                });
-
-                // for referenced names it might be useful to know
-                // their origin scope.  current_scope here is the
-                // toplevel one.
-                function fixrefs(scope, i) {
-                        // do children first; order shouldn't matter
-                        for (i = scope.children.length; --i >= 0;)
-                                fixrefs(scope.children[i]);
-                        for (i in scope.refs) if (HOP(scope.refs, i)) {
-                                // find origin scope and propagate the reference to origin
-                                for (var origin = scope.has(i), s = scope; s; s = s.parent) {
-                                        s.refs[i] = origin;
-                                        if (s === origin) break;
-                                }
-                        }
-                };
-                fixrefs(current_scope);
-
-                return ret;
-        });
-
-};
-
-/* -----[ mangle names ]----- */
-
-function ast_mangle(ast, options) {
-        var w = ast_walker(), walk = w.walk, scope;
-        options = options || {};
-
-        function get_mangled(name, newMangle) {
-                if (!options.toplevel && !scope.parent) return name; // don't mangle toplevel
-                if (options.except && member(name, options.except))
-                        return name;
-                return scope.get_mangled(name, newMangle);
-        };
-
-        function get_define(name) {
-                // we always lookup a defined symbol for the current scope FIRST, so declared
-                // vars trump a DEFINE symbol, but if no such var is found, then match a DEFINE value
-                if (!scope.has(name)) {
-                    if (HOP(options.defines, name)) {
-                        return options.defines[name];
-                    }
-                }
-                return null;
-        };
-
-        function _lambda(name, args, body) {
-                var is_defun = this[0] == "defun";
-                if (is_defun && name) name = get_mangled(name);
-                body = with_scope(body.scope, function(){
-                        if (!is_defun && name) name = get_mangled(name);
-                        args = MAP(args, function(name){ return get_mangled(name) });
-                        return MAP(body, walk);
-                });
-                return [ this[0], name, args, body ];
-        };
-
-        function with_scope(s, cont) {
-                var _scope = scope;
-                scope = s;
-                for (var i in s.names) if (HOP(s.names, i)) {
-                        get_mangled(i, true);
-                }
-                var ret = cont();
-                ret.scope = s;
-                scope = _scope;
-                return ret;
-        };
-
-        function _vardefs(defs) {
-                return [ this[0], MAP(defs, function(d){
-                        return [ get_mangled(d[0]), walk(d[1]) ];
-                }) ];
-        };
-
-        return w.with_walkers({
-                "function": _lambda,
-                "defun": function() {
-                        // move function declarations to the top when
-                        // they are not in some block.
-                        var ast = _lambda.apply(this, arguments);
-                        switch (w.parent()[0]) {
-                            case "toplevel":
-                            case "function":
-                            case "defun":
-                                return MAP.at_top(ast);
-                        }
-                        return ast;
-                },
-                "var": _vardefs,
-                "const": _vardefs,
-                "name": function(name) {
-                        return get_define(name) || [ this[0], get_mangled(name) ];
-                },
-                "try": function(t, c, f) {
-                        return [ this[0],
-                                 MAP(t, walk),
-                                 c != null ? [ get_mangled(c[0]), MAP(c[1], walk) ] : null,
-                                 f != null ? MAP(f, walk) : null ];
-                },
-                "toplevel": function(body) {
-                        var self = this;
-                        return with_scope(self.scope, function(){
-                                return [ self[0], MAP(body, walk) ];
-                        });
-                }
-        }, function() {
-                return walk(ast_add_scope(ast));
-        });
-};
-
-/* -----[
-   - compress foo["bar"] into foo.bar,
-   - remove block brackets {} where possible
-   - join consecutive var declarations
-   - various optimizations for IFs:
-     - if (cond) foo(); else bar();  ==>  cond?foo():bar();
-     - if (cond) foo();  ==>  cond&&foo();
-     - if (foo) return bar(); else return baz();  ==> return foo?bar():baz(); // also for throw
-     - if (foo) return bar(); else something();  ==> {if(foo)return bar();something()}
-   ]----- */
-
-var warn = function(){};
-
-function best_of(ast1, ast2) {
-        return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1;
-};
-
-function last_stat(b) {
-        if (b[0] == "block" && b[1] && b[1].length > 0)
-                return b[1][b[1].length - 1];
-        return b;
-}
-
-function aborts(t) {
-        if (t) {
-                t = last_stat(t);
-                if (t[0] == "return" || t[0] == "break" || t[0] == "continue" || t[0] == "throw")
-                        return true;
-        }
-};
-
-function boolean_expr(expr) {
-        return ( (expr[0] == "unary-prefix"
-                  && member(expr[1], [ "!", "delete" ])) ||
-
-                 (expr[0] == "binary"
-                  && member(expr[1], [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ])) ||
-
-                 (expr[0] == "binary"
-                  && member(expr[1], [ "&&", "||" ])
-                  && boolean_expr(expr[2])
-                  && boolean_expr(expr[3])) ||
-
-                 (expr[0] == "conditional"
-                  && boolean_expr(expr[2])
-                  && boolean_expr(expr[3])) ||
-
-                 (expr[0] == "assign"
-                  && expr[1] === true
-                  && boolean_expr(expr[3])) ||
-
-                 (expr[0] == "seq"
-                  && boolean_expr(expr[expr.length - 1]))
-               );
-};
-
-function make_conditional(c, t, e) {
-    var make_real_conditional = function() {
-        if (c[0] == "unary-prefix" && c[1] == "!") {
-            return e ? [ "conditional", c[2], e, t ] : [ "binary", "||", c[2], t ];
-        } else {
-            return e ? [ "conditional", c, t, e ] : [ "binary", "&&", c, t ];
-        }
-    };
-    // shortcut the conditional if the expression has a constant value
-    return when_constant(c, function(ast, val){
-        warn_unreachable(val ? e : t);
-        return          (val ? t : e);
-    }, make_real_conditional);
-};
-
-function empty(b) {
-        return !b || (b[0] == "block" && (!b[1] || b[1].length == 0));
-};
-
-function is_string(node) {
-        return (node[0] == "string" ||
-                node[0] == "unary-prefix" && node[1] == "typeof" ||
-                node[0] == "binary" && node[1] == "+" &&
-                (is_string(node[2]) || is_string(node[3])));
-};
-
-var when_constant = (function(){
-
-        var $NOT_CONSTANT = {};
-
-        // this can only evaluate constant expressions.  If it finds anything
-        // not constant, it throws $NOT_CONSTANT.
-        function evaluate(expr) {
-                switch (expr[0]) {
-                    case "string":
-                    case "num":
-                        return expr[1];
-                    case "name":
-                    case "atom":
-                        switch (expr[1]) {
-                            case "true": return true;
-                            case "false": return false;
-                        }
-                        break;
-                    case "unary-prefix":
-                        switch (expr[1]) {
-                            case "!": return !evaluate(expr[2]);
-                            case "typeof": return typeof evaluate(expr[2]);
-                            case "~": return ~evaluate(expr[2]);
-                            case "-": return -evaluate(expr[2]);
-                            case "+": return +evaluate(expr[2]);
-                        }
-                        break;
-                    case "binary":
-                        var left = expr[2], right = expr[3];
-                        switch (expr[1]) {
-                            case "&&"         : return evaluate(left) &&         evaluate(right);
-                            case "||"         : return evaluate(left) ||         evaluate(right);
-                            case "|"          : return evaluate(left) |          evaluate(right);
-                            case "&"          : return evaluate(left) &          evaluate(right);
-                            case "^"          : return evaluate(left) ^          evaluate(right);
-                            case "+"          : return evaluate(left) +          evaluate(right);
-                            case "*"          : return evaluate(left) *          evaluate(right);
-                            case "/"          : return evaluate(left) /          evaluate(right);
-                            case "-"          : return evaluate(left) -          evaluate(right);
-                            case "<<"         : return evaluate(left) <<         evaluate(right);
-                            case ">>"         : return evaluate(left) >>         evaluate(right);
-                            case ">>>"        : return evaluate(left) >>>        evaluate(right);
-                            case "=="         : return evaluate(left) ==         evaluate(right);
-                            case "==="        : return evaluate(left) ===        evaluate(right);
-                            case "!="         : return evaluate(left) !=         evaluate(right);
-                            case "!=="        : return evaluate(left) !==        evaluate(right);
-                            case "<"          : return evaluate(left) <          evaluate(right);
-                            case "<="         : return evaluate(left) <=         evaluate(right);
-                            case ">"          : return evaluate(left) >          evaluate(right);
-                            case ">="         : return evaluate(left) >=         evaluate(right);
-                            case "in"         : return evaluate(left) in         evaluate(right);
-                            case "instanceof" : return evaluate(left) instanceof evaluate(right);
-                        }
-                }
-                throw $NOT_CONSTANT;
-        };
-
-        return function(expr, yes, no) {
-                try {
-                        var val = evaluate(expr), ast;
-                        switch (typeof val) {
-                            case "string": ast =  [ "string", val ]; break;
-                            case "number": ast =  [ "num", val ]; break;
-                            case "boolean": ast =  [ "name", String(val) ]; break;
-                            default: throw new Error("Can't handle constant of type: " + (typeof val));
-                        }
-                        return yes.call(expr, ast, val);
-                } catch(ex) {
-                        if (ex === $NOT_CONSTANT) {
-                                if (expr[0] == "binary"
-                                    && (expr[1] == "===" || expr[1] == "!==")
-                                    && ((is_string(expr[2]) && is_string(expr[3]))
-                                        || (boolean_expr(expr[2]) && boolean_expr(expr[3])))) {
-                                        expr[1] = expr[1].substr(0, 2);
-                                }
-                                else if (no && expr[0] == "binary"
-                                         && (expr[1] == "||" || expr[1] == "&&")) {
-                                    // the whole expression is not constant but the lval may be...
-                                    try {
-                                        var lval = evaluate(expr[2]);
-                                        expr = ((expr[1] == "&&" && (lval ? expr[3] : lval))    ||
-                                                (expr[1] == "||" && (lval ? lval    : expr[3])) ||
-                                                expr);
-                                    } catch(ex2) {
-                                        // IGNORE... lval is not constant 
-                                    }
-                                }
-                                return no ? no.call(expr, expr) : null;
-                        }
-                        else throw ex;
-                }
-        };
-
-})();
-
-function warn_unreachable(ast) {
-        if (!empty(ast))
-                warn("Dropping unreachable code: " + gen_code(ast, true));
-};
-
-function ast_squeeze(ast, options) {
-        options = defaults(options, {
-                make_seqs   : true,
-                dead_code   : true,
-                keep_comps  : true,
-                no_warnings : false
-        });
-
-        var w = ast_walker(), walk = w.walk, scope;
-
-        function negate(c) {
-                var not_c = [ "unary-prefix", "!", c ];
-                switch (c[0]) {
-                    case "unary-prefix":
-                        return c[1] == "!" && boolean_expr(c[2]) ? c[2] : not_c;
-                    case "seq":
-                        c = slice(c);
-                        c[c.length - 1] = negate(c[c.length - 1]);
-                        return c;
-                    case "conditional":
-                        return best_of(not_c, [ "conditional", c[1], negate(c[2]), negate(c[3]) ]);
-                    case "binary":
-                        var op = c[1], left = c[2], right = c[3];
-                        if (!options.keep_comps) switch (op) {
-                            case "<="  : return [ "binary", ">", left, right ];
-                            case "<"   : return [ "binary", ">=", left, right ];
-                            case ">="  : return [ "binary", "<", left, right ];
-                            case ">"   : return [ "binary", "<=", left, right ];
-                        }
-                        switch (op) {
-                            case "=="  : return [ "binary", "!=", left, right ];
-                            case "!="  : return [ "binary", "==", left, right ];
-                            case "===" : return [ "binary", "!==", left, right ];
-                            case "!==" : return [ "binary", "===", left, right ];
-                            case "&&"  : return best_of(not_c, [ "binary", "||", negate(left), negate(right) ]);
-                            case "||"  : return best_of(not_c, [ "binary", "&&", negate(left), negate(right) ]);
-                        }
-                        break;
-                }
-                return not_c;
-        };
-
-        function with_scope(s, cont) {
-                var _scope = scope;
-                scope = s;
-                var ret = cont();
-                ret.scope = s;
-                scope = _scope;
-                return ret;
-        };
-
-        function rmblock(block) {
-                if (block != null && block[0] == "block" && block[1]) {
-                        if (block[1].length == 1)
-                                block = block[1][0];
-                        else if (block[1].length == 0)
-                                block = [ "block" ];
-                }
-                return block;
-        };
-
-        function _lambda(name, args, body) {
-                var is_defun = this[0] == "defun";
-                body = with_scope(body.scope, function(){
-                        var ret = tighten(MAP(body, walk), "lambda");
-                        if (!is_defun && name && !HOP(scope.refs, name))
-                                name = null;
-                        return ret;
-                });
-                return [ this[0], name, args, body ];
-        };
-
-        // we get here for blocks that have been already transformed.
-        // this function does a few things:
-        // 1. discard useless blocks
-        // 2. join consecutive var declarations
-        // 3. remove obviously dead code
-        // 4. transform consecutive statements using the comma operator
-        // 5. if block_type == "lambda" and it detects constructs like if(foo) return ... - rewrite like if (!foo) { ... }
-        function tighten(statements, block_type) {
-                statements = statements.reduce(function(a, stat){
-                        if (stat[0] == "block") {
-                                if (stat[1]) {
-                                        a.push.apply(a, stat[1]);
-                                }
-                        } else {
-                                a.push(stat);
-                        }
-                        return a;
-                }, []);
-
-                statements = (function(a, prev){
-                        statements.forEach(function(cur){
-                                if (prev && ((cur[0] == "var" && prev[0] == "var") ||
-                                             (cur[0] == "const" && prev[0] == "const"))) {
-                                        prev[1] = prev[1].concat(cur[1]);
-                                } else {
-                                        a.push(cur);
-                                        prev = cur;
-                                }
-                        });
-                        return a;
-                })([]);
-
-                if (options.dead_code) statements = (function(a, has_quit){
-                        statements.forEach(function(st){
-                                if (has_quit) {
-                                        if (member(st[0], [ "function", "defun" , "var", "const" ])) {
-                                                a.push(st);
-                                        }
-                                        else if (!options.no_warnings)
-                                                warn_unreachable(st);
-                                }
-                                else {
-                                        a.push(st);
-                                        if (member(st[0], [ "return", "throw", "break", "continue" ]))
-                                                has_quit = true;
-                                }
-                        });
-                        return a;
-                })([]);
-
-                if (options.make_seqs) statements = (function(a, prev) {
-                        statements.forEach(function(cur){
-                                if (prev && prev[0] == "stat" && cur[0] == "stat") {
-                                        prev[1] = [ "seq", prev[1], cur[1] ];
-                                } else {
-                                        a.push(cur);
-                                        prev = cur;
-                                }
-                        });
-                        return a;
-                })([]);
-
-                if (block_type == "lambda") statements = (function(i, a, stat){
-                        while (i < statements.length) {
-                                stat = statements[i++];
-                                if (stat[0] == "if" && !stat[3]) {
-                                        if (stat[2][0] == "return" && stat[2][1] == null) {
-                                                a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ]));
-                                                break;
-                                        }
-                                        var last = last_stat(stat[2]);
-                                        if (last[0] == "return" && last[1] == null) {
-                                                a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ]));
-                                                break;
-                                        }
-                                }
-                                a.push(stat);
-                        }
-                        return a;
-                })(0, []);
-
-                return statements;
-        };
-
-        function make_if(c, t, e) {
-                return when_constant(c, function(ast, val){
-                        if (val) {
-                                warn_unreachable(e);
-                                return t;
-                        } else {
-                                warn_unreachable(t);
-                                return e;
-                        }
-                }, function() {
-                        return make_real_if(c, t, e);
-                });
-        };
-
-        function make_real_if(c, t, e) {
-                c = walk(c);
-                t = walk(t);
-                e = walk(e);
-
-                if (empty(t)) {
-                        c = negate(c);
-                        t = e;
-                        e = null;
-                } else if (empty(e)) {
-                        e = null;
-                } else {
-                        // if we have both else and then, maybe it makes sense to switch them?
-                        (function(){
-                                var a = gen_code(c);
-                                var n = negate(c);
-                                var b = gen_code(n);
-                                if (b.length < a.length) {
-                                        var tmp = t;
-                                        t = e;
-                                        e = tmp;
-                                        c = n;
-                                }
-                        })();
-                }
-                if (empty(e) && empty(t))
-                        return [ "stat", c ];
-                var ret = [ "if", c, t, e ];
-                if (t[0] == "if" && empty(t[3]) && empty(e)) {
-                        ret = best_of(ret, walk([ "if", [ "binary", "&&", c, t[1] ], t[2] ]));
-                }
-                else if (t[0] == "stat") {
-                        if (e) {
-                                if (e[0] == "stat") {
-                                        ret = best_of(ret, [ "stat", make_conditional(c, t[1], e[1]) ]);
-                                }
-                        }
-                        else {
-                                ret = best_of(ret, [ "stat", make_conditional(c, t[1]) ]);
-                        }
-                }
-                else if (e && t[0] == e[0] && (t[0] == "return" || t[0] == "throw") && t[1] && e[1]) {
-                        ret = best_of(ret, [ t[0], make_conditional(c, t[1], e[1] ) ]);
-                }
-                else if (e && aborts(t)) {
-                        ret = [ [ "if", c, t ] ];
-                        if (e[0] == "block") {
-                                if (e[1]) ret = ret.concat(e[1]);
-                        }
-                        else {
-                                ret.push(e);
-                        }
-                        ret = walk([ "block", ret ]);
-                }
-                else if (t && aborts(e)) {
-                        ret = [ [ "if", negate(c), e ] ];
-                        if (t[0] == "block") {
-                                if (t[1]) ret = ret.concat(t[1]);
-                        } else {
-                                ret.push(t);
-                        }
-                        ret = walk([ "block", ret ]);
-                }
-                return ret;
-        };
-
-        function _do_while(cond, body) {
-                return when_constant(cond, function(cond, val){
-                        if (!val) {
-                                warn_unreachable(body);
-                                return [ "block" ];
-                        } else {
-                                return [ "for", null, null, null, walk(body) ];
-                        }
-                });
-        };
-
-        return w.with_walkers({
-                "sub": function(expr, subscript) {
-                        if (subscript[0] == "string") {
-                                var name = subscript[1];
-                                if (is_identifier(name))
-                                        return [ "dot", walk(expr), name ];
-                                else if (/^[1-9][0-9]*$/.test(name) || name === "0")
-                                        return [ "sub", walk(expr), [ "num", parseInt(name, 10) ] ];
-                        }
-                },
-                "if": make_if,
-                "toplevel": function(body) {
-                        return [ "toplevel", with_scope(this.scope, function(){
-                                return tighten(MAP(body, walk));
-                        }) ];
-                },
-                "switch": function(expr, body) {
-                        var last = body.length - 1;
-                        return [ "switch", walk(expr), MAP(body, function(branch, i){
-                                var block = tighten(MAP(branch[1], walk));
-                                if (i == last && block.length > 0) {
-                                        var node = block[block.length - 1];
-                                        if (node[0] == "break" && !node[1])
-                                                block.pop();
-                                }
-                                return [ branch[0] ? walk(branch[0]) : null, block ];
-                        }) ];
-                },
-                "function": _lambda,
-                "defun": _lambda,
-                "block": function(body) {
-                        if (body) return rmblock([ "block", tighten(MAP(body, walk)) ]);
-                },
-                "binary": function(op, left, right) {
-                        return when_constant([ "binary", op, walk(left), walk(right) ], function yes(c){
-                                return best_of(walk(c), this);
-                        }, function no() {
-                                return this;
-                        });
-                },
-                "conditional": function(c, t, e) {
-                        return make_conditional(walk(c), walk(t), walk(e));
-                },
-                "try": function(t, c, f) {
-                        return [
-                                "try",
-                                tighten(MAP(t, walk)),
-                                c != null ? [ c[0], tighten(MAP(c[1], walk)) ] : null,
-                                f != null ? tighten(MAP(f, walk)) : null
-                        ];
-                },
-                "unary-prefix": function(op, expr) {
-                        expr = walk(expr);
-                        var ret = [ "unary-prefix", op, expr ];
-                        if (op == "!")
-                                ret = best_of(ret, negate(expr));
-                        return when_constant(ret, function(ast, val){
-                                return walk(ast); // it's either true or false, so minifies to !0 or !1
-                        }, function() { return ret });
-                },
-                "name": function(name) {
-                        switch (name) {
-                            case "true": return [ "unary-prefix", "!", [ "num", 0 ]];
-                            case "false": return [ "unary-prefix", "!", [ "num", 1 ]];
-                        }
-                },
-                "new": function(ctor, args) {
-                        if (ctor[0] == "name" && ctor[1] == "Array" && !scope.has("Array")) {
-                                if (args.length != 1) {
-                                        return [ "array", args ];
-                                } else {
-                                        return [ "call", [ "name", "Array" ], args ];
-                                }
-                        }
-                },
-                "call": function(expr, args) {
-                        if (expr[0] == "name" && expr[1] == "Array" && args.length != 1 && !scope.has("Array")) {
-                                return [ "array", args ];
-                        }
-                },
-                "while": _do_while,
-                "do": _do_while
-        }, function() {
-                return walk(ast_add_scope(ast));
-        });
-};
-
-/* -----[ re-generate code from the AST ]----- */
-
-var DOT_CALL_NO_PARENS = jsp.array_to_hash([
-        "name",
-        "array",
-        "object",
-        "string",
-        "dot",
-        "sub",
-        "call",
-        "regexp"
-]);
-
-function make_string(str, ascii_only) {
-        var dq = 0, sq = 0;
-        str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029]/g, function(s){
-                switch (s) {
-                    case "\\": return "\\\\";
-                    case "\b": return "\\b";
-                    case "\f": return "\\f";
-                    case "\n": return "\\n";
-                    case "\r": return "\\r";
-                    case "\t": return "\\t";
-                    case "\u2028": return "\\u2028";
-                    case "\u2029": return "\\u2029";
-                    case '"': ++dq; return '"';
-                    case "'": ++sq; return "'";
-                }
-                return s;
-        });
-        if (ascii_only) str = to_ascii(str);
-        if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'";
-        else return '"' + str.replace(/\x22/g, '\\"') + '"';
-};
-
-function to_ascii(str) {
-        return str.replace(/[\u0080-\uffff]/g, function(ch) {
-                var code = ch.charCodeAt(0).toString(16);
-                while (code.length < 4) code = "0" + code;
-                return "\\u" + code;
-        });
-};
-
-var SPLICE_NEEDS_BRACKETS = jsp.array_to_hash([ "if", "while", "do", "for", "for-in", "with" ]);
-
-function gen_code(ast, options) {
-        options = defaults(options, {
-                indent_start : 0,
-                indent_level : 4,
-                quote_keys   : false,
-                space_colon  : false,
-                beautify     : false,
-                ascii_only   : false
-        });
-        var beautify = !!options.beautify;
-        var indentation = 0,
-            newline = beautify ? "\n" : "",
-            space = beautify ? " " : "";
-
-        function encode_string(str) {
-                return make_string(str, options.ascii_only);
-        };
-
-        function make_name(name) {
-                name = name.toString();
-                if (options.ascii_only)
-                        name = to_ascii(name);
-                return name;
-        };
-
-        function indent(line) {
-                if (line == null)
-                        line = "";
-                if (beautify)
-                        line = repeat_string(" ", options.indent_start + indentation * options.indent_level) + line;
-                return line;
-        };
-
-        function with_indent(cont, incr) {
-                if (incr == null) incr = 1;
-                indentation += incr;
-                try { return cont.apply(null, slice(arguments, 1)); }
-                finally { indentation -= incr; }
-        };
-
-        function add_spaces(a) {
-                if (beautify)
-                        return a.join(" ");
-                var b = [];
-                for (var i = 0; i < a.length; ++i) {
-                        var next = a[i + 1];
-                        b.push(a[i]);
-                        if (next &&
-                            ((/[a-z0-9_\x24]$/i.test(a[i].toString()) && /^[a-z0-9_\x24]/i.test(next.toString())) ||
-                             (/[\+\-]$/.test(a[i].toString()) && /^[\+\-]/.test(next.toString())))) {
-                                b.push(" ");
-                        }
-                }
-                return b.join("");
-        };
-
-        function add_commas(a) {
-                return a.join("," + space);
-        };
-
-        function parenthesize(expr) {
-                var gen = make(expr);
-                for (var i = 1; i < arguments.length; ++i) {
-                        var el = arguments[i];
-                        if ((el instanceof Function && el(expr)) || expr[0] == el)
-                                return "(" + gen + ")";
-                }
-                return gen;
-        };
-
-        function best_of(a) {
-                if (a.length == 1) {
-                        return a[0];
-                }
-                if (a.length == 2) {
-                        var b = a[1];
-                        a = a[0];
-                        return a.length <= b.length ? a : b;
-                }
-                return best_of([ a[0], best_of(a.slice(1)) ]);
-        };
-
-        function needs_parens(expr) {
-                if (expr[0] == "function" || expr[0] == "object") {
-                        // dot/call on a literal function requires the
-                        // function literal itself to be parenthesized
-                        // only if it's the first "thing" in a
-                        // statement.  This means that the parent is
-                        // "stat", but it could also be a "seq" and
-                        // we're the first in this "seq" and the
-                        // parent is "stat", and so on.  Messy stuff,
-                        // but it worths the trouble.
-                        var a = slice($stack), self = a.pop(), p = a.pop();
-                        while (p) {
-                                if (p[0] == "stat") return true;
-                                if (((p[0] == "seq" || p[0] == "call" || p[0] == "dot" || p[0] == "sub" || p[0] == "conditional") && p[1] === self) ||
-                                    ((p[0] == "binary" || p[0] == "assign" || p[0] == "unary-postfix") && p[2] === self)) {
-                                        self = p;
-                                        p = a.pop();
-                                } else {
-                                        return false;
-                                }
-                        }
-                }
-                return !HOP(DOT_CALL_NO_PARENS, expr[0]);
-        };
-
-        function make_num(num) {
-                var str = num.toString(10), a = [ str.replace(/^0\./, ".") ], m;
-                if (Math.floor(num) === num) {
-                        a.push("0x" + num.toString(16).toLowerCase(), // probably pointless
-                               "0" + num.toString(8)); // same.
-                        if ((m = /^(.*?)(0+)$/.exec(num))) {
-                                a.push(m[1] + "e" + m[2].length);
-                        }
-                } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) {
-                        a.push(m[2] + "e-" + (m[1].length + m[2].length),
-                               str.substr(str.indexOf(".")));
-                }
-                return best_of(a);
-        };
-
-        var generators = {
-                "string": encode_string,
-                "num": make_num,
-                "name": make_name,
-                "toplevel": function(statements) {
-                        return make_block_statements(statements)
-                                .join(newline + newline);
-                },
-                "splice": function(statements) {
-                        var parent = $stack[$stack.length - 2][0];
-                        if (HOP(SPLICE_NEEDS_BRACKETS, parent)) {
-                                // we need block brackets in this case
-                                return make_block.apply(this, arguments);
-                        } else {
-                                return MAP(make_block_statements(statements, true),
-                                           function(line, i) {
-                                                   // the first line is already indented
-                                                   return i > 0 ? indent(line) : line;
-                                           }).join(newline);
-                        }
-                },
-                "block": make_block,
-                "var": function(defs) {
-                        return "var " + add_commas(MAP(defs, make_1vardef)) + ";";
-                },
-                "const": function(defs) {
-                        return "const " + add_commas(MAP(defs, make_1vardef)) + ";";
-                },
-                "try": function(tr, ca, fi) {
-                        var out = [ "try", make_block(tr) ];
-                        if (ca) out.push("catch", "(" + ca[0] + ")", make_block(ca[1]));
-                        if (fi) out.push("finally", make_block(fi));
-                        return add_spaces(out);
-                },
-                "throw": function(expr) {
-                        return add_spaces([ "throw", make(expr) ]) + ";";
-                },
-                "new": function(ctor, args) {
-                        args = args.length > 0 ? "(" + add_commas(MAP(args, make)) + ")" : "";
-                        return add_spaces([ "new", parenthesize(ctor, "seq", "binary", "conditional", "assign", function(expr){
-                                var w = ast_walker(), has_call = {};
-                                try {
-                                        w.with_walkers({
-                                                "call": function() { throw has_call },
-                                                "function": function() { return this }
-                                        }, function(){
-                                                w.walk(expr);
-                                        });
-                                } catch(ex) {
-                                        if (ex === has_call)
-                                                return true;
-                                        throw ex;
-                                }
-                        }) + args ]);
-                },
-                "switch": function(expr, body) {
-                        return add_spaces([ "switch", "(" + make(expr) + ")", make_switch_block(body) ]);
-                },
-                "break": function(label) {
-                        var out = "break";
-                        if (label != null)
-                                out += " " + make_name(label);
-                        return out + ";";
-                },
-                "continue": function(label) {
-                        var out = "continue";
-                        if (label != null)
-                                out += " " + make_name(label);
-                        return out + ";";
-                },
-                "conditional": function(co, th, el) {
-                        return add_spaces([ parenthesize(co, "assign", "seq", "conditional"), "?",
-                                            parenthesize(th, "seq"), ":",
-                                            parenthesize(el, "seq") ]);
-                },
-                "assign": function(op, lvalue, rvalue) {
-                        if (op && op !== true) op += "=";
-                        else op = "=";
-                        return add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]);
-                },
-                "dot": function(expr) {
-                        var out = make(expr), i = 1;
-                        if (expr[0] == "num") {
-                                if (!/\./.test(expr[1]))
-                                        out += ".";
-                        } else if (needs_parens(expr))
-                                out = "(" + out + ")";
-                        while (i < arguments.length)
-                                out += "." + make_name(arguments[i++]);
-                        return out;
-                },
-                "call": function(func, args) {
-                        var f = make(func);
-                        if (needs_parens(func))
-                                f = "(" + f + ")";
-                        return f + "(" + add_commas(MAP(args, function(expr){
-                                return parenthesize(expr, "seq");
-                        })) + ")";
-                },
-                "function": make_function,
-                "defun": make_function,
-                "if": function(co, th, el) {
-                        var out = [ "if", "(" + make(co) + ")", el ? make_then(th) : make(th) ];
-                        if (el) {
-                                out.push("else", make(el));
-                        }
-                        return add_spaces(out);
-                },
-                "for": function(init, cond, step, block) {
-                        var out = [ "for" ];
-                        init = (init != null ? make(init) : "").replace(/;*\s*$/, ";" + space);
-                        cond = (cond != null ? make(cond) : "").replace(/;*\s*$/, ";" + space);
-                        step = (step != null ? make(step) : "").replace(/;*\s*$/, "");
-                        var args = init + cond + step;
-                        if (args == "; ; ") args = ";;";
-                        out.push("(" + args + ")", make(block));
-                        return add_spaces(out);
-                },
-                "for-in": function(vvar, key, hash, block) {
-                        return add_spaces([ "for", "(" +
-                                            (vvar ? make(vvar).replace(/;+$/, "") : make(key)),
-                                            "in",
-                                            make(hash) + ")", make(block) ]);
-                },
-                "while": function(condition, block) {
-                        return add_spaces([ "while", "(" + make(condition) + ")", make(block) ]);
-                },
-                "do": function(condition, block) {
-                        return add_spaces([ "do", make(block), "while", "(" + make(condition) + ")" ]) + ";";
-                },
-                "return": function(expr) {
-                        var out = [ "return" ];
-                        if (expr != null) out.push(make(expr));
-                        return add_spaces(out) + ";";
-                },
-                "binary": function(operator, lvalue, rvalue) {
-                        var left = make(lvalue), right = make(rvalue);
-                        // XXX: I'm pretty sure other cases will bite here.
-                        //      we need to be smarter.
-                        //      adding parens all the time is the safest bet.
-                        if (member(lvalue[0], [ "assign", "conditional", "seq" ]) ||
-                            lvalue[0] == "binary" && PRECEDENCE[operator] > PRECEDENCE[lvalue[1]]) {
-                                left = "(" + left + ")";
-                        }
-                        if (member(rvalue[0], [ "assign", "conditional", "seq" ]) ||
-                            rvalue[0] == "binary" && PRECEDENCE[operator] >= PRECEDENCE[rvalue[1]] &&
-                            !(rvalue[1] == operator && member(operator, [ "&&", "||", "*" ]))) {
-                                right = "(" + right + ")";
-                        }
-                        return add_spaces([ left, operator, right ]);
-                },
-                "unary-prefix": function(operator, expr) {
-                        var val = make(expr);
-                        if (!(expr[0] == "num" || (expr[0] == "unary-prefix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr)))
-                                val = "(" + val + ")";
-                        return operator + (jsp.is_alphanumeric_char(operator.charAt(0)) ? " " : "") + val;
-                },
-                "unary-postfix": function(operator, expr) {
-                        var val = make(expr);
-                        if (!(expr[0] == "num" || (expr[0] == "unary-postfix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr)))
-                                val = "(" + val + ")";
-                        return val + operator;
-                },
-                "sub": function(expr, subscript) {
-                        var hash = make(expr);
-                        if (needs_parens(expr))
-                                hash = "(" + hash + ")";
-                        return hash + "[" + make(subscript) + "]";
-                },
-                "object": function(props) {
-                        if (props.length == 0)
-                                return "{}";
-                        return "{" + newline + with_indent(function(){
-                                return MAP(props, function(p){
-                                        if (p.length == 3) {
-                                                // getter/setter.  The name is in p[0], the arg.list in p[1][2], the
-                                                // body in p[1][3] and type ("get" / "set") in p[2].
-                                                return indent(make_function(p[0], p[1][2], p[1][3], p[2]));
-                                        }
-                                        var key = p[0], val = make(p[1]);
-                                        if (options.quote_keys) {
-                                                key = encode_string(key);
-                                        } else if ((typeof key == "number" || !beautify && +key + "" == key)
-                                                   && parseFloat(key) >= 0) {
-                                                key = make_num(+key);
-                                        } else if (!is_identifier(key)) {
-                                                key = encode_string(key);
-                                        }
-                                        return indent(add_spaces(beautify && options.space_colon
-                                                                 ? [ key, ":", val ]
-                                                                 : [ key + ":", val ]));
-                                }).join("," + newline);
-                        }) + newline + indent("}");
-                },
-                "regexp": function(rx, mods) {
-                        return "/" + rx + "/" + mods;
-                },
-                "array": function(elements) {
-                        if (elements.length == 0) return "[]";
-                        return add_spaces([ "[", add_commas(MAP(elements, function(el){
-                                if (!beautify && el[0] == "atom" && el[1] == "undefined") return "";
-                                return parenthesize(el, "seq");
-                        })), "]" ]);
-                },
-                "stat": function(stmt) {
-                        return make(stmt).replace(/;*\s*$/, ";");
-                },
-                "seq": function() {
-                        return add_commas(MAP(slice(arguments), make));
-                },
-                "label": function(name, block) {
-                        return add_spaces([ make_name(name), ":", make(block) ]);
-                },
-                "with": function(expr, block) {
-                        return add_spaces([ "with", "(" + make(expr) + ")", make(block) ]);
-                },
-                "atom": function(name) {
-                        return make_name(name);
-                }
-        };
-
-        // The squeezer replaces "block"-s that contain only a single
-        // statement with the statement itself; technically, the AST
-        // is correct, but this can create problems when we output an
-        // IF having an ELSE clause where the THEN clause ends in an
-        // IF *without* an ELSE block (then the outer ELSE would refer
-        // to the inner IF).  This function checks for this case and
-        // adds the block brackets if needed.
-        function make_then(th) {
-                if (th[0] == "do") {
-                        // https://github.com/mishoo/UglifyJS/issues/#issue/57
-                        // IE croaks with "syntax error" on code like this:
-                        //     if (foo) do ... while(cond); else ...
-                        // we need block brackets around do/while
-                        return make([ "block", [ th ]]);
-                }
-                var b = th;
-                while (true) {
-                        var type = b[0];
-                        if (type == "if") {
-                                if (!b[3])
-                                        // no else, we must add the block
-                                        return make([ "block", [ th ]]);
-                                b = b[3];
-                        }
-                        else if (type == "while" || type == "do") b = b[2];
-                        else if (type == "for" || type == "for-in") b = b[4];
-                        else break;
-                }
-                return make(th);
-        };
-
-        function make_function(name, args, body, keyword) {
-                var out = keyword || "function";
-                if (name) {
-                        out += " " + make_name(name);
-                }
-                out += "(" + add_commas(MAP(args, make_name)) + ")";
-                return add_spaces([ out, make_block(body) ]);
-        };
-
-        function make_block_statements(statements, noindent) {
-                for (var a = [], last = statements.length - 1, i = 0; i <= last; ++i) {
-                        var stat = statements[i];
-                        var code = make(stat);
-                        if (code != ";") {
-                                if (!beautify && i == last) {
-                                        if ((stat[0] == "while" && empty(stat[2])) ||
-                                            (member(stat[0], [ "for", "for-in"] ) && empty(stat[4])) ||
-                                            (stat[0] == "if" && empty(stat[2]) && !stat[3]) ||
-                                            (stat[0] == "if" && stat[3] && empty(stat[3]))) {
-                                                code = code.replace(/;*\s*$/, ";");
-                                        } else {
-                                                code = code.replace(/;+\s*$/, "");
-                                        }
-                                }
-                                a.push(code);
-                        }
-                }
-                return noindent ? a : MAP(a, indent);
-        };
-
-        function make_switch_block(body) {
-                var n = body.length;
-                if (n == 0) return "{}";
-                return "{" + newline + MAP(body, function(branch, i){
-                        var has_body = branch[1].length > 0, code = with_indent(function(){
-                                return indent(branch[0]
-                                              ? add_spaces([ "case", make(branch[0]) + ":" ])
-                                              : "default:");
-                        }, 0.5) + (has_body ? newline + with_indent(function(){
-                                return make_block_statements(branch[1]).join(newline);
-                        }) : "");
-                        if (!beautify && has_body && i < n - 1)
-                                code += ";";
-                        return code;
-                }).join(newline) + newline + indent("}");
-        };
-
-        function make_block(statements) {
-                if (!statements) return ";";
-                if (statements.length == 0) return "{}";
-                return "{" + newline + with_indent(function(){
-                        return make_block_statements(statements).join(newline);
-                }) + newline + indent("}");
-        };
-
-        function make_1vardef(def) {
-                var name = def[0], val = def[1];
-                if (val != null)
-                        name = add_spaces([ make_name(name), "=", parenthesize(val, "seq") ]);
-                return name;
-        };
-
-        var $stack = [];
-
-        function make(node) {
-                var type = node[0];
-                var gen = generators[type];
-                if (!gen)
-                        throw new Error("Can't find generator for \"" + type + "\"");
-                $stack.push(node);
-                var ret = gen.apply(type, node.slice(1));
-                $stack.pop();
-                return ret;
-        };
-
-        return make(ast);
-};
-
-function split_lines(code, max_line_length) {
-        var splits = [ 0 ];
-        jsp.parse(function(){
-                var next_token = jsp.tokenizer(code);
-                var last_split = 0;
-                var prev_token;
-                function current_length(tok) {
-                        return tok.pos - last_split;
-                };
-                function split_here(tok) {
-                        last_split = tok.pos;
-                        splits.push(last_split);
-                };
-                function custom(){
-                        var tok = next_token.apply(this, arguments);
-                        out: {
-                                if (prev_token) {
-                                        if (prev_token.type == "keyword") break out;
-                                }
-                                if (current_length(tok) > max_line_length) {
-                                        switch (tok.type) {
-                                            case "keyword":
-                                            case "atom":
-                                            case "name":
-                                            case "punc":
-                                                split_here(tok);
-                                                break out;
-                                        }
-                                }
-                        }
-                        prev_token = tok;
-                        return tok;
-                };
-                custom.context = function() {
-                        return next_token.context.apply(this, arguments);
-                };
-                return custom;
-        }());
-        return splits.map(function(pos, i){
-                return code.substring(pos, splits[i + 1] || code.length);
-        }).join("\n");
-};
-
-/* -----[ Utilities ]----- */
-
-function repeat_string(str, i) {
-        if (i <= 0) return "";
-        if (i == 1) return str;
-        var d = repeat_string(str, i >> 1);
-        d += d;
-        if (i & 1) d += str;
-        return d;
-};
-
-function defaults(args, defs) {
-        var ret = {};
-        if (args === true)
-                args = {};
-        for (var i in defs) if (HOP(defs, i)) {
-                ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];
-        }
-        return ret;
-};
-
-function is_identifier(name) {
-        return /^[a-z_$][a-z0-9_$]*$/i.test(name)
-                && name != "this"
-                && !HOP(jsp.KEYWORDS_ATOM, name)
-                && !HOP(jsp.RESERVED_WORDS, name)
-                && !HOP(jsp.KEYWORDS, name);
-};
-
-function HOP(obj, prop) {
-        return Object.prototype.hasOwnProperty.call(obj, prop);
-};
-
-// some utilities
-
-var MAP;
-
-(function(){
-        MAP = function(a, f, o) {
-                var ret = [];
-                for (var i = 0; i < a.length; ++i) {
-                        var val = f.call(o, a[i], i);
-                        if (val instanceof AtTop) ret.unshift(val.v);
-                        else ret.push(val);
-                }
-                return ret;
-        };
-        MAP.at_top = function(val) { return new AtTop(val) };
-        function AtTop(val) { this.v = val };
-})();
-
-/* -----[ Exports ]----- */
-
-exports.ast_walker = ast_walker;
-exports.ast_mangle = ast_mangle;
-exports.ast_squeeze = ast_squeeze;
-exports.gen_code = gen_code;
-exports.ast_add_scope = ast_add_scope;
-exports.set_logger = function(logger) { warn = logger };
-exports.make_string = make_string;
-exports.split_lines = split_lines;
-exports.MAP = MAP;
-
-// keep this last!
-exports.ast_squeeze_more = require("./squeeze-more").ast_squeeze_more;
diff --git a/build/lib/squeeze-more.js b/build/lib/squeeze-more.js
deleted file mode 100644 (file)
index 12380af..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-var jsp = require("./parse-js"),
-    pro = require("./process"),
-    slice = jsp.slice,
-    member = jsp.member,
-    PRECEDENCE = jsp.PRECEDENCE,
-    OPERATORS = jsp.OPERATORS;
-
-function ast_squeeze_more(ast) {
-        var w = pro.ast_walker(), walk = w.walk;
-        return w.with_walkers({
-                "call": function(expr, args) {
-                        if (expr[0] == "dot" && expr[2] == "toString" && args.length == 0) {
-                                // foo.toString()  ==>  foo+""
-                                return [ "binary", "+", expr[1], [ "string", "" ]];
-                        }
-                }
-        }, function() {
-                return walk(ast);
-        });
-};
-
-exports.ast_squeeze_more = ast_squeeze_more;
diff --git a/build/post-compile.js b/build/post-compile.js
deleted file mode 100644 (file)
index f77a38b..0000000
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-
-var fs = require( "fs" ),
-       src = fs.readFileSync( process.argv[2], "utf8" ),
-       version = fs.readFileSync( "version.txt", "utf8" ),
-       // License Template
-       license = "/*! jQuery v@VERSION jquery.com | jquery.org/license */";
-
-
-// Previously done in sed but reimplemented here due to portability issues
-src = src.replace( /^(\s*\*\/)(.+)/m, "$1\n$2" ) + ";";
-
-// Set minimal license block var
-license = license.replace( "@VERSION", version );
-
-// Replace license block with minimal license
-src = src.replace( /\/\/.*?\/?\*.+?(?=\n|\r|$)|\/\*[\s\S]*?\/\/[\s\S]*?\*\//, license );
-
-fs.writeFileSync( "dist/jquery.min.js", src, "utf8" );
diff --git a/build/sizer.js b/build/sizer.js
deleted file mode 100644 (file)
index 2372b5f..0000000
+++ /dev/null
@@ -1,36 +0,0 @@
-var fs = require( "fs" ),
-       stdin = process.openStdin(),
-       rsize = /(\d+).*?(jquery\S+)/g,
-       oldsizes = {},
-       sizes = {};
-
-try {
-       oldsizes = JSON.parse( fs.readFileSync(  __dirname + "/.sizecache.json", "utf8" ) );
-} catch(e) {
-       oldsizes = {};
-};
-
-stdin.on( "data" , function( chunk ) {
-       var match;
-
-       while ( match = rsize.exec( chunk ) ) {
-               sizes[ match[2] ] = parseInt( match[1], 10 );
-       }
-});
-
-function lpad( str, len, chr ) {
-       return ( Array(len+1).join( chr || " ") + str ).substr( -len );
-}
-
-stdin.on( "end", function() {
-       console.log( "jQuery Size - compared to last make" );
-       fs.writeFileSync( __dirname + "/.sizecache.json", JSON.stringify( sizes, true ), "utf8" );
-       for ( var key in sizes ) {
-               var diff = oldsizes[ key ] && ( sizes[ key ] - oldsizes[ key ] );
-               if ( diff > 0 ) {
-                       diff = "+" + diff;
-               }
-               console.log( "%s %s %s", lpad( sizes[ key ], 8 ), lpad( diff ? "(" + diff + ")" : "(-)", 8 ), key );
-       }
-       process.exit();
-});
\ No newline at end of file
diff --git a/build/uglify.js b/build/uglify.js
deleted file mode 100644 (file)
index aad18e8..0000000
+++ /dev/null
@@ -1,285 +0,0 @@
-#! /usr/bin/env node
-// -*- js -*-
-
-global.sys = require(/^v0\.[012]/.test(process.version) ? "sys" : "util");
-var fs = require("fs");
-var jsp = require("./lib/parse-js"),
-       pro = require("./lib/process");
-
-var options = {
-        ast: false,
-        mangle: true,
-        mangle_toplevel: false,
-        squeeze: true,
-        make_seqs: true,
-        dead_code: true,
-        verbose: false,
-        show_copyright: true,
-        out_same_file: false,
-        max_line_length: 32 * 1024,
-        unsafe: false,
-        reserved_names: null,
-        defines: { },
-        codegen_options: {
-                ascii_only: false,
-                beautify: false,
-                indent_level: 4,
-                indent_start: 0,
-                quote_keys: false,
-                space_colon: false
-        },
-        output: true            // stdout
-};
-
-var args = jsp.slice(process.argv, 2);
-var filename;
-
-out: while (args.length > 0) {
-        var v = args.shift();
-        switch (v) {
-            case "-b":
-            case "--beautify":
-                options.codegen_options.beautify = true;
-                break;
-            case "-i":
-            case "--indent":
-                options.codegen_options.indent_level = args.shift();
-                break;
-            case "-q":
-            case "--quote-keys":
-                options.codegen_options.quote_keys = true;
-                break;
-            case "-mt":
-            case "--mangle-toplevel":
-                options.mangle_toplevel = true;
-                break;
-            case "--no-mangle":
-            case "-nm":
-                options.mangle = false;
-                break;
-            case "--no-squeeze":
-            case "-ns":
-                options.squeeze = false;
-                break;
-            case "--no-seqs":
-                options.make_seqs = false;
-                break;
-            case "--no-dead-code":
-                options.dead_code = false;
-                break;
-            case "--no-copyright":
-            case "-nc":
-                options.show_copyright = false;
-                break;
-            case "-o":
-            case "--output":
-                options.output = args.shift();
-                break;
-            case "--overwrite":
-                options.out_same_file = true;
-                break;
-            case "-v":
-            case "--verbose":
-                options.verbose = true;
-                break;
-            case "--ast":
-                options.ast = true;
-                break;
-            case "--unsafe":
-                options.unsafe = true;
-                break;
-            case "--max-line-len":
-                options.max_line_length = parseInt(args.shift(), 10);
-                break;
-            case "--reserved-names":
-                options.reserved_names = args.shift().split(",");
-                break;
-            case "-d":
-            case "--define":
-                 var defarg = args.shift();
-                 try {
-                     var defsym = function(sym) {
-                             // KEYWORDS_ATOM doesn't include NaN or Infinity - should we check
-                             // for them too ?? We don't check reserved words and the like as the
-                             // define values are only substituted AFTER parsing
-                             if (jsp.KEYWORDS_ATOM.hasOwnProperty(sym)) {
-                                 throw "Don't define values for inbuilt constant '"+sym+"'";
-                             }
-                             return sym;
-                         },
-                         defval = function(v) {
-                             if (v.match(/^"(.*)"$/) || v.match(/^'(.*)'$/)) {
-                                 return [ "string", RegExp.$1 ];
-                             }
-                             else if (!isNaN(parseFloat(v))) {
-                                 return [ "num", parseFloat(v) ];
-                             }
-                             else if (v.match(/^[a-z\$_][a-z\$_0-9]*$/i)) {
-                                 return [ "name", v ];
-                             }
-                             else if (!v.match(/"/)) {
-                                 return [ "string", v ];
-                             }
-                             else if (!v.match(/'/)) {
-                                 return [ "string", v ];
-                             }
-                             throw "Can't understand the specified value: "+v;
-                         };
-                     if (defarg.match(/^([a-z_\$][a-z_\$0-9]*)(=(.*))?$/i)) {
-                         var sym = defsym(RegExp.$1),
-                             val = RegExp.$2 ? defval(RegExp.$2.substr(1)) : [ 'name', 'true' ];
-                         options.defines[sym] = val;
-                     }
-                     else {
-                         throw "The --define option expects SYMBOL[=value]";
-                     }
-                 } catch(ex) {
-                     sys.print("ERROR: In option --define "+defarg+"\n"+ex+"\n");
-                     process.exit(1);
-                 }
-                 break;
-            case "--define-from-module":
-                var defmodarg = args.shift(),
-                    defmodule = require(defmodarg),
-                    sym,
-                    val;
-                for (sym in defmodule) {
-                    if (defmodule.hasOwnProperty(sym)) {
-                        options.defines[sym] = function(val) {
-                            if (typeof val == "string")
-                                return [ "string", val ];
-                            if (typeof val == "number")
-                                return [ "num", val ];
-                            if (val === true)
-                                return [ 'name', 'true' ];
-                            if (val === false)
-                                return [ 'name', 'false' ];
-                            if (val === null)
-                                return [ 'name', 'null' ];
-                            if (val === undefined)
-                                return [ 'name', 'undefined' ];
-                            sys.print("ERROR: In option --define-from-module "+defmodarg+"\n");
-                            sys.print("ERROR: Unknown object type for: "+sym+"="+val+"\n");
-                            process.exit(1);
-                            return null;
-                        }(defmodule[sym]);
-                    }
-                }
-                break;
-            case "--ascii":
-                options.codegen_options.ascii_only = true;
-                break;
-            default:
-                filename = v;
-                break out;
-        }
-}
-
-if (options.verbose) {
-        pro.set_logger(function(msg){
-                sys.debug(msg);
-        });
-}
-
-jsp.set_logger(function(msg){
-        sys.debug(msg);
-});
-
-if (filename) {
-        fs.readFile(filename, "utf8", function(err, text){
-                if (err) throw err;
-                output(squeeze_it(text));
-        });
-} else {
-        var stdin = process.openStdin();
-        stdin.setEncoding("utf8");
-        var text = "";
-        stdin.on("data", function(chunk){
-                text += chunk;
-        });
-        stdin.on("end", function() {
-                output(squeeze_it(text));
-        });
-}
-
-function output(text) {
-        var out;
-        if (options.out_same_file && filename)
-                options.output = filename;
-        if (options.output === true) {
-                out = process.stdout;
-        } else {
-                out = fs.createWriteStream(options.output, {
-                        flags: "w",
-                        encoding: "utf8",
-                        mode: 0644
-                });
-        }
-        out.write(text);
-        if (options.output !== true) {
-                out.end();
-        }
-};
-
-// --------- main ends here.
-
-function show_copyright(comments) {
-        var ret = "";
-        for (var i = 0; i < comments.length; ++i) {
-                var c = comments[i];
-                if (c.type == "comment1") {
-                        ret += "//" + c.value + "\n";
-                } else {
-                        ret += "/*" + c.value + "*/";
-                }
-        }
-        return ret;
-};
-
-function squeeze_it(code) {
-        var result = "";
-        if (options.show_copyright) {
-                var tok = jsp.tokenizer(code), c;
-                c = tok();
-                result += show_copyright(c.comments_before);
-        }
-        try {
-                var ast = time_it("parse", function(){ return jsp.parse(code); });
-                if (options.mangle) ast = time_it("mangle", function(){
-                        return pro.ast_mangle(ast, {
-                                toplevel: options.mangle_toplevel,
-                                defines: options.defines,
-                                except: options.reserved_names
-                        });
-                });
-                if (options.squeeze) ast = time_it("squeeze", function(){
-                        ast = pro.ast_squeeze(ast, {
-                                make_seqs  : options.make_seqs,
-                                dead_code  : options.dead_code,
-                                keep_comps : !options.unsafe
-                        });
-                        if (options.unsafe)
-                                ast = pro.ast_squeeze_more(ast);
-                        return ast;
-                });
-                if (options.ast)
-                        return sys.inspect(ast, null, null);
-                result += time_it("generate", function(){ return pro.gen_code(ast, options.codegen_options) });
-                if (!options.codegen_options.beautify && options.max_line_length) {
-                        result = time_it("split", function(){ return pro.split_lines(result, options.max_line_length) });
-                }
-                return result;
-        } catch(ex) {
-                sys.debug(ex.stack);
-                sys.debug(sys.inspect(ex));
-                sys.debug(JSON.stringify(ex));
-        }
-};
-
-function time_it(name, cont) {
-        if (!options.verbose)
-                return cont();
-        var t1 = new Date().getTime();
-        try { return cont(); }
-        finally { sys.debug("// " + name + ": " + ((new Date().getTime() - t1) / 1000).toFixed(3) + " sec."); }
-};