Importing dromaeo performance tests to src/chrome/test/data....

chrome/test/data/dromaeo/webrunner.js

Index: chrome/test/data/dromaeo/webrunner.js
===================================================================
--- chrome/test/data/dromaeo/webrunner.js	(revision 0)
+++ chrome/test/data/dromaeo/webrunner.js	(revision 0)
@@ -0,0 +1,760 @@
+(function(){
+	
+	// Populated from: http://www.medcalc.be/manual/t-distribution.php
+	// 95% confidence for N - 1 = 4
+	var tDistribution = 2.776;
+	
+	// The number of individual test iterations to do
+	var numTests = 5;
+	
+	// The type of run that we're doing (options are "runs/s" or "ms")
+	var runStyle = "runs/s";
+	
+	// A rough estimate, in seconds, of how long it'll take each test
+	// iteration to run
+	var timePerTest = runStyle === "runs/s" ? 1 : 0.5;
+	
+	// Initialize a batch of tests
+	//  name = The name of the test collection
+	this.startTest = function(name, version){
+		numloaded++;
+		if ( numloaded == totalTests )
+			setTimeout( init, 100 );
+
+		testName = name;
+		if ( !queues[testName] ) return;
+		testID = testName;
+		testNames[testID] = testName;
+		testVersions[testID] = version || 0;
+		testSummary[testID] = testSummaryNum[testID] = testDone[testID] = testNum[testID] = 0;
+
+		queues[testID].push(function(){
+			summary = 0;
+			dequeue();
+		});
+	};
+
+	// Anything that you want to have run in order, but not actually test
+	this.prep = function(fn){
+		if ( !queues[testName] ) return;
+		queues[testID].push(function(){
+			fn();
+			dequeue();
+		});
+	};
+
+	// End the tests and finalize the report
+	this.endTest = function(){
+		if ( !queues[testName] ) return;
+		// Save the summary output until all the test are complete
+		queues[testID].push(function(){
+			dequeue();
+		});
+	};
+
+	// Run a new test
+	//  name = The unique name of the test
+	//  num = The 'length' of the test (length of string, # of tests, etc.)
+	//  fn = A function holding the test to run
+	this.test = function(name, num, fn){
+		if ( !queues[testName] ) return;
+		// Save the summary output until all the test are complete
+		var curTest = testName, curID = testID;
+
+		if ( arguments.length === 3 ) {
+			if ( !nameDone[name] )
+				nameDone[name] = 0;
+			nameDone[name]++;
+	
+			if ( nameDone[name] != 3 )
+				return; 
+		} else {
+			fn = num;
+			num = 1;
+		}
+
+		time += timePerTest * numTests;
+
+		testNum[curID]++;
+
+		// Don't execute the test immediately
+		queues[testID].push(function(){
+			title = name;
+			var times = [], start, pos = 0, cur;
+			
+			setTimeout(function(){
+				// run tests
+				try {
+					if ( doShark(name) ) {
+						connectShark();
+						startShark();
+					}
+					
+					start = (new Date()).getTime();
+					
+					if ( runStyle === "runs/s" ) {
+						var runs = 0;
+						
+						cur = (new Date()).getTime();
+						
+						while ( (cur - start) < 1000 ) {
+							fn();
+							cur = (new Date()).getTime();
+							runs++;
+						}
+					} else {
+						fn();
+						cur = (new Date()).getTime();
+					}
+
+					if ( doShark(name) ) {
+						stopShark();
+						disconnectShark();
+					}
+					
+					// For making Median and Variance
+					if ( runStyle === "runs/s" ) {
+						times.push( (runs * 1000) / (cur - start) );
+					} else {
+						times.push( cur - start );
+					}
+				} catch( e ) {
+					alert("FAIL " + name + " " + num + e);
+					return;
+				}
+
+				if ( pos < numTests ) {
+					updateTime();
+					updateTestPos({curID: curID, collection: testNames[curID], version: testVersions[curID]});
+				}
+
+				if ( ++pos < numTests ) {
+					setTimeout( arguments.callee, 1 );
+				
+				} else {
+					var data = compute( times, numTests );
+
+					data.curID = curID;
+					data.collection = testNames[curID];
+					data.version = testVersions[curID];
+					data.name = title;
+					data.scale = num;
+								
+					logTest(data);
+			
+					dequeue();
+				}
+			}, 1);
+		});
+
+		function compute(times, runs){
+			var results = {runs: runs}, num = times.length;
+
+			times = times.sort(function(a,b){
+				return a - b;
+			});
+
+			// Make Sum
+			results.sum = 0;
+
+			for ( var i = 0; i < num; i++ )
+				results.sum += times[i];
+
+			// Make Min
+			results.min = times[0];
+					  
+			// Make Max
+			results.max = times[ num - 1 ];
+
+			// Make Mean
+			results.mean = results.sum / num;
+			
+			// Make Median
+			results.median = num % 2 == 0 ?
+				(times[Math.floor(num/2)] + times[Math.ceil(num/2)]) / 2 :
+				times[Math.round(num/2)];
+			
+			// Make Variance
+			results.variance = 0;
+
+			for ( var i = 0; i < num; i++ )
+				results.variance += Math.pow(times[i] - results.mean, 2);
+
+			results.variance /= num - 1;
+					
+			// Make Standard Deviation
+			results.deviation = Math.sqrt( results.variance );
+
+			// Compute Standard Errors Mean
+			results.sem = (results.deviation / Math.sqrt(results.runs)) * tDistribution;
+
+			// Error
+			results.error = ((results.sem / results.mean) * 100) || 0;
+
+			return results;
+		}
+	};
+	
+	// All the test data
+	var tests;
+	
+	// The number of test files to load
+	var totalTests = 0;
+	
+	// The number of test files loaded
+	var numloaded = 0;
+	
+	// Queue of functions to run
+	var queue = [];
+	var queues = {};
+
+	var catnames = {
+		dromaeo: "Dromaeo JavaScript Tests",
+		sunspider: "SunSpider JavaScript Tests",
+		"v8": "V8 JavaScript Tests",
+		dom: "DOM Core Tests",
+		jslib: "JavaScript Library Tests",
+		cssquery: "CSS Selector Tests"
+	};
+
+	
+	var testElems = {};
+	var testNum = {};
+	var testDone = {};
+	var testNames = {};
+	var testVersions = {};
+	var dataStore = [];
+	var names = [];
+	var interval;
+	var totalTime = 0;
+	var time = 0;
+	var title, testName, testID, testSummary = {} , testSummaryNum = {}, maxTotal = 0, maxTotalNum = 0;
+	var nameDone = {};
+	
+	// Query String Parsing
+	var search = (window.location.search || "?").substr(1);
+
+	search = search.replace(/&runStyle=([^&]+)/, function(all, type){
+		runStyle = type;
+		return "";
+	});
+
+	var parts = search.split("&");
+
+	if ( parts[0] === "recommended" ) {
+		parts[0] = "dromaeo|sunspider|v8|dom|jslib";
+	}
+
+	var none = !parts[0] || parts[0].match(/=/);
+	var filter = parts.length && !parts[0].match(/=/) && parts[0] !== "all" ?
+		new RegExp(parts.shift(), "i") :
+		/./;
+
+	// To enable shark debugging add &shark to the end of the URL
+	var doShark = function(name) { return false; };
+	for ( var i = 0; i < parts.length; i++ ) {
+		var m = /^shark(?:=(.*))?$/.exec(parts[i]);
+		if (m) {
+			if (m[1] === undefined) {
+				doShark = function(name) { return true; };
+			}
+			else {
+				var sharkMatch = new RegExp(m[1]);
+				doShark = function(name) {
+					return sharkMatch.test(name);
+				};
+			}
+		}
+
+		m = /^numTests=(\d+)$/.exec(parts[i]);
+		if (m)
+			numTests = Number(m[1]);
+	}
+
+	jQuery(function(){
+		var id = search.match(/id=([\d,]+)/);
+
+		if ( none && !id ) {
+			$("#overview").hide();
+			return;
+		} 
+
+		var cat = filter.toString().slice(1,-2);
+
+		if ( catnames[cat] ) {
+			$("#overview span:first").html( catnames[cat] );
+
+			if ( catnames[cat].length > 22 ) {
+				$("#overview span:first").css("font-size", 22);
+			}
+		}
+
+		$("#tests").hide();
+
+		jQuery.getJSON("tests/MANIFEST.json", function(json){
+			tests = json;
+
+			names = [];
+
+			for ( var name in tests )
+				// Don't load tests that we aren't looking for
+				if ( filter.test( name ) )
+					names.push( name );
+
+			names = names.sort(function(a, b){
+				return tests[a].name < tests[b].name ?  -1 :
+					tests[a].name == tests[b].name ?  0 : 1;
+			});
+
+			// Check if we're loading a specific result set
+			// ?id=NUM
+			if ( id ) {
+				jQuery.ajax({
+					url: "store.php?id=" + id[1],
+					dataType: "json",
+					success: function(data){
+						resultsLoaded(id[1], data);
+					}
+				});
+
+			// Otherwise we're loading a normal set of tests
+			} else {
+				$("#wrapper").append("<br style='clear:both;'/><center><a href='?" + names.join("|") + "'>Re-run tests</a></center>");
+
+				for ( var i = 0; i < names.length; i++ ) (function(name){
+					var test = tests[name];
+
+					queues[name] = [];
+					makeElem(name);
+					initTest(name);
+					
+					totalTests++;
+					
+					// Check if we're loading an HTML file
+					if ( test.file.match(/html$/) ) {
+						var iframe = document.createElement("iframe");
+						iframe.style.height = "1px";
+						iframe.style.width = "1px";
+						iframe.src = "tests/" + test.file;
+						document.body.appendChild( iframe );
+					
+					// Otherwise we're loading a pure-JS test
+					} else {
+						jQuery.getScript("tests/" + test.file);
+					}
+				})(names[i]);
+			}
+		});
+	});
+
+	// Remove the next test from the queue and execute it
+	function dequeue(){
+		if ( interval && queue.length ) {
+			queue.shift()();
+			
+		} else if ( queue.length == 0 ) {
+			interval = false;
+			time = 0;
+			
+			$("#overview input").remove();
+			updateTimebar();
+	
+			if ( dataStore && dataStore.length ) {
+				$("body").addClass("alldone");
+				var div = jQuery("<div class='results'>Saving...</div>").insertBefore("#overview");
+				jQuery.ajax({
+					type: "POST",
+					url: "store.php",
+					data: "data=" + encodeURIComponent(JSON.stringify(dataStore)) + "&style=" + runStyle,
+					success: function(id){
+						var url = window.location.href.replace(/\?.*$/, "") + "?id=" + id;
+						div.html("Results saved. You can access them at a later time at the following URL:<br/><strong><a href='" + url + "'>" + url + "</a></strong></div>");
+					}
+				});
+			}
+		}
+	}
+	
+	function updateTimebar(){
+		$("#timebar").html("<span><strong>" + (runStyle === "runs/s" ? Math.pow(Math.E, maxTotal / maxTotalNum) : maxTotal).toFixed(2) + "</strong>" + runStyle + " (Total)</span>");
+	}
+	
+	// Run once all the test files are fully loaded
+	function init(){
+		for ( var n = 0; n < names.length; n++ ) {
+			queue = queue.concat( queues[ names[n] ] );
+		}
+
+		totalTime = time;
+		time += timePerTest;
+		updateTime();
+		
+		$("#pause")
+			.val("Run")
+			.click(function(){
+				if ( interval ) {
+					interval = null;
+					this.value = "Run";
+				} else {
+					if ( !interval ) {
+						interval = true;
+						dequeue();
+					}
+					this.value = "Pause";
+				}
+			});
+	}
+
+	function initTest(curID){
+		$("<div class='result-item'></div>")
+			.append( testElems[ curID ] )
+			.append( "<p>" + (tests[curID] ? tests[ curID ].desc : "") + "<br/><a href='" + 
+				(tests[curID] && tests[curID].origin ? tests[ curID ].origin[1] : "") + "'>Origin</a>, <a href='tests/" +
+				(tests[curID] ? tests[ curID ].file : "") + "'>Source</a>, <b>Tests:</b> " +
+				(tests[curID] && tests[curID].tags ? tests[ curID ].tags.join(", ") : "") + "</p>" )
+			.append( "<ol class='results'></ol>" )
+			.appendTo("#main");
+	}
+	
+	function resultsLoaded(id, datas){
+		var results = {};
+		var runs = {};
+		var output = "";
+		var excluded = [];
+		var overview = document.getElementById("overview");
+
+		for ( var d = 0; d < datas.length; d++ ) {
+			var data = datas[d];
+			
+			runStyle = data.style;
+
+			if ( datas.length == 1 ) {
+				$("#overview").before("<div class='results'>Viewing test run #" + id +
+					", run on: " + data.created_at + " by:<br>" + data.useragent + "</div>");
+			}
+
+			runs[data.id] = data;
+			runs[data.id].mean = 0;
+			runs[data.id].error = 0;
+			runs[data.id].num = 0;
+			runs[data.id].name = (data.useragent.match(/(MSIE [\d.]+)/) ||
+				data.useragent.match(/((?:WebKit|Firefox|Shiretoko|Opera)\/[\w.]+)/) || [0,data.id])[1];
+
+			for ( var i = 0; i < data.results.length; i++ ) {
+				var result = data.results[i];
+				var curID = result.collection;
+				var run = result.run_id;
+				
+				result.version += data.style;
+
+				if ( !results[curID] )
+					results[curID] = {tests:{}, total:{}, version: result.version};
+
+				if ( results[curID].version == result.version ) {
+					if ( !results[curID].total[run] ) {
+						results[curID].total[run] = {max:0, mean:0, median:0, min:0, deviation:0, error:0, num:0};
+						results[curID].tests[run] = [];
+					}
+					
+					result.error = ((((result.deviation / Math.sqrt(result.runs)) * tDistribution) / result.mean) * 100) || 0;
+					results[curID].tests[run].push( result );
+
+					var error = (parseFloat(result.error) / 100) * parseFloat(result.mean);
+					error = (runStyle === "ms" ? error : error == 0 ? 0 : Math.log(error));
+					var total = results[curID].total[run];
+					total.num++;
+
+					for ( var type in total ) {
+						if ( type == "error" ) {
+							total.error += error;
+						} else if ( type == "mean" ) {
+							total.mean += (runStyle === "ms" ? parseFloat(result.mean) : Math.log(parseFloat(result.mean)));
+						} else if ( type !== "num" ) {
+							total[type] += parseFloat(result[type]);
+						}
+					}
+					
+					runs[run].num++;
+					runs[run].mean += runStyle === "ms" ? parseFloat(result.mean) : Math.log(parseFloat(result.mean));
+					runs[run].error += error;
+				}
+			}
+		}
+
+		var runTests = [];
+
+		if ( datas.length == 1 ) {
+			$("body").addClass("alldone");
+
+			for ( var i = 0; i < data.results.length; i++ ) {
+				var item = data.results[i];
+				var result = item.curID = item.collection;
+
+				if ( !filter.test(result) )
+					continue;
+
+				if ( !testElems[result] ) {
+					runTests.push(result);
+					makeElem( result );
+					initTest( result );
+				}
+
+				// Compute Standard Errors Mean
+				item.sem = (item.deviation / Math.sqrt(item.runs)) * tDistribution;
+
+				// Error
+				item.error = ((item.sem / item.mean) * 100) || 0;
+
+				logTest( item );
+
+				// testDone, testNum, testSummary
+				testDone[ result ] = numTests - 1;
+				testNum[ result ] = 1;
+
+				updateTestPos( item );
+			}
+
+			$("div.result-item").addClass("done");
+
+			totalTime = time = timePerTest;
+			updateTime();
+
+			$("#overview input").remove();
+			updateTimebar();
+		} else {
+			// Remove results where there is only one comparison set
+			for ( var id in results ) {
+				var num = 0;
+				
+				for ( var ntest in results[id].tests ) {
+					num++;
+					if ( num > 1 )
+						break;
+				}
+				
+				if ( num <= 1 ) {
+					excluded.push( id );
+					delete results[id];
+				}
+			}
+		
+			var preoutput = "<tr><td></td>";
+			for ( var run in runs )
+				preoutput += "<th><a href='?id=" + run + "'>" + runs[run].name + "</a></th>";
+			//preoutput += "<th>Winning %</th></tr>";
+			preoutput += "</tr>";
+
+			for ( var result in results ) {
+				// Skip results that we're filtering out
+				if ( !filter.test(result) )
+					continue;
+
+				runTests.push(result);
+
+				if ( runStyle === "runs/s" ) {
+					for ( var run in runs ) {
+						var mean = results[result].total[run].mean - 0;
+						var error = results[result].total[run].error - 0;
+
+						mean = Math.pow(Math.E, mean / results[result].total[run].num);
+						error = Math.pow(Math.E, error / results[result].total[run].num);
+						results[result].total[run].mean = mean;
+						results[result].total[run].error = error;
+					}
+				}
+
+				var name = tests[result] ? tests[result].name : result;
+				var tmp = processWinner(results[result].total);
+
+				output += "<tr><th class='name'><span onclick='toggleResults(this.nextSibling);'>&#9654; </span>" +
+					"<a href='' onclick='return toggleResults(this);'>" + name + "</a></th>";
+
+				for ( var run in runs ) {
+					var mean = results[result].total[run].mean - 0;
+					var error = results[result].total[run].error - 0;
+		
+					output += "<td class='" + (tmp[run] || '') + "'>" + mean.toFixed(2) + "<small>" + runStyle + " &#177;" + ((error / mean) * 100).toFixed(2) + "%</small></td>";
+				}
+				
+				//showWinner(tmp);
+				output += "</tr>";
+
+				var _tests = results[result].tests, _data = _tests[run], _num = _data.length;
+				for ( var i = 0; i < _num; i++ ) {
+					output += "<tr class='onetest hidden'><td><small>" + _data[i].name + "</small></td>";
+					for ( var run in runs ) {
+						output += "<td>" + (_tests[run][i].mean - 0).toFixed(2) + "<small>" + runStyle + " &#177;" + (_tests[run][i].error - 0).toFixed(2) + "%</small></td>";
+					}
+					output += "<td></td></tr>";
+				}
+			}
+
+			if ( runStyle === "runs/s" ) {
+				for ( var run in runs ) {
+					runs[run].mean = Math.pow(Math.E, runs[run].mean / runs[run].num);
+					runs[run].error = Math.pow(Math.E, runs[run].error / runs[run].num);
+				}
+			}
+	
+			var tmp = processWinner(runs);
+			var totaloutput = "";
+
+			if ( runStyle === "ms" ) {
+				totaloutput += "<tr><th class='name'>Total:</th>";
+			} else {
+				totaloutput += "<tr><th class='name'>Total Score:</th>";
+			}
+
+			for ( var run in runs ) {
+				totaloutput += "<th class='name " + (tmp[run] || '') + "' title='" + (tmp[run + "title"] || '') + "'>" + runs[run].mean.toFixed(2) + "<small>" + runStyle + " &#177;" + ((runs[run].error / runs[run].mean) * 100).toFixed(2) + "%</small></th>";
+			}
+
+			//showWinner(tmp);
+			totaloutput += "</tr>";
+
+			overview.className = "";
+			overview.innerHTML = "<div class='resultwrap'><table class='results'>" + preoutput + totaloutput + output + totaloutput + "</table>" + (excluded.length ? "<div style='text-align:left;'><small><b>Excluded Tests:</b> " + excluded.sort().join(", ") + "</small></div>" : "") + "</div>";
+		}
+
+		$("#wrapper").append("<center><a href='?" + runTests.join("|") + "'>Re-run tests</a></center>");
+		
+		function showWinner(tmp){
+			if ( datas.length > 1 ) {
+				if ( tmp.tie )
+					output += "<th>Tie</th>";
+				else
+					output += "<th>" + tmp.diff + "%</th>";
+			}
+		}
+	}
+
+	this.toggleResults = function(elem){
+		var span = elem.previousSibling;
+
+		elem.blur();
+		elem = elem.parentNode.parentNode.nextSibling;
+
+		span.innerHTML = elem.className.indexOf("hidden") < 0 ? "&#9654; " : "&#9660; ";
+
+		while ( elem && elem.className.indexOf("onetest") >= 0 ) {
+			elem.className = "onetest" + (elem.className.indexOf("hidden") >= 0 ? " " : " hidden");
+			elem = elem.nextSibling;
+		}
+
+		return false;
+	};
+
+	function updateTime(){
+		time -= timePerTest;
+		$("#left").html(Math.floor(time / 60) + ":" + (time % 60 < 10 ? "0" : "" ) + Math.floor(time % 60));
+
+		var w = ((totalTime - time) / totalTime) * 100;
+
+		$("#timebar").width((w < 1 ? 1 : w) + "%");
+	}
+	
+	function logTest(data){
+		// Keep a running summary going
+		data.mean = parseFloat(data.mean);
+		var mean = (runStyle === "runs/s" ? Math.log(data.mean) : data.mean);
+		testSummary[data.curID] = (testSummary[data.curID] || 0) + mean;
+		testSummaryNum[data.curID] = (testSummaryNum[data.curID] || 0) + 1;
+		
+		maxTotal += mean;
+		maxTotalNum++;
+
+		testDone[data.curID]--;
+		updateTestPos(data);
+
+		testElems[data.curID].next().next().append("<li><b>" + data.name + 
+			":</b> " + data.mean.toFixed(2) + "<small>" + runStyle + " &#177;" + data.error.toFixed(2) + "%</small></li>");
+
+		dataStore.push(data);
+	}
+
+	function updateTestPos(data, update){
+		if ( !update )
+			testDone[data.curID]++;
+
+		var per = (testDone[data.curID] / (testNum[data.curID] * numTests)) * 100;
+
+		if ( update )
+			per = 1;
+		
+		var mean = (runStyle === "runs/s" ?
+			Math.pow(Math.E, testSummary[data.curID] / testSummaryNum[data.curID]) :
+			testSummary[data.curID]);
+
+		testElems[data.curID].html("<b>" + (tests[data.curID] ? tests[data.curID].name : data.curID) +
+			":</b> <div class='bar'><div style='width:" +
+			per + "%;'>" + (per >= 100 ? "<span>" + mean.toFixed(2) + runStyle + "</span>" : "") + "</div></div>");
+
+		if ( per >= 100 && testSummary[data.curID] > 0 ) {
+			testElems[data.curID].parent().addClass("done");
+		}
+	}
+	
+	function processWinner(data){
+		var minVal = -1, min2Val = -1, min, min2;
+
+		for ( var i in data ) {
+			var total = data[i].mean;
+			if ( minVal == -1 || (runStyle === "ms" && total <= minVal || runStyle === "runs/s" && total >= minVal) ) {
+				min2Val = minVal;
+				min2 = min;
+				minVal = total;
+				min = i;
+			} else if ( min2Val == -1 || (runStyle === "ms" && total <= minVal || runStyle === "runs/s" && total >= min2Val) ) {
+				min2Val = total;
+				min2 = i;
+			}
+		}
+
+		var tieVal = (runStyle === "ms" ? minVal : min2Val) + data[min].error + data[min2].error;
+
+		var ret = {
+			winner: min,
+			diff: runStyle === "ms" ?
+				-1 * Math.round((1 - (min2Val / minVal)) * 100) :
+				Math.round(((minVal / min2Val) - 1) * 100),
+			tie: minVal == min2Val || (runStyle === "ms" ? tieVal >= min2Val : tieVal >= minVal)
+		};
+
+		ret.tie = ret.tie || ret.diff == 0;
+
+		if ( ret.tie ) {
+			ret[ min ] = 'tie';
+			ret[ min2 ] = 'tie';
+			ret[ min + 'title' ] = "Tied with another run.";
+			ret[ min2 + 'title' ] = "Tied with another run.";
+		} else {
+			ret[ min ] = 'winner';
+			if ( min2Val > -1 ) {
+				ret[ min + 'title' ] = "Won by " + ret.diff + "%.";
+			}
+		}
+
+		return ret;
+	}
+	
+	function makeElem(testID){
+/*
+		if ( tests[testID] ) {
+			var cat = tests[testID].category, catsm = cat.replace(/[^\w]/g, "-");
+			if ( !$("#" + catsm).length ) {
+				$("#main").append("<h2 id='" + catsm + "' class='test'><a href='?cat=" + cat +"'>" + cat + '</a><div class="bar"><div id="timebar" style="width:25%;"><span class="left">Est.&nbsp;Time:&nbsp;<strong id="left">0:00</strong></span></div></div>');
+			}
+		}
+*/
+		
+		testElems[testID] = $("<div class='test'></div>")
+			.click(function(){
+				var next = jQuery(this).next().next();
+				if ( next.children().length == 0 ) return;
+				var display = next.css("display");
+				next.css("display", display == 'none' ? 'block' : 'none');
+			});
+
+		updateTestPos({curID: testID, collection: tests[testID] ? tests[testID].name : testID, version: testVersions[testID]}, true);
+	}
+})();