/** * almond dev0.2 Copyright (c) 2011, The Dojo Foundation All Rights Reserved. * Available via the MIT or new BSD license. * see: http://github.com/jrburke/almond for details */ //Going sloppy to avoid 'use strict' string cost, but strict practices should //be followed. /*jslint sloppy: true */ /*global setTimeout: false */ var requirejs, require, define; (function (undef) { var main, req, makeMap, defined = {}, waiting = {}, config = {}, defining = {}, aps = [].slice; /** * Given a relative module name, like ./something, normalize it to * a real name that can be mapped to a path. * @param {String} name the relative name * @param {String} baseName a real name that the name arg is relative * to. * @returns {String} normalized name */ function normalize(name, baseName) { var nameParts, nameSegment, mapValue, foundMap, foundI, foundStarMap, starI, i, j, part, baseParts = baseName && baseName.split("/"), map = config.map, starMap = (map && map['*']) || {}; //Adjust any relative paths. if (name && name.charAt(0) === ".") { //If have a base name, try to normalize against it, //otherwise, assume it is a top-level require that will //be relative to baseUrl in the end. if (baseName) { //Convert baseName to array, and lop off the last part, //so that . matches that "directory" and not name of the baseName's //module. For instance, baseName of "one/two/three", maps to //"one/two/three.js", but we want the directory, "one/two" for //this normalization. baseParts = baseParts.slice(0, baseParts.length - 1); name = baseParts.concat(name.split("/")); //start trimDots for (i = 0; i < name.length; i += 1) { part = name[i]; if (part === ".") { name.splice(i, 1); i -= 1; } else if (part === "..") { if (i === 1 && (name[2] === '..' || name[0] === '..')) { //End of the line. Keep at least one non-dot //path segment at the front so it can be mapped //correctly to disk. Otherwise, there is likely //no path mapping for a path starting with '..'. //This can still fail, but catches the most reasonable //uses of .. break; } else if (i > 0) { name.splice(i - 1, 2); i -= 2; } } } //end trimDots name = name.join("/"); } } //Apply map config if available. if ((baseParts || starMap) && map) { nameParts = name.split('/'); for (i = nameParts.length; i > 0; i -= 1) { nameSegment = nameParts.slice(0, i).join("/"); if (baseParts) { //Find the longest baseName segment match in the config. //So, do joins on the biggest to smallest lengths of baseParts. for (j = baseParts.length; j > 0; j -= 1) { mapValue = map[baseParts.slice(0, j).join('/')]; //baseName segment has config, find if it has one for //this name. if (mapValue) { mapValue = mapValue[nameSegment]; if (mapValue) { //Match, update name to the new value. foundMap = mapValue; foundI = i; break; } } } } if (foundMap) { break; } //Check for a star map match, but just hold on to it, //if there is a shorter segment match later in a matching //config, then favor over this star map. if (!foundStarMap && starMap && starMap[nameSegment]) { foundStarMap = starMap[nameSegment]; starI = i; } } if (!foundMap && foundStarMap) { foundMap = foundStarMap; foundI = starI; } if (foundMap) { nameParts.splice(0, foundI, foundMap); name = nameParts.join('/'); } } return name; } function makeRequire(relName, forceSync) { return function () { //A version of a require function that passes a moduleName //value for items that may need to //look up paths relative to the moduleName return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync])); }; } function makeNormalize(relName) { return function (name) { return normalize(name, relName); }; } function makeLoad(depName) { return function (value) { defined[depName] = value; }; } function callDep(name) { if (waiting.hasOwnProperty(name)) { var args = waiting[name]; delete waiting[name]; defining[name] = true; main.apply(undef, args); } if (!defined.hasOwnProperty(name)) { throw new Error('No ' + name); } return defined[name]; } //Turns a plugin!resource to [plugin, resource] //with the plugin being undefined if the name //did not have a plugin prefix. function splitPrefix(name) { var prefix, index = name ? name.indexOf('!') : -1; if (index > -1) { prefix = name.substring(0, index); name = name.substring(index + 1, name.length); } return [prefix, name]; } /** * Makes a name map, normalizing the name, and using a plugin * for normalization if necessary. Grabs a ref to plugin * too, as an optimization. */ makeMap = function (name, relName) { var plugin, parts = splitPrefix(name), prefix = parts[0]; name = parts[1]; if (prefix) { prefix = normalize(prefix, relName); plugin = callDep(prefix); } //Normalize according if (prefix) { if (plugin && plugin.normalize) { name = plugin.normalize(name, makeNormalize(relName)); } else { name = normalize(name, relName); } } else { name = normalize(name, relName); parts = splitPrefix(name); prefix = parts[0]; name = parts[1]; if (prefix) { plugin = callDep(prefix); } } //Using ridiculous property names for space reasons return { f: prefix ? prefix + '!' + name : name, //fullName n: name, pr: prefix, p: plugin }; }; function makeConfig(name) { return function () { return (config && config.config && config.config[name]) || {}; }; } main = function (name, deps, callback, relName) { var cjsModule, depName, ret, map, i, args = [], usingExports; //Use name if no relName relName = relName || name; //Call the callback to define the module, if necessary. if (typeof callback === 'function') { //Pull out the defined dependencies and pass the ordered //values to the callback. //Default to [require, exports, module] if no deps deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps; for (i = 0; i < deps.length; i += 1) { map = makeMap(deps[i], relName); depName = map.f; //Fast path CommonJS standard dependencies. if (depName === "require") { args[i] = makeRequire(name); } else if (depName === "exports") { //CommonJS module spec 1.1 args[i] = defined[name] = {}; usingExports = true; } else if (depName === "module") { //CommonJS module spec 1.1 cjsModule = args[i] = { id: name, uri: '', exports: defined[name], config: makeConfig(name) }; } else if (defined.hasOwnProperty(depName) || waiting.hasOwnProperty(depName)) { args[i] = callDep(depName); } else if (map.p) { map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {}); args[i] = defined[depName]; } else if (!defining[depName]) { throw new Error(name + ' missing ' + depName); } } ret = callback.apply(defined[name], args); if (name) { //If setting exports via "module" is in play, //favor that over return value and exports. After that, //favor a non-undefined return value over exports use. if (cjsModule && cjsModule.exports !== undef && cjsModule.exports !== defined[name]) { defined[name] = cjsModule.exports; } else if (ret !== undef || !usingExports) { //Use the return value from the function. defined[name] = ret; } } } else if (name) { //May just be an object definition for the module. Only //worry about defining if have a module name. defined[name] = callback; } }; requirejs = require = req = function (deps, callback, relName, forceSync, alt) { if (typeof deps === "string") { //Just return the module wanted. In this scenario, the //deps arg is the module name, and second arg (if passed) //is just the relName. //Normalize module name, if it contains . or .. return callDep(makeMap(deps, callback).f); } else if (!deps.splice) { //deps is a config object, not an array. config = deps; if (callback.splice) { //callback is an array, which means it is a dependency list. //Adjust args if there are dependencies deps = callback; callback = relName; relName = null; } else { deps = undef; } } //Support require(['a']) callback = callback || function () {}; //If relName is a function, it is an errback handler, //so remove it. if (typeof relName === 'function') { relName = forceSync; forceSync = alt; } //Simulate async callback; if (forceSync) { main(undef, deps, callback, relName); } else { setTimeout(function () { main(undef, deps, callback, relName); }, 15); } return req; }; /** * Just drops the config on the floor, but returns req in case * the config return value is used. */ req.config = function (cfg) { config = cfg; return req; }; define = function (name, deps, callback) { //This module may not have dependencies if (!deps.splice) { //deps is not an array, so probably means //an object literal or factory function for //the value. Adjust args. callback = deps; deps = []; } waiting[name] = [name, deps, callback]; }; define.amd = { jQuery: true }; }()); define("../../../almond", function(){}); /** * @license RequireJS order 1.0.5 Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved. * Available via the MIT or new BSD license. * see: http://github.com/jrburke/requirejs for details */ /*jslint nomen: false, plusplus: false, strict: false */ /*global require: false, define: false, window: false, document: false, setTimeout: false */ //Specify that requirejs optimizer should wrap this code in a closure that //maps the namespaced requirejs API to non-namespaced local variables. /*requirejs namespace: true */ (function () { //Sadly necessary browser inference due to differences in the way //that browsers load and execute dynamically inserted javascript //and whether the script/cache method works when ordered execution is //desired. Currently, Gecko and Opera do not load/fire onload for scripts with //type="script/cache" but they execute injected scripts in order //unless the 'async' flag is present. //However, this is all changing in latest browsers implementing HTML5 //spec. With compliant browsers .async true by default, and //if false, then it will execute in order. Favor that test first for forward //compatibility. var testScript = typeof document !== "undefined" && typeof window !== "undefined" && document.createElement("script"), supportsInOrderExecution = testScript && (testScript.async || ((window.opera && Object.prototype.toString.call(window.opera) === "[object Opera]") || //If Firefox 2 does not have to be supported, then //a better check may be: //('mozIsLocallyAvailable' in window.navigator) ("MozAppearance" in document.documentElement.style))), //This test is true for IE browsers, which will load scripts but only //execute them once the script is added to the DOM. supportsLoadSeparateFromExecute = testScript && testScript.readyState === 'uninitialized', readyRegExp = /^(complete|loaded)$/, cacheWaiting = [], cached = {}, scriptNodes = {}, scriptWaiting = []; //Done with the test script. testScript = null; //Callback used by the type="script/cache" callback that indicates a script //has finished downloading. function scriptCacheCallback(evt) { var node = evt.currentTarget || evt.srcElement, i, moduleName, resource; if (evt.type === "load" || readyRegExp.test(node.readyState)) { //Pull out the name of the module and the context. moduleName = node.getAttribute("data-requiremodule"); //Mark this cache request as loaded cached[moduleName] = true; //Find out how many ordered modules have loaded for (i = 0; (resource = cacheWaiting[i]); i++) { if (cached[resource.name]) { resource.req([resource.name], resource.onLoad); } else { //Something in the ordered list is not loaded, //so wait. break; } } //If just loaded some items, remove them from cacheWaiting. if (i > 0) { cacheWaiting.splice(0, i); } //Remove this script tag from the DOM //Use a setTimeout for cleanup because some older IE versions vomit //if removing a script node while it is being evaluated. setTimeout(function () { node.parentNode.removeChild(node); }, 15); } } /** * Used for the IE case, where fetching is done by creating script element * but not attaching it to the DOM. This function will be called when that * happens so it can be determined when the node can be attached to the * DOM to trigger its execution. */ function onFetchOnly(node) { var i, loadedNode, resourceName; //Mark this script as loaded. node.setAttribute('data-orderloaded', 'loaded'); //Cycle through waiting scripts. If the matching node for them //is loaded, and is in the right order, add it to the DOM //to execute the script. for (i = 0; (resourceName = scriptWaiting[i]); i++) { loadedNode = scriptNodes[resourceName]; if (loadedNode && loadedNode.getAttribute('data-orderloaded') === 'loaded') { delete scriptNodes[resourceName]; require.addScriptToDom(loadedNode); } else { break; } } //If just loaded some items, remove them from waiting. if (i > 0) { scriptWaiting.splice(0, i); } } define('order',{ version: '1.0.5', load: function (name, req, onLoad, config) { var hasToUrl = !!req.nameToUrl, url, node, context; //If no nameToUrl, then probably a build with a loader that //does not support it, and all modules are inlined. if (!hasToUrl) { req([name], onLoad); return; } url = req.nameToUrl(name, null); //Make sure the async attribute is not set for any pathway involving //this script. require.s.skipAsync[url] = true; if (supportsInOrderExecution || config.isBuild) { //Just a normal script tag append, but without async attribute //on the script. req([name], onLoad); } else if (supportsLoadSeparateFromExecute) { //Just fetch the URL, but do not execute it yet. The //non-standards IE case. Really not so nice because it is //assuming and touching requrejs internals. OK though since //ordered execution should go away after a long while. context = require.s.contexts._; if (!context.urlFetched[url] && !context.loaded[name]) { //Indicate the script is being fetched. context.urlFetched[url] = true; //Stuff from require.load require.resourcesReady(false); context.scriptCount += 1; //Fetch the script now, remember it. node = require.attach(url, context, name, null, null, onFetchOnly); scriptNodes[name] = node; scriptWaiting.push(name); } //Do a normal require for it, once it loads, use it as return //value. req([name], onLoad); } else { //Credit to LABjs author Kyle Simpson for finding that scripts //with type="script/cache" allow scripts to be downloaded into //browser cache but not executed. Use that //so that subsequent addition of a real type="text/javascript" //tag will cause the scripts to be executed immediately in the //correct order. if (req.specified(name)) { req([name], onLoad); } else { cacheWaiting.push({ name: name, req: req, onLoad: onLoad }); require.attach(url, null, name, scriptCacheCallback, "script/cache"); } } } }); }()); var one = { name: 'one' }; define("one", function(){}); var two = { name: 'two', oneName: one.name }; define("two", function(){});