├── .gitignore
├── tests
    ├── modules
    │   ├── a.js
    │   ├── b.js
    │   ├── c.js
    │   ├── d.js
    │   ├── has-plugin-test.js
    │   └── test-branch.js
    ├── base.gif
    ├── requirejs-plugin.html
    ├── report.php
    ├── results.php
    ├── runTests.html
    └── require.js
├── package.json
├── detect
    ├── strings.js
    ├── script.js
    ├── function.js
    ├── dates.js
    ├── json.js
    ├── __base.js
    ├── video.js
    ├── audio.js
    ├── graphics.js
    ├── array.js
    ├── events.js
    ├── object.js
    ├── form.js
    ├── css.js
    ├── features.js
    ├── dom.js
    └── bugs.js
├── _plugin.js
├── has.js
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | tests/results.data


--------------------------------------------------------------------------------
/tests/modules/a.js:
--------------------------------------------------------------------------------
1 | define([], function(){
2 | 	return "a";
3 | });


--------------------------------------------------------------------------------
/tests/modules/b.js:
--------------------------------------------------------------------------------
1 | define([], function(){
2 | 	return "b";
3 | });


--------------------------------------------------------------------------------
/tests/modules/c.js:
--------------------------------------------------------------------------------
1 | define([], function(){
2 | 	return "c";
3 | });


--------------------------------------------------------------------------------
/tests/modules/d.js:
--------------------------------------------------------------------------------
1 | define([], function(){
2 | 	return "d";
3 | });


--------------------------------------------------------------------------------
/tests/base.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kriszyp/has.js/master/tests/base.gif


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | 	"name": "has",
3 | 	"directories": {
4 | 		"lib": "./detect"
5 | 	},
6 | 	"main": "./has.js"
7 | }
8 | 


--------------------------------------------------------------------------------
/tests/modules/has-plugin-test.js:
--------------------------------------------------------------------------------
1 | define(["has"], function(has){
2 | 	has.add("true", true);
3 | 	has.add("false", function(){
4 | 		return false;
5 | 	});
6 | 	return has;
7 | });


--------------------------------------------------------------------------------
/tests/modules/test-branch.js:
--------------------------------------------------------------------------------
1 | define(["has!dom?./a:./b", "has/array!array-every?./a:./b", "./has-plugin-test!true?false?./a:false?./b:./c:./d", "./has-plugin-test!false?a"], function(dom, every, branch, none){
2 | 	console.assert(dom === "a","dom");
3 | 	console.assert(every === ([].every ? "a": "b"), "every");
4 | 	console.assert(branch === "c", "branch");
5 | 	console.assert(none === undefined, "undefined");
6 | 	console.log("passed tests");
7 | });


--------------------------------------------------------------------------------
/detect/strings.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 | 	
 4 |     var addtest = has.add;
 5 | 
 6 |     // String tests
 7 |     addtest("string-trim", function(){
 8 |         return ({}).toString.call(''.trim) == "[object Function]";
 9 |     });
10 | 
11 | 	return has;
12 | });
13 | })(typeof define != "undefined" ? define : function(deps, factory){
14 | 	factory(has); // use global has() if a module system is not available 
15 | });
16 | 
17 | 


--------------------------------------------------------------------------------
/detect/script.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 | 	
 4 |     var addtest = has.add;
 5 | 
 6 |     if(!has("dom")){ return; }
 7 | 
 8 |     var script = document.createElement("script");
 9 | 
10 |     addtest("script-defer", function(){
11 |         return ("defer" in script);
12 |     });
13 | 
14 |     addtest("script-async", function(){
15 |         return ("async" in script);
16 |     });
17 | 	return has;
18 | });
19 | })(typeof define != "undefined" ? define : function(deps, factory){
20 | 	factory(has); // use global has() if a module system is not available 
21 | });
22 | 
23 | 


--------------------------------------------------------------------------------
/tests/requirejs-plugin.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |         <title>has.js as RequireJS module and plugin</title>
 5 | 
 6 |         <script src="../../requirejs/require.js"></script>
 7 |         <script>
 8 |         	require({
 9 |         		baseUrl:"../../",
10 |         		packages: [
11 |         			{
12 |         				name:"has",
13 |         				location:"has.js",
14 |         				lib:"./detect",
15 |         				main:"./has"
16 |         			}
17 |         		]
18 |         	});
19 |         	require(["has.js/tests/modules/test-branch"]);
20 |         </script>
21 | 
22 |     </head>
23 |     <body>
24 | 
25 |     </body>
26 | </html>
27 | 


--------------------------------------------------------------------------------
/detect/function.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 | 	
 4 |     var addtest = has.add,
 5 |     	toString = {}.toString,
 6 |         FUNCTION_CLASS = "[object Function]";
 7 | 
 8 |     // Function tests
 9 |     addtest("function-bind", function(){
10 |         return toString.call(Function.bind) == FUNCTION_CLASS;
11 |     });
12 | 
13 |     addtest("function-caller", function(){ 
14 |         function test(){ return test.caller !== undefined; }
15 |         return test();
16 |     });
17 | 
18 | 	return has;
19 | });
20 | })(typeof define != "undefined" ? define : function(deps, factory){
21 | 	factory(has); // use global has() if a module system is not available 
22 | });
23 | 
24 | 


--------------------------------------------------------------------------------
/tests/report.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |     <title>has.js submissions</title>
 5 | </head>
 6 | <body>
 7 |   
 8 |     <h1>FTW</h1>
 9 | 
10 |     <?php
11 | 
12 |     if(!empty($_POST)){
13 |         $data = json_encode($_POST);
14 |         $fp = @fopen("results.data", "a+");
15 |         if($fp){
16 |             fputs($fp, $data . "\n");
17 |             fclose($fp);
18 |             print "<p>Data stashed. Really, <em>Thanks!</em></p>";
19 |         }else{
20 |             print "<p>It appears there was an issue.</p>";
21 |         }
22 |     }else{
23 |         print "<p>No data set sent along?</p>";
24 |     }
25 | 
26 | ?>
27 | <p><a href="runTests.html">back to runTests.html</a></p>
28 | </body>
29 | </html>


--------------------------------------------------------------------------------
/detect/dates.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 | 
 4 |     var toString = {}.toString,
 5 |     	addtest = has.add,
 6 |         NEW_DATE = new Date,
 7 |         FUNCTION_CLASS = "[object Function]";
 8 | 
 9 |     // Date tests
10 |     addtest("date-toisostring", function(){
11 |         return toString.call(NEW_DATE.toISOString) == FUNCTION_CLASS;
12 |     });
13 | 
14 |     addtest("date-tojson", function(){
15 |         return toString.call(NEW_DATE.toJSON) == FUNCTION_CLASS;
16 |     });
17 | 
18 |     addtest("date-now", function(){
19 |         return toString.call(Date.now) == FUNCTION_CLASS;
20 |     });
21 | 
22 | 	return has;
23 | });
24 | })(typeof define != "undefined" ? define : function(deps, factory){
25 | 	factory(has); // the use global has() if a module system is not available 
26 | });
27 | 
28 | 


--------------------------------------------------------------------------------
/detect/json.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 | 	
 4 |     var addtest = has.add,
 5 |     	STR = "string",
 6 |         FN = "function"
 7 |     ;
 8 | 
 9 |     // JSON tests
10 |     addtest("json-parse", function(g){
11 |         var parsed, supported = false;
12 |         if("JSON" in g && typeof JSON.parse == FN){
13 |           parsed = JSON.parse('{"a":true}');
14 |           supported = !!(parsed && parsed.a);
15 |         }
16 |         return supported;
17 |     });
18 | 
19 |     addtest("json-stringify", function(g){
20 |         return ("JSON" in g) && typeof JSON.stringify == FN && JSON.stringify({a:true}) == '{"a":true}';
21 |     });
22 | 
23 | 	return has;
24 | });
25 | })(typeof define != "undefined" ? define : function(deps, factory){
26 | 	factory(has); // use global has() if a module system is not available 
27 | });
28 | 


--------------------------------------------------------------------------------
/detect/__base.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 | 	
 4 |     var addtest = has.add,
 5 |     	STR = "string",
 6 |         FN = "function"
 7 |     ;
 8 | 
 9 |     // above this line is "boilerplate" template for all test groupings.
10 |     // while each module has it's own enclosing function, these strings
11 |     // and aliases passed through the self-executing-anon-function are
12 |     // common across all tests. This is so we can blindly pull parts
13 |     // of other test modules into a single rollup. Tests should be 
14 |     // "as standalone as humanly possible", with some exceptions (and 
15 |     // then, only for the benefit of performance and sharing)
16 | 
17 |     // put your tests here, eg:
18 |     addtest("has-test-skeleton", function(global, document, anElement){
19 |         return true; // Boolean
20 |     });
21 | 	return has;
22 | });
23 | })(typeof define != "undefined" ? define : function(deps, factory){
24 | 	factory(has); // use global has() if a module system is not available 
25 | });
26 | 
27 | 


--------------------------------------------------------------------------------
/detect/video.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 | 	
 4 |     var addtest = has.add;
 5 | 
 6 |     if(!has("dom")){ return; }
 7 | 
 8 |     var video = document.createElement("video");
 9 | 
10 |     addtest("video", function(){
11 |         return has.isHostType(video, "canPlayType");
12 |     });
13 | 
14 |     // note: in FF 3.5.1 and 3.5.0 only, "no" was a return value instead of empty string.
15 | 
16 |     addtest("video-h264-baseline", function(){
17 |         // workaround required for ie9, who doesn't report video support without audio codec specified.
18 |         //   bug 599718 @ msft connect
19 |         var h264 = 'video/mp4; codecs="avc1.42E01E';
20 |         return has("video") && (video.canPlayType(h264 + '"') || video.canPlayType(h264 + ', mp4a.40.2"'));
21 |     });
22 | 
23 |     addtest("video-ogg-theora", function(){
24 |         return has("video") && video.canPlayType('video/ogg; codecs="theora, vorbis"');
25 |     });
26 | 
27 |     addtest("video-webm", function(){
28 |         return has("video") && video.canPlayType('video/webm; codecs="vp8, vorbis"');
29 |     });
30 | 
31 | 	return has;
32 | });
33 | })(typeof define != "undefined" ? define : function(deps, factory){
34 | 	factory(has); // use global has() if a module system is not available 
35 | });
36 | 
37 | 


--------------------------------------------------------------------------------
/_plugin.js:
--------------------------------------------------------------------------------
 1 | define(["require"], function(require){
 2 | 	// this allows us to use has as a dependency plugin for RequireJS and other AMD loaders (like Dojo). The syntax supports the ternary operation for branching:
 3 | 	// define("my-module", ["has!array-every?module-using-every:module-using-for-loop"], function(arrayModule){
 4 | 	// });
 5 | 	var has;
 6 | 	return function(id, parentRequire, loaded, config){
 7 | 		// split into the different branches, based on has features
 8 | 		// first parse the id
 9 | 		var tokens = id.match(/[\?:]|[^:\?]*/g), i = 0;
10 | 		has = has || config.isBuild ?
11 | 			function(feature){
12 | 				return config[feature];
13 | 			} :
14 | 			require("has");
15 | 		function get(skip){
16 | 			var operator, term = tokens[i++];
17 | 			if(term == ":"){
18 | 				// empty string module name, resolves to undefined
19 | 				return;
20 | 			}else{
21 | 				// postfixed with a ? means it is a feature to branch on, the term is the name of the feature
22 | 				if(tokens[i++] == "?"){
23 | 					if(!skip && has(term)){
24 | 						// matched the feature, get the first value from the options 
25 | 						return get();
26 | 					}else{
27 | 						// did not match, get the second value, passing over the first
28 | 						get(true);
29 | 						return get(skip);
30 | 					}
31 | 				}
32 | 				// a module
33 | 				return term;
34 | 			}
35 | 		}
36 | 		id = get();
37 | 		if(id){
38 | 			parentRequire([id], loaded);
39 | 		}else{
40 | 			loaded();
41 | 		}
42 | 	};
43 | });


--------------------------------------------------------------------------------
/detect/audio.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 | 
 4 |     var CAN_PLAY_GUESSES = { "maybe": 1, "probably": 1 },
 5 |     	addtest = has.add,
 6 |         STR = "string",
 7 |         FN = "function"
 8 |     ;
 9 | 
10 |     if(!has("dom")){ return; }
11 | 
12 |     var audio = document.createElement("audio");
13 | 
14 |     addtest("audio", function(){
15 |         return has.isHostType(audio, "canPlayType");
16 |     });
17 | 
18 |     // TODO: evaluate if these tests fit within the has.js scope because they don't
19 |     // provide a definate yes or no answer
20 |     //
21 |     // NOTE: Opera returns a false-negative in this test if there are single spaces
22 |     // around the codes value, e.g. codes='vorbis'
23 |     addtest("audio-ogg", function(){
24 |         return has("audio") && !!CAN_PLAY_GUESSES[audio.canPlayType("audio/ogg; codecs=vorbis")];
25 |     });
26 | 
27 |     addtest("audio-mp3", function(){
28 |         return has("audio") && !!CAN_PLAY_GUESSES[audio.canPlayType("audio/mpeg;")];
29 |     });
30 | 
31 |     addtest("audio-wav", function(){
32 |         return has("audio") && !!CAN_PLAY_GUESSES[audio.canPlayType("audio/wav; codecs=1")];
33 |     });
34 | 
35 |     addtest("audio-m4a", function(){
36 |         return has("audio") && !!(CAN_PLAY_GUESSES[audio.canPlayType("audio/x-m4a;")] ||
37 |             CAN_PLAY_GUESSES[audio.canPlayType("audio/aac;")]);
38 |     });
39 | 	return has;
40 | 
41 | });
42 | })(typeof define != "undefined" ? define : function(deps, factory){
43 | 	factory(has); // the use global has() if a module system is not available 
44 | });
45 | 


--------------------------------------------------------------------------------
/detect/graphics.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has", "./dom"], function(has){
 3 | 	
 4 |     var addtest = has.add,
 5 |     	FN = "function",
 6 | 		toString = {}.toString,
 7 |         STR = "string",
 8 |         FN = "function"
 9 |     ;
10 | 
11 |     if(!has("dom")){ return; }
12 | 
13 |     addtest("canvas", function(g){
14 |         return has.isHostType(g, "CanvasRenderingContext2D");
15 |     });
16 | 
17 |     addtest("canvas-webgl", function(g){
18 |         return has.isHostType(g, "WebGLRenderingContext");
19 |     });
20 | 
21 |     addtest("canvas-text", function(g, d){
22 |         return has("canvas") && typeof d.createElement("canvas").getContext("2d").fillText == FN;
23 |     });
24 | 
25 | 
26 |     var svgNS = "http://www.w3.org/2000/svg";
27 | 
28 |     addtest("svg", function(g){
29 |         return ("SVGAngle" in g);
30 |     });
31 | 
32 |     addtest("svg-inlinesvg", function(g, d, el){
33 |         var supported = null;
34 |         el.innerHTML = "<svg/>";
35 |         supported = (el.firstChild && el.firstChild.namespaceURI) == svgNS;
36 |         el.innerHTML = "";
37 |         return supported;
38 |     });
39 | 
40 |     addtest("svg-smil", function(g, d){
41 |         return has("dom-createelementns") && /SVG/.test(toString.call(d.createElementNS(svgNS, "animate")));
42 |     });
43 | 
44 |     addtest("svg-clippaths", function(g, d){
45 |         return has("dom-createelementns") && /SVG/.test(toString.call(d.createElementNS(svgNS, "clipPath")));
46 |     });
47 | 
48 |     addtest("vml", function(g, d, el){
49 |         /*
50 |           Sources:
51 |           http://en.wikipedia.org/wiki/Vector_Markup_Language
52 |           http://msdn.microsoft.com/en-us/library/bb263897(v=VS.85).aspx
53 |           http://www.svg-vml.net/Zibool-compar.htm
54 |         */
55 |         el.innerHTML = "<v:shape adj=\"1\"/>";
56 |         var supported = ("adj" in el.firstChild);
57 |         el.innerHTML = "";
58 |         return supported;
59 |     });
60 | 
61 | 	return has;
62 | });
63 | })(typeof define != "undefined" ? define : function(deps, factory){
64 | 	factory(has); // use global has() if a module system is not available 
65 | });
66 | 
67 | 


--------------------------------------------------------------------------------
/detect/array.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 |     var toString = {}.toString,
 4 |     	addtest = has.add,
 5 |         EMPTY_ARRAY = [],
 6 |         FUNCTION_CLASS = "[object Function]";
 7 | 
 8 |     // Array tests
 9 |     addtest("array-every", function(){
10 |         return toString.call(EMPTY_ARRAY.every) == FUNCTION_CLASS;
11 |     });
12 | 
13 |     addtest("array-filter", function(){
14 |         return toString.call(EMPTY_ARRAY.filter) == FUNCTION_CLASS;
15 |     });
16 | 
17 |     addtest("array-foreach", function(){
18 |         return toString.call(EMPTY_ARRAY.forEach) == FUNCTION_CLASS;
19 |     });
20 | 
21 |     addtest("array-indexof", function(){
22 |         return toString.call(EMPTY_ARRAY.indexOf) == FUNCTION_CLASS;
23 |     });
24 | 
25 |     addtest("array-isarray", function(){
26 |         return toString.call(Array.isArray) == FUNCTION_CLASS &&
27 |             Array.isArray(EMPTY_ARRAY) === true;
28 |     });
29 | 
30 |     addtest("array-lastindexof", function(){
31 |         return toString.call(EMPTY_ARRAY.lastIndexOf) == FUNCTION_CLASS;
32 |     });
33 | 
34 |     addtest("array-map", function(){
35 |         return toString.call(EMPTY_ARRAY.map) == FUNCTION_CLASS;
36 |     });
37 | 
38 |     addtest("array-reduce", function(){
39 |         return toString.call(EMPTY_ARRAY.reduce) == FUNCTION_CLASS;
40 |     });
41 | 
42 |     addtest("array-reduceright", function(){
43 |         return toString.call(EMPTY_ARRAY.reduce) == FUNCTION_CLASS;
44 |     });
45 | 
46 |     addtest("array-some", function(){
47 |         return toString.call(EMPTY_ARRAY.some) == FUNCTION_CLASS;
48 |     });
49 | 
50 |     addtest("array-es5", function(){
51 |         return has("array-every") && has("array-filter") && has("array-foreach") &&
52 |             has("array-indexof") && has("array-isarray") && has("array-lastindexof") &&
53 |             has("array-map") && has("array-reduce") && has("array-reduceright") &&
54 |             has("array-some");
55 |     });
56 | 
57 |     addtest("array-slice-nodelist", function(g, d, el){
58 |         var supported = false,
59 |             de = d.documentElement,
60 |             id = de.id;
61 | 
62 |         // Opera 9.25 bug
63 |         de.id = "length";
64 |         // older Safari will return an empty array
65 |         try{
66 |             supported = !!EMPTY_ARRAY.slice.call(d.childNodes, 0)[0];
67 |         }catch(e){}
68 | 
69 |         de.id = id;
70 |         return supported;
71 |     });
72 |     return has;
73 | });
74 | })(typeof define != "undefined" ? define : function(deps, factory){
75 | 	factory(has); // the use global has() if a module system is not available 
76 | });
77 | 	
78 | 


--------------------------------------------------------------------------------
/detect/events.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 | 	var addtest = has.add;
 4 | 
 5 |     function event_tests(g, d, test){
 6 |         var de = d.documentElement,
 7 |             input = d.createElement("input"),
 8 |             result = {
 9 |                 metakey: null,
10 |                 preventdefault: null,
11 |                 stoppropagation: null,
12 |                 srcelement: null,
13 |                 relatedtarget: null
14 |             };
15 | 
16 |         if(has.isHostType(input, "click")){
17 |             input.type = "checkbox";
18 |             input.style.display = "none";
19 |             input.onclick = function(e){
20 |                 e || (e = g.event);
21 |                 result.metakey = ("metaKey" in e);
22 |                 result.stoppropagation = ("stopPropagation" in e);
23 |                 result.preventdefault = ("preventDefault" in e);
24 |                 result.srcelement = ("srcElement" in e);
25 |                 result.relatedtarget = ("relatedTarget" in e);
26 |             };
27 |             try{
28 |                 de.insertBefore(input, de.firstChild);
29 |                 input.click();
30 |                 de.removeChild(input);
31 |             }catch(e){}
32 |             input.onclick = null;
33 |         }
34 | 
35 |         addtest("event-metakey", result.metakey);
36 |         addtest("event-preventdefault", result.preventdefault);
37 |         addtest("event-stoppropagation", result.stoppropagation);
38 |         addtest("event-srcelement", result.srcelement);
39 |         addtest("event-relatedtarget", result.relatedtarget);
40 |         return result[test];
41 |     }
42 | 
43 |     if(!has("dom")){ return; }
44 | 
45 |     addtest("event-contextmenu", function(g, d, el){
46 |         var supported = null;
47 |         if(has.isHostType(el, "setAttribute")){
48 |             el.setAttribute("oncontextmenu", "");
49 |             supported = (typeof el.oncontextmenu != "undefined");
50 |         }
51 |         return supported;
52 |     });
53 | 
54 |     addtest("event-metakey", function(g, d){
55 |         return event_tests(g, d, "metakey");
56 |     });
57 | 
58 |     addtest("event-preventdefault", function(g, d){
59 |         return event_tests(g, d, "preventdefault");
60 |     });
61 | 
62 |     addtest("event-stoppropagation", function(g, d){
63 |         return event_tests(g, d, "stoppropagation");
64 |     });
65 | 
66 |     addtest("event-srcelement", function(g, d){
67 |         return event_tests(g, d, "srcelement");
68 |     });
69 | 
70 |     addtest("event-relatedtarget", function(g, d){
71 |         return event_tests(g, d, "relatedtarget");
72 |     });
73 | 
74 | 	return has;
75 | });
76 | })(typeof define != "undefined" ? define : function(deps, factory){
77 | 	factory(has); // use global has() if a module system is not available 
78 | });
79 | 
80 | 


--------------------------------------------------------------------------------
/tests/results.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |     <style type='text/css'>
 5 |         tbody td, thead td {
 6 |             font-size:9pt;
 7 |         }
 8 |         
 9 |         thead td {
10 |             border-bottom:1px solid #ededed;
11 |         }
12 |         
13 |         thead td, tbody td {
14 |             padding:2px;
15 |             border-right:1px solid #ededed;
16 |         }
17 |         
18 |         td.yes { background-color:green; }
19 |         td.no { background-color:red; }
20 |         td.maybe { background-color:yellow; }
21 |         td.unknown { background-color:#ededed; }
22 |         
23 |     </style>
24 |     <meta http-equiv="Content-type" content="text/html; charset=utf-8">
25 |     <title>has.js results matrix</title>
26 | </head>
27 | <body>
28 |     <?php
29 |     
30 |         // load allll the data
31 |         $lines = file("results.data");
32 |         
33 |         // go over each line, adjusting our flat list of data
34 |         // into something like array(
35 |         //      "someuseragent" => array(
36 |         //          $test1, $test2, $test3 // where each are results of a test from this UA
37 |         //      )
38 |         //  )
39 |         $out = array();
40 |         foreach($lines as $line){
41 |             $data = json_decode($line);
42 |             $ua = $data -> useragent;
43 |             if(empty($out[$ua])){
44 |                 $out[$ua] = array();
45 |             }
46 |             unset($data -> useragent);
47 |             $out[$ua][] = $data;
48 |         }
49 | 
50 |         // go over each useragent, and compare each of the tests in the dataset.
51 |         // if they are all the same, display without issue.
52 | 
53 |         global $master_test_list;
54 |         $master_test_list = array();
55 | 
56 |         foreach($out as $agent => $dataset){
57 |             
58 |             $numtests = count($dataset);
59 |             
60 |             // pull out all the unique test names we know about
61 |             foreach($dataset as $datapart){
62 |                 foreach($datapart as $name => $value){
63 |                     if(!in_array($name, $master_test_list)){
64 |                         $master_test_list[] = $name; 
65 |                     }
66 |                 }
67 |             }
68 |             
69 |         }
70 | 
71 |         function mixdown($results){
72 |             // this is making me insane. trying to cover the cases where a couple
73 |             // things may or may not happen.
74 |             // * some test may not have been written at the time the other data was collected
75 |             //      + in this case we need to specify "unknown" class.
76 |             // * some tests, sorted by useragent, may have varying results. 
77 |             //      + in this case, we need to use 'maybe' class ......
78 |             //      + this is probably bad, as it means perhaps faulty data has
79 |             //        gotten into our suite. 
80 |             // jesus christ i should just flatten the tests immediately. huh?
81 |             $ret = array();
82 |             foreach($results as $test){
83 |                 foreach($test as $k => $v){
84 |                     if($v == "true"){
85 |                     //    print $v . ":";
86 |                     }
87 |                     //print $k . "<br>";
88 |                 }
89 |             }
90 |         }
91 |     
92 |     ?>
93 |     
94 |     <h1>Thanks!</h1>
95 |     
96 | </body>
97 | </html>


--------------------------------------------------------------------------------
/detect/object.js:
--------------------------------------------------------------------------------
 1 | (function(define){
 2 | define(["has"], function(has){
 3 | 	
 4 |     // FIXME: break this out into "modules", like array.js, dom.js, lang.js (?) ^ph
 5 | 
 6 |     // we could define a couple "constants" for reuse ...
 7 |     // just need to ensure they are the same across detect/*.js
 8 |     // so we can wrap in a single (fn(){})() at 'build' ^ph
 9 |     var addtest = has.add,
10 |     	toString = {}.toString,
11 |         FN = "function",
12 |         FUNCTION_CLASS = "[object Function]",
13 |         OBJECT = Object
14 |     ;
15 | 
16 |     // true for Gecko, Webkit, Opera 10.5+
17 |     addtest("object-__proto__", function(){
18 |         var supported = false,
19 |             arr = [],
20 |             obj = { },
21 |             backup = arr.__proto__;
22 | 
23 |         if(arr.__proto__ == Array.prototype &&
24 |                 obj.__proto__ == Object.prototype){
25 |             // test if it's writable and restorable
26 |             arr.__proto__ = obj;
27 |             supported = typeof arr.push == "undefined";
28 |             arr.__proto__ = backup;
29 |         }
30 |         return supported && typeof arr.push == FN;
31 |     });
32 | 
33 |     addtest("object-create", function(){
34 |         return toString.call(OBJECT.create) == FUNCTION_CLASS;
35 |     });
36 | 
37 |     addtest("object-getprototypeof", function(){
38 |         return toString.call(OBJECT.getPrototypeOf) == FUNCTION_CLASS;
39 |     });
40 | 
41 |     addtest("object-seal", function(){
42 |         return toString.call(OBJECT.seal) == FUNCTION_CLASS;
43 |     });
44 | 
45 |     addtest("object-freeze", function(){
46 |         return toString.call(OBJECT.freeze) == FUNCTION_CLASS;
47 |     });
48 | 
49 |     addtest("object-issealed", function(){
50 |         return toString.call(OBJECT.isSealed) == FUNCTION_CLASS;
51 |     });
52 | 
53 |     addtest("object-isfrozen", function(){
54 |         return toString.call(OBJECT.isFrozen) == FUNCTION_CLASS;
55 |     });
56 | 
57 |     addtest("object-keys", function(){
58 |         return toString.call(OBJECT.keys) == FUNCTION_CLASS;
59 |     });
60 | 
61 |     addtest("object-preventextensions", function(){
62 |         return toString.call(OBJECT.preventExtensions) == FUNCTION_CLASS;
63 |     });
64 | 
65 |     addtest("object-isextensible", function(){
66 |         return toString.call(OBJECT.isExtensible) == FUNCTION_CLASS;
67 |     });
68 | 
69 |     addtest("object-defineproperty", function(){
70 |         return toString.call(OBJECT.defineProperty) == FUNCTION_CLASS;
71 |     });
72 | 
73 |     addtest("object-defineproperties", function(){
74 |         return toString.call(OBJECT.defineProperties) == FUNCTION_CLASS;
75 |     });
76 | 
77 |     addtest("object-getownpropertydescriptor", function(){
78 |         return toString.call(OBJECT.getOwnPropertyDescriptor) == FUNCTION_CLASS;
79 |     });
80 | 
81 |     addtest("object-getownpropertynames", function(){
82 |         return toString.call(OBJECT.getOwnPropertyNames) == FUNCTION_CLASS;
83 |     });
84 | 
85 |     addtest("object-es5", function(){
86 |         return has("object-create") && has("object-defineproperties") && has("object-defineproperty") &&
87 |                has("object-freeze") && has("object-getownpropertydescriptor") && has("object-getownpropertynames") &&
88 |                has("object-getprototypeof") && has("object-isextensible") && has("object-isfrozen") &&
89 |                has("object-issealed") && has("object-keys") && has("object-preventextensions") && has("object-seal");
90 |     });
91 | 
92 | 	return has;
93 | });
94 | })(typeof define != "undefined" ? define : function(deps, factory){
95 | 	factory(has); // use global has() if a module system is not available 
96 | });
97 | 
98 | 


--------------------------------------------------------------------------------
/detect/form.js:
--------------------------------------------------------------------------------
  1 | (function(define){
  2 | define(["has"], function(has){
  3 | 	
  4 | 	var STR = "string",
  5 |     	addtest = has.add,
  6 |         FN = "function"
  7 |     ;
  8 | 
  9 |     function typeValidates( type ){
 10 |         input.setAttribute("type", type);
 11 |         input.value = "\x01";
 12 |         return has("input-checkvalidity") && input.type == type &&
 13 |                (/search|tel/.test(type) || input.value != "\x01" || !input.checkValidity());
 14 |     }
 15 | 
 16 |     if(!has("dom")){ return; }
 17 | 
 18 |     var input = document.createElement("input");
 19 | 
 20 |     addtest("input-checkvalidity", function(){
 21 |         return has.isHostType(input, "checkValidity");
 22 |     });
 23 | 
 24 |     addtest("input-attr-autocomplete", function(){
 25 |         return ("autocomplete" in input);
 26 |     });
 27 | 
 28 |     addtest("input-attr-autofocus", function(){
 29 |         return ("autofocus" in input);
 30 |     });
 31 | 
 32 |     addtest("input-attr-list", function(){
 33 |         return ("list" in input);
 34 |     });
 35 | 
 36 |     addtest("input-attr-placeholder", function(){
 37 |         return ("placeholder" in input);
 38 |     });
 39 | 
 40 |     addtest("input-attr-max", function(){
 41 |         return ("max" in input);
 42 |     });
 43 | 
 44 |     addtest("input-attr-maxlength", function(){
 45 |         return ("maxLength" in input);
 46 |     });
 47 | 
 48 |     addtest("input-attr-min", function(){
 49 |         return ("min" in input);
 50 |     });
 51 | 
 52 |     addtest("input-attr-multiple", function(){
 53 |         return ("multiple" in input);
 54 |     });
 55 | 
 56 |     addtest("input-attr-pattern", function(){
 57 |         return ("pattern" in input);
 58 |     });
 59 | 
 60 |     addtest("input-attr-readonly", function(){
 61 |         return ("readOnly" in input);
 62 |     });
 63 | 
 64 |     addtest("input-attr-required", function(){
 65 |         return ("required" in input);
 66 |     });
 67 | 
 68 |     addtest("input-attr-size", function(){
 69 |         return ("size" in input);
 70 |     });
 71 | 
 72 |     addtest("input-attr-step", function(){
 73 |         return ("step" in input);
 74 |     });
 75 | 
 76 |     addtest("input-attr-selectedoption", function(){
 77 |         return ("selectedOption" in input);
 78 |     });
 79 | 
 80 |     addtest("input-attr-indeterminate ", function(){
 81 |         return ("indeterminate " in input);
 82 |     });
 83 | 
 84 |     addtest("input-attr-willvalidate", function(){
 85 |         return ("willValidate" in input);
 86 |     });
 87 | 
 88 |     addtest("input-attr-valueasnumber", function(){
 89 |         return ("valueAsNumber" in input);
 90 |     });
 91 | 
 92 |     addtest("input-attr-valueasdate", function(){
 93 |         return ("valueAsDate" in input);
 94 |     });
 95 | 
 96 |     addtest("input-attr-validity", function(){
 97 |         return has.isHostType(input, "validity");
 98 |     });
 99 | 
100 |     addtest("input-attr-validationmessage", function(){
101 |         return ("validationMessage" in input);
102 |     });
103 | 
104 |     addtest("input-attr-willvalidate", function(){
105 |         return ("willValidate" in input);
106 |     });
107 | 
108 |     addtest("input-type-color", function(){
109 |         return typeValidates("color");
110 |     });
111 | 
112 |     addtest("input-type-search", function(){
113 |         return typeValidates("search");
114 |     });
115 | 
116 |     addtest("input-type-tel", function(){
117 |         return typeValidates("tel");
118 |     });
119 | 
120 |     addtest("input-type-url", function(){
121 |         return typeValidates("url");
122 |     });
123 | 
124 |     addtest("input-type-email", function(){
125 |         return typeValidates("email");
126 |     });
127 | 
128 |     addtest("input-type-datetime", function(){
129 |         return typeValidates("datetime");
130 |     });
131 | 
132 |     addtest("input-type-date", function(){
133 |         return typeValidates("date");
134 |     });
135 | 
136 |     addtest("input-type-month", function(){
137 |         return typeValidates("month");
138 |     });
139 | 
140 |     addtest("input-type-week", function(){
141 |         return typeValidates("week");
142 |     });
143 | 
144 |     addtest("input-type-time", function(){
145 |         return typeValidates("time");
146 |     });
147 | 
148 |     addtest("input-type-datetime-local", function(){
149 |         return typeValidates("datetime-local");
150 |     });
151 | 
152 |     addtest("input-type-number", function(){
153 |         return typeValidates("number");
154 |     });
155 | 
156 |     addtest("input-type-range", function(g, d){
157 |         return typeValidates("range");
158 |     });
159 | 
160 | 	return has;
161 | });
162 | })(typeof define != "undefined" ? define : function(deps, factory){
163 | 	factory(has); // use global has() if a module system is not available 
164 | });
165 | 
166 | 


--------------------------------------------------------------------------------
/detect/css.js:
--------------------------------------------------------------------------------
  1 | (function(define){
  2 | define(["has"], function(has){
  3 | 
  4 |     if(!has("dom")){ return; }
  5 | 	var addtest = has.add,
  6 | 		cssprop = has.cssprop;
  7 |     // FROM cft.js
  8 |     addtest("css-enabled", function(g, d, el){
  9 |         var supported, fake,
 10 |             de = d.documentElement,
 11 |             root = d.body || (function(){
 12 |                 fake = true;
 13 |                 return de.insertBefore(d.createElement("body"), de.firstChild);
 14 |             }());
 15 | 
 16 |         el.style.display = "none";
 17 |         root.insertBefore(el, root.firstChild);
 18 |         supported = (el.offsetWidth === 0);
 19 |         root.removeChild(el);
 20 | 
 21 |         if(fake){
 22 |             root.parentNode.removeChild(root);
 23 |         }
 24 |         return supported;
 25 |     });
 26 | 
 27 |     addtest("css-content-box", function(g, d, el){
 28 |         var fake, root,
 29 |             de = d.documentElement,
 30 |             supported = null;
 31 | 
 32 |         if(has("css-enabled")){
 33 |             root = d.body || (function(){
 34 |                 fake = true;
 35 |                 return de.insertBefore(d.createElement("body"), de.firstChild);
 36 |             }());
 37 | 
 38 |             el.style.cssText = "position: absolute; top: -4000px; width: 40px; height: 40px; border: 1px solid black;";
 39 |             root.insertBefore(el, root.firstChild);
 40 | 
 41 |             supported = (el.clientWidth == 40);
 42 |             root.removeChild(el);
 43 |             el.style.cssText = "";
 44 |         }
 45 |         if(fake){
 46 |             root.parentNode.removeChild(root);
 47 |         }
 48 |         return supported;
 49 |     });
 50 | 
 51 |     addtest("css-position-fixed", function(g, d, el){
 52 |         var backup, control, fake, root,
 53 |             de = d.documentElement,
 54 |             supported = null;
 55 | 
 56 |         if(has("css-enabled")){
 57 |             control = el.cloneNode(false);
 58 |             root = d.body || (function(){
 59 |                 fake = true;
 60 |                 return de.insertBefore(d.createElement("body"), de.firstChild);
 61 |             }());
 62 | 
 63 |             backup = root.style.cssText;
 64 |             root.style.cssText = "padding:0;margin:0";
 65 |             el.style.cssText = "position:fixed;top:42px";
 66 | 
 67 |             root.insertBefore(control, root.firstChild);
 68 |             root.insertBefore(el, control);
 69 |             supported = (el.offsetTop !== control.offsetTop);
 70 | 
 71 |             root.removeChild(el);
 72 |             root.removeChild(control);
 73 |             root.style.cssText = backup;
 74 |             el.style.cssText = "";
 75 |         }
 76 |         if(fake){
 77 |             root.parentNode.removeChild(root);
 78 |         }
 79 |         return supported;
 80 |     });
 81 | 
 82 |     // FROM cft.js
 83 |     addtest("css-rgba", function(g, d, el){
 84 |         var re = /^rgba/,
 85 |             supported = null;
 86 | 
 87 |         if(has("css-enabled")){
 88 |           try{
 89 |               el.style.color = "rgba(1,1,1,0.5)";
 90 |               supported = re.test(el.style.color);
 91 |               el.style.color = "";
 92 |           }catch(e){}
 93 |         }
 94 |         return supported;
 95 |     });
 96 | 
 97 |     addtest("css-border-radius", function(g, d, el){
 98 |         return cssprop("borderRadius", el);
 99 |     });
100 | 
101 |     addtest("css-box-shadow", function(g, d, el){
102 |         return cssprop("boxShadow", el);
103 |     });
104 | 
105 |     addtest("css-box-sizing", function(g, d, el){
106 |         return cssprop("boxSizing", el);
107 |     });
108 | 
109 |     addtest("css-opacity", function(g, d, el){
110 |         return cssprop("opacity", el);
111 |     });
112 | 
113 |     addtest("css-opacity-filter", function(g, d){
114 |         return !has("css-opacity") && (typeof d.documentElement.filters != "undefined");
115 |     });
116 | 
117 |     addtest("css-resize", function(g, d, el){
118 |         return cssprop("resize", el);
119 |     });
120 | 
121 |     addtest("css-selectable", function(g, d, el){
122 |         return cssprop("userSelect", el);
123 |     });
124 | 
125 |     addtest("css-style-float", function(g, d, el){
126 |         return cssprop("styleFloat", el);
127 |     });
128 | 
129 |     // TODO: Fix false positive in Opera
130 |     addtest("css-pointerevents", function(g, d, el){
131 |         return cssprop("pointerEvents", el);
132 |     });
133 | 
134 |     addtest("css-text-overflow", function(g, d, el){
135 |         return cssprop("textOverflow", el);
136 |     });
137 | 
138 |     addtest("css-text-shadow", function(g, d, el){
139 |         return cssprop("textShadow", el);
140 |     });
141 | 
142 |     addtest("css-transform", function(g, d, el){
143 |         return cssprop("transform", el);
144 |     });
145 | 
146 |     // FIXME: modernizr has flexbox, backgroundsize, borderimage, cssanimations, csscolumns, cssgradients,
147 |     // cssreflections, csstransforms, csstransforms3d, csstransitions, fontface
148 | 
149 | 	return has;
150 | });
151 | })(typeof define != "undefined" ? define : function(deps, factory){
152 | 	factory(has); // the use global has() if a module system is not available 
153 | });
154 | 
155 | 


--------------------------------------------------------------------------------
/detect/features.js:
--------------------------------------------------------------------------------
  1 | (function(define){
  2 | define(["has"], function(has){
  3 | 
  4 |     var STR = "string",
  5 |     	addtest = has.add,
  6 |         FN = "function"
  7 |     ;
  8 | 
  9 |     // FIXME: isn't really native
 10 |     // miller device gives "[object Console]" in Opera & Webkit. Object in FF, though. ^pi
 11 |     addtest("native-console", function(g){
 12 |         return ("console" in g);
 13 |     });
 14 | 
 15 |     addtest("native-xhr", function(g){
 16 |         return has.isHostType(g, "XMLHttpRequest");
 17 |     });
 18 | 
 19 |     addtest("native-cors-xhr", function(g){
 20 |         return has("native-xhr") && ("withCredentials" in new XMLHttpRequest);
 21 |     });
 22 | 
 23 |     addtest("native-xhr-uploadevents", function(g){
 24 |         return has("native-xhr") && ("upload" in new XMLHttpRequest);
 25 |     });
 26 | 
 27 |     addtest("activex", function(g){
 28 |         return has.isHostType(g, "ActiveXObject");
 29 |     });
 30 | 
 31 |     addtest("activex-enabled", function(g){
 32 |         var supported = null;
 33 |         if(has("activex")){
 34 |             try{
 35 |                 supported = !!new ActiveXObject("htmlfile");
 36 |             }catch(e){
 37 |                 supported = false;
 38 |             }
 39 |         }
 40 |         return supported;
 41 |     });
 42 | 
 43 |     addtest("native-navigator", function(g){
 44 |         return ("navigator" in g);
 45 |     });
 46 | 
 47 |     /**
 48 |      * geolocation tests for the new Geolocation API specification.
 49 |      *   This test is a standards compliant-only test; for more complete
 50 |      *   testing, including a Google Gears fallback, please see:
 51 |      *   http://code.google.com/p/geo-location-javascript/
 52 |      * or view a fallback solution using google's geo API:
 53 |      *   http://gist.github.com/366184
 54 |      */
 55 | 
 56 |     addtest("native-geolocation", function(g){
 57 |         return has("native-navigator") && ("geolocation" in g.navigator);
 58 |     });
 59 | 
 60 |     addtest("native-crosswindowmessaging", function(g){
 61 |         return ("postMessage" in g);
 62 |     });
 63 | 
 64 |     addtest("native-orientation",function(g){
 65 |         return ("ondeviceorientation" in g);
 66 |     });
 67 | 
 68 |     /*
 69 |      * not sure if there is any point in testing for worker support
 70 |      * as an adequate fallback is impossible/pointless
 71 |      *
 72 |      * ^rw
 73 |      */
 74 | 
 75 |     addtest("native-worker", function(g){
 76 |         return ("Worker" in g);
 77 |     });
 78 | 
 79 |     addtest("native-sharedworker", function(g){
 80 |         return ("SharedWorker" in g);
 81 |     });
 82 | 
 83 |     addtest("native-eventsource", function(g){
 84 |         return ("EventSource" in g);
 85 |     });
 86 | 
 87 |     // non-browser specific
 88 |     addtest("eval-global-scope", function(g){
 89 |         var fnId = "__eval" + Number(new Date()),
 90 |             supported = false;
 91 | 
 92 |         // catch indirect eval call errors (i.e. in such clients as Blackberry 9530)
 93 |         try{
 94 |             g.eval("var " + fnId + "=true");
 95 |         }catch(e){}
 96 | 
 97 |         supported = (g[fnId] === true);
 98 |         if(supported){
 99 |             try{
100 |                 delete g[fnId];
101 |             }catch(e){
102 |                 g[fnId] = undefined;
103 |             }
104 |         }
105 |         return supported;
106 |     });
107 | 
108 |     // in chrome incognito mode, openDatabase is truthy, but using it
109 |     //   will throw an exception: http://crbug.com/42380
110 |     // we create a dummy database. there is no way to delete it afterwards. sorry.
111 |     addtest("native-sql-db", function(g){
112 |         var dbname = "hasjstestdb",
113 |             supported = ("openDatabase" in g);
114 | 
115 |         if(supported){
116 |             try{
117 |                 supported = !!openDatabase( dbname, "1.0", dbname, 2e4);
118 |             }catch(e){
119 |                 supported = false;
120 |             }
121 |         }
122 |         return supported;
123 |     });
124 | 
125 |     // FIXME: hosttype
126 |     // FIXME: moz and webkit now ship this prefixed. check all possible prefixes. ^pi
127 |     addtest("native-indexeddb", function(g){
128 |         return ("indexedDB" in g);
129 |     });
130 | 
131 | 
132 |     addtest("native-localstorage", function(g){
133 |       //  Thanks Modernizr!
134 |       var supported = false;
135 |       try{
136 |         supported = ("localStorage" in g) && ("setItem" in localStorage);
137 |       }catch(e){}
138 |       return supported;
139 |     });
140 | 
141 |     addtest("native-sessionstorage", function(g){
142 |       //  Thanks Modernizr!
143 |       var supported = false;
144 |       try{
145 |         supported = ("sessionStorage" in g) && ("setItem" in sessionStorage);
146 |       }catch(e){}
147 |       return supported;
148 |     });
149 | 
150 |     addtest("native-history-state", function(g){
151 |         return ("history" in g) && ("pushState" in history);
152 |     });
153 | 
154 |     addtest("native-websockets", function(g){
155 |         return ("WebSocket" in g);
156 |     });
157 | 
158 | 	return has;
159 | });
160 | })(typeof define != "undefined" ? define : function(deps, factory){
161 | 	factory(has); // use global has() if a module system is not available 
162 | });
163 | 
164 | 


--------------------------------------------------------------------------------
/detect/dom.js:
--------------------------------------------------------------------------------
  1 | (function(define){
  2 | define(["has"], function(has){
  3 | 	
  4 | 	var addtest = has.add;
  5 | 	 
  6 |     if(!has("dom")){ return; }
  7 | 
  8 |     addtest("dom-quirks", function(g, d, el){
  9 |         var supported;
 10 |         if(typeof d.compatMode == "string"){
 11 |             supported = (d.compatMode == "BackCompat");
 12 |         }else{
 13 |             el.style.width = "1";
 14 |             supported = (e.style.width == "1px");
 15 |             el.style.cssText = "";
 16 |         }
 17 |         return supported;
 18 |     });
 19 | 
 20 |     addtest("dom-dataset", function(g, d, el){
 21 |         el.setAttribute("data-a-b", "c");
 22 |         return has.isHostType(el, "dataset") && el.dataset.aB == "c";
 23 |     });
 24 | 
 25 |     // works in all but IE < 9
 26 |     addtest("dom-addeventlistener", function(g, d){
 27 |         return has.isHostType(d, "addEventListener");
 28 |     });
 29 | 
 30 |     // works in all but IE
 31 |     addtest("dom-createelementns", function(g, d){
 32 |         return has.isHostType(d, "createElementNS");
 33 |     });
 34 | 
 35 |     // should fail in webkit, as they dont support it.
 36 |     addtest("dom-attrmodified", function(g, d, el){
 37 |         var supported = false,
 38 |             listener = function(){ supported = true; };
 39 | 
 40 |         if(has("dom-addeventlistener")){
 41 |             supported = false;
 42 |             el.addEventListener("DOMAttrModified", listener, false);
 43 |             el.setAttribute("___TEST___", true);
 44 |             el.removeAttribute("___TEST___", true);
 45 |             el.removeEventListener("DOMAttrModified", listener, false);
 46 |         }
 47 |         return supported;
 48 |     });
 49 | 
 50 |     addtest("dom-subtreemodified", function(g, d, el){
 51 |         var supported = false,
 52 |             listener = function(){ supported = true; };
 53 | 
 54 |         if(has("dom-addeventlistener")){
 55 |             supported = false;
 56 |             el.appendChild(d.createElement("div"));
 57 |             el.addEventListener("DOMSubtreeModified", listener, false);
 58 |             has.clearElement(el);
 59 |             el.removeEventListener("DOMSubtreeModified", listener, false);
 60 |         }
 61 |         return supported;
 62 |     });
 63 | 
 64 |     // FROM cft.js
 65 |     addtest("dom-children", function(g, d, el){
 66 |         var supported = false;
 67 |         if(has.isHostType(el, "children")){
 68 |             var div = el.appendChild(d.createElement("div")),
 69 |                 children = el.children;
 70 | 
 71 |             // Safari 2.x returns ALL children including text nodes
 72 |             el.appendChild(d.createTextNode("x"));
 73 |             div.appendChild(div.cloneNode(false));
 74 |             supported = !!children && children.length == 1 && children[0] == div;
 75 |             has.clearElement(el);
 76 |         }
 77 |         return supported;
 78 |     });
 79 | 
 80 |     // true for html, xhtml and unknown elements are case
 81 |     // sensitive to how they are written in the markup
 82 |     addtest("dom-tagname-uppercase", function(g, d, el){
 83 |         return el.nodeName == "DIV";
 84 |     });
 85 | 
 86 |     addtest("dom-html5-elements", function(g, d, el){
 87 |         el.innerHTML = "<nav>a</nav>";
 88 |         return el.childNodes.length == 1;
 89 |     });
 90 | 
 91 |     // true for IE < 9
 92 |     // http://msdn.microsoft.com/en-us/library/ms536389(VS.85).aspx vs
 93 |     // http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-2141741547
 94 |     addtest("dom-create-attr", function(g, d){
 95 |         var input, supported = false;
 96 |         try{
 97 |             input = d.createElement("<input type='hidden' name='hasjs'>");
 98 |             supported = input.type == "hidden" && input.name == "hasjs";
 99 |         }catch(e){}
100 |         return supported;
101 |     });
102 | 
103 |     // TODO: this test is really testing if expando's become attributes (IE)
104 |     // true for IE
105 |     addtest("dom-selectable", function(g, d, el){
106 |         var supported = false;
107 |         try{
108 |             el.unselectable = "on";
109 |             supported = typeof el.attributes.unselectable != "undefined" &&
110 |                 el.attributes.unselectable.value == "on";
111 |             el.unselectable = "off";
112 |         }catch(e){}
113 |         return supported;
114 |     });
115 | 
116 |     // true for all modern browsers, including IE 9+
117 |     addtest("dom-computed-style", function(g, d){
118 |         return has.isHostType(d, "defaultView") && has.isHostType(d.defaultView, "getComputedStyle");
119 |     });
120 | 
121 |     // true for IE
122 |     addtest("dom-current-style", function(g, d){
123 |         return !has("dom-computed-style") && has.isHostType(d.documentElement, "currentStyle");
124 |     });
125 | 
126 |     // true for IE
127 |     addtest("dom-element-do-scroll", function(g, d){
128 |         return has.isHostType(d.documentElement, "doScroll");
129 |     });
130 | 
131 |     // test for dynamic-updating base tag support (allows us to avoid href & src attr rewriting)
132 |     // false for Firefox < 4 and IE < 8
133 |     addtest("dom-dynamic-base", function (g, d, el){
134 |         var backup, base,
135 |             q = d.createElement("q"),
136 |             head = d.getElementsByTagName("head")[0],
137 |             href = location.href,
138 |             fake = false,
139 |             supported = null,
140 |             token = location.search || location.hash;
141 | 
142 |         if(head){
143 |             base = d.getElementsByTagName("base")[0] || (function(){
144 |                 fake = true;
145 |                 return head.insertBefore(d.createElement("base"), head.firstChild);
146 |             })();
147 | 
148 |             backup = base.href || href.slice(0, token ? href.indexOf(token) : href.length).replace(/[^\/]*$/, "");
149 |             base.href = location.protocol + "//x";
150 |             q.cite = "y";
151 |             supported = q.cite.indexOf("x/y") > -1;
152 | 
153 |             // reset href before removal, otherwise href persists in Opera
154 |             base.href = backup;
155 |             if(fake){
156 |                 head.removeChild(base);
157 |             }
158 |         }
159 |         return supported;
160 |     });
161 | 
162 |     addtest("dom-classlist", function(g, d, e){
163 |         var iht = has.isHostType;
164 |         if(!iht(e, "classList")){
165 |             return false;
166 |         }
167 | 
168 |         var cl = e.classList;
169 | 
170 |         return iht(cl, "item") && iht(cl, "contains") && iht(cl, "add") &&
171 |             iht(cl, "remove") && iht(cl, "toggle");
172 |     });
173 | 
174 | 	return has;
175 | });
176 | })(typeof define != "undefined" ? define : function(deps, factory){
177 | 	factory(has); // the use global has() if a module system is not available 
178 | });
179 | 
180 | 


--------------------------------------------------------------------------------
/has.js:
--------------------------------------------------------------------------------
  1 | (function(define, g){
  2 | define(["./_plugin"], function(plugin){
  3 |     // summary: A simple feature detection function/framework.
  4 |     //
  5 |     // name: String
  6 |     //      The name of the feature to detect, as defined by the overall `has` tests.
  7 |     //      Tests can be registered via `has.add(testname, testfunction)`.
  8 |     //
  9 |     // example:
 10 |     //      mylibrary.bind = has("native-bind") ? function(fn, context){
 11 |     //          return fn.bind(context);
 12 |     //      } : function(fn, context){
 13 |     //          return function(){
 14 |     //              fn.apply(context, arguments);
 15 |     //          }
 16 |     //      }
 17 | 
 18 |     var NON_HOST_TYPES = { "boolean": 1, "number": 1, "string": 1, "undefined": 1 },
 19 |         VENDOR_PREFIXES = ["Webkit", "Moz", "O", "ms", "Khtml"],
 20 |         d = isHostType(g, "document") && g.document,
 21 |         el = d && isHostType(d, "createElement") && d.createElement("DiV"),
 22 |         testCache = {}
 23 |     ;
 24 | 
 25 |     function has(/* String */name){
 26 |         if(typeof testCache[name] == "function"){
 27 |             testCache[name] = testCache[name](g, d, el);
 28 |         }
 29 |         return testCache[name]; // Boolean
 30 |     }
 31 | 
 32 |     function add(/* String */name, /* Function */test, /* Boolean? */now){
 33 |         // summary: Register a new feature detection test for some named feature
 34 |         //
 35 |         // name: String
 36 |         //      The name of the feature to test.
 37 |         //
 38 |         // test: Function
 39 |         //      A test function to register. If a function, queued for testing until actually
 40 |         //      needed. The test function should return a boolean indicating
 41 |         //      the presence of a feature or bug.
 42 |         //
 43 |         // now: Boolean?
 44 |         //      Optional. Omit if `test` is not a function. Provides a way to immediately
 45 |         //      run the test and cache the result.
 46 |         // example:
 47 |         //      A redundant test, testFn with immediate execution:
 48 |         //  |       has.add("javascript", function(){ return true; }, true);
 49 |         //
 50 |         // example:
 51 |         //      Again with the redundantness. You can do this in your tests, but we should
 52 |         //      not be doing this in any internal has.js tests
 53 |         //  |       has.add("javascript", true);
 54 |         //
 55 |         // example:
 56 |         //      Three things are passed to the testFunction. `global`, `document`, and a generic element
 57 |         //      from which to work your test should the need arise.
 58 |         //  |       has.add("bug-byid", function(g, d, el){
 59 |         //  |           // g  == global, typically window, yadda yadda
 60 |         //  |           // d  == document object
 61 |         //  |           // el == the generic element. a `has` element.
 62 |         //  |           return false; // fake test, byid-when-form-has-name-matching-an-id is slightly longer
 63 |         //  |       });
 64 |         testCache[name] = now ? test(g, d, el) : test;
 65 |     }
 66 | 
 67 |     // cssprop adapted from http://gist.github.com/598008 (thanks, ^pi)
 68 |     function cssprop(name, el){
 69 |         var supported = false,
 70 |             capitalized = name.charAt(0).toUpperCase() + name.slice(1),
 71 |             length = VENDOR_PREFIXES.length,
 72 |             style = el.style;
 73 | 
 74 |         if(typeof style[name] == "string"){
 75 |             supported = true;
 76 |         }else{
 77 |             while(length--){
 78 |                 if(typeof style[VENDOR_PREFIXES[length] + capitalized] == "string"){
 79 |                     supported = true;
 80 |                     break;
 81 |                 }
 82 |             }
 83 |         }
 84 |         return supported;
 85 |     }
 86 | 
 87 |     function clearElement(el){
 88 |         if(el){
 89 |             while(el.lastChild){
 90 |                 el.removeChild(el.lastChild);
 91 |             }
 92 |         }
 93 |         return el;
 94 |     }
 95 | 
 96 |     // Host objects can return type values that are different from their actual
 97 |     // data type. The objects we are concerned with usually return non-primitive
 98 |     // types of object, function, or unknown.
 99 |     function isHostType(object, property){
100 |         var type = typeof object[property];
101 |         return type == 'object' ? !!object[property] : !NON_HOST_TYPES[type];
102 |     }
103 | 
104 |     //>>excludeStart("production", true);
105 |     function all(){
106 |         // summary: For debugging or logging, can be removed in production. Run all known tests
107 |         //  at some point in time for the current environment.
108 |         var name, ret = {};
109 |         for(name in testCache){
110 |             try{
111 |                 ret[name] = has(name);
112 |             }catch(e){
113 |                 ret[name] = "error";
114 |                 ret[name].ERROR_MSG = e.toString();
115 |             }
116 |         }
117 |         return ret;
118 |     }
119 | 
120 |     has.all = all;
121 |     has.pluginBuilder = "./build/plugin"; 
122 |     //>>excludeEnd("production");
123 |     has.add = add;
124 |     has.load = plugin;
125 |     has.clearElement = clearElement;
126 |     has.cssprop = cssprop;
127 |     has.isHostType = isHostType;
128 |     has._tests = testCache;
129 | 
130 |     has.add("dom", function(g, d, el){
131 |         return d && el && isHostType(g, "location") && isHostType(d, "documentElement") &&
132 |             isHostType(d, "getElementById") && isHostType(d, "getElementsByName") &&
133 |             isHostType(d, "getElementsByTagName") && isHostType(d, "createComment") &&
134 |             isHostType(d, "createElement") && isHostType(d, "createTextNode") &&
135 |             isHostType(el, "appendChild") && isHostType(el, "insertBefore") &&
136 |             isHostType(el, "removeChild") && isHostType(el, "getAttribute") &&
137 |             isHostType(el, "setAttribute") && isHostType(el, "removeAttribute") &&
138 |             isHostType(el, "style") && typeof el.style.cssText == "string";
139 |     }, true);
140 | 
141 |     // Stop repeat background-image requests and reduce memory consumption in IE6 SP1
142 |     // http://misterpixel.blogspot.com/2006/09/forensic-analysis-of-ie6.html
143 |     // http://blogs.msdn.com/b/cwilso/archive/2006/11/07/ie-re-downloading-background-images.aspx?PageIndex=1
144 |     // http://support.microsoft.com/kb/823727
145 |     try{
146 |         document.execCommand("BackgroundImageCache", false, true);
147 |     }catch(e){}
148 | 
149 |     return has;
150 | 
151 | });
152 | })(typeof define != "undefined" ? 
153 | 	define : // if define() is available, load has as a module (no global)  
154 | 	function(deps, factory){
155 | 		// if directly loaded, make has a global
156 | 		has = factory();
157 | }, this);
158 | 


--------------------------------------------------------------------------------
/tests/runTests.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 |     <head>
  4 |         <style type="text/css">
  5 |             .yes {
  6 |                 color:green;
  7 |             }
  8 |             .no {
  9 |                 color:red;
 10 |             }
 11 |             .na {
 12 |                 color:blue;
 13 |             }
 14 |             .error {
 15 |                 background-color: red;
 16 |                 color: black;
 17 |             }
 18 |             #ua {
 19 |                 font-weight:bold;
 20 |             }
 21 |             .resultList { list-style:none; }
 22 |             .resultList li {
 23 |                 float:left;
 24 |                 width:250px;
 25 |                 padding:5px;
 26 |                 border-bottom:1px dotted #ededed;
 27 |             }
 28 |             fieldset { margin-bottom:4px; }
 29 |         </style>
 30 | 
 31 |         <title>has.js tests</title>
 32 | 
 33 |         <script src="../has.js"></script>
 34 | 
 35 |         <!--script src="require.js"></script-->
 36 | 
 37 |         <script src="../detect/bugs.js"></script>
 38 |         <script src="../detect/array.js"></script>
 39 |         <script src="../detect/graphics.js"></script>
 40 |         <script src="../detect/css.js"></script>
 41 |         <script src="../detect/dates.js"></script>
 42 |         <script src="../detect/dom.js"></script>
 43 |         <script src="../detect/features.js"></script>
 44 |         <script src="../detect/form.js"></script>
 45 |         <script src="../detect/function.js"></script>
 46 |         <script src="../detect/json.js"></script>
 47 |         <script src="../detect/object.js"></script>
 48 |         <script src="../detect/strings.js"></script>
 49 |         <script src="../detect/events.js"></script>
 50 |         <script src="../detect/script.js"></script>
 51 |         <script src="../detect/audio.js"></script>
 52 |         <script src="../detect/video.js"></script>
 53 | 
 54 |     </head>
 55 |     <body>
 56 | 
 57 |         <h1>has.js</h1>
 58 | 
 59 |         <p>Feature Detection, a la carte stylie</p>
 60 | 
 61 |         <div id="output"></div>
 62 | 
 63 |         <script>
 64 |             has.specials = {};
 65 | 
 66 |             has.byId = function(id){
 67 |                 return document.getElementById(id);
 68 |             }
 69 | 
 70 |             // redundant test
 71 |             has.add("js-enabled-direct", true);
 72 | 
 73 |             var lazy = 0;
 74 |             has.add("js-enabled-lazy", function(){ lazy++; return true; });
 75 |             if(!lazy && !has("js-enabled-lazy")){
 76 |                 alert("lazy test failed.");
 77 |             }
 78 | 
 79 |             var run = 0;
 80 |             has.add("js-enabled-lazy-now", function(){ run++; return true; }, true);
 81 |             if(!run){
 82 |                 alert("lazy with immediate execution failed");
 83 |             }
 84 | 
 85 |             var html = [],
 86 |                 data = [],
 87 |                 nao = +new Date,
 88 |                 results = has.all(),
 89 |                 done = +new Date,
 90 |                 bugRE = /^bug-/
 91 |             ;
 92 | 
 93 |             function resultClass(result, isBug, special){
 94 |                 // format bug-* tests opposite from others
 95 |                 if(result === null){
 96 |                     return "na";
 97 |                 }
 98 |                 if(result == "error"){
 99 |                     return "error";
100 |                 }
101 |                 if(isBug){
102 |                     return (result ? "no" : "yes");
103 |                 }
104 |                 return (result ? "yes" : "no");
105 |             }
106 | 
107 |             var keys = [], i;
108 | 
109 |             if(has('object-keys')){
110 |                 keys = Object.keys(results);
111 |             }else{
112 |                 for(i in results){
113 |                     keys.push(i);
114 |                 }
115 |             }
116 |             keys.sort();
117 | 
118 |             var categories = { 'none': [] },
119 |                 categoryRE = /^(\w+)[-]?/;
120 | 
121 |             var outputResult = function(key, i){
122 |                 var special = "", r = results[key],
123 |                     match = key.match(categoryRE),
124 |                     category = match ? match[1] : 'none';
125 | 
126 |                 if(!(category in categories)){
127 |                     categories[category] = [];
128 |                 }
129 |                 var html = categories[category];
130 | 
131 |                 if(key in has.specials){
132 |                     special = r[has.specials[key]] || "";
133 |                 }
134 | 
135 |                 if(r == "error"){
136 |                     special = ": " + r.ERROR_MSG;
137 |                 }
138 | 
139 |                 data.push("<input type='hidden' name='", key, "' value='", r + special ,"'>");
140 |                 html.push("<li>", key ," <em class='", resultClass(r, bugRE.test(key)), "'>",
141 |                     (r === null ? 'n/a' : (r == "error" ? r : !!r)) , "</em>", special, "</li>");
142 |             };
143 | 
144 |             if(has('array-foreach')){
145 |                 keys.forEach(outputResult);
146 |             }else{
147 |                 i = 0;
148 |                 for(var key; key=keys[i]; i++){
149 |                     outputResult(key, i);
150 |                 }
151 |             }
152 | 
153 |             for(var j in categories){
154 |                 if(!categories[j].length){ continue; }
155 |                 html.push('<fieldset><legend>Results for category ', j, '</legend><ul class="resultList">');
156 |                 html = html.concat(categories[j]);
157 |                 html.push('</ul></fieldset>');
158 |             }
159 | 
160 |             window.onload = function(){
161 |                 has.byId("output").innerHTML = html.join("");
162 |                 has.byId("resultinputs").innerHTML = data.join("");
163 | 
164 |                 has.byId("cost").value = has.byId("took").innerHTML = "took: " + (done - nao) + "ms";
165 |                 has.byId("useragent").value = has.byId("ua").innerHTML = navigator.userAgent;
166 | 
167 |                 has.byId("boom").disabled = false; // backend not in place
168 |             };
169 |         </script>
170 | 
171 |         <fieldset>
172 |             <legend>Results for category base-uri</legend>
173 |             <ul class="resultList">
174 |                 <li>
175 |                     <img src="base.gif" alt="base-uri-reset: false">
176 |                 </li>
177 |             </ul>
178 |         </fieldset>
179 | 
180 |         <p>Test running took <span id="took"></span></p>
181 |         <p>Your userAgent is being reported as: <span id="ua"></span></p>
182 | 
183 |         <form action="report.php" method="POST">
184 |             <button id="boom" type="submit" disabled="disabled">Report these to teh matrix</button>
185 |             <div id="resultinputs"></div>
186 |             <input type="hidden" name="useragent" id="useragent">
187 |             <input type="hidden" name="cost" id="cost">
188 |         </form>
189 | 
190 |         <p>More about this test page and project on <a href="http://github.com/phiggins42/has.js">github:has.js</a></p>
191 |     </body>
192 | </html>
193 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # has.js
  2 | 
  3 | Pure feature detection library, a la carte style.
  4 | 
  5 | This document is **not** complete. 
  6 | 
  7 | ## About
  8 | 
  9 | Browser sniffing and feature inference are flawed techniques for detecting browser support in client side JavaScript. The goal of 
 10 | **has.js** is to provide a collection of self-contained tests and unified framework around using pure feature detection for whatever 
 11 | library consumes it. 
 12 | 
 13 | You likely _won't_ see **has.js** as a public API in any library. The idea is that _%yourfavoritelibrary%_ will import some or all
 14 | the available tests, based on their own needs for providing you a normalized future proof API against common tasks.
 15 | 
 16 | **not stable**, so keep that in mind. This is a young project, and the decided naming conventions may be a moving target. 
 17 | The tests are nothing that haven't been done over and over in various places,
 18 | so the intention is to come to some agreement on a basic naming convention and API based on real world use cases.
 19 | 
 20 | Currently, the testing convention is _has('somefeature')_ returns _Boolean_. eg:
 21 | 
 22 |     if(has("function-bind")){
 23 |         // your enviroment has a native Function.prototype.bind
 24 |     }else{
 25 |         // you should get a new browser. 
 26 |     }
 27 |     
 28 | In the real world, this may translate into something like:
 29 | 
 30 |     mylibrary.trim = has("string-trim") ? function(str){
 31 |         return (str || "").trim();
 32 |     } : function(str){
 33 |         /* do the regexp based string trimming you feel like using */
 34 |     }
 35 | 
 36 | By doing this, we can easily defer to browser-native versions of common functions, augment prototypes (which **has.js** will _not_ do) to 
 37 | supplement the natives, or whatever we choose.
 38 | 
 39 | Running _has()_ is a one-time cost, deferred until needed. After first run, subsequent _has()_ checks are cached and return immediately.
 40 | 
 41 | ## Testing Registration
 42 | 
 43 | Each test is self-contained. Register a test with _has.add()_:
 44 | 
 45 |     has.add("some-test-name", function(global, document, anElement){
 46 |         // global is a reference to global scope, document is the same
 47 |         // anElement only exists in browser enviroments, and can be used
 48 |         // as a common element from which to do DOM working.
 49 |         // ALWAYS CLEAN UP AFTER YOURSELF in a test. No leaks, thanks. 
 50 |         // return a Boolean from here.
 51 |         return true; 
 52 |     });
 53 |     
 54 | You can register and run a test immediately by passing a truthy value after the test function:
 55 | 
 56 |     has.add("some-other-test", function(){
 57 |         return false; // Boolean
 58 |     }, true)
 59 | 
 60 | This is preferred over what would seem a much more effective version:
 61 | 
 62 |     // this is not wrapped in a function, and should be:
 63 |     has.add("some-other-test", ("foo" in bar)); // or whatever
 64 |     
 65 | By forcing a function wrapper around the test logic we are able to defer execution until needed, as well as provide a normalized way for 
 66 | each test to have it's own execution context. This way, we can remove some or all the tests we do not need in whatever upstream library
 67 | should adopt _has_.
 68 | 
 69 | ## As a Module
 70 | has.js can be loaded as a module with RequireJS, Dojo, or any other AMD module 
 71 | loader, and no global variable will be created. Requiring or depending on has.js give 
 72 | you access to has(). You can also depend on any of the detect modules and has will
 73 | be included. For example, we could create a module that depends on has/array:
 74 | 
 75 |     define(["has/array"], function(has){
 76 |       if(has("array-every")){
 77 |         someArray.every(...);
 78 |       }
 79 |       ...
 80 |     }); 
 81 | 
 82 | Make sure that you have has.js setup as a package in order for this work properly though.
 83 | You can setup has.js as a package in RequireJS with something like:
 84 | 
 85 | 	packages: [
 86 | 		{
 87 | 			name:"has",
 88 | 			location:"has.js",
 89 | 			lib:"./detect",
 90 | 			main:"../has"
 91 | 		}
 92 | 	]
 93 | 
 94 | ## As a Dependency Plugin
 95 | 
 96 | has.js can also be used as a dependency loader plugin for AMD module loaders. This allows
 97 | you to conditionally load modules based on available features. The syntax for feature-dependent
 98 | modules is based on the JavaScript ternary operator:
 99 | 
100 |     define(["has!feature?module-if-has-feature:module-if-does-not-have-feature",...
101 | 
102 | This follows the standard rule for ternary operators. If the feature (the token before the
103 | ?) is available, the module before the : is loaded, otherwise the module after the colon
104 | is loaded. Ternary operators can also be nested. We can have a set of different modules
105 | based on different features:
106 | 
107 |     define(["has!feature1?module1:feature2?module2:feature3?module3:default-module",...
108 | 
109 | If feature1 is available, module1 will be returned, if feature2 is available, module2 will be returned, etc.  
110 | 
111 | Also, if no module (empty string) is provided in one of the ternary slots, undefined will be returned. For example:
112 | 
113 |     define(["has!feature?module-if-has-feature",...
114 | 
115 | This will return the module "module-if-has-feature" if the feature is available, otherwise
116 | it will return undefined.
117 | 
118 | The "has" module itself does not register any tests. Normally you would reference the 
119 | has detection module that registers the needed tests to ensure that the correct tests
120 | are available. For example, if you want to branch to different modules based on the
121 | existence of the the Array's every() method, you could do:
122 | 
123 |     define(["has/array!array-every?module-for-every:module-when-no-every",...
124 |      
125 | Or more likely, you can also create your test registration module, then use this module as the
126 | branching module. For example, we could create a test registration module:
127 | 
128 |     define("my-tests", ["has"], function(has){
129 |         has.add("some-test", function(){
130 |           // the test code
131 |         });
132 |     }); 
133 | 
134 | And then we could use it:
135 | 
136 |     define(["my-tests!some-test?module-a:module-b"], function(...
137 |     
138 | 
139 | ## Platform Builds
140 | 
141 | Something resembling a "builder" is coming. A basic dependency matcher and test lister is provided in `build/`
142 | 
143 | ## Contribute
144 | 
145 | **has.js** contributions are covered under a common license by way of [Dojo Foundation CLA](http://dojofoundation.org/cla), and brought to you by the following awesome folks:
146 | 
147 |   + [John David Dalton](http://allyoucanleet.com/) - FuseJS Project Lead
148 |   + [Brad Dougherty](http://github.com/bdougherty)
149 |   + [Bryan Forbes](http://http://www.reigndropsfall.net) - Dojo Committer
150 |   + [Ryan Grove](http://twitter.com/yaypie) - YUI engineer
151 |   + [Andrée Hansson](http://github.com/peol)
152 |   + [Peter Higgins](http://higginsforpresident.net) - Dojo Project Lead
153 |   + [Paul Irish](http://paulirish.com) - jQuery Team, Modernizr developer
154 |   + [Weston Ruter](http://weston.ruter.net/) - X-Team/XHTMLized developer
155 |   + [Rick Waldron](http://github.com/rwldrn/)
156 |   + [Juriy Zaytsev](http://perfectionkills.com) - @kangax, nuff' said.
157 |   
158 | There is an _irc_ room setup for discussion or questions: **#hasjs@irc.freenode.net**
159 | 
160 | ## Conventions
161 | 
162 | Internally, we follow these conventions:
163 | 
164 |   + All Strings are quoted using double-quotes **"**
165 |   + Test names are lowercase, hyphen separated strings. Enclosed in double-quotes
166 |     + Tests are passed `g`, `d`, and `n`. Use these aliases always.
167 |   + Globals are as follows, available as used but will be reduced to a single ref:
168 |     + STR == "string"
169 |     + FN == "function"
170 |   + Tests return Booleans. Sometimes, you must coerce a boolean:
171 |     + DO return !!(someExpression) as necessary
172 |     + DO N0T return !!("x" in y) or anything else that would otherwise return a boolean, eg
173 |       + x !== y, x > y, x typeof y
174 |     + DO wrap expressions in parens: eg return ("x" in y)
175 | 
176 | ## License 
177 | 
178 | Tentatively, **has.js** is available under the Academic Free License, New BSD License, and the MIT License. Providing this common code under multiple licenses requires us to have all contributors agree to a [CLA](http://dojofoundation.org/cla).
179 | 
180 | ## TODO
181 | 
182 | **has.js** is open source, and open to contribution. Please fork and send pull requests as you see fit. This is a rough list of things that are needed or coming:
183 | 
184 |   + moar tests. Fork/pull request anytime. 
185 |   + Static Frontend - some home to put a static instance of has.js online to collect UA -> has(test) mappings
186 |   + Documentation regarding each of the tests, by name. eg: has("native-xhr") // tests if the environment has a native XmlHttpRequest implementation. 
187 |   + moar tests. Again with the forking. 
188 |   + "compiler" code / frontend 
189 |      + ideally something that will use the list of tests, provide a clean interface to selecting tests needed and to download a single has.js file with tests embedded.
190 |      + keeping in mind to remove additional closures and provide (only needed) var CONTS = "" style helpers in a single wrapping function. 


--------------------------------------------------------------------------------
/detect/bugs.js:
--------------------------------------------------------------------------------
  1 | (function(define){
  2 | define(["has", "./strings", "./dom"], function(has){
  3 | 
  4 |     // http://github.com/kangax/cft
  5 |     var toString = {}.toString,
  6 |     	addtest = has.add,
  7 |         STR = "string",
  8 |         FN = "function",
  9 |         FUNCTION_CLASS = "[object Function]"
 10 |     ;
 11 | 
 12 |     function testForIn(value){
 13 |         var i,
 14 |             count = 0,
 15 |             klass = function(){ this.toString = 1; };
 16 | 
 17 |         for(i in new klass){
 18 |             count++;
 19 |         }
 20 |         return count == value;
 21 |     }
 22 | 
 23 |     // true for IE < 9
 24 |     addtest("bug-for-in-skips-shadowed", function(){
 25 |         return testForIn(0);
 26 |     });
 27 | 
 28 |     // true for Safari 2
 29 |     addtest("bug-for-in-repeats-shadowed", function(){
 30 |         return testForIn(2);
 31 |     });
 32 | 
 33 |     addtest("bug-string-split-regexp", function(){
 34 |         var buggy = null, s = "a_b";
 35 |         if(toString.call(s.split) == FUNCTION_CLASS){
 36 |             buggy = s.split(/(_)/).length != 3;
 37 |         }
 38 |         return buggy;
 39 |     });
 40 | 
 41 |     addtest("bug-function-expression", function(){
 42 |         // `x` should be resolved to `null` (the one we declared outside this function)
 43 |         // but since named function expression identifier leaks onto the enclosing scope in IE,
 44 |         // it will be resolved to a function
 45 |         var f = function x(){},
 46 |            buggy = typeof x == FN;
 47 |         if(buggy){
 48 |           x = null;
 49 |         }
 50 |         return buggy;
 51 |     });
 52 | 
 53 |     addtest("bug-string-replace-ignores-functions", function(){
 54 |         var buggy = null, s = "a";
 55 |         if(toString.call(s.replace) == FUNCTION_CLASS){
 56 |             buggy = s.replace(s, function(){ return ""; }) != "";
 57 |         }
 58 |         return buggy;
 59 |     });
 60 | 
 61 |     addtest("bug-arguments-instanceof-array", function(g){
 62 |         return arguments instanceof g.Array;
 63 |     });
 64 | 
 65 |     addtest("bug-array-concat-arguments", function(){
 66 |         return (function(){
 67 |             var buggy = null;
 68 |             if(has("bug-arguments-instanceof-array")){
 69 |                 buggy = [].concat(arguments)[0] != 1;
 70 |             }
 71 |             return buggy;
 72 |         })(1,2);
 73 |     });
 74 | 
 75 |     // ES5 added <BOM> (\uFEFF) as a whitespace character
 76 |     var whitespace = "\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u180E\u2000\u2001\u2002"+
 77 |         "\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF";
 78 | 
 79 |     addtest("bug-es5-trim", function(){
 80 |         var buggy = null;
 81 |         if(has("string-trim")){
 82 |             buggy = !!whitespace.trim();
 83 |         }
 84 |         return buggy;
 85 |     });
 86 | 
 87 |     addtest("bug-es5-regexp", function(){
 88 |         return !(/^\s+$/).test(whitespace);
 89 |     });
 90 | 
 91 |     addtest("bug-tofixed-rounding", function(){
 92 |         return (.9).toFixed() == 0;
 93 |     });
 94 | 
 95 |     if(!has("dom")){ return; }
 96 | 
 97 |     addtest("bug-offset-values-positioned-inside-static", function(g, d, el){
 98 |         var div, fake,
 99 |             buggy = null,
100 |             de = d.documentElement,
101 |             id = "__test_" + Number(new Date()),
102 |             css = "margin:0;padding:0;border:0;visibility:hidden;",
103 |             root = d.body || (function(){
104 |                 fake = true;
105 |                 return de.insertBefore(d.createElement("body"), de.firstChild);
106 |             }());
107 | 
108 |         el.innerHTML =
109 |             "<div style='position:absolute;top:10px;" + css + "'>"+
110 |             "<div style='position:relative;top:10px;" + css + "'>"+
111 |             "<div style='height:10px;font-size:1px;"  + css + "'><\/div>"+
112 |             "<div id='" + id + "'>x<\/div>"+
113 |             "<\/div>"+
114 |             "<\/div>";
115 | 
116 |         root.insertBefore(el, root.firstChild);
117 |         div = d.getElementById(id);
118 | 
119 |         if(div.firstChild){
120 |             buggy = false;
121 |             if(div.offsetTop != 10){
122 |                 // buggy, set position to relative and check if it fixes it
123 |                 div.style.position = "relative";
124 |                 if(div.offsetTop == 10){
125 |                     buggy = true;
126 |                 }
127 |             }
128 |         }
129 |         if(fake){
130 |             root.parentNode.removeChild(root);
131 |         }
132 |         root.removeChild(el);
133 |         has.clearElement(el);
134 |         return buggy;
135 |     });
136 | 
137 |     // Opera 9.x (possibly other versions as well) returns actual values (instead of "auto")
138 |     // for statically positioned elements
139 |     addtest("bug-computed-values-for-static", function(g, d){
140 |         var cs, view,
141 |             de = d.documentElement,
142 |             style = d.style,
143 |             position = null,
144 |             buggy = position;
145 | 
146 |         if(has("dom-computed-style")){
147 |             // if element is not statically positioned, make it as such, then restore
148 |             view = d.defaultView;
149 |             cs = view.getComputedStyle(de, null);
150 |             if(cs.position != "static"){
151 |                 position = cs.position;
152 |                 style.position = "";
153 |             }
154 |             buggy = !!(buggy = view.getComputedStyle(de, null)) && buggy.left != "auto";
155 |             if(position !== null){
156 |                 style.position = position;
157 |             }
158 |         }
159 |         return buggy;
160 |     });
161 | 
162 |     addtest("bug-computed-style-hidden-zero-height", function(g, d){
163 |         var cs,
164 |             de = d.documentElement,
165 |             style = de.style,
166 |             display = style.display,
167 |             buggy = null;
168 | 
169 |         if(has("dom-computed-style")){
170 |             style.display = "none";
171 |             cs = d.defaultView.getComputedStyle(de, null);
172 |             buggy = cs && cs.height == "0px";
173 |             style.display = display;
174 |         }
175 |         return buggy;
176 |     });
177 | 
178 |     addtest("bug-root-children-not-styled", function(g, d, el){
179 |         var buggy = null,
180 |             de = d.documentElement;
181 | 
182 |         el.style.cssText = "width:40px;height:40px;";
183 | 
184 |         try{
185 |             de.insertBefore(el, de.firstChild);
186 |             buggy = el.clientWidth == 0;
187 |             de.removeChild(el);
188 |         }catch(e){}
189 | 
190 |         el.style.cssText = "";
191 |         return buggy;
192 |     });
193 | 
194 |     addtest("bug-contains", function(g, d, el){
195 |         var buggy = null,
196 |             e2 = d.createElement("div");
197 | 
198 |         if(has.isHostType(el, "contains")){
199 |             buggy = el.contains(e2);
200 |         }
201 |         return buggy;
202 |     });
203 | 
204 |     addtest("bug-query-selector-ignores-caps", function(g, d, el){
205 |         var e2, buggy = null;
206 | 
207 |         if(d.compatMode == "BackCompat" && has.isHostType(el, "querySelector")){
208 |             e2 = d.createElement("span");
209 |             e2.className = "Test";
210 |             el.appendChild(e2);
211 |             buggy = (el.querySelector(".Test") != null);
212 |             el.removeChild(e2);
213 |         }
214 |         return buggy;
215 |     });
216 | 
217 |     // true for Safari
218 |     addtest("bug-typeof-nodelist-function", function(g, d){
219 |         return (typeof d.documentElement.childNodes == FN);
220 |     });
221 | 
222 |     // true for IE
223 |     addtest("bug-getelementsbytagname-returns-comment-nodes", function(g, d, el){
224 |         var all, buggy = null;
225 | 
226 |         el.appendChild(d.createElement("span")).appendChild(d.createTextNode("a"));
227 |         el.appendChild(d.createComment("b"));
228 |         all = el.getElementsByTagName("*");
229 | 
230 |         // IE5.5 returns a 0-length collection when calling getElementsByTagName with wildcard
231 |         if(all.length){
232 |             buggy = !!all[1] && all[1].nodeType != 1;
233 |         }
234 |         has.clearElement(el);
235 |         return buggy;
236 |     });
237 | 
238 |     // name attribute can not be set at run time in IE < 8
239 |     // http://msdn.microsoft.com/en-us/library/ms536389.aspx
240 |     addtest("bug-readonly-element-name", function(g, d, el){
241 |         var buggy,
242 |             input = el.appendChild(d.createElement("input"));
243 | 
244 |         input.name = 'x';
245 |         buggy = !el.getElementsByTagName('*')['x'];
246 |         has.clearElement(el);
247 |         return buggy;
248 |     });
249 | 
250 |     // type attribute can only be set once and cannot be changed once in DOM
251 |     // http://msdn.microsoft.com/en-us/library/ms534700.aspx
252 |     addtest("bug-readonly-element-type", function(g, d, el){
253 |         var buggy = true,
254 |             input = el.appendChild(d.createElement("input"));
255 | 
256 |         input.type = 'text';
257 |         try {
258 |           input.type = 'password';
259 |           buggy = input.type != 'password';
260 |         } catch (e) { }
261 |         has.clearElement(el);
262 |         return buggy;
263 |     });
264 | 
265 |     // true for IE
266 |     addtest("bug-properties-are-attributes", function(g, d, el){
267 |         el.__foo = "bar";
268 |         var buggy = el.getAttribute("__foo") == "bar";
269 | 
270 |         if(buggy){
271 |             el.removeAttribute("__foo");
272 |         }else{
273 |             delete el.__foo;
274 |         }
275 |         return buggy;
276 |     });
277 | 
278 |     // true for IE
279 |     addtest("bug-pre-ignores-newline", function(g, d){
280 |         var buggy,
281 |             de = d.documentElement,
282 |             el = de.appendChild(d.createElement("pre")),
283 |             txt = el.appendChild(d.createTextNode("xx")),
284 |             initialHeight = el.offsetHeight;
285 | 
286 |         el.firstChild.nodeValue = "x\nx";
287 |         // check if `offsetHeight` changed after adding "\n" to the value
288 |         buggy = el.offsetHeight == initialHeight;
289 |         de.removeChild(el);
290 |         return buggy;
291 |     });
292 | 
293 |     addtest("bug-select-innerhtml", function(g, d, el){
294 |         var buggy = true;
295 |         el = d.createElement("select");
296 |         el.innerHTML = "<option value='test'>test<\/option>";
297 |         if(has.isHostType(el, "options") && el.options[0]){
298 |             buggy = el.options[0].nodeName.toUpperCase() != "OPTION";
299 |         }
300 |         return buggy;
301 |     });
302 | 
303 |     addtest("bug-table-innerhtml", function(g, d, el){
304 |         var buggy = true;
305 |         el = d.createElement("table");
306 |         try{
307 |             if(has.isHostType(el, "tBodies")){
308 |                 el.innerHTML = "<tbody><tr><td>test<\/td><\/tr><\/tbody>";
309 |                 buggy = typeof el.tBodies[0] == "undefined";
310 |             }
311 |         }catch(e){}
312 |         return buggy;
313 |     });
314 | 
315 |     addtest("bug-script-rejects-textnode-append", function(g, d){
316 |         var buggy = true,
317 |             script = d.createElement("script");
318 | 
319 |         try{
320 |             script.appendChild(d.createTextNode(""));
321 |             buggy = !script.firstChild ||
322 |                 (script.firstChild && script.firstChild.nodeType != 3);
323 |         }catch(e){}
324 |         return buggy;
325 |     });
326 | 
327 |     addtest("bug-getelementbyid-ids-names", function(g, d){
328 |         var input
329 |             name = "__test_" + Number(new Date()),
330 |             root = d.getElementsByTagName("head")[0] || d.documentElement,
331 |             buggy = null;
332 | 
333 |         if(has("dom-create-attr")){
334 |             input = d.createElement("<input name='"+ name +"'>");
335 |         }else{
336 |             input = d.createElement("input");
337 |             input.name = name;
338 |         }
339 |         try{
340 |             root.insertBefore(input, root.firstChild);
341 |             buggy = d.getElementById(name) == input;
342 |             root.removeChild(input);
343 |         }catch(e){}
344 |         return buggy;
345 |     });
346 | 
347 |     addtest("bug-getelementbyid-ignores-case", function(g, d){
348 |         var buggy,
349 |             id = "__test_" + Number(new Date()),
350 |             script = d.createElement("script"),
351 |             root = d.getElementsByTagName('script')[0].parentNode;
352 | 
353 |         script.id = id;
354 |         script.type = "text/javascript";
355 |         root.insertBefore(script, root.firstChild);
356 |         buggy = d.getElementById(id.toUpperCase()) == script;
357 |         root.removeChild(script);
358 |         return buggy;
359 |     });
360 | 
361 |     addtest("bug-getelementsbyname", function(g, d, el){
362 |         var buggy,
363 |             script = d.createElement("script"),
364 |             id = "__test_" + Number(new Date()),
365 |             root = d.getElementsByTagName('script')[0].parentNode;
366 | 
367 |         script.id = id;
368 |         script.type = "text/javascript";
369 |         root.insertBefore(script, root.firstChild);
370 |         buggy = d.getElementsByName(id)[0] == script;
371 |         root.removeChild(script);
372 |         return buggy;
373 |     });
374 | 
375 |     addtest("bug-xpath-position", function(g, d, el){
376 |         var buggy = null,
377 |             xpath = ".//*[local-name()='p' or local-name()='P'][position() = 2]";
378 | 
379 |         if(has.isHostType(d, "evaluate") && has.isHostType(g, "XPathResult")){
380 |             el.appendChild(d.createElement("p")).appendChild(d.createTextNode("a"));
381 |             el.appendChild(d.createElement("p")).appendChild(d.createTextNode("b"));
382 |             xpath = d.evaluate(xpath, el, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
383 | 
384 |             if(xpath && has.isHostType(xpath, "snapshotItem")){
385 |                 xpath = xpath.snapshotItem(0);
386 |                 buggy = !!(xpath && xpath.firstChild) && xpath.firstChild.nodeValue != "b";
387 |             }
388 |             has.clearElement(el);
389 |         }
390 |         return buggy;
391 |     });
392 | 
393 |     addtest("bug-overflow-style", function(g, d, el){
394 |         el.innerHTML = "<p style='overflow: visible;'>x</p>";
395 | 
396 |         var buggy = null,
397 |             p = el.firstChild,
398 |             style = p && p.style;
399 | 
400 |         if(style){
401 |             style.overflow = "hidden";
402 |             buggy = style.overflow != "hidden";
403 |         }
404 |         el.innerHTML = "";
405 |         return buggy;
406 |     });
407 | 
408 |     // TODO: Add more QSA tests
409 |     addtest("bug-qsa", function(g, d, el){
410 |         var buggy = null;
411 |         if(has.isHostType(el, "querySelectorAll")){
412 |             el.appendChild(d.createElement("object"))
413 |                 .appendChild(d.createElement("param"));
414 |             buggy = el.querySelectorAll("param").length != 1;
415 |             has.clearElement(el);
416 |         }
417 |         return buggy;
418 |     });
419 | 
420 |     addtest("bug-string-split-regexp", function(){
421 |         var buggy = null, s = "a_b";
422 |         if(toString.call(s.split) == FUNCTION_CLASS){
423 |             buggy = s.split(/(_)/).length != 3;
424 |         }
425 |         return buggy;
426 |     });
427 | 
428 |     addtest("bug-function-expression", function(){
429 |         // `x` should be resolved to `null` (the one we declared outside this function)
430 |         // but since named function expression identifier leaks onto the enclosing scope in IE,
431 |         // it will be resolved to a function
432 |         var f = function x(){},
433 |            buggy = typeof x == FN;
434 |         if(buggy){
435 |           x = null;
436 |         }
437 |         return buggy;
438 |     });
439 | 
440 |     addtest("bug-string-replace-ignores-functions", function(){
441 |         var buggy = null, s = "a";
442 |         if(toString.call(s.replace) == FUNCTION_CLASS){
443 |             buggy = s.replace(s, function(){ return ""; }) != "";
444 |         }
445 |         return buggy;
446 |     });
447 | 
448 |     addtest("bug-arguments-instanceof-array", function(g){
449 |         return arguments instanceof g.Array;
450 |     });
451 | 
452 |     addtest("bug-array-concat-arguments", function(){
453 |         return (function(){
454 |             var buggy = null;
455 |             if(has("bug-arguments-instanceof-array")){
456 |                 buggy = [].concat(arguments)[0] != 1;
457 |             }
458 |             return buggy;
459 |         })(1,2);
460 |     });
461 | 
462 |     addtest("bug-dontenum-enumerable", function(){
463 |         for(var prop in { toString: true }){
464 |             return false;
465 |         }
466 |         return true;
467 |     });
468 | 
469 |     // ES5 added <BOM> (\uFEFF) as a whitespace character
470 |     var whitespace = "\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u180E\u2000\u2001\u2002"+
471 |         "\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF";
472 | 
473 |     addtest("bug-es5-trim", function(){
474 |         var buggy = null;
475 |         if(has("string-trim")){
476 |             buggy = !!whitespace.trim();
477 |         }
478 |         return buggy;
479 |     });
480 | 
481 |     addtest("bug-es5-regexp", function(){
482 |         return !(/^\s+$/).test(whitespace);
483 |     });
484 | 
485 |     addtest("bug-tofixed-rounding", function(){
486 |         return (.9).toFixed() == 0;
487 |     });
488 | 
489 | 	return has;
490 | });
491 | })(typeof define != "undefined" ? define : function(deps, factory){
492 | 	factory(has); // the use global has() if a module system is not available 
493 | });
494 | 


--------------------------------------------------------------------------------
/tests/require.js:
--------------------------------------------------------------------------------
   1 | /** vim: et:ts=4:sw=4:sts=4
   2 |  * @license RequireJS 0.14.5 Copyright (c) 2010, The Dojo Foundation All Rights Reserved.
   3 |  * Available via the MIT or new BSD license.
   4 |  * see: http://github.com/jrburke/requirejs for details
   5 |  */
   6 | //laxbreak is true to allow build pragmas to change some statements.
   7 | /*jslint plusplus: false, nomen: false, laxbreak: true, regexp: false */
   8 | /*global window: false, document: false, navigator: false,
   9 | setTimeout: false, traceDeps: true, clearInterval: false, self: false,
  10 | setInterval: false, importScripts: false, jQuery: false */
  11 | "use strict";
  12 | 
  13 | var require, define;
  14 | (function () {
  15 |     //Change this version number for each release.
  16 |     var version = "0.14.5+",
  17 |             empty = {}, s,
  18 |             i, defContextName = "_", contextLoads = [],
  19 |             scripts, script, rePkg, src, m, dataMain, cfg = {}, setReadyState,
  20 |             readyRegExp = /^(complete|loaded)$/,
  21 |             commentRegExp = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,
  22 |             cjsRequireRegExp = /require\(["']([\w-_\.\/]+)["']\)/g,
  23 |             main,
  24 |             isBrowser = !!(typeof window !== "undefined" && navigator && document),
  25 |             isWebWorker = !isBrowser && typeof importScripts !== "undefined",
  26 |             ostring = Object.prototype.toString,
  27 |             ap = Array.prototype,
  28 |             aps = ap.slice, scrollIntervalId, req, baseElement,
  29 |             defQueue = [], useInteractive = false, currentlyAddingScript;
  30 | 
  31 |     function isFunction(it) {
  32 |         return ostring.call(it) === "[object Function]";
  33 |     }
  34 | 
  35 |     //Check for an existing version of require. If so, then exit out. Only allow
  36 |     //one version of require to be active in a page. However, allow for a require
  37 |     //config object, just exit quickly if require is an actual function.
  38 |     if (typeof require !== "undefined") {
  39 |         if (isFunction(require)) {
  40 |             return;
  41 |         } else {
  42 |             //assume it is a config object.
  43 |             cfg = require;
  44 |         }
  45 |     }
  46 |     
  47 |     //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
  48 |     /**
  49 |      * Calls a method on a plugin. The obj object should have two property,
  50 |      * name: the name of the method to call on the plugin
  51 |      * args: the arguments to pass to the plugin method.
  52 |      */
  53 |     function callPlugin(prefix, context, obj) {
  54 |         //Call the plugin, or load it.
  55 |         var plugin = s.plugins.defined[prefix], waiting;
  56 |         if (plugin) {
  57 |             plugin[obj.name].apply(null, obj.args);
  58 |         } else {
  59 |             //Put the call in the waiting call BEFORE requiring the module,
  60 |             //since the require could be synchronous in some environments,
  61 |             //like builds
  62 |             waiting = s.plugins.waiting[prefix] || (s.plugins.waiting[prefix] = []);
  63 |             waiting.push(obj);
  64 | 
  65 |             //Load the module
  66 |             req(["require/" + prefix], context.contextName);
  67 |         }
  68 |     }
  69 |     //>>excludeEnd("requireExcludePlugin");
  70 | 
  71 |     /**
  72 |      * Convenience method to call main for a require.def call that was put on
  73 |      * hold in the defQueue.
  74 |      */
  75 |     function callDefMain(args, context) {
  76 |         main.apply(req, args);
  77 |         //Mark the module loaded. Must do it here in addition
  78 |         //to doing it in require.def in case a script does
  79 |         //not call require.def
  80 |         context.loaded[args[0]] = true;
  81 |     }
  82 | 
  83 |     /**
  84 |      * Used to set up package paths from a packagePaths or packages config object.
  85 |      * @param {Object} packages the object to store the new package config
  86 |      * @param {Array} currentPackages an array of packages to configure
  87 |      * @param {String} [dir] a prefix dir to use.
  88 |      */
  89 |     function configurePackageDir(packages, currentPackages, dir) {
  90 |         var i, location, pkgObj;
  91 |         for (i = 0; (pkgObj = currentPackages[i]); i++) {
  92 |             pkgObj = typeof pkgObj === "string" ? { name: pkgObj } : pkgObj;
  93 |             location = pkgObj.location;
  94 | 
  95 |             //Add dir to the path, but avoid paths that start with a slash
  96 |             //or have a colon (indicates a protocol)
  97 |             if (dir && (!location || (location.indexOf("/") !== 0 && location.indexOf(":") === -1))) {
  98 |                 pkgObj.location = dir + "/" + (pkgObj.location || pkgObj.name);
  99 |             }
 100 | 
 101 |             //Normalize package paths.
 102 |             pkgObj.location = pkgObj.location || pkgObj.name;
 103 |             pkgObj.lib = pkgObj.lib || "lib";
 104 |             pkgObj.main = pkgObj.main || "main";
 105 | 
 106 |             packages[pkgObj.name] = pkgObj;
 107 |         }
 108 |     }
 109 | 
 110 |     /**
 111 |      * Determine if priority loading is done. If so clear the priorityWait
 112 |      */
 113 |     function isPriorityDone(context) {
 114 |         var priorityDone = true,
 115 |             priorityWait = context.config.priorityWait,
 116 |             priorityName, i;
 117 |         if (priorityWait) {
 118 |             for (i = 0; (priorityName = priorityWait[i]); i++) {
 119 |                 if (!context.loaded[priorityName]) {
 120 |                     priorityDone = false;
 121 |                     break;
 122 |                 }
 123 |             }
 124 |             if (priorityDone) {
 125 |                 delete context.config.priorityWait;
 126 |             }
 127 |         }
 128 |         return priorityDone;
 129 |     }
 130 | 
 131 |     /**
 132 |      * Resumes tracing of dependencies and then checks if everything is loaded.
 133 |      */
 134 |     function resume(context) {
 135 |         var args, i, paused = s.paused;
 136 |         if (context.scriptCount <= 0) {
 137 |             //Synchronous envs will push the number below zero with the
 138 |             //decrement above, be sure to set it back to zero for good measure.
 139 |             //require() calls that also do not end up loading scripts could
 140 |             //push the number negative too.
 141 |             context.scriptCount = 0;
 142 | 
 143 |             //Make sure any remaining defQueue items get properly processed.
 144 |             while (defQueue.length) {
 145 |                 args = defQueue.shift();
 146 |                 if (args[0] === null) {
 147 |                     req.onError(new Error('Mismatched anonymous require.def modules'));
 148 |                 } else {
 149 |                     callDefMain(args, context);
 150 |                 }
 151 |             }
 152 | 
 153 |             //Skip the resume if current context is in priority wait.
 154 |             if (context.config.priorityWait && !isPriorityDone(context)) {
 155 |                 return;
 156 |             }
 157 | 
 158 |             if (paused.length) {
 159 |                 for (i = 0; (args = paused[i]); i++) {
 160 |                     req.checkDeps.apply(req, args);
 161 |                 }
 162 |             }
 163 | 
 164 |             req.checkLoaded(s.ctxName);
 165 |         }
 166 |     }
 167 | 
 168 |     /**
 169 |      * Main entry point.
 170 |      *
 171 |      * If the only argument to require is a string, then the module that
 172 |      * is represented by that string is fetched for the appropriate context.
 173 |      *
 174 |      * If the first argument is an array, then it will be treated as an array
 175 |      * of dependency string names to fetch. An optional function callback can
 176 |      * be specified to execute when all of those dependencies are available.
 177 |      */
 178 |     require = function (deps, callback, contextName, relModuleName) {
 179 |         var context, config;
 180 |         if (typeof deps === "string" && !isFunction(callback)) {
 181 |             //Just return the module wanted. In this scenario, the
 182 |             //second arg (if passed) is just the contextName.
 183 |             return require.get(deps, callback, contextName, relModuleName);
 184 |         }
 185 |         // Dependencies first
 186 |         if (!require.isArray(deps)) {
 187 |             // deps is a config object
 188 |             config = deps;
 189 |             if (require.isArray(callback)) {
 190 |                 // Adjust args if there are dependencies
 191 |                 deps = callback;
 192 |                 callback = contextName;
 193 |                 contextName = relModuleName;
 194 |                 relModuleName = arguments[4];
 195 |             } else {
 196 |                 deps = [];
 197 |             }
 198 |         }
 199 | 
 200 |         main(null, deps, callback, config, contextName, relModuleName);
 201 | 
 202 |         //If the require call does not trigger anything new to load,
 203 |         //then resume the dependency processing. Context will be undefined
 204 |         //on first run of require.
 205 |         context = s.contexts[(contextName || (config && config.context) || s.ctxName)];
 206 |         if (context && context.scriptCount === 0) {
 207 |             resume(context);
 208 |         }
 209 |         //Returning undefined for Spidermonky strict checking in Komodo
 210 |         return undefined;
 211 |     };
 212 | 
 213 |     //Alias for caja compliance internally -
 214 |     //specifically: "Dynamically computed names should use require.async()"
 215 |     //even though this spec isn't really decided on.
 216 |     //Since it is here, use this alias to make typing shorter.
 217 |     req = require;
 218 | 
 219 |     /**
 220 |      * Any errors that require explicitly generates will be passed to this
 221 |      * function. Intercept/override it if you want custom error handling.
 222 |      * If you do override it, this method should *always* throw an error
 223 |      * to stop the execution flow correctly. Otherwise, other weird errors
 224 |      * will occur.
 225 |      * @param {Error} err the error object.
 226 |      */
 227 |     req.onError = function (err) {
 228 |         throw err;
 229 |     };
 230 | 
 231 |     /**
 232 |      * The function that handles definitions of modules. Differs from
 233 |      * require() in that a string for the module should be the first argument,
 234 |      * and the function to execute after dependencies are loaded should
 235 |      * return a value to define the module corresponding to the first argument's
 236 |      * name.
 237 |      */
 238 |     define = req.def = function (name, deps, callback, contextName) {
 239 |         var i, scripts, script, node = currentlyAddingScript;
 240 | 
 241 |         //Allow for anonymous functions
 242 |         if (typeof name !== 'string') {
 243 |             //Adjust args appropriately
 244 |             contextName = callback;
 245 |             callback = deps;
 246 |             deps = name;
 247 |             name = null;
 248 |         }
 249 | 
 250 |         //This module may not have dependencies
 251 |         if (!req.isArray(deps)) {
 252 |             contextName = callback;
 253 |             callback = deps;
 254 |             deps = [];
 255 |         }
 256 | 
 257 |         //If no name, and callback is a function, then figure out if it a
 258 |         //CommonJS thing with dependencies.
 259 |         if (!name && !deps.length && req.isFunction(callback)) {
 260 |             //Remove comments from the callback string,
 261 |             //look for require calls, and pull them into the dependencies.
 262 |             callback
 263 |                 .toString()
 264 |                 .replace(commentRegExp, "")
 265 |                 .replace(cjsRequireRegExp, function (match, dep) {
 266 |                     deps.push(dep);
 267 |                 });
 268 | 
 269 |             //May be a CommonJS thing even without require calls, but still
 270 |             //could use exports, and such, so always add those as dependencies.
 271 |             //This is a bit wasteful for RequireJS modules that do not need
 272 |             //an exports or module object, but erring on side of safety.
 273 |             //REQUIRES the function to expect the CommonJS variables in the
 274 |             //order listed below.
 275 |             deps = ["require", "exports", "module"].concat(deps);
 276 |         }
 277 | 
 278 |         //If in IE 6-8 and hit an anonymous require.def call, do the interactive/
 279 |         //currentlyAddingScript scripts stuff.
 280 |         if (!name && useInteractive) {
 281 |             scripts = document.getElementsByTagName('script');
 282 |             for (i = scripts.length - 1; i > -1 && (script = scripts[i]); i--) {
 283 |                 if (script.readyState === 'interactive') {
 284 |                     node = script;
 285 |                     break;
 286 |                 }
 287 |             }
 288 |             if (!node) {
 289 |                 req.onError(new Error("ERROR: No matching script interactive for " + callback));
 290 |             }
 291 | 
 292 |             name = node.getAttribute("data-requiremodule");
 293 |         }
 294 | 
 295 |         if (typeof name === 'string') {
 296 |             //Do not try to auto-register a jquery later.
 297 |             //Do this work here and in main, since for IE/useInteractive, this function
 298 |             //is the earliest touch-point.
 299 |             s.contexts[s.ctxName].jQueryDef = (name === "jquery");
 300 |         }
 301 | 
 302 |         //Always save off evaluating the def call until the script onload handler.
 303 |         //This allows multiple modules to be in a file without prematurely
 304 |         //tracing dependencies, and allows for anonymous module support,
 305 |         //where the module name is not known until the script onload event
 306 |         //occurs.
 307 |         defQueue.push([name, deps, callback, null, contextName]);
 308 |     };
 309 | 
 310 |     main = function (name, deps, callback, config, contextName, relModuleName) {
 311 |         //Grab the context, or create a new one for the given context name.
 312 |         var context, newContext, loaded, pluginPrefix,
 313 |             canSetContext, prop, newLength, outDeps, mods, paths, index, i,
 314 |             deferMods, deferModArgs, lastModArg, waitingName, packages,
 315 |             packagePaths;
 316 | 
 317 |         contextName = contextName ? contextName : (config && config.context ? config.context : s.ctxName);
 318 |         context = s.contexts[contextName];
 319 | 
 320 |         if (name) {
 321 |             //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
 322 |             // Pull off any plugin prefix.
 323 |             index = name.indexOf("!");
 324 |             if (index !== -1) {
 325 |                 pluginPrefix = name.substring(0, index);
 326 |                 name = name.substring(index + 1, name.length);
 327 |             } else {
 328 |                 //Could be that the plugin name should be auto-applied.
 329 |                 //Used by i18n plugin to enable anonymous i18n modules, but
 330 |                 //still associating the auto-generated name with the i18n plugin.
 331 |                 pluginPrefix = context.defPlugin[name];
 332 |             }
 333 | 
 334 |             //>>excludeEnd("requireExcludePlugin");
 335 | 
 336 |             //If module already defined for context, or already waiting to be
 337 |             //evaluated, leave.
 338 |             waitingName = context.waiting[name];
 339 |             if (context && (context.defined[name] || (waitingName && waitingName !== ap[name]))) {
 340 |                 return;
 341 |             }
 342 |         }
 343 | 
 344 |         if (contextName !== s.ctxName) {
 345 |             //If nothing is waiting on being loaded in the current context,
 346 |             //then switch s.ctxName to current contextName.
 347 |             loaded = (s.contexts[s.ctxName] && s.contexts[s.ctxName].loaded);
 348 |             canSetContext = true;
 349 |             if (loaded) {
 350 |                 for (prop in loaded) {
 351 |                     if (!(prop in empty)) {
 352 |                         if (!loaded[prop]) {
 353 |                             canSetContext = false;
 354 |                             break;
 355 |                         }
 356 |                     }
 357 |                 }
 358 |             }
 359 |             if (canSetContext) {
 360 |                 s.ctxName = contextName;
 361 |             }
 362 |         }
 363 | 
 364 |         if (!context) {
 365 |             newContext = {
 366 |                 contextName: contextName,
 367 |                 config: {
 368 |                     waitSeconds: 7,
 369 |                     baseUrl: s.baseUrl || "./",
 370 |                     paths: {},
 371 |                     packages: {}
 372 |                 },
 373 |                 waiting: [],
 374 |                 specified: {
 375 |                     "require": true,
 376 |                     "exports": true,
 377 |                     "module": true
 378 |                 },
 379 |                 loaded: {},
 380 |                 scriptCount: 0,
 381 |                 urlFetched: {},
 382 |                 defPlugin: {},
 383 |                 defined: {},
 384 |                 modifiers: {}
 385 |             };
 386 | 
 387 |             //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
 388 |             if (s.plugins.newContext) {
 389 |                 s.plugins.newContext(newContext);
 390 |             }
 391 |             //>>excludeEnd("requireExcludePlugin");
 392 | 
 393 |             context = s.contexts[contextName] = newContext;
 394 |         }
 395 | 
 396 |         //If have a config object, update the context's config object with
 397 |         //the config values.
 398 |         if (config) {
 399 |             //Make sure the baseUrl ends in a slash.
 400 |             if (config.baseUrl) {
 401 |                 if (config.baseUrl.charAt(config.baseUrl.length - 1) !== "/") {
 402 |                     config.baseUrl += "/";
 403 |                 }
 404 |             }
 405 | 
 406 |             //Save off the paths and packages since they require special processing,
 407 |             //they are additive.
 408 |             paths = context.config.paths;
 409 |             packages = context.config.packages;
 410 | 
 411 |             //Mix in the config values, favoring the new values over
 412 |             //existing ones in context.config.
 413 |             req.mixin(context.config, config, true);
 414 | 
 415 |             //Adjust paths if necessary.
 416 |             if (config.paths) {
 417 |                 for (prop in config.paths) {
 418 |                     if (!(prop in empty)) {
 419 |                         paths[prop] = config.paths[prop];
 420 |                     }
 421 |                 }
 422 |                 context.config.paths = paths;
 423 |             }
 424 | 
 425 |             packagePaths = config.packagePaths;
 426 |             if (packagePaths || config.packages) {
 427 |                 //Convert packagePaths into a packages config.
 428 |                 if (packagePaths) {
 429 |                     for (prop in packagePaths) {
 430 |                         if (!(prop in empty)) {
 431 |                             configurePackageDir(packages, packagePaths[prop], prop);
 432 |                         }
 433 |                     }
 434 |                 }
 435 | 
 436 |                 //Adjust packages if necessary.
 437 |                 if (config.packages) {
 438 |                     configurePackageDir(packages, config.packages);
 439 |                 }
 440 | 
 441 |                 //Done with modifications, assing packages back to context config
 442 |                 context.config.packages = packages;
 443 |             }
 444 | 
 445 |             //If priority loading is in effect, trigger the loads now
 446 |             if (config.priority) {
 447 |                 //Create a separate config property that can be
 448 |                 //easily tested for config priority completion.
 449 |                 //Do this instead of wiping out the config.priority
 450 |                 //in case it needs to be inspected for debug purposes later.
 451 |                 req(config.priority);
 452 |                 context.config.priorityWait = config.priority;
 453 |             }
 454 | 
 455 |             //If a deps array or a config callback is specified, then call
 456 |             //require with those args. This is useful when require is defined as a
 457 |             //config object before require.js is loaded.
 458 |             if (config.deps || config.callback) {
 459 |                 req(config.deps || [], config.callback);
 460 |             }
 461 | 
 462 |             //>>excludeStart("requireExcludePageLoad", pragmas.requireExcludePageLoad);
 463 |             //Set up ready callback, if asked. Useful when require is defined as a
 464 |             //config object before require.js is loaded.
 465 |             if (config.ready) {
 466 |                 req.ready(config.ready);
 467 |             }
 468 |             //>>excludeEnd("requireExcludePageLoad");
 469 | 
 470 |             //If it is just a config block, nothing else,
 471 |             //then return.
 472 |             if (!deps) {
 473 |                 return;
 474 |             }
 475 |         }
 476 | 
 477 |         //Normalize dependency strings: need to determine if they have
 478 |         //prefixes and to also normalize any relative paths. Replace the deps
 479 |         //array of strings with an array of objects.
 480 |         if (deps) {
 481 |             outDeps = deps;
 482 |             deps = [];
 483 |             for (i = 0; i < outDeps.length; i++) {
 484 |                 deps[i] = req.splitPrefix(outDeps[i], (name || relModuleName), context);
 485 |             }
 486 |         }
 487 | 
 488 |         //Store the module for later evaluation
 489 |         newLength = context.waiting.push({
 490 |             name: name,
 491 |             deps: deps,
 492 |             callback: callback
 493 |         });
 494 | 
 495 |         if (name) {
 496 |             //Store index of insertion for quick lookup
 497 |             context.waiting[name] = newLength - 1;
 498 | 
 499 |             //Mark the module as specified so no need to fetch it again.
 500 |             //Important to set specified here for the
 501 |             //pause/resume case where there are multiple modules in a file.
 502 |             context.specified[name] = true;
 503 | 
 504 |             //>>excludeStart("requireExcludeModify", pragmas.requireExcludeModify);
 505 |             //Load any modifiers for the module.
 506 |             mods = context.modifiers[name];
 507 |             if (mods) {
 508 |                 req(mods, contextName);
 509 |                 deferMods = mods.__deferMods;
 510 |                 if (deferMods) {
 511 |                     for (i = 0; i < deferMods.length; i++) {
 512 |                         deferModArgs = deferMods[i];
 513 | 
 514 |                         //Add the context name to the def call.
 515 |                         lastModArg = deferModArgs[deferModArgs.length - 1];
 516 |                         if (lastModArg === undefined) {
 517 |                             deferModArgs[deferModArgs.length - 1] = contextName;
 518 |                         } else if (typeof lastModArg === "string") {
 519 |                             deferMods.push(contextName);
 520 |                         }
 521 | 
 522 |                         require.def.apply(require, deferModArgs);
 523 |                     }
 524 |                 }
 525 |             }
 526 |             //>>excludeEnd("requireExcludeModify");
 527 |         }
 528 | 
 529 |         //If the callback is not an actual function, it means it already
 530 |         //has the definition of the module as a literal value.
 531 |         if (name && callback && !req.isFunction(callback)) {
 532 |             context.defined[name] = callback;
 533 |         }
 534 | 
 535 |         //If a pluginPrefix is available, call the plugin, or load it.
 536 |         //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
 537 |         if (pluginPrefix) {
 538 |             callPlugin(pluginPrefix, context, {
 539 |                 name: "require",
 540 |                 args: [name, deps, callback, context]
 541 |             });
 542 |         }
 543 |         //>>excludeEnd("requireExcludePlugin");
 544 | 
 545 |         //Hold on to the module until a script load or other adapter has finished
 546 |         //evaluating the whole file. This helps when a file has more than one
 547 |         //module in it -- dependencies are not traced and fetched until the whole
 548 |         //file is processed.
 549 |         s.paused.push([pluginPrefix, name, deps, context]);
 550 | 
 551 |         //Set loaded here for modules that are also loaded
 552 |         //as part of a layer, where onScriptLoad is not fired
 553 |         //for those cases. Do this after the inline define and
 554 |         //dependency tracing is done.
 555 |         //Also check if auto-registry of jQuery needs to be skipped.
 556 |         if (name) {
 557 |             context.loaded[name] = true;
 558 |             context.jQueryDef = (name === "jquery");
 559 |         }
 560 |     };
 561 | 
 562 |     /**
 563 |      * Simple function to mix in properties from source into target,
 564 |      * but only if target does not already have a property of the same name.
 565 |      */
 566 |     req.mixin = function (target, source, force) {
 567 |         for (var prop in source) {
 568 |             if (!(prop in empty) && (!(prop in target) || force)) {
 569 |                 target[prop] = source[prop];
 570 |             }
 571 |         }
 572 |         return req;
 573 |     };
 574 | 
 575 |     req.version = version;
 576 | 
 577 |     //Set up page state.
 578 |     s = req.s = {
 579 |         ctxName: defContextName,
 580 |         contexts: {},
 581 |         paused: [],
 582 |         //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
 583 |         plugins: {
 584 |             defined: {},
 585 |             callbacks: {},
 586 |             waiting: {}
 587 |         },
 588 |         //>>excludeEnd("requireExcludePlugin");
 589 |         //Stores a list of URLs that should not get async script tag treatment.
 590 |         skipAsync: {},
 591 |         isBrowser: isBrowser,
 592 |         isPageLoaded: !isBrowser,
 593 |         readyCalls: [],
 594 |         doc: isBrowser ? document : null
 595 |     };
 596 | 
 597 |     req.isBrowser = s.isBrowser;
 598 |     if (isBrowser) {
 599 |         s.head = document.getElementsByTagName("head")[0];
 600 |         //If BASE tag is in play, using appendChild is a problem for IE6.
 601 |         //When that browser dies, this can be removed. Details in this jQuery bug:
 602 |         //http://dev.jquery.com/ticket/2709
 603 |         baseElement = document.getElementsByTagName("base")[0];
 604 |         if (baseElement) {
 605 |             s.head = baseElement.parentNode;
 606 |         }
 607 |     }
 608 | 
 609 |     //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
 610 |     /**
 611 |      * Sets up a plugin callback name. Want to make it easy to test if a plugin
 612 |      * needs to be called for a certain lifecycle event by testing for
 613 |      * if (s.plugins.onLifeCyleEvent) so only define the lifecycle event
 614 |      * if there is a real plugin that registers for it.
 615 |      */
 616 |     function makePluginCallback(name, returnOnTrue) {
 617 |         var cbs = s.plugins.callbacks[name] = [];
 618 |         s.plugins[name] = function () {
 619 |             for (var i = 0, cb; (cb = cbs[i]); i++) {
 620 |                 if (cb.apply(null, arguments) === true && returnOnTrue) {
 621 |                     return true;
 622 |                 }
 623 |             }
 624 |             return false;
 625 |         };
 626 |     }
 627 | 
 628 |     /**
 629 |      * Registers a new plugin for require.
 630 |      */
 631 |     req.plugin = function (obj) {
 632 |         var i, prop, call, prefix = obj.prefix, cbs = s.plugins.callbacks,
 633 |             waiting = s.plugins.waiting[prefix], generics,
 634 |             defined = s.plugins.defined, contexts = s.contexts, context;
 635 | 
 636 |         //Do not allow redefinition of a plugin, there may be internal
 637 |         //state in the plugin that could be lost.
 638 |         if (defined[prefix]) {
 639 |             return req;
 640 |         }
 641 | 
 642 |         //Save the plugin.
 643 |         defined[prefix] = obj;
 644 | 
 645 |         //Set up plugin callbacks for methods that need to be generic to
 646 |         //require, for lifecycle cases where it does not care about a particular
 647 |         //plugin, but just that some plugin work needs to be done.
 648 |         generics = ["newContext", "isWaiting", "orderDeps"];
 649 |         for (i = 0; (prop = generics[i]); i++) {
 650 |             if (!s.plugins[prop]) {
 651 |                 makePluginCallback(prop, prop === "isWaiting");
 652 |             }
 653 |             cbs[prop].push(obj[prop]);
 654 |         }
 655 | 
 656 |         //Call newContext for any contexts that were already created.
 657 |         if (obj.newContext) {
 658 |             for (prop in contexts) {
 659 |                 if (!(prop in empty)) {
 660 |                     context = contexts[prop];
 661 |                     obj.newContext(context);
 662 |                 }
 663 |             }
 664 |         }
 665 | 
 666 |         //If there are waiting requests for a plugin, execute them now.
 667 |         if (waiting) {
 668 |             for (i = 0; (call = waiting[i]); i++) {
 669 |                 if (obj[call.name]) {
 670 |                     obj[call.name].apply(null, call.args);
 671 |                 }
 672 |             }
 673 |             delete s.plugins.waiting[prefix];
 674 |         }
 675 | 
 676 |         return req;
 677 |     };
 678 |     //>>excludeEnd("requireExcludePlugin");
 679 | 
 680 |     /**
 681 |      * As of jQuery 1.4.3, it supports a readyWait property that will hold off
 682 |      * calling jQuery ready callbacks until all scripts are loaded. Be sure
 683 |      * to track it if readyWait is available. Also, since jQuery 1.4.3 does
 684 |      * not register as a module, need to do some global inference checking.
 685 |      * Even if it does register as a module, not guaranteed to be the precise
 686 |      * name of the global. If a jQuery is tracked for this context, then go
 687 |      * ahead and register it as a module too, if not already in process.
 688 |      */
 689 |     function jQueryCheck(context, jqCandidate) {
 690 |         if (!context.jQuery) {
 691 |             var $ = jqCandidate || (typeof jQuery !== "undefined" ? jQuery : null);
 692 |             if ($ && "readyWait" in $) {
 693 |                 context.jQuery = $;
 694 | 
 695 |                 //Manually create a "jquery" module entry if not one already
 696 |                 //or in process.
 697 |                 if (!context.defined.jquery && !context.jQueryDef) {
 698 |                     context.defined.jquery = $;
 699 |                 }
 700 | 
 701 |                 //Make sure 
 702 |                 if (context.scriptCount) {
 703 |                     $.readyWait += 1;
 704 |                     context.jQueryIncremented = true;
 705 |                 }
 706 |             }
 707 |         }
 708 |     }
 709 | 
 710 |     /**
 711 |      * Internal method used by environment adapters to complete a load event.
 712 |      * A load event could be a script load or just a load pass from a synchronous
 713 |      * load call.
 714 |      * @param {String} moduleName the name of the module to potentially complete.
 715 |      * @param {Object} context the context object
 716 |      */
 717 |     req.completeLoad = function (moduleName, context) {
 718 |         //If there is a waiting require.def call
 719 |         var args;
 720 |         while (defQueue.length) {
 721 |             args = defQueue.shift();
 722 |             if (args[0] === null) {
 723 |                 args[0] = moduleName;
 724 |                 break;
 725 |             } else if (args[0] === moduleName) {
 726 |                 //Found matching require.def call for this script!
 727 |                 break;
 728 |             } else {
 729 |                 //Some other named require.def call, most likely the result
 730 |                 //of a build layer that included many require.def calls.
 731 |                 callDefMain(args, context);
 732 |             }
 733 |         }
 734 |         if (args) {
 735 |             callDefMain(args, context);
 736 |         }
 737 | 
 738 |         //Mark the script as loaded. Note that this can be different from a
 739 |         //moduleName that maps to a require.def call. This line is important
 740 |         //for traditional browser scripts.
 741 |         context.loaded[moduleName] = true;
 742 | 
 743 |         //If a global jQuery is defined, check for it. Need to do it here
 744 |         //instead of main() since stock jQuery does not register as
 745 |         //a module via define.
 746 |         jQueryCheck(context);
 747 | 
 748 |         context.scriptCount -= 1;
 749 |         resume(context);
 750 |     };
 751 | 
 752 |     /**
 753 |      * Legacy function, remove at some point
 754 |      */
 755 |     req.pause = req.resume = function () {};
 756 | 
 757 |     /**
 758 |      * Trace down the dependencies to see if they are loaded. If not, trigger
 759 |      * the load.
 760 |      * @param {String} pluginPrefix the plugin prefix, if any associated with the name.
 761 |      *
 762 |      * @param {String} name: the name of the module that has the dependencies.
 763 |      *
 764 |      * @param {Array} deps array of dependencies.
 765 |      *
 766 |      * @param {Object} context: the loading context.
 767 |      *
 768 |      * @private
 769 |      */
 770 |     req.checkDeps = function (pluginPrefix, name, deps, context) {
 771 |         //Figure out if all the modules are loaded. If the module is not
 772 |         //being loaded or already loaded, add it to the "to load" list,
 773 |         //and request it to be loaded.
 774 |         var i, dep;
 775 | 
 776 |         if (pluginPrefix) {
 777 |             //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
 778 |             callPlugin(pluginPrefix, context, {
 779 |                 name: "checkDeps",
 780 |                 args: [name, deps, context]
 781 |             });
 782 |             //>>excludeEnd("requireExcludePlugin");
 783 |         } else {
 784 |             for (i = 0; (dep = deps[i]); i++) {
 785 |                 if (!context.specified[dep.fullName]) {
 786 |                     context.specified[dep.fullName] = true;
 787 | 
 788 |                     //Reset the start time to use for timeouts
 789 |                     context.startTime = (new Date()).getTime();
 790 | 
 791 |                     //If a plugin, call its load method.
 792 |                     if (dep.prefix) {
 793 |                         //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
 794 |                         callPlugin(dep.prefix, context, {
 795 |                             name: "load",
 796 |                             args: [dep.name, context.contextName]
 797 |                         });
 798 |                         //>>excludeEnd("requireExcludePlugin");
 799 |                     } else {
 800 |                         req.load(dep.name, context.contextName);
 801 |                     }
 802 |                 }
 803 |             }
 804 |         }
 805 |     };
 806 | 
 807 |     //>>excludeStart("requireExcludeModify", pragmas.requireExcludeModify);
 808 |     /**
 809 |      * Register a module that modifies another module. The modifier will
 810 |      * only be called once the target module has been loaded.
 811 |      *
 812 |      * First syntax:
 813 |      *
 814 |      * require.modify({
 815 |      *     "some/target1": "my/modifier1",
 816 |      *     "some/target2": "my/modifier2",
 817 |      * });
 818 |      *
 819 |      * With this syntax, the my/modifier1 will only be loaded when
 820 |      * "some/target1" is loaded.
 821 |      *
 822 |      * Second syntax, defining a modifier.
 823 |      *
 824 |      * require.modify("some/target1", "my/modifier",
 825 |      *                        ["some/target1", "some/other"],
 826 |      *                        function (target, other) {
 827 |      *                            //Modify properties of target here.
 828 |      *                            Only properties of target can be modified, but
 829 |      *                            target cannot be replaced.
 830 |      *                        }
 831 |      * );
 832 |      */
 833 |     req.modify = function (target, name, deps, callback, contextName) {
 834 |         var prop, modifier, list,
 835 |                 cName = (typeof target === "string" ? contextName : name) || s.ctxName,
 836 |                 context = s.contexts[cName],
 837 |                 mods = context.modifiers;
 838 | 
 839 |         if (typeof target === "string") {
 840 |             //A modifier module.
 841 |             //First store that it is a modifier.
 842 |             list = mods[target] || (mods[target] = []);
 843 |             if (!list[name]) {
 844 |                 list.push(name);
 845 |                 list[name] = true;
 846 |             }
 847 | 
 848 |             //Trigger the normal module definition logic if the target
 849 |             //is already in the system.
 850 |             if (context.specified[target]) {
 851 |                 req.def(name, deps, callback, contextName);
 852 |             } else {
 853 |                 //Hold on to the execution/dependency checks for the modifier
 854 |                 //until the target is fetched.
 855 |                 (list.__deferMods || (list.__deferMods = [])).push([name, deps, callback, contextName]);
 856 |             }
 857 |         } else {
 858 |             //A list of modifiers. Save them for future reference.
 859 |             for (prop in target) {
 860 |                 if (!(prop in empty)) {
 861 |                     //Store the modifier for future use.
 862 |                     modifier = target[prop];
 863 |                     list = mods[prop] || (context.modifiers[prop] = []);
 864 |                     if (!list[modifier]) {
 865 |                         list.push(modifier);
 866 |                         list[modifier] = true;
 867 | 
 868 |                         if (context.specified[prop]) {
 869 |                             //Load the modifier right away.
 870 |                             req([modifier], cName);
 871 |                         }
 872 |                     }
 873 |                 }
 874 |             }
 875 |         }
 876 |     };
 877 |     //>>excludeEnd("requireExcludeModify");
 878 | 
 879 |     req.isArray = function (it) {
 880 |         return ostring.call(it) === "[object Array]";
 881 |     };
 882 | 
 883 |     req.isFunction = isFunction;
 884 | 
 885 |     /**
 886 |      * Gets one module's exported value. This method is used by require().
 887 |      * It is broken out as a separate function to allow a host environment
 888 |      * shim to overwrite this function with something appropriate for that
 889 |      * environment.
 890 |      *
 891 |      * @param {String} moduleName the name of the module.
 892 |      * @param {String} [contextName] the name of the context to use. Uses
 893 |      * default context if no contextName is provided. You should never
 894 |      * pass the contextName explicitly -- it is handled by the require() code.
 895 |      * @param {String} [relModuleName] a module name to use for relative
 896 |      * module name lookups. You should never pass this argument explicitly --
 897 |      * it is handled by the require() code.
 898 |      *
 899 |      * @returns {Object} the exported module value.
 900 |      */
 901 |     req.get = function (moduleName, contextName, relModuleName) {
 902 |         if (moduleName === "require" || moduleName === "exports" || moduleName === "module") {
 903 |             req.onError(new Error("Explicit require of " + moduleName + " is not allowed."));
 904 |         }
 905 |         contextName = contextName || s.ctxName;
 906 | 
 907 |         var ret, context = s.contexts[contextName];
 908 | 
 909 |         //Normalize module name, if it contains . or ..
 910 |         moduleName = req.normalizeName(moduleName, relModuleName, context);
 911 | 
 912 |         ret = context.defined[moduleName];
 913 |         if (ret === undefined) {
 914 |             req.onError(new Error("require: module name '" +
 915 |                         moduleName +
 916 |                         "' has not been loaded yet for context: " +
 917 |                         contextName));
 918 |         }
 919 |         return ret;
 920 |     };
 921 | 
 922 |     /**
 923 |      * Makes the request to load a module. May be an async load depending on
 924 |      * the environment and the circumstance of the load call. Override this
 925 |      * method in a host environment shim to do something specific for that
 926 |      * environment.
 927 |      *
 928 |      * @param {String} moduleName the name of the module.
 929 |      * @param {String} contextName the name of the context to use.
 930 |      */
 931 |     req.load = function (moduleName, contextName) {
 932 |         var context = s.contexts[contextName],
 933 |             urlFetched = context.urlFetched,
 934 |             loaded = context.loaded, url;
 935 |         s.isDone = false;
 936 | 
 937 |         //Only set loaded to false for tracking if it has not already been set.
 938 |         if (!loaded[moduleName]) {
 939 |             loaded[moduleName] = false;
 940 |         }
 941 | 
 942 |         if (contextName !== s.ctxName) {
 943 |             //Not in the right context now, hold on to it until
 944 |             //the current context finishes all its loading.
 945 |             contextLoads.push(arguments);
 946 |         } else {
 947 |             //First derive the path name for the module.
 948 |             url = req.nameToUrl(moduleName, null, contextName);
 949 |             if (!urlFetched[url]) {
 950 |                 context.scriptCount += 1;
 951 |                 req.attach(url, contextName, moduleName);
 952 |                 urlFetched[url] = true;
 953 | 
 954 |                 //If tracking a jQuery, then make sure its readyWait
 955 |                 //is incremented to prevent its ready callbacks from
 956 |                 //triggering too soon.
 957 |                 if (context.jQuery && !context.jQueryIncremented) {
 958 |                     context.jQuery.readyWait += 1;
 959 |                     context.jQueryIncremented = true;
 960 |                 }
 961 |             }
 962 |         }
 963 |     };
 964 | 
 965 |     req.jsExtRegExp = /\.js$/;
 966 | 
 967 |     /**
 968 |      * Given a relative module name, like ./something, normalize it to
 969 |      * a real name that can be mapped to a path.
 970 |      * @param {String} name the relative name
 971 |      * @param {String} baseName a real name that the name arg is relative
 972 |      * to.
 973 |      * @param {Object} context
 974 |      * @returns {String} normalized name
 975 |      */
 976 |     req.normalizeName = function (name, baseName, context) {
 977 |         //Adjust any relative paths.
 978 |         var part;
 979 |         if (name.charAt(0) === ".") {
 980 |             //If have a base name, try to normalize against it,
 981 |             //otherwise, assume it is a top-level require that will
 982 |             //be relative to baseUrl in the end.
 983 |             if (baseName) {
 984 |                 if (context.config.packages[baseName]) {
 985 |                     //If the baseName is a package name, then just treat it as one
 986 |                     //name to concat the name with.
 987 |                     baseName = [baseName];
 988 |                 } else {
 989 |                     //Convert baseName to array, and lop off the last part,
 990 |                     //so that . matches that "directory" and not name of the baseName's
 991 |                     //module. For instance, baseName of "one/two/three", maps to
 992 |                     //"one/two/three.js", but we want the directory, "one/two" for
 993 |                     //this normalization.
 994 |                     baseName = baseName.split("/");
 995 |                     baseName = baseName.slice(0, baseName.length - 1);
 996 |                 }
 997 | 
 998 |                 name = baseName.concat(name.split("/"));
 999 |                 for (i = 0; (part = name[i]); i++) {
1000 |                     if (part === ".") {
1001 |                         name.splice(i, 1);
1002 |                         i -= 1;
1003 |                     } else if (part === "..") {
1004 |                         name.splice(i - 1, 2);
1005 |                         i -= 2;
1006 |                     }
1007 |                 }
1008 |                 name = name.join("/");
1009 |             }
1010 |         }
1011 |         return name;
1012 |     };
1013 | 
1014 |     /**
1015 |      * Splits a name into a possible plugin prefix and
1016 |      * the module name. If baseName is provided it will
1017 |      * also normalize the name via require.normalizeName()
1018 |      * 
1019 |      * @param {String} name the module name
1020 |      * @param {String} [baseName] base name that name is
1021 |      * relative to.
1022 |      * @param {Object} context
1023 |      *
1024 |      * @returns {Object} with properties, 'prefix' (which
1025 |      * may be null), 'name' and 'fullName', which is a combination
1026 |      * of the prefix (if it exists) and the name.
1027 |      */
1028 |     req.splitPrefix = function (name, baseName, context) {
1029 |         var index = name.indexOf("!"), prefix = null;
1030 |         if (index !== -1) {
1031 |             prefix = name.substring(0, index);
1032 |             name = name.substring(index + 1, name.length);
1033 |         }
1034 | 
1035 |         //Account for relative paths if there is a base name.
1036 |         name = req.normalizeName(name, baseName, context);
1037 | 
1038 |         return {
1039 |             prefix: prefix,
1040 |             name: name,
1041 |             fullName: prefix ? prefix + "!" + name : name
1042 |         };
1043 |     };
1044 | 
1045 |     /**
1046 |      * Converts a module name to a file path.
1047 |      */
1048 |     req.nameToUrl = function (moduleName, ext, contextName, relModuleName) {
1049 |         var paths, packages, pkg, pkgPath, syms, i, parentModule, url,
1050 |             context = s.contexts[contextName],
1051 |             config = context.config;
1052 | 
1053 |         //Normalize module name if have a base relative module name to work from.
1054 |         moduleName = req.normalizeName(moduleName, relModuleName, context);
1055 | 
1056 |         //If a colon is in the URL, it indicates a protocol is used and it is just
1057 |         //an URL to a file, or if it starts with a slash or ends with .js, it is just a plain file.
1058 |         //The slash is important for protocol-less URLs as well as full paths.
1059 |         if (moduleName.indexOf(":") !== -1 || moduleName.charAt(0) === '/' || req.jsExtRegExp.test(moduleName)) {
1060 |             //Just a plain path, not module name lookup, so just return it.
1061 |             //Add extension if it is included. This is a bit wonky, only non-.js things pass
1062 |             //an extension, this method probably needs to be reworked.
1063 |             url = moduleName + (ext ? ext : "");
1064 |         } else {
1065 |             //A module that needs to be converted to a path.
1066 |             paths = config.paths;
1067 |             packages = config.packages;
1068 | 
1069 |             syms = moduleName.split("/");
1070 |             //For each module name segment, see if there is a path
1071 |             //registered for it. Start with most specific name
1072 |             //and work up from it.
1073 |             for (i = syms.length; i > 0; i--) {
1074 |                 parentModule = syms.slice(0, i).join("/");
1075 |                 if (paths[parentModule]) {
1076 |                     syms.splice(0, i, paths[parentModule]);
1077 |                     break;
1078 |                 } else if ((pkg = packages[parentModule])) {
1079 |                     //pkg can have just a string value to the path
1080 |                     //or can be an object with props:
1081 |                     //main, lib, name, location.
1082 |                     pkgPath = pkg.location + '/' + pkg.lib;
1083 |                     //If module name is just the package name, then looking
1084 |                     //for the main module.
1085 |                     if (moduleName === pkg.name) {
1086 |                         pkgPath += '/' + pkg.main;
1087 |                     }
1088 |                     syms.splice(0, i, pkgPath);
1089 |                     break;
1090 |                 }
1091 |             }
1092 | 
1093 |             //Join the path parts together, then figure out if baseUrl is needed.
1094 |             url = syms.join("/") + (ext || ".js");
1095 |             url = (url.charAt(0) === '/' || url.match(/^\w+:/) ? "" : config.baseUrl) + url;
1096 |         }
1097 |         return config.urlArgs ? url +
1098 |                                 ((url.indexOf('?') === -1 ? '?' : '&') +
1099 |                                  config.urlArgs) : url;
1100 |     };
1101 | 
1102 |     /**
1103 |      * Checks if all modules for a context are loaded, and if so, evaluates the
1104 |      * new ones in right dependency order.
1105 |      *
1106 |      * @private
1107 |      */
1108 |     req.checkLoaded = function (contextName) {
1109 |         var context = s.contexts[contextName || s.ctxName],
1110 |                 waitInterval = context.config.waitSeconds * 1000,
1111 |                 //It is possible to disable the wait interval by using waitSeconds of 0.
1112 |                 expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
1113 |                 loaded, defined = context.defined,
1114 |                 modifiers = context.modifiers, waiting, noLoads = "",
1115 |                 hasLoadedProp = false, stillLoading = false, prop,
1116 | 
1117 |                 //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
1118 |                 pIsWaiting = s.plugins.isWaiting, pOrderDeps = s.plugins.orderDeps,
1119 |                 //>>excludeEnd("requireExcludePlugin");
1120 | 
1121 |                 i, module, allDone, loads, loadArgs, err;
1122 | 
1123 |         //If already doing a checkLoaded call,
1124 |         //then do not bother checking loaded state.
1125 |         if (context.isCheckLoaded) {
1126 |             return;
1127 |         }
1128 | 
1129 |         //Determine if priority loading is done. If so clear the priority. If
1130 |         //not, then do not check
1131 |         if (context.config.priorityWait) {
1132 |             if (isPriorityDone(context)) {
1133 |                 //Call resume, since it could have
1134 |                 //some waiting dependencies to trace.
1135 |                 resume(context);
1136 |             } else {
1137 |                 return;
1138 |             }
1139 |         }
1140 | 
1141 |         //Signal that checkLoaded is being require, so other calls that could be triggered
1142 |         //by calling a waiting callback that then calls require and then this function
1143 |         //should not proceed. At the end of this function, if there are still things
1144 |         //waiting, then checkLoaded will be called again.
1145 |         context.isCheckLoaded = true;
1146 | 
1147 |         //Grab waiting and loaded lists here, since it could have changed since
1148 |         //this function was first called.
1149 |         waiting = context.waiting;
1150 |         loaded = context.loaded;
1151 | 
1152 |         //See if anything is still in flight.
1153 |         for (prop in loaded) {
1154 |             if (!(prop in empty)) {
1155 |                 hasLoadedProp = true;
1156 |                 if (!loaded[prop]) {
1157 |                     if (expired) {
1158 |                         noLoads += prop + " ";
1159 |                     } else {
1160 |                         stillLoading = true;
1161 |                         break;
1162 |                     }
1163 |                 }
1164 |             }
1165 |         }
1166 | 
1167 |         //Check for exit conditions.
1168 |         if (!hasLoadedProp && !waiting.length
1169 |             //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
1170 |             && (!pIsWaiting || !pIsWaiting(context))
1171 |             //>>excludeEnd("requireExcludePlugin");
1172 |            ) {
1173 |             //If the loaded object had no items, then the rest of
1174 |             //the work below does not need to be done.
1175 |             context.isCheckLoaded = false;
1176 |             return;
1177 |         }
1178 |         if (expired && noLoads) {
1179 |             //If wait time expired, throw error of unloaded modules.
1180 |             err = new Error("require.js load timeout for modules: " + noLoads);
1181 |             err.requireType = "timeout";
1182 |             err.requireModules = noLoads;
1183 |             req.onError(err);
1184 |         }
1185 |         if (stillLoading) {
1186 |             //Something is still waiting to load. Wait for it.
1187 |             context.isCheckLoaded = false;
1188 |             if (isBrowser || isWebWorker) {
1189 |                 setTimeout(function () {
1190 |                     req.checkLoaded(contextName);
1191 |                 }, 50);
1192 |             }
1193 |             return;
1194 |         }
1195 | 
1196 |         //Order the dependencies. Also clean up state because the evaluation
1197 |         //of modules might create new loading tasks, so need to reset.
1198 |         //Be sure to call plugins too.
1199 |         context.waiting = [];
1200 |         context.loaded = {};
1201 | 
1202 |         //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
1203 |         //Call plugins to order their dependencies, do their
1204 |         //module definitions.
1205 |         if (pOrderDeps) {
1206 |             pOrderDeps(context);
1207 |         }
1208 |         //>>excludeEnd("requireExcludePlugin");
1209 | 
1210 |         //>>excludeStart("requireExcludeModify", pragmas.requireExcludeModify);
1211 |         //Before defining the modules, give priority treatment to any modifiers
1212 |         //for modules that are already defined.
1213 |         for (prop in modifiers) {
1214 |             if (!(prop in empty)) {
1215 |                 if (defined[prop]) {
1216 |                     req.execModifiers(prop, {}, waiting, context);
1217 |                 }
1218 |             }
1219 |         }
1220 |         //>>excludeEnd("requireExcludeModify");
1221 | 
1222 |         //Define the modules, doing a depth first search.
1223 |         for (i = 0; (module = waiting[i]); i++) {
1224 |             req.exec(module, {}, waiting, context);
1225 |         }
1226 | 
1227 |         //Indicate checkLoaded is now done.
1228 |         context.isCheckLoaded = false;
1229 | 
1230 |         if (context.waiting.length
1231 |             //>>excludeStart("requireExcludePlugin", pragmas.requireExcludePlugin);
1232 |             || (pIsWaiting && pIsWaiting(context))
1233 |             //>>excludeEnd("requireExcludePlugin");
1234 |            ) {
1235 |             //More things in this context are waiting to load. They were probably
1236 |             //added while doing the work above in checkLoaded, calling module
1237 |             //callbacks that triggered other require calls.
1238 |             req.checkLoaded(contextName);
1239 |         } else if (contextLoads.length) {
1240 |             //Check for other contexts that need to load things.
1241 |             //First, make sure current context has no more things to
1242 |             //load. After defining the modules above, new require calls
1243 |             //could have been made.
1244 |             loaded = context.loaded;
1245 |             allDone = true;
1246 |             for (prop in loaded) {
1247 |                 if (!(prop in empty)) {
1248 |                     if (!loaded[prop]) {
1249 |                         allDone = false;
1250 |                         break;
1251 |                     }
1252 |                 }
1253 |             }
1254 | 
1255 |             if (allDone) {
1256 |                 s.ctxName = contextLoads[0][1];
1257 |                 loads = contextLoads;
1258 |                 //Reset contextLoads in case some of the waiting loads
1259 |                 //are for yet another context.
1260 |                 contextLoads = [];
1261 |                 for (i = 0; (loadArgs = loads[i]); i++) {
1262 |                     req.load.apply(req, loadArgs);
1263 |                 }
1264 |             }
1265 |         } else {
1266 |             //Make sure we reset to default context.
1267 |             s.ctxName = defContextName;
1268 |             s.isDone = true;
1269 |             if (req.callReady) {
1270 |                 req.callReady();
1271 |             }
1272 |         }
1273 |     };
1274 | 
1275 |     /**
1276 |      * Helper function that creates a setExports function for a "module"
1277 |      * CommonJS dependency. Do this here to avoid creating a closure that
1278 |      * is part of a loop in require.exec.
1279 |      */
1280 |     function makeSetExports(moduleObj) {
1281 |         return function (exports) {
1282 |             moduleObj.exports = exports;
1283 |         };
1284 |     }
1285 | 
1286 |     function makeContextModuleFunc(name, contextName, moduleName) {
1287 |         return function () {
1288 |             //A version of a require function that forces a contextName value
1289 |             //and also passes a moduleName value for items that may need to
1290 |             //look up paths relative to the moduleName
1291 |             var args = [].concat(aps.call(arguments, 0));
1292 |             args.push(contextName, moduleName);
1293 |             return (name ? require[name] : require).apply(null, args);
1294 |         };
1295 |     }
1296 | 
1297 |     /**
1298 |      * Helper function that creates a require function object to give to
1299 |      * modules that ask for it as a dependency. It needs to be specific
1300 |      * per module because of the implication of path mappings that may
1301 |      * need to be relative to the module name.
1302 |      */
1303 |     function makeRequire(context, moduleName) {
1304 |         var contextName = context.contextName,
1305 |             modRequire = makeContextModuleFunc(null, contextName, moduleName);
1306 | 
1307 |         req.mixin(modRequire, {
1308 |             //>>excludeStart("requireExcludeModify", pragmas.requireExcludeModify);
1309 |             modify: makeContextModuleFunc("modify", contextName, moduleName),
1310 |             //>>excludeEnd("requireExcludeModify");
1311 |             def: makeContextModuleFunc("def", contextName, moduleName),
1312 |             get: makeContextModuleFunc("get", contextName, moduleName),
1313 |             nameToUrl: makeContextModuleFunc("nameToUrl", contextName, moduleName),
1314 |             ready: req.ready,
1315 |             context: context,
1316 |             config: context.config,
1317 |             isBrowser: s.isBrowser
1318 |         });
1319 |         return modRequire;
1320 |     }
1321 | 
1322 |     /**
1323 |      * Executes the modules in the correct order.
1324 |      * 
1325 |      * @private
1326 |      */
1327 |     req.exec = function (module, traced, waiting, context) {
1328 |         //Some modules are just plain script files, abddo not have a formal
1329 |         //module definition, 
1330 |         if (!module) {
1331 |             //Returning undefined for Spidermonky strict checking in Komodo
1332 |             return undefined;
1333 |         }
1334 | 
1335 |         var name = module.name, cb = module.callback, deps = module.deps, j, dep,
1336 |             defined = context.defined, ret, args = [], depModule, cjsModule,
1337 |             usingExports = false, depName;
1338 | 
1339 |         //If already traced or defined, do not bother a second time.
1340 |         if (name) {
1341 |             if (traced[name] || name in defined) {
1342 |                 return defined[name];
1343 |             }
1344 | 
1345 |             //Mark this module as being traced, so that it is not retraced (as in a circular
1346 |             //dependency)
1347 |             traced[name] = true;
1348 |         }
1349 | 
1350 |         if (deps) {
1351 |             for (j = 0; (dep = deps[j]); j++) {
1352 |                 depName = dep.name;
1353 |                 if (depName === "require") {
1354 |                     depModule = makeRequire(context, name);
1355 |                 } else if (depName === "exports") {
1356 |                     //CommonJS module spec 1.1
1357 |                     depModule = defined[name] = {};
1358 |                     usingExports = true;
1359 |                 } else if (depName === "module") {
1360 |                     //CommonJS module spec 1.1
1361 |                     cjsModule = depModule = {
1362 |                         id: name,
1363 |                         uri: name ? req.nameToUrl(name, null, context.contextName) : undefined
1364 |                     };
1365 |                     cjsModule.setExports = makeSetExports(cjsModule);
1366 |                 } else {
1367 |                     //Get dependent module. It could not exist, for a circular
1368 |                     //dependency or if the loaded dependency does not actually call
1369 |                     //require. Favor not throwing an error here if undefined because
1370 |                     //we want to allow code that does not use require as a module
1371 |                     //definition framework to still work -- allow a web site to
1372 |                     //gradually update to contained modules. That is more
1373 |                     //important than forcing a throw for the circular dependency case.
1374 |                     depModule = depName in defined ? defined[depName] : (traced[depName] ? undefined : req.exec(waiting[waiting[depName]], traced, waiting, context));
1375 |                 }
1376 | 
1377 |                 args.push(depModule);
1378 |             }
1379 |         }
1380 | 
1381 |         //Call the callback to define the module, if necessary.
1382 |         cb = module.callback;
1383 |         if (cb && req.isFunction(cb)) {
1384 |             ret = req.execCb(name, cb, args);
1385 |             if (name) {
1386 |                 //If using exports and the function did not return a value,
1387 |                 //and the "module" object for this definition function did not
1388 |                 //define an exported value, then use the exports object.
1389 |                 if (usingExports && ret === undefined && (!cjsModule || !("exports" in cjsModule))) {
1390 |                     ret = defined[name];
1391 |                 } else {
1392 |                     if (cjsModule && "exports" in cjsModule) {
1393 |                         ret = defined[name] = cjsModule.exports;
1394 |                     } else {
1395 |                         if (name in defined && !usingExports) {
1396 |                             req.onError(new Error(name + " has already been defined"));
1397 |                         }
1398 |                         defined[name] = ret;
1399 |                     }
1400 |                 }
1401 |             }
1402 |         }
1403 | 
1404 |         //>>excludeStart("requireExcludeModify", pragmas.requireExcludeModify);
1405 |         //Execute modifiers, if they exist.
1406 |         req.execModifiers(name, traced, waiting, context);
1407 |         //>>excludeEnd("requireExcludeModify");
1408 | 
1409 |         return ret;
1410 |     };
1411 | 
1412 |     /**
1413 |      * Executes a module callack function. Broken out as a separate function
1414 |      * solely to allow the build system to sequence the files in the built
1415 |      * layer in the right sequence.
1416 |      * @param {String} name the module name.
1417 |      * @param {Function} cb the module callback/definition function.
1418 |      * @param {Array} args The arguments (dependent modules) to pass to callback.
1419 |      *
1420 |      * @private
1421 |      */
1422 |     req.execCb = function (name, cb, args) {
1423 |         return cb.apply(null, args);
1424 |     };
1425 | 
1426 |     //>>excludeStart("requireExcludeModify", pragmas.requireExcludeModify);
1427 |     /**
1428 |      * Executes modifiers for the given module name.
1429 |      * @param {String} target
1430 |      * @param {Object} traced
1431 |      * @param {Object} context
1432 |      *
1433 |      * @private
1434 |      */
1435 |     req.execModifiers = function (target, traced, waiting, context) {
1436 |         var modifiers = context.modifiers, mods = modifiers[target], mod, i;
1437 |         if (mods) {
1438 |             for (i = 0; i < mods.length; i++) {
1439 |                 mod = mods[i];
1440 |                 //Not all modifiers define a module, they might collect other modules.
1441 |                 //If it is just a collection it will not be in waiting.
1442 |                 if (mod in waiting) {
1443 |                     req.exec(waiting[waiting[mod]], traced, waiting, context);
1444 |                 }
1445 |             }
1446 |             delete modifiers[target];
1447 |         }
1448 |     };
1449 |     //>>excludeEnd("requireExcludeModify");
1450 | 
1451 |     /**
1452 |      * callback for script loads, used to check status of loading.
1453 |      *
1454 |      * @param {Event} evt the event from the browser for the script
1455 |      * that was loaded.
1456 |      *
1457 |      * @private
1458 |      */
1459 |     req.onScriptLoad = function (evt) {
1460 |         //Using currentTarget instead of target for Firefox 2.0's sake. Not
1461 |         //all old browsers will be supported, but this one was easy enough
1462 |         //to support and still makes sense.
1463 |         var node = evt.currentTarget || evt.srcElement, contextName, moduleName,
1464 |             context;
1465 |         if (evt.type === "load" || readyRegExp.test(node.readyState)) {
1466 |             //Pull out the name of the module and the context.
1467 |             contextName = node.getAttribute("data-requirecontext");
1468 |             moduleName = node.getAttribute("data-requiremodule");
1469 |             context = s.contexts[contextName];
1470 | 
1471 |             req.completeLoad(moduleName, context);
1472 | 
1473 |             //Clean up script binding.
1474 |             if (node.removeEventListener) {
1475 |                 node.removeEventListener("load", req.onScriptLoad, false);
1476 |             } else {
1477 |                 //Probably IE. If not it will throw an error, which will be
1478 |                 //useful to know.
1479 |                 node.detachEvent("onreadystatechange", req.onScriptLoad);
1480 |             }
1481 |         }
1482 |     };
1483 | 
1484 |     /**
1485 |      * Attaches the script represented by the URL to the current
1486 |      * environment. Right now only supports browser loading,
1487 |      * but can be redefined in other environments to do the right thing.
1488 |      * @param {String} url the url of the script to attach.
1489 |      * @param {String} contextName the name of the context that wants the script.
1490 |      * @param {moduleName} the name of the module that is associated with the script.
1491 |      * @param {Function} [callback] optional callback, defaults to require.onScriptLoad
1492 |      * @param {String} [type] optional type, defaults to text/javascript
1493 |      */
1494 |     req.attach = function (url, contextName, moduleName, callback, type) {
1495 |         var node, loaded, context;
1496 |         if (isBrowser) {
1497 |             //In the browser so use a script tag
1498 |             callback = callback || req.onScriptLoad;
1499 |             node = document.createElement("script");
1500 |             node.type = type || "text/javascript";
1501 |             node.charset = "utf-8";
1502 |             //Use async so Gecko does not block on executing the script if something
1503 |             //like a long-polling comet tag is being run first. Gecko likes
1504 |             //to evaluate scripts in DOM order, even for dynamic scripts.
1505 |             //It will fetch them async, but only evaluate the contents in DOM
1506 |             //order, so a long-polling script tag can delay execution of scripts
1507 |             //after it. But telling Gecko we expect async gets us the behavior
1508 |             //we want -- execute it whenever it is finished downloading. Only
1509 |             //Helps Firefox 3.6+
1510 |             //Allow some URLs to not be fetched async. Mostly helps the order!
1511 |             //plugin
1512 |             if (!s.skipAsync[url]) {
1513 |                 node.async = true;
1514 |             }
1515 |             node.setAttribute("data-requirecontext", contextName);
1516 |             node.setAttribute("data-requiremodule", moduleName);
1517 | 
1518 |             //Set up load listener.
1519 |             if (node.addEventListener) {
1520 |                 node.addEventListener("load", callback, false);
1521 |             } else {
1522 |                 //Probably IE. If not it will throw an error, which will be
1523 |                 //useful to know. IE (at least 6-8) do not fire
1524 |                 //script onload right after executing the script, so
1525 |                 //we cannot tie the anonymous require.def call to a name.
1526 |                 //However, IE reports the script as being in "interactive"
1527 |                 //readyState at the time of the require.def call.
1528 |                 useInteractive = true;
1529 |                 node.attachEvent("onreadystatechange", callback);
1530 |             }
1531 |             node.src = url;
1532 | 
1533 |             //For some cache cases in IE 6-8, the script executes before the end
1534 |             //of the appendChild execution, so to tie an anonymous require.def
1535 |             //call to the module name (which is stored on the node), hold on
1536 |             //to a reference to this node, but clear after the DOM insertion.
1537 |             currentlyAddingScript = node;
1538 |             if (baseElement) {
1539 |                 s.head.insertBefore(node, baseElement);
1540 |             } else {
1541 |                 s.head.appendChild(node);
1542 |             }
1543 |             currentlyAddingScript = null;
1544 |             return node;
1545 |         } else if (isWebWorker) {
1546 |             //In a web worker, use importScripts. This is not a very
1547 |             //efficient use of importScripts, importScripts will block until
1548 |             //its script is downloaded and evaluated. However, if web workers
1549 |             //are in play, the expectation that a build has been done so that
1550 |             //only one script needs to be loaded anyway. This may need to be
1551 |             //reevaluated if other use cases become common.
1552 |             context = s.contexts[contextName];
1553 |             loaded = context.loaded;
1554 |             loaded[moduleName] = false;
1555 |             importScripts(url);
1556 | 
1557 |             //Account for anonymous modules
1558 |             req.completeLoad(moduleName, context);
1559 |         }
1560 |         return null;
1561 |     };
1562 | 
1563 |     //Determine what baseUrl should be if not already defined via a require config object
1564 |     s.baseUrl = cfg.baseUrl;
1565 |     if (isBrowser && (!s.baseUrl || !s.head)) {
1566 |         //Figure out baseUrl. Get it from the script tag with require.js in it.
1567 |         scripts = document.getElementsByTagName("script");
1568 |         if (cfg.baseUrlMatch) {
1569 |             rePkg = cfg.baseUrlMatch;
1570 |         } else {
1571 |             //>>includeStart("jquery", pragmas.jquery);
1572 |             rePkg = /(requireplugins-|require-)?jquery[\-\d\.]*(min)?\.js(\W|$)/i;
1573 |             //>>includeEnd("jquery");
1574 | 
1575 |             //>>includeStart("dojoConvert", pragmas.dojoConvert);
1576 |             rePkg = /dojo\.js(\W|$)/i;
1577 |             //>>includeEnd("dojoConvert");
1578 | 
1579 |             //>>excludeStart("dojoConvert", pragmas.dojoConvert);
1580 | 
1581 |             //>>excludeStart("jquery", pragmas.jquery);
1582 |             rePkg = /(allplugins-)?require\.js(\W|$)/i;
1583 |             //>>excludeEnd("jquery");
1584 | 
1585 |             //>>excludeEnd("dojoConvert");
1586 |         }
1587 | 
1588 |         for (i = scripts.length - 1; i > -1 && (script = scripts[i]); i--) {
1589 |             //Set the "head" where we can append children by
1590 |             //using the script's parent.
1591 |             if (!s.head) {
1592 |                 s.head = script.parentNode;
1593 |             }
1594 | 
1595 |             //Look for a data-main attribute to set main script for the page
1596 |             //to load.
1597 |             if (!cfg.deps) {
1598 |                 dataMain = script.getAttribute('data-main');
1599 |                 if (dataMain) {
1600 |                     cfg.deps = [dataMain];
1601 |                 }
1602 |             }
1603 | 
1604 |             //Using .src instead of getAttribute to get an absolute URL.
1605 |             //While using a relative URL will be fine for script tags, other
1606 |             //URLs used for text! resources that use XHR calls might benefit
1607 |             //from an absolute URL.
1608 |             src = script.src;
1609 |             if (src && !s.baseUrl) {
1610 |                 m = src.match(rePkg);
1611 |                 if (m) {
1612 |                     s.baseUrl = src.substring(0, m.index);
1613 |                     break;
1614 |                 }
1615 |             }
1616 |         }
1617 |     }
1618 | 
1619 |     //>>excludeStart("requireExcludePageLoad", pragmas.requireExcludePageLoad);
1620 |     //****** START page load functionality ****************
1621 |     /**
1622 |      * Sets the page as loaded and triggers check for all modules loaded.
1623 |      */
1624 |     req.pageLoaded = function () {
1625 |         if (!s.isPageLoaded) {
1626 |             s.isPageLoaded = true;
1627 |             if (scrollIntervalId) {
1628 |                 clearInterval(scrollIntervalId);
1629 |             }
1630 | 
1631 |             //Part of a fix for FF < 3.6 where readyState was not set to
1632 |             //complete so libraries like jQuery that check for readyState
1633 |             //after page load where not getting initialized correctly.
1634 |             //Original approach suggested by Andrea Giammarchi:
1635 |             //http://webreflection.blogspot.com/2009/11/195-chars-to-help-lazy-loading.html
1636 |             //see other setReadyState reference for the rest of the fix.
1637 |             if (setReadyState) {
1638 |                 document.readyState = "complete";
1639 |             }
1640 | 
1641 |             req.callReady();
1642 |         }
1643 |     };
1644 | 
1645 |     /**
1646 |      * Internal function that calls back any ready functions. If you are
1647 |      * integrating RequireJS with another library without require.ready support,
1648 |      * you can define this method to call your page ready code instead.
1649 |      */
1650 |     req.callReady = function () {
1651 |         var callbacks = s.readyCalls, i, callback, contexts, context, prop;
1652 | 
1653 |         if (s.isPageLoaded && s.isDone) {
1654 |             if (callbacks.length) {
1655 |                 s.readyCalls = [];
1656 |                 for (i = 0; (callback = callbacks[i]); i++) {
1657 |                     callback();
1658 |                 }
1659 |             }
1660 | 
1661 |             //If jQuery with readyWait is being tracked, updated its
1662 |             //readyWait count.
1663 |             contexts = s.contexts;
1664 |             for (prop in contexts) {
1665 |                 if (!(prop in empty)) {
1666 |                     context = contexts[prop];
1667 |                     if (context.jQueryIncremented) {
1668 |                         context.jQuery.readyWait -= 1;
1669 |                         context.jQueryIncremented = false;
1670 |                     }
1671 |                 }
1672 |             }
1673 |         }
1674 |     };
1675 | 
1676 |     /**
1677 |      * Registers functions to call when the page is loaded
1678 |      */
1679 |     req.ready = function (callback) {
1680 |         if (s.isPageLoaded && s.isDone) {
1681 |             callback();
1682 |         } else {
1683 |             s.readyCalls.push(callback);
1684 |         }
1685 |         return req;
1686 |     };
1687 | 
1688 |     if (isBrowser) {
1689 |         if (document.addEventListener) {
1690 |             //Standards. Hooray! Assumption here that if standards based,
1691 |             //it knows about DOMContentLoaded.
1692 |             document.addEventListener("DOMContentLoaded", req.pageLoaded, false);
1693 |             window.addEventListener("load", req.pageLoaded, false);
1694 |             //Part of FF < 3.6 readystate fix (see setReadyState refs for more info)
1695 |             if (!document.readyState) {
1696 |                 setReadyState = true;
1697 |                 document.readyState = "loading";
1698 |             }
1699 |         } else if (window.attachEvent) {
1700 |             window.attachEvent("onload", req.pageLoaded);
1701 | 
1702 |             //DOMContentLoaded approximation, as found by Diego Perini:
1703 |             //http://javascript.nwbox.com/IEContentLoaded/
1704 |             if (self === self.top) {
1705 |                 scrollIntervalId = setInterval(function () {
1706 |                     try {
1707 |                         //From this ticket:
1708 |                         //http://bugs.dojotoolkit.org/ticket/11106,
1709 |                         //In IE HTML Application (HTA), such as in a selenium test,
1710 |                         //javascript in the iframe can't see anything outside
1711 |                         //of it, so self===self.top is true, but the iframe is
1712 |                         //not the top window and doScroll will be available
1713 |                         //before document.body is set. Test document.body
1714 |                         //before trying the doScroll trick.
1715 |                         if (document.body) {
1716 |                             document.documentElement.doScroll("left");
1717 |                             req.pageLoaded();
1718 |                         }
1719 |                     } catch (e) {}
1720 |                 }, 30);
1721 |             }
1722 |         }
1723 | 
1724 |         //Check if document already complete, and if so, just trigger page load
1725 |         //listeners. NOTE: does not work with Firefox before 3.6. To support
1726 |         //those browsers, manually call require.pageLoaded().
1727 |         if (document.readyState === "complete") {
1728 |             req.pageLoaded();
1729 |         }
1730 |     }
1731 |     //****** END page load functionality ****************
1732 |     //>>excludeEnd("requireExcludePageLoad");
1733 | 
1734 |     //Set up default context. If require was a configuration object, use that as base config.
1735 |     req(cfg);
1736 | 
1737 |     //If modules are built into require.js, then need to make sure dependencies are
1738 |     //traced. Use a setTimeout in the browser world, to allow all the modules to register
1739 |     //themselves. In a non-browser env, assume that modules are not built into require.js,
1740 |     //which seems odd to do on the server.
1741 |     if (typeof setTimeout !== "undefined") {
1742 |         setTimeout(function () {
1743 |             var ctx = s.contexts[(cfg.context || defContextName)];
1744 |             //Allow for jQuery to be loaded/already in the page, and if jQuery 1.4.3,
1745 |             //make sure to hold onto it for readyWait triggering.
1746 |             jQueryCheck(ctx);
1747 |             resume(ctx);
1748 |         }, 0);
1749 |     }
1750 | }());
1751 | 


--------------------------------------------------------------------------------