/**

 * @license r.js 1.0.1 Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.

 * Available via the MIT or new BSD license.

 * see: http://github.com/jrburke/requirejs for details

 */

/*

 * This is a bootstrap script to allow running RequireJS in the command line

 * in either a Java/Rhino or Node environment. It is modified by the top-level

 * dist.js file to inject other files to completely enable this file. It is

 * the shell of the r.js file.

 */

/*jslint strict: false, evil: true, nomen: false */

/*global readFile: true, process: false, Packages: false, print: false,

console: false, java: false, module: false */

var requirejs, require, define;

(function (console, args, readFileFunc) {

    var fileName, env, fs, vm, path, exec, rhinoContext, dir, nodeRequire,

        nodeDefine, exists, reqMain, loadedOptimizedLib,

        version = '1.0.1',

        jsSuffixRegExp = /\.js$/,

        commandOption = '',

        //Used by jslib/rhino/args.js

        rhinoArgs = args,

        readFile = typeof readFileFunc !== 'undefined' ? readFileFunc : null;

    function showHelp() {

        console.log('See https://github.com/jrburke/r.js for usage.');

    }

    if (typeof Packages !== 'undefined') {

        env = 'rhino';

        fileName = args[0];

        if (fileName && fileName.indexOf('-') === 0) {

            commandOption = fileName.substring(1);

            fileName = args[1];

        }

        //Set up execution context.

        rhinoContext = Packages.org.mozilla.javascript.ContextFactory.getGlobal().enterContext();

        exec = function (string, name) {

            return rhinoContext.evaluateString(this, string, name, 0, null);

        };

        exists = function (fileName) {

            return (new java.io.File(fileName)).exists();

        };

        //Define a console.log for easier logging. Don't

        //get fancy though.

        if (typeof console === 'undefined') {

            console = {

                log: function () {

                    print.apply(undefined, arguments);

                }

            };

        }

    } else if (typeof process !== 'undefined') {

        env = 'node';

        //Get the fs module via Node's require before it

        //gets replaced. Used in require/node.js

        fs = require('fs');

        vm = require('vm');

        path = require('path');

        nodeRequire = require;

        nodeDefine = define;

        reqMain = require.main;

        //Temporarily hide require and define to allow require.js to define

        //them.

        require = undefined;

        define = undefined;

        readFile = function (path) {

            return fs.readFileSync(path, 'utf8');

        };

        exec = function (string, name) {

            return vm.runInThisContext(this.requirejsVars.require.makeNodeWrapper(string),

                                       name ? fs.realpathSync(name) : '');

        };

        exists = function (fileName) {

            return path.existsSync(fileName);

        };

        fileName = process.argv[2];

        if (fileName && fileName.indexOf('-') === 0) {

            commandOption = fileName.substring(1);

            fileName = process.argv[3];

        }

    }

    /** vim: et:ts=4:sw=4:sts=4

 * @license RequireJS 1.0.1 Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.

 * Available via the MIT or new BSD license.

 * see: http://github.com/jrburke/requirejs for details

 */

/*jslint strict: false, plusplus: false, sub: true */

/*global window: false, navigator: false, document: false, importScripts: false,

  jQuery: false, clearInterval: false, setInterval: false, self: false,

  setTimeout: false, opera: false */

(function () {

    //Change this version number for each release.

    var version = "1.0.1",

        commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,

        cjsRequireRegExp = /require\(\s*["']([^'"\s]+)["']\s*\)/g,

        currDirRegExp = /^\.\//,

        jsSuffixRegExp = /\.js$/,

        ostring = Object.prototype.toString,

        ap = Array.prototype,

        aps = ap.slice,

        apsp = ap.splice,

        isBrowser = !!(typeof window !== "undefined" && navigator && document),

        isWebWorker = !isBrowser && typeof importScripts !== "undefined",

        //PS3 indicates loaded and complete, but need to wait for complete

        //specifically. Sequence is "loading", "loaded", execution,

        // then "complete". The UA check is unfortunate, but not sure how

        //to feature test w/o causing perf issues.

        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?

                      /^complete$/ : /^(complete|loaded)$/,

        defContextName = "_",

        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.

        isOpera = typeof opera !== "undefined" && opera.toString() === "[object Opera]",

        empty = {},

        contexts = {},

        globalDefQueue = [],

        interactiveScript = null,

        checkLoadedDepth = 0,

        useInteractive = false,

        req, cfg = {}, currentlyAddingScript, s, head, baseElement, scripts, script,

        src, subPath, mainScript, dataMain, i, ctx, jQueryCheck, checkLoadedTimeoutId;

    function isFunction(it) {

        return ostring.call(it) === "[object Function]";

    }

    function isArray(it) {

        return ostring.call(it) === "[object Array]";

    }

    /**

     * Simple function to mix in properties from source into target,

     * but only if target does not already have a property of the same name.

     * This is not robust in IE for transferring methods that match

     * Object.prototype names, but the uses of mixin here seem unlikely to

     * trigger a problem related to that.

     */

    function mixin(target, source, force) {

        for (var prop in source) {

            if (!(prop in empty) && (!(prop in target) || force)) {

                target[prop] = source[prop];

            }

        }

        return req;

    }

    /**

     * Constructs an error with a pointer to an URL with more information.

     * @param {String} id the error ID that maps to an ID on a web page.

     * @param {String} message human readable error.

     * @param {Error} [err] the original error, if there is one.

     *

     * @returns {Error}

     */

    function makeError(id, msg, err) {

        var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);

        if (err) {

            e.originalError = err;

        }

        return e;

    }

    /**

     * Used to set up package paths from a packagePaths or packages config object.

     * @param {Object} pkgs the object to store the new package config

     * @param {Array} currentPackages an array of packages to configure

     * @param {String} [dir] a prefix dir to use.

     */

    function configurePackageDir(pkgs, currentPackages, dir) {

        var i, location, pkgObj;

        for (i = 0; (pkgObj = currentPackages[i]); i++) {

            pkgObj = typeof pkgObj === "string" ? { name: pkgObj } : pkgObj;

            location = pkgObj.location;

            //Add dir to the path, but avoid paths that start with a slash

            //or have a colon (indicates a protocol)

            if (dir && (!location || (location.indexOf("/") !== 0 && location.indexOf(":") === -1))) {

                location = dir + "/" + (location || pkgObj.name);

            }

            //Create a brand new object on pkgs, since currentPackages can

            //be passed in again, and config.pkgs is the internal transformed

            //state for all package configs.

            pkgs[pkgObj.name] = {

                name: pkgObj.name,

                location: location || pkgObj.name,

                //Remove leading dot in main, so main paths are normalized,

                //and remove any trailing .js, since different package

                //envs have different conventions: some use a module name,

                //some use a file name.

                main: (pkgObj.main || "main")

                      .replace(currDirRegExp, '')

                      .replace(jsSuffixRegExp, '')

            };

        }

    }

    /**

     * jQuery 1.4.3-1.5.x use a readyWait/ready() pairing to hold DOM

     * ready callbacks, but jQuery 1.6 supports a holdReady() API instead.

     * At some point remove the readyWait/ready() support and just stick

     * with using holdReady.

     */

    function jQueryHoldReady($, shouldHold) {

        if ($.holdReady) {

            $.holdReady(shouldHold);

        } else if (shouldHold) {

            $.readyWait += 1;

        } else {

            $.ready(true);

        }

    }

    if (typeof define !== "undefined") {

        //If a define is already in play via another AMD loader,

        //do not overwrite.

        return;

    }

    if (typeof requirejs !== "undefined") {

        if (isFunction(requirejs)) {

            //Do not overwrite and existing requirejs instance.

            return;

        } else {

            cfg = requirejs;

            requirejs = undefined;

        }

    }

    //Allow for a require config object

    if (typeof require !== "undefined" && !isFunction(require)) {

        //assume it is a config object.

        cfg = require;

        require = undefined;

    }

    /**

     * Creates a new context for use in require and define calls.

     * Handle most of the heavy lifting. Do not want to use an object

     * with prototype here to avoid using "this" in require, in case it

     * needs to be used in more super secure envs that do not want this.

     * Also there should not be that many contexts in the page. Usually just

     * one for the default context, but could be extra for multiversion cases

     * or if a package needs a special context for a dependency that conflicts

     * with the standard context.

     */

    function newContext(contextName) {

        var context, resume,

            config = {

                waitSeconds: 7,

                baseUrl: "./",

                paths: {},

                pkgs: {},

                catchError: {}

            },

            defQueue = [],

            specified = {

                "require": true,

                "exports": true,

                "module": true

            },

            urlMap = {},

            defined = {},

            loaded = {},

            waiting = {},

            waitAry = [],

            urlFetched = {},

            managerCounter = 0,

            managerCallbacks = {},

            plugins = {},

            //Used to indicate which modules in a build scenario

            //need to be full executed.

            needFullExec = {},

            fullExec = {},

            resumeDepth = 0;

        /**

         * Trims the . and .. from an array of path segments.

         * It will keep a leading path segment if a .. will become

         * the first path segment, to help with module name lookups,

         * which act like paths, but can be remapped. But the end result,

         * all paths that use this function should look normalized.

         * NOTE: this method MODIFIES the input array.

         * @param {Array} ary the array of path segments.

         */

        function trimDots(ary) {

            var i, part;

            for (i = 0; (part = ary[i]); i++) {

                if (part === ".") {

                    ary.splice(i, 1);

                    i -= 1;

                } else if (part === "..") {

                    if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {

                        //End of the line. Keep at least one non-dot

                        //path segment at the front so it can be mapped

                        //correctly to disk. Otherwise, there is likely

                        //no path mapping for a path starting with '..'.

                        //This can still fail, but catches the most reasonable

                        //uses of ..

                        break;

                    } else if (i > 0) {

                        ary.splice(i - 1, 2);

                        i -= 2;

                    }

                }

            }

        }

        /**

         * Given a relative module name, like ./something, normalize it to

         * a real name that can be mapped to a path.

         * @param {String} name the relative name

         * @param {String} baseName a real name that the name arg is relative

         * to.

         * @returns {String} normalized name

         */

        function normalize(name, baseName) {

            var pkgName, pkgConfig;

            //Adjust any relative paths.

            if (name && name.charAt(0) === ".") {

                //If have a base name, try to normalize against it,

                //otherwise, assume it is a top-level require that will

                //be relative to baseUrl in the end.

                if (baseName) {

                    if (config.pkgs[baseName]) {

                        //If the baseName is a package name, then just treat it as one

                        //name to concat the name with.

                        baseName = [baseName];

                    } else {

                        //Convert baseName to array, and lop off the last part,

                        //so that . matches that "directory" and not name of the baseName's

                        //module. For instance, baseName of "one/two/three", maps to

                        //"one/two/three.js", but we want the directory, "one/two" for

                        //this normalization.

                        baseName = baseName.split("/");

                        baseName = baseName.slice(0, baseName.length - 1);

                    }

                    name = baseName.concat(name.split("/"));

                    trimDots(name);

                    //Some use of packages may use a . path to reference the

                    //"main" module name, so normalize for that.

                    pkgConfig = config.pkgs[(pkgName = name[0])];

                    name = name.join("/");

                    if (pkgConfig && name === pkgName + '/' + pkgConfig.main) {

                        name = pkgName;

                    }

                }

            }

            return name;

        }

        /**

         * Creates a module mapping that includes plugin prefix, module

         * name, and path. If parentModuleMap is provided it will

         * also normalize the name via require.normalize()

         *

         * @param {String} name the module name

         * @param {String} [parentModuleMap] parent module map

         * for the module name, used to resolve relative names.

         *

         * @returns {Object}

         */

        function makeModuleMap(name, parentModuleMap) {

            var index = name ? name.indexOf("!") : -1,

                prefix = null,

                parentName = parentModuleMap ? parentModuleMap.name : null,

                originalName = name,

                normalizedName, url, pluginModule;

            if (index !== -1) {

                prefix = name.substring(0, index);

                name = name.substring(index + 1, name.length);

            }

            if (prefix) {

                prefix = normalize(prefix, parentName);

            }

            //Account for relative paths if there is a base name.

            if (name) {

                if (prefix) {

                    pluginModule = defined[prefix];

                    if (pluginModule && pluginModule.normalize) {

                        //Plugin is loaded, use its normalize method.

                        normalizedName = pluginModule.normalize(name, function (name) {

                            return normalize(name, parentName);

                        });

                    } else {

                        normalizedName = normalize(name, parentName);

                    }

                } else {

                    //A regular module.

                    normalizedName = normalize(name, parentName);

                    url = urlMap[normalizedName];

                    if (!url) {

                        //Calculate url for the module, if it has a name.

                        url = context.nameToUrl(normalizedName, null, parentModuleMap);

                        //Store the URL mapping for later.

                        urlMap[normalizedName] = url;

                    }

                }

            }

            return {

                prefix: prefix,

                name: normalizedName,

                parentMap: parentModuleMap,

                url: url,

                originalName: originalName,

                fullName: prefix ? prefix + "!" + (normalizedName || '') : normalizedName

            };

        }

        /**

         * Determine if priority loading is done. If so clear the priorityWait

         */

        function isPriorityDone() {

            var priorityDone = true,

                priorityWait = config.priorityWait,

                priorityName, i;

            if (priorityWait) {

                for (i = 0; (priorityName = priorityWait[i]); i++) {

                    if (!loaded[priorityName]) {

                        priorityDone = false;

                        break;

                    }

                }

                if (priorityDone) {

                    delete config.priorityWait;

                }

            }

            return priorityDone;

        }

        function makeContextModuleFunc(func, relModuleMap, enableBuildCallback) {

            return function () {

                //A version of a require function that passes a moduleName

                //value for items that may need to

                //look up paths relative to the moduleName

                var args = aps.call(arguments, 0), lastArg;

                if (enableBuildCallback &&

                    isFunction((lastArg = args[args.length - 1]))) {

                    lastArg.__requireJsBuild = true;

                }

                args.push(relModuleMap);

                return func.apply(null, args);

            };

        }

        /**

         * Helper function that creates a require function object to give to

         * modules that ask for it as a dependency. It needs to be specific

         * per module because of the implication of path mappings that may

         * need to be relative to the module name.

         */

        function makeRequire(relModuleMap, enableBuildCallback) {

            var modRequire = makeContextModuleFunc(context.require, relModuleMap, enableBuildCallback);

            mixin(modRequire, {

                nameToUrl: makeContextModuleFunc(context.nameToUrl, relModuleMap),

                toUrl: makeContextModuleFunc(context.toUrl, relModuleMap),

                defined: makeContextModuleFunc(context.requireDefined, relModuleMap),

                specified: makeContextModuleFunc(context.requireSpecified, relModuleMap),

                isBrowser: req.isBrowser

            });

            return modRequire;

        }

        /*

         * Queues a dependency for checking after the loader is out of a

         * "paused" state, for example while a script file is being loaded

         * in the browser, where it may have many modules defined in it.

         */

        function queueDependency(manager) {

            context.paused.push(manager);

        }

        function execManager(manager) {

            var i, ret, err, errFile, errModuleTree,

                cb = manager.callback,

                map = manager.map,

                fullName = map.fullName,

                args = manager.deps,

                listeners = manager.listeners;

            //Call the callback to define the module, if necessary.

            if (cb && isFunction(cb)) {

                if (config.catchError.define) {

                    try {

                        ret = req.execCb(fullName, manager.callback, args, defined[fullName]);

                    } catch (e) {

                        err = e;

                    }

                } else {

                    ret = req.execCb(fullName, manager.callback, args, defined[fullName]);

                }

                if (fullName) {

                    //If setting exports via "module" is in play,

                    //favor that over return value and exports. After that,

                    //favor a non-undefined return value over exports use.