Manage bower dependencies with grunt-bowercopy

Tracked bower dependencies are located at "src/sizzle" and "test/libs".
The source-destination mapping is in the Gruntfile.

When updating a bower dependency, update the version in bower.json, run
`grunt bower`, and then commit the result. When adding a dependency,
update the bowercopy task accordingly.

Fixes #14615.
Closes gh-1452.

.gitignore

-dist
+/dist
 .project
 .settings
 *~
@@ -6,9 +6,8 @@ dist
 *.patch
 /*.html
 .DS_Store
+.bower.json
+.sizecache.json
 dist/.destination.json
-dist/.sizecache.json
-build/.sizecache.json
 bower_components
-bower_modules
 node_modules

.jscs.json

@@ -19,5 +19,5 @@
     "disallowKeywordsOnNewLine": [ "else" ],
     "requireLineFeedAtFileEnd": true,
 
-    "excludeFiles": [ "src/intro.js", "src/outro.js" ]
+    "excludeFiles": [ "src/intro.js", "src/outro.js", "src/sizzle/**/*" ]
 }

.jshintignore

 src/intro.js
 src/outro.js
+src/sizzle/**/*
+test/libs/**/*
 test/data/jquery-1.9.1.js
-bower_modules
 test/data/badcall.js
 test/data/badjson.js
 test/data/json_obj.js

Gruntfile.js

@@ -10,7 +10,6 @@ module.exports = function( grunt ) {
 	}
 
 	var gzip = require( "gzip-js" ),
-		path = require( "path" ),
 		srcHintOptions = readOptionalJSON( "src/.jshintrc" );
 
 	// The concatenated file won't pass onevar
@@ -47,14 +46,23 @@ module.exports = function( grunt ) {
 				}
 			}
 		},
-		bower: {
-			install: {
+		bowercopy: {
+			options: {
+				clean: true
+			},
+			src: {
+				files: {
+					"src/sizzle": "sizzle"
+				}
+			},
+			tests: {
 				options: {
-					targetDir: "bower_modules",
-					cleanup: true,
-					layout: function( type ) {
-						return path.join( type );
-					}
+					destPrefix: "test/libs"
+				},
+				files: {
+					"qunit": "qunit/qunit",
+					"require.js": "requirejs/require.js",
+					"sinon/fake_timers.js": "sinon/lib/sinon/util/fake_timers.js"
 				}
 			}
 		},
@@ -139,6 +147,9 @@ module.exports = function( grunt ) {
 	// Integrate jQuery specific tasks
 	grunt.loadTasks( "build/tasks" );
 
+	// Alias bower to bowercopy
+	grunt.registerTask( "bower", "bowercopy" );
+
 	// Short list as a high frequency watch task
 	grunt.registerTask( "dev", [ "build:*:*", "jshint", "jscs" ] );
 

bower.json

@@ -20,21 +20,6 @@
     "qunit": "~1.12.0",
     "sinon": "~1.7.3"
   },
-  "exportsOverride": {
-    "sizzle": {
-      "sizzle": "."
-    },
-
-    "requirejs": {
-      "requirejs": "require.js"
-    },
-    "qunit": {
-      "qunit": "qunit"
-    },
-    "sinon": {
-      "sinon": "**/*.js"
-    }
-  },
   "keywords": [
     "jquery",
     "javascript",

build/release.js

@@ -18,8 +18,6 @@ var releaseVersion,
 	pkg,
 	branch,
 
-	sizzleLoc = "bower_modules/sizzle",
-
 	scpURL = "jqadmin@code.origin.jquery.com:/var/www/html/code.jquery.com/",
 	cdnURL = "http://code.origin.jquery.com/",
 	repoURL = "git@github.com:jquery/jquery.git",
@@ -103,9 +101,6 @@ function initialize( next ) {
 	if ( !exists( "package.json" ) ) {
 		die( "No package.json in this directory" );
 	}
-	if ( !exists( sizzleLoc ) ) {
-		die( "Sizzle expected to exist at " + sizzleLoc );
-	}
 	pkg = readJSON( "package.json" );
 
 	console.log( "Current version is " + pkg.version + "; generating release " + releaseVersion );
@@ -309,15 +304,9 @@ function commitDistFiles( next ) {
 	// Add files to be committed
 	git( [ "add", "package.json" ], function() {
 		git( [ "commit", "-m", "Remove scripts property from package.json" ], function() {
-			// Add sizzle in a separate commit to avoid a big diff
-			// Use force to add normally ignored files
-			git( [ "add", "-f", sizzleLoc ], function() {
-				git( [ "commit", "-m", "Add sizzle" ], function() {
-					// Add jquery files for distribution in a final commit
-					git( [ "add", "-f", devFile, minFile, mapFile ], function() {
-						git( [ "commit", "-m", releaseVersion ], next, debug );
-					}, debug );
-				}, debug );
+			// Add jquery files for distribution in a final commit
+			git( [ "add", "-f", devFile, minFile, mapFile ], function() {
+				git( [ "commit", "-m", releaseVersion ], next, debug );
 			}, debug );
 		}, debug );
 	}, debug );

build/tasks/build.js

@@ -26,7 +26,7 @@ module.exports = function( grunt ) {
 				endFile: "src/outro.js"
 			},
 			paths: {
-				sizzle: "../bower_modules/sizzle/dist/sizzle"
+				sizzle: "sizzle/dist/sizzle"
 			},
 			rawText: {},
 			onBuildWrite: convert

package.json

@@ -31,7 +31,7 @@
   "devDependencies": {
     "archiver": "~0.4.10",
     "grunt": "~0.4.1",
-    "grunt-bower-task": "~0.3.2",
+    "grunt-bowercopy": "~0.4.1",
     "grunt-cli": "~0.1.11",
     "grunt-compare-size": "~0.4.0",
     "grunt-contrib-jshint": "~0.7.0",
@@ -48,9 +48,6 @@
   },
   "scripts": {
     "build": "npm install && grunt",
-
-    "install": "grunt bower",
-
     "start": "grunt watch",
     "test": "grunt"
   }

src/sizzle/test/data/mixed_sort.html

+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+	<script>var QUnit = parent.QUnit</script>
+	<script src="testinit.js"></script>
+	<script src="../../dist/sizzle.js"></script>
+</head>
+<body>
+	<script>
+		var doc = parent.document,
+			unframed = [ doc.getElementById( "qunit-fixture" ), doc.body, doc.documentElement ],
+			framed = Sizzle( "*" );
+
+		window.parent.iframeCallback(
+			Sizzle.uniqueSort( unframed.concat( framed ) ),
+			framed.concat( unframed.reverse() ),
+			"Mixed array was sorted correctly"
+		);
+	</script>
+</body>
+</html>

src/sizzle/test/data/testinit.js

+var fireNative,
+	jQuery = this.jQuery || "jQuery", // For testing .noConflict()
+	$ = this.$ || "$",
+	originaljQuery = jQuery,
+	original$ = $;
+
+(function() {
+	// Config parameter to force basic code paths
+	QUnit.config.urlConfig.push({
+		id: "basic",
+		label: "Bypass optimizations",
+		tooltip: "Force use of the most basic code by disabling native querySelectorAll; contains; compareDocumentPosition"
+	});
+	if ( QUnit.urlParams.basic ) {
+		document.querySelectorAll = null;
+		document.documentElement.contains = null;
+		document.documentElement.compareDocumentPosition = null;
+		// Return array of length two to pass assertion
+		// But support should be false as its not native
+		document.getElementsByClassName = function() { return [ 0, 1 ]; };
+	}
+})();
+
+/**
+ * Returns an array of elements with the given IDs
+ * @example q("main", "foo", "bar")
+ * @result [<div id="main">, <span id="foo">, <input id="bar">]
+ */
+function q() {
+	var r = [],
+		i = 0;
+
+	for ( ; i < arguments.length; i++ ) {
+		r.push( document.getElementById( arguments[i] ) );
+	}
+	return r;
+}
+
+/**
+ * Asserts that a select matches the given IDs
+ * @param {String} a - Assertion name
+ * @param {String} b - Sizzle selector
+ * @param {String} c - Array of ids to construct what is expected
+ * @example t("Check for something", "//[a]", ["foo", "baar"]);
+ * @result returns true if "//[a]" return two elements with the IDs 'foo' and 'baar'
+ */
+function t( a, b, c ) {
+	var f = Sizzle(b),
+		s = "",
+		i = 0;
+
+	for ( ; i < f.length; i++ ) {
+		s += ( s && "," ) + '"' + f[ i ].id + '"';
+	}
+
+	deepEqual(f, q.apply( q, c ), a + " (" + b + ")");
+}
+
+/**
+ * Add random number to url to stop caching
+ *
+ * @example url("data/test.html")
+ * @result "data/test.html?10538358428943"
+ *
+ * @example url("data/test.php?foo=bar")
+ * @result "data/test.php?foo=bar&10538358345554"
+ */
+function url( value ) {
+	return value + (/\?/.test(value) ? "&" : "?") + new Date().getTime() + "" + parseInt(Math.random()*100000);
+}
+
+var createWithFriesXML = function() {
+	var string = '<?xml version="1.0" encoding="UTF-8"?> \
+	<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" \
+		xmlns:xsd="http://www.w3.org/2001/XMLSchema" \
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> \
+		<soap:Body> \
+			<jsconf xmlns="http://www.example.com/ns1"> \
+				<response xmlns:ab="http://www.example.com/ns2"> \
+					<meta> \
+						<component id="seite1" class="component"> \
+							<properties xmlns:cd="http://www.example.com/ns3"> \
+								<property name="prop1"> \
+									<thing /> \
+									<value>1</value> \
+								</property> \
+								<property name="prop2"> \
+									<thing att="something" /> \
+								</property> \
+								<foo_bar>foo</foo_bar> \
+							</properties> \
+						</component> \
+					</meta> \
+				</response> \
+			</jsconf> \
+		</soap:Body> \
+	</soap:Envelope>';
+
+	return jQuery.parseXML( string );
+};
+
+fireNative = document.createEvent ?
+	function( node, type ) {
+		var event = document.createEvent("HTMLEvents");
+		event.initEvent( type, true, true );
+		node.dispatchEvent( event );
+	} :
+	function( node, type ) {
+		var event = document.createEventObject();
+		node.fireEvent( "on" + type, event );
+	};
+
+function testIframeWithCallback( title, fileName, func ) {
+	test( title, function() {
+		var iframe;
+
+		stop();
+		window.iframeCallback = function() {
+			var self = this,
+				args = arguments;
+			setTimeout(function() {
+				window.iframeCallback = undefined;
+				iframe.remove();
+				func.apply( self, args );
+				func = function() {};
+				start();
+			}, 0 );
+		};
+		iframe = jQuery( "<div/>" ).css({ position: "absolute", width: "500px", left: "-600px" })
+			.append( jQuery( "<iframe/>" ).attr( "src", url( "./data/" + fileName ) ) )
+			.appendTo( "#qunit-fixture" );
+	});
+};
+window.iframeCallback = undefined;
+
+function moduleTeardown() {}

src/sizzle/test/unit/extending.js

+module("extending", { teardown: moduleTeardown });
+
+test("custom pseudos", function() {
+	expect( 6 );
+
+	Sizzle.selectors.filters.foundation = Sizzle.selectors.filters.root;
+	deepEqual( Sizzle(":foundation"), [ document.documentElement ], "Copy element filter with new name" );
+	delete Sizzle.selectors.filters.foundation;
+
+	Sizzle.selectors.setFilters.primary = Sizzle.selectors.setFilters.first;
+	t( "Copy set filter with new name", "div:primary", ["qunit"] );
+	delete Sizzle.selectors.setFilters.primary;
+
+	Sizzle.selectors.filters.aristotlean = Sizzle.selectors.createPseudo(function() {
+		return function( elem ) {
+			return !!elem.id;
+		};
+	});
+	t( "Custom element filter", "#foo :aristotlean", [ "sndp", "en", "yahoo", "sap", "anchor2", "simon" ] );
+	delete Sizzle.selectors.filters.aristotlean;
+
+	Sizzle.selectors.filters.endswith = Sizzle.selectors.createPseudo(function( text ) {
+		return function( elem ) {
+			return Sizzle.getText( elem ).slice( -text.length ) === text;
+		};
+	});
+	t( "Custom element filter with argument", "a:endswith(ogle)", ["google"] );
+	delete Sizzle.selectors.filters.endswith;
+
+	Sizzle.selectors.setFilters.second = Sizzle.selectors.createPseudo(function() {
+		return Sizzle.selectors.createPseudo(function( seed, matches ) {
+			if ( seed[1] ) {
+				matches[1] = seed[1];
+				seed[1] = false;
+			}
+		});
+	});
+	t( "Custom set filter", "#qunit-fixture p:second", ["ap"] );
+	delete Sizzle.selectors.filters.second;
+
+	Sizzle.selectors.setFilters.slice = Sizzle.selectors.createPseudo(function( argument ) {
+		var bounds = argument.split(":");
+		return Sizzle.selectors.createPseudo(function( seed, matches ) {
+			var i = bounds[1];
+
+			// Match elements found at the specified indexes
+			while ( --i >= bounds[0] ) {
+				if ( seed[i] ) {
+					matches[i] = seed[i];
+					seed[i] = false;
+				}
+			}
+		});
+	});
+	t( "Custom set filter with argument", "#qunit-fixture p:slice(1:3)", [ "ap", "sndp" ] );
+	delete Sizzle.selectors.filters.slice;
+});
+
+test("backwards-compatible custom pseudos", function() {
+	expect( 3 );
+
+	Sizzle.selectors.filters.icontains = function( elem, i, match ) {
+		return Sizzle.getText( elem ).toLowerCase().indexOf( (match[3] || "").toLowerCase() ) > -1;
+	};
+	t( "Custom element filter with argument", "a:icontains(THIS BLOG ENTRY)", ["simon1"] );
+	delete Sizzle.selectors.filters.icontains;
+
+	Sizzle.selectors.setFilters.podium = function( elements, argument ) {
+		var count = argument == null || argument === "" ? 3 : +argument;
+		return elements.slice( 0, count );
+	};
+	// Using TAG as the first token here forces this setMatcher into a fail state
+	// Where the descendent combinator was lost
+	t( "Custom setFilter", "form#form :PODIUM", ["label-for", "text1", "text2"] );
+	t( "Custom setFilter with argument", "#form input:Podium(1)", ["text1"] );
+	delete Sizzle.selectors.setFilters.podium;
+});
+
+test("custom attribute getters", function() {
+	expect( 2 );
+
+	var original = Sizzle.selectors.attrHandle.hreflang,
+		selector = "a:contains('mark')[hreflang='http://diveintomark.org/en']";
+
+	Sizzle.selectors.attrHandle.hreflang = function( elem, name ) {
+		var href = elem.getAttribute("href"),
+			lang = elem.getAttribute( name );
+		return lang && ( href + lang );
+	};
+
+	deepEqual( Sizzle(selector, createWithFriesXML()), [], "Custom attrHandle (preferred document)" );
+	t( "Custom attrHandle (preferred document)", selector, ["mark"] );
+
+	Sizzle.selectors.attrHandle.hreflang = original;
+});

src/sizzle/test/unit/utilities.js

+module("utilities", { teardown: moduleTeardown });
+
+function testAttr( doc ) {
+	expect( 9 );
+
+	var el;
+	if ( doc ) {
+		// XML
+		el = doc.createElement( "input" );
+		el.setAttribute( "type", "checkbox" );
+	} else {
+		// Set checked on creation by creating with a fragment
+		// See http://jsfiddle.net/8sVgA/1/show/light in oldIE
+		el = jQuery( "<input type='checkbox' checked='checked' />" )[0];
+	}
+
+	// Set it again for good measure
+	el.setAttribute( "checked", "checked" );
+	el.setAttribute( "id", "id" );
+	el.setAttribute( "value", "on" );
+
+	strictEqual( Sizzle.attr( el, "nonexistent" ), null, "nonexistent" );
+	strictEqual( Sizzle.attr( el, "id" ), "id", "existent" );
+	strictEqual( Sizzle.attr( el, "value" ), "on", "value" );
+	strictEqual( Sizzle.attr( el, "checked" ), "checked", "boolean" );
+	strictEqual( Sizzle.attr( el, "href" ), null, "interpolation risk" );
+	strictEqual( Sizzle.attr( el, "constructor" ), null,
+		"Object.prototype property \"constructor\" (negative)" );
+	strictEqual( Sizzle.attr( el, "watch" ), null,
+		"Gecko Object.prototype property \"watch\" (negative)" );
+	el.setAttribute( "constructor", "foo" );
+	el.setAttribute( "watch", "bar" );
+	strictEqual( Sizzle.attr( el, "constructor" ), "foo",
+		"Object.prototype property \"constructor\"" );
+	strictEqual( Sizzle.attr( el, "watch" ), "bar",
+		"Gecko Object.prototype property \"watch\"" );
+}
+
+test("Sizzle.attr (HTML)", function() {
+	testAttr();
+});
+
+test("Sizzle.attr (XML)", function() {
+	testAttr( jQuery.parseXML("<root/>") );
+});
+
+test("Sizzle.contains", function() {
+	expect( 16 );
+
+	var container = document.getElementById("nonnodes"),
+		element = container.firstChild,
+		text = element.nextSibling,
+		nonContained = container.nextSibling,
+		detached = document.createElement("a");
+	ok( element && element.nodeType === 1, "preliminary: found element" );
+	ok( text && text.nodeType === 3, "preliminary: found text" );
+	ok( nonContained, "preliminary: found non-descendant" );
+	ok( Sizzle.contains(container, element), "child" );
+	ok( Sizzle.contains(container.parentNode, element), "grandchild" );
+	ok( Sizzle.contains(container, text), "text child" );
+	ok( Sizzle.contains(container.parentNode, text), "text grandchild" );
+	ok( !Sizzle.contains(container, container), "self" );
+	ok( !Sizzle.contains(element, container), "parent" );
+	ok( !Sizzle.contains(container, nonContained), "non-descendant" );
+	ok( !Sizzle.contains(container, document), "document" );
+	ok( !Sizzle.contains(container, document.documentElement), "documentElement (negative)" );
+	ok( !Sizzle.contains(container, null), "Passing null does not throw an error" );
+	ok( Sizzle.contains(document, document.documentElement), "documentElement (positive)" );
+	ok( Sizzle.contains(document, element), "document container (positive)" );
+	ok( !Sizzle.contains(document, detached), "document container (negative)" );
+});
+
+if ( jQuery("<svg xmlns='http://www.w3.org/2000/svg' version='1.1' height='1' width='1'><g/></svg>")[0].firstChild ) {
+	test("Sizzle.contains in SVG (jQuery #10832)", function() {
+		expect( 4 );
+
+		var svg = jQuery(
+			"<svg xmlns='http://www.w3.org/2000/svg' version='1.1' height='1' width='1'>" +
+				"<g><circle cx='1' cy='1' r='1' /></g>" +
+			"</svg>"
+		).appendTo("#qunit-fixture")[0];
+
+		ok( Sizzle.contains( svg, svg.firstChild ), "root child" );
+		ok( Sizzle.contains( svg.firstChild, svg.firstChild.firstChild ), "element child" );
+		ok( Sizzle.contains( svg, svg.firstChild.firstChild ), "root granchild" );
+		ok( !Sizzle.contains( svg.firstChild.firstChild, svg.firstChild ), "parent (negative)" );
+	});
+}
+
+test("Sizzle.uniqueSort", function() {
+	expect( 14 );
+
+	function Arrayish( arr ) {
+		var i = this.length = arr.length;
+		while ( i-- ) {
+			this[ i ] = arr[ i ];
+		}
+	}
+	Arrayish.prototype = {
+		slice: [].slice,
+		sort: [].sort,
+		splice: [].splice
+	};
+
+	var i, tests,
+		detached = [],
+		body = document.body,
+		fixture = document.getElementById("qunit-fixture"),
+		detached1 = document.createElement("p"),
+		detached2 = document.createElement("ul"),
+		detachedChild = detached1.appendChild( document.createElement("a") ),
+		detachedGrandchild = detachedChild.appendChild( document.createElement("b") );
+
+	for ( i = 0; i < 12; i++ ) {
+		detached.push( document.createElement("li") );
+		detached[i].id = "detached" + i;
+		detached2.appendChild( document.createElement("li") ).id = "detachedChild" + i;
+	}
+
+	tests = {
+		"Empty": {
+			input: [],
+			expected: []
+		},
+		"Single-element": {
+			input: [ fixture ],
+			expected: [ fixture ]
+		},
+		"No duplicates": {
+			input: [ fixture, body ],
+			expected: [ body, fixture ]
+		},
+		"Duplicates": {
+			input: [ body, fixture, fixture, body ],
+			expected: [ body, fixture ]
+		},
+		"Detached": {
+			input: detached.slice( 0 ),
+			expected: detached.slice( 0 )
+		},
+		"Detached children": {
+			input: [
+				detached2.childNodes[0],
+				detached2.childNodes[1],
+				detached2.childNodes[2],
+				detached2.childNodes[3]
+			],
+			expected: [
+				detached2.childNodes[0],
+				detached2.childNodes[1],
+				detached2.childNodes[2],
+				detached2.childNodes[3]
+			]
+		},
+		"Attached/detached mixture": {
+			input: [ detached1, fixture, detached2, document, detachedChild, body, detachedGrandchild ],
+			expected: [ document, body, fixture ],
+			length: 3
+		}
+	};
+
+	jQuery.each( tests, function( label, test ) {
+		var length = test.length || test.input.length;
+		deepEqual( Sizzle.uniqueSort( test.input ).slice( 0, length ), test.expected, label + " (array)" );
+		deepEqual( Sizzle.uniqueSort( new Arrayish(test.input) ).slice( 0, length ), test.expected, label + " (quasi-array)" );
+	});
+});
+
+testIframeWithCallback( "Sizzle.uniqueSort works cross-window (jQuery #14381)", "mixed_sort.html", deepEqual );

test/data/testinit.js

@@ -300,7 +300,7 @@ this.loadTests = function() {
 
 
 				// Subproject tests must be last because they replace our test fixture
-				testSubproject( "Sizzle", "../bower_modules/sizzle/test/", /^unit\/.*\.js$/, function() {
+				testSubproject( "Sizzle", "../src/sizzle/test/", /^unit\/.*\.js$/, function() {
 					// Call load to build module filter select element
 					QUnit.load();
 

test/index.html

@@ -4,7 +4,7 @@
 	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 	<meta http-equiv="X-UA-Compatible" content="IE=Edge" />
 	<title>jQuery Test Suite</title>
-	<link rel="Stylesheet" media="screen" href="../bower_modules/qunit/qunit.css" />
+	<link rel="Stylesheet" media="screen" href="libs/qunit/qunit.css" />
 	<link rel="Stylesheet" media="screen" href="data/testsuite.css" />
 	<!-- Includes -->
 
@@ -14,9 +14,9 @@
 	-->
 	<script src="data/jquery-1.9.1.js"></script>
 
-	<script src="../bower_modules/qunit/qunit.js"></script>
-	<script src="../bower_modules/requirejs/require.js"></script>
-	<script src="../bower_modules/sinon/fake_timers.js"></script>
+	<script src="libs/qunit/qunit.js"></script>
+	<script src="libs/require.js"></script>
+	<script src="libs/sinon/fake_timers.js"></script>
 	<!-- See testinit for the list of tests -->
 	<script src="data/testinit.js"></script>
 

test/jquery.js

@@ -19,7 +19,7 @@
 		require.config({
 			baseUrl: path,
 			paths: {
-				sizzle: path + "bower_modules/sizzle/dist/sizzle"
+				sizzle: "src/sizzle/dist/sizzle"
 			}
 		});
 		src = "src/jquery";

test/libs/qunit/qunit.css

+/**
+ * QUnit v1.12.0 - A JavaScript Unit Testing Framework
+ *
+ * http://qunitjs.com
+ *
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/** Font Family and Sizes */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
+	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
+}
+
+#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
+#qunit-tests { font-size: smaller; }
+
+
+/** Resets */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
+	margin: 0;
+	padding: 0;
+}
+
+
+/** Header */
+
+#qunit-header {
+	padding: 0.5em 0 0.5em 1em;
+
+	color: #8699a4;
+	background-color: #0d3349;
+
+	font-size: 1.5em;
+	line-height: 1em;
+	font-weight: normal;
+
+	border-radius: 5px 5px 0 0;
+	-moz-border-radius: 5px 5px 0 0;
+	-webkit-border-top-right-radius: 5px;
+	-webkit-border-top-left-radius: 5px;
+}
+
+#qunit-header a {
+	text-decoration: none;
+	color: #c2ccd1;
+}
+
+#qunit-header a:hover,
+#qunit-header a:focus {
+	color: #fff;
+}
+
+#qunit-testrunner-toolbar label {
+	display: inline-block;
+	padding: 0 .5em 0 .1em;
+}
+
+#qunit-banner {
+	height: 5px;
+}
+
+#qunit-testrunner-toolbar {
+	padding: 0.5em 0 0.5em 2em;
+	color: #5E740B;
+	background-color: #eee;
+	overflow: hidden;
+}
+
+#qunit-userAgent {
+	padding: 0.5em 0 0.5em 2.5em;
+	background-color: #2b81af;
+	color: #fff;
+	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+
+#qunit-modulefilter-container {
+	float: right;
+}
+
+/** Tests: Pass/Fail */
+
+#qunit-tests {
+	list-style-position: inside;
+}
+
+#qunit-tests li {
+	padding: 0.4em 0.5em 0.4em 2.5em;
+	border-bottom: 1px solid #fff;
+	list-style-position: inside;
+}
+
+#qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
+	display: none;
+}
+
+#qunit-tests li strong {
+	cursor: pointer;
+}
+
+#qunit-tests li a {
+	padding: 0.5em;
+	color: #c2ccd1;
+	text-decoration: none;
+}
+#qunit-tests li a:hover,
+#qunit-tests li a:focus {
+	color: #000;
+}
+
+#qunit-tests li .runtime {
+	float: right;
+	font-size: smaller;
+}
+
+.qunit-assert-list {
+	margin-top: 0.5em;
+	padding: 0.5em;
+
+	background-color: #fff;
+
+	border-radius: 5px;
+	-moz-border-radius: 5px;
+	-webkit-border-radius: 5px;
+}
+
+.qunit-collapsed {
+	display: none;
+}
+
+#qunit-tests table {
+	border-collapse: collapse;
+	margin-top: .2em;
+}
+
+#qunit-tests th {
+	text-align: right;
+	vertical-align: top;
+	padding: 0 .5em 0 0;
+}
+
+#qunit-tests td {
+	vertical-align: top;
+}
+
+#qunit-tests pre {
+	margin: 0;
+	white-space: pre-wrap;
+	word-wrap: break-word;
+}
+
+#qunit-tests del {
+	background-color: #e0f2be;
+	color: #374e0c;
+	text-decoration: none;
+}
+
+#qunit-tests ins {
+	background-color: #ffcaca;
+	color: #500;
+	text-decoration: none;
+}
+
+/*** Test Counts */
+
+#qunit-tests b.counts                       { color: black; }
+#qunit-tests b.passed                       { color: #5E740B; }
+#qunit-tests b.failed                       { color: #710909; }
+
+#qunit-tests li li {
+	padding: 5px;
+	background-color: #fff;
+	border-bottom: none;
+	list-style-position: inside;
+}
+
+/*** Passing Styles */
+
+#qunit-tests li li.pass {
+	color: #3c510c;
+	background-color: #fff;
+	border-left: 10px solid #C6E746;
+}
+
+#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
+#qunit-tests .pass .test-name               { color: #366097; }
+
+#qunit-tests .pass .test-actual,
+#qunit-tests .pass .test-expected           { color: #999999; }
+
+#qunit-banner.qunit-pass                    { background-color: #C6E746; }
+
+/*** Failing Styles */
+
+#qunit-tests li li.fail {
+	color: #710909;
+	background-color: #fff;
+	border-left: 10px solid #EE5757;
+	white-space: pre;
+}
+
+#qunit-tests > li:last-child {
+	border-radius: 0 0 5px 5px;
+	-moz-border-radius: 0 0 5px 5px;
+	-webkit-border-bottom-right-radius: 5px;
+	-webkit-border-bottom-left-radius: 5px;
+}
+
+#qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
+#qunit-tests .fail .test-name,
+#qunit-tests .fail .module-name             { color: #000000; }
+
+#qunit-tests .fail .test-actual             { color: #EE5757; }
+#qunit-tests .fail .test-expected           { color: green;   }
+
+#qunit-banner.qunit-fail                    { background-color: #EE5757; }
+
+
+/** Result */
+
+#qunit-testresult {
+	padding: 0.5em 0.5em 0.5em 2.5em;
+
+	color: #2b81af;
+	background-color: #D2E0E6;
+
+	border-bottom: 1px solid white;
+}
+#qunit-testresult .module-name {
+	font-weight: bold;
+}
+
+/** Fixture */
+
+#qunit-fixture {
+	position: absolute;
+	top: -10000px;
+	left: -10000px;
+	width: 1000px;
+	height: 1000px;
+}