Merge branch 'master' into position-notification

111 files changed, 1686 insertions, 11099 deletions

diff --git a/.gitignore b/.gitignore
index dc1bdf6c1..23d9dd000 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,3 @@
-build/dist
-build/size
-build/build/.sizecache.json
 dist
 node_modules
 docs
diff --git a/build/build.xml b/build/build.xml
deleted file mode 100644
index ddaa5b86d..000000000
--- a/build/build.xml
+++ /dev/null
@@ -1,373 +0,0 @@
-<?xml version="1.0" encoding="iso-8859-1"?>
-
-<!--
-	jQuery UI Release!
-
-	Call task called 'deploy-release' to build a full release.
-	The release built will be stored on 'dist' dir.
-
--->
-
-<project name="jquery-ui" default="deploy-release" basedir=".">
-
-	<taskdef resource="net/sf/antcontrib/antcontrib.properties">
-		<classpath>
-			<pathelement location="build/ant-contrib-0.6.jar"/>
-		</classpath>
-	</taskdef>
-
-	<property file="ant.properties" />
-
-	<loadfile failonerror="no" srcFile="../version.txt" property="release.version">
-		<filterchain><striplinebreaks/></filterchain>
-	</loadfile>
-	<property name="release.filename" value="jquery-ui-${release.version}" />
-
-	<property name="dist.dir" value="dist/${release.filename}/" />
-	<property name="cdndist.dir" value="dist/${release.filename}-cdn" />
-	<property name="build.dir" value="build" />
-	<property name="ui.dir" value="../" />
-	<property name="src.dir" value="${ui.dir}/ui/" />
-	<property name="theme.dir" value="${ui.dir}/themes/base/" />
-	<property name="docs.dir" value="${dist.dir}/docs/" />
-	<property name="min.dir" value="${dist.dir}/ui/minified" />
-	<property name="size.dir" value="size" />
-
-	<property name="concatenated" value="jquery-ui" />
-	<property name="concatenated.i18n" value="jquery-ui-i18n" />
-
-	<property name="core.files" value="jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.effects.core.js" />
-	<property name="core.files.min" value="jquery.ui.core.min.js, jquery.ui.widget.min.js, jquery.ui.mouse.min.js, jquery.ui.draggable.min.js, jquery.ui.droppable.min.js, jquery.ui.resizable.min.js, jquery.ui.selectable.min.js, jquery.ui.sortable.min.js, jquery.effects.core.min.js" />
-
-	<property description="YUI Compressor" name="yuicompressor-jar" value="${build.dir}/yuicompressor-2.4.2.jar" />
-
-	<target name="deploy-release" depends="clean, docs-download, copy, minify, replace-version, prepend-header, zip" description="Release builder">
-	</target>
-
-	<target name="replace-version">
-		<replaceregexp match="@VERSION" replace="${release.version}" flags="g" byline="true">
-			<fileset dir="${dist.dir}/ui/" includes="*.js"/>
-			<fileset dir="${dist.dir}/ui/minified/" includes="*.js"/>
-			<fileset dir="${dist.dir}/themes/" includes="**/*.css"/>
-		</replaceregexp>
-		<echo message="Replaced all @VERSION to ${release.version}." />
-	</target>
-
-	<target name="prepend-header">
-		<copy todir="${dist.dir}/headers/">
-			<fileset dir="${dist.dir}/themes/base" includes="*.css" />
-		</copy>
-		<replaceregexp match="^(\/\*.*?\*\/\s).+" replace="\1" flags="s">
-			<fileset dir="${dist.dir}/headers/" includes="*.css"/>
-		</replaceregexp>
-		<for param="file">
-			<path><fileset dir="${dist.dir}/themes/base/minified" includes="*.css" /></path>
-			<sequential>
-				<propertyregex override="yes" property="target" input="@{file}" regexp=".*[\\/](.+)\.min\.css$" replace="\1"/>
-				<concat destfile="${dist.dir}/ui-headered/${target}.min.css">
-					<header file="${dist.dir}/headers/${target}.css" />
-					<fileset file="@{file}" />
-				</concat>
-			</sequential>
-		</for>
-		<copy todir="${dist.dir}/themes/base/minified" overwrite="true">
-			<fileset dir="${dist.dir}/ui-headered/" includes="*.css" />
-		</copy>
-
-		<delete dir="${dist.dir}/headers/" />
-		<delete dir="${dist.dir}/ui-headered/" />
-	</target>
-
-	<target description="Zip the package" name="zip">
-		<zip destfile="${dist.dir}/../${release.filename}.zip">
-			<zipfileset dir="dist/" />
-		</zip>
-	</target>
-
-	<target name="concatenate">
-		<echo message="Building concatenated" />
-		<mkdir dir="${dist.dir}/ui/" />
-		<delete file="${dist.dir}/ui/${concatenated}.js" />
-
-		<concat destfile="${dist.dir}/ui/${concatenated}.js">
-			<filelist dir="${src.dir}/" files="${core.files}" />
-			<fileset dir="${src.dir}/" includes="jquery.ui.*.js, jquery.effects.*.js" excludes="${core.files}" />
-		</concat>
-		<echo message="Concatenated built." />
-
-		<concat destfile="${dist.dir}/themes/base/${concatenated}.css">
-			<fileset dir="${theme.dir}/" includes="jquery.ui.core.css" />
-			<fileset dir="${theme.dir}/" includes="jquery.ui.*.css" excludes="jquery.ui.all.css, jquery.ui.core.css, jquery.ui.base.css, jquery.ui.theme.css" />
-			<fileset dir="${theme.dir}/" includes="jquery.ui.theme.css" />
-		</concat>
-		<echo message="Concatenated theme." />
-
-		<mkdir dir="${dist.dir}/ui/i18n/" />
-		<delete file="${dist.dir}/ui/i18n/${concatenated.i18n}.js" />
-
-		<concat destfile="${dist.dir}/ui/i18n/${concatenated.i18n}.js" encoding="utf-8">
-			<fileset dir="${src.dir}/i18n/" includes="jquery.ui.*.js" />
-		</concat>
-		<echo message="Concatenated i18n built." />
-	</target>
-
-	<target name="minify" depends="concatenate" description="Remove all comments and whitespace, no compression, great in combination with GZip">
-		<echo message="Building minified" />
-		<mkdir dir="${min.dir}" />
-		<mkdir dir="${min.dir}/i18n/" />
-		<mkdir dir="${dist.dir}/themes/base/minified" />
-		<parallel threadsperprocessor="1">
-			<apply executable="build/minify-js.sh">
-				<fileset dir="${dist.dir}/ui" includes="**.js" />
-				<srcfile />
-				<mapper type="glob" from="*.js" to="${min.dir}/*.min.js" />
-				<targetfile/>
-			</apply>
-			<apply executable="build/minify-js.sh">
-				<fileset dir="${dist.dir}/ui/i18n" includes="**.js" />
-				<srcfile />
-				<mapper type="glob" from="*.js" to="${min.dir}/i18n/*.min.js" />
-				<targetfile/>
-			</apply>
-			<apply executable="java" parallel="false">
-				<fileset dir="${dist.dir}/themes/base" includes="*.css" />
-				<arg line="-jar" />
-				<arg path="${yuicompressor-jar}" />
-				<arg line="--charset utf-8" />
-				<arg line="-v" />
-				<srcfile />
-				<arg line="-o" />
-				<mapper type="glob" from="*.css" to="${dist.dir}/themes/base/minified/*.min.css" />
-				<targetfile/>
-			</apply>
-		</parallel>
-
-		<replaceregexp match=".css" replace=".min.css" flags="g">
-			<fileset dir="${dist.dir}/themes/base/minified/">
-				<include name="*.base.min.css"/>
-				<include name="*.all.min.css"/>
-			</fileset>
-		</replaceregexp>
-
-		<!-- make a copy of all theme images to ensure that relative paths in minified css files work -->
-		<copy todir="${dist.dir}/themes/base/minified/images" >
-			<fileset dir="${ui.dir}/themes/base/images" />
-		</copy>
-
-		<!-- make a copy of the minified files for use in tests -->
-		<copy todir="dist" file="${min.dir}/jquery-ui.min.js" />
-		<copy todir="dist/theme" file="${dist.dir}/themes/base/minified/jquery-ui.min.css" />
-		<copy todir="dist/theme/images" >
-			<fileset dir="${ui.dir}/themes/base/images" />
-		</copy>
-
-		<echo message="Minified ui/ built." />
-	</target>
-
-	<target description="Copy needed folders" name="copy">
-		<echo message="Copying files" />
-		<mkdir dir="${dist.dir}" />
-
-		<copy overwrite="true" todir="${dist.dir}/">
-			<fileset dir="${ui.dir}/" includes="jquery-*.js" />
-		</copy>
-
-		<copy overwrite="true" todir="${dist.dir}/ui/">
-			<fileset dir="${src.dir}/" includes="jquery.ui.*.js, jquery.effects.*.js" />
-		</copy>
-
-		<copy overwrite="true" todir="${dist.dir}/ui/i18n/" >
-			<fileset dir="${src.dir}/i18n/" />
-		</copy>
-
-		<copy overwrite="true" todir="${dist.dir}/">
-			<fileset dir="${ui.dir}/" includes="*.txt" />
-		</copy>
-
-		<copy overwrite="true" todir="${dist.dir}/demos/" >
-			<fileset dir="${ui.dir}/demos/" />
-		</copy>
-
-		<copy overwrite="true" todir="${dist.dir}/external/" >
-			<fileset dir="${ui.dir}/external/" />
-		</copy>
-
-		<copy overwrite="true" todir="${dist.dir}/tests/" >
-			<fileset dir="${ui.dir}/tests/" />
-		</copy>
-
-		<copy overwrite="true" todir="${dist.dir}/themes/" >
-			<fileset dir="${ui.dir}/themes/" />
-		</copy>
-		<echo message="Files copied." />
-	</target>
-
-	 <target name="clean">
-		<delete dir="dist" />
-		</target>
-
-	<target name="docs-download">
-		<mkdir dir="${docs.dir}" />
-		<property name="url" value="http://docs.jquery.com/action/render/UI/API/${release.version}/" />
-		<parallel threadcount="8">
-			<get src="${url}Draggable" dest="${docs.dir}draggable.html" />
-			<get src="${url}Droppable" dest="${docs.dir}droppable.html" />
-			<get src="${url}Resizable" dest="${docs.dir}resizable.html" />
-			<get src="${url}Selectable" dest="${docs.dir}selectable.html" />
-			<get src="${url}Sortable" dest="${docs.dir}sortable.html" />
-
-			<get src="${url}Accordion" dest="${docs.dir}accordion.html" />
-			<get src="${url}Autocomplete" dest="${docs.dir}autocomplete.html" />
-			<get src="${url}Button" dest="${docs.dir}button.html" />
-			<get src="${url}Datepicker" dest="${docs.dir}datepicker.html" />
-			<get src="${url}Dialog" dest="${docs.dir}dialog.html" />
-			<get src="${url}Menu" dest="${docs.dir}menu.html" />
-			<get src="${url}Progressbar" dest="${docs.dir}progressbar.html" />
-			<get src="${url}Slider" dest="${docs.dir}slider.html" />
-			<get src="${url}Spinner" dest="${docs.dir}spinner.html" />
-			<get src="${url}Tooltip" dest="${docs.dir}tooltip.html" />
-			<get src="${url}Tabs" dest="${docs.dir}tabs.html" />
-
-			<get src="${url}Position" dest="${docs.dir}position.html" />
-
-			<get src="http://docs.jquery.com/action/render/UI/Effects/animate" dest="${docs.dir}animate.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/addClass" dest="${docs.dir}addClass.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/effect" dest="${docs.dir}effect.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/hide" dest="${docs.dir}hide.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/removeClass" dest="${docs.dir}removeClass.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/show" dest="${docs.dir}show.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/switchClass" dest="${docs.dir}switchClass.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/toggle" dest="${docs.dir}toggle.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/toggleClass" dest="${docs.dir}toggleClass.html" />
-
-
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Blind" dest="${docs.dir}effect-blind.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Clip" dest="${docs.dir}effect-clip.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Drop" dest="${docs.dir}effect-drop.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Explode" dest="${docs.dir}effect-explode.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Fade" dest="${docs.dir}effect-fade.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Fold" dest="${docs.dir}effect-fold.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Puff" dest="${docs.dir}effect-puff.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Slide" dest="${docs.dir}effect-slide.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Scale" dest="${docs.dir}effect-scale.html" />
-
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Bounce" dest="${docs.dir}effect-bounce.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Highlight" dest="${docs.dir}effect-highlight.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Pulsate" dest="${docs.dir}effect-pulsate.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Shake" dest="${docs.dir}effect-shake.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Size" dest="${docs.dir}effect-size.html" />
-			<get src="http://docs.jquery.com/action/render/UI/Effects/Transfer" dest="${docs.dir}effect-transfer.html" />
-		</parallel>
-	</target>
-
-	<target name="themes-download">
-		<!-- to create/update query strings for the theme-file, execute this in Firebug on /download page:
-		$("select option[value!=none]").map(function() { $(this).parent().val(this.value).change(); return $(this).parents("form").serialize(); }).get().join(",");
-		-->
-		<loadfile srcFile="themes" property="urls" />
-		<property name="zip" value="${dist.dir}themes/tmp.zip" />
-		<mkdir dir="${dist.dir}themes" />
-		<for list="${urls}" param="url">
-			<sequential>
-				<get src="http://ui-dev.jquery.com/download/?@{url}" dest="${zip}" />
-				<unzip src="${zip}" dest="${dist.dir}themes/">
-						<patternset>
-								<include name="development-bundle/themes/**"/>
-								<exclude name="development-bundle/themes/base/**"/>
-						</patternset>
-					<mapper type="glob" from="development-bundle/themes/*" to="*" />
-				</unzip>
-				<delete file="${zip}" />
-			</sequential>
-		</for>
-		<move todir="${dist.dir}themes/">
-			<fileset dir="${dist.dir}themes/" />
-			<mapper>
-				<mapper type="regexp" from="(.*)jquery-ui-.*custom.css" to="\1jquery-ui.css" />
-			</mapper>
-		</move>
-		<copy todir="dist/jquery-ui-themes-${release.version}">
-			<fileset dir="${dist.dir}/" includes="AUTHORS.txt,GPL-LICENSE.txt,MIT-LICENSE.txt,version.txt,themes/**" />
-		</copy>
-		<zip destfile="${dist.dir}/../jquery-ui-themes-${release.version}.zip">
-			<zipfileset dir="dist/" includes="jquery-ui-themes-${release.version}/" />
-		</zip>
-	</target>
-
-	<target name="whitespace">
-		<replaceregexp match="[\t ]+$" replace="" flags="g" byline="true">
-			<fileset dir="${src.dir}" includes="*.js"/>
-			<fileset dir="${src.dir}/i18n/" includes="*.js"/>
-		</replaceregexp>
-		<echo message="All trailing spaces removed." />
-	</target>
-
-	<target name="size" depends="copy, minify, replace-version, prepend-header" description="Report sizes of files">
-		<echo message="Collecting files to size" />
-		<mkdir dir="${size.dir}" />
-		<copy todir="${size.dir}">
-			<fileset dir="${dist.dir}/ui" includes="*.js" />
-			<fileset dir="${dist.dir}/ui/i18n" includes="*.js" />
-			<fileset dir="${dist.dir}/ui/minified" includes="*.js" />
-			<fileset dir="${dist.dir}/ui/minified/i18n" includes="*.js" />
-			<fileset dir="${dist.dir}/themes/base" includes="*.css" />
-			<fileset dir="${dist.dir}/themes/base/minified" includes="*.css" />
-		</copy>
-		<echo message="GZipping Minified" />
-		<apply executable="gzip">
-			<fileset dir="${size.dir}" includes="*.min.js" />
-			<fileset dir="${size.dir}" includes="*.min.css" />
-			<arg value="-c" />
-			<srcfile />
-			<redirector>
-				<outputmapper id="out" type="glob" from="*" to="${size.dir}/*.gz"/>
-			</redirector>
-		</apply>
-		<echo message="Comparing file size with previous build" />
-		<exec executable="bash">
-			<arg value="-c" />
-			<arg value="wc -c ${size.dir}/* | `which node nodejs 2>/dev/null` build/sizer.js" />
-		</exec>
-		<delete dir="${size.dir}" />
-	</target>
-
-	<target name="cdn">
-		<delete dir="${cdndist.dir}" />
-		<mkdir dir="${cdndist.dir}" />
-		<copy todir="${cdndist.dir}">
-			<fileset dir=".." includes="AUTHORS.txt, GPL-LICENSE.txt, MIT-LICENSE.txt, version.txt" />
-		</copy>
-		<copy todir="${cdndist.dir}">
-			<fileset dir="${dist.dir}ui" includes="jquery-ui.js" />
-			<fileset dir="${dist.dir}ui/minified" includes="jquery-ui.min.js" />
-		</copy>
-		<copy todir="${cdndist.dir}/i18n">
-			<fileset dir="${dist.dir}ui/i18n" />
-			<fileset dir="${dist.dir}ui/minified/i18n" />
-		</copy>
-		<copy todir="${cdndist.dir}/themes">
-			<fileset dir="${dist.dir}themes" />
-		</copy>
-		<checksum>
-			<fileset dir="${cdndist.dir}" />
-		</checksum>
-		<for param="file">
-			<path><fileset dir="${cdndist.dir}" includes="**/" excludes="**/*.MD5" /></path>
-			<sequential>
-				<!-- @{file} is an absolute path, use that ugly regexes to make it relative -->
-				<propertyregex override="yes" property="relativepath" input="@{file}" regexp=".+?cdn[\\/](.+)$" replace="\1"/>
-				<propertyregex override="yes" property="relativepath" input="${relativepath}" regexp="\\" replace="/" global="true" />
-				<concat destfile="${cdndist.dir}/MANIFEST" append="yes">${relativepath} </concat>
-				<concat destfile="${cdndist.dir}/MANIFEST" append="yes"><file file="@{file}.MD5" /></concat>
-			</sequential>
-		</for>
-		<delete dir="${cdndist.dir}" includes="**/*.MD5" />
-		<zip destfile="${dist.dir}/../${release.filename}-googlecdn.zip">
-			<zipfileset dir="dist/" includes="${release.filename}-cdn/" />
-		</zip>
-		<zip destfile="${dist.dir}/../${release.filename}-mscdn.zip">
-			<zipfileset dir="dist/${release.filename}-cdn/" />
-		</zip>
-		</target>
-
-</project>
diff --git a/build/build/ant-contrib-0.6.jar b/build/build/ant-contrib-0.6.jar
deleted file mode 100644
index db90b0aae..000000000
--- a/build/build/ant-contrib-0.6.jar
+++ /dev/null
diff --git a/build/build/lib/jslint.js b/build/build/lib/jslint.js
deleted file mode 100644
index f563292bf..000000000
--- a/build/build/lib/jslint.js
+++ /dev/null
@@ -1,5504 +0,0 @@
-// jslint.js
-// 2010-02-20
-
-/*
-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.
-*/
-
-/*
-    JSLINT is a global function. It takes two parameters.
-
-        var myResult = JSLINT(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 HTML text, or a Konfabulator text.
-
-    The second parameter is an optional object of options which control the
-    operation of JSLINT. Most of the options are booleans: They are all are
-    optional and have a default value of false.
-
-    If it checks out, JSLINT returns true. Otherwise, it returns false.
-
-    If false, you can inspect JSLINT.errors to find out the problems.
-    JSLINT.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
-    JSLINT.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 = JSLINT.report(limited);
-
-    If limited is true, then the report will be limited to only errors.
-
-    You can request a data structure which contains JSLint's results.
-
-        var myData = JSLINT.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
-        },
-        unuseds: [
-            {
-                name: STRING,
-                line: NUMBER
-            }
-        ],
-        implieds: [
-            {
-                name: STRING,
-                line: NUMBER
-            }
-        ],
-        urls: [
-            STRING
-        ],
-        json: BOOLEAN
-    }
-
-    Empty arrays will not be included.
-
-*/
-
-/*jslint
-    evil: true, nomen: false, onevar: false, regexp: false, strict: true
-*/
-
-/*members "\b", "\t", "\n", "\f", "\r", "!=", "!==", "\"", "%",
-    "(begin)", "(breakage)", "(context)", "(error)", "(global)",
-    "(identifier)", "(last)", "(line)", "(loopage)", "(name)", "(onevar)",
-    "(params)", "(scope)", "(verb)", "*", "+", "++", "-", "--", "\/",
-    "<", "<=", "==", "===", ">", ">=", ADSAFE, Array, Boolean,
-    COM, Canvas, CustomAnimation, Date, Debug, E, Error, EvalError,
-    FadeAnimation, Flash, FormField, Frame, Function, HotKey, Image, JSON,
-    LN10, LN2, LOG10E, LOG2E, MAX_VALUE, MIN_VALUE, Math, MenuItem,
-    MoveAnimation, NEGATIVE_INFINITY, Number, Object, Option, PI,
-    POSITIVE_INFINITY, Point, RangeError, Rectangle, ReferenceError, RegExp,
-    ResizeAnimation, RotateAnimation, SQRT1_2, SQRT2, ScrollBar, String,
-    Style, SyntaxError, System, Text, TextArea, Timer, TypeError, URIError,
-    URL, Web, Window, XMLDOM, XMLHttpRequest, "\\", a, abbr, acronym,
-    addEventListener, address, adsafe, alert, aliceblue, animator,
-    antiquewhite, appleScript, applet, apply, approved, aqua, aquamarine,
-    area, arguments, arity, autocomplete, azure, b, background,
-    "background-attachment", "background-color", "background-image",
-    "background-position", "background-repeat", base, bdo, beep, beige, big,
-    bisque, bitwise, black, blanchedalmond, block, blockquote, blue,
-    blueviolet, blur, body, border, "border-bottom", "border-bottom-color",
-    "border-bottom-style", "border-bottom-width", "border-collapse",
-    "border-color", "border-left", "border-left-color", "border-left-style",
-    "border-left-width", "border-right", "border-right-color",
-    "border-right-style", "border-right-width", "border-spacing",
-    "border-style", "border-top", "border-top-color", "border-top-style",
-    "border-top-width", "border-width", bottom, br, brown, browser,
-    burlywood, button, bytesToUIString, c, cadetblue, call, callee, caller,
-    canvas, cap, caption, "caption-side", cases, center, charAt, charCodeAt,
-    character, chartreuse, chocolate, chooseColor, chooseFile, chooseFolder,
-    cite, clear, clearInterval, clearTimeout, clip, close, closeWidget,
-    closed, closure, cm, code, col, colgroup, color, comment, condition,
-    confirm, console, constructor, content, convertPathToHFS,
-    convertPathToPlatform, coral, cornflowerblue, cornsilk,
-    "counter-increment", "counter-reset", create, crimson, css, cursor,
-    cyan, d, darkblue, darkcyan, darkgoldenrod, darkgray, darkgreen,
-    darkkhaki, darkmagenta, darkolivegreen, darkorange, darkorchid, darkred,
-    darksalmon, darkseagreen, darkslateblue, darkslategray, darkturquoise,
-    darkviolet, data, dd, debug, decodeURI, decodeURIComponent, deeppink,
-    deepskyblue, defaultStatus, defineClass, del, deserialize, devel, dfn,
-    dimension, dimgray, dir, direction, display, div, dl, document,
-    dodgerblue, dt, edition, else, em, embed, empty, "empty-cells",
-    encodeURI, encodeURIComponent, entityify, eqeqeq, errors, escape, eval,
-    event, evidence, evil, ex, exception, exec, exps, fieldset, filesystem,
-    firebrick, first, float, floor, floralwhite, focus, focusWidget, font,
-    "font-face", "font-family", "font-size", "font-size-adjust",
-    "font-stretch", "font-style", "font-variant", "font-weight",
-    forestgreen, forin, form, fragment, frame, frames, frameset, from,
-    fromCharCode, fuchsia, fud, funct, function, functions, g, gainsboro,
-    gc, getComputedStyle, ghostwhite, global, globals, gold, goldenrod,
-    gray, green, greenyellow, h1, h2, h3, h4, h5, h6, hasOwnProperty, head,
-    height, help, history, honeydew, hotpink, hr, html, i, iTunes, id,
-    identifier, iframe, img, immed, implieds, in, include, indent, indexOf,
-    indianred, indigo, init, input, ins, isAlpha, isApplicationRunning,
-    isDigit, isFinite, isNaN, ivory, join, jslint, json, kbd, khaki,
-    konfabulatorVersion, label, labelled, lang, last, lavender,
-    lavenderblush, lawngreen, laxbreak, lbp, led, left, legend,
-    lemonchiffon, length, "letter-spacing", li, lib, lightblue, lightcoral,
-    lightcyan, lightgoldenrodyellow, lightgreen, lightpink, lightsalmon,
-    lightseagreen, lightskyblue, lightslategray, lightsteelblue,
-    lightyellow, lime, limegreen, line, "line-height", linen, link,
-    "list-style", "list-style-image", "list-style-position",
-    "list-style-type", load, loadClass, location, log, m, magenta, map,
-    margin, "margin-bottom", "margin-left", "margin-right", "margin-top",
-    "marker-offset", maroon, match, "max-height", "max-width", maxerr, maxlen,
-    md5, media, mediumaquamarine, mediumblue, mediumorchid, mediumpurple,
-    mediumseagreen, mediumslateblue, mediumspringgreen, mediumturquoise,
-    mediumvioletred, member, menu, message, meta, midnightblue,
-    "min-height", "min-width", mintcream, mistyrose, mm, moccasin, moveBy,
-    moveTo, name, navajowhite, navigator, navy, new, newcap, noframes,
-    nomen, noscript, nud, object, ol, oldlace, olive, olivedrab, on,
-    onbeforeunload, onblur, onerror, onevar, onfocus, onload, onresize,
-    onunload, opacity, open, openURL, opener, opera, optgroup, option,
-    orange, orangered, orchid, outer, outline, "outline-color",
-    "outline-style", "outline-width", overflow, "overflow-x", "overflow-y",
-    p, padding, "padding-bottom", "padding-left", "padding-right",
-    "padding-top", page, "page-break-after", "page-break-before",
-    palegoldenrod, palegreen, paleturquoise, palevioletred, papayawhip,
-    param, parent, parseFloat, parseInt, passfail, pc, peachpuff, peru,
-    pink, play, plum, plusplus, pop, popupMenu, position, powderblue, pre,
-    predef, preferenceGroups, preferences, print, prompt, prototype, pt,
-    purple, push, px, q, quit, quotes, random, range, raw, reach, readFile,
-    readUrl, reason, red, regexp, reloadWidget, removeEventListener,
-    replace, report, reserved, resizeBy, resizeTo, resolvePath,
-    resumeUpdates, rhino, right, rosybrown, royalblue, runCommand,
-    runCommandInBg, saddlebrown, safe, salmon, samp, sandybrown, saveAs,
-    savePreferences, screen, script, scroll, scrollBy, scrollTo, seagreen,
-    seal, search, seashell, select, serialize, setInterval, setTimeout,
-    shift, showWidgetPreferences, sidebar, sienna, silver, skyblue,
-    slateblue, slategray, sleep, slice, small, snow, sort, span, spawn,
-    speak, split, springgreen, src, status, steelblue, strict, strong,
-    style, styleproperty, sub, substr, sup, supplant, suppressUpdates, sync,
-    system, table, "table-layout", tan, tbody, td, teal, tellWidget, test,
-    "text-align", "text-decoration", "text-indent", "text-shadow",
-    "text-transform", textarea, tfoot, th, thead, thistle, title,
-    toLowerCase, toString, toUpperCase, toint32, token, tomato, top, tr, tt,
-    turquoise, type, u, ul, undef, unescape, "unicode-bidi", unused,
-    unwatch, updateNow, urls, value, valueOf, var, version,
-    "vertical-align", violet, visibility, watch, wheat, white,
-    "white-space", whitesmoke, widget, width, "word-spacing", "word-wrap",
-    yahooCheckLogin, yahooLogin, yahooLogout, yellow, yellowgreen,
-    "z-index"
-*/
-
-
-// We build the application inside a function so that we produce only a single
-// global variable. The function will be invoked, its return value is the JSLINT
-// application itself.
-
-"use strict";
-
-var JSLINT = (function () {
-    var adsafe_id,      // The widget's ADsafe id.
-        adsafe_may,     // The widget may load approved scripts.
-        adsafe_went,    // ADSAFE.go has been called.
-        anonname,       // The guessed name for anonymous functions.
-        approved,       // ADsafe approved urls.
-
-        atrule = {
-            media      : true,
-            'font-face': true,
-            page       : true
-        },
-
-// 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 members that should not be permitted in the safe subset.
-
-        banned = {              // the member names that ADsafe prohibits.
-            'arguments'     : true,
-            callee          : true,
-            caller          : true,
-            constructor     : true,
-            'eval'          : true,
-            prototype       : true,
-            unwatch         : true,
-            valueOf         : true,
-            watch           : true
-        },
-
-
-// These are the JSLint boolean options.
-
-        boolOptions = {
-            adsafe     : true, // if ADsafe should be enforced
-            bitwise    : true, // if bitwise operators should not be allowed
-            browser    : true, // if the standard browser globals should be predefined
-            cap        : true, // if upper case HTML should be allowed
-            css        : true, // if CSS workarounds should be tolerated
-            debug      : true, // if debugger statements should be allowed
-            devel      : true, // if logging should be allowed (console, alert, etc.)
-            eqeqeq     : true, // if === should be required
-            evil       : true, // if eval should be allowed
-            forin      : true, // if for in statements must filter
-            fragment   : true, // if HTML fragments should be allowed
-            immed      : true, // if immediate invocations must be wrapped in parens
-            laxbreak   : true, // if line breaks should not be checked
-            newcap     : true, // if constructor names must be capitalized
-            nomen      : true, // if names should be checked
-            on         : true, // if HTML event handlers should be allowed
-            onevar     : true, // if only one var statement per function should be allowed
-            passfail   : true, // if the scan should stop on first error
-            plusplus   : true, // if increment/decrement should not be allowed
-            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
-            safe       : true, // if use of some browser features should be restricted
-            sidebar    : true, // if the System object should be predefined
-            strict     : true, // require the "use strict"; pragma
-            sub        : true, // if all forms of subscript notation are tolerated
-            white      : true, // if strict whitespace rules apply
-            widget     : true  // if the Yahoo Widgets globals should be predefined
-        },
-
-// browser contains a set of global names which are commonly provided by a
-// web browser environment.
-
-        browser = {
-            addEventListener: false,
-            blur            : false,
-            clearInterval   : false,
-            clearTimeout    : false,
-            close           : false,
-            closed          : false,
-            defaultStatus   : false,
-            document        : false,
-            event           : false,
-            focus           : false,
-            frames          : false,
-            getComputedStyle: false,
-            history         : false,
-            Image           : false,
-            length          : 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,
-            opener          : false,
-            Option          : false,
-            parent          : false,
-            print           : false,
-            removeEventListener: false,
-            resizeBy        : false,
-            resizeTo        : false,
-            screen          : false,
-            scroll          : false,
-            scrollBy        : false,
-            scrollTo        : false,
-            setInterval     : false,
-            setTimeout      : false,
-            status          : false,
-            top             : false,
-            XMLHttpRequest  : false
-        },
-
-        cssAttributeData,
-        cssAny,
-
-        cssColorData = {
-            "aliceblue"             : true,
-            "antiquewhite"          : true,
-            "aqua"                  : true,
-            "aquamarine"            : true,
-            "azure"                 : true,
-            "beige"                 : true,
-            "bisque"                : true,
-            "black"                 : true,
-            "blanchedalmond"        : true,
-            "blue"                  : true,
-            "blueviolet"            : true,
-            "brown"                 : true,
-            "burlywood"             : true,
-            "cadetblue"             : true,
-            "chartreuse"            : true,
-            "chocolate"             : true,
-            "coral"                 : true,
-            "cornflowerblue"        : true,
-            "cornsilk"              : true,
-            "crimson"               : true,
-            "cyan"                  : true,
-            "darkblue"              : true,
-            "darkcyan"              : true,
-            "darkgoldenrod"         : true,
-            "darkgray"              : true,
-            "darkgreen"             : true,
-            "darkkhaki"             : true,
-            "darkmagenta"           : true,
-            "darkolivegreen"        : true,
-            "darkorange"            : true,
-            "darkorchid"            : true,
-            "darkred"               : true,
-            "darksalmon"            : true,
-            "darkseagreen"          : true,
-            "darkslateblue"         : true,
-            "darkslategray"         : true,
-            "darkturquoise"         : true,
-            "darkviolet"            : true,
-            "deeppink"              : true,
-            "deepskyblue"           : true,
-            "dimgray"               : true,
-            "dodgerblue"            : true,
-            "firebrick"             : true,
-            "floralwhite"           : true,
-            "forestgreen"           : true,
-            "fuchsia"               : true,
-            "gainsboro"             : true,
-            "ghostwhite"            : true,
-            "gold"                  : true,
-            "goldenrod"             : true,
-            "gray"                  : true,
-            "green"                 : true,
-            "greenyellow"           : true,
-            "honeydew"              : true,
-            "hotpink"               : true,
-            "indianred"             : true,
-            "indigo"                : true,
-            "ivory"                 : true,
-            "khaki"                 : true,
-            "lavender"              : true,
-            "lavenderblush"         : true,
-            "lawngreen"             : true,
-            "lemonchiffon"          : true,
-            "lightblue"             : true,
-            "lightcoral"            : true,
-            "lightcyan"             : true,
-            "lightgoldenrodyellow"  : true,
-            "lightgreen"            : true,
-            "lightpink"             : true,
-            "lightsalmon"           : true,
-            "lightseagreen"         : true,
-            "lightskyblue"          : true,
-            "lightslategray"        : true,
-            "lightsteelblue"        : true,
-            "lightyellow"           : true,
-            "lime"                  : true,
-            "limegreen"             : true,
-            "linen"                 : true,
-            "magenta"               : true,
-            "maroon"                : true,
-            "mediumaquamarine"      : true,
-            "mediumblue"            : true,
-            "mediumorchid"          : true,
-            "mediumpurple"          : true,
-            "mediumseagreen"        : true,
-            "mediumslateblue"       : true,
-            "mediumspringgreen"     : true,
-            "mediumturquoise"       : true,
-            "mediumvioletred"       : true,
-            "midnightblue"          : true,
-            "mintcream"             : true,
-            "mistyrose"             : true,
-            "moccasin"              : true,
-            "navajowhite"           : true,
-            "navy"                  : true,
-            "oldlace"               : true,
-            "olive"                 : true,
-            "olivedrab"             : true,
-            "orange"                : true,
-            "orangered"             : true,
-            "orchid"                : true,
-            "palegoldenrod"         : true,
-            "palegreen"             : true,
-            "paleturquoise"         : true,
-            "palevioletred"         : true,
-            "papayawhip"            : true,
-            "peachpuff"             : true,
-            "peru"                  : true,
-            "pink"                  : true,
-            "plum"                  : true,
-            "powderblue"            : true,
-            "purple"                : true,
-            "red"                   : true,
-            "rosybrown"             : true,
-            "royalblue"             : true,
-            "saddlebrown"           : true,
-            "salmon"                : true,
-            "sandybrown"            : true,
-            "seagreen"              : true,
-            "seashell"              : true,
-            "sienna"                : true,
-            "silver"                : true,
-            "skyblue"               : true,
-            "slateblue"             : true,
-            "slategray"             : true,
-            "snow"                  : true,
-            "springgreen"           : true,
-            "steelblue"             : true,
-            "tan"                   : true,
-            "teal"                  : true,
-            "thistle"               : true,
-            "tomato"                : true,
-            "turquoise"             : true,
-            "violet"                : true,
-            "wheat"                 : true,
-            "white"                 : true,
-            "whitesmoke"            : true,
-            "yellow"                : true,
-            "yellowgreen"           : true
-        },
-
-        cssBorderStyle,
-        cssBreak,
-
-        cssLengthData = {
-            '%': true,
-            'cm': true,
-            'em': true,
-            'ex': true,
-            'in': true,
-            'mm': true,
-            'pc': true,
-            'pt': true,
-            'px': true
-        },
-
-        cssOverflow,
-
-        devel = {
-            alert           : false,
-            confirm         : false,
-            console         : false,
-            Debug           : false,
-            opera           : false,
-            prompt          : 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
-        htmltag = {
-            a:        {},
-            abbr:     {},
-            acronym:  {},
-            address:  {},
-            applet:   {},
-            area:     {empty: true, parent: ' map '},
-            b:        {},
-            base:     {empty: true, parent: ' head '},
-            bdo:      {},
-            big:      {},
-            blockquote: {},
-            body:     {parent: ' html noframes '},
-            br:       {empty: true},
-            button:   {},
-            canvas:   {parent: ' body p div th td '},
-            caption:  {parent: ' table '},
-            center:   {},
-            cite:     {},
-            code:     {},
-            col:      {empty: true, parent: ' table colgroup '},
-            colgroup: {parent: ' table '},
-            dd:       {parent: ' dl '},
-            del:      {},
-            dfn:      {},
-            dir:      {},
-            div:      {},
-            dl:       {},
-            dt:       {parent: ' dl '},
-            em:       {},
-            embed:    {},
-            fieldset: {},
-            font:     {},
-            form:     {},
-            frame:    {empty: true, parent: ' frameset '},
-            frameset: {parent: ' html frameset '},
-            h1:       {},
-            h2:       {},
-            h3:       {},
-            h4:       {},
-            h5:       {},
-            h6:       {},
-            head:     {parent: ' html '},
-            html:     {parent: '*'},
-            hr:       {empty: true},
-            i:        {},
-            iframe:   {},
-            img:      {empty: true},
-            input:    {empty: true},
-            ins:      {},
-            kbd:      {},
-            label:    {},
-            legend:   {parent: ' fieldset '},
-            li:       {parent: ' dir menu ol ul '},
-            link:     {empty: true, parent: ' head '},
-            map:      {},
-            menu:     {},
-            meta:     {empty: true, parent: ' head noframes noscript '},
-            noframes: {parent: ' html body '},
-            noscript: {parent: ' body head noframes '},
-            object:   {},
-            ol:       {},
-            optgroup: {parent: ' select '},
-            option:   {parent: ' optgroup select '},
-            p:        {},
-            param:    {empty: true, parent: ' applet object '},
-            pre:      {},
-            q:        {},
-            samp:     {},
-            script:   {empty: true, parent: ' body div frame head iframe p pre span '},
-            select:   {},
-            small:    {},
-            span:     {},
-            strong:   {},
-            style:    {parent: ' head ', empty: true},
-            sub:      {},
-            sup:      {},
-            table:    {},
-            tbody:    {parent: ' table '},
-            td:       {parent: ' tr '},
-            textarea: {},
-            tfoot:    {parent: ' table '},
-            th:       {parent: ' tr '},
-            thead:    {parent: ' table '},
-            title:    {parent: ' head '},
-            tr:       {parent: ' table tbody thead tfoot '},
-            tt:       {},
-            u:        {},
-            ul:       {},
-            'var':    {}
-        },
-
-        ids,            // HTML ids
-        implied,        // Implied globals
-        inblock,
-        indent,
-        jsonmode,
-        lines,
-        lookahead,
-        member,
-        membersOnly,
-        nexttoken,
-        noreach,
-        option,
-        predefined,     // Global variables defined by option
-        prereg,
-        prevtoken,
-
-        rhino = {
-            defineClass : false,
-            deserialize : false,
-            gc          : false,
-            help        : 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
-
-        sidebar = {
-            System      : false
-        },
-
-        src,
-        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
-        },
-
-        standard_member = {
-            E                   : true,
-            LN2                 : true,
-            LN10                : true,
-            LOG2E               : true,
-            LOG10E              : true,
-            PI                  : true,
-            SQRT1_2             : true,
-            SQRT2               : true,
-            MAX_VALUE           : true,
-            MIN_VALUE           : true,
-            NEGATIVE_INFINITY   : true,
-            POSITIVE_INFINITY   : true
-        },
-
-        strict_mode,
-        syntax = {},
-        tab,
-        token,
-        urls,
-        warnings,
-
-// widget contains the global names which are provided to a Yahoo
-// (fna Konfabulator) widget.
-
-        widget = {
-            alert                   : true,
-            animator                : true,
-            appleScript             : true,
-            beep                    : true,
-            bytesToUIString         : true,
-            Canvas                  : true,
-            chooseColor             : true,
-            chooseFile              : true,
-            chooseFolder            : true,
-            closeWidget             : true,
-            COM                     : true,
-            convertPathToHFS        : true,
-            convertPathToPlatform   : true,
-            CustomAnimation         : true,
-            escape                  : true,
-            FadeAnimation           : true,
-            filesystem              : true,
-            Flash                   : true,
-            focusWidget             : true,
-            form                    : true,
-            FormField               : true,
-            Frame                   : true,
-            HotKey                  : true,
-            Image                   : true,
-            include                 : true,
-            isApplicationRunning    : true,
-            iTunes                  : true,
-            konfabulatorVersion     : true,
-            log                     : true,
-            md5                     : true,
-            MenuItem                : true,
-            MoveAnimation           : true,
-            openURL                 : true,
-            play                    : true,
-            Point                   : true,
-            popupMenu               : true,
-            preferenceGroups        : true,
-            preferences             : true,
-            print                   : true,
-            prompt                  : true,
-            random                  : true,
-            Rectangle               : true,
-            reloadWidget            : true,
-            ResizeAnimation         : true,
-            resolvePath             : true,
-            resumeUpdates           : true,
-            RotateAnimation         : true,
-            runCommand              : true,
-            runCommandInBg          : true,
-            saveAs                  : true,
-            savePreferences         : true,
-            screen                  : true,
-            ScrollBar               : true,
-            showWidgetPreferences   : true,
-            sleep                   : true,
-            speak                   : true,
-            Style                   : true,
-            suppressUpdates         : true,
-            system                  : true,
-            tellWidget              : true,
-            Text                    : true,
-            TextArea                : true,
-            Timer                   : true,
-            unescape                : true,
-            updateNow               : true,
-            URL                     : true,
-            Web                     : true,
-            widget                  : true,
-            Window                  : true,
-            XMLDOM                  : true,
-            XMLHttpRequest          : true,
-            yahooCheckLogin         : true,
-            yahooLogin              : true,
-            yahooLogout             : true
-        },
-
-//  xmode is used to adapt to the exceptions in html parsing.
-//  It can have these states:
-//      false   .js script file
-//      html
-//      outer
-//      script
-//      style
-//      scriptstring
-//      styleproperty
-
-        xmode,
-        xquote,
-
-// 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*([(){}\[.,:;'"~\?\]#@]|==?=?|\/(\*(jslint|members?|global)?|=|\/)?|\*[\/=]?|\+[+=]?|-[\-=]?|%=?|&[&=]?|\|[|=]?|>>?>?=?|<([\/=!]|\!(\[|--)?|<=?)?|\^=?|\!=?=?|[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+([xX][0-9a-fA-F]+|\.[0-9]*)?([eE][+\-]?[0-9]+)?)/,
-// html token
-////////        hx = /^\s*(['"=>\/&#]|<(?:\/|\!(?:--)?)?|[a-zA-Z][a-zA-Z0-9_\-]*|[0-9]+|--|.)/,
-        hx = /^\s*(['"=>\/&#]|<(?:\/|\!(?:--)?)?|[a-zA-Z][a-zA-Z0-9_\-]*|[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,
-// outer html token
-        ox = /[>&]|<[\/!]?|--/,
-// star slash
-        lx = /\*\/|\/\*/,
-// identifier
-        ix = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/,
-// javascript url
-        jx = /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i,
-// url badness
-        ux = /&|\+|\u00AD|\.\.|\/\*|%[^;]|base64|url|expression|data|mailto/i,
-// style
-        sx = /^\s*([{:#%.=,>+\[\]@()"';]|\*=?|\$=|\|=|\^=|~=|[a-zA-Z_][a-zA-Z0-9_\-]*|[0-9]+|<\/|\/\*)/,
-        ssx = /^\s*([@#!"'};:\-%.=,+\[\]()*_]|[a-zA-Z][a-zA-Z0-9._\-]*|\/\*?|\d+(?:\.\d+)?|<\/)/,
-// attributes characters
-        qx = /[^a-zA-Z0-9-_\/ ]/,
-// query characters for ids
-        dx = /[\[\]\/\\"'*<>.&:(){}+=#]/,
-
-        rx = {
-            outer: hx,
-            html: hx,
-            style: sx,
-            styleproperty: ssx
-        };
-
-    function F() {}
-
-    if (typeof Object.create !== 'function') {
-        Object.create = function (o) {
-            F.prototype = o;
-            return new F();
-        };
-    }
-
-
-    function is_own(object, name) {
-        return Object.prototype.hasOwnProperty.call(object, name);
-    }
-
-
-    function combine(t, o) {
-        var n;
-        for (n in o) {
-            if (is_own(o, n)) {
-                t[n] = o[n];
-            }
-        }
-    }
-
-    String.prototype.entityify = function () {
-        return this.
-            replace(/&/g, '&amp;').
-            replace(/</g, '&lt;').
-            replace(/>/g, '&gt;');
-    };
-
-    String.prototype.isAlpha = function () {
-        return (this >= 'a' && this <= 'z\uffff') ||
-            (this >= 'A' && this <= 'Z\uffff');
-    };
-
-
-    String.prototype.isDigit = function () {
-        return (this >= '0' && this <= '9');
-    };
-
-
-    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;
-        });
-    };
-
-    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 assume() {
-        if (!option.safe) {
-            if (option.rhino) {
-                combine(predefined, rhino);
-            }
-            if (option.devel) {
-                combine(predefined, devel);
-            }
-            if (option.browser || option.sidebar) {
-                combine(predefined, browser);
-            }
-            if (option.sidebar) {
-                combine(predefined, sidebar);
-            }
-            if (option.widget) {
-                combine(predefined, widget);
-            }
-        }
-    }
-
-
-// Produce an error warning.
-
-    function quit(m, l, ch) {
-        throw {
-            name: 'JSLintError',
-            line: l,
-            character: ch,
-            message: m + " (" + Math.floor((l / lines.length) * 100) +
-                    "% scanned)."
-        };
-    }
-
-    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);
-        JSLINT.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);
-        quit("Stopping, unable to continue.", w.line, w.character);
-    }
-
-    function errorAt(m, l, ch, a, b, c, d) {
-        return error(m, {
-            line: l,
-            from: ch
-        }, a, b, c, d);
-    }
-
-
-
-// lexical analysis
-
-    var lex = (function lex() {
-        var character, from, line, s;
-
-// Private lex methods
-
-        function nextLine() {
-            var at;
-            if (line >= lines.length) {
-                return false;
-            }
-            character = 1;
-            s = lines[line];
-            line += 1;
-            at = s.search(/ \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);
-            }
-            return true;
-        }
-
-// Produce a token object.  The token inherits from a syntax symbol.
-
-        function it(type, value) {
-            var i, t;
-            if (type === '(color)') {
-                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 (jx.test(value)) {
-                    warningAt("Script URL.", line, from);
-                }
-            }
-            if (type === '(identifier)') {
-                t.identifier = true;
-                if (value === '__iterator__' || value === '__proto__') {
-                    errorAt("Reserved name '{a}'.",
-                        line, from, value);
-                } else if (option.nomen &&
-                        (value.charAt(0) === '_' ||
-                         value.charAt(value.length - 1) === '_')) {
-                    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');
-            }
-            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;
-                }
-                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 xquote:
-                    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;
-
-                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 = '';
-
-                    if (jsonmode && x !== '"') {
-                        warningAt("Strings must use doublequote.",
-                                line, character);
-                    }
-
-                    if (xquote === x || (xmode === 'scriptstring' && !xquote)) {
-                        return it('(punctuator)', x);
-                    }
-
-                    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;
-                    for (;;) {
-                        while (j >= s.length) {
-                            j = 0;
-                            if (xmode !== 'html' || !nextLine()) {
-                                errorAt("Unclosed string.", line, from);
-                            }
-                        }
-                        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 === xquote) {
-                            warningAt("Bad HTML string", line, character + j);
-                        } else if (c === '<') {
-                            if (option.safe && xmode === 'html') {
-                                warningAt("ADsafe string violation.",
-                                        line, character + j);
-                            } else if (s.charAt(j + 1) === '/' && (xmode || option.safe)) {
-                                warningAt("Expected '<\\/' and instead saw '</'.", line, character);
-                            } else if (s.charAt(j + 1) === '!' && (xmode || option.safe)) {
-                                warningAt("Unexpected '<!' in a string.", line, character);
-                            }
-                        } else if (c === '\\') {
-                            if (xmode === 'html') {
-                                if (option.safe) {
-                                    warningAt("ADsafe string violation.",
-                                            line, character + j);
-                                }
-                            } else if (xmode === 'styleproperty') {
-                                j += 1;
-                                character += 1;
-                                c = s.charAt(j);
-                                if (c !== x) {
-                                    warningAt("Escapement in style string.",
-                                            line, character + j);
-                                }
-                            } else {
-                                j += 1;
-                                character += 1;
-                                c = s.charAt(j);
-                                switch (c) {
-                                case xquote:
-                                    warningAt("Bad HTML string", line,
-                                        character + j);
-                                    break;
-                                case '\\':
-                                case '\'':
-                                case '"':
-                                case '/':
-                                    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':
-                                    c = '\v';
-                                    break;
-                                case 'x':
-                                    if (jsonmode) {
-                                        warningAt("Avoid \\x-.", line, character);
-                                    }
-                                    esc(2);
-                                    break;
-                                default:
-                                    warningAt("Bad escapement.", line, character);
-                                }
-                            }
-                        }
-                        r += c;
-                        character += 1;
-                        j += 1;
-                    }
-                }
-
-                for (;;) {
-                    if (!s) {
-                        return it(nextLine() ? '(endline)' : '(end)', '');
-                    }
-                    while (xmode === 'outer') {
-                        i = s.search(ox);
-                        if (i === 0) {
-                            break;
-                        } else if (i > 0) {
-                            character += 1;
-                            s = s.slice(i);
-                            break;
-                        } else {
-                            if (!nextLine()) {
-                                return it('(end)', '');
-                            }
-                        }
-                    }
-//                     t = match(rx[xmode] || tx);
-//                     if (!t) {
-//                         if (xmode === 'html') {
-//                             return it('(error)', s.charAt(0));
-//                         } else {
-//                             t = '';
-//                             c = '';
-//                             while (s && s < '!') {
-//                                 s = s.substr(1);
-//                             }
-//                             if (s) {
-//                                 errorAt("Unexpected '{a}'.",
-//                                         line, character, s.substr(0, 1));
-//                             }
-//                         }
-                    t = match(rx[xmode] || tx);
-                    if (!t) {
-                        t = '';
-                        c = '';
-                        while (s && s < '!') {
-                            s = s.substr(1);
-                        }
-                        if (s) {
-                            if (xmode === 'html') {
-                                return it('(error)', s.charAt(0));
-                            } else {
-                                errorAt("Unexpected '{a}'.",
-                                        line, character, s.substr(0, 1));
-                            }
-                        }
-                    } else {
-
-    //      identifier
-
-                        if (c.isAlpha() || c === '_' || c === '$') {
-                            return it('(identifier)', t);
-                        }
-
-    //      number
-
-                        if (c.isDigit()) {
-                            if (xmode !== 'style' && !isFinite(Number(t))) {
-                                warningAt("Bad number '{a}'.",
-                                    line, character, t);
-                            }
-                            if (xmode !== 'style' &&
-                                     xmode !== 'styleproperty' &&
-                                     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 !== '.' && xmode !== 'styleproperty') {
-                                        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 '//':
-                            if (src || (xmode && xmode !== 'script')) {
-                                warningAt("Unexpected comment.", line, character);
-                            } else if (xmode === 'script' && /<\s*\//i.test(s)) {
-                                warningAt("Unexpected <\/ in comment.", line, character);
-                            } else if ((option.safe || xmode === 'script') && ax.test(s)) {
-                                warningAt("Dangerous comment.", line, character);
-                            }
-                            s = '';
-                            token.comment = true;
-                            break;
-
-    //      /* comment
-
-                        case '/*':
-                            if (src || (xmode && xmode !== 'script' && xmode !== 'style' && xmode !== 'styleproperty')) {
-                                warningAt("Unexpected comment.", line, character);
-                            }
-                            if (option.safe && ax.test(s)) {
-                                warningAt("ADsafe comment violation.", line, character);
-                            }
-                            for (;;) {
-                                i = s.search(lx);
-                                if (i >= 0) {
-                                    break;
-                                }
-                                if (!nextLine()) {
-                                    errorAt("Unclosed comment.", line, character);
-                                } else {
-                                    if (option.safe && ax.test(s)) {
-                                        warningAt("ADsafe comment violation.", 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 /*jslint /*global
-
-                        case '/*members':
-                        case '/*member':
-                        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;
-                                    case '/':
-                                        if (depth > 0) {
-                                            warningAt("Unescaped '{a}'.", line, from + l, '/');
-                                        }
-                                        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);
-                                            }
-                                        }
-                                        q = false;
-                                        if (c === ']') {
-                                            warningAt("Empty class.", line, from + l - 1);
-                                            q = true;
-                                        }
-    klass:                              do {
-                                            c = s.charAt(l);
-                                            l += 1;
-                                            switch (c) {
-                                            case '[':
-                                            case '^':
-                                                warningAt("Unescaped '{a}'.", line, from + l, c);
-                                                q = true;
-                                                break;
-                                            case '-':
-                                                if (q) {
-                                                    q = false;
-                                                } else {
-                                                    warningAt("Unescaped '{a}'.", line, from + l, '-');
-                                                    q = true;
-                                                }
-                                                break;
-                                            case ']':
-                                                if (!q) {
-                                                    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;
-                                                q = true;
-                                                break;
-                                            case '/':
-                                                warningAt("Unescaped '{a}'.", line, from + l - 1, '/');
-                                                q = true;
-                                                break;
-                                            case '<':
-                                                if (xmode === 'script') {
-                                                    c = s.charAt(l);
-                                                    if (c === '!' || c === '/') {
-                                                        warningAt("HTML confusion in regular expression '<{a}'.", line, from + l, c);
-                                                    }
-                                                }
-                                                q = true;
-                                                break;
-                                            default:
-                                                q = 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);
-                                        break;
-                                    case '<':
-                                        if (xmode === 'script') {
-                                            c = s.charAt(l);
-                                            if (c === '!' || c === '/') {
-                                                warningAt("HTML confusion in regular expression '<{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 '<!--':
-                            l = line;
-                            c = character;
-                            for (;;) {
-                                i = s.indexOf('--');
-                                if (i >= 0) {
-                                    break;
-                                }
-                                i = s.indexOf('<!');
-                                if (i >= 0) {
-                                    errorAt("Nested HTML comment.",
-                                        line, character + i);
-                                }
-                                if (!nextLine()) {
-                                    errorAt("Unclosed HTML comment.", l, c);
-                                }
-                            }
-                            l = s.indexOf('<!');
-                            if (l >= 0 && l < i) {
-                                errorAt("Nested HTML comment.",
-                                    line, character + l);
-                            }
-                            character += i;
-                            if (s[i + 2] !== '>') {
-                                errorAt("Expected -->.", line, character);
-                            }
-                            character += 3;
-                            s = s.slice(i + 3);
-                            break;
-                        case '#':
-                            if (xmode === 'html' || xmode === 'styleproperty') {
-                                for (;;) {
-                                    c = s.charAt(0);
-                                    if ((c < '0' || c > '9') &&
-                                            (c < 'a' || c > 'f') &&
-                                            (c < 'A' || c > 'F')) {
-                                        break;
-                                    }
-                                    character += 1;
-                                    s = s.substr(1);
-                                    t += c;
-                                }
-                                if (t.length !== 4 && t.length !== 7) {
-                                    warningAt("Bad hex color '{a}'.", line,
-                                        from + l, t);
-                                }
-                                return it('(color)', t);
-                            }
-                            return it('(punctuator)', t);
-                        default:
-                            if (xmode === 'outer' && c === '&') {
-                                character += 1;
-                                s = s.substr(1);
-                                for (;;) {
-                                    c = s.charAt(0);
-                                    character += 1;
-                                    s = s.substr(1);
-                                    if (c === ';') {
-                                        break;
-                                    }
-                                    if (!((c >= '0' && c <= '9') ||
-                                            (c >= 'a' && c <= 'z') ||
-                                            c === '#')) {
-                                        errorAt("Bad entity", line, from + l,
-                                        character);
-                                    }
-                                }
-                                break;
-                            }
-                            return it('(punctuator)', t);
-                        }
-                    }
-                }
-            }
-        };
-    }());
-
-
-    function addlabel(t, type) {
-
-        if (option.safe && funct['(global)'] && typeof predefined[t] !== 'boolean') {
-            warning('ADsafe global: ' + t + '.', token);
-        } else 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)']) {
-            warning(funct[t] === true ?
-                "'{a}' was used before it was defined." :
-                "'{a}' is already defined.",
-                nexttoken, t);
-        }
-        funct[t] = type;
-        if (funct['(global)']) {
-            global[t] = funct;
-            if (is_own(implied, t)) {
-                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 '/*jslint':
-            if (option.safe) {
-                warning("ADsafe restriction.");
-            }
-            obj = option;
-            filter = boolOptions;
-            break;
-        case '/*global':
-            if (option.safe) {
-                warning("ADsafe restriction.");
-            }
-            obj = predefined;
-            break;
-        default:
-        }
-        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 === '/*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 === '/*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 === '/*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 (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 === '/*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 JSLINT, the Pratt parser. In addition to parsing, it
-// is looking for ad hoc lint patterns. We add to Pratt's model .fud, 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 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 key to the parsing method called Top Down Operator Precedence.
-
-    function parse(rbp, initial) {
-        var left;
-        if (nexttoken.id === '(end)') {
-            error("Unexpected early end of program.", token);
-        }
-        advance();
-        if (option.safe && typeof predefined[token.value] === 'boolean' &&
-                (nexttoken.id !== '(' && nexttoken.id !== '.')) {
-            warning('ADsafe violation.', token);
-        }
-        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) {
-                advance();
-                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 || xmode === 'styleproperty' || xmode === 'style') {
-            if (left.character !== right.from && left.line === right.line) {
-                warning("Unexpected space after '{a}'.", right, left.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) {
-                warning("Missing space after '{a}'.",
-                        nexttoken, 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) {
-                warning("Missing space after '{a}'.",
-                        nexttoken, 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.laxbreak) {
-                warning("Bad line breaking before '{a}'.", token, nexttoken.id);
-            }
-        } else if (token.character !== nexttoken.from && option.white) {
-            warning("Unexpected space after '{a}'.", nexttoken, token.value);
-        }
-        advance(',');
-        nonadjacent(token, nexttoken);
-    }
-
-
-// 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 = parse(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 (this.id === 'this' || this.id === 'arguments') {
-                if (strict_mode && funct['(global)']) {
-                    warning("Strict violation.", this);
-                } else if (option.safe) {
-                    warning("ADsafe violation.", 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 (typeof f === 'function') {
-                return f(left, this);
-            } else {
-                this.left = left;
-                this.right = parse(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 = parse(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}'.", left, '!');
-            }
-            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 === 'true' ||
-                node.type === 'false' ||
-                node.type === 'undefined' ||
-                node.type === 'null');
-    }
-
-
-    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);
-            }
-            if (option.safe) {
-                l = left;
-                do {
-                    if (typeof predefined[l.value] === 'boolean') {
-                        warning('ADsafe violation.', l);
-                    }
-                    l = l.left;
-                } while (l);
-            }
-            if (left) {
-                if (left.id === '.' || left.id === '[') {
-                    if (!left.left || left.left.value === 'arguments') {
-                        warning('Bad assignment.', that);
-                    }
-                    that.right = parse(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 = parse(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 = parse(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)) {
-                    parse(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;
-    }
-
-
-    function optionalidentifier() {
-        if (nexttoken.reserved) {
-            warning("Expected an identifier and instead saw '{a}' (a reserved word).",
-                    nexttoken, nexttoken.id);
-        }
-        if (nexttoken.identifier) {
-            advance();
-            return token.value;
-        }
-    }
-
-
-    function identifier() {
-        var i = optionalidentifier();
-        if (i) {
-            return i;
-        }
-        if (token.id === 'function' && nexttoken.id === '(') {
-            warning("Missing name in function statement.");
-        } 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') {
-                    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;
-
-// We don't like the empty statement.
-
-        if (t.id === ';') {
-            warning("Unnecessary semicolon.", t);
-            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 = parse(0, true);
-
-// Look for the final semicolon.
-
-        if (!t.block) {
-            if (!r || !r.exps) {
-                warning(
-"Expected an assignment or function call and instead saw an expression.",
-                        token);
-            } else if (r.id === '(' && r.left.id === 'new') {
-                warning("Do not use 'new' for side effects.");
-            }
-            if (nexttoken.id !== ';') {
-                warningAt("Missing semicolon.", token.line,
-                        token.from + token.value.length);
-            } else {
-                adjacent(token, nexttoken);
-                advance(';');
-                nonadjacent(token, nexttoken);
-            }
-        }
-
-// Restore the indentation.
-
-        indent = i;
-        scope = s;
-        return r;
-    }
-
-
-    function use_strict() {
-        if (nexttoken.value === 'use strict') {
-            advance();
-            advance(';');
-            strict_mode = true;
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-
-    function statements(begin) {
-        var a = [], f, p;
-        if (begin && !use_strict() && option.strict) {
-            warning('Missing "use strict" statement.', nexttoken);
-        }
-        if (option.adsafe) {
-            switch (begin) {
-            case 'script':
-                if (!adsafe_may) {
-                    if (nexttoken.value !== 'ADSAFE' ||
-                            peek(0).id !== '.' ||
-                            (peek(1).value !== 'id' &&
-                            peek(1).value !== 'go')) {
-                        error('ADsafe violation: Missing ADSAFE.id or ADSAFE.go.',
-                            nexttoken);
-                    }
-                }
-                if (nexttoken.value === 'ADSAFE' &&
-                        peek(0).id === '.' &&
-                        peek(1).value === 'id') {
-                    if (adsafe_may) {
-                        error('ADsafe violation.', nexttoken);
-                    }
-                    advance('ADSAFE');
-                    advance('.');
-                    advance('id');
-                    advance('(');
-                    if (nexttoken.value !== adsafe_id) {
-                        error('ADsafe violation: id does not match.', nexttoken);
-                    }
-                    advance('(string)');
-                    advance(')');
-                    advance(';');
-                    adsafe_may = true;
-                }
-                break;
-            case 'lib':
-                if (nexttoken.value === 'ADSAFE') {
-                    advance('ADSAFE');
-                    advance('.');
-                    advance('lib');
-                    advance('(');
-                    advance('(string)');
-                    comma();
-                    f = parse(0);
-                    if (f.id !== 'function') {
-                        error('The second argument to lib must be a function.', f);
-                    }
-                    p = f.funct['(params)'];
-                    p = p && p.join(', ');
-                    if (p && p !== 'lib') {
-                        error("Expected '{a}' and instead saw '{b}'.",
-                            f, '(lib)', '(' + p + ')');
-                    }
-                    advance(')');
-                    advance(';');
-                    return a;
-                } else {
-                    error("ADsafe lib violation.");
-                }
-            }
-        }
-        while (!nexttoken.reach && nexttoken.id !== '(end)') {
-            if (nexttoken.id === ';') {
-                warning("Unnecessary semicolon.");
-                advance(';');
-            } else {
-                a.push(statement());
-            }
-        }
-        return a;
-    }
-
-
-    function block(f) {
-        var a, b = inblock, old_indent = indent, s = scope, t;
-        inblock = f;
-        scope = Object.create(scope);
-        nonadjacent(token, nexttoken);
-        t = nexttoken;
-        if (nexttoken.id === '{') {
-            advance('{');
-            if (nexttoken.id !== '}' || token.line !== nexttoken.line) {
-                indent += option.indent;
-                while (!f && nexttoken.from > indent) {
-                    indent += option.indent;
-                }
-                if (!f) {
-                    use_strict();
-                }
-                a = statements();
-                indent -= option.indent;
-                indentation();
-            }
-            advance('}', t);
-            indent = old_indent;
-        } else {
-            warning("Expected '{a}' and instead saw '{b}'.",
-                    nexttoken, '{', nexttoken.value);
-            noreach = true;
-            a = [statement()];
-            noreach = false;
-        }
-        funct['(verb)'] = null;
-        scope = s;
-        inblock = b;
-        return a;
-    }
-
-
-// An identity function, used by string and number tokens.
-
-    function idValue() {
-        return this;
-    }
-
-
-    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);
-        }
-    }
-
-// CSS parsing.
-
-
-    function cssName() {
-        if (nexttoken.identifier) {
-            advance();
-            return true;
-        }
-    }
-
-    function cssNumber() {
-        if (nexttoken.id === '-') {
-            advance('-');
-            adjacent();
-            nolinebreak();
-        }
-        if (nexttoken.type === '(number)') {
-            advance('(number)');
-            return true;
-        }
-    }
-
-    function cssString() {
-        if (nexttoken.type === '(string)') {
-            advance();
-            return true;
-        }
-    }
-
-    function cssColor() {
-        var i, number, value;
-        if (nexttoken.identifier) {
-            value = nexttoken.value;
-            if (value === 'rgb' || value === 'rgba') {
-                advance();
-                advance('(');
-                for (i = 0; i < 3; i += 1) {
-                    if (i) {
-                        advance(',');
-                    }
-                    number = nexttoken.value;
-                    if (nexttoken.type !== '(number)' || number < 0) {
-                        warning("Expected a positive number and instead saw '{a}'",
-                            nexttoken, number);
-                        advance();
-                    } else {
-                        advance();
-                        if (nexttoken.id === '%') {
-                            advance('%');
-                            if (number > 100) {
-                                warning("Expected a percentage and instead saw '{a}'",
-                                    token, number);
-                            }
-                        } else {
-                            if (number > 255) {
-                                warning("Expected a small number and instead saw '{a}'",
-                                    token, number);
-                            }
-                        }
-                    }
-                }
-                if (value === 'rgba') {
-                    advance(',');
-                    number = +nexttoken.value;
-                    if (nexttoken.type !== '(number)' || number < 0 || number > 1) {
-                        warning("Expected a number between 0 and 1 and instead saw '{a}'",
-                            nexttoken, number);
-                    }
-                    advance();
-                    if (nexttoken.id === '%') {
-                        warning("Unexpected '%'.");
-                        advance('%');
-                    }
-                }
-                advance(')');
-                return true;
-            } else if (cssColorData[nexttoken.value] === true) {
-                advance();
-                return true;
-            }
-        } else if (nexttoken.type === '(color)') {
-            advance();
-            return true;
-        }
-        return false;
-    }
-
-    function cssLength() {
-        if (nexttoken.id === '-') {
-            advance('-');
-            adjacent();
-            nolinebreak();
-        }
-        if (nexttoken.type === '(number)') {
-            advance();
-            if (nexttoken.type !== '(string)' &&
-                    cssLengthData[nexttoken.value] === true) {
-                adjacent();
-                advance();
-            } else if (+token.value !== 0) {
-                warning("Expected a linear unit and instead saw '{a}'.",
-                    nexttoken, nexttoken.value);
-            }
-            return true;
-        }
-        return false;
-    }
-
-    function cssLineHeight() {
-        if (nexttoken.id === '-') {
-            advance('-');
-            adjacent();
-        }
-        if (nexttoken.type === '(number)') {
-            advance();
-            if (nexttoken.type !== '(string)' &&
-                    cssLengthData[nexttoken.value] === true) {
-                adjacent();
-                advance();
-            }
-            return true;
-        }
-        return false;
-    }
-
-    function cssWidth() {
-        if (nexttoken.identifier) {
-            switch (nexttoken.value) {
-            case 'thin':
-            case 'medium':
-            case 'thick':
-                advance();
-                return true;
-            }
-        } else {
-            return cssLength();
-        }
-    }
-
-    function cssMargin() {
-        if (nexttoken.identifier) {
-            if (nexttoken.value === 'auto') {
-                advance();
-                return true;
-            }
-        } else {
-            return cssLength();
-        }
-    }
-
-    function cssAttr() {
-        if (nexttoken.identifier && nexttoken.value === 'attr') {
-            advance();
-            advance('(');
-            if (!nexttoken.identifier) {
-                warning("Expected a name and instead saw '{a}'.",
-                        nexttoken, nexttoken.value);
-            }
-            advance();
-            advance(')');
-            return true;
-        }
-        return false;
-    }
-
-    function cssCommaList() {
-        while (nexttoken.id !== ';') {
-            if (!cssName() && !cssString()) {
-                warning("Expected a name and instead saw '{a}'.",
-                        nexttoken, nexttoken.value);
-            }
-            if (nexttoken.id !== ',') {
-                return true;
-            }
-            comma();
-        }
-    }
-
-    function cssCounter() {
-        if (nexttoken.identifier && nexttoken.value === 'counter') {
-            advance();
-            advance('(');
-            if (!nexttoken.identifier) {
-            }
-            advance();
-            if (nexttoken.id === ',') {
-                comma();
-                if (nexttoken.type !== '(string)') {
-                    warning("Expected a string and instead saw '{a}'.",
-                        nexttoken, nexttoken.value);
-                }
-                advance();
-            }
-            advance(')');
-            return true;
-        }
-        if (nexttoken.identifier && nexttoken.value === 'counters') {
-            advance();
-            advance('(');
-            if (!nexttoken.identifier) {
-                warning("Expected a name and instead saw '{a}'.",
-                        nexttoken, nexttoken.value);
-            }
-            advance();
-            if (nexttoken.id === ',') {
-                comma();
-                if (nexttoken.type !== '(string)') {
-                    warning("Expected a string and instead saw '{a}'.",
-                        nexttoken, nexttoken.value);
-                }
-                advance();
-            }
-            if (nexttoken.id === ',') {
-                comma();
-                if (nexttoken.type !== '(string)') {
-                    warning("Expected a string and instead saw '{a}'.",
-                        nexttoken, nexttoken.value);
-                }
-                advance();
-            }
-            advance(')');
-            return true;
-        }
-        return false;
-    }
-
-
-    function cssShape() {
-        var i;
-        if (nexttoken.identifier && nexttoken.value === 'rect') {
-            advance();
-            advance('(');
-            for (i = 0; i < 4; i += 1) {
-                if (!cssLength()) {
-                    warning("Expected a number and instead saw '{a}'.",
-                        nexttoken, nexttoken.value);
-                    break;
-                }
-            }
-            advance(')');
-            return true;
-        }
-        return false;
-    }
-
-    function cssUrl() {
-        var c, url;
-        if (nexttoken.identifier && nexttoken.value === 'url') {
-            nexttoken = lex.range('(', ')');
-            url = nexttoken.value;
-            c = url.charAt(0);
-            if (c === '"' || c === '\'') {
-                if (url.slice(-1) !== c) {
-                    warning("Bad url string.");
-                } else {
-                    url = url.slice(1, -1);
-                    if (url.indexOf(c) >= 0) {
-                        warning("Bad url string.");
-                    }
-                }
-            }
-            if (!url) {
-                warning("Missing url.");
-            }
-            advance();
-            if (option.safe && ux.test(url)) {
-                error("ADsafe URL violation.");
-            }
-            urls.push(url);
-            return true;
-        }
-        return false;
-    }
-
-    cssAny = [cssUrl, function () {
-        for (;;) {
-            if (nexttoken.identifier) {
-                switch (nexttoken.value.toLowerCase()) {
-                case 'url':
-                    cssUrl();
-                    break;
-                case 'expression':
-                    warning("Unexpected expression '{a}'.",
-                        nexttoken, nexttoken.value);
-                    advance();
-                    break;
-                default:
-                    advance();
-                }
-            } else {
-                if (nexttoken.id === ';' || nexttoken.id === '!'  ||
-                        nexttoken.id === '(end)' || nexttoken.id === '}') {
-                    return true;
-                }
-                advance();
-            }
-        }
-    }];
-
-    cssBorderStyle = [
-        'none', 'hidden', 'dotted', 'dashed', 'solid', 'double', 'ridge',
-        'inset', 'outset'
-    ];
-
-    cssBreak = [
-        'auto', 'always', 'avoid', 'left', 'right'
-    ];
-
-    cssOverflow = [
-        'auto', 'hidden', 'scroll', 'visible'
-    ];
-
-    cssAttributeData = {
-        background: [
-            true, 'background-attachment', 'background-color',
-            'background-image', 'background-position', 'background-repeat'
-        ],
-        'background-attachment': ['scroll', 'fixed'],
-        'background-color': ['transparent', cssColor],
-        'background-image': ['none', cssUrl],
-        'background-position': [
-            2, [cssLength, 'top', 'bottom', 'left', 'right', 'center']
-        ],
-        'background-repeat': [
-            'repeat', 'repeat-x', 'repeat-y', 'no-repeat'
-        ],
-        'border': [true, 'border-color', 'border-style', 'border-width'],
-        'border-bottom': [
-            true, 'border-bottom-color', 'border-bottom-style',
-            'border-bottom-width'
-        ],
-        'border-bottom-color': cssColor,
-        'border-bottom-style': cssBorderStyle,
-        'border-bottom-width': cssWidth,
-        'border-collapse': ['collapse', 'separate'],
-        'border-color': ['transparent', 4, cssColor],
-        'border-left': [
-            true, 'border-left-color', 'border-left-style', 'border-left-width'
-        ],
-        'border-left-color': cssColor,
-        'border-left-style': cssBorderStyle,
-        'border-left-width': cssWidth,
-        'border-right': [
-            true, 'border-right-color', 'border-right-style',
-            'border-right-width'
-        ],
-        'border-right-color': cssColor,
-        'border-right-style': cssBorderStyle,
-        'border-right-width': cssWidth,
-        'border-spacing': [2, cssLength],
-        'border-style': [4, cssBorderStyle],
-        'border-top': [
-            true, 'border-top-color', 'border-top-style', 'border-top-width'
-        ],
-        'border-top-color': cssColor,
-        'border-top-style': cssBorderStyle,
-        'border-top-width': cssWidth,
-        'border-width': [4, cssWidth],
-        bottom: [cssLength, 'auto'],
-        'caption-side' : ['bottom', 'left', 'right', 'top'],
-        clear: ['both', 'left', 'none', 'right'],
-        clip: [cssShape, 'auto'],
-        color: cssColor,
-        content: [
-            'open-quote', 'close-quote', 'no-open-quote', 'no-close-quote',
-            cssString, cssUrl, cssCounter, cssAttr
-        ],
-        'counter-increment': [
-            cssName, 'none'
-        ],
-        'counter-reset': [
-            cssName, 'none'
-        ],
-        cursor: [
-            cssUrl, 'auto', 'crosshair', 'default', 'e-resize', 'help', 'move',
-            'n-resize', 'ne-resize', 'nw-resize', 'pointer', 's-resize',
-            'se-resize', 'sw-resize', 'w-resize', 'text', 'wait'
-        ],
-        direction: ['ltr', 'rtl'],
-        display: [
-            'block', 'compact', 'inline', 'inline-block', 'inline-table',
-            'list-item', 'marker', 'none', 'run-in', 'table', 'table-caption',
-            'table-cell', 'table-column', 'table-column-group',
-            'table-footer-group', 'table-header-group', 'table-row',
-            'table-row-group'
-        ],
-        'empty-cells': ['show', 'hide'],
-        'float': ['left', 'none', 'right'],
-        font: [
-            'caption', 'icon', 'menu', 'message-box', 'small-caption',
-            'status-bar', true, 'font-size', 'font-style', 'font-weight',
-            'font-family'
-        ],
-        'font-family': cssCommaList,
-        'font-size': [
-            'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large',
-            'xx-large', 'larger', 'smaller', cssLength
-        ],
-        'font-size-adjust': ['none', cssNumber],
-        'font-stretch': [
-            'normal', 'wider', 'narrower', 'ultra-condensed',
-            'extra-condensed', 'condensed', 'semi-condensed',
-            'semi-expanded', 'expanded', 'extra-expanded'
-        ],
-        'font-style': [
-            'normal', 'italic', 'oblique'
-        ],
-        'font-variant': [
-            'normal', 'small-caps'
-        ],
-        'font-weight': [
-            'normal', 'bold', 'bolder', 'lighter', cssNumber
-        ],
-        height: [cssLength, 'auto'],
-        left: [cssLength, 'auto'],
-        'letter-spacing': ['normal', cssLength],
-        'line-height': ['normal', cssLineHeight],
-        'list-style': [
-            true, 'list-style-image', 'list-style-position', 'list-style-type'
-        ],
-        'list-style-image': ['none', cssUrl],
-        'list-style-position': ['inside', 'outside'],
-        'list-style-type': [
-            'circle', 'disc', 'square', 'decimal', 'decimal-leading-zero',
-            'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha',
-            'lower-latin', 'upper-alpha', 'upper-latin', 'hebrew', 'katakana',
-            'hiragana-iroha', 'katakana-oroha', 'none'
-        ],
-        margin: [4, cssMargin],
-        'margin-bottom': cssMargin,
-        'margin-left': cssMargin,
-        'margin-right': cssMargin,
-        'margin-top': cssMargin,
-        'marker-offset': [cssLength, 'auto'],
-        'max-height': [cssLength, 'none'],
-        'max-width': [cssLength, 'none'],
-        'min-height': cssLength,
-        'min-width': cssLength,
-        opacity: cssNumber,
-        outline: [true, 'outline-color', 'outline-style', 'outline-width'],
-        'outline-color': ['invert', cssColor],
-        'outline-style': [
-            'dashed', 'dotted', 'double', 'groove', 'inset', 'none',
-            'outset', 'ridge', 'solid'
-        ],
-        'outline-width': cssWidth,
-        overflow: cssOverflow,
-        'overflow-x': cssOverflow,
-        'overflow-y': cssOverflow,
-        padding: [4, cssLength],
-        'padding-bottom': cssLength,
-        'padding-left': cssLength,
-        'padding-right': cssLength,
-        'padding-top': cssLength,
-        'page-break-after': cssBreak,
-        'page-break-before': cssBreak,
-        position: ['absolute', 'fixed', 'relative', 'static'],
-        quotes: [8, cssString],
-        right: [cssLength, 'auto'],
-        'table-layout': ['auto', 'fixed'],
-        'text-align': ['center', 'justify', 'left', 'right'],
-        'text-decoration': [
-            'none', 'underline', 'overline', 'line-through', 'blink'
-        ],
-        'text-indent': cssLength,
-        'text-shadow': ['none', 4, [cssColor, cssLength]],
-        'text-transform': ['capitalize', 'uppercase', 'lowercase', 'none'],
-        top: [cssLength, 'auto'],
-        'unicode-bidi': ['normal', 'embed', 'bidi-override'],
-        'vertical-align': [
-            'baseline', 'bottom', 'sub', 'super', 'top', 'text-top', 'middle',
-            'text-bottom', cssLength
-        ],
-        visibility: ['visible', 'hidden', 'collapse'],
-        'white-space': [
-            'normal', 'nowrap', 'pre', 'pre-line', 'pre-wrap', 'inherit'
-        ],
-        width: [cssLength, 'auto'],
-        'word-spacing': ['normal', cssLength],
-        'word-wrap': ['break-word', 'normal'],
-        'z-index': ['auto', cssNumber]
-    };
-
-    function styleAttribute() {
-        var v;
-        while (nexttoken.id === '*' || nexttoken.id === '#' ||
-                nexttoken.value === '_') {
-            if (!option.css) {
-                warning("Unexpected '{a}'.", nexttoken, nexttoken.value);
-            }
-            advance();
-        }
-        if (nexttoken.id === '-') {
-            if (!option.css) {
-                warning("Unexpected '{a}'.", nexttoken, nexttoken.value);
-            }
-            advance('-');
-            if (!nexttoken.identifier) {
-                warning(
-"Expected a non-standard style attribute and instead saw '{a}'.",
-                    nexttoken, nexttoken.value);
-            }
-            advance();
-            return cssAny;
-        } else {
-            if (!nexttoken.identifier) {
-                warning("Excepted a style attribute, and instead saw '{a}'.",
-                    nexttoken, nexttoken.value);
-            } else {
-                if (is_own(cssAttributeData, nexttoken.value)) {
-                    v = cssAttributeData[nexttoken.value];
-                } else {
-                    v = cssAny;
-                    if (!option.css) {
-                        warning("Unrecognized style attribute '{a}'.",
-                                nexttoken, nexttoken.value);
-                    }
-                }
-            }
-            advance();
-            return v;
-        }
-    }
-
-    function styleValue(v) {
-        var i = 0,
-            n,
-            once,
-            match,
-            round,
-            start = 0,
-            vi;
-        switch (typeof v) {
-        case 'function':
-            return v();
-        case 'string':
-            if (nexttoken.identifier && nexttoken.value === v) {
-                advance();
-                return true;
-            }
-            return false;
-        }
-        for (;;) {
-            if (i >= v.length) {
-                return false;
-            }
-            vi = v[i];
-            i += 1;
-            if (vi === true) {
-                break;
-            } else if (typeof vi === 'number') {
-                n = vi;
-                vi = v[i];
-                i += 1;
-            } else {
-                n = 1;
-            }
-            match = false;
-            while (n > 0) {
-                if (styleValue(vi)) {
-                    match = true;
-                    n -= 1;
-                } else {
-                    break;
-                }
-            }
-            if (match) {
-                return true;
-            }
-        }
-        start = i;
-        once = [];
-        for (;;) {
-            round = false;
-            for (i = start; i < v.length; i += 1) {
-                if (!once[i]) {
-                    if (styleValue(cssAttributeData[v[i]])) {
-                        match = true;
-                        round = true;
-                        once[i] = true;
-                        break;
-                    }
-                }
-            }
-            if (!round) {
-                return match;
-            }
-        }
-    }
-
-    function styleChild() {
-        if (nexttoken.id === '(number)') {
-            advance();
-            if (nexttoken.value === 'n' && nexttoken.identifier) {
-                adjacent();
-                advance();
-                if (nexttoken.id === '+') {
-                    adjacent();
-                    advance('+');
-                    adjacent();
-                    advance('(number)');
-                }
-            }
-            return;
-        } else {
-            switch (nexttoken.value) {
-            case 'odd':
-            case 'even':
-                if (nexttoken.identifier) {
-                    advance();
-                    return;
-                }
-            }
-        }
-        warning("Unexpected token '{a}'.", nexttoken, nexttoken.value);
-    }
-
-    function substyle() {
-        var v;
-        for (;;) {
-            if (nexttoken.id === '}' || nexttoken.id === '(end)' ||
-                    xquote && nexttoken.id === xquote) {
-                return;
-            }
-            while (nexttoken.id === ';') {
-                warning("Misplaced ';'.");
-                advance(';');
-            }
-            v = styleAttribute();
-            advance(':');
-            if (nexttoken.identifier && nexttoken.value === 'inherit') {
-                advance();
-            } else {
-                if (!styleValue(v)) {
-                    warning("Unexpected token '{a}'.", nexttoken,
-                        nexttoken.value);
-                    advance();
-                }
-            }
-            if (nexttoken.id === '!') {
-                advance('!');
-                adjacent();
-                if (nexttoken.identifier && nexttoken.value === 'important') {
-                    advance();
-                } else {
-                    warning("Expected '{a}' and instead saw '{b}'.",
-                        nexttoken, 'important', nexttoken.value);
-                }
-            }
-            if (nexttoken.id === '}' || nexttoken.id === xquote) {
-                warning("Missing '{a}'.", nexttoken, ';');
-            } else {
-                advance(';');
-            }
-        }
-    }
-
-    function styleSelector() {
-        if (nexttoken.identifier) {
-            if (!is_own(htmltag, nexttoken.value)) {
-                warning("Expected a tagName, and instead saw {a}.",
-                    nexttoken, nexttoken.value);
-            }
-            advance();
-        } else {
-            switch (nexttoken.id) {
-            case '>':
-            case '+':
-                advance();
-                styleSelector();
-                break;
-            case ':':
-                advance(':');
-                switch (nexttoken.value) {
-                case 'active':
-                case 'after':
-                case 'before':
-                case 'checked':
-                case 'disabled':
-                case 'empty':
-                case 'enabled':
-                case 'first-child':
-                case 'first-letter':
-                case 'first-line':
-                case 'first-of-type':
-                case 'focus':
-                case 'hover':
-                case 'last-of-type':
-                case 'link':
-                case 'only-of-type':
-                case 'root':
-                case 'target':
-                case 'visited':
-                    advance();
-                    break;
-                case 'lang':
-                    advance();
-                    advance('(');
-                    if (!nexttoken.identifier) {
-                        warning("Expected a lang code, and instead saw :{a}.",
-                            nexttoken, nexttoken.value);
-                    }
-                    advance(')');
-                    break;
-                case 'nth-child':
-                case 'nth-last-child':
-                case 'nth-last-of-type':
-                case 'nth-of-type':
-                    advance();
-                    advance('(');
-                    styleChild();
-                    advance(')');
-                    break;
-                case 'not':
-                    advance();
-                    advance('(');
-                    if (nexttoken.id === ':' && peek(0).value === 'not') {
-                        warning("Nested not.");
-                    }
-                    styleSelector();
-                    advance(')');
-                    break;
-                default:
-                    warning("Expected a pseudo, and instead saw :{a}.",
-                        nexttoken, nexttoken.value);
-                }
-                break;
-            case '#':
-                advance('#');
-                if (!nexttoken.identifier) {
-                    warning("Expected an id, and instead saw #{a}.",
-                        nexttoken, nexttoken.value);
-                }
-                advance();
-                break;
-            case '*':
-                advance('*');
-                break;
-            case '.':
-                advance('.');
-                if (!nexttoken.identifier) {
-                    warning("Expected a class, and instead saw #.{a}.",
-                        nexttoken, nexttoken.value);
-                }
-                advance();
-                break;
-            case '[':
-                advance('[');
-                if (!nexttoken.identifier) {
-                    warning("Expected an attribute, and instead saw [{a}].",
-                        nexttoken, nexttoken.value);
-                }
-                advance();
-                if (nexttoken.id === '=' || nexttoken.value === '~=' ||
-                        nexttoken.value === '$=' ||
-                        nexttoken.value === '|=' ||
-                        nexttoken.id === '*=' ||
-                        nexttoken.id === '^=') {
-                    advance();
-                    if (nexttoken.type !== '(string)') {
-                        warning("Expected a string, and instead saw {a}.",
-                            nexttoken, nexttoken.value);
-                    }
-                    advance();
-                }
-                advance(']');
-                break;
-            default:
-                error("Expected a CSS selector, and instead saw {a}.",
-                    nexttoken, nexttoken.value);
-            }
-        }
-    }
-
-    function stylePattern() {
-        var name;
-        if (nexttoken.id === '{') {
-            warning("Expected a style pattern, and instead saw '{a}'.", nexttoken,
-                nexttoken.id);
-        } else if (nexttoken.id === '@') {
-            advance('@');
-            name = nexttoken.value;
-            if (nexttoken.identifier && atrule[name] === true) {
-                advance();
-                return name;
-            }
-            warning("Expected an at-rule, and instead saw @{a}.", nexttoken, name);
-        }
-        for (;;) {
-            styleSelector();
-            if (nexttoken.id === '</' || nexttoken.id === '{' ||
-                    nexttoken.id === '(end)') {
-                return '';
-            }
-            if (nexttoken.id === ',') {
-                comma();
-            }
-        }
-    }
-
-    function styles() {
-        var i;
-        while (nexttoken.id === '@') {
-            i = peek();
-            if (i.identifier && i.value === 'import') {
-                advance('@');
-                advance();
-                if (!cssUrl()) {
-                    warning("Expected '{a}' and instead saw '{b}'.", nexttoken,
-                        'url', nexttoken.value);
-                    advance();
-                }
-                advance(';');
-            } else {
-                break;
-            }
-        }
-        while (nexttoken.id !== '</' && nexttoken.id !== '(end)') {
-            stylePattern();
-            xmode = 'styleproperty';
-            if (nexttoken.id === ';') {
-                advance(';');
-            } else {
-                advance('{');
-                substyle();
-                xmode = 'style';
-                advance('}');
-            }
-        }
-    }
-
-
-// HTML parsing.
-
-    function doBegin(n) {
-        if (n !== 'html' && !option.fragment) {
-            if (n === 'div' && option.adsafe) {
-                error("ADSAFE: Use the fragment option.");
-            } else {
-                error("Expected '{a}' and instead saw '{b}'.",
-                    token, 'html', n);
-            }
-        }
-        if (option.adsafe) {
-            if (n === 'html') {
-                error(
-"Currently, ADsafe does not operate on whole HTML documents. It operates on <div> fragments and .js files.", token);
-            }
-            if (option.fragment) {
-                if (n !== 'div') {
-                    error("ADsafe violation: Wrap the widget in a div.", token);
-                }
-            } else {
-                error("Use the fragment option.", token);
-            }
-        }
-        option.browser = true;
-        assume();
-    }
-
-    function doAttribute(n, a, v) {
-        var u, x;
-        if (a === 'id') {
-            u = typeof v === 'string' ? v.toUpperCase() : '';
-            if (ids[u] === true) {
-                warning("Duplicate id='{a}'.", nexttoken, v);
-            }
-            if (!/^[A-Za-z][A-Za-z0-9._:\-]*$/.test(v)) {
-                warning("Bad id: '{a}'.", nexttoken, v);
-            } else if (option.adsafe) {
-                if (adsafe_id) {
-                    if (v.slice(0, adsafe_id.length) !== adsafe_id) {
-                        warning("ADsafe violation: An id must have a '{a}' prefix",
-                                nexttoken, adsafe_id);
-                    } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) {
-                        warning("ADSAFE violation: bad id.");
-                    }
-                } else {
-                    adsafe_id = v;
-                    if (!/^[A-Z]+_$/.test(v)) {
-                        warning("ADSAFE violation: bad id.");
-                    }
-                }
-            }  
-            x = v.search(dx);
-            if (x >= 0) {
-                warning("Unexpected character '{a}' in {b}.", token, v.charAt(x), a);
-            }
-            ids[u] = true;
-        } else if (a === 'class' || a === 'type' || a === 'name') {
-            x = v.search(qx);
-            if (x >= 0) {
-                warning("Unexpected character '{a}' in {b}.", token, v.charAt(x), a);
-            }
-            ids[u] = true;
-        } else if (a === 'href' || a === 'background' ||
-                a === 'content' || a === 'data' ||
-                a.indexOf('src') >= 0 || a.indexOf('url') >= 0) {
-            if (option.safe && ux.test(v)) {
-                error("ADsafe URL violation.");
-            }
-            urls.push(v);
-        } else if (a === 'for') {
-            if (option.adsafe) {
-                if (adsafe_id) {
-                    if (v.slice(0, adsafe_id.length) !== adsafe_id) {
-                        warning("ADsafe violation: An id must have a '{a}' prefix",
-                                nexttoken, adsafe_id);
-                    } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) {
-                        warning("ADSAFE violation: bad id.");
-                    }
-                } else {
-                    warning("ADSAFE violation: bad id.");
-                }
-            }
-        } else if (a === 'name') {
-            if (option.adsafe && v.indexOf('_') >= 0) {
-                warning("ADsafe name violation.");
-            }
-        }
-    }
-
-    function doTag(n, a) {
-        var i, t = htmltag[n], x;
-        src = false;
-        if (!t) {
-            error("Unrecognized tag '<{a}>'.",
-                    nexttoken,
-                    n === n.toLowerCase() ? n :
-                        n + ' (capitalization error)');
-        }
-        if (stack.length > 0) {
-            if (n === 'html') {
-                error("Too many <html> tags.", token);
-            }
-            x = t.parent;
-            if (x) {
-                if (x.indexOf(' ' + stack[stack.length - 1].name + ' ') < 0) {
-                    error("A '<{a}>' must be within '<{b}>'.",
-                            token, n, x);
-                }
-            } else if (!option.adsafe && !option.fragment) {
-                i = stack.length;
-                do {
-                    if (i <= 0) {
-                        error("A '<{a}>' must be within '<{b}>'.",
-                                token, n, 'body');
-                    }
-                    i -= 1;
-                } while (stack[i].name !== 'body');
-            }
-        }
-        switch (n) {
-        case 'div':
-            if (option.adsafe && stack.length === 1 && !adsafe_id) {
-                warning("ADSAFE violation: missing ID_.");
-            }
-            break;
-        case 'script':
-            xmode = 'script';
-            advance('>');
-            indent = nexttoken.from;
-            if (a.lang) {
-                warning("lang is deprecated.", token);
-            }
-            if (option.adsafe && stack.length !== 1) {
-                warning("ADsafe script placement violation.", token);
-            }
-            if (a.src) {
-                if (option.adsafe && (!adsafe_may || !approved[a.src])) {
-                    warning("ADsafe unapproved script source.", token);
-                }
-                if (a.type) {
-                    warning("type is unnecessary.", token);
-                }
-            } else {
-                if (adsafe_went) {
-                    error("ADsafe script violation.", token);
-                }
-                statements('script');
-            }
-            xmode = 'html';
-            advance('</');
-            if (!nexttoken.identifier && nexttoken.value !== 'script') {
-                warning("Expected '{a}' and instead saw '{b}'.",
-                        nexttoken, 'script', nexttoken.value);
-            }
-            advance();
-            xmode = 'outer';
-            break;
-        case 'style':
-            xmode = 'style';
-            advance('>');
-            styles();
-            xmode = 'html';
-            advance('</');
-            if (!nexttoken.identifier && nexttoken.value !== 'style') {
-                warning("Expected '{a}' and instead saw '{b}'.",
-                        nexttoken, 'style', nexttoken.value);
-            }
-            advance();
-            xmode = 'outer';
-            break;
-        case 'input':
-            switch (a.type) {
-            case 'radio':
-            case 'checkbox':
-            case 'button':
-            case 'reset':
-            case 'submit':
-                break;
-            case 'text':
-            case 'file':
-            case 'password':
-            case 'file':
-            case 'hidden':
-            case 'image':
-                if (option.adsafe && a.autocomplete !== 'off') {
-                    warning("ADsafe autocomplete violation.");
-                }
-                break;
-            default:
-                warning("Bad input type.");
-            }
-            break;
-        case 'applet':
-        case 'body':
-        case 'embed':
-        case 'frame':
-        case 'frameset':
-        case 'head':
-        case 'iframe':
-        case 'noembed':
-        case 'noframes':
-        case 'object':
-        case 'param':
-            if (option.adsafe) {
-                warning("ADsafe violation: Disallowed tag: " + n);
-            }
-            break;
-        }
-    }
-
-
-    function closetag(n) {
-        return '</' + n + '>';
-    }
-
-    function html() {
-        var a, attributes, e, n, q, t, v, w = option.white, wmode;
-        xmode = 'html';
-        xquote = '';
-        stack = null;
-        for (;;) {
-            switch (nexttoken.value) {
-            case '<':
-                xmode = 'html';
-                advance('<');
-                attributes = {};
-                t = nexttoken;
-                if (!t.identifier) {
-                    warning("Bad identifier {a}.", t, t.value);
-                }
-                n = t.value;
-                if (option.cap) {
-                    n = n.toLowerCase();
-                }
-                t.name = n;
-                advance();
-                if (!stack) {
-                    stack = [];
-                    doBegin(n);
-                }
-                v = htmltag[n];
-                if (typeof v !== 'object') {
-                    error("Unrecognized tag '<{a}>'.", t, n);
-                }
-                e = v.empty;
-                t.type = n;
-                for (;;) {
-                    if (nexttoken.id === '/') {
-                        advance('/');
-                        if (nexttoken.id !== '>') {
-                            warning("Expected '{a}' and instead saw '{b}'.",
-                                    nexttoken, '>', nexttoken.value);
-                        }
-                        break;
-                    }
-                    if (nexttoken.id && nexttoken.id.substr(0, 1) === '>') {
-                        break;
-                    }
-                    if (!nexttoken.identifier) {
-                        if (nexttoken.id === '(end)' || nexttoken.id === '(error)') {
-                            error("Missing '>'.", nexttoken);
-                        }
-                        warning("Bad identifier.");
-                    }
-                    option.white = true;
-                    nonadjacent(token, nexttoken);
-                    a = nexttoken.value;
-                    option.white = w;
-                    advance();
-                    if (!option.cap && a !== a.toLowerCase()) {
-                        warning("Attribute '{a}' not all lower case.", nexttoken, a);
-                    }
-                    a = a.toLowerCase();
-                    xquote = '';
-                    if (is_own(attributes, a)) {
-                        warning("Attribute '{a}' repeated.", nexttoken, a);
-                    }
-                    if (a.slice(0, 2) === 'on') {
-                        if (!option.on) {
-                            warning("Avoid HTML event handlers.");
-                        }
-                        xmode = 'scriptstring';
-                        advance('=');
-                        q = nexttoken.id;
-                        if (q !== '"' && q !== "'") {
-                            error("Missing quote.");
-                        }
-                        xquote = q;
-                        wmode = option.white;
-                        option.white = false;
-                        advance(q);
-                        statements('on');
-                        option.white = wmode;
-                        if (nexttoken.id !== q) {
-                            error("Missing close quote on script attribute.");
-                        }
-                        xmode = 'html';
-                        xquote = '';
-                        advance(q);
-                        v = false;
-                    } else if (a === 'style') {
-                        xmode = 'scriptstring';
-                        advance('=');
-                        q = nexttoken.id;
-                        if (q !== '"' && q !== "'") {
-                            error("Missing quote.");
-                        }
-                        xmode = 'styleproperty';
-                        xquote = q;
-                        advance(q);
-                        substyle();
-                        xmode = 'html';
-                        xquote = '';
-                        advance(q);
-                        v = false;
-                    } else {
-                        if (nexttoken.id === '=') {
-                            advance('=');
-                            v = nexttoken.value;
-                            if (!nexttoken.identifier &&
-                                    nexttoken.id !== '"' &&
-                                    nexttoken.id !== '\'' &&
-                                    nexttoken.type !== '(string)' &&
-                                    nexttoken.type !== '(number)' &&
-                                    nexttoken.type !== '(color)') {
-                                warning("Expected an attribute value and instead saw '{a}'.", token, a);
-                            }
-                            advance();
-                        } else {
-                            v = true;
-                        }
-                    }
-                    attributes[a] = v;
-                    doAttribute(n, a, v);
-                }
-                doTag(n, attributes);
-                if (!e) {
-                    stack.push(t);
-                }
-                xmode = 'outer';
-                advance('>');
-                break;
-            case '</':
-                xmode = 'html';
-                advance('</');
-                if (!nexttoken.identifier) {
-                    warning("Bad identifier.");
-                }
-                n = nexttoken.value;
-                if (option.cap) {
-                    n = n.toLowerCase();
-                }
-                advance();
-                if (!stack) {
-                    error("Unexpected '{a}'.", nexttoken, closetag(n));
-                }
-                t = stack.pop();
-                if (!t) {
-                    error("Unexpected '{a}'.", nexttoken, closetag(n));
-                }
-                if (t.name !== n) {
-                    error("Expected '{a}' and instead saw '{b}'.",
-                            nexttoken, closetag(t.name), closetag(n));
-                }
-                if (nexttoken.id !== '>') {
-                    error("Missing '{a}'.", nexttoken, '>');
-                }
-                xmode = 'outer';
-                advance('>');
-                break;
-            case '<!':
-                if (option.safe) {
-                    warning("ADsafe HTML violation.");
-                }
-                xmode = 'html';
-                for (;;) {
-                    advance();
-                    if (nexttoken.id === '>' || nexttoken.id === '(end)') {
-                        break;
-                    }
-                    if (nexttoken.value.indexOf('--') >= 0) {
-                        warning("Unexpected --.");
-                    }
-                    if (nexttoken.value.indexOf('<') >= 0) {
-                        warning("Unexpected <.");
-                    }
-                    if (nexttoken.value.indexOf('>') >= 0) {
-                        warning("Unexpected >.");
-                    }
-                }
-                xmode = 'outer';
-                advance('>');
-                break;
-            case '(end)':
-                return;
-            default:
-                if (nexttoken.id === '(end)') {
-                    error("Missing '{a}'.", nexttoken,
-                            '</' + stack[stack.length - 1].value + '>');
-                } else {
-                    advance();
-                }
-            }
-            if (stack && stack.length === 0 && (option.adsafe ||
-                    !option.fragment || nexttoken.id === '(end)')) {
-                break;
-            }
-        }
-        if (nexttoken.id !== '(end)') {
-            error("Unexpected material after the end.");
-        }
-    }
-
-
-// Build the syntax table by declaring the syntactic elements of the language.
-
-    type('(number)', idValue);
-    type('(string)', idValue);
-
-    syntax['(identifier)'] = {
-        type: '(identifier)',
-        lbp: 0,
-        identifier: true,
-        nud: function () {
-            var v = this.value,
-                s = scope[v],
-                f;
-            if (typeof s === 'function') {
-                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 'label':
-                    warning("'{a}' is a statement label.", token, v);
-                    break;
-                }
-
-// The name is not defined in the function.  If we are in the global scope,
-// then we have an undefined variable.
-
-            } else if (funct['(global)']) {
-                if (option.undef && predefined[v] !== 'boolean') {
-                    warning("'{a}' is not defined.", token, v);
-                }
-                note_implied(token);
-
-// If the name is already defined in the current
-// function, but not as outer, then there is a scope error.
-
-            } else {
-                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') {
-                        if (option.undef) {
-                            warning("'{a}' is not defined.", token, v);
-                        } else {
-                            funct[v] = true;
-                        }
-                        note_implied(token);
-                    } else {
-                        switch (s[v]) {
-                        case 'function':
-                        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;
-    });
-
-    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');
-    reservevar('eval');
-    reservevar('false');
-    reservevar('Infinity');
-    reservevar('NaN');
-    reservevar('null');
-    reservevar('this');
-    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 = parse(10);
-        advance(':');
-        that['else'] = parse(10);
-        return that;
-    }, 30);
-
-    infix('||', 'or', 40);
-    infix('&&', 'and', 50);
-    bitwise('|', 'bitor', 70);
-    bitwise('^', 'bitxor', 80);
-    bitwise('&', 'bitand', 90);
-    relation('==', function (left, right) {
-        if (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) {
-        if (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 = parse(130);
-        if (left && right && left.id === '(string)' && right.id === '(string)') {
-            left.value += right.value;
-            left.character = right.character;
-            if (jx.test(left.value)) {
-                warning("JavaScript URL.", left);
-            }
-            return left;
-        }
-        that.left = left;
-        that.right = right;
-        return that;
-    }, 130);
-    prefix('+', 'num');
-    infix('-', 'sub', 130);
-    prefix('-', 'neg');
-    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 = parse(0);
-        if (!p || (p.id !== '.' && p.id !== '[')) {
-            warning("Expected '{a}' and instead saw '{b}'.",
-                    nexttoken, '.', nexttoken.value);
-        }
-        this.first = p;
-        return this;
-    }).exps = true;
-
-
-    prefix('~', function () {
-        if (option.bitwise) {
-            warning("Unexpected '{a}'.", this, '~');
-        }
-        parse(150);
-        return this;
-    });
-    prefix('!', function () {
-        this.right = parse(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 = parse(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 'Array':
-                    if (nexttoken.id !== '(') {
-                        warning("Use the array literal notation [].", token);
-                    } else {
-                        advance('(');
-                        if (nexttoken.id === ')') {
-                            warning("Use the array literal notation [].", token);
-                        } else {
-                            i = parse(0);
-                            c.dimension = i;
-                            if ((i.id === '(number)' && /[.+\-Ee]/.test(i.value)) ||
-                                    (i.id === '-' && !i.right) ||
-                                    i.id === '(string)' || i.id === '[' ||
-                                    i.id === '{' || i.id === 'true' ||
-                                    i.id === 'false' ||
-                                    i.id === 'null' || i.id === 'undefined' ||
-                                    i.id === 'Infinity') {
-                                warning("Use the array literal notation [].", token);
-                            }
-                            if (nexttoken.id !== ')') {
-                                error("Use the array literal notation [].", token);
-                            }
-                        }
-                        advance(')');
-                    }
-                    this.first = c;
-                    return this;
-                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 {
-            warning("Weird construction. Delete 'new'.", this);
-        }
-        adjacent(token, nexttoken);
-        if (nexttoken.id !== '(') {
-            warning("Missing '()' invoking a constructor.");
-        }
-        this.first = c;
-        return this;
-    });
-    syntax['new'].exps = true;
-
-    infix('.', function (left, that) {
-        adjacent(prevtoken, token);
-        var m = identifier();
-        if (typeof m === 'string') {
-            countMember(m);
-        }
-        that.left = left;
-        that.right = m;
-        if (!option.evil && left && left.value === 'document' &&
-                (m === 'write' || m === 'writeln')) {
-            warning("document.write can be a form of eval.", left);
-        } else if (option.adsafe) {
-            if (left && left.value === 'ADSAFE') {
-                if (m === 'id' || m === 'lib') {
-                    warning("ADsafe violation.", that);
-                } else if (m === 'go') {
-                    if (xmode !== 'script') {
-                        warning("ADsafe violation.", that);
-                    } else if (adsafe_went || nexttoken.id !== '(' ||
-                            peek(0).id !== '(string)' ||
-                            peek(0).value !== adsafe_id ||
-                            peek(1).id !== ',') {
-                        error("ADsafe violation: go.", that);
-                    }
-                    adsafe_went = true;
-                    adsafe_may = false;
-                }
-            }
-        }
-        if (!option.evil && (m === 'eval' || m === 'execScript')) {
-            warning('eval is evil.');
-        } else if (option.safe) {
-            for (;;) {
-                if (banned[m] === true) {
-                    warning("ADsafe restricted word '{a}'.", token, m);
-                }
-                if (typeof predefined[left.value] !== 'boolean' ||
-                        nexttoken.id === '(') {
-                    break;
-                }
-                if (standard_member[m] === true) {
-                    if (nexttoken.id === '.') {
-                        warning("ADsafe violation.", that);
-                    }
-                    break;
-                }
-                if (nexttoken.id !== '.') {
-                    warning("ADsafe violation.", that);
-                    break;
-                }
-                advance('.');
-                token.left = that;
-                token.right = m;
-                that = token;
-                m = identifier();
-                if (typeof m === 'string') {
-                    countMember(m);
-                }
-            }
-        }
-        return that;
-    }, 160, true);
-
-    infix('(', function (left, that) {
-        adjacent(prevtoken, token);
-        nospace();
-        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);
-                        }
-                    }
-                }
-            } else if (left.id === '.') {
-                if (option.safe && left.left.value === 'Math' &&
-                        left.right === 'random') {
-                    warning("ADsafe violation.", left);
-                }
-            }
-        }
-        if (nexttoken.id !== ')') {
-            for (;;) {
-                p[p.length] = parse(10);
-                n += 1;
-                if (nexttoken.id !== ',') {
-                    break;
-                }
-                comma();
-            }
-        }
-        advance(')');
-        if (option.immed && left.id === 'function' && nexttoken.id !== ')') {
-            warning("Wrap the entire immediate function invocation in parens.",
-                that);
-        }
-        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();
-        var v = parse(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) {
-        nospace();
-        var e = parse(0), s;
-        if (e && e.type === '(string)') {
-            if (option.safe && banned[e.value] === true) {
-                warning("ADsafe restricted word '{a}'.", that, e.value);
-            } else if (!option.evil &&
-                    (e.value === 'eval' || e.value === 'execScript')) {
-                warning("eval is evil.", that);
-            } else if (option.safe &&
-                    (e.value.charAt(0) === '_' || e.value.charAt(0) === '-')) {
-                warning("ADsafe restricted subscript '{a}'.", that, e.value);
-            }
-            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);
-                }
-            }
-        } else if (!e || e.type !== '(number)' || e.value < 0) {
-            if (option.safe) {
-                warning('ADsafe subscripting.');
-            }
-        }
-        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(parse(10));
-            if (nexttoken.id === ',') {
-                comma();
-                if (nexttoken.id === ']') {
-                    warning("Extra comma.", token);
-                    break;
-                }
-            } else {
-                break;
-            }
-        }
-        if (b) {
-            indent -= option.indent;
-            indentation();
-        }
-        advance(']', this);
-        return this;
-    }, 160);
-
-    (function (x) {
-        x.nud = function () {
-            var b, i, s, seen = {};
-            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();
-                }
-                i = optionalidentifier(true);
-                if (!i) {
-                    if (nexttoken.id === '(string)') {
-                        i = nexttoken.value;
-                        if (ix.test(i)) {
-                            s = syntax[i];
-                        }
-                        advance();
-                    } else if (nexttoken.id === '(number)') {
-                        i = nexttoken.value.toString();
-                        advance();
-                    } else {
-                        error("Expected '{a}' and instead saw '{b}'.",
-                                nexttoken, '}', nexttoken.value);
-                    }
-                }
-                if (seen[i] === true) {
-                    warning("Duplicate member '{a}'.", nexttoken, i);
-                }
-                seen[i] = true;
-                countMember(i);
-                advance(':');
-                nonadjacent(token, nexttoken);
-                parse(10);
-                if (nexttoken.id === ',') {
-                    comma();
-                    if (nexttoken.id === ',' || nexttoken.id === '}') {
-                        warning("Extra comma.", token);
-                    }
-                } else {
-                    break;
-                }
-            }
-            if (b) {
-                indent -= option.indent;
-                indentation();
-            }
-            advance('}', this);
-            return this;
-        };
-        x.fud = function () {
-            error("Expected to see a statement and instead saw a block.", token);
-        };
-    }(delim('{')));
-
-
-    function varstatement(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 (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 = parse(0);
-                name.first = value;
-            }
-            if (nexttoken.id !== ',') {
-                break;
-            }
-            comma();
-        }
-        return this;
-    }
-
-
-    stmt('var', varstatement).exps = true;
-
-
-    function functionparams() {
-        var i, t = nexttoken, p = [];
-        advance('(');
-        nospace();
-        if (nexttoken.id === ')') {
-            advance(')');
-            nospace(prevtoken, token);
-            return;
-        }
-        for (;;) {
-            i = identifier();
-            p.push(i);
-            addlabel(i, 'parameter');
-            if (nexttoken.id === ',') {
-                comma();
-            } else {
-                advance(')', t);
-                nospace(prevtoken, token);
-                return p;
-            }
-        }
-    }
-
-    function doFunction(i) {
-        var s = scope;
-        scope = Object.create(s);
-        funct = {
-            '(name)'    : i || '"' + anonname + '"',
-            '(line)'    : nexttoken.line,
-            '(context)' : funct,
-            '(breakage)': 0,
-            '(loopage)' : 0,
-            '(scope)'   : scope
-        };
-        token.funct = funct;
-        functions.push(funct);
-        if (i) {
-            addlabel(i, 'function');
-        }
-        funct['(params)'] = functionparams();
-
-        block(false);
-        scope = s;
-        funct['(last)'] = token.line;
-        funct = funct['(context)'];
-    }
-
-
-    blockstmt('function', function () {
-        if (inblock) {
-            warning(
-"Function statements cannot be placed in blocks. Use a function expression or move the statement to the top of the outer function.", token);
-
-        }
-        var i = identifier();
-        adjacent(token, nexttoken);
-        addlabel(i, 'unused');
-        doFunction(i);
-        if (nexttoken.id === '(' && nexttoken.line === token.line) {
-            error(
-"Function statements 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 (funct['(loopage)']) {
-            warning("Don't make functions within a loop.");
-        }
-        return this;
-    });
-
-    blockstmt('if', function () {
-        var t = nexttoken;
-        advance('(');
-        nonadjacent(this, t);
-        nospace();
-        parse(20);
-        if (nexttoken.id === '=') {
-            warning("Expected a conditional expression and instead saw an assignment.");
-            advance('=');
-            parse(20);
-        }
-        advance(')', t);
-        nospace(prevtoken, token);
-        block(true);
-        if (nexttoken.id === 'else') {
-            nonadjacent(token, nexttoken);
-            advance('else');
-            if (nexttoken.id === 'if' || nexttoken.id === 'switch') {
-                statement(true);
-            } else {
-                block(true);
-            }
-        }
-        return this;
-    });
-
-    blockstmt('try', function () {
-        var b, e, s;
-        if (option.adsafe) {
-            warning("ADsafe try violation.", this);
-        }
-        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();
-        parse(20);
-        if (nexttoken.id === '=') {
-            warning("Expected a conditional expression and instead saw an assignment.");
-            advance('=');
-            parse(20);
-        }
-        advance(')', t);
-        nospace(prevtoken, token);
-        block(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 = parse(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:
-                    warning(
-                        "Expected a 'break' statement before 'case'.",
-                        token);
-                }
-                indentation(-option.indent);
-                advance('case');
-                this.cases.push(parse(20));
-                g = true;
-                advance(':');
-                funct['(verb)'] = 'case';
-                break;
-            case 'default':
-                switch (funct['(verb)']) {
-                case 'break':
-                case 'continue':
-                case 'return':
-                case 'throw':
-                    break;
-                default:
-                    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') {
-                    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 ':':
-                        statements();
-                        break;
-                    default:
-                        error("Missing ':' on a case clause.", token);
-                    }
-                } else {
-                    error("Expected '{a}' and instead saw '{b}'.",
-                        nexttoken, 'case', nexttoken.value);
-                }
-            }
-        }
-    }).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();
-            parse(20);
-            if (nexttoken.id === '=') {
-                warning("Expected a conditional expression and instead saw an assignment.");
-                advance('=');
-                parse(20);
-            }
-            advance(')', t);
-            nospace(prevtoken, token);
-            funct['(breakage)'] -= 1;
-            funct['(loopage)'] -= 1;
-            return this;
-        });
-        x.labelled = true;
-        x.exps = true;
-    }());
-
-    blockstmt('for', function () {
-        var f = option.forin, 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(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');
-            parse(20);
-            advance(')', t);
-            s = block(true);
-            if (!f && (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();
-                } else {
-                    for (;;) {
-                        parse(0, 'for');
-                        if (nexttoken.id !== ',') {
-                            break;
-                        }
-                        comma();
-                    }
-                }
-            }
-            nolinebreak(token);
-            advance(';');
-            if (nexttoken.id !== ';') {
-                parse(20);
-                if (nexttoken.id === '=') {
-                    warning("Expected a conditional expression and instead saw an assignment.");
-                    advance('=');
-                    parse(20);
-                }
-            }
-            nolinebreak(token);
-            advance(';');
-            if (nexttoken.id === ';') {
-                error("Expected '{a}' and instead saw '{b}'.",
-                        nexttoken, ')', ';');
-            }
-            if (nexttoken.id !== ')') {
-                for (;;) {
-                    parse(0, 'for');
-                    if (nexttoken.id !== ',') {
-                        break;
-                    }
-                    comma();
-                }
-            }
-            advance(')', t);
-            nospace(prevtoken, token);
-            block(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);
-        }
-        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);
-        }
-        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 () {
-        nolinebreak(this);
-        if (nexttoken.id === '(regexp)') {
-            warning("Wrap the /regexp/ literal in parens to disambiguate the slash operator.");
-        }
-        if (nexttoken.id !== ';' && !nexttoken.reach) {
-            nonadjacent(token, nexttoken);
-            this.first = parse(20);
-        }
-        reachable('return');
-        return this;
-    }).exps = true;
-
-
-    stmt('throw', function () {
-        nolinebreak(this);
-        nonadjacent(token, nexttoken);
-        this.first = parse(20);
-        reachable('throw');
-        return this;
-    }).exps = true;
-
-    reserve('void');
-
-//  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');
-
-    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__') {
-                        warning("Stupid key '{a}'.",
-                                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 JSLINT function itself.
-
-    var itself = function (s, o) {
-        var a, i;
-        JSLINT.errors = [];
-        predefined = Object.create(standard);
-        if (o) {
-            a = o.predef;
-            if (a instanceof Array) {
-                for (i = 0; i < a.length; i += 1) {
-                    predefined[a[i]] = true;
-                }
-            }
-            if (o.adsafe) {
-                o.safe = true;
-            }
-            if (o.safe) {
-                o.browser = false;
-                o.css     = false;
-                o.debug   = false;
-                o.devel   = false;
-                o.eqeqeq  = true;
-                o.evil    = false;
-                o.forin   = false;
-                o.nomen   = true;
-                o.on      = false;
-                o.rhino   = false;
-                o.safe    = true;
-                o.sidebar = false;
-                o.strict  = true;
-                o.sub     = false;
-                o.undef   = true;
-                o.widget  = false;
-                predefined.Date = null;
-                predefined['eval'] = null;
-                predefined.Function = null;
-                predefined.Object = null;
-                predefined.ADSAFE = false;
-                predefined.lib = false;
-            }
-            option = o;
-        } else {
-            option = {};
-        }
-        option.indent = option.indent || 4;
-        option.maxerr = option.maxerr || 50;
-        adsafe_id = '';
-        adsafe_may = false;
-        adsafe_went = false;
-        approved = {};
-        if (option.approved) {
-            for (i = 0; i < option.approved.length; i += 1) {
-                approved[option.approved[i]] = option.approved[i];
-            }
-        } else {
-            approved.test = 'test';
-        }
-        tab = '';
-        for (i = 0; i < option.indent; i += 1) {
-            tab += ' ';
-        }
-        indent = 1;
-        global = Object.create(predefined);
-        scope = global;
-        funct = {
-            '(global)': true,
-            '(name)': '(global)',
-            '(scope)': scope,
-            '(breakage)': 0,
-            '(loopage)': 0
-        };
-        functions = [funct];
-        ids = {};
-        urls = [];
-        src = false;
-        xmode = false;
-        stack = null;
-        member = {};
-        membersOnly = null;
-        implied = {};
-        inblock = false;
-        lookahead = [];
-        jsonmode = false;
-        warnings = 0;
-        lex.init(s);
-        prereg = true;
-        strict_mode = false;
-
-        prevtoken = token = nexttoken = syntax['(begin)'];
-        assume();
-
-        try {
-            advance();
-            if (nexttoken.value.charAt(0) === '<') {
-                html();
-                if (option.adsafe && !adsafe_went) {
-                    warning("ADsafe violation: Missing ADSAFE.go.", this);
-                }
-            } else {
-                switch (nexttoken.id) {
-                case '{':
-                case '[':
-                    option.laxbreak = true;
-                    jsonmode = true;
-                    jsonValue();
-                    break;
-                case '@':
-                case '*':
-                case '#':
-                case '.':
-                case ':':
-                    xmode = 'style';
-                    advance();
-                    if (token.id !== '@' || !nexttoken.identifier ||
-                            nexttoken.value !== 'charset' || token.line !== 1 ||
-                            token.from !== 1) {
-                        error('A css file should begin with @charset "UTF-8";');
-                    }
-                    advance();
-                    if (nexttoken.type !== '(string)' &&
-                            nexttoken.value !== 'UTF-8') {
-                        error('A css file should begin with @charset "UTF-8";');
-                    }
-                    advance();
-                    advance(';');
-                    styles();
-                    break;
-
-                default:
-                    if (option.adsafe && option.fragment) {
-                        error("Expected '{a}' and instead saw '{b}'.",
-                            nexttoken, '<div>', nexttoken.value);
-                    }
-                    statements('lib');
-                }
-            }
-            advance('(end)');
-        } catch (e) {
-            if (e) {
-                JSLINT.errors.push({
-                    reason    : e.message,
-                    line      : e.line || nexttoken.line,
-                    character : e.character || nexttoken.from
-                }, null);
-            }
-        }
-        return JSLINT.errors.length === 0;
-    };
-
-    function is_array(o) {
-        return Object.prototype.toString.apply(o) === '[object Array]';
-    }
-
-    function to_array(o) {
-        var a = [], k;
-        for (k in o) {
-            if (is_own(o, k)) {
-                a.push(k);
-            }
-        }
-        return a;
-    }
-
-// Data summary.
-
-    itself.data = function () {
-
-        var data = {functions: []}, 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 = to_array(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 (is_array(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 (xmode === 'style') {
-                o.push('<p>CSS.</p>');
-            } else 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 = to_array(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.jslint = itself;
-
-    itself.edition = '2010-02-20';
-
-    if (typeof exports !== "undefined") {
-        exports.JSLINT = itself;
-    }
-
-    return itself;
-
-}());
diff --git a/build/build/lib/parse-js.js b/build/build/lib/parse-js.js
deleted file mode 100644
index 8edecb733..000000000
--- a/build/build/lib/parse-js.js
+++ /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/build/lib/process.js b/build/build/lib/process.js
deleted file mode 100644
index 3878c8d62..000000000
--- a/build/build/lib/process.js
+++ /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/build/lib/squeeze-more.js b/build/build/lib/squeeze-more.js
deleted file mode 100644
index 12380af82..000000000
--- a/build/build/lib/squeeze-more.js
+++ /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/build/minify-js.sh b/build/build/minify-js.sh
deleted file mode 100755
index 2633a2f57..000000000
--- a/build/build/minify-js.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash
-dir=$(dirname $0)
-`which node nodejs 2> /dev/null` $dir/uglify.js $1 > $2
diff --git a/build/build/sizer.js b/build/build/sizer.js
deleted file mode 100644
index bdd27c6c4..000000000
--- a/build/build/sizer.js
+++ /dev/null
@@ -1,41 +0,0 @@
-var fs = require( "fs" ),
-	stdin = process.openStdin(),
-	rsize = /(\d+).*?(jquery\S+)/g,
-	oldsizes = {},
-	sizes = {},
-	input = "";
-
-stdin.setEncoding( "utf8" );
-
-try {
-	oldsizes = JSON.parse( fs.readFileSync(  __dirname + "/.sizecache.json", "utf8" ) );
-} catch(e) {
-	oldsizes = {};
-};
-
-function lpad( str, len, chr ) {
-	return ( Array(len+1).join( chr || " ") + str ).substr( -len );
-}
-
-stdin.on( "data" , function( chunk ) {
-	input += chunk;
-});
-stdin.on( "end", function() {
-	var match;
-
-	while ( match = rsize.exec( input ) ) {
-		sizes[ match[2] ] = parseInt( match[1], 10 );
-	}
-
-	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( oldsizes[key] ? "(" + diff + ")" : "(-)", 8 ), key );
-	}
-	process.nextTick(function() {
-		process.exit();
-	});
-});
\ No newline at end of file
diff --git a/build/build/style.xsl b/build/build/style.xsl
deleted file mode 100644
index 32daeed94..000000000
--- a/build/build/style.xsl
+++ /dev/null
@@ -1,211 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
-<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
-<xsl:output method="html" />
-	
-	<xsl:template name="ref">
-		<xsl:text>link-</xsl:text>
-		<xsl:value-of select="translate(@name, '$.|', '')"/>
-		<xsl:text>-</xsl:text>
-		<xsl:for-each select="params">
-			<xsl:value-of select="translate(@name, '&lt;&gt;|$.', '')" />
-		</xsl:for-each>
-	</xsl:template>
-
-	<xsl:template name="href">
-		<xsl:attribute name="href">
-			<xsl:text>#</xsl:text>
-			<xsl:call-template name="ref" />
-		</xsl:attribute>
-	</xsl:template>
-	
-	<xsl:template name="id">
-		<xsl:attribute name="id">
-			<xsl:call-template name="ref" />
-		</xsl:attribute>
-	</xsl:template>
-	
-	<xsl:template name="return">
-		<xsl:attribute name="title">
-			<xsl:choose>
-				<xsl:when test="@return='jQuery'">A jQuery object.</xsl:when>
-				<xsl:when test="@return='Boolean'">true or false.</xsl:when>
-				<xsl:when test="@return='Object'">A simple Javascript object..</xsl:when>
-				<xsl:when test="@return='String'">A string of characters.</xsl:when>
-				<xsl:when test="@return='Number'">A valid numeric.</xsl:when>
-				<xsl:when test="@return='String|Number'">A string of characters or a number.</xsl:when>
-				<xsl:when test="@return='Element'">The Javascript object representation of a DOM Element.</xsl:when>
-				<xsl:when test="@return='Element|Array&lt;Element&gt;'">One or more DOM Elements (a single one or an array).</xsl:when>
-				<xsl:when test="@return='Map'">A Javascript object that contains key/value pairs in the form of properties and values.</xsl:when>
-				<xsl:when test="@return='Array&lt;Element&gt;'">An Array of DOM Elements.</xsl:when>
-				<xsl:when test="@return='Array&lt;String&gt;'">An Array of strings.</xsl:when>
-				<xsl:when test="@return='Function'">A reference to a Javascript function.</xsl:when>
-				<xsl:when test="@return='XMLHttpRequest'">An XMLHttpRequest object (referencing a HTTP request).</xsl:when>
-			</xsl:choose>
-		</xsl:attribute>
-		<xsl:value-of select="@return"/>
-	</xsl:template>
-
-	<xsl:template name="type">
-		<xsl:attribute name="title">
-			<xsl:choose>
-				<xsl:when test="@type='jQuery'">A jQuery object.</xsl:when>
-				<xsl:when test="@type='Boolean'">true or false.</xsl:when>
-				<xsl:when test="@type='Object'">A simple Javascript object..</xsl:when>
-				<xsl:when test="@type='String'">A string of characters.</xsl:when>
-				<xsl:when test="@type='Number'">A valid numeric.</xsl:when>
-				<xsl:when test="@type='String|Number'">A string of characters or a number.</xsl:when>
-				<xsl:when test="@type='Element'">The Javascript object representation of a DOM Element.</xsl:when>
-				<xsl:when test="@type='Element|Array&lt;Element&gt;'">One or more DOM Elements (a single one or an array).</xsl:when>
-				<xsl:when test="@type='Map'">A Javascript object that contains key/value pairs in the form of properties and values.</xsl:when>
-				<xsl:when test="@type='Array&lt;Element&gt;'">An Array of DOM Elements.</xsl:when>
-				<xsl:when test="@type='Array&lt;String&gt;'">An Array of strings.</xsl:when>
-				<xsl:when test="@type='Function'">A reference to a Javascript function.</xsl:when>
-				<xsl:when test="@type='XMLHttpRequest'">An XMLHttpRequest object (referencing a HTTP request).</xsl:when>
-			</xsl:choose>
-		</xsl:attribute>
-		<xsl:value-of select="@type"/>
-	</xsl:template>
-	
-	<xsl:template name="break">
-		<xsl:value-of select="." disable-output-escaping="yes" />
-	</xsl:template>
-	
-	<xsl:template name="option">
-		<div class="param">
-			<div class="param-header">
-				<h3><span><xsl:value-of select="@name"/></span></h3>
-				<p class="param-type"><span><xsl:call-template name="type" /></span></p>
-				<p class="param-default">Default: <xsl:value-of select="@default"/></p>
-			</div>
-			<div class="param-details">
-				<p><xsl:value-of select="desc"/></p>
-				<!-- TODO select all examples -->
-				<xsl:for-each select="following-sibling::example[1]">
-					<h4>Code sample:</h4>
-					<p><xsl:value-of select="desc" disable-output-escaping="yes"/></p>
-					<code>
-						<xsl:value-of select="code"/>
-					</code>
-				</xsl:for-each>
-			</div>
-		</div>
-	</xsl:template>
-	
-	<xsl:template match="/*">
-		<div id="widget-docs">
-			<ul>
-				<li><a href="#docs-overview"><span>Overview</span></a></li>
-				<li><a href="#docs-options"><span>Options</span></a></li>
-				<li><a href="#docs-methods"><span>Methods</span></a></li>
-				<li><a href="#docs-theming"><span>Theming</span></a></li>
-			</ul>
-			
-		<!-- TAB 1 -->
-			<div id="docs-overview">
-				<div id="docs-overview-sidebar">
-					<h4>Dependencies:</h4>
-					<ul>							
-						<li><a href="#">jquery.ui.core.js</a></li>
-						<li><a href="#">jquery.ui.draggable.js <span>(Optional)</span></a></li>
-						<li><a href="#">jquery.ui.resizable.js <span>(Optional)</span></a></li>
-					</ul>
-				</div>
-				<div id="docs-overview-main">
-					<p>
-						<xsl:for-each select="//function[1]/desc">
-							<xsl:call-template name="break" />
-						</xsl:for-each>
-					</p>
-					<p>
-						<xsl:for-each select="//function[1]/longdesc">
-							<xsl:call-template name="break" />
-						</xsl:for-each>
-					</p>
-				</div>
-			</div>
-			
-		<!-- TAB 2 -->
-			<div id="docs-options">
-				<p class="intro"><xsl:value-of select="//function[1]/params/desc"/></p>
-				
-				<div class="docs-list-header clearfix">
-					<h2>Property options</h2>
-					<p><a href="#">Show details</a> | <a href="#">Hide details</a></p>
-				</div>
-				
-				<div class="docs-list clearfix">
-					<xsl:for-each select="//function[1]/option[not(starts-with(@type, 'function'))]">
-						<xsl:call-template name="option"/>
-					</xsl:for-each>
-				</div><!-- /property options -->
-				
-				<div class="docs-list-header clearfix">
-					<h2>Event options</h2>
-					<p><a href="#">Show details</a> | <a href="#">Hide details</a></p>
-				</div>
-				
-				<div class="docs-list clearfix">
-					<xsl:for-each select="//function[1]/option[starts-with(@type, 'function')]">
-						<xsl:call-template name="option"/>
-					</xsl:for-each>
-				</div><!-- /event options -->
-			</div>
-		
-		<!-- TAB 3 -->	
-			<div id="docs-methods">
-				<p class="intro">A brief description of methods and their uses goes here so their use is clearly explained and any caveats can be mentioned up front.</p>
-				
-				<div class="docs-list-header clearfix">
-					<h2>Methods</h2>
-					<p><a href="#">Show details</a> | <a href="#">Hide details</a></p>
-				</div>
-				
-				<div class="docs-list clearfix">
-					<xsl:for-each select="//function[position() != 1]">
-						<div class="param">
-							<div class="param-header">
-								<h3><span><xsl:value-of select="//function[1]/@name"/>( <xsl:value-of select="params[1]/@name"/>
-								<xsl:for-each select="params[position() != 1]">
-									<xsl:text>, </xsl:text><xsl:value-of select="@name"/>
-								</xsl:for-each>
-								 )</span></h3>
-								<p class="param-type">Returns: <span><xsl:call-template name="return" /></span></p>
-							</div>
-							<div class="param-details">
-								<p><xsl:value-of select="desc"/></p>
-								<p><xsl:value-of select="longdesc"/></p>
-								<h4>Arguments:</h4>
-								<table class="param-args" summary="Arguments for this method" cellspacing="0">
-									<tbody>
-										<xsl:for-each select="params[position() != 1]">
-											<tr>
-												<td><xsl:value-of select="@name"/></td>
-												<td><xsl:value-of select="@type"/></td>
-												<td><xsl:value-of select="."/></td>
-											</tr>
-										</xsl:for-each>
-									</tbody>
-								</table>
-								
-								<h4>Code sample:</h4>
-								<xsl:for-each select="example">
-									<h5><xsl:value-of select="desc"/></h5>
-									<code>
-										<xsl:value-of select="code"/>
-									</code>
-								</xsl:for-each>
-							</div>
-						</div>
-					</xsl:for-each>
-					
-				</div><!-- /methods -->
-			</div>
-			
-		<!-- TAB 4 -->
-			<div id="docs-theming">
-				%%THEMING%%
-			</div>				
-		</div>
-	</xsl:template>
-
-</xsl:stylesheet>
diff --git a/build/build/uglify.js b/build/build/uglify.js
deleted file mode 100644
index 5b3fad4da..000000000
--- a/build/build/uglify.js
+++ /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 + "*/\n";
-                }
-        }
-        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."); }
-};
diff --git a/build/build/yuicompressor-2.4.2.jar b/build/build/yuicompressor-2.4.2.jar
deleted file mode 100644
index c29470bd0..000000000
--- a/build/build/yuicompressor-2.4.2.jar
+++ /dev/null
diff --git a/demos/position/default.html b/demos/position/default.html
index 202417348..01137be62 100644
--- a/demos/position/default.html
+++ b/demos/position/default.html
@@ -1,4 +1,4 @@
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
 <head>
 	<meta charset="utf-8">
@@ -37,53 +37,28 @@
 		width: 120px;
 		height: 40px;
 	}
-	.ui-flipped-top {
-		border-top: 3px solid #000000;
-	}
-	.ui-flipped-bottom {
-		border-bottom: 3px solid #000000;
-	}
-	.ui-flipped-left {
-		border-left: 3px solid #000000;
-	}
-	.ui-flipped-right {
-		border-right: 3px solid #000000;
-	}
 	select, input {
 		margin-left: 15px;
 	}
 	</style>
 	<script>
 	$(function() {
-		function position( using ) {
+		function position() {
 			$( ".positionable" ).position({
 				of: $( "#parent" ),
 				my: $( "#my_horizontal" ).val() + " " + $( "#my_vertical" ).val(),
 				at: $( "#at_horizontal" ).val() + " " + $( "#at_vertical" ).val(),
 				offset: $( "#offset" ).val(),
-				using: using,
-				collision: $( "#collision_horizontal" ).val() + ' ' + $( "#collision_vertical" ).val()
+				collision: $( "#collision_horizontal" ).val() + " " + $( "#collision_vertical" ).val()
 			});
 		}
 
 		$( ".positionable" ).css( "opacity", 0.5 );
 
-		$( ":input" ).bind( "click keyup change", function() { position(); });
+		$( ":input" ).bind( "click keyup change", position );
 
 		$( "#parent" ).draggable({
-			drag: function() { position(); }
-		});
-
-		$( ".positionable" ).draggable({
-			drag: function( event, ui ) {
-				// reset offset before calculating it
-				$( "#offset" ).val( "0" );
-				position(function( result ) {
-					$( "#offset" ).val( "" + ( ui.offset.left - result.left ) +
-						" " + ( ui.offset.top - result.top ) );
-					position();
-				});
-			}
+			drag: position
 		});
 
 		position();
@@ -142,7 +117,7 @@
 	</div>
 	<div style="padding-bottom: 20px;">
 		<b>offset:</b>
-		<input id="offset" type="text" size="15"/>
+		<input id="offset">
 	</div>
 	<div style="padding-bottom: 20px;">
 		<b>collision:</b>
diff --git a/grunt.js b/grunt.js
index 0887cad4c..7827961da 100644
--- a/grunt.js
+++ b/grunt.js
@@ -70,6 +70,8 @@ cssFiles.forEach(function( file ) {
 
 // csslint and cssmin tasks
 grunt.loadNpmTasks( "grunt-css" );
+// file size comparison tasks
+grunt.loadNpmTasks( "grunt-compare-size" );
 
 grunt.registerHelper( "strip_all_banners", function( filepath ) {
 	return grunt.file.read( filepath ).replace( /^\s*\/\*[\s\S]*?\*\/\s*/g, "" );
@@ -269,9 +271,8 @@ grunt.initConfig({
 			// TODO remove items from this list once rewritten
 			return !( /(effects.core|mouse|datepicker|draggable|droppable|resizable|selectable|sortable)\.js$/ ).test( file );
 		}),
-		grunt: "grunt.js"
-		// TODO enabled once fixed up
-		// tests: "tests/unit/**/*.js"
+		grunt: "grunt.js",
+		tests: "tests/unit/**/*.js"
 	},
 	csslint: {
 		// nothing: []
@@ -304,8 +305,7 @@ grunt.initConfig({
 			smarttabs: true,
 			// TODO: use "faux strict mode" https://github.com/jshint/jshint/issues/504
 			// strict: true,
-			// TODO: enable trailing
-			// trailing: true,
+			trailing: true,
 			undef: true
 		};
 
@@ -342,15 +342,53 @@ grunt.initConfig({
 			tests: {
 				options: extend({
 					browser: true,
-					jquery: true
+					jquery: true,
+					// TODO: this is only for document.write() https://github.com/jshint/jshint/issues/519
+					evil: true
 				}, defaults ),
+				// TODO: don't create so many globals in tests
 				globals: {
+					addMonths: true,
+					asyncTest: true,
+					container: true,
+					deepEqual: true,
+					d1: true,
+					d2: true,
+					dlg: true,
+					domEqual: true,
+					drag: true,
+					dragged: true,
+					el: true,
+					equal: true,
+					equalsDate: true,
+					expect: true,
+					Globalize: true,
+					heightAfter: true,
+					init: true,
+					isNotOpen: true,
+					isOpen: true,
+					modal: true,
 					module: true,
-					test: true,
+					moved: true,
+					notEqual: true,
+					offsetAfter: true,
+					offsetBefore: true,
 					ok: true,
-					equal: true,
-					deepEqual: true,
-					QUnit: true
+					PROP_NAME: true,
+					QUnit: true,
+					restoreScroll: true,
+					shouldBeDroppable: true,
+					shouldmove: true,
+					shouldNotBeDroppable: true,
+					shouldnotmove: true,
+					shouldnotresize: true,
+					shouldresize: true,
+					start: true,
+					strictEqual: true,
+					stop: true,
+					test: true,
+					TestHelpers: true,
+					widthAfter: true
 				}
 			}
 		};
@@ -359,7 +397,16 @@ grunt.initConfig({
 
 grunt.registerMultiTask( "copy", "Copy files to destination folder and replace @VERSION with pkg.version", function() {
 	function replaceVersion( source ) {
-		return source.replace( "@VERSION", grunt.config( "pkg.version" ) );
+		return source.replace( /@VERSION/g, grunt.config( "pkg.version" ) );
+	}
+	function copyFile( src, dest ) {
+		if ( /(js|css)$/.test( src ) ) {
+			grunt.file.copy( src, dest, {
+				process: replaceVersion
+			});
+		} else {
+			grunt.file.copy( src, dest );
+		}
 	}
 	var files = grunt.file.expandFiles( this.file.src ),
 		target = this.file.dest + "/",
@@ -371,18 +418,12 @@ grunt.registerMultiTask( "copy", "Copy files to destination folder and replace @
 	}
 	files.forEach(function( fileName ) {
 		var targetFile = strip ? fileName.replace( strip, "" ) : fileName;
-		if ( /(js|css)$/.test( fileName ) ) {
-			grunt.file.copy( fileName, target + targetFile, {
-				process: replaceVersion
-			});
-		} else {
-			grunt.file.copy( fileName, target + targetFile );
-		}
+		copyFile( fileName, target + targetFile );
 	});
 	grunt.log.writeln( "Copied " + files.length + " files." );
 	for ( fileName in this.data.renames ) {
 		renameCount += 1;
-		grunt.file.copy( fileName, target + grunt.template.process( this.data.renames[ fileName ], grunt.config() ) );
+		copyFile( fileName, target + grunt.template.process( this.data.renames[ fileName ], grunt.config() ) );
 	}
 	if ( renameCount ) {
 		grunt.log.writeln( "Renamed " + renameCount + " files." );
@@ -537,77 +578,6 @@ grunt.registerTask( "clean", function() {
 	require( "rimraf" ).sync( "dist" );
 });
 
-// TODO merge with code in jQuery Core, share as grunt plugin/npm
-// this here actually uses the provided filenames in the output
-// the helpers should just be regular functions, no need to share those with the world
-grunt.registerMultiTask( "compare_size", "Compare size of this branch to master", function() {
-	var files = grunt.file.expandFiles( this.file.src ),
-		done = this.async(),
-		sizecache = __dirname + "/dist/.sizecache.json",
-		sources = {
-			min: grunt.file.read( files[1] ),
-			max: grunt.file.read( files[0] )
-		},
-		oldsizes = {},
-		sizes = {};
-
-	try {
-		oldsizes = JSON.parse( grunt.file.read( sizecache ) );
-	} catch( e ) {
-		oldsizes = {};
-	}
-
-	// Obtain the current branch and continue...
-	grunt.helper( "git_current_branch", function( err, branch ) {
-		var key, diff;
-
-		// Derived and adapted from Corey Frang's original `sizer`
-		grunt.log.writeln( "sizes - compared to master" );
-
-		sizes[ files[0] ] = sources.max.length;
-		sizes[ files[1] ] = sources.min.length;
-		sizes[ files[1] + ".gz" ] = grunt.helper( "gzip", sources.min ).length;
-
-		for ( key in sizes ) {
-			diff = oldsizes[ key ] && ( sizes[ key ] - oldsizes[ key ] );
-			if ( diff > 0 ) {
-				diff = "+" + diff;
-			}
-			console.log( "%s %s %s",
-				grunt.helper("lpad",  sizes[ key ], 8 ),
-				grunt.helper("lpad",  diff ? "(" + diff + ")" : "(-)", 8 ),
-				key
-			);
-		}
-
-		if ( branch === "master" ) {
-			// If master, write to file - this makes it easier to compare
-			// the size of your current code state to the master branch,
-			// without returning to the master to reset the cache
-			grunt.file.write( sizecache, JSON.stringify(sizes) );
-		}
-		done();
-	});
-});
-grunt.registerHelper( "git_current_branch", function( done ) {
-	grunt.utils.spawn({
-		cmd: "git",
-		args: [ "branch", "--no-color" ]
-	}, function( err, result ) {
-		var branch;
-
-		result.split( "\n" ).forEach(function( branch ) {
-			var matches = /^\* (.*)/.exec( branch );
-			if ( matches !== null && matches.length && matches[ 1 ] ) {
-				done( null, matches[ 1 ] );
-			}
-		});
-	});
-});
-grunt.registerHelper( "lpad", function( str, len, chr ) {
-	return ( Array( len + 1 ).join( chr || " " ) + str ).substr( -len );
-});
-
 grunt.registerTask( "default", "lint csslint qunit build compare_size" );
 grunt.registerTask( "sizer", "concat:ui min:dist/jquery-ui.min.js compare_size" );
 grunt.registerTask( "build", "concat min cssmin" );
diff --git a/package.json b/package.json
index 30e2b4898..d69b9c370 100644
--- a/package.json
+++ b/package.json
@@ -26,10 +26,11 @@
   ],
   "dependencies": {},
   "devDependencies": {
-    "grunt": "0.3.7",
+    "grunt": "0.3.9",
     "grunt-css": "0.1.1",
+    "grunt-compare-size": "0.1.1",
     "request": "2.9.153",
     "rimraf": "2.0.1"
   },
   "keywords": []
-}
\ No newline at end of file
+}
diff --git a/tests/unit/accordion/accordion_core.js b/tests/unit/accordion/accordion_core.js
index 92d79c121..7a1d56c18 100644
--- a/tests/unit/accordion/accordion_core.js
+++ b/tests/unit/accordion/accordion_core.js
@@ -1,6 +1,9 @@
 (function( $ ) {
 
-module( "accordion: core", accordion_setupTeardown() );
+var setupTeardown = TestHelpers.accordion.setupTeardown,
+	state = TestHelpers.accordion.state;
+
+module( "accordion: core", setupTeardown() );
 
 $.each( { div: "#list1", ul: "#navigation", dl: "#accordion-dl" }, function( type, selector ) {
 	test( "markup structure: " + type, function() {
@@ -21,15 +24,15 @@ test( "handle click on header-descendant", function() {
 	expect( 1 );
 	var element = $( "#navigation" ).accordion();
 	$( "#navigation h2:eq(1) a" ).click();
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 test( "accessibility", function () {
 	expect( 37 );
 	var element = $( "#list1" ).accordion({
-		active: 1
-	});
-	var headers = element.find( ".ui-accordion-header" );
+			active: 1
+		}),
+		headers = element.find( ".ui-accordion-header" );
 
 	equal( element.attr( "role" ), "tablist", "element role" );
 	headers.each(function( i ) {
@@ -85,22 +88,22 @@ asyncTest( "keybaord support", function() {
 		ok( headers.eq( 2 ).is( ".ui-state-focus" ), "RIGHT moves focus to next header" );
 		headers.eq( 2 ).simulate( "keydown", { keyCode: keyCode.DOWN } );
 		ok( headers.eq( 0 ).is( ".ui-state-focus" ), "DOWN wraps focus to first header" );
-	
+
 		headers.eq( 0 ).simulate( "keydown", { keyCode: keyCode.UP } );
 		ok( headers.eq( 2 ).is( ".ui-state-focus" ), "UP wraps focus to last header" );
 		headers.eq( 2 ).simulate( "keydown", { keyCode: keyCode.LEFT } );
 		ok( headers.eq( 1 ).is( ".ui-state-focus" ), "LEFT moves focus to previous header" );
-	
+
 		headers.eq( 1 ).simulate( "keydown", { keyCode: keyCode.HOME } );
 		ok( headers.eq( 0 ).is( ".ui-state-focus" ), "HOME moves focus to first header" );
 		headers.eq( 0 ).simulate( "keydown", { keyCode: keyCode.END } );
 		ok( headers.eq( 2 ).is( ".ui-state-focus" ), "END moves focus to last header" );
-	
+
 		headers.eq( 2 ).simulate( "keydown", { keyCode: keyCode.ENTER } );
 		equal( element.accordion( "option", "active" ) , 2, "ENTER activates panel" );
 		headers.eq( 1 ).simulate( "keydown", { keyCode: keyCode.SPACE } );
 		equal( element.accordion( "option", "active" ), 1, "SPACE activates panel" );
-	
+
 		anchor.simulate( "focus" );
 		setTimeout(function() {
 			ok( !headers.eq( 1 ).is( ".ui-state-focus" ), "header loses focus when focusing inside the panel" );
diff --git a/tests/unit/accordion/accordion_defaults.js b/tests/unit/accordion/accordion_defaults.js
index 9ad85bbce..ef24cf25e 100644
--- a/tests/unit/accordion/accordion_defaults.js
+++ b/tests/unit/accordion/accordion_defaults.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "accordion", {
+TestHelpers.commonWidgetTests( "accordion", {
 	defaults: {
 		active: 0,
 		animate: {},
diff --git a/tests/unit/accordion/accordion_defaults_deprecated.js b/tests/unit/accordion/accordion_defaults_deprecated.js
index 99f5ac827..22d5e1289 100644
--- a/tests/unit/accordion/accordion_defaults_deprecated.js
+++ b/tests/unit/accordion/accordion_defaults_deprecated.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "accordion", {
+TestHelpers.commonWidgetTests( "accordion", {
 	defaults: {
 		active: 0,
 		animate: null,
diff --git a/tests/unit/accordion/accordion_deprecated.js b/tests/unit/accordion/accordion_deprecated.js
index eec034e18..8d8e8a0d6 100644
--- a/tests/unit/accordion/accordion_deprecated.js
+++ b/tests/unit/accordion/accordion_deprecated.js
@@ -1,70 +1,74 @@
 (function( $ ) {
 
-module( "accordion (deprecated): expanded active option, activate method", accordion_setupTeardown() );
+var equalHeights = TestHelpers.accordion.equalHeights,
+	setupTeardown = TestHelpers.accordion.setupTeardown,
+	state = TestHelpers.accordion.state;
+
+module( "accordion (deprecated): expanded active option, activate method", setupTeardown() );
 
 test( "activate, numeric", function() {
 	expect( 5 );
 	var element = $( "#list1" ).accordion({ active: 1 });
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 	element.accordion( "activate", 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.accordion( "activate", 0 );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	element.accordion( "activate", 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 	element.accordion( "activate", 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 });
 
 test( "activate, numeric, collapsible:true", function() {
 	expect( 3 );
 	var element = $( "#list1" ).accordion({ collapsible: true });
 	element.accordion( "activate", 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.accordion( "activate", 0 );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	element.accordion( "activate", -1 );
-	accordion_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 });
 
 test( "activate, boolean, collapsible: true", function() {
 	expect( 2 );
 	var element = $( "#list1" ).accordion({ collapsible: true });
 	element.accordion( "activate", 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.accordion( "activate", false );
-	accordion_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 });
 
 test( "activate, boolean, collapsible: false", function() {
 	expect( 2 );
 	var element = $( "#list1" ).accordion();
 	element.accordion( "activate", 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.accordion( "activate", false );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 });
 
 test( "activate, string expression", function() {
 	expect( 4 );
 	var element = $( "#list1" ).accordion({ active: "h3:last" });
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.accordion( "activate", ":first" );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	element.accordion( "activate", ":eq(1)" );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 	element.accordion( "activate", ":last" );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 });
 
 test( "activate, jQuery or DOM element", function() {
 	expect( 3 );
 	var element = $( "#list1" ).accordion({ active: $( "#list1 h3:last" ) });
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.accordion( "activate", $( "#list1 h3:first" ) );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	element.accordion( "activate", $( "#list1 h3" )[ 1 ] );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 test( "{ active: Selector }", function() {
@@ -72,9 +76,9 @@ test( "{ active: Selector }", function() {
 	var element = $("#list1").accordion({
 		active: "h3:last"
 	});
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.accordion( "option", "active", "h3:eq(1)" );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 test( "{ active: Element }", function() {
@@ -82,9 +86,9 @@ test( "{ active: Element }", function() {
 	var element = $( "#list1" ).accordion({
 		active: $( "#list1 h3:last" )[ 0 ]
 	});
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.accordion( "option", "active", $( "#list1 h3:eq(1)" )[ 0 ] );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 test( "{ active: jQuery Object }", function() {
@@ -92,26 +96,26 @@ test( "{ active: jQuery Object }", function() {
 	var element = $( "#list1" ).accordion({
 		active: $( "#list1 h3:last" )
 	});
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.accordion( "option", "active", $( "#list1 h3:eq(1)" ) );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 
 
 
 
-module( "accordion (deprecated) - height options", accordion_setupTeardown() );
+module( "accordion (deprecated) - height options", setupTeardown() );
 
 test( "{ autoHeight: true }, default", function() {
 	expect( 3 );
-	accordion_equalHeights( $( "#navigation" ).accordion({ autoHeight: true }), 95, 130 );
+	equalHeights( $( "#navigation" ).accordion({ autoHeight: true }), 95, 130 );
 });
 
 test( "{ autoHeight: false }", function() {
 	expect( 3 );
-	var element = $( "#navigation" ).accordion({ autoHeight: false });
-	var sizes = [];
+	var element = $( "#navigation" ).accordion({ autoHeight: false }),
+		sizes = [];
 	element.find( ".ui-accordion-content" ).each(function() {
 		sizes.push( $(this).height() );
 	});
@@ -124,7 +128,7 @@ test( "{ fillSpace: true }", function() {
 	expect( 3 );
 	$( "#navigationWrapper" ).height( 500 );
 	var element = $( "#navigation" ).accordion({ fillSpace: true });
-	accordion_equalHeights( element, 446, 458 );
+	equalHeights( element, 446, 458 );
 });
 
 test( "{ fillSapce: true } with sibling", function() {
@@ -138,7 +142,7 @@ test( "{ fillSapce: true } with sibling", function() {
 		})
 		.prependTo( "#navigationWrapper" );
 	var element = $( "#navigation" ).accordion({ fillSpace: true });
-	accordion_equalHeights( element , 346, 358);
+	equalHeights( element , 346, 358);
 });
 
 test( "{ fillSpace: true } with multiple siblings", function() {
@@ -167,14 +171,14 @@ test( "{ fillSpace: true } with multiple siblings", function() {
 		})
 		.prependTo( "#navigationWrapper" );
 	var element = $( "#navigation" ).accordion({ fillSpace: true });
-	accordion_equalHeights( element, 296, 308 );
+	equalHeights( element, 296, 308 );
 });
 
 
 
 
 
-module( "accordion (deprecated) - icons", accordion_setupTeardown() );
+module( "accordion (deprecated) - icons", setupTeardown() );
 
 test( "icons, headerSelected", function() {
 	expect( 3 );
@@ -191,7 +195,7 @@ test( "icons, headerSelected", function() {
 
 
 
-module( "accordion (deprecated) - resize", accordion_setupTeardown() );
+module( "accordion (deprecated) - resize", setupTeardown() );
 
 test( "resize", function() {
 	expect( 6 );
@@ -202,29 +206,29 @@ test( "resize", function() {
 		.accordion({
 			heightStyle: "fill"
 		});
-	accordion_equalHeights( element, 246, 258 );
+	equalHeights( element, 246, 258 );
 
 	element.parent().height( 500 );
 	element.accordion( "resize" );
-	accordion_equalHeights( element, 446, 458 );
+	equalHeights( element, 446, 458 );
 });
 
 
 
 
 
-module( "accordion (deprecated) - navigation", accordion_setupTeardown() );
+module( "accordion (deprecated) - navigation", setupTeardown() );
 
 test( "{ navigation: true, navigationFilter: header }", function() {
 	expect( 2 );
 	var element = $( "#navigation" ).accordion({
 		navigation: true,
 		navigationFilter: function() {
-			return /\?p=1\.1\.3$/.test( this.href );
+			return (/\?p=1\.1\.3$/).test( this.href );
 		}
 	});
 	equal( element.accordion( "option", "active" ), 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 });
 
 test( "{ navigation: true, navigationFilter: content }", function() {
@@ -232,27 +236,27 @@ test( "{ navigation: true, navigationFilter: content }", function() {
 	var element = $( "#navigation" ).accordion({
 		navigation: true,
 		navigationFilter: function() {
-			return /\?p=1\.1\.3\.2$/.test( this.href );
+			return (/\?p=1\.1\.3\.2$/).test( this.href );
 		}
 	});
 	equal( element.accordion( "option", "active" ), 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 });
 
 
 
 
 
-module( "accordion (deprecated) - changestart/change events", accordion_setupTeardown() );
+module( "accordion (deprecated) - changestart/change events", setupTeardown() );
 
 test( "changestart", function() {
 	expect( 26 );
 	var element = $( "#list1" ).accordion({
-		active: false,
-		collapsible: true
-	});
-	var headers = element.find( ".ui-accordion-header" );
-	var content = element.find( ".ui-accordion-content" );
+			active: false,
+			collapsible: true
+		}),
+		headers = element.find( ".ui-accordion-header" ),
+		content = element.find( ".ui-accordion-content" );
 
 	element.one( "accordionchangestart", function( event, ui ) {
 		equal( ui.oldHeader.size(), 0 );
@@ -261,10 +265,10 @@ test( "changestart", function() {
 		strictEqual( ui.newHeader[ 0 ], headers[ 0 ] );
 		equal( ui.newContent.size(), 1 );
 		strictEqual( ui.newContent[ 0 ], content[ 0 ] );
-		accordion_state( element, 0, 0, 0 );
+		state( element, 0, 0, 0 );
 	});
 	element.accordion( "option", "active", 0 );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	element.one( "accordionchangestart", function( event, ui ) {
 		equal( ui.oldHeader.size(), 1 );
@@ -275,10 +279,10 @@ test( "changestart", function() {
 		strictEqual( ui.newHeader[ 0 ], headers[ 1 ] );
 		equal( ui.newContent.size(), 1 );
 		strictEqual( ui.newContent[ 0 ], content[ 1 ] );
-		accordion_state( element, 1, 0, 0 );
+		state( element, 1, 0, 0 );
 	});
 	headers.eq( 1 ).click();
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.one( "accordionchangestart", function( event, ui ) {
 		equal( ui.oldHeader.size(), 1 );
@@ -287,20 +291,20 @@ test( "changestart", function() {
 		strictEqual( ui.oldContent[ 0 ], content[ 1 ] );
 		equal( ui.newHeader.size(), 0 );
 		equal( ui.newContent.size(), 0 );
-		accordion_state( element, 0, 1, 0 );
+		state( element, 0, 1, 0 );
 	});
 	element.accordion( "option", "active", false );
-	accordion_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 });
 
 test( "change", function() {
 	expect( 20 );
 	var element = $( "#list1" ).accordion({
-		active: false,
-		collapsible: true
-	});
-	var headers = element.find( ".ui-accordion-header" );
-	var content = element.find( ".ui-accordion-content" );
+			active: false,
+			collapsible: true
+		}),
+		headers = element.find( ".ui-accordion-header" ),
+		content = element.find( ".ui-accordion-content" );
 
 	element.one( "accordionchange", function( event, ui ) {
 		equal( ui.oldHeader.size(), 0 );
diff --git a/tests/unit/accordion/accordion_events.js b/tests/unit/accordion/accordion_events.js
index dbb3e37df..932e4637d 100644
--- a/tests/unit/accordion/accordion_events.js
+++ b/tests/unit/accordion/accordion_events.js
@@ -1,6 +1,9 @@
 (function( $ ) {
 
-module( "accordion: events", accordion_setupTeardown() );
+var setupTeardown = TestHelpers.accordion.setupTeardown,
+	state = TestHelpers.accordion.state;
+
+module( "accordion: events", setupTeardown() );
 
 test( "create", function() {
 	expect( 10 );
@@ -44,11 +47,11 @@ test( "create", function() {
 test( "beforeActivate", function() {
 	expect( 38 );
 	var element = $( "#list1" ).accordion({
-		active: false,
-		collapsible: true
-	});
-	var headers = element.find( ".ui-accordion-header" );
-	var content = element.find( ".ui-accordion-content" );
+			active: false,
+			collapsible: true
+		}),
+		headers = element.find( ".ui-accordion-header" ),
+		content = element.find( ".ui-accordion-content" );
 
 	element.one( "accordionbeforeactivate", function( event, ui ) {
 		ok( !( "originalEvent" in event ) );
@@ -58,10 +61,10 @@ test( "beforeActivate", function() {
 		strictEqual( ui.newHeader[ 0 ], headers[ 0 ] );
 		equal( ui.newContent.size(), 1 );
 		strictEqual( ui.newContent[ 0 ], content[ 0 ] );
-		accordion_state( element, 0, 0, 0 );
+		state( element, 0, 0, 0 );
 	});
 	element.accordion( "option", "active", 0 );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	element.one( "accordionbeforeactivate", function( event, ui ) {
 		equal( event.originalEvent.type, "click" );
@@ -73,10 +76,10 @@ test( "beforeActivate", function() {
 		strictEqual( ui.newHeader[ 0 ], headers[ 1 ] );
 		equal( ui.newContent.size(), 1 );
 		strictEqual( ui.newContent[ 0 ], content[ 1 ] );
-		accordion_state( element, 1, 0, 0 );
+		state( element, 1, 0, 0 );
 	});
 	headers.eq( 1 ).click();
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.one( "accordionbeforeactivate", function( event, ui ) {
 		ok( !( "originalEvent" in event ) );
@@ -86,10 +89,10 @@ test( "beforeActivate", function() {
 		strictEqual( ui.oldContent[ 0 ], content[ 1 ] );
 		equal( ui.newHeader.size(), 0 );
 		equal( ui.newContent.size(), 0 );
-		accordion_state( element, 0, 1, 0 );
+		state( element, 0, 1, 0 );
 	});
 	element.accordion( "option", "active", false );
-	accordion_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 
 	element.one( "accordionbeforeactivate", function( event, ui ) {
 		ok( !( "originalEvent" in event ) );
@@ -100,20 +103,20 @@ test( "beforeActivate", function() {
 		equal( ui.newContent.size(), 1 );
 		strictEqual( ui.newContent[ 0 ], content[ 2 ] );
 		event.preventDefault();
-		accordion_state( element, 0, 0, 0 );
+		state( element, 0, 0, 0 );
 	});
 	element.accordion( "option", "active", 2 );
-	accordion_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 });
 
 test( "activate", function() {
 	expect( 21 );
 	var element = $( "#list1" ).accordion({
-		active: false,
-		collapsible: true
-	});
-	var headers = element.find( ".ui-accordion-header" );
-	var content = element.find( ".ui-accordion-content" );
+			active: false,
+			collapsible: true
+		}),
+		headers = element.find( ".ui-accordion-header" ),
+		content = element.find( ".ui-accordion-content" );
 
 	element.one( "accordionactivate", function( event, ui ) {
 		equal( ui.oldHeader.size(), 0 );
diff --git a/tests/unit/accordion/accordion_methods.js b/tests/unit/accordion/accordion_methods.js
index 2f4722070..2c5b36632 100644
--- a/tests/unit/accordion/accordion_methods.js
+++ b/tests/unit/accordion/accordion_methods.js
@@ -1,6 +1,10 @@
 (function( $ ) {
 
-module( "accordion: methods", accordion_setupTeardown() );
+var equalHeights = TestHelpers.accordion.equalHeights,
+	setupTeardown = TestHelpers.accordion.setupTeardown,
+	state = TestHelpers.accordion.state;
+
+module( "accordion: methods", setupTeardown() );
 
 test( "destroy", function() {
 	expect( 1 );
@@ -12,17 +16,17 @@ test( "destroy", function() {
 test( "enable/disable", function() {
 	expect( 4 );
 	var element = $( "#list1" ).accordion();
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	element.accordion( "disable" );
 	// event does nothing
 	element.find( ".ui-accordion-header" ).eq( 1 ).trigger( "click" );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	// option still works
 	element.accordion( "option", "active", 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 	element.accordion( "enable" );
 	element.accordion( "option", "active", 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 });
 
 test( "refresh", function() {
@@ -34,11 +38,11 @@ test( "refresh", function() {
 		.accordion({
 			heightStyle: "fill"
 		});
-	accordion_equalHeights( element, 246, 258 );
+	equalHeights( element, 246, 258 );
 
 	element.parent().height( 500 );
 	element.accordion( "refresh" );
-	accordion_equalHeights( element, 446, 458 );
+	equalHeights( element, 446, 458 );
 });
 
 }( jQuery ) );
diff --git a/tests/unit/accordion/accordion_options.js b/tests/unit/accordion/accordion_options.js
index 2b7176394..f64ddc675 100644
--- a/tests/unit/accordion/accordion_options.js
+++ b/tests/unit/accordion/accordion_options.js
@@ -1,12 +1,16 @@
 (function( $ ) {
 
-module( "accordion: options", accordion_setupTeardown() );
+var equalHeights = TestHelpers.accordion.equalHeights,
+	setupTeardown = TestHelpers.accordion.setupTeardown,
+	state = TestHelpers.accordion.state;
+
+module( "accordion: options", setupTeardown() );
 
 test( "{ active: default }", function() {
 	expect( 2 );
 	var element = $( "#list1" ).accordion();
 	equal( element.accordion( "option", "active" ), 0 );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 });
 
 test( "{ active: false }", function() {
@@ -15,19 +19,19 @@ test( "{ active: false }", function() {
 		active: false,
 		collapsible: true
 	});
-	accordion_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 	equal( element.find( ".ui-accordion-header.ui-state-active" ).size(), 0, "no headers selected" );
 	equal( element.accordion( "option", "active" ), false );
 
 	element.accordion( "option", "collapsible", false );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	equal( element.accordion( "option", "active" ), 0 );
 
 	element.accordion( "destroy" );
 	element.accordion({
 		active: false
 	});
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	strictEqual( element.accordion( "option", "active" ), 0 );
 });
 
@@ -37,19 +41,19 @@ test( "{ active: Number }", function() {
 		active: 2
 	});
 	equal( element.accordion( "option", "active" ), 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 
 	element.accordion( "option", "active", 0 );
 	equal( element.accordion( "option", "active" ), 0 );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	element.find( ".ui-accordion-header" ).eq( 1 ).click();
 	equal( element.accordion( "option", "active" ), 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.accordion( "option", "active", 10 );
 	equal( element.accordion( "option", "active" ), 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 if ( $.uiBackCompat === false ) {
@@ -59,19 +63,19 @@ if ( $.uiBackCompat === false ) {
 			active: -1
 		});
 		equal( element.accordion( "option", "active" ), 2 );
-		accordion_state( element, 0, 0, 1 );
+		state( element, 0, 0, 1 );
 
 		element.accordion( "option", "active", -2 );
 		equal( element.accordion( "option", "active" ), 1 );
-		accordion_state( element, 0, 1, 0 );
+		state( element, 0, 1, 0 );
 
 		element.accordion( "option", "active", -10 );
 		equal( element.accordion( "option", "active" ), 1 );
-		accordion_state( element, 0, 1, 0 );
+		state( element, 0, 1, 0 );
 
 		element.accordion( "option", "active", -3 );
 		equal( element.accordion( "option", "active" ), 0 );
-		accordion_state( element, 1, 0, 0 );
+		state( element, 1, 0, 0 );
 	});
 }
 
@@ -80,7 +84,7 @@ test( "{ animate: false }", function() {
 	var element = $( "#list1" ).accordion({
 			animate: false
 		}),
-		panels = element.find( ".ui-accordion-content" );
+		panels = element.find( ".ui-accordion-content" ),
 		animate = $.fn.animate;
 	$.fn.animate = function() {
 		ok( false, ".animate() called" );
@@ -98,7 +102,7 @@ asyncTest( "{ animate: Number }", function() {
 	var element = $( "#list1" ).accordion({
 			animate: 100
 		}),
-		panels = element.find( ".ui-accordion-content" );
+		panels = element.find( ".ui-accordion-content" ),
 		animate = $.fn.animate;
 	// called twice (both panels)
 	$.fn.animate = function( props, duration, easing ) {
@@ -120,10 +124,10 @@ asyncTest( "{ animate: Number }", function() {
 asyncTest( "{ animate: String }", function() {
 	expect( 7 );
 	var element = $( "#list1" ).accordion({
-		animate: "linear"
-	}),
-	panels = element.find( ".ui-accordion-content" );
-	animate = $.fn.animate;
+			animate: "linear"
+		}),
+		panels = element.find( ".ui-accordion-content" ),
+		animate = $.fn.animate;
 	// called twice (both panels)
 	$.fn.animate = function( props, duration, easing ) {
 		equal( duration, undefined, "default duration" );
@@ -144,10 +148,10 @@ asyncTest( "{ animate: String }", function() {
 asyncTest( "{ animate: {} }", function() {
 	expect( 7 );
 	var element = $( "#list1" ).accordion({
-		animate: {}
-	}),
-	panels = element.find( ".ui-accordion-content" );
-	animate = $.fn.animate;
+			animate: {}
+		}),
+		panels = element.find( ".ui-accordion-content" ),
+		animate = $.fn.animate;
 	// called twice (both panels)
 	$.fn.animate = function( props, duration, easing ) {
 		equal( duration, undefined, "default duration" );
@@ -168,10 +172,10 @@ asyncTest( "{ animate: {} }", function() {
 asyncTest( "{ animate: { duration, easing } }", function() {
 	expect( 7 );
 	var element = $( "#list1" ).accordion({
-		animate: { duration: 100, easing: "linear" }
-	}),
-	panels = element.find( ".ui-accordion-content" );
-	animate = $.fn.animate;
+			animate: { duration: 100, easing: "linear" }
+		}),
+		panels = element.find( ".ui-accordion-content" ),
+		animate = $.fn.animate;
 	// called twice (both panels)
 	$.fn.animate = function( props, duration, easing ) {
 		equal( duration, 100, "correct duration" );
@@ -192,11 +196,11 @@ asyncTest( "{ animate: { duration, easing } }", function() {
 asyncTest( "{ animate: { duration, easing } }, animate down", function() {
 	expect( 7 );
 	var element = $( "#list1" ).accordion({
-		active: 1,
-		animate: { duration: 100, easing: "linear" }
-	}),
-	panels = element.find( ".ui-accordion-content" );
-	animate = $.fn.animate;
+			active: 1,
+			animate: { duration: 100, easing: "linear" }
+		}),
+		panels = element.find( ".ui-accordion-content" ),
+		animate = $.fn.animate;
 	// called twice (both panels)
 	$.fn.animate = function( props, duration, easing ) {
 		equal( duration, 100, "correct duration" );
@@ -217,17 +221,17 @@ asyncTest( "{ animate: { duration, easing } }, animate down", function() {
 asyncTest( "{ animate: { duration, easing, down } }, animate down", function() {
 	expect( 7 );
 	var element = $( "#list1" ).accordion({
-		active: 1,
-		animate: {
-			duration: 100,
-			easing: "linear",
-			down: {
-				easing: "swing"
+			active: 1,
+			animate: {
+				duration: 100,
+				easing: "linear",
+				down: {
+					easing: "swing"
+				}
 			}
-		}
-	}),
-	panels = element.find( ".ui-accordion-content" );
-	animate = $.fn.animate;
+		}),
+		panels = element.find( ".ui-accordion-content" ),
+		animate = $.fn.animate;
 	// called twice (both panels)
 	$.fn.animate = function( props, duration, easing ) {
 		equal( duration, 100, "correct duration" );
@@ -252,11 +256,11 @@ test( "{ collapsible: false }", function() {
 	});
 	element.accordion( "option", "active", false );
 	equal( element.accordion( "option", "active" ), 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.find( ".ui-accordion-header" ).eq( 1 ).click();
 	equal( element.accordion( "option", "active" ), 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 test( "{ collapsible: true }", function() {
@@ -268,15 +272,15 @@ test( "{ collapsible: true }", function() {
 
 	element.accordion( "option", "active", false );
 	equal( element.accordion( "option", "active" ), false );
-	accordion_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 
 	element.accordion( "option", "active", 1 );
 	equal( element.accordion( "option", "active" ), 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.find( ".ui-accordion-header" ).eq( 1 ).click();
 	equal( element.accordion( "option", "active" ), false );
-	accordion_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 });
 
 test( "{ event: null }", function() {
@@ -284,16 +288,16 @@ test( "{ event: null }", function() {
 	var element = $( "#list1" ).accordion({
 		event: null
 	});
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	element.accordion( "option", "active", 1 );
 	equal( element.accordion( "option", "active" ), 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	// ensure default click handler isn't bound
 	element.find( ".ui-accordion-header" ).eq( 2 ).click();
 	equal( element.accordion( "option", "active" ), 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 test( "{ event: custom }", function() {
@@ -301,20 +305,20 @@ test( "{ event: custom }", function() {
 	var element = $( "#list1" ).accordion({
 		event: "custom1 custom2"
 	});
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	element.find( ".ui-accordion-header" ).eq( 1 ).trigger( "custom1" );
 	equal( element.accordion( "option", "active" ), 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	// ensure default click handler isn't bound
 	element.find( ".ui-accordion-header" ).eq( 2 ).trigger( "click" );
 	equal( element.accordion( "option", "active" ), 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.find( ".ui-accordion-header" ).eq( 2 ).trigger( "custom2" );
 	equal( element.accordion( "option", "active" ), 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 
 	element.accordion( "option", "event", "custom3" );
 
@@ -322,20 +326,20 @@ test( "{ event: custom }", function() {
 	element.find( ".ui-accordion-header" ).eq( 1 ).trigger( "custom1" );
 	element.find( ".ui-accordion-header" ).eq( 1 ).trigger( "custom2" );
 	equal( element.accordion( "option", "active" ), 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 
 	element.find( ".ui-accordion-header" ).eq( 1 ).trigger( "custom3" );
 	equal( element.accordion( "option", "active" ), 1 );
-	accordion_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 test( "{ header: default }", function() {
 	expect( 2 );
 	// default: > li > :first-child,> :not(li):even
 	// > :not(li):even
-	accordion_state( $( "#list1" ).accordion(), 1, 0, 0);
+	state( $( "#list1" ).accordion(), 1, 0, 0);
 	// > li > :first-child
-	accordion_state( $( "#navigation" ).accordion(), 1, 0, 0);
+	state( $( "#navigation" ).accordion(), 1, 0, 0);
 });
 
 test( "{ header: custom }", function() {
@@ -347,23 +351,23 @@ test( "{ header: custom }", function() {
 		ok( $( this ).hasClass( "ui-accordion-header" ) );
 	});
 	equal( element.find( ".ui-accordion-header" ).length, 3 );
-	accordion_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	element.accordion( "option", "active", 2 );
-	accordion_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 });
 
 test( "{ heightStyle: 'auto' }", function() {
 	expect( 3 );
 	var element = $( "#navigation" ).accordion({ heightStyle: "auto" });
-	accordion_equalHeights( element, 95, 130 );
+	equalHeights( element, 95, 130 );
 });
 
 test( "{ heightStyle: 'content' }", function() {
 	expect( 3 );
-	var element = $( "#navigation" ).accordion({ heightStyle: "content" });
-	var sizes = element.find( ".ui-accordion-content" ).map(function() {
-		return $( this ).height();
-	}).get();
+	var element = $( "#navigation" ).accordion({ heightStyle: "content" }),
+		sizes = element.find( ".ui-accordion-content" ).map(function() {
+			return $( this ).height();
+		}).get();
 	ok( sizes[ 0 ] >= 70 && sizes[ 0 ] <= 105, "was " + sizes[ 0 ] );
 	ok( sizes[ 1 ] >= 98 && sizes[ 1 ] <= 126, "was " + sizes[ 1 ] );
 	ok( sizes[ 2 ] >= 42 && sizes[ 2 ] <= 54, "was " + sizes[ 2 ] );
@@ -373,7 +377,7 @@ test( "{ heightStyle: 'fill' }", function() {
 	expect( 3 );
 	$( "#navigationWrapper" ).height( 500 );
 	var element = $( "#navigation" ).accordion({ heightStyle: "fill" });
-	accordion_equalHeights( element, 446, 458 );
+	equalHeights( element, 446, 458 );
 });
 
 test( "{ heightStyle: 'fill' } with sibling", function() {
@@ -387,7 +391,7 @@ test( "{ heightStyle: 'fill' } with sibling", function() {
 		})
 		.prependTo( "#navigationWrapper" );
 	var element = $( "#navigation" ).accordion({ heightStyle: "fill" });
-	accordion_equalHeights( element , 346, 358);
+	equalHeights( element , 346, 358);
 });
 
 test( "{ heightStyle: 'fill' } with multiple siblings", function() {
@@ -416,7 +420,7 @@ test( "{ heightStyle: 'fill' } with multiple siblings", function() {
 		})
 		.prependTo( "#navigationWrapper" );
 	var element = $( "#navigation" ).accordion({ heightStyle: "fill" });
-	accordion_equalHeights( element, 296, 308 );
+	equalHeights( element, 296, 308 );
 });
 
 test( "{ icons: false }", function() {
diff --git a/tests/unit/accordion/accordion_test_helpers.js b/tests/unit/accordion/accordion_test_helpers.js
index 542809ea0..56967793d 100644
--- a/tests/unit/accordion/accordion_test_helpers.js
+++ b/tests/unit/accordion/accordion_test_helpers.js
@@ -1,30 +1,32 @@
-function accordion_state( accordion ) {
-	var expected = $.makeArray( arguments ).slice( 1 );
-	var actual = accordion.find( ".ui-accordion-content" ).map(function() {
-		return $( this ).css( "display" ) === "none" ? 0 : 1;
-	}).get();
-	QUnit.push( QUnit.equiv(actual, expected), actual, expected );
-}
+TestHelpers.accordion = {
+	equalHeights: function( accordion, min, max ) {
+		var sizes = [];
+		accordion.find( ".ui-accordion-content" ).each(function() {
+			sizes.push( $( this ).outerHeight() );
+		});
+		ok( sizes[ 0 ] >= min && sizes[ 0 ] <= max,
+			"must be within " + min + " and " + max + ", was " + sizes[ 0 ] );
+		deepEqual( sizes[ 0 ], sizes[ 1 ] );
+		deepEqual( sizes[ 0 ], sizes[ 2 ] );
+	},
 
-function accordion_equalHeights( accordion, min, max ) {
-	var sizes = [];
-	accordion.find( ".ui-accordion-content" ).each(function() {
-		sizes.push( $( this ).outerHeight() );
-	});
-	ok( sizes[ 0 ] >= min && sizes[ 0 ] <= max,
-		"must be within " + min + " and " + max + ", was " + sizes[ 0 ] );
-	deepEqual( sizes[ 0 ], sizes[ 1 ] );
-	deepEqual( sizes[ 0 ], sizes[ 2 ] );
-}
+	setupTeardown: function() {
+		var animate = $.ui.accordion.prototype.options.animate;
+		return {
+			setup: function() {
+				$.ui.accordion.prototype.options.animate = false;
+			},
+			teardown: function() {
+				$.ui.accordion.prototype.options.animate = animate;
+			}
+		};
+	},
 
-function accordion_setupTeardown() {
-	var animate = $.ui.accordion.prototype.options.animate;
-	return {
-		setup: function() {
-			$.ui.accordion.prototype.options.animate = false;
-		},
-		teardown: function() {
-			$.ui.accordion.prototype.options.animate = animate;
-		}
-	};
-}
+	state: function( accordion ) {
+		var expected = $.makeArray( arguments ).slice( 1 ),
+			actual = accordion.find( ".ui-accordion-content" ).map(function() {
+			return $( this ).css( "display" ) === "none" ? 0 : 1;
+		}).get();
+		QUnit.push( QUnit.equiv(actual, expected), actual, expected );
+	}
+};
diff --git a/tests/unit/autocomplete/autocomplete_defaults.js b/tests/unit/autocomplete/autocomplete_defaults.js
index ac83eaea4..c090ce4df 100644
--- a/tests/unit/autocomplete/autocomplete_defaults.js
+++ b/tests/unit/autocomplete/autocomplete_defaults.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "autocomplete", {
+TestHelpers.commonWidgetTests( "autocomplete", {
 	defaults: {
 		appendTo: "body",
 		autoFocus: false,
diff --git a/tests/unit/autocomplete/autocomplete_events.js b/tests/unit/autocomplete/autocomplete_events.js
index 1c7ff7462..082263a35 100644
--- a/tests/unit/autocomplete/autocomplete_events.js
+++ b/tests/unit/autocomplete/autocomplete_events.js
@@ -123,7 +123,7 @@ asyncTest( "cancel search", function() {
 
 asyncTest( "cancel focus", function() {
 	expect( 1 );
-	var customVal = "custom value";
+	var customVal = "custom value",
 		element = $( "#autocomplete" ).autocomplete({
 			delay: 0,
 			source: data,
diff --git a/tests/unit/button/button_core.js b/tests/unit/button/button_core.js
index c110b4311..0d93ecedf 100644
--- a/tests/unit/button/button_core.js
+++ b/tests/unit/button/button_core.js
@@ -8,7 +8,7 @@
 module("button: core");
 
 test("checkbox", function() {
-	var input = $("#check");
+	var input = $("#check"),
 		label = $("label[for=check]");
 	ok( input.is(":visible") );
 	ok( label.is(":not(.ui-button)") );
@@ -18,7 +18,7 @@ test("checkbox", function() {
 });
 
 test("radios", function() {
-	var inputs = $("#radio0 input");
+	var inputs = $("#radio0 input"),
 		labels = $("#radio0 label");
 	ok( inputs.is(":visible") );
 	ok( labels.is(":not(.ui-button)") );
@@ -51,7 +51,7 @@ test("radio groups", function() {
 });
 
 test("input type submit, don't create child elements", function() {
-	var input = $("#submit")
+	var input = $("#submit");
 	deepEqual( input.children().length, 0 );
 	input.button();
 	deepEqual( input.children().length, 0 );
@@ -68,11 +68,12 @@ test("buttonset", function() {
 });
 
 test("buttonset (rtl)", function() {
-	var parent = $("#radio1").parent();
+	var set,
+		parent = $("#radio1").parent();
 	// Set to rtl
 	parent.attr("dir", "rtl");
 
-	var set = $("#radio1").buttonset();
+	set = $("#radio1").buttonset();
 	ok( set.is(".ui-buttonset") );
 	deepEqual( set.children(".ui-button").length, 3 );
 	deepEqual( set.children("input:radio.ui-helper-hidden-accessible").length, 3 );
diff --git a/tests/unit/button/button_defaults.js b/tests/unit/button/button_defaults.js
index 96c7e5bfa..ef22d3011 100644
--- a/tests/unit/button/button_defaults.js
+++ b/tests/unit/button/button_defaults.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "button", {
+TestHelpers.commonWidgetTests( "button", {
 	defaults: {
 		disabled: null,
 		icons: {
diff --git a/tests/unit/button/button_methods.js b/tests/unit/button/button_methods.js
index a83a73ba4..347806d4e 100644
--- a/tests/unit/button/button_methods.js
+++ b/tests/unit/button/button_methods.js
@@ -7,8 +7,8 @@
 module("button: methods");
 
 test("destroy", function() {
-	var beforeHtml = $("#button").parent().html();
-	var afterHtml = $("#button").button().button("destroy").parent().html();
+	var beforeHtml = $("#button").parent().html(),
+		afterHtml = $("#button").button().button("destroy").parent().html();
 	// Opera 9 outputs role="" instead of removing the attribute like everyone else
 	if ($.browser.opera) {
 		afterHtml = afterHtml.replace(/ role=""/g, "");
diff --git a/tests/unit/datepicker/datepicker_core.js b/tests/unit/datepicker/datepicker_core.js
index bbc447ffe..4bf04d83e 100644
--- a/tests/unit/datepicker/datepicker_core.js
+++ b/tests/unit/datepicker/datepicker_core.js
@@ -53,52 +53,52 @@ test("widget method", function() {
 });
 
 test('baseStructure', function() {
-	var inp = init('#inp');
-	inp.focus();
-	var dp = $('#ui-datepicker-div');
-	var iframe = ($.browser.msie && parseInt($.browser.version) < 7);
+	var header, title, table, thead, week, panel, inl, child,
+		inp = init('#inp').focus(),
+		dp = $('#ui-datepicker-div'),
+		iframe = ($.browser.msie && parseInt($.browser.version, 10) < 7);
 	ok(dp.is(':visible'), 'Structure - datepicker visible');
 	ok(!dp.is('.ui-datepicker-rtl'), 'Structure - not right-to-left');
 	ok(!dp.is('.ui-datepicker-multi'), 'Structure - not multi-month');
 	equal(dp.children().length, 2 + (iframe ? 1 : 0), 'Structure - child count');
 
-	var header = dp.children(':first');
+	header = dp.children(':first');
 	ok(header.is('div.ui-datepicker-header'), 'Structure - header division');
 	equal(header.children().length, 3, 'Structure - header child count');
-	ok(header.children(':first').is('a.ui-datepicker-prev') && header.children(':first').html() != '', 'Structure - prev link');
-	ok(header.children(':eq(1)').is('a.ui-datepicker-next') && header.children(':eq(1)').html() != '', 'Structure - next link');
+	ok(header.children(':first').is('a.ui-datepicker-prev') && header.children(':first').html() !== '', 'Structure - prev link');
+	ok(header.children(':eq(1)').is('a.ui-datepicker-next') && header.children(':eq(1)').html() !== '', 'Structure - next link');
 
-	var title = header.children(':last');
-	ok(title.is('div.ui-datepicker-title') && title.html() != '','Structure - title division');
+	title = header.children(':last');
+	ok(title.is('div.ui-datepicker-title') && title.html() !== '','Structure - title division');
 	equal(title.children().length, 2, 'Structure - title child count');
-	ok(title.children(':first').is('span.ui-datepicker-month') && title.children(':first').text() != '', 'Structure - month text')
-	ok(title.children(':last').is('span.ui-datepicker-year') && title.children(':last').text() != '', 'Structure - year text')
+	ok(title.children(':first').is('span.ui-datepicker-month') && title.children(':first').text() !== '', 'Structure - month text');
+	ok(title.children(':last').is('span.ui-datepicker-year') && title.children(':last').text() !== '', 'Structure - year text');
 
-	var table = dp.children(':eq(1)');
+	table = dp.children(':eq(1)');
 	ok(table.is('table.ui-datepicker-calendar'), 'Structure - month table');
 	ok(table.children(':first').is('thead'), 'Structure - month table thead');
-	var thead = table.children(':first').children(':first');
+	thead = table.children(':first').children(':first');
 	ok(thead.is('tr'), 'Structure - month table title row');
 	equal(thead.find('th').length, 7, 'Structure - month table title cells');
 	ok(table.children(':eq(1)').is('tbody'), 'Structure - month table body');
 	ok(table.children(':eq(1)').children('tr').length >= 4, 'Structure - month table week count');
-	var week = table.children(':eq(1)').children(':first');
+	week = table.children(':eq(1)').children(':first');
 	ok(week.is('tr'), 'Structure - month table week row');
 	equal(week.children().length, 7, 'Structure - week child count');
 	ok(week.children(':first').is('td.ui-datepicker-week-end'), 'Structure - month table first day cell');
 	ok(week.children(':last').is('td.ui-datepicker-week-end'), 'Structure - month table second day cell');
-	ok(dp.children('iframe').length == (iframe ? 1 : 0), 'Structure - iframe');
+	ok(dp.children('iframe').length === (iframe ? 1 : 0), 'Structure - iframe');
 	inp.datepicker('hide').datepicker('destroy');
 
 	// Editable month/year and button panel
 	inp = init('#inp', {changeMonth: true, changeYear: true, showButtonPanel: true});
 	inp.focus();
 
-	var title = dp.find('div.ui-datepicker-title');
+	title = dp.find('div.ui-datepicker-title');
 	ok(title.children(':first').is('select.ui-datepicker-month'), 'Structure - month selector');
 	ok(title.children(':last').is('select.ui-datepicker-year'), 'Structure - year selector');
 
-	var panel = dp.children(':last');
+	panel = dp.children(':last');
 	ok(panel.is('div.ui-datepicker-buttonpane'), 'Structure - button panel division');
 	equal(panel.children().length, 2, 'Structure - button panel child count');
 	ok(panel.children(':first').is('button.ui-datepicker-current'), 'Structure - today button');
@@ -110,7 +110,7 @@ test('baseStructure', function() {
 	inp.focus();
 	ok(dp.is('.ui-datepicker-multi'), 'Structure multi [2] - multi-month');
 	equal(dp.children().length, 3 + (iframe ? 1 : 0), 'Structure multi [2] - child count');
-	var child = dp.children(':first');
+	child = dp.children(':first');
 	ok(child.is('div.ui-datepicker-group') && child.is('div.ui-datepicker-group-first'), 'Structure multi [2] - first month division');
 	child = dp.children(':eq(1)');
 	ok(child.is('div.ui-datepicker-group') && child.is('div.ui-datepicker-group-last'), 'Structure multi [2] - second month division');
@@ -146,16 +146,16 @@ test('baseStructure', function() {
 	inp.datepicker('hide').datepicker('destroy');
 
 	// Inline
-	var inl = init('#inl');
+	inl = init('#inl');
 	dp = inl.children();
 	ok(dp.is('.ui-datepicker-inline'), 'Structure inline - main div');
 	ok(!dp.is('.ui-datepicker-rtl'), 'Structure inline - not right-to-left');
 	ok(!dp.is('.ui-datepicker-multi'), 'Structure inline - not multi-month');
 	equal(dp.children().length, 2, 'Structure inline - child count');
-	var header = dp.children(':first');
+	header = dp.children(':first');
 	ok(header.is('div.ui-datepicker-header'), 'Structure inline - header division');
 	equal(header.children().length, 3, 'Structure inline - header child count');
-	var table = dp.children(':eq(1)');
+	table = dp.children(':eq(1)');
 	ok(table.is('table.ui-datepicker-calendar'), 'Structure inline - month table');
 	ok(table.children(':first').is('thead'), 'Structure inline - month table thead');
 	ok(table.children(':eq(1)').is('tbody'), 'Structure inline - month table body');
@@ -176,19 +176,20 @@ test('baseStructure', function() {
 });
 
 test('customStructure', function() {
-	var dp = $('#ui-datepicker-div');
-	// Check right-to-left localisation
-	var inp = init('#inp', $.datepicker.regional['he']);
+	var iframe, header, panel, title, thead,
+		dp = $('#ui-datepicker-div'),
+		// Check right-to-left localisation
+		inp = init('#inp', $.datepicker.regional.he);
 	inp.data('showButtonPanel.datepicker',true);
 	inp.focus();
-	var iframe = ($.browser.msie && parseInt($.browser.version) < 7);
+	iframe = ($.browser.msie && parseInt($.browser.version, 10) < 7);
 	ok(dp.is('.ui-datepicker-rtl'), 'Structure RTL - right-to-left');
-	var header = dp.children(':first');
+	header = dp.children(':first');
 	ok(header.is('div.ui-datepicker-header'), 'Structure RTL - header division');
 	equal(header.children().length, 3, 'Structure RTL - header child count');
 	ok(header.children(':first').is('a.ui-datepicker-next'), 'Structure RTL - prev link');
 	ok(header.children(':eq(1)').is('a.ui-datepicker-prev'), 'Structure RTL - next link');
-	var panel = dp.children(':last');
+	panel = dp.children(':last');
 	ok(panel.is('div.ui-datepicker-buttonpane'), 'Structure RTL - button division');
 	equal(panel.children().length, 2, 'Structure RTL - button panel child count');
 	ok(panel.children(':first').is('button.ui-datepicker-close'), 'Structure RTL - close button');
@@ -198,7 +199,7 @@ test('customStructure', function() {
 	// Hide prev/next
 	inp = init('#inp', {hideIfNoPrevNext: true, minDate: new Date(2008, 2 - 1, 4), maxDate: new Date(2008, 2 - 1, 14)});
 	inp.val('02/10/2008').focus();
-	var header = dp.children(':first');
+	header = dp.children(':first');
 	ok(header.is('div.ui-datepicker-header'), 'Structure hide prev/next - header division');
 	equal(header.children().length, 1, 'Structure hide prev/next - links child count');
 	ok(header.children(':first').is('div.ui-datepicker-title'), 'Structure hide prev/next - title division');
@@ -207,7 +208,7 @@ test('customStructure', function() {
 	// Changeable Month with read-only year
 	inp = init('#inp', {changeMonth: true});
 	inp.focus();
-	var title = dp.children(':first').children(':last');
+	title = dp.children(':first').children(':last');
 	equal(title.children().length, 2, 'Structure changeable month - title child count');
 	ok(title.children(':first').is('select.ui-datepicker-month'), 'Structure changeable month - month selector');
 	ok(title.children(':last').is('span.ui-datepicker-year'), 'Structure changeable month - read-only year');
@@ -216,7 +217,7 @@ test('customStructure', function() {
 	// Changeable year with read-only month
 	inp = init('#inp', {changeYear: true});
 	inp.focus();
-	var title = dp.children(':first').children(':last');
+	title = dp.children(':first').children(':last');
 	equal(title.children().length, 2, 'Structure changeable year - title child count');
 	ok(title.children(':first').is('span.ui-datepicker-month'), 'Structure changeable year - read-only month');
 	ok(title.children(':last').is('select.ui-datepicker-year'), 'Structure changeable year - year selector');
@@ -225,15 +226,15 @@ test('customStructure', function() {
 	// Read-only first day of week
 	inp = init('#inp', {changeFirstDay: false});
 	inp.focus();
-	var thead = dp.find('.ui-datepicker-calendar thead tr');
+	thead = dp.find('.ui-datepicker-calendar thead tr');
 	equal(thead.children().length, 7, 'Structure read-only first day - thead child count');
 	equal(thead.find('a').length, 0, 'Structure read-only first day - thead links count');
 	inp.datepicker('hide').datepicker('destroy');
 });
 
 test('keystrokes', function() {
-	var inp = init('#inp');
-	var date = new Date();
+	var inp = init('#inp'),
+		date = new Date();
 	inp.val('').datepicker('show').
 		simulate('keydown', {keyCode: $.ui.keyCode.ENTER});
 	equalsDate(inp.datepicker('getDate'), date, 'Keystroke enter');
@@ -366,9 +367,10 @@ test('keystrokes', function() {
 });
 
 test('mouse', function() {
-	var inp = init('#inp');
-	var dp = $('#ui-datepicker-div');
-	var date = new Date();
+	var inl,
+		inp = init('#inp'),
+		dp = $('#ui-datepicker-div'),
+		date = new Date();
 	inp.val('').datepicker('show');
 	$('.ui-datepicker-calendar tbody a:contains(10)', dp).simulate('click', {});
 	date.setDate(10);
@@ -419,9 +421,9 @@ test('mouse', function() {
 	equalsDate(inp.datepicker('getDate'), new Date(2008, 2 - 1, 18),
 		'Mouse click - next + min/max');
 	// Inline
-	var inl = init('#inl');
-	var dp = $('.ui-datepicker-inline', inl);
-	var date = new Date();
+	inl = init('#inl');
+	dp = $('.ui-datepicker-inline', inl);
+	date = new Date();
 	inl.datepicker('setDate', date);
 	$('.ui-datepicker-calendar tbody a:contains(10)', dp).simulate('click', {});
 	date.setDate(10);
diff --git a/tests/unit/datepicker/datepicker_defaults.js b/tests/unit/datepicker/datepicker_defaults.js
index 4243cf187..28e150791 100644
--- a/tests/unit/datepicker/datepicker_defaults.js
+++ b/tests/unit/datepicker/datepicker_defaults.js
@@ -6,4 +6,4 @@ var datepicker_defaults = {
 	disabled: false
 };
 
-//commonWidgetTests('datepicker', { defaults: datepicker_defaults });
+//TestHelpers.commonWidgetTests('datepicker', { defaults: datepicker_defaults });
diff --git a/tests/unit/datepicker/datepicker_events.js b/tests/unit/datepicker/datepicker_events.js
index 9876b7e60..b3e6704ef 100644
--- a/tests/unit/datepicker/datepicker_events.js
+++ b/tests/unit/datepicker/datepicker_events.js
@@ -5,9 +5,9 @@
 
 module("datepicker: events");
 
-var selectedThis = null;
-var selectedDate = null;
-var selectedInst = null;
+var selectedThis = null,
+selectedDate = null,
+selectedInst = null;
 
 function callback(date, inst) {
 	selectedThis = this;
@@ -22,8 +22,9 @@ function callback2(year, month, inst) {
 }
 
 test('events', function() {
-	var inp = init('#inp', {onSelect: callback});
-	var date = new Date();
+	var dateStr, newMonthYear, inp2,
+		inp = init('#inp', {onSelect: callback}),
+	date = new Date();
 	// onSelect
 	inp.val('').datepicker('show').
 		simulate('keydown', {keyCode: $.ui.keyCode.ENTER});
@@ -41,7 +42,7 @@ test('events', function() {
 		simulate('keydown', {keyCode: $.ui.keyCode.ESCAPE});
 	equal(selectedDate, $.datepicker.formatDate('mm/dd/yy', date),
 		'Callback selected date - esc');
-    var dateStr = '02/04/2008';
+    dateStr = '02/04/2008';
     inp.val(dateStr).datepicker('show').
         simulate('keydown', {keyCode: $.ui.keyCode.ENTER});
     equal(dateStr, selectedDate,
@@ -49,7 +50,7 @@ test('events', function() {
 	// onChangeMonthYear
 	inp.datepicker('option', {onChangeMonthYear: callback2, onSelect: null}).
 		val('').datepicker('show');
-	var newMonthYear = function(date) {
+	newMonthYear = function(date) {
 		return date.getFullYear() + '/' + (date.getMonth() + 1);
 	};
 	date = new Date();
@@ -118,7 +119,7 @@ test('events', function() {
 		simulate('keydown', {ctrlKey: true, keyCode: $.ui.keyCode.END});
 	equal(selectedDate, '', 'Callback close date - ctrl+end');
 
-	var inp2 = init('#inp2');
+	inp2 = init('#inp2');
 	inp2.datepicker().datepicker('option', {onClose: callback}).datepicker('show');
 	inp.datepicker('show');
 	equal(selectedThis, inp2[0], 'Callback close this');
diff --git a/tests/unit/datepicker/datepicker_methods.js b/tests/unit/datepicker/datepicker_methods.js
index c8f1b75b2..603427440 100644
--- a/tests/unit/datepicker/datepicker_methods.js
+++ b/tests/unit/datepicker/datepicker_methods.js
@@ -6,7 +6,8 @@
 module("datepicker: methods");
 
 test('destroy', function() {
-	var inp = init('#inp');
+	var inl,
+		inp = init('#inp');
 	ok(inp.is('.hasDatepicker'), 'Default - marker class set');
 	ok($.data(inp[0], PROP_NAME), 'Default - instance present');
 	ok(inp.next().is('#alt'), 'Default - button absent');
@@ -19,7 +20,7 @@ test('destroy', function() {
 	inp= init('#inp', {showOn: 'both'});
 	ok(inp.is('.hasDatepicker'), 'Button - marker class set');
 	ok($.data(inp[0], PROP_NAME), 'Button - instance present');
-	ok(inp.next().text() == '...', 'Button - button added');
+	ok(inp.next().text() === '...', 'Button - button added');
 	inp.datepicker('destroy');
 	inp = $('#inp');
 	ok(!inp.is('.hasDatepicker'), 'Button - marker class cleared');
@@ -29,7 +30,7 @@ test('destroy', function() {
 	inp = init('#inp', {appendText: 'Testing'});
 	ok(inp.is('.hasDatepicker'), 'Append - marker class set');
 	ok($.data(inp[0], PROP_NAME), 'Append - instance present');
-	ok(inp.next().text() == 'Testing', 'Append - append text added');
+	ok(inp.next().text() === 'Testing', 'Append - append text added');
 	inp.datepicker('destroy');
 	inp = $('#inp');
 	ok(!inp.is('.hasDatepicker'), 'Append - marker class cleared');
@@ -40,29 +41,30 @@ test('destroy', function() {
 		buttonImage: 'img/calendar.gif', appendText: 'Testing'});
 	ok(inp.is('.hasDatepicker'), 'Both - marker class set');
 	ok($.data(inp[0], PROP_NAME), 'Both - instance present');
-	ok(inp.next()[0].nodeName.toLowerCase() == 'img', 'Both - button added');
-	ok(inp.next().next().text() == 'Testing', 'Both - append text added');
+	ok(inp.next()[0].nodeName.toLowerCase() === 'img', 'Both - button added');
+	ok(inp.next().next().text() === 'Testing', 'Both - append text added');
 	inp.datepicker('destroy');
 	inp = $('#inp');
 	ok(!inp.is('.hasDatepicker'), 'Both - marker class cleared');
 	ok(!$.data(inp[0], PROP_NAME), 'Both - instance absent');
 	ok(inp.next().is('#alt'), 'Both - button and append text absent');
 	// Inline
-	var inl = init('#inl');
+	inl = init('#inl');
 	ok(inl.is('.hasDatepicker'), 'Inline - marker class set');
-	ok(inl.html() != '', 'Inline - datepicker present');
+	ok(inl.html() !== '', 'Inline - datepicker present');
 	ok($.data(inl[0], PROP_NAME), 'Inline - instance present');
-	ok(inl.next().length == 0 || inl.next().is('p'), 'Inline - button absent');
+	ok(inl.next().length === 0 || inl.next().is('p'), 'Inline - button absent');
 	inl.datepicker('destroy');
 	inl = $('#inl');
 	ok(!inl.is('.hasDatepicker'), 'Inline - marker class cleared');
-	ok(inl.html() == '', 'Inline - datepicker absent');
+	ok(inl.html() === '', 'Inline - datepicker absent');
 	ok(!$.data(inl[0], PROP_NAME), 'Inline - instance absent');
-	ok(inl.next().length == 0 || inl.next().is('p'), 'Inline - button absent');
+	ok(inl.next().length === 0 || inl.next().is('p'), 'Inline - button absent');
 });
 
 test('enableDisable', function() {
-	var inp = init('#inp');
+	var inl, dp,
+		inp = init('#inp');
 	ok(!inp.datepicker('isDisabled'), 'Enable/disable - initially marked as enabled');
 	ok(!inp[0].disabled, 'Enable/disable - field initially enabled');
 	inp.datepicker('disable');
@@ -91,19 +93,19 @@ test('enableDisable', function() {
 		buttonImage: 'img/calendar.gif'});
 	ok(!inp.datepicker('isDisabled'), 'Enable/disable image - initially marked as enabled');
 	ok(!inp[0].disabled, 'Enable/disable image - field initially enabled');
-	ok(inp.next('img').css('opacity') == 1, 'Enable/disable image - image initially enabled');
+	ok(parseFloat(inp.next('img').css('opacity')) === 1, 'Enable/disable image - image initially enabled');
 	inp.datepicker('disable');
 	ok(inp.datepicker('isDisabled'), 'Enable/disable image - now marked as disabled');
 	ok(inp[0].disabled, 'Enable/disable image - field now disabled');
-	ok(inp.next('img').css('opacity') != 1, 'Enable/disable image - image now disabled');
+	ok(parseFloat(inp.next('img').css('opacity')) !== 1, 'Enable/disable image - image now disabled');
 	inp.datepicker('enable');
 	ok(!inp.datepicker('isDisabled'), 'Enable/disable image - now marked as enabled');
 	ok(!inp[0].disabled, 'Enable/disable image - field now enabled');
-	ok(inp.next('img').css('opacity') == 1, 'Enable/disable image - image now enabled');
+	ok(parseFloat(inp.next('img').css('opacity')) === 1, 'Enable/disable image - image now enabled');
 	inp.datepicker('destroy');
 	// Inline
-	var inl = init('#inl', {changeYear: true});
-	var dp = $('.ui-datepicker-inline', inl);
+	inl = init('#inl', {changeYear: true});
+	dp = $('.ui-datepicker-inline', inl);
 	ok(!inl.datepicker('isDisabled'), 'Enable/disable inline - initially marked as enabled');
 	ok(!dp.children().is('.ui-state-disabled'), 'Enable/disable inline - not visually disabled initially');
 	ok(!dp.find('select').prop('disabled'), 'Enable/disable inline - form element enabled initially');
diff --git a/tests/unit/datepicker/datepicker_options.js b/tests/unit/datepicker/datepicker_options.js
index f538c6d03..3e200ecaa 100644
--- a/tests/unit/datepicker/datepicker_options.js
+++ b/tests/unit/datepicker/datepicker_options.js
@@ -16,8 +16,8 @@ test('setDefaults', function() {
 });
 
 test('option', function() {
-	var inp = init('#inp');
-	var inst = $.data(inp[0], PROP_NAME);
+	var inp = init('#inp'),
+	inst = $.data(inp[0], PROP_NAME);
 	// Set option
 	equal(inst.settings.showOn, null, 'Initial setting showOn');
 	equal($.datepicker._get(inst, 'showOn'), 'focus', 'Initial instance showOn');
@@ -47,8 +47,8 @@ test('option', function() {
 });
 
 test('change', function() {
-	var inp = init('#inp');
-	var inst = $.data(inp[0], PROP_NAME);
+	var inp = init('#inp'),
+	inst = $.data(inp[0], PROP_NAME);
 	equal(inst.settings.showOn, null, 'Initial setting showOn');
 	equal($.datepicker._get(inst, 'showOn'), 'focus', 'Initial instance showOn');
 	equal($.datepicker._defaults.showOn, 'focus', 'Initial default showOn');
@@ -67,14 +67,15 @@ test('change', function() {
 });
 
 test('invocation', function() {
-	var inp = init('#inp');
-	var dp = $('#ui-datepicker-div');
-	var body = $('body');
+	var button, image,
+		inp = init('#inp'),
+		dp = $('#ui-datepicker-div'),
+		body = $('body');
 	// On focus
-	var button = inp.siblings('button');
-	ok(button.length == 0, 'Focus - button absent');
-	var image = inp.siblings('img');
-	ok(image.length == 0, 'Focus - image absent');
+	button = inp.siblings('button');
+	ok(button.length === 0, 'Focus - button absent');
+	image = inp.siblings('img');
+	ok(image.length === 0, 'Focus - image absent');
 	inp.focus();
 	ok(dp.is(':visible'), 'Focus - rendered on focus');
 	inp.simulate('keydown', {keyCode: $.ui.keyCode.ESCAPE});
@@ -89,8 +90,8 @@ test('invocation', function() {
 	ok(!dp.is(':visible'), 'Button - initially hidden');
 	button = inp.siblings('button');
 	image = inp.siblings('img');
-	ok(button.length == 1, 'Button - button present');
-	ok(image.length == 0, 'Button - image absent');
+	ok(button.length === 1, 'Button - button present');
+	ok(image.length === 0, 'Button - image absent');
 	equal(button.text(), 'Popup', 'Button - button text');
 	inp.focus();
 	ok(!dp.is(':visible'), 'Button - not rendered on focus');
@@ -104,9 +105,9 @@ test('invocation', function() {
 		buttonImage: 'img/calendar.gif', buttonText: 'Cal'});
 	ok(!dp.is(':visible'), 'Image button - initially hidden');
 	button = inp.siblings('button');
-	ok(button.length == 0, 'Image button - button absent');
+	ok(button.length === 0, 'Image button - button absent');
 	image = inp.siblings('img');
-	ok(image.length == 1, 'Image button - image present');
+	ok(image.length === 1, 'Image button - image present');
 	equal(image.attr('src'), 'img/calendar.gif', 'Image button - image source');
 	equal(image.attr('title'), 'Cal', 'Image button - image text');
 	inp.focus();
@@ -120,11 +121,11 @@ test('invocation', function() {
 	inp = init('#inp', {showOn: 'both', buttonImage: 'img/calendar.gif'});
 	ok(!dp.is(':visible'), 'Both - initially hidden');
 	button = inp.siblings('button');
-	ok(button.length == 1, 'Both - button present');
+	ok(button.length === 1, 'Both - button present');
 	image = inp.siblings('img');
-	ok(image.length == 0, 'Both - image absent');
+	ok(image.length === 0, 'Both - image absent');
 	image = button.children('img');
-	ok(image.length == 1, 'Both - button image present');
+	ok(image.length === 1, 'Both - button image present');
 	inp.focus();
 	ok(dp.is(':visible'), 'Both - rendered on focus');
 	body.simulate('mousedown', {});
@@ -137,29 +138,29 @@ test('invocation', function() {
 });
 
 test('otherMonths', function() {
-	var inp = init('#inp');
-	var pop = $('#ui-datepicker-div');
+	var inp = init('#inp'),
+		pop = $('#ui-datepicker-div');
 	inp.val('06/01/2009').datepicker('show');
 	equal(pop.find('tbody').text(), '\u00a0123456789101112131415161718192021222324252627282930\u00a0\u00a0\u00a0\u00a0',
 		'Other months - none');
-	ok(pop.find('td:last *').length == 0, 'Other months - no content');
+	ok(pop.find('td:last *').length === 0, 'Other months - no content');
 	inp.datepicker('hide').datepicker('option', 'showOtherMonths', true).datepicker('show');
 	equal(pop.find('tbody').text(), '311234567891011121314151617181920212223242526272829301234',
 		'Other months - show');
-	ok(pop.find('td:last span').length == 1, 'Other months - span content');
+	ok(pop.find('td:last span').length === 1, 'Other months - span content');
 	inp.datepicker('hide').datepicker('option', 'selectOtherMonths', true).datepicker('show');
 	equal(pop.find('tbody').text(), '311234567891011121314151617181920212223242526272829301234',
 		'Other months - select');
-	ok(pop.find('td:last a').length == 1, 'Other months - link content');
+	ok(pop.find('td:last a').length === 1, 'Other months - link content');
 	inp.datepicker('hide').datepicker('option', 'showOtherMonths', false).datepicker('show');
 	equal(pop.find('tbody').text(), '\u00a0123456789101112131415161718192021222324252627282930\u00a0\u00a0\u00a0\u00a0',
 		'Other months - none');
-	ok(pop.find('td:last *').length == 0, 'Other months - no content');
+	ok(pop.find('td:last *').length === 0, 'Other months - no content');
 });
 
 test('defaultDate', function() {
-	var inp = init('#inp');
-	var date = new Date();
+	var inp = init('#inp'),
+		date = new Date();
 	inp.val('').datepicker('show').
 		simulate('keydown', {keyCode: $.ui.keyCode.ENTER});
 	equalsDate(inp.datepicker('getDate'), date, 'Default date null');
@@ -252,17 +253,19 @@ test('defaultDate', function() {
 });
 
 test('miscellaneous', function() {
-	var dp = $('#ui-datepicker-div');
-	var inp = init('#inp');
+	var curYear, longNames, shortNames, date,
+		dp = $('#ui-datepicker-div'),
+		inp = init('#inp');
 	// Year range
-	var genRange = function(start, offset) {
-		var range = '';
-		for (var i = start; i < start + offset; i++) {
+	function genRange(start, offset) {
+		var i = start,
+			range = '';
+		for (; i < start + offset; i++) {
 			range += i;
 		}
 		return range;
-	};
-	var curYear = new Date().getFullYear();
+	}
+	curYear = new Date().getFullYear();
 	inp.val('02/04/2008').datepicker('show');
 	equal(dp.find('.ui-datepicker-year').text(), '2008', 'Year range - read-only default');
 	inp.datepicker('hide').datepicker('option', {changeYear: true}).datepicker('show');
@@ -285,9 +288,9 @@ test('miscellaneous', function() {
 	equal(dp.find('.ui-datepicker-next').text(), 'Next', 'Navigation next - default');
 	inp.datepicker('hide').datepicker('option', {navigationAsDateFormat: true, prevText: '< M', currentText: 'MM', nextText: 'M >'}).
 		val('02/04/2008').datepicker('show');
-	var longNames = $.datepicker.regional[''].monthNames;
-	var shortNames = $.datepicker.regional[''].monthNamesShort;
-	var date = new Date();
+	longNames = $.datepicker.regional[''].monthNames;
+	shortNames = $.datepicker.regional[''].monthNamesShort;
+	date = new Date();
 	equal(dp.find('.ui-datepicker-prev').text(), '< ' + shortNames[0], 'Navigation prev - as date format');
 	equal(dp.find('.ui-datepicker-current').text(),
 		longNames[date.getMonth()], 'Navigation current - as date format');
@@ -311,11 +314,12 @@ test('miscellaneous', function() {
 });
 
 test('minMax', function() {
-	var inp = init('#inp');
-	var lastYear = new Date(2007, 6 - 1, 4);
-	var nextYear = new Date(2009, 6 - 1, 4);
-	var minDate = new Date(2008, 2 - 1, 29);
-	var maxDate = new Date(2008, 12 - 1, 7);
+	var date,
+		inp = init('#inp'),
+		lastYear = new Date(2007, 6 - 1, 4),
+		nextYear = new Date(2009, 6 - 1, 4),
+		minDate = new Date(2008, 2 - 1, 29),
+		maxDate = new Date(2008, 12 - 1, 7);
 	inp.val('06/04/2008').datepicker('show');
 	inp.simulate('keydown', {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}).
 		simulate('keydown', {keyCode: $.ui.keyCode.ENTER});
@@ -360,7 +364,7 @@ test('minMax', function() {
 	equalsDate(inp.datepicker('getDate'), maxDate,
 		'Min/max - null, 12/07/2008 - ctrl+pgdn');
 	// Relative dates
-	var date = new Date();
+	date = new Date();
 	date.setDate(date.getDate() - 7);
 	inp.datepicker('option', {minDate: '-1w', maxDate: '+1 M +10 D '}).
 		datepicker('hide').val('').datepicker('show');
@@ -394,9 +398,10 @@ test('minMax', function() {
 });
 
 test('setDate', function() {
-	var inp = init('#inp');
-	var date1 = new Date(2008, 6 - 1, 4);
-	var date2 = new Date();
+	var inl, alt, minDate, maxDate, dateAndTimeToSet, dateAndTimeClone,
+		inp = init('#inp'),
+		date1 = new Date(2008, 6 - 1, 4),
+		date2 = new Date();
 	ok(inp.datepicker('getDate') == null, 'Set date - default');
 	inp.datepicker('setDate', date1);
 	equalsDate(inp.datepicker('getDate'), date1, 'Set date - 2008-06-04');
@@ -423,7 +428,7 @@ test('setDate', function() {
 	inp.datepicker('setDate', 'c -3 w');
 	equalsDate(inp.datepicker('getDate'), date1, 'Set date - c -3 w');
 	// Inline
-	var inl = init('#inl');
+	inl = init('#inl');
 	date1 = new Date(2008, 6 - 1, 4);
 	date2 = new Date();
 	equalsDate(inl.datepicker('getDate'), date2, 'Set date inline - default');
@@ -441,7 +446,7 @@ test('setDate', function() {
 	inl.datepicker('setDate');
 	ok(inl.datepicker('getDate') == null, 'Set date inline - null');
 	// Alternate field
-	var alt = $('#alt');
+	alt = $('#alt');
 	inp.datepicker('option', {altField: '#alt', altFormat: 'yy-mm-dd'});
 	date1 = new Date(2008, 6 - 1, 4);
 	inp.datepicker('setDate', date1);
@@ -451,8 +456,8 @@ test('setDate', function() {
 	inp = init('#inp');
 	date1 = new Date(2008, 1 - 1, 4);
 	date2 = new Date(2008, 6 - 1, 4);
-	var minDate = new Date(2008, 2 - 1, 29);
-	var maxDate = new Date(2008, 3 - 1, 28);
+	minDate = new Date(2008, 2 - 1, 29);
+	maxDate = new Date(2008, 3 - 1, 28);
 	inp.val('').datepicker('option', {minDate: minDate}).datepicker('setDate', date2);
 	equalsDate(inp.datepicker('getDate'), date2, 'Set date min/max - setDate > min');
 	inp.datepicker('setDate', date1);
@@ -465,15 +470,15 @@ test('setDate', function() {
 	equalsDate(inp.datepicker('getDate'), minDate, 'Set date min/max - setDate < min');
 	inp.datepicker('setDate', date2);
 	equalsDate(inp.datepicker('getDate'), maxDate, 'Set date min/max - setDate > max');
-	var dateAndTimeToSet = new Date(2008, 3 - 1, 28, 1, 11, 0);
-	var dateAndTimeClone = new Date(2008, 3 - 1, 28, 1, 11, 0);
+	dateAndTimeToSet = new Date(2008, 3 - 1, 28, 1, 11, 0);
+	dateAndTimeClone = new Date(2008, 3 - 1, 28, 1, 11, 0);
 	inp.datepicker('setDate', dateAndTimeToSet);
 	equal(dateAndTimeToSet.getTime(), dateAndTimeClone.getTime(), 'Date object passed should not be changed by setDate');
 });
 
 test('altField', function() {
-	var inp = init('#inp');
-	var alt = $('#alt');
+	var inp = init('#inp'),
+		alt = $('#alt');
 	// No alternate field set
 	alt.val('');
 	inp.val('06/04/2008').datepicker('show');
@@ -507,26 +512,6 @@ test('altField', function() {
 	inp.simulate('keydown', {ctrlKey: true, keyCode: $.ui.keyCode.END});
 	equal(inp.val(), '', 'Alt field - dp - ctrl+end');
 	equal(alt.val(), '', 'Alt field - alt - ctrl+end');
-
-	return
-	// TODO manual entry impl works (see altField demo) but this test doesn't
-	// probably something the rewrite won't cover anymore anyway
-
-	// Verify alt field is updated on keyup
-	alt.val('');
-	inp.val('06/04/200').datepicker('show');
-	inp.simulate('keydown', {charCode: '8'.charCodeAt(0)});
-	inp.simulate('keypress', {charCode: '8'.charCodeAt(0)});
-	inp.simulate('keyup', {charCode: '8'.charCodeAt(0)});
-	equal(inp.val(), '06/04/2008', 'Alt field - dp - manual entry');
-	equal(alt.val(), '2008-06-04', 'Alt field - manual entry');
-	// Verify alt field is not updated on keyup if date is invalid
-	inp.val('12/04');
-	inp.simulate('keydown', {charCode: '/'.charCodeAt(0)});
-	inp.simulate('keypress', {charCode: '/'.charCodeAt(0)});
-	inp.simulate('keyup', {charCode: '/'.charCodeAt(0)});
-	equal(inp.val(), '12/04/', 'Alt field - dp - manual entry incomplete');
-	equal(alt.val(), '2008-06-04', 'Alt field - manual entry - not updated');
 });
 
 test('autoSize', function() {
@@ -541,7 +526,7 @@ test('autoSize', function() {
 	inp.datepicker('option', 'dateFormat', 'DD, MM dd, yy');
 	equal(inp.prop('size'), 29, 'Auto size - DD, MM dd, yy');
 	// French
-	inp.datepicker('option', $.extend({autoSize: false}, $.datepicker.regional['fr']));
+	inp.datepicker('option', $.extend({autoSize: false}, $.datepicker.regional.fr));
 	equal(inp.prop('size'), 29, 'Auto size - fr - default');
 	inp.datepicker('option', 'autoSize', true);
 	equal(inp.prop('size'), 10, 'Auto size - fr - dd/mm/yy');
@@ -552,7 +537,7 @@ test('autoSize', function() {
 	inp.datepicker('option', 'dateFormat', 'DD, MM dd, yy');
 	equal(inp.prop('size'), 28, 'Auto size - fr - DD, MM dd, yy');
 	// Hebrew
-	inp.datepicker('option', $.extend({autoSize: false}, $.datepicker.regional['he']));
+	inp.datepicker('option', $.extend({autoSize: false}, $.datepicker.regional.he));
 	equal(inp.prop('size'), 28, 'Auto size - he - default');
 	inp.datepicker('option', 'autoSize', true);
 	equal(inp.prop('size'), 10, 'Auto size - he - dd/mm/yy');
@@ -565,8 +550,8 @@ test('autoSize', function() {
 });
 
 test('daylightSaving', function() {
-	var inp = init('#inp');
-	var dp = $('#ui-datepicker-div');
+	var inp = init('#inp'),
+		dp = $('#ui-datepicker-div');
 	ok(true, 'Daylight saving - ' + new Date());
 	// Australia, Sydney - AM change, southern hemisphere
 	inp.val('04/01/2008').datepicker('show');
@@ -646,9 +631,12 @@ test('daylightSaving', function() {
 	equal(inp.val(), '11/03/2008', 'Daylight saving - US 11/03/2008');
 });
 
-var beforeShowThis = null;
-var beforeShowInput = null;
-var beforeShowInst = null;
+var beforeShowThis = null,
+	beforeShowInput = null,
+	beforeShowInst = null,
+	beforeShowDayThis = null,
+	beforeShowDayOK = true;
+
 
 function beforeAll(input, inst) {
 	beforeShowThis = this;
@@ -657,84 +645,86 @@ function beforeAll(input, inst) {
 	return {currentText: 'Current'};
 }
 
-var beforeShowDayThis = null;
-var beforeShowDayOK = true;
-
 function beforeDay(date) {
 	beforeShowDayThis = this;
 	beforeShowDayOK &= (date > new Date(2008, 1 - 1, 26) &&
 		date < new Date(2008, 3 - 1, 6));
-	return [(date.getDate() % 2 == 0), (date.getDate() % 10 == 0 ? 'day10' : ''),
-		(date.getDate() % 3 == 0 ? 'Divisble by 3' : '')];
+	return [(date.getDate() % 2 === 0), (date.getDate() % 10 === 0 ? 'day10' : ''),
+		(date.getDate() % 3 === 0 ? 'Divisble by 3' : '')];
 }
 
 function calcWeek(date) {
-	var doy = date.getDate() + 6;
-	for (var m = date.getMonth() - 1; m >= 0; m--)
+	var doy = date.getDate() + 6,
+		m = date.getMonth() - 1;
+	for (; m >= 0; m--) {
 		doy += $.datepicker._getDaysInMonth(date.getFullYear(), m);
+	}
 	// Simple count from 01/01 starting at week 1
 	return Math.floor(doy / 7);
 }
 
 test('callbacks', function() {
 	// Before show
-	var inp = init('#inp', {beforeShow: beforeAll});
-	var inst = $.data(inp[0], 'datepicker');
+	var dp, day20, day21,
+		inp = init('#inp', {beforeShow: beforeAll}),
+		inst = $.data(inp[0], 'datepicker');
 	equal($.datepicker._get(inst, 'currentText'), 'Today', 'Before show - initial');
 	inp.val('02/04/2008').datepicker('show');
 	equal($.datepicker._get(inst, 'currentText'), 'Current', 'Before show - changed');
-	ok(beforeShowThis.id == inp[0].id, 'Before show - this OK');
-	ok(beforeShowInput.id == inp[0].id, 'Before show - input OK');
+	ok(beforeShowThis.id === inp[0].id, 'Before show - this OK');
+	ok(beforeShowInput.id === inp[0].id, 'Before show - input OK');
 	deepEqual(beforeShowInst, inst, 'Before show - inst OK');
 	inp.datepicker('hide').datepicker('destroy');
 	// Before show day
 	inp = init('#inp', {beforeShowDay: beforeDay});
-	var dp = $('#ui-datepicker-div');
+	dp = $('#ui-datepicker-div');
 	inp.val('02/04/2008').datepicker('show');
-	ok(beforeShowDayThis.id == inp[0].id, 'Before show day - this OK');
+	ok(beforeShowDayThis.id === inp[0].id, 'Before show day - this OK');
 	ok(beforeShowDayOK, 'Before show day - dates OK');
-	var day20 = dp.find('.ui-datepicker-calendar td:contains("20")');
-	var day21 = dp.find('.ui-datepicker-calendar td:contains("21")');
+	day20 = dp.find('.ui-datepicker-calendar td:contains("20")');
+	day21 = dp.find('.ui-datepicker-calendar td:contains("21")');
 	ok(!day20.is('.ui-datepicker-unselectable'), 'Before show day - unselectable 20');
 	ok(day21.is('.ui-datepicker-unselectable'), 'Before show day - unselectable 21');
 	ok(day20.is('.day10'), 'Before show day - CSS 20');
 	ok(!day21.is('.day10'), 'Before show day - CSS 21');
 	ok(!day20.attr('title'), 'Before show day - title 20');
-	ok(day21.attr('title') == 'Divisble by 3', 'Before show day - title 21');
+	ok(day21.attr('title') === 'Divisble by 3', 'Before show day - title 21');
 	inp.datepicker('hide').datepicker('destroy');
 });
 
 test('localisation', function() {
-	var inp = init('#inp', $.datepicker.regional['fr']);
+	var dp, month, day, date,
+		inp = init('#inp', $.datepicker.regional.fr);
 	inp.datepicker('option', {dateFormat: 'DD, d MM yy', showButtonPanel:true, changeMonth:true, changeYear:true}).val('').datepicker('show');
-	var dp = $('#ui-datepicker-div');
+	dp = $('#ui-datepicker-div');
 	equal($('.ui-datepicker-close', dp).text(), 'Fermer', 'Localisation - close');
 	$('.ui-datepicker-close', dp).simulate('mouseover');
 	equal($('.ui-datepicker-prev', dp).text(), 'Précédent', 'Localisation - previous');
 	equal($('.ui-datepicker-current', dp).text(), 'Aujourd\'hui', 'Localisation - current');
 	equal($('.ui-datepicker-next', dp).text(), 'Suivant', 'Localisation - next');
-	var month = 0;
+	month = 0;
 	$('.ui-datepicker-month option', dp).each(function() {
-		equal($(this).text(), $.datepicker.regional['fr'].monthNamesShort[month],
+		equal($(this).text(), $.datepicker.regional.fr.monthNamesShort[month],
 			'Localisation - month ' + month);
 		month++;
 	});
-	var day = 1;
+	day = 1;
 	$('.ui-datepicker-calendar th', dp).each(function() {
-		equal($(this).text(), $.datepicker.regional['fr'].dayNamesMin[day],
+		equal($(this).text(), $.datepicker.regional.fr.dayNamesMin[day],
 			'Localisation - day ' + day);
 		day = (day + 1) % 7;
 	});
 	inp.simulate('keydown', {keyCode: $.ui.keyCode.ENTER});
-	var date = new Date();
-	equal(inp.val(), $.datepicker.regional['fr'].dayNames[date.getDay()] + ', ' +
-		date.getDate() + ' ' + $.datepicker.regional['fr'].monthNames[date.getMonth()] +
+	date = new Date();
+	equal(inp.val(), $.datepicker.regional.fr.dayNames[date.getDay()] + ', ' +
+		date.getDate() + ' ' + $.datepicker.regional.fr.monthNames[date.getMonth()] +
 		' ' + date.getFullYear(), 'Localisation - formatting');
 });
 
 test('noWeekends', function() {
-	for (var i = 1; i <= 31; i++) {
-		var date = new Date(2001, 1 - 1, i);
+	var i, date;
+	for (i = 1; i <= 31; i++) {
+		date = new Date(2001, 1 - 1, i);
 		deepEqual($.datepicker.noWeekends(date), [(i + 1) % 7 >= 2, ''],
 			'No weekends ' + date);
 	}
@@ -769,6 +759,7 @@ test('iso8601Week', function() {
 
 test('parseDate', function() {
 	init('#inp');
+	var currentYear, gmtDate, fr, settings, zh;
 	ok($.datepicker.parseDate('d m y', '') == null, 'Parse date empty');
 	equalsDate($.datepicker.parseDate('d m y', '3 2 01'),
 		new Date(2001, 2 - 1, 3), 'Parse date d m y');
@@ -793,7 +784,7 @@ test('parseDate', function() {
 	equalsDate($.datepicker.parseDate('\'day\' d \'of\' MM (\'\'DD\'\'), yy',
 		'day 3 of February (\'Saturday\'), 2001'), new Date(2001, 2 - 1, 3),
 		'Parse date \'day\' d \'of\' MM (\'\'DD\'\'), yy');
-	var currentYear = new Date().getFullYear();
+	currentYear = new Date().getFullYear();
 	equalsDate($.datepicker.parseDate('y-m-d', (currentYear - 2000) + '-02-03'),
 			new Date(currentYear, 2 - 1, 3), 'Parse date y-m-d - default cutuff');
 	equalsDate($.datepicker.parseDate('y-m-d', (currentYear - 2000 + 10) + '-02-03'),
@@ -808,12 +799,12 @@ test('parseDate', function() {
 			new Date(currentYear + 60, 2 - 1, 3), 'Parse date y-m-d - cutoff +60');
 	equalsDate($.datepicker.parseDate('y-m-d', (currentYear - 2000 + 61) + '-02-03', {shortYearCutoff: '+60'}),
 			new Date(currentYear - 39, 2 - 1, 3), 'Parse date y-m-d - cutoff +60');
-	var gmtDate = new Date(2001, 2 - 1, 3);
+	gmtDate = new Date(2001, 2 - 1, 3);
 	gmtDate.setMinutes(gmtDate.getMinutes() - gmtDate.getTimezoneOffset());
 	equalsDate($.datepicker.parseDate('@', '981158400000'), gmtDate, 'Parse date @');
 	equalsDate($.datepicker.parseDate('!', '631167552000000000'), gmtDate, 'Parse date !');
-	var fr = $.datepicker.regional['fr'];
-	var settings = {dayNamesShort: fr.dayNamesShort, dayNames: fr.dayNames,
+	fr = $.datepicker.regional.fr;
+	settings = {dayNamesShort: fr.dayNamesShort, dayNames: fr.dayNames,
 		monthNamesShort: fr.monthNamesShort, monthNames: fr.monthNames};
 	equalsDate($.datepicker.parseDate('D d M y', 'Lun. 9 Avril 01', settings),
 		new Date(2001, 4 - 1, 9), 'Parse date D M y with settings');
@@ -825,14 +816,15 @@ test('parseDate', function() {
 		'jour 9 de Avril (\'Lundi\'), 2001', settings), new Date(2001, 4 - 1, 9),
 		'Parse date \'jour\' d \'de\' MM (\'\'DD\'\'), yy with settings');
 
-	var zh = $.datepicker.regional['zh-CN'];
+	zh = $.datepicker.regional['zh-CN'];
 	equalsDate($.datepicker.parseDate('yy M d', '2011 十一 22', zh),
 		new Date(2011, 11 - 1, 22), 'Parse date yy M d with zh-CN');
 });
 
 test('parseDateErrors', function() {
 	init('#inp');
-	var expectError = function(expr, value, error) {
+	var fr, settings;
+	function expectError(expr, value, error) {
 		try {
 			expr();
 			ok(false, 'Parsed error ' + value);
@@ -840,7 +832,7 @@ test('parseDateErrors', function() {
 		catch (e) {
 			equal(e, error, 'Parsed error ' + value);
 		}
-	};
+	}
 	expectError(function() { $.datepicker.parseDate(null, 'Sat 2 01'); },
 		'Sat 2 01', 'Invalid arguments');
 	expectError(function() { $.datepicker.parseDate('d m y', null); },
@@ -872,8 +864,8 @@ test('parseDateErrors', function() {
 		'day 3 of Mon2 ("Day7"), 2001', 'Unexpected literal at position 19');
 	expectError(function() { $.datepicker.parseDate('d m y', '29 2 01'); },
 		'29 2 01 - d m y', 'Invalid date');
-	var fr = $.datepicker.regional['fr'];
-	var settings = {dayNamesShort: fr.dayNamesShort, dayNames: fr.dayNames,
+	fr = $.datepicker.regional.fr;
+	settings = {dayNamesShort: fr.dayNamesShort, dayNames: fr.dayNames,
 		monthNamesShort: fr.monthNamesShort, monthNames: fr.monthNames};
 	expectError(function() { $.datepicker.parseDate('D d M y', 'Mon 9 Avr 01', settings); },
 		'Mon 9 Avr 01 - D d M y', 'Unknown name at position 0');
@@ -883,6 +875,7 @@ test('parseDateErrors', function() {
 
 test('formatDate', function() {
 	init('#inp');
+	var gmtDate, fr, settings;
 	equal($.datepicker.formatDate('d m y', new Date(2001, 2 - 1, 3)),
 		'3 2 01', 'Format date d m y');
 	equal($.datepicker.formatDate('dd mm yy', new Date(2001, 2 - 1, 3)),
@@ -904,12 +897,12 @@ test('formatDate', function() {
 	equal($.datepicker.formatDate('\'day\' d \'of\' MM (\'\'DD\'\'), yy',
 		new Date(2001, 2 - 1, 3)), 'day 3 of February (\'Saturday\'), 2001',
 		'Format date \'day\' d \'of\' MM (\'\'DD\'\'), yy');
-	var gmtDate = new Date(2001, 2 - 1, 3);
+	gmtDate = new Date(2001, 2 - 1, 3);
 	gmtDate.setMinutes(gmtDate.getMinutes() - gmtDate.getTimezoneOffset());
 	equal($.datepicker.formatDate('@', gmtDate), '981158400000', 'Format date @');
 	equal($.datepicker.formatDate('!', gmtDate), '631167552000000000', 'Format date !');
-	var fr = $.datepicker.regional['fr'];
-	var settings = {dayNamesShort: fr.dayNamesShort, dayNames: fr.dayNames,
+	fr = $.datepicker.regional.fr;
+	settings = {dayNamesShort: fr.dayNamesShort, dayNames: fr.dayNames,
 		monthNamesShort: fr.monthNamesShort, monthNames: fr.monthNames};
 	equal($.datepicker.formatDate('D M y', new Date(2001, 4 - 1, 9), settings),
 		'Lun. Avril 01', 'Format date D M y with settings');
diff --git a/tests/unit/datepicker/datepicker_tickets.js b/tests/unit/datepicker/datepicker_tickets.js
index fcf712370..105be63a6 100644
--- a/tests/unit/datepicker/datepicker_tickets.js
+++ b/tests/unit/datepicker/datepicker_tickets.js
@@ -7,8 +7,8 @@ module("datepicker: tickets");
 
 // http://forum.jquery.com/topic/several-breaking-changes-in-jquery-ui-1-8rc1
 test('beforeShowDay-getDate', function() {
-	var inp = init('#inp', {beforeShowDay: function(date) { inp.datepicker('getDate'); return [true, '']; }});
-	var dp = $('#ui-datepicker-div');
+	var inp = init('#inp', {beforeShowDay: function(date) { inp.datepicker('getDate'); return [true, '']; }}),
+	   dp = $('#ui-datepicker-div');
 	inp.val('01/01/2010').datepicker('show');
 	// contains non-breaking space
 	equal($('div.ui-datepicker-title').text(), 'January 2010', 'Initial month');
@@ -26,11 +26,11 @@ test('beforeShowDay-getDate', function() {
 
 test('Ticket 7602: Stop datepicker from appearing with beforeShow event handler', function(){
     var inp = init('#inp',{
-        beforeShow: function(){
-            return false;
-        }
-    });
-	var dp = $('#ui-datepicker-div');
+            beforeShow: function(){
+                return false;
+            }
+        }),
+        dp = $('#ui-datepicker-div');
     inp.datepicker('show');
     equal(dp.css('display'), 'none',"beforeShow returns false");
     inp.datepicker('destroy');
diff --git a/tests/unit/dialog/dialog_core.js b/tests/unit/dialog/dialog_core.js
index 4a671968e..5d7beb99b 100644
--- a/tests/unit/dialog/dialog_core.js
+++ b/tests/unit/dialog/dialog_core.js
@@ -40,8 +40,8 @@ function drag(handle, dx, dy) {
 
 function moved(dx, dy, msg) {
 	msg = msg ? msg + "." : "";
-	var actual = { left: Math.round(offsetAfter.left), top: Math.round(offsetAfter.top) };
-	var expected = { left: Math.round(offsetBefore.left + dx), top: Math.round(offsetBefore.top + dy) };
+	var actual = { left: Math.round(offsetAfter.left), top: Math.round(offsetAfter.top) },
+		expected = { left: Math.round(offsetBefore.left + dx), top: Math.round(offsetBefore.top + dy) };
 	deepEqual(actual, expected, 'dragged[' + dragged.dx + ', ' + dragged.dy + '] ' + msg);
 }
 
@@ -59,8 +59,8 @@ function shouldnotmove(why) {
 
 function resized(dw, dh, msg) {
 	msg = msg ? msg + "." : "";
-	var actual = { width: widthAfter, height: heightAfter };
-	var expected = { width: widthBefore + dw, height: heightBefore + dh };
+	var actual = { width: widthAfter, height: heightAfter },
+		expected = { width: widthBefore + dw, height: heightBefore + dh };
 	deepEqual(actual, expected, 'resized[' + dragged.dx + ', ' + dragged.dy + '] ' + msg);
 }
 
diff --git a/tests/unit/dialog/dialog_defaults.js b/tests/unit/dialog/dialog_defaults.js
index 9f2e4c6a8..623908da7 100644
--- a/tests/unit/dialog/dialog_defaults.js
+++ b/tests/unit/dialog/dialog_defaults.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "dialog", {
+TestHelpers.commonWidgetTests( "dialog", {
 	defaults: {
 		autoOpen: true,
 		buttons: {},
diff --git a/tests/unit/dialog/dialog_events.js b/tests/unit/dialog/dialog_events.js
index 4b769bafc..85afa5a3b 100644
--- a/tests/unit/dialog/dialog_events.js
+++ b/tests/unit/dialog/dialog_events.js
@@ -63,7 +63,8 @@ test("dragStart", function() {
 
 test("drag", function() {
 	expect(9);
-	var hasDragged = false;
+	var handle,
+		hasDragged = false;
 
 	el = $('<div></div>').dialog({
 		drag: function(ev, ui) {
@@ -83,7 +84,7 @@ test("drag", function() {
 		ok(ui.position !== undefined, "ui.position in callback");
 		ok(ui.offset !== undefined, "ui.offset in callback");
 	});
-	var handle = $(".ui-dialog-titlebar", dlg());
+	handle = $(".ui-dialog-titlebar", dlg());
 	drag(handle, 50, 50);
 	el.remove();
 });
@@ -138,7 +139,8 @@ test("resizeStart", function() {
 
 test("resize", function() {
 	expect(13);
-	var hasResized = false;
+	var handle,
+		hasResized = false;
 
 	el = $('<div></div>').dialog({
 		resize: function(ev, ui) {
@@ -162,7 +164,7 @@ test("resize", function() {
 		ok(ui.position !== undefined, "ui.position in callback");
 		ok(ui.size !== undefined, "ui.size in callback");
 	});
-	var handle = $(".ui-resizable-se", dlg());
+	handle = $(".ui-resizable-se", dlg());
 	drag(handle, 50, 50);
 	el.remove();
 });
diff --git a/tests/unit/dialog/dialog_methods.js b/tests/unit/dialog/dialog_methods.js
index 645baa9f5..1f84cd6b5 100644
--- a/tests/unit/dialog/dialog_methods.js
+++ b/tests/unit/dialog/dialog_methods.js
@@ -98,14 +98,17 @@ test("isOpen", function() {
 });
 
 test("moveToTop", function() {
-	var expected = $('<div></div>').dialog(),
+	var d1, d2, dlg1, dlg2,
+		expected = $('<div></div>').dialog(),
 		actual = expected.dialog('moveToTop');
 	equal(actual, expected, 'moveToTop is chainable');
 
-	var d1 = $('<div></div>').dialog(), dlg1 = d1.parents('.ui-dialog');
+	d1 = $('<div></div>').dialog();
+	dlg1 = d1.parents('.ui-dialog');
 	d1.dialog('close');
 	d1.dialog('open');
-	var d2 = $('<div></div>').dialog(), dlg2 = d2.parents('.ui-dialog');
+	d2 = $('<div></div>').dialog();
+	dlg2 = d2.parents('.ui-dialog');
 	d2.dialog('close');
 	d2.dialog('open');
 	ok(dlg1.css('zIndex') < dlg2.css('zIndex'), 'dialog 1 under dialog 2 before moveToTop method called');
diff --git a/tests/unit/dialog/dialog_options.js b/tests/unit/dialog/dialog_options.js
index 10443892b..c071c1b09 100644
--- a/tests/unit/dialog/dialog_options.js
+++ b/tests/unit/dialog/dialog_options.js
@@ -20,7 +20,8 @@ test("autoOpen", function() {
 test("buttons", function() {
 	expect(21);
 
-	var buttons = {
+	var btn, i, newButtons,
+		buttons = {
 		"Ok": function(ev, ui) {
 			ok(true, "button click fires callback");
 			equal(this, el[0], "context of callback");
@@ -34,10 +35,10 @@ test("buttons", function() {
 	};
 
 	el = $('<div></div>').dialog({ buttons: buttons });
-	var btn = $("button", dlg());
+	btn = $("button", dlg());
 	equal(btn.length, 2, "number of buttons");
 
-	var i = 0;
+	i = 0;
 	$.each(buttons, function(key, val) {
 		equal(btn.eq(i).text(), key, "text of button " + (i+1));
 		i++;
@@ -48,7 +49,7 @@ test("buttons", function() {
 
 	btn.trigger("click");
 
-	var newButtons = {
+	newButtons = {
 		"Close": function(ev, ui) {
 			ok(true, "button click fires callback");
 			equal(this, el[0], "context of callback");
@@ -275,54 +276,54 @@ test("minWidth", function() {
 });
 
 test("position, default center on window", function() {
-	var el = $('<div></div>').dialog();
-	var dialog = el.dialog('widget');
-	var offset = dialog.offset();
+	var el = $('<div></div>').dialog(),
+		dialog = el.dialog('widget'),
+		offset = dialog.offset();
 	deepEqual(offset.left, Math.round($(window).width() / 2 - dialog.outerWidth() / 2) + $(window).scrollLeft());
 	deepEqual(offset.top, Math.round($(window).height() / 2 - dialog.outerHeight() / 2) + $(window).scrollTop());
 	el.remove();
 });
 
 test("position, top on window", function() {
-	var el = $('<div></div>').dialog({ position: "top" });
-	var dialog = el.dialog('widget');
-	var offset = dialog.offset();
+	var el = $('<div></div>').dialog({ position: "top" }),
+		dialog = el.dialog('widget'),
+		offset = dialog.offset();
 	deepEqual(offset.left, Math.round($(window).width() / 2 - dialog.outerWidth() / 2) + $(window).scrollLeft());
 	deepEqual(offset.top, $(window).scrollTop());
 	el.remove();
 });
 
 test("position, left on window", function() {
-	var el = $('<div></div>').dialog({ position: "left" });
-	var dialog = el.dialog('widget');
-	var offset = dialog.offset();
+	var el = $('<div></div>').dialog({ position: "left" }),
+		dialog = el.dialog('widget'),
+		offset = dialog.offset();
 	deepEqual(offset.left, 0);
 	deepEqual(offset.top, Math.round($(window).height() / 2 - dialog.outerHeight() / 2) + $(window).scrollTop());
 	el.remove();
 });
 
 test("position, right bottom on window", function() {
-	var el = $('<div></div>').dialog({ position: "right bottom" });
-	var dialog = el.dialog('widget');
-	var offset = dialog.offset();
+	var el = $('<div></div>').dialog({ position: "right bottom" }),
+		dialog = el.dialog('widget'),
+		offset = dialog.offset();
 	deepEqual(offset.left, $(window).width() - dialog.outerWidth() + $(window).scrollLeft());
 	deepEqual(offset.top, $(window).height() - dialog.outerHeight() + $(window).scrollTop());
 	el.remove();
 });
 
 test("position, right bottom on window w/array", function() {
-	var el = $('<div></div>').dialog({ position: ["right", "bottom"] });
-	var dialog = el.dialog('widget');
-	var offset = dialog.offset();
+	var el = $('<div></div>').dialog({ position: ["right", "bottom"] }),
+		dialog = el.dialog('widget'),
+		offset = dialog.offset();
 	deepEqual(offset.left, $(window).width() - dialog.outerWidth() + $(window).scrollLeft());
 	deepEqual(offset.top, $(window).height() - dialog.outerHeight() + $(window).scrollTop());
 	el.remove();
 });
 
 test("position, offset from top left w/array", function() {
-	var el = $('<div></div>').dialog({ position: [10, 10] });
-	var dialog = el.dialog('widget');
-	var offset = dialog.offset();
+	var el = $('<div></div>').dialog({ position: [10, 10] }),
+		dialog = el.dialog('widget'),
+		offset = dialog.offset();
 	deepEqual(offset.left, 10 + $(window).scrollLeft());
 	deepEqual(offset.top, 10 + $(window).scrollTop());
 	el.remove();
@@ -330,14 +331,13 @@ test("position, offset from top left w/array", function() {
 
 test("position, right bottom at right bottom via ui.position args", function() {
 	var el = $('<div></div>').dialog({
-		position: {
-			my: "right bottom",
-			at: "right bottom"
-		}
-	});
-
-	var dialog = el.dialog('widget');
-	var offset = dialog.offset();
+			position: {
+				my: "right bottom",
+				at: "right bottom"
+			}
+		}),
+		dialog = el.dialog('widget'),
+		offset = dialog.offset();
 
 	deepEqual(offset.left, $(window).width() - dialog.outerWidth() + $(window).scrollLeft());
 	deepEqual(offset.top, $(window).height() - dialog.outerHeight() + $(window).scrollTop());
@@ -346,23 +346,23 @@ test("position, right bottom at right bottom via ui.position args", function() {
 
 test("position, at another element", function() {
 	var parent = $('<div></div>').css({
-		position: 'absolute',
-		top: 400,
-		left: 600,
-		height: 10,
-		width: 10
-	}).appendTo('body');
-
-	var el = $('<div></div>').dialog({
-		position: {
-			my: "left top",
-			at: "left top",
-			of: parent
-		}
-	});
+			position: 'absolute',
+			top: 400,
+			left: 600,
+			height: 10,
+			width: 10
+		}).appendTo('body'),
+
+		el = $('<div></div>').dialog({
+			position: {
+				my: "left top",
+				at: "left top",
+				of: parent
+			}
+		}),
 
-	var dialog = el.dialog('widget');
-	var offset = dialog.offset();
+		dialog = el.dialog('widget'),
+		offset = dialog.offset();
 
 	deepEqual(offset.left, 600);
 	deepEqual(offset.top, 400);
@@ -373,7 +373,7 @@ test("position, at another element", function() {
 			of: parent
 	});
 
-	var offset = dialog.offset();
+	offset = dialog.offset();
 
 	deepEqual(offset.left, 610);
 	deepEqual(offset.top, 410);
diff --git a/tests/unit/dialog/dialog_tickets.js b/tests/unit/dialog/dialog_tickets.js
index bd9056153..a169bd1a5 100644
--- a/tests/unit/dialog/dialog_tickets.js
+++ b/tests/unit/dialog/dialog_tickets.js
@@ -12,12 +12,6 @@ asyncTest( "#3123: Prevent tabbing out of modal dialogs", function() {
 		inputs = el.find( "input" ),
 		widget = el.dialog( "widget" );
 
-	inputs.eq( 1 ).focus();
-	equal( document.activeElement, inputs[1], "Focus set on second input" );
-	inputs.eq( 1 ).simulate( "keydown", { keyCode: $.ui.keyCode.TAB });
-
-	setTimeout( checkTab, 2 );
-
 	function checkTab() {
 		ok( $.contains( widget, document.activeElement ), "Tab key event moved focus within the modal" );
 
@@ -32,14 +26,21 @@ asyncTest( "#3123: Prevent tabbing out of modal dialogs", function() {
 		el.remove();
 		start();
 	}
+
+	inputs.eq( 1 ).focus();
+	equal( document.activeElement, inputs[1], "Focus set on second input" );
+	inputs.eq( 1 ).simulate( "keydown", { keyCode: $.ui.keyCode.TAB });
+
+	setTimeout( checkTab, 2 );
 });
 
 test("#4826: setting resizable false toggles resizable on dialog", function() {
 	expect(6);
+	var i;
 
 	el = $('<div></div>').dialog({ resizable: false });
 	shouldnotresize("[default]");
-	for (var i=0; i<2; i++) {
+	for (i=0; i<2; i++) {
 		el.dialog('close').dialog('open');
 		shouldnotresize('initialized with resizable false toggle ('+ (i+1) +')');
 	}
@@ -47,7 +48,7 @@ test("#4826: setting resizable false toggles resizable on dialog", function() {
 
 	el = $('<div></div>').dialog({ resizable: true });
 	shouldresize("[default]");
-	for (var i=0; i<2; i++) {
+	for (i=0; i<2; i++) {
 		el.dialog('close').dialog('option', 'resizable', false).dialog('open');
 		shouldnotresize('set option resizable false toggle ('+ (i+1) +')');
 	}
@@ -108,7 +109,7 @@ test("#6137: dialog('open') causes form elements to reset on IE7", function() {
 test("#6645: Missing element not found check in overlay", function(){
     expect(2);
     d1 = $('<div title="dialog 1">Dialog 1</div>').dialog({modal: true});
-    d2 = $('<div title="dialog 2">Dialog 2</div>').dialog({modal: true, close: function(){ d2.remove()}});
+    d2 = $('<div title="dialog 2">Dialog 2</div>').dialog({modal: true, close: function(){ d2.remove(); }});
     equal($.ui.dialog.overlay.instances.length, 2, 'two overlays created');
     d2.dialog('close');
     equal($.ui.dialog.overlay.instances.length, 1, 'one overlay remains after closing the 2nd overlay');
@@ -119,7 +120,7 @@ test("#6966: Escape key closes all dialogs, not the top one", function(){
 	expect(8);
     // test with close function removing dialog
     d1 = $('<div title="dialog 1">Dialog 1</div>').dialog({modal: true});
-    d2 = $('<div title="dialog 2">Dialog 2</div>').dialog({modal: true, close: function(){ d2.remove()}});
+    d2 = $('<div title="dialog 2">Dialog 2</div>').dialog({modal: true, close: function(){ d2.remove(); }});
     ok(d1.dialog("isOpen"), 'first dialog is open');
     ok(d2.dialog("isOpen"), 'second dialog is open');
     d2.simulate("keydown", {keyCode: $.ui.keyCode.ESCAPE});
diff --git a/tests/unit/draggable/draggable_core.js b/tests/unit/draggable/draggable_core.js
index ba5bc4c66..9193881ad 100644
--- a/tests/unit/draggable/draggable_core.js
+++ b/tests/unit/draggable/draggable_core.js
@@ -4,7 +4,7 @@
 
 var el, offsetBefore, offsetAfter, dragged;
 
-var drag = function(handle, dx, dy) {
+function drag(handle, dx, dy) {
 	var element = el.data("draggable").element;
 	offsetBefore = el.offset();
 	$(handle).simulate("drag", {
@@ -15,10 +15,10 @@ var drag = function(handle, dx, dy) {
 	offsetAfter = el.offset();
 }
 
-var moved = function (dx, dy, msg) {
+function moved(dx, dy, msg) {
 	msg = msg ? msg + "." : "";
-	var actual = { left: offsetAfter.left, top: offsetAfter.top };
-	var expected = { left: offsetBefore.left + dx, top: offsetBefore.top + dy };
+	var actual = { left: offsetAfter.left, top: offsetAfter.top },
+		expected = { left: offsetBefore.left + dx, top: offsetBefore.top + dy };
 	deepEqual(actual, expected, 'dragged[' + dragged.dx + ', ' + dragged.dy + '] ' + msg);
 }
 
@@ -35,15 +35,15 @@ function restoreScroll(what) {
 module("draggable");
 
 test("element types", function() {
-	var typeNames = ('p,h1,h2,h3,h4,h5,h6,blockquote,ol,ul,dl,div,form'
-		+ ',table,fieldset,address,ins,del,em,strong,q,cite,dfn,abbr'
-		+ ',acronym,code,samp,kbd,var,img,object,hr'
-		+ ',input,button,label,select,iframe').split(',');
+	var typeNames = ('p,h1,h2,h3,h4,h5,h6,blockquote,ol,ul,dl,div,form' +
+		',table,fieldset,address,ins,del,em,strong,q,cite,dfn,abbr' +
+		',acronym,code,samp,kbd,var,img,object,hr' +
+		',input,button,label,select,iframe').split(',');
 
 	$.each(typeNames, function(i) {
 		var typeName = typeNames[i];
 		el = $(document.createElement(typeName)).appendTo('body');
-		(typeName == 'table' && el.append("<tr><td>content</td></tr>"));
+		(typeName === 'table' && el.append("<tr><td>content</td></tr>"));
 		el.draggable({ cancel: '' });
 		drag(el, 50, 50);
 		moved(50, 50, "&lt;" + typeName + "&gt;");
diff --git a/tests/unit/draggable/draggable_defaults.js b/tests/unit/draggable/draggable_defaults.js
index 4b0aaca19..b47b139cd 100644
--- a/tests/unit/draggable/draggable_defaults.js
+++ b/tests/unit/draggable/draggable_defaults.js
@@ -1,36 +1,32 @@
-/*
- * draggable_defaults.js
- */
-
-var draggable_defaults = {
-	addClasses: true,
-	appendTo: "parent",
-	axis: false,
-	cancel: ":input,option",
-	connectToSortable: false,
-	containment: false,
-	cursor: "auto",
-	cursorAt: false,
-	delay: 0,
-	disabled: false,
-	distance: 1,
-	grid: false,
-	handle: false,
-	helper: "original",
-	iframeFix: false,
-	opacity: false,
-	refreshPositions: false,
-	revert: false,
-	revertDuration: 500,
-	scroll: true,
-	scrollSensitivity: 20,
-	scrollSpeed: 20,
-	scope: "default",
-	snap: false,
-	snapMode: "both",
-	snapTolerance: 20,
-	stack: false,
-	zIndex: false
-};
-
-commonWidgetTests('draggable', { defaults: draggable_defaults });
+TestHelpers.commonWidgetTests( "draggable", {
+	defaults: {
+		addClasses: true,
+		appendTo: "parent",
+		axis: false,
+		cancel: ":input,option",
+		connectToSortable: false,
+		containment: false,
+		cursor: "auto",
+		cursorAt: false,
+		delay: 0,
+		disabled: false,
+		distance: 1,
+		grid: false,
+		handle: false,
+		helper: "original",
+		iframeFix: false,
+		opacity: false,
+		refreshPositions: false,
+		revert: false,
+		revertDuration: 500,
+		scroll: true,
+		scrollSensitivity: 20,
+		scrollSpeed: 20,
+		scope: "default",
+		snap: false,
+		snapMode: "both",
+		snapTolerance: 20,
+		stack: false,
+		zIndex: false
+	}
+});
diff --git a/tests/unit/draggable/draggable_options.js b/tests/unit/draggable/draggable_options.js
index d5f85feab..464e025dd 100644
--- a/tests/unit/draggable/draggable_options.js
+++ b/tests/unit/draggable/draggable_options.js
@@ -17,15 +17,16 @@ function setScroll(what) {
 	}
 }
 
-var border = function(el, side) { return parseInt(el.css('border-' + side + '-width')); }
-
-var margin = function(el, side) { return parseInt(el.css('margin-' + side)); }
+function border(el, side) {
+	return parseInt(el.css('border-' + side + '-width'), 10);
+}
+function margin(el, side) {
+	return parseInt(el.css('margin-' + side), 10);
+}
 
 module("draggable: options");
 
 test("{ addClasses: true }, default", function() {
-	equal(draggable_defaults.addClasses, true);
-
 	el = $("<div></div>").draggable({ addClasses: true });
 	ok(el.is(".ui-draggable"), "'ui-draggable' class added");
 
@@ -40,8 +41,6 @@ test("{ addClasses: false }", function() {
 });
 
 test("{ appendTo: 'parent' }, default", function() {
-	equal(draggable_defaults.appendTo, "parent");
-
 	el = $("#draggable2").draggable({ appendTo: 'parent' });
 	drag(el, 50, 50);
 	moved(50, 50);
@@ -73,8 +72,6 @@ test("{ appendTo: Selector }", function() {
 });
 
 test("{ axis: false }, default", function() {
-	equal(draggable_defaults.axis, false);
-
 	el = $("#draggable2").draggable({ axis: false });
 	drag(el, 50, 50);
 	moved(50, 50);
@@ -106,12 +103,10 @@ test("{ axis: ? }, unexpected", function() {
 		drag(el, 50, 50);
 		moved(50, 50, "axis: " + key);
 		el.draggable("destroy");
-	})
+	});
 });
 
 test("{ cancel: ':input,option' }, default", function() {
-	equal(draggable_defaults.cancel, ":input,option");
-
 	$('<div id="draggable-option-cancel-default"><input type="text"></div>').appendTo('#main');
 
 	el = $("#draggable-option-cancel-default").draggable({ cancel: ":input,option" });
@@ -155,12 +150,10 @@ test("{ cancel: ? }, unexpected", function() {
 		var expected = [50, 50];
 		moved(expected[0], expected[1], "cancel: " + key);
 		el.draggable("destroy");
-	})
+	});
 });
 
 test("{ containment: false }, default", function() {
-	equal(draggable_defaults.containment, false);
-
 	ok(false, 'missing test - untested code is broken code');
 });
 
@@ -170,23 +163,25 @@ test("{ containment: Element }", function() {
 
 test("{ containment: 'parent' }, relative", function() {
 	el = $("#draggable1").draggable({ containment: 'parent' });
-	var p = el.parent(), po = p.offset();
+	var p = el.parent(),
+		po = p.offset(),
+		expected = {
+			left: po.left + border(p, 'left') + margin(el, 'left'),
+			top: po.top + border(p, 'top') + margin(el, 'top')
+		};
 	drag(el, -100, -100);
-	var expected = {
-		left: po.left + border(p, 'left') + margin(el, 'left'),
-		top: po.top + border(p, 'top') + margin(el, 'top')
-	}
 	deepEqual(offsetAfter, expected, 'compare offset to parent');
 });
 
 test("{ containment: 'parent' }, absolute", function() {
 	el = $("#draggable2").draggable({ containment: 'parent' });
-	var p = el.parent(), po = p.offset();
+	var p = el.parent(),
+		po = p.offset(),
+		expected = {
+			left: po.left + border(p, 'left') + margin(el, 'left'),
+			top: po.top + border(p, 'top') + margin(el, 'top')
+		};
 	drag(el, -100, -100);
-	var expected = {
-		left: po.left + border(p, 'left') + margin(el, 'left'),
-		top: po.top + border(p, 'top') + margin(el, 'top')
-	}
 	deepEqual(offsetAfter, expected, 'compare offset to parent');
 });
 
@@ -207,11 +202,9 @@ test("{ containment: [x1, y1, x2, y2] }", function() {
 });
 
 test("{ cursor: 'auto' }, default", function() {
-	equal(draggable_defaults.cursor, 'auto');
-
 	function getCursor() { return $("#draggable2").css("cursor"); }
 
-	expect(3);
+	expect(2);
 
 	var expected = "auto", actual, before, after;
 
@@ -256,8 +249,6 @@ test("{ cursor: 'move' }", function() {
 });
 
 test("{ cursorAt: false}, default", function() {
-	equal(draggable_defaults.cursorAt, false);
-
 	ok(false, 'missing test - untested code is broken code');
 });
 
@@ -611,8 +602,8 @@ test("{ helper: 'original' }, fixed, with scroll offset on root and parent", fun
 
 test("{ helper: 'clone' }, absolute", function() {
 
-	var helperOffset = null;
-	var origOffset = $("#draggable1").offset();
+	var helperOffset = null,
+		origOffset = $("#draggable1").offset();
 
 	el = $("#draggable1").draggable({ helper: "clone", drag: function(event, ui) {
 		helperOffset = ui.helper.offset();
@@ -626,8 +617,8 @@ test("{ helper: 'clone' }, absolute", function() {
 test("{ helper: 'clone' }, absolute with scroll offset on parent", function() {
 
 	setScroll();
-	var helperOffset = null;
-	var origOffset = null;
+	var helperOffset = null,
+	origOffset = null;
 
 	el = $("#draggable1").draggable({ helper: "clone", drag: function(event, ui) {
 		helperOffset = ui.helper.offset();
@@ -655,8 +646,8 @@ test("{ helper: 'clone' }, absolute with scroll offset on parent", function() {
 test("{ helper: 'clone' }, absolute with scroll offset on root", function() {
 
 	setScroll('root');
-	var helperOffset = null;
-	var origOffset = null;
+	var helperOffset = null,
+		origOffset = null;
 
 	el = $("#draggable1").draggable({ helper: "clone", drag: function(event, ui) {
 		helperOffset = ui.helper.offset();
@@ -685,25 +676,25 @@ test("{ helper: 'clone' }, absolute with scroll offset on root and parent", func
 
 	setScroll('root');
 	setScroll();
-	var helperOffset = null;
-	var origOffset = null;
+	var helperOffset = null,
+		origOffset = null;
 
 	el = $("#draggable1").draggable({ helper: "clone", drag: function(event, ui) {
 		helperOffset = ui.helper.offset();
 	} });
 
 	$("#main").css('position', 'relative');
-	origOffset = $("#draggable1").offset()
+	origOffset = $("#draggable1").offset();
 	drag(el, 1, 1);
 	deepEqual({ top: helperOffset.top-1, left: helperOffset.left-1 }, origOffset, 'dragged[' + dragged.dx + ', ' + dragged.dy + '] ');
 
 	$("#main").css('position', 'static');
-	origOffset = $("#draggable1").offset()
+	origOffset = $("#draggable1").offset();
 	drag(el, 1, 1);
 	deepEqual({ top: helperOffset.top-1, left: helperOffset.left-1 }, origOffset, 'dragged[' + dragged.dx + ', ' + dragged.dy + '] ');
 
 	$("#main").css('position', 'absolute');
-	origOffset = $("#draggable1").offset()
+	origOffset = $("#draggable1").offset();
 	drag(el, 1, 1);
 	deepEqual({ top: helperOffset.top-1, left: helperOffset.left-1 }, origOffset, 'dragged[' + dragged.dx + ', ' + dragged.dy + '] ');
 
@@ -734,9 +725,9 @@ test("{ zIndex: 10 }", function() {
 
 	expect(1);
 
-	var expected = 10, actual;
-
-	var zIndex = null;
+	var actual,
+		expected = 10,
+		zIndex = null;
 	el = $("#draggable2").draggable({
 		zIndex: expected,
 		start: function(event, ui) {
diff --git a/tests/unit/droppable/droppable_core.js b/tests/unit/droppable/droppable_core.js
index 4d82017b9..3f709d25d 100644
--- a/tests/unit/droppable/droppable_core.js
+++ b/tests/unit/droppable/droppable_core.js
@@ -17,15 +17,15 @@ function shouldNotBeDroppable() {
 module("droppable: core");
 
 test("element types", function() {
-	var typeNames = ('p,h1,h2,h3,h4,h5,h6,blockquote,ol,ul,dl,div,form'
-		+ ',table,fieldset,address,ins,del,em,strong,q,cite,dfn,abbr'
-		+ ',acronym,code,samp,kbd,var,img,object,hr'
-		+ ',input,button,label,select,iframe').split(',');
+	var typeNames = ('p,h1,h2,h3,h4,h5,h6,blockquote,ol,ul,dl,div,form' +
+		',table,fieldset,address,ins,del,em,strong,q,cite,dfn,abbr' +
+		',acronym,code,samp,kbd,var,img,object,hr' +
+		',input,button,label,select,iframe').split(',');
 
 	$.each(typeNames, function(i) {
 		var typeName = typeNames[i];
 		el = $(document.createElement(typeName)).appendTo('body');
-		(typeName == 'table' && el.append("<tr><td>content</td></tr>"));
+		(typeName === 'table' && el.append("<tr><td>content</td></tr>"));
 		el.droppable();
 		shouldBeDroppable();
 		el.droppable("destroy");
diff --git a/tests/unit/droppable/droppable_defaults.js b/tests/unit/droppable/droppable_defaults.js
index 7584f5ec8..985dba06d 100644
--- a/tests/unit/droppable/droppable_defaults.js
+++ b/tests/unit/droppable/droppable_defaults.js
@@ -1,16 +1,12 @@
-/*
- * droppable_defaults.js
- */
-
-var droppable_defaults = {
-	accept: '*',
-	activeClass: false,
-	addClasses: true,
-	disabled: false,
-	greedy: false,
-	hoverClass: false,
-	scope: "default",
-	tolerance: "intersect"
-};
-
-commonWidgetTests('droppable', { defaults: droppable_defaults });
+TestHelpers.commonWidgetTests( "droppable", {
+	defaults: {
+		accept: "*",
+		activeClass: false,
+		addClasses: true,
+		disabled: false,
+		greedy: false,
+		hoverClass: false,
+		scope: "default",
+		tolerance: "intersect"
+	}
+});
diff --git a/tests/unit/droppable/droppable_options.js b/tests/unit/droppable/droppable_options.js
index 4df2d9ecb..19295778b 100644
--- a/tests/unit/droppable/droppable_options.js
+++ b/tests/unit/droppable/droppable_options.js
@@ -6,8 +6,6 @@
 module("droppable: options");
 
 test("{ accept '*' }, default ", function() {
-	equal(droppable_defaults.accept, '*');
-
 	ok(false, 'missing test - untested code is broken code');
 });
 
@@ -24,8 +22,6 @@ test("activeClass", function() {
 });
 
 test("{ addClasses: true }, default", function() {
-	equal(droppable_defaults.addClasses, true);
-
 	el = $("<div></div>").droppable({ addClasses: true });
 	ok(el.is(".ui-droppable"), "'ui-droppable' class added");
 	el.droppable("destroy");
diff --git a/tests/unit/effects/effects_core.js b/tests/unit/effects/effects_core.js
index aca4c4694..93c7da114 100644
--- a/tests/unit/effects/effects_core.js
+++ b/tests/unit/effects/effects_core.js
@@ -99,7 +99,7 @@ asyncTest( "animateClass clears style properties when stopped", function() {
 	var test = $("div.animateClass"),
 		style = test[0].style,
 		orig = style.cssText;
-	
+
 	expect( 2 );
 
 	test.addClass( "testChangeBackground", duration );
@@ -113,17 +113,17 @@ asyncTest( "animateClass clears style properties when stopped", function() {
 asyncTest( "animateClass: css and class changes during animation are not lost (#7106)", function() {
 	var test = $( "div.ticket7106" );
 
-	// add a class and change a style property after starting an animated class
-	test.addClass( "animate", minDuration, animationComplete )
-		.addClass( "testClass" )
-		.height( 100 );
-
 	// ensure the class stays and that the css property stays
 	function animationComplete() {
 		ok( test.hasClass( "testClass" ), "class change during animateClass was not lost" );
 		equal( test.height(), 100, "css change during animateClass was not lost" );
 		start();
 	}
+
+	// add a class and change a style property after starting an animated class
+	test.addClass( "animate", minDuration, animationComplete )
+		.addClass( "testClass" )
+		.height( 100 );
 });
 
 
@@ -133,10 +133,9 @@ $.each( $.effects.effect, function( effect ) {
 	}
 	module( "effect."+effect );
 	asyncTest( "show/hide", function() {
-		var hidden = $( "div.hidden" );
 		expect( 8 );
-
-		var count = 0,
+		var hidden = $( "div.hidden" ),
+			count = 0,
 			test = 0;
 
 		function queueTest( fn ) {
diff --git a/tests/unit/effects/effects_scale.js b/tests/unit/effects/effects_scale.js
index b9bb91c2e..df61d9e91 100644
--- a/tests/unit/effects/effects_scale.js
+++ b/tests/unit/effects/effects_scale.js
@@ -4,6 +4,11 @@ module( "effect.scale: Scale" );
 function run( position, v, h, vo, ho ) {
 	var desc = "End Position Correct: " + position + " (" + v + "," + h + ") - origin: (" + vo + "," + ho + ")";
 	asyncTest( desc, function() {
+		function complete() {
+			equal( parseInt( test.css( h ), 10 ), target[ h ], "Horizontal Position Correct " + desc );
+			equal( parseInt( test.css( v ), 10 ), target[ v ], "Vertical Position Correct " + desc );
+			start();
+		}
 		var test = $( ".testScale" ),
 			css = {
 				position: position
@@ -21,22 +26,16 @@ function run( position, v, h, vo, ho ) {
 
 		css[ h ] = 33;
 		css[ v ] = 33;
-		target[ h ] = h === ho ? css[ h ] : ho == "center" ? css[ h ] - 35 : css[ h ] - 70;
-		target[ v ] = v === vo ? css[ v ] : vo == "middle" ? css[ v ] - 35 : css[ v ] - 70;
-		if ( relative && h == "right" ) {
+		target[ h ] = h === ho ? css[ h ] : ho === "center" ? css[ h ] - 35 : css[ h ] - 70;
+		target[ v ] = v === vo ? css[ v ] : vo === "middle" ? css[ v ] - 35 : css[ v ] - 70;
+		if ( relative && h === "right" ) {
 			target[ h ] += 70;
 		}
-		if ( relative && v == "bottom" ) {
+		if ( relative && v === "bottom" ) {
 			target[ v ] += 70;
 		}
 		test.css( css );
 		test.effect( effect );
-
-		function complete() {
-			equal( parseInt( test.css( h ), 10 ), target[ h ], "Horizontal Position Correct " + desc );
-			equal( parseInt( test.css( v ), 10 ), target[ v ], "Vertical Position Correct " + desc );
-			start();
-		}
 	});
 }
 
diff --git a/tests/unit/menu/menu.html b/tests/unit/menu/menu.html
index 76f4a7a31..9a598ec8d 100644
--- a/tests/unit/menu/menu.html
+++ b/tests/unit/menu/menu.html
@@ -251,6 +251,22 @@
 	</blockquote>
 </div>
 
+<ul id="menu6">
+	<li class="foo"><a class="foo" href="#">Aberdeen</a></li>
+	<li class="foo ui-state-disabled"><a class="foo" href="#">Ada</a></li>
+	<li class="foo"><a class="foo" href="#">Adamsville</a></li>
+	<li class="foo"><a class="foo" href="#">Addyston</a></li>
+	<li class="ui-state-disabled">
+		<a href="#">Delphi</a>
+		<ul>
+			<li class="foo"><a class="foo" href="#">Ada</a></li>
+			<li class="foo"><a class="foo" href="#">Saarland</a></li>
+			<li class="foo"><a class="foo" href="#">Salzburg</a></li>
+		</ul>
+	</li>
+	<li class="foo"><a class="foo" href="#">Saarland</a></li>
+</ul>
+
 <div id="log"></div>
 
 </div>
diff --git a/tests/unit/menu/menu_core.js b/tests/unit/menu/menu_core.js
index 02e3be3be..f2de7ef1a 100644
--- a/tests/unit/menu/menu_core.js
+++ b/tests/unit/menu/menu_core.js
@@ -9,18 +9,19 @@ module("menu: core");
 
 test("accessibility", function () {
 	expect(5);
-	var menu = $('#menu1').menu();
-	var item0 = $("li:eq(0) a");
+	var item,
+		menu = $('#menu1').menu(),
+		item0 = $("li:eq(0) a");
 
 	ok( menu.hasClass("ui-menu ui-widget ui-widget-content ui-corner-all"), "menu class");
 	equal( menu.attr("role"), "menu", "main role");
 	ok( !menu.attr("aria-activedescendant"), "aria attribute not yet active");
 
-	var item = menu.find( "li:first" ).find( "a" ).attr( "id", "xid" ).end();
+	item = menu.find( "li:first" ).find( "a" ).attr( "id", "xid" ).end();
 	menu.menu( "focus", $.Event(), item );
 	equal( menu.attr("aria-activedescendant"), "xid", "aria attribute, id from dom");
 
-	var item = menu.find( "li:last" );
+	item = menu.find( "li:last" );
 	menu.menu( "focus", $.Event(), item );
 	equal( menu.attr("aria-activedescendant"), "menu1-4", "aria attribute, generated id");
 });
diff --git a/tests/unit/menu/menu_defaults.js b/tests/unit/menu/menu_defaults.js
index 018ac8ccf..ddcdbebf2 100644
--- a/tests/unit/menu/menu_defaults.js
+++ b/tests/unit/menu/menu_defaults.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "menu", {
+TestHelpers.commonWidgetTests( "menu", {
 	defaults: {
 		disabled: false,
 		menus: "ul",
diff --git a/tests/unit/menu/menu_events.js b/tests/unit/menu/menu_events.js
index bee6fcfa6..4cb083240 100644
--- a/tests/unit/menu/menu_events.js
+++ b/tests/unit/menu/menu_events.js
@@ -3,21 +3,24 @@
  */
 (function($) {
 
+var log = TestHelpers.menu.log,
+	click = TestHelpers.menu.click;
+
 module("menu: events");
 
 test("handle click on menu", function() {
 	expect(1);
 	var menu = $('#menu1').menu({
 		select: function(event, ui) {
-			menu_log();
+			log();
 		}
 	});
-	menu_log("click",true);
-	menu_click($('#menu1'),"1");
-	menu_log("afterclick");
-	menu_click( menu,"2");
-	menu_click($('#menu1'),"3");
-	menu_click( menu,"1");
+	log("click",true);
+	click($('#menu1'),"1");
+	log("afterclick");
+	click( menu,"2");
+	click($('#menu1'),"3");
+	click( menu,"1");
 	equal( $("#log").html(), "1,3,2,afterclick,1,click,", "Click order not valid.");
 });
 
@@ -25,16 +28,16 @@ test("handle click on custom item menu", function() {
 	expect(1);
 	var menu = $('#menu5').menu({
 		select: function(event, ui) {
-			menu_log();
+			log();
 		},
 		menus: "div"
 	});
-	menu_log("click",true);
-	menu_click($('#menu5'),"1");
-	menu_log("afterclick");
-	menu_click( menu,"2");
-	menu_click($('#menu5'),"3");
-	menu_click( menu,"1");
+	log("click",true);
+	click($('#menu5'),"1");
+	log("afterclick");
+	click( menu,"2");
+	click($('#menu5'),"3");
+	click( menu,"1");
 	equal( $("#log").html(), "1,3,2,afterclick,1,click,", "Click order not valid.");
 });
 
@@ -75,7 +78,7 @@ test( "handle blur on custom item menu: click", function() {
 		items: "div"
 	});
 
-	menu_click($('#menu5'),"1");
+	click($('#menu5'),"1");
 	$( "<a>", { id: "remove"} ).appendTo("body").trigger( "click" );
 
 	$("#remove").remove();
@@ -84,14 +87,12 @@ test( "handle blur on custom item menu: click", function() {
 
 asyncTest( "handle submenu auto collapse: mouseleave", function() {
 	expect( 4 );
-	var $menu = $( "#menu2" ).menu();
-
-	$menu.find( "li:nth-child(7)" ).trigger( "mouseover" );
-	setTimeout( menumouseleave1, 350 );
+	var $menu = $( "#menu2" ).menu(),
+		event = $.Event( "mouseenter" );
 
 	function menumouseleave1() {
 		equal( $menu.find( "ul[aria-expanded='true']" ).length, 1, "first submenu expanded" );
-		$menu.find( "li:nth-child(7) li:first" ).trigger( "mouseover" );
+		$menu.menu( "focus", event, $menu.find( "li:nth-child(7) li:first" ) );
 		setTimeout( menumouseleave2, 350 );
 	}
 	function menumouseleave2() {
@@ -108,18 +109,19 @@ asyncTest( "handle submenu auto collapse: mouseleave", function() {
 		equal( $menu.find( "ul[aria-expanded='true']" ).length, 0, "first submenu collapsed" );
 		start();
 	}
+
+	$menu.find( "li:nth-child(7)" ).trigger( "mouseenter" );
+	setTimeout( menumouseleave1, 350 );
 });
 
 asyncTest( "handle submenu auto collapse: mouseleave", function() {
 	expect( 4 );
-	var $menu = $( "#menu5" ).menu( { menus: "div" } );
-
-	$menu.find( ":nth-child(7)" ).trigger( "mouseover" );
-	setTimeout( menumouseleave1, 350 );
+	var $menu = $( "#menu5" ).menu( { menus: "div" } ),
+		event = $.Event( "mouseenter" );
 
 	function menumouseleave1() {
 		equal( $menu.find( "div[aria-expanded='true']" ).length, 1, "first submenu expanded" );
-		$menu.find( ":nth-child(7)" ).find( "div" ).eq( 0 ).children().eq( 0 ).trigger( "mouseover" );
+		$menu.menu( "focus", event, $menu.find( ":nth-child(7)" ).find( "div" ).eq( 0 ).children().eq( 0 ) );
 		setTimeout( menumouseleave2, 350 );
 	}
 	function menumouseleave2() {
@@ -136,6 +138,10 @@ asyncTest( "handle submenu auto collapse: mouseleave", function() {
 		equal( $menu.find( "div[aria-expanded='true']" ).length, 0, "first submenu collapsed" );
 		start();
 	}
+
+	$menu.find( ":nth-child(7)" ).trigger( "mouseenter" );
+	setTimeout( menumouseleave1, 350 );
+
 });
 
 
@@ -143,60 +149,60 @@ test("handle keyboard navigation on menu without scroll and without submenus", f
 	expect(12);
 	var element = $('#menu1').menu({
 		select: function(event, ui) {
-			menu_log($(ui.item[0]).text());
+			log($(ui.item[0]).text());
 		},
 		focus: function( event, ui ) {
-			menu_log($(event.target).find(".ui-state-focus").parent().index());
+			log($(event.target).find(".ui-state-focus").parent().index());
 		}
 	});
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.focus();
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
 	equal( $("#log").html(), "2,1,0,keydown,", "Keydown DOWN");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
 	equal( $("#log").html(), "1,keydown,", "Keydown UP");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
 	equal( $("#log").html(), "keydown,", "Keydown LEFT (no effect)");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
 	equal( $("#log").html(), "keydown,", "Keydown RIGHT (no effect)");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
 	equal( $("#log").html(), "4,keydown,", "Keydown PAGE_DOWN");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
 	equal( $("#log").html(), "keydown,", "Keydown PAGE_DOWN (no effect)");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
 	equal( $("#log").html(), "0,keydown,", "Keydown PAGE_UP");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
 	equal( $("#log").html(), "keydown,", "Keydown PAGE_UP (no effect)");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.END } );
 	equal( $("#log").html(), "4,keydown,", "Keydown END");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.HOME } );
 	equal( $("#log").html(), "0,keydown,", "Keydown HOME");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.ESCAPE } );
 	equal( $("#log").html(), "keydown,", "Keydown ESCAPE (no effect)");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.ENTER } );
 	equal( $("#log").html(), "Aberdeen,keydown,", "Keydown ENTER");
 });
@@ -205,14 +211,14 @@ asyncTest("handle keyboard navigation on menu without scroll and with submenus",
 	expect(14);
 	var element = $('#menu2').menu({
 		select: function(event, ui) {
-			menu_log($(ui.item[0]).text());
+			log($(ui.item[0]).text());
 		},
 		focus: function( event, ui ) {
-			menu_log($(event.target).find(".ui-state-focus").parent().index());
+			log($(event.target).find(".ui-state-focus").parent().index());
 		}
 	});
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.one( "menufocus", function( event, ui ) {
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
@@ -222,16 +228,16 @@ asyncTest("handle keyboard navigation on menu without scroll and with submenus",
 	element.focus();
 
 	function menukeyboard1() {
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
 		equal( $("#log").html(), "0,1,keydown,", "Keydown UP");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
 		equal( $("#log").html(), "keydown,", "Keydown LEFT (no effect)");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
@@ -245,7 +251,7 @@ asyncTest("handle keyboard navigation on menu without scroll and with submenus",
 	}
 
 	function menukeyboard2() {
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
 		equal( $("#log").html(), "4,keydown,", "Keydown LEFT (close submenu)");
 
@@ -255,35 +261,35 @@ asyncTest("handle keyboard navigation on menu without scroll and with submenus",
 	}
 
 	function menukeyboard3() {
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
 		equal( $("#log").html(), "2,keydown,", "Keydown PAGE_DOWN");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
 		equal( $("#log").html(), "keydown,", "Keydown PAGE_DOWN (no effect)");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
 		equal( $("#log").html(), "0,keydown,", "Keydown PAGE_UP");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
 		equal( $("#log").html(), "keydown,", "Keydown PAGE_UP (no effect)");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.END } );
 		equal( $("#log").html(), "2,keydown,", "Keydown END");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.HOME } );
 		equal( $("#log").html(), "0,keydown,", "Keydown HOME");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.ESCAPE } );
 		equal( $("#log").html(), "4,keydown,", "Keydown ESCAPE (close submenu)");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.ENTER } );
 		setTimeout( menukeyboard4, 50 );
 	}
@@ -291,7 +297,7 @@ asyncTest("handle keyboard navigation on menu without scroll and with submenus",
 	function menukeyboard4() {
 		equal( $("#log").html(), "0,keydown,", "Keydown ENTER (open submenu)");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.ENTER } );
 		equal( $("#log").html(), "Ada,keydown,", "Keydown ENTER (select item)");
 
@@ -303,69 +309,69 @@ test("handle keyboard navigation on menu with scroll and without submenus", func
 	expect(14);
 	var element = $('#menu3').menu({
 		select: function(event, ui) {
-			menu_log($(ui.item[0]).text());
+			log($(ui.item[0]).text());
 		},
 		focus: function( event, ui ) {
-			menu_log($(event.target).find(".ui-state-focus").parent().index());
+			log($(event.target).find(".ui-state-focus").parent().index());
 		}
 	});
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.focus();
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
 	equal( $("#log").html(), "2,1,0,keydown,", "Keydown DOWN");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
 	equal( $("#log").html(), "0,1,keydown,", "Keydown UP");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
 	equal( $("#log").html(), "keydown,", "Keydown LEFT (no effect)");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
 	equal( $("#log").html(), "keydown,", "Keydown RIGHT (no effect)");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
 	equal( $("#log").html(), "10,keydown,", "Keydown PAGE_DOWN");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
 	equal( $("#log").html(), "20,keydown,", "Keydown PAGE_DOWN");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
 	equal( $("#log").html(), "10,keydown,", "Keydown PAGE_UP");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
 	equal( $("#log").html(), "0,keydown,", "Keydown PAGE_UP");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
 	equal( $("#log").html(), "keydown,", "Keydown PAGE_UP (no effect)");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.END } );
 	equal( $("#log").html(), "37,keydown,", "Keydown END");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
 	equal( $("#log").html(), "keydown,", "Keydown PAGE_DOWN (no effect)");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.HOME } );
 	equal( $("#log").html(), "0,keydown,", "Keydown HOME");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.ESCAPE } );
 	equal( $("#log").html(), "keydown,", "Keydown ESCAPE (no effect)");
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.simulate( "keydown", { keyCode: $.ui.keyCode.ENTER } );
 	equal( $("#log").html(), "Aberdeen,keydown,", "Keydown ENTER");
 });
@@ -374,14 +380,14 @@ asyncTest("handle keyboard navigation on menu with scroll and with submenus", fu
 	expect(14);
 	var element = $('#menu4').menu({
 		select: function(event, ui) {
-			menu_log($(ui.item[0]).text());
+			log($(ui.item[0]).text());
 		},
 		focus: function( event, ui ) {
-			menu_log($(event.target).find(".ui-state-focus").parent().index());
+			log($(event.target).find(".ui-state-focus").parent().index());
 		}
 	});
 
-	menu_log("keydown",true);
+	log("keydown",true);
 	element.one( "menufocus", function( event, ui ) {
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
@@ -392,16 +398,16 @@ asyncTest("handle keyboard navigation on menu with scroll and with submenus", fu
 
 
 	function menukeyboard1() {
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
 		equal( $("#log").html(), "0,1,keydown,", "Keydown UP");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
 		equal( $("#log").html(), "keydown,", "Keydown LEFT (no effect)");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
 
@@ -412,7 +418,7 @@ asyncTest("handle keyboard navigation on menu with scroll and with submenus", fu
 	}
 
 	function menukeyboard2() {
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
 		equal( $("#log").html(), "1,keydown,", "Keydown LEFT (close submenu)");
 
@@ -422,35 +428,35 @@ asyncTest("handle keyboard navigation on menu with scroll and with submenus", fu
 	}
 
 	function menukeyboard3() {
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
 		equal( $("#log").html(), "10,keydown,", "Keydown PAGE_DOWN");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
 		equal( $("#log").html(), "20,keydown,", "Keydown PAGE_DOWN");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
 		equal( $("#log").html(), "10,keydown,", "Keydown PAGE_UP");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
 		equal( $("#log").html(), "0,keydown,", "Keydown PAGE_UP");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.END } );
 		equal( $("#log").html(), "27,keydown,", "Keydown END");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.HOME } );
 		equal( $("#log").html(), "0,keydown,", "Keydown HOME");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.ESCAPE } );
 		equal( $("#log").html(), "1,keydown,", "Keydown ESCAPE (close submenu)");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.ENTER } );
 		setTimeout( menukeyboard4, 50 );
 	}
@@ -458,7 +464,7 @@ asyncTest("handle keyboard navigation on menu with scroll and with submenus", fu
 	function menukeyboard4() {
 		equal( $("#log").html(), "0,keydown,", "Keydown ENTER (open submenu)");
 
-		menu_log("keydown",true);
+		log("keydown",true);
 		element.simulate( "keydown", { keyCode: $.ui.keyCode.ENTER } );
 		equal( $("#log").html(), "Aberdeen,keydown,", "Keydown ENTER (select item)");
 
@@ -466,4 +472,56 @@ asyncTest("handle keyboard navigation on menu with scroll and with submenus", fu
 	}
 });
 
+asyncTest("handle keyboard navigation and mouse click on menu with disabled items", function() {
+	expect(6);
+	var element = $('#menu6').menu({
+		select: function(event, ui) {
+			log($(ui.item[0]).text());
+		},
+		focus: function( event, ui ) {
+			log($(event.target).find(".ui-state-focus").parent().index());
+		}
+	});
+
+	log("keydown",true);
+	element.one( "menufocus", function( event, ui ) {
+		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
+		element.simulate( "keydown", { keyCode: $.ui.keyCode.ENTER } );
+		equal( $("#log").html(), "1,keydown,", "Keydown focus but not select disabled item");
+		setTimeout( menukeyboard1, 50 );
+	});
+	element.focus();
+
+
+	function menukeyboard1() {
+		log("keydown",true);
+		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
+		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
+		element.simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
+		equal( $("#log").html(), "4,3,2,keydown,", "Keydown focus disabled item with submenu");
+
+		log("keydown",true);
+		element.simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
+		equal( $("#log").html(), "keydown,", "Keydown LEFT (no effect)");
+
+		log("keydown",true);
+		element.simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
+
+		setTimeout( function() {
+			equal( $("#log").html(), "keydown,", "Keydown RIGHT (no effect on disabled sub-menu)");
+
+			log("keydown",true);
+			element.simulate( "keydown", { keyCode: $.ui.keyCode.ENTER } );
+
+			setTimeout( function() {
+				equal( $("#log").html(), "keydown,", "Keydown ENTER (no effect on disabled sub-menu)");
+				log("click",true);
+				click( element, "1" );
+				equal( $("#log").html(), "click,", "Click disabled item (no effect)");
+				start();
+			}, 50);
+		}, 50);
+	}
+});
+
 })(jQuery);
diff --git a/tests/unit/menu/menu_methods.js b/tests/unit/menu/menu_methods.js
index 200ea4427..6ad7bc134 100644
--- a/tests/unit/menu/menu_methods.js
+++ b/tests/unit/menu/menu_methods.js
@@ -3,25 +3,28 @@
  */
 (function($) {
 
+var log = TestHelpers.menu.log,
+	click = TestHelpers.menu.click;
+
 module("menu: methods");
 
 test( "enable/disable", function() {
 	expect( 3 );
 	var menu = $( "#menu1" ).menu({
 		select: function(event, ui) {
-			menu_log();
+			log();
 		}
 	});
 	menu.menu("disable");
 	ok(menu.is(".ui-state-disabled"),"Missing ui-state-disabled class");
-	menu_log("click",true);
-	menu_click(menu,"1");
-	menu_log("afterclick");
+	log("click",true);
+	click(menu,"1");
+	log("afterclick");
 	menu.menu("enable");
 	ok(menu.not(".ui-state-disabled"),"Has ui-state-disabled class");
-	menu_log("click");
-	menu_click(menu,"1");
-	menu_log("afterclick");
+	log("click");
+	click(menu,"1");
+	log("afterclick");
 	equal( $("#log").html(), "afterclick,1,click,afterclick,click,", "Click order not valid.");
 });
 
diff --git a/tests/unit/menu/menu_options.js b/tests/unit/menu/menu_options.js
index cda52d88d..e651fd2d1 100644
--- a/tests/unit/menu/menu_options.js
+++ b/tests/unit/menu/menu_options.js
@@ -3,6 +3,9 @@
  */
 (function($) {
 
+var log = TestHelpers.menu.log,
+	click = TestHelpers.menu.click;
+
 module("menu: options");
 
 test( "{ disabled: true }", function() {
@@ -10,13 +13,13 @@ test( "{ disabled: true }", function() {
 	var menu = $( "#menu1" ).menu({
 		disabled: true,
 		select: function(event, ui) {
-			menu_log();
+			log();
 		}
 	});
 	ok(menu.is(".ui-state-disabled"),"Missing ui-state-disabled class");
-	menu_log("click",true);
-	menu_click(menu,"1");
-	menu_log("afterclick");
+	log("click",true);
+	click(menu,"1");
+	log("afterclick");
 	equal( $("#log").html(), "afterclick,click,", "Click order not valid.");
 });
 
@@ -25,13 +28,13 @@ test( "{ disabled: false }", function() {
 	var menu = $( "#menu1" ).menu({
 		disabled: false,
 		select: function(event, ui) {
-			menu_log();
+			log();
 		}
 	});
 	ok(menu.not(".ui-state-disabled"),"Has ui-state-disabled class");
-	menu_log("click",true);
-	menu_click(menu,"1");
-	menu_log("afterclick");
+	log("click",true);
+	click(menu,"1");
+	log("afterclick");
 	equal( $("#log").html(), "afterclick,1,click,", "Click order not valid.");
 });
 
diff --git a/tests/unit/menu/menu_test_helpers.js b/tests/unit/menu/menu_test_helpers.js
index e83795e5a..a576af19a 100644
--- a/tests/unit/menu/menu_test_helpers.js
+++ b/tests/unit/menu/menu_test_helpers.js
@@ -1,14 +1,16 @@
-function menu_log( message, clear ) {
-	if ( clear ) {
-		$( "#log" ).empty();
-	}
-	if ( message === undefined ) {
-		message = $( "#log" ).data( "lastItem" );
-	}
-	$( "#log" ).prepend( $.trim( message ) + "," );
-}
+TestHelpers.menu = {
+	log: function( message, clear ) {
+		if ( clear ) {
+			$( "#log" ).empty();
+		}
+		if ( message === undefined ) {
+			message = $( "#log" ).data( "lastItem" );
+		}
+		$( "#log" ).prepend( $.trim( message ) + "," );
+	},
 
-function menu_click( menu, item ) {
-	$( "#log" ).data( "lastItem", item );
-	menu.children( ":eq(" + item + ")" ).find( "a:first" ).trigger( "click" );
-}
\ No newline at end of file
+	click: function( menu, item ) {
+		$( "#log" ).data( "lastItem", item );
+		menu.children( ":eq(" + item + ")" ).find( "a:first" ).trigger( "click" );
+	}
+};
\ No newline at end of file
diff --git a/tests/unit/position/position_core.js b/tests/unit/position/position_core.js
index fbcac4b7f..5c86e7887 100644
--- a/tests/unit/position/position_core.js
+++ b/tests/unit/position/position_core.js
@@ -42,31 +42,32 @@ test( "my, at, of", function() {
 });
 
 test( "multiple elements", function() {
-	var elements = $( "#el1, #el2" );
-	var result = elements.position({
-		my: "left top",
-		at: "left bottom",
-		of: "#parent",
-		collision: "none"
-	});
+	var elements = $( "#el1, #el2" ),
+		result = elements.position({
+			my: "left top",
+			at: "left bottom",
+			of: "#parent",
+			collision: "none"
+		}),
+		expected = { top: 10, left: 4 };
 
 	deepEqual( result, elements );
-	var expected = { top: 10, left: 4 };
 	elements.each(function() {
 		deepEqual( $( this ).offset(), expected );
 	});
 });
 
 test( "positions", function() {
-	var definitions = [];
-	var offsets = {
-		left: 0,
-		center: 3,
-		right: 6,
-		top: 0,
-		bottom: 6
-	};
-	var start = { left: 4, top: 4 };
+	var definitions = [],
+		offsets = {
+			left: 0,
+			center: 3,
+			right: 6,
+			top: 0,
+			bottom: 6
+		},
+		start = { left: 4, top: 4 },
+		el = $( "#el1" );
 	$.each( [ 0, 1 ], function( my ) {
 		$.each( [ "top", "center", "bottom" ], function( vindex, vertical ) {
 			$.each( [ "left", "center", "right" ], function( hindex, horizontal ) {
@@ -81,7 +82,6 @@ test( "positions", function() {
 			});
 		});
 	});
-	var el = $( "#el1" );
 	$.each( definitions, function( index, definition ) {
 		el.position({
 			my: definition.my,
@@ -445,12 +445,12 @@ test( "addClass: flipped left", function() {
 
 	deepEqual( elem.hasClass( 'ui-flipped-left' ), false, 'Has ui-flipped-left class' );
 
-	elem.position( {
+	elem.position({
 		my: "right center",
 		of: window,
 		collision: "flip",
 		at: "left center"
-	})
+	});
 
 	deepEqual( elem.hasClass( 'ui-flipped-left' ), false, 'Removed ui-flipped-left class' );
 });
diff --git a/tests/unit/position/position_core_within.js b/tests/unit/position/position_core_within.js
index c9670f8ff..042e881eb 100644
--- a/tests/unit/position/position_core_within.js
+++ b/tests/unit/position/position_core_within.js
@@ -65,32 +65,33 @@ test( "my, at, of", function() {
 });
 
 test( "multiple elements", function() {
-	var elements = $( "#el1, #el2" );
-	var result = elements.position({
-		my: "left top",
-		at: "left bottom",
-		of: "#parent",
-		collision: "none",
-		within: $("#within-container")
-	});
+	var elements = $( "#el1, #el2" ),
+		result = elements.position({
+			my: "left top",
+			at: "left bottom",
+			of: "#parent",
+			collision: "none",
+			within: $("#within-container")
+		}),
+		expected = { top: addTop + 10, left: addLeft + 4 };
 
 	deepEqual( result, elements );
-	var expected = { top: addTop + 10, left: addLeft + 4 };
 	elements.each(function() {
 		deepEqual( $( this ).addOffsets(), expected );
 	});
 });
 
 test( "positions", function() {
-	var definitions = [];
-	var offsets = {
-		left: 0,
-		center: 3,
-		right: 6,
-		top: 0,
-		bottom: 6
-	};
-	var start = { left: 4, top: 4 };
+	var definitions = [],
+		offsets = {
+			left: 0,
+			center: 3,
+			right: 6,
+			top: 0,
+			bottom: 6
+		},
+		start = { left: 4, top: 4 },
+		el = $( "#el1" );
 	$.each( [ 0, 1 ], function( my ) {
 		$.each( [ "top", "center", "bottom" ], function( vindex, vertical ) {
 			$.each( [ "left", "center", "right" ], function( hindex, horizontal ) {
@@ -105,7 +106,6 @@ test( "positions", function() {
 			});
 		});
 	});
-	var el = $( "#el1" );
 	$.each( definitions, function( index, definition ) {
 		el.position({
 			my: definition.my,
@@ -120,7 +120,8 @@ test( "positions", function() {
 });
 
 test( "of", function() {
-	var within = $("#within-container");
+	var event,
+		within = $( "#within-container" );
 
 	$( "#elx" ).position({
 		my: "left top",
@@ -149,7 +150,7 @@ test( "of", function() {
 	});
 	deepEqual( $( "#elx" ).addOffsets(), { top: addTop + 40, left: addLeft + 40 }, "DOM element" );
 
-	var event = $.extend( $.Event( "someEvent" ), { pageX: 200, pageY: 300 } );
+	event = $.extend( $.Event( "someEvent" ), { pageX: 200, pageY: 300 } );
 	$( "#elx" ).position({
 		my: "left top",
 		at: "left top",
@@ -219,9 +220,8 @@ test( "within:offsets", function() {
 test( "using", function() {
 	expect( 6 );
 
-	var within = $("#within-container");
-
-	var count = 0,
+	var within = $( "#within-container" ),
+		count = 0,
 		elems = $( "#el1, #el2" ),
 		expectedPosition = { top: addTop + 40, left: addLeft + 40 },
 		originalPosition = elems.position({
@@ -252,14 +252,13 @@ test( "using", function() {
 });
 
 function collisionTest( config, result, msg ) {
-	var within = $("#within-container");
-
-	var elem = $( "#elx" ).position( $.extend({
-		my: "left top",
-		at: "right bottom",
-		of: "#parentx",
-		within: within
-	}, config ) );
+	var within = $( "#within-container" ),
+		elem = $( "#elx" ).position( $.extend({
+			my: "left top",
+			at: "right bottom",
+			of: "#parentx",
+			within: within
+		}, config ) );
 
 	deepEqual( elem.addOffsets(), result, msg );
 }
@@ -448,39 +447,37 @@ test( "collision: flip, with margin", function() {
 });
 
 test( "addClass: flipped left", function() {
-	var within = $("#within-container");
-
-	var elem = $( "#elx" ).position( {
-		my: "left center",
-		of: within[0],
-		within: within,
-		collision: "flip",
-		at: "right center"
-	});
+	var within = $("#within-container"),
+		elem = $( "#elx" ).position( {
+			my: "left center",
+			of: within[0],
+			within: within,
+			collision: "flip",
+			at: "right center"
+		});
 
 	deepEqual( elem.hasClass( 'ui-flipped-left' ), false, 'Has ui-flipped-left class' );
 
-	elem.position( {
+	elem.position({
 		my: "right center",
 		of: within[0],
 		within: within,
 		collision: "flip",
 		at: "left center"
-	})
+	});
 
 	deepEqual( elem.hasClass( 'ui-flipped-left' ), false, 'Removed ui-flipped-left class' );
 });
 
 test( "addClass: flipped top", function() {
-	var within = $("#within-container");
-
-	var elem = $( "#elx" ).position( {
-		my: "left top",
-		of: within[0],
-		within: within,
-		collision: "flip",
-		at: "right bottom"
-	});
+	var within = $("#within-container"),
+		elem = $( "#elx" ).position( {
+			my: "left top",
+			of: within[0],
+			within: within,
+			collision: "flip",
+			at: "right bottom"
+		});
 
 	deepEqual( elem.hasClass( 'ui-flipped-top' ), false, 'Has ui-flipped-top class' );
 
@@ -496,15 +493,14 @@ test( "addClass: flipped top", function() {
 });
 
 test( "addClass: flipped right", function() {
-	var within = $("#within-container");
-
-	var elem = $( "#elx" ).position( {
-		my: "right center",
-		of: within[0],
-		within: within,
-		collision: "flip",
-		at: "left center"
-	});
+	var within = $("#within-container"),
+		elem = $( "#elx" ).position( {
+			my: "right center",
+			of: within[0],
+			within: within,
+			collision: "flip",
+			at: "left center"
+		});
 
 	deepEqual( elem.hasClass( 'ui-flipped-right' ), false, 'Has ui-flipped-right class' );
 
@@ -521,14 +517,13 @@ test( "addClass: flipped right", function() {
 });
 
 test( "addClass: flipped bottom", function() {
-	var within = $("#within-container");
-
-	var elem = $( "#elx" ).position( {
-		my: "left bottom",
-		of: window,
-		collision: "flip",
-		at: "right top"
-	});
+	var within = $("#within-container"),
+		elem = $( "#elx" ).position( {
+			my: "left bottom",
+			of: window,
+			collision: "flip",
+			at: "right top"
+		});
 
 	deepEqual( elem.hasClass( 'ui-flipped-bottom' ), false, 'Has ui-flipped-bottom class' );
 
diff --git a/tests/unit/progressbar/progressbar_defaults.js b/tests/unit/progressbar/progressbar_defaults.js
index 3856e31a0..2f97a78bb 100644
--- a/tests/unit/progressbar/progressbar_defaults.js
+++ b/tests/unit/progressbar/progressbar_defaults.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "progressbar", {
+TestHelpers.commonWidgetTests( "progressbar", {
 	defaults: {
 		disabled: false,
 		value: 0,
diff --git a/tests/unit/progressbar/progressbar_events.js b/tests/unit/progressbar/progressbar_events.js
index 8d7b8868d..f3713171b 100644
--- a/tests/unit/progressbar/progressbar_events.js
+++ b/tests/unit/progressbar/progressbar_events.js
@@ -15,7 +15,7 @@ test("create", function() {
 		change: function() {
 			ok(false, 'create() has triggered change()');
 		}
-	})
+	});
 });
 
 test("change", function() {
diff --git a/tests/unit/resizable/resizable_defaults.js b/tests/unit/resizable/resizable_defaults.js
index f69e5217c..c46e10781 100644
--- a/tests/unit/resizable/resizable_defaults.js
+++ b/tests/unit/resizable/resizable_defaults.js
@@ -1,28 +1,24 @@
-/*
- * resizable_defaults.js
- */
-
-var resizable_defaults = {
-	alsoResize: false,
-	animate: false,
-	animateDuration: 'slow',
-	animateEasing: 'swing',
-	aspectRatio: false,
-	autoHide: false,
-	cancel: ':input,option',
-	containment: false,
-	delay: 0,
-	disabled: false,
-	distance: 1,
-	ghost: false,
-	grid: false,
-	handles: 'e,s,se',
-	helper: false,
-	maxHeight: null,
-	maxWidth: null,
-	minHeight: 10,
-	minWidth: 10,
-	zIndex: 1000
-};
-
-commonWidgetTests('resizable', { defaults: resizable_defaults });
+TestHelpers.commonWidgetTests('resizable', {
+	defaults: {
+		alsoResize: false,
+		animate: false,
+		animateDuration: 'slow',
+		animateEasing: 'swing',
+		aspectRatio: false,
+		autoHide: false,
+		cancel: ':input,option',
+		containment: false,
+		delay: 0,
+		disabled: false,
+		distance: 1,
+		ghost: false,
+		grid: false,
+		handles: 'e,s,se',
+		helper: false,
+		maxHeight: null,
+		maxWidth: null,
+		minHeight: 10,
+		minWidth: 10,
+		zIndex: 1000
+	}
+});
diff --git a/tests/unit/resizable/resizable_methods.js b/tests/unit/resizable/resizable_methods.js
index 03e91d440..2b4c4256c 100644
--- a/tests/unit/resizable/resizable_methods.js
+++ b/tests/unit/resizable/resizable_methods.js
@@ -20,7 +20,7 @@ test("init", function() {
 	$('<div></div>').resizable().resizable("foo").remove();
 	ok(true, 'arbitrary method called after init');
 
-	el = $('<div></div>').resizable()
+	el = $('<div></div>').resizable();
 	var foo = el.resizable("option", "foo");
 	el.remove();
 	ok(true, 'arbitrary option getter after init');
diff --git a/tests/unit/resizable/resizable_options.js b/tests/unit/resizable/resizable_options.js
index 76cca560a..275639ca1 100644
--- a/tests/unit/resizable/resizable_options.js
+++ b/tests/unit/resizable/resizable_options.js
@@ -187,4 +187,13 @@ test("ui-resizable-nw { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 1
 	equal( target.height(), 100, "compare maxHeight" );
 });
 
+test("zIndex, applied to all handles", function() {
+	expect(8);
+	
+	var target = $('<div></div>').resizable({ handles: 'all', zIndex: 100 });
+	target.children( '.ui-resizable-handle' ).each( function( index, handle ) {
+		equals( $( handle ).css( 'zIndex' ), 100, 'compare zIndex' );
+	});
+});
+
 })(jQuery);
diff --git a/tests/unit/selectable/selectable_defaults.js b/tests/unit/selectable/selectable_defaults.js
index dbf799a43..27714d0ae 100644
--- a/tests/unit/selectable/selectable_defaults.js
+++ b/tests/unit/selectable/selectable_defaults.js
@@ -1,16 +1,12 @@
-/*
- * selectable_defaults.js
- */
-
-var selectable_defaults = {
-	appendTo: 'body',
-	autoRefresh: true,
-	cancel: ':input,option',
-	delay: 0,
-	disabled: false,
-	distance: 0,
-	filter: '*',
-	tolerance: 'touch'
-};
-
-commonWidgetTests('selectable', { defaults: selectable_defaults });
+TestHelpers.commonWidgetTests('selectable', {
+	defaults: {
+		appendTo: 'body',
+		autoRefresh: true,
+		cancel: ':input,option',
+		delay: 0,
+		disabled: false,
+		distance: 0,
+		filter: '*',
+		tolerance: 'touch'
+	}
+});
diff --git a/tests/unit/selectable/selectable_methods.js b/tests/unit/selectable/selectable_methods.js
index 32dfe00ed..dbc88f269 100644
--- a/tests/unit/selectable/selectable_methods.js
+++ b/tests/unit/selectable/selectable_methods.js
@@ -20,7 +20,7 @@ test("init", function() {
 	$("<div></div>").selectable().selectable("foo").remove();
 	ok(true, 'arbitrary method called after init');
 
-	el = $("<div></div>").selectable()
+	el = $("<div></div>").selectable();
 	var foo = el.selectable("option", "foo");
 	el.remove();
 	ok(true, 'arbitrary option getter after init');
@@ -49,7 +49,8 @@ test("destroy", function() {
 
 test("enable", function() {
 	expect(3);
-	var fired = false;
+	var expected, actual,
+		fired = false;
 
 	el = $("#selectable1");
 	el.selectable({
@@ -63,14 +64,15 @@ test("enable", function() {
 	equal(fired, true, "start fired");
 	el.selectable("destroy");
 
-	var expected = $('<div></div>').selectable(),
-		actual = expected.selectable('enable');
+	expected = $('<div></div>').selectable();
+	actual = expected.selectable('enable');
 	equal(actual, expected, 'enable is chainable');
 });
 
 test("disable", function() {
 	expect(3);
-	var fired = false;
+	var expected, actual,
+		fired = false;
 
 	el = $("#selectable1");
 	el.selectable({
@@ -85,8 +87,8 @@ test("disable", function() {
 	equal(fired, false, "start fired");
 	el.selectable("destroy");
 
-	var expected = $('<div></div>').selectable(),
-		actual = expected.selectable('disable');
+	expected = $('<div></div>').selectable();
+	actual = expected.selectable('disable');
 	equal(actual, expected, 'disable is chainable');
 });
 
diff --git a/tests/unit/selectable/selectable_options.js b/tests/unit/selectable/selectable_options.js
index 2bc44e6e0..be9fdf5fe 100644
--- a/tests/unit/selectable/selectable_options.js
+++ b/tests/unit/selectable/selectable_options.js
@@ -8,7 +8,7 @@ module("selectable: options");
 test("autoRefresh", function() {
 	expect(3);
 	el = $("#selectable1");
-	var actual, sel = $("*", el), selected = function() { actual += 1 };
+	var actual, sel = $("*", el), selected = function() { actual += 1; };
 
 	actual = 0;
 	el = $("#selectable1").selectable({ autoRefresh: false,	selected: selected });
@@ -33,12 +33,12 @@ test("autoRefresh", function() {
 test("filter", function() {
 	expect(2);
 	el = $("#selectable1");
-	var actual, sel = $("*", el), selected = function() { actual += 1 };
+	var actual, sel = $("*", el), selected = function() { actual += 1; };
 
 	actual = 0;
 	el = $("#selectable1").selectable({ filter: '.special', selected: selected });
 	drag(1000, 1000);
-	ok(sel.length != 1, "this test assumes more than 1 selectee");
+	ok(sel.length !== 1, "this test assumes more than 1 selectee");
 	equal(actual, 1);
 	el.selectable("destroy");
 });
diff --git a/tests/unit/slider/slider_defaults.js b/tests/unit/slider/slider_defaults.js
index 8049fe969..8a0b347f3 100644
--- a/tests/unit/slider/slider_defaults.js
+++ b/tests/unit/slider/slider_defaults.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "slider", {
+TestHelpers.commonWidgetTests( "slider", {
 	defaults: {
 		animate: false,
 		cancel: ':input,option',
diff --git a/tests/unit/slider/slider_methods.js b/tests/unit/slider/slider_methods.js
index b46222002..79f80e868 100644
--- a/tests/unit/slider/slider_methods.js
+++ b/tests/unit/slider/slider_methods.js
@@ -17,8 +17,8 @@ test("init", function() {
 	$('<div></div>').slider().remove();
 	ok(true, '.slider() called on disconnected DOMElement');
 
-	var el = $('<div></div>').slider();
-	var foo = el.slider("option", "foo");
+	var el = $('<div></div>').slider(),
+		foo = el.slider("option", "foo");
 	el.remove();
 	ok(true, 'arbitrary option getter after init');
 
@@ -42,11 +42,12 @@ test("destroy", function() {
 });
 
 test("enable", function() {
-	var expected = $('<div></div>').slider(),
+	var el,
+		expected = $('<div></div>').slider(),
 		actual = expected.slider('enable');
 	equal(actual, expected, 'enable is chainable');
 
-	var el = $('<div></div>').slider({ disabled: true });
+	el = $('<div></div>').slider({ disabled: true });
 	ok(el.hasClass('ui-disabled'), 'slider has ui-disabled class before enable method call');
 	ok(el.hasClass('ui-slider-disabled'), 'slider has ui-slider-disabled class before enable method call');
 	el.slider('enable');
@@ -55,11 +56,12 @@ test("enable", function() {
 });
 
 test("disable", function() {
-	var expected = $('<div></div>').slider(),
+	var el,
+		expected = $('<div></div>').slider(),
 		actual = expected.slider('disable');
 	equal(actual, expected, 'disable is chainable');
 
-	var el = $('<div></div>').slider({ disabled: false });
+	el = $('<div></div>').slider({ disabled: false });
 	ok(!el.hasClass('ui-disabled'), 'slider does not have ui-disabled class before disabled method call');
 	ok(!el.hasClass('ui-slider-disabled'), 'slider does not have ui-slider-disabled class before disable method call');
 	el.slider('disable');
diff --git a/tests/unit/slider/slider_options.js b/tests/unit/slider/slider_options.js
index 7d9899284..09067a3e9 100644
--- a/tests/unit/slider/slider_options.js
+++ b/tests/unit/slider/slider_options.js
@@ -23,8 +23,8 @@ test("max", function() {
 	};
 
 	el.slider(options);
-	ok(el.slider("option", "value") == options.value, "value option is not contained by max");
-	ok(el.slider("value") == options.max, "value method is contained by max");
+	ok(el.slider("option", "value") === options.value, "value option is not contained by max");
+	ok(el.slider("value") === options.max, "value method is contained by max");
 	el.slider('destroy');
 
 });
@@ -41,8 +41,8 @@ test("min", function() {
 	};
 
 	el.slider(options);
-	ok(el.slider("option", "value") == options.value, "value option is not contained by min");
-	ok(el.slider("value") == options.min, "value method is contained by min");
+	ok(el.slider("option", "value") === options.value, "value option is not contained by min");
+	ok(el.slider("value") === options.min, "value method is contained by min");
 	el.slider('destroy');
 
 });
@@ -73,7 +73,7 @@ test("orientation", function() {
 		value: -1
 	};
 
-	var percentVal = (options.value - options.min) / (options.max - options.min) * 100;
+	percentVal = (options.value - options.min) / (options.max - options.min) * 100;
 
 	el.slider(options).slider("option", "orientation", "vertical");
 	ok(el.is('.ui-slider-vertical'), "vertical slider has class .ui-slider-vertical");
diff --git a/tests/unit/sortable/sortable_defaults.js b/tests/unit/sortable/sortable_defaults.js
index 7681addad..b5fc05a5d 100644
--- a/tests/unit/sortable/sortable_defaults.js
+++ b/tests/unit/sortable/sortable_defaults.js
@@ -1,34 +1,30 @@
-/*
- * sortable_defaults.js
- */
-
-var sortable_defaults = {
-	appendTo: "parent",
-	axis: false,
-	cancel: ":input,option",
-	connectWith: false,
-	containment: false,
-	cursor: 'auto',
-	cursorAt: false,
-	delay: 0,
-	disabled: false,
-	distance: 1,
-	dropOnEmpty: true,
-	forcePlaceholderSize: false,
-	forceHelperSize: false,
-	grid: false,
-	handle: false,
-	helper: "original",
-	items: "> *",
-	opacity: false,
-	placeholder: false,
-	revert: false,
-	scroll: true,
-	scrollSensitivity: 20,
-	scrollSpeed: 20,
-	scope: "default",
-	tolerance: "intersect",
-	zIndex: 1000
-};
-
-commonWidgetTests('sortable', { defaults: sortable_defaults });
+TestHelpers.commonWidgetTests( "sortable", {
+	defaults: {
+		appendTo: "parent",
+		axis: false,
+		cancel: ":input,option",
+		connectWith: false,
+		containment: false,
+		cursor: "auto",
+		cursorAt: false,
+		delay: 0,
+		disabled: false,
+		distance: 1,
+		dropOnEmpty: true,
+		forcePlaceholderSize: false,
+		forceHelperSize: false,
+		grid: false,
+		handle: false,
+		helper: "original",
+		items: "> *",
+		opacity: false,
+		placeholder: false,
+		revert: false,
+		scroll: true,
+		scrollSensitivity: 20,
+		scrollSpeed: 20,
+		scope: "default",
+		tolerance: "intersect",
+		zIndex: 1000
+	}
+});
diff --git a/tests/unit/sortable/sortable_events.js b/tests/unit/sortable/sortable_events.js
index cb4ff4ff3..6ed54e1b6 100644
--- a/tests/unit/sortable/sortable_events.js
+++ b/tests/unit/sortable/sortable_events.js
@@ -6,13 +6,13 @@
 module("sortable: events");
 
 test("start", function() {
-	
+
 	var hash;
 	$("#sortable")
 		.sortable({ start: function(e, ui) { hash = ui; } })
 		.find('li:eq(0)').simulate("drag", { dx: 0, dy: 10 });
-	
-	ok(hash, 'start event triggered');	
+
+	ok(hash, 'start event triggered');
 	ok(hash.helper, 'UI hash includes: helper');
 	ok(hash.placeholder, 'UI hash includes: placeholder');
 	ok(hash.position && (hash.position.top && hash.position.left), 'UI hash includes: position');
@@ -20,104 +20,104 @@ test("start", function() {
 	ok(hash.item, 'UI hash includes: item');
 	ok(!hash.sender, 'UI hash does not include: sender');
 
-			
+
 });
 
 test("sort", function() {
-	
+
 	var hash;
 	$("#sortable")
 		.sortable({ sort: function(e, ui) { hash = ui; } })
 		.find('li:eq(0)').simulate("drag", { dx: 0, dy: 10 });
-	
-	ok(hash, 'sort event triggered');	
+
+	ok(hash, 'sort event triggered');
 	ok(hash.helper, 'UI hash includes: helper');
 	ok(hash.placeholder, 'UI hash includes: placeholder');
 	ok(hash.position && (hash.position.top && hash.position.left), 'UI hash includes: position');
 	ok(hash.offset && (hash.offset.top && hash.offset.left), 'UI hash includes: offset');
 	ok(hash.item, 'UI hash includes: item');
 	ok(!hash.sender, 'UI hash does not include: sender');
-	
+
 });
 
 test("change", function() {
-	
+
 	var hash;
 	$("#sortable")
 		.sortable({ change: function(e, ui) { hash = ui; } })
 		.find('li:eq(0)').simulate("drag", { dx: 1, dy: 1 });
-	
+
 	ok(!hash, '1px drag, change event should not be triggered');
-	
+
 	$("#sortable")
 		.sortable({ change: function(e, ui) { hash = ui; } })
-		.find('li:eq(0)').simulate("drag", { dx: 0, dy: 20 });	
-		
-	ok(hash, 'change event triggered');	
+		.find('li:eq(0)').simulate("drag", { dx: 0, dy: 20 });
+
+	ok(hash, 'change event triggered');
 	ok(hash.helper, 'UI hash includes: helper');
 	ok(hash.placeholder, 'UI hash includes: placeholder');
 	ok(hash.position && (hash.position.top && hash.position.left), 'UI hash includes: position');
 	ok(hash.offset && (hash.offset.top && hash.offset.left), 'UI hash includes: offset');
 	ok(hash.item, 'UI hash includes: item');
 	ok(!hash.sender, 'UI hash does not include: sender');
-	
+
 });
 
 test("beforeStop", function() {
-	
+
 	var hash;
 	$("#sortable")
 		.sortable({ beforeStop: function(e, ui) { hash = ui; } })
-		.find('li:eq(0)').simulate("drag", { dx: 0, dy: 20 });	
-		
-	ok(hash, 'beforeStop event triggered');	
+		.find('li:eq(0)').simulate("drag", { dx: 0, dy: 20 });
+
+	ok(hash, 'beforeStop event triggered');
 	ok(hash.helper, 'UI hash includes: helper');
 	ok(hash.placeholder, 'UI hash includes: placeholder');
 	ok(hash.position && (hash.position.top && hash.position.left), 'UI hash includes: position');
 	ok(hash.offset && (hash.offset.top && hash.offset.left), 'UI hash includes: offset');
 	ok(hash.item, 'UI hash includes: item');
 	ok(!hash.sender, 'UI hash does not include: sender');
-	
+
 });
 
 test("stop", function() {
-	
+
 	var hash;
 	$("#sortable")
 		.sortable({ stop: function(e, ui) { hash = ui; } })
-		.find('li:eq(0)').simulate("drag", { dx: 0, dy: 20 });	
-		
-	ok(hash, 'stop event triggered');	
+		.find('li:eq(0)').simulate("drag", { dx: 0, dy: 20 });
+
+	ok(hash, 'stop event triggered');
 	ok(!hash.helper, 'UI should not include: helper');
 	ok(hash.placeholder, 'UI hash includes: placeholder');
 	ok(hash.position && (hash.position.top && hash.position.left), 'UI hash includes: position');
 	ok(hash.offset && (hash.offset.top && hash.offset.left), 'UI hash includes: offset');
 	ok(hash.item, 'UI hash includes: item');
 	ok(!hash.sender, 'UI hash does not include: sender');
-	
+
 });
 
 test("update", function() {
-	
+
 	var hash;
 	$("#sortable")
 		.sortable({ update: function(e, ui) { hash = ui; } })
 		.find('li:eq(0)').simulate("drag", { dx: 1, dy: 1 });
-	
+
 	ok(!hash, '1px drag, update event should not be triggered');
-	
+
 	$("#sortable")
 		.sortable({ update: function(e, ui) { hash = ui; } })
-		.find('li:eq(0)').simulate("drag", { dx: 0, dy: 20 });	
-		
-	ok(hash, 'update event triggered');	
+		.find('li:eq(0)').simulate("drag", { dx: 0, dy: 20 });
+
+	ok(hash, 'update event triggered');
 	ok(!hash.helper, 'UI hash should not include: helper');
 	ok(hash.placeholder, 'UI hash includes: placeholder');
 	ok(hash.position && (hash.position.top && hash.position.left), 'UI hash includes: position');
 	ok(hash.offset && (hash.offset.top && hash.offset.left), 'UI hash includes: offset');
 	ok(hash.item, 'UI hash includes: item');
 	ok(!hash.sender, 'UI hash does not include: sender');
-	
+
 });
 
 test("receive", function() {
diff --git a/tests/unit/sortable/sortable_methods.js b/tests/unit/sortable/sortable_methods.js
index 2446d2755..c2a0b9548 100644
--- a/tests/unit/sortable/sortable_methods.js
+++ b/tests/unit/sortable/sortable_methods.js
@@ -5,7 +5,7 @@
 
 var el, offsetBefore, offsetAfter, dragged;
 
-var drag = function(handle, dx, dy) {
+function drag(handle, dx, dy) {
 	offsetBefore = $(handle).offset();
 	$(handle).simulate("drag", {
 		dx: dx || 0,
@@ -15,7 +15,7 @@ var drag = function(handle, dx, dy) {
 	offsetAfter = $(handle).offset();
 }
 
-var sort = function(handle, dx, dy, index, msg) {
+function sort(handle, dx, dy, index, msg) {
 	drag(handle, dx, dy);
 	equal($(handle).parent().children().index(handle), index, msg);
 }
diff --git a/tests/unit/sortable/sortable_tickets.js b/tests/unit/sortable/sortable_tickets.js
index 6ee503a58..22ad61baf 100644
--- a/tests/unit/sortable/sortable_tickets.js
+++ b/tests/unit/sortable/sortable_tickets.js
@@ -5,7 +5,7 @@
 
 var el, offsetBefore, offsetAfter, dragged;
 
-var drag = function(handle, dx, dy) {
+function drag(handle, dx, dy) {
 	offsetBefore = $(handle).offset();
 	$(handle).simulate("drag", {
 		dx: dx || 0,
@@ -15,7 +15,7 @@ var drag = function(handle, dx, dy) {
 	offsetAfter = $(handle).offset();
 }
 
-var sort = function(handle, dx, dy, index, msg) {
+function sort(handle, dx, dy, index, msg) {
 	drag(handle, dx, dy);
 	equal($(handle).parent().children().index(handle), index, msg);
 }
diff --git a/tests/unit/spinner/spinner_core.js b/tests/unit/spinner/spinner_core.js
index e12d1af2f..a1179bb35 100644
--- a/tests/unit/spinner/spinner_core.js
+++ b/tests/unit/spinner/spinner_core.js
@@ -1,5 +1,7 @@
 (function( $ ) {
 
+var simulateKeyDownUp = TestHelpers.spinner.simulateKeyDownUp;
+
 module( "spinner: core" );
 
 test( "keydown UP on input, increases value not greater than max", function() {
@@ -9,15 +11,15 @@ test( "keydown UP on input, increases value not greater than max", function() {
 		step: 10
 	});
 
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	equal( element.val(), 80 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	equal( element.val(), 90 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	equal( element.val(), 100 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	equal( element.val(), 100 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	equal( element.val(), 100 );
 });
 
@@ -28,15 +30,15 @@ test( "keydown DOWN on input, decreases value not less than min", function() {
 		step: 10
 	});
 
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 	equal( element.val(), 40 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 	equal( element.val(), 30 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 	equal( element.val(), 20 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 	equal( element.val(), 20 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 	equal( element.val(), 20 );
 });
 
@@ -47,15 +49,15 @@ test( "keydown PAGE_UP on input, increases value not greater than max", function
 		page: 10
 	});
 
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
 	equal( element.val(), 80 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
 	equal( element.val(), 90 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
 	equal( element.val(), 100 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
 	equal( element.val(), 100 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
 	equal( element.val(), 100 );
 });
 
@@ -66,15 +68,15 @@ test( "keydown PAGE_DOWN on input, decreases value not less than min", function(
 		page: 10
 	});
 
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
 	equal( element.val(), 40 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
 	equal( element.val(), 30 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
 	equal( element.val(), 20 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
 	equal( element.val(), 20 );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
 	equal( element.val(), 20 );
 });
 
@@ -99,7 +101,7 @@ test( "mouse click on up button, increases value not greater than max", function
 		min: 0
 	}),
 	button = element.spinner( "widget" ).find( ".ui-spinner-down" );
-	
+
 	button.trigger( "mousedown" ).trigger( "mouseup" );
 	equal( element.val(), 1 );
 	button.trigger( "mousedown" ).trigger( "mouseup" );
@@ -189,8 +191,8 @@ test( "don't clear invalid value on blur", function() {
 
 test( "precision", function() {
 	expect( 2 );
-	var element = $( "#spin" ).val( .05 ).spinner({
-		step: .0001
+	var element = $( "#spin" ).val( 0.05 ).spinner({
+		step: 0.0001
 	});
 	element.spinner( "stepUp" );
 	equal( element.val(), "0.0501", "precision from step" );
diff --git a/tests/unit/spinner/spinner_defaults.js b/tests/unit/spinner/spinner_defaults.js
index 0a4e7c236..4f05b1e63 100644
--- a/tests/unit/spinner/spinner_defaults.js
+++ b/tests/unit/spinner/spinner_defaults.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "spinner", {
+TestHelpers.commonWidgetTests( "spinner", {
 	defaults: {
 		culture: null,
 		disabled: false,
diff --git a/tests/unit/spinner/spinner_events.js b/tests/unit/spinner/spinner_events.js
index e43ba3365..133a8d5a2 100644
--- a/tests/unit/spinner/spinner_events.js
+++ b/tests/unit/spinner/spinner_events.js
@@ -1,5 +1,7 @@
 (function( $ ) {
 
+var simulateKeyDownUp = TestHelpers.spinner.simulateKeyDownUp;
+
 module( "spinner: events" );
 
 test( "start", function() {
@@ -13,14 +15,14 @@ test( "start", function() {
 	}
 
 	shouldStart( true, "key UP" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	shouldStart( true, "key DOWN" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 
 	shouldStart( true, "key PAGE_UP" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
 	shouldStart( true, "key PAGE_DOWN" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
 
 	shouldStart( true, "button up" );
 	element.spinner( "widget" ).find( ".ui-spinner-up" ).mousedown().mouseup();
@@ -52,14 +54,14 @@ test( "spin", function() {
 	}
 
 	shouldSpin( true, "key UP" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	shouldSpin( true, "key DOWN" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 
 	shouldSpin( true, "key PAGE_UP" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
 	shouldSpin( true, "key PAGE_DOWN" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
 
 	shouldSpin( true, "button up" );
 	element.spinner( "widget" ).find( ".ui-spinner-up" ).mousedown().mouseup();
@@ -91,14 +93,14 @@ test( "stop", function() {
 	}
 
 	shouldStop( true, "key UP" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	shouldStop( true, "key DOWN" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 
 	shouldStop( true, "key PAGE_UP" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
 	shouldStop( true, "key PAGE_DOWN" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
 
 	shouldStop( true, "button up" );
 	element.spinner( "widget" ).find( ".ui-spinner-up" ).mousedown().mouseup();
@@ -131,42 +133,42 @@ test( "change", function() {
 
 	element.focus();
 	shouldChange( false, "key UP, before blur" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	shouldChange( true, "blur after key UP" );
 	element.blur();
 
 	element.focus();
 	shouldChange( false, "key DOWN, before blur" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 	shouldChange( true, "blur after key DOWN" );
 	element.blur();
 
 	element.focus();
 	shouldChange( false, "key PAGE_UP, before blur" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
 	shouldChange( true, "blur after key PAGE_UP" );
 	element.blur();
 
 	element.focus();
 	shouldChange( false, "key PAGE_DOWN, before blur" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
 	shouldChange( true, "blur after key PAGE_DOWN" );
 	element.blur();
 
 	shouldChange( false, "many keys, before blur" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 	shouldChange( true, "blur after many keys" );
 	element.blur();
 
 	shouldChange( false, "many keys, same final value, before blur" );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 	shouldChange( false, "blur after many keys, same final value" );
 
 	shouldChange( false, "button up, before blur" );
diff --git a/tests/unit/spinner/spinner_methods.js b/tests/unit/spinner/spinner_methods.js
index 9c82218e1..bafd949a7 100644
--- a/tests/unit/spinner/spinner_methods.js
+++ b/tests/unit/spinner/spinner_methods.js
@@ -1,5 +1,7 @@
 (function( $ ) {
 
+var simulateKeyDownUp = TestHelpers.spinner.simulateKeyDownUp;
+
 module( "spinner: methods" );
 
 test( "destroy", function() {
@@ -21,16 +23,16 @@ test( "disable", function() {
 	ok( wrapper.hasClass( "ui-spinner-disabled" ), "after: wrapper has ui-spinner-disabled class" );
 	ok( element.is( ":disabled"), "after: input has disabled attribute" );
 
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	equal( 2, element.val(), "keyboard - value does not change on key UP" );
 
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
 	equal( 2, element.val(), "keyboard - value does not change on key DOWN" );
 
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
 	equal( 2, element.val(), "keyboard - value does not change on key PGUP" );
 
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
+	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
 	equal( 2, element.val(), "keyboard - value does not change on key PGDN" );
 
 	wrapper.find( ".ui-spinner-up" ).trigger( "mousedown" ).trigger( "mouseup" );
@@ -54,7 +56,7 @@ test( "disable", function() {
 
 test( "enable", function() {
 	expect( 5 );
-	var element = $( "#spin" ).val( 1 ).spinner({ disabled: true })
+	var element = $( "#spin" ).val( 1 ).spinner({ disabled: true }),
 		wrapper = element.spinner( "widget" );
 
 	ok( wrapper.hasClass( "ui-spinner-disabled" ), "before: wrapper has ui-spinner-disabled class" );
@@ -65,7 +67,7 @@ test( "enable", function() {
 	ok( !wrapper.hasClass( ".ui-spinner-disabled" ), "after: wrapper does not have ui-spinner-disabled class" );
 	ok( !element.is( ":disabled" ), "after: input does not have disabled attribute" );
 
-	spinner_simulateKeyDownUp( element, $.ui.keyCode.UP );
+	simulateKeyDownUp( element, $.ui.keyCode.UP );
 	equal( 2, element.val(), "keyboard - value changes on key UP" );
 });
 
diff --git a/tests/unit/spinner/spinner_options.js b/tests/unit/spinner/spinner_options.js
index cbad3f870..e21852630 100644
--- a/tests/unit/spinner/spinner_options.js
+++ b/tests/unit/spinner/spinner_options.js
@@ -1,5 +1,7 @@
 (function( $ ) {
 
+var simulateKeyDownUp = TestHelpers.spinner.simulateKeyDownUp;
+
 module( "spinner: options" );
 
 // culture is tested after numberFormat, since it depends on numberFormat
@@ -191,7 +193,7 @@ test( "min, string", function() {
 	equal( element.spinner( "option", "min" ), -100, "option converted to number" );
 
 	element.spinner( "value", -1000 );
-	equal( element.val(), "($100.00)", "min constrained in value method")
+	equal( element.val(), "($100.00)", "min constrained in value method" );
 });
 
 test( "step, 2", function() {
diff --git a/tests/unit/spinner/spinner_test_helpers.js b/tests/unit/spinner/spinner_test_helpers.js
index af555dbf2..2021e8f7a 100644
--- a/tests/unit/spinner/spinner_test_helpers.js
+++ b/tests/unit/spinner/spinner_test_helpers.js
@@ -1,5 +1,8 @@
-var spinner_simulateKeyDownUp = function( element, keyCode, shift ) {
-	element
-		.simulate( "keydown", { keyCode: keyCode, shiftKey: shift || false } )
-		.simulate( "keyup", { keyCode: keyCode, shiftKey: shift || false } );
+TestHelpers.spinner = {
+	simulateKeyDownUp: function( element, keyCode, shift ) {
+		element
+			.simulate( "keydown", { keyCode: keyCode, shiftKey: shift || false } )
+			.simulate( "keyup", { keyCode: keyCode, shiftKey: shift || false } );
+	}
 };
+
diff --git a/tests/unit/subsuite.js b/tests/unit/subsuite.js
index 03e8c9706..6f966590b 100644
--- a/tests/unit/subsuite.js
+++ b/tests/unit/subsuite.js
@@ -1,12 +1,11 @@
 (function() {
 
-var versions = [ "1.6", "1.6.1", "1.6.2", "1.6.3", "1.6.4", "1.7", "1.7.1", "1.7.2", "git" ];
-
-var additionalTests = {
-	accordion: [ "accordion_deprecated.html" ],
-	position: [ "position_deprecated.html" ],
-	tabs: [ "tabs_deprecated.html" ]
-};
+var versions = [ "1.6", "1.6.1", "1.6.2", "1.6.3", "1.6.4", "1.7", "1.7.1", "1.7.2", "git" ],
+	additionalTests = {
+		accordion: [ "accordion_deprecated.html" ],
+		position: [ "position_deprecated.html" ],
+		tabs: [ "tabs_deprecated.html" ]
+	};
 
 window.testAllVersions = function( widget ) {
 	QUnit.testSuites( $.map(
diff --git a/tests/unit/subsuiteRunner.js b/tests/unit/subsuiteRunner.js
index ddfccc7c1..2d6de2de1 100644
--- a/tests/unit/subsuiteRunner.js
+++ b/tests/unit/subsuiteRunner.js
@@ -4,13 +4,16 @@ var subsuiteFrame;
 
 QUnit.extend( QUnit, {
 	testSuites: function( suites ) {
+		function generateSuite( suite ) {
+			asyncTest( suite, function() {
+				QUnit.runSuite( suite );
+			});
+		}
+
 		for ( var i = 0; i < suites.length; i++ ) {
-			(function( suite ) {
-				asyncTest( suite, function() {
-					QUnit.runSuite( suite );
-				});
-			}( suites[i] ) );
+			generateSuite( suites[ i ] );
 		}
+
 		QUnit.done = function() {
 			subsuiteFrame.style.display = "none";
 		};
@@ -23,10 +26,12 @@ QUnit.extend( QUnit, {
 
 	testDone: function() {
 		var current = QUnit.id( this.config.current.id ),
-			children = current.children;
+			children = current.children,
+			i = 0,
+			length = children.length;
 
 		// undo the auto-expansion of failed tests
-		for ( var i = 0; i < children.length; i++ ) {
+		for ( ; i < length; i++ ) {
 			if ( children[i].nodeName === "OL" ) {
 				children[i].style.display = "none";
 			}
@@ -34,10 +39,11 @@ QUnit.extend( QUnit, {
 	},
 
 	runSuite: function( suite ) {
-		var body = document.getElementsByTagName( "body" )[0],
-			iframe = subsuiteFrame = document.createElement( "iframe" ),
-			iframeWin;
+		var iframeWin,
+			body = document.getElementsByTagName( "body" )[0],
+			iframe = document.createElement( "iframe" );
 
+		subsuiteFrame = iframe;
 		iframe.className = "qunit-subsuite";
 		body.appendChild( iframe );
 
diff --git a/tests/unit/swarminject.js b/tests/unit/swarminject.js
index db69326ab..78d37ef46 100644
--- a/tests/unit/swarminject.js
+++ b/tests/unit/swarminject.js
@@ -5,5 +5,5 @@
 	if ( !url || url.indexOf("http") !== 0 ) {
 		return;
 	}
-    document.write("<scr" + "ipt src='http://swarm.jquery.org/js/inject.js?" + (new Date).getTime() + "'></scr" + "ipt>");
+    document.write( "<scr" + "ipt src='http://swarm.jquery.org/js/inject.js?" + (new Date()).getTime() + "'></scr" + "ipt>" );
 })();
diff --git a/tests/unit/tabs/tabs.html b/tests/unit/tabs/tabs.html
index fc494e013..7f60ad277 100644
--- a/tests/unit/tabs/tabs.html
+++ b/tests/unit/tabs/tabs.html
@@ -25,68 +25,13 @@
 	<script src="../../jquery.simulate.js"></script>
 	<script src="../testsuite.js"></script>
 
+	<script src="tabs_test_helpers.js"></script>
 	<script src="tabs_defaults.js"></script>
 	<script src="tabs_core.js"></script>
 	<script src="tabs_events.js"></script>
 	<script src="tabs_methods.js"></script>
 	<script src="tabs_options.js"></script>
 
-	<script>
-	function tabs_state( tabs ) {
-		var expected = $.makeArray( arguments ).slice( 1 );
-		var actual = tabs.find( ".ui-tabs-nav li" ).map(function() {
-			var tab = $( this ),
-				panel = $( $.ui.tabs.prototype._sanitizeSelector(
-					"#" + tab.find( "a" ).attr( "aria-controls" ) ) ),
-				tabIsActive = tab.hasClass( "ui-state-active" ),
-				panelIsActive = panel.css( "display" ) !== "none";
-
-			if ( tabIsActive && panelIsActive ) {
-				return 1;
-			}
-			if ( !tabIsActive && !panelIsActive ) {
-				return 0;
-			}
-			return -1; // mixed state - invalid
-		}).get();
-		deepEqual( actual, expected );
-	}
-
-	function tabs_disabled( tabs, state ) {
-		var expected = $.map( new Array( tabs.find ( ".ui-tabs-nav li" ).length ), function( _, index ) {
-			if ( typeof state === "boolean" ) {
-				return state ? 1 : 0;
-			} else {
-				return $.inArray( index, state ) !== -1 ? 1 : 0;
-			}
-		});
-
-		var internalState = tabs.tabs( "option", "disabled" );
-		if ( internalState === false ) {
-			internalState = [];
-		}
-		if ( internalState === true ) {
-			internalState = $.map( new Array( tabs.find( ".ui-tabs-nav li" ).length ), function( _, index ) {
-				return index;
-			});
-		}
-
-		var actual = tabs.find( ".ui-tabs-nav li" ).map(function( index ) {
-			var tab = $( this ),
-				tabIsDisabled = tab.hasClass( "ui-state-disabled" );
-
-			if ( tabIsDisabled && $.inArray( index, internalState ) !== -1 ) {
-				return 1;
-			}
-			if ( !tabIsDisabled && $.inArray( index, internalState ) === -1 ) {
-				return 0;
-			}
-			return -1; // mixed state - invalid
-		}).get();
-		deepEqual( tabs.tabs( "option", "disabled" ), state );
-		deepEqual( actual, expected );
-	}
-	</script>
 	<script src="../swarminject.js"></script>
 </head>
 <body>
diff --git a/tests/unit/tabs/tabs_core.js b/tests/unit/tabs/tabs_core.js
index 21250fb33..b9bd81987 100644
--- a/tests/unit/tabs/tabs_core.js
+++ b/tests/unit/tabs/tabs_core.js
@@ -1,5 +1,7 @@
 (function( $ ) {
 
+var state = TestHelpers.tabs.state;
+
 module( "tabs: core" );
 
 test( "markup structure", function() {
@@ -89,7 +91,7 @@ test( "#4033 - IE expands hash to full url and misinterprets tab as ajax", funct
 	});
 
 	equal( element.find( ".ui-tabs-nav a" ).attr( "aria-controls" ), "tab", "aria-contorls attribute is correct" );
-	tabs_state( element, 1 );
+	state( element, 1 );
 });
 
 }( jQuery ) );
diff --git a/tests/unit/tabs/tabs_defaults.js b/tests/unit/tabs/tabs_defaults.js
index 52b6f8a71..7ffb05da4 100644
--- a/tests/unit/tabs/tabs_defaults.js
+++ b/tests/unit/tabs/tabs_defaults.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "tabs", {
+TestHelpers.commonWidgetTests( "tabs", {
 	defaults: {
 		active: null,
 		collapsible: false,
diff --git a/tests/unit/tabs/tabs_defaults_deprecated.js b/tests/unit/tabs/tabs_defaults_deprecated.js
index 1a56297e9..fdcff21b3 100644
--- a/tests/unit/tabs/tabs_defaults_deprecated.js
+++ b/tests/unit/tabs/tabs_defaults_deprecated.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "tabs", {
+TestHelpers.commonWidgetTests( "tabs", {
 	defaults: {
 		active: null,
 		ajaxOptions: null,
diff --git a/tests/unit/tabs/tabs_deprecated.html b/tests/unit/tabs/tabs_deprecated.html
index 410aebc40..c22ec3369 100644
--- a/tests/unit/tabs/tabs_deprecated.html
+++ b/tests/unit/tabs/tabs_deprecated.html
@@ -23,6 +23,7 @@
 	<script src="../../jquery.simulate.js"></script>
 	<script src="../testsuite.js"></script>
 
+	<script src="tabs_test_helpers.js"></script>
 	<script src="tabs_defaults_deprecated.js"></script>
 	<script src="tabs_core.js"></script>
 	<script src="tabs_events.js"></script>
@@ -30,62 +31,6 @@
 	<script src="tabs_options.js"></script>
 	<script src="tabs_deprecated.js"></script>
 
-	<script>
-	function tabs_state( tabs ) {
-		var expected = $.makeArray( arguments ).slice( 1 );
-		var actual = tabs.find( ".ui-tabs-nav li" ).map(function() {
-			var tab = $( this ),
-				panel = $( $.ui.tabs.prototype._sanitizeSelector(
-					"#" + tab.find( "a" ).attr( "aria-controls" ) ) ),
-				tabIsActive = tab.hasClass( "ui-state-active" ),
-				panelIsActive = panel.css( "display" ) !== "none";
-
-			if ( tabIsActive && panelIsActive ) {
-				return 1;
-			}
-			if ( !tabIsActive && !panelIsActive ) {
-				return 0;
-			}
-			return -1; // mixed state - invalid
-		}).get();
-		deepEqual( actual, expected );
-	}
-
-	function tabs_disabled( tabs, state ) {
-		var expected = $.map( new Array( tabs.find ( ".ui-tabs-nav li" ).length ), function( _, index ) {
-			if ( typeof state === "boolean" ) {
-				return state ? 1 : 0;
-			} else {
-				return $.inArray( index, state ) !== -1 ? 1 : 0;
-			}
-		});
-
-		var internalState = tabs.tabs( "option", "disabled" );
-		if ( internalState === false ) {
-			internalState = [];
-		}
-		if ( internalState === true ) {
-			internalState = $.map( new Array( tabs.find( ".ui-tabs-nav li" ).length ), function( _, index ) {
-				return index;
-			});
-		}
-
-		var actual = tabs.find( ".ui-tabs-nav li" ).map(function( index ) {
-			var tab = $( this ),
-				tabIsDisabled = tab.hasClass( "ui-state-disabled" );
-
-			if ( tabIsDisabled && $.inArray( index, internalState ) !== -1 ) {
-				return 1;
-			}
-			if ( !tabIsDisabled && $.inArray( index, internalState ) === -1 ) {
-				return 0;
-			}
-			return -1; // mixed state - invalid
-		}).get();
-		deepEqual( tabs.tabs( "option", "disabled" ), state );
-		deepEqual( actual, expected );
-	}
-	</script>
 	<script src="../swarminject.js"></script>
 </head>
 <body>
diff --git a/tests/unit/tabs/tabs_deprecated.js b/tests/unit/tabs/tabs_deprecated.js
index 80bc4a326..8386a13ac 100644
--- a/tests/unit/tabs/tabs_deprecated.js
+++ b/tests/unit/tabs/tabs_deprecated.js
@@ -1,5 +1,7 @@
 (function( $ ) {
 
+var state = TestHelpers.tabs.state;
+
 module( "tabs (deprecated): core" );
 
 test( "panel ids", function() {
@@ -48,17 +50,17 @@ asyncTest( "cache", function() {
 		cache: true
 	});
 	element.one( "tabsshow", function( event, ui ) {
-		tabs_state( element, 0, 0, 1, 0, 0 );
+		state( element, 0, 0, 1, 0, 0 );
 	});
 	element.one( "tabsload", function( event, ui ) {
 		ok( true, "tabsload" );
 
 		setTimeout(function() {
 			element.tabs( "option", "active", 0 );
-			tabs_state( element, 1, 0, 0, 0, 0 );
+			state( element, 1, 0, 0, 0, 0 );
 
 			element.one( "tabsshow", function( event, ui ) {
-				tabs_state( element, 0, 0, 1, 0, 0 );
+				state( element, 0, 0, 1, 0, 0 );
 			});
 			element.one( "tabsload", function( event, ui ) {
 				ok( false, "should be cached" );
@@ -68,7 +70,7 @@ asyncTest( "cache", function() {
 		}, 1 );
 	});
 	element.tabs( "option", "active", 2 );
-	tabs_state( element, 0, 0, 1, 0, 0 );
+	state( element, 0, 0, 1, 0, 0 );
 });
 
 test( "idPrefix", function() {
@@ -89,10 +91,11 @@ test( "tabTemplate + panelTemplate", function() {
 	// defaults are tested in the add method test
 	expect( 11 );
 
-	var element = $( "#tabs2" ).tabs({
-		tabTemplate: "<li class='customTab'><a href='http://example.com/#{href}'>#{label}</a></li>",
-		panelTemplate: "<div class='customPanel'></div>"
-	});
+	var tab, anchor,
+		element = $( "#tabs2" ).tabs({
+			tabTemplate: "<li class='customTab'><a href='http://example.com/#{href}'>#{label}</a></li>",
+			panelTemplate: "<div class='customPanel'></div>"
+		});
 	element.one( "tabsadd", function( event, ui ) {
 		var anchor = $( ui.tab );
 		equal( ui.index, 5, "ui.index" );
@@ -103,8 +106,8 @@ test( "tabTemplate + panelTemplate", function() {
 		ok( $( ui.panel ).hasClass( "customPanel" ), "panel custom class" );
 	});
 	element.tabs( "add", "#new", "New" );
-	var tab = element.find( ".ui-tabs-nav li" ).last(),
-		anchor = tab.find( "a" );
+	tab = element.find( ".ui-tabs-nav li" ).last();
+	anchor = tab.find( "a" );
 	equal( tab.text(), "New", "label" );
 	ok( tab.hasClass( "customTab" ), "tab custom class" );
 	equal( anchor.attr( "href" ), "http://example.com/#new", "href" );
@@ -170,50 +173,50 @@ test( "selected", function() {
 
 	var element = $( "#tabs1" ).tabs();
 	equal( element.tabs( "option", "selected" ), 0, "should be 0 by default" );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	element.tabs( "destroy" );
 
 	location.hash = "#fragment-3";
 	element = $( "#tabs1" ).tabs();
 	equal( element.tabs( "option", "selected" ), 2, "should be 2 based on URL" );
-	tabs_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.tabs( "destroy" );
 
 	el = $('#tabs1').tabs({
 		selected: -1,
 		collapsible: true
 	});
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 	equal( element.find( ".ui-tabs-nav .ui-state-active" ).size(), 0, "no tabs selected" );
 	strictEqual( element.tabs( "option", "selected" ), -1 );
 
 	element.tabs( "option", "collapsible", false );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	equal( element.tabs( "option", "selected" ), 0 );
 	element.tabs( "destroy" );
 
 	element.tabs({
 		selected: -1
 	});
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	strictEqual( element.tabs( "option", "selected" ), 0 );
 	element.tabs( "destroy" );
 
 	element.tabs({ selected: 2 });
 	equal( element.tabs( "option", "selected" ), 2 );
-	tabs_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 
 	element.tabs( "option", "selected", 0 );
 	equal( element.tabs( "option", "selected" ), 0 );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	element.find( ".ui-tabs-nav a" ).eq( 1 ).click();
 	equal( element.tabs( "option", "selected" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.tabs( "option", "selected", 10 );
 	equal( element.tabs( "option", "selected" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	location.hash = "#";
 });
@@ -236,7 +239,7 @@ asyncTest( "load", function() {
 		strictEqual( ui.tab, tab[ 0 ], "tab" );
 		strictEqual( ui.panel, panel[ 0 ], "panel" );
 		equal( $( ui.panel ).find( "p" ).length, 1, "panel html" );
-		tabs_state( element, 0, 0, 1, 0, 0 );
+		state( element, 0, 0, 1, 0, 0 );
 		tabsload1();
 	});
 	element.tabs({ active: 2 });
@@ -252,7 +255,7 @@ asyncTest( "load", function() {
 			strictEqual( ui.tab, tab[ 0 ], "tab" );
 			strictEqual( ui.panel, panel[ 0 ], "panel" );
 			equal( $( ui.panel ).find( "p" ).length, 1, "panel html" );
-			tabs_state( element, 0, 0, 0, 1, 0 );
+			state( element, 0, 0, 0, 1, 0 );
 			tabsload2();
 		});
 		element.tabs( "option", "active", 3 );
@@ -269,7 +272,7 @@ asyncTest( "load", function() {
 			strictEqual( ui.tab, tab[ 0 ], "tab" );
 			strictEqual( ui.panel, panel[ 0 ], "panel" );
 			equal( $( ui.panel ).find( "p" ).length, 1, "panel html" );
-			tabs_state( element, 0, 0, 0, 0, 1 );
+			state( element, 0, 0, 0, 0, 1 );
 			start();
 		});
 		element.find( ".ui-tabs-nav a" ).eq( 4 ).click();
@@ -324,10 +327,10 @@ test( "show", function() {
 		strictEqual( ui.tab, tabs[ 0 ], "ui.tab" );
 		strictEqual( ui.panel, panels[ 0 ], "ui.panel" );
 		equal( ui.index, 0, "ui.index" );
-		tabs_state( element, 1, 0, 0 );
+		state( element, 1, 0, 0 );
 	});
 	element.tabs( "option", "active", 0 );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	// switching tabs
 	element.one( "tabsshow", function( event, ui ) {
@@ -335,17 +338,17 @@ test( "show", function() {
 		strictEqual( ui.tab, tabs[ 1 ], "ui.tab" );
 		strictEqual( ui.panel, panels[ 1 ], "ui.panel" );
 		equal( ui.index, 1, "ui.index" );
-		tabs_state( element, 0, 1, 0 );
+		state( element, 0, 1, 0 );
 	});
 	tabs.eq( 1 ).click();
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	// collapsing
 	element.one( "tabsshow", function( event, ui ) {
 		ok( false, "collapsing" );
 	});
 	element.tabs( "option", "active", false );
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 });
 
 test( "select", function() {
@@ -364,10 +367,10 @@ test( "select", function() {
 		strictEqual( ui.tab, tabs[ 0 ], "ui.tab" );
 		strictEqual( ui.panel, panels[ 0 ], "ui.panel" );
 		equal( ui.index, 0, "ui.index" );
-		tabs_state( element, 0, 0, 0 );
+		state( element, 0, 0, 0 );
 	});
 	element.tabs( "option", "active", 0 );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	// switching tabs
 	element.one( "tabsselect", function( event, ui ) {
@@ -375,17 +378,17 @@ test( "select", function() {
 		strictEqual( ui.tab, tabs[ 1 ], "ui.tab" );
 		strictEqual( ui.panel, panels[ 1 ], "ui.panel" );
 		equal( ui.index, 1, "ui.index" );
-		tabs_state( element, 1, 0, 0 );
+		state( element, 1, 0, 0 );
 	});
 	tabs.eq( 1 ).click();
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	// collapsing
 	element.one( "tabsselect", function( event, ui ) {
 		ok( false, "collapsing" );
 	});
 	element.tabs( "option", "active", false );
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 });
 
 module( "tabs (deprecated): methods" );
@@ -393,8 +396,9 @@ module( "tabs (deprecated): methods" );
 test( "add", function() {
 	expect( 27 );
 
-	var element = $( "#tabs1" ).tabs();
-	tabs_state( element, 1, 0, 0 );
+	var tab, anchor,
+		element = $( "#tabs1" ).tabs();
+	state( element, 1, 0, 0 );
 
 	// add without index
 	element.one( "tabsadd", function( event, ui ) {
@@ -403,9 +407,9 @@ test( "add", function() {
 		equal( ui.panel.id, "new", "ui.panel" );
 	});
 	element.tabs( "add", "#new", "New" );
-	tabs_state( element, 1, 0, 0, 0 );
-	var tab = element.find( ".ui-tabs-nav li" ).last(),
-		anchor = tab.find( "a" );
+	state( element, 1, 0, 0, 0 );
+	tab = element.find( ".ui-tabs-nav li" ).last();
+	anchor = tab.find( "a" );
 	equal( tab.text(), "New", "label" );
 	equal( anchor.attr( "href" ), "#new", "href" );
 	equal( anchor.attr( "aria-controls" ), "new", "aria-controls" );
@@ -413,7 +417,7 @@ test( "add", function() {
 	anchor.simulate( "mouseover" );
 	ok( tab.hasClass( "ui-state-hover" ), "hovered" );
 	anchor.simulate( "click" );
-	tabs_state( element, 0, 0, 0, 1 );
+	state( element, 0, 0, 0, 1 );
 
 	// add remote tab with index
 	element.one( "tabsadd", function( event, ui ) {
@@ -422,7 +426,7 @@ test( "add", function() {
 		equal( ui.panel.id, $( ui.tab ).attr( "aria-controls" ), "ui.panel" );
 	});
 	element.tabs( "add", "data/test.html", "New Remote", 1 );
-	tabs_state( element, 0, 0, 0, 0, 1 );
+	state( element, 0, 0, 0, 0, 1 );
 	tab = element.find( ".ui-tabs-nav li" ).eq( 1 );
 	anchor = tab.find( "a" );
 	equal( tab.text(), "New Remote", "label" );
@@ -432,7 +436,7 @@ test( "add", function() {
 	anchor.simulate( "mouseover" );
 	ok( tab.hasClass( "ui-state-hover" ), "hovered" );
 	anchor.simulate( "click" );
-	tabs_state( element, 0, 1, 0, 0, 0 );
+	state( element, 0, 1, 0, 0, 0 );
 
 	// add to empty tab set
 	element = $( "<div><ul></ul></div>" ).tabs();
@@ -443,7 +447,7 @@ test( "add", function() {
 		equal( ui.panel.id, "first", "ui.panel" );
 	});
 	element.tabs( "add", "#first", "First" );
-	tabs_state( element, 1 );
+	state( element, 1 );
 	equal( element.tabs( "option", "active" ), 0, "active: 0 after add" );
 });
 
@@ -460,7 +464,7 @@ test( "remove", function() {
 	expect( 17 );
 
 	var element = $( "#tabs1" ).tabs({ active: 1 });
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.one( "tabsremove", function( event, ui ) {
 		equal( ui.index, -1, "ui.index" );
@@ -468,7 +472,7 @@ test( "remove", function() {
 		equal( ui.panel.id, "fragment-2", "ui.panel" );
 	});
 	element.tabs( "remove", 1 );
-	tabs_state( element, 0, 1 );
+	state( element, 0, 1 );
 	equal( element.tabs( "option", "active" ), 1 );
 	equal( element.find( ".ui-tabs-nav li a[href$='fragment-2']" ).length, 0,
 		"remove correct list item" );
@@ -480,7 +484,7 @@ test( "remove", function() {
 		equal( ui.panel.id, "fragment-3", "ui.panel" );
 	});
 	element.tabs( "remove", 1 );
-	tabs_state( element, 1 );
+	state( element, 1 );
 	equal( element.tabs( "option", "active"), 0 );
 
 	element.one( "tabsremove", function( event, ui ) {
@@ -496,43 +500,43 @@ test( "select", function() {
 	expect( 23 );
 
 	var element = $( "#tabs1" ).tabs();
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	element.tabs( "select", 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 	equal( element.tabs( "option", "active" ), 1, "active" );
 	equal( element.tabs( "option", "selected" ), 1, "selected" );
 	element.tabs( "destroy" );
 
 	element.tabs({ collapsible: true });
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	element.tabs( "select", 0 );
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 	equal( element.tabs( "option", "active" ), false, "active" );
 	equal( element.tabs( "option", "selected" ), -1, "selected" );
 	element.tabs( "destroy" );
 
 	element.tabs({ collapsible: true });
 	element.tabs( "select", -1 );
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 	equal( element.tabs( "option", "active" ), false, "active" );
 	equal( element.tabs( "option", "selected" ), -1, "selected" );
 	element.tabs( "destroy" );
 
 	element.tabs();
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	equal( element.tabs( "option", "active" ), 0, "active" );
 	equal( element.tabs( "option", "selected" ), 0, "selected" );
 	element.tabs( "select", 0 );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	equal( element.tabs( "option", "active" ), 0, "active" );
 	equal( element.tabs( "option", "selected" ), 0, "selected" );
 	element.tabs( "select", -1 );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	equal( element.tabs( "option", "active" ), 0, "active" );
 	equal( element.tabs( "option", "selected" ), 0, "selected" );
 
 	element.tabs( "select", "#fragment-2" );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 	equal( element.tabs( "option", "active" ), 1, "active" );
 	equal( element.tabs( "option", "selected" ), 1, "selected" );
 });
diff --git a/tests/unit/tabs/tabs_events.js b/tests/unit/tabs/tabs_events.js
index 4f9269b62..3f6ec14d0 100644
--- a/tests/unit/tabs/tabs_events.js
+++ b/tests/unit/tabs/tabs_events.js
@@ -1,5 +1,7 @@
 (function( $ ) {
 
+var state = TestHelpers.tabs.state;
+
 module( "tabs: events" );
 
 test( "create", function() {
@@ -60,10 +62,10 @@ test( "beforeActivate", function() {
 		strictEqual( ui.newTab[ 0 ], tabs[ 0 ], "newTab" );
 		equal( ui.newPanel.size(), 1, "newPanel size" );
 		strictEqual( ui.newPanel[ 0 ], panels[ 0 ], "newPanel" );
-		tabs_state( element, 0, 0, 0 );
+		state( element, 0, 0, 0 );
 	});
 	element.tabs( "option", "active", 0 );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	// switching tabs
 	element.one( "tabsbeforeactivate", function( event, ui ) {
@@ -76,10 +78,10 @@ test( "beforeActivate", function() {
 		strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
 		equal( ui.newPanel.size(), 1, "newPanel size" );
 		strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
-		tabs_state( element, 1, 0, 0 );
+		state( element, 1, 0, 0 );
 	});
 	tabs.eq( 1 ).click();
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	// collapsing
 	element.one( "tabsbeforeactivate", function( event, ui ) {
@@ -90,10 +92,10 @@ test( "beforeActivate", function() {
 		strictEqual( ui.oldPanel[ 0 ], panels[ 1 ], "oldPanel" );
 		equal( ui.newTab.size(), 0, "newTab size" );
 		equal( ui.newPanel.size(), 0, "newPanel size" );
-		tabs_state( element, 0, 1, 0 );
+		state( element, 0, 1, 0 );
 	});
 	element.tabs( "option", "active", false );
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 
 	// prevent activation
 	element.one( "tabsbeforeactivate", function( event, ui ) {
@@ -105,10 +107,10 @@ test( "beforeActivate", function() {
 		equal( ui.newPanel.size(), 1, "newPanel size" );
 		strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
 		event.preventDefault();
-		tabs_state( element, 0, 0, 0 );
+		state( element, 0, 0, 0 );
 	});
 	element.tabs( "option", "active", 1 );
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 });
 
 test( "activate", function() {
@@ -130,10 +132,10 @@ test( "activate", function() {
 		strictEqual( ui.newTab[ 0 ], tabs[ 0 ], "newTab" );
 		equal( ui.newPanel.size(), 1, "newPanel size" );
 		strictEqual( ui.newPanel[ 0 ], panels[ 0 ], "newPanel" );
-		tabs_state( element, 1, 0, 0 );
+		state( element, 1, 0, 0 );
 	});
 	element.tabs( "option", "active", 0 );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	// switching tabs
 	element.one( "tabsactivate", function( event, ui ) {
@@ -146,10 +148,10 @@ test( "activate", function() {
 		strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
 		equal( ui.newPanel.size(), 1, "newPanel size" );
 		strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
-		tabs_state( element, 0, 1, 0 );
+		state( element, 0, 1, 0 );
 	});
 	tabs.eq( 1 ).click();
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	// collapsing
 	element.one( "tabsactivate", function( event, ui ) {
@@ -160,10 +162,10 @@ test( "activate", function() {
 		strictEqual( ui.oldPanel[ 0 ], panels[ 1 ], "oldPanel" );
 		equal( ui.newTab.size(), 0, "newTab size" );
 		equal( ui.newPanel.size(), 0, "newPanel size" );
-		tabs_state( element, 0, 0, 0 );
+		state( element, 0, 0, 0 );
 	});
 	element.tabs( "option", "active", false );
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 
 	// prevent activation
 	element.one( "tabsbeforeactivate", function( event ) {
@@ -197,10 +199,10 @@ test( "beforeLoad", function() {
 		strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
 		equal( ui.panel.html(), "", "panel html" );
 		event.preventDefault();
-		tabs_state( element, 0, 0, 1, 0, 0 );
+		state( element, 0, 0, 1, 0, 0 );
 	});
 	element.tabs({ active: 2 });
-	tabs_state( element, 0, 0, 1, 0, 0 );
+	state( element, 0, 0, 1, 0, 0 );
 	equal( panel.html(), "", "panel html after" );
 	element.tabs( "destroy" );
 
@@ -219,11 +221,11 @@ test( "beforeLoad", function() {
 		strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
 		equal( ui.panel.html(), "", "panel html" );
 		event.preventDefault();
-		tabs_state( element, 1, 0, 0, 0, 0 );
+		state( element, 1, 0, 0, 0, 0 );
 	});
 	element.tabs();
 	element.tabs( "option", "active", 2 );
-	tabs_state( element, 0, 0, 1, 0, 0 );
+	state( element, 0, 0, 1, 0, 0 );
 	equal( panel.html(), "", "panel html after" );
 
 	// click, change panel content
@@ -241,10 +243,10 @@ test( "beforeLoad", function() {
 		strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
 		ui.panel.html( "<p>testing</p>" );
 		event.preventDefault();
-		tabs_state( element, 0, 0, 1, 0, 0 );
+		state( element, 0, 0, 1, 0, 0 );
 	});
 	element.find( ".ui-tabs-nav a" ).eq( 3 ).click();
-	tabs_state( element, 0, 0, 0, 1, 0 );
+	state( element, 0, 0, 0, 1, 0 );
 	// .toLowerCase() is needed to convert <P> to <p> in old IEs
 	equal( panel.html().toLowerCase(), "<p>testing</p>", "panel html after" );
 });
@@ -268,7 +270,7 @@ if ( $.uiBackCompat === false ) {
 			equal( ui.panel.size(), 1, "panel size" );
 			strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
 			equal( ui.panel.find( "p" ).length, 1, "panel html" );
-			tabs_state( element, 0, 0, 1, 0, 0 );
+			state( element, 0, 0, 1, 0, 0 );
 			tabsload1();
 		});
 		element.tabs({ active: 2 });
@@ -286,7 +288,7 @@ if ( $.uiBackCompat === false ) {
 				equal( ui.panel.size(), 1, "panel size" );
 				strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
 				equal( ui.panel.find( "p" ).length, 1, "panel html" );
-				tabs_state( element, 0, 0, 0, 1, 0 );
+				state( element, 0, 0, 0, 1, 0 );
 				tabsload2();
 			});
 			element.tabs( "option", "active", 3 );
@@ -305,7 +307,7 @@ if ( $.uiBackCompat === false ) {
 				equal( ui.panel.size(), 1, "panel size" );
 				strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
 				equal( ui.panel.find( "p" ).length, 1, "panel html" );
-				tabs_state( element, 0, 0, 0, 0, 1 );
+				state( element, 0, 0, 0, 0, 1 );
 				start();
 			});
 			element.find( ".ui-tabs-nav a" ).eq( 4 ).click();
diff --git a/tests/unit/tabs/tabs_methods.js b/tests/unit/tabs/tabs_methods.js
index fee87db96..61ce78189 100644
--- a/tests/unit/tabs/tabs_methods.js
+++ b/tests/unit/tabs/tabs_methods.js
@@ -1,5 +1,8 @@
 (function( $ ) {
 
+var disabled = TestHelpers.tabs.disabled,
+	state = TestHelpers.tabs.state;
+
 module( "tabs: methods" );
 
 test( "destroy", function() {
@@ -12,95 +15,95 @@ test( "enable", function() {
 	expect( 8 );
 
 	var element = $( "#tabs1" ).tabs({ disabled: true });
-	tabs_disabled( element, true );
+	disabled( element, true );
 	element.tabs( "enable" );
-	tabs_disabled( element, false );
+	disabled( element, false );
 	element.tabs( "destroy" );
 
 	element.tabs({ disabled: [ 0, 1 ] });
-	tabs_disabled( element, [ 0, 1 ] );
+	disabled( element, [ 0, 1 ] );
 	element.tabs( "enable" );
-	tabs_disabled( element, false );
+	disabled( element, false );
 });
 
 test( "enable( index )", function() {
     expect( 10 );
 
 	var element = $( "#tabs1" ).tabs({ disabled: true });
-	tabs_disabled( element, true );
+	disabled( element, true );
 	// fully disabled -> partially disabled
 	element.tabs( "enable", 1 );
-	tabs_disabled( element, [ 0, 2 ] );
+	disabled( element, [ 0, 2 ] );
 	// partially disabled -> partially disabled
 	element.tabs( "enable", 2 );
-	tabs_disabled( element, [ 0 ] );
+	disabled( element, [ 0 ] );
 	// already enabled tab, no change
 	element.tabs( "enable", 2 );
-	tabs_disabled( element, [ 0 ] );
+	disabled( element, [ 0 ] );
 	// partially disabled -> fully enabled
 	element.tabs( "enable", 0 );
-	tabs_disabled( element, false );
+	disabled( element, false );
 });
 
 test( "disable", function() {
 	expect( 8 );
 
 	var element = $( "#tabs1" ).tabs({ disabled: false });
-	tabs_disabled( element, false );
+	disabled( element, false );
 	element.tabs( "disable" );
-	tabs_disabled( element, true );
+	disabled( element, true );
 	element.tabs( "destroy" );
 
 	element.tabs({ disabled: [ 0, 1 ] });
-	tabs_disabled( element, [ 0, 1 ] );
+	disabled( element, [ 0, 1 ] );
 	element.tabs( "disable" );
-	tabs_disabled( element, true );
+	disabled( element, true );
 });
 
 test( "disable( index )", function() {
     expect( 10 );
 
 	var element = $( "#tabs1" ).tabs({ disabled: false });
-	tabs_disabled( element, false );
+	disabled( element, false );
 	// fully enabled -> partially disabled
 	element.tabs( "disable", 1 );
-	tabs_disabled( element, [ 1 ] );
+	disabled( element, [ 1 ] );
 	// partially disabled -> partially disabled
 	element.tabs( "disable", 2 );
-	tabs_disabled( element, [ 1, 2 ] );
+	disabled( element, [ 1, 2 ] );
 	// already disabled tab, no change
 	element.tabs( "disable", 2 );
-	tabs_disabled( element, [ 1, 2 ] );
+	disabled( element, [ 1, 2 ] );
 	// partially disabled -> fully disabled
 	element.tabs( "disable", 0 );
-	tabs_disabled( element, true );
+	disabled( element, true );
 });
 
 test( "refresh", function() {
 	expect( 27 );
 
 	var element = $( "#tabs1" ).tabs();
-	tabs_state( element, 1, 0, 0 );
-	tabs_disabled( element, false );
+	state( element, 1, 0, 0 );
+	disabled( element, false );
 
 	// disable tab via markup
 	element.find( ".ui-tabs-nav li" ).eq( 1 ).addClass( "ui-state-disabled" );
 	element.tabs( "refresh" );
-	tabs_state( element, 1, 0, 0 );
-	tabs_disabled( element, [ 1 ] );
+	state( element, 1, 0, 0 );
+	disabled( element, [ 1 ] );
 
 	// add remote tab
 	element.find( ".ui-tabs-nav" ).append( "<li id='newTab'><a href='data/test.html'>new</a></li>" );
 	element.tabs( "refresh" );
-	tabs_state( element, 1, 0, 0, 0 );
-	tabs_disabled( element, [ 1 ] );
+	state( element, 1, 0, 0, 0 );
+	disabled( element, [ 1 ] );
 	equal( element.find( "#" + $( "#newTab a" ).attr( "aria-controls" ) ).length, 1,
 		"panel added for remote tab" );
 
 	// remove all tabs
 	element.find( ".ui-tabs-nav li, .ui-tabs-panel" ).remove();
 	element.tabs( "refresh" );
-	tabs_state( element );
+	state( element );
 	equal( element.tabs( "option", "active" ), false, "no active tab" );
 
 	// add tabs
@@ -115,34 +118,34 @@ test( "refresh", function() {
 		.append( "<div id='newTab4'>new 4</div>" )
 		.append( "<div id='newTab5'>new 5</div>" );
 	element.tabs( "refresh" );
-	tabs_state( element, 0, 0, 0, 0 );
-	tabs_disabled( element, [ 0 ] );
+	state( element, 0, 0, 0, 0 );
+	disabled( element, [ 0 ] );
 
 	// activate third tab
 	element.tabs( "option", "active", 2 );
-	tabs_state( element, 0, 0, 1, 0 );
-	tabs_disabled( element, [ 0 ] );
+	state( element, 0, 0, 1, 0 );
+	disabled( element, [ 0 ] );
 
 	// remove fourth tab, third tab should stay active
 	element.find( ".ui-tabs-nav li" ).eq( 3 ).remove();
 	element.find( ".ui-tabs-panel" ).eq( 3 ).remove();
 	element.tabs( "refresh" );
-	tabs_state( element, 0, 0, 1 );
-	tabs_disabled( element, [ 0 ] );
+	state( element, 0, 0, 1 );
+	disabled( element, [ 0 ] );
 
 	// remove third (active) tab, second tab should become active
 	element.find( ".ui-tabs-nav li" ).eq( 2 ).remove();
 	element.find( ".ui-tabs-panel" ).eq( 2 ).remove();
 	element.tabs( "refresh" );
-	tabs_state( element, 0, 1 );
-	tabs_disabled( element, [ 0 ] );
+	state( element, 0, 1 );
+	disabled( element, [ 0 ] );
 
 	// remove first tab, previously active tab (now first) should stay active
 	element.find( ".ui-tabs-nav li" ).eq( 0 ).remove();
 	element.find( ".ui-tabs-panel" ).eq( 0 ).remove();
 	element.tabs( "refresh" );
-	tabs_state( element, 1 );
-	tabs_disabled( element, false );
+	state( element, 1 );
+	disabled( element, false );
 });
 
 asyncTest( "load", function() {
@@ -162,14 +165,13 @@ asyncTest( "load", function() {
 		strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
 		equal( ui.panel.size(), 1, "panel size" );
 		strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
-		tabs_state( element, 1, 0, 0, 0, 0 );
+		state( element, 1, 0, 0, 0, 0 );
 	});
 	element.one( "tabsload", function( event, ui ) {
 		// TODO: remove wrapping in 2.0
 		var uiTab = $( ui.tab ),
-			uiPanel = $( ui.panel );
-
-		var tab = element.find( ".ui-tabs-nav a" ).eq( 3 ),
+			uiPanel = $( ui.panel ),
+			tab = element.find( ".ui-tabs-nav a" ).eq( 3 ),
 			panelId = tab.attr( "aria-controls" ),
 			panel = $( "#" + panelId );
 
@@ -179,11 +181,11 @@ asyncTest( "load", function() {
 		equal( uiPanel.size(), 1, "panel size" );
 		strictEqual( uiPanel[ 0 ], panel[ 0 ], "panel" );
 		equal( uiPanel.find( "p" ).length, 1, "panel html" );
-		tabs_state( element, 1, 0, 0, 0, 0 );
+		state( element, 1, 0, 0, 0, 0 );
 		setTimeout( tabsload1, 100 );
 	});
 	element.tabs( "load", 3 );
-	tabs_state( element, 1, 0, 0, 0, 0 );
+	state( element, 1, 0, 0, 0, 0 );
 
 	function tabsload1() {
 		// no need to test details of event (tested in events tests)
@@ -195,7 +197,7 @@ asyncTest( "load", function() {
 			setTimeout( tabsload2, 100 );
 		});
 		element.tabs( "option", "active", 3 );
-		tabs_state( element, 0, 0, 0, 1, 0 );
+		state( element, 0, 0, 0, 1, 0 );
 	}
 
 	function tabsload2() {
@@ -210,14 +212,13 @@ asyncTest( "load", function() {
 			strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
 			equal( ui.panel.size(), 1, "panel size" );
 			strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
-			tabs_state( element, 0, 0, 0, 1, 0 );
+			state( element, 0, 0, 0, 1, 0 );
 		});
 		element.one( "tabsload", function( event, ui ) {
 			// TODO: remove wrapping in 2.0
 			var uiTab = $( ui.tab ),
-				uiPanel = $( ui.panel );
-
-			var tab = element.find( ".ui-tabs-nav a" ).eq( 3 ),
+				uiPanel = $( ui.panel ),
+				tab = element.find( ".ui-tabs-nav a" ).eq( 3 ),
 				panelId = tab.attr( "aria-controls" ),
 				panel = $( "#" + panelId );
 
@@ -226,11 +227,11 @@ asyncTest( "load", function() {
 			strictEqual( uiTab[ 0 ], tab[ 0 ], "tab" );
 			equal( uiPanel.size(), 1, "panel size" );
 			strictEqual( uiPanel[ 0 ], panel[ 0 ], "panel" );
-			tabs_state( element, 0, 0, 0, 1, 0 );
+			state( element, 0, 0, 0, 1, 0 );
 			start();
 		});
 		element.tabs( "load", 3 );
-		tabs_state( element, 0, 0, 0, 1, 0 );
+		state( element, 0, 0, 0, 1, 0 );
 	}
 });
 
diff --git a/tests/unit/tabs/tabs_options.js b/tests/unit/tabs/tabs_options.js
index e1ebf5efa..40d4ceaa7 100644
--- a/tests/unit/tabs/tabs_options.js
+++ b/tests/unit/tabs/tabs_options.js
@@ -1,5 +1,8 @@
 (function( $ ) {
 
+var disabled = TestHelpers.tabs.disabled,
+	state = TestHelpers.tabs.state;
+
 module( "tabs: options" );
 
 test( "{ active: default }", function() {
@@ -7,13 +10,13 @@ test( "{ active: default }", function() {
 
 	var element = $( "#tabs1" ).tabs();
 	equal( element.tabs( "option", "active" ), 0, "should be 0 by default" );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	element.tabs( "destroy" );
 
 	location.hash = "#fragment-3";
 	element = $( "#tabs1" ).tabs();
 	equal( element.tabs( "option", "active" ), 2, "should be 2 based on URL" );
-	tabs_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 	element.tabs( "destroy" );
 	location.hash = "#";
 });
@@ -25,19 +28,19 @@ test( "{ active: false }", function() {
 		active: false,
 		collapsible: true
 	});
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 	equal( element.find( ".ui-tabs-nav .ui-state-active" ).size(), 0, "no tabs selected" );
 	strictEqual( element.tabs( "option", "active" ), false );
 
 	element.tabs( "option", "collapsible", false );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	equal( element.tabs( "option", "active" ), 0 );
 
 	element.tabs( "destroy" );
 	element.tabs({
 		active: false
 	});
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 	strictEqual( element.tabs( "option", "active" ), 0 );
 });
 
@@ -48,19 +51,19 @@ test( "{ active: Number }", function() {
 		active: 2
 	});
 	equal( element.tabs( "option", "active" ), 2 );
-	tabs_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 
 	element.tabs( "option", "active", 0 );
 	equal( element.tabs( "option", "active" ), 0 );
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	element.find( ".ui-tabs-nav a" ).eq( 1 ).click();
 	equal( element.tabs( "option", "active" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.tabs( "option", "active", 10 );
 	equal( element.tabs( "option", "active" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 if ( $.uiBackCompat === false ) {
@@ -69,19 +72,19 @@ if ( $.uiBackCompat === false ) {
 			active: -1
 		});
 		equal( element.tabs( "option", "active" ), 2 );
-		tabs_state( element, 0, 0, 1 );
+		state( element, 0, 0, 1 );
 
 		element.tabs( "option", "active", -2 );
 		equal( element.tabs( "option", "active" ), 1 );
-		tabs_state( element, 0, 1, 0 );
+		state( element, 0, 1, 0 );
 
 		element.tabs( "option", "active", -10 );
 		equal( element.tabs( "option", "active" ), 1 );
-		tabs_state( element, 0, 1, 0 );
+		state( element, 0, 1, 0 );
 
 		element.tabs( "option", "active", -3 );
 		equal( element.tabs( "option", "active" ), 0 );
-		tabs_state( element, 1, 0, 0 );
+		state( element, 1, 0, 0 );
 	});
 }
 
@@ -91,9 +94,9 @@ test( "active - mismatched tab/panel order", function() {
 	location.hash = "#tabs7-2";
 	var element = $( "#tabs7" ).tabs();
 	equal( element.tabs( "option", "active" ), 1, "should be 1 based on URL" );
-	tabs_state( element, 0, 1 );
+	state( element, 0, 1 );
 	element.tabs( "option", "active", 0 );
-	tabs_state( element, 1, 0 );
+	state( element, 1, 0 );
 	location.hash = "#";
 });
 
@@ -105,11 +108,11 @@ test( "{ collapsible: false }", function() {
 	});
 	element.tabs( "option", "active", false );
 	equal( element.tabs( "option", "active" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.find( ".ui-state-active a" ).eq( 1 ).click();
 	equal( element.tabs( "option", "active" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 test( "{ collapsible: true }", function() {
@@ -122,15 +125,15 @@ test( "{ collapsible: true }", function() {
 
 	element.tabs( "option", "active", false );
 	equal( element.tabs( "option", "active" ), false );
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 
 	element.tabs( "option", "active", 1 );
 	equal( element.tabs( "option", "active" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.find( ".ui-state-active a" ).click();
 	equal( element.tabs( "option", "active" ), false );
-	tabs_state( element, 0, 0, 0 );
+	state( element, 0, 0, 0 );
 });
 
 test( "disabled", function() {
@@ -138,23 +141,23 @@ test( "disabled", function() {
 
 	// fully enabled by default
 	var element = $( "#tabs1" ).tabs();
-	tabs_disabled( element, false );
+	disabled( element, false );
 
 	// disable single tab
 	element.tabs( "option", "disabled", [ 1 ] );
-	tabs_disabled( element, [ 1 ] );
+	disabled( element, [ 1 ] );
 
 	// disabled active tab
 	element.tabs( "option", "disabled", [ 0, 1 ] );
-	tabs_disabled( element, [ 0, 1 ] );
+	disabled( element, [ 0, 1 ] );
 
 	// disable all tabs
 	element.tabs( "option", "disabled", [ 0, 1, 2 ] );
-	tabs_disabled( element, true );
+	disabled( element, true );
 
 	// enable all tabs
 	element.tabs( "option", "disabled", [] );
-	tabs_disabled( element, false );
+	disabled( element, false );
 });
 
 test( "{ event: null }", function() {
@@ -163,16 +166,16 @@ test( "{ event: null }", function() {
 	var element = $( "#tabs1" ).tabs({
 		event: null
 	});
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	element.tabs( "option", "active", 1 );
 	equal( element.tabs( "option", "active" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	// ensure default click handler isn't bound
 	element.find( ".ui-tabs-nav a" ).eq( 2 ).click();
 	equal( element.tabs( "option", "active" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 test( "{ event: custom }", function() {
@@ -181,31 +184,31 @@ test( "{ event: custom }", function() {
 	var element = $( "#tabs1" ).tabs({
 		event: "custom1 custom2"
 	});
-	tabs_state( element, 1, 0, 0 );
+	state( element, 1, 0, 0 );
 
 	element.find( ".ui-tabs-nav a" ).eq( 1 ).trigger( "custom1" );
 	equal( element.tabs( "option", "active" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	// ensure default click handler isn't bound
 	element.find( ".ui-tabs-nav a" ).eq( 2 ).trigger( "click" );
 	equal( element.tabs( "option", "active" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 
 	element.find( ".ui-tabs-nav a" ).eq( 2 ).trigger( "custom2" );
 	equal( element.tabs( "option", "active" ), 2 );
-	tabs_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 
 	element.tabs( "option", "event", "custom3" );
 
 	// ensure old event handlers are unbound
 	element.find( ".ui-tabs-nav a" ).eq( 1 ).trigger( "custom1" );
 	equal( element.tabs( "option", "active" ), 2 );
-	tabs_state( element, 0, 0, 1 );
+	state( element, 0, 0, 1 );
 
 	element.find( ".ui-tabs-nav a" ).eq( 1 ).trigger( "custom3" );
 	equal( element.tabs( "option", "active" ), 1 );
-	tabs_state( element, 0, 1, 0 );
+	state( element, 0, 1, 0 );
 });
 
 // TODO: add animation tests
diff --git a/tests/unit/tabs/tabs_test_helpers.js b/tests/unit/tabs/tabs_test_helpers.js
new file mode 100644
index 000000000..9f592c074
--- /dev/null
+++ b/tests/unit/tabs/tabs_test_helpers.js
@@ -0,0 +1,61 @@
+TestHelpers.tabs = {
+	disabled: function( tabs, state ) {
+		var expected, actual,
+			internalState = tabs.tabs( "option", "disabled" );
+
+		if ( internalState === false ) {
+			internalState = [];
+		}
+		if ( internalState === true ) {
+			internalState = $.map( new Array( tabs.find( ".ui-tabs-nav li" ).length ), function( _, index ) {
+				return index;
+			});
+		}
+
+		expected = $.map( new Array( tabs.find ( ".ui-tabs-nav li" ).length ), function( _, index ) {
+			if ( typeof state === "boolean" ) {
+				return state ? 1 : 0;
+			} else {
+				return $.inArray( index, state ) !== -1 ? 1 : 0;
+			}
+		});
+
+		actual = tabs.find( ".ui-tabs-nav li" ).map(function( index ) {
+			var tab = $( this ),
+				tabIsDisabled = tab.hasClass( "ui-state-disabled" );
+
+			if ( tabIsDisabled && $.inArray( index, internalState ) !== -1 ) {
+				return 1;
+			}
+			if ( !tabIsDisabled && $.inArray( index, internalState ) === -1 ) {
+				return 0;
+			}
+			// mixed state - invalid
+			return -1;
+		}).get();
+
+		deepEqual( tabs.tabs( "option", "disabled" ), state );
+		deepEqual( actual, expected );
+	},
+
+	state: function( tabs ) {
+		var expected = $.makeArray( arguments ).slice( 1 ),
+			actual = tabs.find( ".ui-tabs-nav li" ).map(function() {
+				var tab = $( this ),
+					panel = $( $.ui.tabs.prototype._sanitizeSelector(
+						"#" + tab.find( "a" ).attr( "aria-controls" ) ) ),
+					tabIsActive = tab.hasClass( "ui-state-active" ),
+					panelIsActive = panel.css( "display" ) !== "none";
+
+				if ( tabIsActive && panelIsActive ) {
+					return 1;
+				}
+				if ( !tabIsActive && !panelIsActive ) {
+					return 0;
+				}
+				return -1; // mixed state - invalid
+			}).get();
+		deepEqual( actual, expected );
+	}
+};
+
diff --git a/tests/unit/testsuite.js b/tests/unit/testsuite.js
index d37e27f7b..a877e38af 100644
--- a/tests/unit/testsuite.js
+++ b/tests/unit/testsuite.js
@@ -1,5 +1,7 @@
 (function() {
 
+window.TestHelpers = {};
+
 function testWidgetDefaults( widget, defaults ) {
 	var pluginDefaults = $.ui[ widget ].prototype.options;
 
@@ -54,7 +56,7 @@ function testBasicUsage( widget ) {
 	});
 }
 
-window.commonWidgetTests = function( widget, settings ) {
+TestHelpers.commonWidgetTests = function( widget, settings ) {
 	module( widget + ": common widget" );
 
 	testWidgetDefaults( widget, settings.defaults );
@@ -63,7 +65,7 @@ window.commonWidgetTests = function( widget, settings ) {
 	test( "version", function() {
 		ok( "version" in $.ui[ widget ].prototype, "version property exists" );
 	});
-}
+};
 
 /*
  * Experimental assertion for comparing DOM objects.
@@ -72,20 +74,22 @@ window.commonWidgetTests = function( widget, settings ) {
  * Then compares the result using deepEqual.
  */
 window.domEqual = function( selector, modifier, message ) {
-	var attributes = ["class", "role", "id", "tabIndex", "aria-activedescendant"];
+	var expected, actual,
+		attributes = ["class", "role", "id", "tabIndex", "aria-activedescendant"];
 
 	function extract(value) {
 		if (!value || !value.length) {
 			QUnit.push( false, actual, expected, "domEqual failed, can't extract " + selector + ", message was: " + message );
 			return;
 		}
-		var result = {};
+		var children,
+			result = {};
 		result.nodeName = value[0].nodeName;
 		$.each(attributes, function(index, attr) {
 			result[attr] = value.prop(attr);
 		});
 		result.children = [];
-		var children = value.children();
+		children = value.children();
 		if (children.length) {
 			children.each(function() {
 				result.children.push(extract($(this)));
@@ -95,11 +99,11 @@ window.domEqual = function( selector, modifier, message ) {
 		}
 		return result;
 	}
-	var expected = extract($(selector));
-	modifier($(selector));
+	expected = extract( $( selector ) );
+	modifier( $( selector ) );
 
-	var actual = extract($(selector));
+	actual = extract( $( selector ) );
 	QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
-}
+};
 
 }());
diff --git a/tests/unit/tooltip/tooltip_defaults.js b/tests/unit/tooltip/tooltip_defaults.js
index b8b41bf47..d12ee9519 100644
--- a/tests/unit/tooltip/tooltip_defaults.js
+++ b/tests/unit/tooltip/tooltip_defaults.js
@@ -1,4 +1,4 @@
-commonWidgetTests( "tooltip", {
+TestHelpers.commonWidgetTests( "tooltip", {
 	defaults: {
 		content: function() {},
 		disabled: false,
diff --git a/tests/unit/tooltip/tooltip_methods.js b/tests/unit/tooltip/tooltip_methods.js
index 3e8256c50..eaab1c0d1 100644
--- a/tests/unit/tooltip/tooltip_methods.js
+++ b/tests/unit/tooltip/tooltip_methods.js
@@ -16,11 +16,12 @@ test( "destroy", function() {
 test( "open/close", function() {
 	expect( 3 );
 	$.fx.off = true;
-	var element = $( "#tooltipped1" ).tooltip();
+	var tooltip,
+		element = $( "#tooltipped1" ).tooltip();
 	equal( $( ".ui-tooltip" ).length, 0, "no tooltip on init" );
 
 	element.tooltip( "open" );
-	var tooltip = $( "#" + element.attr( "aria-describedby" ) );
+	tooltip = $( "#" + element.attr( "aria-describedby" ) );
 	ok( tooltip.is( ":visible" ) );
 
 	element.tooltip( "close" );
@@ -31,11 +32,12 @@ test( "open/close", function() {
 test( "enable/disable", function() {
 	expect( 7 );
 	$.fx.off = true;
-	var element = $( "#tooltipped1" ).tooltip();
+	var tooltip,
+		element = $( "#tooltipped1" ).tooltip();
 	equal( $( ".ui-tooltip" ).length, 0, "no tooltip on init" );
 
 	element.tooltip( "open" );
-	var tooltip = $( "#" + element.attr( "aria-describedby" ) );
+	tooltip = $( "#" + element.attr( "aria-describedby" ) );
 	ok( tooltip.is( ":visible" ) );
 
 	element.tooltip( "disable" );
diff --git a/tests/unit/tooltip/tooltip_options.js b/tests/unit/tooltip/tooltip_options.js
index 42529e087..4f994f8de 100644
--- a/tests/unit/tooltip/tooltip_options.js
+++ b/tests/unit/tooltip/tooltip_options.js
@@ -45,11 +45,12 @@ asyncTest( "content: sync + async callback", function() {
 
 test( "items", function() {
 	expect( 2 );
-	var element = $( "#qunit-fixture" ).tooltip({
-		items: "#fixture-span"
-	});
+	var event,
+		element = $( "#qunit-fixture" ).tooltip({
+			items: "#fixture-span"
+		});
 
-	var event = $.Event( "mouseenter" );
+	event = $.Event( "mouseenter" );
 	event.target = $( "#fixture-span" )[ 0 ];
 	element.tooltip( "open", event );
 	deepEqual( $( "#" + $( "#fixture-span" ).attr( "aria-describedby" ) ).text(), "title-text" );
@@ -63,7 +64,7 @@ test( "items", function() {
 });
 
 test( "tooltipClass", function() {
-	expect( 1 )
+	expect( 1 );
 	var element = $( "#tooltipped1" ).tooltip({
 		tooltipClass: "custom"
 	}).tooltip( "open" );
diff --git a/tests/unit/widget/widget_core.js b/tests/unit/widget/widget_core.js
index e104d4ae9..38495e282 100644
--- a/tests/unit/widget/widget_core.js
+++ b/tests/unit/widget/widget_core.js
@@ -84,7 +84,8 @@ test( "custom selector expression", function() {
 test( "jQuery usage", function() {
 	expect( 16 );
 
-	var shouldCreate = false;
+	var elem, instance, ret, bcInstance,
+		shouldCreate = false;
 
 	$.widget( "ui.testWidget", {
 		getterSetterVal: 5,
@@ -113,22 +114,22 @@ test( "jQuery usage", function() {
 	});
 
 	shouldCreate = true;
-	var elem = $( "<div>" )
+	elem = $( "<div>" )
 		.bind( "testwidgetcreate", function() {
 			ok( shouldCreate, "create event triggered on instantiation" );
 		})
 		.testWidget();
 	shouldCreate = false;
 
-	var instance = elem.data( "ui-testWidget" );
+	instance = elem.data( "ui-testWidget" );
 	equal( typeof instance, "object", "instance stored in .data(pluginName)" );
 	equal( instance.element[0], elem[0], "element stored on widget" );
-	var ret = elem.testWidget( "methodWithParams", "value1", "value2" );
+	ret = elem.testWidget( "methodWithParams", "value1", "value2" );
 	equal( ret, elem, "jQuery object returned from method call" );
 
 	// 1.9 BC for #7810
 	// TODO remove
-	var bcInstance = elem.data("testWidget");
+	bcInstance = elem.data("testWidget");
 	equal( typeof bcInstance, "object", "instance stored in .data(pluginName)" );
 	equal( bcInstance.element[0], elem[0], "element stored on widget" );
 
@@ -148,7 +149,8 @@ test( "jQuery usage", function() {
 test( "direct usage", function() {
 	expect( 9 );
 
-	var shouldCreate = false;
+	var elem, instance, ret,
+		shouldCreate = false;
 
 	$.widget( "ui.testWidget", {
 		getterSetterVal: 5,
@@ -171,17 +173,17 @@ test( "direct usage", function() {
 		}
 	});
 
-	var elem = $( "<div>" )[ 0 ];
+	elem = $( "<div>" )[ 0 ];
 
 	shouldCreate = true;
-	var instance = new $.ui.testWidget( {}, elem );
+	instance = new $.ui.testWidget( {}, elem );
 	shouldCreate = false;
 
 	equal( $( elem ).data( "ui-testWidget" ), instance,
 		"instance stored in .data(pluginName)" );
 	equal( instance.element[ 0 ], elem, "element stored on widget" );
 
-	var ret = instance.methodWithParams( "value1", "value2" );
+	ret = instance.methodWithParams( "value1", "value2" );
 	equal( ret, instance, "plugin returned from method call" );
 
 	ret = instance.getterSetterMethod();
@@ -439,11 +441,12 @@ test( ".option() - getter", function() {
 		_create: function() {}
 	});
 
-	var div = $( "<div>" ).testWidget({
-		foo: "bar",
-		baz: 5,
-		qux: [ "quux", "quuux" ]
-	});
+	var options,
+		div = $( "<div>" ).testWidget({
+			foo: "bar",
+			baz: 5,
+			qux: [ "quux", "quuux" ]
+		});
 
 	deepEqual( div.testWidget( "option", "x" ), null, "non-existent option" );
 	deepEqual( div.testWidget( "option", "foo"), "bar", "single option - string" );
@@ -451,7 +454,7 @@ test( ".option() - getter", function() {
 	deepEqual( div.testWidget( "option", "qux"), [ "quux", "quuux" ],
 		"single option - array" );
 
-	var options = div.testWidget( "option" );
+	options = div.testWidget( "option" );
 	deepEqual( options, {
 		create: null,
 		disabled: false,
@@ -483,14 +486,15 @@ test( ".option() - deep option getter", function() {
 });
 
 test( ".option() - delegate to ._setOptions()", function() {
-	var calls = [];
+	var div,
+		calls = [];
 	$.widget( "ui.testWidget", {
 		_create: function() {},
 		_setOptions: function( options ) {
 			calls.push( options );
 		}
 	});
-	var div = $( "<div>" ).testWidget();
+	div = $( "<div>" ).testWidget();
 
 	calls = [];
 	div.testWidget( "option", "foo", "bar" );
@@ -506,7 +510,8 @@ test( ".option() - delegate to ._setOptions()", function() {
 });
 
 test( ".option() - delegate to ._setOption()", function() {
-	var calls = [];
+	var div,
+		calls = [];
 	$.widget( "ui.testWidget", {
 		_create: function() {},
 		_setOption: function( key, val ) {
@@ -516,7 +521,7 @@ test( ".option() - delegate to ._setOption()", function() {
 			});
 		}
 	});
-	var div = $( "<div>" ).testWidget();
+	div = $( "<div>" ).testWidget();
 
 	calls = [];
 	div.testWidget( "option", "foo", "bar" );
@@ -603,7 +608,7 @@ test( ".widget() - overriden", function() {
 
 test( "._bind() to element (default)", function() {
 	expect( 12 );
-	var that;
+	var that, widget;
 	$.widget( "ui.testWidget", {
 		_create: function() {
 			that = this;
@@ -623,7 +628,7 @@ test( "._bind() to element (default)", function() {
 			equal( "keydown", event.type );
 		}
 	});
-	var widget = $( "<div></div>" )
+	widget = $( "<div></div>" )
 		.testWidget()
 		.trigger( "keyup" )
 		.trigger( "keydown" );
@@ -643,7 +648,7 @@ test( "._bind() to element (default)", function() {
 
 test( "._bind() to descendent", function() {
 	expect( 12 );
-	var that;
+	var that, widget, descendant;
 	$.widget( "ui.testWidget", {
 		_create: function() {
 			that = this;
@@ -664,28 +669,28 @@ test( "._bind() to descendent", function() {
 		}
 	});
 	// trigger events on both widget and descendent to ensure that only descendent receives them
-	var widget = $( "<div><p><strong>hello</strong> world</p></div>" )
+	widget = $( "<div><p><strong>hello</strong> world</p></div>" )
 		.testWidget()
 		.trigger( "keyup" )
 		.trigger( "keydown" );
-	var descendent = widget.find( "strong" )
+	descendant = widget.find( "strong" )
 		.trigger( "keyup" )
 		.trigger( "keydown" );
 	widget
 		.testWidget( "disable" )
 		.trigger( "keyup" )
 		.trigger( "keydown" );
-	descendent
+	descendant
 		.trigger( "keyup" )
 		.trigger( "keydown" );
 	widget
 		.testWidget( "enable" )
 		.trigger( "keyup" )
 		.trigger( "keydown" );
-	descendent
+	descendant
 		.trigger( "keyup" )
 		.trigger( "keydown" );
-	descendent
+	descendant
 		.addClass( "ui-state-disabled" )
 		.trigger( "keyup" )
 		.trigger( "keydown" );
@@ -693,7 +698,7 @@ test( "._bind() to descendent", function() {
 		.testWidget( "destroy" )
 		.trigger( "keyup" )
 		.trigger( "keydown" );
-	descendent
+	descendant
 		.trigger( "keyup" )
 		.trigger( "keydown" );
 });
@@ -942,10 +947,10 @@ test( "._trigger() - array as ui", function() {
 						qux: 5,
 						quux: 20
 					}
+				},
+				extra = {
+					bar: 5
 				};
-			var extra = {
-				bar: 5
-			};
 			this._trigger( "foo", null, [ ui, extra ] );
 		}
 	});
@@ -983,8 +988,7 @@ test( "._trigger() - instance as element", function() {
 	$.widget( "ui.testWidget", {
 		defaultElement: null,
 		testEvent: function() {
-			var ui = { foo: "bar" };
-			this._trigger( "foo", null, ui );
+			this._trigger( "foo", null, { foo: "bar" } );
 		}
 	});
 	var instance = $.ui.testWidget({
diff --git a/tests/unit/widget/widget_extend.js b/tests/unit/widget/widget_extend.js
index 90e686e18..ae9855929 100644
--- a/tests/unit/widget/widget_extend.js
+++ b/tests/unit/widget/widget_extend.js
@@ -1,7 +1,9 @@
 test( "$.widget.extend()", function() {
 	expect( 26 );
 
-	var settings = { xnumber1: 5, xnumber2: 7, xstring1: "peter", xstring2: "pan" },
+	var ret, empty, optionsWithLength, optionsWithDate, myKlass, customObject, optionsWithCustomObject, nullUndef,
+		target, recursive, obj, input, output,
+		settings = { xnumber1: 5, xnumber2: 7, xstring1: "peter", xstring2: "pan" },
 		options = { xnumber2: 1, xstring2: "x", xxx: "newstring" },
 		optionsCopy = { xnumber2: 1, xstring2: "x", xxx: "newstring" },
 		merged = { xnumber1: 5, xnumber2: 1, xstring1: "peter", xstring2: "x", xxx: "newstring" },
@@ -11,7 +13,13 @@ test( "$.widget.extend()", function() {
 		deepmerged = { foo: { bar: true, baz: true }, foo2: document },
 		arr = [1, 2, 3],
 		nestedarray = { arr: arr },
-		ret;
+		defaults = { xnumber1: 5, xnumber2: 7, xstring1: "peter", xstring2: "pan" },
+		defaultsCopy = { xnumber1: 5, xnumber2: 7, xstring1: "peter", xstring2: "pan" },
+		options1 = { xnumber2: 1, xstring2: "x" },
+		options1Copy = { xnumber2: 1, xstring2: "x" },
+		options2 = { xstring2: "xx", xxx: "newstringx" },
+		options2Copy = { xstring2: "xx", xxx: "newstringx" },
+		merged2 = { xnumber1: 5, xnumber2: 1, xstring1: "peter", xstring2: "xx", xxx: "newstringx" };
 
 	$.widget.extend( settings, options );
 	deepEqual( settings, merged, "Check if extended: settings must be extended" );
@@ -25,19 +33,19 @@ test( "$.widget.extend()", function() {
 	strictEqual( $.widget.extend({}, nestedarray).arr, arr, "Don't clone arrays" );
 	ok( $.isPlainObject( $.widget.extend({ arr: arr }, { arr: {} }).arr ), "Cloned object heve to be an plain object" );
 
-	var empty = {};
-	var optionsWithLength = { foo: { length: -1 } };
+	empty = {};
+	optionsWithLength = { foo: { length: -1 } };
 	$.widget.extend( empty, optionsWithLength );
 	deepEqual( empty.foo, optionsWithLength.foo, "The length property must copy correctly" );
 
 	empty = {};
-	var optionsWithDate = { foo: { date: new Date } };
+	optionsWithDate = { foo: { date: new Date() } };
 	$.widget.extend( empty, optionsWithDate );
 	deepEqual( empty.foo, optionsWithDate.foo, "Dates copy correctly" );
 
-	var myKlass = function() {};
-	var customObject = new myKlass();
-	var optionsWithCustomObject = { foo: { date: customObject } };
+	myKlass = function() {};
+	customObject = new myKlass();
+	optionsWithCustomObject = { foo: { date: customObject } };
 	empty = {};
 	$.widget.extend( empty, optionsWithCustomObject );
 	strictEqual( empty.foo.date, customObject, "Custom objects copy correctly (no methods)" );
@@ -48,10 +56,9 @@ test( "$.widget.extend()", function() {
 	$.widget.extend( empty, optionsWithCustomObject );
 	strictEqual( empty.foo.date, customObject, "Custom objects copy correctly" );
 
-	ret = $.widget.extend({ foo: 4 }, { foo: new Number(5) } );
+	ret = $.widget.extend({ foo: 4 }, { foo: Number(5) } );
 	equal( ret.foo, 5, "Wrapped numbers copy correctly" );
 
-	var nullUndef;
 	nullUndef = $.widget.extend( {}, options, { xnumber2: null } );
 	strictEqual( nullUndef.xnumber2, null, "Check to make sure null values are copied");
 
@@ -61,8 +68,8 @@ test( "$.widget.extend()", function() {
 	nullUndef = $.widget.extend( {}, options, { xnumber0: null } );
 	strictEqual( nullUndef.xnumber0, null, "Check to make sure null values are inserted");
 
-	var target = {};
-	var recursive = { foo:target, bar:5 };
+	target = {};
+	recursive = { foo:target, bar:5 };
 	$.widget.extend( target, recursive );
 	deepEqual( target, { foo: {}, bar: 5 }, "Check to make sure a recursive obj doesn't go never-ending loop by not copying it over" );
 
@@ -75,28 +82,20 @@ test( "$.widget.extend()", function() {
 	ret = $.widget.extend( { foo:"bar" }, { foo:null } );
 	strictEqual( typeof ret.foo, "object", "Make sure a null value doesn't crash with deep extend, for #1908" );
 
-	var obj = { foo:null };
+	obj = { foo:null };
 	$.widget.extend( obj, { foo:"notnull" } );
 	equal( obj.foo, "notnull", "Make sure a null value can be overwritten" );
 
-	var defaults = { xnumber1: 5, xnumber2: 7, xstring1: "peter", xstring2: "pan" },
-		defaultsCopy = { xnumber1: 5, xnumber2: 7, xstring1: "peter", xstring2: "pan" },
-		options1 = { xnumber2: 1, xstring2: "x" },
-		options1Copy = { xnumber2: 1, xstring2: "x" },
-		options2 = { xstring2: "xx", xxx: "newstringx" },
-		options2Copy = { xstring2: "xx", xxx: "newstringx" },
-		merged2 = { xnumber1: 5, xnumber2: 1, xstring1: "peter", xstring2: "xx", xxx: "newstringx" };
-
-	var settings = $.widget.extend( {}, defaults, options1, options2 );
+	settings = $.widget.extend( {}, defaults, options1, options2 );
 	deepEqual( settings, merged2, "Check if extended: settings must be extended" );
 	deepEqual( defaults, defaultsCopy, "Check if not modified: options1 must not be modified" );
 	deepEqual( options1, options1Copy, "Check if not modified: options1 must not be modified" );
 	deepEqual( options2, options2Copy, "Check if not modified: options2 must not be modified" );
 
-	var input = {
+	input = {
 		key: [ 1, 2, 3 ]
 	};
-	var output = $.widget.extend( {}, input );
+	output = $.widget.extend( {}, input );
 	deepEqual( input, output, "don't clone arrays" );
 	input.key[0] = 10;
 	deepEqual( input, output, "don't clone arrays" );
diff --git a/tests/visual/menu/menu.html b/tests/visual/menu/menu.html
index d67083663..e62e18ae5 100644
--- a/tests/visual/menu/menu.html
+++ b/tests/visual/menu/menu.html
@@ -118,7 +118,7 @@
 	<li class="ui-state-disabled"><a href="#"><span class="ui-icon ui-icon-scissors"></span>Ada</a></li>
 	<li><a href="#">Adamsville</a></li>
 	<li><a href="#"><span class="ui-icon ui-icon-wrench"></span>Addyston</a></li>
-	<li>
+	<li class="ui-state-disabled">
 		<a href="#">Delphi</a>
 		<ul>
 			<li><a href="#">Ada</a></li>
diff --git a/themes/base/jquery.ui.menu.css b/themes/base/jquery.ui.menu.css
index d53bdc6e0..b96d439ab 100644
--- a/themes/base/jquery.ui.menu.css
+++ b/themes/base/jquery.ui.menu.css
@@ -10,7 +10,7 @@
 .ui-menu { list-style:none; padding: 2px; margin: 0; display:block; outline: none; }
 .ui-menu .ui-menu { margin-top: -3px; position: absolute; }
 .ui-menu .ui-menu-item { margin: 0; padding: 0; zoom: 1; width: 100%; }
-.ui-menu .ui-menu-divider { margin: 5px -2px 5px -2px; height: 0; font-size: 0; line-height: 0; }
+.ui-menu .ui-menu-divider { margin: 5px -2px 5px -2px; height: 0; font-size: 0; line-height: 0; border-width: 1px 0 0 0; }
 .ui-menu .ui-menu-item a { text-decoration: none; display: block; padding: 2px .4em; line-height: 1.5; zoom: 1; font-weight: normal; }
 .ui-menu .ui-menu-item a.ui-state-focus,
 .ui-menu .ui-menu-item a.ui-state-active { font-weight: normal; margin: -1px; }
diff --git a/themes/base/jquery.ui.resizable.css b/themes/base/jquery.ui.resizable.css
index 0bf680482..0bb688d5b 100644
--- a/themes/base/jquery.ui.resizable.css
+++ b/themes/base/jquery.ui.resizable.css
@@ -8,7 +8,7 @@
  * http://docs.jquery.com/UI/Resizable#theming
  */
 .ui-resizable { position: relative;}
-.ui-resizable-handle { position: absolute;font-size: 0.1px;z-index: 99999; display: block; }
+.ui-resizable-handle { position: absolute;font-size: 0.1px; display: block; }
 .ui-resizable-disabled .ui-resizable-handle, .ui-resizable-autohide .ui-resizable-handle { display: none; }
 .ui-resizable-n { cursor: n-resize; height: 7px; width: 100%; top: -5px; left: 0; }
 .ui-resizable-s { cursor: s-resize; height: 7px; width: 100%; bottom: -5px; left: 0; }
diff --git a/ui/i18n/jquery.ui.datepicker-hi.js b/ui/i18n/jquery.ui.datepicker-hi.js
index d75e98ead..edc530679 100644
--- a/ui/i18n/jquery.ui.datepicker-hi.js
+++ b/ui/i18n/jquery.ui.datepicker-hi.js
@@ -2,19 +2,19 @@
 /* Written by Michael Dawart. */
 jQuery(function($){
 	$.datepicker.regional['hi'] = {
-		closeText: 'होकर',
-		prevText: 'अगला',
-		nextText: 'नेक्स्ट',
+		closeText: 'बंद',
+		prevText: 'पिछला',
+		nextText: 'अगला',
 		currentText: 'आज',
-		monthNames: ['जनवरी ','फरवरी','मार्च','अप्रेल','मै','जून',
-		'जूलाई','अगस्त ','सितम्बर','आक्टोबर','नवम्बर','दिसम्बर'],
-		monthNamesShort: ['जन', 'फर', 'मार्च', 'अप्रेल', 'मै', 'जून',
-		'जूलाई', 'अग', 'सित', 'आक्ट', 'नव', 'िद'],
-		dayNames: ['रविवासर', 'सोमवासर', 'मंगलवासर', 'बुधवासर', 'गुरुवासर', 'शुक्रवासर', 'शनिवासर'],
+		monthNames: ['जनवरी ','फरवरी','मार्च','अप्रेल','मई','जून',
+		'जूलाई','अगस्त ','सितम्बर','अक्टूबर','नवम्बर','दिसम्बर'],
+		monthNamesShort: ['जन', 'फर', 'मार्च', 'अप्रेल', 'मई', 'जून',
+		'जूलाई', 'अग', 'सित', अक्ट', 'नव', 'दि'],
+		dayNames: ['रविवार', 'सोमवार', 'मंगलवार', 'बुधवार', 'गुरुवार', 'शुक्रवार', 'शनिवार'],
 		dayNamesShort: ['रवि', 'सोम', 'मंगल', 'बुध', 'गुरु', 'शुक्र', 'शनि'],
 		dayNamesMin: ['रवि', 'सोम', 'मंगल', 'बुध', 'गुरु', 'शुक्र', 'शनि'],
 		weekHeader: 'हफ्ता',
-		dateFormat: 'mm/dd/yy',
+		dateFormat: 'dd/mm/yy',
 		firstDay: 1,
 		isRTL: false,
 		showMonthAfterYear: false,
diff --git a/ui/jquery.effects.bounce.js b/ui/jquery.effects.bounce.js
index 94d73644e..934fb16ef 100644
--- a/ui/jquery.effects.bounce.js
+++ b/ui/jquery.effects.bounce.js
@@ -13,14 +13,14 @@
 (function( $, undefined ) {
 
 $.effects.effect.bounce = function( o, done ) {
-	var el = $( this ), 
+	var el = $( this ),
 		props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
 
 		// defaults:
 		mode = $.effects.setMode( el, o.mode || "effect" ),
 		hide = mode === "hide",
 		show = mode === "show",
-		direction = o.direction || "up", 
+		direction = o.direction || "up",
 		distance = o.distance,
 		times = o.times || 5,
 
@@ -31,7 +31,7 @@ $.effects.effect.bounce = function( o, done ) {
 
 		// utility:
 		ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
-		motion = ( direction === "up" || direction === "left" ), 
+		motion = ( direction === "up" || direction === "left" ),
 		i,
 		upAnim,
 		downAnim,
@@ -40,13 +40,13 @@ $.effects.effect.bounce = function( o, done ) {
 		queue = el.queue(),
 		queuelen = queue.length;
 
-	// Avoid touching opacity to prevent clearType and PNG issues in IE	
+	// Avoid touching opacity to prevent clearType and PNG issues in IE
 	if ( show || hide ) {
 		props.push( "opacity" );
-	} 
+	}
 
-	$.effects.save( el, props ); 
-	el.show(); 
+	$.effects.save( el, props );
+	el.show();
 	$.effects.createWrapper( el ); // Create Wrapper
 
 	// default distance for the BIGGEST bounce is the outer Distance / 3
@@ -90,7 +90,7 @@ $.effects.effect.bounce = function( o, done ) {
 
 		el.animate( upAnim, speed, easing );
 	}
-	
+
 	el.queue(function() {
 		if ( hide ) {
 			el.hide();
diff --git a/ui/jquery.effects.drop.js b/ui/jquery.effects.drop.js
index 6c72be9e5..ea8d242d5 100644
--- a/ui/jquery.effects.drop.js
+++ b/ui/jquery.effects.drop.js
@@ -14,7 +14,7 @@
 
 $.effects.effect.drop = function( o, done ) {
 
-	var el = $( this ), 
+	var el = $( this ),
 		props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
 		mode = $.effects.setMode( el, o.mode || "hide" ),
 		show = mode === "show",
@@ -27,9 +27,9 @@ $.effects.effect.drop = function( o, done ) {
 		distance;
 
 	// Adjust
-	$.effects.save( el, props ); 
-	el.show(); 
-	$.effects.createWrapper( el ); 
+	$.effects.save( el, props );
+	el.show();
+	$.effects.createWrapper( el );
 
 	distance = o.distance || el[ ref === "top" ? "outerHeight": "outerWidth" ]({ margin: true }) / 2;
 
@@ -40,22 +40,22 @@ $.effects.effect.drop = function( o, done ) {
 	}
 
 	// Animation
-	animation[ ref ] = ( show ? 
-		( motion === "pos" ? "+=" : "-=" ) : 
+	animation[ ref ] = ( show ?
+		( motion === "pos" ? "+=" : "-=" ) :
 		( motion === "pos" ? "-=" : "+=" ) ) +
 		distance;
 
 	// Animate
-	el.animate( animation, { 
-		queue: false, 
-		duration: o.duration, 
-		easing: o.easing, 
+	el.animate( animation, {
+		queue: false,
+		duration: o.duration,
+		easing: o.easing,
 		complete: function() {
 			if ( mode === "hide" ) {
 				el.hide();
 			}
-			$.effects.restore( el, props ); 
-			$.effects.removeWrapper( el ); 
+			$.effects.restore( el, props );
+			$.effects.removeWrapper( el );
 			done();
 		}
 	});
diff --git a/ui/jquery.effects.fade.js b/ui/jquery.effects.fade.js
index 89784bd08..66029b51c 100644
--- a/ui/jquery.effects.fade.js
+++ b/ui/jquery.effects.fade.js
@@ -18,7 +18,7 @@ $.effects.effect.fade = function( o, done ) {
 		hide = mode === "hide";
 
 	el.show();
-	el.animate({ 
+	el.animate({
 		opacity: hide ? 0 : 1
 	}, {
 		queue: false,
diff --git a/ui/jquery.effects.scale.js b/ui/jquery.effects.scale.js
index 83b41d3c2..1eedb44eb 100644
--- a/ui/jquery.effects.scale.js
+++ b/ui/jquery.effects.scale.js
@@ -18,9 +18,9 @@ $.effects.effect.puff = function( o, done ) {
 		hide = mode === "hide",
 		percent = parseInt( o.percent, 10 ) || 150,
 		factor = percent / 100,
-		original = { 
-			height: elem.height(), 
-			width: elem.width() 
+		original = {
+			height: elem.height(),
+			width: elem.width()
 		};
 
 	$.extend( o, {
@@ -51,8 +51,8 @@ $.effects.effect.scale = function( o, done ) {
 			( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
 		direction = o.direction || "both",
 		origin = o.origin,
-		original = { 
-			height: el.height(), 
+		original = {
+			height: el.height(),
 			width: el.width(),
 			outerHeight: el.outerHeight(),
 			outerWidth: el.outerWidth()
@@ -60,7 +60,7 @@ $.effects.effect.scale = function( o, done ) {
 		factor = {
 			y: direction !== "horizontal" ? (percent / 100) : 1,
 			x: direction !== "vertical" ? (percent / 100) : 1
-		}; 
+		};
 
 	// We are going to pass this effect to the size effect:
 	options.effect = "size";
@@ -68,27 +68,27 @@ $.effects.effect.scale = function( o, done ) {
 	options.complete = done;
 
 	// Set default origin and restore for show/hide
-	if ( mode !== "effect" ) { 
+	if ( mode !== "effect" ) {
 		options.origin = origin || ["middle","center"];
 		options.restore = true;
 	}
 
-	options.from = o.from || ( mode === "show" ? { height: 0, width: 0 } : original ); 
+	options.from = o.from || ( mode === "show" ? { height: 0, width: 0 } : original );
 	options.to = {
-		height: original.height * factor.y, 
+		height: original.height * factor.y,
 		width: original.width * factor.x,
-		outerHeight: original.outerHeight * factor.y, 
+		outerHeight: original.outerHeight * factor.y,
 		outerWidth: original.outerWidth * factor.x
-	}; 
+	};
 
 	// Fade option to support puff
 	if ( options.fade ) {
 		if ( mode === "show" ) {
-			options.from.opacity = 0; 
+			options.from.opacity = 0;
 			options.to.opacity = 1;
 		}
 		if ( mode === "hide" ) {
-			options.from.opacity = 1; 
+			options.from.opacity = 1;
 			options.to.opacity = 0;
 		}
 	}
@@ -101,7 +101,7 @@ $.effects.effect.scale = function( o, done ) {
 $.effects.effect.size = function( o, done ) {
 
 	// Create element
-	var el = $( this ), 
+	var el = $( this ),
 		props = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
 
 		// Always restore
@@ -125,7 +125,7 @@ $.effects.effect.size = function( o, done ) {
 		el.show();
 	}
 	original = {
-		height: el.height(), 
+		height: el.height(),
 		width: el.width(),
 		outerHeight: el.outerHeight(),
 		outerWidth: el.outerWidth()
@@ -137,11 +137,11 @@ $.effects.effect.size = function( o, done ) {
 	// Set scaling factor
 	factor = {
 		from: {
-			y: el.from.height / original.height, 
+			y: el.from.height / original.height,
 			x: el.from.width / original.width
 		},
 		to: {
-			y: el.to.height / original.height, 
+			y: el.to.height / original.height,
 			x: el.to.width / original.width
 		}
 	};
@@ -150,14 +150,14 @@ $.effects.effect.size = function( o, done ) {
 	if ( scale === "box" || scale === "both" ) {
 
 		// Vertical props scaling
-		if ( factor.from.y !== factor.to.y ) { 
+		if ( factor.from.y !== factor.to.y ) {
 			props = props.concat( vProps );
 			el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
 			el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
 		}
 
 		// Horizontal props scaling
-		if ( factor.from.x !== factor.to.x ) { 
+		if ( factor.from.x !== factor.to.x ) {
 			props = props.concat( hProps );
 			el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
 			el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
@@ -165,20 +165,20 @@ $.effects.effect.size = function( o, done ) {
 	}
 
 	// Scale the content
-	if ( scale === "content" || scale === "both" ) { 
+	if ( scale === "content" || scale === "both" ) {
 
 		// Vertical props scaling
-		if ( factor.from.y !== factor.to.y ) { 
+		if ( factor.from.y !== factor.to.y ) {
 			props = props.concat( cProps );
 			el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
 			el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
 		}
 	}
 
-	$.effects.save( el, restore ? props : props1 ); 
-	el.show(); 
+	$.effects.save( el, restore ? props : props1 );
+	el.show();
 	$.effects.createWrapper( el );
-	el.css( "overflow", "hidden" ).css( el.from ); 
+	el.css( "overflow", "hidden" ).css( el.from );
 
 	// Adjust
 	if (origin) { // Calculate baseline shifts
@@ -200,8 +200,8 @@ $.effects.effect.size = function( o, done ) {
 
 		el.find( "*[width]" ).each( function(){
 			var child = $( this ),
-				c_original = { 
-					height: child.height(), 
+				c_original = {
+					height: child.height(),
 					width: child.width()
 				};
 			if (restore) {
@@ -209,16 +209,16 @@ $.effects.effect.size = function( o, done ) {
 			}
 
 			child.from = {
-				height: c_original.height * factor.from.y, 
+				height: c_original.height * factor.from.y,
 				width: c_original.width * factor.from.x
 			};
 			child.to = {
-				height: c_original.height * factor.to.y, 
+				height: c_original.height * factor.to.y,
 				width: c_original.width * factor.to.x
 			};
 
 			// Vertical props scaling
-			if ( factor.from.y !== factor.to.y ) { 
+			if ( factor.from.y !== factor.to.y ) {
 				child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
 				child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
 			}
@@ -242,10 +242,10 @@ $.effects.effect.size = function( o, done ) {
 	}
 
 	// Animate
-	el.animate( el.to, { 
-		queue: false, 
-		duration: o.duration, 
-		easing: o.easing, 
+	el.animate( el.to, {
+		queue: false,
+		duration: o.duration,
+		easing: o.easing,
 		complete: function() {
 			if ( el.to.opacity === 0 ) {
 				el.css( "opacity", el.from.opacity );
@@ -277,7 +277,7 @@ $.effects.effect.size = function( o, done ) {
 								return toRef + "px";
 							}
 
-							return val + toRef + "px"; 
+							return val + toRef + "px";
 						});
 					});
 				}
diff --git a/ui/jquery.effects.slide.js b/ui/jquery.effects.slide.js
index 77d540a9c..e57a21264 100644
--- a/ui/jquery.effects.slide.js
+++ b/ui/jquery.effects.slide.js
@@ -29,32 +29,32 @@ $.effects.effect.slide = function( o, done ) {
 	// Adjust
 	$.effects.save( el, props );
 	el.show();
-	distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]({ 
+	distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]({
 		margin: true
 	});
-	
+
 	$.effects.createWrapper( el ).css({
 		overflow: "hidden"
 	});
-	
+
 	if ( show ) {
 		el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
 	}
 
 	// Animation
-	animation[ ref ] = ( show ? 
-		( positiveMotion ? "+=" : "-=") : 
+	animation[ ref ] = ( show ?
+		( positiveMotion ? "+=" : "-=") :
 		( positiveMotion ? "-=" : "+=")) +
 		distance;
 
 	// Animate
-	el.animate( animation, { 
-		queue: false, 
-		duration: o.duration, 
-		easing: o.easing, 
+	el.animate( animation, {
+		queue: false,
+		duration: o.duration,
+		easing: o.easing,
 		complete: function() {
 			if ( mode === "hide" ) {
-				el.hide(); 
+				el.hide();
 			}
 			$.effects.restore( el, props );
 			$.effects.removeWrapper( el );
diff --git a/ui/jquery.ui.dialog.js b/ui/jquery.ui.dialog.js
index 3a9bd5dc6..144cf9725 100644
--- a/ui/jquery.ui.dialog.js
+++ b/ui/jquery.ui.dialog.js
@@ -77,10 +77,10 @@ $.widget("ui.dialog", {
 		// #5742 - .attr() might return a DOMElement
 		if ( typeof this.originalTitle !== "string" ) {
 			this.originalTitle = "";
-		}		
-		this.oldPosition = { 
-			parent: this.element.parent(), 
-			index: this.element.parent().children().index( this.element ) 
+		}
+		this.oldPosition = {
+			parent: this.element.parent(),
+			index: this.element.parent().children().index( this.element )
 		};
 		this.options.title = this.options.title || this.originalTitle;
 		var self = this,
@@ -171,7 +171,7 @@ $.widget("ui.dialog", {
 	},
 
 	_destroy: function() {
-		var self = this, next, 
+		var self = this, next,
 			oldPosition = this.oldPosition;
 
 		if ( self.overlay ) {
@@ -187,13 +187,13 @@ $.widget("ui.dialog", {
 		if ( self.originalTitle ) {
 			self.element.attr( "title", self.originalTitle );
 		}
-		
+
 		next = oldPosition.parent.children().eq( oldPosition.index );
 		if ( next.length ) {
 			next.before( self.element );
 		} else {
 			oldPosition.parent.append( self.element );
-		}		
+		}
 	},
 
 	widget: function() {
diff --git a/ui/jquery.ui.menu.js b/ui/jquery.ui.menu.js
index 6982da3c3..bcefd5822 100644
--- a/ui/jquery.ui.menu.js
+++ b/ui/jquery.ui.menu.js
@@ -13,7 +13,8 @@
  */
 (function($) {
 
-var idIncrement = 0;
+var idIncrement = 0,
+	currentEventTarget = null;
 
 $.widget( "ui.menu", {
 	version: "@VERSION",
@@ -53,7 +54,9 @@ $.widget( "ui.menu", {
 			}, this ));
 
 		if ( this.options.disabled ) {
-			this.element.addClass( "ui-state-disabled" );
+			this.element
+				.addClass( "ui-state-disabled" )
+				.attr( "aria-disabled", "true" );
 		}
 
 		this._bind({
@@ -66,20 +69,25 @@ $.widget( "ui.menu", {
 				event.preventDefault();
 			},
 			"click .ui-menu-item:has(a)": function( event ) {
-				event.stopImmediatePropagation();
-				// Don't select disabled menu items
-				if ( !$( event.target ).closest( ".ui-menu-item" ).is( ".ui-state-disabled" ) ) {
-					this.select( event );
-					// Redirect focus to the menu with a delay for firefox
-					this._delay(function() {
-						if ( !this.element.is(":focus") ) {
-							this.element.focus();
-						}
-					}, 20 );
+				var target = $( event.target );
+				if ( target[0] !== currentEventTarget ) {
+					currentEventTarget = target[0];
+					target.one( "click.menu", function( event ) {
+						currentEventTarget = null;
+					});
+					// Don't select disabled menu items
+					if ( !target.closest( ".ui-menu-item" ).is( ".ui-state-disabled" ) ) {
+						this.select( event );
+						// Redirect focus to the menu with a delay for firefox
+						this._delay(function() {
+							if ( !this.element.is(":focus") ) {
+								this.element.focus();
+							}
+						}, 20 );
+					}
 				}
 			},
-			"mouseover .ui-menu-item": function( event ) {
-				event.stopImmediatePropagation();
+			"mouseenter .ui-menu-item": function( event ) {
 				var target = $( event.currentTarget );
 				// Remove ui-state-active class from siblings of the newly focused menu item
 				// to avoid a jump caused by adjacent elements both having a class with a border
@@ -90,7 +98,7 @@ $.widget( "ui.menu", {
 			"mouseleave .ui-menu": "collapseAll",
 			"focus": function( event ) {
 				var menu = this.element,
-					firstItem = menu.children( ".ui-menu-item" ).not( ".ui-state-disabled" ).eq( 0 );
+					firstItem = menu.children( ".ui-menu-item" ).eq( 0 );
 				if ( this._hasScroll() && !this.active ) {
 					menu.children().each(function() {
 						var currentItem = $( this );
@@ -151,6 +159,9 @@ $.widget( "ui.menu", {
 				.removeAttr( "id" )
 				.children( ".ui-icon" )
 					.remove();
+
+		// unbind currentEventTarget click event handler
+		$( currentEventTarget ).unbind( "click.menu" );
 	},
 
 	_keydown: function( event ) {
@@ -158,65 +169,52 @@ $.widget( "ui.menu", {
 		case $.ui.keyCode.PAGE_UP:
 			this.previousPage( event );
 			event.preventDefault();
-			event.stopImmediatePropagation();
 			break;
 		case $.ui.keyCode.PAGE_DOWN:
 			this.nextPage( event );
 			event.preventDefault();
-			event.stopImmediatePropagation();
 			break;
 		case $.ui.keyCode.HOME:
 			this._move( "first", "first", event );
 			event.preventDefault();
-			event.stopImmediatePropagation();
 			break;
 		case $.ui.keyCode.END:
 			this._move( "last", "last", event );
 			event.preventDefault();
-			event.stopImmediatePropagation();
 			break;
 		case $.ui.keyCode.UP:
 			this.previous( event );
 			event.preventDefault();
-			event.stopImmediatePropagation();
 			break;
 		case $.ui.keyCode.DOWN:
 			this.next( event );
 			event.preventDefault();
-			event.stopImmediatePropagation();
 			break;
 		case $.ui.keyCode.LEFT:
-			if (this.collapse( event )) {
-				event.stopImmediatePropagation();
-			}
+			this.collapse( event );
 			event.preventDefault();
 			break;
 		case $.ui.keyCode.RIGHT:
-			if (this.expand( event )) {
-				event.stopImmediatePropagation();
+			if ( !this.active.is( ".ui-state-disabled" ) ) {
+				this.expand( event );
 			}
 			event.preventDefault();
 			break;
 		case $.ui.keyCode.ENTER:
-			if ( this.active.children( "a[aria-haspopup='true']" ).length ) {
-				if ( this.expand( event ) ) {
-					event.stopImmediatePropagation();
+			if ( !this.active.is( ".ui-state-disabled" ) ) {
+				if ( this.active.children( "a[aria-haspopup='true']" ).length ) {
+					this.expand( event );
+				} else {
+					this.select( event );
 				}
 			}
-			else {
-				this.select( event );
-				event.stopImmediatePropagation();
-			}
 			event.preventDefault();
 			break;
 		case $.ui.keyCode.ESCAPE:
-			if ( this.collapse( event ) ) {
-				event.stopImmediatePropagation();
-			}
+			this.collapse( event );
 			event.preventDefault();
 			break;
 		default:
-			event.stopPropagation();
 			clearTimeout( this.filterTimer );
 			var match,
 				prev = this.previousFilter || "",
@@ -291,6 +289,9 @@ $.widget( "ui.menu", {
 		// initialize unlinked menu-items as dividers
 		menus.children( ":not(.ui-menu-item)" ).addClass( "ui-widget-content ui-menu-divider" );
 
+		// add aria-disabled attribute to any disabled menu item
+		menus.children( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
+
 		submenus.each(function() {
 			var menu = $( this ),
 				item = menu.prev( "a" );
@@ -303,7 +304,7 @@ $.widget( "ui.menu", {
 
 	focus: function( event, item ) {
 		var nested, borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
-		this.blur( event );
+		this.blur( event, event && event.type === "focus" );
 
 		if ( this._hasScroll() ) {
 			borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
@@ -342,8 +343,10 @@ $.widget( "ui.menu", {
 		this._trigger( "focus", event, { item: item } );
 	},
 
-	blur: function( event ) {
-		clearTimeout( this.timer );
+	blur: function( event, fromFocus ) {
+		if ( !fromFocus ) {
+			clearTimeout( this.timer );
+		}
 
 		if ( !this.active ) {
 			return;
@@ -441,7 +444,6 @@ $.widget( "ui.menu", {
 			this.active
 				.children( ".ui-menu " )
 				.children( ".ui-menu-item" )
-				.not( ".ui-state-disabled" )
 				.first();
 
 		if ( newItem && newItem.length ) {
@@ -477,12 +479,10 @@ $.widget( "ui.menu", {
 			if ( direction === "first" || direction === "last" ) {
 				next = this.active
 					[ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
-					.not( ".ui-state-disabled" )
 					.eq( -1 );
 			} else {
 				next = this.active
 					[ direction + "All" ]( ".ui-menu-item" )
-					.not( ".ui-state-disabled" )
 					.eq( 0 );
 			}
 		}
@@ -491,9 +491,6 @@ $.widget( "ui.menu", {
 		}
 
 		this.focus( event, next );
-		if ( next.is( ".ui-state-disabled" ) ) {
-			this._move( direction, filter, event );
-		}
 	},
 
 	nextPage: function( event ) {
@@ -508,14 +505,14 @@ $.widget( "ui.menu", {
 			var base = this.active.offset().top,
 				height = this.element.height(),
 				result;
-			this.active.nextAll( ".ui-menu-item" ).not( ".ui-state-disabled" ).each(function() {
+			this.active.nextAll( ".ui-menu-item" ).each(function() {
 				result = $( this );
 				return $( this ).offset().top - base - height < 0;
 			});
 
 			this.focus( event, result );
 		} else {
-			this.focus( event, this.activeMenu.children( ".ui-menu-item" ).not( ".ui-state-disabled" )
+			this.focus( event, this.activeMenu.children( ".ui-menu-item" )
 				[ !this.active ? "first" : "last" ]() );
 		}
 	},
@@ -532,14 +529,14 @@ $.widget( "ui.menu", {
 			var base = this.active.offset().top,
 				height = this.element.height(),
 				result;
-			this.active.prevAll( ".ui-menu-item" ).not( ".ui-state-disabled" ).each(function() {
+			this.active.prevAll( ".ui-menu-item" ).each(function() {
 				result = $( this );
 				return $(this).offset().top - base + height > 0;
 			});
 
 			this.focus( event, result );
 		} else {
-			this.focus( event, this.activeMenu.children( ".ui-menu-item" ).not( ".ui-state-disabled" ).first() );
+			this.focus( event, this.activeMenu.children( ".ui-menu-item" ).first() );
 		}
 	},
 
diff --git a/ui/jquery.ui.resizable.js b/ui/jquery.ui.resizable.js
index 9be33927e..c00602cc8 100644
--- a/ui/jquery.ui.resizable.js
+++ b/ui/jquery.ui.resizable.js
@@ -99,9 +99,8 @@ $.widget("ui.resizable", $.ui.mouse, {
 				var handle = $.trim(n[i]), hname = 'ui-resizable-'+handle;
 				var axis = $('<div class="ui-resizable-handle ' + hname + '"></div>');
 
-				// increase zIndex of sw, se, ne, nw axis
-				//TODO : this modifies original option
-				if(/sw|se|ne|nw/.test(handle)) axis.css({ zIndex: ++o.zIndex });
+				// Apply zIndex to all handles - see #7960
+				axis.css({ zIndex: o.zIndex });
 
 				//TODO : What's going on here?
 				if ('se' == handle) {
diff --git a/ui/jquery.ui.sortable.js b/ui/jquery.ui.sortable.js
index 4093be245..5373967df 100644
--- a/ui/jquery.ui.sortable.js
+++ b/ui/jquery.ui.sortable.js
@@ -59,7 +59,7 @@ $.widget("ui.sortable", $.ui.mouse, {
 
 		//Initialize mouse events for interaction
 		this._mouseInit();
-		
+
 		//We're ready to go
 		this.ready = true
 
@@ -79,7 +79,7 @@ $.widget("ui.sortable", $.ui.mouse, {
 	_setOption: function(key, value){
 		if ( key === "disabled" ) {
 			this.options[ key ] = value;
-	
+
 			this.widget().toggleClass( "ui-sortable-disabled", !!value );
 		} else {
 			// Don't call widget base _setOption for disable as it adds ui-state-disabled class
@@ -519,7 +519,7 @@ $.widget("ui.sortable", $.ui.mouse, {
 			? [options.connectWith]
 			: options.connectWith;
 	},
-	
+
 	_getItemsAsjQuery: function(connected) {
 
 		var self = this;
@@ -673,9 +673,8 @@ $.widget("ui.sortable", $.ui.mouse, {
 					// 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
 					if(className && !o.forcePlaceholderSize) return;
 
-					//If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
-					if(!p.height()) { p.height(self.currentItem.innerHeight() - parseInt(self.currentItem.css('paddingTop')||0, 10) - parseInt(self.currentItem.css('paddingBottom')||0, 10)); };
-					if(!p.width()) { p.width(self.currentItem.innerWidth() - parseInt(self.currentItem.css('paddingLeft')||0, 10) - parseInt(self.currentItem.css('paddingRight')||0, 10)); };
+					p.height(self.currentItem.height());
+					p.width(self.currentItem.width());
 				}
 			};
 		}
@@ -692,28 +691,28 @@ $.widget("ui.sortable", $.ui.mouse, {
 	},
 
 	_contactContainers: function(event) {
-		
-		// get innermost container that intersects with item 
-		var innermostContainer = null, innermostIndex = null;		
-		
-		
+
+		// get innermost container that intersects with item
+		var innermostContainer = null, innermostIndex = null;
+
+
 		for (var i = this.containers.length - 1; i >= 0; i--){
 
-			// never consider a container that's located within the item itself 
+			// never consider a container that's located within the item itself
 			if($.contains(this.currentItem[0], this.containers[i].element[0]))
 				continue;
 
 			if(this._intersectsWith(this.containers[i].containerCache)) {
 
-				// if we've already found a container and it's more "inner" than this, then continue 
+				// if we've already found a container and it's more "inner" than this, then continue
 				if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0]))
 					continue;
 
-				innermostContainer = this.containers[i]; 
+				innermostContainer = this.containers[i];
 				innermostIndex = i;
-					
+
 			} else {
-				// container doesn't intersect. trigger "out" event if necessary 
+				// container doesn't intersect. trigger "out" event if necessary
 				if(this.containers[i].containerCache.over) {
 					this.containers[i]._trigger("out", event, this._uiHash(this));
 					this.containers[i].containerCache.over = 0;
@@ -721,42 +720,42 @@ $.widget("ui.sortable", $.ui.mouse, {
 			}
 
 		}
-		
-		// if no intersecting containers found, return 
-		if(!innermostContainer) return; 
+
+		// if no intersecting containers found, return
+		if(!innermostContainer) return;
 
 		// move the item into the container if it's not there already
 		if(this.containers.length === 1) {
 			this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
 			this.containers[innermostIndex].containerCache.over = 1;
-		} else if(this.currentContainer != this.containers[innermostIndex]) { 
-
-			//When entering a new container, we will find the item with the least distance and append our item near it 
-			var dist = 10000; var itemWithLeastDistance = null; var base = this.positionAbs[this.containers[innermostIndex].floating ? 'left' : 'top']; 
-			for (var j = this.items.length - 1; j >= 0; j--) { 
-				if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) continue; 
-				var cur = this.items[j][this.containers[innermostIndex].floating ? 'left' : 'top']; 
-				if(Math.abs(cur - base) < dist) { 
-					dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j]; 
-				} 
-			} 
-
-			if(!itemWithLeastDistance && !this.options.dropOnEmpty) //Check if dropOnEmpty is enabled 
-				return; 
-
-			this.currentContainer = this.containers[innermostIndex]; 
-			itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true); 
-			this._trigger("change", event, this._uiHash()); 
-			this.containers[innermostIndex]._trigger("change", event, this._uiHash(this)); 
-
-			//Update the placeholder 
-			this.options.placeholder.update(this.currentContainer, this.placeholder); 
-		
-			this.containers[innermostIndex]._trigger("over", event, this._uiHash(this)); 
+		} else if(this.currentContainer != this.containers[innermostIndex]) {
+
+			//When entering a new container, we will find the item with the least distance and append our item near it
+			var dist = 10000; var itemWithLeastDistance = null; var base = this.positionAbs[this.containers[innermostIndex].floating ? 'left' : 'top'];
+			for (var j = this.items.length - 1; j >= 0; j--) {
+				if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) continue;
+				var cur = this.items[j][this.containers[innermostIndex].floating ? 'left' : 'top'];
+				if(Math.abs(cur - base) < dist) {
+					dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
+				}
+			}
+
+			if(!itemWithLeastDistance && !this.options.dropOnEmpty) //Check if dropOnEmpty is enabled
+				return;
+
+			this.currentContainer = this.containers[innermostIndex];
+			itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
+			this._trigger("change", event, this._uiHash());
+			this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
+
+			//Update the placeholder
+			this.options.placeholder.update(this.currentContainer, this.placeholder);
+
+			this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
 			this.containers[innermostIndex].containerCache.over = 1;
-		} 
-	
-		
+		}
+
+
 	},
 
 	_createHelper: function(event) {
diff --git a/version.txt b/version.txt
deleted file mode 100644
index c70a1dfdc..000000000
--- a/version.txt
+++ /dev/null
@@ -1 +0,0 @@
-1.9.0pre
\ No newline at end of file