docs/index.html
<!DOCTYPE html>
<html>
<head>
<title>fallback.js</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<meta name="viewport" content="width=device-width, target-densitydpi=160dpi, initial-scale=1.0; maximum-scale=1.0; user-scalable=0;">
<link rel="stylesheet" media="all" href="docco.css" />
</head>
<body>
<div id="container">
<div id="background"></div>
<ul class="sections">
<li id="title">
<div class="annotation">
<h1>fallback.js</h1>
</div>
</li>
<li id="section-1">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-1">¶</a>
</div>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-comment">/* fallback.js v2.0.0 | http://fallback.io/ | Salvatore Garbesi <sal@dolox.com> | (c) 2014 Dolox, Inc. */</span>
(<span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(global)</span> </span>{</pre></div></div>
</li>
<li id="section-2">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-2">¶</a>
</div>
<p>The container variable for our library instance. As you browse through the libraries code you’ll see the <code>me</code>
variable referenced throughout, this is simply short-hand for the library.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> me = {};</pre></div></div>
</li>
<li id="section-3">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-3">¶</a>
</div>
<p>Initialize our library. This function must be invoked before we start using the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.init = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-4">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-4">¶</a>
</div>
<p>Reference the <code>head</code> element of our document and store it into memory. The if statement is for test coverage.</p>
</div>
<div class="content"><div class='highlight'><pre> me.head = global.document ? global.document.getElementsByTagName(<span class="hljs-string">'head'</span>)[<span class="hljs-number">0</span>] : <span class="hljs-literal">null</span>;</pre></div></div>
</li>
<li id="section-5">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-5">¶</a>
</div>
<p>Reference aliases for the library into the <code>global</code> object for the user to directly access.</p>
</div>
<div class="content"><div class='highlight'><pre> me.alias(global, me.alias.types);</pre></div></div>
</li>
<li id="section-6">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-6">¶</a>
</div>
<p>Initialize our loader object.</p>
</div>
<div class="content"><div class='highlight'><pre> me.loader.init();
};</pre></div></div>
</li>
<li id="section-7">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-7">¶</a>
</div>
<p>Reference the library’s aliases into the <code>global</code> <code>Object</code> for the user to directly access. If a alias that we’re
attempting to reference currently exists in our <code>global</code> <code>Object</code>, then we won’t override it.</p>
</div>
<div class="content"><div class='highlight'><pre>me.alias = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(container, input)</span> </span>{</pre></div></div>
</li>
<li id="section-8">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-8">¶</a>
</div>
<p>Loop through each of our aliases.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(input, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(aliases, key)</span> </span>{</pre></div></div>
</li>
<li id="section-9">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-9">¶</a>
</div>
<p>Store the module name that we’ll reference throughout our loop.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> moduleName = key;</pre></div></div>
</li>
<li id="section-10">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-10">¶</a>
</div>
<p>Store the factory for our module that we’ll reference throughout our loop.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> factory = me;
<span class="hljs-keyword">if</span> (key === <span class="hljs-string">'me'</span>) {</pre></div></div>
</li>
<li id="section-11">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-11">¶</a>
</div>
<p>If the <code>key</code> is <code>me</code>, then we need to reference the library itself.</p>
</div>
<div class="content"><div class='highlight'><pre> moduleName = <span class="hljs-string">'fallback'</span>;
} <span class="hljs-keyword">else</span> {</pre></div></div>
</li>
<li id="section-12">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-12">¶</a>
</div>
<p>Reference the function within our library.</p>
</div>
<div class="content"><div class='highlight'><pre> factory = me[key];
}</pre></div></div>
</li>
<li id="section-13">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-13">¶</a>
</div>
<p>Define modules that reference back to the library so that they can be used within our <code>define</code> and <code>require</code>
functions. For example in a <code>define</code> <code>factory</code> we might want to access the <code>fallback</code> library, or the <code>require</code>
function, this will allow us to do that. Makes for good code encapsulation if the developer wants to take
advantage of it.</p>
</div>
<div class="content"><div class='highlight'><pre> me.define(moduleName, factory);</pre></div></div>
</li>
<li id="section-14">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-14">¶</a>
</div>
<p>Fetch the reference of our new module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> <span class="hljs-built_in">module</span> = me.module(moduleName, <span class="hljs-literal">null</span>, <span class="hljs-literal">false</span>);</pre></div></div>
</li>
<li id="section-15">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-15">¶</a>
</div>
<p>Flag our new module as invoked and loaded since it’s internal.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.invoked = <span class="hljs-built_in">module</span>.loader.loaded = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-16">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-16">¶</a>
</div>
<p>Map all of our aliases to our module.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(aliases, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(alias)</span> </span>{</pre></div></div>
</li>
<li id="section-17">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-17">¶</a>
</div>
<p>If the alias is currently defined in the <code>container</code> object, skip it and throw a warning to the end user.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(container[alias])) {
me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'core'</span>, <span class="hljs-string">'init'</span>, <span class="hljs-string">'aliases'</span>, <span class="hljs-string">'The variable container["'</span> + alias + <span class="hljs-string">'"] already exists. Overriding!'</span>);
}</pre></div></div>
</li>
<li id="section-18">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-18">¶</a>
</div>
<p>Map the alias to our module.</p>
</div>
<div class="content"><div class='highlight'><pre> me.module.alias(moduleName, alias);</pre></div></div>
</li>
<li id="section-19">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-19">¶</a>
</div>
<p>Reference the alias of the module within the <code>container</code> reference.</p>
</div>
<div class="content"><div class='highlight'><pre> container[alias] = factory;
});
});</pre></div></div>
</li>
<li id="section-20">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-20">¶</a>
</div>
<p>Reset any pending anonymous state.</p>
</div>
<div class="content"><div class='highlight'><pre> me.define.anonymous.reset();
};</pre></div></div>
</li>
<li id="section-21">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-21">¶</a>
</div>
<p>This is where we hold all of our functional aliases for the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.alias.types = {</pre></div></div>
</li>
<li id="section-22">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-22">¶</a>
</div>
<p>Referenecs for our <code>config</code> function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-string">'config'</span>: [<span class="hljs-string">'cfg'</span>, <span class="hljs-string">'conf'</span>, <span class="hljs-string">'config'</span>],</pre></div></div>
</li>
<li id="section-23">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-23">¶</a>
</div>
<p>Referenecs for our <code>define</code> function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-string">'define'</span>: [<span class="hljs-string">'def'</span>, <span class="hljs-string">'define'</span>],</pre></div></div>
</li>
<li id="section-24">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-24">¶</a>
</div>
<p>Referenecs for the library.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-string">'me'</span>: [<span class="hljs-string">'fallback'</span>, <span class="hljs-string">'fbk'</span>],</pre></div></div>
</li>
<li id="section-25">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-25">¶</a>
</div>
<p>Referenecs for our <code>require</code> function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-string">'require'</span>: [<span class="hljs-string">'req'</span>, <span class="hljs-string">'require'</span>]
};</pre></div></div>
</li>
<li id="section-26">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-26">¶</a>
</div>
<p>Fetch the parameters that are passed into a <code>Function</code> and return them in an <code>Array</code> <code>String</code> series. For example:
<code>function(a, b, c)</code> returns <code>['a', 'b', 'c']</code>. Thanks to @toddmotto who wrote the better part of this <code>Function</code>.
@reference <a href="http://toddmotto.com/angular-js-dependency-injection-annotation-process/">http://toddmotto.com/angular-js-dependency-injection-annotation-process/</a></p>
</div>
<div class="content"><div class='highlight'><pre>me.args = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(reference)</span> </span>{</pre></div></div>
</li>
<li id="section-27">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-27">¶</a>
</div>
<p>If our <code>reference</code> is not a <code>Function</code>, then halt.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isFunction(reference)) {
<span class="hljs-keyword">return</span> [];
}</pre></div></div>
</li>
<li id="section-28">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-28">¶</a>
</div>
<p>Setup our regular expressions that we’ll use to parse out the arguments of our <code>reference</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> expessions = {
arg: <span class="hljs-regexp">/^\s*(_?)(.+?)\1\s*$/</span>,
args: <span class="hljs-regexp">/^function\s*[^\(]*\(\s*([^\)]*)\)/m</span>,
argsSplit: <span class="hljs-regexp">/,/</span>,
comments: <span class="hljs-regexp">/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg</span>
};</pre></div></div>
</li>
<li id="section-29">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-29">¶</a>
</div>
<p>The <code>Array</code> of our cleansed arguments from the <code>reference</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> args = [];</pre></div></div>
</li>
<li id="section-30">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-30">¶</a>
</div>
<p>Strip out any comments that are listed in the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> name = reference.toString().replace(expessions.comments, <span class="hljs-string">''</span>);</pre></div></div>
</li>
<li id="section-31">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-31">¶</a>
</div>
<p>Explicity fetch the arguments out of the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> declaration = name.match(expessions.args);</pre></div></div>
</li>
<li id="section-32">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-32">¶</a>
</div>
<p>Split on <code>,</code> and loop through each of the arguments.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(declaration[<span class="hljs-number">1</span>].split(expessions.argsSplit), <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(arg)</span> </span>{</pre></div></div>
</li>
<li id="section-33">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-33">¶</a>
</div>
<p>Clean the dirty argument.</p>
</div>
<div class="content"><div class='highlight'><pre> arg.replace(expessions.arg, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(all, underscore, name)</span> </span>{</pre></div></div>
</li>
<li id="section-34">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-34">¶</a>
</div>
<p>Push the cleansed argument to the <code>args</code> <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> args.push(name);
});
});</pre></div></div>
</li>
<li id="section-35">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-35">¶</a>
</div>
<p>Return the cleansed <code>Array</code> of arguments from our <code>reference</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> args;
};</pre></div></div>
</li>
<li id="section-36">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-36">¶</a>
</div>
<p>Clone an array. <code>Array.prototype.slice</code> appears to be the most efficient way of doing this.
@reference <a href="http://jsperf.com/new-array-vs-splice-vs-slice/19">http://jsperf.com/new-array-vs-splice-vs-slice/19</a></p>
</div>
<div class="content"><div class='highlight'><pre>me.arrayClone = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{</pre></div></div>
</li>
<li id="section-37">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-37">¶</a>
</div>
<p>If the <code>input</code> parameter is not an <code>Array</code> or <code>Object</code>, return an empty <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(input) && !me.isObject(input) && <span class="hljs-keyword">typeof</span> input !== <span class="hljs-string">'object'</span>) {
<span class="hljs-keyword">return</span> [];
}</pre></div></div>
</li>
<li id="section-38">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-38">¶</a>
</div>
<p>Clone the Array.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-built_in">Array</span>.prototype.slice.call(input);
};</pre></div></div>
</li>
<li id="section-39">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-39">¶</a>
</div>
<p>Remove all duplicates from an array.</p>
</div>
<div class="content"><div class='highlight'><pre>me.arrayUnique = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{</pre></div></div>
</li>
<li id="section-40">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-40">¶</a>
</div>
<p>Store our normalized values.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> normalized = [];</pre></div></div>
</li>
<li id="section-41">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-41">¶</a>
</div>
<p>If an array was not passed in, halt the function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(normalized)) {
<span class="hljs-keyword">return</span> normalized;
}</pre></div></div>
</li>
<li id="section-42">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-42">¶</a>
</div>
<p>Run through each of our <code>Array</code> values.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(input, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value)</span> </span>{</pre></div></div>
</li>
<li id="section-43">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-43">¶</a>
</div>
<p>Make sure the <code>value</code> doesn’t already exist in our <code>normalized</code> <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.indexOf(normalized, value) === -<span class="hljs-number">1</span>) {</pre></div></div>
</li>
<li id="section-44">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-44">¶</a>
</div>
<p>Push our non-duplicated <code>value</code> off to our <code>normalized</code> <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> normalized.push(value);
}
});</pre></div></div>
</li>
<li id="section-45">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-45">¶</a>
</div>
<p>Return our normalized set of unique values.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> normalized;
};</pre></div></div>
</li>
<li id="section-46">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-46">¶</a>
</div>
<p>Shorthand for a <code>for in</code> loop. Less code, easier readability. If <code>false</code> is returned, the loop will be halted.</p>
</div>
<div class="content"><div class='highlight'><pre>me.each = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input, callback)</span> </span>{</pre></div></div>
</li>
<li id="section-47">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-47">¶</a>
</div>
<p>If anything other than an <code>Array</code> or <code>Object</code> was passed in, halt the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(input) && !me.isObject(input) && <span class="hljs-keyword">typeof</span> input !== <span class="hljs-string">'object'</span>) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-48">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-48">¶</a>
</div>
<p>Normalize our callback to a <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> callback = me.normalizeFunction(callback);</pre></div></div>
</li>
<li id="section-49">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-49">¶</a>
</div>
<p>Run our loop.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index <span class="hljs-keyword">in</span> input) {</pre></div></div>
</li>
<li id="section-50">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-50">¶</a>
</div>
<p>If a <code>false</code> is returned during the loop, then halt the loo!.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (callback(input[index], index) === <span class="hljs-literal">false</span>) {
<span class="hljs-keyword">break</span>;
}
}
};</pre></div></div>
</li>
<li id="section-51">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-51">¶</a>
</div>
<p>The ability to fetch the decendant property of an object, even if it’s in dot notation.</p>
</div>
<div class="content"><div class='highlight'><pre>me.getProperty = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(reference, property)</span> </span>{
<span class="hljs-keyword">var</span> properties = property.split(<span class="hljs-string">'.'</span>);
<span class="hljs-keyword">while</span> (properties.length) {
reference = reference[properties.shift()];
}
<span class="hljs-keyword">return</span> reference;
};</pre></div></div>
</li>
<li id="section-52">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-52">¶</a>
</div>
<p>Legacy browsers don’t support <code>Array.prototype.indexOf</code>, this function dubs as a polyfill for this browsers. In
particular IE < 9, doesn’t support it. @ie @ie6 @ie7 @ie8
@reference <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf</a></p>
</div>
<div class="content"><div class='highlight'><pre>me.indexOf = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input, value)</span> </span>{</pre></div></div>
</li>
<li id="section-53">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-53">¶</a>
</div>
<p>By default we’ll return <code>-1</code> if nothing is found to simulate the native <code>indexOf</code> functionality.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> index = -<span class="hljs-number">1</span>;</pre></div></div>
</li>
<li id="section-54">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-54">¶</a>
</div>
<p>If our <code>input</code> is not an <code>Array</code>, or our <code>value is not a</code>String<code>or</code>Number<code>, halt the</code>Function`.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(input) || !me.isString(value) && !me.isNumber(value)) {
<span class="hljs-keyword">return</span> index;
}</pre></div></div>
</li>
<li id="section-55">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-55">¶</a>
</div>
<p>Search through our <code>Array</code> for our <code>value</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(input, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(iterationValue, iterationIndex)</span> </span>{</pre></div></div>
</li>
<li id="section-56">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-56">¶</a>
</div>
<p>As soon as we find our first value, halt the loop.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (iterationValue === value) {</pre></div></div>
</li>
<li id="section-57">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-57">¶</a>
</div>
<p>Set the index of our result.</p>
</div>
<div class="content"><div class='highlight'><pre> index = <span class="hljs-built_in">parseInt</span>(iterationIndex, <span class="hljs-number">10</span>);</pre></div></div>
</li>
<li id="section-58">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-58">¶</a>
</div>
<p>Halt the loop.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}
});</pre></div></div>
</li>
<li id="section-59">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-59">¶</a>
</div>
<p>Return the index of our <code>value</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> index;
};</pre></div></div>
</li>
<li id="section-60">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-60">¶</a>
</div>
<p>Check whether or not a variable is defined.</p>
</div>
<div class="content"><div class='highlight'><pre>me.isDefined = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(variable)</span> </span>{
<span class="hljs-keyword">return</span> variable !== <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>;
};</pre></div></div>
</li>
<li id="section-61">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-61">¶</a>
</div>
<p>Check a <code>String</code> to see if it contains a prefix.</p>
</div>
<div class="content"><div class='highlight'><pre>me.isPrefixed = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(reference, prefixes)</span> </span>{</pre></div></div>
</li>
<li id="section-62">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-62">¶</a>
</div>
<p>Flag whether or not a URL should be ignore from being prepended with the base URL.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> isPrefixed = <span class="hljs-literal">false</span>;</pre></div></div>
</li>
<li id="section-63">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-63">¶</a>
</div>
<p>Loop through our ignore list.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(prefixes, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(prefix)</span> </span>{</pre></div></div>
</li>
<li id="section-64">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-64">¶</a>
</div>
<p>Check to see if the prefix of our URL has a match in our ignore list.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (reference.substr(<span class="hljs-number">0</span>, prefix.length) === prefix) {</pre></div></div>
</li>
<li id="section-65">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-65">¶</a>
</div>
<p>Flag the URL as ignored.</p>
</div>
<div class="content"><div class='highlight'><pre> isPrefixed = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-66">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-66">¶</a>
</div>
<p>Halt the loop.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}
});</pre></div></div>
</li>
<li id="section-67">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-67">¶</a>
</div>
<p>Return whether or not we found a match.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> isPrefixed;
};</pre></div></div>
</li>
<li id="section-68">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-68">¶</a>
</div>
<p>Check if a variable is a specific type.</p>
</div>
<div class="content"><div class='highlight'><pre>me.isType = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(variable, type)</span> </span>{</pre></div></div>
</li>
<li id="section-69">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-69">¶</a>
</div>
<p>Special check for <code>null</code> for legacy browsers. @ie</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (type === <span class="hljs-string">'Object'</span> && variable === <span class="hljs-literal">null</span>) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}</pre></div></div>
</li>
<li id="section-70">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-70">¶</a>
</div>
<p>Special check for <code>undefined</code> for legacy browsers. @ie</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isDefined(variable)) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}</pre></div></div>
</li>
<li id="section-71">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-71">¶</a>
</div>
<p>Run our global check.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> valid = <span class="hljs-built_in">Object</span>.prototype.toString.call(variable) === <span class="hljs-string">'[object '</span> + type + <span class="hljs-string">']'</span>;</pre></div></div>
</li>
<li id="section-72">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-72">¶</a>
</div>
<p>Newer browsers give the proper types for these, whereas legacy browsers don’t. Instead of writing separate
functions and test for each, we can simply accept them all as being an object.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (valid === <span class="hljs-literal">false</span> && (type === <span class="hljs-string">'HTMLCollection'</span> || type === <span class="hljs-string">'HTMLHeadElement'</span> || type === <span class="hljs-string">'HTMLScriptElement'</span>)) {</pre></div></div>
</li>
<li id="section-73">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-73">¶</a>
</div>
<p>Special patch for Safari. @safari</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (type === <span class="hljs-string">'HTMLCollection'</span>) {
valid = me.isType(variable, <span class="hljs-string">'NodeList'</span>);
}</pre></div></div>
</li>
<li id="section-74">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-74">¶</a>
</div>
<p>Fallback on an <code>Object</code> for legacy browsers.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!valid) {
valid = me.isType(variable, <span class="hljs-string">'Object'</span>);
}
}</pre></div></div>
</li>
<li id="section-75">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-75">¶</a>
</div>
<p>Return whether or not our type is valid.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> valid;
};</pre></div></div>
</li>
<li id="section-76">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-76">¶</a>
</div>
<p>Constrain an object to only contain a specific set of keys. All other keys are discarded, and a warning is thrown.</p>
</div>
<div class="content"><div class='highlight'><pre>me.objectConstrain = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input, whitelist, reference)</span> </span>{</pre></div></div>
</li>
<li id="section-77">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-77">¶</a>
</div>
<p>Store our normalized <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> normalized = {};</pre></div></div>
</li>
<li id="section-78">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-78">¶</a>
</div>
<p>If our <code>input</code> is not an <code>Object</code> return an empty <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(input)) {
<span class="hljs-keyword">return</span> normalized;
}</pre></div></div>
</li>
<li id="section-79">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-79">¶</a>
</div>
<p>If we don’t have a <code>whitelist</code> or if it’s not an <code>Array</code>, return our <code>input</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(whitelist)) {
<span class="hljs-keyword">return</span> input;
}</pre></div></div>
</li>
<li id="section-80">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-80">¶</a>
</div>
<p>Loop through our <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(input, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, key)</span> </span>{</pre></div></div>
</li>
<li id="section-81">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-81">¶</a>
</div>
<p>If the <code>key</code> is not defined in the <code>whitelist</code>, then discard it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.indexOf(whitelist, key) === -<span class="hljs-number">1</span>) {</pre></div></div>
</li>
<li id="section-82">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-82">¶</a>
</div>
<p>Throw a warning to the user that we’ve discarded the <code>key</code> in question.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (reference) {
me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'core'</span>, <span class="hljs-string">'objectConstrain'</span>, <span class="hljs-string">'The key `'</span> + key + <span class="hljs-string">'` is not allowed in `'</span> + reference + <span class="hljs-string">'`, discarding.'</span>, input);
}
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-83">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-83">¶</a>
</div>
<p>Set our normalized value.</p>
</div>
<div class="content"><div class='highlight'><pre> normalized[key] = value;
});</pre></div></div>
</li>
<li id="section-84">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-84">¶</a>
</div>
<p>Return our normalized <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> normalized;
};</pre></div></div>
</li>
<li id="section-85">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-85">¶</a>
</div>
<p>Merge an <code>Object</code> with a set of default values. If the <code>defaults</code> parameter is an <code>Array</code>, it will treat whatever
the value is for <code>fallback</code> as it’s value.</p>
</div>
<div class="content"><div class='highlight'><pre>me.objectMerge = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input, defaults, fallback)</span> </span>{</pre></div></div>
</li>
<li id="section-86">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-86">¶</a>
</div>
<p>Our normalized/merged <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> normalized = {};</pre></div></div>
</li>
<li id="section-87">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-87">¶</a>
</div>
<p>If our <code>input</code> is not an <code>Object</code> return an empty <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(input)) {
<span class="hljs-keyword">return</span> normalized;
}</pre></div></div>
</li>
<li id="section-88">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-88">¶</a>
</div>
<p>The defaults to merge with.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> defaultsIsArray = me.isaArray(defaults);</pre></div></div>
</li>
<li id="section-89">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-89">¶</a>
</div>
<p>If our defaults isn’t an Array or Object, then return our <code>input</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(defaults) && !defaultsIsArray) {
<span class="hljs-keyword">return</span> input;
}</pre></div></div>
</li>
<li id="section-90">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-90">¶</a>
</div>
<p>Loop through our defaults.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(defaults, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, key)</span> </span>{</pre></div></div>
</li>
<li id="section-91">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-91">¶</a>
</div>
<p>If our <code>defaults</code> is an <code>Array</code> we need to swap out the key/values.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (defaultsIsArray === <span class="hljs-literal">true</span>) {
key = value;
value = fallback;
}</pre></div></div>
</li>
<li id="section-92">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-92">¶</a>
</div>
<p>If the <code>key</code> is defined in our <code>input</code> object, then don’t override it, reference it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(input[key])) {
normalized[key] = input[key];
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-93">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-93">¶</a>
</div>
<p>Set the value of our default <code>key</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> normalized[key] = value;
});</pre></div></div>
</li>
<li id="section-94">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-94">¶</a>
</div>
<p>Return our merged <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> normalized;
};</pre></div></div>
</li>
<li id="section-95">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-95">¶</a>
</div>
<p>A function which simply pads a <code>String</code> with whatever <code>String</code> is supplied.</p>
</div>
<div class="content"><div class='highlight'><pre>me.stringPad = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input, pad, left)</span> </span>{
<span class="hljs-keyword">if</span> (!me.isDefined(pad)) {
<span class="hljs-keyword">return</span> input;
}
<span class="hljs-keyword">if</span> (left) {
<span class="hljs-keyword">return</span> (pad + input).slice(-pad.length);
}
<span class="hljs-keyword">return</span> (input + pad).substr(<span class="hljs-number">0</span>, pad.length);
};</pre></div></div>
</li>
<li id="section-96">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-96">¶</a>
</div>
<p>Common functionality for both the <code>define</code> and <code>require</code> <code>Functions</code>.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> amd = {};</pre></div></div>
</li>
<li id="section-97">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-97">¶</a>
</div>
<p>Route and normalize the arguments.</p>
</div>
<div class="content"><div class='highlight'><pre>amd.args = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, router, normalizer, payload)</span> </span>{</pre></div></div>
</li>
<li id="section-98">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-98">¶</a>
</div>
<p>Convert our <code>arguments</code> into an <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> args = me.arrayClone(args);</pre></div></div>
</li>
<li id="section-99">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-99">¶</a>
</div>
<p>Route the arguments.</p>
</div>
<div class="content"><div class='highlight'><pre> args = amd.router(args, router, <span class="hljs-number">3</span>, payload);</pre></div></div>
</li>
<li id="section-100">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-100">¶</a>
</div>
<p>Return back our normalized arguments.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> normalizer(args);
};</pre></div></div>
</li>
<li id="section-101">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-101">¶</a>
</div>
<p>Route a set of arguments.</p>
</div>
<div class="content"><div class='highlight'><pre>amd.router = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, router, maxlength, payload)</span> </span>{</pre></div></div>
</li>
<li id="section-102">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-102">¶</a>
</div>
<p>Determine the router <code>Function</code> that we need to invoke.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> reference = args.length > maxlength ? maxlength : args.length;</pre></div></div>
</li>
<li id="section-103">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-103">¶</a>
</div>
<p>Invoke the router <code>Function</code> with the arguments and payload.</p>
</div>
<div class="content"><div class='highlight'><pre> payload = router[reference](args, payload);</pre></div></div>
</li>
<li id="section-104">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-104">¶</a>
</div>
<p>If we need to derive the <code>dependencies</code> from the <code>factory</code> <code>Function</code>, then do so now.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isString(payload.deps) && !me.isaArray(payload.deps) && me.isFunction(payload.factory)) {
payload.deps = me.args(payload.factory);
}</pre></div></div>
</li>
<li id="section-105">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-105">¶</a>
</div>
<p>Return our factored payload.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-106">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-106">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.amd = amd;</pre></div></div>
</li>
<li id="section-107">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-107">¶</a>
</div>
<p>All of our browser detection functions reside here. Some browsers have special edge cases that we need to cater to,
and that’s the sole purpose of these functions.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> browser = {};</pre></div></div>
</li>
<li id="section-108">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-108">¶</a>
</div>
<p>Detect whether or not the current browser is IE.</p>
</div>
<div class="content"><div class='highlight'><pre>browser.isIE = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
<span class="hljs-keyword">return</span> global.document.documentMode ? <span class="hljs-literal">true</span> : <span class="hljs-literal">false</span>;
};</pre></div></div>
</li>
<li id="section-109">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-109">¶</a>
</div>
<p>Detect whether or not the current browser is IE11.</p>
</div>
<div class="content"><div class='highlight'><pre>browser.isIE11 = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
<span class="hljs-keyword">return</span> <span class="hljs-built_in">Object</span>.hasOwnProperty.call(global, <span class="hljs-string">'ActiveXObject'</span>) && !global.ActiveXObject;
};</pre></div></div>
</li>
<li id="section-110">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-110">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.browser = browser;</pre></div></div>
</li>
<li id="section-111">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-111">¶</a>
</div>
<p>Configure the library. If the <code>input</code> is malformed then the <code>Function</code> will return <code>false</code>, otherwise the <code>Function</code>
will return the normalized value that was imported.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> config = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{</pre></div></div>
</li>
<li id="section-112">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-112">¶</a>
</div>
<p>If the <code>input</code> parameter is not an <code>Object</code>, then halt the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(input)) {
me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'config'</span>, <span class="hljs-string">'Couldn\'t import config. The `input` must be an Object!'</span>, input);
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}</pre></div></div>
</li>
<li id="section-113">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-113">¶</a>
</div>
<p>Drop off any values in the user configuration <code>Object</code> which aren’t whitelisted.</p>
</div>
<div class="content"><div class='highlight'><pre> input = me.objectConstrain(input, config.whitelist, <span class="hljs-string">'fallback.config'</span>);</pre></div></div>
</li>
<li id="section-114">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-114">¶</a>
</div>
<p>Merge in the whitelist with a <code>null</code> value for default, if not specified by the user.</p>
</div>
<div class="content"><div class='highlight'><pre> input = me.objectMerge(input, config.whitelist);</pre></div></div>
</li>
<li id="section-115">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-115">¶</a>
</div>
<p>Loop through each of the keys for our <code>input</code> and run our normalization/import functions on each of them.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(input, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, key)</span> </span>{</pre></div></div>
</li>
<li id="section-116">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-116">¶</a>
</div>
<p>Only accept the <code>value</code> if it’s actually defined, otherwise we’ll wind up overriding our existing configuration
unintentionally with <code>undefined</code> values.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(value)) {
config.settings[key] = input[key] = config[key](value);
}
});</pre></div></div>
</li>
<li id="section-117">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-117">¶</a>
</div>
<p>If <code>amd</code> is set to <code>true</code>, then set <code>define.amd</code> to an <code>Object</code>, otherwise force it to <code>undefined</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(config.settings.amd) && config.settings.amd === <span class="hljs-literal">true</span>) {
me.define.amd = {};
} <span class="hljs-keyword">else</span> {
me.define.amd = <span class="hljs-literal">undefined</span>;
}</pre></div></div>
</li>
<li id="section-118">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-118">¶</a>
</div>
<p>Return our normalized configuration.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> input;
};</pre></div></div>
</li>
<li id="section-119">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-119">¶</a>
</div>
<p>Normalize and import the configuration for our <code>base</code> parameter. If a <code>String</code> is passed in, then the value for the
<code>String</code> will be used for all of the loader types.</p>
</div>
<div class="content"><div class='highlight'><pre>config.base = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{</pre></div></div>
</li>
<li id="section-120">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-120">¶</a>
</div>
<p>We expect the <code>base</code> parameter to be either a <code>String</code> or <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isString(input) && !me.isObject(input)) {
me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'config'</span>, <span class="hljs-string">'The `value` passed in your `config` for `base` was malformed, discarding.'</span>, input);
<span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
}</pre></div></div>
</li>
<li id="section-121">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-121">¶</a>
</div>
<p>If we have a <code>String</code>, generate an object with out whitelist of keys, and use the <code>String</code> as the value.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isString(input)) {
<span class="hljs-keyword">return</span> input;
}</pre></div></div>
</li>
<li id="section-122">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-122">¶</a>
</div>
<p>If we received an <code>Object</code>, then merge in our defaults with a <code>null</code> value if they weren’t specified.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> normalized = me.objectMerge(input, config.base.whitelist, <span class="hljs-literal">null</span>);</pre></div></div>
</li>
<li id="section-123">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-123">¶</a>
</div>
<p>If the values for the normalized <code>Object</code> aren’t a <code>String</code>, then revert to <code>null</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(normalized, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, key)</span> </span>{
<span class="hljs-keyword">if</span> (!me.isString(value)) {
normalized[key] = <span class="hljs-literal">null</span>;
}
});</pre></div></div>
</li>
<li id="section-124">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-124">¶</a>
</div>
<p>Return our normalized <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> normalized;
};</pre></div></div>
</li>
<li id="section-125">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-125">¶</a>
</div>
<p>The whitelist of acceptable keys for <code>base</code> parameter if it’s an <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>config.base.whitelist = [<span class="hljs-string">'css'</span>, <span class="hljs-string">'img'</span>, <span class="hljs-string">'js'</span>];</pre></div></div>
</li>
<li id="section-126">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-126">¶</a>
</div>
<p>The <code>debug</code> parameter can have a various set of values, this <code>Function</code> will normalize its value.</p>
</div>
<div class="content"><div class='highlight'><pre>config.debug = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{</pre></div></div>
</li>
<li id="section-127">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-127">¶</a>
</div>
<p>If the <code>input</code> is a <code>String</code>, and it’s in our whitelist, then accept it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isString(input) && me.indexOf(config.debug.whitelist, input) !== -<span class="hljs-number">1</span>) {
<span class="hljs-keyword">return</span> input;
}</pre></div></div>
</li>
<li id="section-128">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-128">¶</a>
</div>
<p>Force the <code>input</code> to a <code>Boolean</code> and default it to <code>false</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> me.normalizeBoolean(input, <span class="hljs-literal">false</span>);
};</pre></div></div>
</li>
<li id="section-129">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-129">¶</a>
</div>
<p>Whitelisted values for our <code>debug</code> parameter.</p>
</div>
<div class="content"><div class='highlight'><pre>config.debug.whitelist = [<span class="hljs-literal">false</span>, <span class="hljs-literal">true</span>, <span class="hljs-string">'error'</span>, <span class="hljs-string">'warn'</span>, <span class="hljs-string">'info'</span>];</pre></div></div>
</li>
<li id="section-130">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-130">¶</a>
</div>
<p>The character to split our module names on to derive it’s identity. The value must always be a <code>String</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>config.delimiter = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{
<span class="hljs-keyword">return</span> me.normalizeString(input, <span class="hljs-string">'$'</span>);
};</pre></div></div>
</li>
<li id="section-131">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-131">¶</a>
</div>
<p>Normalize and import the <code>libs</code> parameter’s series of <code>Objects</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>config.libs = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{</pre></div></div>
</li>
<li id="section-132">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-132">¶</a>
</div>
<p>If the <code>libs</code> parameter isn’t an <code>Object</code>, discard it and throw a warning to the end user.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(input)) {
me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'config'</span>, <span class="hljs-string">'The `libs` parameter in your `config` was malformed, discarding.'</span>, input);
<span class="hljs-keyword">return</span> {};
}</pre></div></div>
</li>
<li id="section-133">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-133">¶</a>
</div>
<p>The <code>normalized</code> value of our <code>input</code> parameter.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> normalized = {};</pre></div></div>
</li>
<li id="section-134">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-134">¶</a>
</div>
<p>Loop through our series of <code>Objects</code> for the <code>libs</code> parameter.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(input, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, key)</span> </span>{</pre></div></div>
</li>
<li id="section-135">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-135">¶</a>
</div>
<p>Normalize the value.</p>
</div>
<div class="content"><div class='highlight'><pre> value = config.libs.value(value);</pre></div></div>
</li>
<li id="section-136">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-136">¶</a>
</div>
<p>If our value is not an <code>Object</code> then the value is malformed, discard it and throw a warning to the end user.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(value)) {
me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'config'</span>, <span class="hljs-string">'libs'</span>, <span class="hljs-string">'value'</span>, <span class="hljs-string">'The `urls` in your `config` was malformed for `'</span> + key + <span class="hljs-string">'`, discarding.'</span>, value);
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-137">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-137">¶</a>
</div>
<p>Populate our <code>normalized</code> <code>Object</code> with a normalized value.</p>
</div>
<div class="content"><div class='highlight'><pre> normalized = config.libs.populate(normalized, key, value);</pre></div></div>
</li>
<li id="section-138">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-138">¶</a>
</div>
<p>Generate a module for this library.</p>
</div>
<div class="content"><div class='highlight'><pre> me.module(key, normalized[key]);
});</pre></div></div>
</li>
<li id="section-139">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-139">¶</a>
</div>
<p>Return our noramlized <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> normalized;
};</pre></div></div>
</li>
<li id="section-140">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-140">¶</a>
</div>
<p>Each of these functions expect to have values that’s a <code>Boolean</code>. If this isn’t the case, then a value of <code>false</code>
will be set as the value.</p>
</div>
<div class="content"><div class='highlight'><pre>config.libs.amd =
config.amd =
config.globals = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{
<span class="hljs-keyword">return</span> me.normalizeBoolean(input, <span class="hljs-literal">false</span>);
};</pre></div></div>
</li>
<li id="section-141">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-141">¶</a>
</div>
<p>Normalize the <code>value</code> parameter and populate it within the <code>normalized</code> <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>config.libs.populate = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(normalized, key, value)</span> </span>{</pre></div></div>
</li>
<li id="section-142">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-142">¶</a>
</div>
<p>If the <code>normalized</code> parameter isn’t an <code>Object</code>, or the <code>key</code> parameter isn’t a string, then halt the function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(normalized) || !me.isString(key)) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
}</pre></div></div>
</li>
<li id="section-143">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-143">¶</a>
</div>
<p>Reference our whitelist.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> whitelist = config.libs.whitelist;</pre></div></div>
</li>
<li id="section-144">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-144">¶</a>
</div>
<p>Constrain the keys of this object to our whitelist.</p>
</div>
<div class="content"><div class='highlight'><pre> value = me.objectConstrain(value, whitelist, <span class="hljs-string">'fallback.config'</span>);</pre></div></div>
</li>
<li id="section-145">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-145">¶</a>
</div>
<p>Merge in our defaults to fill in whatever keys are missing.</p>
</div>
<div class="content"><div class='highlight'><pre> value = me.objectMerge(value, whitelist);</pre></div></div>
</li>
<li id="section-146">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-146">¶</a>
</div>
<p>Loop through and normalize each of the values for our <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(value, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(subValue, subKey)</span> </span>{</pre></div></div>
</li>
<li id="section-147">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-147">¶</a>
</div>
<p>If <code>exports</code> is <code>undefined</code>, then use the <code>moduleName</code> as the <code>exports</code>. @todo this doesn’t need to be in a loop.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (subKey === <span class="hljs-string">'exports'</span> && !me.isDefined(subValue)) {
subValue = [key];
}</pre></div></div>
</li>
<li id="section-148">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-148">¶</a>
</div>
<p>If the <code>subKey</code> isn’t a function, discard the normalization process for the iteration.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isFunction(config.libs[subKey])) {
<span class="hljs-keyword">return</span>;
}
value[subKey] = config.libs[subKey](subValue, key);
});</pre></div></div>
</li>
<li id="section-149">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-149">¶</a>
</div>
<p>Set our normalize value up for return.</p>
</div>
<div class="content"><div class='highlight'><pre> normalized[key] = value;</pre></div></div>
</li>
<li id="section-150">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-150">¶</a>
</div>
<p>Return our populated normalized <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> normalized;
};</pre></div></div>
</li>
<li id="section-151">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-151">¶</a>
</div>
<p>Normalize the value for an iteration of <code>libs</code> <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>config.libs.value = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value)</span> </span>{</pre></div></div>
</li>
<li id="section-152">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-152">¶</a>
</div>
<p>If the value is a <code>String</code>, convert it to an <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isString(value)) {
value = [value];
}</pre></div></div>
</li>
<li id="section-153">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-153">¶</a>
</div>
<p>If the value is an <code>Array</code>, convert it to an <code>Object</code> where the parameter <code>urls</code> is the value.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isaArray(value)) {
value = {
urls: value
};
}</pre></div></div>
</li>
<li id="section-154">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-154">¶</a>
</div>
<p>If we don’t have an <code>Object</code> at this point, return an empty <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(value)) {
<span class="hljs-keyword">return</span> {};
}</pre></div></div>
</li>
<li id="section-155">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-155">¶</a>
</div>
<p>Normalized the URL values as string series.</p>
</div>
<div class="content"><div class='highlight'><pre> value.urls = me.normalizeStringSeries(value.urls, <span class="hljs-literal">null</span>, <span class="hljs-literal">true</span>);</pre></div></div>
</li>
<li id="section-156">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-156">¶</a>
</div>
<p>Return our normalized value.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> value;
};</pre></div></div>
</li>
<li id="section-157">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-157">¶</a>
</div>
<p>Each of these functions expect to have values that are either a <code>String</code> or series of strings. If neither is the
case, then an empty <code>Array</code> will be returned. If any non-string values are apart of the series, they’ll be dropped
from the series completely.</p>
</div>
<div class="content"><div class='highlight'><pre>config.libs.alias =
config.libs.deps =
config.libs.exports =
config.libs.urls = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{
<span class="hljs-keyword">return</span> me.normalizeStringSeries(input, <span class="hljs-literal">null</span>, <span class="hljs-literal">true</span>);
};</pre></div></div>
</li>
<li id="section-158">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-158">¶</a>
</div>
<p>If either <code>check</code> or <code>init is specified within the</code>libs<code>`Object</code>, then they must be a function or they’ll be
discarded.</p>
</div>
<div class="content"><div class='highlight'><pre>config.libs.check =
config.libs.init = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{
<span class="hljs-keyword">if</span> (!input || !me.isFunction(input)) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
}
<span class="hljs-keyword">return</span> input;
};</pre></div></div>
</li>
<li id="section-159">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-159">¶</a>
</div>
<p>Normalize the version number if it’s passed in with the library’s configuration. We have to force the value to a
<code>String</code> due to version numbers showing up such as <code>1.0.1</code> which JavaScript doesn’t support as a valid <code>Number</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>config.libs.version = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input)</span> </span>{
<span class="hljs-keyword">return</span> me.normalizeString(input, <span class="hljs-literal">null</span>);
};</pre></div></div>
</li>
<li id="section-160">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-160">¶</a>
</div>
<p>The whitelist of acceptable keys for an <code>Object</code> in the <code>libs</code> parameter.</p>
</div>
<div class="content"><div class='highlight'><pre>config.libs.whitelist = [<span class="hljs-string">'alias'</span>, <span class="hljs-string">'amd'</span>, <span class="hljs-string">'check'</span>, <span class="hljs-string">'deps'</span>, <span class="hljs-string">'init'</span>, <span class="hljs-string">'exports'</span>, <span class="hljs-string">'urls'</span>, <span class="hljs-string">'version'</span>];</pre></div></div>
</li>
<li id="section-161">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-161">¶</a>
</div>
<p>The <code>Object</code> that’ll retain the configuration.</p>
</div>
<div class="content"><div class='highlight'><pre>config.settings = {};</pre></div></div>
</li>
<li id="section-162">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-162">¶</a>
</div>
<p>The character to split our module names on to derive it’s identity.</p>
</div>
<div class="content"><div class='highlight'><pre>config.settings.delimiter = <span class="hljs-string">'$'</span>;</pre></div></div>
</li>
<li id="section-163">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-163">¶</a>
</div>
<p>Whether or not to use a reference to <code>window</code> to check if a library has already been loaded. This is also used when
loading libraries to determine if they loaded properly for legacy browsers.</p>
</div>
<div class="content"><div class='highlight'><pre>config.settings.globals = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-164">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-164">¶</a>
</div>
<p>The whitelist of acceptable keys for the <code>config</code> functions input <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>config.whitelist = [<span class="hljs-string">'amd'</span>, <span class="hljs-string">'base'</span>, <span class="hljs-string">'debug'</span>, <span class="hljs-string">'delimiter'</span>, <span class="hljs-string">'globals'</span>, <span class="hljs-string">'libs'</span>];</pre></div></div>
</li>
<li id="section-165">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-165">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.config = config;</pre></div></div>
</li>
<li id="section-166">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-166">¶</a>
</div>
<p>Defining anonymous and named modules for our library is done through this function. There are a number of ways to
pass arguments into this function, for more details see comments in the <code>define.args</code> function.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-comment">/* eslint-disable*/</span>
<span class="hljs-keyword">var</span> define = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
<span class="hljs-comment">/* eslint-enable*/</span></pre></div></div>
</li>
<li id="section-167">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-167">¶</a>
</div>
<p>Fetch and normalize the argument that were passed in.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> args = me.amd.args(<span class="hljs-built_in">arguments</span>, define.args.router, define.args.normalize, {
name: <span class="hljs-literal">null</span>,
error: <span class="hljs-literal">null</span>,
deps: <span class="hljs-literal">null</span>,
factory: <span class="hljs-literal">undefined</span>
});</pre></div></div>
</li>
<li id="section-168">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-168">¶</a>
</div>
<p>Fill up our dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> args = define.deps(args);</pre></div></div>
</li>
<li id="section-169">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-169">¶</a>
</div>
<p>If we’re attempting to define an anonymous module, and we already have an anonymous module that was previously
passed to the function before we had a chance to actually declare it’s name, then there was 2 anonymous modules
which were passed in through a single file. We cannot due this due to the fact that we have no way of knowing which
name should be assigned to which <code>define</code> instance that was called. If we did allow this to go through, we would
essentially be overwriting our previous anonymous module. If this happens we’ll simply halt the function and a
throw a notice to our end user.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!args.name) {</pre></div></div>
</li>
<li id="section-170">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-170">¶</a>
</div>
<p>We cannot define multiple anonymous modules with the same name!</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (define.anonymous.pending) {
me.log(<span class="hljs-number">1</span>, <span class="hljs-string">'define'</span>, <span class="hljs-string">'Multiple Anonymous modules defined in the same file! Halting!'</span>, args);
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-171">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-171">¶</a>
</div>
<p>If we don’t have a name for our module, then we’ll define it as an anonymous module. Our callback that loaded our
file will see this and set the proper name once the callback executes, which will happen synchronously.</p>
</div>
<div class="content"><div class='highlight'><pre> define.anonymous.save(args);
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-172">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-172">¶</a>
</div>
<p>Generate our new module and reference it as our last defined module.</p>
</div>
<div class="content"><div class='highlight'><pre> define.module.last = define.module(args);</pre></div></div>
</li>
<li id="section-173">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-173">¶</a>
</div>
<p>Flag the anonymous modules as not pending.</p>
</div>
<div class="content"><div class='highlight'><pre> define.anonymous.pending = <span class="hljs-literal">false</span>;
};</pre></div></div>
</li>
<li id="section-174">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-174">¶</a>
</div>
<p>Whether or not to enforce the use of AMD. If this setting it turned on via the <code>config</code> <code>Function</code>, any library that
supports AMD will not longer be available via the <code>window</code> <code>global</code>. See documentation for further details.</p>
</div>
<div class="content"><div class='highlight'><pre>define.amd = <span class="hljs-literal">undefined</span>;</pre></div></div>
</li>
<li id="section-175">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-175">¶</a>
</div>
<p>If a module is sitting in an anonymous state and waiting to be imported properly, this <code>Function</code> will take the
<code>dependencies</code> and <code>factory</code> from that anonymous module, import them in to our properly named module, and then
destroy the anonymous module sitting in a limbo state. Here’s how this system of defining anonymous modules works:
If we attempt to load a module via our <code>require</code> function, and that module doesn’t happen to exist in our
configuration, we’ll automatically spawn a new anonymous module for it. Once the file for the module has loaded, if
the file contains an anonymous <code>define</code> call, we’ll then store it in a limbo state with it’s <code>factory</code> and
<code>dependencies</code>. The issue is that the <code>define</code> function will be invoked before the <code>onload</code> callback from our
script file that was loaded for our module, so we have to store it in a limbo state, and then after the callback
executes, we then look to see if an anonymous module is waiting to be defined, if so, we then define it whatever
anonymous module that’s sitting in a limbo state with the name of the module that was given from our callback. If
our callback provides a <code>define</code> function with a name, any anonymous modules sitting in a limbo state will be wiped
out completely.</p>
</div>
<div class="content"><div class='highlight'><pre>define.anonymous = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName)</span> </span>{</pre></div></div>
</li>
<li id="section-176">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-176">¶</a>
</div>
<p>If we don’t have a anonymous module waiting to be defined, then halt the function. We should at the very least have
either a <code>factory</code> or reference to the last defined module (which in this case would be our anonymous module
without a name).</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!define.anonymous.pending && !define.module.last) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-177">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-177">¶</a>
</div>
<p>Fetch the instance of our module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> <span class="hljs-built_in">module</span> = me.module(moduleName, <span class="hljs-literal">null</span>, <span class="hljs-literal">false</span>);</pre></div></div>
</li>
<li id="section-178">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-178">¶</a>
</div>
<p>If we couldn’t find our module, then something went wrong. Let the end user know and halt the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!<span class="hljs-built_in">module</span>) {
me.log(<span class="hljs-number">1</span>, <span class="hljs-string">'define'</span>, <span class="hljs-string">'anonymous'</span>, <span class="hljs-string">'Anonymous module not found for `'</span> + moduleName + <span class="hljs-string">'`! Halting definition!'</span>);
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-179">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-179">¶</a>
</div>
<p>If our module already exists and there’s a module that’s set as our last defined, then a file was loaded which the
library assumed was anonymous, but wound up being explicitly calling the <code>define</code> <code>Function</code> with a <code>name</code>. In this
particular case, we’ll destroy the new definition and instead alias it with our anonymous module. The point in
doing this is so that we only maintain a single reference. If we maintain multiple references there’s a possibility
of each of the references becoming out of sync.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">module</span> && define.module.last && define.module.last.name !== <span class="hljs-built_in">module</span>.name) {</pre></div></div>
</li>
<li id="section-180">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-180">¶</a>
</div>
<p>Define the alias coming from the <code>define</code> function for the anonymous file that was loaded.</p>
</div>
<div class="content"><div class='highlight'><pre> me.module.alias(<span class="hljs-built_in">module</span>.name, [define.module.last.name]);</pre></div></div>
</li>
<li id="section-181">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-181">¶</a>
</div>
<p>Attempt to fetch the index of our anonymous module from our require library.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> anonymousIndex = me.indexOf(me.require.anonymous, moduleName);</pre></div></div>
</li>
<li id="section-182">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-182">¶</a>
</div>
<p>Reference the factory from the file that was loaded if the current factory is <code>undefined</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (anonymousIndex !== -<span class="hljs-number">1</span>) {</pre></div></div>
</li>
<li id="section-183">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-183">¶</a>
</div>
<p>Remove the anonymous entry.</p>
</div>
<div class="content"><div class='highlight'><pre> me.require.anonymous.splice(anonymousIndex, <span class="hljs-number">1</span>);</pre></div></div>
</li>
<li id="section-184">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-184">¶</a>
</div>
<p>Reference the factory.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.factory = define.module.last.factory;
}</pre></div></div>
</li>
<li id="section-185">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-185">¶</a>
</div>
<p>Delete the actually module reference.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">delete</span> me.module.definitions[define.module.last.name];
} <span class="hljs-keyword">else</span> {</pre></div></div>
</li>
<li id="section-186">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-186">¶</a>
</div>
<p>Set the dependencies for our anonymous <code>module</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(define.anonymous.deps)) {
<span class="hljs-built_in">module</span>.deps = define.anonymous.deps;
}</pre></div></div>
</li>
<li id="section-187">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-187">¶</a>
</div>
<p>Set the factory for our anonymous <code>module</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(define.anonymous.deps)) {
<span class="hljs-built_in">module</span>.factory = define.anonymous.factory;
}
}</pre></div></div>
</li>
<li id="section-188">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-188">¶</a>
</div>
<p>Reset the pending anonymous values waiting to be populated.</p>
</div>
<div class="content"><div class='highlight'><pre> define.anonymous.reset();
};</pre></div></div>
</li>
<li id="section-189">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-189">¶</a>
</div>
<p>The dependencies for our anonymous <code>module</code> waiting to be properly defined.</p>
</div>
<div class="content"><div class='highlight'><pre>define.anonymous.deps = <span class="hljs-literal">undefined</span>;</pre></div></div>
</li>
<li id="section-190">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-190">¶</a>
</div>
<p>The factory for our anonymous <code>module</code> waiting to be properly defined.</p>
</div>
<div class="content"><div class='highlight'><pre>define.anonymous.factory = <span class="hljs-literal">undefined</span>;</pre></div></div>
</li>
<li id="section-191">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-191">¶</a>
</div>
<p>Flag whether or not an anonymous module is pending to be defined.</p>
</div>
<div class="content"><div class='highlight'><pre>define.anonymous.pending = <span class="hljs-literal">false</span>;</pre></div></div>
</li>
<li id="section-192">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-192">¶</a>
</div>
<p>Clear out any saved anonymous <code>module</code> properties.</p>
</div>
<div class="content"><div class='highlight'><pre>define.anonymous.reset = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-193">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-193">¶</a>
</div>
<p>Clear the pending state.</p>
</div>
<div class="content"><div class='highlight'><pre> define.anonymous.pending = <span class="hljs-literal">false</span>;</pre></div></div>
</li>
<li id="section-194">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-194">¶</a>
</div>
<p>Clear the dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> define.anonymous.deps = <span class="hljs-literal">undefined</span>;</pre></div></div>
</li>
<li id="section-195">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-195">¶</a>
</div>
<p>Clear the factory.</p>
</div>
<div class="content"><div class='highlight'><pre> define.anonymous.factory = <span class="hljs-literal">undefined</span>;
};</pre></div></div>
</li>
<li id="section-196">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-196">¶</a>
</div>
<p>Store the anonymous module waiting to be defined.</p>
</div>
<div class="content"><div class='highlight'><pre>define.anonymous.save = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args)</span> </span>{</pre></div></div>
</li>
<li id="section-197">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-197">¶</a>
</div>
<p>Remove the reference for our last defined module.</p>
</div>
<div class="content"><div class='highlight'><pre> define.module.last = <span class="hljs-literal">null</span>;</pre></div></div>
</li>
<li id="section-198">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-198">¶</a>
</div>
<p>Reset the previously saved values if present.</p>
</div>
<div class="content"><div class='highlight'><pre> define.anonymous.reset();</pre></div></div>
</li>
<li id="section-199">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-199">¶</a>
</div>
<p>If the <code>args</code> parameter isn’t an <code>Object</code>, halt the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(args)) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-200">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-200">¶</a>
</div>
<p>Flag the pending state.</p>
</div>
<div class="content"><div class='highlight'><pre> define.anonymous.pending = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-201">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-201">¶</a>
</div>
<p>Set the dependencies for our anonymous module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(args.deps)) {
define.anonymous.deps = args.deps;
}</pre></div></div>
</li>
<li id="section-202">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-202">¶</a>
</div>
<p>Set the factory for our anonymous module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(args.factory)) {
define.anonymous.factory = args.factory;
}
};</pre></div></div>
</li>
<li id="section-203">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-203">¶</a>
</div>
<p>Route and normalize the arguments that are passed into our <code>define</code> function. The arguments for our <code>define</code>
<code>Function</code> can be sent in a number of different forms.</p>
</div>
<div class="content"><div class='highlight'><pre>define.args = {};</pre></div></div>
</li>
<li id="section-204">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-204">¶</a>
</div>
<p>Normalize the arguments payload.</p>
</div>
<div class="content"><div class='highlight'><pre>define.args.normalize = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(payload)</span> </span>{</pre></div></div>
</li>
<li id="section-205">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-205">¶</a>
</div>
<p>Normalize the <code>name</code> <code>String</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.name = me.normalizeString(payload.name);</pre></div></div>
</li>
<li id="section-206">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-206">¶</a>
</div>
<p>Normalize the <code>error</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.error = me.normalizeFunction(payload.error);</pre></div></div>
</li>
<li id="section-207">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-207">¶</a>
</div>
<p>Normamlize the <code>dependencies</code> <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.deps = payload.deps ? me.normalizeStringSeries(payload.deps) : <span class="hljs-literal">null</span>;</pre></div></div>
</li>
<li id="section-208">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-208">¶</a>
</div>
<p>Don’t normalize the <code>factory</code>, as it can be anything except <code>undefined</code>.</p>
</div>
</li>
<li id="section-209">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-209">¶</a>
</div>
<p>Return the noramlized <code>payload</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-210">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-210">¶</a>
</div>
<p>Route the arguments passed into the <code>define</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>define.args.router = [];</pre></div></div>
</li>
<li id="section-211">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-211">¶</a>
</div>
<p>Handle no arguments being passed into the <code>define</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>define.args.router[<span class="hljs-number">0</span>] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, payload)</span> </span>{</pre></div></div>
</li>
<li id="section-212">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-212">¶</a>
</div>
<p>Throw an error to the end user.</p>
</div>
<div class="content"><div class='highlight'><pre> me.log(<span class="hljs-number">1</span>, <span class="hljs-string">'define'</span>, <span class="hljs-string">'args'</span>, <span class="hljs-string">'No arguments were passed into `define`! Halting!'</span>, args);</pre></div></div>
</li>
<li id="section-213">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-213">¶</a>
</div>
<p>Return our factored payload.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-214">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-214">¶</a>
</div>
<p>Handle 1 argument being passed into the <code>define</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>define.args.router[<span class="hljs-number">1</span>] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, payload)</span> </span>{</pre></div></div>
</li>
<li id="section-215">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-215">¶</a>
</div>
<p>Reference the <code>factory</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.factory = args[<span class="hljs-number">0</span>];</pre></div></div>
</li>
<li id="section-216">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-216">¶</a>
</div>
<p>Return our factored payload.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-217">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-217">¶</a>
</div>
<p>Handle 2 arguments being passed into the <code>define</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>define.args.router[<span class="hljs-number">2</span>] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, payload)</span> </span>{</pre></div></div>
</li>
<li id="section-218">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-218">¶</a>
</div>
<p>If the first argument is a <code>String</code>, treat the arguments as <code>name</code>, and <code>factory</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isString(args[<span class="hljs-number">0</span>])) {</pre></div></div>
</li>
<li id="section-219">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-219">¶</a>
</div>
<p>Reference the <code>name</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.name = args[<span class="hljs-number">0</span>];</pre></div></div>
</li>
<li id="section-220">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-220">¶</a>
</div>
<p>Reference the <code>factory</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.factory = args[<span class="hljs-number">1</span>];</pre></div></div>
</li>
<li id="section-221">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-221">¶</a>
</div>
<p>If the first argument is an <code>Array</code>, treat the arguments as <code>dependencies</code>, and <code>factory</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (me.isaArray(args[<span class="hljs-number">0</span>])) {</pre></div></div>
</li>
<li id="section-222">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-222">¶</a>
</div>
<p>Reference the <code>dependencies</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.deps = args[<span class="hljs-number">0</span>];</pre></div></div>
</li>
<li id="section-223">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-223">¶</a>
</div>
<p>Reference the <code>factory</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.factory = args[<span class="hljs-number">1</span>];</pre></div></div>
</li>
<li id="section-224">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-224">¶</a>
</div>
<p>If none of the criteria above matched, then the arguments are malformed.</p>
</div>
<div class="content"><div class='highlight'><pre> } <span class="hljs-keyword">else</span> {
me.log(<span class="hljs-number">1</span>, <span class="hljs-string">'define'</span>, <span class="hljs-string">'args'</span>, <span class="hljs-string">'2 arguments were passed into `define` that were malformed! Discarding!'</span>, args);
}</pre></div></div>
</li>
<li id="section-225">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-225">¶</a>
</div>
<p>Return our factored payload.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-226">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-226">¶</a>
</div>
<p>Handle 3 arguments being passed into the <code>define</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>define.args.router[<span class="hljs-number">3</span>] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, payload)</span> </span>{</pre></div></div>
</li>
<li id="section-227">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-227">¶</a>
</div>
<p>Reference the <code>name</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.name = args[<span class="hljs-number">0</span>];</pre></div></div>
</li>
<li id="section-228">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-228">¶</a>
</div>
<p>Reference the <code>dependencies</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.deps = args[<span class="hljs-number">1</span>];</pre></div></div>
</li>
<li id="section-229">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-229">¶</a>
</div>
<p>Reference the <code>factory</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.factory = args[<span class="hljs-number">2</span>];</pre></div></div>
</li>
<li id="section-230">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-230">¶</a>
</div>
<p>Return our factored payload.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-231">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-231">¶</a>
</div>
<p>Fill up our dependencies based on our arguments if we need to.</p>
</div>
<div class="content"><div class='highlight'><pre>define.deps = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args)</span> </span>{</pre></div></div>
</li>
<li id="section-232">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-232">¶</a>
</div>
<p>If we already have our dependencies defined, then skip the function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (args.deps) {
<span class="hljs-keyword">return</span> args;
}</pre></div></div>
</li>
<li id="section-233">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-233">¶</a>
</div>
<p>If our factory isn’t a function, and our dependcies are empty, then we have no dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isFunction(args.factory)) {
args.deps = [];
<span class="hljs-keyword">return</span> args;
}</pre></div></div>
</li>
<li id="section-234">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-234">¶</a>
</div>
<p>If we made it this far, set the arguments from our factory as our dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> args.deps = me.args(args.factory);</pre></div></div>
</li>
<li id="section-235">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-235">¶</a>
</div>
<p>Send back our arguments array with our populated dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> args;
};</pre></div></div>
</li>
<li id="section-236">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-236">¶</a>
</div>
<p>Generate and return our new module.</p>
</div>
<div class="content"><div class='highlight'><pre>define.module = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args)</span> </span>{</pre></div></div>
</li>
<li id="section-237">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-237">¶</a>
</div>
<p>Generate or reference the module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> <span class="hljs-built_in">module</span> = me.module(args.name, {
amd: <span class="hljs-literal">true</span>
});</pre></div></div>
</li>
<li id="section-238">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-238">¶</a>
</div>
<p>Set our dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.deps = me.normalizeStringSeries(args.deps);</pre></div></div>
</li>
<li id="section-239">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-239">¶</a>
</div>
<p>Set our error.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.error = me.normalizeFunction(args.error);</pre></div></div>
</li>
<li id="section-240">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-240">¶</a>
</div>
<p>Set our factory.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.factory = args.factory;</pre></div></div>
</li>
<li id="section-241">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-241">¶</a>
</div>
<p>Explicity flag that the module has been loaded, that way when we reference it, we don’t attempt to load it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.loader.loaded = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-242">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-242">¶</a>
</div>
<p>Return a reference to the module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-built_in">module</span>;
};</pre></div></div>
</li>
<li id="section-243">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-243">¶</a>
</div>
<p>Our last defined module reference. This is used to reference the proper names with our anonymous modules.</p>
</div>
<div class="content"><div class='highlight'><pre>define.module.last = <span class="hljs-literal">null</span>;</pre></div></div>
</li>
<li id="section-244">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-244">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.define = define;</pre></div></div>
</li>
<li id="section-245">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-245">¶</a>
</div>
<p>Generate a global unique idenifier.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> guid = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
<span class="hljs-keyword">return</span> me.guid.block() + me.guid.block(<span class="hljs-literal">true</span>) + me.guid.block(<span class="hljs-literal">true</span>) + me.guid.block();
};</pre></div></div>
</li>
<li id="section-246">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-246">¶</a>
</div>
<p>Random blocks for a GUID.</p>
</div>
<div class="content"><div class='highlight'><pre>guid.block = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(dashed)</span> </span>{
<span class="hljs-keyword">var</span> generated = (<span class="hljs-built_in">Math</span>.random().toString(<span class="hljs-number">16</span>) + <span class="hljs-string">'000000000'</span>).substr(<span class="hljs-number">2</span>, <span class="hljs-number">8</span>);
<span class="hljs-keyword">return</span> dashed ? <span class="hljs-string">'-'</span> + generated.substr(<span class="hljs-number">0</span>, <span class="hljs-number">4</span>) + <span class="hljs-string">'-'</span> + generated.substr(<span class="hljs-number">4</span>, <span class="hljs-number">4</span>) : generated;
};</pre></div></div>
</li>
<li id="section-247">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-247">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.guid = guid;</pre></div></div>
</li>
<li id="section-248">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-248">¶</a>
</div>
<p>The loader object handles asynchronously loading of all the files for the library. It acts as a middle man between
the <code>require</code> function and our loader libraries. Loader libraries for example being <code>loaderImage.js</code>,
<code>loaderStylesheet.js</code> and <code>loaderJavaScript.js</code>. Those individual libraries are treated as non-logic based loaders.
Their sole purpose is to simply load a specific URL, then let us know whether it load successfully or not. Any and
all logic which performs trying additional fallbacks and checks lives within the loader object.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> loader = {};</pre></div></div>
</li>
<li id="section-249">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-249">¶</a>
</div>
<p>Initialization function for our loader object.</p>
</div>
<div class="content"><div class='highlight'><pre>loader.init = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-250">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-250">¶</a>
</div>
<p>Automatically configure our library via attributes being set on any <code>script</code> elements on the page.</p>
</div>
<div class="content"><div class='highlight'><pre> loader.init.autoloader();
};</pre></div></div>
</li>
<li id="section-251">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-251">¶</a>
</div>
<p>If the attributes <code>base</code> or <code>data-base</code> are found on any of the <code>script</code> tags within the page when the library is
loaded, automatically set the <code>base</code> variable for our configuration to that <code>value</code>. If the attributes <code>main</code> or
<code>data-main</code> are found on any of the <code>script</code> tags when the library is loaded on the page, automatically load up that
<code>value</code> as a module. If the <code>value</code> is a comma delimited string, we’ll split on the comma and load each separately.</p>
</div>
<div class="content"><div class='highlight'><pre>loader.init.autoloader = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-252">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-252">¶</a>
</div>
<p>Fetch <code>base</code> and/or <code>data-base</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> base = me.normalizeStringSeries(loader.js.attributes(<span class="hljs-string">'base'</span>));</pre></div></div>
</li>
<li id="section-253">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-253">¶</a>
</div>
<p>If our <code>attribute</code> exists, then configure it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (base.length) {</pre></div></div>
</li>
<li id="section-254">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-254">¶</a>
</div>
<p>Since <code>me.autoloader</code> will return an <code>Array</code> series, only use the first value of our <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> me.config({
base: base.shift()
});
}</pre></div></div>
</li>
<li id="section-255">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-255">¶</a>
</div>
<p>Fetch <code>main</code> and/or <code>data-main</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> main = me.normalizeStringSeries(loader.js.attributes(<span class="hljs-string">'main'</span>));</pre></div></div>
</li>
<li id="section-256">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-256">¶</a>
</div>
<p>If our <code>attribute</code> exists, then <code>require</code> it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (main.length) {
me.require(main);
}
};</pre></div></div>
</li>
<li id="section-257">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-257">¶</a>
</div>
<p>Attempt to load our module.</p>
</div>
<div class="content"><div class='highlight'><pre>loader.boot = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(module)</span> </span>{</pre></div></div>
</li>
<li id="section-258">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-258">¶</a>
</div>
<p>If we made it this far, we need to actually process the module in question.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.loader.working = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-259">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-259">¶</a>
</div>
<p>Set our start time for statistics.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.loader.timeStart = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>().getTime();</pre></div></div>
</li>
<li id="section-260">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-260">¶</a>
</div>
<p>Setup our temporary variables to use for our working URLs.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.loader.workingURLs = me.arrayClone(<span class="hljs-built_in">module</span>.urls);</pre></div></div>
</li>
<li id="section-261">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-261">¶</a>
</div>
<p>Make sure to clone our URLs array as we’re going to be manipulating it.</p>
</div>
<div class="content"><div class='highlight'><pre> loader.urls(<span class="hljs-built_in">module</span>);
};</pre></div></div>
</li>
<li id="section-262">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-262">¶</a>
</div>
<p>Patch for legacy browsers which sometimes fire off <code>onreadystatechange</code> instead of the <code>onload</code> callback. @ie</p>
</div>
<div class="content"><div class='highlight'><pre>loader.onReadyStateChange = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(element, callback)</span> </span>{</pre></div></div>
</li>
<li id="section-263">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-263">¶</a>
</div>
<p>Attach the event to the element.</p>
</div>
<div class="content"><div class='highlight'><pre> element.onreadystatechange = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
<span class="hljs-keyword">if</span> (!<span class="hljs-keyword">this</span>.readyState || <span class="hljs-keyword">this</span>.readyState === <span class="hljs-string">'loaded'</span> || <span class="hljs-keyword">this</span>.readyState === <span class="hljs-string">'complete'</span>) {</pre></div></div>
</li>
<li id="section-264">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-264">¶</a>
</div>
<p>Explicity remove the callback after we receive it.
Some versions of IE tend to fire off multiple success events. @ie</p>
</div>
<div class="content"><div class='highlight'><pre> element.onreadystatechange = <span class="hljs-literal">null</span>;</pre></div></div>
</li>
<li id="section-265">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-265">¶</a>
</div>
<p>Fire off our callback.</p>
</div>
<div class="content"><div class='highlight'><pre> callback();
}
};
};</pre></div></div>
</li>
<li id="section-266">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-266">¶</a>
</div>
<p>Load the URLs passed in for the module in question. This will run a loop through each of the URLs, attempting to
load one at a time, only stopping when either all URLs have been exhausted or a URL has loaded successfully. Other
specific checks that determine whether or not a library was actually loaded properly are defined within the loader
scripts themselves.</p>
</div>
<div class="content"><div class='highlight'><pre>loader.urls = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(module)</span> </span>{</pre></div></div>
</li>
<li id="section-267">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-267">¶</a>
</div>
<p>Reference our working URLs.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> urls = <span class="hljs-built_in">module</span>.loader.workingURLs;</pre></div></div>
</li>
<li id="section-268">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-268">¶</a>
</div>
<p>If we’ve exhausted all URLs available for the module, then the library has failed to load.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!urls.length) {
<span class="hljs-keyword">return</span> loader.urls.failed(<span class="hljs-built_in">module</span>);
}</pre></div></div>
</li>
<li id="section-269">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-269">¶</a>
</div>
<p>Shift our URL off of the <code>Array</code>, that way if we have to loop around, we don’t retry the same URL again.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> url = urls.shift();</pre></div></div>
</li>
<li id="section-270">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-270">¶</a>
</div>
<p>Throw a log message to the end user.</p>
</div>
<div class="content"><div class='highlight'><pre> me.log(<span class="hljs-number">3</span>, <span class="hljs-string">'loader'</span>, <span class="hljs-string">'Requesting to load `'</span> + <span class="hljs-built_in">module</span>.name + <span class="hljs-string">'` via `'</span> + url + <span class="hljs-string">'`'</span>);</pre></div></div>
</li>
<li id="section-271">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-271">¶</a>
</div>
<p>Call upon our specific loader script to load our URL.</p>
</div>
<div class="content"><div class='highlight'><pre> loader[<span class="hljs-built_in">module</span>.identity].boot(<span class="hljs-built_in">module</span>, url, loader.urls.success, loader.urls.failed, <span class="hljs-built_in">module</span>.identity);
};</pre></div></div>
</li>
<li id="section-272">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-272">¶</a>
</div>
<p>Common operations to perform whether a module loaded successfully or not.</p>
</div>
<div class="content"><div class='highlight'><pre>loader.urls.completed = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(module, success)</span> </span>{</pre></div></div>
</li>
<li id="section-273">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-273">¶</a>
</div>
<p>Flag our module has having already attempted to load.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.loader.loaded = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-274">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-274">¶</a>
</div>
<p>Set our end time for statistics.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.loader.timeEnd = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>().getTime();</pre></div></div>
</li>
<li id="section-275">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-275">¶</a>
</div>
<p>Flag our module as no longer in a working/in progress state.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.loader.working = <span class="hljs-literal">false</span>;</pre></div></div>
</li>
<li id="section-276">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-276">¶</a>
</div>
<p>Fire off all of our callbacks.</p>
</div>
<div class="content"><div class='highlight'><pre> me.module.invoke.callbacks(<span class="hljs-built_in">module</span>.name, success);
};</pre></div></div>
</li>
<li id="section-277">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-277">¶</a>
</div>
<p>When a URL or module fails to load this function will be called.</p>
</div>
<div class="content"><div class='highlight'><pre>loader.urls.failed = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(module, url)</span> </span>{</pre></div></div>
</li>
<li id="section-278">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-278">¶</a>
</div>
<p>Legacy IE fires off the failed callback more than once, so we’ll double check to see if we’ve already fired it. @ie</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.indexOf(<span class="hljs-built_in">module</span>.loader.failed, url) !== -<span class="hljs-number">1</span>) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-279">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-279">¶</a>
</div>
<p>Setup our log message that we’ll send to the end user.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> message = <span class="hljs-string">'`'</span> + <span class="hljs-built_in">module</span>.name + <span class="hljs-string">'` failed to load '</span>;</pre></div></div>
</li>
<li id="section-280">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-280">¶</a>
</div>
<p>If there’s no URL, then all URLs have been exhausted!</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!url) {
loader.urls.completed(<span class="hljs-built_in">module</span>, <span class="hljs-literal">false</span>);
me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'loader'</span>, message + <span class="hljs-string">'module.'</span>);
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-281">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-281">¶</a>
</div>
<p>Reset the anonymous module name.</p>
</div>
<div class="content"><div class='highlight'><pre> me.define.anonymous.reset();</pre></div></div>
</li>
<li id="section-282">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-282">¶</a>
</div>
<p>Let the end user know which specific URL failed to load.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.loader.failed.push(url);
me.log(<span class="hljs-number">3</span>, <span class="hljs-string">'loader'</span>, message + <span class="hljs-string">'for URL: '</span> + url);</pre></div></div>
</li>
<li id="section-283">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-283">¶</a>
</div>
<p>Try the next URL in our URLs list.</p>
</div>
<div class="content"><div class='highlight'><pre> loader.urls(<span class="hljs-built_in">module</span>);
};</pre></div></div>
</li>
<li id="section-284">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-284">¶</a>
</div>
<p>When a URL loads sucessfully this function will be called.</p>
</div>
<div class="content"><div class='highlight'><pre>loader.urls.success = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(module, url, factory, predefined)</span> </span>{</pre></div></div>
</li>
<li id="section-285">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-285">¶</a>
</div>
<p>We’re going to store the name of the module we’re attempting to load here. This way if the file that’s loaded
happens to call the <code>define</code> function with an anonymous name, this is the name that we’ll use for the definition.</p>
</div>
<div class="content"><div class='highlight'><pre> me.define.anonymous(<span class="hljs-built_in">module</span>.name);</pre></div></div>
</li>
<li id="section-286">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-286">¶</a>
</div>
<p>If our library was already loaded, we don’t know what URL was successful, so we’ll skip setting it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (predefined === <span class="hljs-literal">true</span>) {
me.log(<span class="hljs-number">3</span>, <span class="hljs-string">'loader'</span>, <span class="hljs-string">'`'</span> + <span class="hljs-built_in">module</span>.name + <span class="hljs-string">'` already loaded on the page; referencing.'</span>);
} <span class="hljs-keyword">else</span> {
<span class="hljs-built_in">module</span>.loader.success = url;
me.log(<span class="hljs-number">3</span>, <span class="hljs-string">'loader'</span>, <span class="hljs-string">'`'</span> + <span class="hljs-built_in">module</span>.name + <span class="hljs-string">'` loaded successfully `'</span> + url + <span class="hljs-string">'`.'</span>);
}</pre></div></div>
</li>
<li id="section-287">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-287">¶</a>
</div>
<p>If we have a <code>init</code> function, we’ll run it now.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isFunction(<span class="hljs-built_in">module</span>.init)) {
<span class="hljs-built_in">module</span>.init();
}</pre></div></div>
</li>
<li id="section-288">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-288">¶</a>
</div>
<p>If we don’t have a factory for our module, then there was no definition. Regardless of what our value is we’ll
reference it here.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isDefined(<span class="hljs-built_in">module</span>.factory)) {
<span class="hljs-built_in">module</span>.factory = factory;
<span class="hljs-built_in">module</span>.invoked = <span class="hljs-literal">true</span>;
}</pre></div></div>
</li>
<li id="section-289">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-289">¶</a>
</div>
<p>Wrap up the loader process and handle our callbacks.</p>
</div>
<div class="content"><div class='highlight'><pre> loader.urls.completed(<span class="hljs-built_in">module</span>, <span class="hljs-literal">true</span>);
};</pre></div></div>
</li>
<li id="section-290">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-290">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.loader = loader;</pre></div></div>
</li>
<li id="section-291">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-291">¶</a>
</div>
<p>Logging function for when debugging is turned on.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> log = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-292">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-292">¶</a>
</div>
<p>Make sure that both debugging is enable and what <code>global.console</code> exists.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.config.settings.debug || !global.console) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}</pre></div></div>
</li>
<li id="section-293">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-293">¶</a>
</div>
<p>Convert our <code>Arguments</code> into an <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> args = me.arrayClone(<span class="hljs-built_in">arguments</span>);</pre></div></div>
</li>
<li id="section-294">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-294">¶</a>
</div>
<p>If we have no arguments, then halt the function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!args.length) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}
<span class="hljs-keyword">var</span> first = args.shift();
<span class="hljs-keyword">var</span> level = me.log.levels[<span class="hljs-number">3</span>];</pre></div></div>
</li>
<li id="section-295">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-295">¶</a>
</div>
<p>If our first argument was a number, then it’s our level to log at.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isNumber(first)) {
<span class="hljs-keyword">if</span> (me.log.levels[first]) {
level = me.log.levels[first];
}
first = args.shift();
}</pre></div></div>
</li>
<li id="section-296">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-296">¶</a>
</div>
<p>Check to make sure the level of the debug message is acceptable for the configured debugging output.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.config.settings.debug !== <span class="hljs-literal">true</span> && me.config.settings.debug !== level) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}</pre></div></div>
</li>
<li id="section-297">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-297">¶</a>
</div>
<p>Log the message to console.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> log.message(level, log.prefixes(args, first), args);
};</pre></div></div>
</li>
<li id="section-298">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-298">¶</a>
</div>
<p>The various levels for our <code>log</code> function.</p>
</div>
<div class="content"><div class='highlight'><pre>log.levels = {
<span class="hljs-number">1</span>: <span class="hljs-string">'error'</span>,
<span class="hljs-number">2</span>: <span class="hljs-string">'warn'</span>,
<span class="hljs-number">3</span>: <span class="hljs-string">'info'</span>
};</pre></div></div>
</li>
<li id="section-299">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-299">¶</a>
</div>
<p>Determine the method to be used to send a message to console.</p>
</div>
<div class="content"><div class='highlight'><pre>log.method = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(level)</span> </span>{</pre></div></div>
</li>
<li id="section-300">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-300">¶</a>
</div>
<p>Make a reference to our function, if the our level function doesn’t exist natively in the browser.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> method = <span class="hljs-string">'log'</span>;</pre></div></div>
</li>
<li id="section-301">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-301">¶</a>
</div>
<p>If the <code>method</code> exists, then use it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isFunction(global.console[level])) {
method = level;
}</pre></div></div>
</li>
<li id="section-302">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-302">¶</a>
</div>
<p>Return the logging method.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> method;
};</pre></div></div>
</li>
<li id="section-303">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-303">¶</a>
</div>
<p>Log a message to the console.</p>
</div>
<div class="content"><div class='highlight'><pre>log.message = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(level, prefixes, args)</span> </span>{</pre></div></div>
</li>
<li id="section-304">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-304">¶</a>
</div>
<p>The message for console.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> message = <span class="hljs-string">'%cFallbackJS: %c'</span> + level.toUpperCase() + <span class="hljs-string">': '</span> + prefixes.join(<span class="hljs-string">': '</span>) + <span class="hljs-string">': %c'</span> + args.join();</pre></div></div>
</li>
<li id="section-305">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-305">¶</a>
</div>
<p>The styles for the message if the browser supports console styling.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> style1 = <span class="hljs-string">'font-weight: bold; color: #da542c'</span>;
<span class="hljs-keyword">var</span> style2 = <span class="hljs-string">'font-weight: bold; color: #000'</span>;
<span class="hljs-keyword">var</span> style3 = <span class="hljs-string">'color: #777'</span>;</pre></div></div>
</li>
<li id="section-306">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-306">¶</a>
</div>
<p>If we’re in IE, ditch the console styles, it’s not supported. @ie</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.browser.isIE()) {</pre></div></div>
</li>
<li id="section-307">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-307">¶</a>
</div>
<p>Wipe the styles.</p>
</div>
<div class="content"><div class='highlight'><pre> style1 = style2 = style3 = <span class="hljs-string">''</span>;</pre></div></div>
</li>
<li id="section-308">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-308">¶</a>
</div>
<p>Replace the color variables in the message.</p>
</div>
<div class="content"><div class='highlight'><pre> message = message.replace(<span class="hljs-regexp">/%c/g</span>, <span class="hljs-string">''</span>);
}</pre></div></div>
</li>
<li id="section-309">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-309">¶</a>
</div>
<p>Log our message to the console. @todo need a non colorful message for legacy ie</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> global.console[log.method(level)](message, style1, style2, style3);
};</pre></div></div>
</li>
<li id="section-310">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-310">¶</a>
</div>
<p>Deteremine the prefixed messages to be sent with a log message.</p>
</div>
<div class="content"><div class='highlight'><pre>log.prefixes = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, first)</span> </span>{</pre></div></div>
</li>
<li id="section-311">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-311">¶</a>
</div>
<p>The prefixes before our actual message.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> prefixes = [first];</pre></div></div>
</li>
<li id="section-312">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-312">¶</a>
</div>
<p>Loop through each arguments, til we find the first item that’s not a space, or a string not containing a space.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(args, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(item)</span> </span>{
<span class="hljs-keyword">if</span> (!me.isString(item) || item.indexOf(<span class="hljs-string">' '</span>) !== -<span class="hljs-number">1</span>) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}
prefixes.push(args.shift());
});</pre></div></div>
</li>
<li id="section-313">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-313">¶</a>
</div>
<p>Return the set of prefixes.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> prefixes;
};</pre></div></div>
</li>
<li id="section-314">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-314">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.log = log;</pre></div></div>
</li>
<li id="section-315">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-315">¶</a>
</div>
<p>Fetch an already existant module from our definitions. If the module in question doesn’t exist then we’ll generate
it automatically unless the <code>generate</code> parameter is explicitly set to <code>false</code>. If a <code>module</code> is defined, then it’s
defaults will come out of whatever is contained in the <code>input</code> parameter.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-comment">/* eslint-disable */</span>
<span class="hljs-keyword">var</span> <span class="hljs-built_in">module</span> = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName, input, generate)</span> </span>{
<span class="hljs-comment">/* eslint-enable */</span></pre></div></div>
</li>
<li id="section-316">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-316">¶</a>
</div>
<p>Fetch our real module name, in the case that we’re passed an alias.</p>
</div>
<div class="content"><div class='highlight'><pre> moduleName = <span class="hljs-built_in">module</span>.named(moduleName);</pre></div></div>
</li>
<li id="section-317">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-317">¶</a>
</div>
<p>If the module already exists, then return it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">module</span>.exists(moduleName)) {
<span class="hljs-keyword">return</span> <span class="hljs-built_in">module</span>.definitions[moduleName];
}</pre></div></div>
</li>
<li id="section-318">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-318">¶</a>
</div>
<p>If we explicity stated not to generate our module, then stop here.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (generate === <span class="hljs-literal">false</span>) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
}</pre></div></div>
</li>
<li id="section-319">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-319">¶</a>
</div>
<p>Generate and return our newly generated module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-built_in">module</span>.define(moduleName, input);
};</pre></div></div>
</li>
<li id="section-320">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-320">¶</a>
</div>
<p>Store our aliases in a mapped <code>Object</code> that way it can be referenced easily.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.alias = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName, aliases)</span> </span>{</pre></div></div>
</li>
<li id="section-321">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-321">¶</a>
</div>
<p>Store the actual module name as an alias of itself.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.aliases[moduleName] = moduleName;</pre></div></div>
</li>
<li id="section-322">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-322">¶</a>
</div>
<p>Normalize our incoming aliases.</p>
</div>
<div class="content"><div class='highlight'><pre> aliases = me.normalizeStringSeries(aliases);</pre></div></div>
</li>
<li id="section-323">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-323">¶</a>
</div>
<p>If no alias were passed in, then halt our function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!aliases.length) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-324">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-324">¶</a>
</div>
<p>Fetch our module so we can add our aliases to it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> moduleInstance = <span class="hljs-built_in">module</span>(moduleName, <span class="hljs-literal">null</span>, <span class="hljs-literal">false</span>);</pre></div></div>
</li>
<li id="section-325">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-325">¶</a>
</div>
<p>Loop through each of our aliases and store them.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(aliases, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(alias)</span> </span>{</pre></div></div>
</li>
<li id="section-326">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-326">¶</a>
</div>
<p>If the alias already exists, notify the end user before overwriting it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(<span class="hljs-built_in">module</span>.aliases[alias])) {
me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'module'</span>, <span class="hljs-string">'Module alias `'</span> + alias + <span class="hljs-string">'` already exists for `'</span> + <span class="hljs-built_in">module</span>.aliases[alias] + <span class="hljs-string">'`! Overwriting!'</span>);
}</pre></div></div>
</li>
<li id="section-327">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-327">¶</a>
</div>
<p>Reference our alias.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.aliases[alias] = moduleName;</pre></div></div>
</li>
<li id="section-328">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-328">¶</a>
</div>
<p>If we don’t aleady have an alias stored in our modules aliases, then add it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.indexOf(moduleInstance.alias, alias)) {
moduleInstance.alias.push(alias);
}
});
};</pre></div></div>
</li>
<li id="section-329">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-329">¶</a>
</div>
<p>An <code>Object</code> of aliases mappings where the <code>key</code> is the alias and the <code>value</code> is the <code>module</code> that the alias is for.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.aliases = {};</pre></div></div>
</li>
<li id="section-330">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-330">¶</a>
</div>
<p>Fetch the base URL for the current identity being passed in.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.base = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(identity)</span> </span>{</pre></div></div>
</li>
<li id="section-331">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-331">¶</a>
</div>
<p>If our <code>base</code> variable is null/empty, return null.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.config.settings.base) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
}</pre></div></div>
</li>
<li id="section-332">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-332">¶</a>
</div>
<p>If our <code>base</code> variable is a string, then return it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isString(me.config.settings.base)) {
<span class="hljs-keyword">return</span> me.config.settings.base;
}</pre></div></div>
</li>
<li id="section-333">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-333">¶</a>
</div>
<p>If no identity was given them revert to our fallback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!identity) {
identity = <span class="hljs-built_in">module</span>.identify.fallback;
}</pre></div></div>
</li>
<li id="section-334">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-334">¶</a>
</div>
<p>If a base URL exists for the identity, then return it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(me.config.settings.base[identity]) && me.config.settings.base[identity]) {
<span class="hljs-keyword">return</span> me.config.settings.base[identity];
}</pre></div></div>
</li>
<li id="section-335">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-335">¶</a>
</div>
<p>No base URL was found.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
};</pre></div></div>
</li>
<li id="section-336">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-336">¶</a>
</div>
<p>Attempt to load a module.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.boot = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName, successCallback, errorCallback)</span> </span>{</pre></div></div>
</li>
<li id="section-337">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-337">¶</a>
</div>
<p>Fetch the instance of our module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> moduleInstance = <span class="hljs-built_in">module</span>(moduleName);</pre></div></div>
</li>
<li id="section-338">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-338">¶</a>
</div>
<p>If our module is already loaded, then skip the loading process and hit the callback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (moduleInstance.loader.loaded === <span class="hljs-literal">true</span>) {
successCallback();
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-339">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-339">¶</a>
</div>
<p>Push our success callback to the queue.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isFunction(successCallback)) {
moduleInstance.successCallbacks.push(successCallback);
}</pre></div></div>
</li>
<li id="section-340">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-340">¶</a>
</div>
<p>Push our error callback to the queue.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isFunction(errorCallback)) {
moduleInstance.errorCallbacks.push(errorCallback);
}</pre></div></div>
</li>
<li id="section-341">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-341">¶</a>
</div>
<p>If this module is currently in the process of being loaded, queue our callback and skip processing.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (moduleInstance.loader.working === <span class="hljs-literal">true</span>) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-342">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-342">¶</a>
</div>
<p>Attempt to load the module on to the page.</p>
</div>
<div class="content"><div class='highlight'><pre> me.loader.boot(moduleInstance);
};</pre></div></div>
</li>
<li id="section-343">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-343">¶</a>
</div>
<p>Define a new module and normalize the <code>input</code>. This <code>Function</code> will override a module if it already exists with the
same name unless the <code>noOverride</code> parameter is explicity set to <code>true</code>.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.define = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName, input, noOverride)</span> </span>{</pre></div></div>
</li>
<li id="section-344">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-344">¶</a>
</div>
<p>If a module with the <code>moduleName</code> already exists, fetch the actual name of the module in case we have an alias.</p>
</div>
<div class="content"><div class='highlight'><pre> moduleName = <span class="hljs-built_in">module</span>.named(moduleName);</pre></div></div>
</li>
<li id="section-345">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-345">¶</a>
</div>
<p>If the module already exists, determine whether or not to override it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">module</span>.exists(moduleName)) {</pre></div></div>
</li>
<li id="section-346">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-346">¶</a>
</div>
<p>If we explicity state not to override an existing module, then halt the function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (noOverride === <span class="hljs-literal">true</span>) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
}</pre></div></div>
</li>
<li id="section-347">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-347">¶</a>
</div>
<p>Let the end user know that we’re overriding a module.</p>
</div>
<div class="content"><div class='highlight'><pre> me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'module'</span>, <span class="hljs-string">'Module `'</span> + moduleName + <span class="hljs-string">'` already exists! Overwriting!'</span>);
}</pre></div></div>
</li>
<li id="section-348">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-348">¶</a>
</div>
<p>Force our input to an <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(input)) {
input = {};
}</pre></div></div>
</li>
<li id="section-349">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-349">¶</a>
</div>
<p>Normalize our <code>input</code> parameter.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> normalized = <span class="hljs-built_in">module</span>.define.normalize(moduleName, input);</pre></div></div>
</li>
<li id="section-350">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-350">¶</a>
</div>
<p>Store the definition reference of our module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> moduleInstance = <span class="hljs-built_in">module</span>.definitions[moduleName] = normalized;</pre></div></div>
</li>
<li id="section-351">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-351">¶</a>
</div>
<p>Import the aliases for our module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">module</span>.alias(moduleName, normalized.alias);</pre></div></div>
</li>
<li id="section-352">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-352">¶</a>
</div>
<p>Return our newly defined module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> moduleInstance;
};</pre></div></div>
</li>
<li id="section-353">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-353">¶</a>
</div>
<p>Normalize the <code>input</code> data for a new module.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.define.normalize = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName, input)</span> </span>{</pre></div></div>
</li>
<li id="section-354">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-354">¶</a>
</div>
<p>Fetch the defaults for a module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> defaults = <span class="hljs-built_in">module</span>.define.defaults();</pre></div></div>
</li>
<li id="section-355">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-355">¶</a>
</div>
<p>Storage for <code>input</code> after it’s been normalized.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> normalized = {};</pre></div></div>
</li>
<li id="section-356">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-356">¶</a>
</div>
<p>Loop through the top level and loader sublevels of our <code>input</code> and <code>defaults</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each([<span class="hljs-literal">false</span>, <span class="hljs-literal">true</span>], <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(inputKey)</span> </span>{</pre></div></div>
</li>
<li id="section-357">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-357">¶</a>
</div>
<p>The reference to the level of our defaults that we’re normalizing in this iteration.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> payload = defaults;</pre></div></div>
</li>
<li id="section-358">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-358">¶</a>
</div>
<p>If the <code>inputKey</code> isn’t empty, then we’re normalizing a sublevel. Adjust the payload’s reference.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (inputKey) {
normalized.loader = {};
payload = payload.loader;
}</pre></div></div>
</li>
<li id="section-359">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-359">¶</a>
</div>
<p>Loop through our defaults.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(payload, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(values, key)</span> </span>{</pre></div></div>
</li>
<li id="section-360">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-360">¶</a>
</div>
<p>By default set the value to whatever was passed in to our function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> value = input[key];</pre></div></div>
</li>
<li id="section-361">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-361">¶</a>
</div>
<p>If our <code>values</code> is an <code>Array</code>, then run the normalization function on the input value.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isaArray(values)) {
value = values[<span class="hljs-number">0</span>](value, values[<span class="hljs-number">1</span>]);
}</pre></div></div>
</li>
<li id="section-362">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-362">¶</a>
</div>
<p>If the <code>inputKey</code> isn’t empty, store the <code>value</code> in our sublevel of our normalized <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (inputKey) {
normalized.loader[key] = value;
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-363">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-363">¶</a>
</div>
<p>Store the value at the top level of our normalized <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> normalized[key] = value;
});
});</pre></div></div>
</li>
<li id="section-364">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-364">¶</a>
</div>
<p>Forcefully set the module name within the <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> normalized.name = moduleName;</pre></div></div>
</li>
<li id="section-365">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-365">¶</a>
</div>
<p>Store the identity of our module now, so that we may reference it later.</p>
</div>
<div class="content"><div class='highlight'><pre> normalized.identity = <span class="hljs-built_in">module</span>.identify(moduleName);</pre></div></div>
</li>
<li id="section-366">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-366">¶</a>
</div>
<p>Normalize all of the URLs for the module now and store them in a normalized state.</p>
</div>
<div class="content"><div class='highlight'><pre> normalized.urls = <span class="hljs-built_in">module</span>.urls(moduleName, normalized.identity, normalized.urls);</pre></div></div>
</li>
<li id="section-367">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-367">¶</a>
</div>
<p>Return our normalized input.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> normalized;
};</pre></div></div>
</li>
<li id="section-368">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-368">¶</a>
</div>
<p>The following are our defaults that we’ll use to normalize our data when defining a new module. The values of this
<code>Object</code> are <code>Array</code> based. The first parameter of the <code>Array</code> is the <code>Function</code> that we’ll use to normalize the
value, the 2nd parameter is the fallback value that we’ll use. For example: <code>alias: [me.normalizeStringSeries, []]</code>
will run the <code>me.normalizeStringSeries</code> on the value of <code>alias</code>, and if the value is malformed, the value will be
set to <code>[]</code>. If the value in our <code>defaults</code> <code>Object</code> is not an <code>Array</code>, then it will be skipped/ignored from the
normalization loop.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.define.defaults = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
<span class="hljs-keyword">return</span> {</pre></div></div>
</li>
<li id="section-369">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-369">¶</a>
</div>
<p>Wheter or not the module is a AMD.</p>
</div>
<div class="content"><div class='highlight'><pre> amd: [me.normalizeBoolean, <span class="hljs-literal">false</span>],</pre></div></div>
</li>
<li id="section-370">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-370">¶</a>
</div>
<p>Aliases for the module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-string">'alias'</span>: [me.normalizeStringSeries, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-371">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-371">¶</a>
</div>
<p>Custom check function to determine whether or not our library has loaded properly.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-string">'check'</span>: [me.normalizeFunction, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-372">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-372">¶</a>
</div>
<p>Dependencies for the module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-string">'deps'</span>: [me.normalizeStringSeries, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-373">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-373">¶</a>
</div>
<p>An error <code>Function</code> which will be called if the library or it’s dependencies fail to load.</p>
</div>
<div class="content"><div class='highlight'><pre> error: [me.normalizeFunction, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-374">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-374">¶</a>
</div>
<p>We store our errorr callbacks here for processing after our library has finished loading.</p>
</div>
<div class="content"><div class='highlight'><pre> errorCallbacks: [me.normalizeFunctionSeries, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-375">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-375">¶</a>
</div>
<p>Exports for the module that we’ll check the global scope for to see if the module loaded properly.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-string">'exports'</span>: [me.normalizeStringSeries, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-376">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-376">¶</a>
</div>
<p>The identity of the module, for example: <code>css</code>, <code>img</code>, or <code>js</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> identitiy: [me.normalizeString, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-377">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-377">¶</a>
</div>
<p>If the factory of the module is a function, it’ll be invoked upon it’s first require then that state will be
saved. This flags whether or not the factory was invoked and saved.</p>
</div>
<div class="content"><div class='highlight'><pre> invoked: [me.normalizeBoolean, <span class="hljs-literal">false</span>],</pre></div></div>
</li>
<li id="section-378">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-378">¶</a>
</div>
<p>The value of our module. It’s value can be anything, example: <code>Array</code>, <code>Function</code>, <code>HTMLElement</code>, <code>Object</code>,
<code>String</code>, etc.</p>
</div>
<div class="content"><div class='highlight'><pre> factory: <span class="hljs-literal">null</span>,</pre></div></div>
</li>
<li id="section-379">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-379">¶</a>
</div>
<p>Must be either <code>null</code> or a <code>Function</code>. As soon as module is first used/referenced, this <code>Function</code> will
immediately be called upon if present.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-string">'init'</span>: [me.normalizeFunction, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-380">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-380">¶</a>
</div>
<p>Any loader data for the module will be stored here.</p>
</div>
<div class="content"><div class='highlight'><pre> loader: {</pre></div></div>
</li>
<li id="section-381">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-381">¶</a>
</div>
<p>Any URLs that failed to load will be stored here.</p>
</div>
<div class="content"><div class='highlight'><pre> failed: [me.normalizeStringSeries, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-382">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-382">¶</a>
</div>
<p>Whether or not we actually attempted to load this module.</p>
</div>
<div class="content"><div class='highlight'><pre> loaded: [me.normalizeBoolean, <span class="hljs-literal">false</span>],</pre></div></div>
</li>
<li id="section-383">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-383">¶</a>
</div>
<p>If a URL loaded sucecssfully, it will be stored here.</p>
</div>
<div class="content"><div class='highlight'><pre> success: [me.normalizeString, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-384">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-384">¶</a>
</div>
<p>The time that a module finished loading.</p>
</div>
<div class="content"><div class='highlight'><pre> timeEnd: [me.normalizeNumber, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-385">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-385">¶</a>
</div>
<p>The time that a module initiated it’s load sequence. This includes all loading for the module in question. For
example if a library had 3 fallback URLs, and the first 2 failed due to timeouts, and the 3rd was successful,
this variable would reflect the current time prior to the first 2 URLs failing.</p>
</div>
<div class="content"><div class='highlight'><pre> timeStart: [me.normalizeNumber, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-386">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-386">¶</a>
</div>
<p>Flags whether or not the module is currently in the process of loading.</p>
</div>
<div class="content"><div class='highlight'><pre> working: [me.normalizeBoolean, <span class="hljs-literal">false</span>]
},</pre></div></div>
</li>
<li id="section-387">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-387">¶</a>
</div>
<p>We store our errorr callbacks here for processing after our library has finished loading.</p>
</div>
<div class="content"><div class='highlight'><pre> successCallbacks: [me.normalizeFunctionSeries, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-388">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-388">¶</a>
</div>
<p>Where all the URLs are stored for our module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-string">'urls'</span>: [me.normalizeStringSeries, <span class="hljs-literal">null</span>],</pre></div></div>
</li>
<li id="section-389">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-389">¶</a>
</div>
<p>The version of our module.</p>
</div>
<div class="content"><div class='highlight'><pre> version: [me.normalizeString, <span class="hljs-literal">null</span>]
};
};</pre></div></div>
</li>
<li id="section-390">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-390">¶</a>
</div>
<p>All our module definitions will be stored and referenced through this <code>Object</code>. The keys of this <code>Object</code> correlate
to the modules actual name.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.definitions = {};</pre></div></div>
</li>
<li id="section-391">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-391">¶</a>
</div>
<p>Fetch the dependencies for an <code>Array</code> of modules that passed in. If <code>findNestedDependencies</code> is explicitly set to
<code>true</code>, then the <code>Function</code> will run a loop and fetch the full dependecy tree for all of the modules until all
dependencies have been exhausted and added to the queue.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.dependencies = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(modules, findNestedDependencies)</span> </span>{</pre></div></div>
</li>
<li id="section-392">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-392">¶</a>
</div>
<p>Store our queue of dependency modules.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> queue = [];</pre></div></div>
</li>
<li id="section-393">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-393">¶</a>
</div>
<p>Loop through and fetch our dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(modules, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName)</span> </span>{</pre></div></div>
</li>
<li id="section-394">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-394">¶</a>
</div>
<p>Reference our module definition.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> moduleInstance = <span class="hljs-built_in">module</span>(moduleName, <span class="hljs-literal">null</span>, <span class="hljs-literal">false</span>);</pre></div></div>
</li>
<li id="section-395">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-395">¶</a>
</div>
<p>If the module doesn’t exist, or there aren’t any dependencies, skip the iteration.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!moduleInstance || !moduleInstance.deps.length) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-396">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-396">¶</a>
</div>
<p>Queue our dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> queue = queue.concat(moduleInstance.deps);</pre></div></div>
</li>
<li id="section-397">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-397">¶</a>
</div>
<p>If we explicity want a loop of all our dependencies, then we’ll trace through them here.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (findNestedDependencies === <span class="hljs-literal">true</span>) {
queue = queue.concat(<span class="hljs-built_in">module</span>.dependencies(moduleInstance.deps, findNestedDependencies));
}
});</pre></div></div>
</li>
<li id="section-398">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-398">¶</a>
</div>
<p>Return all of our queued dependency modules.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> queue;
};</pre></div></div>
</li>
<li id="section-399">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-399">¶</a>
</div>
<p>Check to see whether a module exists by name.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.exists = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName)</span> </span>{</pre></div></div>
</li>
<li id="section-400">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-400">¶</a>
</div>
<p>Search the definitions <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(<span class="hljs-built_in">module</span>.definitions[<span class="hljs-built_in">module</span>.named(moduleName)])) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
}</pre></div></div>
</li>
<li id="section-401">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-401">¶</a>
</div>
<p>No module found.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
};</pre></div></div>
</li>
<li id="section-402">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-402">¶</a>
</div>
<p>Identify the type of module that we have. Example: CSS, Image, JavaScript, etc.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.identify = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName)</span> </span>{</pre></div></div>
</li>
<li id="section-403">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-403">¶</a>
</div>
<p>If we can’t identify the module, use our fallback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> fallback = <span class="hljs-built_in">module</span>.identify.fallback;</pre></div></div>
</li>
<li id="section-404">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-404">¶</a>
</div>
<p>If no <code>moduleName</code> was passed in, return the fallback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!moduleName) {
<span class="hljs-keyword">return</span> fallback;
}</pre></div></div>
</li>
<li id="section-405">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-405">¶</a>
</div>
<p>Split the <code>moduleName</code> on our <code>delimiter</code> which is derived from our configuration.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> split = moduleName.split(me.config.settings.delimiter);</pre></div></div>
</li>
<li id="section-406">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-406">¶</a>
</div>
<p>If we can’t find our delimiter, then return our fallback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (split.length < <span class="hljs-number">2</span> || me.indexOf(<span class="hljs-built_in">module</span>.identify.types, split[<span class="hljs-number">0</span>]) === -<span class="hljs-number">1</span>) {
<span class="hljs-keyword">return</span> fallback;
}</pre></div></div>
</li>
<li id="section-407">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-407">¶</a>
</div>
<p>Return our modules identity.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> split[<span class="hljs-number">0</span>];
};</pre></div></div>
</li>
<li id="section-408">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-408">¶</a>
</div>
<p>The identifier to fallback on if we cannot find a match.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.identify.fallback = <span class="hljs-string">'js'</span>;</pre></div></div>
</li>
<li id="section-409">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-409">¶</a>
</div>
<p>The support identifier types.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.identify.types = [<span class="hljs-string">'css'</span>, <span class="hljs-string">'img'</span>, <span class="hljs-string">'js'</span>];</pre></div></div>
</li>
<li id="section-410">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-410">¶</a>
</div>
<p>Invoke and return the invoked instance of the <code>factory</code> for our <code>module</code>, if the <code>factory</code> happens to be a
<code>Function</code>. If the <code>factory</code> is not a <code>Function</code>, we’ll simply return whatever value is set for the `factory.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.invoke = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName)</span> </span>{</pre></div></div>
</li>
<li id="section-411">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-411">¶</a>
</div>
<p>Fetch the instance of our <code>module</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> moduleInstance = <span class="hljs-built_in">module</span>(moduleName, <span class="hljs-literal">null</span>, <span class="hljs-literal">false</span>);</pre></div></div>
</li>
<li id="section-412">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-412">¶</a>
</div>
<p>If we couldn’t fetch an instance of our <code>module</code>, something went wrong, relay a message to the end user.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!moduleInstance) {
me.log(<span class="hljs-number">1</span>, <span class="hljs-string">'Module wasn\'t found!'</span>, moduleName);
<span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
}</pre></div></div>
</li>
<li id="section-413">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-413">¶</a>
</div>
<p>If the module hasn’t already been invoked, then invoke it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!moduleInstance.invoked) {</pre></div></div>
</li>
<li id="section-414">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-414">¶</a>
</div>
<p>Flag the module as invoked, so we don’t run through this step again.</p>
</div>
<div class="content"><div class='highlight'><pre> moduleInstance.invoked = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-415">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-415">¶</a>
</div>
<p>Reference the instance of our invoked <code>factory</code> as the <code>factory</code> value for the module.</p>
</div>
<div class="content"><div class='highlight'><pre> moduleInstance.factory = <span class="hljs-built_in">module</span>.invoke.factory(moduleInstance.factory, moduleInstance.deps);
}</pre></div></div>
</li>
<li id="section-416">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-416">¶</a>
</div>
<p>Return the invoked <code>factory</code> instance of the module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> moduleInstance.factory;
};</pre></div></div>
</li>
<li id="section-417">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-417">¶</a>
</div>
<p>Invoke all pending callbacks that are queued for a specific module.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.invoke.callbacks = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName, success)</span> </span>{</pre></div></div>
</li>
<li id="section-418">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-418">¶</a>
</div>
<p>Fetch the reference to our module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> moduleInstance = <span class="hljs-built_in">module</span>(moduleName, <span class="hljs-literal">null</span>, <span class="hljs-literal">false</span>);</pre></div></div>
</li>
<li id="section-419">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-419">¶</a>
</div>
<p>Determine which set of callbacks to invoke.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> reference = moduleInstance.errorCallbacks;</pre></div></div>
</li>
<li id="section-420">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-420">¶</a>
</div>
<p>If we’re invoking our success callbacks, then wipe the error callback references from memory.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (success) {
moduleInstance.errorCallbacks = [];
reference = moduleInstance.successCallbacks;
}</pre></div></div>
</li>
<li id="section-421">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-421">¶</a>
</div>
<p>If there are no callbacks, then halt the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(reference) || !reference.length) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-422">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-422">¶</a>
</div>
<p>Loop through end invoke each of the callbacks.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(reference, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(callback, index)</span> </span>{</pre></div></div>
</li>
<li id="section-423">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-423">¶</a>
</div>
<p>Invoke the callback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isFunction(callback)) {
callback();
}</pre></div></div>
</li>
<li id="section-424">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-424">¶</a>
</div>
<p>Remove the callback from the queue.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">delete</span> reference[index];
});
};</pre></div></div>
</li>
<li id="section-425">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-425">¶</a>
</div>
<p>Invoke a <code>factory</code> with the arguments being the dependencies that are passed in via the <code>deps</code> parameter.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.invoke.factory = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(factory, deps)</span> </span>{</pre></div></div>
</li>
<li id="section-426">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-426">¶</a>
</div>
<p>If the <code>factory</code> passed in is not a <code>Function</code>, then simply return it’s current value.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isFunction(factory)) {
<span class="hljs-keyword">return</span> factory;
}</pre></div></div>
</li>
<li id="section-427">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-427">¶</a>
</div>
<p>Invoke and return the invoked reference of our <code>factory</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> factory.apply(<span class="hljs-literal">null</span>, <span class="hljs-built_in">module</span>.references(deps));
};</pre></div></div>
</li>
<li id="section-428">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-428">¶</a>
</div>
<p>Fetch the actual name of a module. If a modules alias is passed in, this <code>Function</code> will fetch the modules name.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.named = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName)</span> </span>{</pre></div></div>
</li>
<li id="section-429">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-429">¶</a>
</div>
<p>Fetch our actual module name, in the case that the <code>Function</code> was passed an alias.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(<span class="hljs-built_in">module</span>.aliases[moduleName])) {
moduleName = <span class="hljs-built_in">module</span>.aliases[moduleName];
}</pre></div></div>
</li>
<li id="section-430">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-430">¶</a>
</div>
<p>Return the module name.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> moduleName;
};</pre></div></div>
</li>
<li id="section-431">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-431">¶</a>
</div>
<p>Invoke an <code>Array</code> of modules, and return each of their <code>factory</code> values in an <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.references = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(modules)</span> </span>{</pre></div></div>
</li>
<li id="section-432">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-432">¶</a>
</div>
<p>Store a list of our <code>factory</code> references.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> references = [];</pre></div></div>
</li>
<li id="section-433">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-433">¶</a>
</div>
<p>If no <code>modules</code> were passed into the <code>Function</code>, then simply return an empty <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!modules.length) {
<span class="hljs-keyword">return</span> references;
}</pre></div></div>
</li>
<li id="section-434">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-434">¶</a>
</div>
<p>Loop through and invoke each of our modules.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(modules, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleInstance)</span> </span>{</pre></div></div>
</li>
<li id="section-435">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-435">¶</a>
</div>
<p>Push the <code>factory</code> off to our <code>references</code> <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> references.push(<span class="hljs-built_in">module</span>.invoke(moduleInstance));
});</pre></div></div>
</li>
<li id="section-436">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-436">¶</a>
</div>
<p>Return our set of modules references.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> references;
};</pre></div></div>
</li>
<li id="section-437">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-437">¶</a>
</div>
<p>Normalize all of the URLs for our modules. This function will automatically prepend our base URLs and store them.
This has a few benefits: we don’t have to worry about processing the URLs later. We’re able to store a snapshot
of the current base URLs for the module in question, this way we can change our base URLs later and still maintain
and use a different set of base URLs with other modules.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.urls = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName, identity, urls)</span> </span>{</pre></div></div>
</li>
<li id="section-438">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-438">¶</a>
</div>
<p>Fetch the base URL for our module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> base = <span class="hljs-built_in">module</span>.base(identity) || <span class="hljs-string">''</span>;</pre></div></div>
</li>
<li id="section-439">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-439">¶</a>
</div>
<p>Store our extension string, for Node JS, don’t add an extension. @nodejs</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> extension = <span class="hljs-string">'.'</span> + identity;</pre></div></div>
</li>
<li id="section-440">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-440">¶</a>
</div>
<p>If we don’t have any URLs, then set the URLs to a AMD.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!urls.length) {
<span class="hljs-keyword">return</span> [base + moduleName + extension];
}</pre></div></div>
</li>
<li id="section-441">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-441">¶</a>
</div>
<p>Store our set of normalized URLs that we’ll reference.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> normalizedUrls = [];</pre></div></div>
</li>
<li id="section-442">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-442">¶</a>
</div>
<p>Loop through each of the URLs.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(urls, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(url)</span> </span>{</pre></div></div>
</li>
<li id="section-443">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-443">¶</a>
</div>
<p>If the URL we’re examining doesn’t have an extension then automatically add it. If the <code>identity</code> of the module
happens to be an image, then the user must pass in an extension. We cannot assume the extension of image files
types, but we can for CSS and JavaScript files.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (identity !== <span class="hljs-string">'img'</span> && url.substr(-extension.length) !== extension) {
url += extension;
}</pre></div></div>
</li>
<li id="section-444">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-444">¶</a>
</div>
<p>If we have a <code>base</code> URL and it’s not prefixed with a match from our ignore list, then prepend the base URL.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (base && !me.isPrefixed(url, <span class="hljs-built_in">module</span>.urls.ignore)) {
url = base + url;
}</pre></div></div>
</li>
<li id="section-445">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-445">¶</a>
</div>
<p>Push the normalized URL off to our list.</p>
</div>
<div class="content"><div class='highlight'><pre> normalizedUrls.push(url);
});</pre></div></div>
</li>
<li id="section-446">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-446">¶</a>
</div>
<p>Return the set of our normalized URLs.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> normalizedUrls;
};</pre></div></div>
</li>
<li id="section-447">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-447">¶</a>
</div>
<p>URL prefixes to specifically ignore from prepending with our base URL.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">module</span>.urls.ignore = [<span class="hljs-string">'/'</span>, <span class="hljs-string">'data:'</span>, <span class="hljs-string">'http://'</span>, <span class="hljs-string">'https://'</span>];</pre></div></div>
</li>
<li id="section-448">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-448">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.module = <span class="hljs-built_in">module</span>;</pre></div></div>
</li>
<li id="section-449">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-449">¶</a>
</div>
<p>Generate a normalization function based on the type that is passed in. For example if a type of <code>String</code> was passed
in, the function <code>normalizeString</code> would be generated for the library. The purpose of these functions are to
normalize any data that’s passed into them. If you try to pass an <code>Array</code> to <code>normalizeString</code>, the function would
then return the <code>fallback</code> value that is specified; if no <code>fallback</code> value is specified it would then return <code>null</code>.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> normalize = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input, type, fallback)</span> </span>{</pre></div></div>
</li>
<li id="section-450">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-450">¶</a>
</div>
<p>Declare our function name;</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> functionName = <span class="hljs-string">'is'</span> + type;</pre></div></div>
</li>
<li id="section-451">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-451">¶</a>
</div>
<p>If an invalid <code>type</code> is passed in to our function, return our <code>fallback</code> or <code>null</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isFunction(me[functionName])) {
<span class="hljs-keyword">return</span> me.isDefined(fallback) ? fallback : <span class="hljs-literal">null</span>;
}
<span class="hljs-keyword">return</span> me[functionName](input) ? input : fallback;
};</pre></div></div>
</li>
<li id="section-452">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-452">¶</a>
</div>
<p>Perform normalization on a series of data types. It provides the same functionality as the <code>normalize</code> function but
it expects to receive of an <code>Array</code> series of data sets.</p>
</div>
<div class="content"><div class='highlight'><pre>normalize.series = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input, type, fallback, strip)</span> </span>{</pre></div></div>
</li>
<li id="section-453">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-453">¶</a>
</div>
<p>Store our normalized series.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> normalized = [];</pre></div></div>
</li>
<li id="section-454">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-454">¶</a>
</div>
<p>Case our input to an array/series.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(input)) {
input = [input];
}</pre></div></div>
</li>
<li id="section-455">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-455">¶</a>
</div>
<p>Loop through eaach of our values. For legacy browsers, if <code>undefined</code> is part of an <code>Array</code> and you use a <code>for in</code>,
the iteration for <code>undefined</code> won’t show up in the loop! This is a fallback for those browsers! Wow! @ie</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index < input.length; index++) {</pre></div></div>
</li>
<li id="section-456">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-456">¶</a>
</div>
<p>Normalize our value.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> value = me.normalize(input[index], type, fallback);</pre></div></div>
</li>
<li id="section-457">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-457">¶</a>
</div>
<p>If strip is not explicity set in, and the <code>value</code> is <code>undefined</code> or <code>null</code>, it’ll be removed from the normalized
result set.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (strip !== <span class="hljs-literal">false</span> && (!me.isDefined(value) || value === <span class="hljs-literal">null</span>)) {
<span class="hljs-keyword">continue</span>;
}</pre></div></div>
</li>
<li id="section-458">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-458">¶</a>
</div>
<p>Set our normalized value.</p>
</div>
<div class="content"><div class='highlight'><pre> normalized.push(value);
}</pre></div></div>
</li>
<li id="section-459">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-459">¶</a>
</div>
<p>Return our normalized series.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> normalized;
};</pre></div></div>
</li>
<li id="section-460">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-460">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.normalize = normalize;</pre></div></div>
</li>
<li id="section-461">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-461">¶</a>
</div>
<p>Run a number of functions in parallel with the ability to call a single callback once they’ve all completed.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> parallel = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(factories, callback)</span> </span>{</pre></div></div>
</li>
<li id="section-462">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-462">¶</a>
</div>
<p>Our <code>factories</code> argument must be an <code>Array</code>, if not halt the function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(factories)) {
callback();
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-463">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-463">¶</a>
</div>
<p>Normalize our <code>factories</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> factories = me.normalizeFunctionSeries(factories, <span class="hljs-literal">null</span>, <span class="hljs-literal">true</span>);</pre></div></div>
</li>
<li id="section-464">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-464">¶</a>
</div>
<p>Generate a new queue instance.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> guid = parallel.generate(factories.length);</pre></div></div>
</li>
<li id="section-465">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-465">¶</a>
</div>
<p>Loop through all of our refernces and execute them.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(factories, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(factory)</span> </span>{</pre></div></div>
</li>
<li id="section-466">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-466">¶</a>
</div>
<p>Anonymous spawn and track our <code>Function</code> to invoke.</p>
</div>
<div class="content"><div class='highlight'><pre> parallel.anonymous(factory, guid, callback);
});
};</pre></div></div>
</li>
<li id="section-467">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-467">¶</a>
</div>
<p>Our anonymous functions that we’re executing in parallel.</p>
</div>
<div class="content"><div class='highlight'><pre>parallel.anonymous = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(factory, guid, callback)</span> </span>{</pre></div></div>
</li>
<li id="section-468">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-468">¶</a>
</div>
<p>If our <code>factory</code> parameter isn’t a <code>Function</code>, halt the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isFunction(factory)) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-469">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-469">¶</a>
</div>
<p>Normalize our <code>guid</code> parameter.</p>
</div>
<div class="content"><div class='highlight'><pre> guid = me.normalizeString(guid, me.guid(<span class="hljs-literal">true</span>));</pre></div></div>
</li>
<li id="section-470">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-470">¶</a>
</div>
<p>Normalize our <code>callback</code> paramter.</p>
</div>
<div class="content"><div class='highlight'><pre> callback = me.normalizeFunction(callback);</pre></div></div>
</li>
<li id="section-471">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-471">¶</a>
</div>
<p>Invoke our queued function.</p>
</div>
<div class="content"><div class='highlight'><pre> factory(<span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-472">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-472">¶</a>
</div>
<p>Reference the instance of our parallel runner.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> queue = parallel.queue[guid];</pre></div></div>
</li>
<li id="section-473">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-473">¶</a>
</div>
<p>If the <code>guid</code> is not defined in our queue, then it was cancelled.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isDefined(queue)) {
<span class="hljs-keyword">return</span> callback(<span class="hljs-literal">false</span>);
}</pre></div></div>
</li>
<li id="section-474">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-474">¶</a>
</div>
<p>Increment our callback invocation count.</p>
</div>
<div class="content"><div class='highlight'><pre> queue.interval++;</pre></div></div>
</li>
<li id="section-475">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-475">¶</a>
</div>
<p>If all of our functions ran successful, process our final callback and clear our memory of the queue.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (queue.interval === queue.length) {</pre></div></div>
</li>
<li id="section-476">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-476">¶</a>
</div>
<p>Remove our runner instance from the queue.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">delete</span> parallel.queue[guid];</pre></div></div>
</li>
<li id="section-477">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-477">¶</a>
</div>
<p>Fire off our final callback, as the queue has been exhausted.</p>
</div>
<div class="content"><div class='highlight'><pre> callback(<span class="hljs-literal">true</span>);
}
});
};</pre></div></div>
</li>
<li id="section-478">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-478">¶</a>
</div>
<p>Generate a new parallel instance into our queue.</p>
</div>
<div class="content"><div class='highlight'><pre>parallel.generate = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(length)</span> </span>{</pre></div></div>
</li>
<li id="section-479">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-479">¶</a>
</div>
<p>Generate a unique identifier for our parallel instance to avoid collisions.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> guid = me.guid(<span class="hljs-literal">true</span>);</pre></div></div>
</li>
<li id="section-480">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-480">¶</a>
</div>
<p>Add the our <code>references</code> to our parallel queue.</p>
</div>
<div class="content"><div class='highlight'><pre> parallel.queue[guid] = {</pre></div></div>
</li>
<li id="section-481">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-481">¶</a>
</div>
<p>The number of callbacks that were invoked.</p>
</div>
<div class="content"><div class='highlight'><pre> interval: <span class="hljs-number">0</span>,</pre></div></div>
</li>
<li id="section-482">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-482">¶</a>
</div>
<p>The total number of callbacks to run in parralel.</p>
</div>
<div class="content"><div class='highlight'><pre> length: length
};
<span class="hljs-keyword">return</span> guid;
};</pre></div></div>
</li>
<li id="section-483">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-483">¶</a>
</div>
<p>Container <code>Object</code> for all of the currently running parallel jobs.</p>
</div>
<div class="content"><div class='highlight'><pre>parallel.queue = {};</pre></div></div>
</li>
<li id="section-484">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-484">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.parallel = parallel;</pre></div></div>
</li>
<li id="section-485">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-485">¶</a>
</div>
<p>Load up and invoke our modules along with all of their dependencies. This function will first find all dependencies
for our modules and then attempt to load and invoke them from least to most dependent. This procedure needs to
happen in 2 separate operations due to the possibility of anonymous modules having their own dependencies that we
don’t actually know about until after we’ve loaded it’s file.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-comment">/* eslint-disable */</span>
<span class="hljs-keyword">var</span> <span class="hljs-built_in">require</span> = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
<span class="hljs-comment">/* eslint-enable */</span></pre></div></div>
</li>
<li id="section-486">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-486">¶</a>
</div>
<p>Fetch and normalize the argument that were passed in.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> args = me.amd.args(<span class="hljs-built_in">arguments</span>, <span class="hljs-built_in">require</span>.args.router, <span class="hljs-built_in">require</span>.args.normalize, {
error: <span class="hljs-literal">null</span>,
deps: <span class="hljs-literal">null</span>,
factory: <span class="hljs-literal">null</span>
});</pre></div></div>
</li>
<li id="section-487">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-487">¶</a>
</div>
<p>Boot up our dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">require</span>.boot(args.deps, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-488">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-488">¶</a>
</div>
<p>At this point all of our dependencies have loaded, now we need to go ahead and invoke all of our dependencies in
an order from least to most dependent, that way our initial <code>require</code> being requested can be invoked.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">require</span>.invoke(args.deps);</pre></div></div>
</li>
<li id="section-489">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-489">¶</a>
</div>
<p>Invoke our <code>factory</code> function with it’s required dependency references.</p>
</div>
<div class="content"><div class='highlight'><pre> me.module.invoke.factory(args.factory, args.deps);
}, args.error);
};</pre></div></div>
</li>
<li id="section-490">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-490">¶</a>
</div>
<p>Load up all of our dependencies, along with any nested dependencies in the order of least to most dependent.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.boot = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(modules, successCallback, errorCallback)</span> </span>{</pre></div></div>
</li>
<li id="section-491">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-491">¶</a>
</div>
<p>If our <code>deps</code> argument was malformed or empty, invoke our callback and halt the function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(modules) || !modules.length) {
successCallback();
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-492">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-492">¶</a>
</div>
<p>Boot up our anonymous modules first. If we’re booting, halt the function and we’ll loop back around.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">require</span>.boot.anonymous(modules, successCallback, errorCallback)) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-493">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-493">¶</a>
</div>
<p>Boot our dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">require</span>.boot.dependencies(modules, successCallback, errorCallback);
};</pre></div></div>
</li>
<li id="section-494">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-494">¶</a>
</div>
<p>Check to see if there’s any anonymous modules waiting to be loaded, if there is, then we’ll load them.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.boot.anonymous = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(modules, successCallback, errorCallback)</span> </span>{</pre></div></div>
</li>
<li id="section-495">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-495">¶</a>
</div>
<p>Store our anonymous module that we need to load.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> queue = <span class="hljs-built_in">require</span>.boot.anonymous.queue(modules);</pre></div></div>
</li>
<li id="section-496">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-496">¶</a>
</div>
<p>If we have any anonymous modules that we need to load, do it now, then loop back around.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (queue.length) {
<span class="hljs-built_in">require</span>.loop(queue, modules, successCallback, errorCallback);</pre></div></div>
</li>
<li id="section-497">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-497">¶</a>
</div>
<p>Explicitly return <code>true</code> so that we don’t halt the loop.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
}</pre></div></div>
</li>
<li id="section-498">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-498">¶</a>
</div>
<p>By returning <code>false</code> we’ll halt the anonymous module loop check.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
};</pre></div></div>
</li>
<li id="section-499">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-499">¶</a>
</div>
<p>Check to see if we have any dependencies which are anonymous modules that’ve yet to be loaded.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.boot.anonymous.queue = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(modules)</span> </span>{</pre></div></div>
</li>
<li id="section-500">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-500">¶</a>
</div>
<p>Store our queue of anonymous modules.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> queue = [];</pre></div></div>
</li>
<li id="section-501">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-501">¶</a>
</div>
<p>Loop through and fetch our dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(modules, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName)</span> </span>{</pre></div></div>
</li>
<li id="section-502">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-502">¶</a>
</div>
<p>Reference our module definition.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> <span class="hljs-built_in">module</span> = me.module(moduleName, <span class="hljs-literal">null</span>, <span class="hljs-literal">false</span>);</pre></div></div>
</li>
<li id="section-503">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-503">¶</a>
</div>
<p>If our module doesn’t exist, then it’s a anonymous module that we need to load up first to find out what
dependencies are actually required for it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!<span class="hljs-built_in">module</span>) {</pre></div></div>
</li>
<li id="section-504">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-504">¶</a>
</div>
<p>Push the module off to our anonymous list.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">require</span>.anonymous.push(moduleName);</pre></div></div>
</li>
<li id="section-505">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-505">¶</a>
</div>
<p>Setup the configuration for our anonymous module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">require</span>.config(moduleName);</pre></div></div>
</li>
<li id="section-506">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-506">¶</a>
</div>
<p>Push the module off to our queue.</p>
</div>
<div class="content"><div class='highlight'><pre> queue.push(moduleName);</pre></div></div>
</li>
<li id="section-507">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-507">¶</a>
</div>
<p>Don’t pass this point, as we can’t figure out the dependencies for our module yet.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-508">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-508">¶</a>
</div>
<p>Loop and find any dependencies that are anonymous modules as well and queue them.</p>
</div>
<div class="content"><div class='highlight'><pre> queue = queue.concat(<span class="hljs-built_in">require</span>.boot.anonymous.queue(<span class="hljs-built_in">module</span>.deps));
});</pre></div></div>
</li>
<li id="section-509">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-509">¶</a>
</div>
<p>Return all of our queued anonymous modules.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> queue;
};</pre></div></div>
</li>
<li id="section-510">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-510">¶</a>
</div>
<p>Load up all of the dependencies for the modules that are passed in.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.boot.dependencies = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(modules, successCallback, errorCallback)</span> </span>{</pre></div></div>
</li>
<li id="section-511">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-511">¶</a>
</div>
<p>Fetch all of the dependencies for our modules.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> dependencies = me.module.dependencies(modules);</pre></div></div>
</li>
<li id="section-512">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-512">¶</a>
</div>
<p>Loop around until we find the start of our dependency tree.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (dependencies.length) {</pre></div></div>
</li>
<li id="section-513">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-513">¶</a>
</div>
<p>If we have dependencies, we’re not at the start of the tree, keep looping around.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-built_in">require</span>.boot(dependencies, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-514">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-514">¶</a>
</div>
<p>Load the modules.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">require</span>.module(modules, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-515">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-515">¶</a>
</div>
<p>Fetch the dependencies for our modules again.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> newDependencies = me.module.dependencies(modules);</pre></div></div>
</li>
<li id="section-516">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-516">¶</a>
</div>
<p>Determine if there are any new dependencies, since we’ve loaded our set of modules.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (newDependencies.join() !== dependencies.join()) {</pre></div></div>
</li>
<li id="section-517">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-517">¶</a>
</div>
<p>Load up our new dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-built_in">require</span>.boot(newDependencies, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-518">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-518">¶</a>
</div>
<p>Loop back around to see if any new dependencies have loaded from our set of newly loaded dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">require</span>.module(modules, successCallback, errorCallback);
});
}</pre></div></div>
</li>
<li id="section-519">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-519">¶</a>
</div>
<p>If we didn’t have any new dependencies, then run our callback.</p>
</div>
<div class="content"><div class='highlight'><pre> successCallback();
}, errorCallback);
}, errorCallback);
}</pre></div></div>
</li>
<li id="section-520">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-520">¶</a>
</div>
<p>Load the start of our dependency tree.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">require</span>.module(modules, successCallback, errorCallback);
};</pre></div></div>
</li>
<li id="section-521">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-521">¶</a>
</div>
<p>Route and normalize the arguments that are passed into our <code>require</code> function. The arguments for our <code>require</code>
<code>Function</code> can be sent in a number of different forms.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.args = {};</pre></div></div>
</li>
<li id="section-522">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-522">¶</a>
</div>
<p>Normalize the arguments payload.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.args.normalize = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(payload)</span> </span>{</pre></div></div>
</li>
<li id="section-523">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-523">¶</a>
</div>
<p>Normalize the <code>error</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.error = me.normalizeFunction(payload.error, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{});</pre></div></div>
</li>
<li id="section-524">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-524">¶</a>
</div>
<p>Normamlize the <code>dependencies</code> <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.deps = payload.deps ? me.normalizeStringSeries(payload.deps) : <span class="hljs-literal">null</span>;</pre></div></div>
</li>
<li id="section-525">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-525">¶</a>
</div>
<p>Normalize the <code>factory</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.factory = me.normalizeFunction(payload.factory);</pre></div></div>
</li>
<li id="section-526">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-526">¶</a>
</div>
<p>Return the noramlized <code>payload</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-527">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-527">¶</a>
</div>
<p>Route the arguments passed into the <code>require</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.args.router = [];</pre></div></div>
</li>
<li id="section-528">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-528">¶</a>
</div>
<p>Handle no arguments being passed into the <code>require</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.args.router[<span class="hljs-number">0</span>] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, payload)</span> </span>{</pre></div></div>
</li>
<li id="section-529">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-529">¶</a>
</div>
<p>Throw an error to the end user.</p>
</div>
<div class="content"><div class='highlight'><pre> me.log(<span class="hljs-number">1</span>, <span class="hljs-string">'require'</span>, <span class="hljs-string">'args'</span>, <span class="hljs-string">'No arguments were passed into `require`! Halting!'</span>, args);</pre></div></div>
</li>
<li id="section-530">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-530">¶</a>
</div>
<p>Return our factored payload.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-531">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-531">¶</a>
</div>
<p>Handle 1 argument being passed into the <code>require</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.args.router[<span class="hljs-number">1</span>] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, payload)</span> </span>{</pre></div></div>
</li>
<li id="section-532">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-532">¶</a>
</div>
<p>If it’s a <code>Function</code>, derive our dependencies from it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isFunction(args[<span class="hljs-number">0</span>])) {</pre></div></div>
</li>
<li id="section-533">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-533">¶</a>
</div>
<p>Reference the factory.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.factory = args[<span class="hljs-number">0</span>];</pre></div></div>
</li>
<li id="section-534">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-534">¶</a>
</div>
<p>If it’s an <code>Array</code> or <code>String</code> it’s the <code>dependencies</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (me.isaArray(args[<span class="hljs-number">0</span>]) || me.isString(args[<span class="hljs-number">0</span>])) {
payload.deps = args[<span class="hljs-number">0</span>];</pre></div></div>
</li>
<li id="section-535">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-535">¶</a>
</div>
<p>If none of the criteria above matched, then the arguments are malformed.</p>
</div>
<div class="content"><div class='highlight'><pre> } <span class="hljs-keyword">else</span> {
me.log(<span class="hljs-number">1</span>, <span class="hljs-string">'require'</span>, <span class="hljs-string">'args'</span>, <span class="hljs-string">'1 argument was passed into `require` that was malformed! Discarding!'</span>, args);
}</pre></div></div>
</li>
<li id="section-536">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-536">¶</a>
</div>
<p>Return our factored payload.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-537">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-537">¶</a>
</div>
<p>Handle 2 arguments being passed into the <code>require</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.args.router[<span class="hljs-number">2</span>] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, payload)</span> </span>{</pre></div></div>
</li>
<li id="section-538">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-538">¶</a>
</div>
<p>If both arguments are a <code>Function</code> then treat them as the <code>factory</code> and <code>error</code> callbacks.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isFunction(args[<span class="hljs-number">0</span>]) && me.isFunction(args[<span class="hljs-number">1</span>])) {</pre></div></div>
</li>
<li id="section-539">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-539">¶</a>
</div>
<p>Reference the <code>error</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.error = args[<span class="hljs-number">1</span>];</pre></div></div>
</li>
<li id="section-540">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-540">¶</a>
</div>
<p>Reference the <code>factory</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.factory = me.normalizeFunction(args[<span class="hljs-number">0</span>]);</pre></div></div>
</li>
<li id="section-541">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-541">¶</a>
</div>
<p>Otherwise treat the arguments as the <code>dependencies</code> and <code>factory</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (me.isaArray(args[<span class="hljs-number">0</span>]) || me.isString(args[<span class="hljs-number">0</span>])) {</pre></div></div>
</li>
<li id="section-542">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-542">¶</a>
</div>
<p>Reference the <code>dependencies</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.deps = args[<span class="hljs-number">0</span>];</pre></div></div>
</li>
<li id="section-543">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-543">¶</a>
</div>
<p>Reference the <code>factory</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.factory = args[<span class="hljs-number">1</span>];</pre></div></div>
</li>
<li id="section-544">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-544">¶</a>
</div>
<p>If none of the criteria above matched, then the arguments are malformed.</p>
</div>
<div class="content"><div class='highlight'><pre> } <span class="hljs-keyword">else</span> {
me.log(<span class="hljs-number">1</span>, <span class="hljs-string">'require'</span>, <span class="hljs-string">'args'</span>, <span class="hljs-string">'2 arguments were passed into `require` that were malformed! Discarding!'</span>, args);
}</pre></div></div>
</li>
<li id="section-545">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-545">¶</a>
</div>
<p>Return our factored payload.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-546">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-546">¶</a>
</div>
<p>Handle 3 arguments being passed into the <code>require</code> <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.args.router[<span class="hljs-number">3</span>] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(args, payload)</span> </span>{</pre></div></div>
</li>
<li id="section-547">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-547">¶</a>
</div>
<p>Reference the <code>dependencies</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.deps = args[<span class="hljs-number">0</span>];</pre></div></div>
</li>
<li id="section-548">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-548">¶</a>
</div>
<p>Reference the <code>factory</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.factory = me.normalizeFunction(args[<span class="hljs-number">1</span>]);</pre></div></div>
</li>
<li id="section-549">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-549">¶</a>
</div>
<p>Reference the <code>error</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> payload.error = me.normalizeFunction(args[<span class="hljs-number">2</span>]);</pre></div></div>
</li>
<li id="section-550">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-550">¶</a>
</div>
<p>Return our factored payload.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> payload;
};</pre></div></div>
</li>
<li id="section-551">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-551">¶</a>
</div>
<p>List of anonymously required modules.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.anonymous = [];</pre></div></div>
</li>
<li id="section-552">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-552">¶</a>
</div>
<p>Configure an anonymous module with a path and definition.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.config = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName)</span> </span>{</pre></div></div>
</li>
<li id="section-553">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-553">¶</a>
</div>
<p>If we don’t have a <code>moduleName</code>, then the invocation was malformed. Halt the function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!moduleName) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}</pre></div></div>
</li>
<li id="section-554">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-554">¶</a>
</div>
<p>Create our <code>Object</code> that we’ll pass to our configuration <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> config = {
libs: {}
};</pre></div></div>
</li>
<li id="section-555">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-555">¶</a>
</div>
<p>Set our URL to be relative to our configurations <code>base</code> variable.</p>
</div>
<div class="content"><div class='highlight'><pre> config.libs[moduleName] = {
amd: <span class="hljs-literal">true</span>,
urls: moduleName
};</pre></div></div>
</li>
<li id="section-556">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-556">¶</a>
</div>
<p>Pass the anonymous module over to our configuration to generate the module and URLs.</p>
</div>
<div class="content"><div class='highlight'><pre> me.config(config);
};</pre></div></div>
</li>
<li id="section-557">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-557">¶</a>
</div>
<p>Assumes that all depdendencies being passed into the <code>deps</code> parameter have already been loaded. The sole purpose of
this <code>Function</code> is to simply invoke the factories for each of the dependencies if they haven’t already been invoked.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.invoke = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(deps)</span> </span>{</pre></div></div>
</li>
<li id="section-558">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-558">¶</a>
</div>
<p>Fetch any dependencies of our dependencies.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> dependencies = me.module.dependencies(deps, <span class="hljs-literal">true</span>);</pre></div></div>
</li>
<li id="section-559">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-559">¶</a>
</div>
<p>Reverse our dependency list as our fetcher method loops through finding most to least dependent, we actually need
to invoke each <code>factory</code> from least to most dependent.</p>
</div>
<div class="content"><div class='highlight'><pre> dependencies.reverse();</pre></div></div>
</li>
<li id="section-560">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-560">¶</a>
</div>
<p>Append our initial dependencies to the bottom of our list to be invoked last.</p>
</div>
<div class="content"><div class='highlight'><pre> dependencies = dependencies.concat(deps);</pre></div></div>
</li>
<li id="section-561">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-561">¶</a>
</div>
<p>Loop through each of the dependencies in our list that we need to invoke.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(dependencies, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(dependency)</span> </span>{</pre></div></div>
</li>
<li id="section-562">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-562">¶</a>
</div>
<p>Invoke our dependency.</p>
</div>
<div class="content"><div class='highlight'><pre> me.module.invoke(dependency);
});
};</pre></div></div>
</li>
<li id="section-563">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-563">¶</a>
</div>
<p>Load up a queue of modules, then run <code>require.boot</code> to check and make sure all modules along with their dependencies
have successfully loaded. This <code>Function</code> is being to used to exhaust all dependencies. In the case of anonymous
modules, we may load up a file and find out we have new dependencies that must be loaded, this <code>Function</code> is taking
care of that.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.loop = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(queue, modules, successCallback, errorCallback)</span> </span>{</pre></div></div>
</li>
<li id="section-564">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-564">¶</a>
</div>
<p>Load any modules in our queue.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">require</span>.module(queue, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-565">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-565">¶</a>
</div>
<p>Run back to <code>require.boot</code> and attempt to boot up the modules originally requested.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-built_in">require</span>.boot(modules, successCallback, errorCallback);
}, errorCallback);
};</pre></div></div>
</li>
<li id="section-566">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-566">¶</a>
</div>
<p>Load up an <code>Array</code> of modules simultaneously.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.module = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(modules, successCallback, errorCallback)</span> </span>{</pre></div></div>
</li>
<li id="section-567">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-567">¶</a>
</div>
<p>If we have no <code>modules</code>, then invoke our callback and halt the function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(modules) || !modules.length) {
successCallback();
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-568">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-568">¶</a>
</div>
<p>Store an <code>Array</code> of functions that we’ll run simultaneously.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> queue = [];</pre></div></div>
</li>
<li id="section-569">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-569">¶</a>
</div>
<p>Loop and queue each of our modules.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(modules, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName)</span> </span>{</pre></div></div>
</li>
<li id="section-570">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-570">¶</a>
</div>
<p>Push our anonymous <code>Function</code> off to our parallel queue.</p>
</div>
<div class="content"><div class='highlight'><pre> queue.push(<span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(callback)</span> </span>{</pre></div></div>
</li>
<li id="section-571">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-571">¶</a>
</div>
<p>Load the module.</p>
</div>
<div class="content"><div class='highlight'><pre> me.module.boot(moduleName, callback, callback);
});
});</pre></div></div>
</li>
<li id="section-572">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-572">¶</a>
</div>
<p>Invoke the queue along with the callback handler.</p>
</div>
<div class="content"><div class='highlight'><pre> me.parallel(queue, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
<span class="hljs-built_in">require</span>.module.callback(modules, successCallback, errorCallback);
});
};</pre></div></div>
</li>
<li id="section-573">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-573">¶</a>
</div>
<p>Handle the callback after loading modules to check if there were errors.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-built_in">require</span>.module.callback = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(modules, successCallback, errorCallback)</span> </span>{</pre></div></div>
</li>
<li id="section-574">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-574">¶</a>
</div>
<p>Store any errors in this <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> errors = [];</pre></div></div>
</li>
<li id="section-575">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-575">¶</a>
</div>
<p>Loop through each of modules and see if there were any errors.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(modules, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(moduleName)</span> </span>{</pre></div></div>
</li>
<li id="section-576">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-576">¶</a>
</div>
<p>Fetch a reference of the module.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> <span class="hljs-built_in">module</span> = me.module(moduleName);</pre></div></div>
</li>
<li id="section-577">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-577">¶</a>
</div>
<p>If there’s no successful, but there are failed URLs, then the module failed to load.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!<span class="hljs-built_in">module</span>.loader.success && <span class="hljs-built_in">module</span>.loader.failed.length) {
errors.push({
<span class="hljs-built_in">module</span>: moduleName,
message: <span class="hljs-string">'Failed to load.'</span>
});
}
});</pre></div></div>
</li>
<li id="section-578">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-578">¶</a>
</div>
<p>If we have errors, fire off our error callback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (errors.length) {
<span class="hljs-keyword">return</span> errorCallback(errors);
}</pre></div></div>
</li>
<li id="section-579">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-579">¶</a>
</div>
<p>Fallback on our success callback.</p>
</div>
<div class="content"><div class='highlight'><pre> successCallback();
};</pre></div></div>
</li>
<li id="section-580">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-580">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.require = <span class="hljs-built_in">require</span>;</pre></div></div>
</li>
<li id="section-581">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-581">¶</a>
</div>
<p>Output the configured libraries, their load times and other useful statistics for the end user.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> stats = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-582">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-582">¶</a>
</div>
<p>Line separator <code>String</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> separator = <span class="hljs-string">'\n'</span> + <span class="hljs-keyword">new</span> <span class="hljs-built_in">Array</span>(<span class="hljs-number">280</span>).join(<span class="hljs-string">'-'</span>) + <span class="hljs-string">'\n'</span>;</pre></div></div>
</li>
<li id="section-583">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-583">¶</a>
</div>
<p>Padding <code>String</code> that we’ll use for our output string.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> padding30 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Array</span>(<span class="hljs-number">30</span>).join(<span class="hljs-string">' '</span>);</pre></div></div>
</li>
<li id="section-584">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-584">¶</a>
</div>
<p>Padding <code>String</code> that we’ll use for our output string.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> padding60 = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Array</span>(<span class="hljs-number">60</span>).join(<span class="hljs-string">' '</span>);</pre></div></div>
</li>
<li id="section-585">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-585">¶</a>
</div>
<p>Generate the banner for our output.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> output = stats.banner(separator, padding30, padding60);</pre></div></div>
</li>
<li id="section-586">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-586">¶</a>
</div>
<p>Generate the heading of our output.</p>
</div>
<div class="content"><div class='highlight'><pre> output += stats.head(separator, padding30, padding60);</pre></div></div>
</li>
<li id="section-587">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-587">¶</a>
</div>
<p>The body of our statistics table.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(me.module.definitions, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, key)</span> </span>{
output += stats.row(key, value, padding30, padding60);
});</pre></div></div>
</li>
<li id="section-588">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-588">¶</a>
</div>
<p>Return our output <code>String</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> output;
};
stats.banner = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(separator, padding30, padding60)</span> </span>{
<span class="hljs-keyword">var</span> output = <span class="hljs-string">'\n'</span>;</pre></div></div>
</li>
<li id="section-589">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-589">¶</a>
</div>
<p>Add our banner to the output string.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.banner.length === <span class="hljs-number">8</span>) {</pre></div></div>
</li>
<li id="section-590">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-590">¶</a>
</div>
<p>Minified version of the library.</p>
</div>
<div class="content"><div class='highlight'><pre> output += me.stringPad(me.banner, padding60, <span class="hljs-literal">true</span>) + <span class="hljs-string">'\n'</span>;
} <span class="hljs-keyword">else</span> {</pre></div></div>
</li>
<li id="section-591">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-591">¶</a>
</div>
<p>Non-minified version of the library.</p>
</div>
<div class="content"><div class='highlight'><pre> output += me.banner;
}</pre></div></div>
</li>
<li id="section-592">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-592">¶</a>
</div>
<p>Add the version to the bnaner.</p>
</div>
<div class="content"><div class='highlight'><pre> output += <span class="hljs-string">'\n'</span> + me.stringPad(<span class="hljs-string">'v'</span> + me.version, padding60, <span class="hljs-literal">true</span>) + <span class="hljs-string">'\n'</span>;</pre></div></div>
</li>
<li id="section-593">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-593">¶</a>
</div>
<p>Add the homepage to the banner.</p>
</div>
<div class="content"><div class='highlight'><pre> output += <span class="hljs-string">'\n'</span> + me.stringPad(me.homepage, padding60, <span class="hljs-literal">true</span>) + <span class="hljs-string">'\n'</span>;</pre></div></div>
</li>
<li id="section-594">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-594">¶</a>
</div>
<p>Separate the banner from the head column titles.</p>
</div>
<div class="content"><div class='highlight'><pre> output += separator;
<span class="hljs-keyword">return</span> output;
};</pre></div></div>
</li>
<li id="section-595">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-595">¶</a>
</div>
<p>Heading of the statistics output.</p>
</div>
<div class="content"><div class='highlight'><pre>stats.head = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(separator, padding30, padding60)</span> </span>{</pre></div></div>
</li>
<li id="section-596">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-596">¶</a>
</div>
<p>The table head column titles.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> output = me.stringPad(<span class="hljs-string">'Library'</span>, padding60);
output += me.stringPad(<span class="hljs-string">'Version'</span>, padding30);
output += me.stringPad(<span class="hljs-string">'Type'</span>, padding30);
output += me.stringPad(<span class="hljs-string">'Time'</span>, padding30);
output += me.stringPad(<span class="hljs-string">'Loaded'</span>, padding30);
output += me.stringPad(<span class="hljs-string">'Invoked'</span>, padding30);
output += me.stringPad(<span class="hljs-string">'Failed'</span>, padding30);
output += <span class="hljs-string">'Success'</span>;
output += separator;</pre></div></div>
</li>
<li id="section-597">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-597">¶</a>
</div>
<p>Return the heading.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> output;
};
stats.row = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(key, value, padding30, padding60)</span> </span>{
<span class="hljs-keyword">var</span> time = (value.loader.timeEnd - value.loader.timeStart) / <span class="hljs-number">1000</span>;
time = time || time === <span class="hljs-number">0</span> ? time + <span class="hljs-string">'s'</span> : <span class="hljs-string">'N/A'</span>;
<span class="hljs-keyword">var</span> output = me.stringPad(key, padding60);
output += me.stringPad(value.version, padding30);
output += me.stringPad(<span class="hljs-keyword">typeof</span> value.factory, padding30);
output += me.stringPad(time, padding30);
output += me.stringPad(me.normalizeBoolean(value.loader.loaded, <span class="hljs-literal">false</span>), padding30);
output += me.stringPad(me.normalizeBoolean(value.invoked, <span class="hljs-literal">false</span>), padding30);
output += me.stringPad(value.loader.failed.length, padding30);
output += value.loader.success ? value.loader.success : <span class="hljs-string">'N/A'</span>;
output += <span class="hljs-string">'\n'</span>;
<span class="hljs-keyword">return</span> output;
};</pre></div></div>
</li>
<li id="section-598">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-598">¶</a>
</div>
<p>Reference the module within the library.</p>
</div>
<div class="content"><div class='highlight'><pre>me.stats = stats;</pre></div></div>
</li>
<li id="section-599">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-599">¶</a>
</div>
<p>Automatically generate utility functions for our library. This library will generate the following functions:</p>
<ul>
<li>isArray, normalizeArray, normalizeArraySeries</li>
<li>isBoolean, normalizeBoolean, normalizeBooleanSeries</li>
<li>isFunction, normalizeFunction, normalizeFunctionSeries</li>
<li>isNumber, normalizeNumber, normalizeNumberSeries</li>
<li>isObject, normalizeObject, normalizeObjectSeries</li>
<li>isString, normalizeString, normalizeStringSeries</li>
</ul>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> utility = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(container, type)</span> </span>{</pre></div></div>
</li>
<li id="section-600">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-600">¶</a>
</div>
<p>Adding a function prefixed with <code>is</code> to check if a variable is actually the type that’s being passed in.</p>
</div>
<div class="content"><div class='highlight'><pre> container[<span class="hljs-string">'is'</span> + type] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(variable)</span> </span>{
<span class="hljs-keyword">return</span> me.isType(variable, type);
};</pre></div></div>
</li>
<li id="section-601">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-601">¶</a>
</div>
<p>Our normalization function.</p>
</div>
<div class="content"><div class='highlight'><pre> container[<span class="hljs-string">'normalize'</span> + type] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input, fallback)</span> </span>{
<span class="hljs-keyword">return</span> me.normalize(input, type, me.isDefined(fallback) ? fallback : <span class="hljs-literal">null</span>);
};</pre></div></div>
</li>
<li id="section-602">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-602">¶</a>
</div>
<p>Our normalization series function.</p>
</div>
<div class="content"><div class='highlight'><pre> container[<span class="hljs-string">'normalize'</span> + type + <span class="hljs-string">'Series'</span>] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input, fallback, strip)</span> </span>{
<span class="hljs-keyword">return</span> me.normalize.series(input, type, me.isDefined(fallback) ? fallback : [], strip);
};
};</pre></div></div>
</li>
<li id="section-603">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-603">¶</a>
</div>
<p>Automatically spawn helper functions that we’ll use throughout the library. For example we’re spawning the following
functions: <code>isArray</code>, <code>normalizeArray</code>, <code>normalizeArraySeries</code>, etc. Spawning these functions this way results in
less code for the library and achieves the same objective.</p>
</div>
<div class="content"><div class='highlight'><pre>utility.init = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(container, input)</span> </span>{</pre></div></div>
</li>
<li id="section-604">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-604">¶</a>
</div>
<p>Loop through each of our different utility types.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index <span class="hljs-keyword">in</span> input) {</pre></div></div>
</li>
<li id="section-605">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-605">¶</a>
</div>
<p>Make sure it’s not empty.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (input[index]) {</pre></div></div>
</li>
<li id="section-606">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-606">¶</a>
</div>
<p>Spawn the utility function for the library.</p>
</div>
<div class="content"><div class='highlight'><pre> utility(container, input[index]);
}
}</pre></div></div>
</li>
<li id="section-607">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-607">¶</a>
</div>
<p>We have to reference <code>isaArray</code> since <code>isArray</code> is a reserved keyword and won’t be compressed.
@reference <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray</a></p>
</div>
<div class="content"><div class='highlight'><pre> me.isaArray = me.isArray;
};</pre></div></div>
</li>
<li id="section-608">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-608">¶</a>
</div>
<p>The different utility types that we want to generate functions for.</p>
</div>
<div class="content"><div class='highlight'><pre>utility.types = [<span class="hljs-string">'Array'</span>, <span class="hljs-string">'Boolean'</span>, <span class="hljs-string">'Function'</span>, <span class="hljs-string">'Number'</span>, <span class="hljs-string">'Object'</span>, <span class="hljs-string">'String'</span>];</pre></div></div>
</li>
<li id="section-609">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-609">¶</a>
</div>
<p>Spawn our utility functions for the library.</p>
</div>
<div class="content"><div class='highlight'><pre>utility.init(me, utility.types);</pre></div></div>
</li>
<li id="section-610">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-610">¶</a>
</div>
<p>Image loader which is responsible for loading any images for the library.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> img = {};</pre></div></div>
</li>
<li id="section-611">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-611">¶</a>
</div>
<p>The image loader is pretty straight forward as legacy browser support goes way back, we don’t need to perform any
extra checking or manipulation.</p>
</div>
<div class="content"><div class='highlight'><pre>img.boot = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(module, url, callbackSuccess, callbackFailed)</span> </span>{</pre></div></div>
</li>
<li id="section-612">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-612">¶</a>
</div>
<p>Create a new <code>img</code> element.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> element = global.document.createElement(<span class="hljs-string">'img'</span>);</pre></div></div>
</li>
<li id="section-613">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-613">¶</a>
</div>
<p>If we get an <code>onerror</code> callback, the image failed to load.</p>
</div>
<div class="content"><div class='highlight'><pre> element.onerror = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-614">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-614">¶</a>
</div>
<p>Remove the element from the page.</p>
</div>
<div class="content"><div class='highlight'><pre> img.remove(element);</pre></div></div>
</li>
<li id="section-615">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-615">¶</a>
</div>
<p>Process our failed callback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> callbackFailed(<span class="hljs-built_in">module</span>, url);
};</pre></div></div>
</li>
<li id="section-616">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-616">¶</a>
</div>
<p>If we get an <code>onload</code> callback, the image loaded successfully.</p>
</div>
<div class="content"><div class='highlight'><pre> element.onload = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-617">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-617">¶</a>
</div>
<p>Remove the element from the page.</p>
</div>
<div class="content"><div class='highlight'><pre> img.remove(element);</pre></div></div>
</li>
<li id="section-618">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-618">¶</a>
</div>
<p>In the case of images, the factory represents the URL.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> callbackSuccess(<span class="hljs-built_in">module</span>, url, url);
};</pre></div></div>
</li>
<li id="section-619">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-619">¶</a>
</div>
<p>Set the actual URL that we’re going to request to load for our image.</p>
</div>
<div class="content"><div class='highlight'><pre> element.src = url;</pre></div></div>
</li>
<li id="section-620">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-620">¶</a>
</div>
<p>Attempt to load the image on the page.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> me.head.appendChild(element);
};</pre></div></div>
</li>
<li id="section-621">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-621">¶</a>
</div>
<p>Remove a dynamically generated element from the page.</p>
</div>
<div class="content"><div class='highlight'><pre>img.remove = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(element)</span> </span>{</pre></div></div>
</li>
<li id="section-622">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-622">¶</a>
</div>
<p>If <code>element.remove</code> exists, use it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isFunction(element.remove)) {
element.remove();
<span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
}</pre></div></div>
</li>
<li id="section-623">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-623">¶</a>
</div>
<p>Legacy IE (IE < 9) doesn’t have a <code>.remove</code> method. @ie</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isObject(element.removeNode)) {
element.removeNode();
<span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
}</pre></div></div>
</li>
<li id="section-624">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-624">¶</a>
</div>
<p>Return <code>false</code> if we weren’t able to remove the element.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
};</pre></div></div>
</li>
<li id="section-625">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-625">¶</a>
</div>
<p>Reference the module within the <code>loader</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>me.loader.img = img;</pre></div></div>
</li>
<li id="section-626">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-626">¶</a>
</div>
<p>JavaScript loader which is responsible for loading any scripts for the library.</p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> javascript = {};</pre></div></div>
</li>
<li id="section-627">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-627">¶</a>
</div>
<p>Attempt to load a script onto the page.</p>
</div>
<div class="content"><div class='highlight'><pre>javascript.boot = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(module, url, callbackSuccess, callbackFailed)</span> </span>{</pre></div></div>
</li>
<li id="section-628">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-628">¶</a>
</div>
<p>If the library is already loaded on the page, don’t attempt to reload it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> factory = javascript.check(<span class="hljs-built_in">module</span>);</pre></div></div>
</li>
<li id="section-629">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-629">¶</a>
</div>
<p>Check if our module has already been loaded.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(factory)) {
<span class="hljs-keyword">return</span> callbackSuccess(<span class="hljs-built_in">module</span>, url, factory, <span class="hljs-literal">true</span>);
}</pre></div></div>
</li>
<li id="section-630">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-630">¶</a>
</div>
<p>If our library failed to load, we’ll call upon this function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> failed = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
<span class="hljs-keyword">return</span> callbackFailed(<span class="hljs-built_in">module</span>, url);
};</pre></div></div>
</li>
<li id="section-631">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-631">¶</a>
</div>
<p>Whether a callback comes back as an error/success, they’re not always trustworthy.
We need to manually check to make sure that our libraries were loaded properly.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> check = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-632">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-632">¶</a>
</div>
<p>Attempt to fetch the factory for our module.</p>
</div>
<div class="content"><div class='highlight'><pre> factory = javascript.check(<span class="hljs-built_in">module</span>, <span class="hljs-literal">true</span>);</pre></div></div>
</li>
<li id="section-633">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-633">¶</a>
</div>
<p>If the factory is empty, then it failed to load! Invoke the failure callback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isDefined(factory)) {
<span class="hljs-keyword">return</span> failed();
}</pre></div></div>
</li>
<li id="section-634">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-634">¶</a>
</div>
<p>We passed the checks, invoke the success callback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> callbackSuccess(<span class="hljs-built_in">module</span>, url, factory);
};</pre></div></div>
</li>
<li id="section-635">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-635">¶</a>
</div>
<p>Spawn a new element on the page contained our URL with our callbacks.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> javascript.element(url, check, failed);
};</pre></div></div>
</li>
<li id="section-636">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-636">¶</a>
</div>
<p>Sift through the script elements on the page and attempt to derive the values from <code>attribute</code> that is passed in to
the <code>Function</code>. Along with checking the <code>attribute</code> that is passed in, this <code>Function</code> will also prefix the
given <code>attribute</code> with <code>data-</code> and check for that attribute as well. For example if the <code>Function</code> was called with
<code>base</code>, then the <code>Function</code> will atempt to derive values for the attributes <code>base</code> and <code>data-base</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>javascript.attributes = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(attribute)</span> </span>{</pre></div></div>
</li>
<li id="section-637">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-637">¶</a>
</div>
<p>The <code>Array</code> to store our <code>attribute</code> values.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> values = [];</pre></div></div>
</li>
<li id="section-638">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-638">¶</a>
</div>
<p>If the <code>attribute</code> is not a string, halt the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isString(attribute)) {
<span class="hljs-keyword">return</span> values;
}</pre></div></div>
</li>
<li id="section-639">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-639">¶</a>
</div>
<p>Fetch all script tags that are on the page. The if statement is for test coverage.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> scripts = global.document ? global.document.getElementsByTagName(<span class="hljs-string">'script'</span>) : <span class="hljs-literal">null</span>;</pre></div></div>
</li>
<li id="section-640">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-640">¶</a>
</div>
<p>Check to make sure that we retrieved a <code>HTMLCollection</code>, otherwise halt the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isType(scripts, <span class="hljs-string">'HTMLCollection'</span>)) {
<span class="hljs-keyword">return</span> values;
}</pre></div></div>
</li>
<li id="section-641">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-641">¶</a>
</div>
<p>Loop through each of our scripts.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(scripts, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(script)</span> </span>{</pre></div></div>
</li>
<li id="section-642">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-642">¶</a>
</div>
<p>If our script instance isn’t an <code>HTMLScriptElement</code>, then skip the iteration.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isType(script, <span class="hljs-string">'HTMLScriptElement'</span>)) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-643">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-643">¶</a>
</div>
<p>If <code>getAttribute</code> isn’t a <code>Function</code>, then we’re not looking at a HTML element, skip it. For legacy IE the
<code>getAttribute</code> method is declared as <code>Object</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isObject(script.getAttribute) && !me.isFunction(script.getAttribute)) {
<span class="hljs-keyword">return</span>;
}</pre></div></div>
</li>
<li id="section-644">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-644">¶</a>
</div>
<p>Check to see if our <code>attribute</code> exists along with the prefix <code>data-</code> for the <code>attribute</code> in questino.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each([attribute, <span class="hljs-string">'data-'</span> + attribute], <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(attribute)</span> </span>{</pre></div></div>
</li>
<li id="section-645">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-645">¶</a>
</div>
<p>Store our attribute value.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> value = <span class="hljs-literal">null</span>;</pre></div></div>
</li>
<li id="section-646">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-646">¶</a>
</div>
<p>We need to wrap this in a try catch because we cannot properly detect the method in legacy browsers. @ie
Fetch the value for the attribute.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">try</span> {</pre></div></div>
</li>
<li id="section-647">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-647">¶</a>
</div>
<p>Fetch our attribute.</p>
</div>
<div class="content"><div class='highlight'><pre> value = script.getAttribute(attribute);
} <span class="hljs-keyword">catch</span> (exception) {}</pre></div></div>
</li>
<li id="section-648">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-648">¶</a>
</div>
<p>If the value exists then use it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (value) {</pre></div></div>
</li>
<li id="section-649">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-649">¶</a>
</div>
<p>Split our value on <code>,</code> that way we can pass in multiple values.</p>
</div>
<div class="content"><div class='highlight'><pre> value = value.split(<span class="hljs-string">','</span>);</pre></div></div>
</li>
<li id="section-650">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-650">¶</a>
</div>
<p>Merge our values.</p>
</div>
<div class="content"><div class='highlight'><pre> values = values.concat(value);
}
});
});</pre></div></div>
</li>
<li id="section-651">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-651">¶</a>
</div>
<p>Return the values for attributes.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> values;
};</pre></div></div>
</li>
<li id="section-652">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-652">¶</a>
</div>
<p>Check to see if a module has already been loaded on the page. This <code>Function</code> will return <code>Boolean</code>, <code>true</code> being
that a module has already been loaded and <code>false</code> being that it hasn’t.</p>
</div>
<div class="content"><div class='highlight'><pre>javascript.check = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(module, postLoadCheck)</span> </span>{</pre></div></div>
</li>
<li id="section-653">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-653">¶</a>
</div>
<p>See if the module itself has been flagged as loaded.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">module</span>.loader.loaded === <span class="hljs-literal">true</span> || <span class="hljs-built_in">module</span>.amd === <span class="hljs-literal">true</span> && postLoadCheck === <span class="hljs-literal">true</span>) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
}</pre></div></div>
</li>
<li id="section-654">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-654">¶</a>
</div>
<p>Store the <code>factory</code>, as we’ll use it later in the <code>Function</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> factory;</pre></div></div>
</li>
<li id="section-655">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-655">¶</a>
</div>
<p>If globals are enabled, and we have exports for the module, check the <code>window</code> to see if they’re defined.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">module</span>.amd !== <span class="hljs-literal">true</span> && me.config.settings.globals === <span class="hljs-literal">true</span> && <span class="hljs-built_in">module</span>.exports.length) {
factory = javascript.check.exports(<span class="hljs-built_in">module</span>.exports);
}</pre></div></div>
</li>
<li id="section-656">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-656">¶</a>
</div>
<p>If an anonymous module was defined, then it’s for this library, meaning it loaded successfully.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.define.anonymous.pending === <span class="hljs-literal">true</span>) {
<span class="hljs-keyword">return</span> factory ? factory : <span class="hljs-literal">true</span>;
}</pre></div></div>
</li>
<li id="section-657">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-657">¶</a>
</div>
<p>If the user added their own custom checking function, invoke it now to preform the check.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isFunction(<span class="hljs-built_in">module</span>.check)) {
<span class="hljs-keyword">return</span> <span class="hljs-built_in">module</span>.check();
}</pre></div></div>
</li>
<li id="section-658">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-658">¶</a>
</div>
<p>If the <code>factory</code> is defined, then return it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(factory)) {
<span class="hljs-keyword">return</span> factory;
}</pre></div></div>
</li>
<li id="section-659">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-659">¶</a>
</div>
<p>By default return <code>undefined</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> <span class="hljs-literal">undefined</span>;
};</pre></div></div>
</li>
<li id="section-660">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-660">¶</a>
</div>
<p>Check for the instance of our library based on the exports given. If the instance of our library exists it’ll be
returned, otherwise this function will return <code>null. The</code>Function<code>basically checks the</code>window` variable for a
subkey which are the exports that are specified in the paramter.</p>
</div>
<div class="content"><div class='highlight'><pre>javascript.check.exports = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(exports)</span> </span>{</pre></div></div>
</li>
<li id="section-661">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-661">¶</a>
</div>
<p>If our <code>exports</code> parameter is not an <code>Array</code>, cast it to one.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(exports)) {
exports = [exports];
}</pre></div></div>
</li>
<li id="section-662">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-662">¶</a>
</div>
<p>Storage for our factory value.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> factory = <span class="hljs-literal">null</span>;</pre></div></div>
</li>
<li id="section-663">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-663">¶</a>
</div>
<p>If we have no exports, return <code>null</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!exports.length) {
<span class="hljs-keyword">return</span> factory;
}</pre></div></div>
</li>
<li id="section-664">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-664">¶</a>
</div>
<p>Loop through each of our exports variable, until we find a match.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(exports, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(variable)</span> </span>{</pre></div></div>
</li>
<li id="section-665">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-665">¶</a>
</div>
<p>We have to wrap this in a <code>try catch</code> due the possibility of our <code>window</code> decendant <code>Object</code> being <code>undefined</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">try</span> {</pre></div></div>
</li>
<li id="section-666">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-666">¶</a>
</div>
<p>Attempt to get a reference of our variable.</p>
</div>
<div class="content"><div class='highlight'><pre> factory = me.getProperty(global, variable);
} <span class="hljs-keyword">catch</span> (exception) {</pre></div></div>
</li>
<li id="section-667">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-667">¶</a>
</div>
<p>Let the end user know that we hit an exception due to their malformed <code>exports</code> variable.</p>
</div>
<div class="content"><div class='highlight'><pre> me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'loader'</span>, <span class="hljs-string">'javascript'</span>, <span class="hljs-string">'`fallback.loader.js.check.exports` threw an exception.'</span>, exception);
}
});</pre></div></div>
</li>
<li id="section-668">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-668">¶</a>
</div>
<p>Return the factory for our library.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> factory;
};</pre></div></div>
</li>
<li id="section-669">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-669">¶</a>
</div>
<p>Spawn a new element on the page with our URL.
@reference <a href="https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement">https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement</a></p>
</div>
<div class="content"><div class='highlight'><pre>javascript.element = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(url, success, failed)</span> </span>{</pre></div></div>
</li>
<li id="section-670">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-670">¶</a>
</div>
<p>Create a new script element instance.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> element = global.document.createElement(<span class="hljs-string">'script'</span>);</pre></div></div>
</li>
<li id="section-671">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-671">¶</a>
</div>
<p>Explicitly set async behavior.</p>
</div>
<div class="content"><div class='highlight'><pre> element.async = element.defer = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-672">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-672">¶</a>
</div>
<p>The browser supports it, enable crossorigin.</p>
</div>
<div class="content"><div class='highlight'><pre> element.crossorigin = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-673">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-673">¶</a>
</div>
<p>If we get an error callback, bypass any checking and just fail.</p>
</div>
<div class="content"><div class='highlight'><pre> element.onerror = failed;</pre></div></div>
</li>
<li id="section-674">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-674">¶</a>
</div>
<p>Do our checks and throw our callback.</p>
</div>
<div class="content"><div class='highlight'><pre> element.onload = success;</pre></div></div>
</li>
<li id="section-675">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-675">¶</a>
</div>
<p>Special event handler for certain versions of IE. @ie</p>
</div>
<div class="content"><div class='highlight'><pre> me.loader.onReadyStateChange(element, success);</pre></div></div>
</li>
<li id="section-676">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-676">¶</a>
</div>
<p>Set the actual URL that we’re going to request to load for our library.</p>
</div>
<div class="content"><div class='highlight'><pre> element.src = url;</pre></div></div>
</li>
<li id="section-677">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-677">¶</a>
</div>
<p>Set the type, some legacy browsers require this attribute be present.</p>
</div>
<div class="content"><div class='highlight'><pre> element.type = <span class="hljs-string">'text/javascript'</span>;</pre></div></div>
</li>
<li id="section-678">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-678">¶</a>
</div>
<p>Load our URL on the page.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> me.head.appendChild(element);
};</pre></div></div>
</li>
<li id="section-679">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-679">¶</a>
</div>
<p>Reference the module within the <code>loader</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>me.loader.js = javascript;</pre></div></div>
</li>
<li id="section-680">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-680">¶</a>
</div>
<p>Cascading Stylesheet loader which is responsible for loading any CSS files for the library. A lot of browser quirks
to deal with here. @reference <a href="http://www.phpied.com/when-is-a-stylesheet-really-loaded/">http://www.phpied.com/when-is-a-stylesheet-really-loaded/</a></p>
</div>
<div class="content"><div class='highlight'><pre><span class="hljs-keyword">var</span> stylesheet = {};</pre></div></div>
</li>
<li id="section-681">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-681">¶</a>
</div>
<p>Attempt to load a stylesheet onto the page.</p>
</div>
<div class="content"><div class='highlight'><pre>stylesheet.boot = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(module, url, callbackSuccess, callbackFailed)</span> </span>{</pre></div></div>
</li>
<li id="section-682">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-682">¶</a>
</div>
<p>If the stylesheet is already loaded on the page, don’t attempt to reload it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> factory = stylesheet.check(<span class="hljs-built_in">module</span>, url, <span class="hljs-literal">false</span>);</pre></div></div>
</li>
<li id="section-683">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-683">¶</a>
</div>
<p>Check if our module has already been loaded.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (factory) {
<span class="hljs-keyword">return</span> callbackSuccess(<span class="hljs-built_in">module</span>, url, factory, <span class="hljs-literal">true</span>);
}</pre></div></div>
</li>
<li id="section-684">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-684">¶</a>
</div>
<p>If our library failed to load, we’ll call upon this function.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> failed = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
<span class="hljs-keyword">return</span> callbackFailed(<span class="hljs-built_in">module</span>, url);
};</pre></div></div>
</li>
<li id="section-685">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-685">¶</a>
</div>
<p>Whether a callback comes back as an error/success, they’re not always trustworthy.
We need to manually check to make sure that our libraries were loaded properly.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> check = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
</li>
<li id="section-686">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-686">¶</a>
</div>
<p>Attempt to fetch the factory for our module.</p>
</div>
<div class="content"><div class='highlight'><pre> factory = stylesheet.check(<span class="hljs-built_in">module</span>, url);</pre></div></div>
</li>
<li id="section-687">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-687">¶</a>
</div>
<p>If the factory is empty, then it failed to load! Invoke the failure callback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!factory) {
<span class="hljs-keyword">return</span> failed();
}</pre></div></div>
</li>
<li id="section-688">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-688">¶</a>
</div>
<p>We passed the checks, invoke the success callback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> callbackSuccess(<span class="hljs-built_in">module</span>, url, factory);
};</pre></div></div>
</li>
<li id="section-689">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-689">¶</a>
</div>
<p>Spawn a new element on the page contained our URL with our callbacks.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> stylesheet.element(url, check, failed);
};</pre></div></div>
</li>
<li id="section-690">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-690">¶</a>
</div>
<p>Check to see if a module has already been loaded on the page. This <code>Function</code> will return <code>Boolean</code>, <code>true</code> being
that a module has already been loaded and <code>false</code> being that it hasn’t.</p>
</div>
<div class="content"><div class='highlight'><pre>stylesheet.check = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(module, url, fallback)</span> </span>{</pre></div></div>
</li>
<li id="section-691">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-691">¶</a>
</div>
<p>See if the module itself has been flagged as loaded.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">module</span>.loader.loaded === <span class="hljs-literal">true</span>) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
}</pre></div></div>
</li>
<li id="section-692">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-692">¶</a>
</div>
<p>If the user added their own custom checking function, invoke it now to preform the check.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isFunction(<span class="hljs-built_in">module</span>.check)) {
<span class="hljs-keyword">return</span> <span class="hljs-built_in">module</span>.check();
}</pre></div></div>
</li>
<li id="section-693">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-693">¶</a>
</div>
<p>This has been disabled due to a variety of timing factors with different browsers.
@reference <a href="http://www.phpied.com/when-is-a-stylesheet-really-loaded/">http://www.phpied.com/when-is-a-stylesheet-really-loaded/</a></p>
</div>
</li>
<li id="section-694">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-694">¶</a>
</div>
<p>If globals are enabled, and we have exports for the module, check the DOM to see if they’re defined.
if (me.config.settings.globals === true && module.exports.length && !me.isPrefixed(url, stylesheet.check.ignore)) {
return stylesheet.check.exports(module.exports);
}</p>
</div>
</li>
<li id="section-695">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-695">¶</a>
</div>
<p>By default just return true, as this function was hit from a success callback.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> me.isDefined(fallback) ? fallback : <span class="hljs-literal">true</span>;
};</pre></div></div>
</li>
<li id="section-696">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-696">¶</a>
</div>
<p>Bypass checking if a URL starts with any of the following values. This is due to CORS issues with the browsers when
a CSS file is loaded from an external source.</p>
</div>
<div class="content"><div class='highlight'><pre>stylesheet.check.ignore = [<span class="hljs-string">'//'</span>, <span class="hljs-string">'http://'</span>, <span class="hljs-string">'https://'</span>];</pre></div></div>
</li>
<li id="section-697">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-697">¶</a>
</div>
<p>Check for the instance of our library based on the exports given. If the instance of our library exists it’ll be
returned, otherwise this function will return <code>null. The</code>Function<code>basically checks the</code>window` variable for a
subkey which are the exports that are specified in the paramter.</p>
</div>
<div class="content"><div class='highlight'><pre>stylesheet.check.exports = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(exports)</span> </span>{</pre></div></div>
</li>
<li id="section-698">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-698">¶</a>
</div>
<p>If our <code>exports</code> parameter is not an <code>Array</code>, cast it to one.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isaArray(exports)) {
exports = [exports];
}</pre></div></div>
</li>
<li id="section-699">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-699">¶</a>
</div>
<p>Storage for our factory value.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> factory = <span class="hljs-literal">null</span>;</pre></div></div>
</li>
<li id="section-700">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-700">¶</a>
</div>
<p>If we have no exports, return <code>null</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!exports.length) {
<span class="hljs-keyword">return</span> factory;
}</pre></div></div>
</li>
<li id="section-701">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-701">¶</a>
</div>
<p>Case all of our exports to lowercase as some browsers automatically change them.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> normalized = [];
me.each(exports, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(exportName)</span> </span>{
normalized.push(exportName.toLowerCase());
});</pre></div></div>
</li>
<li id="section-702">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-702">¶</a>
</div>
<p>Swap our exports <code>Array</code> out with out normalized lowercase <code>Array</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> exports = normalized;</pre></div></div>
</li>
<li id="section-703">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-703">¶</a>
</div>
<p>If the <code>global.document</code> doesn’t contain the key <code>styleSheets</code>, return <code>null</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (!me.isDefined(global.document.styleSheets)) {
<span class="hljs-keyword">return</span> factory;
}</pre></div></div>
</li>
<li id="section-704">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-704">¶</a>
</div>
<p>Loop through each of the documents stylesheets.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each(global.document.styleSheets, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(sheet)</span> </span>{</pre></div></div>
</li>
<li id="section-705">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-705">¶</a>
</div>
<p>If the sheet is <code>0</code>, skip it.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (sheet === <span class="hljs-number">0</span>) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
}</pre></div></div>
</li>
<li id="section-706">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-706">¶</a>
</div>
<p>Loop through the following keys in <code>global.document.stylesheets</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> me.each([<span class="hljs-string">'cssRules'</span>, <span class="hljs-string">'rules'</span>], <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(key)</span> </span>{</pre></div></div>
</li>
<li id="section-707">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-707">¶</a>
</div>
<p>This has to be wrapped in a <code>try catch</code> due to some browsers throwing a CORS exception if the stylesheet is
loaded via an external domain.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">try</span> {</pre></div></div>
</li>
<li id="section-708">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-708">¶</a>
</div>
<p>If <code>sheet.rules</code> exists, scan it for our export.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.isDefined(sheet[key])) {
factory = stylesheet.scan(sheet[key], exports);</pre></div></div>
</li>
<li id="section-709">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-709">¶</a>
</div>
<p>If we found our rule, halt the loop.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (factory) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}
}
} <span class="hljs-keyword">catch</span> (exception) {
me.log(<span class="hljs-number">2</span>, <span class="hljs-string">'loader'</span>, <span class="hljs-string">'stylesheet'</span>, <span class="hljs-string">'`fallback.loader.css.check.exports` threw an exception.'</span>, exception);
}
});</pre></div></div>
</li>
<li id="section-710">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-710">¶</a>
</div>
<p>If we found our selector, halt the loop!</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (factory) {
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}
});</pre></div></div>
</li>
<li id="section-711">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-711">¶</a>
</div>
<p>Return whether or not our stylesheet was loaded.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> factory;
};</pre></div></div>
</li>
<li id="section-712">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-712">¶</a>
</div>
<p>Spawn a new element on the page with our URL.
@reference <a href="https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement">https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement</a></p>
</div>
<div class="content"><div class='highlight'><pre>stylesheet.element = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(url, success, failed)</span> </span>{</pre></div></div>
</li>
<li id="section-713">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-713">¶</a>
</div>
<p>Create a new script element instance.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> element = global.document.createElement(<span class="hljs-string">'link'</span>);</pre></div></div>
</li>
<li id="section-714">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-714">¶</a>
</div>
<p>Explicitly set async behavior.</p>
</div>
<div class="content"><div class='highlight'><pre> element.async = element.defer = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-715">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-715">¶</a>
</div>
<p>The browser supports it, enable crossorigin.</p>
</div>
<div class="content"><div class='highlight'><pre> element.crossorigin = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-716">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-716">¶</a>
</div>
<p>Set the actual URL that we’re going to request to load for our library.</p>
</div>
<div class="content"><div class='highlight'><pre> element.href = url;</pre></div></div>
</li>
<li id="section-717">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-717">¶</a>
</div>
<p>If we get an error callback, bypass any checking and just fail.</p>
</div>
<div class="content"><div class='highlight'><pre> element.onerror = failed;</pre></div></div>
</li>
<li id="section-718">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-718">¶</a>
</div>
<p>Do our checks and throw our callback.</p>
</div>
<div class="content"><div class='highlight'><pre> element.onload = success;</pre></div></div>
</li>
<li id="section-719">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-719">¶</a>
</div>
<p>Special event handler for certain versions of IE. @ie</p>
</div>
<div class="content"><div class='highlight'><pre> me.loader.onReadyStateChange(element, success);</pre></div></div>
</li>
<li id="section-720">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-720">¶</a>
</div>
<p>Set the type, some legacy browsers require this attribute be present.</p>
</div>
<div class="content"><div class='highlight'><pre> element.rel = <span class="hljs-string">'stylesheet'</span>;</pre></div></div>
</li>
<li id="section-721">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-721">¶</a>
</div>
<p>Load our URL on the page.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> me.head.appendChild(element);
};</pre></div></div>
</li>
<li id="section-722">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-722">¶</a>
</div>
<p>Scan through the documents stylesheets searching for a specific selector.</p>
</div>
<div class="content"><div class='highlight'><pre>stylesheet.scan = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(ruleset, selectors)</span> </span>{</pre></div></div>
</li>
<li id="section-723">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-723">¶</a>
</div>
<p>Store whether or not we found our selector.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> found = <span class="hljs-literal">false</span>;</pre></div></div>
</li>
<li id="section-724">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-724">¶</a>
</div>
<p>Loop through the rules.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index <span class="hljs-keyword">in</span> ruleset) {
<span class="hljs-keyword">if</span> (ruleset[index]) {
<span class="hljs-keyword">var</span> rule = ruleset[index];</pre></div></div>
</li>
<li id="section-725">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-725">¶</a>
</div>
<p>See if we find a match for one of our selectors.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (me.indexOf(selectors, <span class="hljs-built_in">String</span>(rule.selectorText).toLowerCase()) !== -<span class="hljs-number">1</span>) {</pre></div></div>
</li>
<li id="section-726">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-726">¶</a>
</div>
<p>Flag that we found our selector.</p>
</div>
<div class="content"><div class='highlight'><pre> found = <span class="hljs-literal">true</span>;</pre></div></div>
</li>
<li id="section-727">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-727">¶</a>
</div>
<p>Halt the loop.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">break</span>;
}
}
}</pre></div></div>
</li>
<li id="section-728">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-728">¶</a>
</div>
<p>Return our search status.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">return</span> found;
};</pre></div></div>
</li>
<li id="section-729">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-729">¶</a>
</div>
<p>Reference the module within the <code>loader</code>.</p>
</div>
<div class="content"><div class='highlight'><pre>me.loader.css = stylesheet;
me.banner = <span class="hljs-string">' ad88 88 88 88 88 88 \n d8" 88 88 88 88 "" \n 88 88 88 88 88 \nMM88MMM ,adPPYYba, 88 88 88,dPPYba, ,adPPYYba, ,adPPYba, 88 ,d8 88 ,adPPYba, \n 88 "" `Y8 88 88 88P\' "8a "" `Y8 a8" "" 88 ,a8" 88 I8[ "" \n 88 ,adPPPPP88 88 88 88 d8 ,adPPPPP88 8b 8888[ 88 `"Y8ba, \n 88 88, ,88 88 88 88b, ,a8" 88, ,88 "8a, ,aa 88`"Yba, 88 aa ]8I \n 88 `"8bbdP"Y8 88 88 8Y"Ybbd8"\' `"8bbdP"Y8 `"Ybbd8"\' 88 `Y8a 88 `"YbbdP"\' \n ,88 \n 888P"'</span>;
me.homepage = <span class="hljs-string">'http://fallback.io/'</span>;
me.version = <span class="hljs-string">'2.0.0'</span>;
me.init();
})(<span class="hljs-keyword">this</span>);</pre></div></div>
</li>
</ul>
</div>
</body>
</html>
.