if (ary) {

var i;

for (i = 0; i < ary.length; i += 1) {

if (func(ary[i], i, ary)) {

break;

}

}

}

var prop;

for (prop in obj) {

if (obj.hasOwnProperty(prop)) {

if (func(obj[prop], prop)) {

break;

}

}

}

if (source) {

eachProp(source, function (value, prop) {

if (force || !target.hasOwnProperty(prop)) {

target[prop] = value;

}

});

}

return function () {

return fn.apply(obj, arguments);

};

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

e.requireType = id;

e.requireModules = requireModules;

if (err) {

e.originalError = err;

}

return e;

var config = {

waitSeconds: 7,

baseUrl: './',

paths: {},

pkgs: {},

shim: {}

},

registry = {},

undefEvents = {},

defined = {},

urlMap = {},

urlFetched = {},

requireCounter = 1,

unnormalizedCounter = 1,

//Used to track the order in which modules

//should be executed, by the order they

//load. Important for consistent cycle resolution

//behavior.

waitAry = [],

inCheckLoaded, Module, context, handlers,

checkLoadedTimeoutId;

/**

function trimDots(ary) {

var i, part;

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

part = ary[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;

}

}

}

}

/**

function normalize(name, baseName) {

var baseParts = baseName && baseName.split('/'),

map = config.map,

starMap = map && map['*'],

pkgName, pkgConfig, mapValue, nameParts, i, j, nameSegment,

foundMap;

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

baseParts = [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.

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

}

name = baseParts.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;

}

} else if (name.indexOf('./') === 0) {

// No baseName, so this is ID is resolved relative

// to baseUrl, pull off the leading dot.

name = name.substring(2);

}

}

//Apply map config if available.

if ((baseParts || starMap) && map) {

nameParts = name.split('/');

for (i = nameParts.length; i > 0; i -= 1) {

nameSegment = nameParts.slice(0, i).join('/');

if (baseParts) {

//Find the longest baseName segment match in the config.

//So, do joins on the biggest to smallest lengths of baseParts.

for (j = baseParts.length; j > 0; j -= 1) {

mapValue = map[baseParts.slice(0, j).join('/')];

//baseName segment has config, find if it has one for

//this name.

if (mapValue) {

mapValue = mapValue[nameSegment];

if (mapValue) {

//Match, update name to the new value.

foundMap = mapValue;

break;

}

}

}

}

if (!foundMap && starMap && starMap[nameSegment]) {

foundMap = starMap[nameSegment];

}

if (foundMap) {

nameParts.splice(0, i, foundMap);

name = nameParts.join('/');

break;

}

}

}

return name;

}

function removeScript(name) {

if (isBrowser) {

var scripts = document.getElementsByTagName('script'),

i, scriptNode;

for (i = 0; i < scripts.length; i += 1) {

scriptNode = scripts[i];

if (scriptNode.getAttribute('data-requiremodule') === name &&

scriptNode.getAttribute('data-requirecontext') === context.contextName) {

scriptNode.parentNode.removeChild(scriptNode);

context.scriptCount -= 1;

break;

}

}

}

}

function hasPathFallback(id) {

var pathConfig = config.paths[id];

if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {

removeScript(id);

//Pop off the first array value, since it failed, and

//retry

pathConfig.shift();

context.undef(id);

context.require([id]);

return true;

}

}

/**

function makeModuleMap(name, parentModuleMap, isNormalized) {

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

prefix = null,

parentName = parentModuleMap ? parentModuleMap.name : null,

originalName = name,

isDefine = true,

normalizedName, url, pluginModule, suffix;

//If no name, then it means it is a require call, generate an

//internal name.

if (!name) {

isDefine = false;

name = '_@r' + (requireCounter += 1);

}

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.

//Use name here since nameToUrl also calls normalize,

//and for relative names that are outside the baseUrl

//this causes havoc. Was thinking of just removing

//parentModuleMap to avoid extra normalization, but

//normalize() still does a dot removal because of

//issue #142, so just pass in name here and redo

//the normalization. Paths outside baseUrl are just

//messy to support.

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

//Store the URL mapping for later.

urlMap[normalizedName] = url;

}

}

}

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

};

}

function getModule(depMap) {

var id = depMap.id,

mod = registry[id];

if (!mod) {

mod = registry[id] = new context.Module(depMap);

}

return mod;

}

function on(depMap, name, fn) {

var id = depMap.id,

mod = registry[id];

if (defined.hasOwnProperty(id) &&

(!mod || mod.defineEmitComplete)) {

if (name === 'defined') {

fn(defined[id]);

}

} else {

getModule(depMap).on(name, fn);

}

}

function onError(err, errback) {

var ids = err.requireModules,

notified = false;

if (errback) {

errback(err);

} else {

each(ids, function (id) {

var mod = registry[id];

if (mod) {

//Set error on module, so it skips timeout checks.

mod.error = err;

if (mod.events.error) {

notified = true;

mod.emit('error', err);

}

}

});

if (!notified) {

req.onError(err);

}

}

}

/**

function takeGlobalQueue() {

//Push all the globalDefQueue items into the context's defQueue

if (globalDefQueue.length) {

//Array splice in the values since the context code has a

//local var ref to defQueue, so cannot just reassign the one

//on context.

apsp.apply(context.defQueue,

[context.defQueue.length - 1, 0].concat(globalDefQueue));

globalDefQueue = [];

}

}

function makeContextModuleFunc(func, relMap, 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(relMap);

return func.apply(null, args);

};

}

/**

function makeRequire(mod, enableBuildCallback, altRequire) {

var relMap = mod && mod.map,

modRequire = makeContextModuleFunc(altRequire || context.require, relMap, enableBuildCallback);

mixin(modRequire, {

toUrl: makeContextModuleFunc(context.toUrl, relMap),

nameToUrl: makeContextModuleFunc(context.nameToUrl, relMap),

defined: makeContextModuleFunc(context.requireDefined, relMap),

specified: makeContextModuleFunc(context.requireSpecified, relMap)

});

return modRequire;

}

handlers = {

'require': function (mod) {

return makeRequire(mod);

},

'exports': function (mod) {

mod.usingExports = true;

if (mod.map.isDefine) {

return (mod.exports = defined[mod.map.id] = {});

}

},

'module': function (mod) {

return (mod.module = {

id: mod.map.id,

uri: mod.map.url,

config: function () {

return (config.config && config.config[mod.map.id]) || {};

},

exports: defined[mod.map.id]

});

}

};

function removeWaiting(id) {

//Clean up machinery used for waiting modules.

delete registry[id];

each(waitAry, function (mod, i) {

if (mod.map.id === id) {

waitAry.splice(i, 1);

if (!mod.defined) {

context.waitCount -= 1;

}

return true;

}

});

}

function findCycle(mod, traced) {

var id = mod.map.id,

depArray = mod.depMaps,

foundModule;

//Do not bother with unitialized modules or not yet enabled

//modules.

if (!mod.inited) {

return;

}

//Found the cycle.

if (traced[id]) {

return mod;

}

traced[id] = true;

//Trace through the dependencies.

each(depArray, function (depMap) {

var depId = depMap.id,

depMod = registry[depId];

if (!depMod) {

return;

}

if (!depMod.inited || !depMod.enabled) {

//Dependency is not inited, so this cannot

//be used to determine a cycle.

foundModule = null;

delete traced[id];

return true;

}

return (foundModule = findCycle(depMod, traced));

});

return foundModule;

}

function forceExec(mod, traced, uninited) {

var id = mod.map.id,

depArray = mod.depMaps;

if (!mod.inited || !mod.map.isDefine) {

return;

}

if (traced[id]) {

return defined[id];

}

traced[id] = mod;

each(depArray, function(depMap) {

var depId = depMap.id,

depMod = registry[depId],

value;

if (handlers[depId]) {

return;

}

if (depMod) {

if (!depMod.inited || !depMod.enabled) {

//Dependency is not inited,

//so this module cannot be

//given a forced value yet.

uninited[id] = true;

return;

}

//Get the value for the current dependency

value = forceExec(depMod, traced, uninited);

//Even with forcing it may not be done,

//in particular if the module is waiting

//on a plugin resource.

if (!uninited[depId]) {

mod.defineDepById(depId, value);

}

}

});

mod.check(true);

return defined[id];

}

function modCheck(mod) {

mod.check();

}

function checkLoaded() {

var waitInterval = config.waitSeconds * 1000,

//It is possible to disable the wait interval by using waitSeconds of 0.

expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),

noLoads = [],

stillLoading = false,

needCycleCheck = true,

map, modId, err, usingPathFallback;

//Do not bother if this call was a result of a cycle break.

if (inCheckLoaded) {

return;

}

inCheckLoaded = true;

//Figure out the state of all the modules.

eachProp(registry, function (mod) {

map = mod.map;

modId = map.id;

//Skip things that are not enabled or in error state.

if (!mod.enabled) {

return;

}

if (!mod.error) {

//If the module should be executed, and it has not

//been inited and time is up, remember it.

if (!mod.inited && expired) {

if (hasPathFallback(modId)) {

usingPathFallback = true;

stillLoading = true;

} else {

noLoads.push(modId);

removeScript(modId);

}

} else if (!mod.inited && mod.fetched && map.isDefine) {

stillLoading = true;

if (!map.prefix) {

//No reason to keep looking for unfinished

//loading. If the only stillLoading is a

//plugin resource though, keep going,

//because it may be that a plugin resource

//is waiting on a non-plugin cycle.

return (needCycleCheck = false);

}

}

}

});

if (expired && noLoads.length) {

//If wait time expired, throw error of unloaded modules.

err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);

err.contextName = context.contextName;

return onError(err);

}

//Not expired, check for a cycle.

if (needCycleCheck) {

each(waitAry, function (mod) {

if (mod.defined) {

return;

}

var cycleMod = findCycle(mod, {}),

traced = {};

if (cycleMod) {

forceExec(cycleMod, traced, {});

//traced modules may have been

//removed from the registry, but

//their listeners still need to

//be called.

eachProp(traced, modCheck);

}

});

//Now that dependencies have

//been satisfied, trigger the

//completion check that then

//notifies listeners.

eachProp(registry, modCheck);

}

//If still waiting on loads, and the waiting load is something

//other than a plugin resource, or there are still outstanding

//scripts, then just try back later.

if ((!expired || usingPathFallback) && stillLoading) {

//Something is still waiting to load. Wait for it, but only

//if a timeout is not already in effect.

if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {

checkLoadedTimeoutId = setTimeout(function () {

checkLoadedTimeoutId = 0;

checkLoaded();

}, 50);

}

}

inCheckLoaded = false;

}

Module = function (map) {

this.events = undefEvents[map.id] || {};

this.map = map;

this.shim = config.shim[map.id];

this.depExports = [];

this.depMaps = [];

this.depMatched = [];

this.pluginMaps = {};

this.depCount = 0;

/* this.exports this.factory

};

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);

});

}

each(depMaps, bind(this, function (depMap, i) {

if (typeof depMap === 'string') {

depMap = makeModuleMap(depMap,

(this.map.isDefine ? this.map : this.map.parentMap));

this.depMaps.push(depMap);

}

var handler = 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 (errback) {

on(depMap, 'error', 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();

}

},

defineDepById: function (id, depExports) {

var i;

//Find the index for this dependency.

each(this.depMaps, function (map, index) {

if (map.id === id) {

i = index;

return true;

}

});

return this.defineDep(i, depExports);

},

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 (map.prefix) {

this.callPlugin();

} else if (this.shim) {

makeRequire(this, true)(this.shim.deps || [], bind(this, function () {

this.load();

}));

} else {

//Regular dependency.

this.load();

}

},

load: function() {

var url = this.map.url;

//Regular dependency.

if (!urlFetched[url]) {

urlFetched[url] = true;

context.load(this.map.id, url);

}

},

/**

check: function (silent) {

if (!this.enabled) {

return;

}

var id = this.map.id,

depExports = this.depExports,

exports = this.exports,

factory = this.factory,

err, cjsModule;

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;