span> 362 
+			if (typeof resolve != "function" || typeof reject != "function") {
363 
+				throw TypeError("Not a function");
364 
+			}
365 
+
366 
+			iteratePromises(Constructor,arr,function resolver(idx,msg){
367 
+				resolve(msg);
368 
+			},reject);
369 
+		});
370 
+	});
371 
+
372 
+	return Promise;
373 
+});

+ 35 - 0
app/static/bower_components/jQuery/external/qunit/LICENSE.txt
Zobrazit soubor 

@@ -0,0 +1,35 @@
1 
+Copyright JS Foundation and other contributors, https://js.foundation
2 
+
3 
+This software consists of voluntary contributions made by many
4 
+individuals. For exact contribution history, see the revision history
5 
+available at https://github.com/qunitjs/qunit
6 
+
7 
+The following license applies to all parts of this software except as
8 
+documented below:
9 
+
10 
+====
11 
+
12 
+Permission is hereby granted, free of charge, to any person obtaining
13 
+a copy of this software and associated documentation files (the
14 
+"Software"), to deal in the Software without restriction, including
15 
+without limitation the rights to use, copy, modify, merge, publish,
16 
+distribute, sublicense, and/or sell copies of the Software, and to
17 
+permit persons to whom the Software is furnished to do so, subject to
18 
+the following conditions:
19 
+
20 
+The above copyright notice and this permission notice shall be
21 
+included in all copies or substantial portions of the Software.
22 
+
23 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
27 
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
28 
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
29 
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 
+
31 
+====
32 
+
33 
+All files located in the node_modules directory are externally maintained
34 
+libraries used by this software which have their own licenses; we
35 
+recommend you read them, as their terms may differ from the terms above.

+ 436 - 0
app/static/bower_components/jQuery/external/qunit/qunit.css
Zobrazit soubor 

@@ -0,0 +1,436 @@
1 
+/*!
2 
+ * QUnit 2.9.2
3 
+ * https://qunitjs.com/
4 
+ *
5 
+ * Copyright jQuery Foundation and other contributors
6 
+ * Released under the MIT license
7 
+ * https://jquery.org/license
8 
+ *
9 
+ * Date: 2019-02-21T22:49Z
10 
+ */
11 
+
12 
+/** Font Family and Sizes */
13 
+
14 
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-filteredTest, #qunit-userAgent, #qunit-testresult {
15 
+	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
16 
+}
17 
+
18 
+#qunit-testrunner-toolbar, #qunit-filteredTest, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
19 
+#qunit-tests { font-size: smaller; }
20 
+
21 
+
22 
+/** Resets */
23 
+
24 
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-filteredTest, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
25 
+	margin: 0;
26 
+	padding: 0;
27 
+}
28 
+
29 
+
30 
+/** Header (excluding toolbar) */
31 
+
32 
+#qunit-header {
33 
+	padding: 0.5em 0 0.5em 1em;
34 
+
35 
+	color: #8699A4;
36 
+	background-color: #0D3349;
37 
+
38 
+	font-size: 1.5em;
39 
+	line-height: 1em;
40 
+	font-weight: 400;
41 
+
42 
+	border-radius: 5px 5px 0 0;
43 
+}
44 
+
45 
+#qunit-header a {
46 
+	text-decoration: none;
47 
+	color: #C2CCD1;
48 
+}
49 
+
50 
+#qunit-header a:hover,
51 
+#qunit-header a:focus {
52 
+	color: #FFF;
53 
+}
54 
+
55 
+#qunit-banner {
56 
+	height: 5px;
57 
+}
58 
+
59 
+#qunit-filteredTest {
60 
+	padding: 0.5em 1em 0.5em 1em;
61 
+	color: #366097;
62 
+	background-color: #F4FF77;
63 
+}
64 
+
65 
+#qunit-userAgent {
66 
+	padding: 0.5em 1em 0.5em 1em;
67 
+	color: #FFF;
68 
+	background-color: #2B81AF;
69 
+	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
70 
+}
71 
+
72 
+
73 
+/** Toolbar */
74 
+
75 
+#qunit-testrunner-toolbar {
76 
+	padding: 0.5em 1em 0.5em 1em;
77 
+	color: #5E740B;
78 
+	background-color: #EEE;
79 
+}
80 
+
81 
+#qunit-testrunner-toolbar .clearfix {
82 
+	height: 0;
83 
+	clear: both;
84 
+}
85 
+
86 
+#qunit-testrunner-toolbar label {
87 
+	display: inline-block;
88 
+}
89 
+
90 
+#qunit-testrunner-toolbar input[type=checkbox],
91 
+#qunit-testrunner-toolbar input[type=radio] {
92 
+	margin: 3px;
93 
+	vertical-align: -2px;
94 
+}
95 
+
96 
+#qunit-testrunner-toolbar input[type=text] {
97 
+	box-sizing: border-box;
98 
+	height: 1.6em;
99 
+}
100 
+
101 
+.qunit-url-config,
102 
+.qunit-filter,
103 
+#qunit-modulefilter {
104 
+	display: inline-block;
105 
+	line-height: 2.1em;
106 
+}
107 
+
108 
+.qunit-filter,
109 
+#qunit-modulefilter {
110 
+	float: right;
111 
+	position: relative;
112 
+	margin-left: 1em;
113 
+}
114 
+
115 
+.qunit-url-config label {
116 
+	margin-right: 0.5em;
117 
+}
118 
+
119 
+#qunit-modulefilter-search {
120 
+	box-sizing: border-box;
121 
+	width: 400px;
122 
+}
123 
+
124 
+#qunit-modulefilter-search-container:after {
125 
+	position: absolute;
126 
+	right: 0.3em;
127 
+	content: "\25bc";
128 
+	color: black;
129 
+}
130 
+
131 
+#qunit-modulefilter-dropdown {
132 
+	/* align with #qunit-modulefilter-search */
133 
+	box-sizing: border-box;
134 
+	width: 400px;
135 
+	position: absolute;
136 
+	right: 0;
137 
+	top: 50%;
138 
+	margin-top: 0.8em;
139 
+
140 
+	border: 1px solid #D3D3D3;
141 
+	border-top: none;
142 
+	border-radius: 0 0 .25em .25em;
143 
+	color: #000;
144 
+	background-color: #F5F5F5;
145 
+	z-index: 99;
146 
+}
147 
+
148 
+#qunit-modulefilter-dropdown a {
149 
+	color: inherit;
150 
+	text-decoration: none;
151 
+}
152 
+
153 
+#qunit-modulefilter-dropdown .clickable.checked {
154 
+	font-weight: bold;
155 
+	color: #000;
156 
+	background-color: #D2E0E6;
157 
+}
158 
+
159 
+#qunit-modulefilter-dropdown .clickable:hover {
160 
+	color: #FFF;
161 
+	background-color: #0D3349;
162 
+}
163 
+
164 
+#qunit-modulefilter-actions {
165 
+	display: block;
166 
+	overflow: auto;
167 
+
168 
+	/* align with #qunit-modulefilter-dropdown-list */
169 
+	font: smaller/1.5em sans-serif;
170 
+}
171 
+
172 
+#qunit-modulefilter-dropdown #qunit-modulefilter-actions > * {
173 
+	box-sizing: border-box;
174 
+	max-height: 2.8em;
175 
+	display: block;
176 
+	padding: 0.4em;
177 
+}
178 
+
179 
+#qunit-modulefilter-dropdown #qunit-modulefilter-actions > button {
180 
+	float: right;
181 
+	font: inherit;
182 
+}
183 
+
184 
+#qunit-modulefilter-dropdown #qunit-modulefilter-actions > :last-child {
185 
+	/* insert padding to align with checkbox margins */
186 
+	padding-left: 3px;
187 
+}
188 
+
189 
+#qunit-modulefilter-dropdown-list {
190 
+	max-height: 200px;
191 
+	overflow-y: auto;
192 
+	margin: 0;
193 
+	border-top: 2px groove threedhighlight;
194 
+	padding: 0.4em 0 0;
195 
+	font: smaller/1.5em sans-serif;
196 
+}
197 
+
198 
+#qunit-modulefilter-dropdown-list li {
199 
+	white-space: nowrap;
200 
+	overflow: hidden;
201 
+	text-overflow: ellipsis;
202 
+}
203 
+
204 
+#qunit-modulefilter-dropdown-list .clickable {
205 
+	display: block;
206 
+	padding-left: 0.15em;
207 
+}
208 
+
209 
+
210 
+/** Tests: Pass/Fail */
211 
+
212 
+#qunit-tests {
213 
+	list-style-position: inside;
214 
+}
215 
+
216 
+#qunit-tests li {
217 
+	padding: 0.4em 1em 0.4em 1em;
218 
+	border-bottom: 1px solid #FFF;
219 
+	list-style-position: inside;
220 
+}
221 
+
222 
+#qunit-tests > li {
223 
+	display: none;
224 
+}
225 
+
226 
+#qunit-tests li.running,
227 
+#qunit-tests li.pass,
228 
+#qunit-tests li.fail,
229 
+#qunit-tests li.skipped,
230 
+#qunit-tests li.aborted {
231 
+	display: list-item;
232 
+}
233 
+
234 
+#qunit-tests.hidepass {
235 
+	position: relative;
236 
+}
237 
+
238 
+#qunit-tests.hidepass li.running,
239 
+#qunit-tests.hidepass li.pass:not(.todo) {
240 
+	visibility: hidden;
241 
+	position: absolute;
242 
+	width:   0;
243 
+	height:  0;
244 
+	padding: 0;
245 
+	border:  0;
246 
+	margin:  0;
247 
+}
248 
+
249 
+#qunit-tests li strong {
250 
+	cursor: pointer;
251 
+}
252 
+
253 
+#qunit-tests li.skipped strong {
254 
+	cursor: default;
255 
+}
256 
+
257 
+#qunit-tests li a {
258 
+	padding: 0.5em;
259 
+	color: #C2CCD1;
260 
+	text-decoration: none;
261 
+}
262 
+
263 
+#qunit-tests li p a {
264 
+	padding: 0.25em;
265 
+	color: #6B6464;
266 
+}
267 
+#qunit-tests li a:hover,
268 
+#qunit-tests li a:focus {
269 
+	color: #000;
270 
+}
271 
+
272 
+#qunit-tests li .runtime {
273 
+	float: right;
274 
+	font-size: smaller;
275 
+}
276 
+
277 
+.qunit-assert-list {
278 
+	margin-top: 0.5em;
279 
+	padding: 0.5em;
280 
+
281 
+	background-color: #FFF;
282 
+
283 
+	border-radius: 5px;
284 
+}
285 
+
286 
+.qunit-source {
287 
+	margin: 0.6em 0 0.3em;
288 
+}
289 
+
290 
+.qunit-collapsed {
291 
+	display: none;
292 
+}
293 
+
294 
+#qunit-tests table {
295 
+	border-collapse: collapse;
296 
+	margin-top: 0.2em;
297 
+}
298 
+
299 
+#qunit-tests th {
300 
+	text-align: right;
301 
+	vertical-align: top;
302 
+	padding: 0 0.5em 0 0;
303 
+}
304 
+
305 
+#qunit-tests td {
306 
+	vertical-align: top;
307 
+}
308 
+
309 
+#qunit-tests pre {
310 
+	margin: 0;
311 
+	white-space: pre-wrap;
312 
+	word-wrap: break-word;
313 
+}
314 
+
315 
+#qunit-tests del {
316 
+	color: #374E0C;
317 
+	background-color: #E0F2BE;
318 
+	text-decoration: none;
319 
+}
320 
+
321 
+#qunit-tests ins {
322 
+	color: #500;
323 
+	background-color: #FFCACA;
324 
+	text-decoration: none;
325 
+}
326 
+
327 
+/*** Test Counts */
328 
+
329 
+#qunit-tests b.counts                       { color: #000; }
330 
+#qunit-tests b.passed                       { color: #5E740B; }
331 
+#qunit-tests b.failed                       { color: #710909; }
332 
+
333 
+#qunit-tests li li {
334 
+	padding: 5px;
335 
+	background-color: #FFF;
336 
+	border-bottom: none;
337 
+	list-style-position: inside;
338 
+}
339 
+
340 
+/*** Passing Styles */
341 
+
342 
+#qunit-tests li li.pass {
343 
+	color: #3C510C;
344 
+	background-color: #FFF;
345 
+	border-left: 10px solid #C6E746;
346 
+}
347 
+
348 
+#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
349 
+#qunit-tests .pass .test-name               { color: #366097; }
350 
+
351 
+#qunit-tests .pass .test-actual,
352 
+#qunit-tests .pass .test-expected           { color: #999; }
353 
+
354 
+#qunit-banner.qunit-pass                    { background-color: #C6E746; }
355 
+
356 
+/*** Failing Styles */
357 
+
358 
+#qunit-tests li li.fail {
359 
+	color: #710909;
360 
+	background-color: #FFF;
361 
+	border-left: 10px solid #EE5757;
362 
+	white-space: pre;
363 
+}
364 
+
365 
+#qunit-tests > li:last-child {
366 
+	border-radius: 0 0 5px 5px;
367 
+}
368 
+
369 
+#qunit-tests .fail                          { color: #000; background-color: #EE5757; }
370 
+#qunit-tests .fail .test-name,
371 
+#qunit-tests .fail .module-name             { color: #000; }
372 
+
373 
+#qunit-tests .fail .test-actual             { color: #EE5757; }
374 
+#qunit-tests .fail .test-expected           { color: #008000; }
375 
+
376 
+#qunit-banner.qunit-fail                    { background-color: #EE5757; }
377 
+
378 
+
379 
+/*** Aborted tests */
380 
+#qunit-tests .aborted { color: #000; background-color: orange; }
381 
+/*** Skipped tests */
382 
+
383 
+#qunit-tests .skipped {
384 
+	background-color: #EBECE9;
385 
+}
386 
+
387 
+#qunit-tests .qunit-todo-label,
388 
+#qunit-tests .qunit-skipped-label {
389 
+	background-color: #F4FF77;
390 
+	display: inline-block;
391 
+	font-style: normal;
392 
+	color: #366097;
393 
+	line-height: 1.8em;
394 
+	padding: 0 0.5em;
395 
+	margin: -0.4em 0.4em -0.4em 0;
396 
+}
397 
+
398 
+#qunit-tests .qunit-todo-label {
399 
+	background-color: #EEE;
400 
+}
401 
+
402 
+/** Result */
403 
+
404 
+#qunit-testresult {
405 
+	color: #2B81AF;
406 
+	background-color: #D2E0E6;
407 
+
408 
+	border-bottom: 1px solid #FFF;
409 
+}
410 
+#qunit-testresult .clearfix {
411 
+	height: 0;
412 
+	clear: both;
413 
+}
414 
+#qunit-testresult .module-name {
415 
+	font-weight: 700;
416 
+}
417 
+#qunit-testresult-display {
418 
+	padding: 0.5em 1em 0.5em 1em;
419 
+	width: 85%;
420 
+	float:left;
421 
+}
422 
+#qunit-testresult-controls {
423 
+	padding: 0.5em 1em 0.5em 1em;
424 
+  width: 10%;
425 
+	float:left;
426 
+}
427 
+
428 
+/** Fixture */
429 
+
430 
+#qunit-fixture {
431 
+	position: absolute;
432 
+	top: -10000px;
433 
+	left: -10000px;
434 
+	width: 1000px;
435 
+	height: 1000px;
436 
+}

File diff suppressed because it is too large
+ 6604 - 0
app/static/bower_components/jQuery/external/qunit/qunit.js


File diff suppressed because it is too large
+ 2145 - 0
app/static/bower_components/jQuery/external/requirejs/require.js


+ 27 - 0
app/static/bower_components/jQuery/external/sinon/LICENSE.txt
Zobrazit soubor 

@@ -0,0 +1,27 @@
1 
+(The BSD License)
2 
+
3 
+Copyright (c) 2010-2017, Christian Johansen, christian@cjohansen.no
4 
+All rights reserved.
5 
+
6 
+Redistribution and use in source and binary forms, with or without modification,
7 
+are permitted provided that the following conditions are met:
8 
+
9 
+    * Redistributions of source code must retain the above copyright notice,
10 
+      this list of conditions and the following disclaimer.
11 
+    * Redistributions in binary form must reproduce the above copyright notice,
12 
+      this list of conditions and the following disclaimer in the documentation
13 
+      and/or other materials provided with the distribution.
14 
+    * Neither the name of Christian Johansen nor the names of his contributors
15 
+      may be used to endorse or promote products derived from this software
16 
+      without specific prior written permission.
17 
+
18 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
19 
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
22 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26 
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

File diff suppressed because it is too large
+ 11809 - 0
app/static/bower_components/jQuery/external/sinon/sinon.js


+ 36 - 0
app/static/bower_components/jQuery/external/sizzle/LICENSE.txt
Zobrazit soubor 

@@ -0,0 +1,36 @@
1 
+Copyright JS Foundation and other contributors, https://js.foundation/
2 
+
3 
+This software consists of voluntary contributions made by many
4 
+individuals. For exact contribution history, see the revision history
5 
+available at https://github.com/jquery/sizzle
6 
+
7 
+The following license applies to all parts of this software except as
8 
+documented below:
9 
+
10 
+====
11 
+
12 
+Permission is hereby granted, free of charge, to any person obtaining
13 
+a copy of this software and associated documentation files (the
14 
+"Software"), to deal in the Software without restriction, including
15 
+without limitation the rights to use, copy, modify, merge, publish,
16 
+distribute, sublicense, and/or sell copies of the Software, and to
17 
+permit persons to whom the Software is furnished to do so, subject to
18 
+the following conditions:
19 
+
20 
+The above copyright notice and this permission notice shall be
21 
+included in all copies or substantial portions of the Software.
22 
+
23 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
27 
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
28 
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
29 
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 
+
31 
+====
32 
+
33 
+All files located in the node_modules and external directories are
34 
+externally maintained libraries used by this software which have their
35 
+own licenses; we recommend you read them, as their terms may differ from
36 
+the terms above.

+ 116 - 0
app/static/bower_components/jQuery/package.json
Zobrazit soubor 

@@ -0,0 +1,116 @@
1 
+{
2 
+  "name": "jquery",
3 
+  "title": "jQuery",
4 
+  "description": "JavaScript library for DOM operations",
5 
+  "version": "3.6.0",
6 
+  "main": "dist/jquery.js",
7 
+  "homepage": "https://jquery.com",
8 
+  "author": {
9 
+    "name": "OpenJS Foundation and other contributors",
10 
+    "url": "https://github.com/jquery/jquery/blob/3.6.0/AUTHORS.txt"
11 
+  },
12 
+  "repository": {
13 
+    "type": "git",
14 
+    "url": "https://github.com/jquery/jquery.git"
15 
+  },
16 
+  "keywords": [
17 
+    "jquery",
18 
+    "javascript",
19 
+    "browser",
20 
+    "library"
21 
+  ],
22 
+  "bugs": {
23 
+    "url": "https://github.com/jquery/jquery/issues"
24 
+  },
25 
+  "license": "MIT",
26 
+  "devDependencies": {
27 
+    "@babel/core": "7.3.3",
28 
+    "@babel/plugin-transform-for-of": "7.2.0",
29 
+    "commitplease": "3.2.0",
30 
+    "core-js": "2.6.5",
31 
+    "eslint-config-jquery": "3.0.0",
32 
+    "grunt": "1.3.0",
33 
+    "grunt-babel": "8.0.0",
34 
+    "grunt-cli": "1.3.2",
35 
+    "grunt-compare-size": "0.4.2",
36 
+    "grunt-contrib-uglify": "3.4.0",
37 
+    "grunt-contrib-watch": "1.1.0",
38 
+    "grunt-eslint": "22.0.0",
39 
+    "grunt-git-authors": "3.2.0",
40 
+    "grunt-jsonlint": "1.1.0",
41 
+    "grunt-karma": "4.0.0",
42 
+    "grunt-newer": "1.3.0",
43 
+    "grunt-npmcopy": "0.2.0",
44 
+    "gzip-js": "0.3.2",
45 
+    "husky": "1.3.1",
46 
+    "insight": "0.10.1",
47 
+    "jsdom": "13.2.0",
48 
+    "karma": "5.2.3",
49 
+    "karma-browserstack-launcher": "1.4.0",
50 
+    "karma-chrome-launcher": "2.2.0",
51 
+    "karma-firefox-launcher": "1.1.0",
52 
+    "karma-ie-launcher": "1.0.0",
53 
+    "karma-jsdom-launcher": "8.0.2",
54 
+    "karma-qunit": "3.0.0",
55 
+    "load-grunt-tasks": "5.1.0",
56 
+    "native-promise-only": "0.8.1",
57 
+    "promises-aplus-tests": "2.1.2",
58 
+    "q": "1.5.1",
59 
+    "qunit": "2.9.2",
60 
+    "raw-body": "2.3.3",
61 
+    "requirejs": "2.3.6",
62 
+    "sinon": "2.3.7",
63 
+    "sizzle": "2.3.6",
64 
+    "strip-json-comments": "2.0.1",
65 
+    "testswarm": "1.1.2",
66 
+    "uglify-js": "3.4.7"
67 
+  },
68 
+  "scripts": {
69 
+    "build": "npm install && grunt",
70 
+    "start": "grunt watch",
71 
+    "test:browserless": "grunt && grunt test:slow",
72 
+    "test:browser": "grunt && grunt karma:main",
73 
+    "test:amd": "grunt && grunt karma:amd",
74 
+    "test:no-deprecated": "grunt test:prepare && grunt custom:-deprecated && grunt karma:main",
75 
+    "test:no-sizzle": "grunt test:prepare && grunt custom:-sizzle && grunt karma:main",
76 
+    "test:slim": "grunt test:prepare && grunt custom:slim && grunt karma:main",
77 
+    "test": "npm run test:slim && npm run test:no-deprecated && npm run test:no-sizzle && grunt && grunt test:slow && grunt karma:main && grunt karma:amd",
78 
+    "jenkins": "npm run test:browserless"
79 
+  },
80 
+  "commitplease": {
81 
+    "nohook": true,
82 
+    "components": [
83 
+      "Docs",
84 
+      "Tests",
85 
+      "Build",
86 
+      "Support",
87 
+      "Release",
88 
+      "Core",
89 
+      "Ajax",
90 
+      "Attributes",
91 
+      "Callbacks",
92 
+      "CSS",
93 
+      "Data",
94 
+      "Deferred",
95 
+      "Deprecated",
96 
+      "Dimensions",
97 
+      "Effects",
98 
+      "Event",
99 
+      "Manipulation",
100 
+      "Offset",
101 
+      "Queue",
102 
+      "Selector",
103 
+      "Serialize",
104 
+      "Traversing",
105 
+      "Wrap"
106 
+    ],
107 
+    "markerPattern": "^((clos|fix|resolv)(e[sd]|ing))|^(refs?)",
108 
+    "ticketPattern": "^((Closes|Fixes) ([a-zA-Z]{2,}-)[0-9]+)|^(Refs? [^#])"
109 
+  },
110 
+  "husky": {
111 
+    "hooks": {
112 
+      "commit-msg": "commitplease .git/COMMIT_EDITMSG",
113 
+      "pre-commit": "grunt lint:newer qunit_fixture"
114 
+    }
115 
+  }
116 
+}

+ 38 - 0
app/static/bower_components/jQuery/src/.eslintrc.json
Zobrazit soubor 

@@ -0,0 +1,38 @@
1 
+{
2 
+	"root": true,
3 
+
4 
+	"extends": "../.eslintrc-browser.json",
5 
+
6 
+	"rules": {
7 
+		"indent": [ "error", "tab", {
8 
+			"outerIIFEBody": 0,
9 
+
10 
+			// Ignore the top level function defining an AMD module
11 
+			"ignoredNodes": [
12 
+				"Program > ExpressionStatement > CallExpression > :last-child > *"
13 
+			]
14 
+		} ]
15 
+	},
16 
+
17 
+	"overrides": [
18 
+		{
19 
+			"files": "wrapper.js",
20 
+			"rules": {
21 
+				"no-unused-vars": "off",
22 
+				"indent": [ "error", "tab", {
23 
+
24 
+					// Unlike other codes, "wrapper.js" is implemented in UMD.
25 
+					// So it required a specific exception for jQuery's UMD
26 
+					// Code Style. This makes that indentation check is not
27 
+					// performed for 1 depth of outer FunctionExpressions
28 
+					"ignoredNodes": [
29 
+						"Program > ExpressionStatement > CallExpression > :last-child > *"
30 
+					]
31 
+				} ]
32 
+			},
33 
+			"globals": {
34 
+				"jQuery": false
35 
+			}
36 
+		}
37 
+	]
38 
+}

+ 876 - 0
app/static/bower_components/jQuery/src/ajax.js
Zobrazit soubor 

@@ -0,0 +1,876 @@
1 
+define( [
2 
+	"./core",
3 
+	"./var/document",
4 
+	"./var/isFunction",
5 
+	"./var/rnothtmlwhite",
6 
+	"./ajax/var/location",
7 
+	"./ajax/var/nonce",
8 
+	"./ajax/var/rquery",
9 
+
10 
+	"./core/init",
11 
+	"./core/parseXML",
12 
+	"./event/trigger",
13 
+	"./deferred",
14 
+	"./serialize" // jQuery.param
15 
+], function( jQuery, document, isFunction, rnothtmlwhite, location, nonce, rquery ) {
16 
+
17 
+"use strict";
18 
+
19 
+var
20 
+	r20 = /%20/g,
21 
+	rhash = /#.*$/,
22 
+	rantiCache = /([?&])_=[^&]*/,
23 
+	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
24 
+
25 
+	// #7653, #8125, #8152: local protocol detection
26 
+	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
27 
+	rnoContent = /^(?:GET|HEAD)$/,
28 
+	rprotocol = /^\/\//,
29 
+
30 
+	/* Prefilters
31 
+	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
32 
+	 * 2) These are called:
33 
+	 *    - BEFORE asking for a transport
34 
+	 *    - AFTER param serialization (s.data is a string if s.processData is true)
35 
+	 * 3) key is the dataType
36 
+	 * 4) the catchall symbol "*" can be used
37 
+	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
38 
+	 */
39 
+	prefilters = {},
40 
+
41 
+	/* Transports bindings
42 
+	 * 1) key is the dataType
43 
+	 * 2) the catchall symbol "*" can be used
44 
+	 * 3) selection will start with transport dataType and THEN go to "*" if needed
45 
+	 */
46 
+	transports = {},
47 
+
48 
+	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
49 
+	allTypes = "*/".concat( "*" ),
50 
+
51 
+	// Anchor tag for parsing the document origin
52 
+	originAnchor = document.createElement( "a" );
53 
+
54 
+originAnchor.href = location.href;
55 
+
56 
+// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
57 
+function addToPrefiltersOrTransports( structure ) {
58 
+
59 
+	// dataTypeExpression is optional and defaults to "*"
60 
+	return function( dataTypeExpression, func ) {
61 
+
62 
+		if ( typeof dataTypeExpression !== "string" ) {
63 
+			func = dataTypeExpression;
64 
+			dataTypeExpression = "*";
65 
+		}
66 
+
67 
+		var dataType,
68 
+			i = 0,
69 
+			dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
70 
+
71 
+		if ( isFunction( func ) ) {
72 
+
73 
+			// For each dataType in the dataTypeExpression
74 
+			while ( ( dataType = dataTypes[ i++ ] ) ) {
75 
+
76 
+				// Prepend if requested
77 
+				if ( dataType[ 0 ] === "+" ) {
78 
+					dataType = dataType.slice( 1 ) || "*";
79 
+					( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
80 
+
81 
+				// Otherwise append
82 
+				} else {
83 
+					( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
84 
+				}
85 
+			}
86 
+		}
87 
+	};
88 
+}
89 
+
90 
+// Base inspection function for prefilters and transports
91 
+function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
92 
+
93 
+	var inspected = {},
94 
+		seekingTransport = ( structure === transports );
95 
+
96 
+	function inspect( dataType ) {
97 
+		var selected;
98 
+		inspected[ dataType ] = true;
99 
+		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
100 
+			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
101 
+			if ( typeof dataTypeOrTransport === "string" &&
102 
+				!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
103 
+
104 
+				options.dataTypes.unshift( dataTypeOrTransport );
105 
+				inspect( dataTypeOrTransport );
106 
+				return false;
107 
+			} else if ( seekingTransport ) {
108 
+				return !( selected = dataTypeOrTransport );
109 
+			}
110 
+		} );
111 
+		return selected;
112 
+	}
113 
+
114 
+	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
115 
+}
116 
+
117 
+// A special extend for ajax options
118 
+// that takes "flat" options (not to be deep extended)
119 
+// Fixes #9887
120 
+function ajaxExtend( target, src ) {
121 
+	var key, deep,
122 
+		flatOptions = jQuery.ajaxSettings.flatOptions || {};
123 
+
124 
+	for ( key in src ) {
125 
+		if ( src[ key ] !== undefined ) {
126 
+			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
127 
+		}
128 
+	}
129 
+	if ( deep ) {
130 
+		jQuery.extend( true, target, deep );
131 
+	}
132 
+
133 
+	return target;
134 
+}
135 
+
136 
+/* Handles responses to an ajax request:
137 
+ * - finds the right dataType (mediates between content-type and expected dataType)
138 
+ * - returns the corresponding response
139 
+ */
140 
+function ajaxHandleResponses( s, jqXHR, responses ) {
141 
+
142 
+	var ct, type, finalDataType, firstDataType,
143 
+		contents = s.contents,
144 
+		dataTypes = s.dataTypes;
145 
+
146 
+	// Remove auto dataType and get content-type in the process
147 
+	while ( dataTypes[ 0 ] === "*" ) {
148 
+		dataTypes.shift();
149 
+		if ( ct === undefined ) {
150 
+			ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
151 
+		}
152 
+	}
153 
+
154 
+	// Check if we're dealing with a known content-type
155 
+	if ( ct ) {
156 
+		for ( type in contents ) {
157 
+			if ( contents[ type ] && contents[ type ].test( ct ) ) {
158 
+				dataTypes.unshift( type );
159 
+				break;
160 
+			}
161 
+		}
162 
+	}
163 
+
164 
+	// Check to see if we have a response for the expected dataType
165 
+	if ( dataTypes[ 0 ] in responses ) {
166 
+		finalDataType = dataTypes[ 0 ];
167 
+	} else {
168 
+
169 
+		// Try convertible dataTypes
170 
+		for ( type in responses ) {
171 
+			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
172 
+				finalDataType = type;
173 
+				break;
174 
+			}
175 
+			if ( !firstDataType ) {
176 
+				firstDataType = type;
177 
+			}
178 
+		}
179 
+
180 
+		// Or just use first one
181 
+		finalDataType = finalDataType || firstDataType;
182 
+	}
183 
+
184 
+	// If we found a dataType
185 
+	// We add the dataType to the list if needed
186 
+	// and return the corresponding response
187 
+	if ( finalDataType ) {
188 
+		if ( finalDataType !== dataTypes[ 0 ] ) {
189 
+			dataTypes.unshift( finalDataType );
190 
+		}
191 
+		return responses[ finalDataType ];
192 
+	}
193 
+}
194 
+
195 
+/* Chain conversions given the request and the original response
196 
+ * Also sets the responseXXX fields on the jqXHR instance
197 
+ */
198 
+function ajaxConvert( s, response, jqXHR, isSuccess ) {
199 
+	var conv2, current, conv, tmp, prev,
200 
+		converters = {},
201 
+
202 
+		// Work with a copy of dataTypes in case we need to modify it for conversion
203 
+		dataTypes = s.dataTypes.slice();
204 
+
205 
+	// Create converters map with lowercased keys
206 
+	if ( dataTypes[ 1 ] ) {
207 
+		for ( conv in s.converters ) {
208 
+			converters[ conv.toLowerCase() ] = s.converters[ conv ];
209 
+		}
210 
+	}
211 
+
212 
+	current = dataTypes.shift();
213 
+
214 
+	// Convert to each sequential dataType
215 
+	while ( current ) {
216 
+
217 
+		if ( s.responseFields[ current ] ) {
218 
+			jqXHR[ s.responseFields[ current ] ] = response;
219 
+		}
220 
+
221 
+		// Apply the dataFilter if provided
222 
+		if ( !prev && isSuccess && s.dataFilter ) {
223 
+			response = s.dataFilter( response, s.dataType );
224 
+		}
225 
+
226 
+		prev = current;
227 
+		current = dataTypes.shift();
228 
+
229 
+		if ( current ) {
230 
+
231 
+			// There's only work to do if current dataType is non-auto
232 
+			if ( current === "*" ) {
233 
+
234 
+				current = prev;
235 
+
236 
+			// Convert response if prev dataType is non-auto and differs from current
237 
+			} else if ( prev !== "*" && prev !== current ) {
238 
+
239 
+				// Seek a direct converter
240 
+				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
241 
+
242 
+				// If none found, seek a pair
243 
+				if ( !conv ) {
244 
+					for ( conv2 in converters ) {
245 
+
246 
+						// If conv2 outputs current
247 
+						tmp = conv2.split( " " );
248 
+						if ( tmp[ 1 ] === current ) {
249 
+
250 
+							// If prev can be converted to accepted input
251 
+							conv = converters[ prev + " " + tmp[ 0 ] ] ||
252 
+								converters[ "* " + tmp[ 0 ] ];
253 
+							if ( conv ) {
254 
+
255 
+								// Condense equivalence converters
256 
+								if ( conv === true ) {
257 
+									conv = converters[ conv2 ];
258 
+
259 
+								// Otherwise, insert the intermediate dataType
260 
+								} else if ( converters[ conv2 ] !== true ) {
261 
+									current = tmp[ 0 ];
262 
+									dataTypes.unshift( tmp[ 1 ] );
263 
+								}
264 
+								break;
265 
+							}
266 
+						}
267 
+					}
268 
+				}
269 
+
270 
+				// Apply converter (if not an equivalence)
271 
+				if ( conv !== true ) {
272 
+
273 
+					// Unless errors are allowed to bubble, catch and return them
274 
+					if ( conv && s.throws ) {
275 
+						response = conv( response );
276 
+					} else {
277 
+						try {
278 
+							response = conv( response );
279 
+						} catch ( e ) {
280 
+							return {
281 
+								state: "parsererror",
282 
+								error: conv ? e : "No conversion from " + prev + " to " + current
283 
+							};
284 
+						}
285 
+					}
286 
+				}
287 
+			}
288 
+		}
289 
+	}
290 
+
291 
+	return { state: "success", data: response };
292 
+}
293 
+
294 
+jQuery.extend( {
295 
+
296 
+	// Counter for holding the number of active queries
297 
+	active: 0,
298 
+
299 
+	// Last-Modified header cache for next request
300 
+	lastModified: {},
301 
+	etag: {},
302 
+
303 
+	ajaxSettings: {
304 
+		url: location.href,
305 
+		type: "GET",
306 
+		isLocal: rlocalProtocol.test( location.protocol ),
307 
+		global: true,
308 
+		processData: true,
309 
+		async: true,
310 
+		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
311 
+
312 
+		/*
313 
+		timeout: 0,
314 
+		data: null,
315 
+		dataType: null,
316 
+		username: null,
317 
+		password: null,
318 
+		cache: null,
319 
+		throws: false,
320 
+		traditional: false,
321 
+		headers: {},
322 
+		*/
323 
+
324 
+		accepts: {
325 
+			"*": allTypes,
326 
+			text: "text/plain",
327 
+			html: "text/html",
328 
+			xml: "application/xml, text/xml",
329 
+			json: "application/json, text/javascript"
330 
+		},
331 
+
332 
+		contents: {
333 
+			xml: /\bxml\b/,
334 
+			html: /\bhtml/,
335 
+			json: /\bjson\b/
336 
+		},
337 
+
338 
+		responseFields: {
339 
+			xml: "responseXML",
340 
+			text: "responseText",
341 
+			json: "responseJSON"
342 
+		},
343 
+
344 
+		// Data converters
345 
+		// Keys separate source (or catchall "*") and destination types with a single space
346 
+		converters: {
347 
+
348 
+			// Convert anything to text
349 
+			"* text": String,
350 
+
351 
+			// Text to html (true = no transformation)
352 
+			"text html": true,
353 
+
354 
+			// Evaluate text as a json expression
355 
+			"text json": JSON.parse,
356 
+
357 
+			// Parse text as xml
358 
+			"text xml": jQuery.parseXML
359 
+		},
360 
+
361 
+		// For options that shouldn't be deep extended:
362 
+		// you can add your own custom options here if
363 
+		// and when you create one that shouldn't be
364 
+		// deep extended (see ajaxExtend)
365 
+		flatOptions: {
366 
+			url: true,
367 
+			context: true
368 
+		}
369 
+	},
370 
+
371 
+	// Creates a full fledged settings object into target
372 
+	// with both ajaxSettings and settings fields.
373 
+	// If target is omitted, writes into ajaxSettings.
374 
+	ajaxSetup: function( target, settings ) {
375 
+		return settings ?
376 
+
377 
+			// Building a settings object
378 
+			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
379 
+
380 
+			// Extending ajaxSettings
381 
+			ajaxExtend( jQuery.ajaxSettings, target );
382 
+	},
383 
+
384 
+	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
385 
+	ajaxTransport: addToPrefiltersOrTransports( transports ),
386 
+
387 
+	// Main method
388 
+	ajax: function( url, options ) {
389 
+
390 
+		// If url is an object, simulate pre-1.5 signature
391 
+		if ( typeof url === "object" ) {
392 
+			options = url;
393 
+			url = undefined;
394 
+		}
395 
+
396 
+		// Force options to be an object
397 
+		options = options || {};
398 
+
399 
+		var transport,
400 
+
401 
+			// URL without anti-cache param
402 
+			cacheURL,
403 
+
404 
+			// Response headers
405 
+			responseHeadersString,
406 
+			responseHeaders,
407 
+
408 
+			// timeout handle
409 
+			timeoutTimer,
410 
+
411 
+			// Url cleanup var
412 
+			urlAnchor,
413 
+
414 
+			// Request state (becomes false upon send and true upon completion)
415 
+			completed,
416 
+
417 
+			// To know if global events are to be dispatched
418 
+			fireGlobals,
419 
+
420 
+			// Loop variable
421 
+			i,
422 
+
423 
+			// uncached part of the url
424 
+			uncached,
425 
+
426 
+			// Create the final options object
427 
+			s = jQuery.ajaxSetup( {}, options ),
428 
+
429 
+			// Callbacks context
430 
+			callbackContext = s.context || s,
431 
+
432 
+			// Context for global events is callbackContext if it is a DOM node or jQuery collection
433 
+			globalEventContext = s.context &&
434 
+				( callbackContext.nodeType || callbackContext.jquery ) ?
435 
+				jQuery( callbackContext ) :
436 
+				jQuery.event,
437 
+
438 
+			// Deferreds
439 
+			deferred = jQuery.Deferred(),
440 
+			completeDeferred = jQuery.Callbacks( "once memory" ),
441 
+
442 
+			// Status-dependent callbacks
443 
+			statusCode = s.statusCode || {},
444 
+
445 
+			// Headers (they are sent all at once)
446 
+			requestHeaders = {},
447 
+			requestHeadersNames = {},
448 
+
449 
+			// Default abort message
450 
+			strAbort = "canceled",
451 
+
452 
+			// Fake xhr
453 
+			jqXHR = {
454 
+				readyState: 0,
455 
+
456 
+				// Builds headers hashtable if needed
457 
+				getResponseHeader: function( key ) {
458 
+					var match;
459 
+					if ( completed ) {
460 
+						if ( !responseHeaders ) {
461 
+							responseHeaders = {};
462 
+							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
463 
+								responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
464 
+									( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
465 
+										.concat( match[ 2 ] );
466 
+							}
467 
+						}
468 
+						match = responseHeaders[ key.toLowerCase() + " " ];
469 
+					}
470 
+					return match == null ? null : match.join( ", " );
471 
+				},
472 
+
473 
+				// Raw string
474 
+				getAllResponseHeaders: function() {
475 
+					return completed ? responseHeadersString : null;
476 
+				},
477 
+
478 
+				// Caches the header
479 
+				setRequestHeader: function( name, value ) {
480 
+					if ( completed == null ) {
481 
+						name = requestHeadersNames[ name.toLowerCase() ] =
482 
+							requestHeadersNames[ name.toLowerCase() ] || name;
483 
+						requestHeaders[ name ] = value;
484 
+					}
485 
+					return this;
486 
+				},
487 
+
488 
+				// Overrides response content-type header
489 
+				overrideMimeType: function( type ) {
490 
+					if ( completed == null ) {
491 
+						s.mimeType = type;
492 
+					}
493 
+					return this;
494 
+				},
495 
+
496 
+				// Status-dependent callbacks
497 
+				statusCode: function( map ) {
498 
+					var code;
499 
+					if ( map ) {
500 
+						if ( completed ) {
501 
+
502 
+							// Execute the appropriate callbacks
503 
+							jqXHR.always( map[ jqXHR.status ] );
504 
+						} else {
505 
+
506 
+							// Lazy-add the new callbacks in a way that preserves old ones
507 
+							for ( code in map ) {
508 
+								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
509 
+							}
510 
+						}
511 
+					}
512 
+					return this;
513 
+				},
514 
+
515 
+				// Cancel the request
516 
+				abort: function( statusText ) {
517 
+					var finalText = statusText || strAbort;
518 
+					if ( transport ) {
519 
+						transport.abort( finalText );
520 
+					}
521 
+					done( 0, finalText );
522 
+					return this;
523 
+				}
524 
+			};
525 
+
526 
+		// Attach deferreds
527 
+		deferred.promise( jqXHR );
528 
+
529 
+		// Add protocol if not provided (prefilters might expect it)
530 
+		// Handle falsy url in the settings object (#10093: consistency with old signature)
531 
+		// We also use the url parameter if available
532 
+		s.url = ( ( url || s.url || location.href ) + "" )
533 
+			.replace( rprotocol, location.protocol + "//" );
534 
+
535 
+		// Alias method option to type as per ticket #12004
536 
+		s.type = options.method || options.type || s.method || s.type;
537 
+
538 
+		// Extract dataTypes list
539 
+		s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
540 
+
541 
+		// A cross-domain request is in order when the origin doesn't match the current origin.
542 
+		if ( s.crossDomain == null ) {
543 
+			urlAnchor = document.createElement( "a" );
544 
+
545 
+			// Support: IE <=8 - 11, Edge 12 - 15
546 
+			// IE throws exception on accessing the href property if url is malformed,
547 
+			// e.g. http://example.com:80x/
548 
+			try {
549 
+				urlAnchor.href = s.url;
550 
+
551 
+				// Support: IE <=8 - 11 only
552 
+				// Anchor's host property isn't correctly set when s.url is relative
553 
+				urlAnchor.href = urlAnchor.href;
554 
+				s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
555 
+					urlAnchor.protocol + "//" + urlAnchor.host;
556 
+			} catch ( e ) {
557 
+
558 
+				// If there is an error parsing the URL, assume it is crossDomain,
559 
+				// it can be rejected by the transport if it is invalid
560 
+				s.crossDomain = true;
561 
+			}
562 
+		}
563 
+
564 
+		// Convert data if not already a string
565 
+		if ( s.data && s.processData && typeof s.data !== "string" ) {
566 
+			s.data = jQuery.param( s.data, s.traditional );
567 
+		}
568 
+
569 
+		// Apply prefilters
570 
+		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
571 
+
572 
+		// If request was aborted inside a prefilter, stop there
573 
+		if ( completed ) {
574 
+			return jqXHR;
575 
+		}
576 
+
577 
+		// We can fire global events as of now if asked to
578 
+		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
579 
+		fireGlobals = jQuery.event && s.global;
580 
+
581 
+		// Watch for a new set of requests
582 
+		if ( fireGlobals && jQuery.active++ === 0 ) {
583 
+			jQuery.event.trigger( "ajaxStart" );
584 
+		}
585 
+
586 
+		// Uppercase the type
587 
+		s.type = s.type.toUpperCase();
588 
+
589 
+		// Determine if request has content
590 
+		s.hasContent = !rnoContent.test( s.type );
591 
+
592 
+		// Save the URL in case we're toying with the If-Modified-Since
593 
+		// and/or If-None-Match header later on
594 
+		// Remove hash to simplify url manipulation
595 
+		cacheURL = s.url.replace( rhash, "" );
596 
+
597 
+		// More options handling for requests with no content
598 
+		if ( !s.hasContent ) {
599 
+
600 
+			// Remember the hash so we can put it back
601 
+			uncached = s.url.slice( cacheURL.length );
602 
+
603 
+			// If data is available and should be processed, append data to url
604 
+			if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
605 
+				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
606 
+
607 
+				// #9682: remove data so that it's not used in an eventual retry
608 
+				delete s.data;
609 
+			}
610 
+
611 
+			// Add or update anti-cache param if needed
612 
+			if ( s.cache === false ) {
613 
+				cacheURL = cacheURL.replace( rantiCache, "$1" );
614 
+				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) +
615 
+					uncached;
616 
+			}
617 
+
618 
+			// Put hash and anti-cache on the URL that will be requested (gh-1732)
619 
+			s.url = cacheURL + uncached;
620 
+
621 
+		// Change '%20' to '+' if this is encoded form body content (gh-2658)
622 
+		} else if ( s.data && s.processData &&
623 
+			( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
624 
+			s.data = s.data.replace( r20, "+" );
625 
+		}
626 
+
627 
+		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
628 
+		if ( s.ifModified ) {
629 
+			if ( jQuery.lastModified[ cacheURL ] ) {
630 
+				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
631 
+			}
632 
+			if ( jQuery.etag[ cacheURL ] ) {
633 
+				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
634 
+			}
635 
+		}
636 
+
637 
+		// Set the correct header, if data is being sent
638 
+		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
639 
+			jqXHR.setRequestHeader( "Content-Type", s.contentType );
640 
+		}
641 
+
642 
+		// Set the Accepts header for the server, depending on the dataType
643 
+		jqXHR.setRequestHeader(
644 
+			"Accept",
645 
+			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
646 
+				s.accepts[ s.dataTypes[ 0 ] ] +
647 
+					( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
648 
+				s.accepts[ "*" ]
649 
+		);
650 
+
651 
+		// Check for headers option
652 
+		for ( i in s.headers ) {
653 
+			jqXHR.setRequestHeader( i, s.headers[ i ] );
654 
+		}
655 
+
656 
+		// Allow custom headers/mimetypes and early abort
657 
+		if ( s.beforeSend &&
658 
+			( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
659 
+
660 
+			// Abort if not done already and return
661 
+			return jqXHR.abort();
662 
+		}
663 
+
664 
+		// Aborting is no longer a cancellation
665 
+		strAbort = "abort";
666 
+
667 
+		// Install callbacks on deferreds
668 
+		completeDeferred.add( s.complete );
669 
+		jqXHR.done( s.success );
670 
+		jqXHR.fail( s.error );
671 
+
672 
+		// Get transport
673 
+		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
674 
+
675 
+		// If no transport, we auto-abort
676 
+		if ( !transport ) {
677 
+			done( -1, "No Transport" );
678 
+		} else {
679 
+			jqXHR.readyState = 1;
680 
+
681 
+			// Send global event
682 
+			if ( fireGlobals ) {
683 
+				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
684 
+			}
685 
+
686 
+			// If request was aborted inside ajaxSend, stop there
687 
+			if ( completed ) {
688 
+				return jqXHR;
689 
+			}
690 
+
691 
+			// Timeout
692 
+			if ( s.async && s.timeout > 0 ) {
693 
+				timeoutTimer = window.setTimeout( function() {
694 
+					jqXHR.abort( "timeout" );
695 
+				}, s.timeout );
696 
+			}
697 
+
698 
+			try {
699 
+				completed = false;
700 
+				transport.send( requestHeaders, done );
701 
+			} catch ( e ) {
702 
+
703 
+				// Rethrow post-completion exceptions
704 
+				if ( completed ) {
705 
+					throw e;
706 
+				}
707 
+
708 
+				// Propagate others as results
709 
+				done( -1, e );
710 
+			}
711 
+		}
712 
+
713 
+		// Callback for when everything is done
714 
+		function done( status, nativeStatusText, responses, headers ) {
715 
+			var isSuccess, success, error, response, modified,
716 
+				statusText = nativeStatusText;
717 
+
718 
+			// Ignore repeat invocations
719 
+			if ( completed ) {
720 
+				return;
721 
+			}
722 
+
723 
+			completed = true;
724 
+
725 
+			// Clear timeout if it exists
726 
+			if ( timeoutTimer ) {
727 
+				window.clearTimeout( timeoutTimer );
728 
+			}
729 
+
730 
+			// Dereference transport for early garbage collection
731 
+			// (no matter how long the jqXHR object will be used)
732 
+			transport = undefined;
733 
+
734 
+			// Cache response headers
735 
+			responseHeadersString = headers || "";
736 
+
737 
+			// Set readyState
738 
+			jqXHR.readyState = status > 0 ? 4 : 0;
739 
+
740 
+			// Determine if successful
741 
+			isSuccess = status >= 200 && status < 300 || status === 304;
742 
+
743 
+			// Get response data
744 
+			if ( responses ) {
745 
+				response = ajaxHandleResponses( s, jqXHR, responses );
746 
+			}
747 
+
748 
+			// Use a noop converter for missing script but not if jsonp
749 
+			if ( !isSuccess &&
750 
+				jQuery.inArray( "script", s.dataTypes ) > -1 &&
751 
+				jQuery.inArray( "json", s.dataTypes ) < 0 ) {
752 
+				s.converters[ "text script" ] = function() {};
753 
+			}
754 
+
755 
+			// Convert no matter what (that way responseXXX fields are always set)
756 
+			response = ajaxConvert( s, response, jqXHR, isSuccess );
757 
+
758 
+			// If successful, handle type chaining
759 
+			if ( isSuccess ) {
760 
+
761 
+				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
762 
+				if ( s.ifModified ) {
763 
+					modified = jqXHR.getResponseHeader( "Last-Modified" );
764 
+					if ( modified ) {
765 
+						jQuery.lastModified[ cacheURL ] = modified;
766 
+					}
767 
+					modified = jqXHR.getResponseHeader( "etag" );
768 
+					if ( modified ) {
769 
+						jQuery.etag[ cacheURL ] = modified;
770 
+					}
771 
+				}
772 
+
773 
+				// if no content
774 
+				if ( status === 204 || s.type === "HEAD" ) {
775 
+					statusText = "nocontent";
776 
+
777 
+				// if not modified
778 
+				} else if ( status === 304 ) {
779 
+					statusText = "notmodified";
780 
+
781 
+				// If we have data, let's convert it
782 
+				} else {
783 
+					statusText = response.state;
784 
+					success = response.data;
785 
+					error = response.error;
786 
+					isSuccess = !error;
787 
+				}
788 
+			} else {
789 
+
790 
+				// Extract error from statusText and normalize for non-aborts
791 
+				error = statusText;
792 
+				if ( status || !statusText ) {
793 
+					statusText = "error";
794 
+					if ( status < 0 ) {
795 
+						status = 0;
796 
+					}
797 
+				}
798 
+			}
799 
+
800 
+			// Set data for the fake xhr object
801 
+			jqXHR.status = status;
802 
+			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
803 
+
804 
+			// Success/Error
805 
+			if ( isSuccess ) {
806 
+				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
807 
+			} else {
808 
+				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
809 
+			}
810 
+
811 
+			// Status-dependent callbacks
812 
+			jqXHR.statusCode( statusCode );
813 
+			statusCode = undefined;
814 
+
815 
+			if ( fireGlobals ) {
816 
+				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
817 
+					[ jqXHR, s, isSuccess ? success : error ] );
818 
+			}
819 
+
820 
+			// Complete
821 
+			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
822 
+
823 
+			if ( fireGlobals ) {
824 
+				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
825 
+
826 
+				// Handle the global AJAX counter
827 
+				if ( !( --jQuery.active ) ) {
828 
+					jQuery.event.trigger( "ajaxStop" );
829 
+				}
830 
+			}
831 
+		}
832 
+
833 
+		return jqXHR;
834 
+	},
835 
+
836 
+	getJSON: function( url, data, callback ) {
837 
+		return jQuery.get( url, data, callback, "json" );
838 
+	},
839 
+
840 
+	getScript: function( url, callback ) {
841 
+		return jQuery.get( url, undefined, callback, "script" );
842 
+	}
843 
+} );
844 
+
845 
+jQuery.each( [ "get", "post" ], function( _i, method ) {
846 
+	jQuery[ method ] = function( url, data, callback, type ) {
847 
+
848 
+		// Shift arguments if data argument was omitted
849 
+		if ( isFunction( data ) ) {
850 
+			type = type || callback;
851 
+			callback = data;
852 
+			data = undefined;
853 
+		}
854 
+
855 
+		// The url can be an options object (which then must have .url)
856 
+		return jQuery.ajax( jQuery.extend( {
857 
+			url: url,
858 
+			type: method,
859 
+			dataType: type,
860 
+			data: data,
861 
+			success: callback
862 
+		}, jQuery.isPlainObject( url ) && url ) );
863 
+	};
864 
+} );
865 
+
866 
+jQuery.ajaxPrefilter( function( s ) {
867 
+	var i;
868 
+	for ( i in s.headers ) {
869 
+		if ( i.toLowerCase() === "content-type" ) {
870 
+			s.contentType = s.headers[ i ] || "";
871 
+		}
872 
+	}
873 
+} );
874 
+
875 
+return jQuery;
876 
+} );

+ 103 - 0
app/static/bower_components/jQuery/src/ajax/jsonp.js
Zobrazit soubor 

@@ -0,0 +1,103 @@
1 
+define( [
2 
+	"../core",
3 
+	"../var/isFunction",
4 
+	"./var/nonce",
5 
+	"./var/rquery",
6 
+	"../ajax"
7 
+], function( jQuery, isFunction, nonce, rquery ) {
8 
+
9 
+"use strict";
10 
+
11 
+var oldCallbacks = [],
12 
+	rjsonp = /(=)\?(?=&|$)|\?\?/;
13 
+
14 
+// Default jsonp settings
15 
+jQuery.ajaxSetup( {
16 
+	jsonp: "callback",
17 
+	jsonpCallback: function() {
18 
+		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) );
19 
+		this[ callback ] = true;
20 
+		return callback;
21 
+	}
22 
+} );
23 
+
24 
+// Detect, normalize options and install callbacks for jsonp requests
25 
+jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
26 
+
27 
+	var callbackName, overwritten, responseContainer,
28 
+		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
29 
+			"url" :
30 
+			typeof s.data === "string" &&
31 
+				( s.contentType || "" )
32 
+					.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
33 
+				rjsonp.test( s.data ) && "data"
34 
+		);
35 
+
36 
+	// Handle iff the expected data type is "jsonp" or we have a parameter to set
37 
+	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
38 
+
39 
+		// Get callback name, remembering preexisting value associated with it
40 
+		callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?
41 
+			s.jsonpCallback() :
42 
+			s.jsonpCallback;
43 
+
44 
+		// Insert callback into url or form data
45 
+		if ( jsonProp ) {
46 
+			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
47 
+		} else if ( s.jsonp !== false ) {
48 
+			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
49 
+		}
50 
+
51 
+		// Use data converter to retrieve json after script execution
52 
+		s.converters[ "script json" ] = function() {
53 
+			if ( !responseContainer ) {
54 
+				jQuery.error( callbackName + " was not called" );
55 
+			}
56 
+			return responseContainer[ 0 ];
57 
+		};
58 
+
59 
+		// Force json dataType
60 
+		s.dataTypes[ 0 ] = "json";
61 
+
62 
+		// Install callback
63 
+		overwritten = window[ callbackName ];
64 
+		window[ callbackName ] = function() {
65 
+			responseContainer = arguments;
66 
+		};
67 
+
68 
+		// Clean-up function (fires after converters)
69 
+		jqXHR.always( function() {
70 
+
71 
+			// If previous value didn't exist - remove it
72 
+			if ( overwritten === undefined ) {
73 
+				jQuery( window ).removeProp( callbackName );
74 
+
75 
+			// Otherwise restore preexisting value
76 
+			} else {
77 
+				window[ callbackName ] = overwritten;
78 
+			}
79 
+
80 
+			// Save back as free
81 
+			if ( s[ callbackName ] ) {
82 
+
83 
+				// Make sure that re-using the options doesn't screw things around
84 
+				s.jsonpCallback = originalSettings.jsonpCallback;
85 
+
86 
+				// Save the callback name for future use
87 
+				oldCallbacks.push( callbackName );
88 
+			}
89 
+
90 
+			// Call if it was a function and we have a response
91 
+			if ( responseContainer && isFunction( overwritten ) ) {
92 
+				overwritten( responseContainer[ 0 ] );
93 
+			}
94 
+
95 
+			responseContainer = overwritten = undefined;
96 
+		} );
97 
+
98 
+		// Delegate to script
99 
+		return "script";
100 
+	}
101 
+} );
102 
+
103 
+} );

+ 77 - 0
app/static/bower_components/jQuery/src/ajax/load.js
Zobrazit soubor 

@@ -0,0 +1,77 @@
1 
+define( [
2 
+	"../core",
3 
+	"../core/stripAndCollapse",
4 
+	"../var/isFunction",
5 
+	"../core/parseHTML",
6 
+	"../ajax",
7 
+	"../traversing",
8 
+	"../manipulation",
9 
+	"../selector"
10 
+], function( jQuery, stripAndCollapse, isFunction ) {
11 
+
12 
+"use strict";
13 
+
14 
+/**
15 
+ * Load a url into a page
16 
+ */
17 
+jQuery.fn.load = function( url, params, callback ) {
18 
+	var selector, type, response,
19 
+		self = this,
20 
+		off = url.indexOf( " " );
21 
+
22 
+	if ( off > -1 ) {
23 
+		selector = stripAndCollapse( url.slice( off ) );
24 
+		url = url.slice( 0, off );
25 
+	}
26 
+
27 
+	// If it's a function
28 
+	if ( isFunction( params ) ) {
29 
+
30 
+		// We assume that it's the callback
31 
+		callback = params;
32 
+		params = undefined;
33 
+
34 
+	// Otherwise, build a param string
35 
+	} else if ( params && typeof params === "object" ) {
36 
+		type = "POST";
37 
+	}
38 
+
39 
+	// If we have elements to modify, make the request
40 
+	if ( self.length > 0 ) {
41 
+		jQuery.ajax( {
42 
+			url: url,
43 
+
44 
+			// If "type" variable is undefined, then "GET" method will be used.
45 
+			// Make value of this field explicit since
46 
+			// user can override it through ajaxSetup method
47 
+			type: type || "GET",
48 
+			dataType: "html",
49 
+			data: params
50 
+		} ).done( function( responseText ) {
51 
+
52 
+			// Save response for use in complete callback
53 
+			response = arguments;
54 
+
55 
+			self.html( selector ?
56 
+
57 
+				// If a selector was specified, locate the right elements in a dummy div
58 
+				// Exclude scripts to avoid IE 'Permission Denied' errors
59 
+				jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
60 
+
61 
+				// Otherwise use the full result
62 
+				responseText );
63 
+
64 
+		// If the request succeeds, this function gets "data", "status", "jqXHR"
65 
+		// but they are ignored because response was set above.
66 
+		// If it fails, this function gets "jqXHR", "status", "error"
67 
+		} ).always( callback && function( jqXHR, status ) {
68 
+			self.each( function() {
69 
+				callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
70 
+			} );
71 
+		} );
72 
+	}
73 
+
74 
+	return this;
75 
+};
76 
+
77 
+} );

+ 74 - 0
app/static/bower_components/jQuery/src/ajax/script.js
Zobrazit soubor 

@@ -0,0 +1,74 @@
1 
+define( [
2 
+	"../core",
3 
+	"../var/document",
4 
+	"../ajax"
5 
+], function( jQuery, document ) {
6 
+
7 
+"use strict";
8 
+
9 
+// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
10 
+jQuery.ajaxPrefilter( function( s ) {
11 
+	if ( s.crossDomain ) {
12 
+		s.contents.script = false;
13 
+	}
14 
+} );
15 
+
16 
+// Install script dataType
17 
+jQuery.ajaxSetup( {
18 
+	accepts: {
19 
+		script: "text/javascript, application/javascript, " +
20 
+			"application/ecmascript, application/x-ecmascript"
21 
+	},
22 
+	contents: {
23 
+		script: /\b(?:java|ecma)script\b/
24 
+	},
25 
+	converters: {
26 
+		"text script": function( text ) {
27 
+			jQuery.globalEval( text );
28 
+			return text;
29 
+		}
30 
+	}
31 
+} );
32 
+
33 
+// Handle cache's special case and crossDomain
34 
+jQuery.ajaxPrefilter( "script", function( s ) {
35 
+	if ( s.cache === undefined ) {
36 
+		s.cache = false;
37 
+	}
38 
+	if ( s.crossDomain ) {
39 
+		s.type = "GET";
40 
+	}
41 
+} );
42 
+
43 
+// Bind script tag hack transport
44 
+jQuery.ajaxTransport( "script", function( s ) {
45 
+
46 
+	// This transport only deals with cross domain or forced-by-attrs requests
47 
+	if ( s.crossDomain || s.scriptAttrs ) {
48 
+		var script, callback;
49 
+		return {
50 
+			send: function( _, complete ) {
51 
+				script = jQuery( "<script>" )
52 
+					.attr( s.scriptAttrs || {} )
53 
+					.prop( { charset: s.scriptCharset, src: s.url } )
54 
+					.on( "load error", callback = function( evt ) {
55 
+						script.remove();
56 
+						callback = null;
57 
+						if ( evt ) {
58 
+							complete( evt.type === "error" ? 404 : 200, evt.type );
59 
+						}
60 
+					} );
61 
+
62 
+				// Use native DOM manipulation to avoid our domManip AJAX trickery
63 
+				document.head.appendChild( script[ 0 ] );
64 
+			},
65 
+			abort: function() {
66 
+				if ( callback ) {
67 
+					callback();
68 
+				}
69 
+			}
70 
+		};
71 
+	}
72 
+} );
73 
+
74 
+} );

+ 170 - 0
app/static/bower_components/jQuery/src/ajax/xhr.js
Zobrazit soubor 

@@ -0,0 +1,170 @@
1 
+define( [
2 
+	"../core",
3 
+	"../var/support",
4 
+	"../ajax"
5 
+], function( jQuery, support ) {
6 
+
7 
+"use strict";
8 
+
9 
+jQuery.ajaxSettings.xhr = function() {
10 
+	try {
11 
+		return new window.XMLHttpRequest();
12 
+	} catch ( e ) {}
13 
+};
14 
+
15 
+var xhrSuccessStatus = {
16 
+
17 
+		// File protocol always yields status code 0, assume 200
18 
+		0: 200,
19 
+
20 
+		// Support: IE <=9 only
21 
+		// #1450: sometimes IE returns 1223 when it should be 204
22 
+		1223: 204
23 
+	},
24 
+	xhrSupported = jQuery.ajaxSettings.xhr();
25 
+
26 
+support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
27 
+support.ajax = xhrSupported = !!xhrSupported;
28 
+
29 
+jQuery.ajaxTransport( function( options ) {
30 
+	var callback, errorCallback;
31 
+
32 
+	// Cross domain only allowed if supported through XMLHttpRequest
33 
+	if ( support.cors || xhrSupported && !options.crossDomain ) {
34 
+		return {
35 
+			send: function( headers, complete ) {
36 
+				var i,
37 
+					xhr = options.xhr();
38 
+
39 
+				xhr.open(
40 
+					options.type,
41 
+					options.url,
42 
+					options.async,
43 
+					options.username,
44 
+					options.password
45 
+				);
46 
+
47 
+				// Apply custom fields if provided
48 
+				if ( options.xhrFields ) {
49 
+					for ( i in options.xhrFields ) {
50 
+						xhr[ i ] = options.xhrFields[ i ];
51 
+					}
52 
+				}
53 
+
54 
+				// Override mime type if needed
55 
+				if ( options.mimeType && xhr.overrideMimeType ) {
56 
+					xhr.overrideMimeType( options.mimeType );
57 
+				}
58 
+
59 
+				// X-Requested-With header
60 
+				// For cross-domain requests, seeing as conditions for a preflight are
61 
+				// akin to a jigsaw puzzle, we simply never set it to be sure.
62 
+				// (it can always be set on a per-request basis or even using ajaxSetup)
63 
+				// For same-domain requests, won't change header if already provided.
64 
+				if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
65 
+					headers[ "X-Requested-With" ] = "XMLHttpRequest";
66 
+				}
67 
+
68 
+				// Set headers
69 
+				for ( i in headers ) {
70 
+					xhr.setRequestHeader( i, headers[ i ] );
71 
+				}
72 
+
73 
+				// Callback
74 
+				callback = function( type ) {
75 
+					return function() {
76 
+						if ( callback ) {
77 
+							callback = errorCallback = xhr.onload =
78 
+								xhr.onerror = xhr.onabort = xhr.ontimeout =
79 
+									xhr.onreadystatechange = null;
80 
+
81 
+							if ( type === "abort" ) {
82 
+								xhr.abort();
83 
+							} else if ( type === "error" ) {
84 
+
85 
+								// Support: IE <=9 only
86 
+								// On a manual native abort, IE9 throws
87 
+								// errors on any property access that is not readyState
88 
+								if ( typeof xhr.status !== "number" ) {
89 
+									complete( 0, "error" );
90 
+								} else {
91 
+									complete(
92 
+
93 
+										// File: protocol always yields status 0; see #8605, #14207
94 
+										xhr.status,
95 
+										xhr.statusText
96 
+									);
97 
+								}
98 
+							} else {
99 
+								complete(
100 
+									xhrSuccessStatus[ xhr.status ] || xhr.status,
101 
+									xhr.statusText,
102 
+
103 
+									// Support: IE <=9 only
104 
+									// IE9 has no XHR2 but throws on binary (trac-11426)
105 
+									// For XHR2 non-text, let the caller handle it (gh-2498)
106 
+									( xhr.responseType || "text" ) !== "text"  ||
107 
+									typeof xhr.responseText !== "string" ?
108 
+										{ binary: xhr.response } :
109 
+										{ text: xhr.responseText },
110 
+									xhr.getAllResponseHeaders()
111 
+								);
112 
+							}
113 
+						}
114 
+					};
115 
+				};
116 
+
117 
+				// Listen to events
118 
+				xhr.onload = callback();
119 
+				errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
120 
+
121 
+				// Support: IE 9 only
122 
+				// Use onreadystatechange to replace onabort
123 
+				// to handle uncaught aborts
124 
+				if ( xhr.onabort !== undefined ) {
125 
+					xhr.onabort = errorCallback;
126 
+				} else {
127 
+					xhr.onreadystatechange = function() {
128 
+
129 
+						// Check readyState before timeout as it changes
130 
+						if ( xhr.readyState === 4 ) {
131 
+
132 
+							// Allow onerror to be called first,
133 
+							// but that will not handle a native abort
134 
+							// Also, save errorCallback to a variable
135 
+							// as xhr.onerror cannot be accessed
136 
+							window.setTimeout( function() {
137 
+								if ( callback ) {
138 
+									errorCallback();
139 
+								}
140 
+							} );
141 
+						}
142 
+					};
143 
+				}
144 
+
145 
+				// Create the abort callback
146 
+				callback = callback( "abort" );
147 
+
148 
+				try {
149 
+
150 
+					// Do send the request (this may raise an exception)
151 
+					xhr.send( options.hasContent && options.data || null );
152 
+				} catch ( e ) {
153 
+
154 
+					// #14683: Only rethrow if this hasn't been notified as an error yet
155 
+					if ( callback ) {
156 
+						throw e;
157 
+					}
158 
+				}
159 
+			},
160 
+
161 
+			abort: function() {
162 
+				if ( callback ) {
163 
+					callback();
164 
+				}
165 
+			}
166 
+		};
167 
+	}
168 
+} );
169 
+
170 
+} );

+ 13 - 0
app/static/bower_components/jQuery/src/attributes.js
Zobrazit soubor 

@@ -0,0 +1,13 @@
1 
+define( [
2 
+	"./core",
3 
+	"./attributes/attr",
4 
+	"./attributes/prop",
5 
+	"./attributes/classes",
6 
+	"./attributes/val"
7 
+], function( jQuery ) {
8 
+
9 
+"use strict";
10 
+
11 
+// Return jQuery for attributes-only inclusion
12 
+return jQuery;
13 
+} );

+ 141 - 0
app/static/bower_components/jQuery/src/attributes/attr.js
Zobrazit soubor 

@@ -0,0 +1,141 @@
1 
+define( [
2 
+	"../core",
3 
+	"../core/access",
4 
+	"../core/nodeName",
5 
+	"./support",
6 
+	"../var/rnothtmlwhite",
7 
+	"../selector"
8 
+], function( jQuery, access, nodeName, support, rnothtmlwhite ) {
9 
+
10 
+"use strict";
11 
+
12 
+var boolHook,
13 
+	attrHandle = jQuery.expr.attrHandle;
14 
+
15 
+jQuery.fn.extend( {
16 
+	attr: function( name, value ) {
17 
+		return access( this, jQuery.attr, name, value, arguments.length > 1 );
18 
+	},
19 
+
20 
+	removeAttr: function( name ) {
21 
+		return this.each( function() {
22 
+			jQuery.removeAttr( this, name );
23 
+		} );
24 
+	}
25 
+} );
26 
+
27 
+jQuery.extend( {
28 
+	attr: function( elem, name, value ) {
29 
+		var ret, hooks,
30 
+			nType = elem.nodeType;
31 
+
32 
+		// Don't get/set attributes on text, comment and attribute nodes
33 
+		if ( nType === 3 || nType === 8 || nType === 2 ) {
34 
+			return;
35 
+		}
36 
+
37 
+		// Fallback to prop when attributes are not supported
38 
+		if ( typeof elem.getAttribute === "undefined" ) {
39 
+			return jQuery.prop( elem, name, value );
40 
+		}
41 
+
42 
+		// Attribute hooks are determined by the lowercase version
43 
+		// Grab necessary hook if one is defined
44 
+		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
45 
+			hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
46 
+				( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
47 
+		}
48 
+
49 
+		if ( value !== undefined ) {
50 
+			if ( value === null ) {
51 
+				jQuery.removeAttr( elem, name );
52 
+				return;
53 
+			}
54 
+
55 
+			if ( hooks && "set" in hooks &&
56 
+				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
57 
+				return ret;
58 
+			}
59 
+
60 
+			elem.setAttribute( name, value + "" );
61 
+			return value;
62 
+		}
63 
+
64 
+		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
65 
+			return ret;
66 
+		}
67 
+
68 
+		ret = jQuery.find.attr( elem, name );
69 
+
70 
+		// Non-existent attributes return null, we normalize to undefined
71 
+		return ret == null ? undefined : ret;
72 
+	},
73 
+
74 
+	attrHooks: {
75 
+		type: {
76 
+			set: function( elem, value ) {
77 
+				if ( !support.radioValue && value === "radio" &&
78 
+					nodeName( elem, "input" ) ) {
79 
+					var val = elem.value;
80 
+					elem.setAttribute( "type", value );
81 
+					if ( val ) {
82 
+						elem.value = val;
83 
+					}
84 
+					return value;
85 
+				}
86 
+			}
87 
+		}
88 
+	},
89 
+
90 
+	removeAttr: function( elem, value ) {
91 
+		var name,
92 
+			i = 0,
93 
+
94 
+			// Attribute names can contain non-HTML whitespace characters
95 
+			// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
96 
+			attrNames = value && value.match( rnothtmlwhite );
97 
+
98 
+		if ( attrNames && elem.nodeType === 1 ) {
99 
+			while ( ( name = attrNames[ i++ ] ) ) {
100 
+				elem.removeAttribute( name );
101 
+			}
102 
+		}
103 
+	}
104 
+} );
105 
+
106 
+// Hooks for boolean attributes
107 
+boolHook = {
108 
+	set: function( elem, value, name ) {
109 
+		if ( value === false ) {
110 
+
111 
+			// Remove boolean attributes when set to false
112 
+			jQuery.removeAttr( elem, name );
113 
+		} else {
114 
+			elem.setAttribute( name, name );
115 
+		}
116 
+		return name;
117 
+	}
118 
+};
119 
+
120 
+jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) {
121 
+	var getter = attrHandle[ name ] || jQuery.find.attr;
122 
+
123 
+	attrHandle[ name ] = function( elem, name, isXML ) {
124 
+		var ret, handle,
125 
+			lowercaseName = name.toLowerCase();
126 
+
127 
+		if ( !isXML ) {
128 
+
129 
+			// Avoid an infinite loop by temporarily removing this function from the getter
130 
+			handle = attrHandle[ lowercaseName ];
131 
+			attrHandle[ lowercaseName ] = ret;
132 
+			ret = getter( elem, name, isXML ) != null ?
133 
+				lowercaseName :
134 
+				null;
135 
+			attrHandle[ lowercaseName ] = handle;
136 
+		}
137 
+		return ret;
138 
+	};
139 
+} );
140 
+
141 
+} );

+ 186 - 0
app/static/bower_components/jQuery/src/attributes/classes.js
Zobrazit soubor 

@@ -0,0 +1,186 @@
1 
+define( [
2 
+	"../core",
3 
+	"../core/stripAndCollapse",
4 
+	"../var/isFunction",
5 
+	"../var/rnothtmlwhite",
6 
+	"../data/var/dataPriv",
7 
+	"../core/init"
8 
+], function( jQuery, stripAndCollapse, isFunction, rnothtmlwhite, dataPriv ) {
9 
+
10 
+"use strict";
11 
+
12 
+function getClass( elem ) {
13 
+	return elem.getAttribute && elem.getAttribute( "class" ) || "";
14 
+}
15 
+
16 
+function classesToArray( value ) {
17 
+	if ( Array.isArray( value ) ) {
18 
+		return value;
19 
+	}
20 
+	if ( typeof value === "string" ) {
21 
+		return value.match( rnothtmlwhite ) || [];
22 
+	}
23 
+	return [];
24 
+}
25 
+
26 
+jQuery.fn.extend( {
27 
+	addClass: function( value ) {
28 
+		var classes, elem, cur, curValue, clazz, j, finalValue,
29 
+			i = 0;
30 
+
31 
+		if ( isFunction( value ) ) {
32 
+			return this.each( function( j ) {
33 
+				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
34 
+			} );
35 
+		}
36 
+
37 
+		classes = classesToArray( value );
38 
+
39 
+		if ( classes.length ) {
40 
+			while ( ( elem = this[ i++ ] ) ) {
41 
+				curValue = getClass( elem );
42 
+				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
43 
+
44 
+				if ( cur ) {
45 
+					j = 0;
46 
+					while ( ( clazz = classes[ j++ ] ) ) {
47 
+						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
48 
+							cur += clazz + " ";
49 
+						}
50 
+					}
51 
+
52 
+					// Only assign if different to avoid unneeded rendering.
53 
+					finalValue = stripAndCollapse( cur );
54 
+					if ( curValue !== finalValue ) {
55 
+						elem.setAttribute( "class", finalValue );
56 
+					}
57 
+				}
58 
+			}
59 
+		}
60 
+
61 
+		return this;
62 
+	},
63 
+
64 
+	removeClass: function( value ) {
65 
+		var classes, elem, cur, curValue, clazz, j, finalValue,
66 
+			i = 0;
67 
+
68 
+		if ( isFunction( value ) ) {
69 
+			return this.each( function( j ) {
70 
+				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
71 
+			} );
72 
+		}
73 
+
74 
+		if ( !arguments.length ) {
75 
+			return this.attr( "class", "" );
76 
+		}
77 
+
78 
+		classes = classesToArray( value );
79 
+
80 
+		if ( classes.length ) {
81 
+			while ( ( elem = this[ i++ ] ) ) {
82 
+				curValue = getClass( elem );
83 
+
84 
+				// This expression is here for better compressibility (see addClass)
85 
+				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
86 
+
87 
+				if ( cur ) {
88 
+					j = 0;
89 
+					while ( ( clazz = classes[ j++ ] ) ) {
90 
+
91 
+						// Remove *all* instances
92 
+						while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
93 
+							cur = cur.replace( " " + clazz + " ", " " );
94 
+						}
95 
+					}
96 
+
97 
+					// Only assign if different to avoid unneeded rendering.
98 
+					finalValue = stripAndCollapse( cur );
99 
+					if ( curValue !== finalValue ) {
100 
+						elem.setAttribute( "class", finalValue );
101 
+					}
102 
+				}
103 
+			}
104 
+		}
105 
+
106 
+		return this;
107 
+	},
108 
+
109 
+	toggleClass: function( value, stateVal ) {
110 
+		var type = typeof value,
111 
+			isValidValue = type === "string" || Array.isArray( value );
112 
+
113 
+		if ( typeof stateVal === "boolean" && isValidValue ) {
114 
+			return stateVal ? this.addClass( value ) : this.removeClass( value );
115 
+		}
116 
+
117 
+		if ( isFunction( value ) ) {
118 
+			return this.each( function( i ) {
119 
+				jQuery( this ).toggleClass(
120 
+					value.call( this, i, getClass( this ), stateVal ),
121 
+					stateVal
122 
+				);
123 
+			} );
124 
+		}
125 
+
126 
+		return this.each( function() {
127 
+			var className, i, self, classNames;
128 
+
129 
+			if ( isValidValue ) {
130 
+
131 
+				// Toggle individual class names
132 
+				i = 0;
133 
+				self = jQuery( this );
134 
+				classNames = classesToArray( value );
135 
+
136 
+				while ( ( className = classNames[ i++ ] ) ) {
137 
+
138 
+					// Check each className given, space separated list
139 
+					if ( self.hasClass( className ) ) {
140 
+						self.removeClass( className );
141 
+					} else {
142 
+						self.addClass( className );
143 
+					}
144 
+				}
145 
+
146 
+			// Toggle whole class name
147 
+			} else if ( value === undefined || type === "boolean" ) {
148 
+				className = getClass( this );
149 
+				if ( className ) {
150 
+
151 
+					// Store className if set
152 
+					dataPriv.set( this, "__className__", className );
153 
+				}
154 
+
155 
+				// If the element has a class name or if we're passed `false`,
156 
+				// then remove the whole classname (if there was one, the above saved it).
157 
+				// Otherwise bring back whatever was previously saved (if anything),
158 
+				// falling back to the empty string if nothing was stored.
159 
+				if ( this.setAttribute ) {
160 
+					this.setAttribute( "class",
161 
+						className || value === false ?
162 
+							"" :
163 
+							dataPriv.get( this, "__className__" ) || ""
164 
+					);
165 
+				}
166 
+			}
167 
+		} );
168 
+	},
169 
+
170 
+	hasClass: function( selector ) {
171 
+		var className, elem,
172 
+			i = 0;
173 
+
174 
+		className = " " + selector + " ";
175 
+		while ( ( elem = this[ i++ ] ) ) {
176 
+			if ( elem.nodeType === 1 &&
177 
+				( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
178 
+				return true;
179 
+			}
180 
+		}
181 
+
182 
+		return false;
183 
+	}
184 
+} );
185 
+
186 
+} );

+ 143 - 0
app/static/bower_components/jQuery/src/attributes/prop.js
Zobrazit soubor 

@@ -0,0 +1,143 @@
1 
+define( [
2 
+	"../core",
3 
+	"../core/access",
4 
+	"./support",
5 
+	"../selector"
6 
+], function( jQuery, access, support ) {
7 
+
8 
+"use strict";
9 
+
10 
+var rfocusable = /^(?:input|select|textarea|button)$/i,
11 
+	rclickable = /^(?:a|area)$/i;
12 
+
13 
+jQuery.fn.extend( {
14 
+	prop: function( name, value ) {
15 
+		return access( this, jQuery.prop, name, value, arguments.length > 1 );
16 
+	},
17 
+
18 
+	removeProp: function( name ) {
19 
+		return this.each( function() {
20 
+			delete this[ jQuery.propFix[ name ] || name ];
21 
+		} );
22 
+	}
23 
+} );
24 
+
25 
+jQuery.extend( {
26 
+	prop: function( elem, name, value ) {
27 
+		var ret, hooks,
28 
+			nType = elem.nodeType;
29 
+
30 
+		// Don't get/set properties on text, comment and attribute nodes
31 
+		if ( nType === 3 || nType === 8 || nType === 2 ) {
32 
+			return;
33 
+		}
34 
+
35 
+		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
36 
+
37 
+			// Fix name and attach hooks
38 
+			name = jQuery.propFix[ name ] || name;
39 
+			hooks = jQuery.propHooks[ name ];
40 
+		}
41 
+
42 
+		if ( value !== undefined ) {
43 
+			if ( hooks && "set" in hooks &&
44 
+				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
45 
+				return ret;
46 
+			}
47 
+
48 
+			return ( elem[ name ] = value );
49 
+		}
50 
+
51 
+		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
52 
+			return ret;
53 
+		}
54 
+
55 
+		return elem[ name ];
56 
+	},
57 
+
58 
+	propHooks: {
59 
+		tabIndex: {
60 
+			get: function( elem ) {
61 
+
62 
+				// Support: IE <=9 - 11 only
63 
+				// elem.tabIndex doesn't always return the
64 
+				// correct value when it hasn't been explicitly set
65 
+				// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
66 
+				// Use proper attribute retrieval(#12072)
67 
+				var tabindex = jQuery.find.attr( elem, "tabindex" );
68 
+
69 
+				if ( tabindex ) {
70 
+					return parseInt( tabindex, 10 );
71 
+				}
72 
+
73 
+				if (
74 
+					rfocusable.test( elem.nodeName ) ||
75 
+					rclickable.test( elem.nodeName ) &&
76 
+					elem.href
77 
+				) {
78 
+					return 0;
79 
+				}
80 
+
81 
+				return -1;
82 
+			}
83 
+		}
84 
+	},
85 
+
86 
+	propFix: {
87 
+		"for": "htmlFor",
88 
+		"class": "className"
89 
+	}
90 
+} );
91 
+
92 
+// Support: IE <=11 only
93 
+// Accessing the selectedIndex property
94 
+// forces the browser to respect setting selected
95 
+// on the option
96 
+// The getter ensures a default option is selected
97 
+// when in an optgroup
98 
+// eslint rule "no-unused-expressions" is disabled for this code
99 
+// since it considers such accessions noop
100 
+if ( !support.optSelected ) {
101 
+	jQuery.propHooks.selected = {
102 
+		get: function( elem ) {
103 
+
104 
+			/* eslint no-unused-expressions: "off" */
105 
+
106 
+			var parent = elem.parentNode;
107 
+			if ( parent && parent.parentNode ) {
108 
+				parent.parentNode.selectedIndex;
109 
+			}
110 
+			return null;
111 
+		},
112 
+		set: function( elem ) {
113 
+
114 
+			/* eslint no-unused-expressions: "off" */
115 
+
116 
+			var parent = elem.parentNode;
117 
+			if ( parent ) {
118 
+				parent.selectedIndex;
119 
+
120 
+				if ( parent.parentNode ) {
121 
+					parent.parentNode.selectedIndex;
122 
+				}
123 
+			}
124 
+		}
125 
+	};
126 
+}
127 
+
128 
+jQuery.each( [
129 
+	"tabIndex",
130 
+	"readOnly",
131 
+	"maxLength",
132 
+	"cellSpacing",
133 
+	"cellPadding",
134 
+	"rowSpan",
135 
+	"colSpan",
136 
+	"useMap",
137 
+	"frameBorder",
138 
+	"contentEditable"
139 
+], function() {
140 
+	jQuery.propFix[ this.toLowerCase() ] = this;
141 
+} );
142 
+
143 
+} );

+ 33 - 0
app/static/bower_components/jQuery/src/attributes/support.js
Zobrazit soubor 

@@ -0,0 +1,33 @@
1 
+define( [
2 
+	"../var/document",
3 
+	"../var/support"
4 
+], function( document, support ) {
5 
+
6 
+"use strict";
7 
+
8 
+( function() {
9 
+	var input = document.createElement( "input" ),
10 
+		select = document.createElement( "select" ),
11 
+		opt = select.appendChild( document.createElement( "option" ) );
12 
+
13 
+	input.type = "checkbox";
14 
+
15 
+	// Support: Android <=4.3 only
16 
+	// Default value for a checkbox should be "on"
17 
+	support.checkOn = input.value !== "";
18 
+
19 
+	// Support: IE <=11 only
20 
+	// Must access selectedIndex to make default options select
21 
+	support.optSelected = opt.selected;
22 
+
23 
+	// Support: IE <=11 only
24 
+	// An input loses its value after becoming a radio
25 
+	input = document.createElement( "input" );
26 
+	input.value = "t";
27 
+	input.type = "radio";
28 
+	support.radioValue = input.value === "t";
29 
+} )();
30 
+
31 
+return support;
32 
+
33 
+} );

+ 191 - 0
app/static/bower_components/jQuery/src/attributes/val.js
Zobrazit soubor 

@@ -0,0 +1,191 @@
1 
+define( [
2 
+	"../core",
3 
+	"../core/stripAndCollapse",
4 
+	"./support",
5 
+	"../core/nodeName",
6 
+	"../var/isFunction",
7 
+
8 
+	"../core/init"
9 
+], function( jQuery, stripAndCollapse, support, nodeName, isFunction ) {
10 
+
11 
+"use strict";
12 
+
13 
+var rreturn = /\r/g;
14 
+
15 
+jQuery.fn.extend( {
16 
+	val: function( value ) {
17 
+		var hooks, ret, valueIsFunction,
18 
+			elem = this[ 0 ];
19 
+
20 
+		if ( !arguments.length ) {
21 
+			if ( elem ) {
22 
+				hooks = jQuery.valHooks[ elem.type ] ||
23 
+					jQuery.valHooks[ elem.nodeName.toLowerCase() ];
24 
+
25 
+				if ( hooks &&
26 
+					"get" in hooks &&
27 
+					( ret = hooks.get( elem, "value" ) ) !== undefined
28 
+				) {
29 
+					return ret;
30 
+				}
31 
+
32 
+				ret = elem.value;
33 
+
34 
+				// Handle most common string cases
35 
+				if ( typeof ret === "string" ) {
36 
+					return ret.replace( rreturn, "" );
37 
+				}
38 
+
39 
+				// Handle cases where value is null/undef or number
40 
+				return ret == null ? "" : ret;
41 
+			}
42 
+
43 
+			return;
44 
+		}
45 
+
46 
+		valueIsFunction = isFunction( value );
47 
+
48 
+		return this.each( function( i ) {
49 
+			var val;
50 
+
51 
+			if ( this.nodeType !== 1 ) {
52 
+				return;
53 
+			}
54 
+
55 
+			if ( valueIsFunction ) {
56 
+				val = value.call( this, i, jQuery( this ).val() );
57 
+			} else {
58 
+				val = value;
59 
+			}
60 
+
61 
+			// Treat null/undefined as ""; convert numbers to string
62 
+			if ( val == null ) {
63 
+				val = "";
64 
+
65 
+			} else if ( typeof val === "number" ) {
66 
+				val += "";
67 
+
68 
+			} else if ( Array.isArray( val ) ) {
69 
+				val = jQuery.map( val, function( value ) {
70 
+					return value == null ? "" : value + "";
71 
+				} );
72 
+			}
73 
+
74 
+			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
75 
+
76 
+			// If set returns undefined, fall back to normal setting
77 
+			if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
78 
+				this.value = val;
79 
+			}
80 
+		} );
81 
+	}
82 
+} );
83 
+
84 
+jQuery.extend( {
85 
+	valHooks: {
86 
+		option: {
87 
+			get: function( elem ) {
88 
+
89 
+				var val = jQuery.find.attr( elem, "value" );
90 
+				return val != null ?
91 
+					val :
92 
+
93 
+					// Support: IE <=10 - 11 only
94 
+					// option.text throws exceptions (#14686, #14858)
95 
+					// Strip and collapse whitespace
96 
+					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
97 
+					stripAndCollapse( jQuery.text( elem ) );
98 
+			}
99 
+		},
100 
+		select: {
101 
+			get: function( elem ) {
102 
+				var value, option, i,
103 
+					options = elem.options,
104 
+					index = elem.selectedIndex,
105 
+					one = elem.type === "select-one",
106 
+					values = one ? null : [],
107 
+					max = one ? index + 1 : options.length;
108 
+
109 
+				if ( index < 0 ) {
110 
+					i = max;
111 
+
112 
+				} else {
113 
+					i = one ? index : 0;
114 
+				}
115 
+
116 
+				// Loop through all the selected options
117 
+				for ( ; i < max; i++ ) {
118 
+					option = options[ i ];
119 
+
120 
+					// Support: IE <=9 only
121 
+					// IE8-9 doesn't update selected after form reset (#2551)
122 
+					if ( ( option.selected || i === index ) &&
123 
+
124 
+							// Don't return options that are disabled or in a disabled optgroup
125 
+							!option.disabled &&
126 
+							( !option.parentNode.disabled ||
127 
+								!nodeName( option.parentNode, "optgroup" ) ) ) {
128 
+
129 
+						// Get the specific value for the option
130 
+						value = jQuery( option ).val();
131 
+
132 
+						// We don't need an array for one selects
133 
+						if ( one ) {
134 
+							return value;
135 
+						}
136 
+
137 
+						// Multi-Selects return an array
138 
+						values.push( value );
139 
+					}
140 
+				}
141 
+
142 
+				return values;
143 
+			},
144 
+
145 
+			set: function( elem, value ) {
146 
+				var optionSet, option,
147 
+					options = elem.options,
148 
+					values = jQuery.makeArray( value ),
149 
+					i = options.length;
150 
+
151 
+				while ( i-- ) {
152 
+					option = options[ i ];
153 
+
154 
+					/* eslint-disable no-cond-assign */
155 
+
156 
+					if ( option.selected =
157 
+						jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
158 
+					) {
159 
+						optionSet = true;
160 
+					}
161 
+
162 
+					/* eslint-enable no-cond-assign */
163 
+				}
164 
+
165 
+				// Force browsers to behave consistently when non-matching value is set
166 
+				if ( !optionSet ) {
167 
+					elem.selectedIndex = -1;
168 
+				}
169 
+				return values;
170 
+			}
171 
+		}
172 
+	}
173 
+} );
174 
+
175 
+// Radios and checkboxes getter/setter
176 
+jQuery.each( [ "radio", "checkbox" ], function() {
177 
+	jQuery.valHooks[ this ] = {
178 
+		set: function( elem, value ) {
179 
+			if ( Array.isArray( value ) ) {
180 
+				return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
181 
+			}
182 
+		}
183 
+	};
184 
+	if ( !support.checkOn ) {
185 
+		jQuery.valHooks[ this ].get = function( elem ) {
186 
+			return elem.getAttribute( "value" ) === null ? "on" : elem.value;
187 
+		};
188 
+	}
189 
+} );
190 
+
191 
+} );

+ 236 - 0
app/static/bower_components/jQuery/src/callbacks.js
Zobrazit soubor 

@@ -0,0 +1,236 @@
1 
+define( [
2 
+	"./core",
3 
+	"./core/toType",
4 
+	"./var/isFunction",
5 
+	"./var/rnothtmlwhite"
6 
+], function( jQuery, toType, isFunction, rnothtmlwhite ) {
7 
+
8 
+"use strict";
9 
+
10 
+// Convert String-formatted options into Object-formatted ones
11 
+function createOptions( options ) {
12 
+	var object = {};
13 
+	jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
14 
+		object[ flag ] = true;
15 
+	} );
16 
+	return object;
17 
+}
18 
+
19 
+/*
20 
+ * Create a callback list using the following parameters:
21 
+ *
22 
+ *	options: an optional list of space-separated options that will change how
23 
+ *			the callback list behaves or a more traditional option object
24 
+ *
25 
+ * By default a callback list will act like an event callback list and can be
26 
+ * "fired" multiple times.
27 
+ *
28 
+ * Possible options:
29 
+ *
30 
+ *	once:			will ensure the callback list can only be fired once (like a Deferred)
31 
+ *
32 
+ *	memory:			will keep track of previous values and will call any callback added
33 
+ *					after the list has been fired right away with the latest "memorized"
34 
+ *					values (like a Deferred)
35 
+ *
36 
+ *	unique:			will ensure a callback can only be added once (no duplicate in the list)
37 
+ *
38 
+ *	stopOnFalse:	interrupt callings when a callback returns false
39 
+ *
40 
+ */
41 
+jQuery.Callbacks = function( options ) {
42 
+
43 
+	// Convert options from String-formatted to Object-formatted if needed
44 
+	// (we check in cache first)
45 
+	options = typeof options === "string" ?
46 
+		createOptions( options ) :
47 
+		jQuery.extend( {}, options );
48 
+
49 
+	var // Flag to know if list is currently firing
50 
+		firing,
51 
+
52 
+		// Last fire value for non-forgettable lists
53 
+		memory,
54 
+
55 
+		// Flag to know if list was already fired
56 
+		fired,
57 
+
58 
+		// Flag to prevent firing
59 
+		locked,
60 
+
61 
+		// Actual callback list
62 
+		list = [],
63 
+
64 
+		// Queue of execution data for repeatable lists
65 
+		queue = [],
66 
+
67 
+		// Index of currently firing callback (modified by add/remove as needed)
68 
+		firingIndex = -1,
69 
+
70 
+		// Fire callbacks
71 
+		fire = function() {
72 
+
73 
+			// Enforce single-firing
74 
+			locked = locked || options.once;
75 
+
76 
+			// Execute callbacks for all pending executions,
77 
+			// respecting firingIndex overrides and runtime changes
78 
+			fired = firing = true;
79 
+			for ( ; queue.length; firingIndex = -1 ) {
80 
+				memory = queue.shift();
81 
+				while ( ++firingIndex < list.length ) {
82 
+
83 
+					// Run callback and check for early termination
84 
+					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
85 
+						options.stopOnFalse ) {
86 
+
87 
+						// Jump to end and forget the data so .add doesn't re-fire
88 
+						firingIndex = list.length;
89 
+						memory = false;
90 
+					}
91 
+				}
92 
+			}
93 
+
94 
+			// Forget the data if we're done with it
95 
+			if ( !options.memory ) {
96 
+				memory = false;
97 
+			}
98 
+
99 
+			firing = false;
100 
+
101 
+			// Clean up if we're done firing for good
102 
+			if ( locked ) {
103 
+
104 
+				// Keep an empty list if we have data for future add calls
105 
+				if ( memory ) {
106 
+					list = [];
107 
+
108 
+				// Otherwise, this object is spent
109 
+				} else {
110 
+					list = "";
111 
+				}
112 
+			}
113 
+		},
114 
+
115 
+		// Actual Callbacks object
116 
+		self = {
117 
+
118 
+			// Add a callback or a collection of callbacks to the list
119 
+			add: function() {
120 
+				if ( list ) {
121 
+
122 
+					// If we have memory from a past run, we should fire after adding
123 
+					if ( memory && !firing ) {
124 
+						firingIndex = list.length - 1;
125 
+						queue.push( memory );
126 
+					}
127 
+
128 
+					( function add( args ) {
129 
+						jQuery.each( args, function( _, arg ) {
130 
+							if ( isFunction( arg ) ) {
131 
+								if ( !options.unique || !self.has( arg ) ) {
132 
+									list.push( arg );
133 
+								}
134 
+							} else if ( arg && arg.length && toType( arg ) !== "string" ) {
135 
+
136 
+								// Inspect recursively
137 
+								add( arg );
138 
+							}
139 
+						} );
140 
+					} )( arguments );
141 
+
142 
+					if ( memory && !firing ) {
143 
+						fire();
144 
+					}
145 
+				}
146 
+				return this;
147 
+			},
148 
+
149 
+			// Remove a callback from the list
150 
+			remove: function() {
151 
+				jQuery.each( arguments, function( _, arg ) {
152 
+					var index;
153 
+					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
154 
+						list.splice( index, 1 );
155 
+
156 
+						// Handle firing indexes
157 
+						if ( index <= firingIndex ) {
158 
+							firingIndex--;
159 
+						}
160 
+					}
161 
+				} );
162 
+				return this;
163 
+			},
164 
+
165 
+			// Check if a given callback is in the list.
166 
+			// If no argument is given, return whether or not list has callbacks attached.
167 
+			has: function( fn ) {
168 
+				return fn ?
169 
+					jQuery.inArray( fn, list ) > -1 :
170 
+					list.length > 0;
171 
+			},
172 
+
173 
+			// Remove all callbacks from the list
174 
+			empty: function() {
175 
+				if ( list ) {
176 
+					list = [];
177 
+				}
178 
+				return this;
179 
+			},
180 
+
181 
+			// Disable .fire and .add
182 
+			// Abort any current/pending executions
183 
+			// Clear all callbacks and values
184 
+			disable: function() {
185 
+				locked = queue = [];
186 
+				list = memory = "";
187 
+				return this;
188 
+			},
189 
+			disabled: function() {
190 
+				return !list;
191 
+			},
192 
+
193 
+			// Disable .fire
194 
+			// Also disable .add unless we have memory (since it would have no effect)
195 
+			// Abort any pending executions
196 
+			lock: function() {
197 
+				locked = queue = [];
198 
+				if ( !memory && !firing ) {
199 
+					list = memory = "";
200 
+				}
201 
+				return this;
202 
+			},
203 
+			locked: function() {
204 
+				return !!locked;
205 
+			},
206 
+
207 
+			// Call all callbacks with the given context and arguments
208 
+			fireWith: function( context, args ) {
209 
+				if ( !locked ) {
210 
+					args = args || [];
211 
+					args = [ context, args.slice ? args.slice() : args ];
212 
+					queue.push( args );
213 
+					if ( !firing ) {
214 
+						fire();
215 
+					}
216 
+				}
217 
+				return this;
218 
+			},
219 
+
220 
+			// Call all the callbacks with the given arguments
221 
+			fire: function() {
222 
+				self.fireWith( this, arguments );
223 
+				return this;
224 
+			},
225 
+
226 
+			// To know if the callbacks have already been called at least once
227 
+			fired: function() {
228 
+				return !!fired;
229 
+			}
230 
+		};
231 
+
232 
+	return self;
233 
+};
234 
+
235 
+return jQuery;
236 
+} );

+ 400 - 0
app/static/bower_components/jQuery/src/core.js
Zobrazit soubor 

@@ -0,0 +1,400 @@
1 
+/* global Symbol */
2 
+// Defining this global in .eslintrc.json would create a danger of using the global
3 
+// unguarded in another place, it seems safer to define global only for this module
4 
+
5 
+define( [
6 
+	"./var/arr",
7 
+	"./var/getProto",
8 
+	"./var/slice",
9 
+	"./var/flat",
10 
+	"./var/push",
11 
+	"./var/indexOf",
12 
+	"./var/class2type",
13 
+	"./var/toString",
14 
+	"./var/hasOwn",
15 
+	"./var/fnToString",
16 
+	"./var/ObjectFunctionString",
17 
+	"./var/support",
18 
+	"./var/isFunction",
19 
+	"./var/isWindow",
20 
+	"./core/DOMEval",
21 
+	"./core/toType"
22 
+], function( arr, getProto, slice, flat, push, indexOf,
23 
+	class2type, toString, hasOwn, fnToString, ObjectFunctionString,
24 
+	support, isFunction, isWindow, DOMEval, toType ) {
25 
+
26 
+"use strict";
27 
+
28 
+var
29 
+	version = "3.6.0",
30 
+
31 
+	// Define a local copy of jQuery
32 
+	jQuery = function( selector, context ) {
33 
+
34 
+		// The jQuery object is actually just the init constructor 'enhanced'
35 
+		// Need init if jQuery is called (just allow error to be thrown if not included)
36 
+		return new jQuery.fn.init( selector, context );
37 
+	};
38 
+
39 
+jQuery.fn = jQuery.prototype = {
40 
+
41 
+	// The current version of jQuery being used
42 
+	jquery: version,
43 
+
44 
+	constructor: jQuery,
45 
+
46 
+	// The default length of a jQuery object is 0
47 
+	length: 0,
48 
+
49 
+	toArray: function() {
50 
+		return slice.call( this );
51 
+	},
52 
+
53 
+	// Get the Nth element in the matched element set OR
54 
+	// Get the whole matched element set as a clean array
55 
+	get: function( num ) {
56 
+
57 
+		// Return all the elements in a clean array
58 
+		if ( num == null ) {
59 
+			return slice.call( this );
60 
+		}
61 
+
62 
+		// Return just the one element from the set
63 
+		return num < 0 ? this[ num + this.length ] : this[ num ];
64 
+	},
65 
+
66 
+	// Take an array of elements and push it onto the stack
67 
+	// (returning the new matched element set)
68 
+	pushStack: function( elems ) {
69 
+
70 
+		// Build a new jQuery matched element set
71 
+		var ret = jQuery.merge( this.constructor(), elems );
72 
+
73 
+		// Add the old object onto the stack (as a reference)
74 
+		ret.prevObject = this;
75 
+
76 
+		// Return the newly-formed element set
77 
+		return ret;
78 
+	},
79 
+
80 
+	// Execute a callback for every element in the matched set.
81 
+	each: function( callback ) {
82 
+		return jQuery.each( this, callback );
83 
+	},
84 
+
85 
+	map: function( callback ) {
86 
+		return this.pushStack( jQuery.map( this, function( elem, i ) {
87 
+			return callback.call( elem, i, elem );
88 
+		} ) );
89 
+	},
90 
+
91 
+	slice: function() {
92 
+		return this.pushStack( slice.apply( this, arguments ) );
93 
+	},
94 
+
95 
+	first: function() {
96 
+		return this.eq( 0 );
97 
+	},
98 
+
99 
+	last: function() {
100 
+		return this.eq( -1 );
101 
+	},
102 
+
103 
+	even: function() {
104 
+		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
105 
+			return ( i + 1 ) % 2;
106 
+		} ) );
107 
+	},
108 
+
109 
+	odd: function() {
110 
+		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
111 
+			return i % 2;
112 
+		} ) );
113 
+	},
114 
+
115 
+	eq: function( i ) {
116 
+		var len = this.length,
117 
+			j = +i + ( i < 0 ? len : 0 );
118 
+		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
119 
+	},
120 
+
121 
+	end: function() {
122 
+		return this.prevObject || this.constructor();
123 
+	},
124 
+
125 
+	// For internal use only.
126 
+	// Behaves like an Array's method, not like a jQuery method.
127 
+	push: push,
128 
+	sort: arr.sort,
129 
+	splice: arr.splice
130 
+};
131 
+
132 
+jQuery.extend = jQuery.fn.extend = function() {
133 
+	var options, name, src, copy, copyIsArray, clone,
134 
+		target = arguments[ 0 ] || {},
135 
+		i = 1,
136 
+		length = arguments.length,
137 
+		deep = false;
138 
+
139 
+	// Handle a deep copy situation
140 
+	if ( typeof target === "boolean" ) {
141 
+		deep = target;
142 
+
143 
+		// Skip the boolean and the target
144 
+		target = arguments[ i ] || {};
145 
+		i++;
146 
+	}
147 
+
148 
+	// Handle case when target is a string or something (possible in deep copy)
149 
+	if ( typeof target !== "object" && !isFunction( target ) ) {
150 
+		target = {};
151 
+	}
152 
+
153 
+	// Extend jQuery itself if only one argument is passed
154 
+	if ( i === length ) {
155 
+		target = this;
156 
+		i--;
157 
+	}
158 
+
159 
+	for ( ; i < length; i++ ) {
160 
+
161 
+		// Only deal with non-null/undefined values
162 
+		if ( ( options = arguments[ i ] ) != null ) {
163 
+
164 
+			// Extend the base object
165 
+			for ( name in options ) {
166 
+				copy = options[ name ];
167 
+
168 
+				// Prevent Object.prototype pollution
169 
+				// Prevent never-ending loop
170 
+				if ( name === "__proto__" || target === copy ) {
171 
+					continue;
172 
+				}
173 
+
174 
+				// Recurse if we're merging plain objects or arrays
175 
+				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
176 
+					( copyIsArray = Array.isArray( copy ) ) ) ) {
177 
+					src = target[ name ];
178 
+
179 
+					// Ensure proper type for the source value
180 
+					if ( copyIsArray && !Array.isArray( src ) ) {
181 
+						clone = [];
182 
+					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
183 
+						clone = {};
184 
+					} else {
185 
+						clone = src;
186 
+					}
187 
+					copyIsArray = false;
188 
+
189 
+					// Never move original objects, clone them
190 
+					target[ name ] = jQuery.extend( deep, clone, copy );
191 
+
192 
+				// Don't bring in undefined values
193 
+				} else if ( copy !== undefined ) {
194 
+					target[ name ] = copy;
195 
+				}
196 
+			}
197 
+		}
198 
+	}
199 
+
200 
+	// Return the modified object
201 
+	return target;
202 
+};
203 
+
204 
+jQuery.extend( {
205 
+
206 
+	// Unique for each copy of jQuery on the page
207 
+	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
208 
+
209 
+	// Assume jQuery is ready without the ready module
210 
+	isReady: true,
211 
+
212 
+	error: function( msg ) {
213 
+		throw new Error( msg );
214 
+	},
215 
+
216 
+	noop: function() {},
217 
+
218 
+	isPlainObject: function( obj ) {
219 
+		var proto, Ctor;
220 
+
221 
+		// Detect obvious negatives
222 
+		// Use toString instead of jQuery.type to catch host objects
223 
+		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
224 
+			return false;
225 
+		}
226 
+
227 
+		proto = getProto( obj );
228 
+
229 
+		// Objects with no prototype (e.g., `Object.create( null )`) are plain
230 
+		if ( !proto ) {
231 
+			return true;
232 
+		}
233 
+
234 
+		// Objects with prototype are plain iff they were constructed by a global Object function
235 
+		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
236 
+		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
237 
+	},
238 
+
239 
+	isEmptyObject: function( obj ) {
240 
+		var name;
241 
+
242 
+		for ( name in obj ) {
243 
+			return false;
244 
+		}
245 
+		return true;
246 
+	},
247 
+
248 
+	// Evaluates a script in a provided context; falls back to the global one
249 
+	// if not specified.
250 
+	globalEval: function( code, options, doc ) {
251 
+		DOMEval( code, { nonce: options && options.nonce }, doc );
252 
+	},
253 
+
254 
+	each: function( obj, callback ) {
255 
+		var length, i = 0;
256 
+
257 
+		if ( isArrayLike( obj ) ) {
258 
+			length = obj.length;
259 
+			for ( ; i < length; i++ ) {
260 
+				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
261 
+					break;
262 
+				}
263 
+			}
264 
+		} else {
265 
+			for ( i in obj ) {
266 
+				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
267 
+					break;
268 
+				}
269 
+			}
270 
+		}
271 
+
272 
+		return obj;
273 
+	},
274 
+
275 
+	// results is for internal usage only
276 
+	makeArray: function( arr, results ) {
277 
+		var ret = results || [];
278 
+
279 
+		if ( arr != null ) {
280 
+			if ( isArrayLike( Object( arr ) ) ) {
281 
+				jQuery.merge( ret,
282 
+					typeof arr === "string" ?
283 
+						[ arr ] : arr
284 
+				);
285 
+			} else {
286 
+				push.call( ret, arr );
287 
+			}
288 
+		}
289 
+
290 
+		return ret;
291 
+	},
292 
+
293 
+	inArray: function( elem, arr, i ) {
294 
+		return arr == null ? -1 : indexOf.call( arr, elem, i );
295 
+	},
296 
+
297 
+	// Support: Android <=4.0 only, PhantomJS 1 only
298 
+	// push.apply(_, arraylike) throws on ancient WebKit
299 
+	merge: function( first, second ) {
300 
+		var len = +second.length,
301 
+			j = 0,
302 
+			i = first.length;
303 
+
304 
+		for ( ; j < len; j++ ) {
305 
+			first[ i++ ] = second[ j ];
306 
+		}
307 
+
308 
+		first.length = i;
309 
+
310 
+		return first;
311 
+	},
312 
+
313 
+	grep: function( elems, callback, invert ) {
314 
+		var callbackInverse,
315 
+			matches = [],
316 
+			i = 0,
317 
+			length = elems.length,
318 
+			callbackExpect = !invert;
319 
+
320 
+		// Go through the array, only saving the items
321 
+		// that pass the validator function
322 
+		for ( ; i < length; i++ ) {
323 
+			callbackInverse = !callback( elems[ i ], i );
324 
+			if ( callbackInverse !== callbackExpect ) {
325 
+				matches.push( elems[ i ] );
326 
+			}
327 
+		}
328 
+
329 
+		return matches;
330 
+	},
331 
+
332 
+	// arg is for internal usage only
333 
+	map: function( elems, callback, arg ) {
334 
+		var length, value,
335 
+			i = 0,
336 
+			ret = [];
337 
+
338 
+		// Go through the array, translating each of the items to their new values
339 
+		if ( isArrayLike( elems ) ) {
340 
+			length = elems.length;
341 
+			for ( ; i < length; i++ ) {
342 
+				value = callback( elems[ i ], i, arg );
343 
+
344 
+				if ( value != null ) {
345 
+					ret.push( value );
346 
+				}
347 
+			}
348 
+
349 
+		// Go through every key on the object,
350 
+		} else {
351 
+			for ( i in elems ) {
352 
+				value = callback( elems[ i ], i, arg );
353 
+
354 
+				if ( value != null ) {
355 
+					ret.push( value );
356 
+				}
357 
+			}
358 
+		}
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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor 

@@ -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
Zobrazit soubor


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

tum/whitesports - Gogs: Simplico Git Service
ホーム エクスプローラ ヘルプ
サインイン
tum
/
whitesports
Watch 1
Star 0
Fork 0
コード 課題 0 プルリクエスト 0 コミット 9 リリース 0 Wiki
ブランチ: master
ブランチ タグ

1 コミット (master)

作者 SHA1 メッセージ 日付
  Tum d01d7cf85d first commit 4 年 前