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 === 'object' && value &&

!isArray(value) && !isFunction(value) &&

!(value instanceof RegExp)) {

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

//Defaults. Do not set a default for map

//config to speed up normalize(), which

//will run faster if there is no default.

waitSeconds: 7,

baseUrl: './',

paths: {},

bundles: {},

pkgs: {},

shim: {},

config: {}

},

registry = {},

//registry of just enabled modules, to speed

//cycle breaking code when lots of modules

//are registered, but not activated.

enabledRegistry = {},

undefEvents = {},

defQueue = [],

defined = {},

urlFetched = {},

bundlesMap = {},

requireCounter = 1,

unnormalizedCounter = 1;

/**

function trimDots(ary) {

var i, part;

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

part = ary[i];

if (part === '.') {

ary.splice(i, 1);

i -= 1;

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

// If at the start, or previous value is still ..,

// keep them so that when converted to a path it may

// still work when converted to a path, even though

// as an ID it is less than ideal. In larger point

// releases, may be better to just kick out an error.

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

continue;

} else if (i > 0) {

ary.splice(i - 1, 2);

i -= 2;

}

}

}

}

/**

function normalize(name, baseName, applyMap) {

var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,

foundMap, foundI, foundStarMap, starI, normalizedBaseParts,

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

map = config.map,

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

//Adjust any relative paths.

if (name) {

name = name.split('/');

lastIndex = name.length - 1;

// If wanting node ID compatibility, strip .js from end

// of IDs. Have to do this here, and not in nameToUrl

// because node allows either .js or non .js to map

// to same file.

if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {

name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');

}

// Starts with a '.' so need the baseName

if (name[0].charAt(0) === '.' && baseParts) {

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

}

trimDots(name);

name = name.join('/');

}

//Apply map config if available.

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

nameParts = name.split('/');

outerLoop: 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 outerLoop;

}

}

}

}

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

}

}

// If the name points to a package's name, use

// the package main instead.

pkgMain = getOwn(config.pkgs, name);

return pkgMain ? pkgMain : 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) {

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

//retry

pathConfig.shift();

context.require.undef(id);

//Custom require that does not do map translation, since

//ID is "absolute", already mapped/resolved.

context.makeRequire(null, {

skipMap: true

})([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 {

// If nested plugin references, then do not try to

// normalize, as it will not normalize correctly. This

// places a restriction on resourceIds, and the longer

// term solution is not to normalize until plugins are

// loaded and all normalizations to allow for async

// loading of a loader plugin. But for now, fixes the

// common uses. Details in #1131

normalizedName = name.indexOf('!') === -1 ?

normalize(name, parentName, applyMap) :

name;

}

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

mod = getModule(depMap);

if (mod.error && name === 'error') {

fn(mod.error);

} else {

mod.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, 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 (defined[mod.map.id] = 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 getOwn(config.config, mod.map.id) || {};

},

exports: mod.exports || (mod.exports = {})

});

}

}

};

function cleanRegistry(id) {

//Clean up machinery used for waiting modules.

delete registry[id];

delete enabledRegistry[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 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(enabledRegistry, function (mod) {

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

}

// Favor return value over exports. If node/cjs in play,

// then will not have a return value anyway. Favor

// module.exports assignment over exports object.

if (this.map.isDefine && exports === undefined) {

cjsModule = this.module;

if (cjsModule) {

exports = cjsModule.exports;

} else if (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 {