if (ary) {

var i;

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

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

break;

}

}

}

if (ary) {

var i;

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

if (ary[i] && 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 || !hasProp(target, prop)) {

if (deepStringMixin && typeof value !== 'string') {

if (!target[prop]) {

target[prop] = {};

}

mixin(target[prop], value, force, deepStringMixin);

} else {

target[prop] = value;

}

}

});

}

return target;

return function () {

return fn.apply(obj, arguments);

};

if (!value) {

return value;

}

var g = global;

each(value.split('.'), function (part) {

g = g[part];

});

return g;

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

};

each([

['toUrl'],

['undef'],

['defined', 'requireDefined'],

['specified', 'requireSpecified']

], function (item) {

var prop = item[1] || item[0];

req[item[0]] = context ? makeContextModuleFunc(context[prop], relMap) :

//If no context, then use default context. Reference from

//contexts instead of early binding to default context, so

//that during builds, the latest instance of the default

//context with its config gets used.

function () {

var ctx = contexts[defContextName];

return ctx[prop].apply(ctx, 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 inCheckLoaded, Module, context, handlers,

checkLoadedTimeoutId,

config = {

waitSeconds: 7,

baseUrl: './',

paths: {},

pkgs: {},

shim: {}

},

registry = {},

undefEvents = {},

defQueue = [],

defined = {},

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 = [];

/**

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, applyMap) {

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

foundMap, foundI, foundStarMap, starI,

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

normalizedBaseParts = baseParts,

map = config.map,

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

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

normalizedBaseParts = 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.

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

}

name = normalizedBaseParts.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 (applyMap && (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;

foundI = i;

break;

}

}

}

}

if (foundMap) {

break;

}

//Check for a star map match, but just hold on to it,

//if there is a shorter segment match later in a matching

//config, then favor over this star map.

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

foundStarMap = starMap[nameSegment];

starI = i;

}

}

if (!foundMap && foundStarMap) {

foundMap = foundStarMap;

foundI = starI;

}

if (foundMap) {

nameParts.splice(0, foundI, foundMap);

name = nameParts.join('/');

}

}

return name;

}

function removeScript(name) {

if (isBrowser) {

each(scripts(), function (scriptNode) {

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

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

scriptNode.parentNode.removeChild(scriptNode);

return true;

}

});

}

}

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, applyMap) {

var url, pluginModule, suffix,

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

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

}

if (index !== -1) {

prefix = name.substring(0, index);

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

}

if (prefix) {

prefix = normalize(prefix, parentName, applyMap);

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

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

};

}

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 (hasProp(defined, 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(defQueue,

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

globalDefQueue = [];

}

}

/**

function makeRequire(mod, enableBuildCallback, altRequire) {

var relMap = mod && mod.map,

modRequire = makeContextModuleFunc(altRequire || context.require,

relMap,

enableBuildCallback);

addRequireMethods(modRequire, context, relMap);

modRequire.isBrowser = isBrowser;

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, processed) {

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 || processed[depId] ||

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

return;

}

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

});

processed[id] = true;

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 map, modId, err, usingPathFallback,

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;

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

});

}

//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.depMaps.rjsSkipMap = depMaps.rjsSkipMap;

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

}

},

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 (this.shim) {

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

return map.prefix ? this.callPlugin() : this.load();

}));