function eachReverse(ary, func) {  if (ary) {    var i;    for (i = ary.length - 1; i > -1; i -= 1) {      if (ary[i] && func(ary[i], i, ary)) {        break;      }    }  }}

if (isBrowser) {  head = s.head = document.getElementsByTagName('head')[0];  //If BASE tag is in play, using appendChild is a problem for IE6.  //When that browser dies, this can be removed. Details in this jQuery bug:  //http://dev.jquery.com/ticket/2709  baseElement = document.getElementsByTagName('base')[0];  if (baseElement) {    head = s.head = baseElement.parentNode;  }}

/*** Set a configuration for the context.* @param {Object} cfg config object to integrate.*/configure: function (cfg) {  //Make sure the baseUrl ends in a slash.  if (cfg.baseUrl) {    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {      cfg.baseUrl += '/';    }  }  //Save off the paths and packages since they require special processing,  //they are additive.  var pkgs = config.pkgs,              shim = config.shim,              objs = {                paths: true,                config: true,                map: true              };  eachProp(cfg, function (value, prop) {    if (objs[prop]) {      if (prop === 'map') {        if (!config.map) {          config.map = {};        }        mixin(config[prop], value, true, true);      } else {        mixin(config[prop], value, true);      }    } else {      config[prop] = value;    }  });  //Merge shim  if (cfg.shim) {    eachProp(cfg.shim, function (value, id) {      //Normalize the structure      if (isArray(value)) {        value = {          deps: value        };      }      if ((value.exports || value.init) && !value.exportsFn) {        value.exportsFn = context.makeShimExports(value);      }      shim[id] = value;    });    config.shim = shim;  }  //Adjust packages if necessary.  if (cfg.packages) {    each(cfg.packages, function (pkgObj) {      var location;      pkgObj = typeof pkgObj === 'string' ? { name: pkgObj} : pkgObj;      location = pkgObj.location;      //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, '')      };    });    //Done with modifications, assing packages back to context config    config.pkgs = pkgs;  }  //If there are any "waiting to execute" modules in the registry,  //update the maps for them, since their info, like URLs to load,  //may have changed.  eachProp(registry, function (mod, id) {    //If module already has init called, since it is too    //late to modify them, and ignore unnormalized ones    //since they are transient.    if (!mod.inited && !mod.map.unnormalized) {      mod.map = makeModuleMap(id);    }  });  //If a deps array or a config callback is specified, then call  //require with those args. This is useful when require is defined as a  //config object before require.js is loaded.  if (cfg.deps || cfg.callback) {    context.require(cfg.deps || [], cfg.callback);  }},

/*** Cycles over properties in an object and calls a function for each* property value. If the function returns a truthy value, then the* iteration is stopped.*/function eachProp(obj, func) {  var prop;  for (prop in obj) {    if (hasProp(obj, prop)) {      if (func(obj[prop], prop)) {        break;      }    }  }}

function localRequire(deps, callback, errback) {  var id, map, requireMod;  if (options.enableBuildCallback && callback && isFunction(callback)) {    callback.__requireJsBuild = true;  }  if (typeof deps === 'string') {    if (isFunction(callback)) {      //Invalid call      return onError(makeError('requireargs', 'Invalid require call'), errback);    }    //If require|exports|module are requested, get the    //value for them from the special handlers. Caveat:    //this only works while module is being defined.    if (relMap && hasProp(handlers, deps)) {      return handlers[deps](registry[relMap.id]);    }    //Synchronous access to one module. If require.get is    //available (as in the Node adapter), prefer that.    if (req.get) {      return req.get(context, deps, relMap, localRequire);    }    //Normalize module name, if it contains . or ..    map = makeModuleMap(deps, relMap, false, true);    id = map.id;    if (!hasProp(defined, id)) {      return onError(makeError('notloaded', 'Module name "' +                                id +                                '" has not been loaded yet for context: ' +                                contextName +                                (relMap ? '' : '. Use require([])')));    }    return defined[id];  }  //Grab defines waiting in the global queue.  intakeDefines();  //Mark all the dependencies as needing to be loaded.  context.nextTick(function () {    //Some defines could have been added since the    //require call, collect them.    intakeDefines();    requireMod = getModule(makeModuleMap(null, relMap));    //Store if map config should be applied to this require    //call for dependencies.    requireMod.skipMap = options.skipMap;    requireMod.init(deps, callback, errback, {      enabled: true    });    checkLoaded();  });  return localRequire;}

/*** 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.* @param {Boolean} isNormalized: is the ID already normalized.* This is true if this call is done for a define() module ID.* @param {Boolean} applyMap: apply the map config to the ID.* Should only be true if this map is for a dependency.** @returns {Object}*/function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {  var url, pluginModule, suffix, nameParts,            prefix = null,            parentName = parentModuleMap ? parentModuleMap.name : null,            originalName = name,            isDefine = true,            normalizedName = '';  //If no name, then it means it is a require call, generate an  //internal name.  if (!name) {    isDefine = false;    name = '_@r' + (requireCounter += 1);  }  nameParts = splitPrefix(name);  prefix = nameParts[0];  name = nameParts[1];  if (prefix) {    prefix = normalize(prefix, parentName, applyMap);    pluginModule = getOwn(defined, prefix);  }  //Account for relative paths if there is a base name.  if (name) {    if (prefix) {      if (pluginModule && pluginModule.normalize) {        //Plugin is loaded, use its normalize method.        normalizedName = pluginModule.normalize(name, function (name) {          return normalize(name, parentName, applyMap);        });      } else {        normalizedName = normalize(name, parentName, applyMap);      }    } else {      //A regular module.      normalizedName = normalize(name, parentName, applyMap);      //Normalized name may be a plugin ID due to map config      //application in normalize. The map config values must      //already be normalized, so do not need to redo that part.      nameParts = splitPrefix(normalizedName);      prefix = nameParts[0];      normalizedName = nameParts[1];      isNormalized = true;      url = context.nameToUrl(normalizedName);    }  }  //If the id is a plugin id that cannot be determined if it needs  //normalization, stamp it with a unique ID so two matching relative  //ids that may conflict can be separate.  suffix = prefix && !pluginModule && !isNormalized ?                  '_unnormalized' + (unnormalizedCounter += 1) :                  '';  return {    prefix: prefix,    name: normalizedName,    parentMap: parentModuleMap,    unnormalized: !!suffix,    url: url,    originalName: originalName,    isDefine: isDefine,    id: (prefix ?                    prefix + '!' + normalizedName :                    normalizedName) + suffix  };}

Module = function (map) {  this.events = getOwn(undefEvents, map.id) || {};  this.map = map;  this.shim = getOwn(config.shim, map.id);  this.depExports = [];  this.depMaps = [];  this.depMatched = [];  this.pluginMaps = {};  this.depCount = 0;  /* this.exports this.factory  this.depMaps = [],  this.enabled, this.fetched  */};Module.prototype = {  init: function (depMaps, factory, errback, options) {    options = options || {};    //Do not do more inits if already done. Can happen if there    //are multiple define calls for the same module. That is not    //a normal, common case, but it is also not unexpected.    if (this.inited) {      return;    }    this.factory = factory;    if (errback) {      //Register for errors on this module.      this.on('error', errback);    } else if (this.events.error) {      //If no errback already, but there are error listeners      //on this module, set up an errback to pass to the deps.      errback = bind(this, function (err) {        this.emit('error', err);      });    }    //Do a copy of the dependency array, so that    //source inputs are not modified. For example    //"shim" deps are passed in here directly, and    //doing a direct modification of the depMaps array    //would affect that config.    this.depMaps = depMaps && depMaps.slice(0);    this.errback = errback;    //Indicate this module has be initialized    this.inited = true;    this.ignore = options.ignore;    //Could have option to init this module in enabled mode,    //or could have been previously marked as enabled. However,    //the dependencies are not known until init is called. So    //if enabled previously, now trigger dependencies as enabled.    if (options.enabled || this.enabled) {      //Enable this module and dependencies.      //Will call this.check()      this.enable();    } else {      this.check();    }  },  defineDep: function (i, depExports) {    //Because of cycles, defined callback for a given    //export can be called more than once.    if (!this.depMatched[i]) {      this.depMatched[i] = true;      this.depCount -= 1;      this.depExports[i] = depExports;    }  },  fetch: function () {    if (this.fetched) {      return;    }    this.fetched = true;    context.startTime = (new Date()).getTime();    var map = this.map;    //If the manager is for a plugin managed resource,    //ask the plugin to load it now.    if (this.shim) {      context.makeRequire(this.map, {        enableBuildCallback: true      })(this.shim.deps || [], bind(this, function () {        return map.prefix ? this.callPlugin() : this.load();      }));    } else {      //Regular dependency.      return map.prefix ? this.callPlugin() : this.load();    }  },  load: function () {    var url = this.map.url;    //Regular dependency.    if (!urlFetched[url]) {      urlFetched[url] = true;      context.load(this.map.id, url);    }  },  /**  * Checks if the module is ready to define itself, and if so,  * define it.  */  check: function () {    if (!this.enabled || this.enabling) {      return;    }    var err, cjsModule,                id = this.map.id,                depExports = this.depExports,                exports = this.exports,                factory = this.factory;    if (!this.inited) {      this.fetch();    } else if (this.error) {      this.emit('error', this.error);    } else if (!this.defining) {      //The factory could trigger another require call      //that would result in checking this module to      //define itself again. If already in the process      //of doing that, skip this work.      this.defining = true;      if (this.depCount < 1 && !this.defined) {        if (isFunction(factory)) {          //If there is an error listener, favor passing          //to that instead of throwing an error. However,          //only do it for define()'d  modules. require          //errbacks should not be called for failures in          //their callbacks (#699). However if a global          //onError is set, use that.          if ((this.events.error && this.map.isDefine) ||                            req.onError !== defaultOnError) {            try {              exports = context.execCb(id, factory, depExports, exports);            } catch (e) {              err = e;            }          } else {            exports = context.execCb(id, factory, depExports, exports);          }          if (this.map.isDefine) {            //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.            cjsModule = this.module;            if (cjsModule &&                                    cjsModule.exports !== undefined &&            //Make sure it is not already the exports value                                    cjsModule.exports !== this.exports) {              exports = cjsModule.exports;            } else if (exports === undefined && this.usingExports) {              //exports already set the defined value.              exports = this.exports;            }          }          if (err) {            err.requireMap = this.map;            err.requireModules = this.map.isDefine ? [this.map.id] : null;            err.requireType = this.map.isDefine ? 'define' : 'require';            return onError((this.error = err));          }        } else {          //Just a literal value          exports = factory;        }        this.exports = exports;        if (this.map.isDefine && !this.ignore) {          defined[id] = exports;          if (req.onResourceLoad) {            req.onResourceLoad(context, this.map, this.depMaps);          }        }        //Clean up        cleanRegistry(id);        this.defined = true;      }      //Finished the define stage. Allow calling check again      //to allow define notifications below in the case of a      //cycle.      this.defining = false;      if (this.defined && !this.defineEmitted) {        this.defineEmitted = true;        this.emit('defined', this.exports);        this.defineEmitComplete = true;      }    }  },  callPlugin: function () {    var map = this.map,                id = map.id,    //Map already normalized the prefix.                pluginMap = makeModuleMap(map.prefix);    //Mark this as a dependency for this plugin, so it    //can be traced for cycles.    this.depMaps.push(pluginMap);    on(pluginMap, 'defined', bind(this, function (plugin) {      var load, normalizedMap, normalizedMod,                    name = this.map.name,                    parentName = this.map.parentMap ? this.map.parentMap.name : null,                    localRequire = context.makeRequire(map.parentMap, {                      enableBuildCallback: true                    });      //If current map is not normalized, wait for that      //normalized name to load instead of continuing.      if (this.map.unnormalized) {        //Normalize the ID if the plugin allows it.        if (plugin.normalize) {          name = plugin.normalize(name, function (name) {            return normalize(name, parentName, true);          }) || '';        }        //prefix and name should already be normalized, no need        //for applying map config again either.        normalizedMap = makeModuleMap(map.prefix + '!' + name,                                                  this.map.parentMap);        on(normalizedMap,                        'defined', bind(this, function (value) {                          this.init([], function () { return value; }, null, {                            enabled: true,                            ignore: true                          });                        }));        normalizedMod = getOwn(registry, normalizedMap.id);        if (normalizedMod) {          //Mark this as a dependency for this plugin, so it          //can be traced for cycles.          this.depMaps.push(normalizedMap);          if (this.events.error) {            normalizedMod.on('error', bind(this, function (err) {              this.emit('error', err);            }));          }          normalizedMod.enable();        }        return;      }      load = bind(this, function (value) {        this.init([], function () { return value; }, null, {          enabled: true        });      });      load.error = bind(this, function (err) {        this.inited = true;        this.error = err;        err.requireModules = [id];        //Remove temp unnormalized modules for this module,        //since they will never be resolved otherwise now.        eachProp(registry, function (mod) {          if (mod.map.id.indexOf(id + '_unnormalized') === 0) {            cleanRegistry(mod.map.id);          }        });        onError(err);      });      //Allow plugins to load other code without having to know the      //context or how to 'complete' the load.      load.fromText = bind(this, function (text, textAlt) {        /*jslint evil: true */        var moduleName = map.name,                        moduleMap = makeModuleMap(moduleName),                        hasInteractive = useInteractive;        //As of 2.1.0, support just passing the text, to reinforce        //fromText only being called once per resource. Still        //support old style of passing moduleName but discard        //that moduleName in favor of the internal ref.        if (textAlt) {          text = textAlt;        }        //Turn off interactive script matching for IE for any define        //calls in the text, then turn it back on at the end.        if (hasInteractive) {          useInteractive = false;        }        //Prime the system by creating a module instance for        //it.        getModule(moduleMap);        //Transfer any config to this other module.        if (hasProp(config.config, id)) {          config.config[moduleName] = config.config[id];        }        try {          req.exec(text);        } catch (e) {          return onError(makeError('fromtexteval',                                          'fromText eval for ' + id +                                        ' failed: ' + e,                                          e,                                          [id]));        }        if (hasInteractive) {          useInteractive = true;        }        //Mark this as a dependency for the plugin        //resource        this.depMaps.push(moduleMap);        //Support anonymous modules.        context.completeLoad(moduleName);        //Bind the value of that module to the value for this        //resource ID.        localRequire([moduleName], load);      });      //Use parentName here since the plugin's name is not reliable,      //could be some weird string with no path that actually wants to      //reference the parentName's path.      plugin.load(map.name, localRequire, load, config);    }));    context.enable(pluginMap, this);    this.pluginMaps[pluginMap.id] = pluginMap;  },  enable: function () {    enabledRegistry[this.map.id] = this;    this.enabled = true;    //Set flag mentioning that the module is enabling,    //so that immediate calls to the defined callbacks    //for dependencies do not trigger inadvertent load    //with the depCount still being zero.    this.enabling = true;    //Enable each dependency    each(this.depMaps, bind(this, function (depMap, i) {      var id, mod, handler;      if (typeof depMap === 'string') {        //Dependency needs to be converted to a depMap        //and wired up to this module.        depMap = makeModuleMap(depMap,                                            (this.map.isDefine ? this.map : this.map.parentMap),                                            false,                                            !this.skipMap);        this.depMaps[i] = depMap;        handler = getOwn(handlers, depMap.id);        if (handler) {          this.depExports[i] = handler(this);          return;        }        this.depCount += 1;        on(depMap, 'defined', bind(this, function (depExports) {          this.defineDep(i, depExports);          this.check();        }));        if (this.errback) {          on(depMap, 'error', bind(this, this.errback));        }      }      id = depMap.id;      mod = registry[id];      //Skip special modules like 'require', 'exports', 'module'      //Also, don't call enable if it is already enabled,      //important in circular dependency cases.      if (!hasProp(handlers, id) && mod && !mod.enabled) {        context.enable(depMap, this);      }    }));    //Enable each plugin that is used in    //a dependency    eachProp(this.pluginMaps, bind(this, function (pluginMap) {      var mod = getOwn(registry, pluginMap.id);      if (mod && !mod.enabled) {        context.enable(pluginMap, this);      }    }));    this.enabling = false;    this.check();  },  on: function (name, cb) {    var cbs = this.events[name];    if (!cbs) {      cbs = this.events[name] = [];    }    cbs.push(cb);  },  emit: function (name, evt) {    each(this.events[name], function (cb) {      cb(evt);    });    if (name === 'error') {      //Now that the error handler was triggered, remove      //the listeners, since this broken Module instance      //can stay around for a while in the registry.      delete this.events[name];    }  }};

enable: function () {  enabledRegistry[this.map.id] = this;  this.enabled = true;  //Set flag mentioning that the module is enabling,  //so that immediate calls to the defined callbacks  //for dependencies do not trigger inadvertent load  //with the depCount still being zero.  this.enabling = true;  //Enable each dependency  each(this.depMaps, bind(this, function (depMap, i) {    var id, mod, handler;    if (typeof depMap === 'string') {      //Dependency needs to be converted to a depMap      //and wired up to this module.      depMap = makeModuleMap(depMap,                                          (this.map.isDefine ? this.map : this.map.parentMap),                                          false,                                          !this.skipMap);      this.depMaps[i] = depMap;      handler = getOwn(handlers, depMap.id);      if (handler) {        this.depExports[i] = handler(this);        return;      }      this.depCount += 1;      on(depMap, 'defined', bind(this, function (depExports) {        this.defineDep(i, depExports);        this.check();      }));      if (this.errback) {        on(depMap, 'error', bind(this, this.errback));      }    }    id = depMap.id;    mod = registry[id];    //Skip special modules like 'require', 'exports', 'module'    //Also, don't call enable if it is already enabled,    //important in circular dependency cases.    if (!hasProp(handlers, id) && mod && !mod.enabled) {      context.enable(depMap, this);    }  }));  //Enable each plugin that is used in  //a dependency  eachProp(this.pluginMaps, bind(this, function (pluginMap) {    var mod = getOwn(registry, pluginMap.id);    if (mod && !mod.enabled) {      context.enable(pluginMap, this);    }  }));  this.enabling = false;  this.check();},

/*** Checks if the module is ready to define itself, and if so,* define it.*/check: function () {  if (!this.enabled || this.enabling) {    return;  }  var err, cjsModule,              id = this.map.id,              depExports = this.depExports,              exports = this.exports,              factory = this.factory;  if (!this.inited) {    this.fetch();  } else if (this.error) {    this.emit('error', this.error);  } else if (!this.defining) {    //The factory could trigger another require call    //that would result in checking this module to    //define itself again. If already in the process    //of doing that, skip this work.    this.defining = true;    if (this.depCount < 1 && !this.defined) {      if (isFunction(factory)) {        //If there is an error listener, favor passing        //to that instead of throwing an error. However,        //only do it for define()'d  modules. require        //errbacks should not be called for failures in        //their callbacks (#699). However if a global        //onError is set, use that.        if ((this.events.error && this.map.isDefine) ||                          req.onError !== defaultOnError) {          try {            exports = context.execCb(id, factory, depExports, exports);          } catch (e) {            err = e;          }        } else {          exports = context.execCb(id, factory, depExports, exports);        }        if (this.map.isDefine) {          //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.          cjsModule = this.module;          if (cjsModule &&                                  cjsModule.exports !== undefined &&          //Make sure it is not already the exports value                                  cjsModule.exports !== this.exports) {            exports = cjsModule.exports;          } else if (exports === undefined && this.usingExports) {            //exports already set the defined value.            exports = this.exports;          }        }        if (err) {          err.requireMap = this.map;          err.requireModules = this.map.isDefine ? [this.map.id] : null;          err.requireType = this.map.isDefine ? 'define' : 'require';          return onError((this.error = err));        }      } else {        //Just a literal value        exports = factory;      }      this.exports = exports;      if (this.map.isDefine && !this.ignore) {        defined[id] = exports;        if (req.onResourceLoad) {          req.onResourceLoad(context, this.map, this.depMaps);        }      }      //Clean up      cleanRegistry(id);      this.defined = true;    }    //Finished the define stage. Allow calling check again    //to allow define notifications below in the case of a    //cycle.    this.defining = false;    if (this.defined && !this.defineEmitted) {      this.defineEmitted = true;      this.emit('defined', this.exports);      this.defineEmitComplete = true;    }  }},