/** vim: et:ts=4:sw=4:sts=4 * @license RequireJS 0.26.0+ 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 strict: false, plusplus: false */ /*global window: false, navigator: false, document: false, importScripts: false, jQuery: false, clearInterval: false, setInterval: false, self: false, setTimeout: false, opera: false */ var requirejs, require, define; (function () { //Change this version number for each release. var version = "0.26.0+", commentRegExp = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg, cjsRequireRegExp = /require\(\s*["']([^'"\s]+)["']\s*\)/g, currDirRegExp = /^\.\//, jsSuffixRegExp = /\.js$/, ostring = Object.prototype.toString, ap = Array.prototype, aps = ap.slice, apsp = ap.splice, isBrowser = !!(typeof window !== "undefined" && navigator && document), isWebWorker = !isBrowser && typeof importScripts !== "undefined", //PS3 indicates loaded and complete, but need to wait for complete //specifically. Sequence is "loading", "loaded", execution, // then "complete". The UA check is unfortunate, but not sure how //to feature test w/o causing perf issues. readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ? /^complete$/ : /^(complete|loaded)$/, defContextName = "_", //Oh the tragedy, detecting opera. See the usage of isOpera for reason. isOpera = typeof opera !== "undefined" && opera.toString() === "[object Opera]", reqWaitIdPrefix = "_r@@", empty = {}, contexts = {}, globalDefQueue = [], interactiveScript = null, isDone = false, checkLoadedDepth = 0, useInteractive = false, req, cfg = {}, currentlyAddingScript, s, head, baseElement, scripts, script, src, subPath, mainScript, dataMain, i, scrollIntervalId, setReadyState, ctx, jQueryCheck, checkLoadedTimeoutId; function isFunction(it) { return ostring.call(it) === "[object Function]"; } function isArray(it) { return ostring.call(it) === "[object Array]"; } /** * Simple function to mix in properties from source into target, * but only if target does not already have a property of the same name. * This is not robust in IE for transferring methods that match * Object.prototype names, but the uses of mixin here seem unlikely to * trigger a problem related to that. */ function mixin(target, source, force) { for (var prop in source) { if (!(prop in empty) && (!(prop in target) || force)) { target[prop] = source[prop]; } } return req; } /** * Constructs an error with a pointer to an URL with more information. * @param {String} id the error ID that maps to an ID on a web page. * @param {String} message human readable error. * @param {Error} [err] the original error, if there is one. * * @returns {Error} */ function makeError(id, msg, err) { var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id); if (err) { e.originalError = err; } return e; } /** * Used to set up package paths from a packagePaths or packages config object. * @param {Object} pkgs the object to store the new package config * @param {Array} currentPackages an array of packages to configure * @param {String} [dir] a prefix dir to use. */ function configurePackageDir(pkgs, currentPackages, dir) { var i, location, pkgObj; for (i = 0; (pkgObj = currentPackages[i]); i++) { pkgObj = typeof pkgObj === "string" ? { name: pkgObj } : pkgObj; location = pkgObj.location; //Add dir to the path, but avoid paths that start with a slash //or have a colon (indicates a protocol) if (dir && (!location || (location.indexOf("/") !== 0 && location.indexOf(":") === -1))) { location = dir + "/" + (location || pkgObj.name); } //Create a brand new object on pkgs, since currentPackages can //be passed in again, and config.pkgs is the internal transformed //state for all package configs. pkgs[pkgObj.name] = { name: pkgObj.name, location: location || pkgObj.name, //Remove leading dot in main, so main paths are normalized, //and remove any trailing .js, since different package //envs have different conventions: some use a module name, //some use a file name. main: (pkgObj.main || "main") .replace(currDirRegExp, '') .replace(jsSuffixRegExp, '') }; } } /** * jQuery 1.4.3-1.5.x use a readyWait/ready() pairing to hold DOM * ready callbacks, but jQuery 1.6 supports a holdReady() API instead. * At some point remove the readyWait/ready() support and just stick * with using holdReady. */ function jQueryHoldReady($, shouldHold) { if ($.holdReady) { $.holdReady(shouldHold); } else if (shouldHold) { $.readyWait += 1; } else { $.ready(true); } } if (typeof define !== "undefined") { //If a define is already in play via another AMD loader, //do not overwrite. return; } if (typeof requirejs !== "undefined") { if (isFunction(requirejs)) { //Do not overwrite and existing requirejs instance. return; } else { cfg = requirejs; requirejs = undefined; } } //Allow for a require config object if (typeof require !== "undefined" && !isFunction(require)) { //assume it is a config object. cfg = require; require = undefined; } /** * Creates a new context for use in require and define calls. * Handle most of the heavy lifting. Do not want to use an object * with prototype here to avoid using "this" in require, in case it * needs to be used in more super secure envs that do not want this. * Also there should not be that many contexts in the page. Usually just * one for the default context, but could be extra for multiversion cases * or if a package needs a special context for a dependency that conflicts * with the standard context. */ function newContext(contextName) { var context, resume, config = { waitSeconds: 7, baseUrl: s.baseUrl || "./", paths: {}, pkgs: {}, catchError: {} }, defQueue = [], specified = { "require": true, "exports": true, "module": true }, urlMap = {}, defined = {}, loaded = {}, waiting = {}, waitAry = [], waitIdCounter = 0, managerCallbacks = {}, plugins = {}, pluginsQueue = {}, resumeDepth = 0, normalizedWaiting = {}; /** * Trims the . and .. from an array of path segments. * It will keep a leading path segment if a .. will become * the first path segment, to help with module name lookups, * which act like paths, but can be remapped. But the end result, * all paths that use this function should look normalized. * NOTE: this method MODIFIES the input array. * @param {Array} ary the array of path segments. */ function trimDots(ary) { var i, part; for (i = 0; (part = ary[i]); i++) { if (part === ".") { ary.splice(i, 1); i -= 1; } else if (part === "..") { if (i === 1 && (ary[2] === '..' || ary[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) { ary.splice(i - 1, 2); i -= 2; } } } } /** * 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 pkgName, pkgConfig; //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) { if (config.pkgs[baseName]) { //If the baseName is a package name, then just treat it as one //name to concat the name with. baseName = [baseName]; } else { //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. baseName = baseName.split("/"); baseName = baseName.slice(0, baseName.length - 1); } name = baseName.concat(name.split("/")); trimDots(name); //Some use of packages may use a . path to reference the //"main" module name, so normalize for that. pkgConfig = config.pkgs[(pkgName = name[0])]; name = name.join("/"); if (pkgConfig && name === pkgName + '/' + pkgConfig.main) { name = pkgName; } } } return name; } /** * Creates a module mapping that includes plugin prefix, module * name, and path. If parentModuleMap is provided it will * also normalize the name via require.normalize() * * @param {String} name the module name * @param {String} [parentModuleMap] parent module map * for the module name, used to resolve relative names. * * @returns {Object} */ function makeModuleMap(name, parentModuleMap) { var index = name ? name.indexOf("!") : -1, prefix = null, parentName = parentModuleMap ? parentModuleMap.name : null, originalName = name, normalizedName, url, pluginModule; if (index !== -1) { prefix = name.substring(0, index); name = name.substring(index + 1, name.length); } if (prefix) { prefix = normalize(prefix, parentName); } //Account for relative paths if there is a base name. if (name) { if (prefix) { pluginModule = defined[prefix]; if (pluginModule) { //Plugin is loaded, use its normalize method, otherwise, //normalize name as usual. if (pluginModule.normalize) { normalizedName = pluginModule.normalize(name, function (name) { return normalize(name, parentName); }); } else { normalizedName = normalize(name, parentName); } } else { //Plugin is not loaded yet, so do not normalize //the name, wait for plugin to load to see if //it has a normalize method. To avoid possible //ambiguity with relative names loaded from another //plugin, use the parent's name as part of this name. normalizedName = '__$p' + parentName + '@' + (name || ''); } } else { normalizedName = normalize(name, parentName); } url = urlMap[normalizedName]; if (!url) { //Calculate url for the module, if it has a name. if (req.toModuleUrl) { //Special logic required for a particular engine, //like Node. url = req.toModuleUrl(context, normalizedName, parentModuleMap); } else { url = context.nameToUrl(normalizedName, null, parentModuleMap); } //Store the URL mapping for later. urlMap[normalizedName] = url; } } return { prefix: prefix, name: normalizedName, parentMap: parentModuleMap, url: url, originalName: originalName, fullName: prefix ? prefix + "!" + (normalizedName || '') : normalizedName }; } /** * Determine if priority loading is done. If so clear the priorityWait */ function isPriorityDone() { var priorityDone = true, priorityWait = config.priorityWait, priorityName, i; if (priorityWait) { for (i = 0; (priorityName = priorityWait[i]); i++) { if (!loaded[priorityName]) { priorityDone = false; break; } } if (priorityDone) { delete config.priorityWait; } } return priorityDone; } /** * Helper function that creates a setExports function for a "module" * CommonJS dependency. Do this here to avoid creating a closure that * is part of a loop. */ function makeSetExports(moduleObj) { return function (exports) { moduleObj.exports = exports; }; } function makeContextModuleFunc(func, relModuleMap, enableBuildCallback) { 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 var args = [].concat(aps.call(arguments, 0)), lastArg; if (enableBuildCallback && isFunction((lastArg = args[args.length - 1]))) { lastArg.__requireJsBuild = true; } args.push(relModuleMap); return func.apply(null, args); }; } /** * Helper function that creates a require function object to give to * modules that ask for it as a dependency. It needs to be specific * per module because of the implication of path mappings that may * need to be relative to the module name. */ function makeRequire(relModuleMap, enableBuildCallback) { var modRequire = makeContextModuleFunc(context.require, relModuleMap, enableBuildCallback); mixin(modRequire, { nameToUrl: makeContextModuleFunc(context.nameToUrl, relModuleMap), toUrl: makeContextModuleFunc(context.toUrl, relModuleMap), defined: makeContextModuleFunc(context.requireDefined, relModuleMap), specified: makeContextModuleFunc(context.requireSpecified, relModuleMap), ready: req.ready, isBrowser: req.isBrowser }); //Something used by node. if (req.paths) { modRequire.paths = req.paths; } return modRequire; } /** * Used to update the normalized name for plugin-based dependencies * after a plugin loads, since it can have its own normalization structure. * @param {String} pluginName the normalized plugin module name. */ function updateNormalizedNames(pluginName) { var oldFullName, oldModuleMap, moduleMap, fullName, callbacks, i, j, k, depArray, existingCallbacks, maps = normalizedWaiting[pluginName]; if (maps) { for (i = 0; (oldModuleMap = maps[i]); i++) { oldFullName = oldModuleMap.fullName; moduleMap = makeModuleMap(oldModuleMap.originalName, oldModuleMap.parentMap); fullName = moduleMap.fullName; //Callbacks could be undefined if the same plugin!name was //required twice in a row, so use empty array in that case. callbacks = managerCallbacks[oldFullName] || []; existingCallbacks = managerCallbacks[fullName]; if (fullName !== oldFullName) { //Update the specified object, but only if it is already //in there. In sync environments, it may not be yet. if (oldFullName in specified) { delete specified[oldFullName]; specified[fullName] = true; } //Update managerCallbacks to use the correct normalized name. //If there are already callbacks for the normalized name, //just add to them. if (existingCallbacks) { managerCallbacks[fullName] = existingCallbacks.concat(callbacks); } else { managerCallbacks[fullName] = callbacks; } delete managerCallbacks[oldFullName]; //In each manager callback, update the normalized name in the depArray. for (j = 0; j < callbacks.length; j++) { depArray = callbacks[j].depArray; for (k = 0; k < depArray.length; k++) { if (depArray[k] === oldFullName) { depArray[k] = fullName; } } } } } } delete normalizedWaiting[pluginName]; } /* * Queues a dependency for checking after the loader is out of a * "paused" state, for example while a script file is being loaded * in the browser, where it may have many modules defined in it. * * depName will be fully qualified, no relative . or .. path. */ function queueDependency(dep) { //Make sure to load any plugin and associate the dependency //with that plugin. var prefix = dep.prefix, fullName = dep.fullName; //Do not bother if the depName is already in transit if (specified[fullName] || fullName in defined) { return; } if (prefix && !plugins[prefix]) { //Queue up loading of the dependency, track it //via context.plugins. Mark it as a plugin so //that the build system will know to treat it //special. plugins[prefix] = undefined; //Remember this dep that needs to have normaliztion done //after the plugin loads. (normalizedWaiting[prefix] || (normalizedWaiting[prefix] = [])) .push(dep); //Register an action to do once the plugin loads, to update //all managerCallbacks to use a properly normalized module //name. (managerCallbacks[prefix] || (managerCallbacks[prefix] = [])).push({ onDep: function (name, value) { if (name === prefix) { updateNormalizedNames(prefix); } } }); queueDependency(makeModuleMap(prefix)); } context.paused.push(dep); } function execManager(manager) { var i, ret, waitingCallbacks, err, errFile, errModuleTree, cb = manager.callback, fullName = manager.fullName, args = [], ary = manager.depArray; //Call the callback to define the module, if necessary. if (cb && isFunction(cb)) { //Pull out the defined dependencies and pass the ordered //values to the callback. if (ary) { for (i = 0; i < ary.length; i++) { args.push(manager.deps[ary[i]]); } } if (config.catchError.define) { try { ret = req.execCb(fullName, manager.callback, args, defined[fullName]); } catch (e) { err = e; } } else { ret = req.execCb(fullName, manager.callback, args, defined[fullName]); } if (fullName) { //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 (manager.cjsModule && manager.cjsModule.exports !== undefined) { ret = defined[fullName] = manager.cjsModule.exports; } else if (ret === undefined && manager.usingExports) { //exports already set the defined value. ret = defined[fullName]; } else { //Use the return value from the function. defined[fullName] = ret; } } } else if (fullName) { //May just be an object definition for the module. Only //worry about defining if have a module name. ret = defined[fullName] = cb; } //Clean up waiting. Do this before error calls, and before //calling back waitingCallbacks, so that bookkeeping is correct //in the event of an error and error is reported in correct order, //since the waitingCallbacks will likely have errors if the //onError function does not throw. if (waiting[manager.waitId]) { delete waiting[manager.waitId]; manager.isDone = true; context.waitCount -= 1; if (context.waitCount === 0) { //Clear the wait array used for cycles. waitAry = []; } } if (err) { errFile = (fullName ? makeModuleMap(fullName).url : '') || err.fileName || err.sourceURL; errModuleTree = err.moduleTree; err = makeError('defineerror', 'Error evaluating ' + 'module "' + fullName + '" at location "' + errFile + '":\n' + err + '\nfileName:' + errFile + '\nlineNumber: ' + (err.lineNumber || err.line), err); err.moduleName = fullName; err.moduleTree = errModuleTree; return req.onError(err); } if (fullName) { //If anything was waiting for this module to be defined, //notify them now. waitingCallbacks = managerCallbacks[fullName]; if (waitingCallbacks) { for (i = 0; i < waitingCallbacks.length; i++) { waitingCallbacks[i].onDep(fullName, ret); } delete managerCallbacks[fullName]; } } return undefined; } function main(inName, depArray, callback, relModuleMap) { var moduleMap = makeModuleMap(inName, relModuleMap), name = moduleMap.name, fullName = moduleMap.fullName, uniques = {}, manager = { //Use a wait ID because some entries are anon //async require calls. waitId: name || reqWaitIdPrefix + (waitIdCounter++), depCount: 0, depMax: 0, prefix: moduleMap.prefix, name: name, fullName: fullName, deps: {}, depArray: depArray, callback: callback, onDep: function (depName, value) { if (!(depName in manager.deps)) { manager.deps[depName] = value; manager.depCount += 1; if (manager.depCount === manager.depMax) { //All done, execute! execManager(manager); } } } }, i, depArg, depName, cjsMod; if (fullName) { //If module already defined for context, or already loaded, //then leave. Also leave if jQuery is registering but it does //not match the desired version number in the config. if (fullName in defined || loaded[fullName] === true || (fullName === "jquery" && config.jQuery && config.jQuery !== callback().fn.jquery)) { return; } //Set specified/loaded here for modules that are also loaded //as part of a layer, where onScriptLoad is not fired //for those cases. Do this after the inline define and //dependency tracing is done. specified[fullName] = true; loaded[fullName] = true; //If module is jQuery set up delaying its dom ready listeners. if (fullName === "jquery" && callback) { jQueryCheck(callback()); } } //Add the dependencies to the deps field, and register for callbacks //on the dependencies. for (i = 0; i < depArray.length; i++) { depArg = depArray[i]; //There could be cases like in IE, where a trailing comma will //introduce a null dependency, so only treat a real dependency //value as a dependency. if (depArg) { //Split the dependency name into plugin and name parts depArg = makeModuleMap(depArg, (name ? moduleMap : relModuleMap)); depName = depArg.fullName; //Fix the name in depArray to be just the name, since //that is how it will be called back later. depArray[i] = depName; //Fast path CommonJS standard dependencies. if (depName === "require") { manager.deps[depName] = makeRequire(moduleMap); } else if (depName === "exports") { //CommonJS module spec 1.1 manager.deps[depName] = defined[fullName] = {}; manager.usingExports = true; } else if (depName === "module") { //CommonJS module spec 1.1 manager.cjsModule = cjsMod = manager.deps[depName] = { id: name, uri: name ? context.nameToUrl(name, null, relModuleMap) : undefined, exports: defined[fullName] }; cjsMod.setExports = makeSetExports(cjsMod); } else if (depName in defined && !(depName in waiting)) { //Module already defined, no need to wait for it. manager.deps[depName] = defined[depName]; } else if (!uniques[depName]) { //A dynamic dependency. manager.depMax += 1; queueDependency(depArg); //Register to get notification when dependency loads. (managerCallbacks[depName] || (managerCallbacks[depName] = [])).push(manager); uniques[depName] = true; } } } //Do not bother tracking the manager if it is all done. if (manager.depCount === manager.depMax) { //All done, execute! execManager(manager); } else { waiting[manager.waitId] = manager; waitAry.push(manager); context.waitCount += 1; } } /** * Convenience method to call main for a define call that was put on * hold in the defQueue. */ function callDefMain(args) { main.apply(null, args); //Mark the module loaded. Must do it here in addition //to doing it in define in case a script does //not call define loaded[args[0]] = true; } /** * jQuery 1.4.3+ supports ways to hold off calling * calling jQuery ready callbacks until all scripts are loaded. Be sure * to track it if the capability exists.. Also, since jQuery 1.4.3 does * not register as a module, need to do some global inference checking. * Even if it does register as a module, not guaranteed to be the precise * name of the global. If a jQuery is tracked for this context, then go * ahead and register it as a module too, if not already in process. */ jQueryCheck = function (jqCandidate) { if (!context.jQuery) { var $ = jqCandidate || (typeof jQuery !== "undefined" ? jQuery : null); if ($) { //If a specific version of jQuery is wanted, make sure to only //use this jQuery if it matches. if (config.jQuery && $.fn.jquery !== config.jQuery) { return; } if ("holdReady" in $ || "readyWait" in $) { context.jQuery = $; //Manually create a "jquery" module entry if not one already //or in process. Note this could trigger an attempt at //a second jQuery registration, but does no harm since //the first one wins, and it is the same value anyway. callDefMain(["jquery", [], function () { return jQuery; }]); //Ask jQuery to hold DOM ready callbacks. if (context.scriptCount) { jQueryHoldReady($, true); context.jQueryIncremented = true; } } } } }; function forceExec(manager, traced) { if (manager.isDone) { return undefined; } var fullName = manager.fullName, depArray = manager.depArray, depName, i; if (fullName) { if (traced[fullName]) { return defined[fullName]; } traced[fullName] = true; } //forceExec all of its dependencies. for (i = 0; i < depArray.length; i++) { //Some array members may be null, like if a trailing comma //IE, so do the explicit [i] access and check if it has a value. depName = depArray[i]; if (depName) { if (!manager.deps[depName] && waiting[depName]) { manager.onDep(depName, forceExec(waiting[depName], traced)); } } } return fullName ? defined[fullName] : undefined; } /** * Checks if all modules for a context are loaded, and if so, evaluates the * new ones in right dependency order. * * @private */ function checkLoaded() { var waitInterval = config.waitSeconds * 1000, //It is possible to disable the wait interval by using waitSeconds of 0. expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(), noLoads = "", hasLoadedProp = false, stillLoading = false, prop, err, manager; //If there are items still in the paused queue processing wait. //This is particularly important in the sync case where each paused //item is processed right away but there may be more waiting. if (context.pausedCount > 0) { return undefined; } //Determine if priority loading is done. If so clear the priority. If //not, then do not check if (config.priorityWait) { if (isPriorityDone()) { //Call resume, since it could have //some waiting dependencies to trace. resume(); } else { return undefined; } } //See if anything is still in flight. for (prop in loaded) { if (!(prop in empty)) { hasLoadedProp = true; if (!loaded[prop]) { if (expired) { noLoads += prop + " "; } else { stillLoading = true; break; } } } } //Check for exit conditions. if (!hasLoadedProp && !context.waitCount) { //If the loaded object had no items, then the rest of //the work below does not need to be done. return undefined; } if (expired && noLoads) { //If wait time expired, throw error of unloaded modules. err = makeError("timeout", "Load timeout for modules: " + noLoads); err.requireType = "timeout"; err.requireModules = noLoads; return req.onError(err); } if (stillLoading || context.scriptCount) { //Something is still waiting to load. Wait for it, but only //if a timeout is not already in effect. if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) { checkLoadedTimeoutId = setTimeout(function () { checkLoadedTimeoutId = 0; checkLoaded(); }, 50); } return undefined; } //If still have items in the waiting cue, but all modules have //been loaded, then it means there are some circular dependencies //that need to be broken. //However, as a waiting thing is fired, then it can add items to //the waiting cue, and those items should not be fired yet, so //make sure to redo the checkLoaded call after breaking a single //cycle, if nothing else loaded then this logic will pick it up //again. if (context.waitCount) { //Cycle through the waitAry, and call items in sequence. for (i = 0; (manager = waitAry[i]); i++) { forceExec(manager, {}); } //Only allow this recursion to a certain depth. Only //triggered by errors in calling a module in which its //modules waiting on it cannot finish loading, or some circular //dependencies that then may add more dependencies. //The value of 5 is a bit arbitrary. Hopefully just one extra //pass, or two for the case of circular dependencies generating //more work that gets resolved in the sync node case. if (checkLoadedDepth < 5) { checkLoadedDepth += 1; checkLoaded(); } } checkLoadedDepth = 0; //Check for DOM ready, and nothing is waiting across contexts. req.checkReadyState(); return undefined; } function callPlugin(pluginName, dep) { var name = dep.name, fullName = dep.fullName, load; //Do not bother if plugin is already defined or being loaded. if (fullName in defined || fullName in loaded) { return; } if (!plugins[pluginName]) { plugins[pluginName] = defined[pluginName]; } //Only set loaded to false for tracking if it has not already been set. if (!loaded[fullName]) { loaded[fullName] = false; } load = function (ret) { //Allow the build process to register plugin-loaded dependencies. if (req.onPluginLoad) { req.onPluginLoad(context, pluginName, name, ret); } execManager({ prefix: dep.prefix, name: dep.name, fullName: dep.fullName, callback: function () { return ret; } }); loaded[fullName] = true; }; //Allow plugins to load other code without having to know the //context or how to "complete" the load. load.fromText = function (moduleName, text) { /*jslint evil: true */ var hasInteractive = useInteractive; //Indicate a the module is in process of loading. context.loaded[moduleName] = false; context.scriptCount += 1; //Turn off interactive script matching for IE for any define //calls in the text, then turn it back on at the end. if (hasInteractive) { useInteractive = false; } req.exec(text); if (hasInteractive) { useInteractive = true; } //Support anonymous modules. context.completeLoad(moduleName); }; //Use parentName here since the plugin's name is not reliable, //could be some weird string with no path that actually wants to //reference the parentName's path. plugins[pluginName].load(name, makeRequire(dep.parentMap, true), load, config); } function loadPaused(dep) { //Renormalize dependency if its name was waiting on a plugin //to load, which as since loaded. if (dep.prefix && dep.name && dep.name.indexOf('__$p') === 0 && defined[dep.prefix]) { dep = makeModuleMap(dep.originalName, dep.parentMap); } var pluginName = dep.prefix, fullName = dep.fullName, urlFetched = context.urlFetched; //Do not bother if the dependency has already been specified. if (specified[fullName] || loaded[fullName]) { return; } else { specified[fullName] = true; } if (pluginName) { //If plugin not loaded, wait for it. //set up callback list. if no list, then register //managerCallback for that plugin. if (defined[pluginName]) { callPlugin(pluginName, dep); } else { if (!pluginsQueue[pluginName]) { pluginsQueue[pluginName] = []; (managerCallbacks[pluginName] || (managerCallbacks[pluginName] = [])).push({ onDep: function (name, value) { if (name === pluginName) { var i, oldModuleMap, ary = pluginsQueue[pluginName]; //Now update all queued plugin actions. for (i = 0; i < ary.length; i++) { oldModuleMap = ary[i]; //Update the moduleMap since the //module name may be normalized //differently now. callPlugin(pluginName, makeModuleMap(oldModuleMap.originalName, oldModuleMap.parentMap)); } delete pluginsQueue[pluginName]; } } }); } pluginsQueue[pluginName].push(dep); } } else { if (!urlFetched[dep.url]) { req.load(context, fullName, dep.url); urlFetched[dep.url] = true; } } } /** * Resumes tracing of dependencies and then checks if everything is loaded. */ resume = function () { var args, i, p; resumeDepth += 1; if (context.scriptCount <= 0) { //Synchronous envs will push the number below zero with the //decrement above, be sure to set it back to zero for good measure. //require() calls that also do not end up loading scripts could //push the number negative too. context.scriptCount = 0; } //Make sure any remaining defQueue items get properly processed. while (defQueue.length) { args = defQueue.shift(); if (args[0] === null) { return req.onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1])); } else { callDefMain(args); } } //Skip the resume of paused dependencies //if current context is in priority wait. if (!config.priorityWait || isPriorityDone()) { while (context.paused.length) { p = context.paused; context.pausedCount += p.length; //Reset paused list context.paused = []; for (i = 0; (args = p[i]); i++) { loadPaused(args); } //Move the start time for timeout forward. context.startTime = (new Date()).getTime(); context.pausedCount -= p.length; } } //Only check if loaded when resume depth is 1. It is likely that //it is only greater than 1 in sync environments where a factory //function also then calls the callback-style require. In those //cases, the checkLoaded should not occur until the resume //depth is back at the top level. if (resumeDepth === 1) { checkLoaded(); } resumeDepth -= 1; return undefined; }; //Define the context object. Many of these fields are on here //just to make debugging easier. context = { contextName: contextName, config: config, defQueue: defQueue, waiting: waiting, waitCount: 0, specified: specified, loaded: loaded, urlMap: urlMap, scriptCount: 0, urlFetched: {}, defined: defined, paused: [], pausedCount: 0, plugins: plugins, managerCallbacks: managerCallbacks, makeModuleMap: makeModuleMap, normalize: normalize, /** * Set a configuration for the context. * @param {Object} cfg config object to integrate. */ configure: function (cfg) { var paths, prop, packages, pkgs, packagePaths, requireWait; //Make sure the baseUrl ends in a slash. if (cfg.baseUrl) { if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== "/") { cfg.baseUrl += "/"; } } //Save off the paths and packages since they require special processing, //they are additive. paths = config.paths; packages = config.packages; pkgs = config.pkgs; //Mix in the config values, favoring the new values over //existing ones in context.config. mixin(config, cfg, true); //Adjust paths if necessary. if (cfg.paths) { for (prop in cfg.paths) { if (!(prop in empty)) { paths[prop] = cfg.paths[prop]; } } config.paths = paths; } packagePaths = cfg.packagePaths; if (packagePaths || cfg.packages) { //Convert packagePaths into a packages config. if (packagePaths) { for (prop in packagePaths) { if (!(prop in empty)) { configurePackageDir(pkgs, packagePaths[prop], prop); } } } //Adjust packages if necessary. if (cfg.packages) { configurePackageDir(pkgs, cfg.packages); } //Done with modifications, assing packages back to context config config.pkgs = pkgs; } //If priority loading is in effect, trigger the loads now if (cfg.priority) { //Hold on to requireWait value, and reset it after done requireWait = context.requireWait; //Allow tracing some require calls to allow the fetching //of the priority config. context.requireWait = false; //But first, call resume to register any defined modules that may //be in a data-main built file before the priority config //call. Also grab any waiting define calls for this context. context.takeGlobalQueue(); resume(); context.require(cfg.priority); //Trigger a resume right away, for the case when //the script with the priority load is done as part //of a data-main call. In that case the normal resume //call will not happen because the scriptCount will be //at 1, since the script for data-main is being processed. resume(); //Restore previous state. context.requireWait = requireWait; config.priorityWait = cfg.priority; } //If a deps array or a config callback is specified, then call //require with those args. This is useful when require is defined as a //config object before require.js is loaded. if (cfg.deps || cfg.callback) { context.require(cfg.deps || [], cfg.callback); } //Set up ready callback, if asked. Useful when require is defined as a //config object before require.js is loaded. if (cfg.ready) { req.ready(cfg.ready); } }, requireDefined: function (moduleName, relModuleMap) { return makeModuleMap(moduleName, relModuleMap).fullName in defined; }, requireSpecified: function (moduleName, relModuleMap) { return makeModuleMap(moduleName, relModuleMap).fullName in specified; }, require: function (deps, callback, relModuleMap) { var moduleName, fullName, moduleMap; if (typeof deps === "string") { //Synchronous access to one module. If require.get is //available (as in the Node adapter), prefer that. //In this case deps is the moduleName and callback is //the relModuleMap if (req.get) { return req.get(context, deps, callback); } //Just return the module wanted. In this scenario, the //second arg (if passed) is just the relModuleMap. moduleName = deps; relModuleMap = callback; //Normalize module name, if it contains . or .. moduleMap = makeModuleMap(moduleName, relModuleMap); fullName = moduleMap.fullName; if (!(fullName in defined)) { return req.onError(makeError("notloaded", "Module name '" + moduleMap.fullName + "' has not been loaded yet for context: " + contextName)); } return defined[fullName]; } main(null, deps, callback, relModuleMap); //If the require call does not trigger anything new to load, //then resume the dependency processing. if (!context.requireWait) { while (!context.scriptCount && context.paused.length) { //For built layers, there can be some defined //modules waiting for intake into the context, //in particular module plugins. Take them. context.takeGlobalQueue(); resume(); } } return context.require; }, /** * Internal method to transfer globalQueue items to this context's * defQueue. */ takeGlobalQueue: function () { //Push all the globalDefQueue items into the context's defQueue if (globalDefQueue.length) { //Array splice in the values since the context code has a //local var ref to defQueue, so cannot just reassign the one //on context. apsp.apply(context.defQueue, [context.defQueue.length - 1, 0].concat(globalDefQueue)); globalDefQueue = []; } }, /** * Internal method used by environment adapters to complete a load event. * A load event could be a script load or just a load pass from a synchronous * load call. * @param {String} moduleName the name of the module to potentially complete. */ completeLoad: function (moduleName) { var args; context.takeGlobalQueue(); while (defQueue.length) { args = defQueue.shift(); if (args[0] === null) { args[0] = moduleName; break; } else if (args[0] === moduleName) { //Found matching define call for this script! break; } else { //Some other named define call, most likely the result //of a build layer that included many define calls. callDefMain(args); args = null; } } if (args) { callDefMain(args); } else { //A script that does not call define(), so just simulate //the call for it. Special exception for jQuery dynamic load. callDefMain([moduleName, [], moduleName === "jquery" && typeof jQuery !== "undefined" ? function () { return jQuery; } : null]); } //Mark the script as loaded. Note that this can be different from a //moduleName that maps to a define call. This line is important //for traditional browser scripts. loaded[moduleName] = true; //If a global jQuery is defined, check for it. Need to do it here //instead of main() since stock jQuery does not register as //a module via define. jQueryCheck(); //Doing this scriptCount decrement branching because sync envs //need to decrement after resume, otherwise it looks like //loading is complete after the first dependency is fetched. //For browsers, it works fine to decrement after, but it means //the checkLoaded setTimeout 50 ms cost is taken. To avoid //that cost, decrement beforehand. if (req.isAsync) { context.scriptCount -= 1; } resume(); if (!req.isAsync) { context.scriptCount -= 1; } }, /** * Converts a module name + .extension into an URL path. * *Requires* the use of a module name. It does not support using * plain URLs like nameToUrl. */ toUrl: function (moduleNamePlusExt, relModuleMap) { var index = moduleNamePlusExt.lastIndexOf("."), ext = null; if (index !== -1) { ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length); moduleNamePlusExt = moduleNamePlusExt.substring(0, index); } return context.nameToUrl(moduleNamePlusExt, ext, relModuleMap); }, /** * Converts a module name to a file path. Supports cases where * moduleName may actually be just an URL. */ nameToUrl: function (moduleName, ext, relModuleMap) { var paths, pkgs, pkg, pkgPath, syms, i, parentModule, url, config = context.config; //Normalize module name if have a base relative module name to work from. moduleName = normalize(moduleName, relModuleMap && relModuleMap.fullName); //If a colon is in the URL, it indicates a protocol is used and it is just //an URL to a file, or if it starts with a slash or ends with .js, it is just a plain file. //The slash is important for protocol-less URLs as well as full paths. if (req.jsExtRegExp.test(moduleName)) { //Just a plain path, not module name lookup, so just return it. //Add extension if it is included. This is a bit wonky, only non-.js things pass //an extension, this method probably needs to be reworked. url = moduleName + (ext ? ext : ""); } else { //A module that needs to be converted to a path. paths = config.paths; pkgs = config.pkgs; syms = moduleName.split("/"); //For each module name segment, see if there is a path //registered for it. Start with most specific name //and work up from it. for (i = syms.length; i > 0; i--) { parentModule = syms.slice(0, i).join("/"); if (paths[parentModule]) { syms.splice(0, i, paths[parentModule]); break; } else if ((pkg = pkgs[parentModule])) { //If module name is just the package name, then looking //for the main module. if (moduleName === pkg.name) { pkgPath = pkg.location + '/' + pkg.main; } else { pkgPath = pkg.location; } syms.splice(0, i, pkgPath); break; } } //Join the path parts together, then figure out if baseUrl is needed. url = syms.join("/") + (ext || ".js"); url = (url.charAt(0) === '/' || url.match(/^\w+:/) ? "" : config.baseUrl) + url; } return config.urlArgs ? url + ((url.indexOf('?') === -1 ? '?' : '&') + config.urlArgs) : url; } }; //Make these visible on the context so can be called at the very //end of the file to bootstrap context.jQueryCheck = jQueryCheck; context.resume = resume; return context; } /** * Main entry point. * * If the only argument to require is a string, then the module that * is represented by that string is fetched for the appropriate context. * * If the first argument is an array, then it will be treated as an array * of dependency string names to fetch. An optional function callback can * be specified to execute when all of those dependencies are available. * * Make a local req variable to help Caja compliance (it assumes things * on a require that are not standardized), and to give a short * name for minification/local scope use. */ req = requirejs = function (deps, callback) { //Find the right context, use default var contextName = defContextName, context, config; // Determine if have config object in the call. if (!isArray(deps) && typeof deps !== "string") { // deps is a config object config = deps; if (isArray(callback)) { // Adjust args if there are dependencies deps = callback; callback = arguments[2]; } else { deps = []; } } if (config && config.context) { contextName = config.context; } context = contexts[contextName] || (contexts[contextName] = newContext(contextName)); if (config) { context.configure(config); } return context.require(deps, callback); }; /** * Support require.config() to make it easier to cooperate with other * AMD loaders on globally agreed names. */ req.config = function (config) { return req(config); }; /** * Export require as a global, but only if it does not already exist. */ if (typeof require === "undefined") { require = req; } /** * Global require.toUrl(), to match global require, mostly useful * for debugging/work in the global space. */ req.toUrl = function (moduleNamePlusExt) { return contexts[defContextName].toUrl(moduleNamePlusExt); }; req.version = version; req.isArray = isArray; req.isFunction = isFunction; req.mixin = mixin; //Used to filter out dependencies that are already paths. req.jsExtRegExp = /^\/|:|\?|\.js$/; s = req.s = { contexts: contexts, //Stores a list of URLs that should not get async script tag treatment. skipAsync: {}, isPageLoaded: !isBrowser, readyCalls: [] }; req.isAsync = req.isBrowser = isBrowser; if (isBrowser) { head = s.head = document.getElementsByTagName("head")[0]; //If BASE tag is in play, using appendChild is a problem for IE6. //When that browser dies, this can be removed. Details in this jQuery bug: //http://dev.jquery.com/ticket/2709 baseElement = document.getElementsByTagName("base")[0]; if (baseElement) { head = s.head = baseElement.parentNode; } } /** * Any errors that require explicitly generates will be passed to this * function. Intercept/override it if you want custom error handling. * @param {Error} err the error object. */ req.onError = function (err) { throw err; }; /** * Does the request to load a module for the browser case. * Make this a separate function to allow other environments * to override it. * * @param {Object} context the require context to find state. * @param {String} moduleName the name of the module. * @param {Object} url the URL to the module. */ req.load = function (context, moduleName, url) { var loaded = context.loaded; isDone = false; //Only set loaded to false for tracking if it has not already been set. if (!loaded[moduleName]) { loaded[moduleName] = false; } context.scriptCount += 1; req.attach(url, context, moduleName); //If tracking a jQuery, then make sure its ready callbacks //are put on hold to prevent its ready callbacks from //triggering too soon. if (context.jQuery && !context.jQueryIncremented) { jQueryHoldReady(context.jQuery, true); context.jQueryIncremented = true; } }; function getInteractiveScript() { var scripts, i, script; if (interactiveScript && interactiveScript.readyState === 'interactive') { return interactiveScript; } scripts = document.getElementsByTagName('script'); for (i = scripts.length - 1; i > -1 && (script = scripts[i]); i--) { if (script.readyState === 'interactive') { return (interactiveScript = script); } } return null; } /** * The function that handles definitions of modules. Differs from * require() in that a string for the module should be the first argument, * and the function to execute after dependencies are loaded should * return a value to define the module corresponding to the first argument's * name. */ define = req.def = function (name, deps, callback) { var node, context; //Allow for anonymous functions if (typeof name !== 'string') { //Adjust args appropriately callback = deps; deps = name; name = null; } //This module may not have dependencies if (!req.isArray(deps)) { callback = deps; deps = []; } //If no name, and callback is a function, then figure out if it a //CommonJS thing with dependencies. if (!name && !deps.length && req.isFunction(callback)) { //Remove comments from the callback string, //look for require calls, and pull them into the dependencies, //but only if there are function args. if (callback.length) { callback .toString() .replace(commentRegExp, "") .replace(cjsRequireRegExp, function (match, dep) { deps.push(dep); }); //May be a CommonJS thing even without require calls, but still //could use exports, and module. Avoid doing exports and module //work though if it just needs require. //REQUIRES the function to expect the CommonJS variables in the //order listed below. deps = (callback.length === 1 ? ["require"] : ["require", "exports", "module"]).concat(deps); } } //If in IE 6-8 and hit an anonymous define() call, do the interactive //work. if (useInteractive) { node = currentlyAddingScript || getInteractiveScript(); if (node) { if (!name) { name = node.getAttribute("data-requiremodule"); } context = contexts[node.getAttribute("data-requirecontext")]; } } //Always save off evaluating the def call until the script onload handler. //This allows multiple modules to be in a file without prematurely //tracing dependencies, and allows for anonymous module support, //where the module name is not known until the script onload event //occurs. If no context, use the global queue, and get it processed //in the onscript load callback. (context ? context.defQueue : globalDefQueue).push([name, deps, callback]); return undefined; }; define.amd = { multiversion: true, plugins: true, jQuery: true }; /** * Executes the text. Normally just uses eval, but can be modified * to use a more environment specific call. * @param {String} text the text to execute/evaluate. */ req.exec = function (text) { return eval(text); }; /** * Executes a module callack function. Broken out as a separate function * solely to allow the build system to sequence the files in the built * layer in the right sequence. * * @private */ req.execCb = function (name, callback, args, exports) { return callback.apply(exports, args); }; /** * callback for script loads, used to check status of loading. * * @param {Event} evt the event from the browser for the script * that was loaded. * * @private */ req.onScriptLoad = function (evt) { //Using currentTarget instead of target for Firefox 2.0's sake. Not //all old browsers will be supported, but this one was easy enough //to support and still makes sense. var node = evt.currentTarget || evt.srcElement || currentlyAddingScript, contextName, moduleName, context; if (evt.type === "load" || readyRegExp.test(node.readyState)) { //Reset interactive script so a script node is not held onto for //to long. interactiveScript = null; //Pull out the name of the module and the context. contextName = node.getAttribute("data-requirecontext"); moduleName = node.getAttribute("data-requiremodule"); context = contexts[contextName]; contexts[contextName].completeLoad(moduleName); //Clean up script binding. Favor detachEvent because of IE9 //issue, see attachEvent/addEventListener comment elsewhere //in this file. if (node.detachEvent && !isOpera) { //Probably IE. If not it will throw an error, which will be //useful to know. node.detachEvent("onreadystatechange", req.onScriptLoad); } else { node.removeEventListener("load", req.onScriptLoad, false); } } }; /** * Attaches the script represented by the URL to the current * environment. Right now only supports browser loading, * but can be redefined in other environments to do the right thing. * @param {String} url the url of the script to attach. * @param {Object} context the context that wants the script. * @param {moduleName} the name of the module that is associated with the script. * @param {Function} [callback] optional callback, defaults to require.onScriptLoad * @param {String} [type] optional type, defaults to text/javascript */ req.attach = function (url, context, moduleName, callback, type) { var node, loaded; if (isBrowser) { //In the browser so use a script tag callback = callback || req.onScriptLoad; node = context && context.config && context.config.xhtml ? document.createElementNS("http://www.w3.org/1999/xhtml", "html:script") : document.createElement("script"); node.type = type || "text/javascript"; node.charset = "utf-8"; //Use async so Gecko does not block on executing the script if something //like a long-polling comet tag is being run first. Gecko likes //to evaluate scripts in DOM order, even for dynamic scripts. //It will fetch them async, but only evaluate the contents in DOM //order, so a long-polling script tag can delay execution of scripts //after it. But telling Gecko we expect async gets us the behavior //we want -- execute it whenever it is finished downloading. Only //Helps Firefox 3.6+ //Allow some URLs to not be fetched async. Mostly helps the order! //plugin node.async = !s.skipAsync[url]; if (context) { node.setAttribute("data-requirecontext", context.contextName); } node.setAttribute("data-requiremodule", moduleName); //Set up load listener. Test attachEvent first because IE9 has //a subtle issue in its addEventListener and script onload firings //that do not match the behavior of all other browsers with //addEventListener support, which fire the onload event for a //script right after the script execution. See: //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution //UNFORTUNATELY Opera implements attachEvent but does not follow the script //script execution mode. if (node.attachEvent && !isOpera) { //Probably IE. IE (at least 6-8) do not fire //script onload right after executing the script, so //we cannot tie the anonymous define call to a name. //However, IE reports the script as being in "interactive" //readyState at the time of the define call. useInteractive = true; node.attachEvent("onreadystatechange", callback); } else { node.addEventListener("load", callback, false); } node.src = url; //For some cache cases in IE 6-8, the script executes before the end //of the appendChild execution, so to tie an anonymous define //call to the module name (which is stored on the node), hold on //to a reference to this node, but clear after the DOM insertion. currentlyAddingScript = node; if (baseElement) { head.insertBefore(node, baseElement); } else { head.appendChild(node); } currentlyAddingScript = null; return node; } else if (isWebWorker) { //In a web worker, use importScripts. This is not a very //efficient use of importScripts, importScripts will block until //its script is downloaded and evaluated. However, if web workers //are in play, the expectation that a build has been done so that //only one script needs to be loaded anyway. This may need to be //reevaluated if other use cases become common. loaded = context.loaded; loaded[moduleName] = false; importScripts(url); //Account for anonymous modules context.completeLoad(moduleName); } return null; }; //Look for a data-main script attribute, which could also adjust the baseUrl. if (isBrowser) { //Figure out baseUrl. Get it from the script tag with require.js in it. scripts = document.getElementsByTagName("script"); for (i = scripts.length - 1; i > -1 && (script = scripts[i]); i--) { //Set the "head" where we can append children by //using the script's parent. if (!head) { head = script.parentNode; } //Look for a data-main attribute to set main script for the page //to load. If it is there, the path to data main becomes the //baseUrl, if it is not already set. if ((dataMain = script.getAttribute('data-main'))) { if (!cfg.baseUrl) { //Pull off the directory of data-main for use as the //baseUrl. src = dataMain.split('/'); mainScript = src.pop(); subPath = src.length ? src.join('/') + '/' : './'; //Set final config. cfg.baseUrl = subPath; //Strip off any trailing .js since dataMain is now //like a module name. dataMain = mainScript.replace(jsSuffixRegExp, ''); } //Put the data-main script in the files to load. cfg.deps = cfg.deps ? cfg.deps.concat(dataMain) : [dataMain]; break; } } } //Set baseUrl based on config. s.baseUrl = cfg.baseUrl; //****** START page load functionality **************** /** * Sets the page as loaded and triggers check for all modules loaded. */ req.pageLoaded = function () { if (!s.isPageLoaded) { s.isPageLoaded = true; if (scrollIntervalId) { clearInterval(scrollIntervalId); } //Part of a fix for FF < 3.6 where readyState was not set to //complete so libraries like jQuery that check for readyState //after page load where not getting initialized correctly. //Original approach suggested by Andrea Giammarchi: //http://webreflection.blogspot.com/2009/11/195-chars-to-help-lazy-loading.html //see other setReadyState reference for the rest of the fix. if (setReadyState) { document.readyState = "complete"; } req.callReady(); } }; //See if there is nothing waiting across contexts, and if not, trigger //callReady. req.checkReadyState = function () { var contexts = s.contexts, prop; for (prop in contexts) { if (!(prop in empty)) { if (contexts[prop].waitCount) { return; } } } s.isDone = true; req.callReady(); }; /** * Internal function that calls back any ready functions. If you are * integrating RequireJS with another library without require.ready support, * you can define this method to call your page ready code instead. */ req.callReady = function () { var callbacks = s.readyCalls, i, callback, contexts, context, prop; if (s.isPageLoaded && s.isDone) { if (callbacks.length) { s.readyCalls = []; for (i = 0; (callback = callbacks[i]); i++) { callback(); } } //If jQuery with DOM ready delayed, release it now. contexts = s.contexts; for (prop in contexts) { if (!(prop in empty)) { context = contexts[prop]; if (context.jQueryIncremented) { jQueryHoldReady(context.jQuery, false); context.jQueryIncremented = false; } } } } }; /** * Registers functions to call when the page is loaded */ req.ready = function (callback) { if (s.isPageLoaded && s.isDone) { callback(); } else { s.readyCalls.push(callback); } return req; }; if (isBrowser) { if (document.addEventListener) { //Standards. Hooray! Assumption here that if standards based, //it knows about DOMContentLoaded. document.addEventListener("DOMContentLoaded", req.pageLoaded, false); window.addEventListener("load", req.pageLoaded, false); //Part of FF < 3.6 readystate fix (see setReadyState refs for more info) if (!document.readyState) { setReadyState = true; document.readyState = "loading"; } } else if (window.attachEvent) { window.attachEvent("onload", req.pageLoaded); //DOMContentLoaded approximation, as found by Diego Perini: //http://javascript.nwbox.com/IEContentLoaded/ if (self === self.top) { scrollIntervalId = setInterval(function () { try { //From this ticket: //http://bugs.dojotoolkit.org/ticket/11106, //In IE HTML Application (HTA), such as in a selenium test, //javascript in the iframe can't see anything outside //of it, so self===self.top is true, but the iframe is //not the top window and doScroll will be available //before document.body is set. Test document.body //before trying the doScroll trick. if (document.body) { document.documentElement.doScroll("left"); req.pageLoaded(); } } catch (e) {} }, 30); } } //Check if document already complete, and if so, just trigger page load //listeners. NOTE: does not work with Firefox before 3.6. To support //those browsers, manually call require.pageLoaded(). if (document.readyState === "complete") { req.pageLoaded(); } } //****** END page load functionality **************** //Set up default context. If require was a configuration object, use that as base config. req(cfg); //If modules are built into require.js, then need to make sure dependencies are //traced. Use a setTimeout in the browser world, to allow all the modules to register //themselves. In a non-browser env, assume that modules are not built into require.js, //which seems odd to do on the server. if (req.isAsync && typeof setTimeout !== "undefined") { ctx = s.contexts[(cfg.context || defContextName)]; //Indicate that the script that includes require() is still loading, //so that require()'d dependencies are not traced until the end of the //file is parsed (approximated via the setTimeout call). ctx.requireWait = true; setTimeout(function () { ctx.requireWait = false; //Any modules included with the require.js file will be in the //global queue, assign them to this context. ctx.takeGlobalQueue(); //Allow for jQuery to be loaded/already in the page, and if jQuery 1.4.3, //make sure to hold onto it for readyWait triggering. ctx.jQueryCheck(); if (!ctx.scriptCount) { ctx.resume(); } req.checkReadyState(); }, 0); } }());