зеркало из https://github.com/mozilla/ace.git
2497 строки
97 KiB
JavaScript
2497 строки
97 KiB
JavaScript
/** vim: et:ts=4:sw=4:sts=4
|
|
* @license RequireJS Copyright (c) 2010, The Dojo Foundation All Rights Reserved.
|
|
* Available via the MIT or new BSD license.
|
|
* see: http://github.com/jrburke/requirejs for details
|
|
*/
|
|
//laxbreak is true to allow build pragmas to change some statements.
|
|
/*jslint plusplus: false, nomen: false, laxbreak: true, regexp: false */
|
|
/*global window: false, document: false, navigator: false,
|
|
setTimeout: false, traceDeps: true, clearInterval: false, self: false,
|
|
setInterval: false, importScripts: false, jQuery: false */
|
|
|
|
|
|
var require, define;
|
|
(function () {
|
|
//Change this version number for each release.
|
|
var version = "0.14.5+",
|
|
empty = {}, s,
|
|
i, defContextName = "_", contextLoads = [],
|
|
scripts, script, rePkg, src, m, dataMain, cfg = {}, setReadyState,
|
|
commentRegExp = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,
|
|
cjsRequireRegExp = /require\(["']([\w\!\-_\.\/]+)["']\)/g,
|
|
main,
|
|
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)$/,
|
|
ostring = Object.prototype.toString,
|
|
ap = Array.prototype,
|
|
aps = ap.slice, scrollIntervalId, req, baseElement,
|
|
defQueue = [], useInteractive = false, currentlyAddingScript;
|
|
|
|
function isFunction(it) {
|
|
return ostring.call(it) === "[object Function]";
|
|
}
|
|
|
|
//Check for an existing version of require. If so, then exit out. Only allow
|
|
//one version of require to be active in a page. However, allow for a require
|
|
//config object, just exit quickly if require is an actual function.
|
|
if (typeof require !== "undefined") {
|
|
if (isFunction(require)) {
|
|
return;
|
|
} else {
|
|
//assume it is a config object.
|
|
cfg = require;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calls a method on a plugin. The obj object should have two property,
|
|
* name: the name of the method to call on the plugin
|
|
* args: the arguments to pass to the plugin method.
|
|
*/
|
|
function callPlugin(prefix, context, obj) {
|
|
//Call the plugin, or load it.
|
|
var plugin = s.plugins.defined[prefix], waiting;
|
|
if (plugin) {
|
|
plugin[obj.name].apply(null, obj.args);
|
|
} else {
|
|
//Put the call in the waiting call BEFORE requiring the module,
|
|
//since the require could be synchronous in some environments,
|
|
//like builds
|
|
waiting = s.plugins.waiting[prefix] || (s.plugins.waiting[prefix] = []);
|
|
waiting.push(obj);
|
|
|
|
//Load the module
|
|
req(["require/" + prefix], context.contextName);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convenience method to call main for a require.def call that was put on
|
|
* hold in the defQueue.
|
|
*/
|
|
function callDefMain(args, context) {
|
|
main.apply(req, args);
|
|
//Mark the module loaded. Must do it here in addition
|
|
//to doing it in require.def in case a script does
|
|
//not call require.def
|
|
context.loaded[args[0]] = true;
|
|
}
|
|
|
|
/**
|
|
* Used to set up package paths from a packagePaths or packages config object.
|
|
* @param {Object} packages 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(packages, 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))) {
|
|
pkgObj.location = dir + "/" + (pkgObj.location || pkgObj.name);
|
|
}
|
|
|
|
//Normalize package paths.
|
|
pkgObj.location = pkgObj.location || pkgObj.name;
|
|
pkgObj.lib = pkgObj.lib || "lib";
|
|
pkgObj.main = pkgObj.main || "main";
|
|
|
|
packages[pkgObj.name] = pkgObj;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determine if priority loading is done. If so clear the priorityWait
|
|
*/
|
|
function isPriorityDone(context) {
|
|
var priorityDone = true,
|
|
priorityWait = context.config.priorityWait,
|
|
priorityName, i;
|
|
if (priorityWait) {
|
|
for (i = 0; (priorityName = priorityWait[i]); i++) {
|
|
if (!context.loaded[priorityName]) {
|
|
priorityDone = false;
|
|
break;
|
|
}
|
|
}
|
|
if (priorityDone) {
|
|
delete context.config.priorityWait;
|
|
}
|
|
}
|
|
return priorityDone;
|
|
}
|
|
|
|
/**
|
|
* Resumes tracing of dependencies and then checks if everything is loaded.
|
|
*/
|
|
function resume(context) {
|
|
var args, i, paused = s.paused;
|
|
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) {
|
|
req.onError(new Error('Mismatched anonymous require.def modules'));
|
|
} else {
|
|
callDefMain(args, context);
|
|
}
|
|
}
|
|
|
|
//Skip the resume if current context is in priority wait.
|
|
if (context.config.priorityWait && !isPriorityDone(context)) {
|
|
return;
|
|
}
|
|
|
|
if (paused.length) {
|
|
for (i = 0; (args = paused[i]); i++) {
|
|
req.checkDeps.apply(req, args);
|
|
}
|
|
}
|
|
|
|
req.checkLoaded(s.ctxName);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
require = function (deps, callback, contextName, relModuleName) {
|
|
var context, config;
|
|
if (typeof deps === "string" && !isFunction(callback)) {
|
|
//Just return the module wanted. In this scenario, the
|
|
//second arg (if passed) is just the contextName.
|
|
return require.get(deps, callback, contextName, relModuleName);
|
|
}
|
|
// Dependencies first
|
|
if (!require.isArray(deps)) {
|
|
// deps is a config object
|
|
config = deps;
|
|
if (require.isArray(callback)) {
|
|
// Adjust args if there are dependencies
|
|
deps = callback;
|
|
callback = contextName;
|
|
contextName = relModuleName;
|
|
relModuleName = arguments[4];
|
|
} else {
|
|
deps = [];
|
|
}
|
|
}
|
|
|
|
main(null, deps, callback, config, contextName, relModuleName);
|
|
|
|
//If the require call does not trigger anything new to load,
|
|
//then resume the dependency processing. Context will be undefined
|
|
//on first run of require.
|
|
context = s.contexts[(contextName || (config && config.context) || s.ctxName)];
|
|
if (context && context.scriptCount === 0) {
|
|
resume(context);
|
|
}
|
|
//Returning undefined for Spidermonky strict checking in Komodo
|
|
return undefined;
|
|
};
|
|
|
|
//Alias for caja compliance internally -
|
|
//specifically: "Dynamically computed names should use require.async()"
|
|
//even though this spec isn't really decided on.
|
|
//Since it is here, use this alias to make typing shorter.
|
|
req = require;
|
|
|
|
/**
|
|
* Any errors that require explicitly generates will be passed to this
|
|
* function. Intercept/override it if you want custom error handling.
|
|
* If you do override it, this method should *always* throw an error
|
|
* to stop the execution flow correctly. Otherwise, other weird errors
|
|
* will occur.
|
|
* @param {Error} err the error object.
|
|
*/
|
|
req.onError = function (err) {
|
|
throw err;
|
|
};
|
|
|
|
/**
|
|
* 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, contextName) {
|
|
var i, scripts, script, node = currentlyAddingScript;
|
|
|
|
//Allow for anonymous functions
|
|
if (typeof name !== 'string') {
|
|
//Adjust args appropriately
|
|
contextName = callback;
|
|
callback = deps;
|
|
deps = name;
|
|
name = null;
|
|
}
|
|
|
|
//This module may not have dependencies
|
|
if (!req.isArray(deps)) {
|
|
contextName = callback;
|
|
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.
|
|
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 such, so always add those as dependencies.
|
|
//This is a bit wasteful for RequireJS modules that do not need
|
|
//an exports or module object, but erring on side of safety.
|
|
//REQUIRES the function to expect the CommonJS variables in the
|
|
//order listed below.
|
|
deps = ["require", "exports", "module"].concat(deps);
|
|
}
|
|
|
|
//If in IE 6-8 and hit an anonymous require.def call, do the interactive/
|
|
//currentlyAddingScript scripts stuff.
|
|
if (!name && useInteractive) {
|
|
scripts = document.getElementsByTagName('script');
|
|
for (i = scripts.length - 1; i > -1 && (script = scripts[i]); i--) {
|
|
if (script.readyState === 'interactive') {
|
|
node = script;
|
|
break;
|
|
}
|
|
}
|
|
if (!node) {
|
|
req.onError(new Error("ERROR: No matching script interactive for " + callback));
|
|
}
|
|
|
|
name = node.getAttribute("data-requiremodule");
|
|
}
|
|
|
|
if (typeof name === 'string') {
|
|
//Do not try to auto-register a jquery later.
|
|
//Do this work here and in main, since for IE/useInteractive, this function
|
|
//is the earliest touch-point.
|
|
s.contexts[s.ctxName].jQueryDef = (name === "jquery");
|
|
}
|
|
|
|
//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.
|
|
defQueue.push([name, deps, callback, null, contextName]);
|
|
};
|
|
|
|
main = function (name, deps, callback, config, contextName, relModuleName) {
|
|
//Grab the context, or create a new one for the given context name.
|
|
var context, newContext, loaded, pluginPrefix,
|
|
canSetContext, prop, newLength, outDeps, mods, paths, index, i,
|
|
deferMods, deferModArgs, lastModArg, waitingName, packages,
|
|
packagePaths;
|
|
|
|
contextName = contextName ? contextName : (config && config.context ? config.context : s.ctxName);
|
|
context = s.contexts[contextName];
|
|
|
|
if (name) {
|
|
// Pull off any plugin prefix.
|
|
index = name.indexOf("!");
|
|
if (index !== -1) {
|
|
pluginPrefix = name.substring(0, index);
|
|
name = name.substring(index + 1, name.length);
|
|
} else {
|
|
//Could be that the plugin name should be auto-applied.
|
|
//Used by i18n plugin to enable anonymous i18n modules, but
|
|
//still associating the auto-generated name with the i18n plugin.
|
|
pluginPrefix = context.defPlugin[name];
|
|
}
|
|
|
|
|
|
//If module already defined for context, or already waiting to be
|
|
//evaluated, leave.
|
|
waitingName = context.waiting[name];
|
|
if (context && (context.defined[name] || (waitingName && waitingName !== ap[name]))) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (contextName !== s.ctxName) {
|
|
//If nothing is waiting on being loaded in the current context,
|
|
//then switch s.ctxName to current contextName.
|
|
loaded = (s.contexts[s.ctxName] && s.contexts[s.ctxName].loaded);
|
|
canSetContext = true;
|
|
if (loaded) {
|
|
for (prop in loaded) {
|
|
if (!(prop in empty)) {
|
|
if (!loaded[prop]) {
|
|
canSetContext = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (canSetContext) {
|
|
s.ctxName = contextName;
|
|
}
|
|
}
|
|
|
|
if (!context) {
|
|
newContext = {
|
|
contextName: contextName,
|
|
config: {
|
|
waitSeconds: 7,
|
|
baseUrl: s.baseUrl || "./",
|
|
paths: {},
|
|
packages: {}
|
|
},
|
|
waiting: [],
|
|
specified: {
|
|
"require": true,
|
|
"exports": true,
|
|
"module": true
|
|
},
|
|
loaded: {},
|
|
scriptCount: 0,
|
|
urlFetched: {},
|
|
defPlugin: {},
|
|
defined: {},
|
|
modifiers: {}
|
|
};
|
|
|
|
if (s.plugins.newContext) {
|
|
s.plugins.newContext(newContext);
|
|
}
|
|
|
|
context = s.contexts[contextName] = newContext;
|
|
}
|
|
|
|
//If have a config object, update the context's config object with
|
|
//the config values.
|
|
if (config) {
|
|
//Make sure the baseUrl ends in a slash.
|
|
if (config.baseUrl) {
|
|
if (config.baseUrl.charAt(config.baseUrl.length - 1) !== "/") {
|
|
config.baseUrl += "/";
|
|
}
|
|
}
|
|
|
|
//Save off the paths and packages since they require special processing,
|
|
//they are additive.
|
|
paths = context.config.paths;
|
|
packages = context.config.packages;
|
|
|
|
//Mix in the config values, favoring the new values over
|
|
//existing ones in context.config.
|
|
req.mixin(context.config, config, true);
|
|
|
|
//Adjust paths if necessary.
|
|
if (config.paths) {
|
|
for (prop in config.paths) {
|
|
if (!(prop in empty)) {
|
|
paths[prop] = config.paths[prop];
|
|
}
|
|
}
|
|
context.config.paths = paths;
|
|
}
|
|
|
|
packagePaths = config.packagePaths;
|
|
if (packagePaths || config.packages) {
|
|
//Convert packagePaths into a packages config.
|
|
if (packagePaths) {
|
|
for (prop in packagePaths) {
|
|
if (!(prop in empty)) {
|
|
configurePackageDir(packages, packagePaths[prop], prop);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Adjust packages if necessary.
|
|
if (config.packages) {
|
|
configurePackageDir(packages, config.packages);
|
|
}
|
|
|
|
//Done with modifications, assing packages back to context config
|
|
context.config.packages = packages;
|
|
}
|
|
|
|
//If priority loading is in effect, trigger the loads now
|
|
if (config.priority) {
|
|
//Create a separate config property that can be
|
|
//easily tested for config priority completion.
|
|
//Do this instead of wiping out the config.priority
|
|
//in case it needs to be inspected for debug purposes later.
|
|
req(config.priority);
|
|
context.config.priorityWait = config.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 (config.deps || config.callback) {
|
|
req(config.deps || [], config.callback);
|
|
}
|
|
|
|
//Set up ready callback, if asked. Useful when require is defined as a
|
|
//config object before require.js is loaded.
|
|
if (config.ready) {
|
|
req.ready(config.ready);
|
|
}
|
|
|
|
//If it is just a config block, nothing else,
|
|
//then return.
|
|
if (!deps) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
//Normalize dependency strings: need to determine if they have
|
|
//prefixes and to also normalize any relative paths. Replace the deps
|
|
//array of strings with an array of objects.
|
|
if (deps) {
|
|
outDeps = deps;
|
|
deps = [];
|
|
for (i = 0; i < outDeps.length; i++) {
|
|
deps[i] = req.splitPrefix(outDeps[i], (name || relModuleName), context);
|
|
}
|
|
}
|
|
|
|
//Store the module for later evaluation
|
|
newLength = context.waiting.push({
|
|
name: name,
|
|
deps: deps,
|
|
callback: callback
|
|
});
|
|
|
|
if (name) {
|
|
//Store index of insertion for quick lookup
|
|
context.waiting[name] = newLength - 1;
|
|
|
|
//Mark the module as specified so no need to fetch it again.
|
|
//Important to set specified here for the
|
|
//pause/resume case where there are multiple modules in a file.
|
|
context.specified[name] = true;
|
|
|
|
//Load any modifiers for the module.
|
|
mods = context.modifiers[name];
|
|
if (mods) {
|
|
req(mods, contextName);
|
|
deferMods = mods.__deferMods;
|
|
if (deferMods) {
|
|
for (i = 0; i < deferMods.length; i++) {
|
|
deferModArgs = deferMods[i];
|
|
|
|
//Add the context name to the def call.
|
|
lastModArg = deferModArgs[deferModArgs.length - 1];
|
|
if (lastModArg === undefined) {
|
|
deferModArgs[deferModArgs.length - 1] = contextName;
|
|
} else if (typeof lastModArg === "string") {
|
|
deferMods.push(contextName);
|
|
}
|
|
|
|
require.def.apply(require, deferModArgs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//If the callback is not an actual function, it means it already
|
|
//has the definition of the module as a literal value.
|
|
if (name && callback && !req.isFunction(callback)) {
|
|
context.defined[name] = callback;
|
|
}
|
|
|
|
//If a pluginPrefix is available, call the plugin, or load it.
|
|
if (pluginPrefix) {
|
|
callPlugin(pluginPrefix, context, {
|
|
name: "require",
|
|
args: [name, deps, callback, context]
|
|
});
|
|
}
|
|
|
|
//Hold on to the module until a script load or other adapter has finished
|
|
//evaluating the whole file. This helps when a file has more than one
|
|
//module in it -- dependencies are not traced and fetched until the whole
|
|
//file is processed.
|
|
s.paused.push([pluginPrefix, name, deps, context]);
|
|
|
|
//Set 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.
|
|
//Also check if auto-registry of jQuery needs to be skipped.
|
|
if (name) {
|
|
context.loaded[name] = true;
|
|
context.jQueryDef = (name === "jquery");
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Simple function to mix in properties from source into target,
|
|
* but only if target does not already have a property of the same name.
|
|
*/
|
|
req.mixin = function (target, source, force) {
|
|
for (var prop in source) {
|
|
if (!(prop in empty) && (!(prop in target) || force)) {
|
|
target[prop] = source[prop];
|
|
}
|
|
}
|
|
return req;
|
|
};
|
|
|
|
req.version = version;
|
|
|
|
//Set up page state.
|
|
s = req.s = {
|
|
ctxName: defContextName,
|
|
contexts: {},
|
|
paused: [],
|
|
plugins: {
|
|
defined: {},
|
|
callbacks: {},
|
|
waiting: {}
|
|
},
|
|
//Stores a list of URLs that should not get async script tag treatment.
|
|
skipAsync: {},
|
|
isBrowser: isBrowser,
|
|
isPageLoaded: !isBrowser,
|
|
readyCalls: [],
|
|
doc: isBrowser ? document : null
|
|
};
|
|
|
|
req.isBrowser = s.isBrowser;
|
|
if (isBrowser) {
|
|
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) {
|
|
s.head = baseElement.parentNode;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets up a plugin callback name. Want to make it easy to test if a plugin
|
|
* needs to be called for a certain lifecycle event by testing for
|
|
* if (s.plugins.onLifeCyleEvent) so only define the lifecycle event
|
|
* if there is a real plugin that registers for it.
|
|
*/
|
|
function makePluginCallback(name, returnOnTrue) {
|
|
var cbs = s.plugins.callbacks[name] = [];
|
|
s.plugins[name] = function () {
|
|
for (var i = 0, cb; (cb = cbs[i]); i++) {
|
|
if (cb.apply(null, arguments) === true && returnOnTrue) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Registers a new plugin for require.
|
|
*/
|
|
req.plugin = function (obj) {
|
|
var i, prop, call, prefix = obj.prefix, cbs = s.plugins.callbacks,
|
|
waiting = s.plugins.waiting[prefix], generics,
|
|
defined = s.plugins.defined, contexts = s.contexts, context;
|
|
|
|
//Do not allow redefinition of a plugin, there may be internal
|
|
//state in the plugin that could be lost.
|
|
if (defined[prefix]) {
|
|
return req;
|
|
}
|
|
|
|
//Save the plugin.
|
|
defined[prefix] = obj;
|
|
|
|
//Set up plugin callbacks for methods that need to be generic to
|
|
//require, for lifecycle cases where it does not care about a particular
|
|
//plugin, but just that some plugin work needs to be done.
|
|
generics = ["newContext", "isWaiting", "orderDeps"];
|
|
for (i = 0; (prop = generics[i]); i++) {
|
|
if (!s.plugins[prop]) {
|
|
makePluginCallback(prop, prop === "isWaiting");
|
|
}
|
|
cbs[prop].push(obj[prop]);
|
|
}
|
|
|
|
//Call newContext for any contexts that were already created.
|
|
if (obj.newContext) {
|
|
for (prop in contexts) {
|
|
if (!(prop in empty)) {
|
|
context = contexts[prop];
|
|
obj.newContext(context);
|
|
}
|
|
}
|
|
}
|
|
|
|
//If there are waiting requests for a plugin, execute them now.
|
|
if (waiting) {
|
|
for (i = 0; (call = waiting[i]); i++) {
|
|
if (obj[call.name]) {
|
|
obj[call.name].apply(null, call.args);
|
|
}
|
|
}
|
|
delete s.plugins.waiting[prefix];
|
|
}
|
|
|
|
return req;
|
|
};
|
|
|
|
/**
|
|
* As of jQuery 1.4.3, it supports a readyWait property that will hold off
|
|
* calling jQuery ready callbacks until all scripts are loaded. Be sure
|
|
* to track it if readyWait is available. 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.
|
|
*/
|
|
function jQueryCheck(context, jqCandidate) {
|
|
if (!context.jQuery) {
|
|
var $ = jqCandidate || (typeof jQuery !== "undefined" ? jQuery : null);
|
|
if ($ && "readyWait" in $) {
|
|
context.jQuery = $;
|
|
|
|
//Manually create a "jquery" module entry if not one already
|
|
//or in process.
|
|
if (!context.defined.jquery && !context.jQueryDef) {
|
|
context.defined.jquery = $;
|
|
}
|
|
|
|
//Make sure
|
|
if (context.scriptCount) {
|
|
$.readyWait += 1;
|
|
context.jQueryIncremented = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* @param {Object} context the context object
|
|
*/
|
|
req.completeLoad = function (moduleName, context) {
|
|
//If there is a waiting require.def call
|
|
var args;
|
|
while (defQueue.length) {
|
|
args = defQueue.shift();
|
|
if (args[0] === null) {
|
|
args[0] = moduleName;
|
|
break;
|
|
} else if (args[0] === moduleName) {
|
|
//Found matching require.def call for this script!
|
|
break;
|
|
} else {
|
|
//Some other named require.def call, most likely the result
|
|
//of a build layer that included many require.def calls.
|
|
callDefMain(args, context);
|
|
}
|
|
}
|
|
if (args) {
|
|
callDefMain(args, context);
|
|
}
|
|
|
|
//Mark the script as loaded. Note that this can be different from a
|
|
//moduleName that maps to a require.def call. This line is important
|
|
//for traditional browser scripts.
|
|
context.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(context);
|
|
|
|
context.scriptCount -= 1;
|
|
resume(context);
|
|
};
|
|
|
|
/**
|
|
* Legacy function, remove at some point
|
|
*/
|
|
req.pause = req.resume = function () {};
|
|
|
|
/**
|
|
* Trace down the dependencies to see if they are loaded. If not, trigger
|
|
* the load.
|
|
* @param {String} pluginPrefix the plugin prefix, if any associated with the name.
|
|
*
|
|
* @param {String} name: the name of the module that has the dependencies.
|
|
*
|
|
* @param {Array} deps array of dependencies.
|
|
*
|
|
* @param {Object} context: the loading context.
|
|
*
|
|
* @private
|
|
*/
|
|
req.checkDeps = function (pluginPrefix, name, deps, context) {
|
|
//Figure out if all the modules are loaded. If the module is not
|
|
//being loaded or already loaded, add it to the "to load" list,
|
|
//and request it to be loaded.
|
|
var i, dep;
|
|
|
|
if (pluginPrefix) {
|
|
callPlugin(pluginPrefix, context, {
|
|
name: "checkDeps",
|
|
args: [name, deps, context]
|
|
});
|
|
} else {
|
|
for (i = 0; (dep = deps[i]); i++) {
|
|
if (!context.specified[dep.fullName]) {
|
|
context.specified[dep.fullName] = true;
|
|
|
|
//Reset the start time to use for timeouts
|
|
context.startTime = (new Date()).getTime();
|
|
|
|
//If a plugin, call its load method.
|
|
if (dep.prefix) {
|
|
callPlugin(dep.prefix, context, {
|
|
name: "load",
|
|
args: [dep.name, context.contextName]
|
|
});
|
|
} else {
|
|
req.load(dep.name, context.contextName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Register a module that modifies another module. The modifier will
|
|
* only be called once the target module has been loaded.
|
|
*
|
|
* First syntax:
|
|
*
|
|
* require.modify({
|
|
* "some/target1": "my/modifier1",
|
|
* "some/target2": "my/modifier2",
|
|
* });
|
|
*
|
|
* With this syntax, the my/modifier1 will only be loaded when
|
|
* "some/target1" is loaded.
|
|
*
|
|
* Second syntax, defining a modifier.
|
|
*
|
|
* require.modify("some/target1", "my/modifier",
|
|
* ["some/target1", "some/other"],
|
|
* function (target, other) {
|
|
* //Modify properties of target here.
|
|
* Only properties of target can be modified, but
|
|
* target cannot be replaced.
|
|
* }
|
|
* );
|
|
*/
|
|
req.modify = function (target, name, deps, callback, contextName) {
|
|
var prop, modifier, list,
|
|
cName = (typeof target === "string" ? contextName : name) || s.ctxName,
|
|
context = s.contexts[cName],
|
|
mods = context.modifiers;
|
|
|
|
if (typeof target === "string") {
|
|
//A modifier module.
|
|
//First store that it is a modifier.
|
|
list = mods[target] || (mods[target] = []);
|
|
if (!list[name]) {
|
|
list.push(name);
|
|
list[name] = true;
|
|
}
|
|
|
|
//Trigger the normal module definition logic if the target
|
|
//is already in the system.
|
|
if (context.specified[target]) {
|
|
req.def(name, deps, callback, contextName);
|
|
} else {
|
|
//Hold on to the execution/dependency checks for the modifier
|
|
//until the target is fetched.
|
|
(list.__deferMods || (list.__deferMods = [])).push([name, deps, callback, contextName]);
|
|
}
|
|
} else {
|
|
//A list of modifiers. Save them for future reference.
|
|
for (prop in target) {
|
|
if (!(prop in empty)) {
|
|
//Store the modifier for future use.
|
|
modifier = target[prop];
|
|
list = mods[prop] || (context.modifiers[prop] = []);
|
|
if (!list[modifier]) {
|
|
list.push(modifier);
|
|
list[modifier] = true;
|
|
|
|
if (context.specified[prop]) {
|
|
//Load the modifier right away.
|
|
req([modifier], cName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
req.isArray = function (it) {
|
|
return ostring.call(it) === "[object Array]";
|
|
};
|
|
|
|
req.isFunction = isFunction;
|
|
|
|
/**
|
|
* Gets one module's exported value. This method is used by require().
|
|
* It is broken out as a separate function to allow a host environment
|
|
* shim to overwrite this function with something appropriate for that
|
|
* environment.
|
|
*
|
|
* @param {String} moduleName the name of the module.
|
|
* @param {String} [contextName] the name of the context to use. Uses
|
|
* default context if no contextName is provided. You should never
|
|
* pass the contextName explicitly -- it is handled by the require() code.
|
|
* @param {String} [relModuleName] a module name to use for relative
|
|
* module name lookups. You should never pass this argument explicitly --
|
|
* it is handled by the require() code.
|
|
*
|
|
* @returns {Object} the exported module value.
|
|
*/
|
|
req.get = function (moduleName, contextName, relModuleName) {
|
|
if (moduleName === "require" || moduleName === "exports" || moduleName === "module") {
|
|
req.onError(new Error("Explicit require of " + moduleName + " is not allowed."));
|
|
}
|
|
contextName = contextName || s.ctxName;
|
|
|
|
var ret, context = s.contexts[contextName], nameProps;
|
|
|
|
//Normalize module name, if it contains . or ..
|
|
nameProps = req.splitPrefix(moduleName, relModuleName, context);
|
|
|
|
ret = context.defined[nameProps.name];
|
|
if (ret === undefined) {
|
|
req.onError(new Error("require: module name '" +
|
|
moduleName +
|
|
"' has not been loaded yet for context: " +
|
|
contextName));
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
/**
|
|
* Makes the request to load a module. May be an async load depending on
|
|
* the environment and the circumstance of the load call. Override this
|
|
* method in a host environment shim to do something specific for that
|
|
* environment.
|
|
*
|
|
* @param {String} moduleName the name of the module.
|
|
* @param {String} contextName the name of the context to use.
|
|
*/
|
|
req.load = function (moduleName, contextName) {
|
|
var context = s.contexts[contextName],
|
|
urlFetched = context.urlFetched,
|
|
loaded = context.loaded, url;
|
|
s.isDone = false;
|
|
|
|
//Only set loaded to false for tracking if it has not already been set.
|
|
if (!loaded[moduleName]) {
|
|
loaded[moduleName] = false;
|
|
}
|
|
|
|
if (contextName !== s.ctxName) {
|
|
//Not in the right context now, hold on to it until
|
|
//the current context finishes all its loading.
|
|
contextLoads.push(arguments);
|
|
} else {
|
|
//First derive the path name for the module.
|
|
url = req.nameToUrl(moduleName, null, contextName);
|
|
if (!urlFetched[url]) {
|
|
context.scriptCount += 1;
|
|
req.attach(url, contextName, moduleName);
|
|
urlFetched[url] = true;
|
|
|
|
//If tracking a jQuery, then make sure its readyWait
|
|
//is incremented to prevent its ready callbacks from
|
|
//triggering too soon.
|
|
if (context.jQuery && !context.jQueryIncremented) {
|
|
context.jQuery.readyWait += 1;
|
|
context.jQueryIncremented = true;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
req.jsExtRegExp = /^\/|:|\?|\.js$/;
|
|
|
|
/**
|
|
* 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.
|
|
* @param {Object} context
|
|
* @returns {String} normalized name
|
|
*/
|
|
req.normalizeName = function (name, baseName, context) {
|
|
//Adjust any relative paths.
|
|
var part;
|
|
if (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 (context.config.packages[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("/"));
|
|
for (i = 0; (part = name[i]); i++) {
|
|
if (part === ".") {
|
|
name.splice(i, 1);
|
|
i -= 1;
|
|
} else if (part === "..") {
|
|
if (i === 1) {
|
|
//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 '..'.
|
|
break;
|
|
} else if (i > 1) {
|
|
name.splice(i - 1, 2);
|
|
i -= 2;
|
|
}
|
|
}
|
|
}
|
|
name = name.join("/");
|
|
}
|
|
}
|
|
return name;
|
|
};
|
|
|
|
/**
|
|
* Splits a name into a possible plugin prefix and
|
|
* the module name. If baseName is provided it will
|
|
* also normalize the name via require.normalizeName()
|
|
*
|
|
* @param {String} name the module name
|
|
* @param {String} [baseName] base name that name is
|
|
* relative to.
|
|
* @param {Object} context
|
|
*
|
|
* @returns {Object} with properties, 'prefix' (which
|
|
* may be null), 'name' and 'fullName', which is a combination
|
|
* of the prefix (if it exists) and the name.
|
|
*/
|
|
req.splitPrefix = function (name, baseName, context) {
|
|
var index = name.indexOf("!"), prefix = null;
|
|
if (index !== -1) {
|
|
prefix = name.substring(0, index);
|
|
name = name.substring(index + 1, name.length);
|
|
}
|
|
|
|
//Account for relative paths if there is a base name.
|
|
name = req.normalizeName(name, baseName, context);
|
|
|
|
return {
|
|
prefix: prefix,
|
|
name: name,
|
|
fullName: prefix ? prefix + "!" + name : name
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Converts a module name to a file path.
|
|
*/
|
|
req.nameToUrl = function (moduleName, ext, contextName, relModuleName) {
|
|
var paths, packages, pkg, pkgPath, syms, i, parentModule, url,
|
|
context = s.contexts[contextName],
|
|
config = context.config;
|
|
|
|
//Normalize module name if have a base relative module name to work from.
|
|
moduleName = req.normalizeName(moduleName, relModuleName, context);
|
|
|
|
//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;
|
|
packages = config.packages;
|
|
|
|
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 = packages[parentModule])) {
|
|
//pkg can have just a string value to the path
|
|
//or can be an object with props:
|
|
//main, lib, name, location.
|
|
pkgPath = pkg.location + '/' + pkg.lib;
|
|
//If module name is just the package name, then looking
|
|
//for the main module.
|
|
if (moduleName === pkg.name) {
|
|
pkgPath += '/' + pkg.main;
|
|
}
|
|
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;
|
|
};
|
|
|
|
//In async environments, checkLoaded can get called a few times in the same
|
|
//call stack. Allow only one to do the finishing work. Set to false
|
|
//for sync environments.
|
|
req.blockCheckLoaded = true;
|
|
|
|
/**
|
|
* Checks if all modules for a context are loaded, and if so, evaluates the
|
|
* new ones in right dependency order.
|
|
*
|
|
* @private
|
|
*/
|
|
req.checkLoaded = function (contextName) {
|
|
var context = s.contexts[contextName || s.ctxName],
|
|
waitInterval = context.config.waitSeconds * 1000,
|
|
//It is possible to disable the wait interval by using waitSeconds of 0.
|
|
expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
|
|
loaded, defined = context.defined,
|
|
modifiers = context.modifiers, waiting, noLoads = "",
|
|
hasLoadedProp = false, stillLoading = false, prop,
|
|
|
|
pIsWaiting = s.plugins.isWaiting, pOrderDeps = s.plugins.orderDeps,
|
|
|
|
i, module, allDone, loads, loadArgs, err;
|
|
|
|
//If already doing a checkLoaded call,
|
|
//then do not bother checking loaded state.
|
|
if (context.isCheckLoaded) {
|
|
return;
|
|
}
|
|
|
|
//Determine if priority loading is done. If so clear the priority. If
|
|
//not, then do not check
|
|
if (context.config.priorityWait) {
|
|
if (isPriorityDone(context)) {
|
|
//Call resume, since it could have
|
|
//some waiting dependencies to trace.
|
|
resume(context);
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
//Signal that checkLoaded is being require, so other calls that could be triggered
|
|
//by calling a waiting callback that then calls require and then this function
|
|
//should not proceed. At the end of this function, if there are still things
|
|
//waiting, then checkLoaded will be called again.
|
|
context.isCheckLoaded = req.blockCheckLoaded;
|
|
|
|
//Grab waiting and loaded lists here, since it could have changed since
|
|
//this function was first called.
|
|
waiting = context.waiting;
|
|
loaded = context.loaded;
|
|
|
|
//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 && !waiting.length
|
|
&& (!pIsWaiting || !pIsWaiting(context))
|
|
) {
|
|
//If the loaded object had no items, then the rest of
|
|
//the work below does not need to be done.
|
|
context.isCheckLoaded = false;
|
|
return;
|
|
}
|
|
if (expired && noLoads) {
|
|
//If wait time expired, throw error of unloaded modules.
|
|
err = new Error("require.js load timeout for modules: " + noLoads);
|
|
err.requireType = "timeout";
|
|
err.requireModules = noLoads;
|
|
req.onError(err);
|
|
}
|
|
if (stillLoading) {
|
|
//Something is still waiting to load. Wait for it.
|
|
context.isCheckLoaded = false;
|
|
if (isBrowser || isWebWorker) {
|
|
setTimeout(function () {
|
|
req.checkLoaded(contextName);
|
|
}, 50);
|
|
}
|
|
return;
|
|
}
|
|
|
|
//Order the dependencies. Also clean up state because the evaluation
|
|
//of modules might create new loading tasks, so need to reset.
|
|
//Be sure to call plugins too.
|
|
context.waiting = [];
|
|
context.loaded = {};
|
|
|
|
//Call plugins to order their dependencies, do their
|
|
//module definitions.
|
|
if (pOrderDeps) {
|
|
pOrderDeps(context);
|
|
}
|
|
|
|
//Before defining the modules, give priority treatment to any modifiers
|
|
//for modules that are already defined.
|
|
for (prop in modifiers) {
|
|
if (!(prop in empty)) {
|
|
if (defined[prop]) {
|
|
req.execModifiers(prop, {}, waiting, context);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Define the modules, doing a depth first search.
|
|
for (i = 0; (module = waiting[i]); i++) {
|
|
req.exec(module, {}, waiting, context);
|
|
}
|
|
|
|
//Indicate checkLoaded is now done.
|
|
context.isCheckLoaded = false;
|
|
|
|
if (context.waiting.length
|
|
|| (pIsWaiting && pIsWaiting(context))
|
|
) {
|
|
//More things in this context are waiting to load. They were probably
|
|
//added while doing the work above in checkLoaded, calling module
|
|
//callbacks that triggered other require calls.
|
|
req.checkLoaded(contextName);
|
|
} else if (contextLoads.length) {
|
|
//Check for other contexts that need to load things.
|
|
//First, make sure current context has no more things to
|
|
//load. After defining the modules above, new require calls
|
|
//could have been made.
|
|
loaded = context.loaded;
|
|
allDone = true;
|
|
for (prop in loaded) {
|
|
if (!(prop in empty)) {
|
|
if (!loaded[prop]) {
|
|
allDone = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (allDone) {
|
|
s.ctxName = contextLoads[0][1];
|
|
loads = contextLoads;
|
|
//Reset contextLoads in case some of the waiting loads
|
|
//are for yet another context.
|
|
contextLoads = [];
|
|
for (i = 0; (loadArgs = loads[i]); i++) {
|
|
req.load.apply(req, loadArgs);
|
|
}
|
|
}
|
|
} else {
|
|
//Make sure we reset to default context.
|
|
s.ctxName = defContextName;
|
|
s.isDone = true;
|
|
if (req.callReady) {
|
|
req.callReady();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 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 in require.exec.
|
|
*/
|
|
function makeSetExports(moduleObj) {
|
|
return function (exports) {
|
|
moduleObj.exports = exports;
|
|
};
|
|
}
|
|
|
|
function makeContextModuleFunc(name, contextName, moduleName) {
|
|
return function () {
|
|
//A version of a require function that forces a contextName value
|
|
//and also passes a moduleName value for items that may need to
|
|
//look up paths relative to the moduleName
|
|
var args = [].concat(aps.call(arguments, 0));
|
|
args.push(contextName, moduleName);
|
|
return (name ? require[name] : require).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(context, moduleName) {
|
|
var contextName = context.contextName,
|
|
modRequire = makeContextModuleFunc(null, contextName, moduleName);
|
|
|
|
req.mixin(modRequire, {
|
|
modify: makeContextModuleFunc("modify", contextName, moduleName),
|
|
def: makeContextModuleFunc("def", contextName, moduleName),
|
|
get: makeContextModuleFunc("get", contextName, moduleName),
|
|
nameToUrl: makeContextModuleFunc("nameToUrl", contextName, moduleName),
|
|
ready: req.ready,
|
|
context: context,
|
|
config: context.config,
|
|
isBrowser: s.isBrowser
|
|
});
|
|
return modRequire;
|
|
}
|
|
|
|
/**
|
|
* Executes the modules in the correct order.
|
|
*
|
|
* @private
|
|
*/
|
|
req.exec = function (module, traced, waiting, context) {
|
|
//Some modules are just plain script files, abddo not have a formal
|
|
//module definition,
|
|
if (!module) {
|
|
//Returning undefined for Spidermonky strict checking in Komodo
|
|
return undefined;
|
|
}
|
|
|
|
var name = module.name, cb = module.callback, deps = module.deps, j, dep,
|
|
defined = context.defined, ret, args = [], depModule, cjsModule,
|
|
usingExports = false, depName;
|
|
|
|
//If already traced or defined, do not bother a second time.
|
|
if (name) {
|
|
if (traced[name] || name in defined) {
|
|
return defined[name];
|
|
}
|
|
|
|
//Mark this module as being traced, so that it is not retraced (as in a circular
|
|
//dependency)
|
|
traced[name] = true;
|
|
}
|
|
|
|
if (deps) {
|
|
for (j = 0; (dep = deps[j]); j++) {
|
|
depName = dep.name;
|
|
if (depName === "require") {
|
|
depModule = makeRequire(context, name);
|
|
} else if (depName === "exports") {
|
|
//CommonJS module spec 1.1
|
|
depModule = defined[name] = {};
|
|
usingExports = true;
|
|
} else if (depName === "module") {
|
|
//CommonJS module spec 1.1
|
|
cjsModule = depModule = {
|
|
id: name,
|
|
uri: name ? req.nameToUrl(name, null, context.contextName) : undefined
|
|
};
|
|
cjsModule.setExports = makeSetExports(cjsModule);
|
|
} else {
|
|
//Get dependent module. It could not exist, for a circular
|
|
//dependency or if the loaded dependency does not actually call
|
|
//require. Favor not throwing an error here if undefined because
|
|
//we want to allow code that does not use require as a module
|
|
//definition framework to still work -- allow a web site to
|
|
//gradually update to contained modules. That is more
|
|
//important than forcing a throw for the circular dependency case.
|
|
depModule = depName in defined ? defined[depName] : (traced[depName] ? undefined : req.exec(waiting[waiting[depName]], traced, waiting, context));
|
|
}
|
|
|
|
args.push(depModule);
|
|
}
|
|
}
|
|
|
|
//Call the callback to define the module, if necessary.
|
|
cb = module.callback;
|
|
if (cb && req.isFunction(cb)) {
|
|
ret = req.execCb(name, cb, args);
|
|
if (name) {
|
|
//If using exports and the function did not return a value,
|
|
//and the "module" object for this definition function did not
|
|
//define an exported value, then use the exports object.
|
|
if (usingExports && ret === undefined && (!cjsModule || !("exports" in cjsModule))) {
|
|
ret = defined[name];
|
|
} else {
|
|
if (cjsModule && "exports" in cjsModule) {
|
|
ret = defined[name] = cjsModule.exports;
|
|
} else {
|
|
if (name in defined && !usingExports) {
|
|
req.onError(new Error(name + " has already been defined"));
|
|
}
|
|
defined[name] = ret;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Execute modifiers, if they exist.
|
|
req.execModifiers(name, traced, waiting, context);
|
|
|
|
return ret;
|
|
};
|
|
|
|
/**
|
|
* 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.
|
|
* @param {String} name the module name.
|
|
* @param {Function} cb the module callback/definition function.
|
|
* @param {Array} args The arguments (dependent modules) to pass to callback.
|
|
*
|
|
* @private
|
|
*/
|
|
req.execCb = function (name, cb, args) {
|
|
return cb.apply(null, args);
|
|
};
|
|
|
|
/**
|
|
* Executes modifiers for the given module name.
|
|
* @param {String} target
|
|
* @param {Object} traced
|
|
* @param {Object} context
|
|
*
|
|
* @private
|
|
*/
|
|
req.execModifiers = function (target, traced, waiting, context) {
|
|
var modifiers = context.modifiers, mods = modifiers[target], mod, i;
|
|
if (mods) {
|
|
for (i = 0; i < mods.length; i++) {
|
|
mod = mods[i];
|
|
//Not all modifiers define a module, they might collect other modules.
|
|
//If it is just a collection it will not be in waiting.
|
|
if (mod in waiting) {
|
|
req.exec(waiting[waiting[mod]], traced, waiting, context);
|
|
}
|
|
}
|
|
delete modifiers[target];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 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, contextName, moduleName,
|
|
context;
|
|
if (evt.type === "load" || readyRegExp.test(node.readyState)) {
|
|
//Pull out the name of the module and the context.
|
|
contextName = node.getAttribute("data-requirecontext");
|
|
moduleName = node.getAttribute("data-requiremodule");
|
|
context = s.contexts[contextName];
|
|
|
|
req.completeLoad(moduleName, context);
|
|
|
|
//Clean up script binding.
|
|
if (node.removeEventListener) {
|
|
node.removeEventListener("load", req.onScriptLoad, false);
|
|
} else {
|
|
//Probably IE. If not it will throw an error, which will be
|
|
//useful to know.
|
|
node.detachEvent("onreadystatechange", req.onScriptLoad);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 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 {String} contextName the name of 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, contextName, moduleName, callback, type) {
|
|
var node, loaded, context;
|
|
if (isBrowser) {
|
|
//In the browser so use a script tag
|
|
callback = callback || req.onScriptLoad;
|
|
node = 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
|
|
if (!s.skipAsync[url]) {
|
|
node.async = true;
|
|
}
|
|
node.setAttribute("data-requirecontext", contextName);
|
|
node.setAttribute("data-requiremodule", moduleName);
|
|
|
|
//Set up load listener.
|
|
if (node.addEventListener) {
|
|
node.addEventListener("load", callback, false);
|
|
} else {
|
|
//Probably IE. If not it will throw an error, which will be
|
|
//useful to know. IE (at least 6-8) do not fire
|
|
//script onload right after executing the script, so
|
|
//we cannot tie the anonymous require.def call to a name.
|
|
//However, IE reports the script as being in "interactive"
|
|
//readyState at the time of the require.def call.
|
|
useInteractive = true;
|
|
node.attachEvent("onreadystatechange", callback);
|
|
}
|
|
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 require.def
|
|
//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) {
|
|
s.head.insertBefore(node, baseElement);
|
|
} else {
|
|
s.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.
|
|
context = s.contexts[contextName];
|
|
loaded = context.loaded;
|
|
loaded[moduleName] = false;
|
|
importScripts(url);
|
|
|
|
//Account for anonymous modules
|
|
req.completeLoad(moduleName, context);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
//Determine what baseUrl should be if not already defined via a require config object
|
|
s.baseUrl = cfg.baseUrl;
|
|
if (isBrowser && (!s.baseUrl || !s.head)) {
|
|
//Figure out baseUrl. Get it from the script tag with require.js in it.
|
|
scripts = document.getElementsByTagName("script");
|
|
if (cfg.baseUrlMatch) {
|
|
rePkg = cfg.baseUrlMatch;
|
|
} else {
|
|
|
|
|
|
|
|
rePkg = /(allplugins-)?require\.js(\W|$)/i;
|
|
|
|
}
|
|
|
|
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 (!s.head) {
|
|
s.head = script.parentNode;
|
|
}
|
|
|
|
//Look for a data-main attribute to set main script for the page
|
|
//to load.
|
|
if (!cfg.deps) {
|
|
dataMain = script.getAttribute('data-main');
|
|
if (dataMain) {
|
|
cfg.deps = [dataMain];
|
|
}
|
|
}
|
|
|
|
//Using .src instead of getAttribute to get an absolute URL.
|
|
//While using a relative URL will be fine for script tags, other
|
|
//URLs used for text! resources that use XHR calls might benefit
|
|
//from an absolute URL.
|
|
src = script.src;
|
|
if (src && !s.baseUrl) {
|
|
m = src.match(rePkg);
|
|
if (m) {
|
|
s.baseUrl = src.substring(0, m.index);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//****** 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();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 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 readyWait is being tracked, updated its
|
|
//readyWait count.
|
|
contexts = s.contexts;
|
|
for (prop in contexts) {
|
|
if (!(prop in empty)) {
|
|
context = contexts[prop];
|
|
if (context.jQueryIncremented) {
|
|
context.jQuery.readyWait -= 1;
|
|
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 (typeof setTimeout !== "undefined") {
|
|
setTimeout(function () {
|
|
var ctx = s.contexts[(cfg.context || defContextName)];
|
|
//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.
|
|
jQueryCheck(ctx);
|
|
resume(ctx);
|
|
}, 0);
|
|
}
|
|
}());
|
|
|
|
/**
|
|
* @license RequireJS i18n Copyright (c) 2010, The Dojo Foundation All Rights Reserved.
|
|
* Available via the MIT or new BSD license.
|
|
* see: http://github.com/jrburke/requirejs for details
|
|
*/
|
|
/*jslint regexp: false, nomen: false, plusplus: false */
|
|
/*global require: false, navigator: false */
|
|
|
|
|
|
/**
|
|
* This plugin handles i18n! prefixed modules. It does the following:
|
|
*
|
|
* 1) A regular module can have a dependency on an i18n bundle, but the regular
|
|
* module does not want to specify what locale to load. So it just specifies
|
|
* the top-level bundle, like "i18n!nls/colors".
|
|
*
|
|
* This plugin will load the i18n bundle at nls/colors, see that it is a root/master
|
|
* bundle since it does not have a locale in its name. It will then try to find
|
|
* the best match locale available in that master bundle, then request all the
|
|
* locale pieces for that best match locale. For instance, if the locale is "en-us",
|
|
* then the plugin will ask for the "en-us", "en" and "root" bundles to be loaded
|
|
* (but only if they are specified on the master bundle).
|
|
*
|
|
* Once all the bundles for the locale pieces load, then it mixes in all those
|
|
* locale pieces into each other, then finally sets the context.defined value
|
|
* for the nls/colors bundle to be that mixed in locale.
|
|
*
|
|
* 2) A regular module specifies a specific locale to load. For instance,
|
|
* i18n!nls/fr-fr/colors. In this case, the plugin needs to load the master bundle
|
|
* first, at nls/colors, then figure out what the best match locale is for fr-fr,
|
|
* since maybe only fr or just root is defined for that locale. Once that best
|
|
* fit is found, all of its locale pieces need to have their bundles loaded.
|
|
*
|
|
* Once all the bundles for the locale pieces load, then it mixes in all those
|
|
* locale pieces into each other, then finally sets the context.defined value
|
|
* for the nls/fr-fr/colors bundle to be that mixed in locale.
|
|
*/
|
|
(function () {
|
|
//regexp for reconstructing the master bundle name from parts of the regexp match
|
|
//nlsRegExp.exec("foo/bar/baz/nls/en-ca/foo") gives:
|
|
//["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
|
|
//nlsRegExp.exec("foo/bar/baz/nls/foo") gives:
|
|
//["foo/bar/baz/nls/foo", "foo/bar/baz/nls/", "/", "/", "foo", ""]
|
|
//so, if match[5] is blank, it means this is the top bundle definition.
|
|
var nlsRegExp = /(^.*(^|\/)nls(\/|$))([^\/]*)\/?([^\/]*)/,
|
|
empty = {};
|
|
|
|
function getWaiting(name, context) {
|
|
var nlswAry = context.nlsWaiting;
|
|
return nlswAry[name] ||
|
|
//Push a new waiting object on the nlsWaiting array, but also put
|
|
//a shortcut lookup by name to the object on the array.
|
|
(nlswAry[name] = nlswAry[(nlswAry.push({ _name: name}) - 1)]);
|
|
}
|
|
|
|
/**
|
|
* Makes sure all the locale pieces are loaded, and finds the best match
|
|
* for the requested locale.
|
|
*/
|
|
function resolveLocale(masterName, bundle, locale, context) {
|
|
//Break apart the locale to get the parts.
|
|
var i, parts, toLoad, nlsw, loc, val, bestLoc = "root";
|
|
|
|
parts = locale.split("-");
|
|
|
|
//Now see what bundles exist for each country/locale.
|
|
//Want to walk up the chain, so if locale is en-us-foo,
|
|
//look for en-us-foo, en-us, en, then root.
|
|
toLoad = [];
|
|
|
|
nlsw = getWaiting(masterName, context);
|
|
|
|
for (i = parts.length; i > -1; i--) {
|
|
loc = i ? parts.slice(0, i).join("-") : "root";
|
|
val = bundle[loc];
|
|
if (val) {
|
|
//Store which bundle to use for the default bundle definition.
|
|
if (locale === context.config.locale && !nlsw._match) {
|
|
nlsw._match = loc;
|
|
}
|
|
|
|
//Store the best match for the target locale
|
|
if (bestLoc === "root") {
|
|
bestLoc = loc;
|
|
}
|
|
|
|
//Track that the locale needs to be resolved with its parts.
|
|
//Mark what locale should be used when resolving.
|
|
nlsw[loc] = loc;
|
|
|
|
//If locale value is true, it means it is a resource that
|
|
//needs to be loaded. Track it to load if it has not already
|
|
//been asked for.
|
|
if (val === true) {
|
|
//split off the bundl name from master name and insert the
|
|
//locale before the bundle name. So, if masterName is
|
|
//some/path/nls/colors, then the locale fr-fr's bundle name should
|
|
//be some/path/nls/fr-fr/colors
|
|
val = masterName.split("/");
|
|
val.splice(-1, 0, loc);
|
|
val = val.join("/");
|
|
|
|
if (!context.specified[val] && !(val in context.loaded) && !context.defined[val]) {
|
|
context.defPlugin[val] = 'i18n';
|
|
toLoad.push(val);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//If locale was not an exact match, store the closest match for it.
|
|
if (bestLoc !== locale) {
|
|
if (context.defined[bestLoc]) {
|
|
//Already got it. Easy peasy lemon squeezy.
|
|
context.defined[locale] = context.defined[bestLoc];
|
|
} else {
|
|
//Need to wait for things to load then define it.
|
|
nlsw[locale] = bestLoc;
|
|
}
|
|
}
|
|
|
|
//Load any bundles that are still needed.
|
|
if (toLoad.length) {
|
|
require(toLoad, context.contextName);
|
|
}
|
|
}
|
|
|
|
require.plugin({
|
|
prefix: "i18n",
|
|
|
|
/**
|
|
* This callback is prefix-specific, only gets called for this prefix
|
|
*/
|
|
require: function (name, deps, callback, context) {
|
|
var i, match, nlsw, bundle, master, toLoad, obj = context.defined[name];
|
|
|
|
//All i18n modules must match the nls module name structure.
|
|
match = nlsRegExp.exec(name);
|
|
//If match[5] is blank, it means this is the top bundle definition,
|
|
//so it does not have to be handled. Only deal with ones that have a locale
|
|
//(a match[4] value but no match[5])
|
|
if (match[5]) {
|
|
master = match[1] + match[5];
|
|
|
|
//Track what locale bundle need to be generated once all the modules load.
|
|
nlsw = getWaiting(master, context);
|
|
nlsw[match[4]] = match[4];
|
|
|
|
bundle = context.nls[master];
|
|
if (!bundle) {
|
|
//No master bundle yet, ask for it.
|
|
context.defPlugin[master] = 'i18n';
|
|
require([master], context.contextName);
|
|
bundle = context.nls[master] = {};
|
|
}
|
|
//For nls modules, the callback is just a regular object,
|
|
//so save it off in the bundle now.
|
|
bundle[match[4]] = callback;
|
|
} else {
|
|
//Integrate bundle into the nls area.
|
|
bundle = context.nls[name];
|
|
if (bundle) {
|
|
//A specific locale already started the bundle object.
|
|
//Do a mixin (which will not overwrite the locale property
|
|
//on the bundle that has the previously loaded locale's info)
|
|
require.mixin(bundle, obj);
|
|
} else {
|
|
bundle = context.nls[name] = obj;
|
|
}
|
|
context.nlsRootLoaded[name] = true;
|
|
|
|
//Make sure there are no locales waiting to be resolved.
|
|
toLoad = context.nlsToLoad[name];
|
|
if (toLoad) {
|
|
delete context.nlsToLoad[name];
|
|
for (i = 0; i < toLoad.length; i++) {
|
|
resolveLocale(name, bundle, toLoad[i], context);
|
|
}
|
|
}
|
|
|
|
resolveLocale(name, bundle, context.config.locale, context);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Called when a new context is defined. Use this to store
|
|
* context-specific info on it.
|
|
*/
|
|
newContext: function (context) {
|
|
require.mixin(context, {
|
|
nlsWaiting: [],
|
|
nls: {},
|
|
nlsRootLoaded: {},
|
|
nlsToLoad: {}
|
|
});
|
|
if (!context.config.locale) {
|
|
context.config.locale = typeof navigator === "undefined" ? "root" :
|
|
(navigator.language || navigator.userLanguage || "root").toLowerCase();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Called when a dependency needs to be loaded.
|
|
*/
|
|
load: function (name, contextName) {
|
|
//Make sure the root bundle is loaded, to check if we can support
|
|
//loading the requested locale, or if a different one needs
|
|
//to be chosen.
|
|
var masterName, context = require.s.contexts[contextName], bundle,
|
|
match = nlsRegExp.exec(name), locale = match[4];
|
|
|
|
//If match[5] is blank, it means this is the top bundle definition,
|
|
//so it does not have to be handled. Only deal with ones that have a locale
|
|
//(a match[4] value but no match[5])
|
|
if (match[5]) {
|
|
//locale-specific bundle
|
|
masterName = match[1] + match[5];
|
|
bundle = context.nls[masterName];
|
|
if (context.nlsRootLoaded[masterName] && bundle) {
|
|
resolveLocale(masterName, bundle, locale, context);
|
|
} else {
|
|
//Store this locale to figure out after masterName is loaded and load masterName.
|
|
(context.nlsToLoad[masterName] || (context.nlsToLoad[masterName] = [])).push(locale);
|
|
context.defPlugin[masterName] = 'i18n';
|
|
require([masterName], contextName);
|
|
}
|
|
} else {
|
|
//Top-level bundle. Just call regular load, if not already loaded
|
|
if (!context.nlsRootLoaded[name]) {
|
|
context.defPlugin[name] = 'i18n';
|
|
require.load(name, contextName);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Called when the dependencies of a module are checked.
|
|
*/
|
|
checkDeps: function (name, deps, context) {
|
|
//i18n bundles are always defined as objects for their "dependencies",
|
|
//and that object is already processed in the require method, no need to
|
|
//do work in here.
|
|
},
|
|
|
|
/**
|
|
* Called to determine if a module is waiting to load.
|
|
*/
|
|
isWaiting: function (context) {
|
|
return !!context.nlsWaiting.length;
|
|
},
|
|
|
|
/**
|
|
* Called when all modules have been loaded.
|
|
*/
|
|
orderDeps: function (context) {
|
|
//Clear up state since further processing could
|
|
//add more things to fetch.
|
|
var i, j, master, msWaiting, bundle, parts, moduleSuffix, mixed,
|
|
modulePrefix, loc, defLoc, locPart, nlsWaiting = context.nlsWaiting,
|
|
bestFit;
|
|
context.nlsWaiting = [];
|
|
context.nlsToLoad = {};
|
|
|
|
//First, properly mix in any nls bundles waiting to happen.
|
|
for (i = 0; (msWaiting = nlsWaiting[i]); i++) {
|
|
//Each property is a master bundle name.
|
|
master = msWaiting._name;
|
|
bundle = context.nls[master];
|
|
defLoc = null;
|
|
|
|
//Create the module name parts from the master name. So, if master
|
|
//is foo/nls/bar, then the parts should be prefix: "foo/nls",
|
|
// suffix: "bar", and the final locale's module name will be foo/nls/locale/bar
|
|
parts = master.split("/");
|
|
modulePrefix = parts.slice(0, parts.length - 1).join("/");
|
|
moduleSuffix = parts[parts.length - 1];
|
|
//Cycle through the locale props on the waiting object and combine
|
|
//the locales together.
|
|
for (loc in msWaiting) {
|
|
if (loc !== "_name" && !(loc in empty)) {
|
|
if (loc === "_match") {
|
|
//Found default locale to use for the top-level bundle name.
|
|
defLoc = msWaiting[loc];
|
|
|
|
} else if (msWaiting[loc] !== loc) {
|
|
//A "best fit" locale, store it off to the end and handle
|
|
//it at the end by just assigning the best fit value, since
|
|
//after this for loop, the best fit locale will be defined.
|
|
(bestFit || (bestFit = {}))[loc] = msWaiting[loc];
|
|
} else {
|
|
//Mix in the properties of this locale together.
|
|
//Split the locale into pieces.
|
|
mixed = {};
|
|
parts = loc.split("-");
|
|
for (j = parts.length; j > 0; j--) {
|
|
locPart = parts.slice(0, j).join("-");
|
|
if (locPart !== "root" && bundle[locPart]) {
|
|
require.mixin(mixed, bundle[locPart]);
|
|
}
|
|
}
|
|
if (bundle.root) {
|
|
require.mixin(mixed, bundle.root);
|
|
}
|
|
|
|
context.defined[modulePrefix + "/" + loc + "/" + moduleSuffix] = mixed;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Finally define the default locale. Wait to the end of the property
|
|
//loop above so that the default locale bundle has been properly mixed
|
|
//together.
|
|
context.defined[master] = context.defined[modulePrefix + "/" + defLoc + "/" + moduleSuffix];
|
|
|
|
//Handle any best fit locale definitions.
|
|
if (bestFit) {
|
|
for (loc in bestFit) {
|
|
if (!(loc in empty)) {
|
|
context.defined[modulePrefix + "/" + loc + "/" + moduleSuffix] = context.defined[modulePrefix + "/" + bestFit[loc] + "/" + moduleSuffix];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}());
|
|
/**
|
|
* @license RequireJS text Copyright (c) 2010, The Dojo Foundation All Rights Reserved.
|
|
* Available via the MIT or new BSD license.
|
|
* see: http://github.com/jrburke/requirejs for details
|
|
*/
|
|
/*jslint regexp: false, nomen: false, plusplus: false */
|
|
/*global require: false, XMLHttpRequest: false, ActiveXObject: false */
|
|
|
|
|
|
(function () {
|
|
var progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'],
|
|
xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,
|
|
bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im;
|
|
|
|
if (!require.textStrip) {
|
|
require.textStrip = function (text) {
|
|
//Strips <?xml ...?> declarations so that external SVG and XML
|
|
//documents can be added to a document without worry. Also, if the string
|
|
//is an HTML document, only the part inside the body tag is returned.
|
|
if (text) {
|
|
text = text.replace(xmlRegExp, "");
|
|
var matches = text.match(bodyRegExp);
|
|
if (matches) {
|
|
text = matches[1];
|
|
}
|
|
} else {
|
|
text = "";
|
|
}
|
|
return text;
|
|
};
|
|
}
|
|
|
|
//Upgrade require to add some methods for XHR handling. But it could be that
|
|
//this require is used in a non-browser env, so detect for existing method
|
|
//before attaching one.
|
|
if (!require.getXhr) {
|
|
require.getXhr = function () {
|
|
//Would love to dump the ActiveX crap in here. Need IE 6 to die first.
|
|
var xhr, i, progId;
|
|
if (typeof XMLHttpRequest !== "undefined") {
|
|
return new XMLHttpRequest();
|
|
} else {
|
|
for (i = 0; i < 3; i++) {
|
|
progId = progIds[i];
|
|
try {
|
|
xhr = new ActiveXObject(progId);
|
|
} catch (e) {}
|
|
|
|
if (xhr) {
|
|
progIds = [progId]; // so faster next time
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!xhr) {
|
|
throw new Error("require.getXhr(): XMLHttpRequest not available");
|
|
}
|
|
|
|
return xhr;
|
|
};
|
|
}
|
|
|
|
if (!require.fetchText) {
|
|
require.fetchText = function (url, callback) {
|
|
var xhr = require.getXhr();
|
|
xhr.open('GET', url, true);
|
|
xhr.onreadystatechange = function (evt) {
|
|
//Do not explicitly handle errors, those should be
|
|
//visible via console output in the browser.
|
|
if (xhr.readyState === 4) {
|
|
callback(xhr.responseText);
|
|
}
|
|
};
|
|
xhr.send(null);
|
|
};
|
|
}
|
|
|
|
require.plugin({
|
|
prefix: "text",
|
|
|
|
/**
|
|
* This callback is prefix-specific, only gets called for this prefix
|
|
*/
|
|
require: function (name, deps, callback, context) {
|
|
//No-op, require never gets these text items, they are always
|
|
//a dependency, see load for the action.
|
|
},
|
|
|
|
/**
|
|
* Called when a new context is defined. Use this to store
|
|
* context-specific info on it.
|
|
*/
|
|
newContext: function (context) {
|
|
require.mixin(context, {
|
|
text: {},
|
|
textWaiting: []
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Called when a dependency needs to be loaded.
|
|
*/
|
|
load: function (name, contextName) {
|
|
//Name has format: some.module!filext!strip!text
|
|
//The strip and text parts are optional.
|
|
//if strip is present, then that means only get the string contents
|
|
//inside a body tag in an HTML string. For XML/SVG content it means
|
|
//removing the <?xml ...?> declarations so the content can be inserted
|
|
//into the current doc without problems.
|
|
//If text is present, it is the actual text of the file.
|
|
var strip = false, text = null, key, url, index = name.indexOf("."),
|
|
modName = name.substring(0, index), fullKey,
|
|
ext = name.substring(index + 1, name.length),
|
|
context = require.s.contexts[contextName],
|
|
tWaitAry = context.textWaiting;
|
|
|
|
index = ext.indexOf("!");
|
|
if (index !== -1) {
|
|
//Pull off the strip arg.
|
|
strip = ext.substring(index + 1, ext.length);
|
|
ext = ext.substring(0, index);
|
|
index = strip.indexOf("!");
|
|
if (index !== -1 && strip.substring(0, index) === "strip") {
|
|
//Pull off the text.
|
|
text = strip.substring(index + 1, strip.length);
|
|
strip = "strip";
|
|
} else if (strip !== "strip") {
|
|
//strip is actually the inlined text.
|
|
text = strip;
|
|
strip = null;
|
|
}
|
|
}
|
|
key = modName + "!" + ext;
|
|
fullKey = strip ? key + "!" + strip : key;
|
|
|
|
//Store off text if it is available for the given key and be done.
|
|
if (text !== null && !context.text[key]) {
|
|
context.defined[name] = context.text[key] = text;
|
|
return;
|
|
}
|
|
|
|
//If text is not available, load it.
|
|
if (!context.text[key] && !context.textWaiting[key] && !context.textWaiting[fullKey]) {
|
|
//Keep track that the fullKey needs to be resolved, during the
|
|
//orderDeps stage.
|
|
if (!tWaitAry[fullKey]) {
|
|
tWaitAry[fullKey] = tWaitAry[(tWaitAry.push({
|
|
name: name,
|
|
key: key,
|
|
fullKey: fullKey,
|
|
strip: !!strip
|
|
}) - 1)];
|
|
}
|
|
|
|
//Load the text.
|
|
url = require.nameToUrl(modName, "." + ext, contextName);
|
|
context.loaded[name] = false;
|
|
require.fetchText(url, function (text) {
|
|
context.text[key] = text;
|
|
context.loaded[name] = true;
|
|
});
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Called when the dependencies of a module are checked.
|
|
*/
|
|
checkDeps: function (name, deps, context) {
|
|
//No-op, checkDeps never gets these text items, they are always
|
|
//a dependency, see load for the action.
|
|
},
|
|
|
|
/**
|
|
* Called to determine if a module is waiting to load.
|
|
*/
|
|
isWaiting: function (context) {
|
|
return !!context.textWaiting.length;
|
|
},
|
|
|
|
/**
|
|
* Called when all modules have been loaded.
|
|
*/
|
|
orderDeps: function (context) {
|
|
//Clear up state since further processing could
|
|
//add more things to fetch.
|
|
var i, dep, text, tWaitAry = context.textWaiting;
|
|
context.textWaiting = [];
|
|
for (i = 0; (dep = tWaitAry[i]); i++) {
|
|
text = context.text[dep.key];
|
|
context.defined[dep.name] = dep.strip ? require.textStrip(text) : text;
|
|
}
|
|
}
|
|
});
|
|
}());
|
|
/**
|
|
* @license RequireJS jsonp Copyright (c) 2010, 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 */
|
|
/*global require: false, setTimeout: false */
|
|
|
|
|
|
(function () {
|
|
var countId = 0;
|
|
|
|
//A place to hold callback functions
|
|
require._jsonp = {};
|
|
|
|
require.plugin({
|
|
prefix: "jsonp",
|
|
|
|
/**
|
|
* This callback is prefix-specific, only gets called for this prefix
|
|
*/
|
|
require: function (name, deps, callback, context) {
|
|
//No-op, require never gets these jsonp items, they are always
|
|
//a dependency, see load for the action.
|
|
},
|
|
|
|
/**
|
|
* Called when a new context is defined. Use this to store
|
|
* context-specific info on it.
|
|
*/
|
|
newContext: function (context) {
|
|
require.mixin(context, {
|
|
jsonpWaiting: []
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Called when a dependency needs to be loaded.
|
|
*/
|
|
load: function (name, contextName) {
|
|
//Name has format: some/url?param1=value1&callback=?
|
|
//where the last question mark indicates where the jsonp callback
|
|
//function name needs to go.
|
|
var index = name.indexOf("?"),
|
|
url = name.substring(0, index),
|
|
params = name.substring(index + 1, name.length),
|
|
context = require.s.contexts[contextName],
|
|
data = {
|
|
name: name
|
|
},
|
|
funcName = "f" + (countId++),
|
|
head = require.s.head,
|
|
node = head.ownerDocument.createElement("script");
|
|
|
|
//Create JSONP callback function
|
|
require._jsonp[funcName] = function (value) {
|
|
data.value = value;
|
|
context.loaded[name] = true;
|
|
//Use a setTimeout for cleanup because some older IE versions vomit
|
|
//if removing a script node while it is being evaluated.
|
|
setTimeout(function () {
|
|
head.removeChild(node);
|
|
delete require._jsonp[funcName];
|
|
}, 15);
|
|
};
|
|
|
|
//Hold on to the data for later dependency resolution in orderDeps.
|
|
context.jsonpWaiting.push(data);
|
|
|
|
//Build up the full JSONP URL
|
|
url = require.nameToUrl(url, "?", contextName);
|
|
//nameToUrl call may or may not have placed an ending ? on the URL,
|
|
//be sure there is one and add the rest of the params.
|
|
url += (url.indexOf("?") === -1 ? "?" : "") + params.replace("?", "require._jsonp." + funcName);
|
|
|
|
context.loaded[name] = false;
|
|
node.type = "text/javascript";
|
|
node.charset = "utf-8";
|
|
node.src = url;
|
|
|
|
//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+
|
|
node.async = true;
|
|
|
|
head.appendChild(node);
|
|
},
|
|
|
|
/**
|
|
* Called when the dependencies of a module are checked.
|
|
*/
|
|
checkDeps: function (name, deps, context) {
|
|
//No-op, checkDeps never gets these jsonp items, they are always
|
|
//a dependency, see load for the action.
|
|
},
|
|
|
|
/**
|
|
* Called to determine if a module is waiting to load.
|
|
*/
|
|
isWaiting: function (context) {
|
|
return !!context.jsonpWaiting.length;
|
|
},
|
|
|
|
/**
|
|
* Called when all modules have been loaded.
|
|
*/
|
|
orderDeps: function (context) {
|
|
//Clear up state since further processing could
|
|
//add more things to fetch.
|
|
var i, dep, waitAry = context.jsonpWaiting;
|
|
context.jsonpWaiting = [];
|
|
for (i = 0; (dep = waitAry[i]); i++) {
|
|
context.defined[dep.name] = dep.value;
|
|
}
|
|
}
|
|
});
|
|
}());
|
|
/**
|
|
* @license RequireJS order Copyright (c) 2010, 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 */
|
|
/*global require: false, window: false, document: false, setTimeout: false */
|
|
|
|
|
|
(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.
|
|
//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.
|
|
var supportsInOrderExecution = ((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)),
|
|
readyRegExp = /^(complete|loaded)$/;
|
|
|
|
//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,
|
|
context, contextName, moduleName, waiting, cached;
|
|
|
|
if (evt.type === "load" || readyRegExp.test(node.readyState)) {
|
|
//Pull out the name of the module and the context.
|
|
contextName = node.getAttribute("data-requirecontext");
|
|
moduleName = node.getAttribute("data-requiremodule");
|
|
context = require.s.contexts[contextName];
|
|
waiting = context.orderWaiting;
|
|
cached = context.orderCached;
|
|
|
|
//Mark this cache request as loaded
|
|
cached[moduleName] = true;
|
|
|
|
//Find out how many ordered modules have loaded
|
|
for (i = 0; cached[waiting[i]]; i++) {}
|
|
if (i > 0) {
|
|
require(waiting.splice(0, i), contextName);
|
|
}
|
|
|
|
//If no other order cache items are in the queue, do some cleanup.
|
|
if (!waiting.length) {
|
|
context.orderCached = {};
|
|
}
|
|
|
|
//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);
|
|
}
|
|
}
|
|
|
|
require.plugin({
|
|
prefix: "order",
|
|
|
|
/**
|
|
* This callback is prefix-specific, only gets called for this prefix
|
|
*/
|
|
require: function (name, deps, callback, context) {
|
|
//No-op, require never gets these order items, they are always
|
|
//a dependency, see load for the action.
|
|
},
|
|
|
|
/**
|
|
* Called when a new context is defined. Use this to store
|
|
* context-specific info on it.
|
|
*/
|
|
newContext: function (context) {
|
|
require.mixin(context, {
|
|
orderWaiting: [],
|
|
orderCached: {}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Called when a dependency needs to be loaded.
|
|
*/
|
|
load: function (name, contextName) {
|
|
var context = require.s.contexts[contextName],
|
|
url = require.nameToUrl(name, null, contextName);
|
|
|
|
//Make sure the async attribute is not set for any pathway involving
|
|
//this script.
|
|
require.s.skipAsync[url] = true;
|
|
if (supportsInOrderExecution) {
|
|
//Just a normal script tag append, but without async attribute
|
|
//on the script.
|
|
require([name], contextName);
|
|
} 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.
|
|
context.orderWaiting.push(name);
|
|
context.loaded[name] = false;
|
|
require.attach(url, contextName, name, scriptCacheCallback, "script/cache");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Called when the dependencies of a module are checked.
|
|
*/
|
|
checkDeps: function (name, deps, context) {
|
|
//No-op, checkDeps never gets these order items, they are always
|
|
//a dependency, see load for the action.
|
|
},
|
|
|
|
/**
|
|
* Called to determine if a module is waiting to load.
|
|
*/
|
|
isWaiting: function (context) {
|
|
return !!context.orderWaiting.length;
|
|
},
|
|
|
|
/**
|
|
* Called when all modules have been loaded. Not needed for this plugin.
|
|
* State is reset as part of scriptCacheCallback.
|
|
*/
|
|
orderDeps: function (context) {
|
|
}
|
|
});
|
|
}());
|
|
|
|
//Target build file for a require.js that has all of require's functionality,
|
|
//and includes specific plugins: i18n and text.
|