359
+
360
+		// Flatten any nested arrays
361
+		return flat( ret );
362
+	},
363
+
364
+	// A global GUID counter for objects
365
+	guid: 1,
366
+
367
+	// jQuery.support is not used in Core but other projects attach their
368
+	// properties to it so it needs to exist.
369
+	support: support
370
+} );
371
+
372
+if ( typeof Symbol === "function" ) {
373
+	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
374
+}
375
+
376
+// Populate the class2type map
377
+jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
378
+	function( _i, name ) {
379
+		class2type[ "[object " + name + "]" ] = name.toLowerCase();
380
+	} );
381
+
382
+function isArrayLike( obj ) {
383
+
384
+	// Support: real iOS 8.2 only (not reproducible in simulator)
385
+	// `in` check used to prevent JIT error (gh-2145)
386
+	// hasOwn isn't used here due to false negatives
387
+	// regarding Nodelist length in IE
388
+	var length = !!obj && "length" in obj && obj.length,
389
+		type = toType( obj );
390
+
391
+	if ( isFunction( obj ) || isWindow( obj ) ) {
392
+		return false;
393
+	}
394
+
395
+	return type === "array" || length === 0 ||
396
+		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
397
+}
398
+
399
+return jQuery;
400
+} );

+ 43 - 0
app/static/bower_components/jQuery/src/core/DOMEval.js

@@ -0,0 +1,43 @@
1
+define( [
2
+	"../var/document"
3
+], function( document ) {
4
+	"use strict";
5
+
6
+	var preservedScriptAttributes = {
7
+		type: true,
8
+		src: true,
9
+		nonce: true,
10
+		noModule: true
11
+	};
12
+
13
+	function DOMEval( code, node, doc ) {
14
+		doc = doc || document;
15
+
16
+		var i, val,
17
+			script = doc.createElement( "script" );
18
+
19
+		script.text = code;
20
+		if ( node ) {
21
+			for ( i in preservedScriptAttributes ) {
22
+
23
+				// Support: Firefox 64+, Edge 18+
24
+				// Some browsers don't support the "nonce" property on scripts.
25
+				// On the other hand, just using `getAttribute` is not enough as
26
+				// the `nonce` attribute is reset to an empty string whenever it
27
+				// becomes browsing-context connected.
28
+				// See https://github.com/whatwg/html/issues/2369
29
+				// See https://html.spec.whatwg.org/#nonce-attributes
30
+				// The `node.getAttribute` check was added for the sake of
31
+				// `jQuery.globalEval` so that it can fake a nonce-containing node
32
+				// via an object.
33
+				val = node[ i ] || node.getAttribute && node.getAttribute( i );
34
+				if ( val ) {
35
+					script.setAttribute( i, val );
36
+				}
37
+			}
38
+		}
39
+		doc.head.appendChild( script ).parentNode.removeChild( script );
40
+	}
41
+
42
+	return DOMEval;
43
+} );

+ 72 - 0
app/static/bower_components/jQuery/src/core/access.js

@@ -0,0 +1,72 @@
1
+define( [
2
+	"../core",
3
+	"../core/toType",
4
+	"../var/isFunction"
5
+], function( jQuery, toType, isFunction ) {
6
+
7
+"use strict";
8
+
9
+// Multifunctional method to get and set values of a collection
10
+// The value/s can optionally be executed if it's a function
11
+var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
12
+	var i = 0,
13
+		len = elems.length,
14
+		bulk = key == null;
15
+
16
+	// Sets many values
17
+	if ( toType( key ) === "object" ) {
18
+		chainable = true;
19
+		for ( i in key ) {
20
+			access( elems, fn, i, key[ i ], true, emptyGet, raw );
21
+		}
22
+
23
+	// Sets one value
24
+	} else if ( value !== undefined ) {
25
+		chainable = true;
26
+
27
+		if ( !isFunction( value ) ) {
28
+			raw = true;
29
+		}
30
+
31
+		if ( bulk ) {
32
+
33
+			// Bulk operations run against the entire set
34
+			if ( raw ) {
35
+				fn.call( elems, value );
36
+				fn = null;
37
+
38
+			// ...except when executing function values
39
+			} else {
40
+				bulk = fn;
41
+				fn = function( elem, _key, value ) {
42
+					return bulk.call( jQuery( elem ), value );
43
+				};
44
+			}
45
+		}
46
+
47
+		if ( fn ) {
48
+			for ( ; i < len; i++ ) {
49
+				fn(
50
+					elems[ i ], key, raw ?
51
+						value :
52
+						value.call( elems[ i ], i, fn( elems[ i ], key ) )
53
+				);
54
+			}
55
+		}
56
+	}
57
+
58
+	if ( chainable ) {
59
+		return elems;
60
+	}
61
+
62
+	// Gets
63
+	if ( bulk ) {
64
+		return fn.call( elems );
65
+	}
66
+
67
+	return len ? fn( elems[ 0 ], key ) : emptyGet;
68
+};
69
+
70
+return access;
71
+
72
+} );

+ 23 - 0
app/static/bower_components/jQuery/src/core/camelCase.js

@@ -0,0 +1,23 @@
1
+define( [], function() {
2
+
3
+"use strict";
4
+
5
+// Matches dashed string for camelizing
6
+var rmsPrefix = /^-ms-/,
7
+	rdashAlpha = /-([a-z])/g;
8
+
9
+// Used by camelCase as callback to replace()
10
+function fcamelCase( _all, letter ) {
11
+	return letter.toUpperCase();
12
+}
13
+
14
+// Convert dashed to camelCase; used by the css and data modules
15
+// Support: IE <=9 - 11, Edge 12 - 15
16
+// Microsoft forgot to hump their vendor prefix (#9572)
17
+function camelCase( string ) {
18
+	return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
19
+}
20
+
21
+return camelCase;
22
+
23
+} );

+ 129 - 0
app/static/bower_components/jQuery/src/core/init.js

@@ -0,0 +1,129 @@
1
+// Initialize a jQuery object
2
+define( [
3
+	"../core",
4
+	"../var/document",
5
+	"../var/isFunction",
6
+	"./var/rsingleTag",
7
+
8
+	"../traversing/findFilter"
9
+], function( jQuery, document, isFunction, rsingleTag ) {
10
+
11
+"use strict";
12
+
13
+// A central reference to the root jQuery(document)
14
+var rootjQuery,
15
+
16
+	// A simple way to check for HTML strings
17
+	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
18
+	// Strict HTML recognition (#11290: must start with <)
19
+	// Shortcut simple #id case for speed
20
+	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
21
+
22
+	init = jQuery.fn.init = function( selector, context, root ) {
23
+		var match, elem;
24
+
25
+		// HANDLE: $(""), $(null), $(undefined), $(false)
26
+		if ( !selector ) {
27
+			return this;
28
+		}
29
+
30
+		// Method init() accepts an alternate rootjQuery
31
+		// so migrate can support jQuery.sub (gh-2101)
32
+		root = root || rootjQuery;
33
+
34
+		// Handle HTML strings
35
+		if ( typeof selector === "string" ) {
36
+			if ( selector[ 0 ] === "<" &&
37
+				selector[ selector.length - 1 ] === ">" &&
38
+				selector.length >= 3 ) {
39
+
40
+				// Assume that strings that start and end with <> are HTML and skip the regex check
41
+				match = [ null, selector, null ];
42
+
43
+			} else {
44
+				match = rquickExpr.exec( selector );
45
+			}
46
+
47
+			// Match html or make sure no context is specified for #id
48
+			if ( match && ( match[ 1 ] || !context ) ) {
49
+
50
+				// HANDLE: $(html) -> $(array)
51
+				if ( match[ 1 ] ) {
52
+					context = context instanceof jQuery ? context[ 0 ] : context;
53
+
54
+					// Option to run scripts is true for back-compat
55
+					// Intentionally let the error be thrown if parseHTML is not present
56
+					jQuery.merge( this, jQuery.parseHTML(
57
+						match[ 1 ],
58
+						context && context.nodeType ? context.ownerDocument || context : document,
59
+						true
60
+					) );
61
+
62
+					// HANDLE: $(html, props)
63
+					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
64
+						for ( match in context ) {
65
+
66
+							// Properties of context are called as methods if possible
67
+							if ( isFunction( this[ match ] ) ) {
68
+								this[ match ]( context[ match ] );
69
+
70
+							// ...and otherwise set as attributes
71
+							} else {
72
+								this.attr( match, context[ match ] );
73
+							}
74
+						}
75
+					}
76
+
77
+					return this;
78
+
79
+				// HANDLE: $(#id)
80
+				} else {
81
+					elem = document.getElementById( match[ 2 ] );
82
+
83
+					if ( elem ) {
84
+
85
+						// Inject the element directly into the jQuery object
86
+						this[ 0 ] = elem;
87
+						this.length = 1;
88
+					}
89
+					return this;
90
+				}
91
+
92
+			// HANDLE: $(expr, $(...))
93
+			} else if ( !context || context.jquery ) {
94
+				return ( context || root ).find( selector );
95
+
96
+			// HANDLE: $(expr, context)
97
+			// (which is just equivalent to: $(context).find(expr)
98
+			} else {
99
+				return this.constructor( context ).find( selector );
100
+			}
101
+
102
+		// HANDLE: $(DOMElement)
103
+		} else if ( selector.nodeType ) {
104
+			this[ 0 ] = selector;
105
+			this.length = 1;
106
+			return this;
107
+
108
+		// HANDLE: $(function)
109
+		// Shortcut for document ready
110
+		} else if ( isFunction( selector ) ) {
111
+			return root.ready !== undefined ?
112
+				root.ready( selector ) :
113
+
114
+				// Execute immediately if ready is not present
115
+				selector( jQuery );
116
+		}
117
+
118
+		return jQuery.makeArray( selector, this );
119
+	};
120
+
121
+// Give the init function the jQuery prototype for later instantiation
122
+init.prototype = jQuery.fn;
123
+
124
+// Initialize central reference
125
+rootjQuery = jQuery( document );
126
+
127
+return init;
128
+
129
+} );

+ 26 - 0
app/static/bower_components/jQuery/src/core/isAttached.js

@@ -0,0 +1,26 @@
1
+define( [
2
+	"../core",
3
+	"../var/documentElement",
4
+	"../selector" // jQuery.contains
5
+], function( jQuery, documentElement ) {
6
+	"use strict";
7
+
8
+	var isAttached = function( elem ) {
9
+			return jQuery.contains( elem.ownerDocument, elem );
10
+		},
11
+		composed = { composed: true };
12
+
13
+	// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
14
+	// Check attachment across shadow DOM boundaries when possible (gh-3504)
15
+	// Support: iOS 10.0-10.2 only
16
+	// Early iOS 10 versions support `attachShadow` but not `getRootNode`,
17
+	// leading to errors. We need to check for `getRootNode`.
18
+	if ( documentElement.getRootNode ) {
19
+		isAttached = function( elem ) {
20
+			return jQuery.contains( elem.ownerDocument, elem ) ||
21
+				elem.getRootNode( composed ) === elem.ownerDocument;
22
+		};
23
+	}
24
+
25
+	return isAttached;
26
+} );

+ 13 - 0
app/static/bower_components/jQuery/src/core/nodeName.js

@@ -0,0 +1,13 @@
1
+define( function() {
2
+
3
+"use strict";
4
+
5
+function nodeName( elem, name ) {
6
+
7
+	return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
8
+
9
+}
10
+
11
+return nodeName;
12
+
13
+} );

+ 65 - 0
app/static/bower_components/jQuery/src/core/parseHTML.js

@@ -0,0 +1,65 @@
1
+define( [
2
+	"../core",
3
+	"../var/document",
4
+	"./var/rsingleTag",
5
+	"../manipulation/buildFragment",
6
+
7
+	// This is the only module that needs core/support
8
+	"./support"
9
+], function( jQuery, document, rsingleTag, buildFragment, support ) {
10
+
11
+"use strict";
12
+
13
+// Argument "data" should be string of html
14
+// context (optional): If specified, the fragment will be created in this context,
15
+// defaults to document
16
+// keepScripts (optional): If true, will include scripts passed in the html string
17
+jQuery.parseHTML = function( data, context, keepScripts ) {
18
+	if ( typeof data !== "string" ) {
19
+		return [];
20
+	}
21
+	if ( typeof context === "boolean" ) {
22
+		keepScripts = context;
23
+		context = false;
24
+	}
25
+
26
+	var base, parsed, scripts;
27
+
28
+	if ( !context ) {
29
+
30
+		// Stop scripts or inline event handlers from being executed immediately
31
+		// by using document.implementation
32
+		if ( support.createHTMLDocument ) {
33
+			context = document.implementation.createHTMLDocument( "" );
34
+
35
+			// Set the base href for the created document
36
+			// so any parsed elements with URLs
37
+			// are based on the document's URL (gh-2965)
38
+			base = context.createElement( "base" );
39
+			base.href = document.location.href;
40
+			context.head.appendChild( base );
41
+		} else {
42
+			context = document;
43
+		}
44
+	}
45
+
46
+	parsed = rsingleTag.exec( data );
47
+	scripts = !keepScripts && [];
48
+
49
+	// Single tag
50
+	if ( parsed ) {
51
+		return [ context.createElement( parsed[ 1 ] ) ];
52
+	}
53
+
54
+	parsed = buildFragment( [ data ], context, scripts );
55
+
56
+	if ( scripts && scripts.length ) {
57
+		jQuery( scripts ).remove();
58
+	}
59
+
60
+	return jQuery.merge( [], parsed.childNodes );
61
+};
62
+
63
+return jQuery.parseHTML;
64
+
65
+} );

+ 35 - 0
app/static/bower_components/jQuery/src/core/parseXML.js

@@ -0,0 +1,35 @@
1
+define( [
2
+	"../core"
3
+], function( jQuery ) {
4
+
5
+"use strict";
6
+
7
+// Cross-browser xml parsing
8
+jQuery.parseXML = function( data ) {
9
+	var xml, parserErrorElem;
10
+	if ( !data || typeof data !== "string" ) {
11
+		return null;
12
+	}
13
+
14
+	// Support: IE 9 - 11 only
15
+	// IE throws on parseFromString with invalid input.
16
+	try {
17
+		xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
18
+	} catch ( e ) {}
19
+
20
+	parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ];
21
+	if ( !xml || parserErrorElem ) {
22
+		jQuery.error( "Invalid XML: " + (
23
+			parserErrorElem ?
24
+				jQuery.map( parserErrorElem.childNodes, function( el ) {
25
+					return el.textContent;
26
+				} ).join( "\n" ) :
27
+				data
28
+		) );
29
+	}
30
+	return xml;
31
+};
32
+
33
+return jQuery.parseXML;
34
+
35
+} );

+ 97 - 0
app/static/bower_components/jQuery/src/core/ready-no-deferred.js

@@ -0,0 +1,97 @@
1
+define( [
2
+	"../core",
3
+	"../var/document",
4
+	"../var/isFunction"
5
+], function( jQuery, document, isFunction ) {
6
+
7
+"use strict";
8
+
9
+var readyCallbacks = [],
10
+	whenReady = function( fn ) {
11
+		readyCallbacks.push( fn );
12
+	},
13
+	executeReady = function( fn ) {
14
+
15
+		// Prevent errors from freezing future callback execution (gh-1823)
16
+		// Not backwards-compatible as this does not execute sync
17
+		window.setTimeout( function() {
18
+			fn.call( document, jQuery );
19
+		} );
20
+	};
21
+
22
+jQuery.fn.ready = function( fn ) {
23
+	whenReady( fn );
24
+	return this;
25
+};
26
+
27
+jQuery.extend( {
28
+
29
+	// Is the DOM ready to be used? Set to true once it occurs.
30
+	isReady: false,
31
+
32
+	// A counter to track how many items to wait for before
33
+	// the ready event fires. See #6781
34
+	readyWait: 1,
35
+
36
+	ready: function( wait ) {
37
+
38
+		// Abort if there are pending holds or we're already ready
39
+		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
40
+			return;
41
+		}
42
+
43
+		// Remember that the DOM is ready
44
+		jQuery.isReady = true;
45
+
46
+		// If a normal DOM Ready event fired, decrement, and wait if need be
47
+		if ( wait !== true && --jQuery.readyWait > 0 ) {
48
+			return;
49
+		}
50
+
51
+		whenReady = function( fn ) {
52
+			readyCallbacks.push( fn );
53
+
54
+			while ( readyCallbacks.length ) {
55
+				fn = readyCallbacks.shift();
56
+				if ( isFunction( fn ) ) {
57
+					executeReady( fn );
58
+				}
59
+			}
60
+		};
61
+
62
+		whenReady();
63
+	}
64
+} );
65
+
66
+// Make jQuery.ready Promise consumable (gh-1778)
67
+jQuery.ready.then = jQuery.fn.ready;
68
+
69
+/**
70
+ * The ready event handler and self cleanup method
71
+ */
72
+function completed() {
73
+	document.removeEventListener( "DOMContentLoaded", completed );
74
+	window.removeEventListener( "load", completed );
75
+	jQuery.ready();
76
+}
77
+
78
+// Catch cases where $(document).ready() is called
79
+// after the browser event has already occurred.
80
+// Support: IE9-10 only
81
+// Older IE sometimes signals "interactive" too soon
82
+if ( document.readyState === "complete" ||
83
+	( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
84
+
85
+	// Handle it asynchronously to allow scripts the opportunity to delay ready
86
+	window.setTimeout( jQuery.ready );
87
+
88
+} else {
89
+
90
+	// Use the handy event callback
91
+	document.addEventListener( "DOMContentLoaded", completed );
92
+
93
+	// A fallback to window.onload, that will always work
94
+	window.addEventListener( "load", completed );
95
+}
96
+
97
+} );

+ 86 - 0
app/static/bower_components/jQuery/src/core/ready.js

@@ -0,0 +1,86 @@
1
+define( [
2
+	"../core",
3
+	"../var/document",
4
+	"../core/readyException",
5
+	"../deferred"
6
+], function( jQuery, document ) {
7
+
8
+"use strict";
9
+
10
+// The deferred used on DOM ready
11
+var readyList = jQuery.Deferred();
12
+
13
+jQuery.fn.ready = function( fn ) {
14
+
15
+	readyList
16
+		.then( fn )
17
+
18
+		// Wrap jQuery.readyException in a function so that the lookup
19
+		// happens at the time of error handling instead of callback
20
+		// registration.
21
+		.catch( function( error ) {
22
+			jQuery.readyException( error );
23
+		} );
24
+
25
+	return this;
26
+};
27
+
28
+jQuery.extend( {
29
+
30
+	// Is the DOM ready to be used? Set to true once it occurs.
31
+	isReady: false,
32
+
33
+	// A counter to track how many items to wait for before
34
+	// the ready event fires. See #6781
35
+	readyWait: 1,
36
+
37
+	// Handle when the DOM is ready
38
+	ready: function( wait ) {
39
+
40
+		// Abort if there are pending holds or we're already ready
41
+		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
42
+			return;
43
+		}
44
+
45
+		// Remember that the DOM is ready
46
+		jQuery.isReady = true;
47
+
48
+		// If a normal DOM Ready event fired, decrement, and wait if need be
49
+		if ( wait !== true && --jQuery.readyWait > 0 ) {
50
+			return;
51
+		}
52
+
53
+		// If there are functions bound, to execute
54
+		readyList.resolveWith( document, [ jQuery ] );
55
+	}
56
+} );
57
+
58
+jQuery.ready.then = readyList.then;
59
+
60
+// The ready event handler and self cleanup method
61
+function completed() {
62
+	document.removeEventListener( "DOMContentLoaded", completed );
63
+	window.removeEventListener( "load", completed );
64
+	jQuery.ready();
65
+}
66
+
67
+// Catch cases where $(document).ready() is called
68
+// after the browser event has already occurred.
69
+// Support: IE <=9 - 10 only
70
+// Older IE sometimes signals "interactive" too soon
71
+if ( document.readyState === "complete" ||
72
+	( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
73
+
74
+	// Handle it asynchronously to allow scripts the opportunity to delay ready
75
+	window.setTimeout( jQuery.ready );
76
+
77
+} else {
78
+
79
+	// Use the handy event callback
80
+	document.addEventListener( "DOMContentLoaded", completed );
81
+
82
+	// A fallback to window.onload, that will always work
83
+	window.addEventListener( "load", completed );
84
+}
85
+
86
+} );

+ 13 - 0
app/static/bower_components/jQuery/src/core/readyException.js

@@ -0,0 +1,13 @@
1
+define( [
2
+	"../core"
3
+], function( jQuery ) {
4
+
5
+"use strict";
6
+
7
+jQuery.readyException = function( error ) {
8
+	window.setTimeout( function() {
9
+		throw error;
10
+	} );
11
+};
12
+
13
+} );

+ 14 - 0
app/static/bower_components/jQuery/src/core/stripAndCollapse.js

@@ -0,0 +1,14 @@
1
+define( [
2
+	"../var/rnothtmlwhite"
3
+], function( rnothtmlwhite ) {
4
+	"use strict";
5
+
6
+	// Strip and collapse whitespace according to HTML spec
7
+	// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
8
+	function stripAndCollapse( value ) {
9
+		var tokens = value.match( rnothtmlwhite ) || [];
10
+		return tokens.join( " " );
11
+	}
12
+
13
+	return stripAndCollapse;
14
+} );

+ 20 - 0
app/static/bower_components/jQuery/src/core/support.js

@@ -0,0 +1,20 @@
1
+define( [
2
+	"../var/document",
3
+	"../var/support"
4
+], function( document, support ) {
5
+
6
+"use strict";
7
+
8
+// Support: Safari 8 only
9
+// In Safari 8 documents created via document.implementation.createHTMLDocument
10
+// collapse sibling forms: the second one becomes a child of the first one.
11
+// Because of that, this security measure has to be disabled in Safari 8.
12
+// https://bugs.webkit.org/show_bug.cgi?id=137337
13
+support.createHTMLDocument = ( function() {
14
+	var body = document.implementation.createHTMLDocument( "" ).body;
15
+	body.innerHTML = "<form></form><form></form>";
16
+	return body.childNodes.length === 2;
17
+} )();
18
+
19
+return support;
20
+} );

+ 20 - 0
app/static/bower_components/jQuery/src/core/toType.js

@@ -0,0 +1,20 @@
1
+define( [
2
+	"../var/class2type",
3
+	"../var/toString"
4
+], function( class2type, toString ) {
5
+
6
+"use strict";
7
+
8
+function toType( obj ) {
9
+	if ( obj == null ) {
10
+		return obj + "";
11
+	}
12
+
13
+	// Support: Android <=2.3 only (functionish RegExp)
14
+	return typeof obj === "object" || typeof obj === "function" ?
15
+		class2type[ toString.call( obj ) ] || "object" :
16
+		typeof obj;
17
+}
18
+
19
+return toType;
20
+} );

+ 494 - 0
app/static/bower_components/jQuery/src/css.js

@@ -0,0 +1,494 @@
1
+define( [
2
+	"./core",
3
+	"./core/access",
4
+	"./core/camelCase",
5
+	"./core/nodeName",
6
+	"./var/rcssNum",
7
+	"./css/var/rnumnonpx",
8
+	"./css/var/cssExpand",
9
+	"./css/var/getStyles",
10
+	"./css/var/swap",
11
+	"./css/curCSS",
12
+	"./css/adjustCSS",
13
+	"./css/addGetHookIf",
14
+	"./css/support",
15
+	"./css/finalPropName",
16
+
17
+	"./core/init",
18
+	"./core/ready",
19
+	"./selector" // contains
20
+], function( jQuery, access, camelCase, nodeName, rcssNum, rnumnonpx, cssExpand,
21
+	getStyles, swap, curCSS, adjustCSS, addGetHookIf, support, finalPropName ) {
22
+
23
+"use strict";
24
+
25
+var
26
+
27
+	// Swappable if display is none or starts with table
28
+	// except "table", "table-cell", or "table-caption"
29
+	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
30
+	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
31
+	rcustomProp = /^--/,
32
+	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
33
+	cssNormalTransform = {
34
+		letterSpacing: "0",
35
+		fontWeight: "400"
36
+	};
37
+
38
+function setPositiveNumber( _elem, value, subtract ) {
39
+
40
+	// Any relative (+/-) values have already been
41
+	// normalized at this point
42
+	var matches = rcssNum.exec( value );
43
+	return matches ?
44
+
45
+		// Guard against undefined "subtract", e.g., when used as in cssHooks
46
+		Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
47
+		value;
48
+}
49
+
50
+function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
51
+	var i = dimension === "width" ? 1 : 0,
52
+		extra = 0,
53
+		delta = 0;
54
+
55
+	// Adjustment may not be necessary
56
+	if ( box === ( isBorderBox ? "border" : "content" ) ) {
57
+		return 0;
58
+	}
59
+
60
+	for ( ; i < 4; i += 2 ) {
61
+
62
+		// Both box models exclude margin
63
+		if ( box === "margin" ) {
64
+			delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
65
+		}
66
+
67
+		// If we get here with a content-box, we're seeking "padding" or "border" or "margin"
68
+		if ( !isBorderBox ) {
69
+
70
+			// Add padding
71
+			delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
72
+
73
+			// For "border" or "margin", add border
74
+			if ( box !== "padding" ) {
75
+				delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
76
+
77
+			// But still keep track of it otherwise
78
+			} else {
79
+				extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
80
+			}
81
+
82
+		// If we get here with a border-box (content + padding + border), we're seeking "content" or
83
+		// "padding" or "margin"
84
+		} else {
85
+
86
+			// For "content", subtract padding
87
+			if ( box === "content" ) {
88
+				delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
89
+			}
90
+
91
+			// For "content" or "padding", subtract border
92
+			if ( box !== "margin" ) {
93
+				delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
94
+			}
95
+		}
96
+	}
97
+
98
+	// Account for positive content-box scroll gutter when requested by providing computedVal
99
+	if ( !isBorderBox && computedVal >= 0 ) {
100
+
101
+		// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
102
+		// Assuming integer scroll gutter, subtract the rest and round down
103
+		delta += Math.max( 0, Math.ceil(
104
+			elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
105
+			computedVal -
106
+			delta -
107
+			extra -
108
+			0.5
109
+
110
+		// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
111
+		// Use an explicit zero to avoid NaN (gh-3964)
112
+		) ) || 0;
113
+	}
114
+
115
+	return delta;
116
+}
117
+
118
+function getWidthOrHeight( elem, dimension, extra ) {
119
+
120
+	// Start with computed style
121
+	var styles = getStyles( elem ),
122
+
123
+		// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
124
+		// Fake content-box until we know it's needed to know the true value.
125
+		boxSizingNeeded = !support.boxSizingReliable() || extra,
126
+		isBorderBox = boxSizingNeeded &&
127
+			jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
128
+		valueIsBorderBox = isBorderBox,
129
+
130
+		val = curCSS( elem, dimension, styles ),
131
+		offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
132
+
133
+	// Support: Firefox <=54
134
+	// Return a confounding non-pixel value or feign ignorance, as appropriate.
135
+	if ( rnumnonpx.test( val ) ) {
136
+		if ( !extra ) {
137
+			return val;
138
+		}
139
+		val = "auto";
140
+	}
141
+
142
+
143
+	// Support: IE 9 - 11 only
144
+	// Use offsetWidth/offsetHeight for when box sizing is unreliable.
145
+	// In those cases, the computed value can be trusted to be border-box.
146
+	if ( ( !support.boxSizingReliable() && isBorderBox ||
147
+
148
+		// Support: IE 10 - 11+, Edge 15 - 18+
149
+		// IE/Edge misreport `getComputedStyle` of table rows with width/height
150
+		// set in CSS while `offset*` properties report correct values.
151
+		// Interestingly, in some cases IE 9 doesn't suffer from this issue.
152
+		!support.reliableTrDimensions() && nodeName( elem, "tr" ) ||
153
+
154
+		// Fall back to offsetWidth/offsetHeight when value is "auto"
155
+		// This happens for inline elements with no explicit setting (gh-3571)
156
+		val === "auto" ||
157
+
158
+		// Support: Android <=4.1 - 4.3 only
159
+		// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
160
+		!parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
161
+
162
+		// Make sure the element is visible & connected
163
+		elem.getClientRects().length ) {
164
+
165
+		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
166
+
167
+		// Where available, offsetWidth/offsetHeight approximate border box dimensions.
168
+		// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
169
+		// retrieved value as a content box dimension.
170
+		valueIsBorderBox = offsetProp in elem;
171
+		if ( valueIsBorderBox ) {
172
+			val = elem[ offsetProp ];
173
+		}
174
+	}
175
+
176
+	// Normalize "" and auto
177
+	val = parseFloat( val ) || 0;
178
+
179
+	// Adjust for the element's box model
180
+	return ( val +
181
+		boxModelAdjustment(
182
+			elem,
183
+			dimension,
184
+			extra || ( isBorderBox ? "border" : "content" ),
185
+			valueIsBorderBox,
186
+			styles,
187
+
188
+			// Provide the current computed size to request scroll gutter calculation (gh-3589)
189
+			val
190
+		)
191
+	) + "px";
192
+}
193
+
194
+jQuery.extend( {
195
+
196
+	// Add in style property hooks for overriding the default
197
+	// behavior of getting and setting a style property
198
+	cssHooks: {
199
+		opacity: {
200
+			get: function( elem, computed ) {
201
+				if ( computed ) {
202
+
203
+					// We should always get a number back from opacity
204
+					var ret = curCSS( elem, "opacity" );
205
+					return ret === "" ? "1" : ret;
206
+				}
207
+			}
208
+		}
209
+	},
210
+
211
+	// Don't automatically add "px" to these possibly-unitless properties
212
+	cssNumber: {
213
+		"animationIterationCount": true,
214
+		"columnCount": true,
215
+		"fillOpacity": true,
216
+		"flexGrow": true,
217
+		"flexShrink": true,
218
+		"fontWeight": true,
219
+		"gridArea": true,
220
+		"gridColumn": true,
221
+		"gridColumnEnd": true,
222
+		"gridColumnStart": true,
223
+		"gridRow": true,
224
+		"gridRowEnd": true,
225
+		"gridRowStart": true,
226
+		"lineHeight": true,
227
+		"opacity": true,
228
+		"order": true,
229
+		"orphans": true,
230
+		"widows": true,
231
+		"zIndex": true,
232
+		"zoom": true
233
+	},
234
+
235
+	// Add in properties whose names you wish to fix before
236
+	// setting or getting the value
237
+	cssProps: {},
238
+
239
+	// Get and set the style property on a DOM Node
240
+	style: function( elem, name, value, extra ) {
241
+
242
+		// Don't set styles on text and comment nodes
243
+		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
244
+			return;
245
+		}
246
+
247
+		// Make sure that we're working with the right name
248
+		var ret, type, hooks,
249
+			origName = camelCase( name ),
250
+			isCustomProp = rcustomProp.test( name ),
251
+			style = elem.style;
252
+
253
+		// Make sure that we're working with the right name. We don't
254
+		// want to query the value if it is a CSS custom property
255
+		// since they are user-defined.
256
+		if ( !isCustomProp ) {
257
+			name = finalPropName( origName );
258
+		}
259
+
260
+		// Gets hook for the prefixed version, then unprefixed version
261
+		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
262
+
263
+		// Check if we're setting a value
264
+		if ( value !== undefined ) {
265
+			type = typeof value;
266
+
267
+			// Convert "+=" or "-=" to relative numbers (#7345)
268
+			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
269
+				value = adjustCSS( elem, name, ret );
270
+
271
+				// Fixes bug #9237
272
+				type = "number";
273
+			}
274
+
275
+			// Make sure that null and NaN values aren't set (#7116)
276
+			if ( value == null || value !== value ) {
277
+				return;
278
+			}
279
+
280
+			// If a number was passed in, add the unit (except for certain CSS properties)
281
+			// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
282
+			// "px" to a few hardcoded values.
283
+			if ( type === "number" && !isCustomProp ) {
284
+				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
285
+			}
286
+
287
+			// background-* props affect original clone's values
288
+			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
289
+				style[ name ] = "inherit";
290
+			}
291
+
292
+			// If a hook was provided, use that value, otherwise just set the specified value
293
+			if ( !hooks || !( "set" in hooks ) ||
294
+				( value = hooks.set( elem, value, extra ) ) !== undefined ) {
295
+
296
+				if ( isCustomProp ) {
297
+					style.setProperty( name, value );
298
+				} else {
299
+					style[ name ] = value;
300
+				}
301
+			}
302
+
303
+		} else {
304
+
305
+			// If a hook was provided get the non-computed value from there
306
+			if ( hooks && "get" in hooks &&
307
+				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
308
+
309
+				return ret;
310
+			}
311
+
312
+			// Otherwise just get the value from the style object
313
+			return style[ name ];
314
+		}
315
+	},
316
+
317
+	css: function( elem, name, extra, styles ) {
318
+		var val, num, hooks,
319
+			origName = camelCase( name ),
320
+			isCustomProp = rcustomProp.test( name );
321
+
322
+		// Make sure that we're working with the right name. We don't
323
+		// want to modify the value if it is a CSS custom property
324
+		// since they are user-defined.
325
+		if ( !isCustomProp ) {
326
+			name = finalPropName( origName );
327
+		}
328
+
329
+		// Try prefixed name followed by the unprefixed name
330
+		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
331
+
332
+		// If a hook was provided get the computed value from there
333
+		if ( hooks && "get" in hooks ) {
334
+			val = hooks.get( elem, true, extra );
335
+		}
336
+
337
+		// Otherwise, if a way to get the computed value exists, use that
338
+		if ( val === undefined ) {
339
+			val = curCSS( elem, name, styles );
340
+		}
341
+
342
+		// Convert "normal" to computed value
343
+		if ( val === "normal" && name in cssNormalTransform ) {
344
+			val = cssNormalTransform[ name ];
345
+		}
346
+
347
+		// Make numeric if forced or a qualifier was provided and val looks numeric
348
+		if ( extra === "" || extra ) {
349
+			num = parseFloat( val );
350
+			return extra === true || isFinite( num ) ? num || 0 : val;
351
+		}
352
+
353
+		return val;
354
+	}
355
+} );
356
+
357
+jQuery.each( [ "height", "width" ], function( _i, dimension ) {
358
+	jQuery.cssHooks[ dimension ] = {
359
+		get: function( elem, computed, extra ) {
360
+			if ( computed ) {
361
+
362
+				// Certain elements can have dimension info if we invisibly show them
363
+				// but it must have a current display style that would benefit
364
+				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
365
+
366
+					// Support: Safari 8+
367
+					// Table columns in Safari have non-zero offsetWidth & zero
368
+					// getBoundingClientRect().width unless display is changed.
369
+					// Support: IE <=11 only
370
+					// Running getBoundingClientRect on a disconnected node
371
+					// in IE throws an error.
372
+					( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
373
+					swap( elem, cssShow, function() {
374
+						return getWidthOrHeight( elem, dimension, extra );
375
+					} ) :
376
+					getWidthOrHeight( elem, dimension, extra );
377
+			}
378
+		},
379
+
380
+		set: function( elem, value, extra ) {
381
+			var matches,
382
+				styles = getStyles( elem ),
383
+
384
+				// Only read styles.position if the test has a chance to fail
385
+				// to avoid forcing a reflow.
386
+				scrollboxSizeBuggy = !support.scrollboxSize() &&
387
+					styles.position === "absolute",
388
+
389
+				// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
390
+				boxSizingNeeded = scrollboxSizeBuggy || extra,
391
+				isBorderBox = boxSizingNeeded &&
392
+					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
393
+				subtract = extra ?
394
+					boxModelAdjustment(
395
+						elem,
396
+						dimension,
397
+						extra,
398
+						isBorderBox,
399
+						styles
400
+					) :
401
+					0;
402
+
403
+			// Account for unreliable border-box dimensions by comparing offset* to computed and
404
+			// faking a content-box to get border and padding (gh-3699)
405
+			if ( isBorderBox && scrollboxSizeBuggy ) {
406
+				subtract -= Math.ceil(
407
+					elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
408
+					parseFloat( styles[ dimension ] ) -
409
+					boxModelAdjustment( elem, dimension, "border", false, styles ) -
410
+					0.5
411
+				);
412
+			}
413
+
414
+			// Convert to pixels if value adjustment is needed
415
+			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
416
+				( matches[ 3 ] || "px" ) !== "px" ) {
417
+
418
+				elem.style[ dimension ] = value;
419
+				value = jQuery.css( elem, dimension );
420
+			}
421
+
422
+			return setPositiveNumber( elem, value, subtract );
423
+		}
424
+	};
425
+} );
426
+
427
+jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
428
+	function( elem, computed ) {
429
+		if ( computed ) {
430
+			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
431
+				elem.getBoundingClientRect().left -
432
+					swap( elem, { marginLeft: 0 }, function() {
433
+						return elem.getBoundingClientRect().left;
434
+					} )
435
+			) + "px";
436
+		}
437
+	}
438
+);
439
+
440
+// These hooks are used by animate to expand properties
441
+jQuery.each( {
442
+	margin: "",
443
+	padding: "",
444
+	border: "Width"
445
+}, function( prefix, suffix ) {
446
+	jQuery.cssHooks[ prefix + suffix ] = {
447
+		expand: function( value ) {
448
+			var i = 0,
449
+				expanded = {},
450
+
451
+				// Assumes a single number if not a string
452
+				parts = typeof value === "string" ? value.split( " " ) : [ value ];
453
+
454
+			for ( ; i < 4; i++ ) {
455
+				expanded[ prefix + cssExpand[ i ] + suffix ] =
456
+					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
457
+			}
458
+
459
+			return expanded;
460
+		}
461
+	};
462
+
463
+	if ( prefix !== "margin" ) {
464
+		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
465
+	}
466
+} );
467
+
468
+jQuery.fn.extend( {
469
+	css: function( name, value ) {
470
+		return access( this, function( elem, name, value ) {
471
+			var styles, len,
472
+				map = {},
473
+				i = 0;
474
+
475
+			if ( Array.isArray( name ) ) {
476
+				styles = getStyles( elem );
477
+				len = name.length;
478
+
479
+				for ( ; i < len; i++ ) {
480
+					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
481
+				}
482
+
483
+				return map;
484
+			}
485
+
486
+			return value !== undefined ?
487
+				jQuery.style( elem, name, value ) :
488
+				jQuery.css( elem, name );
489
+		}, name, value, arguments.length > 1 );
490
+	}
491
+} );
492
+
493
+return jQuery;
494
+} );

+ 26 - 0
app/static/bower_components/jQuery/src/css/addGetHookIf.js

@@ -0,0 +1,26 @@
1
+define( function() {
2
+
3
+"use strict";
4
+
5
+function addGetHookIf( conditionFn, hookFn ) {
6
+
7
+	// Define the hook, we'll check on the first run if it's really needed.
8
+	return {
9
+		get: function() {
10
+			if ( conditionFn() ) {
11
+
12
+				// Hook not needed (or it's not possible to use it due
13
+				// to missing dependency), remove it.
14
+				delete this.get;
15
+				return;
16
+			}
17
+
18
+			// Hook needed; redefine it so that the support test is not executed again.
19
+			return ( this.get = hookFn ).apply( this, arguments );
20
+		}
21
+	};
22
+}
23
+
24
+return addGetHookIf;
25
+
26
+} );

+ 74 - 0
app/static/bower_components/jQuery/src/css/adjustCSS.js

@@ -0,0 +1,74 @@
1
+define( [
2
+	"../core",
3
+	"../var/rcssNum"
4
+], function( jQuery, rcssNum ) {
5
+
6
+"use strict";
7
+
8
+function adjustCSS( elem, prop, valueParts, tween ) {
9
+	var adjusted, scale,
10
+		maxIterations = 20,
11
+		currentValue = tween ?
12
+			function() {
13
+				return tween.cur();
14
+			} :
15
+			function() {
16
+				return jQuery.css( elem, prop, "" );
17
+			},
18
+		initial = currentValue(),
19
+		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
20
+
21
+		// Starting value computation is required for potential unit mismatches
22
+		initialInUnit = elem.nodeType &&
23
+			( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
24
+			rcssNum.exec( jQuery.css( elem, prop ) );
25
+
26
+	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
27
+
28
+		// Support: Firefox <=54
29
+		// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
30
+		initial = initial / 2;
31
+
32
+		// Trust units reported by jQuery.css
33
+		unit = unit || initialInUnit[ 3 ];
34
+
35
+		// Iteratively approximate from a nonzero starting point
36
+		initialInUnit = +initial || 1;
37
+
38
+		while ( maxIterations-- ) {
39
+
40
+			// Evaluate and update our best guess (doubling guesses that zero out).
41
+			// Finish if the scale equals or crosses 1 (making the old*new product non-positive).
42
+			jQuery.style( elem, prop, initialInUnit + unit );
43
+			if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
44
+				maxIterations = 0;
45
+			}
46
+			initialInUnit = initialInUnit / scale;
47
+
48
+		}
49
+
50
+		initialInUnit = initialInUnit * 2;
51
+		jQuery.style( elem, prop, initialInUnit + unit );
52
+
53
+		// Make sure we update the tween properties later on
54
+		valueParts = valueParts || [];
55
+	}
56
+
57
+	if ( valueParts ) {
58
+		initialInUnit = +initialInUnit || +initial || 0;
59
+
60
+		// Apply relative offset (+=/-=) if specified
61
+		adjusted = valueParts[ 1 ] ?
62
+			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
63
+			+valueParts[ 2 ];
64
+		if ( tween ) {
65
+			tween.unit = unit;
66
+			tween.start = initialInUnit;
67
+			tween.end = adjusted;
68
+		}
69
+	}
70
+	return adjusted;
71
+}
72
+
73
+return adjustCSS;
74
+} );

+ 65 - 0
app/static/bower_components/jQuery/src/css/curCSS.js

@@ -0,0 +1,65 @@
1
+define( [
2
+	"../core",
3
+	"../core/isAttached",
4
+	"./var/rboxStyle",
5
+	"./var/rnumnonpx",
6
+	"./var/getStyles",
7
+	"./support"
8
+], function( jQuery, isAttached, rboxStyle, rnumnonpx, getStyles, support ) {
9
+
10
+"use strict";
11
+
12
+function curCSS( elem, name, computed ) {
13
+	var width, minWidth, maxWidth, ret,
14
+
15
+		// Support: Firefox 51+
16
+		// Retrieving style before computed somehow
17
+		// fixes an issue with getting wrong values
18
+		// on detached elements
19
+		style = elem.style;
20
+
21
+	computed = computed || getStyles( elem );
22
+
23
+	// getPropertyValue is needed for:
24
+	//   .css('filter') (IE 9 only, #12537)
25
+	//   .css('--customProperty) (#3144)
26
+	if ( computed ) {
27
+		ret = computed.getPropertyValue( name ) || computed[ name ];
28
+
29
+		if ( ret === "" && !isAttached( elem ) ) {
30
+			ret = jQuery.style( elem, name );
31
+		}
32
+
33
+		// A tribute to the "awesome hack by Dean Edwards"
34
+		// Android Browser returns percentage for some values,
35
+		// but width seems to be reliably pixels.
36
+		// This is against the CSSOM draft spec:
37
+		// https://drafts.csswg.org/cssom/#resolved-values
38
+		if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
39
+
40
+			// Remember the original values
41
+			width = style.width;
42
+			minWidth = style.minWidth;
43
+			maxWidth = style.maxWidth;
44
+
45
+			// Put in the new values to get a computed value out
46
+			style.minWidth = style.maxWidth = style.width = ret;
47
+			ret = computed.width;
48
+
49
+			// Revert the changed values
50
+			style.width = width;
51
+			style.minWidth = minWidth;
52
+			style.maxWidth = maxWidth;
53
+		}
54
+	}
55
+
56
+	return ret !== undefined ?
57
+
58
+		// Support: IE <=9 - 11 only
59
+		// IE returns zIndex value as an integer.
60
+		ret + "" :
61
+		ret;
62
+}
63
+
64
+return curCSS;
65
+} );

+ 42 - 0
app/static/bower_components/jQuery/src/css/finalPropName.js

@@ -0,0 +1,42 @@
1
+define( [
2
+	"../var/document",
3
+	"../core"
4
+], function( document, jQuery ) {
5
+
6
+"use strict";
7
+
8
+var cssPrefixes = [ "Webkit", "Moz", "ms" ],
9
+	emptyStyle = document.createElement( "div" ).style,
10
+	vendorProps = {};
11
+
12
+// Return a vendor-prefixed property or undefined
13
+function vendorPropName( name ) {
14
+
15
+	// Check for vendor prefixed names
16
+	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
17
+		i = cssPrefixes.length;
18
+
19
+	while ( i-- ) {
20
+		name = cssPrefixes[ i ] + capName;
21
+		if ( name in emptyStyle ) {
22
+			return name;
23
+		}
24
+	}
25
+}
26
+
27
+// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
28
+function finalPropName( name ) {
29
+	var final = jQuery.cssProps[ name ] || vendorProps[ name ];
30
+
31
+	if ( final ) {
32
+		return final;
33
+	}
34
+	if ( name in emptyStyle ) {
35
+		return name;
36
+	}
37
+	return vendorProps[ name ] = vendorPropName( name ) || name;
38
+}
39
+
40
+return finalPropName;
41
+
42
+} );

+ 15 - 0
app/static/bower_components/jQuery/src/css/hiddenVisibleSelectors.js

@@ -0,0 +1,15 @@
1
+define( [
2
+	"../core",
3
+	"../selector"
4
+], function( jQuery ) {
5
+
6
+"use strict";
7
+
8
+jQuery.expr.pseudos.hidden = function( elem ) {
9
+	return !jQuery.expr.pseudos.visible( elem );
10
+};
11
+jQuery.expr.pseudos.visible = function( elem ) {
12
+	return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
13
+};
14
+
15
+} );

+ 105 - 0
app/static/bower_components/jQuery/src/css/showHide.js

@@ -0,0 +1,105 @@
1
+define( [
2
+	"../core",
3
+	"../data/var/dataPriv",
4
+	"../css/var/isHiddenWithinTree"
5
+], function( jQuery, dataPriv, isHiddenWithinTree ) {
6
+
7
+"use strict";
8
+
9
+var defaultDisplayMap = {};
10
+
11
+function getDefaultDisplay( elem ) {
12
+	var temp,
13
+		doc = elem.ownerDocument,
14
+		nodeName = elem.nodeName,
15
+		display = defaultDisplayMap[ nodeName ];
16
+
17
+	if ( display ) {
18
+		return display;
19
+	}
20
+
21
+	temp = doc.body.appendChild( doc.createElement( nodeName ) );
22
+	display = jQuery.css( temp, "display" );
23
+
24
+	temp.parentNode.removeChild( temp );
25
+
26
+	if ( display === "none" ) {
27
+		display = "block";
28
+	}
29
+	defaultDisplayMap[ nodeName ] = display;
30
+
31
+	return display;
32
+}
33
+
34
+function showHide( elements, show ) {
35
+	var display, elem,
36
+		values = [],
37
+		index = 0,
38
+		length = elements.length;
39
+
40
+	// Determine new display value for elements that need to change
41
+	for ( ; index < length; index++ ) {
42
+		elem = elements[ index ];
43
+		if ( !elem.style ) {
44
+			continue;
45
+		}
46
+
47
+		display = elem.style.display;
48
+		if ( show ) {
49
+
50
+			// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
51
+			// check is required in this first loop unless we have a nonempty display value (either
52
+			// inline or about-to-be-restored)
53
+			if ( display === "none" ) {
54
+				values[ index ] = dataPriv.get( elem, "display" ) || null;
55
+				if ( !values[ index ] ) {
56
+					elem.style.display = "";
57
+				}
58
+			}
59
+			if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
60
+				values[ index ] = getDefaultDisplay( elem );
61
+			}
62
+		} else {
63
+			if ( display !== "none" ) {
64
+				values[ index ] = "none";
65
+
66
+				// Remember what we're overwriting
67
+				dataPriv.set( elem, "display", display );
68
+			}
69
+		}
70
+	}
71
+
72
+	// Set the display of the elements in a second loop to avoid constant reflow
73
+	for ( index = 0; index < length; index++ ) {
74
+		if ( values[ index ] != null ) {
75
+			elements[ index ].style.display = values[ index ];
76
+		}
77
+	}
78
+
79
+	return elements;
80
+}
81
+
82
+jQuery.fn.extend( {
83
+	show: function() {
84
+		return showHide( this, true );
85
+	},
86
+	hide: function() {
87
+		return showHide( this );
88
+	},
89
+	toggle: function( state ) {
90
+		if ( typeof state === "boolean" ) {
91
+			return state ? this.show() : this.hide();
92
+		}
93
+
94
+		return this.each( function() {
95
+			if ( isHiddenWithinTree( this ) ) {
96
+				jQuery( this ).show();
97
+			} else {
98
+				jQuery( this ).hide();
99
+			}
100
+		} );
101
+	}
102
+} );
103
+
104
+return showHide;
105
+} );

+ 152 - 0
app/static/bower_components/jQuery/src/css/support.js

@@ -0,0 +1,152 @@
1
+define( [
2
+	"../core",
3
+	"../var/document",
4
+	"../var/documentElement",
5
+	"../var/support"
6
+], function( jQuery, document, documentElement, support ) {
7
+
8
+"use strict";
9
+
10
+( function() {
11
+
12
+	// Executing both pixelPosition & boxSizingReliable tests require only one layout
13
+	// so they're executed at the same time to save the second computation.
14
+	function computeStyleTests() {
15
+
16
+		// This is a singleton, we need to execute it only once
17
+		if ( !div ) {
18
+			return;
19
+		}
20
+
21
+		container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
22
+			"margin-top:1px;padding:0;border:0";
23
+		div.style.cssText =
24
+			"position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
25
+			"margin:auto;border:1px;padding:1px;" +
26
+			"width:60%;top:1%";
27
+		documentElement.appendChild( container ).appendChild( div );
28
+
29
+		var divStyle = window.getComputedStyle( div );
30
+		pixelPositionVal = divStyle.top !== "1%";
31
+
32
+		// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
33
+		reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
34
+
35
+		// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
36
+		// Some styles come back with percentage values, even though they shouldn't
37
+		div.style.right = "60%";
38
+		pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
39
+
40
+		// Support: IE 9 - 11 only
41
+		// Detect misreporting of content dimensions for box-sizing:border-box elements
42
+		boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
43
+
44
+		// Support: IE 9 only
45
+		// Detect overflow:scroll screwiness (gh-3699)
46
+		// Support: Chrome <=64
47
+		// Don't get tricked when zoom affects offsetWidth (gh-4029)
48
+		div.style.position = "absolute";
49
+		scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
50
+
51
+		documentElement.removeChild( container );
52
+
53
+		// Nullify the div so it wouldn't be stored in the memory and
54
+		// it will also be a sign that checks already performed
55
+		div = null;
56
+	}
57
+
58
+	function roundPixelMeasures( measure ) {
59
+		return Math.round( parseFloat( measure ) );
60
+	}
61
+
62
+	var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
63
+		reliableTrDimensionsVal, reliableMarginLeftVal,
64
+		container = document.createElement( "div" ),
65
+		div = document.createElement( "div" );
66
+
67
+	// Finish early in limited (non-browser) environments
68
+	if ( !div.style ) {
69
+		return;
70
+	}
71
+
72
+	// Support: IE <=9 - 11 only
73
+	// Style of cloned element affects source element cloned (#8908)
74
+	div.style.backgroundClip = "content-box";
75
+	div.cloneNode( true ).style.backgroundClip = "";
76
+	support.clearCloneStyle = div.style.backgroundClip === "content-box";
77
+
78
+	jQuery.extend( support, {
79
+		boxSizingReliable: function() {
80
+			computeStyleTests();
81
+			return boxSizingReliableVal;
82
+		},
83
+		pixelBoxStyles: function() {
84
+			computeStyleTests();
85
+			return pixelBoxStylesVal;
86
+		},
87
+		pixelPosition: function() {
88
+			computeStyleTests();
89
+			return pixelPositionVal;
90
+		},
91
+		reliableMarginLeft: function() {
92
+			computeStyleTests();
93
+			return reliableMarginLeftVal;
94
+		},
95
+		scrollboxSize: function() {
96
+			computeStyleTests();
97
+			return scrollboxSizeVal;
98
+		},
99
+
100
+		// Support: IE 9 - 11+, Edge 15 - 18+
101
+		// IE/Edge misreport `getComputedStyle` of table rows with width/height
102
+		// set in CSS while `offset*` properties report correct values.
103
+		// Behavior in IE 9 is more subtle than in newer versions & it passes
104
+		// some versions of this test; make sure not to make it pass there!
105
+		//
106
+		// Support: Firefox 70+
107
+		// Only Firefox includes border widths
108
+		// in computed dimensions. (gh-4529)
109
+		reliableTrDimensions: function() {
110
+			var table, tr, trChild, trStyle;
111
+			if ( reliableTrDimensionsVal == null ) {
112
+				table = document.createElement( "table" );
113
+				tr = document.createElement( "tr" );
114
+				trChild = document.createElement( "div" );
115
+
116
+				table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
117
+				tr.style.cssText = "border:1px solid";
118
+
119
+				// Support: Chrome 86+
120
+				// Height set through cssText does not get applied.
121
+				// Computed height then comes back as 0.
122
+				tr.style.height = "1px";
123
+				trChild.style.height = "9px";
124
+
125
+				// Support: Android 8 Chrome 86+
126
+				// In our bodyBackground.html iframe,
127
+				// display for all div elements is set to "inline",
128
+				// which causes a problem only in Android 8 Chrome 86.
129
+				// Ensuring the div is display: block
130
+				// gets around this issue.
131
+				trChild.style.display = "block";
132
+
133
+				documentElement
134
+					.appendChild( table )
135
+					.appendChild( tr )
136
+					.appendChild( trChild );
137
+
138
+				trStyle = window.getComputedStyle( tr );
139
+				reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +
140
+					parseInt( trStyle.borderTopWidth, 10 ) +
141
+					parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;
142
+
143
+				documentElement.removeChild( table );
144
+			}
145
+			return reliableTrDimensionsVal;
146
+		}
147
+	} );
148
+} )();
149
+
150
+return support;
151
+
152
+} );

+ 180 - 0
app/static/bower_components/jQuery/src/data.js

@@ -0,0 +1,180 @@
1
+define( [
2
+	"./core",
3
+	"./core/access",
4
+	"./core/camelCase",
5
+	"./data/var/dataPriv",
6
+	"./data/var/dataUser"
7
+], function( jQuery, access, camelCase, dataPriv, dataUser ) {
8
+
9
+"use strict";
10
+
11
+//	Implementation Summary
12
+//
13
+//	1. Enforce API surface and semantic compatibility with 1.9.x branch
14
+//	2. Improve the module's maintainability by reducing the storage
15
+//		paths to a single mechanism.
16
+//	3. Use the same single mechanism to support "private" and "user" data.
17
+//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
18
+//	5. Avoid exposing implementation details on user objects (eg. expando properties)
19
+//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
20
+
21
+var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
22
+	rmultiDash = /[A-Z]/g;
23
+
24
+function getData( data ) {
25
+	if ( data === "true" ) {
26
+		return true;
27
+	}
28
+
29
+	if ( data === "false" ) {
30
+		return false;
31
+	}
32
+
33
+	if ( data === "null" ) {
34
+		return null;
35
+	}
36
+
37
+	// Only convert to a number if it doesn't change the string
38
+	if ( data === +data + "" ) {
39
+		return +data;
40
+	}
41
+
42
+	if ( rbrace.test( data ) ) {
43
+		return JSON.parse( data );
44
+	}
45
+
46
+	return data;
47
+}
48
+
49
+function dataAttr( elem, key, data ) {
50
+	var name;
51
+
52
+	// If nothing was found internally, try to fetch any
53
+	// data from the HTML5 data-* attribute
54
+	if ( data === undefined && elem.nodeType === 1 ) {
55
+		name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
56
+		data = elem.getAttribute( name );
57
+
58
+		if ( typeof data === "string" ) {
59
+			try {
60
+				data = getData( data );
61
+			} catch ( e ) {}
62
+
63
+			// Make sure we set the data so it isn't changed later
64
+			dataUser.set( elem, key, data );
65
+		} else {
66
+			data = undefined;
67
+		}
68
+	}
69
+	return data;
70
+}
71
+
72
+jQuery.extend( {
73
+	hasData: function( elem ) {
74
+		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
75
+	},
76
+
77
+	data: function( elem, name, data ) {
78
+		return dataUser.access( elem, name, data );
79
+	},
80
+
81
+	removeData: function( elem, name ) {
82
+		dataUser.remove( elem, name );
83
+	},
84
+
85
+	// TODO: Now that all calls to _data and _removeData have been replaced
86
+	// with direct calls to dataPriv methods, these can be deprecated.
87
+	_data: function( elem, name, data ) {
88
+		return dataPriv.access( elem, name, data );
89
+	},
90
+
91
+	_removeData: function( elem, name ) {
92
+		dataPriv.remove( elem, name );
93
+	}
94
+} );
95
+
96
+jQuery.fn.extend( {
97
+	data: function( key, value ) {
98
+		var i, name, data,
99
+			elem = this[ 0 ],
100
+			attrs = elem && elem.attributes;
101
+
102
+		// Gets all values
103
+		if ( key === undefined ) {
104
+			if ( this.length ) {
105
+				data = dataUser.get( elem );
106
+
107
+				if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
108
+					i = attrs.length;
109
+					while ( i-- ) {
110
+
111
+						// Support: IE 11 only
112
+						// The attrs elements can be null (#14894)
113
+						if ( attrs[ i ] ) {
114
+							name = attrs[ i ].name;
115
+							if ( name.indexOf( "data-" ) === 0 ) {
116
+								name = camelCase( name.slice( 5 ) );
117
+								dataAttr( elem, name, data[ name ] );
118
+							}
119
+						}
120
+					}
121
+					dataPriv.set( elem, "hasDataAttrs", true );
122
+				}
123
+			}
124
+
125
+			return data;
126
+		}
127
+
128
+		// Sets multiple values
129
+		if ( typeof key === "object" ) {
130
+			return this.each( function() {
131
+				dataUser.set( this, key );
132
+			} );
133
+		}
134
+
135
+		return access( this, function( value ) {
136
+			var data;
137
+
138
+			// The calling jQuery object (element matches) is not empty
139
+			// (and therefore has an element appears at this[ 0 ]) and the
140
+			// `value` parameter was not undefined. An empty jQuery object
141
+			// will result in `undefined` for elem = this[ 0 ] which will
142
+			// throw an exception if an attempt to read a data cache is made.
143
+			if ( elem && value === undefined ) {
144
+
145
+				// Attempt to get data from the cache
146
+				// The key will always be camelCased in Data
147
+				data = dataUser.get( elem, key );
148
+				if ( data !== undefined ) {
149
+					return data;
150
+				}
151
+
152
+				// Attempt to "discover" the data in
153
+				// HTML5 custom data-* attrs
154
+				data = dataAttr( elem, key );
155
+				if ( data !== undefined ) {
156
+					return data;
157
+				}
158
+
159
+				// We tried really hard, but the data doesn't exist.
160
+				return;
161
+			}
162
+
163
+			// Set the data...
164
+			this.each( function() {
165
+
166
+				// We always store the camelCased key
167
+				dataUser.set( this, key, value );
168
+			} );
169
+		}, null, value, arguments.length > 1, null, true );
170
+	},
171
+
172
+	removeData: function( key ) {
173
+		return this.each( function() {
174
+			dataUser.remove( this, key );
175
+		} );
176
+	}
177
+} );
178
+
179
+return jQuery;
180
+} );

+ 399 - 0
app/static/bower_components/jQuery/src/deferred.js

@@ -0,0 +1,399 @@
1
+define( [
2
+	"./core",
3
+	"./var/isFunction",
4
+	"./var/slice",
5
+	"./callbacks"
6
+], function( jQuery, isFunction, slice ) {
7
+
8
+"use strict";
9
+
10
+function Identity( v ) {
11
+	return v;
12
+}
13
+function Thrower( ex ) {
14
+	throw ex;
15
+}
16
+
17
+function adoptValue( value, resolve, reject, noValue ) {
18
+	var method;
19
+
20
+	try {
21
+
22
+		// Check for promise aspect first to privilege synchronous behavior
23
+		if ( value && isFunction( ( method = value.promise ) ) ) {
24
+			method.call( value ).done( resolve ).fail( reject );
25
+
26
+		// Other thenables
27
+		} else if ( value && isFunction( ( method = value.then ) ) ) {
28
+			method.call( value, resolve, reject );
29
+
30
+		// Other non-thenables
31
+		} else {
32
+
33
+			// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
34
+			// * false: [ value ].slice( 0 ) => resolve( value )
35
+			// * true: [ value ].slice( 1 ) => resolve()
36
+			resolve.apply( undefined, [ value ].slice( noValue ) );
37
+		}
38
+
39
+	// For Promises/A+, convert exceptions into rejections
40
+	// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
41
+	// Deferred#then to conditionally suppress rejection.
42
+	} catch ( value ) {
43
+
44
+		// Support: Android 4.0 only
45
+		// Strict mode functions invoked without .call/.apply get global-object context
46
+		reject.apply( undefined, [ value ] );
47
+	}
48
+}
49
+
50
+jQuery.extend( {
51
+
52
+	Deferred: function( func ) {
53
+		var tuples = [
54
+
55
+				// action, add listener, callbacks,
56
+				// ... .then handlers, argument index, [final state]
57
+				[ "notify", "progress", jQuery.Callbacks( "memory" ),
58
+					jQuery.Callbacks( "memory" ), 2 ],
59
+				[ "resolve", "done", jQuery.Callbacks( "once memory" ),
60
+					jQuery.Callbacks( "once memory" ), 0, "resolved" ],
61
+				[ "reject", "fail", jQuery.Callbacks( "once memory" ),
62
+					jQuery.Callbacks( "once memory" ), 1, "rejected" ]
63
+			],
64
+			state = "pending",
65
+			promise = {
66
+				state: function() {
67
+					return state;
68
+				},
69
+				always: function() {
70
+					deferred.done( arguments ).fail( arguments );
71
+					return this;
72
+				},
73
+				"catch": function( fn ) {
74
+					return promise.then( null, fn );
75
+				},
76
+
77
+				// Keep pipe for back-compat
78
+				pipe: function( /* fnDone, fnFail, fnProgress */ ) {
79
+					var fns = arguments;
80
+
81
+					return jQuery.Deferred( function( newDefer ) {
82
+						jQuery.each( tuples, function( _i, tuple ) {
83
+
84
+							// Map tuples (progress, done, fail) to arguments (done, fail, progress)
85
+							var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
86
+
87
+							// deferred.progress(function() { bind to newDefer or newDefer.notify })
88
+							// deferred.done(function() { bind to newDefer or newDefer.resolve })
89
+							// deferred.fail(function() { bind to newDefer or newDefer.reject })
90
+							deferred[ tuple[ 1 ] ]( function() {
91
+								var returned = fn && fn.apply( this, arguments );
92
+								if ( returned && isFunction( returned.promise ) ) {
93
+									returned.promise()
94
+										.progress( newDefer.notify )
95
+										.done( newDefer.resolve )
96
+										.fail( newDefer.reject );
97
+								} else {
98
+									newDefer[ tuple[ 0 ] + "With" ](
99
+										this,
100
+										fn ? [ returned ] : arguments
101
+									);
102
+								}
103
+							} );
104
+						} );
105
+						fns = null;
106
+					} ).promise();
107
+				},
108
+				then: function( onFulfilled, onRejected, onProgress ) {
109
+					var maxDepth = 0;
110
+					function resolve( depth, deferred, handler, special ) {
111
+						return function() {
112
+							var that = this,
113
+								args = arguments,
114
+								mightThrow = function() {
115
+									var returned, then;
116
+
117
+									// Support: Promises/A+ section 2.3.3.3.3
118
+									// https://promisesaplus.com/#point-59
119
+									// Ignore double-resolution attempts
120
+									if ( depth < maxDepth ) {
121
+										return;
122
+									}
123
+
124
+									returned = handler.apply( that, args );
125
+
126
+									// Support: Promises/A+ section 2.3.1
127
+									// https://promisesaplus.com/#point-48
128
+									if ( returned === deferred.promise() ) {
129
+										throw new TypeError( "Thenable self-resolution" );
130
+									}
131
+
132
+									// Support: Promises/A+ sections 2.3.3.1, 3.5
133
+									// https://promisesaplus.com/#point-54
134
+									// https://promisesaplus.com/#point-75
135
+									// Retrieve `then` only once
136
+									then = returned &&
137
+
138
+										// Support: Promises/A+ section 2.3.4
139
+										// https://promisesaplus.com/#point-64
140
+										// Only check objects and functions for thenability
141
+										( typeof returned === "object" ||
142
+											typeof returned === "function" ) &&
143
+										returned.then;
144
+
145
+									// Handle a returned thenable
146
+									if ( isFunction( then ) ) {
147
+
148
+										// Special processors (notify) just wait for resolution
149
+										if ( special ) {
150
+											then.call(
151
+												returned,
152
+												resolve( maxDepth, deferred, Identity, special ),
153
+												resolve( maxDepth, deferred, Thrower, special )
154
+											);
155
+
156
+										// Normal processors (resolve) also hook into progress
157
+										} else {
158
+
159
+											// ...and disregard older resolution values
160
+											maxDepth++;
161
+
162
+											then.call(
163
+												returned,
164
+												resolve( maxDepth, deferred, Identity, special ),
165
+												resolve( maxDepth, deferred, Thrower, special ),
166
+												resolve( maxDepth, deferred, Identity,
167
+													deferred.notifyWith )
168
+											);
169
+										}
170
+
171
+									// Handle all other returned values
172
+									} else {
173
+
174
+										// Only substitute handlers pass on context
175
+										// and multiple values (non-spec behavior)
176
+										if ( handler !== Identity ) {
177
+											that = undefined;
178
+											args = [ returned ];
179
+										}
180
+
181
+										// Process the value(s)
182
+										// Default process is resolve
183
+										( special || deferred.resolveWith )( that, args );
184
+									}
185
+								},
186
+
187
+								// Only normal processors (resolve) catch and reject exceptions
188
+								process = special ?
189
+									mightThrow :
190
+									function() {
191
+										try {
192
+											mightThrow();
193
+										} catch ( e ) {
194
+
195
+											if ( jQuery.Deferred.exceptionHook ) {
196
+												jQuery.Deferred.exceptionHook( e,
197
+													process.stackTrace );
198
+											}
199
+
200
+											// Support: Promises/A+ section 2.3.3.3.4.1
201
+											// https://promisesaplus.com/#point-61
202
+											// Ignore post-resolution exceptions
203
+											if ( depth + 1 >= maxDepth ) {
204
+
205
+												// Only substitute handlers pass on context
206
+												// and multiple values (non-spec behavior)
207
+												if ( handler !== Thrower ) {
208
+													that = undefined;
209
+													args = [ e ];
210
+												}
211
+
212
+												deferred.rejectWith( that, args );
213
+											}
214
+										}
215
+									};
216
+
217
+							// Support: Promises/A+ section 2.3.3.3.1
218
+							// https://promisesaplus.com/#point-57
219
+							// Re-resolve promises immediately to dodge false rejection from
220
+							// subsequent errors
221
+							if ( depth ) {
222
+								process();
223
+							} else {
224
+
225
+								// Call an optional hook to record the stack, in case of exception
226
+								// since it's otherwise lost when execution goes async
227
+								if ( jQuery.Deferred.getStackHook ) {
228
+									process.stackTrace = jQuery.Deferred.getStackHook();
229
+								}
230
+								window.setTimeout( process );
231
+							}
232
+						};
233
+					}
234
+
235
+					return jQuery.Deferred( function( newDefer ) {
236
+
237
+						// progress_handlers.add( ... )
238
+						tuples[ 0 ][ 3 ].add(
239
+							resolve(
240
+								0,
241
+								newDefer,
242
+								isFunction( onProgress ) ?
243
+									onProgress :
244
+									Identity,
245
+								newDefer.notifyWith
246
+							)
247
+						);
248
+
249
+						// fulfilled_handlers.add( ... )
250
+						tuples[ 1 ][ 3 ].add(
251
+							resolve(
252
+								0,
253
+								newDefer,
254
+								isFunction( onFulfilled ) ?
255
+									onFulfilled :
256
+									Identity
257
+							)
258
+						);
259
+
260
+						// rejected_handlers.add( ... )
261
+						tuples[ 2 ][ 3 ].add(
262
+							resolve(
263
+								0,
264
+								newDefer,
265
+								isFunction( onRejected ) ?
266
+									onRejected :
267
+									Thrower
268
+							)
269
+						);
270
+					} ).promise();
271
+				},
272
+
273
+				// Get a promise for this deferred
274
+				// If obj is provided, the promise aspect is added to the object
275
+				promise: function( obj ) {
276
+					return obj != null ? jQuery.extend( obj, promise ) : promise;
277
+				}
278
+			},
279
+			deferred = {};
280
+
281
+		// Add list-specific methods
282
+		jQuery.each( tuples, function( i, tuple ) {
283
+			var list = tuple[ 2 ],
284
+				stateString = tuple[ 5 ];
285
+
286
+			// promise.progress = list.add
287
+			// promise.done = list.add
288
+			// promise.fail = list.add
289
+			promise[ tuple[ 1 ] ] = list.add;
290
+
291
+			// Handle state
292
+			if ( stateString ) {
293
+				list.add(
294
+					function() {
295
+
296
+						// state = "resolved" (i.e., fulfilled)
297
+						// state = "rejected"
298
+						state = stateString;
299
+					},
300
+
301
+					// rejected_callbacks.disable
302
+					// fulfilled_callbacks.disable
303
+					tuples[ 3 - i ][ 2 ].disable,
304
+
305
+					// rejected_handlers.disable
306
+					// fulfilled_handlers.disable
307
+					tuples[ 3 - i ][ 3 ].disable,
308
+
309
+					// progress_callbacks.lock
310
+					tuples[ 0 ][ 2 ].lock,
311
+
312
+					// progress_handlers.lock
313
+					tuples[ 0 ][ 3 ].lock
314
+				);
315
+			}
316
+
317
+			// progress_handlers.fire
318
+			// fulfilled_handlers.fire
319
+			// rejected_handlers.fire
320
+			list.add( tuple[ 3 ].fire );
321
+
322
+			// deferred.notify = function() { deferred.notifyWith(...) }
323
+			// deferred.resolve = function() { deferred.resolveWith(...) }
324
+			// deferred.reject = function() { deferred.rejectWith(...) }
325
+			deferred[ tuple[ 0 ] ] = function() {
326
+				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
327
+				return this;
328
+			};
329
+
330
+			// deferred.notifyWith = list.fireWith
331
+			// deferred.resolveWith = list.fireWith
332
+			// deferred.rejectWith = list.fireWith
333
+			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
334
+		} );
335
+
336
+		// Make the deferred a promise
337
+		promise.promise( deferred );
338
+
339
+		// Call given func if any
340
+		if ( func ) {
341
+			func.call( deferred, deferred );
342
+		}
343
+
344
+		// All done!
345
+		return deferred;
346
+	},
347
+
348
+	// Deferred helper
349
+	when: function( singleValue ) {
350
+		var
351
+
352
+			// count of uncompleted subordinates
353
+			remaining = arguments.length,
354
+
355
+			// count of unprocessed arguments
356
+			i = remaining,
357
+
358
+			// subordinate fulfillment data
359
+			resolveContexts = Array( i ),
360
+			resolveValues = slice.call( arguments ),
361
+
362
+			// the primary Deferred
363
+			primary = jQuery.Deferred(),
364
+
365
+			// subordinate callback factory
366
+			updateFunc = function( i ) {
367
+				return function( value ) {
368
+					resolveContexts[ i ] = this;
369
+					resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
370
+					if ( !( --remaining ) ) {
371
+						primary.resolveWith( resolveContexts, resolveValues );
372
+					}
373
+				};
374
+			};
375
+
376
+		// Single- and empty arguments are adopted like Promise.resolve
377
+		if ( remaining <= 1 ) {
378
+			adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,
379
+				!remaining );
380
+
381
+			// Use .then() to unwrap secondary thenables (cf. gh-3000)
382
+			if ( primary.state() === "pending" ||
383
+				isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
384
+
385
+				return primary.then();
386
+			}
387
+		}
388
+
389
+		// Multiple arguments are aggregated like Promise.all array elements
390
+		while ( i-- ) {
391
+			adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );
392
+		}
393
+
394
+		return primary.promise();
395
+	}
396
+} );
397
+
398
+return jQuery;
399
+} );

+ 21 - 0
app/static/bower_components/jQuery/src/deferred/exceptionHook.js

@@ -0,0 +1,21 @@
1
+define( [
2
+	"../core",
3
+	"../deferred"
4
+], function( jQuery ) {
5
+
6
+"use strict";
7
+
8
+// These usually indicate a programmer mistake during development,
9
+// warn about them ASAP rather than swallowing them by default.
10
+var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
11
+
12
+jQuery.Deferred.exceptionHook = function( error, stack ) {
13
+
14
+	// Support: IE 8 - 9 only
15
+	// Console exists when dev tools are open, which can happen at any time
16
+	if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
17
+		window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
18
+	}
19
+};
20
+
21
+} );

+ 87 - 0
app/static/bower_components/jQuery/src/deprecated.js

@@ -0,0 +1,87 @@
1
+define( [
2
+	"./core",
3
+	"./core/nodeName",
4
+	"./core/camelCase",
5
+	"./core/toType",
6
+	"./var/isFunction",
7
+	"./var/isWindow",
8
+	"./var/slice",
9
+
10
+	"./deprecated/ajax-event-alias",
11
+	"./deprecated/event"
12
+], function( jQuery, nodeName, camelCase, toType, isFunction, isWindow, slice ) {
13
+
14
+"use strict";
15
+
16
+// Support: Android <=4.0 only
17
+// Make sure we trim BOM and NBSP
18
+var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
19
+
20
+// Bind a function to a context, optionally partially applying any
21
+// arguments.
22
+// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
23
+// However, it is not slated for removal any time soon
24
+jQuery.proxy = function( fn, context ) {
25
+	var tmp, args, proxy;
26
+
27
+	if ( typeof context === "string" ) {
28
+		tmp = fn[ context ];
29
+		context = fn;
30
+		fn = tmp;
31
+	}
32
+
33
+	// Quick check to determine if target is callable, in the spec
34
+	// this throws a TypeError, but we will just return undefined.
35
+	if ( !isFunction( fn ) ) {
36
+		return undefined;
37
+	}
38
+
39
+	// Simulated bind
40
+	args = slice.call( arguments, 2 );
41
+	proxy = function() {
42
+		return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
43
+	};
44
+
45
+	// Set the guid of unique handler to the same of original handler, so it can be removed
46
+	proxy.guid = fn.guid = fn.guid || jQuery.guid++;
47
+
48
+	return proxy;
49
+};
50
+
51
+jQuery.holdReady = function( hold ) {
52
+	if ( hold ) {
53
+		jQuery.readyWait++;
54
+	} else {
55
+		jQuery.ready( true );
56
+	}
57
+};
58
+jQuery.isArray = Array.isArray;
59
+jQuery.parseJSON = JSON.parse;
60
+jQuery.nodeName = nodeName;
61
+jQuery.isFunction = isFunction;
62
+jQuery.isWindow = isWindow;
63
+jQuery.camelCase = camelCase;
64
+jQuery.type = toType;
65
+
66
+jQuery.now = Date.now;
67
+
68
+jQuery.isNumeric = function( obj ) {
69
+
70
+	// As of jQuery 3.0, isNumeric is limited to
71
+	// strings and numbers (primitives or objects)
72
+	// that can be coerced to finite numbers (gh-2662)
73
+	var type = jQuery.type( obj );
74
+	return ( type === "number" || type === "string" ) &&
75
+
76
+		// parseFloat NaNs numeric-cast false positives ("")
77
+		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
78
+		// subtraction forces infinities to NaN
79
+		!isNaN( obj - parseFloat( obj ) );
80
+};
81
+
82
+jQuery.trim = function( text ) {
83
+	return text == null ?
84
+		"" :
85
+		( text + "" ).replace( rtrim, "" );
86
+};
87
+} );

+ 22 - 0
app/static/bower_components/jQuery/src/deprecated/ajax-event-alias.js

@@ -0,0 +1,22 @@
1
+define( [
2
+	"../core",
3
+	"../ajax",
4
+	"../event"
5
+], function( jQuery ) {
6
+
7
+"use strict";
8
+
9
+jQuery.each( [
10
+	"ajaxStart",
11
+	"ajaxStop",
12
+	"ajaxComplete",
13
+	"ajaxError",
14
+	"ajaxSuccess",
15
+	"ajaxSend"
16
+], function( _i, type ) {
17
+	jQuery.fn[ type ] = function( fn ) {
18
+		return this.on( type, fn );
19
+	};
20
+} );
21
+
22
+} );

+ 50 - 0
app/static/bower_components/jQuery/src/deprecated/event.js

@@ -0,0 +1,50 @@
1
+define( [
2
+	"../core",
3
+
4
+	"../event",
5
+	"../event/trigger"
6
+], function( jQuery ) {
7
+
8
+"use strict";
9
+
10
+jQuery.fn.extend( {
11
+
12
+	bind: function( types, data, fn ) {
13
+		return this.on( types, null, data, fn );
14
+	},
15
+	unbind: function( types, fn ) {
16
+		return this.off( types, null, fn );
17
+	},
18
+
19
+	delegate: function( selector, types, data, fn ) {
20
+		return this.on( types, selector, data, fn );
21
+	},
22
+	undelegate: function( selector, types, fn ) {
23
+
24
+		// ( namespace ) or ( selector, types [, fn] )
25
+		return arguments.length === 1 ?
26
+			this.off( selector, "**" ) :
27
+			this.off( types, selector || "**", fn );
28
+	},
29
+
30
+	hover: function( fnOver, fnOut ) {
31
+		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
32
+	}
33
+} );
34
+
35
+jQuery.each(
36
+	( "blur focus focusin focusout resize scroll click dblclick " +
37
+	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
38
+	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
39
+	function( _i, name ) {
40
+
41
+		// Handle event binding
42
+		jQuery.fn[ name ] = function( data, fn ) {
43
+			return arguments.length > 0 ?
44
+				this.on( name, null, data, fn ) :
45
+				this.trigger( name );
46
+		};
47
+	}
48
+);
49
+
50
+} );

+ 60 - 0
app/static/bower_components/jQuery/src/dimensions.js

@@ -0,0 +1,60 @@
1
+define( [
2
+	"./core",
3
+	"./core/access",
4
+	"./var/isWindow",
5
+	"./css"
6
+], function( jQuery, access, isWindow ) {
7
+
8
+"use strict";
9
+
10
+// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
11
+jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
12
+	jQuery.each( {
13
+		padding: "inner" + name,
14
+		content: type,
15
+		"": "outer" + name
16
+	}, function( defaultExtra, funcName ) {
17
+
18
+		// Margin is only for outerHeight, outerWidth
19
+		jQuery.fn[ funcName ] = function( margin, value ) {
20
+			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
21
+				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
22
+
23
+			return access( this, function( elem, type, value ) {
24
+				var doc;
25
+
26
+				if ( isWindow( elem ) ) {
27
+
28
+					// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
29
+					return funcName.indexOf( "outer" ) === 0 ?
30
+						elem[ "inner" + name ] :
31
+						elem.document.documentElement[ "client" + name ];
32
+				}
33
+
34
+				// Get document width or height
35
+				if ( elem.nodeType === 9 ) {
36
+					doc = elem.documentElement;
37
+
38
+					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
39
+					// whichever is greatest
40
+					return Math.max(
41
+						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
42
+						elem.body[ "offset" + name ], doc[ "offset" + name ],
43
+						doc[ "client" + name ]
44
+					);
45
+				}
46
+
47
+				return value === undefined ?
48
+
49
+					// Get width or height on the element, requesting but not forcing parseFloat
50
+					jQuery.css( elem, type, extra ) :
51
+
52
+					// Set width or height on the element
53
+					jQuery.style( elem, type, value, extra );
54
+			}, type, chainable ? margin : undefined, chainable );
55
+		};
56
+	} );
57
+} );
58
+
59
+return jQuery;
60
+} );

+ 702 - 0
app/static/bower_components/jQuery/src/effects.js

@@ -0,0 +1,702 @@
1
+define( [
2
+	"./core",
3
+	"./core/camelCase",
4
+	"./var/document",
5
+	"./var/isFunction",
6
+	"./var/rcssNum",
7
+	"./var/rnothtmlwhite",
8
+	"./css/var/cssExpand",
9
+	"./css/var/isHiddenWithinTree",
10
+	"./css/adjustCSS",
11
+	"./data/var/dataPriv",
12
+	"./css/showHide",
13
+
14
+	"./core/init",
15
+	"./queue",
16
+	"./deferred",
17
+	"./traversing",
18
+	"./manipulation",
19
+	"./css",
20
+	"./effects/Tween"
21
+], function( jQuery, camelCase, document, isFunction, rcssNum, rnothtmlwhite, cssExpand,
22
+	isHiddenWithinTree, adjustCSS, dataPriv, showHide ) {
23
+
24
+"use strict";
25
+
26
+var
27
+	fxNow, inProgress,
28
+	rfxtypes = /^(?:toggle|show|hide)$/,
29
+	rrun = /queueHooks$/;
30
+
31
+function schedule() {
32
+	if ( inProgress ) {
33
+		if ( document.hidden === false && window.requestAnimationFrame ) {
34
+			window.requestAnimationFrame( schedule );
35
+		} else {
36
+			window.setTimeout( schedule, jQuery.fx.interval );
37
+		}
38
+
39
+		jQuery.fx.tick();
40
+	}
41
+}
42
+
43
+// Animations created synchronously will run synchronously
44
+function createFxNow() {
45
+	window.setTimeout( function() {
46
+		fxNow = undefined;
47
+	} );
48
+	return ( fxNow = Date.now() );
49
+}
50
+
51
+// Generate parameters to create a standard animation
52
+function genFx( type, includeWidth ) {
53
+	var which,
54
+		i = 0,
55
+		attrs = { height: type };
56
+
57
+	// If we include width, step value is 1 to do all cssExpand values,
58
+	// otherwise step value is 2 to skip over Left and Right
59
+	includeWidth = includeWidth ? 1 : 0;
60
+	for ( ; i < 4; i += 2 - includeWidth ) {
61
+		which = cssExpand[ i ];
62
+		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
63
+	}
64
+
65
+	if ( includeWidth ) {
66
+		attrs.opacity = attrs.width = type;
67
+	}
68
+
69
+	return attrs;
70
+}
71
+
72
+function createTween( value, prop, animation ) {
73
+	var tween,
74
+		collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
75
+		index = 0,
76
+		length = collection.length;
77
+	for ( ; index < length; index++ ) {
78
+		if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
79
+
80
+			// We're done with this property
81
+			return tween;
82
+		}
83
+	}
84
+}
85
+
86
+function defaultPrefilter( elem, props, opts ) {
87
+	var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
88
+		isBox = "width" in props || "height" in props,
89
+		anim = this,
90
+		orig = {},
91
+		style = elem.style,
92
+		hidden = elem.nodeType && isHiddenWithinTree( elem ),
93
+		dataShow = dataPriv.get( elem, "fxshow" );
94
+
95
+	// Queue-skipping animations hijack the fx hooks
96
+	if ( !opts.queue ) {
97
+		hooks = jQuery._queueHooks( elem, "fx" );
98
+		if ( hooks.unqueued == null ) {
99
+			hooks.unqueued = 0;
100
+			oldfire = hooks.empty.fire;
101
+			hooks.empty.fire = function() {
102
+				if ( !hooks.unqueued ) {
103
+					oldfire();
104
+				}
105
+			};
106
+		}
107
+		hooks.unqueued++;
108
+
109
+		anim.always( function() {
110
+
111
+			// Ensure the complete handler is called before this completes
112
+			anim.always( function() {
113
+				hooks.unqueued--;
114
+				if ( !jQuery.queue( elem, "fx" ).length ) {
115
+					hooks.empty.fire();
116
+				}
117
+			} );
118
+		} );
119
+	}
120
+
121
+	// Detect show/hide animations
122
+	for ( prop in props ) {
123
+		value = props[ prop ];
124
+		if ( rfxtypes.test( value ) ) {
125
+			delete props[ prop ];
126
+			toggle = toggle || value === "toggle";
127
+			if ( value === ( hidden ? "hide" : "show" ) ) {
128
+
129
+				// Pretend to be hidden if this is a "show" and
130
+				// there is still data from a stopped show/hide
131
+				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
132
+					hidden = true;
133
+
134
+				// Ignore all other no-op show/hide data
135
+				} else {
136
+					continue;
137
+				}
138
+			}
139
+			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
140
+		}
141
+	}
142
+
143
+	// Bail out if this is a no-op like .hide().hide()
144
+	propTween = !jQuery.isEmptyObject( props );
145
+	if ( !propTween && jQuery.isEmptyObject( orig ) ) {
146
+		return;
147
+	}
148
+
149
+	// Restrict "overflow" and "display" styles during box animations
150
+	if ( isBox && elem.nodeType === 1 ) {
151
+
152
+		// Support: IE <=9 - 11, Edge 12 - 15
153
+		// Record all 3 overflow attributes because IE does not infer the shorthand
154
+		// from identically-valued overflowX and overflowY and Edge just mirrors
155
+		// the overflowX value there.
156
+		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
157
+
158
+		// Identify a display type, preferring old show/hide data over the CSS cascade
159
+		restoreDisplay = dataShow && dataShow.display;
160
+		if ( restoreDisplay == null ) {
161
+			restoreDisplay = dataPriv.get( elem, "display" );
162
+		}
163
+		display = jQuery.css( elem, "display" );
164
+		if ( display === "none" ) {
165
+			if ( restoreDisplay ) {
166
+				display = restoreDisplay;
167
+			} else {
168
+
169
+				// Get nonempty value(s) by temporarily forcing visibility
170
+				showHide( [ elem ], true );
171
+				restoreDisplay = elem.style.display || restoreDisplay;
172
+				display = jQuery.css( elem, "display" );
173
+				showHide( [ elem ] );
174
+			}
175
+		}
176
+
177
+		// Animate inline elements as inline-block
178
+		if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
179
+			if ( jQuery.css( elem, "float" ) === "none" ) {
180
+
181
+				// Restore the original display value at the end of pure show/hide animations
182
+				if ( !propTween ) {
183
+					anim.done( function() {
184
+						style.display = restoreDisplay;
185
+					} );
186
+					if ( restoreDisplay == null ) {
187
+						display = style.display;
188
+						restoreDisplay = display === "none" ? "" : display;
189
+					}
190
+				}
191
+				style.display = "inline-block";
192
+			}
193
+		}
194
+	}
195
+
196
+	if ( opts.overflow ) {
197
+		style.overflow = "hidden";
198
+		anim.always( function() {
199
+			style.overflow = opts.overflow[ 0 ];
200
+			style.overflowX = opts.overflow[ 1 ];
201
+			style.overflowY = opts.overflow[ 2 ];
202
+		} );
203
+	}
204
+
205
+	// Implement show/hide animations
206
+	propTween = false;
207
+	for ( prop in orig ) {
208
+
209
+		// General show/hide setup for this element animation
210
+		if ( !propTween ) {
211
+			if ( dataShow ) {
212
+				if ( "hidden" in dataShow ) {
213
+					hidden = dataShow.hidden;
214
+				}
215
+			} else {
216
+				dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
217
+			}
218
+
219
+			// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
220
+			if ( toggle ) {
221
+				dataShow.hidden = !hidden;
222
+			}
223
+
224
+			// Show elements before animating them
225
+			if ( hidden ) {
226
+				showHide( [ elem ], true );
227
+			}
228
+
229
+			/* eslint-disable no-loop-func */
230
+
231
+			anim.done( function() {
232
+
233
+				/* eslint-enable no-loop-func */
234
+
235
+				// The final step of a "hide" animation is actually hiding the element
236
+				if ( !hidden ) {
237
+					showHide( [ elem ] );
238
+				}
239
+				dataPriv.remove( elem, "fxshow" );
240
+				for ( prop in orig ) {
241
+					jQuery.style( elem, prop, orig[ prop ] );
242
+				}
243
+			} );
244
+		}
245
+
246
+		// Per-property setup
247
+		propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
248
+		if ( !( prop in dataShow ) ) {
249
+			dataShow[ prop ] = propTween.start;
250
+			if ( hidden ) {
251
+				propTween.end = propTween.start;
252
+				propTween.start = 0;
253
+			}
254
+		}
255
+	}
256
+}
257
+
258
+function propFilter( props, specialEasing ) {
259
+	var index, name, easing, value, hooks;
260
+
261
+	// camelCase, specialEasing and expand cssHook pass
262
+	for ( index in props ) {
263
+		name = camelCase( index );
264
+		easing = specialEasing[ name ];
265
+		value = props[ index ];
266
+		if ( Array.isArray( value ) ) {
267
+			easing = value[ 1 ];
268
+			value = props[ index ] = value[ 0 ];
269
+		}
270
+
271
+		if ( index !== name ) {
272
+			props[ name ] = value;
273
+			delete props[ index ];
274
+		}
275
+
276
+		hooks = jQuery.cssHooks[ name ];
277
+		if ( hooks && "expand" in hooks ) {
278
+			value = hooks.expand( value );
279
+			delete props[ name ];
280
+
281
+			// Not quite $.extend, this won't overwrite existing keys.
282
+			// Reusing 'index' because we have the correct "name"
283
+			for ( index in value ) {
284
+				if ( !( index in props ) ) {
285
+					props[ index ] = value[ index ];
286
+					specialEasing[ index ] = easing;
287
+				}
288
+			}
289
+		} else {
290
+			specialEasing[ name ] = easing;
291
+		}
292
+	}
293
+}
294
+
295
+function Animation( elem, properties, options ) {
296
+	var result,
297
+		stopped,
298
+		index = 0,
299
+		length = Animation.prefilters.length,
300
+		deferred = jQuery.Deferred().always( function() {
301
+
302
+			// Don't match elem in the :animated selector
303
+			delete tick.elem;
304
+		} ),
305
+		tick = function() {
306
+			if ( stopped ) {
307
+				return false;
308
+			}
309
+			var currentTime = fxNow || createFxNow(),
310
+				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
311
+
312
+				// Support: Android 2.3 only
313
+				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
314
+				temp = remaining / animation.duration || 0,
315
+				percent = 1 - temp,
316
+				index = 0,
317
+				length = animation.tweens.length;
318
+
319
+			for ( ; index < length; index++ ) {
320
+				animation.tweens[ index ].run( percent );
321
+			}
322
+
323
+			deferred.notifyWith( elem, [ animation, percent, remaining ] );
324
+
325
+			// If there's more to do, yield
326
+			if ( percent < 1 && length ) {
327
+				return remaining;
328
+			}
329
+
330
+			// If this was an empty animation, synthesize a final progress notification
331
+			if ( !length ) {
332
+				deferred.notifyWith( elem, [ animation, 1, 0 ] );
333
+			}
334
+
335
+			// Resolve the animation and report its conclusion
336
+			deferred.resolveWith( elem, [ animation ] );
337
+			return false;
338
+		},
339
+		animation = deferred.promise( {
340
+			elem: elem,
341
+			props: jQuery.extend( {}, properties ),
342
+			opts: jQuery.extend( true, {
343
+				specialEasing: {},
344
+				easing: jQuery.easing._default
345
+			}, options ),
346
+			originalProperties: properties,
347
+			originalOptions: options,
348
+			startTime: fxNow || createFxNow(),
349
+			duration: options.duration,
350
+			tweens: [],
351
+			createTween: function( prop, end ) {
352
+				var tween = jQuery.Tween( elem, animation.opts, prop, end,
353
+					animation.opts.specialEasing[ prop ] || animation.opts.easing );
354
+				animation.tweens.push( tween );
355
+				return tween;
356
+			},
357
+			stop: function( gotoEnd ) {
358
+				var index = 0,
359
+
360
+					// If we are going to the end, we want to run all the tweens
361
+					// otherwise we skip this part
362
+					length = gotoEnd ? animation.tweens.length : 0;
363
+				if ( stopped ) {
364
+					return this;
365
+				}
366
+				stopped = true;
367
+				for ( ; index < length; index++ ) {
368
+					animation.tweens[ index ].run( 1 );
369
+				}
370
+
371
+				// Resolve when we played the last frame; otherwise, reject
372
+				if ( gotoEnd ) {
373
+					deferred.notifyWith( elem, [ animation, 1, 0 ] );
374
+					deferred.resolveWith( elem, [ animation, gotoEnd ] );
375
+				} else {
376
+					deferred.rejectWith( elem, [ animation, gotoEnd ] );
377
+				}
378
+				return this;
379
+			}
380
+		} ),
381
+		props = animation.props;
382
+
383
+	propFilter( props, animation.opts.specialEasing );
384
+
385
+	for ( ; index < length; index++ ) {
386
+		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
387
+		if ( result ) {
388
+			if ( isFunction( result.stop ) ) {
389
+				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
390
+					result.stop.bind( result );
391
+			}
392
+			return result;
393
+		}
394
+	}
395
+
396
+	jQuery.map( props, createTween, animation );
397
+
398
+	if ( isFunction( animation.opts.start ) ) {
399
+		animation.opts.start.call( elem, animation );
400
+	}
401
+
402
+	// Attach callbacks from options
403
+	animation
404
+		.progress( animation.opts.progress )
405
+		.done( animation.opts.done, animation.opts.complete )
406
+		.fail( animation.opts.fail )
407
+		.always( animation.opts.always );
408
+
409
+	jQuery.fx.timer(
410
+		jQuery.extend( tick, {
411
+			elem: elem,
412
+			anim: animation,
413
+			queue: animation.opts.queue
414
+		} )
415
+	);
416
+
417
+	return animation;
418
+}
419
+
420
+jQuery.Animation = jQuery.extend( Animation, {
421
+
422
+	tweeners: {
423
+		"*": [ function( prop, value ) {
424
+			var tween = this.createTween( prop, value );
425
+			adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
426
+			return tween;
427
+		} ]
428
+	},
429
+
430
+	tweener: function( props, callback ) {
431
+		if ( isFunction( props ) ) {
432
+			callback = props;
433
+			props = [ "*" ];
434
+		} else {
435
+			props = props.match( rnothtmlwhite );
436
+		}
437
+
438
+		var prop,
439
+			index = 0,
440
+			length = props.length;
441
+
442
+		for ( ; index < length; index++ ) {
443
+			prop = props[ index ];
444
+			Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
445
+			Animation.tweeners[ prop ].unshift( callback );
446
+		}
447
+	},
448
+
449
+	prefilters: [ defaultPrefilter ],
450
+
451
+	prefilter: function( callback, prepend ) {
452
+		if ( prepend ) {
453
+			Animation.prefilters.unshift( callback );
454
+		} else {
455
+			Animation.prefilters.push( callback );
456
+		}
457
+	}
458
+} );
459
+
460
+jQuery.speed = function( speed, easing, fn ) {
461
+	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
462
+		complete: fn || !fn && easing ||
463
+			isFunction( speed ) && speed,
464
+		duration: speed,
465
+		easing: fn && easing || easing && !isFunction( easing ) && easing
466
+	};
467
+
468
+	// Go to the end state if fx are off
469
+	if ( jQuery.fx.off ) {
470
+		opt.duration = 0;
471
+
472
+	} else {
473
+		if ( typeof opt.duration !== "number" ) {
474
+			if ( opt.duration in jQuery.fx.speeds ) {
475
+				opt.duration = jQuery.fx.speeds[ opt.duration ];
476
+
477
+			} else {
478
+				opt.duration = jQuery.fx.speeds._default;
479
+			}
480
+		}
481
+	}
482
+
483
+	// Normalize opt.queue - true/undefined/null -> "fx"
484
+	if ( opt.queue == null || opt.queue === true ) {
485
+		opt.queue = "fx";
486
+	}
487
+
488
+	// Queueing
489
+	opt.old = opt.complete;
490
+
491
+	opt.complete = function() {
492
+		if ( isFunction( opt.old ) ) {
493
+			opt.old.call( this );
494
+		}
495
+
496
+		if ( opt.queue ) {
497
+			jQuery.dequeue( this, opt.queue );
498
+		}
499
+	};
500
+
501
+	return opt;
502
+};
503
+
504
+jQuery.fn.extend( {
505
+	fadeTo: function( speed, to, easing, callback ) {
506
+
507
+		// Show any hidden elements after setting opacity to 0
508
+		return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
509
+
510
+			// Animate to the value specified
511
+			.end().animate( { opacity: to }, speed, easing, callback );
512
+	},
513
+	animate: function( prop, speed, easing, callback ) {
514
+		var empty = jQuery.isEmptyObject( prop ),
515
+			optall = jQuery.speed( speed, easing, callback ),
516
+			doAnimation = function() {
517
+
518
+				// Operate on a copy of prop so per-property easing won't be lost
519
+				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
520
+
521
+				// Empty animations, or finishing resolves immediately
522
+				if ( empty || dataPriv.get( this, "finish" ) ) {
523
+					anim.stop( true );
524
+				}
525
+			};
526
+
527
+		doAnimation.finish = doAnimation;
528
+
529
+		return empty || optall.queue === false ?
530
+			this.each( doAnimation ) :
531
+			this.queue( optall.queue, doAnimation );
532
+	},
533
+	stop: function( type, clearQueue, gotoEnd ) {
534
+		var stopQueue = function( hooks ) {
535
+			var stop = hooks.stop;
536
+			delete hooks.stop;
537
+			stop( gotoEnd );
538
+		};
539
+
540
+		if ( typeof type !== "string" ) {
541
+			gotoEnd = clearQueue;
542
+			clearQueue = type;
543
+			type = undefined;
544
+		}
545
+		if ( clearQueue ) {
546
+			this.queue( type || "fx", [] );
547
+		}
548
+
549
+		return this.each( function() {
550
+			var dequeue = true,
551
+				index = type != null && type + "queueHooks",
552
+				timers = jQuery.timers,
553
+				data = dataPriv.get( this );
554
+
555
+			if ( index ) {
556
+				if ( data[ index ] && data[ index ].stop ) {
557
+					stopQueue( data[ index ] );
558
+				}
559
+			} else {
560
+				for ( index in data ) {
561
+					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
562
+						stopQueue( data[ index ] );
563
+					}
564
+				}
565
+			}
566
+
567
+			for ( index = timers.length; index--; ) {
568
+				if ( timers[ index ].elem === this &&
569
+					( type == null || timers[ index ].queue === type ) ) {
570
+
571
+					timers[ index ].anim.stop( gotoEnd );
572
+					dequeue = false;
573
+					timers.splice( index, 1 );
574
+				}
575
+			}
576
+
577
+			// Start the next in the queue if the last step wasn't forced.
578
+			// Timers currently will call their complete callbacks, which
579
+			// will dequeue but only if they were gotoEnd.
580
+			if ( dequeue || !gotoEnd ) {
581
+				jQuery.dequeue( this, type );
582
+			}
583
+		} );
584
+	},
585
+	finish: function( type ) {
586
+		if ( type !== false ) {
587
+			type = type || "fx";
588
+		}
589
+		return this.each( function() {
590
+			var index,
591
+				data = dataPriv.get( this ),
592
+				queue = data[ type + "queue" ],
593
+				hooks = data[ type + "queueHooks" ],
594
+				timers = jQuery.timers,
595
+				length = queue ? queue.length : 0;
596
+
597
+			// Enable finishing flag on private data
598
+			data.finish = true;
599
+
600
+			// Empty the queue first
601
+			jQuery.queue( this, type, [] );
602
+
603
+			if ( hooks && hooks.stop ) {
604
+				hooks.stop.call( this, true );
605
+			}
606
+
607
+			// Look for any active animations, and finish them
608
+			for ( index = timers.length; index--; ) {
609
+				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
610
+					timers[ index ].anim.stop( true );
611
+					timers.splice( index, 1 );
612
+				}
613
+			}
614
+
615
+			// Look for any animations in the old queue and finish them
616
+			for ( index = 0; index < length; index++ ) {
617
+				if ( queue[ index ] && queue[ index ].finish ) {
618
+					queue[ index ].finish.call( this );
619
+				}
620
+			}
621
+
622
+			// Turn off finishing flag
623
+			delete data.finish;
624
+		} );
625
+	}
626
+} );
627
+
628
+jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) {
629
+	var cssFn = jQuery.fn[ name ];
630
+	jQuery.fn[ name ] = function( speed, easing, callback ) {
631
+		return speed == null || typeof speed === "boolean" ?
632
+			cssFn.apply( this, arguments ) :
633
+			this.animate( genFx( name, true ), speed, easing, callback );
634
+	};
635
+} );
636
+
637
+// Generate shortcuts for custom animations
638
+jQuery.each( {
639
+	slideDown: genFx( "show" ),
640
+	slideUp: genFx( "hide" ),
641
+	slideToggle: genFx( "toggle" ),
642
+	fadeIn: { opacity: "show" },
643
+	fadeOut: { opacity: "hide" },
644
+	fadeToggle: { opacity: "toggle" }
645
+}, function( name, props ) {
646
+	jQuery.fn[ name ] = function( speed, easing, callback ) {
647
+		return this.animate( props, speed, easing, callback );
648
+	};
649
+} );
650
+
651
+jQuery.timers = [];
652
+jQuery.fx.tick = function() {
653
+	var timer,
654
+		i = 0,
655
+		timers = jQuery.timers;
656
+
657
+	fxNow = Date.now();
658
+
659
+	for ( ; i < timers.length; i++ ) {
660
+		timer = timers[ i ];
661
+
662
+		// Run the timer and safely remove it when done (allowing for external removal)
663
+		if ( !timer() && timers[ i ] === timer ) {
664
+			timers.splice( i--, 1 );
665
+		}
666
+	}
667
+
668
+	if ( !timers.length ) {
669
+		jQuery.fx.stop();
670
+	}
671
+	fxNow = undefined;
672
+};
673
+
674
+jQuery.fx.timer = function( timer ) {
675
+	jQuery.timers.push( timer );
676
+	jQuery.fx.start();
677
+};
678
+
679
+jQuery.fx.interval = 13;
680
+jQuery.fx.start = function() {
681
+	if ( inProgress ) {
682
+		return;
683
+	}
684
+
685
+	inProgress = true;
686
+	schedule();
687
+};
688
+
689
+jQuery.fx.stop = function() {
690
+	inProgress = null;
691
+};
692
+
693
+jQuery.fx.speeds = {
694
+	slow: 600,
695
+	fast: 200,
696
+
697
+	// Default speed
698
+	_default: 400
699
+};
700
+
701
+return jQuery;
702
+} );

+ 125 - 0
app/static/bower_components/jQuery/src/effects/Tween.js

@@ -0,0 +1,125 @@
1
+define( [
2
+	"../core",
3
+	"../css/finalPropName",
4
+
5
+	"../css"
6
+], function( jQuery, finalPropName ) {
7
+
8
+"use strict";
9
+
10
+function Tween( elem, options, prop, end, easing ) {
11
+	return new Tween.prototype.init( elem, options, prop, end, easing );
12
+}
13
+jQuery.Tween = Tween;
14
+
15
+Tween.prototype = {
16
+	constructor: Tween,
17
+	init: function( elem, options, prop, end, easing, unit ) {
18
+		this.elem = elem;
19
+		this.prop = prop;
20
+		this.easing = easing || jQuery.easing._default;
21
+		this.options = options;
22
+		this.start = this.now = this.cur();
23
+		this.end = end;
24
+		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
25
+	},
26
+	cur: function() {
27
+		var hooks = Tween.propHooks[ this.prop ];
28
+
29
+		return hooks && hooks.get ?
30
+			hooks.get( this ) :
31
+			Tween.propHooks._default.get( this );
32
+	},
33
+	run: function( percent ) {
34
+		var eased,
35
+			hooks = Tween.propHooks[ this.prop ];
36
+
37
+		if ( this.options.duration ) {
38
+			this.pos = eased = jQuery.easing[ this.easing ](
39
+				percent, this.options.duration * percent, 0, 1, this.options.duration
40
+			);
41
+		} else {
42
+			this.pos = eased = percent;
43
+		}
44
+		this.now = ( this.end - this.start ) * eased + this.start;
45
+
46
+		if ( this.options.step ) {
47
+			this.options.step.call( this.elem, this.now, this );
48
+		}
49
+
50
+		if ( hooks && hooks.set ) {
51
+			hooks.set( this );
52
+		} else {
53
+			Tween.propHooks._default.set( this );
54
+		}
55
+		return this;
56
+	}
57
+};
58
+
59
+Tween.prototype.init.prototype = Tween.prototype;
60
+
61
+Tween.propHooks = {
62
+	_default: {
63
+		get: function( tween ) {
64
+			var result;
65
+
66
+			// Use a property on the element directly when it is not a DOM element,
67
+			// or when there is no matching style property that exists.
68
+			if ( tween.elem.nodeType !== 1 ||
69
+				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
70
+				return tween.elem[ tween.prop ];
71
+			}
72
+
73
+			// Passing an empty string as a 3rd parameter to .css will automatically
74
+			// attempt a parseFloat and fallback to a string if the parse fails.
75
+			// Simple values such as "10px" are parsed to Float;
76
+			// complex values such as "rotate(1rad)" are returned as-is.
77
+			result = jQuery.css( tween.elem, tween.prop, "" );
78
+
79
+			// Empty strings, null, undefined and "auto" are converted to 0.
80
+			return !result || result === "auto" ? 0 : result;
81
+		},
82
+		set: function( tween ) {
83
+
84
+			// Use step hook for back compat.
85
+			// Use cssHook if its there.
86
+			// Use .style if available and use plain properties where available.
87
+			if ( jQuery.fx.step[ tween.prop ] ) {
88
+				jQuery.fx.step[ tween.prop ]( tween );
89
+			} else if ( tween.elem.nodeType === 1 && (
90
+				jQuery.cssHooks[ tween.prop ] ||
91
+					tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {
92
+				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
93
+			} else {
94
+				tween.elem[ tween.prop ] = tween.now;
95
+			}
96
+		}
97
+	}
98
+};
99
+
100
+// Support: IE <=9 only
101
+// Panic based approach to setting things on disconnected nodes
102
+Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
103
+	set: function( tween ) {
104
+		if ( tween.elem.nodeType && tween.elem.parentNode ) {
105
+			tween.elem[ tween.prop ] = tween.now;
106
+		}
107
+	}
108
+};
109
+
110
+jQuery.easing = {
111
+	linear: function( p ) {
112
+		return p;
113
+	},
114
+	swing: function( p ) {
115
+		return 0.5 - Math.cos( p * Math.PI ) / 2;
116
+	},
117
+	_default: "swing"
118
+};
119
+
120
+jQuery.fx = Tween.prototype.init;
121
+
122
+// Back compat <1.8 extension point
123
+jQuery.fx.step = {};
124
+
125
+} );

+ 0 - 0
app/static/bower_components/jQuery/src/effects/animatedSelector.js


Some files were not shown because too many files changed in this diff

tum/ecoloop - Gogs: Simplico Git Service

Няма описание

Dockerfile 591B

1234567891011121314151617181920212223242526
  1. # Pull base image
  2. FROM python:3.11-slim
  3. # Set environment variables
  4. ENV PYTHONDONTWRITEBYTECODE 1
  5. ENV PYTHONUNBUFFERED 1
  6. # Set work directory
  7. WORKDIR /app
  8. # Install system dependencies: Node.js/npm and Graphviz toolchain for ER diagrams
  9. RUN apt-get update \
  10. && apt-get install -y --no-install-recommends \
  11. nodejs npm \
  12. graphviz libgraphviz-dev \
  13. build-essential pkg-config \
  14. gettext \
  15. && rm -rf /var/lib/apt/lists/*
  16. # Install dependencies
  17. COPY requirements.txt /app/
  18. RUN pip install --no-cache-dir -r requirements.txt
  19. # Copy project
  20. COPY . /app/