require.js

/** 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.