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 (hasProp(obj, 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;

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: {},

map: {},

config: {}

},

registry = {},

undefEvents = {},

defQueue = [],

defined = {},

urlFetched = {},

requireCounter = 1,

unnormalizedCounter = 1;

/**

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 (getOwn(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 = getOwn(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 = getOwn(map, baseParts.slice(0, j).join('/'));

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

//this name.

if (mapValue) {

mapValue = getOwn(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 && getOwn(starMap, nameSegment)) {

foundStarMap = getOwn(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 = getOwn(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.require.undef(id);

context.require([id]);

return true;

}

}

//Turns a plugin!resource to [plugin, resource]

//with the plugin being undefined if the name

//did not have a plugin prefix.

function splitPrefix(name) {

var prefix,

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

if (index > -1) {

prefix = name.substring(0, index);

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

}

return [prefix, name];

}

/**

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

};

}

function getModule(depMap) {

var id = depMap.id,

mod = getOwn(registry, id);

if (!mod) {

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

}

return mod;

}

function on(depMap, name, fn) {

var id = depMap.id,

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

}

}

handlers = {

'require': function (mod) {

if (mod.require) {

return mod.require;

} else {

return (mod.require = context.makeRequire(mod.map));

}

},

'exports': function (mod) {

mod.usingExports = true;

if (mod.map.isDefine) {

if (mod.exports) {

return mod.exports;

} else {

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

}

}

},

'module': function (mod) {

if (mod.module) {

return mod.module;

} else {

return (mod.module = {

id: mod.map.id,

uri: mod.map.url,

config: function () {

return (config.config && getOwn(config.config, mod.map.id)) || {};

},

exports: defined[mod.map.id]

});

}

}

};

function cleanRegistry(id) {

//Clean up machinery used for waiting modules.

delete registry[id];

}

function breakCycle(mod, traced, processed) {

var id = mod.map.id;

if (mod.error) {

mod.emit('error', mod.error);

} else {

traced[id] = true;

each(mod.depMaps, function (depMap, i) {

var depId = depMap.id,

dep = getOwn(registry, depId);

//Only force things that have not completed

//being defined, so still in the registry,

//and only if it has not been matched up

//in the module already.

if (dep && !mod.depMatched[i] && !processed[depId]) {

if (getOwn(traced, depId)) {

mod.defineDep(i, defined[depId]);

mod.check(); //pass false?

} else {

breakCycle(dep, traced, processed);

}

}

});

processed[id] = true;

}

}

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

reqCalls = [],

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

reqCalls.push(mod);

}

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(reqCalls, function (mod) {

breakCycle(mod, {}, {});

});

}

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

};

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

}

},

/**

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.

if (this.events.error) {

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.id];

err.requireType = 'define';

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

delete registry[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) {